BD modificada, renombre, DAO, DTO, VO, Singleton e Factory

.claude/settings.local.json

@@ -7,7 +7,8 @@
       "Bash(Get-ChildItem -Path \"c:\\\\Users\\\\usuario\\\\Desktop\\\\ValorSentimental\" -Recurse -Force)",
       "Bash(Select-Object -Property FullName, Name)",
       "Bash(ConvertTo-Json)",
-      "Bash(Out-String)"
+      "Bash(Out-String)",
+      "Bash(Select-Object FullName)"
     ]
   }
 }

backend/aplicacion.py

@@ -0,0 +1,392 @@
+"""
+Configura y expone la app Flask como singleton.
+Las rutas son delegadores delgados: validan la entrada, llaman al servicio correspondiente y serializan la respuesta.
+"""
+
+import dataclasses
+import re
+from datetime import datetime, timezone
+
+import requests as http_requests
+from flask import Flask, jsonify, request
+from flask_cors import CORS
+
+from config import OMDB_API_KEY
+from dao.ciclo_dao import CicloDAO
+from dao.emocion_dao import EmocionDAO
+from dao.historial_dao import HistorialDAO
+from dao.pelicula_dao import PeliculaDAO
+from dao.usuario_dao import UsuarioDao
+from base_datos import iniciar_historial_usuario
+from modelos import PeliculaVistaVO
+from services.pipeline import AnalysisService
+from services.analisis_sentimientos import analizar_texto, crear_clasificador_emociones
+from services.recomendacion import cargar_dataset_movies
+
+
+_poster_cache: dict[str, str | None] = {}
+_movies_index: dict[str, dict] = {}  # movieId -> row, built after dataset loads
+
+
+def _year_from_title(title: str) -> str | None:
+    m = re.search(r"\((\d{4})\)\s*$", title or "")
+    return m.group(1) if m else None
+
+
+def _meta_pelicula(movie_id: str) -> tuple[str | None, str | None]:
+    """Returns (anio, genero) from the in-memory dataset index."""
+    row = _movies_index.get(str(movie_id))
+    if not row:
+        return None, None
+    genres_raw = str(row.get("genres", "") or "").strip()
+    genero = genres_raw if genres_raw and genres_raw != "(no genres listed)" else None
+    anio = _year_from_title(str(row.get("title", "") or ""))
+    return anio, genero
+
+app = Flask(__name__)
+CORS(app)
+
+_modelo = crear_clasificador_emociones()  # Carga localmente pysentimiento/robertuito (descarga al primer arranque)
+_movies_df, _media_rating_global = cargar_dataset_movies()
+_movies_index = {str(r.get("movieId", "")).strip(): r for r in _movies_df}
+iniciar_historial_usuario()
+print(
+    f"Listo. Dataset de recomendaciones: {len(_movies_df)} peliculas "
+    f"(rating global medio={_media_rating_global:.3f})"
+)
+
+_analysis_service = AnalysisService(_modelo, _movies_df, _media_rating_global)
+
+_usuario_dao = UsuarioDao()
+_emocion_dao = EmocionDAO()
+_ciclo_dao = CicloDAO()
+_historial_dao = HistorialDAO()
+_pelicula_dao = PeliculaDAO()
+
+
+# ------------------------------------------------------------------
+# Auth
+# ------------------------------------------------------------------
+
+@app.route("/auth/register", methods=["POST"])
+def register():
+    payload = request.json or {}
+    username = str(payload.get("username", "")).strip()
+    password = str(payload.get("password", "")).strip()
+    if not username or not password:
+        return jsonify({"error": "username y password son obligatorios"}), 400
+    if len(username) < 3:
+        return jsonify({"error": "El usuario debe tener al menos 3 caracteres"}), 400
+    if len(password) < 6:
+        return jsonify({"error": "La contraseña debe tener al menos 6 caracteres"}), 400
+    usuario = _usuario_dao.registrar(username, password)
+    if not usuario:
+        return jsonify({"error": "El nombre de usuario ya existe"}), 409
+    return jsonify({"user_id": usuario.id, "username": usuario.username, "token": usuario.token}), 201
+
+@app.route("/auth/login", methods=["POST"])
+def login():
+    payload = request.json or {}
+    username = str(payload.get("username", "")).strip()
+    password = str(payload.get("password", "")).strip()
+    if not username or not password:
+        return jsonify({"error": "username y password son obligatorios"}), 400
+    usuario = _usuario_dao.login(username, password)
+    if not usuario:
+        return jsonify({"error": "Credenciales incorrectas"}), 401
+    return jsonify({"user_id": usuario.id, "username": usuario.username, "token": usuario.token})
+
+@app.route("/auth/logout", methods=["POST"])
+def logout():
+    payload = request.json or {}
+    token = str(payload.get("token", "")).strip()
+    _usuario_dao.cerrar_sesion(token)
+    return jsonify({"ok": True})
+
+@app.route("/auth/password", methods=["POST"])
+def change_password():
+    payload = request.json or {}
+    token = str(payload.get("token", "")).strip()
+    old_password = str(payload.get("old_password", "")).strip()
+    new_password = str(payload.get("new_password", "")).strip()
+    if not token or not old_password or not new_password:
+        return jsonify({"error": "token, old_password y new_password son obligatorios"}), 400
+    if len(new_password) < 6:
+        return jsonify({"error": "La nueva contraseña debe tener al menos 6 caracteres"}), 400
+    usuario = _usuario_dao.obtener_por_token(token)
+    if not usuario or not _usuario_dao.actualizar_contraseña(usuario.id, new_password):
+        return jsonify({"error": "Contraseña actual incorrecta o sesión inválida"}), 401
+    return jsonify({"ok": True})
+
+@app.route("/auth/verify", methods=["POST"])
+def verify_token():
+    payload = request.json or {}
+    token = str(payload.get("token", "")).strip()
+    if not token:
+        return jsonify({"valid": False}), 400
+    usuario = _usuario_dao.obtener_por_token(token)
+    if not usuario:
+        return jsonify({"valid": False}), 401
+    return jsonify({"valid": True, "user_id": usuario.id, "username": usuario.username})
+
+@app.route("/auth/account", methods=["DELETE"])
+def delete_account():
+    payload = request.json or {}
+    token = str(payload.get("token", "")).strip()
+    if not token:
+        return jsonify({"error": "token es obligatorio"}), 400
+    usuario = _usuario_dao.obtener_por_token(token)
+    if not usuario:
+        return jsonify({"error": "Token inválido o cuenta no encontrada"}), 401
+    _historial_dao.borrar_por_usuario(usuario.id)
+    _emocion_dao.borrar_por_usuario(usuario.id)
+    _ciclo_dao.borrar_por_usuario(usuario.id)
+    _usuario_dao.eliminar(usuario.id)
+    return jsonify({"ok": True, "deleted_user": usuario.username})
+
+
+# ------------------------------------------------------------------
+# Análisis
+# ------------------------------------------------------------------
+
+@app.route("/analizar", methods=["POST"])
+def analizar():
+    payload = request.json or {}
+    texto = payload.get("texto", "")
+    user_id = str(payload.get("user_id", "")).strip()
+    estrategia = str(payload.get("estrategia") or "v1").strip().lower()
+    resultado = _analysis_service.analizar(texto, user_id, estrategia)
+    return jsonify(dataclasses.asdict(resultado))
+
+
+# ------------------------------------------------------------------
+# Seguimiento de recomendación
+# ------------------------------------------------------------------
+
+@app.route("/recomendacion/seguimiento", methods=["POST"])
+def seguimiento_recomendacion():
+    payload = request.json or {}
+    user_id = str(payload.get("user_id", "")).strip()
+    texto_posterior = str(payload.get("texto_post", "")).strip()
+    id_pelicula = str(payload.get("id_pelicula") or payload.get("movie_id") or "").strip()
+    titulo_pelicula = 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 texto_posterior:
+        return jsonify({"error": "user_id, ciclo_recomendacion_id y texto_post son obligatorios"}), 400
+
+    ciclo = _ciclo_dao.obtener_por_id(cycle_id, user_id)
+    if not ciclo:
+        return jsonify({"error": "ciclo de recomendacion no encontrado"}), 404
+
+    emocion_pre = _emocion_dao.obtener_por_id(ciclo.emocion_pre_id)
+
+    momento_analisis = datetime.now(timezone.utc).isoformat()
+    result_post, emocion_posterior, valencia_posterior = analizar_texto(_modelo, texto_posterior)
+
+    emocion_post_obj = _emocion_dao.añadir(
+        user_id=user_id,
+        texto=texto_posterior,
+        emocion=emocion_posterior,
+        valencia=valencia_posterior,
+        tiempo=momento_analisis,
+    )
+
+    if id_pelicula:
+        _anio, _genero = _meta_pelicula(id_pelicula)
+        _pelicula_dao.guardar_si_no_existe(id_pelicula, titulo_pelicula, anio=_anio, genero=_genero)
+    if emocion_post_obj:
+        _ciclo_dao.cerrar_ciclo(
+            ciclo_id=cycle_id,
+            user_id=user_id,
+            pelicula_id=id_pelicula,
+            emocion_post_id=emocion_post_obj.id,
+        )
+
+    pre_emotion = emocion_pre.emocion if emocion_pre else None
+    pre_valence = emocion_pre.valencia if emocion_pre else None
+
+    return jsonify({
+        "ciclo_recomendacion_id": cycle_id,
+        "id_pelicula": id_pelicula,
+        "title": titulo_pelicula,
+        "pre_emotion": pre_emotion,
+        "pre_valence": pre_valence,
+        "post_emotion": emocion_posterior,
+        "post_valence": valencia_posterior,
+        "cambio_emocional": pre_emotion != emocion_posterior,
+        "cambio_valencia": pre_valence != valencia_posterior,
+        "emociones_post": result_post,
+    })
+
+
+# ------------------------------------------------------------------
+# Historial de visionado
+# ------------------------------------------------------------------
+
+@app.route("/historial/visto", methods=["POST"])
+def guardar_visto():
+    payload = request.json or {}
+    user_id = str(payload.get("user_id", "")).strip()
+    id_pelicula = str(payload.get("id_pelicula") or payload.get("movie_id") or "").strip()
+
+    if not user_id or not id_pelicula:
+        return jsonify({"error": "user_id y id_pelicula son obligatorios"}), 400
+
+    momento_visionado = datetime.now(timezone.utc).isoformat()
+    titulo_pelicula = str(payload.get("title", "")).strip()
+    emocion_str = str(payload.get("emotion", "")).strip()
+    texto = str(payload.get("session_text", "")).strip()
+    rating_usuario_raw = payload.get("user_rating")
+    rating_usuario = None
+
+    if rating_usuario_raw is not None and str(rating_usuario_raw).strip() != "":
+        try:
+            rating_usuario = float(rating_usuario_raw)
+        except (TypeError, ValueError):
+            return jsonify({"error": "rating_usuario debe ser numerica entre 1 y 5"}), 400
+        if rating_usuario < 1 or rating_usuario > 5:
+            return jsonify({"error": "rating_usuario debe estar entre 1 y 5"}), 400
+
+    _anio, _genero = _meta_pelicula(id_pelicula)
+    _pelicula_dao.guardar_si_no_existe(id_pelicula, titulo_pelicula, anio=_anio, genero=_genero)
+
+    emocion_id = None
+    if emocion_str:
+        valencia = "positiva" if emocion_str in ("alegria", "sorpresa") else "negativa"
+        emocion_obj = _emocion_dao.añadir(
+            user_id=user_id,
+            texto=texto,
+            emocion=emocion_str,
+            valencia=valencia,
+            tiempo=momento_visionado,
+        )
+        emocion_id = emocion_obj.id if emocion_obj else None
+
+    entrada = _historial_dao.añadir_pelicula(
+        user_id=user_id,
+        pelicula_id=id_pelicula,
+        emocion_id=emocion_id,
+        valoracion=rating_usuario,
+        texto=texto,
+        tiempo=momento_visionado,
+    )
+
+    vo = PeliculaVistaVO(
+        id=entrada.id if entrada else 0,
+        user_id=user_id,
+        movie_id=id_pelicula,
+        titulo=titulo_pelicula,
+        emocion=emocion_str or None,
+        valoracion=rating_usuario,
+        texto_sesion=texto or None,
+        visto_en=momento_visionado,
+    )
+    return jsonify(dataclasses.asdict(vo)), 201
+
+@app.route("/historial", methods=["GET", "DELETE"])
+def obtener_historial():
+    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 = _historial_dao.borrar_por_usuario(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))
+
+    vistas = _historial_dao.obtener_vistas_por_usuario(user_id=user_id, limit=limit)
+    return jsonify({"items": [dataclasses.asdict(vo) for vo in vistas], "count": len(vistas)})
+
+
+# ------------------------------------------------------------------
+# Transiciones emocionales
+# ------------------------------------------------------------------
+
+@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))
+
+    emociones = _emocion_dao.obtener_por_usuario(user_id, limit=500)
+    entradas_h = _historial_dao.obtener_por_usuario(user_id, limit=1000)
+
+    peliculas_map: dict[str, str] = {}
+    for h in entradas_h:
+        if h.pelicula_id not in peliculas_map:
+            peli = _pelicula_dao.obtener_por_id(h.pelicula_id)
+            peliculas_map[h.pelicula_id] = peli.titulo if peli else ""
+
+    emociones_asc = sorted(emociones, key=lambda e: e.analizado_en)
+    historial_asc = sorted(entradas_h, key=lambda h: h.visto_en)
+
+    transition_counter: dict[tuple[str, str, str, str], int] = {}
+    for idx in range(1, len(emociones_asc)):
+        prev = emociones_asc[idx - 1]
+        curr = emociones_asc[idx]
+        if prev.emocion == curr.emocion:
+            continue
+        matched = None
+        for h in reversed(historial_asc):
+            if prev.analizado_en < h.visto_en <= curr.analizado_en:
+                matched = h
+                break
+        if not matched:
+            continue
+        key = (matched.pelicula_id, peliculas_map.get(matched.pelicula_id, ""), prev.emocion, curr.emocion)
+        transition_counter[key] = transition_counter.get(key, 0) + 1
+
+    items = [
+        {"movie_id": mid, "title": title, "from_emotion": fe, "to_emotion": te, "count": cnt}
+        for (mid, title, fe, te), cnt in transition_counter.items()
+    ]
+    items.sort(key=lambda x: x["count"], reverse=True)
+    return jsonify({"items": items[:limit], "count": len(items[:limit])})
+
+
+# ------------------------------------------------------------------
+# Poster OMDB
+# ------------------------------------------------------------------
+
+@app.route("/poster/<imdb_id>", methods=["GET"])
+def get_poster(imdb_id):
+    key = str(imdb_id).strip()
+    if not key or key == "0":
+        return jsonify({"poster_url": None})
+    if key in _poster_cache:
+        return jsonify({"poster_url": _poster_cache[key]})
+    if not OMDB_API_KEY:
+        _poster_cache[key] = None
+        return jsonify({"poster_url": None})
+    try:
+        resp = http_requests.get(
+            "https://www.omdbapi.com/",
+            params={"i": f"tt{key}", "apikey": OMDB_API_KEY},
+            timeout=5,
+        )
+        poster = resp.json().get("Poster") if resp.ok else None
+        url = poster if poster and poster != "N/A" else None
+    except Exception:
+        url = None
+    _poster_cache[key] = url
+    return jsonify({"poster_url": url})

backend/app_factory.py

@@ -1,293 +0,0 @@
-"""
-Crea y configura la app Flask.
-Las rutas son delegadores delgados: validan la entrada, llaman al servicio correspondiente y serializan la respuesta.
-"""
-
-import dataclasses
-from datetime import datetime, timezone
-
-import requests as http_requests
-from flask import Flask, jsonify, request
-from flask_cors import CORS
-
-from db import iniciar_historial_usuario
-from repositories.auth_repository import (
-    cambiar_contraseña,
-    cerrar_sesion,
-    eliminar_cuenta,
-    iniciar_sesion,
-    registrar_usuario,
-)
-from repositories.history_repository import (
-    añadir_evento_emocional,
-    borrar_historial_usuario,
-    guardar_estado_posterior,
-    obtener_ciclo_recomendacion,
-    obtener_peliculas_del_historial,
-    obtener_relacion_pelicula_emocion,
-    añadir_pelicula_a_historial,
-)
-from config import OMDB_API_KEY
-from services.analysis_service import AnalysisService
-from services.emotion_service import analizar_texto, crear_clasificador_emociones
-from services.recommender_service import cargar_dataset_movies
-
-
-_poster_cache: dict[str, str | None] = {}
-
-
-def create_app() -> Flask:
-    app = Flask(__name__)
-    CORS(app)
-
-    print("Cargando modelo...")
-    modelo = crear_clasificador_emociones()
-    movies_df, media_rating_global = cargar_dataset_movies()
-    iniciar_historial_usuario()
-    print(
-        f"Listo. Dataset de recomendaciones: {len(movies_df)} peliculas "
-        f"(rating global medio={media_rating_global:.3f})"
-    )
-
-    analysis_service = AnalysisService(modelo, movies_df, media_rating_global)
-
-    @app.route("/auth/register", methods=["POST"])
-    def register():
-        payload = request.json or {}
-        username = str(payload.get("username", "")).strip()
-        password = str(payload.get("password", "")).strip()
-        email = str(payload.get("email", "")).strip()
-        if not username or not password:
-            return jsonify({"error": "username y password son obligatorios"}), 400
-        if len(username) < 3:
-            return jsonify({"error": "El usuario debe tener al menos 3 caracteres"}), 400
-        if len(password) < 6:
-            return jsonify({"error": "La contraseña debe tener al menos 6 caracteres"}), 400
-        result = registrar_usuario(username, password, email)
-        if not result:
-            return jsonify({"error": "El nombre de usuario ya existe"}), 409
-        return jsonify(result), 201
-
-    @app.route("/auth/login", methods=["POST"])
-    def login():
-        payload = request.json or {}
-        username = str(payload.get("username", "")).strip()
-        password = str(payload.get("password", "")).strip()
-        if not username or not password:
-            return jsonify({"error": "username y password son obligatorios"}), 400
-        result = iniciar_sesion(username, password)
-        if not result:
-            return jsonify({"error": "Credenciales incorrectas"}), 401
-        return jsonify(result)
-
-    @app.route("/auth/logout", methods=["POST"])
-    def logout():
-        payload = request.json or {}
-        token = str(payload.get("token", "")).strip()
-        cerrar_sesion(token)
-        return jsonify({"ok": True})
-
-    @app.route("/auth/password", methods=["POST"])
-    def change_password():
-        payload      = request.json or {}
-        token        = str(payload.get("token",        "")).strip()
-        old_password = str(payload.get("old_password", "")).strip()
-        new_password = str(payload.get("new_password", "")).strip()
-        if not token or not old_password or not new_password:
-            return jsonify({"error": "token, old_password y new_password son obligatorios"}), 400
-        if len(new_password) < 6:
-            return jsonify({"error": "La nueva contraseña debe tener al menos 6 caracteres"}), 400
-        if not cambiar_contraseña(token, old_password, new_password):
-            return jsonify({"error": "Contraseña actual incorrecta o sesión inválida"}), 401
-        return jsonify({"ok": True})
-
-    @app.route("/auth/account", methods=["DELETE"])
-    def delete_account():
-        payload = request.json or {}
-        token = str(payload.get("token", "")).strip()
-        if not token:
-            return jsonify({"error": "token es obligatorio"}), 400
-        result = eliminar_cuenta(token)
-        if not result:
-            return jsonify({"error": "Token inválido o cuenta no encontrada"}), 401
-        return jsonify({"ok": True, "deleted_user": result["username"]})
-
-    @app.route("/analizar", methods=["POST"])
-    def analizar():
-        payload = request.json or {}
-        texto = payload.get("texto", "")
-        user_id = str(payload.get("user_id", "")).strip()
-        estrategia = str(payload.get("estrategia") or "v1").strip().lower()
-
-        resultado = analysis_service.analizar(texto, user_id, estrategia)
-        return jsonify(dataclasses.asdict(resultado))
-
-    @app.route("/recomendacion/seguimiento", methods=["POST"])
-    def seguimiento_recomendacion():
-        payload = request.json or {}
-        user_id = str(payload.get("user_id", "")).strip()
-        texto_posterior = str(payload.get("texto_post", "")).strip()
-        id_pelicula = str(payload.get("id_pelicula") or payload.get("movie_id") or "").strip()
-        titulo_pelicula = 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 texto_posterior:
-            return jsonify({"error": "user_id, ciclo_recomendacion_id y texto_post son obligatorios"}), 400
-
-        cycle = obtener_ciclo_recomendacion(cycle_id=cycle_id, user_id=user_id)
-        if not cycle:
-            return jsonify({"error": "ciclo de recomendacion no encontrado"}), 404
-
-        momento_analisis = datetime.now(timezone.utc).isoformat()
-        result_post, emocion_posterior, valencia_posterior = analizar_texto(modelo, texto_posterior)
-
-        añadir_evento_emocional(
-            user_id=user_id,
-            text=texto_posterior,
-            emotion=emocion_posterior,
-            analyzed_at=momento_analisis,
-        )
-        guardar_estado_posterior(
-            cycle_id=cycle_id,
-            user_id=user_id,
-            post_text=texto_posterior,
-            post_emotion=emocion_posterior,
-            post_valence=valencia_posterior,
-            post_analyzed_at=momento_analisis,
-            movie_id=id_pelicula,
-            movie_title=titulo_pelicula,
-        )
-
-        return jsonify(
-            {
-                "ciclo_recomendacion_id": cycle_id,
-                "id_pelicula": id_pelicula,
-                "title": titulo_pelicula,
-                "pre_emotion": cycle.get("pre_emotion"),
-                "pre_valence": cycle.get("pre_valence"),
-                "post_emotion": emocion_posterior,
-                "post_valence": valencia_posterior,
-                "cambio_emocional": cycle.get("pre_emotion") != emocion_posterior,
-                "cambio_valencia": cycle.get("pre_valence") != valencia_posterior,
-                "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()
-        id_pelicula = str(payload.get("id_pelicula") or payload.get("movie_id") or "").strip()
-
-        if not user_id or not id_pelicula:
-            return jsonify({"error": "user_id y id_pelicula son obligatorios"}), 400
-
-        momento_visionado = datetime.now(timezone.utc).isoformat()
-        titulo_pelicula = str(payload.get("title", "")).strip()
-        emocion = str(payload.get("emotion", "")).strip()
-        texto = str(payload.get("session_text", "")).strip()
-        rating_usuario_raw = payload.get("user_rating")
-        rating_usuario = None
-
-        if rating_usuario_raw is not None and str(rating_usuario_raw).strip() != "":
-            try:
-                rating_usuario = float(rating_usuario_raw)
-            except (TypeError, ValueError):
-                return jsonify({"error": "rating_usuario debe ser numerica entre 1 y 5"}), 400
-            if rating_usuario < 1 or rating_usuario > 5:
-                return jsonify({"error": "rating_usuario debe estar entre 1 y 5"}), 400
-
-        id_anadida = añadir_pelicula_a_historial(
-            user_id=user_id,
-            movie_id=id_pelicula,
-            title=titulo_pelicula,
-            emotion=emocion,
-            user_rating=rating_usuario,
-            session_text=texto,
-            viewed_at=momento_visionado,
-        )
-
-        return jsonify(
-            {
-                "id": id_anadida,
-                "user_id": user_id,
-                "movie_id": id_pelicula,
-                "title": titulo_pelicula,
-                "emotion": emocion,
-                "user_rating": rating_usuario,
-                "session_text": texto,
-                "viewed_at": momento_visionado,
-                "momento_visionado": momento_visionado,
-            }
-        ), 201
-
-    @app.route("/historial", methods=["GET", "DELETE"])
-    def obtener_historial():
-        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 = borrar_historial_usuario(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 = obtener_peliculas_del_historial(user_id=user_id, limit=limit)
-        return jsonify({"items": historial, "count": len(historial)})
-
-    @app.route("/poster/<imdb_id>", methods=["GET"])
-    def get_poster(imdb_id):
-        key = str(imdb_id).strip()
-        if not key or key == "0":
-            return jsonify({"poster_url": None})
-
-        if key in _poster_cache:
-            return jsonify({"poster_url": _poster_cache[key]})
-
-        if not OMDB_API_KEY:
-            _poster_cache[key] = None
-            return jsonify({"poster_url": None})
-
-        try:
-            resp = http_requests.get(
-                "https://www.omdbapi.com/",
-                params={"i": f"tt{key}", "apikey": OMDB_API_KEY},
-                timeout=5,
-            )
-            poster = resp.json().get("Poster") if resp.ok else None
-            url = poster if poster and poster != "N/A" else None
-        except Exception:
-            url = None
-
-        _poster_cache[key] = url
-        return jsonify({"poster_url": url})
-
-    @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))
-
-        items = obtener_relacion_pelicula_emocion(user_id=user_id, limit=limit)
-        return jsonify({"items": items, "count": len(items)})
-
-    return app

backend/base_datos.py

@@ -0,0 +1,148 @@
+"""
+Gestión de creación de tablas de la BD SQLite.
+
+Esquema normalizado en BCNF:
+  Usuarios              — datos de autenticación
+  Peliculas             — catálogo de películas vistas (sin duplicados por usuario)
+  Emociones             — registro de eventos emocionales detectados
+  Historial_Peliculas   — qué usuario vio qué película, cuándo y con qué emoción
+  Ciclo_Recomendacion   — ciclo pre/post recomendación vinculado a una película
+"""
+
+from conexion_bd import ConexionBD
+
+
+def iniciar_historial_usuario() -> None:
+    with ConexionBD.instancia().obtener_conexion() as conn:
+        conn.execute("PRAGMA foreign_keys = ON")
+
+        # ------------------------------------------------------------------ #
+        # Usuarios                                                             #
+        # PK: id (UUID)                                                        #
+        # FDs: id → todos los atributos                                        #
+        # ------------------------------------------------------------------ #
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS Usuarios (
+                id            TEXT PRIMARY KEY,
+                username      TEXT UNIQUE NOT NULL,
+                email         TEXT,
+                password_hash TEXT NOT NULL,
+                session_token TEXT,
+                created_at    TEXT NOT NULL
+            )
+            """
+        )
+
+        # ------------------------------------------------------------------ #
+        # Peliculas                                                            #
+        # PK: id (IMDb/OMDB id)                                               #
+        # FDs: id → titulo, anio, genero, poster_url                          #
+        # Entidad independiente — los datos de la película no dependen        #
+        # del usuario ni de la sesión.                                        #
+        # ------------------------------------------------------------------ #
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS Peliculas (
+                id         TEXT PRIMARY KEY,
+                titulo     TEXT NOT NULL,
+                anio       TEXT,
+                genero     TEXT,
+                poster_url TEXT
+            )
+            """
+        )
+
+        # ------------------------------------------------------------------ #
+        # Emociones                                                            #
+        # PK: id (AUTOINCREMENT)                                               #
+        # FDs: id → user_id, texto_analizado, emocion, valencia, analizado_en #
+        # user_id es FK → Usuarios.id                                         #
+        # ------------------------------------------------------------------ #
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS Emociones (
+                id              INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id         TEXT NOT NULL,
+                texto_analizado TEXT,
+                emocion         TEXT NOT NULL,
+                valencia        TEXT NOT NULL,
+                analizado_en    TEXT NOT NULL,
+                FOREIGN KEY (user_id) REFERENCES Usuarios(id) ON DELETE CASCADE
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_emociones_user_tiempo
+            ON Emociones (user_id, analizado_en DESC)
+            """
+        )
+
+        # ------------------------------------------------------------------ #
+        # Historial_Peliculas                                                  #
+        # PK: id (AUTOINCREMENT)                                               #
+        # FDs: id → user_id, pelicula_id, emocion_id, valoracion,             #
+        #           texto_sesion, visto_en                                     #
+        # FKs: user_id → Usuarios.id                                          #
+        #      pelicula_id → Peliculas.id                                      #
+        #      emocion_id → Emociones.id (emoción detectada al ver la peli)   #
+        # ------------------------------------------------------------------ #
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS Historial_Peliculas (
+                id           INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id      TEXT NOT NULL,
+                pelicula_id  TEXT NOT NULL,
+                emocion_id   INTEGER,
+                valoracion   REAL,
+                texto_sesion TEXT,
+                visto_en     TEXT NOT NULL,
+                FOREIGN KEY (user_id)     REFERENCES Usuarios(id)   ON DELETE CASCADE,
+                FOREIGN KEY (pelicula_id) REFERENCES Peliculas(id)  ON DELETE RESTRICT,
+                FOREIGN KEY (emocion_id)  REFERENCES Emociones(id)  ON DELETE SET NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_historial_user_tiempo
+            ON Historial_Peliculas (user_id, visto_en DESC)
+            """
+        )
+
+        # ------------------------------------------------------------------ #
+        # Ciclo_Recomendacion                                                  #
+        # PK: id (AUTOINCREMENT)                                               #
+        # FDs: id → user_id, emocion_pre_id, estrategia, creado_en,           #
+        #           pelicula_id, emocion_post_id                               #
+        # FKs: user_id → Usuarios.id                                          #
+        #      emocion_pre_id  → Emociones.id                                  #
+        #      emocion_post_id → Emociones.id                                  #
+        #      pelicula_id     → Peliculas.id                                  #
+        # ------------------------------------------------------------------ #
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS Ciclo_Recomendacion (
+                id              INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id         TEXT NOT NULL,
+                emocion_pre_id  INTEGER NOT NULL,
+                estrategia      INTEGER NOT NULL,
+                creado_en       TEXT NOT NULL,
+                pelicula_id     TEXT,
+                emocion_post_id INTEGER,
+                FOREIGN KEY (user_id)         REFERENCES Usuarios(id)   ON DELETE CASCADE,
+                FOREIGN KEY (emocion_pre_id)  REFERENCES Emociones(id)  ON DELETE RESTRICT,
+                FOREIGN KEY (emocion_post_id) REFERENCES Emociones(id)  ON DELETE SET NULL,
+                FOREIGN KEY (pelicula_id)     REFERENCES Peliculas(id)  ON DELETE SET NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_ciclo_user_tiempo
+            ON Ciclo_Recomendacion (user_id, creado_en DESC)
+            """
+        )
+
+        conn.commit()

backend/conexion_bd.py

@@ -0,0 +1,25 @@
+import sqlite3
+
+from config import HISTORY_DB_PATH
+
+
+class ConexionBD:
+    """Singleton clásico que centraliza el acceso a la conexión SQLite."""
+
+    _instancia: "ConexionBD | None" = None
+
+    def __new__(cls) -> "ConexionBD":
+        if cls._instancia is None:
+            cls._instancia = super().__new__(cls)
+            cls._instancia._db_path = HISTORY_DB_PATH
+        return cls._instancia
+
+    @classmethod
+    def instancia(cls) -> "ConexionBD":
+        return cls()
+
+    def obtener_conexion(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self._db_path)
+        conn.row_factory = sqlite3.Row
+        conn.execute("PRAGMA foreign_keys = ON")
+        return conn

backend/config.py

@@ -1,6 +1,6 @@
 """
 Este archivo contiene rutas, constantes y configuracion como modelos pre-cargados
-que se utilizan en varias partes del backend.
+que se utilizan en varias partes del 
 """
 
 import os
@@ -31,9 +31,14 @@ EMOTION_MAP = {
 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"
+# HuggingFace — token en https://huggingface.co/settings/tokens
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+# Modelo de emociones: cargado localmente via transformers (no usa Inference API)
+HF_EMOTION_MODEL = "pysentimiento/robertuito-emotion-analysis"
+# Modelo de texto: usa el nuevo router de HuggingFace Inference Providers
+HF_TEXT_MODEL = "meta-llama/Llama-3.2-3B-Instruct"
+HF_INFERENCE_URL = "https://router.huggingface.co/hf-inference/models"
+
 # 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).

backend/dao/ciclo_dao.py

@@ -0,0 +1,86 @@
+from conexion_bd import ConexionBD
+from modelos import CicloRecomendacion
+
+
+class CicloDAO:
+    def __init__(self):
+        self._bd = ConexionBD.instancia()
+
+    def obtener_conexion(self):
+        return self._bd.obtener_conexion()
+
+    def crear(self, user_id: str, emocion_pre_id: int, estrategia: int, tiempo_pre: str) -> CicloRecomendacion | None:
+        try:
+            with self.obtener_conexion() as con:
+                cur = con.execute(
+                    """INSERT INTO Ciclo_Recomendacion
+                           (user_id, emocion_pre_id, estrategia, creado_en)
+                       VALUES (?, ?, ?, ?)""",
+                    (user_id, emocion_pre_id, estrategia, tiempo_pre),
+                )
+                con.commit()
+            return CicloRecomendacion(
+                id=cur.lastrowid, user_id=user_id,
+                emocion_pre_id=emocion_pre_id, estrategia=estrategia,
+                creado_en=tiempo_pre, pelicula_id=None, emocion_post_id=None,
+            )
+        except Exception:
+            return None
+
+    def obtener_por_id(self, ciclo_id: int, user_id: str) -> CicloRecomendacion | None:
+        with self.obtener_conexion() as con:
+            row = con.execute(
+                """SELECT id, user_id, emocion_pre_id, estrategia, creado_en,
+                          pelicula_id, emocion_post_id
+                   FROM Ciclo_Recomendacion
+                   WHERE id = ? AND user_id = ?""",
+                (ciclo_id, user_id),
+            ).fetchone()
+        if not row:
+            return None
+        return self._row_a_ciclo(row)
+
+    def obtener_por_usuario(self, user_id: str, limit: int = 50) -> list[CicloRecomendacion]:
+        with self.obtener_conexion() as con:
+            rows = con.execute(
+                """SELECT id, user_id, emocion_pre_id, estrategia, creado_en,
+                          pelicula_id, emocion_post_id
+                   FROM Ciclo_Recomendacion
+                   WHERE user_id = ?
+                   ORDER BY creado_en DESC
+                   LIMIT ?""",
+                (user_id, limit),
+            ).fetchall()
+        return [self._row_a_ciclo(r) for r in rows]
+
+    def cerrar_ciclo(self, ciclo_id: int, user_id: str,
+                     pelicula_id: str, emocion_post_id: int) -> bool:
+        try:
+            with self.obtener_conexion() as con:
+                con.execute(
+                    """UPDATE Ciclo_Recomendacion
+                       SET pelicula_id = ?, emocion_post_id = ?
+                       WHERE id = ? AND user_id = ?""",
+                    (pelicula_id, emocion_post_id, ciclo_id, user_id),
+                )
+                con.commit()
+            return True
+        except Exception:
+            return False
+
+    def borrar_por_usuario(self, user_id: str) -> bool:
+        try:
+            with self.obtener_conexion() as con:
+                con.execute("DELETE FROM Ciclo_Recomendacion WHERE user_id = ?", (user_id,))
+                con.commit()
+            return True
+        except Exception:
+            return False
+
+    def _row_a_ciclo(self, row) -> CicloRecomendacion:
+        return CicloRecomendacion(
+            id=row["id"], user_id=row["user_id"],
+            emocion_pre_id=row["emocion_pre_id"], estrategia=row["estrategia"],
+            creado_en=row["creado_en"], pelicula_id=row["pelicula_id"],
+            emocion_post_id=row["emocion_post_id"],
+        )

backend/dao/emocion_dao.py

@@ -1,8 +1,80 @@
-from db import obtener_conexion_bd
+from conexion_bd import ConexionBD
+from modelos import Emocion
+
 
 class EmocionDAO:
     def __init__(self):
-        self.obtener_conexion = obtener_conexion_bd()
+        self._bd = ConexionBD.instancia()
+
+    def obtener_conexion(self):
+        return self._bd.obtener_conexion()
+
+    def añadir(self, user_id: str, texto: str, emocion: str, valencia: str, tiempo: str) -> Emocion | None:
+        try:
+            with self.obtener_conexion() as con:
+                cur = con.execute(
+                    """INSERT INTO Emociones (user_id, texto_analizado, emocion, valencia, analizado_en)
+                       VALUES (?, ?, ?, ?, ?)""",
+                    (user_id, texto, emocion, valencia, tiempo),
+                )
+                con.commit()
+            return Emocion(
+                id=cur.lastrowid, user_id=user_id,
+                texto_analizado=texto, emocion=emocion,
+                valencia=valencia, analizado_en=tiempo,
+            )
+        except Exception:
+            return None
+
+    def obtener_por_usuario(self, user_id: str, limit: int = 50) -> list[Emocion]:
+        with self.obtener_conexion() as con:
+            rows = con.execute(
+                """SELECT id, user_id, texto_analizado, emocion, valencia, analizado_en
+                   FROM Emociones
+                   WHERE user_id = ?
+                   ORDER BY analizado_en DESC
+                   LIMIT ?""",
+                (user_id, limit),
+            ).fetchall()
+        return [self._row_a_emocion(r) for r in rows]
+
+    def obtener_ultima(self, user_id: str) -> Emocion | None:
+        with self.obtener_conexion() as con:
+            row = con.execute(
+                """SELECT id, user_id, texto_analizado, emocion, valencia, analizado_en
+                   FROM Emociones
+                   WHERE user_id = ?
+                   ORDER BY analizado_en DESC
+                   LIMIT 1""",
+                (user_id,),
+            ).fetchone()
+        if not row:
+            return None
+        return self._row_a_emocion(row)
+
+    def obtener_por_id(self, emocion_id: int) -> Emocion | None:
+        with self.obtener_conexion() as con:
+            row = con.execute(
+                """SELECT id, user_id, texto_analizado, emocion, valencia, analizado_en
+                   FROM Emociones WHERE id = ?""",
+                (emocion_id,),
+            ).fetchone()
+        if not row:
+            return None
+        return self._row_a_emocion(row)
+
+    def borrar_por_usuario(self, user_id: str) -> bool:
+        try:
+            with self.obtener_conexion() as con:
+                con.execute("DELETE FROM Emociones WHERE user_id = ?", (user_id,))
+                con.commit()
+            return True
+        except Exception:
+            return False
 
-    def añadir(self, user_id: str, texto: str, emocion: str, tiempo: str):
-        con = self.
+    def _row_a_emocion(self, row) -> Emocion:
+        return Emocion(
+            id=row["id"], user_id=row["user_id"],
+            texto_analizado=row["texto_analizado"], emocion=row["emocion"],
+            valencia=row["valencia"], analizado_en=row["analizado_en"],
+        )

backend/dao/historial_dao.py

@@ -1,26 +1,107 @@
-from db import obtener_conexion_bd
-from models import PeliculaVista, Emocion
+from conexion_bd import ConexionBD
+from modelos import HistorialPelicula, PeliculaVistaVO
+
 
 class HistorialDAO:
     def __init__(self):
-        self.obtener_conexion = obtener_conexion_bd()
+        self._bd = ConexionBD.instancia()
 
-    def añadir_pelicula(self, user_id: str, titulo: str, emocion: str, rating: float, texto: str, tiempo: str):
-        con = self.obtener_conexion()
-        con.execute(
-            "INSERT INTO historial_peliculas () "
-        )
-        con.comit()
-        
-    def obtener_por_usuario(self, user_id: str):
-        con = self.obtener_conexion()
-        peliculas = con.execute(
-            "SELECT from historial_peliculas WHERE user_id = ?",
-            (user_id),
-        ).fetchall()
+    def obtener_conexion(self):
+        return self._bd.obtener_conexion()
+
+    def añadir_pelicula(self, user_id: str, pelicula_id: str, emocion_id: int | None,
+                        valoracion: float | None, texto: str | None, tiempo: str) -> HistorialPelicula | None:
+        try:
+            with self.obtener_conexion() as con:
+                cur = con.execute(
+                    """INSERT INTO Historial_Peliculas
+                           (user_id, pelicula_id, emocion_id, valoracion, texto_sesion, visto_en)
+                       VALUES (?, ?, ?, ?, ?, ?)""",
+                    (user_id, pelicula_id, emocion_id, valoracion, texto, tiempo),
+                )
+                con.commit()
+            return HistorialPelicula(
+                id=cur.lastrowid, user_id=user_id, pelicula_id=pelicula_id,
+                emocion_id=emocion_id, valoracion=valoracion,
+                texto_sesion=texto, visto_en=tiempo,
+            )
+        except Exception:
+            return None
+
+    def obtener_por_usuario(self, user_id: str, limit: int = 50) -> list[HistorialPelicula]:
+        with self.obtener_conexion() as con:
+            rows = con.execute(
+                """SELECT id, user_id, pelicula_id, emocion_id, valoracion, texto_sesion, visto_en
+                   FROM Historial_Peliculas
+                   WHERE user_id = ?
+                   ORDER BY visto_en DESC
+                   LIMIT ?""",
+                (user_id, limit),
+            ).fetchall()
+        return [self._row_a_historial(r) for r in rows]
+
+    def obtener_entre_fechas(self, user_id: str, inicio: str, fin: str) -> list[HistorialPelicula]:
+        with self.obtener_conexion() as con:
+            rows = con.execute(
+                """SELECT id, user_id, pelicula_id, emocion_id, valoracion, texto_sesion, visto_en
+                   FROM Historial_Peliculas
+                   WHERE user_id = ? AND visto_en >= ? AND visto_en <= ?
+                   ORDER BY visto_en DESC""",
+                (user_id, inicio, fin),
+            ).fetchall()
+        return [self._row_a_historial(r) for r in rows]
 
+    def actualizar_valoracion(self, historial_id: int, valoracion: float) -> bool:
+        try:
+            with self.obtener_conexion() as con:
+                con.execute(
+                    "UPDATE Historial_Peliculas SET valoracion = ? WHERE id = ?",
+                    (valoracion, historial_id),
+                )
+                con.commit()
+            return True
+        except Exception:
+            return False
+
+    def borrar_por_usuario(self, user_id: str) -> bool:
+        try:
+            with self.obtener_conexion() as con:
+                con.execute("DELETE FROM Historial_Peliculas WHERE user_id = ?", (user_id,))
+                con.commit()
+            return True
+        except Exception:
+            return False
+
+    def obtener_vistas_por_usuario(self, user_id: str, limit: int = 50) -> list[PeliculaVistaVO]:
+        with self.obtener_conexion() as con:
+            rows = con.execute(
+                """SELECT h.id, h.user_id, h.pelicula_id, h.valoracion, h.texto_sesion, h.visto_en,
+                          p.titulo, e.emocion
+                   FROM Historial_Peliculas h
+                   LEFT JOIN Peliculas p ON p.id = h.pelicula_id
+                   LEFT JOIN Emociones e ON e.id = h.emocion_id
+                   WHERE h.user_id = ?
+                   ORDER BY h.visto_en DESC
+                   LIMIT ?""",
+                (user_id, limit),
+            ).fetchall()
         return [
-            PeliculaVista(
-                id =  peli["id"], user_id = ["user_id"], movie_id = peli["movie_id"], titulo = peli["title"], emocion = peli["emotion"], valoracion = peli["user_rating"], texto = peli["session_text"], tiempo = peli["viewed_at"],
-            ) for peli in peliculas
+            PeliculaVistaVO(
+                id=row["id"],
+                user_id=row["user_id"],
+                movie_id=row["pelicula_id"],
+                titulo=row["titulo"] or "",
+                emocion=row["emocion"],
+                valoracion=row["valoracion"],
+                texto_sesion=row["texto_sesion"],
+                visto_en=row["visto_en"],
+            )
+            for row in rows
         ]
+
+    def _row_a_historial(self, row) -> HistorialPelicula:
+        return HistorialPelicula(
+            id=row["id"], user_id=row["user_id"], pelicula_id=row["pelicula_id"],
+            emocion_id=row["emocion_id"], valoracion=row["valoracion"],
+            texto_sesion=row["texto_sesion"], visto_en=row["visto_en"],
+        )

backend/dao/pelicula_dao.py

@@ -0,0 +1,73 @@
+from conexion_bd import ConexionBD
+from modelos import Pelicula
+
+
+class PeliculaDAO:
+    def __init__(self):
+        self._bd = ConexionBD.instancia()
+
+    def obtener_conexion(self):
+        return self._bd.obtener_conexion()
+
+    def guardar_si_no_existe(self, pelicula_id: str, titulo: str, anio: str | None = None,
+                             genero: str | None = None, poster_url: str | None = None) -> Pelicula:
+        with self.obtener_conexion() as con:
+            con.execute(
+                """INSERT INTO Peliculas (id, titulo, anio, genero, poster_url)
+                   VALUES (?, ?, ?, ?, ?)
+                   ON CONFLICT(id) DO UPDATE SET
+                       anio = COALESCE(Peliculas.anio, excluded.anio),
+                       genero = COALESCE(Peliculas.genero, excluded.genero),
+                       poster_url = COALESCE(Peliculas.poster_url, excluded.poster_url)""",
+                (pelicula_id, titulo, anio, genero, poster_url),
+            )
+            con.commit()
+            row = con.execute(
+                "SELECT id, titulo, anio, genero, poster_url FROM Peliculas WHERE id = ?",
+                (pelicula_id,),
+            ).fetchone()
+        return self._row_a_pelicula(row)
+
+    def obtener_por_id(self, pelicula_id: str) -> Pelicula | None:
+        with self.obtener_conexion() as con:
+            row = con.execute(
+                "SELECT id, titulo, anio, genero, poster_url FROM Peliculas WHERE id = ?",
+                (pelicula_id,),
+            ).fetchone()
+        if not row:
+            return None
+        return self._row_a_pelicula(row)
+
+    def buscar_por_titulo(self, texto: str, limit: int = 20) -> list[Pelicula]:
+        with self.obtener_conexion() as con:
+            rows = con.execute(
+                """SELECT id, titulo, anio, genero, poster_url FROM Peliculas
+                   WHERE titulo LIKE ?
+                   ORDER BY titulo
+                   LIMIT ?""",
+                (f"%{texto}%", limit),
+            ).fetchall()
+        return [self._row_a_pelicula(r) for r in rows]
+
+    def actualizar(self, pelicula_id: str, titulo: str | None = None, anio: str | None = None,
+                   genero: str | None = None, poster_url: str | None = None) -> bool:
+        campos = {k: v for k, v in
+                  {"titulo": titulo, "anio": anio, "genero": genero, "poster_url": poster_url}.items()
+                  if v is not None}
+        if not campos:
+            return False
+        sets = ", ".join(f"{col} = ?" for col in campos)
+        valores = list(campos.values()) + [pelicula_id]
+        try:
+            with self.obtener_conexion() as con:
+                con.execute(f"UPDATE Peliculas SET {sets} WHERE id = ?", valores)
+                con.commit()
+            return True
+        except Exception:
+            return False
+
+    def _row_a_pelicula(self, row) -> Pelicula:
+        return Pelicula(
+            id=row["id"], titulo=row["titulo"], anio=row["anio"],
+            genero=row["genero"], poster_url=row["poster_url"],
+        )

backend/dao/usuario_dao.py

@@ -1,94 +1,117 @@
-from db import obtener_conexion_bd
-from models import Usuario
 import uuid
-import datetime
+from datetime import datetime, timezone
+
+from werkzeug.security import check_password_hash, generate_password_hash
+
+from conexion_bd import ConexionBD
+from modelos import Usuario
+
 
 class UsuarioDao:
     def __init__(self):
-        self.obtener_conexion = obtener_conexion_bd()
+        self._bd = ConexionBD.instancia()
+
+    def obtener_conexion(self):
+        return self._bd.obtener_conexion()
 
-    # Crea usuario
-    def registrar(self, nombre: str, contraseña: str):
+    def registrar(self, nombre: str, contraseña: str) -> Usuario | None:
         user_id = str(uuid.uuid4())
         token = str(uuid.uuid4())
-
+        created_at = datetime.now(timezone.utc).isoformat()
         try:
-            con = self.obtener_conexion()
-            usuario = con.execute(
-                """INSERT INTO usuarios (id, username , password_hash, session_token, created_at)
-                   VALUES (?, ?, ?, ?, ?, ?)""",
-                (user_id, nombre, hashear(contraseña), token, datetime.now().isoformat()),
+            with self.obtener_conexion() as con:
+                con.execute(
+                    """INSERT INTO Usuarios (id, username, email, password_hash, session_token, created_at)
+                       VALUES (?, ?, ?, ?, ?, ?)""",
+                    (user_id, nombre, "", generate_password_hash(contraseña), token, created_at),
+                )
+                con.commit()
+            return Usuario(id=user_id, username=nombre, token=token)
+        except Exception:
+            return None
+
+    def login(self, nombre: str, contraseña: str) -> Usuario | None:
+        with self.obtener_conexion() as con:
+            row = con.execute(
+                "SELECT id, username, password_hash FROM Usuarios WHERE username = ?",
+                (nombre,),
+            ).fetchone()
+        if not row or not check_password_hash(row["password_hash"], contraseña):
+            return None
+        token = str(uuid.uuid4())
+        with self.obtener_conexion() as con:
+            con.execute(
+                "UPDATE Usuarios SET session_token = ? WHERE id = ?",
+                (token, row["id"]),
             )
             con.commit()
-            
-            return Usuario(user_id, nombre, token)
-        except Exception:
+        return Usuario(id=row["id"], username=row["username"], token=token)
+
+    def obtener_por_id(self, user_id: str) -> Usuario | None:
+        with self.obtener_conexion() as con:
+            row = con.execute(
+                "SELECT id, username, session_token FROM Usuarios WHERE id = ?",
+                (user_id,),
+            ).fetchone()
+        if not row:
             return None
-        
-    # Inicia sesion
-    def login(self, nombre: str, contraseña: str):
-        con = self.obtener_conexion()
-        usuario = con.execute(
-            "SELECT id, username, password_hash FROM usuarios WHERE username = ?",
-                (nombre),
+        return Usuario(id=row["id"], username=row["username"], token=row["session_token"] or "")
+
+    def obtener_por_nombre(self, nombre: str) -> Usuario | None:
+        with self.obtener_conexion() as con:
+            row = con.execute(
+                "SELECT id, username, session_token FROM Usuarios WHERE username = ?",
+                (nombre,),
             ).fetchone()
-        if not usuario or not comprobar_contraseña(usuario["password_hash", contraseña]):
+        if not row:
             return None
-        token = str(uuid.uiid4())
-        con = self.obtener_conexion()
-        con.execute("UPDATE Usuarios SET session_token = ? where id = ?",
-                    (token, usuario["id"]))
-        con.commit()
-        return Usuario(id = usuario["id"], nombre = usuario["username"], token = token)
-    
-    # Obtener por username
-    def obtener_por_nombre(self, nombre: str):
-        con = self.obtener_conexion()
-        usuario = con.execute(
-            "SELECT id, username FROM usuarios WHERE username = ?",
-            (nombre),
-        ).fetchone()
-        if not usuario: return None
+        return Usuario(id=row["id"], username=row["username"], token=row["session_token"] or "")
 
-        return Usuario(usuario["id"], usuario["name"], usuario["token"])
-    
-    # Obtener por token
-    def obtener_por_token(self, token:str):
-        con = self.obtener_conexion()
-        usuario = con.execute(
-            "SELECT id, username FROM usuarios WHERE token = ?",
-            (token),
-        ).fetchone()
-        if not usuario: return None
+    def obtener_por_token(self, token: str) -> Usuario | None:
+        with self.obtener_conexion() as con:
+            row = con.execute(
+                "SELECT id, username, session_token FROM Usuarios WHERE session_token = ?",
+                (token,),
+            ).fetchone()
+        if not row:
+            return None
+        return Usuario(id=row["id"], username=row["username"], token=row["session_token"])
 
-        return Usuario(usuario["id"], usuario["name"], usuario["token"])
-    
-    def actualizar_token(self, user_id: str, token: str):
-        con = self.obtener_conexion()
-        con.execute(
-            "UPDATE Usuarios set session_token = ? where user_id = ?",
-            (token, user_id),
-        )
-        con.comit()
-        return Usuario()
-    
-    def actualizar_contraseña(self, user_id: str, contraseña_hash: str):
-        con = self.obtener_conexion()
-        con.execute(
-            "UPDATE Usuarios set password = ? where user_id = ?",
-            (contraseña_hash, user_id)
-        )
-        con.comit()
-        return Usuario()
-    
-    def eliminar(self, user_id: str):
-        con = self.obtener_conexion()
-        con.execute(
-            "DELETE from Usuarios where user_id = ?",
-            (user_id),
-        )
-        con.commit()
-        return 
+    def actualizar_token(self, user_id: str, token: str) -> bool:
+        try:
+            with self.obtener_conexion() as con:
+                con.execute("UPDATE Usuarios SET session_token = ? WHERE id = ?", (token, user_id))
+                con.commit()
+            return True
+        except Exception:
+            return False
 
+    def cerrar_sesion(self, token: str) -> bool:
+        try:
+            with self.obtener_conexion() as con:
+                con.execute("UPDATE Usuarios SET session_token = NULL WHERE session_token = ?", (token,))
+                con.commit()
+            return True
+        except Exception:
+            return False
+
+    def actualizar_contraseña(self, user_id: str, contraseña_nueva: str) -> bool:
+        try:
+            with self.obtener_conexion() as con:
+                con.execute(
+                    "UPDATE Usuarios SET password_hash = ? WHERE id = ?",
+                    (generate_password_hash(contraseña_nueva), user_id),
+                )
+                con.commit()
+            return True
+        except Exception:
+            return False
 
-        
+    def eliminar(self, user_id: str) -> bool:
+        try:
+            with self.obtener_conexion() as con:
+                con.execute("DELETE FROM Usuarios WHERE id = ?", (user_id,))
+                con.commit()
+            return True
+        except Exception:
+            return False

backend/db.py

@@ -1,112 +0,0 @@
-"""
-Este archivo se encarga de gestionar la conexion con la BD
-así como de crear las tablas iniciales necesarias para almacenar 
-el historial de visionado
-"""
-
-import sqlite3
-
-from config import HISTORY_DB_PATH
-
-
-def obtener_conexion_bd() -> sqlite3.Connection:
-    """
-    Crea la conexión con la base de datos SQLite
-    """
-    # Cada conexion usa sqlite3.Row para acceder por nombre de columna.
-    conn = sqlite3.connect(HISTORY_DB_PATH) # Se conecta a la BD en la ruta configurada
-    conn.row_factory = sqlite3.Row # Permite acceder a las filas como diccionarios por nombre de columna
-    return conn
-
-
-def iniciar_historial_usuario() -> None:
-    """
-    Inicia la BD creando todas las tablas necesarias 
-    """
-    with obtener_conexion_bd() as conn:
-        # Historial de visionado con rating opcional por usuario.
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS historial_peliculas (
-                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(historial_peliculas)").fetchall()
-        column_names = {row[1] for row in columns}
-        if "user_rating" not in column_names:
-            conn.execute("ALTER TABLE historial_peliculas ADD COLUMN user_rating REAL")
-
-        # Indices para lecturas frecuentes por usuario + fecha.
-        conn.execute(
-            """
-            CREATE INDEX IF NOT EXISTS idx_historial_peliculas_user_viewed_at
-            ON historial_peliculas (user_id, viewed_at DESC)
-            """
-        )
-        # Crea una tabla para eventos de emocion detectada con texto analizado.
-        # Tiene para los distintos usuarios un registro del texto a analizar, la emocion detectada y cuando se hizo
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS eventos_emociones (
-                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_eventos_emociones_user_analyzed_at
-            ON eventos_emociones (user_id, analyzed_at DESC)
-            """
-        )
-        # Tabla para ciclos de recomendacion con datos pre y post recomendacion.
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS ciclos_recomendaciones (
-                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_ciclos_recomendaciones_user_created_at
-            ON ciclos_recomendaciones (user_id, created_at DESC)
-            """
-        )
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS usuarios (
-                id TEXT PRIMARY KEY,
-                username TEXT UNIQUE NOT NULL,
-                email TEXT,
-                password_hash TEXT NOT NULL,
-                session_token TEXT,
-                created_at TEXT NOT NULL
-            )
-            """
-        )
-        conn.commit()

backend/main.py

@@ -0,0 +1,9 @@
+"""
+Este archivo es el punto de entrada del servidor.
+Importa la app Flask singleton y la ejecuta en el puerto 5000.
+"""
+
+from aplicacion import app
+
+if __name__ == "__main__":
+    app.run(port=5000)

backend/modelos.py

@@ -0,0 +1,132 @@
+from dataclasses import dataclass, field
+
+
+# ---------------------------------------------------------------------------
+# Entidades de dominio (mapeadas 1:1 con tablas)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class Usuario:
+    id: str
+    username: str
+    token: str
+
+
+@dataclass
+class Pelicula:
+    id: str
+    titulo: str
+    anio: str | None
+    genero: str | None
+    poster_url: str | None
+
+
+@dataclass
+class Emocion:
+    id: int
+    user_id: str
+    texto_analizado: str | None
+    emocion: str
+    valencia: str
+    analizado_en: str
+
+
+@dataclass
+class HistorialPelicula:
+    id: int
+    user_id: str
+    pelicula_id: str
+    emocion_id: int | None
+    valoracion: float | None
+    texto_sesion: str | None
+    visto_en: str
+
+
+@dataclass
+class CicloRecomendacion:
+    id: int
+    user_id: str
+    emocion_pre_id: int
+    estrategia: int
+    creado_en: str
+    pelicula_id: str | None
+    emocion_post_id: int | None
+
+
+# ---------------------------------------------------------------------------
+# Value Objects (VOs) — datos de solo lectura que cruzan capas
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class EmocionVO:
+    """Vista plana de una Emocion para transferir entre capas."""
+    id: int
+    emocion: str
+    valencia: str
+    analizado_en: str
+    texto_analizado: str | None = None
+
+    @staticmethod
+    def desde(e: Emocion) -> "EmocionVO":
+        return EmocionVO(
+            id=e.id,
+            emocion=e.emocion,
+            valencia=e.valencia,
+            analizado_en=e.analizado_en,
+            texto_analizado=e.texto_analizado,
+        )
+
+
+@dataclass(frozen=True)
+class PeliculaVistaVO:
+    """Vista plana de Historial + Pelicula para serializar a JSON."""
+    id: int
+    user_id: str
+    movie_id: str
+    titulo: str
+    emocion: str | None
+    valoracion: float | None
+    texto_sesion: str | None
+    visto_en: str
+
+
+# ---------------------------------------------------------------------------
+# Modelos internos de servicios
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ContextoEmocional:
+    emocion_es: str
+    arousal_actual: float
+    valencia_actual: float
+    historico_arousal: list[float] = field(default_factory=list)
+
+
+@dataclass
+class PerfilUsuario:
+    peliculas_vistas: set[str] = field(default_factory=set)
+    probabilidades_generos: dict[str, float] = field(default_factory=dict)
+    contador_generos_gustados: dict = field(default_factory=dict)
+    medias_rating_por_genero: dict[str, float] = field(default_factory=dict)
+    zona_confort: set[str] = field(default_factory=set)
+    ranking_generos: dict[str, int] = field(default_factory=dict)
+    tiene_historial: bool = False
+
+
+@dataclass
+class ResultadoAnalisis:
+    emociones: list[dict]
+    emocion_dominante: str
+    valencia_dominante: str
+    valencia_continua: float
+    arousal_actual: float
+    estrategia: str
+    debug_recomendacion: dict
+    historico_arousal_size: int
+    emocion_anterior: str | None
+    modo_recomendacion: str
+    ciclo_recomendacion_id: int | None
+    chatbot_texto: str
+    chatbot_fuente: str
+    pelicula_transicion: dict | None
+    recomendaciones: list[dict]

backend/models.py

@@ -1,45 +0,0 @@
-from collections import Counter
-from dataclasses import dataclass, field
-from datetime import datetime
-
-
-@dataclass
-class Usuario:
-    id: str
-    name: str
-    token: str
-
-@dataclass
-class PeliculaVista:
-    id: int
-    user_id: str
-    movie_id: str
-    titulo: str
-    emocion: str
-    valoracion: float | None
-    texto: str
-    tiempo: str
-
-@dataclass
-class Emocion:
-    id: int
-    user_id: int
-    texto: str
-    emocion: str
-    tiempo: str
-
-@dataclass
-class Ciclo:
-    id: int
-    user_id: str
-    texto_pre: str
-    texto_post: str
-    emocion_pre_: str
-    emocion_post: str
-    valencia_pre: str
-    valencia_post: str
-    tiempo_pre: str
-    tiempo_post: str
-    estrategia: int
-    movie_id: str | None
-    movie_titulo: str | None

backend/repositories/__init__.py

@@ -1,2 +0,0 @@
-#Se utiliza para marcar el paquete de Python
-#Asi los imports relativos dentro del backend funcionan

backend/repositories/auth_repository.py

@@ -1,91 +0,0 @@
-import uuid
-from datetime import datetime, timezone
-
-from werkzeug.security import check_password_hash, generate_password_hash
-
-from db import obtener_conexion_bd
-
-
-def registrar_usuario(username: str, password: str, email: str = "") -> dict | None:
-    user_id = str(uuid.uuid4())
-    created_at = datetime.now(timezone.utc).isoformat()
-    password_hash = generate_password_hash(password)
-    token = str(uuid.uuid4())
-    try:
-        with obtener_conexion_bd() as conn:
-            conn.execute(
-                """INSERT INTO usuarios (id, username, email, password_hash, session_token, created_at)
-                   VALUES (?, ?, ?, ?, ?, ?)""",
-                (user_id, username, email, password_hash, token, created_at),
-            )
-            conn.commit()
-        return {"user_id": user_id, "username": username, "token": token}
-    except Exception:
-        return None
-
-
-def iniciar_sesion(username: str, password: str) -> dict | None:
-    with obtener_conexion_bd() as conn:
-        row = conn.execute(
-            "SELECT id, username, password_hash FROM usuarios WHERE username = ?",
-            (username,),
-        ).fetchone()
-    if not row or not check_password_hash(row["password_hash"], password):
-        return None
-    token = str(uuid.uuid4())
-    with obtener_conexion_bd() as conn:
-        conn.execute("UPDATE usuarios SET session_token = ? WHERE id = ?", (token, row["id"]))
-        conn.commit()
-    return {"user_id": row["id"], "username": row["username"], "token": token}
-
-
-def obtener_usuario_por_token(token: str) -> dict | None:
-    if not token:
-        return None
-    with obtener_conexion_bd() as conn:
-        row = conn.execute(
-            "SELECT id, username FROM usuarios WHERE session_token = ?",
-            (token,),
-        ).fetchone()
-    return dict(row) if row else None
-
-
-def cerrar_sesion(token: str) -> None:
-    if not token:
-        return
-    with obtener_conexion_bd() as conn:
-        conn.execute("UPDATE usuarios SET session_token = NULL WHERE session_token = ?", (token,))
-        conn.commit()
-
-
-def cambiar_contraseña(token: str, old_password: str, new_password: str) -> bool:
-    user = obtener_usuario_por_token(token)
-    if not user:
-        return False
-    with obtener_conexion_bd() as conn:
-        row = conn.execute(
-            "SELECT password_hash FROM usuarios WHERE id = ?", (user["id"],)
-        ).fetchone()
-    if not row or not check_password_hash(row["password_hash"], old_password):
-        return False
-    with obtener_conexion_bd() as conn:
-        conn.execute(
-            "UPDATE usuarios SET password_hash = ? WHERE id = ?",
-            (generate_password_hash(new_password), user["id"]),
-        )
-        conn.commit()
-    return True
-
-
-def eliminar_cuenta(token: str) -> dict | None:
-    user = obtener_usuario_por_token(token)
-    if not user:
-        return None
-    user_id = user["id"]
-    with obtener_conexion_bd() as conn:
-        conn.execute("DELETE FROM historial_peliculas WHERE user_id = ?", (user_id,))
-        conn.execute("DELETE FROM eventos_emociones WHERE user_id = ?", (user_id,))
-        conn.execute("DELETE FROM ciclos_recomendaciones WHERE user_id = ?", (user_id,))
-        conn.execute("DELETE FROM usuarios WHERE id = ?", (user_id,))
-        conn.commit()
-    return user

backend/repositories/history_repository.py

@@ -1,522 +0,0 @@
-"""
-Este archivo contiene funciones para realizar sobre la BD operaciones sobre el 
-historial de visionado del usuario y el seguimiento del ciclo de recomendacion
-siguiendo eventos emocionales del usuario antes y despues de la recomendacion.
-
-Solo hay funciones que acceden a la informacion de las tablas de la BD
-"""
-
-# Se importan la funcion que conecta con la BD de Sqlite para ejecutar las consultas
-from db import obtener_conexion_bd
-
-def borrar_historial_usuario(user_id: str) -> int:
-    """
-    Borra el historial de visionado de un usuario.
-
-    Args:
-        - user_id: El ID del usuario cuyo historial se desea borrar.
-    Returns:
-        - El número de registros eliminados del historial.
-    """
-    with obtener_conexion_bd() as conn:
-        # Se ejecuta DELETE para borrar historial de visionado del usuario.
-        cur = conn.execute(
-            """
-            DELETE FROM historial_peliculas
-            WHERE user_id = ?
-            """,
-            (user_id,),
-        )
-        conn.commit() # Se hace commit para confirmar cambios con insert, update o delete
-        return int(cur.rowcount or 0)
-
-
-def obtener_historial_usuario(user_id: str, limit: int = 200) -> list[dict]:
-    """
-    Obtiene las filas del historial de visionado de un usuario.
-
-    Args:
-        - user_id: El ID del usuario cuyo historial se desea obtener.
-        - limit: El número máximo de registros a obtener.
-
-    Returns:
-        - Una lista de diccionarios con los registros del historial.
-    """
-    with obtener_conexion_bd() as conn:
-        # Consulta base para perfilar recomendaciones con movie_id y user_rating.
-        filas = conn.execute(
-            """
-            SELECT movie_id, user_rating
-            FROM historial_peliculas
-            WHERE user_id = ?
-            ORDER BY viewed_at DESC
-            LIMIT ?
-            """,
-            (user_id, limit),
-        ).fetchall()
-    
-    # Devuelve un diccionario con (movie_id, user_rating) para cada fila del historial del usuario
-    return [dict(fila) for fila in filas]
-
-
-def añadir_evento_emocional(user_id: str, text: str, emotion: str, analyzed_at: str) -> int | None:
-    """
-    Añade cuando se le detecta una emocion al usuario
-
-    Args:
-        - user_id: El ID del usuario al que se le detecta la emocion.
-        - text: El texto analizado para detectar la emocion.
-        - emotion: La emocion detectada.
-        - analyzed_at: La fecha y hora en formato ISO cuando se analizo el texto.
-    Returns:
-        - El ID del evento emocional insertado o None si no se pudo insertar.
-    """
-
-    if not user_id:
-        return None
-
-    with obtener_conexion_bd() as conn:
-        # Registro temporal de cada analisis emocional del usuario.
-        cur = conn.execute(
-            """
-            INSERT INTO eventos_emociones (user_id, text, emotion, analyzed_at)
-            VALUES (?, ?, ?, ?)
-            """,
-            (user_id, text, emotion, analyzed_at),
-        )
-        conn.commit()
-        return cur.lastrowid
-
-
-def crear_ciclo_recomendacion(
-    user_id: str,
-    pre_text: str,
-    pre_emotion: str,
-    pre_valence: str,
-    recommendation_mode: str,
-    created_at: str,
-) -> int | None:
-    """
-    Crea un nuevo ciclo de recomendacion para seguimiento posterior.
-    Un ciclo de recomendacion contiene el estado emocional previo a la recomendacion, el modo de recomendacion aplicado,
-    y luego se actualiza con el estado posterior y pelicula elegida por el usuario.
-
-    Args:
-        - user_id: El ID del usuario para el que se crea el ciclo de recomendacion
-        - pre_text: El texto analizado para detectar la emocion previa a la recomendacion
-        - pre_emotion: La emocion detectada previa a la recomendacion
-        - pre_valence: La valencia detectada previa a la recomendacion
-        - recommendation_mode: El modo de recomendacion aplicado (exploracion o zona conocida)
-        - created_at: La fecha y hora en formato ISO cuando se creo el ciclo de recomendación
-    Returns:
-        - El ID del ciclo de recomendacion creado o None si no se pudo crear
-
-    """
-    if not user_id:
-        return None
-
-    with obtener_conexion_bd() as conn:
-        # Se guarda el estado previo a la recomendacion para seguimiento posterior.
-        cur = conn.execute(
-            """
-            INSERT INTO ciclos_recomendaciones (
-                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 obtener_ciclo_recomendacion(cycle_id: int, user_id: str) -> dict | None:
-    """
-    Funcion que devuelve un ciclo de recomendacion de la BD
-
-    Args:   
-        - cycle_id: El ID del ciclo de recomendacion a obtener
-        - user_id: El ID del usuario al que pertenece el ciclo de recomendacion
-    Returns:
-        - Un diccionario con los datos del ciclo de recomendacion o None si no se encuentra
-    """
-
-    with obtener_conexion_bd() as conn:
-        fila = 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 ciclos_recomendaciones
-            WHERE id = ? AND user_id = ?
-            LIMIT 1
-            """,
-            (cycle_id, user_id),
-        ).fetchone() # Se usa fetchone porque solo hay un ciclo correspondiente
-    return dict(fila) if fila else None
-
-def obtener_ciclos_usuario(user_id: str, limit: int = 500) -> list[dict]:
-    """
-    Funcion encargada de extraer todos los ciclos de recomendacion para poder aprender a inferir
-
-    Args:
-        - user_id: Identificador del usuario a obtener ciclos
-        - limit: num maximo de ciclos a obtener
-    Returns:
-        - Array con los ciclos de recomendacion del usuario
-    """
-    if not user_id:
-        return []
-    with obtener_conexion_bd() as conn:
-        filas = conn.execute(
-            """
-            SELECT id, user_id, pre_emotion, pre_valence, recommendation_mode, created_at,
-                   selected_movie_id,
-                   post_emotion, post_valence, post_analyzed_at
-            FROM ciclos_recomendaciones
-            WHERE user_id = ?
-              AND selected_movie_id IS NOT NULL
-              AND post_emotion IS NOT NULL
-            ORDER BY created_at DESC
-            LIMIT ?
-            """,
-            (user_id, limit),
-        ).fetchall()
-    return [dict(f) for f in filas]
-
-def obtener_rating_pelicula_recomendada(
-    user_id: str,
-    movie_id: str,
-    center_iso: str,
-    window_minutes: int = 240,
-) -> float | None:
-    """
-    Funcion que devuelve el rating del historial para esa película visto cerca del instante del ciclo.
-    Como el rating de la pelicula recomendada no se almacena en el ciclo de recomendacion se accede al hisrtoal
-
-    Args:
-        - user_id: Identificador del usuario que ha visto la pelicula
-        - movie_id: Identificador de la pelicula recomendada que ha visto
-        - center_iso: 
-        - window_minutes:
-    Returns:
-        -
-    """
-    if not user_id or not movie_id or not center_iso:
-        return None
-
-    with obtener_conexion_bd() as conn:
-        fila = conn.execute(
-            """
-            SELECT user_rating, viewed_at
-            FROM historial_peliculas
-            WHERE user_id = ?
-              AND movie_id = ?
-              AND viewed_at >= datetime(?, '-' || ? || ' minutes')
-              AND viewed_at <= datetime(?, '+' || ? || ' minutes')
-            ORDER BY ABS(strftime('%s', viewed_at) - strftime('%s', ?)) ASC
-            LIMIT 1
-            """,
-            (user_id, movie_id, center_iso, window_minutes, center_iso, window_minutes, center_iso),
-        ).fetchone()
-
-    if not fila:
-        return None
-    try:
-        return float(fila["user_rating"]) if fila["user_rating"] is not None else None
-    except (TypeError, ValueError, KeyError):
-        return None
-        
-def guardar_estado_posterior(
-    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:
-    """
-    Funcion que añade a un ciclo de recomendacion el estado posterior a la recomendacion
-    Se le preguntara al usuario que introduzca un rating de la pelicula vista
-    Asi como que exprese su emocion una vez vista la pelicula, para medir el cambio emocional y de valencia
-
-    Args:
-        - cycle_id: El ID del ciclo de recomendacion a actualizar
-        - user_id: El ID del usuario al que pertenece el ciclo de recomendacion
-        - post_text: El texto analizado para detectar la emocion posterior a la recomendacion
-        - post_emotion: La emocion detectada posterior a la recomendacion
-        - post_valence: La valencia detectada posterior a la recomendacion
-        - post_analyzed_at: La fecha y hora en formato ISO cuando se analizo el texto posterior a la recomendacion
-        - movie_id: El ID de la pelicula vista que se le pregunta al usuario
-        - movie_title: El titulo de la pelicula vista que se le pregunta al usuario
-    Returns:
-        - None (es un update de una instancia ya creada en la BD)
-    """
-    with obtener_conexion_bd() as conn:
-        # Actualiza el ciclo con pelicula elegida y estado emocional posterior.
-        conn.execute(
-            """
-            UPDATE ciclos_recomendaciones
-            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 obtener_ultima_emocion(user_id: str) -> dict | None:
-    """
-    Funcion que devuelve el ultimo evento emocional registrado para un usuario
-    Se utiliza para detectar la emocion previa a una recomendacion y medir transiciones emocionales
-
-    Args: 
-        - user_id: El ID del usuario del que se desea obtener el ultimo evento emocional
-    Returns:
-        - Un diccionario con los datos del ultimo evento emocional o None si no se encuentra. El diccionario contiene las claves: id, user_id, text, emotion, analyzed_at
-    """
-
-    if not user_id:
-        return None
-
-    with obtener_conexion_bd() as conn:
-        # Se realiza la consulta, se ordena descendentemente por fecha y nos quedamos con la ultima instancia
-        fila = conn.execute(
-            """
-            SELECT id, user_id, text, emotion, analyzed_at
-            FROM eventos_emociones
-            WHERE user_id = ?
-            ORDER BY analyzed_at DESC
-            LIMIT 1
-            """,
-            (user_id,),
-        ).fetchone()
-
-    return dict(fila) if fila else None
-
-
-def obtener_historial_emocional(user_id: str, limit: int = 200) -> list[dict]:
-    """
-    Devuelve eventos emocionales recientes de un usuario.
-
-    Args:
-        - user_id: ID de usuario.
-        - limit: Numero maximo de eventos a devolver.
-    Returns:
-        - Lista de eventos con claves emotion y analyzed_at, ordenados por fecha descendente.
-    """
-    if not user_id:
-        return []
-
-    with obtener_conexion_bd() as conn:
-        filas = conn.execute(
-            """
-            SELECT emotion, analyzed_at
-            FROM eventos_emociones
-            WHERE user_id = ?
-            ORDER BY analyzed_at DESC
-            LIMIT ?
-            """,
-            (user_id, limit),
-        ).fetchall()
-
-    return [dict(fila) for fila in filas]
-
-
-def obtener_pelicula_vista_entre(user_id: str, start_iso: str, end_iso: str) -> dict | None:
-    """
-    Funcion que obtiene la pelicula vista por el usuario entre dos momentos determinados
-    Se usa para detectar la pelicula vista entre dos eventos de recogida de estado emocional
-
-    Args:
-        - user_id: El ID del usuario del que se desea obtener la pelicula vista
-        - start_iso: El momento inicial en formato ISO entre el que se desea obtener la pelicula vista
-        - end_iso: El momento final en formato ISO entre el que se desea obtener la pelicula vista
-    Returns:
-        - Un diccionario con los datos de la pelicula vista entre ambos momentos o None si no se encuentra. El diccionario contiene las claves: movie_id, title, viewed_at
-    """
-    with obtener_conexion_bd() as conn:
-        fila = conn.execute(
-            """
-            SELECT movie_id, title, viewed_at
-            FROM historial_peliculas
-            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(fila) if fila else None
-    
-
-def añadir_pelicula_a_historial(
-    user_id: str,
-    movie_id: str,
-    title: str,
-    emotion: str,
-    user_rating: float | None,
-    session_text: str,
-    viewed_at: str,
-) -> int:
-    """
-    Funcion que añade al historial de visualizaciones una nueva pelicula, junto con su valoracion y emocion
-
-    Args:
-        - user_id: El ID del usuario al que se le añade la pelicula al historial
-        - movie_id: El ID de la pelicula vista
-        - title: El titulo de la pelicula vista
-        - emotion: La emocion asociada a la pelicula vista (puede ser la emocion detectada en el texto del usuario)
-        - user_rating: La valoracion que el usuario da a la pelicula vista (puede ser None si no se proporciona)
-        - session_text: El texto de la sesion que se asocia a la pelicula vista
-        - viewed_at: La fecha y hora en formato ISO cuando se visualizo la pelicula
-    Returns:
-        - El ID del registro insertado en el historial de visualizaciones
-    """
-    with obtener_conexion_bd() as conn:
-        cur = conn.execute(
-            """
-            INSERT INTO historial_peliculas (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 obtener_peliculas_del_historial(user_id: str, limit: int) -> list[dict]:
-    """
-    Funcion que devuelve las ultimas peliculas vistas por el usuario junto con su emocion asociada
-    Se utiliza para detectar transiciones emocionales entre peliculas vistas y medir su frecuencia
-
-    Args:
-        - user_id: El ID del usuario del que se desea obtener las peliculas vistas
-        - limit: El número máximo de registros a obtener
-
-    Returns:
-        - Una lista de diccionarios con los datos de las peliculas vistas por el usuario. Cada diccionario contiene las claves: movie_id, title, emotion, viewed_at; ordenado por fecha de visualizacion empezando por la mas reciente
-    """
-    with obtener_conexion_bd() as conn:
-        filas = conn.execute(
-            """
-            SELECT id, user_id, movie_id, title, emotion, user_rating, session_text, viewed_at
-            FROM historial_peliculas
-            WHERE user_id = ?
-            ORDER BY viewed_at DESC
-            LIMIT ?
-            """,
-            (user_id, limit),
-        ).fetchall()
-    return [dict(fila) for fila in filas]
-
-
-def obtener_relacion_pelicula_emocion(user_id: str, limit: int) -> list[dict]:
-    """
-    Funcion que calcula que peliculas han sido vistas por el usuario entre eventos emocionales con cambio de emocion
-    De esta manera se detecta que peliculas estan asociadas a que transiciones emocionales y con que frecuencia
-
-    Args: 
-    - user_id: El ID del usuario del que se desea obtener las transiciones emocionales asociadas a peliculas vistas
-    - limit: El número máximo de registros a obtener
-
-    Returns:
-        - Una lista de diccionarios con los datos de las transiciones emocionales asociadas a peliculas vistas por el usuario. Cada diccionario contiene las claves: movie_id, title, from_emotion, to_emotion, count; ordenado por frecuencia de la transicion empezando por la mas frecuente
-    """
-
-    with obtener_conexion_bd() as conn:
-        # Se obtiene el historial de eventos emocionales (texto y emocion asociada)
-        filas_emociones = conn.execute(
-            """
-            SELECT id, user_id, text, emotion, analyzed_at
-            FROM eventos_emociones
-            WHERE user_id = ?
-            ORDER BY analyzed_at ASC
-            LIMIT 500
-            """,
-            (user_id,),
-        ).fetchall()
-
-        # Se obtiene el historial de peliculas vistas (movie_id, title y momento del visionado)
-        filas_peliculas = conn.execute(
-            """
-            SELECT movie_id, title, viewed_at
-            FROM historial_peliculas
-            WHERE user_id = ?
-            ORDER BY viewed_at ASC
-            LIMIT 1000
-            """,
-            (user_id,),
-        ).fetchall()
-
-    emociones = [dict(fila) for fila in filas_emociones]
-    peliculas = [dict(fila) for fila in filas_peliculas]
-
-    # Se recorren los eventos emocionales buscando transiciones de emocion entre eventos consecutivos
-    # (movie_id, title, emocion_origen, emocion_destino) -> conteo.
-    transition_counter: dict[tuple[str, str, str, str], int] = {}
-
-    for idx in range(1, len(emociones)):
-        emocion_previa = emociones[idx - 1]
-        emocion_actual = emociones[idx]
-        
-        #Si son la misma emocion no se ha transicionado
-        if emocion_previa.get("emotion") == emocion_actual.get("emotion"):
-            continue
-        
-        #En caso de haber cambiado de estado emocional se obtiene el momento de ambos eventos para buscar la pelicula vista
-        #entre ambos momentos
-        momento_inicio = emocion_previa.get("analyzed_at", "")
-        momento_fin = emocion_actual.get("analyzed_at", "")
-        
-        # Se busca la pelicula vista en ese momento en especifico
-        matched_movie = None
-        for pelicula in reversed(peliculas):
-            viewed_at = pelicula.get("viewed_at", "")
-            if momento_inicio < viewed_at <= momento_fin:
-                matched_movie = pelicula
-                break
-
-        if not matched_movie:
-            continue
-        
-        # Si se encuentra una pelicula vista entre ambos eventos emocionales
-        # se cuenta la transicion emocional asociada a esa pelicula, para detectar 
-        # que peliculas estan mas asociadas a que transiciones emocionales
-        key = (
-            str(matched_movie.get("movie_id", "")),
-            matched_movie.get("title") or "",
-            emocion_previa.get("emotion", ""),
-            emocion_actual.get("emotion", ""),
-        )
-        transition_counter[key] = transition_counter.get(key, 0) + 1
-
-    items = []
-    # Se construye la lista de diccionarios con los datos de las peliculas asociadas a transiciones emocionales y su frecuencia
-    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/scripts/crear_bd.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""Crea la base de datos SQLite con todas las tablas e índices del esquema BCNF."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+BACKEND_DIR = Path(__file__).resolve().parent.parent
+ROOT_DIR = BACKEND_DIR.parent
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
+
+from base_datos import iniciar_historial_usuario
+from config import HISTORY_DB_PATH
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Crea la BD SQLite con el esquema completo.")
+    parser.add_argument(
+        "--db-path",
+        type=Path,
+        default=HISTORY_DB_PATH,
+        help=f"Ruta de la base de datos (por defecto: {HISTORY_DB_PATH})",
+    )
+    args = parser.parse_args()
+
+    db_path: Path = args.db_path.resolve()
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    iniciar_historial_usuario()
+
+    print(f"BD creada/verificada: {db_path}")
+    print("Tablas: Usuarios, Peliculas, Emociones, Historial_Peliculas, Ciclo_Recomendacion")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

backend/scripts/limpiar_bdm.py

@@ -1,30 +1,25 @@
 #!/usr/bin/env python3
-"""Limpia todos los datos de la base de datos SQLite del backend."""
+"""Limpia todos los datos de la base de datos SQLite del """
 
 from __future__ import annotations
 
 import argparse
 import sqlite3
-from pathlib import Path
 import sys
+from pathlib import Path
 
-CURRENT_DIR = Path(__file__).resolve().parent
-BACKEND_DIR = CURRENT_DIR.parent
-if str(BACKEND_DIR) not in sys.path:
-    sys.path.insert(0, str(BACKEND_DIR))
+BACKEND_DIR = Path(__file__).resolve().parent.parent
+ROOT_DIR = BACKEND_DIR.parent
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
 
+from base_datos import iniciar_historial_usuario
 from config import HISTORY_DB_PATH
-from db import iniciar_historial_usuario
 
 
-def _obtener_tablas_usuario(conn: sqlite3.Connection) -> list[str]:
+def _obtener_tablas(conn: sqlite3.Connection) -> list[str]:
     rows = conn.execute(
-        """
-        SELECT name
-        FROM sqlite_master
-        WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
-        ORDER BY name
-        """
+        "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
     ).fetchall()
     return [str(r[0]) for r in rows]
 
@@ -36,13 +31,14 @@ def limpiar_datos(db_path: Path) -> dict[str, int]:
     deleted_by_table: dict[str, int] = {}
     with sqlite3.connect(db_path) as conn:
         conn.execute("PRAGMA foreign_keys = OFF")
-        tables = _obtener_tablas_usuario(conn)
+        tables = _obtener_tablas(conn)
 
         for table_name in tables:
             cur = conn.execute(f"DELETE FROM {table_name}")
             deleted_by_table[table_name] = int(cur.rowcount or 0)
 
-        if "sqlite_sequence" in [r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()]:
+        all_tables = {r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()}
+        if "sqlite_sequence" in all_tables:
             conn.execute("DELETE FROM sqlite_sequence")
 
         conn.commit()
@@ -66,11 +62,11 @@ def main() -> int:
     total = sum(deleted_by_table.values())
     print(f"BD limpiada: {db_path}")
     for table_name, count in deleted_by_table.items():
-        print(f"- {table_name}: {count} filas eliminadas")
+        print(f"  {table_name}: {count} filas eliminadas")
     print(f"Total eliminado: {total} filas")
 
     iniciar_historial_usuario()
-    print("Esquema verificado (tablas e indices creados si no existian).")
+    print("Esquema verificado (tablas e índices recreados si faltaban).")
     return 0
 
 

backend/scripts/verificar_recomendador.py

@@ -1,205 +0,0 @@
-#!/usr/bin/env python3
-"""Comprueba de forma automatica que el recomendador se comporta correctamente."""
-
-from __future__ import annotations
-
-import argparse
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-import sqlite3
-import sys
-
-CURRENT_DIR = Path(__file__).resolve().parent
-BACKEND_DIR = CURRENT_DIR.parent
-if str(BACKEND_DIR) not in sys.path:
-    sys.path.insert(0, str(BACKEND_DIR))
-
-from config import HISTORY_DB_PATH
-from db import iniciar_historial_usuario
-from models import ContextoEmocional
-from services.recommender_service import cargar_dataset_movies, recomendar_peliculas
-
-
-TEST_USER = "__test_algo__"
-EMPTY_USER = "__test_algo_sin_historial__"
-
-
-def _genres_of(row: dict) -> set[str]:
-    genres = str(row.get("genres", "")).split("|")
-    return {g.strip() for g in genres if g.strip() and g.strip() != "(no genres listed)"}
-
-
-def _limpiar_usuario(conn: sqlite3.Connection, user_id: str) -> None:
-    conn.execute("DELETE FROM historial_peliculas WHERE user_id = ?", (user_id,))
-    conn.execute("DELETE FROM eventos_emociones WHERE user_id = ?", (user_id,))
-    conn.execute("DELETE FROM ciclos_recomendaciones WHERE user_id = ?", (user_id,))
-
-
-def _insertar_historial_sintetico(conn: sqlite3.Connection, movies: list[dict], g1: str, g2: str) -> set[str]:
-    favoritas = []
-    for row in movies:
-        row_genres = _genres_of(row)
-        if g1 in row_genres or g2 in row_genres:
-            favoritas.append(row)
-        if len(favoritas) >= 10:
-            break
-
-    if len(favoritas) < 6:
-        raise RuntimeError("No hay suficientes peliculas para crear historial sintetico")
-
-    now = datetime.now(timezone.utc)
-    watched_ids: set[str] = set()
-    for idx, row in enumerate(favoritas):
-        movie_id = str(row.get("movieId", "")).strip()
-        if not movie_id:
-            continue
-        watched_ids.add(movie_id)
-        viewed_at = (now - timedelta(days=idx + 1)).isoformat()
-        conn.execute(
-            """
-            INSERT INTO historial_peliculas (user_id, movie_id, title, emotion, user_rating, session_text, viewed_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-            """,
-            (
-                TEST_USER,
-                movie_id,
-                str(row.get("title", "")),
-                "tristeza",
-                4.5,
-                "historial sintetico",
-                viewed_at,
-            ),
-        )
-
-    return watched_ids
-
-
-def _seleccionar_generos(movies: list[dict], min_pool: int = 30) -> tuple[str, str]:
-    counts: dict[str, int] = {}
-    for row in movies:
-        for g in _genres_of(row):
-            counts[g] = counts.get(g, 0) + 1
-
-    ranked = sorted(counts.items(), key=lambda x: x[1], reverse=True)
-    filtered = [g for g, n in ranked if n >= min_pool]
-    if len(filtered) < 2:
-        raise RuntimeError("No hay suficientes generos con masa critica en el dataset")
-    return filtered[0], filtered[1]
-
-
-def _ratio_inside(recs: list[dict], zona_confort: set[str]) -> float:
-    if not recs:
-        return 0.0
-    inside = 0
-    for row in recs:
-        if _genres_of(row) & zona_confort:
-            inside += 1
-    return inside / len(recs)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Valida el algoritmo de recomendacion con datos de prueba.")
-    parser.add_argument("--limit", type=int, default=5, help="Numero de recomendaciones por escenario")
-    parser.add_argument(
-        "--db-path",
-        type=Path,
-        default=HISTORY_DB_PATH,
-        help=f"Ruta de base de datos (por defecto: {HISTORY_DB_PATH})",
-    )
-    args = parser.parse_args()
-
-    iniciar_historial_usuario()
-    movies_df, media_global = cargar_dataset_movies()
-    if not movies_df:
-        print("ERROR: no se pudo cargar movies.csv para validar el recomendador")
-        return 1
-
-    db_path = args.db_path.resolve()
-    with sqlite3.connect(db_path) as conn:
-        _limpiar_usuario(conn, TEST_USER)
-        _limpiar_usuario(conn, EMPTY_USER)
-
-        g1, g2 = _seleccionar_generos(movies_df)
-        zona_confort = {g1, g2}
-        watched_ids = _insertar_historial_sintetico(conn, movies_df, g1, g2)
-        conn.commit()
-
-    ctx_pos = ContextoEmocional(emocion_es="alegria", arousal_actual=0.5, valencia_actual=None)
-    ctx_neg = ContextoEmocional(emocion_es="tristeza", arousal_actual=0.5, valencia_actual=None)
-
-    recs_empty = recomendar_peliculas(
-        contexto=ctx_pos,
-        user_id=EMPTY_USER,
-        limit=args.limit,
-        movies_df=movies_df,
-        media_global_ratings=media_global,
-        estrategia_recomendacion="v1",
-    )
-    recs_pos = recomendar_peliculas(
-        contexto=ctx_pos,
-        user_id=TEST_USER,
-        limit=args.limit,
-        movies_df=movies_df,
-        media_global_ratings=media_global,
-        estrategia_recomendacion="v1",
-    )
-    recs_neg = recomendar_peliculas(
-        contexto=ctx_neg,
-        user_id=TEST_USER,
-        limit=args.limit,
-        movies_df=movies_df,
-        media_global_ratings=media_global,
-        estrategia_recomendacion="v1",
-    )
-
-    empty_ok = len(recs_empty) == args.limit
-    pos_ok_len = len(recs_pos) == args.limit
-    neg_ok_len = len(recs_neg) == args.limit
-
-    pos_inside_ratio = _ratio_inside(recs_pos, zona_confort)
-    neg_inside_ratio = _ratio_inside(recs_neg, zona_confort)
-
-    recs_pos_ids = {str(r.get("movieId", "")).strip() for r in recs_pos}
-    seen_leak = bool(recs_pos_ids & watched_ids)
-
-    print("=== Verificacion recomendador ===")
-    print(f"Dataset cargado: {len(movies_df)} peliculas")
-    print(f"Zona de confort sintetica: {sorted(zona_confort)}")
-    print(f"Escenario sin historial: {len(recs_empty)} recomendaciones")
-    print(f"Escenario positivo (alegria): {len(recs_pos)} recomendaciones")
-    print(f"Escenario negativo (tristeza): {len(recs_neg)} recomendaciones")
-    print(f"Ratio recomendaciones dentro de zona (positivo): {pos_inside_ratio:.2f}")
-    print(f"Ratio recomendaciones dentro de zona (negativo): {neg_inside_ratio:.2f}")
-    print(f"Fuga de peliculas ya vistas (positivo): {seen_leak}")
-
-    checks = {
-        "sin_historial_limite": empty_ok,
-        "positivo_limite": pos_ok_len,
-        "negativo_limite": neg_ok_len,
-        "positivo_fuera_zona_predomina": pos_inside_ratio <= 0.50,
-        "negativo_dentro_zona_predomina": neg_inside_ratio >= 0.50,
-        "sin_fuga_vistas_en_positivo": not seen_leak,
-    }
-
-    failed = [name for name, ok in checks.items() if not ok]
-    exit_code = 0
-    if failed:
-        print("RESULTADO: FAIL")
-        print("Checks fallidos:")
-        for name in failed:
-            print(f"- {name}")
-        exit_code = 1
-    else:
-        print("RESULTADO: OK")
-
-    # Evita dejar datos sintéticos de test en la base de datos real.
-    with sqlite3.connect(db_path) as conn:
-        _limpiar_usuario(conn, TEST_USER)
-        _limpiar_usuario(conn, EMPTY_USER)
-        conn.commit()
-
-    return exit_code
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

backend/server.py

@@ -1,11 +0,0 @@
-"""
-Este archivo es el punto de entrada del servidor
-Crea la aplicacion Flask y la ejecuta en el puerto 5000. 
-"""
-
-from app_factory import create_app
-
-app = create_app()
-
-if __name__ == "__main__":
-    app.run(port=5000)

backend/services/{emotion_service.py → analisis_sentimientos.py}

@@ -1,14 +1,9 @@
 """
-Este archivo contiene la logica del analisis de sentimientos de los textos introducidos por los usuarios
+Este archivo contiene la logica del analisis de sentimientos de los textos introducidos por los usuarios.
+Carga el modelo pysentimiento/robertuito-emotion-analysis localmente via transformers.
 """
 
-from transformers import pipeline
-
-"""
-Se tiene EMOTION:MAP para traducir emociones del español al ingles
-Se tiene NEGATIVE_EMOTIONS y POSITIVE_EMOTIONS para mapear emociones a valencia (positivo, negativo o neutro)
-"""
-from config import EMOTION_MAP, NEGATIVE_EMOTIONS, POSITIVE_EMOTIONS
+from config import EMOTION_MAP, NEGATIVE_EMOTIONS, POSITIVE_EMOTIONS, HF_EMOTION_MODEL
 
 
 AROUSAL_BY_MODEL_LABEL = {
@@ -58,36 +53,50 @@ def mapeo_emocion_valencia(emocion: str) -> str:
     return "neutro"
 
 
+_pipeline_emociones = None
+
+
 def crear_clasificador_emociones():
-    """
-    Funcion que crea y devuelve el modelo preentrenado de clasificacion de emociones de pysentimiento
-    """
-   
-    return pipeline(
-        "text-classification",
-        model="pysentimiento/robertuito-emotion-analysis",
-        top_k=None,
-        device=-1,
-    )
+    """Carga el pipeline de emociones de pysentimiento (se descarga la primera vez)."""
+    global _pipeline_emociones
+    if _pipeline_emociones is None:
+        try:
+            from transformers import pipeline
+            _pipeline_emociones = pipeline(
+                "text-classification",
+                model=HF_EMOTION_MODEL,
+                top_k=None,
+            )
+        except Exception as exc:
+            print(f"Aviso: no se pudo cargar el modelo de emociones ({exc}). Se usara neutral.")
+            _pipeline_emociones = None
+    return _pipeline_emociones
 
 
 def analizar_texto(modelo, texto: str) -> tuple[list[dict], str, str]:
     """
-    Funcion que analiza un texto dado con el modelo/clasificador de pysentimiento
+    Analiza un texto usando el pipeline local de transformers.
 
-    Args:
-        - modelo: El modelo de clasificacion de emociones ya cargado (pipeline de HuggingFace).
-        - texto: El texto que se desea analizar.    
     Returns:
-        - resultado: Lista de diccionarios con las emociones detectadas y sus scores, ordenada de mayor a menor score. Cada diccionario tiene la forma {"label": "alegria", "score": 0.85}.
-        - emocion_dominante: La emocion con mayor score, traducida al español (e.g. "alegria", "tristeza", etc.)
-        - valencia: La valencia de la emocion dominante, que puede ser "positivo", "negativo" o "neutro".
+        - resultado: lista de {"label": ..., "score": ...} ordenada de mayor a menor.
+        - emocion_dominante: emocion con mayor score en español.
+        - valencia: "positivo", "negativo" o "neutro".
     """
-    # Ordena por score para devolver la emocion dominante en la primera posicion.
-    resultado = sorted(modelo(texto)[0], key=lambda x: x["score"], reverse=True)
-    dominant_model = resultado[0]["label"] if resultado else "others" # Si no se detecta ninguna usa others como neutral.
-    dominant_es = EMOTION_MAP.get(dominant_model, "neutral") # Si no se encuentra en el mapeo, se asume neutral.
-    dominant_valence = mapeo_emocion_valencia(dominant_es) # Mapea la emocion dominante a su valencia. Si es positivo, negativo o neutro.
+    clf = modelo if modelo is not None else crear_clasificador_emociones()
+
+    try:
+        if clf is not None:
+            raw = clf(texto)[0]
+            resultado = sorted(raw, key=lambda x: x["score"], reverse=True)
+        else:
+            resultado = [{"label": "others", "score": 1.0}]
+    except Exception as exc:
+        print(f"Aviso: fallo analisis de emociones ({exc}). Se usa neutral.")
+        resultado = [{"label": "others", "score": 1.0}]
+
+    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
 
 def estimar_arousal_emocion_es(emocion_es: str) -> float:

backend/services/{recommender_service.py → calculos.py}

@@ -1,119 +1,15 @@
-"""
-Motor de recomendaciones de peliculas basado en el estado emocional del usuario y su historial de visualizacion.
-Combina calidad global (suavizado bayesiano), similitud de generos y preferencias personales.
-Adapta la estrategia segun el estado emocional usando el patron Strategy.
-"""
-
-import csv
 import random
-from abc import ABC, abstractmethod
 from collections import Counter
 
-from config import GLOBAL_PRIOR_COUNT, LIKE_THRESHOLD, POSITIVE_EMOTIONS, ROOT_DIR
-from models import ContextoEmocional, PerfilUsuario
-from repositories.history_repository import obtener_historial_usuario
-
-
-# ---------------------------------------------------------------------------
-# Carga de datos
-# ---------------------------------------------------------------------------
-
-def _cargar_estadisticas_ratings() -> tuple[dict[str, tuple[float, int]], float]:
-    ratings_path = ROOT_DIR / "data" / "ml-latest" / "ratings.csv"
-    if not ratings_path.exists():
-        return {}, 0.0
-
-    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):
-            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]] = {
-        mid: (s / c, int(c))
-        for mid, (s, c) in movie_sum_count.items()
-        if c
-    }
-    global_mean = (total_sum / total_count) if total_count else 0.0
-    return stats, global_mean
-
-
-def _cargar_links() -> dict[str, str]:
-    """Returns {movieId: imdbId} from links.csv (tries full dataset first, then small)."""
-    candidates = [
-        ROOT_DIR / "data" / "ml-latest" / "links.csv",
-        ROOT_DIR / "notebooks" / "data" / "raw" / "ml-latest-small" / "links.csv",
-    ]
-    for path in candidates:
-        if path.exists():
-            with open(path, "r", encoding="utf-8", newline="") as f:
-                return {
-                    str(row.get("movieId", "")).strip(): str(row.get("imdbId", "")).strip()
-                    for row in csv.DictReader(f)
-                    if str(row.get("imdbId", "")).strip()
-                }
-    return {}
-
-
-def cargar_dataset_movies() -> tuple[list[dict], float]:
-    rating_stats, global_mean = _cargar_estadisticas_ratings()
-    links = _cargar_links()
-    path = ROOT_DIR / "data" / "ml-latest" / "movies.csv"
-
-    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)
-            row["imdb_id"] = links.get(movie_id, "")
-
-        return rows, global_mean
-
-    fallback_path = ROOT_DIR / "data" / "procesado" / "peliculas_100_emociones.csv"
-    if fallback_path.exists():
-        with open(fallback_path, "r", encoding="utf-8", newline="") as f:
-            rows = list(csv.DictReader(f))
-        for row in rows:
-            movie_id = str(row.get("movieId", "")).strip()
-            row["imdb_id"] = links.get(movie_id, "")
-        total_w = sum(float(r.get("rating_mean", 0) or 0) * int(r.get("rating_count", 0) or 0) for r in rows)
-        total_n = sum(int(r.get("rating_count", 0) or 0) for r in rows)
-        fallback_mean = (total_w / total_n) if total_n else 3.5
-        return rows, fallback_mean
-
-    return [], global_mean
-
-
-# ---------------------------------------------------------------------------
-# Helpers de perfil y scoring
-# ---------------------------------------------------------------------------
-
-def _obtener_generos_pelicula(row: dict) -> set[str]:
+from config import GLOBAL_PRIOR_COUNT, LIKE_THRESHOLD, POSITIVE_EMOTIONS
+from modelos import PerfilUsuario
+
+
+def obtener_generos_pelicula(row: dict) -> set[str]:
     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],
-) -> PerfilUsuario:
+def construir_perfil_usuario(movies_df: list[dict], history_rows: list[dict]) -> PerfilUsuario:
     peliculas_vistas = {
         str(row.get("movie_id", "")).strip()
         for row in history_rows
@@ -157,7 +53,7 @@ def _construir_perfil_usuario(
         movie_id = str(movie.get("movieId", "")).strip()
         if movie_id not in peliculas_vistas:
             continue
-        genres = _obtener_generos_pelicula(movie)
+        genres = obtener_generos_pelicula(movie)
         contador_generos_vistos.update(genres)
         if movie_id in peliculas_gustadas:
             contador_generos_gustados.update(genres)
@@ -201,7 +97,7 @@ def _construir_perfil_usuario(
     )
 
 
-def _puntuacion_calidad_global(row: dict, media_global_ratings: float) -> float:
+def puntuacion_calidad_global(row: dict, media_global_ratings: float) -> float:
     cantidad = float(row.get("rating_count", 0) or 0)
     media = float(row.get("rating_mean", 0) or 0)
     if cantidad <= 0:
@@ -211,22 +107,22 @@ def _puntuacion_calidad_global(row: dict, media_global_ratings: float) -> float:
     return max(0.0, min(1.0, suavizado / 5.0))
 
 
-def _grado_confort_vector(peli: dict, zona_confort: set[str]) -> float:
-    generos = list(_obtener_generos_pelicula(peli))
+def grado_confort_vector(peli: dict, zona_confort: set[str]) -> float:
+    generos = list(obtener_generos_pelicula(peli))
     if not generos or not zona_confort:
         return 0.0
     return sum(1 for g in generos if g in zona_confort) / len(generos)
 
 
-def _calcular_pertenencia_zona_confort(peli: dict, zona_confort_ponderada: dict[str, float]) -> float:
-    generos = _obtener_generos_pelicula(peli)
+def calcular_pertenencia_zona_confort(peli: dict, zona_confort_ponderada: dict[str, float]) -> float:
+    generos = obtener_generos_pelicula(peli)
     if not generos or not zona_confort_ponderada:
         return 0.0
     pesos = [zona_confort_ponderada.get(g, 0.0) for g in generos]
     return sum(pesos) / len(pesos)
 
 
-def _percentil_desde_cero(arousal_actual: float, historico_arousal: list[float]) -> float:
+def percentil_desde_cero(arousal_actual: float, historico_arousal: list[float]) -> float:
     valores = [float(v) for v in historico_arousal if v is not None]
     valores.append(0.0)
     valores.sort()
@@ -240,7 +136,7 @@ def _percentil_desde_cero(arousal_actual: float, historico_arousal: list[float])
     return round(menores / len(valores), 4)
 
 
-def _normalizar_valencia_actual(valencia_actual: str | float | None, emotion_es: str) -> str:
+def normalizar_valencia_actual(valencia_actual: str | float | None, emotion_es: str) -> str:
     if isinstance(valencia_actual, (int, float)):
         if float(valencia_actual) > 0.5:
             return "positivo"
@@ -260,7 +156,7 @@ def _normalizar_valencia_actual(valencia_actual: str | float | None, emotion_es:
     return "negativo"
 
 
-def _valencia_a_factor(valencia_normalizada: str | float | None) -> float:
+def valencia_a_factor(valencia_normalizada: str | float | None) -> float:
     if isinstance(valencia_normalizada, (int, float)):
         return max(0.0, min(1.0, float(valencia_normalizada)))
     if valencia_normalizada == "positivo":
@@ -270,8 +166,8 @@ def _valencia_a_factor(valencia_normalizada: str | float | None) -> float:
     return 0.5
 
 
-def _recomendar_calidad_aleatoria(candidatas: list[dict], media_global: float, limit: int) -> list[dict]:
-    ranked = sorted(candidatas, key=lambda r: _puntuacion_calidad_global(r, media_global), reverse=True)
+def recomendar_calidad_aleatoria(candidatas: list[dict], media_global: float, limit: int) -> list[dict]:
+    ranked = sorted(candidatas, key=lambda r: puntuacion_calidad_global(r, media_global), reverse=True)
     pool = ranked[:max(limit * 4, limit)]
     if len(pool) <= limit:
         random.shuffle(pool)
@@ -279,152 +175,10 @@ def _recomendar_calidad_aleatoria(candidatas: list[dict], media_global: float, l
     return random.sample(pool, k=limit)
 
 
-def _sample_from_ranked(ranked: list[dict], limit: int) -> list[dict]:
-    """Sample randomly from the top pool to avoid always returning identical results."""
+def sample_from_ranked(ranked: list[dict], limit: int) -> list[dict]:
     pool_size = max(limit * 5, 30)
     pool = ranked[:pool_size]
     if len(pool) <= limit:
         random.shuffle(pool)
         return pool
     return random.sample(pool, k=limit)
-
-
-# ---------------------------------------------------------------------------
-# Strategy pattern
-# ---------------------------------------------------------------------------
-
-class EstrategiaRecomendacion(ABC):
-    @abstractmethod
-    def recomendar(
-        self,
-        peliculas_candidatas: list[dict],
-        perfil: PerfilUsuario,
-        media_global_ratings: float,
-        limit: int,
-        contexto: ContextoEmocional,
-        debug_context: dict | None,
-    ) -> list[dict]: ...
-
-
-class EstrategiaV1(EstrategiaRecomendacion):
-    """Clasificador binario: emocion positiva → fuera de zona de confort, negativa → dentro."""
-
-    def recomendar(self, peliculas_candidatas, perfil, media_global_ratings, limit, contexto, debug_context):
-        is_positive = contexto.emocion_es in POSITIVE_EMOTIONS
-
-        if is_positive:
-            outside = [r for r in peliculas_candidatas if not (_obtener_generos_pelicula(r) & perfil.zona_confort)]
-            base = outside if outside else peliculas_candidatas
-        else:
-            inside = [r for r in peliculas_candidatas if _obtener_generos_pelicula(r) & perfil.zona_confort]
-            base = inside if inside else peliculas_candidatas
-
-        ranked = sorted(base, key=lambda r: _puntuacion_calidad_global(r, media_global_ratings), reverse=True)
-        return _sample_from_ranked(ranked, limit)
-
-
-class EstrategiaV2(EstrategiaRecomendacion):
-    """Intensidad adaptativa: grado de confort continuo ponderado por calidad."""
-
-    def recomendar(self, peliculas_candidatas, perfil, media_global_ratings, limit, contexto, debug_context):
-        is_positive = contexto.emocion_es in POSITIVE_EMOTIONS
-
-        if is_positive:
-            outside = [r for r in peliculas_candidatas if not (_obtener_generos_pelicula(r) & perfil.zona_confort)]
-            base = outside if outside else peliculas_candidatas
-            ranked = sorted(
-                base,
-                key=lambda r: (1.0 - _grado_confort_vector(r, perfil.zona_confort))
-                              * _puntuacion_calidad_global(r, media_global_ratings),
-                reverse=True,
-            )
-        else:
-            inside = [r for r in peliculas_candidatas if _obtener_generos_pelicula(r) & perfil.zona_confort]
-            base = inside if inside else peliculas_candidatas
-            ranked = sorted(
-                base,
-                key=lambda r: _grado_confort_vector(r, perfil.zona_confort)
-                              * _puntuacion_calidad_global(r, media_global_ratings),
-                reverse=True,
-            )
-
-        return _sample_from_ranked(ranked, limit)
-
-
-class EstrategiaV3(EstrategiaRecomendacion):
-    """Target de confort continuo: Cd = 0.5 + A * (0.5 - V), donde A es arousal percentilado."""
-
-    def recomendar(self, peliculas_candidatas, perfil, media_global_ratings, limit, contexto, debug_context):
-        a = _percentil_desde_cero(contexto.arousal_actual, contexto.historico_arousal)
-
-        if isinstance(contexto.valencia_actual, (int, float)):
-            v = _valencia_a_factor(contexto.valencia_actual)
-        else:
-            v = _valencia_a_factor(_normalizar_valencia_actual(contexto.valencia_actual, contexto.emocion_es))
-
-        if 0.45 <= v <= 0.55:
-            target_confort = 0.5
-        else:
-            target_confort = max(0.0, min(1.0, 0.5 + a * (0.5 - v)))
-
-        if debug_context is not None:
-            valencia_label = (
-                _normalizar_valencia_actual(contexto.valencia_actual, contexto.emocion_es)
-                if not isinstance(contexto.valencia_actual, (int, float))
-                else ("positivo" if v > 0.5 else "negativo" if v < 0.5 else "neutro")
-            )
-            debug_context["arousal_percentil"] = round(a, 4)
-            debug_context["valencia_factor"] = round(v, 4)
-            debug_context["target_confort"] = round(target_confort, 4)
-            debug_context["valencia_normalizada"] = valencia_label
-
-        ranked = sorted(
-            peliculas_candidatas,
-            key=lambda peli: (
-                1 - abs(_calcular_pertenencia_zona_confort(peli, perfil.probabilidades_generos) - target_confort)
-            ) * _puntuacion_calidad_global(peli, media_global_ratings),
-            reverse=True,
-        )
-        return _sample_from_ranked(ranked, limit)
-
-
-_ESTRATEGIAS: dict[str, EstrategiaRecomendacion] = {
-    "v1": EstrategiaV1(),
-    "v2": EstrategiaV2(),
-    "v3": EstrategiaV3(),
-}
-
-
-# ---------------------------------------------------------------------------
-# Punto de entrada principal
-# ---------------------------------------------------------------------------
-
-def recomendar_peliculas(
-    contexto: ContextoEmocional,
-    user_id: str,
-    limit: int,
-    movies_df: list[dict],
-    media_global_ratings: float,
-    estrategia_recomendacion: str,
-    debug_context: dict | None = None,
-) -> list[dict]:
-    if not movies_df:
-        return []
-
-    history_rows = obtener_historial_usuario(user_id) if user_id else []
-    perfil = _construir_perfil_usuario(movies_df, history_rows)
-
-    peliculas_no_vistas = [r for r in movies_df if str(r.get("movieId", "")).strip() not in perfil.peliculas_vistas]
-    peliculas_candidatas = peliculas_no_vistas if peliculas_no_vistas else movies_df
-
-    if not peliculas_candidatas:
-        return []
-
-    if not perfil.tiene_historial:
-        return _recomendar_calidad_aleatoria(peliculas_candidatas, media_global_ratings, limit)
-
-    estrategia = _ESTRATEGIAS.get(estrategia_recomendacion)
-    if estrategia is None:
-        return _recomendar_calidad_aleatoria(peliculas_candidatas, media_global_ratings, limit)
-
-    return estrategia.recomendar(peliculas_candidatas, perfil, media_global_ratings, limit, contexto, debug_context)

backend/services/{chatbot_service.py → chatbot.py}

@@ -1,13 +1,12 @@
 """
 Este archivo se encarga de generar el texto que el chatbot mostrará al usuario
-basado en su estado emocional, recomendaciones y eventos anteriores. Se intenta usar
-Ollama para generar respuestas más naturales, pero se incluye una plantilla de respaldo
-en caso de que falle la generación.
+basado en su estado emocional, recomendaciones y eventos anteriores. Se usa la
+Inference API de HuggingFace como generador principal, con plantilla de respaldo.
 """
 
 import requests as http_requests
 
-from config import OLLAMA_URL, TEXT_MODEL_NAME
+from config import HF_TOKEN, HF_TEXT_MODEL, HF_INFERENCE_URL
 
 def construir_respuesta_manual(
     emocion_dominante: str, 
@@ -130,7 +129,6 @@ def generar_texto_chatbot(
     )
 
     try:
-        # Primero se intenta generar el texto con Ollama
         prompt = _construir_prompt(
             emocion_dominante=emocion_dominante,
             modo_recomendacion=modo_recomendacion,
@@ -139,28 +137,28 @@ def generar_texto_chatbot(
             pelicula_transicion=pelicula_transicion,
         )
 
-        # Se hace la llamada a Ollama con el prompt construido
+        # Nuevo router HuggingFace usa formato OpenAI-compatible
+        url = f"{HF_INFERENCE_URL}/{HF_TEXT_MODEL}/v1/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {HF_TOKEN}",
+            "Content-Type": "application/json",
+        }
         payload = {
-            "model": TEXT_MODEL_NAME,
-            "prompt": prompt,
-            "stream": False, # No necesitamos streaming para esta respuesta, queremos la respuesta completa de una vez.
-            "options": {
-                "temperature": 0.7, # Un poco de aleatoriedad para respuestas mas variadas, pero sin perder coherencia.
-                "top_p": 0.9, # Consideramos el top 90% de las opciones para generar respuestas mas naturales.
-                "num_predict": 120, # Limite de tokens para la respuesta, suficiente para 3 frases pero evitando respuestas demasiado largas.
-            },
+            "model": HF_TEXT_MODEL,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 120,
+            "temperature": 0.7,
+            "top_p": 0.9,
         }
-        # Se hace la solicitud POST a Ollama
-        #res = http_requests.post(OLLAMA_URL, json=payload, timeout=20) 
-        res = http_requests.post(OLLAMA_URL, json=payload) # Se elimina timeout para forzar Ollama
-        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.")
+        res = http_requests.post(url, headers=headers, json=payload, timeout=20)
+        res.raise_for_status()
+        data = res.json()
+        generated = str(data["choices"][0]["message"]["content"]).strip() if data.get("choices") else ""
+        if generated:
+            return generated, "huggingface"
+
+        print("Aviso: HuggingFace devolvio respuesta vacia. Se usa plantilla.")
     except Exception as exc:
-        print(f"Aviso: fallo generando texto con Ollama ({exc}). Se usa plantilla.")
+        print(f"Aviso: fallo generando texto con HuggingFace ({exc}). Se usa plantilla.")
 
     return respuesta_manual, "template-fallback"

backend/services/estrategias_recomendacion.py

@@ -0,0 +1,132 @@
+from abc import ABC, abstractmethod
+
+from config import POSITIVE_EMOTIONS
+from modelos import ContextoEmocional, PerfilUsuario
+from services.calculos import (
+    calcular_pertenencia_zona_confort,
+    grado_confort_vector,
+    normalizar_valencia_actual,
+    obtener_generos_pelicula,
+    percentil_desde_cero,
+    puntuacion_calidad_global,
+    sample_from_ranked,
+    valencia_a_factor,
+)
+
+
+class EstrategiaRecomendacion(ABC):
+    @abstractmethod
+    def recomendar(
+        self,
+        peliculas_candidatas: list[dict],
+        perfil: PerfilUsuario,
+        media_global_ratings: float,
+        limit: int,
+        contexto: ContextoEmocional,
+        debug_context: dict | None,
+    ) -> list[dict]: ...
+
+
+class EstrategiaV1(EstrategiaRecomendacion):
+    """Clasificador binario: emocion positiva → fuera de zona de confort, negativa → dentro."""
+
+    def recomendar(self, peliculas_candidatas, perfil, media_global_ratings, limit, contexto, debug_context):
+        is_positive = contexto.emocion_es in POSITIVE_EMOTIONS
+
+        if is_positive:
+            outside = [r for r in peliculas_candidatas if not (obtener_generos_pelicula(r) & perfil.zona_confort)]
+            base = outside if outside else peliculas_candidatas
+        else:
+            inside = [r for r in peliculas_candidatas if obtener_generos_pelicula(r) & perfil.zona_confort]
+            base = inside if inside else peliculas_candidatas
+
+        ranked = sorted(base, key=lambda r: puntuacion_calidad_global(r, media_global_ratings), reverse=True)
+        return sample_from_ranked(ranked, limit)
+
+
+class EstrategiaV2(EstrategiaRecomendacion):
+    """Intensidad adaptativa: grado de confort continuo ponderado por calidad."""
+
+    def recomendar(self, peliculas_candidatas, perfil, media_global_ratings, limit, contexto, debug_context):
+        is_positive = contexto.emocion_es in POSITIVE_EMOTIONS
+
+        if is_positive:
+            outside = [r for r in peliculas_candidatas if not (obtener_generos_pelicula(r) & perfil.zona_confort)]
+            base = outside if outside else peliculas_candidatas
+            ranked = sorted(
+                base,
+                key=lambda r: (1.0 - grado_confort_vector(r, perfil.zona_confort))
+                              * puntuacion_calidad_global(r, media_global_ratings),
+                reverse=True,
+            )
+        else:
+            inside = [r for r in peliculas_candidatas if obtener_generos_pelicula(r) & perfil.zona_confort]
+            base = inside if inside else peliculas_candidatas
+            ranked = sorted(
+                base,
+                key=lambda r: grado_confort_vector(r, perfil.zona_confort)
+                              * puntuacion_calidad_global(r, media_global_ratings),
+                reverse=True,
+            )
+
+        return sample_from_ranked(ranked, limit)
+
+
+class EstrategiaV3(EstrategiaRecomendacion):
+    """Target de confort continuo: Cd = 0.5 + A * (0.5 - V), donde A es arousal percentilado."""
+
+    def recomendar(self, peliculas_candidatas, perfil, media_global_ratings, limit, contexto, debug_context):
+        a = percentil_desde_cero(contexto.arousal_actual, contexto.historico_arousal)
+
+        if isinstance(contexto.valencia_actual, (int, float)):
+            v = valencia_a_factor(contexto.valencia_actual)
+        else:
+            v = valencia_a_factor(normalizar_valencia_actual(contexto.valencia_actual, contexto.emocion_es))
+
+        if 0.45 <= v <= 0.55:
+            target_confort = 0.5
+        else:
+            target_confort = max(0.0, min(1.0, 0.5 + a * (0.5 - v)))
+
+        if debug_context is not None:
+            valencia_label = (
+                normalizar_valencia_actual(contexto.valencia_actual, contexto.emocion_es)
+                if not isinstance(contexto.valencia_actual, (int, float))
+                else ("positivo" if v > 0.5 else "negativo" if v < 0.5 else "neutro")
+            )
+            debug_context["arousal_percentil"] = round(a, 4)
+            debug_context["valencia_factor"] = round(v, 4)
+            debug_context["target_confort"] = round(target_confort, 4)
+            debug_context["valencia_normalizada"] = valencia_label
+
+        ranked = sorted(
+            peliculas_candidatas,
+            key=lambda peli: (
+                1 - abs(calcular_pertenencia_zona_confort(peli, perfil.probabilidades_generos) - target_confort)
+            ) * puntuacion_calidad_global(peli, media_global_ratings),
+            reverse=True,
+        )
+        return sample_from_ranked(ranked, limit)
+
+
+class EstrategiaFactory:
+    _registro: dict[str, type[EstrategiaRecomendacion]] = {
+        "v1": EstrategiaV1,
+        "v2": EstrategiaV2,
+        "v3": EstrategiaV3,
+    }
+
+    @classmethod
+    def crear(cls, nombre: str) -> EstrategiaRecomendacion:
+        clase = cls._registro.get(nombre)
+        if clase is None:
+            raise ValueError(f"Estrategia desconocida: '{nombre}'. Disponibles: {list(cls._registro)}")
+        return clase()
+
+    @classmethod
+    def registrar(cls, nombre: str, clase: type[EstrategiaRecomendacion]) -> None:
+        cls._registro[nombre] = clase
+
+    @classmethod
+    def estrategias_disponibles(cls) -> list[str]:
+        return list(cls._registro)

backend/services/{analysis_service.py → pipeline.py}

@@ -6,22 +6,19 @@ Desacopla la logica de negocio de las rutas Flask.
 from datetime import datetime, timezone
 
 from config import POSITIVE_EMOTIONS
-from models import ContextoEmocional, ResultadoAnalisis
-from repositories.history_repository import (
-    añadir_evento_emocional,
-    crear_ciclo_recomendacion,
-    obtener_historial_emocional,
-    obtener_pelicula_vista_entre,
-    obtener_ultima_emocion,
-)
-from services.chatbot_service import generar_texto_chatbot
-from services.emotion_service import (
+from dao.ciclo_dao import CicloDAO
+from dao.emocion_dao import EmocionDAO
+from dao.historial_dao import HistorialDAO
+from dao.pelicula_dao import PeliculaDAO
+from modelos import ContextoEmocional, EmocionVO, ResultadoAnalisis
+from services.chatbot import generar_texto_chatbot
+from services.analisis_sentimientos import (
     analizar_texto,
     calcular_valencia_continua,
     calculo_arousal,
     estimar_arousal_emocion_es,
 )
-from services.recommender_service import recomendar_peliculas
+from services.recomendacion import recomendar_peliculas
 
 
 class AnalysisService:
@@ -29,20 +26,26 @@ class AnalysisService:
         self._modelo = modelo
         self._movies_df = movies_df
         self._media_global_ratings = media_global_ratings
+        self._emocion_dao = EmocionDAO()
+        self._ciclo_dao = CicloDAO()
+        self._historial_dao = HistorialDAO()
+        self._pelicula_dao = PeliculaDAO()
 
     def analizar(self, texto: str, user_id: str, estrategia: str) -> ResultadoAnalisis:
         momento_analisis = datetime.now(timezone.utc).isoformat()
-        emocion_previa = obtener_ultima_emocion(user_id)
+
+        # Emoción previa antes de registrar la actual
+        emocion_previa_obj = self._emocion_dao.obtener_ultima(user_id)
+        emocion_previa_vo = EmocionVO.desde(emocion_previa_obj) if emocion_previa_obj else None
 
         resultado, emocion_dominante, valencia_dominante = analizar_texto(self._modelo, texto)
         arousal_actual = calculo_arousal(resultado)
         valencia_continua = calcular_valencia_continua(resultado)
 
-        historial_eventos = obtener_historial_emocional(user_id=user_id, limit=200)
+        historial_eventos = self._emocion_dao.obtener_por_usuario(user_id=user_id, limit=200)
         historico_arousal = [
-            estimar_arousal_emocion_es(str(ev.get("emotion", "")).strip())
-            for ev in historial_eventos
-            if ev.get("emotion")
+            estimar_arousal_emocion_es(e.emocion)
+            for e in historial_eventos
         ]
 
         contexto = ContextoEmocional(
@@ -65,35 +68,54 @@ class AnalysisService:
 
         modo_recomendacion = "diferente" if emocion_dominante in POSITIVE_EMOTIONS else "similar"
 
-        cycle_id = crear_ciclo_recomendacion(
+        # Registrar emoción actual
+        emocion_actual = self._emocion_dao.añadir(
             user_id=user_id,
-            pre_text=texto,
-            pre_emotion=emocion_dominante,
-            pre_valence=valencia_dominante,
-            recommendation_mode=modo_recomendacion,
-            created_at=momento_analisis,
+            texto=texto,
+            emocion=emocion_dominante,
+            valencia=valencia_dominante,
+            tiempo=momento_analisis,
         )
 
-        añadir_evento_emocional(
-            user_id=user_id,
-            text=texto,
-            emotion=emocion_dominante,
-            analyzed_at=momento_analisis,
-        )
+        # Crear ciclo vinculado a la emoción recién registrada
+        cycle_id = None
+        if emocion_actual:
+            ciclo = self._ciclo_dao.crear(
+                user_id=user_id,
+                emocion_pre_id=emocion_actual.id,
+                estrategia=modo_recomendacion,
+                tiempo_pre=momento_analisis,
+            )
+            cycle_id = ciclo.id if ciclo else None
 
+        # Película vista entre la emoción previa y la actual
         pelicula_transicion = None
-        if emocion_previa:
-            pelicula_transicion = obtener_pelicula_vista_entre(
+        if emocion_previa_vo:
+            hp = self._historial_dao.obtener_entre_fechas(
                 user_id=user_id,
-                start_iso=emocion_previa.get("momento_analisis", ""),
-                end_iso=momento_analisis,
+                inicio=emocion_previa_vo.analizado_en,
+                fin=momento_analisis,
             )
+            if hp:
+                peli = self._pelicula_dao.obtener_por_id(hp[0].pelicula_id)
+                if peli:
+                    pelicula_transicion = {
+                        "movie_id": peli.id,
+                        "title": peli.titulo,
+                        "viewed_at": hp[0].visto_en,
+                    }
+
+        # VO plano para chatbot (espera dict con claves "emotion" y "analyzed_at")
+        emocion_previa_dict = (
+            {"emotion": emocion_previa_vo.emocion, "analyzed_at": emocion_previa_vo.analizado_en}
+            if emocion_previa_vo else None
+        )
 
         chatbot_texto, chatbot_fuente = generar_texto_chatbot(
             emocion_dominante=emocion_dominante,
             modo_recomendacion=modo_recomendacion,
             recomendaciones=recomendaciones,
-            emocion_previa=emocion_previa,
+            emocion_previa=emocion_previa_dict,
             pelicula_transicion=pelicula_transicion,
         )
 
@@ -106,7 +128,7 @@ class AnalysisService:
             estrategia=estrategia,
             debug_recomendacion=debug_reco,
             historico_arousal_size=len(historico_arousal),
-            emocion_anterior=emocion_previa.get("emotion") if emocion_previa else None,
+            emocion_anterior=emocion_previa_vo.emocion if emocion_previa_vo else None,
             modo_recomendacion=modo_recomendacion,
             ciclo_recomendacion_id=cycle_id,
             chatbot_texto=chatbot_texto,

backend/services/recomendacion.py

@@ -0,0 +1,144 @@
+"""
+Motor de recomendaciones de peliculas basado en el estado emocional del usuario y su historial de visualizacion.
+Combina calidad global (suavizado bayesiano), similitud de generos y preferencias personales.
+Adapta la estrategia segun el estado emocional usando el patron Strategy con EstrategiaFactory.
+"""
+
+import csv
+
+from config import ROOT_DIR
+from dao.historial_dao import HistorialDAO
+from modelos import ContextoEmocional
+from services.estrategias_recomendacion import EstrategiaFactory
+from services.calculos import construir_perfil_usuario, recomendar_calidad_aleatoria
+
+_historial_dao = HistorialDAO()
+
+
+def obtener_historial_usuario(user_id: str, limit: int = 200) -> list[dict]:
+    entradas = _historial_dao.obtener_por_usuario(user_id, limit=limit)
+    return [{"movie_id": h.pelicula_id, "user_rating": h.valoracion} for h in entradas]
+
+
+# ---------------------------------------------------------------------------
+# Carga de datos
+# ---------------------------------------------------------------------------
+
+def _cargar_estadisticas_ratings() -> tuple[dict[str, tuple[float, int]], float]:
+    ratings_path = ROOT_DIR / "data" / "ml-latest" / "ratings.csv"
+    if not ratings_path.exists():
+        return {}, 0.0
+
+    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):
+            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]] = {
+        mid: (s / c, int(c))
+        for mid, (s, c) in movie_sum_count.items()
+        if c
+    }
+    global_mean = (total_sum / total_count) if total_count else 0.0
+    return stats, global_mean
+
+
+def _cargar_links() -> dict[str, str]:
+    """Returns {movieId: imdbId} from links.csv (tries full dataset first, then small)."""
+    candidates = [
+        ROOT_DIR / "data" / "ml-latest" / "links.csv",
+        ROOT_DIR / "notebooks" / "data" / "raw" / "ml-latest-small" / "links.csv",
+    ]
+    for path in candidates:
+        if path.exists():
+            with open(path, "r", encoding="utf-8", newline="") as f:
+                return {
+                    str(row.get("movieId", "")).strip(): str(row.get("imdbId", "")).strip()
+                    for row in csv.DictReader(f)
+                    if str(row.get("imdbId", "")).strip()
+                }
+    return {}
+
+
+def cargar_dataset_movies() -> tuple[list[dict], float]:
+    rating_stats, global_mean = _cargar_estadisticas_ratings()
+    links = _cargar_links()
+    path = ROOT_DIR / "data" / "ml-latest" / "movies.csv"
+
+    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)
+            row["imdb_id"] = links.get(movie_id, "")
+
+        return rows, global_mean
+
+    fallback_path = ROOT_DIR / "data" / "procesado" / "peliculas_100_emociones.csv"
+    if fallback_path.exists():
+        with open(fallback_path, "r", encoding="utf-8", newline="") as f:
+            rows = list(csv.DictReader(f))
+        for row in rows:
+            movie_id = str(row.get("movieId", "")).strip()
+            row["imdb_id"] = links.get(movie_id, "")
+        total_w = sum(float(r.get("rating_mean", 0) or 0) * int(r.get("rating_count", 0) or 0) for r in rows)
+        total_n = sum(int(r.get("rating_count", 0) or 0) for r in rows)
+        fallback_mean = (total_w / total_n) if total_n else 3.5
+        return rows, fallback_mean
+
+    return [], global_mean
+
+
+# ---------------------------------------------------------------------------
+# Punto de entrada principal
+# ---------------------------------------------------------------------------
+
+def recomendar_peliculas(
+    contexto: ContextoEmocional,
+    user_id: str,
+    limit: int,
+    movies_df: list[dict],
+    media_global_ratings: float,
+    estrategia_recomendacion: str,
+    debug_context: dict | None = None,
+) -> list[dict]:
+    if not movies_df:
+        return []
+
+    history_rows = obtener_historial_usuario(user_id) if user_id else []
+    perfil = construir_perfil_usuario(movies_df, history_rows)
+
+    peliculas_no_vistas = [r for r in movies_df if str(r.get("movieId", "")).strip() not in perfil.peliculas_vistas]
+    peliculas_candidatas = peliculas_no_vistas if peliculas_no_vistas else movies_df
+
+    if not peliculas_candidatas:
+        return []
+
+    if not perfil.tiene_historial:
+        return recomendar_calidad_aleatoria(peliculas_candidatas, media_global_ratings, limit)
+
+    try:
+        estrategia = EstrategiaFactory.crear(estrategia_recomendacion)
+    except ValueError:
+        return recomendar_calidad_aleatoria(peliculas_candidatas, media_global_ratings, limit)
+
+    return estrategia.recomendar(peliculas_candidatas, perfil, media_global_ratings, limit, contexto, debug_context)

chatbot/src/views/ChatView.vue

@@ -248,9 +248,32 @@ function showSnack(text, color = "success") {
   snackbar.value = { show: true, text, color };
 }
 
-onMounted(() => {
-  userId.value   = localStorage.getItem("vs_user_id") || "";
-  username.value = localStorage.getItem("vs_username") || "";
+onMounted(async () => {
+  const storedUserId = localStorage.getItem("vs_user_id") || "";
+  const storedToken = localStorage.getItem("vs_token") || "";
+  const storedUsername = localStorage.getItem("vs_username") || "";
+
+  if (storedToken) {
+    try {
+      const res = await fetch("http://localhost:5000/auth/verify", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ token: storedToken }),
+      });
+      if (res.ok) {
+        userId.value = storedUserId;
+        username.value = storedUsername;
+      } else {
+        localStorage.removeItem("vs_user_id");
+        localStorage.removeItem("vs_username");
+        localStorage.removeItem("vs_token");
+      }
+    } catch {
+      localStorage.removeItem("vs_user_id");
+      localStorage.removeItem("vs_username");
+      localStorage.removeItem("vs_token");
+    }
+  }
 });
 
 watch(estrategia, v => localStorage.setItem("vs_estrategia", v));
@@ -295,7 +318,7 @@ async function analyze() {
       recommendations:      data.recomendaciones       || [],
     });
   } catch {
-    messages.value.push({ type: "error", text: "Error al conectar con el backend." });
+    messages.value.push({ type: "error", text: "Error al conectar con el " });
   } finally {
     loading.value = false;
   }

docs/diagrama_er.md

@@ -0,0 +1,84 @@
+# Diagrama Entidad-Relación — ValorSentimental
+
+Esquema normalizado en **BCNF (Boyce-Codd Normal Form)**.
+
+```mermaid
+erDiagram
+    Usuarios {
+        TEXT id PK
+        TEXT username UK "NOT NULL"
+        TEXT email
+        TEXT password_hash "NOT NULL"
+        TEXT session_token
+        TEXT created_at "NOT NULL"
+    }
+
+    Peliculas {
+        TEXT id PK "IMDb/OMDB id"
+        TEXT titulo "NOT NULL"
+        TEXT anio
+        TEXT genero
+        TEXT poster_url
+    }
+
+    Emociones {
+        INTEGER id PK
+        TEXT user_id FK
+        TEXT texto_analizado
+        TEXT emocion "NOT NULL"
+        TEXT valencia "NOT NULL"
+        TEXT analizado_en "NOT NULL"
+    }
+
+    Historial_Peliculas {
+        INTEGER id PK
+        TEXT user_id FK
+        TEXT pelicula_id FK
+        INTEGER emocion_id FK "nullable"
+        REAL valoracion
+        TEXT texto_sesion
+        TEXT visto_en "NOT NULL"
+    }
+
+    Ciclo_Recomendacion {
+        INTEGER id PK
+        TEXT user_id FK
+        INTEGER emocion_pre_id FK "NOT NULL"
+        INTEGER estrategia "NOT NULL"
+        TEXT creado_en "NOT NULL"
+        TEXT pelicula_id FK "nullable"
+        INTEGER emocion_post_id FK "nullable"
+    }
+
+    Usuarios ||--o{ Emociones            : "registra"
+    Usuarios ||--o{ Historial_Peliculas  : "visualiza"
+    Usuarios ||--o{ Ciclo_Recomendacion  : "inicia"
+    Peliculas ||--o{ Historial_Peliculas : "aparece en"
+    Peliculas ||--o{ Ciclo_Recomendacion : "recomendada en"
+    Emociones ||--o{ Historial_Peliculas : "emocion_id (al ver)"
+    Emociones ||--o{ Ciclo_Recomendacion : "emocion_pre_id"
+    Emociones ||--o{ Ciclo_Recomendacion : "emocion_post_id"
+```
+
+## Justificación BCNF
+
+| Tabla | Dependencias funcionales | Cumple BCNF |
+|---|---|---|
+| **Usuarios** | `id → username, email, password_hash, session_token, created_at` | ✅ Solo la PK determina atributos |
+| **Peliculas** | `id → titulo, anio, genero, poster_url` | ✅ Separada de historial para evitar anomalías de actualización si cambia el título |
+| **Emociones** | `id → user_id, texto_analizado, emocion, valencia, analizado_en` | ✅ Entidad propia; evita repetir `(emocion, valencia)` en otras tablas |
+| **Historial_Peliculas** | `id → user_id, pelicula_id, emocion_id, valoracion, texto_sesion, visto_en` | ✅ Ningún atributo no-clave determina a otro |
+| **Ciclo_Recomendacion** | `id → user_id, emocion_pre_id, estrategia, creado_en, pelicula_id, emocion_post_id` | ✅ FK a Emociones elimina dependencia transitiva de `(emocion, valencia)` |
+
+## Reglas de integridad referencial
+
+| FK | ON DELETE |
+|---|---|
+| `Emociones.user_id → Usuarios.id` | CASCADE |
+| `Historial_Peliculas.user_id → Usuarios.id` | CASCADE |
+| `Historial_Peliculas.pelicula_id → Peliculas.id` | RESTRICT |
+| `Historial_Peliculas.emocion_id → Emociones.id` | SET NULL |
+| `Ciclo_Recomendacion.user_id → Usuarios.id` | CASCADE |
+| `Ciclo_Recomendacion.emocion_pre_id → Emociones.id` | RESTRICT |
+| `Ciclo_Recomendacion.emocion_post_id → Emociones.id` | SET NULL |
+| `Ciclo_Recomendacion.pelicula_id → Peliculas.id` | SET NULL |

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "ValorSentimental",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

requirements.txt

@@ -4,11 +4,10 @@ flask-cors==4.0.0
 requests==2.31.0
 python-dotenv==1.0.0
 
-# Procesar lenguaje natural y modelos de lenguaje
-transformers==4.35.2 
-torch==2.0.1
-flair==0.12.2
-pysentimiento>=0.7.0
+# Modelo de emociones local (robertuito)
+transformers>=4.40.0
+torch>=2.1.0
+werkzeug>=2.3.0
 
 # Usadas en los Jupyter Notebooks
 deep-translator==1.11.4
@@ -23,3 +22,4 @@ pandas==2.1.4
 numpy==1.24.3
 matplotlib==3.8.3
 seaborn==0.13.1
+