Separacion codigo e documentacion

DIAGRAMAS_PATRONES.md

@@ -0,0 +1,339 @@
+# Diagramas de Patrones de Diseño - ValorSentimental
+
+## 1. Patrón Singleton: ConexionBD
+
+```mermaid
+classDiagram
+    class ConexionBD {
+        -instancia ConexionBD
+        -db_path str
+        +new(cls) ConexionBD
+        +instancia() ConexionBD
+        +obtener_conexion() Connection
+    }
+
+    note for ConexionBD "Singleton clásico que garantiza una única instancia de conexión a la base de datos SQLite"
+```
+
+### Explicación del Singleton:
+
+- **`_instancia`**: Variable de clase que almacena la única instancia (inicialmente `None`)
+- **`__new__()`**: Método que controla la creación de objetos:
+  - Si `_instancia` es `None`, crea la primera instancia
+  - Si ya existe, devuelve la instancia existente
+- **`instancia()`**: Método de conveniencia para obtener la instancia
+- **Beneficio**: Garantiza que toda la aplicación comparta una única conexión a la BD
+
+---
+
+## 2. Patrón Factory + DAO + DO/VO
+
+```mermaid
+classDiagram
+    class Usuario {
+        +id str
+        +username str
+        +token str
+    }
+
+    class Pelicula {
+        +id str
+        +titulo str
+        +genero str
+    }
+
+    class Emocion {
+        +id int
+        +user_id str
+        +texto_analizado str
+        +emocion str
+        +valencia str
+        +analizado_en str
+    }
+
+    class HistorialPelicula {
+        +id int
+        +user_id str
+        +pelicula_id str
+        +emocion_id int
+        +valoracion float
+        +texto_sesion str
+        +visto_en str
+    }
+
+    class CicloRecomendacion {
+        +id int
+        +user_id str
+        +emocion_pre_id int
+        +estrategia int
+        +creado_en str
+        +pelicula_id str
+        +emocion_post_id int
+    }
+
+    class EmocionVO {
+        +id int
+        +emocion str
+        +valencia str
+        +analizado_en str
+        +texto_analizado str
+        +desde(e) EmocionVO
+    }
+
+    class PeliculaVistaVO {
+        +id int
+        +user_id str
+        +movie_id str
+        +titulo str
+        +emocion str
+        +valoracion float
+        +texto_sesion str
+        +visto_en str
+    }
+
+    class UsuarioDao {
+        -bd ConexionBD
+        +obtener_conexion() Connection
+        +registrar(nombre, contrasena) Usuario
+        +login(nombre, contrasena) Usuario
+        +obtener_por_id(user_id) Usuario
+        +obtener_por_nombre(nombre) Usuario
+        +obtener_por_token(token) Usuario
+        +actualizar_token(user_id, token) bool
+        +cerrar_sesion(token) bool
+        +actualizar_contrasena(user_id, contrasena_nueva) bool
+        +eliminar(user_id) bool
+    }
+
+    class PeliculaDao {
+        -bd ConexionBD
+        +obtener_conexion() Connection
+    }
+
+    class EmocionDao {
+        -bd ConexionBD
+        +obtener_conexion() Connection
+    }
+
+    class HistorialDao {
+        -bd ConexionBD
+        +obtener_conexion() Connection
+    }
+
+    class CicloDao {
+        -bd ConexionBD
+        +obtener_conexion() Connection
+    }
+
+    class ConexionBD {
+        -instancia ConexionBD
+        -db_path str
+        +new(cls) ConexionBD
+        +instancia() ConexionBD
+        +obtener_conexion() Connection
+    }
+
+    EmocionVO "1" <-- "1" Emocion : convierte desde
+    PeliculaVistaVO "1" --> "1" HistorialPelicula : basado en
+    PeliculaVistaVO "1" --> "1" Pelicula : contiene datos de
+
+    UsuarioDao "1" --> "1" ConexionBD : usa Singleton
+    PeliculaDao "1" --> "1" ConexionBD : usa Singleton
+    EmocionDao "1" --> "1" ConexionBD : usa Singleton
+    HistorialDao "1" --> "1" ConexionBD : usa Singleton
+    CicloDao "1" --> "1" ConexionBD : usa Singleton
+
+    UsuarioDao "1" --> "*" Usuario : gestiona CRUD
+    PeliculaDao "1" --> "*" Pelicula : gestiona CRUD
+    EmocionDao "1" --> "*" Emocion : gestiona CRUD
+    HistorialDao "1" --> "*" HistorialPelicula : gestiona CRUD
+    CicloDao "1" --> "*" CicloRecomendacion : gestiona CRUD
+```
+
+---
+
+## 3. Diagrama de Capas (Arquitectura)
+
+```mermaid
+graph TB
+    subgraph Presentacion["CAPA PRESENTACION"]
+        API["REST API / Vue.js"]
+    end
+
+    subgraph Servicios["CAPA SERVICIOS"]
+        Recomendacion["RecomendacionService"]
+        Pipeline["PipelineService"]
+        Analisis["AnalisisSentimientosService"]
+        Calculos["CalculosService"]
+    end
+
+    subgraph AccesoDatos["CAPA ACCESO A DATOS (DAOs)"]
+        UsuarioDAO["UsuarioDao"]
+        PeliculaDAO["PeliculaDao"]
+        EmocionDAO["EmocionDao"]
+        HistorialDAO["HistorialDao"]
+        CicloDAO["CicloDao"]
+    end
+
+    subgraph Objetos["CAPA OBJETOS (DOs y VOs)"]
+        DO["Domain Objects<br/>Usuario, Pelicula, Emocion<br/>HistorialPelicula, CicloRecomendacion"]
+        VO["Value Objects<br/>EmocionVO, PeliculaVistaVO"]
+    end
+
+    subgraph BaseDatos["CAPA BASE DE DATOS"]
+        Singleton["ConexionBD<br/>Singleton"]
+        SQLite["SQLite<br/>history.db"]
+    end
+
+    API --> Recomendacion
+    API --> Pipeline
+    API --> Analisis
+
+    Recomendacion --> UsuarioDAO
+    Recomendacion --> PeliculaDAO
+    Recomendacion --> EmocionDAO
+    Recomendacion --> CicloDAO
+
+    Pipeline --> EmocionDAO
+    Pipeline --> HistorialDAO
+
+    Analisis --> EmocionDAO
+
+    UsuarioDAO --> DO
+    PeliculaDAO --> DO
+    EmocionDAO --> DO
+    HistorialDAO --> DO
+    CicloDAO --> DO
+
+    DO --> VO
+
+    UsuarioDAO --> Singleton
+    PeliculaDAO --> Singleton
+    EmocionDAO --> Singleton
+    HistorialDAO --> Singleton
+    CicloDAO --> Singleton
+
+    Singleton --> SQLite
+```
+
+---
+
+## 4. Patrón Factory (implícito en DAOs)
+
+```mermaid
+classDiagram
+    class DaoFactory {
+        -usuario_dao UsuarioDao
+        -pelicula_dao PeliculaDao
+        -emocion_dao EmocionDao
+        -historial_dao HistorialDao
+        -ciclo_dao CicloDao
+        +obtener_usuario_dao() UsuarioDao
+        +obtener_pelicula_dao() PeliculaDao
+        +obtener_emocion_dao() EmocionDao
+        +obtener_historial_dao() HistorialDao
+        +obtener_ciclo_dao() CicloDao
+    }
+
+    class UsuarioDao {
+        -bd ConexionBD
+        +obtener_conexion() Connection
+    }
+
+    class PeliculaDao {
+        -bd ConexionBD
+        +obtener_conexion() Connection
+    }
+
+    class EmocionDao {
+        -bd ConexionBD
+        +obtener_conexion() Connection
+    }
+
+    class HistorialDao {
+        -bd ConexionBD
+        +obtener_conexion() Connection
+    }
+
+    class CicloDao {
+        -bd ConexionBD
+        +obtener_conexion() Connection
+    }
+
+    DaoFactory --> UsuarioDao : crea/devuelve
+    DaoFactory --> PeliculaDao : crea/devuelve
+    DaoFactory --> EmocionDao : crea/devuelve
+    DaoFactory --> HistorialDao : crea/devuelve
+    DaoFactory --> CicloDao : crea/devuelve
+
+    note for DaoFactory "Factory Pattern: proporciona un punto único de acceso a todos los DAOs. Beneficios: centralización, testing y consistencia"
+```
+
+## 6. Responsabilidades por Capa
+
+| Capa | Responsabilidad | Ejemplo |
+|------|-----------------|---------|
+| **DO (Domain Objects)** | Entidades del negocio, sin lógica | `Usuario`, `Pelicula`, `Emocion` |
+| **VO (Value Objects)** | Objetos inmutables para transferencia | `EmocionVO`, `PeliculaVistaVO` |
+| **DAO (Data Access Object)** | Abstracción de acceso a datos | `UsuarioDao.login()`, `EmocionDao.crear()` |
+| **Singleton (ConexionBD)** | Garantiza conexión única a BD | Una única instancia compartida |
+| **Servicios** | Lógica de negocio | `RecomendacionService`, `AnalisisSentimientos` |
+
+---
+
+## 7. Ventajas de esta Arquitectura
+
+### Singleton (ConexionBD)
+✅ Una única conexión a la BD  
+✅ Gestión centralizada de recursos  
+✅ Thread-safe (si se implementa correctamente)  
+✅ Fácil de testear (se puede mockear)
+
+### DAO Pattern
+✅ Abstracción del acceso a datos  
+✅ Facilita cambiar de BD sin afectar servicios  
+✅ Centraliza lógica SQL  
+✅ Reutilizable  
+
+### DO/VO Pattern
+✅ Separación clara de responsabilidades  
+✅ VOs inmutables = seguridad en concurrencia  
+✅ DOs para persistencia, VOs para transferencia  
+✅ Facilita serialización a JSON
+
+---
+
+## 8. Recomendaciones de Mejora
+
+### Implementar DaoFactory
+```python
+class DaoFactory:
+    _daos = {}
+    
+    @staticmethod
+    def obtener_usuario_dao() -> UsuarioDao:
+        if 'usuario' not in DaoFactory._daos:
+            DaoFactory._daos['usuario'] = UsuarioDao()
+        return DaoFactory._daos['usuario']
+```
+
+### Agregar Interfaz Base para DAOs
+```python
+from abc import ABC, abstractmethod
+
+class BaseDao(ABC):
+    def __init__(self):
+        self._bd = ConexionBD.instancia()
+    
+    @abstractmethod
+    def obtener_por_id(self, id): pass
+    
+    @abstractmethod
+    def crear(self, obj): pass
+    
+    @abstractmethod
+    def actualizar(self, obj): pass
+    
+    @abstractmethod
+    def eliminar(self, id): pass
+```

README.md

@@ -0,0 +1,261 @@
+# Valor Sentimental
+
+Valor Sentimental es una aplicacion web de recomendacion de peliculas basada en el estado emocional del usuario. El sistema analiza un texto escrito por la persona, identifica su emocion dominante y recomienda peliculas teniendo en cuenta su historial, sus valoraciones y distintas estrategias de exploracion o zona de confort.
+
+El proyecto combina un backend en Flask, una interfaz en Vue 3 con Vuetify, una base de datos SQLite local y datos de MovieLens para construir el catalogo de peliculas.
+
+## Caracteristicas principales
+
+- Analisis emocional de texto en espanol mediante `pysentimiento/robertuito-emotion-analysis`.
+- Recomendacion de peliculas segun emocion, historial y calidad global.
+- Tres estrategias de recomendacion (`v1`, `v2`, `v3`) implementadas con patron Strategy.
+- Registro, login, logout, cambio de contrasena y eliminacion de cuenta.
+- Historial de peliculas vistas con valoracion de 1 a 5.
+- Seguimiento emocional antes y despues de ver una recomendacion.
+- Onboarding inicial para indicar peliculas ya vistas.
+- Busqueda de peliculas y listado de populares usando MovieLens.
+- Obtencion opcional de posters mediante OMDb.
+- Persistencia local en SQLite.
+
+## Tecnologias
+
+### Backend
+
+- Python
+- Flask
+- Flask-CORS
+- SQLite
+- Transformers
+- PyTorch
+- Hugging Face Inference Providers
+- OMDb API opcional
+
+### Frontend
+
+- Vue 3
+- Vue Router
+- Vuetify
+- Vite
+- Sass
+- Material Design Icons
+
+### Datos
+
+- MovieLens `ml-latest`
+
+## Estructura del proyecto
+
+```text
+ValorSentimental/
+|-- backend/
+|   |-- aplicacion.py              # Rutas Flask y configuracion principal de la API
+|   |-- main.py                    # Punto de entrada del servidor
+|   |-- base_datos.py              # Creacion de tablas SQLite
+|   |-- conexion_bd.py             # Singleton de conexion a BD
+|   |-- config.py                  # Constantes, rutas y variables de entorno
+|   |-- dao/                       # Acceso a datos
+|   `-- services/                  # Logica de analisis, recomendacion y chatbot
+|-- chatbot/
+|   |-- src/                       # Aplicacion Vue
+|   |-- package.json
+|   `-- vite.config.js
+|-- data/
+|   |-- ml-latest/                 # CSV de MovieLens
+|   |-- procesado/                 # Datasets procesados
+|   |-- download_movielens_large.py
+|   `-- script.py                  # Generacion del dataset emocional
+|-- docs/                          # Diagramas y documentacion auxiliar
+|-- DIAGRAMAS_PATRONES.md          # Patrones y arquitectura
+|-- requirements.txt
+`-- README.md
+```
+
+## Requisitos previos
+
+- Python 3.10 o superior recomendado.
+- Node.js 18 o superior recomendado.
+- npm.
+- Conexion a internet en el primer arranque si el modelo de Hugging Face no esta descargado localmente.
+
+## Variables de entorno
+
+El backend carga variables desde `backend/.env`.
+
+Crea un archivo `backend/.env` con el siguiente contenido si quieres activar las funciones externas:
+
+```env
+HF_TOKEN=tu_token_de_huggingface
+OMDB_API_KEY=tu_api_key_de_omdb
+```
+
+`HF_TOKEN` se usa para generar respuestas de chatbot con Hugging Face. Si falla o no existe, la aplicacion usa una respuesta de respaldo basada en plantilla.
+
+`OMDB_API_KEY` es opcional y permite recuperar posters de peliculas desde OMDb.
+
+## Instalacion
+
+### 1. Clonar el repositorio
+
+```bash
+git clone <url-del-repositorio>
+cd ValorSentimental
+```
+
+### 2. Instalar dependencias del backend
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+En Windows PowerShell:
+
+```powershell
+python -m venv .venv
+.\.venv\Scripts\Activate.ps1
+pip install -r requirements.txt
+```
+
+### 3. Instalar dependencias del frontend
+
+```bash
+cd chatbot
+npm install
+```
+
+## Preparacion de datos
+
+El recomendador usa los CSV de MovieLens en `data/ml-latest`. Si no estan presentes, se pueden descargar con:
+
+```bash
+python data/download_movielens_large.py
+```
+
+Tambien se puede generar el dataset procesado de 100 peliculas con emociones inferidas por genero:
+
+```bash
+python data/script.py
+```
+
+El backend intenta cargar primero `data/ml-latest/movies.csv`, `ratings.csv` y `links.csv`. Si no encuentra el dataset completo, usa como alternativa `data/procesado/peliculas_100_emociones.csv`.
+
+## Ejecucion
+
+### Backend
+
+Desde la raiz del proyecto:
+
+```bash
+cd backend
+python main.py
+```
+
+La API queda disponible en:
+
+```text
+http://localhost:5000
+```
+
+En el primer arranque puede tardar porque se carga o descarga el modelo de emociones.
+
+### Frontend
+
+En otra terminal:
+
+```bash
+cd chatbot
+npm run dev
+```
+
+Vite mostrara la URL local, normalmente:
+
+```text
+http://localhost:5173
+```
+
+El frontend esta configurado para llamar al backend en `http://localhost:5000`.
+
+## Flujo de uso
+
+1. El usuario se registra o inicia sesion.
+2. Durante el registro puede anadir peliculas ya vistas para construir un historial inicial.
+3. En el chat escribe como se siente.
+4. El backend analiza el texto y calcula emocion dominante, valencia y arousal.
+5. El recomendador propone peliculas segun el historial y la estrategia seleccionada.
+6. El usuario puede marcar una pelicula como vista y valorarla.
+7. Despues puede indicar como se siente, cerrando un ciclo pre/post recomendacion.
+
+## Estrategias de recomendacion
+
+Las estrategias estan en `backend/services/estrategias_recomendacion.py`.
+
+- `v1`: logica binaria. Si la emocion es positiva, recomienda fuera de la zona de confort; si es negativa, recomienda dentro.
+- `v2`: pondera de forma continua el grado de confort y la calidad de la pelicula.
+- `v3`: calcula un objetivo de confort adaptativo usando valencia y arousal.
+
+Si el usuario no tiene historial, el sistema recomienda peliculas de calidad global usando una puntuacion bayesiana suavizada.
+
+## API principal
+
+### Autenticacion
+
+- `POST /auth/register`
+- `POST /auth/login`
+- `POST /auth/logout`
+- `POST /auth/password`
+- `POST /auth/verify`
+- `DELETE /auth/account`
+
+### Analisis y recomendacion
+
+- `POST /analizar`
+- `POST /recomendacion/seguimiento`
+
+### Historial
+
+- `POST /historial/visto`
+- `GET /historial`
+- `DELETE /historial`
+- `GET /historial/transiciones`
+
+### Catalogo
+
+- `GET /peliculas/populares`
+- `GET /peliculas/buscar?q=<texto>`
+- `POST /onboarding/historial`
+- `GET /poster/<imdb_id>`
+
+## Base de datos
+
+La base de datos se crea automaticamente en:
+
+```text
+backend/history.db
+```
+
+Tablas principales:
+
+- `Usuarios`
+- `Peliculas`
+- `Emociones`
+- `Historial_Peliculas`
+- `Ciclo_Recomendacion`
+
+La arquitectura usa DAOs para separar el acceso a datos de la logica de negocio y un Singleton para centralizar la conexion SQLite.
+
+## Documentacion adicional
+
+El repositorio incluye documentacion de apoyo:
+
+- `DIAGRAMAS_PATRONES.md`: patrones de diseno y arquitectura por capas.
+- `docs/diagrama_er.md`: diagrama entidad-relacion.
+- `docs/login_seq.md`: secuencia de login.
+
+## Notas
+
+- El modelo de emociones se ejecuta localmente mediante Transformers.
+- La generacion textual del chatbot intenta usar Hugging Face y, si no esta disponible, cae a una plantilla local.
+- OMDb solo es necesario para mostrar posters; el recomendador funciona sin esa clave.
+- `history.db` es una base local generada en ejecucion y no deberia versionarse.
+

backend/aplicacion.py

@@ -1,8 +1,3 @@
-"""
-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
@@ -18,30 +13,22 @@ 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 vo import PeliculaVistaVO
 from services.pipeline import AnalysisService
 from services.analisis_sentimientos import analizar_texto, crear_clasificador_emociones
-from services.recomendacion import cargar_dataset_movies
+from services.movielens_service 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."""
+def _genero_pelicula(movie_id: str) -> str | None:
     row = _movies_index.get(str(movie_id))
     if not row:
-        return None, None
+        return 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
+    return genres_raw if genres_raw and genres_raw != "(no genres listed)" else None
 
 app = Flask(__name__)
 CORS(app)
@@ -197,8 +184,7 @@ def seguimiento_recomendacion():
     )
 
     if id_pelicula:
-        _anio, _genero = _meta_pelicula(id_pelicula)
-        _pelicula_dao.guardar_si_no_existe(id_pelicula, titulo_pelicula, anio=_anio, genero=_genero)
+        _pelicula_dao.guardar_si_no_existe(id_pelicula, titulo_pelicula, genero=_genero_pelicula(id_pelicula))
     if emocion_post_obj:
         _ciclo_dao.cerrar_ciclo(
             ciclo_id=cycle_id,
@@ -252,8 +238,7 @@ def guardar_visto():
         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)
+    _pelicula_dao.guardar_si_no_existe(id_pelicula, titulo_pelicula, genero=_genero_pelicula(id_pelicula))
 
     emocion_id = None
     if emocion_str:
@@ -364,6 +349,123 @@ def obtener_transiciones():
     return jsonify({"items": items[:limit], "count": len(items[:limit])})
 
 
+# ------------------------------------------------------------------
+# Catálogo de películas (búsqueda y populares para onboarding)
+# ------------------------------------------------------------------
+
+_PRIOR_COUNT = 50  # same as calculos.py
+
+def _puntuacion_bayesiana(row: dict, media_global: float) -> float:
+    count = int(row.get("rating_count") or 0)
+    mean = float(row.get("rating_mean") or 0.0)
+    return ((count * mean) + (_PRIOR_COUNT * media_global)) / (count + _PRIOR_COUNT)
+
+
+@app.route("/peliculas/populares", methods=["GET"])
+def peliculas_populares():
+    try:
+        limit = max(1, min(int(request.args.get("limit", 20)), 100))
+    except ValueError:
+        limit = 20
+
+    scored = [
+        {
+            "movie_id": str(r.get("movieId", "")).strip(),
+            "titulo": str(r.get("title", "")).strip(),
+            "genero": str(r.get("genres", "")).strip(),
+            "imdb_id": str(r.get("imdb_id", "")).strip(),
+            "rating_mean": round(float(r.get("rating_mean") or 0.0), 2),
+            "rating_count": int(r.get("rating_count") or 0),
+        }
+        for r in sorted(
+            _movies_df,
+            key=lambda r: _puntuacion_bayesiana(r, _media_rating_global),
+            reverse=True,
+        )[:limit]
+    ]
+    return jsonify({"items": scored, "count": len(scored)})
+
+
+@app.route("/peliculas/buscar", methods=["GET"])
+def buscar_peliculas():
+    q = str(request.args.get("q", "")).strip().lower()
+    if not q or len(q) < 2:
+        return jsonify({"error": "El parámetro q debe tener al menos 2 caracteres"}), 400
+    try:
+        limit = max(1, min(int(request.args.get("limit", 15)), 50))
+    except ValueError:
+        limit = 15
+
+    coincidencias = [
+        r for r in _movies_df
+        if q in str(r.get("title", "")).lower()
+    ]
+    coincidencias.sort(
+        key=lambda r: _puntuacion_bayesiana(r, _media_rating_global),
+        reverse=True,
+    )
+    items = [
+        {
+            "movie_id": str(r.get("movieId", "")).strip(),
+            "titulo": str(r.get("title", "")).strip(),
+            "genero": str(r.get("genres", "")).strip(),
+            "imdb_id": str(r.get("imdb_id", "")).strip(),
+            "rating_mean": round(float(r.get("rating_mean") or 0.0), 2),
+            "rating_count": int(r.get("rating_count") or 0),
+        }
+        for r in coincidencias[:limit]
+    ]
+    return jsonify({"items": items, "count": len(items)})
+
+
+@app.route("/onboarding/historial", methods=["POST"])
+def onboarding_historial():
+    """Guarda un lote de películas ya vistas durante el onboarding del registro."""
+    payload = request.json or {}
+    user_id = str(payload.get("user_id", "")).strip()
+    token = str(payload.get("token", "")).strip()
+    peliculas = payload.get("peliculas", [])
+
+    if not user_id or not token:
+        return jsonify({"error": "user_id y token son obligatorios"}), 400
+    if not _usuario_dao.obtener_por_token(token):
+        return jsonify({"error": "Token inválido"}), 401
+    if not isinstance(peliculas, list):
+        return jsonify({"error": "peliculas debe ser una lista"}), 400
+
+    from datetime import datetime, timezone
+    momento = datetime.now(timezone.utc).isoformat()
+    guardadas = 0
+
+    for peli in peliculas:
+        movie_id = str(peli.get("movie_id", "")).strip()
+        titulo = str(peli.get("titulo", "")).strip()
+        if not movie_id:
+            continue
+        genero = _genero_pelicula(movie_id) or str(peli.get("genero", "")).strip() or None
+        rating_raw = peli.get("valoracion")
+        valoracion = None
+        if rating_raw is not None:
+            try:
+                v = float(rating_raw)
+                valoracion = v if 1.0 <= v <= 5.0 else None
+            except (TypeError, ValueError):
+                pass
+        _pelicula_dao.guardar_si_no_existe(movie_id, titulo, genero=genero)
+        entrada = _historial_dao.añadir_pelicula(
+            user_id=user_id,
+            pelicula_id=movie_id,
+            emocion_id=None,
+            valoracion=valoracion,
+            texto=None,
+            tiempo=momento,
+        )
+        if entrada:
+            guardadas += 1
+
+    return jsonify({"ok": True, "guardadas": guardadas}), 201
+
+
 # ------------------------------------------------------------------
 # Poster OMDB
 # ------------------------------------------------------------------

backend/base_datos.py

@@ -26,7 +26,6 @@ def iniciar_historial_usuario() -> None:
             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
@@ -37,18 +36,16 @@ def iniciar_historial_usuario() -> None:
         # ------------------------------------------------------------------ #
         # Peliculas                                                            #
         # PK: id (IMDb/OMDB id)                                               #
-        # FDs: id → titulo, anio, genero, poster_url                          #
+        # FDs: id → titulo, genero                                             #
         # 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
+                id     TEXT PRIMARY KEY,
+                titulo TEXT NOT NULL,
+                genero TEXT
             )
             """
         )

backend/conexion_bd.py

@@ -2,10 +2,7 @@ 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":

backend/dao/ciclo_dao.py

@@ -1,6 +1,5 @@
 from conexion_bd import ConexionBD
-from modelos import CicloRecomendacion
-
+from do import CicloRecomendacion
 
 class CicloDAO:
     def __init__(self):

backend/dao/emocion_dao.py

@@ -1,6 +1,5 @@
 from conexion_bd import ConexionBD
-from modelos import Emocion
-
+from do import Emocion
 
 class EmocionDAO:
     def __init__(self):

backend/dao/historial_dao.py

@@ -1,6 +1,6 @@
 from conexion_bd import ConexionBD
-from modelos import HistorialPelicula, PeliculaVistaVO
-
+from do import HistorialPelicula
+from vo import PeliculaVistaVO
 
 class HistorialDAO:
     def __init__(self):

backend/dao/pelicula_dao.py

@@ -1,6 +1,5 @@
 from conexion_bd import ConexionBD
-from modelos import Pelicula
-
+from do import Pelicula
 
 class PeliculaDAO:
     def __init__(self):
@@ -9,21 +8,19 @@ class PeliculaDAO:
     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:
+    def guardar_si_no_existe(self, pelicula_id: str, titulo: str,
+                             genero: str | None = None) -> Pelicula:
         with self.obtener_conexion() as con:
             con.execute(
-                """INSERT INTO Peliculas (id, titulo, anio, genero, poster_url)
-                   VALUES (?, ?, ?, ?, ?)
+                """INSERT INTO Peliculas (id, titulo, genero)
+                   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),
+                       genero = COALESCE(Peliculas.genero, excluded.genero)""",
+                (pelicula_id, titulo, genero),
             )
             con.commit()
             row = con.execute(
-                "SELECT id, titulo, anio, genero, poster_url FROM Peliculas WHERE id = ?",
+                "SELECT id, titulo, genero FROM Peliculas WHERE id = ?",
                 (pelicula_id,),
             ).fetchone()
         return self._row_a_pelicula(row)
@@ -31,7 +28,7 @@ class PeliculaDAO:
     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 = ?",
+                "SELECT id, titulo, genero FROM Peliculas WHERE id = ?",
                 (pelicula_id,),
             ).fetchone()
         if not row:
@@ -41,7 +38,7 @@ class PeliculaDAO:
     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
+                """SELECT id, titulo, genero FROM Peliculas
                    WHERE titulo LIKE ?
                    ORDER BY titulo
                    LIMIT ?""",
@@ -49,11 +46,9 @@ class PeliculaDAO:
             ).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}
+    def actualizar(self, pelicula_id: str, titulo: str | None = None,
+                   genero: str | None = None) -> bool:
+        campos = {k: v for k, v in {"titulo": titulo, "genero": genero}.items() if v is not None}
         if not campos:
             return False
         sets = ", ".join(f"{col} = ?" for col in campos)
@@ -67,7 +62,4 @@ class PeliculaDAO:
             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"],
-        )
+        return Pelicula(id=row["id"], titulo=row["titulo"], genero=row["genero"])

backend/dao/usuario_dao.py

@@ -4,8 +4,7 @@ from datetime import datetime, timezone
 from werkzeug.security import check_password_hash, generate_password_hash
 
 from conexion_bd import ConexionBD
-from modelos import Usuario
-
+from do import Usuario
 
 class UsuarioDao:
     def __init__(self):
@@ -21,9 +20,9 @@ class UsuarioDao:
         try:
             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),
+                    """INSERT INTO Usuarios (id, username, 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)

backend/do.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+
+@dataclass
+class Usuario:
+    id: str
+    username: str
+    token: str
+
+@dataclass
+class Pelicula:
+    id: str
+    titulo: str
+    genero: 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

backend/{modelos.py → modelos_servicios.py}

@@ -1,99 +1,5 @@
 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
@@ -101,7 +7,6 @@ class ContextoEmocional:
     valencia_actual: float
     historico_arousal: list[float] = field(default_factory=list)
 
-
 @dataclass
 class PerfilUsuario:
     peliculas_vistas: set[str] = field(default_factory=set)
@@ -112,7 +17,6 @@ class PerfilUsuario:
     ranking_generos: dict[str, int] = field(default_factory=dict)
     tiene_historial: bool = False
 
-
 @dataclass
 class ResultadoAnalisis:
     emociones: list[dict]
@@ -129,4 +33,4 @@ class ResultadoAnalisis:
     chatbot_texto: str
     chatbot_fuente: str
     pelicula_transicion: dict | None
-    recomendaciones: list[dict]
+    recomendaciones: list[dict]

backend/scripts/crear_bd.py

@@ -7,10 +7,7 @@ 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))
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
 from base_datos import iniciar_historial_usuario
 from config import HISTORY_DB_PATH

backend/scripts/limpiar_bdm.py

@@ -8,10 +8,7 @@ import sqlite3
 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))
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
 from base_datos import iniciar_historial_usuario
 from config import HISTORY_DB_PATH

backend/services/calculos.py

@@ -2,7 +2,7 @@ import random
 from collections import Counter
 
 from config import GLOBAL_PRIOR_COUNT, LIKE_THRESHOLD, POSITIVE_EMOTIONS
-from modelos import PerfilUsuario
+from modelos_servicios import PerfilUsuario
 
 
 def obtener_generos_pelicula(row: dict) -> set[str]:
@@ -119,7 +119,12 @@ def calcular_pertenencia_zona_confort(peli: dict, zona_confort_ponderada: dict[s
     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)
+    coincidentes = [p for p in pesos if p > 0.0]
+    if not coincidentes:
+        return 0.0
+    cobertura = len(coincidentes) / len(generos)
+    media_coincidentes = sum(coincidentes) / len(coincidentes)
+    return cobertura * media_coincidentes
 
 
 def percentil_desde_cero(arousal_actual: float, historico_arousal: list[float]) -> float:

backend/services/estrategias_recomendacion.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 
 from config import POSITIVE_EMOTIONS
-from modelos import ContextoEmocional, PerfilUsuario
+from modelos_servicios import ContextoEmocional, PerfilUsuario
 from services.calculos import (
     calcular_pertenencia_zona_confort,
     grado_confort_vector,

backend/services/movielens_service.py

@@ -0,0 +1,59 @@
+import csv
+from pathlib import Path
+
+
+def cargar_dataset_movies() -> tuple[list[dict], float]:
+    """
+    Carga el dataset de MovieLens desde CSVs.
+
+    Returns:
+        tuple: (movies_df, media_rating_global)
+            - movies_df: lista de diccionarios con estructura
+              {movieId, title, genres, imdb_id, rating_mean, rating_count}
+            - media_rating_global: promedio global de ratings
+    """
+    base_path = Path(__file__).parent.parent.parent / "data" / "ml-latest-small"
+
+    movies_path = base_path / "movies.csv"
+    ratings_path = base_path / "ratings.csv"
+    links_path = base_path / "links.csv"
+
+    movies = {}
+    with open(movies_path, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            movies[row["movieId"]] = {
+                "movieId": row["movieId"],
+                "title": row["title"],
+                "genres": row["genres"],
+            }
+
+    imdb_ids = {}
+    with open(links_path, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            imdb_ids[row["movieId"]] = row["imdbId"]
+
+    ratings_by_movie = {}
+    all_ratings = []
+    with open(ratings_path, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            movie_id = row["movieId"]
+            rating = float(row["rating"])
+            all_ratings.append(rating)
+
+            if movie_id not in ratings_by_movie:
+                ratings_by_movie[movie_id] = []
+            ratings_by_movie[movie_id].append(rating)
+
+    for movie_id, movie in movies.items():
+        ratings = ratings_by_movie.get(movie_id, [])
+        movie["rating_count"] = len(ratings)
+        movie["rating_mean"] = sum(ratings) / len(ratings) if ratings else 0.0
+        movie["imdb_id"] = imdb_ids.get(movie_id, "")
+
+    movies_df = list(movies.values())
+    media_global = sum(all_ratings) / len(all_ratings) if all_ratings else 0.0
+
+    return movies_df, media_global

backend/services/pipeline.py

@@ -10,7 +10,8 @@ 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 modelos_servicios import ContextoEmocional, ResultadoAnalisis
+from vo import EmocionVO
 from services.chatbot import generar_texto_chatbot
 from services.analisis_sentimientos import (
     analizar_texto,

backend/services/recomendacion.py

@@ -4,11 +4,8 @@ Combina calidad global (suavizado bayesiano), similitud de generos y preferencia
 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 modelos_servicios import ContextoEmocional
 from services.estrategias_recomendacion import EstrategiaFactory
 from services.calculos import construir_perfil_usuario, recomendar_calidad_aleatoria
 
@@ -19,99 +16,6 @@ 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,

backend/vo.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+
+from do import Emocion
+
+@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

chatbot/src/views/AuthView.vue

@@ -20,132 +20,208 @@
       <!-- Card -->
       <div class="auth-card-wrap">
         <v-card class="auth-card" rounded="xl" elevation="0">
-          <div class="auth-card-header">
-            <h2 class="card-title">
-              {{ activeTab === 'login' ? 'Bienvenido de vuelta' : 'Crear cuenta' }}
-            </h2>
-            <p class="card-subtitle">
-              {{ activeTab === 'login'
-                ? 'Inicia sesión para acceder al chat'
-                : 'Regístrate para guardar tu historial' }}
-            </p>
-          </div>
-
-          <v-tabs v-model="activeTab" color="primary" density="compact" class="auth-tabs">
-            <v-tab value="login">Iniciar sesión</v-tab>
-            <v-tab value="register">Registrarse</v-tab>
-          </v-tabs>
-
-          <v-divider />
-
-          <div class="form-wrap">
-            <!-- Login -->
-            <form v-if="activeTab === 'login'" class="auth-form" @submit.prevent="submitLogin">
-              <v-text-field
-                v-model="loginForm.username"
-                label="Nombre de usuario"
-                variant="outlined"
-                density="comfortable"
-                prepend-inner-icon="mdi-account-outline"
-                autocomplete="username"
-                hide-details="auto"
-                class="mb-4"
-              />
-              <v-text-field
-                v-model="loginForm.password"
-                label="Contraseña"
-                :type="showLoginPwd ? 'text' : 'password'"
-                variant="outlined"
-                density="comfortable"
-                prepend-inner-icon="mdi-lock-outline"
-                :append-inner-icon="showLoginPwd ? 'mdi-eye-off-outline' : 'mdi-eye-outline'"
-                autocomplete="current-password"
-                hide-details="auto"
-                class="mb-4"
-                @click:append-inner="showLoginPwd = !showLoginPwd"
-              />
-              <v-alert
-                v-if="loginError"
-                type="error"
-                variant="tonal"
-                rounded="lg"
-                density="compact"
-                class="mb-4"
-              >
-                {{ loginError }}
-              </v-alert>
-              <v-btn
-                type="submit"
-                color="primary"
-                variant="flat"
-                block
-                rounded="lg"
-                size="large"
-                :loading="loginLoading"
-              >
-                Iniciar sesión
-              </v-btn>
-            </form>
-
-            <!-- Register -->
-            <form v-else class="auth-form" @submit.prevent="submitRegister">
-              <v-text-field
-                v-model="registerForm.username"
-                label="Nombre de usuario"
-                variant="outlined"
-                density="comfortable"
-                prepend-inner-icon="mdi-account-outline"
-                autocomplete="username"
-                hide-details="auto"
-                class="mb-4"
-              />
-              <v-text-field
-                v-model="registerForm.email"
-                label="Email (opcional)"
-                type="email"
-                variant="outlined"
-                density="comfortable"
-                prepend-inner-icon="mdi-email-outline"
-                autocomplete="email"
-                hide-details="auto"
-                class="mb-4"
-              />
-              <v-text-field
-                v-model="registerForm.password"
-                label="Contraseña"
-                :type="showRegPwd ? 'text' : 'password'"
-                variant="outlined"
-                density="comfortable"
-                prepend-inner-icon="mdi-lock-outline"
-                :append-inner-icon="showRegPwd ? 'mdi-eye-off-outline' : 'mdi-eye-outline'"
-                autocomplete="new-password"
-                hide-details="auto"
-                class="mb-4"
-                @click:append-inner="showRegPwd = !showRegPwd"
-              />
-              <v-alert
-                v-if="registerError"
-                type="error"
-                variant="tonal"
-                rounded="lg"
-                density="compact"
-                class="mb-4"
-              >
-                {{ registerError }}
-              </v-alert>
-              <v-btn
-                type="submit"
-                color="primary"
-                variant="flat"
-                block
-                rounded="lg"
-                size="large"
-                :loading="registerLoading"
-              >
-                Crear cuenta
-              </v-btn>
-            </form>
-          </div>
+
+          <!-- ── Paso 1: Login / Register ───────────────────────── -->
+          <template v-if="step === 1">
+            <div class="auth-card-header">
+              <h2 class="card-title">
+                {{ activeTab === 'login' ? 'Bienvenido de vuelta' : 'Crear cuenta' }}
+              </h2>
+              <p class="card-subtitle">
+                {{ activeTab === 'login'
+                  ? 'Inicia sesión para acceder al chat'
+                  : 'Regístrate para guardar tu historial' }}
+              </p>
+            </div>
+
+            <v-tabs v-model="activeTab" color="primary" density="compact" class="auth-tabs">
+              <v-tab value="login">Iniciar sesión</v-tab>
+              <v-tab value="register">Registrarse</v-tab>
+            </v-tabs>
+
+            <v-divider />
+
+            <div class="form-wrap">
+              <!-- Login -->
+              <form v-if="activeTab === 'login'" class="auth-form" @submit.prevent="submitLogin">
+                <v-text-field
+                  v-model="loginForm.username"
+                  label="Nombre de usuario"
+                  variant="outlined"
+                  density="comfortable"
+                  prepend-inner-icon="mdi-account-outline"
+                  autocomplete="username"
+                  hide-details="auto"
+                  class="mb-4"
+                />
+                <v-text-field
+                  v-model="loginForm.password"
+                  label="Contraseña"
+                  :type="showLoginPwd ? 'text' : 'password'"
+                  variant="outlined"
+                  density="comfortable"
+                  prepend-inner-icon="mdi-lock-outline"
+                  :append-inner-icon="showLoginPwd ? 'mdi-eye-off-outline' : 'mdi-eye-outline'"
+                  autocomplete="current-password"
+                  hide-details="auto"
+                  class="mb-4"
+                  @click:append-inner="showLoginPwd = !showLoginPwd"
+                />
+                <v-alert v-if="loginError" type="error" variant="tonal" rounded="lg" density="compact" class="mb-4">
+                  {{ loginError }}
+                </v-alert>
+                <v-btn type="submit" color="primary" variant="flat" block rounded="lg" size="large" :loading="loginLoading">
+                  Iniciar sesión
+                </v-btn>
+              </form>
+
+              <!-- Register -->
+              <form v-else class="auth-form" @submit.prevent="submitRegister">
+                <v-text-field
+                  v-model="registerForm.username"
+                  label="Nombre de usuario"
+                  variant="outlined"
+                  density="comfortable"
+                  prepend-inner-icon="mdi-account-outline"
+                  autocomplete="username"
+                  hide-details="auto"
+                  class="mb-4"
+                />
+                <v-text-field
+                  v-model="registerForm.password"
+                  label="Contraseña"
+                  :type="showRegPwd ? 'text' : 'password'"
+                  variant="outlined"
+                  density="comfortable"
+                  prepend-inner-icon="mdi-lock-outline"
+                  :append-inner-icon="showRegPwd ? 'mdi-eye-off-outline' : 'mdi-eye-outline'"
+                  autocomplete="new-password"
+                  hide-details="auto"
+                  class="mb-4"
+                  @click:append-inner="showRegPwd = !showRegPwd"
+                />
+                <v-alert v-if="registerError" type="error" variant="tonal" rounded="lg" density="compact" class="mb-4">
+                  {{ registerError }}
+                </v-alert>
+                <v-btn type="submit" color="primary" variant="flat" block rounded="lg" size="large" :loading="registerLoading">
+                  Crear cuenta
+                </v-btn>
+              </form>
+            </div>
+          </template>
+
+          <!-- ── Paso 2: Onboarding de películas vistas ─────────── -->
+          <template v-else>
+            <div class="auth-card-header">
+              <h2 class="card-title">¿Qué películas ya has visto?</h2>
+              <p class="card-subtitle">
+                Añade algunas y el recomendador aprenderá mejor tus gustos desde el primer momento.
+              </p>
+            </div>
+
+            <v-divider />
+
+            <div class="form-wrap onboarding-wrap">
+              <!-- Buscador -->
+              <div class="search-row">
+                <v-text-field
+                  v-model="searchQuery"
+                  label="Buscar película..."
+                  variant="outlined"
+                  density="comfortable"
+                  prepend-inner-icon="mdi-magnify"
+                  hide-details
+                  clearable
+                  @input="onSearchInput"
+                  @click:clear="clearSearch"
+                />
+              </div>
+
+              <!-- Resultados de búsqueda -->
+              <div v-if="searchResults.length" class="results-list">
+                <div
+                  v-for="peli in searchResults"
+                  :key="peli.movie_id"
+                  class="result-item"
+                  :class="{ 'result-item--added': isAdded(peli.movie_id) }"
+                  @click="togglePelicula(peli)"
+                >
+                  <div class="result-info">
+                    <span class="result-title">{{ peli.titulo }}</span>
+                    <span class="result-genre">{{ formatGenre(peli.genero) }}</span>
+                  </div>
+                  <div class="result-right">
+                    <span v-if="peli.rating_mean" class="result-rating">
+                      <v-icon size="13" color="amber-darken-1">mdi-star</v-icon>
+                      {{ peli.rating_mean.toFixed(1) }}
+                    </span>
+                    <v-icon v-if="isAdded(peli.movie_id)" color="primary" size="20">mdi-check-circle</v-icon>
+                    <v-icon v-else size="20" color="grey-lighten-1">mdi-plus-circle-outline</v-icon>
+                  </div>
+                </div>
+              </div>
+
+              <!-- Películas populares (cuando no hay búsqueda activa) -->
+              <div v-else-if="!searchQuery" class="popular-section">
+                <p class="section-label">Populares</p>
+                <div class="results-list">
+                  <div
+                    v-for="peli in popularMovies"
+                    :key="peli.movie_id"
+                    class="result-item"
+                    :class="{ 'result-item--added': isAdded(peli.movie_id) }"
+                    @click="togglePelicula(peli)"
+                  >
+                    <div class="result-info">
+                      <span class="result-title">{{ peli.titulo }}</span>
+                      <span class="result-genre">{{ formatGenre(peli.genero) }}</span>
+                    </div>
+                    <div class="result-right">
+                      <span v-if="peli.rating_mean" class="result-rating">
+                        <v-icon size="13" color="amber-darken-1">mdi-star</v-icon>
+                        {{ peli.rating_mean.toFixed(1) }}
+                      </span>
+                      <v-icon v-if="isAdded(peli.movie_id)" color="primary" size="20">mdi-check-circle</v-icon>
+                      <v-icon v-else size="20" color="grey-lighten-1">mdi-plus-circle-outline</v-icon>
+                    </div>
+                  </div>
+                </div>
+              </div>
+
+              <!-- Seleccionadas -->
+              <div v-if="seleccionadas.length" class="selected-section">
+                <p class="section-label">Añadidas ({{ seleccionadas.length }})</p>
+                <div class="chips-wrap">
+                  <v-chip
+                    v-for="peli in seleccionadas"
+                    :key="peli.movie_id"
+                    closable
+                    size="small"
+                    class="chip-pelicula"
+                    @click:close="quitarPelicula(peli.movie_id)"
+                  >
+                    {{ peli.titulo }}
+                  </v-chip>
+                </div>
+              </div>
+
+              <!-- Acciones -->
+              <div class="onboarding-actions">
+                <v-btn
+                  color="primary"
+                  variant="flat"
+                  block
+                  rounded="lg"
+                  size="large"
+                  :loading="onboardingLoading"
+                  @click="finalizarOnboarding"
+                >
+                  {{ seleccionadas.length ? `Guardar y empezar (${seleccionadas.length})` : 'Empezar sin historial' }}
+                </v-btn>
+              </div>
+            </div>
+          </template>
+
         </v-card>
       </div>
     </div>
@@ -153,22 +229,37 @@
 </template>
 
 <script setup>
-import { ref } from "vue";
+import { ref, onMounted } from "vue";
 import { useRouter } from "vue-router";
 
 const router = useRouter();
 const activeTab = ref("login");
+const step = ref(1);
 
+// ── Login ──────────────────────────────────────────────────────────
 const loginForm = ref({ username: "", password: "" });
 const loginError = ref("");
 const loginLoading = ref(false);
 const showLoginPwd = ref(false);
 
-const registerForm = ref({ username: "", email: "", password: "" });
+// ── Register ───────────────────────────────────────────────────────
+const registerForm = ref({ username: "", password: "" });
 const registerError = ref("");
 const registerLoading = ref(false);
 const showRegPwd = ref(false);
 
+// ── Onboarding ─────────────────────────────────────────────────────
+const popularMovies = ref([]);
+const searchQuery = ref("");
+const searchResults = ref([]);
+const seleccionadas = ref([]);
+const onboardingLoading = ref(false);
+let searchTimer = null;
+
+// Credenciales guardadas tras el registro, para el onboarding
+let _pendingUserId = "";
+let _pendingToken = "";
+
 async function submitLogin() {
   loginError.value = "";
   if (!loginForm.value.username || !loginForm.value.password) {
@@ -214,24 +305,110 @@ async function submitRegister() {
     const res = await fetch("http://localhost:5000/auth/register", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        username: registerForm.value.username,
-        email: registerForm.value.email,
-        password: registerForm.value.password,
-      }),
+      body: JSON.stringify({ username: registerForm.value.username, password: registerForm.value.password }),
     });
     const data = await res.json();
     if (!res.ok) { registerError.value = data.error || "Error al crear la cuenta."; return; }
+    // Guardamos credenciales en localStorage ya, pero vamos al paso 2
     localStorage.setItem("vs_token", data.token);
     localStorage.setItem("vs_user_id", data.user_id);
     localStorage.setItem("vs_username", data.username);
-    router.push("/chat");
+    _pendingUserId = data.user_id;
+    _pendingToken = data.token;
+    await cargarPopulares();
+    step.value = 2;
   } catch {
     registerError.value = "Error de conexión con el servidor.";
   } finally {
     registerLoading.value = false;
   }
 }
+
+async function cargarPopulares() {
+  try {
+    const res = await fetch("http://localhost:5000/peliculas/populares?limit=20");
+    if (res.ok) {
+      const data = await res.json();
+      popularMovies.value = data.items || [];
+    }
+  } catch {
+    // silencioso — no bloqueamos el onboarding si falla
+  }
+}
+
+function onSearchInput() {
+  clearTimeout(searchTimer);
+  if (!searchQuery.value || searchQuery.value.trim().length < 2) {
+    searchResults.value = [];
+    return;
+  }
+  searchTimer = setTimeout(async () => {
+    try {
+      const q = encodeURIComponent(searchQuery.value.trim());
+      const res = await fetch(`http://localhost:5000/peliculas/buscar?q=${q}&limit=15`);
+      if (res.ok) {
+        const data = await res.json();
+        searchResults.value = data.items || [];
+      }
+    } catch {
+      searchResults.value = [];
+    }
+  }, 300);
+}
+
+function clearSearch() {
+  searchQuery.value = "";
+  searchResults.value = [];
+}
+
+function isAdded(movieId) {
+  return seleccionadas.value.some(p => p.movie_id === movieId);
+}
+
+function togglePelicula(peli) {
+  if (isAdded(peli.movie_id)) {
+    quitarPelicula(peli.movie_id);
+  } else {
+    seleccionadas.value.push(peli);
+  }
+}
+
+function quitarPelicula(movieId) {
+  seleccionadas.value = seleccionadas.value.filter(p => p.movie_id !== movieId);
+}
+
+function formatGenre(genero) {
+  if (!genero || genero === "(no genres listed)") return "";
+  return genero.split("|").slice(0, 3).join(" · ");
+}
+
+async function finalizarOnboarding() {
+  if (!seleccionadas.value.length) {
+    router.push("/chat");
+    return;
+  }
+  onboardingLoading.value = true;
+  try {
+    await fetch("http://localhost:5000/onboarding/historial", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        user_id: _pendingUserId,
+        token: _pendingToken,
+        peliculas: seleccionadas.value.map(p => ({
+          movie_id: p.movie_id,
+          titulo: p.titulo,
+          genero: p.genero,
+        })),
+      }),
+    });
+  } catch {
+    // Si falla el onboarding no bloqueamos al usuario
+  } finally {
+    onboardingLoading.value = false;
+  }
+  router.push("/chat");
+}
 </script>
 
 <style scoped>
@@ -276,7 +453,7 @@ async function submitRegister() {
   position: relative;
   z-index: 1;
   width: 100%;
-  max-width: 440px;
+  max-width: 480px;
   padding: 24px 16px;
   margin: 0 auto;
   display: flex;
@@ -367,8 +544,108 @@ async function submitRegister() {
 
 .auth-form { display: flex; flex-direction: column; }
 
+/* ── Onboarding ─────────────────────────────────────────────────── */
+.onboarding-wrap {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.search-row { width: 100%; }
+
+.results-list {
+  border: 1px solid var(--vs-border, rgba(102,126,234,0.15));
+  border-radius: 10px;
+  overflow: hidden;
+  max-height: 280px;
+  overflow-y: auto;
+}
+
+.result-item {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 10px 14px;
+  cursor: pointer;
+  transition: background 0.15s ease;
+  border-bottom: 1px solid rgba(102,126,234,0.07);
+  gap: 8px;
+}
+
+.result-item:last-child { border-bottom: none; }
+
+.result-item:hover { background: rgba(102,126,234,0.06); }
+
+.result-item--added { background: rgba(102,126,234,0.08); }
+
+.result-info {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  min-width: 0;
+}
+
+.result-title {
+  font-size: 0.875rem;
+  font-weight: 500;
+  color: var(--vs-text, #1a1a2e);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  max-width: 280px;
+}
+
+.result-genre {
+  font-size: 0.72rem;
+  color: var(--vs-muted, #6b7280);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  max-width: 280px;
+}
+
+.result-right {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-shrink: 0;
+}
+
+.result-rating {
+  display: flex;
+  align-items: center;
+  gap: 2px;
+  font-size: 0.78rem;
+  color: var(--vs-muted, #6b7280);
+  white-space: nowrap;
+}
+
+.section-label {
+  font-size: 0.72rem;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--vs-muted, #6b7280);
+  margin: 0 0 8px;
+}
+
+.popular-section, .selected-section { width: 100%; }
+
+.chips-wrap {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+
+.chip-pelicula {
+  font-size: 0.78rem;
+}
+
+.onboarding-actions { width: 100%; }
+
 @media (max-width: 480px) {
   .auth-card-header { padding: 20px 20px 12px; }
   .form-wrap { padding: 20px 20px 24px; }
+  .result-title, .result-genre { max-width: 180px; }
 }
 </style>

data/ml-latest/README.txt

@@ -1,179 +0,0 @@
-Summary
-=======
-
-This dataset (ml-latest) describes 5-star rating and free-text tagging activity from [MovieLens](http://movielens.org), a movie recommendation service. It contains 33832162 ratings and 2328315 tag applications across 86537 movies. These data were created by 330975 users between January 09, 1995 and July 20, 2023. This dataset was generated on July 20, 2023.
-
-Users were selected at random for inclusion. All selected users had rated at least 1 movies. No demographic information is included. Each user is represented by an id, and no other information is provided.
-
-The data are contained in the files `genome-scores.csv`, `genome-tags.csv`, `links.csv`, `movies.csv`, `ratings.csv` and `tags.csv`. More details about the contents and use of all these files follows.
-
-This is a *development* dataset. As such, it may change over time and is not an appropriate dataset for shared research results. See available *benchmark* datasets if that is your intent.
-
-This and other GroupLens data sets are publicly available for download at <http://grouplens.org/datasets/>.
-
-
-Usage License
-=============
-
-Neither the University of Minnesota nor any of the researchers involved can guarantee the correctness of the data, its suitability for any particular purpose, or the validity of results based on the use of the data set. The data set may be used for any research purposes under the following conditions:
-
-* The user may not state or imply any endorsement from the University of Minnesota or the GroupLens Research Group.
-* The user must acknowledge the use of the data set in publications resulting from the use of the data set (see below for citation information).
-* The user may redistribute the data set, including transformations, so long as it is distributed under these same license conditions.
-* The user may not use this information for any commercial or revenue-bearing purposes without first obtaining permission from a faculty member of the GroupLens Research Project at the University of Minnesota.
-* The executable software scripts are provided "as is" without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. The entire risk as to the quality and performance of them is with you. Should the program prove defective, you assume the cost of all necessary servicing, repair or correction.
-
-In no event shall the University of Minnesota, its affiliates or employees be liable to you for any damages arising out of the use or inability to use these programs (including but not limited to loss of data or data being rendered inaccurate).
-
-If you have any further questions or comments, please email <grouplens-info@umn.edu>
-
-
-Citation
-========
-
-To acknowledge use of the dataset in publications, please cite the following paper:
-
-> F. Maxwell Harper and Joseph A. Konstan. 2015. The MovieLens Datasets: History and Context. ACM Transactions on Interactive Intelligent Systems (TiiS) 5, 4: 19:1–19:19. <https://doi.org/10.1145/2827872>
-
-
-Further Information About GroupLens
-===================================
-
-GroupLens is a research group in the Department of Computer Science and Engineering at the University of Minnesota. Since its inception in 1992, GroupLens's research projects have explored a variety of fields including:
-
-* recommender systems
-* online communities
-* mobile and ubiquitious technologies
-* digital libraries
-* local geographic information systems
-
-GroupLens Research operates a movie recommender based on collaborative filtering, MovieLens, which is the source of these data. We encourage you to visit <http://movielens.org> to try it out! If you have exciting ideas for experimental work to conduct on MovieLens, send us an email at <grouplens-info@cs.umn.edu> - we are always interested in working with external collaborators.
-
-
-Content and Use of Files
-========================
-
-Formatting and Encoding
------------------------
-
-The dataset files are written as [comma-separated values](http://en.wikipedia.org/wiki/Comma-separated_values) files with a single header row. Columns that contain commas (`,`) are escaped using double-quotes (`"`). These files are encoded as UTF-8. If accented characters in movie titles or tag values (e.g. Misérables, Les (1995)) display incorrectly, make sure that any program reading the data, such as a text editor, terminal, or script, is configured for UTF-8.
-
-
-User Ids
---------
-
-MovieLens users were selected at random for inclusion. Their ids have been anonymized. User ids are consistent between `ratings.csv` and `tags.csv` (i.e., the same id refers to the same user across the two files).
-
-
-Movie Ids
----------
-
-Only movies with at least one rating or tag are included in the dataset. These movie ids are consistent with those used on the MovieLens web site (e.g., id `1` corresponds to the URL <https://movielens.org/movies/1>). Movie ids are consistent between `ratings.csv`, `tags.csv`, `movies.csv`, and `links.csv` (i.e., the same id refers to the same movie across these four data files).
-
-
-Ratings Data File Structure (ratings.csv)
------------------------------------------
-
-All ratings are contained in the file `ratings.csv`. Each line of this file after the header row represents one rating of one movie by one user, and has the following format:
-
-    userId,movieId,rating,timestamp
-
-The lines within this file are ordered first by userId, then, within user, by movieId.
-
-Ratings are made on a 5-star scale, with half-star increments (0.5 stars - 5.0 stars).
-
-Timestamps represent seconds since midnight Coordinated Universal Time (UTC) of January 1, 1970.
-
-
-Tags Data File Structure (tags.csv)
------------------------------------
-
-All tags are contained in the file `tags.csv`. Each line of this file after the header row represents one tag applied to one movie by one user, and has the following format:
-
-    userId,movieId,tag,timestamp
-
-The lines within this file are ordered first by userId, then, within user, by movieId.
-
-Tags are user-generated metadata about movies. Each tag is typically a single word or short phrase. The meaning, value, and purpose of a particular tag is determined by each user.
-
-Timestamps represent seconds since midnight Coordinated Universal Time (UTC) of January 1, 1970.
-
-
-Movies Data File Structure (movies.csv)
----------------------------------------
-
-Movie information is contained in the file `movies.csv`. Each line of this file after the header row represents one movie, and has the following format:
-
-    movieId,title,genres
-
-Movie titles are entered manually or imported from <https://www.themoviedb.org/>, and include the year of release in parentheses. Errors and inconsistencies may exist in these titles.
-
-Genres are a pipe-separated list, and are selected from the following:
-
-* Action
-* Adventure
-* Animation
-* Children's
-* Comedy
-* Crime
-* Documentary
-* Drama
-* Fantasy
-* Film-Noir
-* Horror
-* Musical
-* Mystery
-* Romance
-* Sci-Fi
-* Thriller
-* War
-* Western
-* (no genres listed)
-
-
-Links Data File Structure (links.csv)
----------------------------------------
-
-Identifiers that can be used to link to other sources of movie data are contained in the file `links.csv`. Each line of this file after the header row represents one movie, and has the following format:
-
-    movieId,imdbId,tmdbId
-
-movieId is an identifier for movies used by <https://movielens.org>. E.g., the movie Toy Story has the link <https://movielens.org/movies/1>.
-
-imdbId is an identifier for movies used by <http://www.imdb.com>. E.g., the movie Toy Story has the link <http://www.imdb.com/title/tt0114709/>.
-
-tmdbId is an identifier for movies used by <https://www.themoviedb.org>. E.g., the movie Toy Story has the link <https://www.themoviedb.org/movie/862>.
-
-Use of the resources listed above is subject to the terms of each provider.
-
-
-Tag Genome (genome-scores.csv and genome-tags.csv)
--------------------------------------------------
-
-This data set includes a current copy of the Tag Genome.
-
-[genome-paper]: http://files.grouplens.org/papers/tag_genome.pdf
-
-The tag genome is a data structure that contains tag relevance scores for movies.  The structure is a dense matrix: each movie in the genome has a value for *every* tag in the genome.
-
-As described in [this article][genome-paper], the tag genome encodes how strongly movies exhibit particular properties represented by tags (atmospheric, thought-provoking, realistic, etc.). The tag genome was computed using a machine learning algorithm on user-contributed content including tags, ratings, and textual reviews.
-
-The genome is split into two files.  The file `genome-scores.csv` contains movie-tag relevance data in the following format:
-
-    movieId,tagId,relevance
-
-The second file, `genome-tags.csv`, provides the tag descriptions for the tag IDs in the genome file, in the following format:
-
-    tagId,tag
-
-The `tagId` values are generated when the data set is exported, so they may vary from version to version of the MovieLens data sets.
-
-Please include the following citation if referencing tag genome data:
-
-> Jesse Vig, Shilad Sen, and John Riedl. 2012. The Tag Genome: Encoding Community Knowledge to Support Novel Interaction. ACM Trans. Interact. Intell. Syst. 2, 3: 13:1–13:44. <https://doi.org/10.1145/2362394.2362395>
-
-
-Cross-Validation
-----------------
-
-Prior versions of the MovieLens dataset included either pre-computed cross-folds or scripts to perform this computation. We no longer bundle either of these features with the dataset, since most modern toolkits provide this as a built-in feature. If you wish to learn about standard approaches to cross-fold computation in the context of recommender systems evaluation, see [LensKit](http://lenskit.org) for tools, documentation, and open-source code examples.

data/{download_movielens_large.py → movielens.py}

@@ -7,7 +7,7 @@ from tempfile import NamedTemporaryFile
 from urllib.request import urlretrieve
 from zipfile import ZipFile
 
-MOVIELENS_LARGE_URL = "https://files.grouplens.org/datasets/movielens/ml-latest.zip"
+MOVIELENS_SMALL_URL = "https://files.grouplens.org/datasets/movielens/ml-latest-small.zip"
 
 
 def download_zip(url: str, destination: Path) -> None:
@@ -41,16 +41,16 @@ def extract_csv_files(zip_path: Path, output_dir: Path) -> list[Path]:
 
 def main() -> None:
     parser = argparse.ArgumentParser(
-        description="Descarga y extrae los CSV de MovieLens (version grande: ml-latest)."
+        description="Descarga y extrae los CSV de MovieLens (version pequeña: ml-latest-small)."
     )
     parser.add_argument(
         "--url",
-        default=MOVIELENS_LARGE_URL,
+        default=MOVIELENS_SMALL_URL,
         help="URL del dataset ZIP de MovieLens.",
     )
     parser.add_argument(
         "--output",
-        default=str(Path(__file__).resolve().parent / "ml-latest"),
+        default=str(Path(__file__).resolve().parent / "ml-latest-small"),
         help="Directorio donde se guardaran los CSV extraidos.",
     )
     parser.add_argument(

data/procesado/peliculas_100_emociones.csv

@@ -1,101 +0,0 @@
-movieId,title,genres,rating_count,rating_mean,estados_emocionales
-296,Pulp Fiction (1994),Comedy|Crime|Drama|Thriller,108756,4.192,ira|alegria
-593,"Silence of the Lambs, The (1991)",Crime|Horror|Thriller,101802,4.15,ira|sorpresa
-260,Star Wars: Episode IV - A New Hope (1977),Action|Adventure|Sci-Fi,97202,4.092,alegria|ira
-527,Schindler's List (1993),Drama|War,84232,4.242,tristeza|neutral
-589,Terminator 2: Judgment Day (1991),Action|Sci-Fi,71820,3.962,ira|sorpresa
-47,Seven (a.k.a. Se7en) (1995),Mystery|Thriller,65666,4.088,sorpresa|ira
-6539,Pirates of the Caribbean: The Curse of the Black Pearl (2003),Action|Adventure|Comedy|Fantasy,50868,3.784,alegria|miedo
-541,Blade Runner (1982),Action|Sci-Fi|Thriller,47695,4.114,ira|sorpresa
-924,2001: A Space Odyssey (1968),Adventure|Drama|Sci-Fi,37113,3.997,alegria|tristeza
-4896,Harry Potter and the Sorcerer's Stone (a.k.a. Harry Potter and the Philosopher's Stone) (2001),Adventure|Children|Fantasy,36127,3.695,alegria|miedo
-919,"Wizard of Oz, The (1939)",Adventure|Children|Fantasy|Musical,30354,3.92,alegria|tristeza
-8360,Shrek 2 (2004),Adventure|Animation|Children|Comedy|Musical|Romance,26972,3.478,alegria|tristeza
-903,Vertigo (1958),Drama|Mystery|Romance|Thriller,20775,4.116,tristeza|sorpresa
-4848,Mulholland Drive (2001),Crime|Drama|Film-Noir|Mystery|Thriller,17061,3.854,ira|sorpresa
-673,Space Jam (1996),Adventure|Animation|Children|Comedy|Fantasy|Sci-Fi,14268,2.79,alegria|miedo
-215,Before Sunrise (1995),Drama|Romance,8835,3.943,tristeza|neutral
-4105,"Evil Dead, The (1981)",Fantasy|Horror|Thriller,7838,3.699,sorpresa|ira
-3503,Solaris (Solyaris) (1972),Drama|Mystery|Sci-Fi,3705,3.883,sorpresa|tristeza
-123,Chungking Express (Chung Hing sam lam) (1994),Drama|Mystery|Romance,3683,4.005,tristeza|sorpresa
-275503,Aftersun (2022),Drama,403,3.999,tristeza|neutral
-318,"Shawshank Redemption, The (1994)",Crime|Drama,122296,4.417,tristeza|ira
-356,Forrest Gump (1994),Comedy|Drama|Romance|War,113581,4.068,tristeza|alegria
-2571,"Matrix, The (1999)",Action|Sci-Fi|Thriller,107056,4.161,ira|sorpresa
-2959,Fight Club (1999),Action|Crime|Drama|Thriller,86207,4.236,ira|neutral
-480,Jurassic Park (1993),Action|Adventure|Sci-Fi|Thriller,83026,3.689,ira|sorpresa
-1196,Star Wars: Episode V - The Empire Strikes Back (1980),Action|Adventure|Sci-Fi,80200,4.118,alegria|ira
-4993,"Lord of the Rings: The Fellowship of the Ring, The (2001)",Adventure|Fantasy,79940,4.099,alegria|miedo
-1,Toy Story (1995),Adventure|Animation|Children|Comedy|Fantasy,76813,3.894,alegria|miedo
-1210,Star Wars: Episode VI - Return of the Jedi (1983),Action|Adventure|Sci-Fi,76773,3.981,alegria|ira
-110,Braveheart (1995),Action|Drama|War,75514,3.996,neutral|tristeza
-7153,"Lord of the Rings: The Return of the King, The (2003)",Action|Adventure|Drama|Fantasy,75512,4.11,neutral|alegria
-1198,Raiders of the Lost Ark (Indiana Jones and the Raiders of the Lost Ark) (1981),Action|Adventure,75248,4.101,alegria|ira
-858,"Godfather, The (1972)",Crime|Drama,75004,4.327,tristeza|ira
-5952,"Lord of the Rings: The Two Towers, The (2002)",Adventure|Fantasy,73687,4.081,alegria|miedo
-50,"Usual Suspects, The (1995)",Crime|Mystery|Thriller,72893,4.268,ira|sorpresa
-2858,American Beauty (1999),Drama|Romance,69902,4.102,tristeza|neutral
-1270,Back to the Future (1985),Adventure|Comedy|Sci-Fi,67777,3.958,alegria|miedo
-58559,"Dark Knight, The (2008)",Action|Crime|Drama|IMAX,65349,4.188,ira|neutral
-79132,Inception (2010),Action|Crime|Drama|Mystery|Sci-Fi|Thriller|IMAX,65056,4.176,ira|sorpresa
-2028,Saving Private Ryan (1998),Action|Drama|War,64235,4.057,neutral|tristeza
-780,Independence Day (a.k.a. ID4) (1996),Action|Adventure|Sci-Fi|Thriller,63687,3.402,ira|sorpresa
-150,Apollo 13 (1995),Adventure|Drama|IMAX,62521,3.89,alegria|tristeza
-608,Fargo (1996),Comedy|Crime|Drama|Thriller,61977,4.115,ira|alegria
-457,"Fugitive, The (1993)",Thriller,61732,3.977,ira|sorpresa
-3578,Gladiator (2000),Action|Adventure|Drama,60749,3.97,neutral|alegria
-2762,"Sixth Sense, The (1999)",Drama|Horror|Mystery,60439,4.008,tristeza|sorpresa
-32,Twelve Monkeys (a.k.a. 12 Monkeys) (1995),Mystery|Sci-Fi|Thriller,59730,3.897,sorpresa|ira
-4306,Shrek (2001),Adventure|Animation|Children|Comedy|Fantasy|Romance,58529,3.749,alegria|miedo
-592,Batman (1989),Action|Crime|Thriller,56330,3.39,ira|sorpresa
-588,Aladdin (1992),Adventure|Animation|Children|Comedy|Musical,55791,3.702,alegria|miedo
-4226,Memento (2000),Mystery|Thriller,55649,4.144,sorpresa|ira
-1704,Good Will Hunting (1997),Drama|Romance,54980,4.107,tristeza|neutral
-364,"Lion King, The (1994)",Adventure|Animation|Children|Drama|Musical|IMAX,53509,3.833,alegria|tristeza
-590,Dances with Wolves (1990),Adventure|Drama|Western,53377,3.741,alegria|tristeza
-380,True Lies (1994),Action|Adventure|Comedy|Romance|Thriller,52789,3.505,alegria|ira
-1197,"Princess Bride, The (1987)",Action|Adventure|Comedy|Fantasy|Romance,50775,4.111,alegria|miedo
-1721,Titanic (1997),Drama|Romance,50706,3.429,tristeza|neutral
-1580,Men in Black (a.k.a. MIB) (1997),Action|Comedy|Sci-Fi,49951,3.595,alegria|ira
-1193,One Flew Over the Cuckoo's Nest (1975),Drama,49316,4.213,tristeza|neutral
-377,Speed (1994),Action|Romance|Thriller,49029,3.491,ira|tristeza
-1291,Indiana Jones and the Last Crusade (1989),Action|Adventure,48979,3.982,alegria|ira
-1240,"Terminator, The (1984)",Action|Sci-Fi|Thriller,48672,3.902,ira|sorpresa
-4886,"Monsters, Inc. (2001)",Adventure|Animation|Children|Comedy|Fantasy,48441,3.841,alegria|miedo
-6377,Finding Nemo (2003),Adventure|Animation|Children|Comedy,48124,3.821,alegria|miedo
-1265,Groundhog Day (1993),Comedy|Fantasy|Romance,47956,3.904,miedo|alegria
-1136,Monty Python and the Holy Grail (1975),Adventure|Comedy|Fantasy,47845,4.137,alegria|miedo
-344,Ace Ventura: Pet Detective (1994),Comedy,47829,3.001,alegria|miedo
-648,Mission: Impossible (1996),Action|Adventure|Mystery|Thriller,47759,3.414,ira|sorpresa
-1036,Die Hard (1988),Action|Crime|Thriller,47472,3.943,ira|sorpresa
-1221,"Godfather: Part II, The (1974)",Crime|Drama,47271,4.27,tristeza|ira
-6874,Kill Bill: Vol. 1 (2003),Action|Crime|Thriller,46973,3.856,ira|sorpresa
-1214,Alien (1979),Horror|Sci-Fi,46572,4.07,sorpresa
-7361,Eternal Sunshine of the Spotless Mind (2004),Drama|Romance|Sci-Fi,46292,4.07,tristeza|sorpresa
-1682,"Truman Show, The (1998)",Comedy|Drama|Sci-Fi,45809,3.892,alegria|tristeza
-4973,"Amelie (Fabuleux destin d'Amélie Poulain, Le) (2001)",Comedy|Romance,45749,4.087,alegria|tristeza
-595,Beauty and the Beast (1991),Animation|Children|Fantasy|Musical|Romance|IMAX,45404,3.68,alegria|tristeza
-1089,Reservoir Dogs (1992),Crime|Mystery|Thriller,45318,4.094,ira|sorpresa
-1213,Goodfellas (1990),Crime|Drama,44592,4.192,tristeza|ira
-1097,E.T. the Extra-Terrestrial (1982),Children|Drama|Sci-Fi,43868,3.738,alegria|tristeza
-293,Léon: The Professional (a.k.a. The Professional) (Léon) (1994),Action|Crime|Drama|Thriller,43539,4.098,ira|neutral
-165,Die Hard: With a Vengeance (1995),Action|Crime|Thriller,43336,3.516,ira|sorpresa
-33794,Batman Begins (2005),Action|Crime|IMAX,43300,3.925,ira|neutral
-4995,"Beautiful Mind, A (2001)",Drama|Romance,43013,3.966,tristeza|neutral
-8961,"Incredibles, The (2004)",Action|Adventure|Animation|Children|Comedy,42953,3.85,alegria|miedo
-3793,X-Men (2000),Action|Adventure|Sci-Fi,42387,3.534,alegria|ira
-4963,Ocean's Eleven (2001),Crime|Thriller,42340,3.817,ira|sorpresa
-1527,"Fifth Element, The (1997)",Action|Adventure|Comedy|Sci-Fi,42155,3.784,alegria|ira
-60069,WALL·E (2008),Adventure|Animation|Children|Romance|Sci-Fi,42033,4.014,alegria|tristeza
-367,"Mask, The (1994)",Action|Comedy|Crime|Fantasy,41407,3.19,ira|miedo
-3147,"Green Mile, The (1999)",Crime|Drama,41222,4.043,tristeza|ira
-2628,Star Wars: Episode I - The Phantom Menace (1999),Action|Adventure|Sci-Fi,41061,3.078,alegria|ira
-2329,American History X (1998),Crime|Drama,41055,4.135,tristeza|ira
-500,Mrs. Doubtfire (1993),Comedy|Drama,40844,3.398,alegria|tristeza
-597,Pretty Woman (1990),Comedy|Romance,40755,3.439,alegria|tristeza
-109487,Interstellar (2014),Sci-Fi|IMAX,40603,4.147,sorpresa
-5445,Minority Report (2002),Action|Crime|Mystery|Sci-Fi|Thriller,40414,3.696,ira|sorpresa
-733,"Rock, The (1996)",Action|Adventure|Thriller,40412,3.687,ira|alegria
-231,Dumb & Dumber (Dumb and Dumber) (1994),Adventure|Comedy,40371,2.976,alegria|miedo
-1258,"Shining, The (1980)",Horror,40297,4.036,neutral
-1200,Aliens (1986),Action|Adventure|Horror|Sci-Fi,40182,4.006,alegria|ira

data/procesado/peliculas_conocidas.csv

@@ -1,21 +0,0 @@
-movieId,title,genres,estados_emocionales
-47,Seven (a.k.a. Se7en) (1995),Mystery|Thriller,miedo|sorpresa
-123,Chungking Express (Chung Hing sam lam) (1994),Drama|Mystery|Romance,tristeza|neutral
-215,Before Sunrise (1995),Drama|Romance,alegria|neutral
-260,Star Wars: Episode IV - A New Hope (1977),Action|Adventure|Sci-Fi,alegria|sorpresa
-296,Pulp Fiction (1994),Comedy|Crime|Drama|Thriller,sorpresa|neutral
-527,Schindler's List (1993),Drama|War,tristeza|neutral
-541,Blade Runner (1982),Action|Sci-Fi|Thriller,neutral|sorpresa
-589,Terminator 2: Judgment Day (1991),Action|Sci-Fi,sorpresa|alegria
-593,"Silence of the Lambs, The (1991)",Crime|Horror|Thriller,miedo|asco
-673,Space Jam (1996),Adventure|Animation|Children|Comedy|Fantasy|Sci-Fi,alegria|neutral
-903,Vertigo (1958),Drama|Mystery|Romance|Thriller,miedo|sorpresa
-919,"Wizard of Oz, The (1939)",Adventure|Children|Fantasy|Musical,alegria|sorpresa
-924,2001: A Space Odyssey (1968),Adventure|Drama|Sci-Fi,neutral|sorpresa
-4105,"Evil Dead, The (1981)",Fantasy|Horror|Thriller,miedo|asco
-4848,Mulholland Drive (2001),Crime|Drama|Film-Noir|Mystery|Thriller,sorpresa|neutral
-4896,Harry Potter and the Sorcerer's Stone (a.k.a. Harry Potter and the Philosopher's Stone) (2001),Adventure|Children|Fantasy,alegria|sorpresa
-3503,Solaris (Solyaris) (1972),Drama|Mystery|Sci-Fi,tristeza|neutral
-8360,Shrek 2 (2004),Adventure|Animation|Children|Comedy|Musical|Romance,alegria|neutral
-275503,Aftersun (2022),Drama,tristeza|neutral
-6539,Pirates of the Caribbean: The Curse of the Black Pearl (2003),Action|Adventure|Comedy|Fantasy,alegria|sorpresa

data/script.py

@@ -1,174 +0,0 @@
-from __future__ import annotations
-
-import csv
-from pathlib import Path
-from urllib.request import urlretrieve
-from zipfile import ZipFile
-
-
-MOVIELENS_LARGE_URL = "https://files.grouplens.org/datasets/movielens/ml-latest.zip"
-TARGET_SIZE = 100
-
-# Esquema base de asignacion genero -> emocion (Ekman + neutral).
-EMOTION_GENRE_MAP = {
-    "alegria": {"Comedy", "Animation", "Children", "Adventure", "Musical"},
-    "tristeza": {"Drama", "Romance", "Musical"},
-    "ira": {"Thriller", "Action", "Crime"},
-    "miedo": {"Fantasy", "Animation", "Comedy"},
-    "asco": {"Documentary", "Comedy"},
-    "sorpresa": {"Mystery", "Sci-Fi", "Fantasy", "Thriller"},
-    "neutral": {"Drama", "Documentary", "Action"},
-}
-
-# En empates, priorizamos emociones especificas sobre neutral.
-EMOTION_PRIORITY = ["alegria", "tristeza", "ira", "miedo", "asco", "sorpresa", "neutral"]
-
-
-def download_movielens_large(base_dir: Path) -> Path:
-    zip_path = base_dir / "ml-latest.zip"
-    extracted_dir = base_dir / "ml-latest"
-
-    if extracted_dir.exists():
-        print(f"El dataset ya existe en: {extracted_dir}")
-        return extracted_dir
-
-    print("Descargando MovieLens (ml-latest)...")
-    urlretrieve(MOVIELENS_LARGE_URL, zip_path)
-
-    print(f"Extrayendo en: {base_dir}")
-    with ZipFile(zip_path, "r") as zip_file:
-        zip_file.extractall(base_dir)
-
-    zip_path.unlink(missing_ok=True)
-    print(f"Descarga completa. Dataset disponible en: {extracted_dir}")
-    return extracted_dir
-
-
-def infer_emotions_from_genres(genres: str) -> str:
-    tokens = set((genres or "").split("|"))
-    scores = {emotion: 0 for emotion in EMOTION_GENRE_MAP}
-
-    for emotion, mapped_genres in EMOTION_GENRE_MAP.items():
-        scores[emotion] = len(tokens.intersection(mapped_genres))
-
-    priority_idx = {emotion: idx for idx, emotion in enumerate(EMOTION_PRIORITY)}
-    ordered = sorted(scores.items(), key=lambda x: (-x[1], priority_idx.get(x[0], 999)))
-    selected = [name for name, score in ordered if score > 0][:2]
-    if not selected:
-        return "neutral"
-    return "|".join(selected)
-
-
-def build_emotion_dataset(base_dir: Path, target_size: int = TARGET_SIZE) -> Path:
-    movielens_dir = base_dir / "ml-latest"
-    movies_path = movielens_dir / "movies.csv"
-    ratings_path = movielens_dir / "ratings.csv"
-    seed_path = base_dir / "procesado" / "peliculas_conocidas.csv"
-
-    if not movies_path.exists() or not ratings_path.exists():
-        raise FileNotFoundError("No se encontraron movies.csv o ratings.csv en data/ml-latest")
-
-    movies_by_id: dict[int, dict[str, str]] = {}
-    with open(movies_path, "r", encoding="utf-8", newline="") as f:
-        reader = csv.DictReader(f)
-        for row in reader:
-            movie_id = int(row["movieId"])
-            movies_by_id[movie_id] = {
-                "movieId": str(movie_id),
-                "title": row.get("title", ""),
-                "genres": row.get("genres", ""),
-            }
-
-    rating_acc: dict[int, tuple[int, float]] = {}
-    with open(ratings_path, "r", encoding="utf-8", newline="") as f:
-        reader = csv.DictReader(f)
-        for row in reader:
-            movie_id = int(row["movieId"])
-            rating_val = float(row["rating"])
-            count, total = rating_acc.get(movie_id, (0, 0.0))
-            rating_acc[movie_id] = (count + 1, total + rating_val)
-
-    ranked: list[dict[str, str | int | float]] = []
-    for movie_id, movie in movies_by_id.items():
-        count, total = rating_acc.get(movie_id, (0, 0.0))
-        mean = (total / count) if count else 0.0
-        ranked.append(
-            {
-                "movieId": movie_id,
-                "title": movie["title"],
-                "genres": movie["genres"],
-                "rating_count": count,
-                "rating_mean": round(mean, 3),
-            }
-        )
-
-    ranked.sort(key=lambda x: (x["rating_count"], x["rating_mean"]), reverse=True)
-
-    seed_ids: list[int] = []
-    if seed_path.exists():
-        with open(seed_path, "r", encoding="utf-8", newline="") as f:
-            reader = csv.DictReader(f)
-            for row in reader:
-                raw_id = row.get("movieId", "").strip()
-                if raw_id.isdigit():
-                    seed_ids.append(int(raw_id))
-
-    seed_set = set(seed_ids)
-    seed_rows = [r for r in ranked if r["movieId"] in seed_set]
-    remaining_rows = [r for r in ranked if r["movieId"] not in seed_set]
-
-    selected: list[dict[str, str | int | float]] = []
-    seen: set[int] = set()
-    for row in seed_rows + remaining_rows:
-        movie_id = int(row["movieId"])
-        if movie_id in seen:
-            continue
-        seen.add(movie_id)
-        selected.append(row)
-        if len(selected) >= target_size:
-            break
-
-    for row in selected:
-        row["estados_emocionales"] = infer_emotions_from_genres(str(row["genres"]))
-
-    out_path = base_dir / "procesado" / "peliculas_100_emociones.csv"
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-
-    with open(out_path, "w", encoding="utf-8", newline="") as f:
-        writer = csv.DictWriter(
-            f,
-            fieldnames=[
-                "movieId",
-                "title",
-                "genres",
-                "rating_count",
-                "rating_mean",
-                "estados_emocionales",
-            ],
-        )
-        writer.writeheader()
-        for row in selected:
-            writer.writerow(
-                {
-                    "movieId": row["movieId"],
-                    "title": row["title"],
-                    "genres": row["genres"],
-                    "rating_count": row["rating_count"],
-                    "rating_mean": row["rating_mean"],
-                    "estados_emocionales": row["estados_emocionales"],
-                }
-            )
-
-    print(f"Dataset generado en: {out_path}")
-    print(f"Peliculas guardadas: {len(selected)}")
-    return out_path
-
-
-def main() -> None:
-    base_dir = Path(__file__).resolve().parent
-    download_movielens_large(base_dir)
-    build_emotion_dataset(base_dir, target_size=TARGET_SIZE)
-
-
-if __name__ == "__main__":
-    main()

data/textos_complejo.csv

@@ -1,43 +0,0 @@
-id,texto,esperado
-1,"¡Me acaban de dar la beca! Estoy eufórico, es el mejor día de mi vida.",joy
-2,"Hoy he aprobado todas las asignaturas con matrícula de honor. ¡Soy el más feliz!",joy
-3,"Mi hija dio sus primeros pasos esta mañana. Me llené de alegría y orgullo.",joy
-4,"¡Gané el concurso! No me lo puedo creer, estoy llorando de la emoción y la felicidad.",joy
-5,"Después de meses de esfuerzo, por fin terminé mi tesis. ¡Estoy contentísimo!",joy
-6,"Reencontrarme con mis amigos de la infancia después de diez años fue una maravilla.",joy
-7,"No puedo parar de llorar. Echo mucho de menos a mi abuela desde que falleció.",sadness
-8,"Perdí el trabajo hoy. No sé cómo voy a pagar el alquiler este mes.",sadness
-9,"Se fue y no dijo adiós. Me dejó un vacío que no sé cómo llenar.",sadness
-10,"Mi perro murió esta noche. Era mi compañero de los últimos doce años y le echo de menos.",sadness
-11,"Me siento muy solo últimamente. Nadie parece entender por lo que estoy pasando.",sadness
-12,"Suspendí el examen final tras meses estudiando. Siento que no sirvo para nada.",sadness
-13,"¡Cómo se atreven a tratarme así! Esto es completamente inaceptable y lo pagarán.",anger
-14,"Me robaron la mochila con el ordenador dentro. Estoy temblando de rabia.",anger
-15,"Llevan tres horas de retraso y ni siquiera se molestan en dar explicaciones. ¡Indignante!",anger
-16,"Me mintieron deliberadamente para quedarse con mi dinero. Estoy furioso y no lo voy a dejar pasar.",anger
-17,"¡No puedo más! Han vuelto a ignorar mis correos después de semanas esperando respuesta.",anger
-18,"Le dije claramente que no tocara mis cosas y lo hizo igualmente. Me saca de quicio.",anger
-19,"Escuché pasos en el pasillo oscuro y estaba completamente solo en casa.",fear
-20,"El médico dijo que necesitaba más pruebas. No paro de pensar en lo peor y no puedo dormir.",fear
-21,"El avión empezó a moverse de forma extraña y sentí que el corazón se me paraba.",fear
-22,"Me persiguió un perro enorme ladrando durante dos manzanas. Seguía temblando cuando llegué a casa.",fear
-23,"Mañana es la operación y no sé si saldré bien. Tengo un miedo horrible.",fear
-24,"El terremoto me pilló despierto. Nunca he sentido tanto pánico en toda mi vida.",fear
-25,"¿Viniste desde tan lejos solo para verme? ¡No me lo esperaba para nada!",surprise
-26,"Abrí la puerta y estaba toda mi familia reunida para darme una fiesta sorpresa. ¡Alucinante!",surprise
-27,"No puedo creer que hayan cancelado ese programa. Llevaba diez años en antena.",surprise
-28,"Me quedé boquiabierto cuando me dijeron que habían encontrado petróleo en el patio de mi casa.",surprise
-29,"¡Apareció el gato que dábamos por perdido hace dos años! Estamos todos en shock.",surprise
-30,"De repente me llamaron para decirme que me habían seleccionado sin haber mandado el currículum.",surprise
-31,"El olor de esa basura podrida era tan nauseabundo que casi vomito.",disgust
-32,"Encontré un gusano en la ensalada a mitad de comer. Me dan náuseas solo de recordarlo.",disgust
-33,"El baño estaba tan sucio y lleno de bichos que no pude entrar. Repugnante.",disgust
-34,"Ese comentario racista me revolvió el estómago. ¿Cómo puede pensar así alguien en pleno siglo XXI?",disgust
-35,"Vi cómo maltrataban al animal y sentí una asco profundo hacia esa persona.",disgust
-36,"Me sirvieron la carne completamente cruda. Asqueroso. Me negué a comer.",disgust
-37,"La reunión está programada para las 15:00 en la sala de conferencias principal.",neutral
-38,"El informe trimestral consta de cuarenta páginas y debe entregarse antes del viernes.",neutral
-39,"La tienda abre de lunes a sábado de 9 a 21 horas. Los domingos permanece cerrada.",neutral
-40,"El tren de las 8:42 hace parada en las estaciones de Atocha, Chamartín y Alcalá.",neutral
-41,"El departamento de recursos humanos enviará el contrato por correo electrónico.",neutral
-42,"La temperatura máxima prevista para mañana es de 18 grados centígrados.",neutral

data/textos_simple.csv

@@ -1,43 +0,0 @@
-id,texto,esperado
-1,"Me encanta esta película, es increíble y me ha hecho sentir muy feliz. ¡Totalmente recomendada!",Positivo
-2,"Qué decepción tan grande. El guión es pésimo, los actores no convencen y el final es un desastre.",Negativo
-3,"La película dura dos horas y fue estrenada en octubre. Está disponible en la plataforma de streaming.",Neutro
-4,"Los efectos visuales son espectaculares y la fotografía es preciosa, pero el ritmo es muy lento y aburre bastante.",Negativo
-5,"Claro, porque esperar tres semanas para que llegue el DVD y que venga rayado es exactamente lo que esperaba de un servicio premium.",Negativo
-6,"Una obra maestra del cine contemporáneo. Cada escena está cuidada al detalle y las actuaciones son sublimes.",Positivo
-7,"¡La mejor serie que he visto en años! No podía dejar de verla, me enganchó desde el primer capítulo.",Positivo
-8,"Entretenida y con buenos momentos de humor. Perfecta para pasar una tarde sin complicaciones.",Positivo
-9,"El director ha conseguido crear una atmósfera única. La banda sonora es espectacular.",Positivo
-10,"Simplemente perfecta. Una experiencia cinematográfica que no olvidaré jamás.",Positivo
-11,"Un completo desastre. Dos horas de mi vida que nunca recuperaré.",Negativo
-12,"Es la peor película que he visto en mucho tiempo. Aburrida, predecible y mal actuada.",Negativo
-13,"No me gustó nada. El director claramente no sabía lo que estaba haciendo.",Negativo
-14,"Malísima. Una pérdida total de tiempo y dinero. No la recomiendo para nada.",Negativo
-15,"Terrible en todos los aspectos. Desde el guión hasta las actuaciones, todo está mal.",Negativo
-16,"Decepcionante. Esperaba mucho más de este director.",Negativo
-17,"Una película sin más. Cumple pero no destaca en nada particular.",Neutro
-18,"Es correcta, aunque no aporta nada nuevo al género. Entretenimiento básico.",Neutro
-19,"Está bien para pasar el rato, pero no es memorable.",Neutro
-20,"Una producción estándar que cumple con las expectativas mínimas.",Neutro
-21,"Tiene momentos brillantes pero también partes muy flojas. Un poco irregular.",Neutro
-22,"Los actores principales están geniales, pero la trama se complica demasiado hacia el final.",Positivo
-23,"Excelente fotografía y banda sonora, aunque el ritmo es inconsistente a veces.",Positivo
-24,"Me gustó el primer acto, pero se vuelve confusa en la segunda mitad.",Neutro
-25,"Buena idea inicial que se ejecuta de manera desigual. Algunos aciertos y algunos errores.",Neutro
-26,"Las actuaciones son sólidas pero el guión tiene algunos agujeros importantes.",Positivo
-27,"Interesante propuesta visual, aunque la historia no termina de convencer del todo.",Negativo
-28,"Disfrutable en general, con altibajos que la hacen irregular pero entretenida.",Positivo
-29,"Sí, claro, porque una película de tres horas sin argumento es exactamente lo que necesitaba ver hoy.",Negativo
-30,"Por supuesto, gastar 15 euros en el cine para ver esto ha sido una inversión excelente.",Negativo
-31,"Fantástico, otra secuela innecesaria que nadie pidió. Justo lo que el mundo necesitaba.",Negativo
-32,"Magnífico trabajo del director, especialmente en la parte donde no pasa absolutamente nada interesante.",Negativo
-33,"Maravilloso, porque esperar 30 minutos para que aparezca el primer diálogo es súper emocionante.",Negativo
-34,"Genial, otra película que trata de ser profunda pero solo consigue ser aburrida.",Negativo
-35,"Me encanta esta serie 😍 Es perfecta! 🎬✨",Positivo
-36,"Qué horror de película 😤 No la recomiendo para nada 👎",Negativo
-37,"Una experiencia cinematográfica increíble 🚀 ¡Totalmente recomendada! ⭐⭐⭐⭐⭐",Positivo
-38,"Aburrida y predecible. Nada que destacar.",Negativo
-39,"El final me dejó completamente sorprendido. Excelente giro argumental.",Positivo
-40,"Los personajes están muy bien desarrollados. Se nota el trabajo del guionista.",Positivo
-41,"La cinematografía es impresionante, cada plano es una obra de arte.",Positivo
-42,"No logra mantener el interés. Se hace larga y tediosa.",Negativo

docs/diagrama_er.md

@@ -1,13 +1,8 @@
-# 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"
@@ -16,9 +11,7 @@ erDiagram
     Peliculas {
         TEXT id PK "IMDb/OMDB id"
         TEXT titulo "NOT NULL"
-        TEXT anio
         TEXT genero
-        TEXT poster_url
     }
 
     Emociones {
@@ -44,20 +37,21 @@ erDiagram
         INTEGER id PK
         TEXT user_id FK
         INTEGER emocion_pre_id FK "NOT NULL"
+        INTEGER emocion_post_id FK "nullable"
+        TEXT pelicula_id FK "nullable"
         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"
+    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"
+    
+    Emociones ||--o{ Historial_Peliculas : "asociada a visionado"
+    Emociones ||--o{ Ciclo_Recomendacion : "estado inicial/final"
 ```
 
 ## Justificación BCNF

docs/login_seq.md

@@ -0,0 +1,28 @@
+```mermaid
+sequenceDiagram
+    participant Cliente as Cliente API/Vue
+    participant Servicio as Servicio
+    participant DAO as UsuarioDao
+    participant Singleton as ConexionBD
+    participant BD as SQLite
+
+    Cliente->>Servicio: login(username, password)
+    Servicio->>DAO: login(username, password)
+    DAO->>Singleton: instancia()
+    Singleton-->>DAO: ConexionBD unica
+    DAO->>Singleton: obtener_conexion()
+    Singleton-->>DAO: sqlite3.Connection
+    DAO->>BD: SELECT WHERE username
+    BD-->>DAO: Row
+    DAO->>DAO: check_password_hash()
+    alt Contrasena OK
+        DAO->>DAO: generar token UUID
+        DAO->>BD: UPDATE session_token
+        BD-->>DAO: OK
+        DAO-->>Servicio: Usuario(id, username, token)
+        Servicio-->>Cliente: user Usuario
+    else Contrasena incorrecta
+        DAO-->>Servicio: None
+        Servicio-->>Cliente: error Credenciales invalidas
+    end
+```

notebooks/data/raw/ml-latest-small/README.txt

@@ -1,153 +0,0 @@
-Summary
-=======
-
-This dataset (ml-latest-small) describes 5-star rating and free-text tagging activity from [MovieLens](http://movielens.org), a movie recommendation service. It contains 100836 ratings and 3683 tag applications across 9742 movies. These data were created by 610 users between March 29, 1996 and September 24, 2018. This dataset was generated on September 26, 2018.
-
-Users were selected at random for inclusion. All selected users had rated at least 20 movies. No demographic information is included. Each user is represented by an id, and no other information is provided.
-
-The data are contained in the files `links.csv`, `movies.csv`, `ratings.csv` and `tags.csv`. More details about the contents and use of all these files follows.
-
-This is a *development* dataset. As such, it may change over time and is not an appropriate dataset for shared research results. See available *benchmark* datasets if that is your intent.
-
-This and other GroupLens data sets are publicly available for download at <http://grouplens.org/datasets/>.
-
-
-Usage License
-=============
-
-Neither the University of Minnesota nor any of the researchers involved can guarantee the correctness of the data, its suitability for any particular purpose, or the validity of results based on the use of the data set. The data set may be used for any research purposes under the following conditions:
-
-* The user may not state or imply any endorsement from the University of Minnesota or the GroupLens Research Group.
-* The user must acknowledge the use of the data set in publications resulting from the use of the data set (see below for citation information).
-* The user may redistribute the data set, including transformations, so long as it is distributed under these same license conditions.
-* The user may not use this information for any commercial or revenue-bearing purposes without first obtaining permission from a faculty member of the GroupLens Research Project at the University of Minnesota.
-* The executable software scripts are provided "as is" without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. The entire risk as to the quality and performance of them is with you. Should the program prove defective, you assume the cost of all necessary servicing, repair or correction.
-
-In no event shall the University of Minnesota, its affiliates or employees be liable to you for any damages arising out of the use or inability to use these programs (including but not limited to loss of data or data being rendered inaccurate).
-
-If you have any further questions or comments, please email <grouplens-info@umn.edu>
-
-
-Citation
-========
-
-To acknowledge use of the dataset in publications, please cite the following paper:
-
-> F. Maxwell Harper and Joseph A. Konstan. 2015. The MovieLens Datasets: History and Context. ACM Transactions on Interactive Intelligent Systems (TiiS) 5, 4: 19:1–19:19. <https://doi.org/10.1145/2827872>
-
-
-Further Information About GroupLens
-===================================
-
-GroupLens is a research group in the Department of Computer Science and Engineering at the University of Minnesota. Since its inception in 1992, GroupLens's research projects have explored a variety of fields including:
-
-* recommender systems
-* online communities
-* mobile and ubiquitious technologies
-* digital libraries
-* local geographic information systems
-
-GroupLens Research operates a movie recommender based on collaborative filtering, MovieLens, which is the source of these data. We encourage you to visit <http://movielens.org> to try it out! If you have exciting ideas for experimental work to conduct on MovieLens, send us an email at <grouplens-info@cs.umn.edu> - we are always interested in working with external collaborators.
-
-
-Content and Use of Files
-========================
-
-Formatting and Encoding
------------------------
-
-The dataset files are written as [comma-separated values](http://en.wikipedia.org/wiki/Comma-separated_values) files with a single header row. Columns that contain commas (`,`) are escaped using double-quotes (`"`). These files are encoded as UTF-8. If accented characters in movie titles or tag values (e.g. Misérables, Les (1995)) display incorrectly, make sure that any program reading the data, such as a text editor, terminal, or script, is configured for UTF-8.
-
-
-User Ids
---------
-
-MovieLens users were selected at random for inclusion. Their ids have been anonymized. User ids are consistent between `ratings.csv` and `tags.csv` (i.e., the same id refers to the same user across the two files).
-
-
-Movie Ids
----------
-
-Only movies with at least one rating or tag are included in the dataset. These movie ids are consistent with those used on the MovieLens web site (e.g., id `1` corresponds to the URL <https://movielens.org/movies/1>). Movie ids are consistent between `ratings.csv`, `tags.csv`, `movies.csv`, and `links.csv` (i.e., the same id refers to the same movie across these four data files).
-
-
-Ratings Data File Structure (ratings.csv)
------------------------------------------
-
-All ratings are contained in the file `ratings.csv`. Each line of this file after the header row represents one rating of one movie by one user, and has the following format:
-
-    userId,movieId,rating,timestamp
-
-The lines within this file are ordered first by userId, then, within user, by movieId.
-
-Ratings are made on a 5-star scale, with half-star increments (0.5 stars - 5.0 stars).
-
-Timestamps represent seconds since midnight Coordinated Universal Time (UTC) of January 1, 1970.
-
-
-Tags Data File Structure (tags.csv)
------------------------------------
-
-All tags are contained in the file `tags.csv`. Each line of this file after the header row represents one tag applied to one movie by one user, and has the following format:
-
-    userId,movieId,tag,timestamp
-
-The lines within this file are ordered first by userId, then, within user, by movieId.
-
-Tags are user-generated metadata about movies. Each tag is typically a single word or short phrase. The meaning, value, and purpose of a particular tag is determined by each user.
-
-Timestamps represent seconds since midnight Coordinated Universal Time (UTC) of January 1, 1970.
-
-
-Movies Data File Structure (movies.csv)
----------------------------------------
-
-Movie information is contained in the file `movies.csv`. Each line of this file after the header row represents one movie, and has the following format:
-
-    movieId,title,genres
-
-Movie titles are entered manually or imported from <https://www.themoviedb.org/>, and include the year of release in parentheses. Errors and inconsistencies may exist in these titles.
-
-Genres are a pipe-separated list, and are selected from the following:
-
-* Action
-* Adventure
-* Animation
-* Children's
-* Comedy
-* Crime
-* Documentary
-* Drama
-* Fantasy
-* Film-Noir
-* Horror
-* Musical
-* Mystery
-* Romance
-* Sci-Fi
-* Thriller
-* War
-* Western
-* (no genres listed)
-
-
-Links Data File Structure (links.csv)
----------------------------------------
-
-Identifiers that can be used to link to other sources of movie data are contained in the file `links.csv`. Each line of this file after the header row represents one movie, and has the following format:
-
-    movieId,imdbId,tmdbId
-
-movieId is an identifier for movies used by <https://movielens.org>. E.g., the movie Toy Story has the link <https://movielens.org/movies/1>.
-
-imdbId is an identifier for movies used by <http://www.imdb.com>. E.g., the movie Toy Story has the link <http://www.imdb.com/title/tt0114709/>.
-
-tmdbId is an identifier for movies used by <https://www.themoviedb.org>. E.g., the movie Toy Story has the link <https://www.themoviedb.org/movie/862>.
-
-Use of the resources listed above is subject to the terms of each provider.
-
-
-Cross-Validation
-----------------
-
-Prior versions of the MovieLens dataset included either pre-computed cross-folds or scripts to perform this computation. We no longer bundle either of these features with the dataset, since most modern toolkits provide this as a built-in feature. If you wish to learn about standard approaches to cross-fold computation in the context of recommender systems evaluation, see [LensKit](http://lenskit.org) for tools, documentation, and open-source code examples.

readme.txt

@@ -1,46 +0,0 @@
-Zona de comfort con la probabilidad de eleccion para cada genero. Ranking por probabilidad de eleccion 
-Distancia = dentro del ranking 
-Recomendar entre 3 y 5. Dentro de cada distnacia escojo las de mejor valoracion
-Umbral minimo de 40 de probabiliad de eleccion (un ou ms generos)
-
-Val del usuario --> Comparar vectores de recomendaciones de dos usuarios.  En sistemas normales
-
-Usar como dimension adicional. Podemos ver que peliculas en X estado emocional y da valoraciones positivas.
-Si ademas de eleccion podemos conocer la val y el estado emocional en el que se encuentra podemos establecer una nueva estrategia.
-
-
-
-
-
-
-
-
----------------
-
-Si una pelicula ya contiene géneros de la zona de confort se pone a d=0? Como se gestiona esto
---> Zona de confort no puede ser pertenece o no, grado de probabilidad, mirar porcentaje de pertenencia a la zona de confort. Elaborar distancias dentro de la zona de confort. 
-Intensidad d la emocion define porcentaje a aceptar d la zona de confort
-Grado de confort que quiero en funcion de polaridad y valencia de la emocion
-Hacer un percentil basado en la distancia de un arosal 0
-
-Version 2 ranking ms fino basado en considerar el arosal o la intensidad de laa emocion, percentil 
-
-Completar experimento personal
-
-Utilizar valoracion de recomendacion para sustituir nota global por ella cuando se obtenga
-
-
-FEITO DESDE A ANTERIOR REUNION:
-- en recomendar peliculas o ranking pasa de facerse segun conteo de generos a segun porcentaje sobre o total de peliculas
-e esto axuda a definir a zona de confort como os generos mais vistos que supoñan ms dun 40% de visionado do usuario (antes eran 2 mais vistos)
-- modificado recomendar_peliculas para ter un switch case en funcion d Version
--v1 pasa a recomendar solo si e positiva ou negativa se esta dentro ou fora de zona d confort (clasificacion binaria)
--v2, definense en emotion_service duas funcions (unha para calcular o arousal e outra para pasar a percentil)
-    - calculo arousal usase uns pesos predeterminados por emocion, calcula a polaridad do texto usando o que nos devolve a ia e se normaliza
-    - ese arousal pasase a un percentil, permitindo saber se a polaridad detectada é habitual no usuario ou non
-    - ahora a maior arousal maior se busca sair da zona de confort se a emocion e positiva (definese unha funcion de forma que o arousal fai que pondere ms) e ao reves se e negativa
-
--v3, pasamos de ver a lista de confort como un array de generos, ahora para cada pelicula hai un indice de confort entre 0 e 1.
-    - con percentil desde cero, aseguramos q nn se sempre se esta estresado nn se teña en conta
-    - se e positiva ou negativa, en funcion do arousal buscase un target de indice de confort a buscar nas peliculas
-    - calculase o score como a distancia entre o target e o indice de confort da pelicula

requirements.txt

@@ -7,6 +7,8 @@ python-dotenv==1.0.0
 # Modelo de emociones local (robertuito)
 transformers>=4.40.0
 torch>=2.1.0
+
+#Seguridad
 werkzeug>=2.3.0
 
 # Usadas en los Jupyter Notebooks