Modularizacion de Backend

.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+  "files.exclude": {
+    "**/__pycache__": true,
+    "**/.pytest_cache": true,
+    "**/.mypy_cache": true,
+    "**/.ruff_cache": true,
+    "**/.ipynb_checkpoints": true
+  },
+  "search.exclude": {
+    "**/__pycache__": true,
+    "**/.pytest_cache": true,
+    "**/.mypy_cache": true,
+    "**/.ruff_cache": true,
+    "**/.ipynb_checkpoints": true
+  }
+}

backend/app_factory.py

@@ -0,0 +1,241 @@
+from datetime import datetime, timezone
+
+from flask import Flask, jsonify, request
+from flask_cors import CORS
+
+from config import POSITIVE_EMOTIONS
+from db import init_history_db
+from repositories.history_repository import (
+    create_recommendation_cycle,
+    delete_user_history,
+    get_history_items,
+    get_last_emotion_event,
+    get_last_viewed_between,
+    get_recommendation_cycle,
+    get_transition_items,
+    insert_view_history,
+    save_emotion_event,
+    save_post_recommendation_state,
+)
+from services.chatbot_service import generate_chatbot_text
+from services.emotion_service import analyze_text, create_emotion_classifier, mapeo_emocion_valencia
+from services.recommender_service import cargar_dataset_movies, recommend_movies
+
+
+def create_app() -> Flask:
+    # Crea la aplicacion Flask y habilita CORS para peticiones del frontend.
+    app = Flask(__name__)
+    CORS(app)
+
+    # Inicializacion unica de modelo, dataset y esquema de base de datos.
+    print("Cargando modelo...")
+    clf = create_emotion_classifier()
+
+    movies_df, global_rating_mean = cargar_dataset_movies()
+    init_history_db()
+    print(
+        f"Listo. Dataset de recomendaciones: {len(movies_df)} peliculas "
+        f"(rating global medio={global_rating_mean:.3f})"
+    )
+
+    @app.route("/analizar", methods=["POST"])
+    def analizar():
+        # Flujo principal: clasificar emocion y devolver recomendaciones.
+        texto = request.json.get("texto", "")
+        user_id = str(request.json.get("user_id", "")).strip()
+        previous_event = get_last_emotion_event(user_id)
+        analyzed_at = datetime.now(timezone.utc).isoformat()
+
+        resultado, dominant_es, dominant_valence = analyze_text(clf, texto)
+        recomendaciones = recommend_movies(
+            emotion_es=dominant_es,
+            user_id=user_id,
+            limit=12,
+            movies_df=movies_df,
+            global_rating_mean=global_rating_mean,
+        )
+        recommendation_mode = "diferente" if dominant_es in POSITIVE_EMOTIONS else "similar"
+
+        cycle_id = create_recommendation_cycle(
+            user_id=user_id,
+            pre_text=texto,
+            pre_emotion=dominant_es,
+            pre_valence=dominant_valence,
+            recommendation_mode=recommendation_mode,
+            created_at=analyzed_at,
+        )
+
+        save_emotion_event(user_id=user_id, text=texto, emotion=dominant_es, analyzed_at=analyzed_at)
+
+        # Si existe evento anterior, se busca pelicula puente entre ambos estados.
+        transition_movie = None
+        if previous_event:
+            transition_movie = get_last_viewed_between(
+                user_id=user_id,
+                start_iso=previous_event.get("analyzed_at", ""),
+                end_iso=analyzed_at,
+            )
+
+        chatbot_text, chatbot_source = generate_chatbot_text(
+            dominant_emotion=dominant_es,
+            recommendation_mode=recommendation_mode,
+            recommendations=recomendaciones,
+            previous_event=previous_event,
+            transition_movie=transition_movie,
+        )
+
+        return jsonify(
+            {
+                "emociones": resultado,
+                "emocion_dominante": dominant_es,
+                "valencia_dominante": dominant_valence,
+                "emocion_anterior": previous_event.get("emotion") if previous_event else None,
+                "modo_recomendacion": recommendation_mode,
+                "ciclo_recomendacion_id": cycle_id,
+                "chatbot_texto": chatbot_text,
+                "chatbot_fuente": chatbot_source,
+                "pelicula_transicion": transition_movie,
+                "recomendaciones": recomendaciones,
+            }
+        )
+
+    @app.route("/recomendacion/seguimiento", methods=["POST"])
+    def seguimiento_recomendacion():
+        # Captura estado post-visionado para medir cambio emocional.
+        payload = request.json or {}
+        user_id = str(payload.get("user_id", "")).strip()
+        post_text = str(payload.get("texto_post", "")).strip()
+        movie_id = str(payload.get("movie_id", "")).strip()
+        movie_title = str(payload.get("title", "")).strip()
+
+        try:
+            cycle_id = int(payload.get("ciclo_recomendacion_id", 0))
+        except (TypeError, ValueError):
+            cycle_id = 0
+
+        if not user_id or not cycle_id or not post_text:
+            return jsonify({"error": "user_id, ciclo_recomendacion_id y texto_post son obligatorios"}), 400
+
+        cycle = get_recommendation_cycle(cycle_id=cycle_id, user_id=user_id)
+        if not cycle:
+            return jsonify({"error": "ciclo de recomendacion no encontrado"}), 404
+
+        analyzed_at = datetime.now(timezone.utc).isoformat()
+        result_post, post_emotion, post_valence = analyze_text(clf, post_text)
+
+        save_emotion_event(user_id=user_id, text=post_text, emotion=post_emotion, analyzed_at=analyzed_at)
+        save_post_recommendation_state(
+            cycle_id=cycle_id,
+            user_id=user_id,
+            post_text=post_text,
+            post_emotion=post_emotion,
+            post_valence=post_valence,
+            post_analyzed_at=analyzed_at,
+            movie_id=movie_id,
+            movie_title=movie_title,
+        )
+
+        return jsonify(
+            {
+                "ciclo_recomendacion_id": cycle_id,
+                "movie_id": movie_id,
+                "title": movie_title,
+                "pre_emotion": cycle.get("pre_emotion"),
+                "pre_valence": cycle.get("pre_valence"),
+                "post_emotion": post_emotion,
+                "post_valence": post_valence,
+                "cambio_emocional": cycle.get("pre_emotion") != post_emotion,
+                "cambio_valencia": cycle.get("pre_valence") != post_valence,
+                "emociones_post": result_post,
+            }
+        )
+
+    @app.route("/historial/visto", methods=["POST"])
+    def guardar_visto():
+        # Guarda una pelicula vista junto a su valoracion del usuario.
+        payload = request.json or {}
+        user_id = str(payload.get("user_id", "")).strip()
+        movie_id = str(payload.get("movie_id", "")).strip()
+
+        if not user_id or not movie_id:
+            return jsonify({"error": "user_id y movie_id son obligatorios"}), 400
+
+        viewed_at = datetime.now(timezone.utc).isoformat()
+        title = str(payload.get("title", "")).strip()
+        emotion = str(payload.get("emotion", "")).strip()
+        session_text = str(payload.get("session_text", "")).strip()
+        user_rating_raw = payload.get("user_rating")
+        user_rating = None
+        if user_rating_raw is not None and str(user_rating_raw).strip() != "":
+            try:
+                user_rating = float(user_rating_raw)
+            except (TypeError, ValueError):
+                return jsonify({"error": "user_rating debe ser numerica entre 1 y 5"}), 400
+            if user_rating < 1 or user_rating > 5:
+                return jsonify({"error": "user_rating debe estar entre 1 y 5"}), 400
+
+        inserted_id = insert_view_history(
+            user_id=user_id,
+            movie_id=movie_id,
+            title=title,
+            emotion=emotion,
+            user_rating=user_rating,
+            session_text=session_text,
+            viewed_at=viewed_at,
+        )
+
+        return jsonify(
+            {
+                "id": inserted_id,
+                "user_id": user_id,
+                "movie_id": movie_id,
+                "title": title,
+                "emotion": emotion,
+                "user_rating": user_rating,
+                "session_text": session_text,
+                "viewed_at": viewed_at,
+            }
+        ), 201
+
+    @app.route("/historial", methods=["GET", "DELETE"])
+    def obtener_historial():
+        # GET lista historial; DELETE borra historial del usuario.
+        if request.method == "DELETE":
+            payload = request.json or {}
+            user_id = str(payload.get("user_id", "") or request.args.get("user_id", "")).strip()
+            if not user_id:
+                return jsonify({"error": "user_id es obligatorio"}), 400
+
+            deleted = delete_user_history(user_id)
+            return jsonify({"ok": True, "user_id": user_id, "deleted": deleted})
+
+        user_id = str(request.args.get("user_id", "")).strip()
+        if not user_id:
+            return jsonify({"error": "user_id es obligatorio"}), 400
+
+        try:
+            limit = int(request.args.get("limit", 30))
+        except ValueError:
+            limit = 30
+
+        limit = max(1, min(limit, 200))
+        historial = get_history_items(user_id=user_id, limit=limit)
+        return jsonify({"items": historial, "count": len(historial)})
+
+    @app.route("/historial/transiciones", methods=["GET"])
+    def obtener_transiciones():
+        # Devuelve peliculas asociadas a cambios de emocion entre eventos.
+        user_id = str(request.args.get("user_id", "")).strip()
+        if not user_id:
+            return jsonify({"error": "user_id es obligatorio"}), 400
+
+        try:
+            limit = int(request.args.get("limit", 20))
+        except ValueError:
+            limit = 20
+
+        limit = max(1, min(limit, 100))
+        items = get_transition_items(user_id=user_id, limit=limit)
+        return jsonify({"items": items, "count": len(items)})
+
+    return app

backend/config.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+
+# El directorio raiz del proyecto es /ValorSentimental.
+ROOT_DIR = Path(__file__).resolve().parent.parent
+# La base de datos de historial se guarda en /ValorSentimental/backend/history.db.
+HISTORY_DB_PATH = ROOT_DIR / "backend" / "history.db"
+
+# Se mapean las 6 emociones de Eckman y neutral, para traducir la salida del modelo.
+EMOTION_MAP = {
+    "joy": "alegria",
+    "sadness": "tristeza",
+    "anger": "ira",
+    "fear": "miedo",
+    "disgust": "asco",
+    "surprise": "sorpresa",
+    "others": "neutral",
+}
+
+# Se indican emociones positivas y negativas manualmente.
+POSITIVE_EMOTIONS = {"alegria", "sorpresa", "neutral"}
+NEGATIVE_EMOTIONS = {"tristeza", "ira", "miedo", "asco"}
+
+# Nombre del modelo de Ollama que se utilizara para generar texto del chatbot.
+TEXT_MODEL_NAME = "llama3.2"
+OLLAMA_URL = "http://localhost:11434/api/generate"
+# Valoracion minima para considerar que al usuario le gusto la pelicula.
+LIKE_THRESHOLD = 4.0
+# Prior de suavizado para score global (evita sesgo por pocas valoraciones).
+GLOBAL_PRIOR_COUNT = 50.0

backend/db.py

@@ -0,0 +1,85 @@
+import sqlite3
+
+from config import HISTORY_DB_PATH
+
+
+def get_db_connection() -> sqlite3.Connection:
+    # Cada conexion usa sqlite3.Row para acceder por nombre de columna.
+    conn = sqlite3.connect(HISTORY_DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def init_history_db() -> None:
+    with get_db_connection() as conn:
+        # Historial de visionado con rating opcional por usuario.
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS view_history (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id TEXT NOT NULL,
+                movie_id TEXT NOT NULL,
+                title TEXT,
+                emotion TEXT,
+                user_rating REAL,
+                session_text TEXT,
+                viewed_at TEXT NOT NULL
+            )
+            """
+        )
+        # Compatibilidad con BDs existentes creadas sin columna de valoracion.
+        columns = conn.execute("PRAGMA table_info(view_history)").fetchall()
+        column_names = {row[1] for row in columns}
+        if "user_rating" not in column_names:
+            conn.execute("ALTER TABLE view_history ADD COLUMN user_rating REAL")
+
+        # Indices para lecturas frecuentes por usuario + fecha.
+        conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_view_history_user_viewed_at
+            ON view_history (user_id, viewed_at DESC)
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS emotion_events (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id TEXT NOT NULL,
+                text TEXT,
+                emotion TEXT NOT NULL,
+                analyzed_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_emotion_events_user_analyzed_at
+            ON emotion_events (user_id, analyzed_at DESC)
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS recommendation_cycles (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id TEXT NOT NULL,
+                pre_text TEXT,
+                pre_emotion TEXT NOT NULL,
+                pre_valence TEXT NOT NULL,
+                recommendation_mode TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                selected_movie_id TEXT,
+                selected_movie_title TEXT,
+                post_text TEXT,
+                post_emotion TEXT,
+                post_valence TEXT,
+                post_analyzed_at TEXT
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_recommendation_cycles_user_created_at
+            ON recommendation_cycles (user_id, created_at DESC)
+            """
+        )
+        conn.commit()

backend/repositories/history_repository.py

@@ -0,0 +1,270 @@
+from db import get_db_connection
+
+
+def delete_user_history(user_id: str) -> int:
+    with get_db_connection() as conn:
+        # Se ejecuta DELETE para borrar historial de visionado del usuario.
+        cur = conn.execute(
+            """
+            DELETE FROM view_history
+            WHERE user_id = ?
+            """,
+            (user_id,),
+        )
+        conn.commit()
+        return int(cur.rowcount or 0)
+
+
+def get_user_history_rows(user_id: str, limit: int = 200) -> list[dict]:
+    with get_db_connection() as conn:
+        # Consulta base para perfilar recomendaciones con movie_id y user_rating.
+        rows = conn.execute(
+            """
+            SELECT movie_id, user_rating
+            FROM view_history
+            WHERE user_id = ?
+            ORDER BY viewed_at DESC
+            LIMIT ?
+            """,
+            (user_id, limit),
+        ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def save_emotion_event(user_id: str, text: str, emotion: str, analyzed_at: str) -> int | None:
+    if not user_id:
+        return None
+
+    with get_db_connection() as conn:
+        # Registro temporal de cada analisis emocional del usuario.
+        cur = conn.execute(
+            """
+            INSERT INTO emotion_events (user_id, text, emotion, analyzed_at)
+            VALUES (?, ?, ?, ?)
+            """,
+            (user_id, text, emotion, analyzed_at),
+        )
+        conn.commit()
+        return cur.lastrowid
+
+
+def create_recommendation_cycle(
+    user_id: str,
+    pre_text: str,
+    pre_emotion: str,
+    pre_valence: str,
+    recommendation_mode: str,
+    created_at: str,
+) -> int | None:
+    if not user_id:
+        return None
+
+    with get_db_connection() as conn:
+        # Se guarda el estado previo a la recomendacion para seguimiento posterior.
+        cur = conn.execute(
+            """
+            INSERT INTO recommendation_cycles (
+                user_id,
+                pre_text,
+                pre_emotion,
+                pre_valence,
+                recommendation_mode,
+                created_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (user_id, pre_text, pre_emotion, pre_valence, recommendation_mode, created_at),
+        )
+        conn.commit()
+        return cur.lastrowid
+
+
+def get_recommendation_cycle(cycle_id: int, user_id: str) -> dict | None:
+    with get_db_connection() as conn:
+        row = conn.execute(
+            """
+            SELECT id, user_id, pre_text, pre_emotion, pre_valence, recommendation_mode,
+                   created_at, selected_movie_id, selected_movie_title,
+                   post_text, post_emotion, post_valence, post_analyzed_at
+            FROM recommendation_cycles
+            WHERE id = ? AND user_id = ?
+            LIMIT 1
+            """,
+            (cycle_id, user_id),
+        ).fetchone()
+    return dict(row) if row else None
+
+
+def save_post_recommendation_state(
+    cycle_id: int,
+    user_id: str,
+    post_text: str,
+    post_emotion: str,
+    post_valence: str,
+    post_analyzed_at: str,
+    movie_id: str,
+    movie_title: str,
+) -> None:
+    with get_db_connection() as conn:
+        # Actualiza el ciclo con pelicula elegida y estado emocional posterior.
+        conn.execute(
+            """
+            UPDATE recommendation_cycles
+            SET selected_movie_id = ?,
+                selected_movie_title = ?,
+                post_text = ?,
+                post_emotion = ?,
+                post_valence = ?,
+                post_analyzed_at = ?
+            WHERE id = ? AND user_id = ?
+            """,
+            (movie_id, movie_title, post_text, post_emotion, post_valence, post_analyzed_at, cycle_id, user_id),
+        )
+        conn.commit()
+
+
+def get_last_emotion_event(user_id: str) -> dict | None:
+    if not user_id:
+        return None
+
+    with get_db_connection() as conn:
+        row = conn.execute(
+            """
+            SELECT id, user_id, text, emotion, analyzed_at
+            FROM emotion_events
+            WHERE user_id = ?
+            ORDER BY analyzed_at DESC
+            LIMIT 1
+            """,
+            (user_id,),
+        ).fetchone()
+
+    return dict(row) if row else None
+
+
+def get_last_viewed_between(user_id: str, start_iso: str, end_iso: str) -> dict | None:
+    with get_db_connection() as conn:
+        row = conn.execute(
+            """
+            SELECT movie_id, title, viewed_at
+            FROM view_history
+            WHERE user_id = ?
+              AND viewed_at > ?
+              AND viewed_at <= ?
+            ORDER BY viewed_at DESC
+            LIMIT 1
+            """,
+            (user_id, start_iso, end_iso),
+        ).fetchone()
+
+    return dict(row) if row else None
+
+
+def insert_view_history(
+    user_id: str,
+    movie_id: str,
+    title: str,
+    emotion: str,
+    user_rating: float | None,
+    session_text: str,
+    viewed_at: str,
+) -> int:
+    with get_db_connection() as conn:
+        cur = conn.execute(
+            """
+            INSERT INTO view_history (user_id, movie_id, title, emotion, user_rating, session_text, viewed_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            (user_id, movie_id, title, emotion, user_rating, session_text, viewed_at),
+        )
+        conn.commit()
+        return int(cur.lastrowid)
+
+
+def get_history_items(user_id: str, limit: int) -> list[dict]:
+    with get_db_connection() as conn:
+        rows = conn.execute(
+            """
+            SELECT id, user_id, movie_id, title, emotion, user_rating, session_text, viewed_at
+            FROM view_history
+            WHERE user_id = ?
+            ORDER BY viewed_at DESC
+            LIMIT ?
+            """,
+            (user_id, limit),
+        ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def get_transition_items(user_id: str, limit: int) -> list[dict]:
+    with get_db_connection() as conn:
+        # Se toman eventos y vistas en orden cronologico para detectar transiciones.
+        event_rows = conn.execute(
+            """
+            SELECT id, user_id, text, emotion, analyzed_at
+            FROM emotion_events
+            WHERE user_id = ?
+            ORDER BY analyzed_at ASC
+            LIMIT 500
+            """,
+            (user_id,),
+        ).fetchall()
+
+        view_rows = conn.execute(
+            """
+            SELECT movie_id, title, viewed_at
+            FROM view_history
+            WHERE user_id = ?
+            ORDER BY viewed_at ASC
+            LIMIT 1000
+            """,
+            (user_id,),
+        ).fetchall()
+
+    events = [dict(row) for row in event_rows]
+    views = [dict(row) for row in view_rows]
+
+    # (movie_id, title, emocion_origen, emocion_destino) -> conteo.
+    transition_counter: dict[tuple[str, str, str, str], int] = {}
+
+    for idx in range(1, len(events)):
+        prev_event = events[idx - 1]
+        curr_event = events[idx]
+        if prev_event.get("emotion") == curr_event.get("emotion"):
+            continue
+
+        start = prev_event.get("analyzed_at", "")
+        end = curr_event.get("analyzed_at", "")
+
+        matched_movie = None
+        for view in reversed(views):
+            viewed_at = view.get("viewed_at", "")
+            if start < viewed_at <= end:
+                matched_movie = view
+                break
+
+        if not matched_movie:
+            continue
+
+        key = (
+            str(matched_movie.get("movie_id", "")),
+            matched_movie.get("title") or "",
+            prev_event.get("emotion", ""),
+            curr_event.get("emotion", ""),
+        )
+        transition_counter[key] = transition_counter.get(key, 0) + 1
+
+    items = []
+    for (movie_id, title, from_emotion, to_emotion), count in transition_counter.items():
+        items.append(
+            {
+                "movie_id": movie_id,
+                "title": title,
+                "from_emotion": from_emotion,
+                "to_emotion": to_emotion,
+                "count": count,
+            }
+        )
+
+    items.sort(key=lambda x: x["count"], reverse=True)
+    return items[:limit]

backend/server.py

@@ -1,766 +1,6 @@
-from pathlib import Path
-import csv
-import random
-import sqlite3
-from collections import Counter
-from datetime import datetime, timezone
-
-from flask import Flask, jsonify, request
-from flask_cors import CORS
-import requests as http_requests
-from transformers import pipeline
-
-app = Flask(__name__)
-CORS(app)
-
-ROOT_DIR = Path(__file__).resolve().parent.parent
-HISTORY_DB_PATH = ROOT_DIR / "backend" / "history.db"
-
-EMOTION_MAP = {
-    "joy": "alegria",
-    "sadness": "tristeza",
-    "anger": "ira",
-    "fear": "miedo",
-    "disgust": "asco",
-    "surprise": "sorpresa",
-    "others": "neutral",
-}
-
-POSITIVE_EMOTIONS = {"alegria", "sorpresa", "neutral"}
-NEGATIVE_EMOTIONS = {"tristeza", "ira", "miedo", "asco"}
-TEXT_MODEL_NAME = "llama3.2"
-OLLAMA_URL = "http://localhost:11434/api/generate"
-LIKE_THRESHOLD = 4.0
-
-
-def emotion_to_valence(emotion: str) -> str:
-    if emotion in POSITIVE_EMOTIONS:
-        return "positivo"
-    if emotion in NEGATIVE_EMOTIONS:
-        return "negativo"
-    return "neutro"
-
-
-def load_movies_dataset() -> list[dict]:
-    candidates = [
-        ROOT_DIR / "data" / "procesado" / "peliculas_100_emociones.csv",
-        ROOT_DIR / "data" / "procesado" / "peliculas_conocidas.csv",
-    ]
-
-    for path in candidates:
-        if path.exists():
-            with open(path, "r", encoding="utf-8", newline="") as f:
-                rows = list(csv.DictReader(f))
-            for row in rows:
-                if "estados_emocionales" not in row and "estado_emocional" in row:
-                    row["estados_emocionales"] = row.get("estado_emocional", "")
-            return rows
-
-    return []
-
-
-def _movie_genres(row: dict) -> set[str]:
-    return {g.strip() for g in row.get("genres", "").split("|") if g.strip()}
-
-
-def _get_user_history_rows(user_id: str, limit: int = 200) -> list[dict]:
-    with get_db_connection() as conn:
-        rows = conn.execute(
-            """
-            SELECT movie_id, user_rating
-            FROM view_history
-            WHERE user_id = ?
-            ORDER BY viewed_at DESC
-            LIMIT ?
-            """,
-            (user_id, limit),
-        ).fetchall()
-    return [dict(row) for row in rows]
-
-
-def _build_history_profile(history_rows: list[dict]) -> tuple[set[str], Counter, Counter]:
-    viewed_ids = {str(row.get("movie_id", "")).strip() for row in history_rows if row.get("movie_id")}
-    viewed_genres_counter: Counter = Counter()
-    liked_ids = {
-        str(row.get("movie_id", "")).strip()
-        for row in history_rows
-        if row.get("movie_id") and (row.get("user_rating") is not None) and float(row.get("user_rating") or 0) >= LIKE_THRESHOLD
-    }
-    liked_genres_counter: Counter = Counter()
-
-    if not viewed_ids:
-        return viewed_ids, viewed_genres_counter, liked_genres_counter
-
-    for movie in MOVIES_DF:
-        movie_id = str(movie.get("movieId", "")).strip()
-        if movie_id in viewed_ids:
-            genres = _movie_genres(movie)
-            viewed_genres_counter.update(genres)
-            if movie_id in liked_ids:
-                liked_genres_counter.update(genres)
-
-    return viewed_ids, viewed_genres_counter, liked_genres_counter
-
-
-def _quality_key(row: dict) -> tuple[float, float]:
-    return (
-        float(row.get("rating_count", 0) or 0),
-        float(row.get("rating_mean", 0) or 0),
-    )
-
-
-def _similarity_to_history(row: dict, history_genres: set[str]) -> float:
-    if not history_genres:
-        return 0.0
-
-    genres = _movie_genres(row)
-    if not genres:
-        return 0.0
-
-    return len(genres & history_genres) / len(genres)
-
-
-def recommend_movies(emotion_es: str, user_id: str = "", limit: int = 12) -> list[dict]:
-    if not MOVIES_DF:
-        return []
-
-    filtered = []
-    for row in MOVIES_DF:
-        parts = row.get("estados_emocionales", "").split("|")
-        if emotion_es in parts:
-            filtered.append(row)
-
-    if not filtered:
-        return []
-
-    history_rows = _get_user_history_rows(user_id) if user_id else []
-    viewed_ids, viewed_genres_counter, liked_genres_counter = _build_history_profile(history_rows)
-    viewed_genres = set(viewed_genres_counter.keys())
-    liked_genres = set(liked_genres_counter.keys())
-    has_history = len(viewed_ids) > 0
-
-    if not has_history:
-        filtered.sort(key=_quality_key, reverse=True)
-        pool_size = min(len(filtered), max(limit * 4, limit))
-        candidate_pool = filtered[:pool_size]
-
-        if len(candidate_pool) <= limit:
-            random.shuffle(candidate_pool)
-            return candidate_pool
-
-        return random.sample(candidate_pool, k=limit)
-
-    unseen_filtered = [
-        row for row in filtered if str(row.get("movieId", "")).strip() not in viewed_ids
-    ]
-    candidates = unseen_filtered if unseen_filtered else filtered
-
-    is_positive = emotion_es in POSITIVE_EMOTIONS
-    # Negativo: parecido a peliculas valoradas positivamente; fallback a todo el historial si no hay valoraciones altas.
-    reference_genres = viewed_genres if is_positive else (liked_genres if liked_genres else viewed_genres)
-    ranked = sorted(
-        candidates,
-        key=lambda r: (_similarity_to_history(r, reference_genres), *_quality_key(r)),
-        reverse=not is_positive,
-    )
-
-    return ranked[:limit]
-
-
-def save_emotion_event(user_id: str, text: str, emotion: str, analyzed_at: str) -> int | None:
-    if not user_id:
-        return None
-
-    with get_db_connection() as conn:
-        cur = conn.execute(
-            """
-            INSERT INTO emotion_events (user_id, text, emotion, analyzed_at)
-            VALUES (?, ?, ?, ?)
-            """,
-            (user_id, text, emotion, analyzed_at),
-        )
-        conn.commit()
-        return cur.lastrowid
-
-
-def create_recommendation_cycle(
-    user_id: str,
-    pre_text: str,
-    pre_emotion: str,
-    recommendation_mode: str,
-    created_at: str,
-) -> int | None:
-    if not user_id:
-        return None
-
-    pre_valence = emotion_to_valence(pre_emotion)
-    with get_db_connection() as conn:
-        cur = conn.execute(
-            """
-            INSERT INTO recommendation_cycles (
-                user_id,
-                pre_text,
-                pre_emotion,
-                pre_valence,
-                recommendation_mode,
-                created_at
-            )
-            VALUES (?, ?, ?, ?, ?, ?)
-            """,
-            (user_id, pre_text, pre_emotion, pre_valence, recommendation_mode, created_at),
-        )
-        conn.commit()
-        return cur.lastrowid
-
-
-def get_recommendation_cycle(cycle_id: int, user_id: str) -> dict | None:
-    with get_db_connection() as conn:
-        row = conn.execute(
-            """
-            SELECT id, user_id, pre_text, pre_emotion, pre_valence, recommendation_mode,
-                   created_at, selected_movie_id, selected_movie_title,
-                   post_text, post_emotion, post_valence, post_analyzed_at
-            FROM recommendation_cycles
-            WHERE id = ? AND user_id = ?
-            LIMIT 1
-            """,
-            (cycle_id, user_id),
-        ).fetchone()
-    return dict(row) if row else None
-
-
-def save_post_recommendation_state(
-    cycle_id: int,
-    user_id: str,
-    post_text: str,
-    post_emotion: str,
-    post_analyzed_at: str,
-    movie_id: str,
-    movie_title: str,
-) -> None:
-    post_valence = emotion_to_valence(post_emotion)
-    with get_db_connection() as conn:
-        conn.execute(
-            """
-            UPDATE recommendation_cycles
-            SET selected_movie_id = ?,
-                selected_movie_title = ?,
-                post_text = ?,
-                post_emotion = ?,
-                post_valence = ?,
-                post_analyzed_at = ?
-            WHERE id = ? AND user_id = ?
-            """,
-            (movie_id, movie_title, post_text, post_emotion, post_valence, post_analyzed_at, cycle_id, user_id),
-        )
-        conn.commit()
-
-
-def get_last_emotion_event(user_id: str) -> dict | None:
-    if not user_id:
-        return None
-
-    with get_db_connection() as conn:
-        row = conn.execute(
-            """
-            SELECT id, user_id, text, emotion, analyzed_at
-            FROM emotion_events
-            WHERE user_id = ?
-            ORDER BY analyzed_at DESC
-            LIMIT 1
-            """,
-            (user_id,),
-        ).fetchone()
-
-    return dict(row) if row else None
-
-
-def get_last_viewed_between(user_id: str, start_iso: str, end_iso: str) -> dict | None:
-    with get_db_connection() as conn:
-        row = conn.execute(
-            """
-            SELECT movie_id, title, viewed_at
-            FROM view_history
-            WHERE user_id = ?
-              AND viewed_at > ?
-              AND viewed_at <= ?
-            ORDER BY viewed_at DESC
-            LIMIT 1
-            """,
-            (user_id, start_iso, end_iso),
-        ).fetchone()
-
-    return dict(row) if row else None
-
-
-def build_chatbot_response(
-    dominant_emotion: str,
-    recommendation_mode: str,
-    recommendations: list[dict],
-    previous_event: dict | None,
-    transition_movie: dict | None,
-) -> str:
-    if recommendation_mode == "diferente":
-        mode_text = "Como estas en un estado positivo, te propongo explorar peliculas distintas a tu historial."
-    else:
-        mode_text = "Como estas en un estado negativo, te propongo peliculas similares a tu historial para mantener una zona conocida."
-
-    if recommendations:
-        top_title = recommendations[0].get("title", "una pelicula")
-        reco_text = f"Primera sugerencia: {top_title}."
-    else:
-        reco_text = "No encontre recomendaciones para ese estado emocional en este momento."
-
-    if not previous_event:
-        transition_text = "Este es tu primer punto de referencia emocional para analizar transiciones futuras."
-    else:
-        prev_emotion = previous_event.get("emotion", "neutral")
-        if prev_emotion == dominant_emotion:
-            transition_text = f"Tu estado se mantiene en {dominant_emotion}."
-        else:
-            transition_text = f"Detecto una transicion de {prev_emotion} a {dominant_emotion}."
-
-        if transition_movie:
-            movie_title = transition_movie.get("title") or transition_movie.get("movie_id", "pelicula marcada")
-            transition_text += f" Ultima pelicula vista entre ambos estados: {movie_title}."
-
-    return f"Estado actual: {dominant_emotion}. {mode_text} {reco_text} {transition_text}"
-
-
-def _build_text_generation_prompt(
-    dominant_emotion: str,
-    recommendation_mode: str,
-    recommendations: list[dict],
-    previous_event: dict | None,
-    transition_movie: dict | None,
-) -> str:
-    top_titles = [str(row.get("title", "")).strip() for row in recommendations[:3] if row.get("title")]
-    top_titles_text = ", ".join(top_titles) if top_titles else "sin recomendaciones"
-    prev_emotion = previous_event.get("emotion") if previous_event else "ninguna"
-    transition_movie_title = ""
-    if transition_movie:
-        transition_movie_title = str(transition_movie.get("title") or transition_movie.get("movie_id") or "").strip()
-
-    return (
-        "Eres un asistente de recomendaciones de peliculas. "
-        "Redacta una respuesta breve en espanol (maximo 3 frases), clara y empatica. "
-        "Incluye estado emocional actual, explicacion de por que el modo de recomendacion es ese, "
-        "y menciona una pelicula sugerida si existe. "
-        f"Estado actual: {dominant_emotion}. "
-        f"Modo: {recommendation_mode}. "
-        f"Emocion anterior: {prev_emotion}. "
-        f"Peliculas sugeridas: {top_titles_text}. "
-        f"Pelicula asociada a transicion: {transition_movie_title or 'ninguna'}."
-    )
-
-
-def generate_chatbot_text(
-    dominant_emotion: str,
-    recommendation_mode: str,
-    recommendations: list[dict],
-    previous_event: dict | None,
-    transition_movie: dict | None,
-) -> tuple[str, str]:
-    template_text = build_chatbot_response(
-        dominant_emotion=dominant_emotion,
-        recommendation_mode=recommendation_mode,
-        recommendations=recommendations,
-        previous_event=previous_event,
-        transition_movie=transition_movie,
-    )
-
-    try:
-        prompt = _build_text_generation_prompt(
-            dominant_emotion=dominant_emotion,
-            recommendation_mode=recommendation_mode,
-            recommendations=recommendations,
-            previous_event=previous_event,
-            transition_movie=transition_movie,
-        )
-        payload = {
-            "model": TEXT_MODEL_NAME,
-            "prompt": prompt,
-            "stream": False,
-            "options": {
-                "temperature": 0.7,
-                "top_p": 0.9,
-                "num_predict": 120,
-            },
-        }
-        res = http_requests.post(OLLAMA_URL, json=payload, timeout=20)
-        if res.ok:
-            data = res.json()
-            generated = str(data.get("response", "")).strip()
-            if generated:
-                return generated, "ollama"
-
-        print(f"Aviso: Ollama devolvio HTTP {res.status_code}. Se usa plantilla.")
-    except Exception as exc:
-        print(f"Aviso: fallo generando texto con Ollama ({exc}). Se usa plantilla.")
-
-    return template_text, "template-fallback"
-
-
-def get_db_connection() -> sqlite3.Connection:
-    conn = sqlite3.connect(HISTORY_DB_PATH)
-    conn.row_factory = sqlite3.Row
-    return conn
-
-
-def init_history_db() -> None:
-    with get_db_connection() as conn:
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS view_history (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                user_id TEXT NOT NULL,
-                movie_id TEXT NOT NULL,
-                title TEXT,
-                emotion TEXT,
-                user_rating REAL,
-                session_text TEXT,
-                viewed_at TEXT NOT NULL
-            )
-            """
-        )
-        # Compatibilidad con BDs existentes creadas sin columna de valoracion.
-        columns = conn.execute("PRAGMA table_info(view_history)").fetchall()
-        column_names = {row[1] for row in columns}
-        if "user_rating" not in column_names:
-            conn.execute("ALTER TABLE view_history ADD COLUMN user_rating REAL")
-        conn.execute(
-            """
-            CREATE INDEX IF NOT EXISTS idx_view_history_user_viewed_at
-            ON view_history (user_id, viewed_at DESC)
-            """
-        )
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS emotion_events (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                user_id TEXT NOT NULL,
-                text TEXT,
-                emotion TEXT NOT NULL,
-                analyzed_at TEXT NOT NULL
-            )
-            """
-        )
-        conn.execute(
-            """
-            CREATE INDEX IF NOT EXISTS idx_emotion_events_user_analyzed_at
-            ON emotion_events (user_id, analyzed_at DESC)
-            """
-        )
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS recommendation_cycles (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                user_id TEXT NOT NULL,
-                pre_text TEXT,
-                pre_emotion TEXT NOT NULL,
-                pre_valence TEXT NOT NULL,
-                recommendation_mode TEXT NOT NULL,
-                created_at TEXT NOT NULL,
-                selected_movie_id TEXT,
-                selected_movie_title TEXT,
-                post_text TEXT,
-                post_emotion TEXT,
-                post_valence TEXT,
-                post_analyzed_at TEXT
-            )
-            """
-        )
-        conn.execute(
-            """
-            CREATE INDEX IF NOT EXISTS idx_recommendation_cycles_user_created_at
-            ON recommendation_cycles (user_id, created_at DESC)
-            """
-        )
-        conn.commit()
-
-
-print("Cargando modelo...")
-clf = pipeline(
-    "text-classification",
-    model="pysentimiento/robertuito-emotion-analysis",
-    top_k=None,
-    device=-1,
-)
-
-MOVIES_DF = load_movies_dataset()
-init_history_db()
-print(f"Listo. Dataset de recomendaciones: {len(MOVIES_DF)} peliculas")
-
-
-@app.route("/analizar", methods=["POST"])
-def analizar():
-    texto = request.json.get("texto", "")
-    user_id = str(request.json.get("user_id", "")).strip()
-    previous_event = get_last_emotion_event(user_id)
-    analyzed_at = datetime.now(timezone.utc).isoformat()
-    resultado = sorted(clf(texto)[0], key=lambda x: x["score"], reverse=True)
-
-    dominant_model = resultado[0]["label"] if resultado else "others"
-    dominant_es = EMOTION_MAP.get(dominant_model, "neutral")
-    dominant_valence = emotion_to_valence(dominant_es)
-    recomendaciones = recommend_movies(dominant_es, user_id=user_id, limit=12)
-    recommendation_mode = "diferente" if dominant_es in POSITIVE_EMOTIONS else "similar"
-
-    cycle_id = create_recommendation_cycle(
-        user_id=user_id,
-        pre_text=texto,
-        pre_emotion=dominant_es,
-        recommendation_mode=recommendation_mode,
-        created_at=analyzed_at,
-    )
-
-    save_emotion_event(user_id=user_id, text=texto, emotion=dominant_es, analyzed_at=analyzed_at)
-
-    transition_movie = None
-    if previous_event:
-        transition_movie = get_last_viewed_between(
-            user_id=user_id,
-            start_iso=previous_event.get("analyzed_at", ""),
-            end_iso=analyzed_at,
-        )
-
-    chatbot_text, chatbot_source = generate_chatbot_text(
-        dominant_emotion=dominant_es,
-        recommendation_mode=recommendation_mode,
-        recommendations=recomendaciones,
-        previous_event=previous_event,
-        transition_movie=transition_movie,
-    )
-
-    return jsonify(
-        {
-            "emociones": resultado,
-            "emocion_dominante": dominant_es,
-            "valencia_dominante": dominant_valence,
-            "emocion_anterior": previous_event.get("emotion") if previous_event else None,
-            "modo_recomendacion": recommendation_mode,
-            "ciclo_recomendacion_id": cycle_id,
-            "chatbot_texto": chatbot_text,
-            "chatbot_fuente": chatbot_source,
-            "pelicula_transicion": transition_movie,
-            "recomendaciones": recomendaciones,
-        }
-    )
-
-
-@app.route("/recomendacion/seguimiento", methods=["POST"])
-def seguimiento_recomendacion():
-    payload = request.json or {}
-    user_id = str(payload.get("user_id", "")).strip()
-    post_text = str(payload.get("texto_post", "")).strip()
-    movie_id = str(payload.get("movie_id", "")).strip()
-    movie_title = str(payload.get("title", "")).strip()
-
-    try:
-        cycle_id = int(payload.get("ciclo_recomendacion_id", 0))
-    except (TypeError, ValueError):
-        cycle_id = 0
-
-    if not user_id or not cycle_id or not post_text:
-        return jsonify({"error": "user_id, ciclo_recomendacion_id y texto_post son obligatorios"}), 400
-
-    cycle = get_recommendation_cycle(cycle_id=cycle_id, user_id=user_id)
-    if not cycle:
-        return jsonify({"error": "ciclo de recomendacion no encontrado"}), 404
-
-    analyzed_at = datetime.now(timezone.utc).isoformat()
-    result_post = sorted(clf(post_text)[0], key=lambda x: x["score"], reverse=True)
-    post_model = result_post[0]["label"] if result_post else "others"
-    post_emotion = EMOTION_MAP.get(post_model, "neutral")
-    post_valence = emotion_to_valence(post_emotion)
-
-    save_emotion_event(user_id=user_id, text=post_text, emotion=post_emotion, analyzed_at=analyzed_at)
-    save_post_recommendation_state(
-        cycle_id=cycle_id,
-        user_id=user_id,
-        post_text=post_text,
-        post_emotion=post_emotion,
-        post_analyzed_at=analyzed_at,
-        movie_id=movie_id,
-        movie_title=movie_title,
-    )
-
-    return jsonify(
-        {
-            "ciclo_recomendacion_id": cycle_id,
-            "movie_id": movie_id,
-            "title": movie_title,
-            "pre_emotion": cycle.get("pre_emotion"),
-            "pre_valence": cycle.get("pre_valence"),
-            "post_emotion": post_emotion,
-            "post_valence": post_valence,
-            "cambio_emocional": cycle.get("pre_emotion") != post_emotion,
-            "cambio_valencia": cycle.get("pre_valence") != post_valence,
-            "emociones_post": result_post,
-        }
-    )
-
-
-@app.route("/historial/visto", methods=["POST"])
-def guardar_visto():
-    payload = request.json or {}
-    user_id = str(payload.get("user_id", "")).strip()
-    movie_id = str(payload.get("movie_id", "")).strip()
-
-    if not user_id or not movie_id:
-        return jsonify({"error": "user_id y movie_id son obligatorios"}), 400
-
-    viewed_at = datetime.now(timezone.utc).isoformat()
-    title = str(payload.get("title", "")).strip()
-    emotion = str(payload.get("emotion", "")).strip()
-    session_text = str(payload.get("session_text", "")).strip()
-    user_rating_raw = payload.get("user_rating")
-    user_rating = None
-    if user_rating_raw is not None and str(user_rating_raw).strip() != "":
-        try:
-            user_rating = float(user_rating_raw)
-        except (TypeError, ValueError):
-            return jsonify({"error": "user_rating debe ser numerica entre 1 y 5"}), 400
-        if user_rating < 1 or user_rating > 5:
-            return jsonify({"error": "user_rating debe estar entre 1 y 5"}), 400
-
-    with get_db_connection() as conn:
-        cur = conn.execute(
-            """
-            INSERT INTO view_history (user_id, movie_id, title, emotion, user_rating, session_text, viewed_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-            """,
-            (user_id, movie_id, title, emotion, user_rating, session_text, viewed_at),
-        )
-        conn.commit()
-        inserted_id = cur.lastrowid
-
-    return jsonify(
-        {
-            "id": inserted_id,
-            "user_id": user_id,
-            "movie_id": movie_id,
-            "title": title,
-            "emotion": emotion,
-            "user_rating": user_rating,
-            "session_text": session_text,
-            "viewed_at": viewed_at,
-        }
-    ), 201
-
-
-@app.route("/historial", methods=["GET"])
-def obtener_historial():
-    user_id = str(request.args.get("user_id", "")).strip()
-    if not user_id:
-        return jsonify({"error": "user_id es obligatorio"}), 400
-
-    try:
-        limit = int(request.args.get("limit", 30))
-    except ValueError:
-        limit = 30
-
-    limit = max(1, min(limit, 200))
-
-    with get_db_connection() as conn:
-        rows = conn.execute(
-            """
-            SELECT id, user_id, movie_id, title, emotion, user_rating, session_text, viewed_at
-            FROM view_history
-            WHERE user_id = ?
-            ORDER BY viewed_at DESC
-            LIMIT ?
-            """,
-            (user_id, limit),
-        ).fetchall()
-
-    historial = [dict(row) for row in rows]
-    return jsonify({"items": historial, "count": len(historial)})
-
-
-@app.route("/historial/transiciones", methods=["GET"])
-def obtener_transiciones():
-    user_id = str(request.args.get("user_id", "")).strip()
-    if not user_id:
-        return jsonify({"error": "user_id es obligatorio"}), 400
-
-    try:
-        limit = int(request.args.get("limit", 20))
-    except ValueError:
-        limit = 20
-
-    limit = max(1, min(limit, 100))
-
-    with get_db_connection() as conn:
-        event_rows = conn.execute(
-            """
-            SELECT id, user_id, text, emotion, analyzed_at
-            FROM emotion_events
-            WHERE user_id = ?
-            ORDER BY analyzed_at ASC
-            LIMIT 500
-            """,
-            (user_id,),
-        ).fetchall()
-
-        view_rows = conn.execute(
-            """
-            SELECT movie_id, title, viewed_at
-            FROM view_history
-            WHERE user_id = ?
-            ORDER BY viewed_at ASC
-            LIMIT 1000
-            """,
-            (user_id,),
-        ).fetchall()
-
-    events = [dict(row) for row in event_rows]
-    views = [dict(row) for row in view_rows]
-
-    transition_counter: dict[tuple[str, str, str, str], int] = {}
-
-    for idx in range(1, len(events)):
-        prev_event = events[idx - 1]
-        curr_event = events[idx]
-        if prev_event.get("emotion") == curr_event.get("emotion"):
-            continue
-
-        start = prev_event.get("analyzed_at", "")
-        end = curr_event.get("analyzed_at", "")
-
-        matched_movie = None
-        for view in reversed(views):
-            viewed_at = view.get("viewed_at", "")
-            if start < viewed_at <= end:
-                matched_movie = view
-                break
-
-        if not matched_movie:
-            continue
-
-        key = (
-            str(matched_movie.get("movie_id", "")),
-            matched_movie.get("title") or "",
-            prev_event.get("emotion", ""),
-            curr_event.get("emotion", ""),
-        )
-        transition_counter[key] = transition_counter.get(key, 0) + 1
-
-    items = []
-    for (movie_id, title, from_emotion, to_emotion), count in transition_counter.items():
-        items.append(
-            {
-                "movie_id": movie_id,
-                "title": title,
-                "from_emotion": from_emotion,
-                "to_emotion": to_emotion,
-                "count": count,
-            }
-        )
-
-    items.sort(key=lambda x: x["count"], reverse=True)
-    return jsonify({"items": items[:limit], "count": len(items)})
+from app_factory import create_app
 
+app = create_app()
 
 if __name__ == "__main__":
     app.run(port=5000)

backend/services/chatbot_service.py

@@ -0,0 +1,111 @@
+import requests as http_requests
+
+from config import OLLAMA_URL, TEXT_MODEL_NAME
+
+
+def build_chatbot_response(
+    dominant_emotion: str,
+    recommendation_mode: str,
+    recommendations: list[dict],
+    previous_event: dict | None,
+    transition_movie: dict | None,
+) -> str:
+    if recommendation_mode == "diferente":
+        mode_text = "Como estas en un estado positivo, te propongo explorar peliculas distintas a tu historial."
+    else:
+        mode_text = "Como estas en un estado negativo, te propongo peliculas similares a tu historial para mantener una zona conocida."
+
+    if recommendations:
+        top_title = recommendations[0].get("title", "una pelicula")
+        reco_text = f"Primera sugerencia: {top_title}."
+    else:
+        reco_text = "No encontre recomendaciones para ese estado emocional en este momento."
+
+    if not previous_event:
+        transition_text = "Este es tu primer punto de referencia emocional para analizar transiciones futuras."
+    else:
+        prev_emotion = previous_event.get("emotion", "neutral")
+        if prev_emotion == dominant_emotion:
+            transition_text = f"Tu estado se mantiene en {dominant_emotion}."
+        else:
+            transition_text = f"Detecto una transicion de {prev_emotion} a {dominant_emotion}."
+
+        if transition_movie:
+            movie_title = transition_movie.get("title") or transition_movie.get("movie_id", "pelicula marcada")
+            transition_text += f" Ultima pelicula vista entre ambos estados: {movie_title}."
+
+    return f"Estado actual: {dominant_emotion}. {mode_text} {reco_text} {transition_text}"
+
+
+def _build_text_generation_prompt(
+    dominant_emotion: str,
+    recommendation_mode: str,
+    recommendations: list[dict],
+    previous_event: dict | None,
+    transition_movie: dict | None,
+) -> str:
+    top_titles = [str(row.get("title", "")).strip() for row in recommendations[:3] if row.get("title")]
+    top_titles_text = ", ".join(top_titles) if top_titles else "sin recomendaciones"
+    prev_emotion = previous_event.get("emotion") if previous_event else "ninguna"
+    transition_movie_title = ""
+    if transition_movie:
+        transition_movie_title = str(transition_movie.get("title") or transition_movie.get("movie_id") or "").strip()
+
+    return (
+        "Eres un asistente de recomendaciones de peliculas. "
+        "Redacta una respuesta breve en espanol (maximo 3 frases), clara y empatica. "
+        "Incluye estado emocional actual, explicacion de por que el modo de recomendacion es ese, "
+        "y menciona una pelicula sugerida si existe. "
+        f"Estado actual: {dominant_emotion}. "
+        f"Modo: {recommendation_mode}. "
+        f"Emocion anterior: {prev_emotion}. "
+        f"Peliculas sugeridas: {top_titles_text}. "
+        f"Pelicula asociada a transicion: {transition_movie_title or 'ninguna'}."
+    )
+
+
+def generate_chatbot_text(
+    dominant_emotion: str,
+    recommendation_mode: str,
+    recommendations: list[dict],
+    previous_event: dict | None,
+    transition_movie: dict | None,
+) -> tuple[str, str]:
+    template_text = build_chatbot_response(
+        dominant_emotion=dominant_emotion,
+        recommendation_mode=recommendation_mode,
+        recommendations=recommendations,
+        previous_event=previous_event,
+        transition_movie=transition_movie,
+    )
+
+    try:
+        prompt = _build_text_generation_prompt(
+            dominant_emotion=dominant_emotion,
+            recommendation_mode=recommendation_mode,
+            recommendations=recommendations,
+            previous_event=previous_event,
+            transition_movie=transition_movie,
+        )
+        payload = {
+            "model": TEXT_MODEL_NAME,
+            "prompt": prompt,
+            "stream": False,
+            "options": {
+                "temperature": 0.7,
+                "top_p": 0.9,
+                "num_predict": 120,
+            },
+        }
+        res = http_requests.post(OLLAMA_URL, json=payload, timeout=20)
+        if res.ok:
+            data = res.json()
+            generated = str(data.get("response", "")).strip()
+            if generated:
+                return generated, "ollama"
+
+        print(f"Aviso: Ollama devolvio HTTP {res.status_code}. Se usa plantilla.")
+    except Exception as exc:
+        print(f"Aviso: fallo generando texto con Ollama ({exc}). Se usa plantilla.")
+
+    return template_text, "template-fallback"

backend/services/emotion_service.py

@@ -0,0 +1,31 @@
+from transformers import pipeline
+
+from config import EMOTION_MAP, NEGATIVE_EMOTIONS, POSITIVE_EMOTIONS
+
+
+def mapeo_emocion_valencia(emocion: str) -> str:
+    # Convierte una emocion puntual a valencia (positivo, negativo o neutro).
+    if emocion in POSITIVE_EMOTIONS:
+        return "positivo"
+    if emocion in NEGATIVE_EMOTIONS:
+        return "negativo"
+    return "neutro"
+
+
+def create_emotion_classifier():
+    # Modelo local de clasificacion emocional en espanol.
+    return pipeline(
+        "text-classification",
+        model="pysentimiento/robertuito-emotion-analysis",
+        top_k=None,
+        device=-1,
+    )
+
+
+def analyze_text(clf, texto: str) -> tuple[list[dict], str, str]:
+    # Ordena por score para devolver la emocion dominante en la primera posicion.
+    resultado = sorted(clf(texto)[0], key=lambda x: x["score"], reverse=True)
+    dominant_model = resultado[0]["label"] if resultado else "others"
+    dominant_es = EMOTION_MAP.get(dominant_model, "neutral")
+    dominant_valence = mapeo_emocion_valencia(dominant_es)
+    return resultado, dominant_es, dominant_valence

backend/services/recommender_service.py

@@ -0,0 +1,238 @@
+import csv
+import random
+from collections import Counter
+
+from config import GLOBAL_PRIOR_COUNT, LIKE_THRESHOLD, POSITIVE_EMOTIONS, ROOT_DIR
+from repositories.history_repository import get_user_history_rows
+
+
+def _cargar_estadisticas_ratings() -> tuple[dict[str, tuple[float, int]], float]:
+    # Carga ratings.csv para calcular media y conteo por pelicula,
+    # mas la media global del dataset.
+    ratings_path = ROOT_DIR / "data" / "ml-latest" / "ratings.csv"
+    if not ratings_path.exists():
+        return {}, 0.0
+
+    # Diccionario temporal para acumular sumas y conteos de ratings.
+    movie_sum_count: dict[str, list[float | int]] = {}
+    total_sum = 0.0
+    total_count = 0
+
+    with open(ratings_path, "r", encoding="utf-8", newline="") as f:
+        for row in csv.DictReader(f):
+            # Se obtiene movieId y rating por fila; si no son validos se omiten.
+            movie_id = str(row.get("movieId", "")).strip()
+            if not movie_id:
+                continue
+
+            try:
+                rating = float(row.get("rating", 0) or 0)
+            except (TypeError, ValueError):
+                continue
+
+            if movie_id not in movie_sum_count:
+                movie_sum_count[movie_id] = [0.0, 0]
+
+            movie_sum_count[movie_id][0] += rating
+            movie_sum_count[movie_id][1] += 1
+            total_sum += rating
+            total_count += 1
+
+    stats: dict[str, tuple[float, int]] = {}
+    for movie_id, (sum_rating, count_rating) in movie_sum_count.items():
+        mean = (sum_rating / count_rating) if count_rating else 0.0
+        stats[movie_id] = (mean, int(count_rating))
+
+    global_mean = (total_sum / total_count) if total_count else 0.0
+    return stats, global_mean
+
+
+def cargar_dataset_movies() -> tuple[list[dict], float]:
+    # Enriquecemos movies.csv con rating_count y rating_mean de ratings.csv.
+    rating_stats, global_mean = _cargar_estadisticas_ratings()
+    candidates = [ROOT_DIR / "data" / "ml-latest" / "movies.csv"]
+
+    for path in candidates:
+        if path.exists():
+            with open(path, "r", encoding="utf-8", newline="") as f:
+                rows = list(csv.DictReader(f))
+
+            for row in rows:
+                movie_id = str(row.get("movieId", "")).strip()
+                mean, count = rating_stats.get(movie_id, (0.0, 0))
+                row["rating_count"] = int(count)
+                row["rating_mean"] = float(mean)
+
+            return rows, global_mean
+
+    return [], global_mean
+
+
+def _obtener_generos_pelicula(row: dict) -> set[str]:
+    # Se separan generos por "|" y se limpian espacios.
+    return {g.strip() for g in row.get("genres", "").split("|") if g.strip()}
+
+
+def _construir_perfil_usuario(
+    movies_df: list[dict],
+    history_rows: list[dict],
+) -> tuple[set[str], Counter, Counter, dict[str, float]]:
+    # Perfil del usuario: peliculas vistas, generos vistos/gustados y media por genero.
+    peliculas_vistas = {str(row.get("movie_id", "")).strip() for row in history_rows if row.get("movie_id")}
+    contador_generos_vistos: Counter = Counter()
+    peliculas_gustadas = {
+        str(row.get("movie_id", "")).strip()
+        for row in history_rows
+        if row.get("movie_id") and (row.get("user_rating") is not None) and float(row.get("user_rating") or 0) >= LIKE_THRESHOLD
+    }
+    contador_generos_gustados: Counter = Counter()
+    sumas_ratings_generos: dict[str, float] = {}
+    conteo_puntuaciones_por_genero: dict[str, int] = {}
+
+    # Si no hay historial, se devuelve perfil vacio.
+    if not peliculas_vistas:
+        return peliculas_vistas, contador_generos_vistos, contador_generos_gustados, {}
+
+    history_rating_by_movie: dict[str, float] = {}
+    for row in history_rows:
+        movie_id = str(row.get("movie_id", "")).strip()
+        if not movie_id:
+            continue
+        if row.get("user_rating") is None:
+            continue
+        try:
+            history_rating_by_movie[movie_id] = float(row.get("user_rating") or 0)
+        except (TypeError, ValueError):
+            continue
+
+    for movie in movies_df:
+        movie_id = str(movie.get("movieId", "")).strip()
+        if movie_id in peliculas_vistas:
+            genres = _obtener_generos_pelicula(movie)
+            contador_generos_vistos.update(genres)
+            if movie_id in peliculas_gustadas:
+                contador_generos_gustados.update(genres)
+
+            if movie_id in history_rating_by_movie:
+                rating = history_rating_by_movie[movie_id]
+                for genre in genres:
+                    sumas_ratings_generos[genre] = sumas_ratings_generos.get(genre, 0.0) + rating
+                    conteo_puntuaciones_por_genero[genre] = conteo_puntuaciones_por_genero.get(genre, 0) + 1
+
+    genre_rating_means = {
+        genre: (sumas_ratings_generos[genre] / conteo_puntuaciones_por_genero[genre])
+        for genre in sumas_ratings_generos
+        if conteo_puntuaciones_por_genero.get(genre, 0) > 0
+    }
+
+    return peliculas_vistas, contador_generos_vistos, contador_generos_gustados, genre_rating_means
+
+
+def _global_quality_score(row: dict, global_rating_mean: float) -> float:
+    # Score global [0..1] con suavizado bayesiano para no sobrevalorar pocos votos.
+    count = float(row.get("rating_count", 0) or 0)
+    mean = float(row.get("rating_mean", 0) or 0)
+
+    if count <= 0:
+        smoothed = global_rating_mean
+    else:
+        smoothed = ((count * mean) + (GLOBAL_PRIOR_COUNT * global_rating_mean)) / (count + GLOBAL_PRIOR_COUNT)
+
+    return max(0.0, min(1.0, smoothed / 5.0))
+
+
+def _similarity_to_history(row: dict, history_genres: set[str]) -> float:
+    if not history_genres:
+        return 0.0
+
+    genres = _obtener_generos_pelicula(row)
+    if not genres:
+        return 0.0
+
+    return len(genres & history_genres) / len(genres)
+
+
+def _personal_preference_score(
+    row: dict,
+    genre_rating_means: dict[str, float],
+    reference_genres: set[str],
+) -> float:
+    # Prediccion personal [0..1] por medias de genero del usuario.
+    # Si faltan ratings propios, cae a similitud por generos.
+    genres = _obtener_generos_pelicula(row)
+    if not genres:
+        return 0.0
+
+    rated_values = [genre_rating_means[g] for g in genres if g in genre_rating_means]
+    if rated_values:
+        return max(0.0, min(1.0, (sum(rated_values) / len(rated_values)) / 5.0))
+
+    return _similarity_to_history(row, reference_genres)
+
+
+def recommend_movies(
+    emotion_es: str,
+    user_id: str,
+    limit: int,
+    movies_df: list[dict],
+    global_rating_mean: float,
+) -> list[dict]:
+    # Motor principal de recomendacion con dos modos:
+    # - estado positivo: exploracion
+    # - estado negativo: zona conocida
+    if not movies_df:
+        return []
+
+    history_rows = get_user_history_rows(user_id) if user_id else []
+    peliculas_vistas, contador_generos_vistos, contador_generos_gustados, genre_rating_means = _construir_perfil_usuario(
+        movies_df,
+        history_rows,
+    )
+    viewed_genres = set(contador_generos_vistos.keys())
+    liked_genres = set(contador_generos_gustados.keys())
+    has_history = len(peliculas_vistas) > 0
+
+    unseen_movies = [row for row in movies_df if str(row.get("movieId", "")).strip() not in peliculas_vistas]
+    candidates = unseen_movies if unseen_movies else movies_df
+
+    if not candidates:
+        return []
+
+    # Fallback para usuarios sin historial: se prioriza calidad global.
+    if not has_history:
+        ranked = sorted(candidates, key=lambda r: _global_quality_score(r, global_rating_mean), reverse=True)
+        pool_size = min(len(ranked), max(limit * 4, limit))
+        candidate_pool = ranked[:pool_size]
+
+        if len(candidate_pool) <= limit:
+            random.shuffle(candidate_pool)
+            return candidate_pool
+
+        return random.sample(candidate_pool, k=limit)
+
+    is_positive = emotion_es in POSITIVE_EMOTIONS
+    if is_positive:
+        # Emocion positiva: mayor peso a novedad sin perder calidad.
+        ranked = sorted(
+            candidates,
+            key=lambda r: (
+                0.25 * _personal_preference_score(r, genre_rating_means, viewed_genres)
+                + 0.30 * _global_quality_score(r, global_rating_mean)
+                + 0.45 * (1.0 - _similarity_to_history(r, viewed_genres))
+            ),
+            reverse=True,
+        )
+    else:
+        # Emocion negativa: mayor peso a preferencia personal + similitud.
+        reference_genres = liked_genres if liked_genres else viewed_genres
+        ranked = sorted(
+            candidates,
+            key=lambda r: (
+                0.55 * _personal_preference_score(r, genre_rating_means, reference_genres)
+                + 0.30 * _global_quality_score(r, global_rating_mean)
+                + 0.15 * _similarity_to_history(r, reference_genres)
+            ),
+            reverse=True,
+        )
+
+    return ranked[:limit]

chatbot/dist/index.html

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Analizador de Emociones</title>
-    <script type="module" crossorigin src="/assets/index-BxMsgJL0.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Dfdk3UzR.css">
+    <script type="module" crossorigin src="/assets/index-CoyYSZRA.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Dlg3yhkK.css">
   </head>
   <body>
     <div id="root"></div>

chatbot/src/App.vue

@@ -5,7 +5,11 @@
         <AppHero :user-id-label="userIdLabel" />
 
         <v-row align="start">
-          <SidePanel :history="history" />
+          <SidePanel
+            :history="history"
+            :clear-loading="clearHistoryLoading"
+            @clear-history="clearHistory"
+          />
 
           <MessageFeed
             :messages="messages"
@@ -35,6 +39,7 @@ const loading = ref(false);
 const userId = ref("");
 const history = ref([]);
 const followupByCycle = ref({});
+const clearHistoryLoading = ref(false);
 
 const viewedMovieIds = computed(() => new Set(history.value.map((item) => String(item.movie_id))));
 const userIdLabel = computed(() => (userId.value ? userId.value.slice(0, 8) : "anon"));
@@ -165,6 +170,34 @@ async function markAsViewed(movie, dominantEmotion, sourceText, recommendationCy
     // No bloquea la experiencia principal del chat si falla el historial.
   }
 }
+
+async function clearHistory() {
+  if (!userId.value || clearHistoryLoading.value) return;
+
+  const confirmed = window.confirm("Se borrara tu historial de visionado. Quieres continuar?");
+  if (!confirmed) return;
+
+  clearHistoryLoading.value = true;
+  try {
+    const res = await fetch("http://localhost:5000/historial", {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ user_id: userId.value }),
+    });
+
+    if (!res.ok) {
+      window.alert("No se pudo borrar el historial.");
+      return;
+    }
+
+    history.value = [];
+    window.alert("Historial borrado correctamente.");
+  } catch {
+    window.alert("No se pudo conectar con el backend para borrar el historial.");
+  } finally {
+    clearHistoryLoading.value = false;
+  }
+}
 </script>
 
 <style>

chatbot/src/components/SidePanel.vue

@@ -1,7 +1,19 @@
 <template>
   <v-col cols="12" md="4">
     <v-card class="panel-card" rounded="xl" elevation="0">
-      <v-card-title class="panel-title">Tu historial reciente</v-card-title>
+      <v-card-title class="panel-title panel-title-row">
+        <span>Tu historial reciente</span>
+        <v-btn
+          size="small"
+          variant="tonal"
+          color="error"
+          prepend-icon="mdi-delete-sweep-outline"
+          :disabled="!history.length || clearLoading"
+          @click="emit('clear-history')"
+        >
+          Borrar
+        </v-btn>
+      </v-card-title>
       <v-card-text>
         <v-list v-if="history.length" density="compact" bg-color="transparent">
           <v-list-item v-for="item in history.slice(0, 8)" :key="item.id" class="history-item">
@@ -46,7 +58,13 @@ defineProps({
     type: Array,
     default: () => [],
   },
+  clearLoading: {
+    type: Boolean,
+    default: false,
+  },
 });
+
+const emit = defineEmits(["clear-history"]);
 </script>
 
 <style scoped>
@@ -61,6 +79,13 @@ defineProps({
   letter-spacing: 0.02em;
 }
 
+.panel-title-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+}
+
 .history-item {
   border-radius: 10px;
   margin-bottom: 3px;

requirements.txt

@@ -1,26 +1,24 @@
 # Backend (API)
-Flask==3.0.2
+Flask==3.0.2 
 flask-cors==4.0.0
 requests==2.31.0
 
-# NLP and models
-transformers==4.35.2
+# Procesar lenguaje natural y modelos de lenguaje
+transformers==4.35.2 
 torch==2.0.1
 flair==0.12.2
 pysentimiento>=0.7.0
 
-# Notebook utilities
+# Usadas en los Jupyter Notebooks
 deep-translator==1.11.4
 nltk==3.8.1
 textblob==0.17.1
 datasets==2.14.6
+jupyter==1.0.0
+ipykernel==6.27.1
 
-# Data analysis and visualization
+# Analisis de datos y visualización
 pandas==2.1.4
 numpy==1.24.3
 matplotlib==3.8.3
 seaborn==0.13.1
-
-# Jupyter
-jupyter==1.0.0
-ipykernel==6.27.1