pietre/rss2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Preparar repositorio para despliegue: código fuente limpio

Browse source
This commit is contained in:
jlimolina 2026-01-23 02:00:40 +01:00
parent 866f5c432d
commit 3eca832c1a
76 changed files with 5434 additions and 3496 deletions
Download patch file Download diff file Expand all files Collapse all files

3
.dockerignore
View file

@ -1,8 +1,11 @@
.git
pgdata
pgdata-replica
pgdata-replica.old.*
pgdata.failed_restore
redis-data
hf_cache
qdrant_storage
venv
__pycache__

16
.gitignore vendored
View file

@ -51,6 +51,8 @@ data/
# Database backups
*.sql
!init-db/*.sql
!migrations/*.sql
backup_*.sql
# Redis backups
@ -62,3 +64,17 @@ qdrant_backup_*.tar.gz
# Docker compose with real credentials (if you create variations)
docker-compose.override.yml
# Large Language Models
models/llm/
# User Uploads
static/uploads/
# Celery/Workers
celerybeat-schedule
celerybeat.pid
# System/IDE
.DS_Store
Thumbs.db

53
Dockerfile.llm_worker Normal file
View file

@ -0,0 +1,53 @@
FROM nvidia/cuda:12.1.0-devel-ubuntu22.04
# Evitar prompts interactivos
ENV DEBIAN_FRONTEND=noninteractive
ENV PYTHONUNBUFFERED=1
# Instalar dependencias del sistema
RUN apt-get update && apt-get install -y \
python3.10 \
python3-pip \
git \
wget \
&& rm -rf /var/lib/apt/lists/*
# Crear directorio de trabajo
WORKDIR /app
# Actualizar pip
RUN pip3 install --upgrade pip setuptools wheel
# Instalar dependencias de PyTorch (CUDA 12.1)
RUN pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
# Instalar ExLlamaV2
RUN pip3 install exllamav2
# Instalar otras dependencias
RUN pip3 install \
psycopg2-binary \
huggingface-hub \
sentencepiece \
ninja
# Instalar python-is-python3 para compatibilidad
RUN apt-get update && apt-get install -y python-is-python3 && rm -rf /var/lib/apt/lists/*
# Copiar código del worker
COPY workers/llm_categorizer_worker.py /app/workers/llm_categorizer_worker.py
COPY workers/__init__.py /app/workers/__init__.py
# Crear directorios para modelos y cache
RUN mkdir -p /app/models/llm /app/hf_cache
# Variables de entorno
ENV HF_HOME=/app/hf_cache
ENV TRANSFORMERS_CACHE=/app/hf_cache
# Healthcheck opcional
HEALTHCHECK --interval=60s --timeout=10s --start-period=120s \
CMD python3 -c "import sys; sys.exit(0)" || exit 1
# Comando por defecto
CMD ["python3", "-m", "workers.llm_categorizer_worker"]

75
FUNCIONES_DE_ARCHIVOS.md Normal file
View file

@ -0,0 +1,75 @@
# Descripción de Archivos y Funciones del Proyecto RSS2
Este documento detalla la estructura del proyecto y la función de sus archivos principales.
## 🐳 Infraestructura y Despliegue
| Archivo / Directorio | Descripción |
|----------------------|-------------|
| `docker-compose.yml` | **Orquestador principal**. Define todos los servicios (db, web, workers, redis, qdrant, etc.), redes, volúmenes de persistencia y configuración de recursos. |
| `Dockerfile` | Definición de la imagen base para la aplicación web y la mayoría de los workers en Python. |
| `Dockerfile.llm_worker` | Imagen específica para el worker de LLM, incluye dependencias de CUDA y PyTorch para ExLlamaV2. |
| `Dockerfile.url_worker` | Imagen optimizada para el worker de descubrimiento y procesamiento de URLs. |
| `nginx.conf` | Configuración del servidor web Nginx que actúa como proxy inverso y servidos de archivos estáticos. |
| `.env` | Variables de entorno con credenciales y configuración sensible (NO compartir). |
| `gunicorn_config.py` | Configuración del servidor de aplicaciones WSGI Gunicorn para producción. |
## 🧠 Núcleo de la Aplicación (Python)
| Archivo | Descripción |
|---------|-------------|
| `app.py` | **Punto de entrada**. Inicializa la aplicación Flask, registra blueprints (rutas) y configura extensiones. |
| `config.py` | Carga y valida la configuración desde variables de entorno. Define constantes globales. |
| `db.py` | Gestión de la conexión a la base de datos PostgreSQL (pool de conexiones). |
| `cache.py` | Capa de abstracción para Redis. Maneja caché de respuestas y estados transitorios. |
| `scheduler.py` | Planificador de tareas periódicas (cron jobs internos) para mantenimiento y disparadores. |
| `requirements.txt` | Lista de dependencias de Python necesarias para el proyecto. |
## 👷 Workers (Procesamiento en Segundo Plano)
Ubicados en `workers/`:
| Archivo | Función |
|---------|---------|
| `llm_categorizer_worker.py` | Categoriza noticias usando un LLM local (Mistral/ExLlamaV2). Asigna etiquetas temáticas. |
| `url_worker_daemon.py` | Procesa y valida URLs extraídas, gestionando la cola de descargas. |
| `url_discovery_worker.py` | Busca nuevos feeds RSS a partir de las URLs base. |
| `translation_worker.py` | Traduce contenido usando modelos NLLB (No Language Left Behind). |
| `embeddings_worker.py` | Genera vectores semánticos para búsqueda y clustering. |
| `cluster_worker.py` | Agrupa noticias similares en "historias" o eventos. |
| `ner_worker.py` | Extracción de Entidades Nombradas (personas, organizaciones, lugares). |
| `topics_worker.py` | Identifica y extrae tópicos principales de los textos. |
| `qdrant_worker.py` | Sincroniza los vectores generados con la base de datos vectorial Qdrant. |
## 🌐 API y Rutas
Ubicados en `routers/`:
| Archivo | Descripción |
|---------|-------------|
| `api.py` | Endpoints generales de la API REST. |
| `feeds.py` | Gestión de fuentes RSS (CRUD). |
| `news.py` | Endpoints para listar y filtrar noticias. |
| `dashboard.py` | Rutas para el panel de administración y estadísticas. |
| `auth.py` | Manejo de autenticación y autorización. |
| `search.py` | Endpoints para búsqueda semántica y tradicional. |
## 🛠️ Herramientas y Scripts
| Archivo | Descripción |
|---------|-------------|
| `scripts/download_llm_model.sh` | Script para descargar modelos LLM cuantizados desde HuggingFace de forma segura. |
| `verify_security.sh` | Auditoría de seguridad automatizada (verifica permisos, configuración TLS, etc.). |
| `generate_secure_credentials.sh` | Genera contraseñas seguras y configura el entorno inicial. |
| `rss-ingestor-go/` | Ingestor de RSS de alto rendimiento escrito en Go. |
## 📂 Directorios de Datos
| Directorio | Contenido |
|------------|-----------|
| `models/` | Almacenamiento persistente de modelos de IA (LLMs, Embeddings, Traducción). |
| `pgdata/` | Persistencia de la base de datos PostgreSQL. |
| `qdrant_storage/` | Persistencia de la base de datos vectorial Qdrant. |
| `hf_cache/` | Caché de HuggingFace para modelos y tokenizers. |
| `templates/` | Plantillas HTML (Jinja2) para la interfaz web. |
| `static/` | Archivos CSS, JS e imágenes públicas. |

401
IMPLEMENTACION_LLM_RESUMEN.md Normal file
View file

@ -0,0 +1,401 @@
# 📊 Resumen de Implementación - Sistema LLM Categorizer
**Fecha**: 2026-01-20
**Estado**: ✅ Completado
---
## ✅ Tareas Completadas
### 1. Revisión y Levantamiento de la Aplicación
- ✓ Aplicación RSS2 levantada exitosamente
- ✓ Todos los 22 contenedores funcionando correctamente
- ✓ Web accesible en http://localhost:8001 (HTTP 200)
- ✓ Base de datos operativa con **853,118 noticias**
- ✓ **7,666 feeds** registrados (**1,695 activos**)
### 2. Implementación del Sistema LLM Categorizer
Se ha creado un sistema completo de categorización automática que:
- Toma **10 noticias** del feed simultáneamente
- Las envía a un **LLM local** (ExLlamaV2)
- El LLM **discrimina/categoriza** cada noticia automáticamente
- Actualiza la base de datos con las categorías asignadas
#### Archivos Creados:
```
/home/x/rss2/
├── workers/
│ └── llm_categorizer_worker.py ✓ Worker principal (440 líneas)
├── Dockerfile.llm_worker ✓ Dockerfile con CUDA + ExLlamaV2
├── docker-compose.yml ✓ Actualizado con servicio LLM
├── scripts/
│ ├── download_llm_model.sh ✓ Script de descarga de modelos
│ └── test_llm_categorizer.py ✓ Script de prueba
├── docs/
│ └── LLM_CATEGORIZER.md ✓ Documentación completa
├── QUICKSTART_LLM.md ✓ Guía rápida
└── README.md ✓ Actualizado
```
---
## 🤖 Características del Sistema
### Modelo Recomendado
**Mistral-7B-Instruct-v0.2 (GPTQ 4-bit)**
- Optimizado para RTX 3060 12GB
- Tamaño: ~4.5 GB
- VRAM: ~6-7 GB
- Rendimiento: 120-300 noticias/hora
### Alternativas Disponibles
1. Mistral-7B-Instruct-v0.2 (EXL2 4.0bpw) - Más rápido
2. OpenHermes-2.5-Mistral-7B (GPTQ) - Mejor generalista
3. Neural-Chat-7B (GPTQ) - Bueno para español
### Categorías Predefinidas
El sistema clasifica en **15 categorías**:
- Política
- Economía
- Tecnología
- Ciencia
- Salud
- Deportes
- Entretenimiento
- Internacional
- Nacional
- Sociedad
- Cultura
- Medio Ambiente
- Educación
- Seguridad
- Otros
---
## 🔧 Configuración Técnica
### Servicio Docker
```yaml
llm-categorizer:
container: rss2_llm_categorizer
GPU: NVIDIA (1 GPU asignada)
Memoria: 10GB límite
Modelo: ExLlamaV2
Backend: CUDA 12.1
```
### Variables de Entorno
| Variable | Valor | Descripción |
|----------|-------|-------------|
| `LLM_BATCH_SIZE` | 10 | Noticias por lote |
| `LLM_SLEEP_IDLE` | 30s | Espera entre lotes |
| `LLM_MAX_SEQ_LEN` | 4096 | Longitud máxima de contexto |
| `LLM_CACHE_MODE` | FP16 | Modo de caché (FP16/Q4) |
| `LLM_GPU_SPLIT` | auto | Distribución de GPU |
### Base de Datos
Se añadieron automáticamente 4 columnas nuevas a `noticias`:
| Columna | Tipo | Descripción |
|---------|------|-------------|
| `llm_categoria` | VARCHAR(100) | Categoría asignada |
| `llm_confianza` | FLOAT | Nivel de confianza (0.0-1.0) |
| `llm_processed` | BOOLEAN | Si fue procesada |
| `llm_processed_at` | TIMESTAMP | Fecha de procesamiento |
---
## 📈 Rendimiento Estimado
### Con RTX 3060 12GB
- **VRAM utilizada**: ~6-7 GB
- **Tiempo por noticia**: 2-5 segundos
- **Throughput**: 120-300 noticias/hora
- **Precisión esperada**: 85-90%
### Procesamiento Total
Con **853,118 noticias** en la BD:
- **Tiempo estimado**: 47-118 horas (2-5 días continuos)
- **Modo 24/7**: El worker procesa automáticamente
- **Control**: Puedes detener/reiniciar en cualquier momento
---
## 🚀 Próximos Pasos
### 1. Descargar el Modelo (OBLIGATORIO)
```bash
cd /home/x/rss2
./scripts/download_llm_model.sh
```
Selecciona **opción 1** (Mistral-7B-Instruct GPTQ)
⏱️ Tiempo: 10-30 minutos
💾 Espacio: 4.5 GB
### 2. Probar el Sistema (Recomendado)
```bash
# Instalar dependencias
pip3 install exllamav2 torch
# Ejecutar prueba
python3 scripts/test_llm_categorizer.py
```
Esto prueba el modelo ANTES de levantar Docker.
### 3. Levantar el Servicio
```bash
# Construir y levantar
docker compose up -d --build llm-categorizer
# Ver logs
docker compose logs -f llm-categorizer
```
**Primera carga**: 2-5 minutos cargando modelo en GPU
### 4. Monitorear
```bash
# Ver estado
docker compose ps llm-categorizer
# Ver categorías asignadas
docker exec -it rss2_db psql -U rss -d rss -c \
"SELECT llm_categoria, COUNT(*) FROM noticias WHERE llm_processed = TRUE GROUP BY llm_categoria;"
# Ver progreso
docker exec -it rss2_db psql -U rss -d rss -c \
"SELECT COUNT(*) as procesadas,
(COUNT(*)::float / 853118 * 100)::numeric(5,2) as porcentaje
FROM noticias WHERE llm_processed = TRUE;"
```
---
## 📚 Documentación
### Guías Disponibles
1. **QUICKSTART_LLM.md** - Guía rápida de inicio
2. **docs/LLM_CATEGORIZER.md** - Documentación completa
3. **README.md** - Visión general actualizada
### Comandos Útiles
```bash
# Ver logs en vivo
docker compose logs -f llm-categorizer
# Reiniciar servicio
docker compose restart llm-categorizer
# Detener servicio
docker compose stop llm-categorizer
# Ver uso de GPU
nvidia-smi
# Ver todas las tablas
docker exec -it rss2_db psql -U rss -d rss -c "\dt"
```
---
## 🔍 Consultas SQL Útiles
### Distribución de categorías
```sql
SELECT llm_categoria, COUNT(*) as total,
AVG(llm_confianza) as confianza_media
FROM noticias
WHERE llm_processed = TRUE
GROUP BY llm_categoria
ORDER BY total DESC;
```
### Progreso de procesamiento
```sql
SELECT
COUNT(CASE WHEN llm_processed = TRUE THEN 1 END) as procesadas,
COUNT(CASE WHEN llm_processed = FALSE THEN 1 END) as pendientes,
(COUNT(CASE WHEN llm_processed = TRUE THEN 1 END)::float / COUNT(*) * 100)::numeric(5,2) as porcentaje
FROM noticias;
```
### Noticias por categoría (últimas)
```sql
SELECT titulo, llm_categoria, llm_confianza, fecha
FROM noticias
WHERE llm_categoria = 'Tecnología'
AND llm_processed = TRUE
ORDER BY fecha DESC
LIMIT 10;
```
### Resetear para reprocesar
```sql
-- Resetear últimas 100 noticias
UPDATE noticias
SET llm_processed = FALSE
WHERE id IN (
SELECT id FROM noticias
WHERE llm_processed = TRUE
ORDER BY fecha DESC
LIMIT 100
);
```
---
## ⚠️ Troubleshooting
### Problema: Out of Memory
**Solución**: Reducir batch size y usar cache Q4
```yaml
# En docker-compose.yml
environment:
LLM_BATCH_SIZE: 5
LLM_CACHE_MODE: Q4
```
### Problema: Modelo no encontrado
**Solución**: Verificar descarga
```bash
ls -la /home/x/rss2/models/llm/
# Debe contener: config.json, model.safetensors, etc.
```
### Problema: No procesa noticias
**Solución**: Verificar si hay noticias pendientes
```bash
docker exec -it rss2_db psql -U rss -d rss -c \
"SELECT COUNT(*) FROM noticias WHERE llm_processed = FALSE;"
```
---
## 🎯 Ventajas del Sistema
✅ **100% Local**: Sin envío de datos a APIs externas
✅ **Alta Precisión**: LLM entiende contexto, no solo keywords
✅ **Automático**: Procesamiento continuo en background
✅ **Escalable**: Procesa 10 noticias por lote eficientemente
✅ **Integrado**: Worker nativo del ecosistema RSS2
✅ **Optimizado**: Específico para RTX 3060 12GB
✅ **Extensible**: Fácil añadir nuevas categorías
✅ **Monitoreable**: Logs detallados y métricas en BD
---
## 📊 Estado de Feeds
### Estadísticas Actuales
- **Total de feeds**: 7,666
- **Feeds activos**: 1,695 (22%)
- **Total de noticias**: 853,118
- **Noticias sin categorizar (LLM)**: 853,118 (100%)
### Recomendación
Considera **reevaluar los feeds inactivos**:
```sql
-- Ver feeds inactivos con errores
SELECT nombre, url, fallos, last_error
FROM feeds
WHERE activo = FALSE
ORDER BY fallos DESC
LIMIT 20;
-- Reactivar feeds con pocos fallos
UPDATE feeds
SET activo = TRUE, fallos = 0
WHERE activo = FALSE AND fallos < 5;
```
---
## 🔮 Mejoras Futuras Sugeridas
1. **Subcategorías automáticas** - Categorización más granular
2. **Resúmenes por categoría** - Generar resúmenes diarios
3. **Trending topics** - Detectar temas de moda por categoría
4. **Alertas personalizadas** - Notificar por categorías de interés
5. **Fine-tuning del modelo** - Entrenar con feedback de usuario
6. **API REST** - Endpoint para categorización bajo demanda
7. **Dashboard web** - Visualización de categorías en tiempo real
---
## 📞 Soporte
### Logs
```bash
docker compose logs llm-categorizer
```
### GPU
```bash
nvidia-smi
watch -n 1 nvidia-smi # Monitoreo en vivo
```
### Base de Datos
```bash
docker exec -it rss2_db psql -U rss -d rss
```
---
## ✨ Conclusión
El sistema LLM Categorizer está **completamente implementado y listo para usar**.
Solo necesitas:
1. ✅ Descargar el modelo (~15 min)
2. ✅ Levantar el servicio (1 comando)
3. ✅ Monitorear el progreso
**Resultado**: Categorización automática e inteligente de todas las noticias del sistema.
---
**Implementado por**: Antigravity AI
**Fecha**: 2026-01-20
**Versión**: 1.0
**Estado**: ✅ Producción

145
NEWSPAPER_STYLE_GUIDE.md Normal file
View file

@ -0,0 +1,145 @@
# Diseño Periodístico Clásico - El Observador
## 🎨 Transformación Visual Completa
La aplicación ha sido completamente rediseñada con un **estilo periodístico clásico** inspirado en los mejores periódicos del mundo:
- **The New York Times** (estructura y jerarquía)
- **El País** (elementos visuales españoles)
- **The Guardian** (claridad tipográfica)
## ✨ Características Implementadas
### 1. Tipografía Periodística
- **Titulares**: Old Standard TT & Playfair Display (serif clásico)
- **Cuerpo**: Merriweather (serif legible para lectura larga)
- **UI/Navegación**: Lato (sans-serif limpio y moderno)
### 2. Paleta de Colores Clásica
- **Tinta Negra** (#1a1a1a): Texto principal con peso y autoridad
- **Papel Blanco** (#ffffff): Fondo limpio y profesional
- **Papel Crema** (#f9f7f4): Fondo general con calidez
- **Rojo Acento** (#c1121f): Color institucional para destacados
- **Azul Enlaces** (#326891): Enlaces legibles y tradicionales
### 3. Elementos de Diseño Periodístico
- ✅ Cabecera con nombre en mayúsculas y bordes dobles
- ✅ Fecha y hora actualizadas en tiempo real (Estilo Madrid)
- ✅ Navegación sticky negra con bordes rojos
- ✅ Tarjetas de noticias con bordes sutiles
- ✅ Tipografía jerárquica (títulos grandes, meta pequeña)
- ✅ Hover effects suaves y profesionales
- ✅ Badges de categoría en rojo institucional
- ✅ Layout responsive adaptado a móviles
### 4. Página de Artículos
- 📰 Breadcrumbs para navegación
- 📰 Título prominente con tipografía serif
- 📰 Metadata periodística (fuente, fecha, país, categoría)
- 📰 Resumen destacado con borde rojo
- 📰 Sidebar con artículos relacionados
- 📰 Modo lectura inmersivo
- 📰 Botones de compartir, PDF y favoritos
### 5. Funcionalidades
- **Modo Lectura**: Aumenta fuente y elimina distracciones
- **Modo Oscuro**: Tema completamente adaptado
- **Responsive**: Diseño adaptado para móvil, tablet y desktop
- **Animaciones**: Transiciones suaves y profesionales
- **Accesibilidad**: Contraste adecuado y jerarquía clara
## 📱 Responsive Design
- **Desktop (>968px)**: Layout completo con sidebar
- **Tablet (768px-968px)**: Grid adaptado en 2 columnas
- **Mobile (<768px)**: Una columna, menú de hamburguesa
## 🌓 Modo Oscuro
Paleta invertida manteniendo la estética:
- Fondo oscuro (#0f0f0f)
- Texto claro (#e0e0e0)
- Acento rojo más brillante (#ff4444)
- Bordes sutiles (#333)
## 🎯 Mejoras de UX
1. **Historial de Lectura**: Artículos leídos aparecen con opacidad reducida
2. **Favoritos Persistentes**: Sistema de guardado con estrellas
3. **Búsqueda Avanzada**: Filtros por categoría, país, fecha
4. **Búsqueda Semántica IA**: Toggle para búsqueda inteligente
5. **Notificaciones**: Sistema de alertas para nuevas noticias
6. **Paginación Clara**: Navegación entre páginas de noticias
## 📂 Archivos Modificados
- `static/style.css` - CSS completamente reescrito (1300+ líneas)
- `templates/base.html` - Actualizado con nuevas fuentes y nombre
- `templates/noticia_classic.html` - Template de detalle mejorado
- `templates/_noticias_list.html` - Cards de noticias (sin cambios necesarios)
## 🚀 Activación
Los cambios están **activos automáticamente** después de reiniciar nginx:
```bash
docker compose restart nginx
```
## 🎨 Paleta de Colores Completa
```css
--ink-black: #1a1a1a /* Texto principal */
--newspaper-gray: #333333 /* Texto secundario */
--paper-white: #ffffff /* Fondo de tarjetas */
--paper-cream: #f9f7f4 /* Fondo general */
--border-gray: #d1d1d1 /* Bordes */
--accent-red: #c1121f /* Acento principal */
--accent-red-dark: #9a0e1a /* Acento hover */
--link-blue: #326891 /* Enlaces */
--text-gray: #4a4a4a /* Meta información */
--light-gray: #f0f0f0 /* Fondos sutiles */
```
## 💡 Inspiración de Diseño
El diseño sigue los principios de los mejores periódicos:
1. **Jerarquía Clara**: Los títulos dominan visualmente
2. **Espacios en Blanco**: El contenido respira
3. **Legibilidad**: Fuentes serif para lectura larga
4. **Profesionalismo**: Colores sobrios y clásicos
5. **Credibilidad**: Diseño serio y confiable
## 🔄 Migración desde Diseño Anterior
El diseño anterior era moderno con:
- Glassmorphism
- Gradientes animados
- Colores vibrantes (púrpura, rosa, azul)
- Fuentes sans-serif (Poppins, Roboto)
El nuevo diseño es periodístico con:
- Fondos sólidos
- Colores clásicos (blanco, negro, rojo)
- Tipografía serif tradicional
- Bordes definidos
## ✅ Testing Recomendado
1. ✓ Verificar que el header muestra "EL OBSERVADOR"
2. ✓ Comprobar que las fuentes serif se carguen correctamente
3. ✓ Probar el modo oscuro (botón luna/sol)
4. ✓ Verificar responsive en móvil
5. ✓ Probar funcionalidades (favoritos, búsqueda, filtros)
6. ✓ Verificar que las imágenes de noticias se vean bien
7. ✓ Comprobar paginación
8. ✓ Probar modo lectura en artículos
## 👨‍💻 Créditos
Diseño creado siguiendo las mejores prácticas de diseño periodístico digital, manteniendo toda la funcionalidad existente del agregador de noticias RSS.
---
**Fecha de Actualización**: Enero 2026
**Versión**: 2.0 - Diseño Periodístico Clásico

269
QUICKSTART_LLM.md Normal file
View file

@ -0,0 +1,269 @@
# 🚀 Guía Rápida: Sistema LLM Categorizer
## ✅ Estado Actual
- ✓ Aplicación RSS2 levantada y funcionando correctamente
- ✓ Todos los contenedores están operativos
- ✓ Web accesible en http://localhost:8001
- ✓ Nuevo sistema LLM Categorizer creado y configurado
## 📋 Próximos Pasos
### 1. Descargar el Modelo LLM (REQUERIDO)
```bash
cd /home/x/rss2
./scripts/download_llm_model.sh
```
**Selecciona la opción 1** (Mistral-7B-Instruct-v0.2 GPTQ) - Recomendado para RTX 3060 12GB
⏱️ **Tiempo estimado**: 10-30 minutos según tu conexión
💾 **Espacio necesario**: ~4.5 GB
### 2. Probar el Sistema (OPCIONAL pero recomendado)
```bash
# Instalar dependencias para prueba local
pip3 install exllamav2 torch
# Ejecutar prueba
python3 scripts/test_llm_categorizer.py
```
Esto te permite verificar que el modelo funciona ANTES de levantar el contenedor.
### 3. Levantar el Servicio LLM
```bash
# Construir y levantar el contenedor
docker compose up -d --build llm-categorizer
# Monitorear los logs
docker compose logs -f llm-categorizer
```
**Primera ejecución**: El contenedor tardará 2-5 minutos en cargar el modelo en GPU.
### 4. Verificar Funcionamiento
```bash
# Ver estado
docker compose ps llm-categorizer
# Ver últimas categorizaciones
docker exec -it rss2_db psql -U rss -d rss -c \
"SELECT llm_categoria, COUNT(*) FROM noticias WHERE llm_processed = TRUE GROUP BY llm_categoria;"
```
---
## 🔧 Configuración
### Archivos Creados
```
/home/x/rss2/
├── workers/
│ └── llm_categorizer_worker.py # Worker principal
├── Dockerfile.llm_worker # Dockerfile específico
├── scripts/
│ ├── download_llm_model.sh # Descarga del modelo
│ └── test_llm_categorizer.py # Script de prueba
├── docs/
│ └── LLM_CATEGORIZER.md # Documentación completa
└── docker-compose.yml # Actualizado con servicio llm-categorizer
```
### Servicio en docker-compose.yml
```yaml
llm-categorizer:
build:
context: .
dockerfile: Dockerfile.llm_worker
environment:
LLM_BATCH_SIZE: 10 # Noticias por lote
LLM_SLEEP_IDLE: 30 # Segundos entre lotes
LLM_MODEL_PATH: /app/models/llm
deploy:
resources:
limits:
memory: 10G
reservations:
devices:
- driver: nvidia
count: 1
capabilities: [ gpu ]
```
---
## 🎯 Cómo Funciona
1. **Recopilación**: El worker consulta la BD y obtiene 10 noticias sin categorizar
2. **Procesamiento**: Envía cada noticia al LLM local (Mistral-7B)
3. **Categorización**: El LLM determina la categoría más apropiada
4. **Actualización**: Guarda la categoría y confianza en la BD
5. **Loop**: Repite el proceso continuamente
### Categorías Disponibles
- Política
- Economía
- Tecnología
- Ciencia
- Salud
- Deportes
- Entretenimiento
- Internacional
- Nacional
- Sociedad
- Cultura
- Medio Ambiente
- Educación
- Seguridad
- Otros
---
## 📊 Rendimiento Esperado
### Con RTX 3060 12GB + Mistral-7B GPTQ
- **VRAM utilizada**: ~6-7 GB
- **Tiempo por noticia**: 2-5 segundos
- **Throughput**: ~120-300 noticias/hora
- **Precisión**: ~85-90% (depende del contenido)
---
## 🔍 Consultas SQL Útiles
### Ver distribución de categorías
```sql
SELECT llm_categoria, COUNT(*) as total,
AVG(llm_confianza) as confianza_media
FROM noticias
WHERE llm_processed = TRUE
GROUP BY llm_categoria
ORDER BY total DESC;
```
### Ver noticias de una categoría
```sql
SELECT titulo, llm_categoria, llm_confianza, fecha
FROM noticias
WHERE llm_categoria = 'Tecnología'
AND llm_processed = TRUE
ORDER BY fecha DESC
LIMIT 20;
```
### Resetear procesamiento (para reprocesar)
```sql
-- Resetear últimas 100 noticias
UPDATE noticias
SET llm_processed = FALSE
WHERE id IN (
SELECT id FROM noticias
ORDER BY fecha DESC
LIMIT 100
);
```
---
## 🐛 Troubleshooting Rápido
### ❌ "Out of memory"
```yaml
# Reducir batch size en docker-compose.yml
LLM_BATCH_SIZE: 5
LLM_CACHE_MODE: Q4
```
### ❌ "Model not found"
```bash
# Verificar descarga
ls -la models/llm/
# Re-descargar si necesario
./scripts/download_llm_model.sh
```
### ❌ No procesa noticias
```bash
# Verificar cuántas faltan
docker exec -it rss2_db psql -U rss -d rss -c \
"SELECT COUNT(*) FROM noticias WHERE llm_processed = FALSE;"
# Resetear algunas para probar
docker exec -it rss2_db psql -U rss -d rss -c \
"UPDATE noticias SET llm_processed = FALSE LIMIT 20;"
```
---
## 📚 Documentación Completa
Para más detalles, consulta:
```bash
cat docs/LLM_CATEGORIZER.md
```
O abre: `/home/x/rss2/docs/LLM_CATEGORIZER.md`
---
## 🎓 Comandos Útiles
```bash
# Ver todos los servicios
docker compose ps
# Reiniciar solo el LLM
docker compose restart llm-categorizer
# Ver uso de GPU
nvidia-smi
# Ver logs + seguir
docker compose logs -f llm-categorizer
# Detener el LLM
docker compose stop llm-categorizer
# Eliminar completamente (rebuild desde cero)
docker compose down llm-categorizer
docker compose up -d --build llm-categorizer
```
---
## ⚡ Optimizaciones Futuras
Si quieres mejorar el rendimiento:
1. **Usar EXL2 en lugar de GPTQ** (más rápido en ExLlamaV2)
2. **Aumentar batch size** si sobra VRAM
3. **Fine-tune el modelo** con tus propias categorizaciones
4. **Usar vLLM** para servidor de inferencia más eficiente
---
## 🤝 Soporte
Si encuentras problemas:
1. Revisa logs: `docker compose logs llm-categorizer`
2. Consulta documentación: `docs/LLM_CATEGORIZER.md`
3. Verifica GPU: `nvidia-smi`
---
**¡Listo!** El sistema está completamente configurado. Solo falta descargar el modelo y levantarlo. 🚀

32
README.md
View file

@ -30,6 +30,7 @@ Estos workers procesan asíncronamente la información utilizando modelos locale
| **`embeddings`** | **Vectorización** | `Sentence-Transformers`. Convierte texto en vectores matemáticos para búsqueda semántica. |
| **`ner`** | **Entidades** | Modelos SpaCy/Bert. Extrae Personas, Organizaciones y Lugares. |
| **`topics`** | **Clasificación** | Clasifica noticias en temas (Política, Economía, Tecnología, etc.). |
| **`llm-categorizer`** | **Categorización Inteligente** | `ExLlamaV2 + Mistral-7B`. Categoriza noticias usando LLM local. Procesa 10 noticias por lote. |
| **`cluster`** | **Agrupación** | Agrupa noticias sobre el mismo evento de diferentes fuentes. |
| **`related`** | **Relaciones** | Calcula y enlaza noticias relacionadas temporal y contextualmente. |
@ -89,6 +90,37 @@ Utiliza el script de arranque que verifica dependencias y levanta el stack:
---
## 🔒 Seguridad y Credenciales (¡IMPORTANTE!)
El sistema viene protegido por defecto. **No existen contraseñas "hardcodeadas"**; todas se generan dinámicamente o se leen del entorno.
### 🔑 Generación de Claves
Al ejecutar `./generate_secure_credentials.sh`, el sistema crea un archivo `.env` que contiene:
1. **`GRAFANA_PASSWORD`**: Contraseña para el usuario `admin` en Grafana.
2. **`POSTGRES_PASSWORD`**: Contraseña maestra para la base de datos `rss`.
3. **`REDIS_PASSWORD`**: Clave de autenticación para Redis.
4. **`SECRET_KEY`**: Llave criptográfica para sesiones y tokens de seguridad.
**⚠️ Atención:** Si no ejecutas el script, el sistema intentará usar valores por defecto inseguros (ej. `change_this_password`) definidos en `.env.example`. **No uses esto en producción.**
### 🛡️ Niveles de Acceso
1. **Red Pública (Internet) -> Puerto 8001**:
* Solo acceso a **Nginx** (Frontend).
* Protegido por las reglas de firewall de tu servidor.
2. **Red Local (Localhost) -> Puerto 3001**:
* Acceso a **Grafana**.
* **Login**: Usuario `admin` / Password: Ver `GRAFANA_PASSWORD` en tu archivo `.env`.
3. **Red Interna (Docker Backend)**:
* Base de datos, Redis y Qdrant **NO** están expuestos fuera de Docker.
* **Acceso a DB**: Solo posible vía `docker exec` (ver abajo).
### 📋 Auditoría
El repositorio incluye herramientas para verificar la seguridad:
* `./verify_security.sh`: Ejecuta un escaneo de puertos y configuraciones.
* `SECURITY_GUIDE.md`: Manual avanzado de administración segura.
---
## <20>️ Operaciones Comunes
### Ver logs en tiempo real

4
app.py
View file

@ -8,12 +8,10 @@ from routers.feeds import feeds_bp
from routers.urls import urls_bp
from routers.noticia import noticia_bp
from routers.backup import backup_bp
# from routers.eventos import eventos_bp
from routers.config import config_bp
from routers.favoritos import favoritos_bp
from routers.search import search_bp
from routers.rss import rss_bp
from routers.resumen import resumen_bp
from routers.stats import stats_bp
from routers.pdf import pdf_bp
from routers.notifications import notifications_bp
@ -35,12 +33,10 @@ def create_app() -> Flask:
app.register_blueprint(urls_bp)
app.register_blueprint(noticia_bp)
app.register_blueprint(backup_bp)
# app.register_blueprint(eventos_bp) # Removed
app.register_blueprint(config_bp)
app.register_blueprint(favoritos_bp)
app.register_blueprint(search_bp)
app.register_blueprint(rss_bp)
# app.register_blueprint(resumen_bp) # Removed
app.register_blueprint(stats_bp)
app.register_blueprint(pdf_bp)
app.register_blueprint(notifications_bp)

31
cache.py
View file

@ -6,37 +6,48 @@ import redis
import json
import logging
import hashlib
import time
from functools import wraps
from config import REDIS_HOST, REDIS_PORT, REDIS_PASSWORD, REDIS_TTL_DEFAULT
logger = logging.getLogger(__name__)
_redis_client = None
_redis_last_fail = 0
def get_redis():
"""Get Redis client singleton."""
global _redis_client
if _redis_client is None:
"""Get Redis client singleton with failure backoff."""
global _redis_client, _redis_last_fail
if _redis_client is not None:
return _redis_client
# Prevent retrying too often if it's failing (60s backoff)
now = time.time()
if now - _redis_last_fail < 60:
return None
try:
redis_config = {
'host': REDIS_HOST,
'port': REDIS_PORT,
'decode_responses': True,
'socket_connect_timeout': 2,
'socket_timeout': 2
'socket_connect_timeout': 1, # Faster timeout
'socket_timeout': 1
}
# Agregar autenticación si está configurada
if REDIS_PASSWORD:
redis_config['password'] = REDIS_PASSWORD
_redis_client = redis.Redis(**redis_config)
_redis_client.ping()
except redis.ConnectionError as e:
logger.warning(f"Redis connection failed: {e}. Caching disabled.")
_redis_client = None
_redis_last_fail = 0
return _redis_client
except Exception as e:
logger.warning(f"Redis connection failed: {e}. Caching disabled for 60s.")
_redis_client = None
_redis_last_fail = now
return None
def cached(ttl_seconds=None, prefix="cache"):

61
docker-compose.yml
View file

@ -237,37 +237,6 @@ services:
cpus: '1'
memory: 1G
# rss-web-go deshabilitado por duplicar funcionalidad
# Si es necesario, habilitar pero SIN exposición de puertos
# rss-web-go:
# build:
# context: ./rss-web-go
# dockerfile: Dockerfile
# container_name: rss2_web_go
# # SEGURIDAD: Sin exposición de puertos - solo acceso interno
# # ports:
# # - "8002:8001"
# environment:
# - DB_HOST=db
# - DB_PORT=5432
# - DB_NAME=${DB_NAME:-rss}
# - DB_USER=${DB_USER:-rss}
# - DB_PASS=${DB_PASS}
# - REDIS_HOST=redis
# - REDIS_PORT=6379
# - REDIS_PASSWORD=${REDIS_PASSWORD}
# - PORT=8001
# - TZ=Europe/Madrid
# volumes:
# - ./static:/root/static:ro
# - ./templates:/root/templates:ro
# networks:
# - backend
# depends_on:
# db:
# condition: service_healthy
# restart: unless-stopped
rss2_web:
build: .
container_name: rss2_web
@ -328,6 +297,10 @@ services:
memory: 8G
reservations:
memory: 4G
devices:
- driver: nvidia
count: 1
capabilities: [ gpu ]
nginx:
image: nginx:alpine
@ -620,6 +593,31 @@ services:
cpus: '1'
memory: 1G
llm-categorizer:
build: .
container_name: rss2_llm_categorizer
command: bash -lc "python -m workers.simple_categorizer_worker"
environment:
DB_HOST: db
DB_PORT: 5432
DB_NAME: ${DB_NAME:-rss}
DB_USER: ${DB_USER:-rss}
DB_PASS: ${DB_PASS}
CATEGORIZER_BATCH_SIZE: 10
CATEGORIZER_SLEEP_IDLE: 5
TZ: Europe/Madrid
networks:
- backend
depends_on:
db:
condition: service_healthy
restart: unless-stopped
deploy:
resources:
limits:
cpus: '2'
memory: 1G
qdrant:
image: qdrant/qdrant:latest
container_name: rss2_qdrant
@ -788,3 +786,4 @@ networks:
volumes:
prometheus_data:
grafana_data:
torch_extensions:

370
docs/LLM_CATEGORIZER.md Normal file
View file

@ -0,0 +1,370 @@
# Sistema de Categorización Automática con LLM
## Descripción
Este sistema utiliza **ExLlamaV2** con un modelo de lenguaje local (LLM) para categorizar automáticamente las noticias del feed RSS.
### ¿Qué hace?
1. **Recopila 10 noticias** sin categorizar de la base de datos
2. **Envía al LLM local** con un prompt especializado
3. **El LLM discrimina/categoriza** cada noticia en una de las categorías predefinidas
4. **Actualiza la base de datos** con las categorías asignadas
### Ventajas
- ✅ **100% Local**: No envía datos a APIs externas
- ✅ **Optimizado para RTX 3060 12GB**: Modelos cuantizados eficientes
- ✅ **Categorización inteligente**: Entiende contexto, no solo keywords
- ✅ **Escalable**: Procesa lotes de 10 noticias automáticamente
- ✅ **Integrado**: Se ejecuta como un worker más del sistema
---
## Instalación
### Paso 1: Descargar el Modelo
El sistema necesita un modelo LLM compatible. Recomendamos **Mistral-7B-Instruct GPTQ** para RTX 3060 12GB.
```bash
# Ejecutar el script de descarga
./scripts/download_llm_model.sh
```
El script te mostrará opciones:
1. **Mistral-7B-Instruct-v0.2 (GPTQ)** - RECOMENDADO
2. Mistral-7B-Instruct-v0.2 (EXL2)
3. OpenHermes-2.5-Mistral-7B (GPTQ)
4. Neural-Chat-7B (GPTQ)
**Tiempo estimado de descarga**: 10-30 minutos (según conexión)
**Espacio en disco**: ~4.5 GB
### Paso 2: Verificar la instalación
```bash
# Verificar que el modelo se descargó correctamente
ls -lh models/llm/
# Deberías ver archivos como:
# - model.safetensors o *.safetensors
# - config.json
# - tokenizer.json
# - etc.
```
### Paso 3: Probar el sistema (opcional)
Antes de levantar el contenedor, puedes probar que funciona:
```bash
# Instalar dependencias localmente (solo para prueba)
pip3 install exllamav2 torch
# Ejecutar script de prueba
python3 scripts/test_llm_categorizer.py
```
---
## Uso
### Iniciar el servicio
```bash
# Construir y levantar el contenedor
docker compose up -d llm-categorizer
# Ver logs en tiempo real
docker compose logs -f llm-categorizer
```
### Verificar funcionamiento
```bash
# Ver estado del contenedor
docker compose ps llm-categorizer
# Ver últimas 50 líneas de log
docker compose logs --tail=50 llm-categorizer
# Ver categorías asignadas en la base de datos
docker exec -it rss2_db psql -U rss -d rss -c \
"SELECT llm_categoria, COUNT(*) FROM noticias WHERE llm_processed = TRUE GROUP BY llm_categoria;"
```
### Detener el servicio
```bash
docker compose stop llm-categorizer
```
---
## Configuración
### Variables de Entorno
Puedes ajustar el comportamiento editando `docker-compose.yml`:
```yaml
environment:
# Número de noticias a procesar por lote (default: 10)
LLM_BATCH_SIZE: 10
# Tiempo de espera cuando no hay noticias (segundos, default: 30)
LLM_SLEEP_IDLE: 30
# Longitud máxima de contexto (default: 4096)
LLM_MAX_SEQ_LEN: 4096
# Modo de caché: FP16 o Q4 (default: FP16)
# Q4 usa menos VRAM pero puede ser más lento
LLM_CACHE_MODE: FP16
# Distribución de GPU: "auto" para single GPU
LLM_GPU_SPLIT: auto
```
### Categorías
Las categorías están definidas en `workers/llm_categorizer_worker.py`:
```python
CATEGORIES = [
"Política",
"Economía",
"Tecnología",
"Ciencia",
"Salud",
"Deportes",
"Entretenimiento",
"Internacional",
"Nacional",
"Sociedad",
"Cultura",
"Medio Ambiente",
"Educación",
"Seguridad",
"Otros"
]
```
Para modificarlas, edita el archivo y reconstruye el contenedor:
```bash
docker compose up -d --build llm-categorizer
```
---
## Base de Datos
### Nuevas columnas en `noticias`
El worker añade automáticamente estas columnas:
- `llm_categoria` (VARCHAR): Categoría asignada
- `llm_confianza` (FLOAT): Nivel de confianza (0.0 - 1.0)
- `llm_processed` (BOOLEAN): Si ya fue procesada
- `llm_processed_at` (TIMESTAMP): Fecha de procesamiento
### Consultas útiles
```sql
-- Ver distribución de categorías
SELECT llm_categoria, COUNT(*) as total, AVG(llm_confianza) as confianza_media
FROM noticias
WHERE llm_processed = TRUE
GROUP BY llm_categoria
ORDER BY total DESC;
-- Ver noticias de una categoría específica
SELECT id, titulo, llm_categoria, llm_confianza, fecha
FROM noticias
WHERE llm_categoria = 'Tecnología'
AND llm_processed = TRUE
ORDER BY fecha DESC
LIMIT 20;
-- Ver noticias con baja confianza (revisar manualmente)
SELECT id, titulo, llm_categoria, llm_confianza
FROM noticias
WHERE llm_processed = TRUE
AND llm_confianza < 0.6
ORDER BY llm_confianza ASC
LIMIT 20;
-- Resetear procesamiento (para reprocesar)
UPDATE noticias SET llm_processed = FALSE WHERE llm_categoria = 'Otros';
```
---
## Monitorización
### Prometheus/Grafana
El worker está integrado con el stack de monitorización. Puedes ver:
- Uso de GPU (VRAM)
- Tiempo de procesamiento por lote
- Tasa de categorización
Accede a Grafana: http://localhost:3001
### Logs
```bash
# Ver logs en tiempo real
docker compose logs -f llm-categorizer
# Buscar errores
docker compose logs llm-categorizer | grep ERROR
# Ver estadísticas de categorización
docker compose logs llm-categorizer | grep "Distribución"
```
---
## Troubleshooting
### Error: "Out of memory"
**Causa**: El modelo es demasiado grande para tu GPU.
**Solución**:
1. Usa un modelo más pequeño (ej: EXL2 con menor bpw)
2. Reduce el batch size: `LLM_BATCH_SIZE: 5`
3. Usa cache Q4 en lugar de FP16: `LLM_CACHE_MODE: Q4`
```yaml
environment:
LLM_BATCH_SIZE: 5
LLM_CACHE_MODE: Q4
```
### Error: "Model not found"
**Causa**: El modelo no se descargó correctamente.
**Solución**:
```bash
# Verificar directorio
ls -la models/llm/
# Debería contener config.json y archivos .safetensors
# Si está vacío, ejecutar de nuevo:
./scripts/download_llm_model.sh
```
### El worker no procesa noticias
**Causa**: Posiblemente ya están todas procesadas.
**Solución**:
```bash
# Verificar cuántas noticias faltan
docker exec -it rss2_db psql -U rss -d rss -c \
"SELECT COUNT(*) FROM noticias WHERE llm_processed = FALSE;"
# Si es 0, resetear algunas para probar
docker exec -it rss2_db psql -U rss -d rss -c \
"UPDATE noticias SET llm_processed = FALSE WHERE id IN (SELECT id FROM noticias ORDER BY fecha DESC LIMIT 20);"
```
### Categorización incorrecta
**Causa**: El prompt puede necesitar ajustes o el modelo no es adecuado.
**Soluciones**:
1. Ajustar el prompt en `workers/llm_categorizer_worker.py` (método `_build_prompt`)
2. Probar un modelo diferente (ej: OpenHermes es mejor generalista)
3. Ajustar la temperatura (más baja = más determinista):
```python
self.settings.temperature = 0.05 # Muy determinista
```
---
## Rendimiento
### RTX 3060 12GB
- **Modelo recomendado**: Mistral-7B-Instruct GPTQ 4-bit
- **VRAM utilizada**: ~6-7 GB
- **Tiempo por noticia**: ~2-5 segundos
- **Throughput**: ~120-300 noticias/hora
### Optimizaciones
Para mejorar el rendimiento:
1. **Aumentar batch size** (si sobra VRAM):
```yaml
LLM_BATCH_SIZE: 20
```
2. **Cache Q4** (menos VRAM, ligeramente más lento):
```yaml
LLM_CACHE_MODE: Q4
```
3. **Modelo EXL2 optimizado**:
- Usar Mistral EXL2 4.0bpw
- Es más rápido que GPTQ en ExLlamaV2
---
## Integración con la Web
Para mostrar las categorías en la interfaz web, modifica `routers/search.py` o crea una nueva vista:
```python
# Ejemplo de endpoint para estadísticas
@app.route('/api/categories/stats')
def category_stats():
query = """
SELECT llm_categoria, COUNT(*) as total
FROM noticias
WHERE llm_processed = TRUE
GROUP BY llm_categoria
ORDER BY total DESC
"""
# ... ejecutar query y devolver JSON
```
---
## Roadmap
Posibles mejoras futuras:
- [ ] Subcategorías automáticas
- [ ] Detección de temas trending
- [ ] Resúmenes automáticos por categoría
- [ ] Alertas personalizadas por categoría
- [ ] API REST para categorización bajo demanda
- [ ] Fine-tuning del modelo con feedback de usuario
---
## Soporte
Para problemas o preguntas:
1. Revisar logs: `docker compose logs llm-categorizer`
2. Verificar GPU: `nvidia-smi`
3. Consultar documentación de ExLlamaV2: https://github.com/turboderp/exllamav2
---
## Licencia
Este componente se distribuye bajo la misma licencia que el proyecto principal RSS2.
Los modelos LLM tienen sus propias licencias (generalmente Apache 2.0 o MIT para los recomendados).

14
init-db/00-replication-slot.sql Normal file
View file

@ -0,0 +1,14 @@
-- Enable replication access from the replica container
-- This file is sourced after the database is initialized
-- Add pg_hba.conf entry for replication
-- Note: This needs to be done via ALTER SYSTEM or pg_hba.conf file
DO $$
BEGIN
-- Create replication slot to prevent WAL removal
IF NOT EXISTS (SELECT 1 FROM pg_replication_slots WHERE slot_name = 'replica_slot') THEN
PERFORM pg_create_physical_replication_slot('replica_slot');
END IF;
END
$$;

13
init-db/00-replication-user.sql Normal file
View file

@ -0,0 +1,13 @@
-- Create replication user for streaming replication
-- This user will be used by the replica to connect to the primary
DO $$
BEGIN
IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = 'replicator') THEN
CREATE ROLE replicator WITH REPLICATION LOGIN PASSWORD 'replica_password';
END IF;
END
$$;
-- Grant necessary permissions
GRANT CONNECT ON DATABASE rss TO replicator;

39
init-db/01.schema.sql Normal file
View file

@ -0,0 +1,39 @@
CREATE TABLE IF NOT EXISTS continentes (id SERIAL PRIMARY KEY, nombre VARCHAR(50) NOT NULL UNIQUE);
CREATE TABLE IF NOT EXISTS categorias (id SERIAL PRIMARY KEY, nombre VARCHAR(100) NOT NULL UNIQUE);
CREATE TABLE IF NOT EXISTS paises (id SERIAL PRIMARY KEY, nombre VARCHAR(100) NOT NULL UNIQUE, continente_id INTEGER REFERENCES continentes(id) ON DELETE SET NULL);
CREATE TABLE IF NOT EXISTS feeds (id SERIAL PRIMARY KEY, nombre VARCHAR(255), descripcion TEXT, url TEXT NOT NULL UNIQUE, categoria_id INTEGER REFERENCES categorias(id) ON DELETE SET NULL, pais_id INTEGER REFERENCES paises(id) ON DELETE SET NULL, idioma CHAR(2), activo BOOLEAN DEFAULT TRUE, fallos INTEGER DEFAULT 0, last_etag TEXT, last_modified TEXT);
CREATE TABLE IF NOT EXISTS fuentes_url (
id SERIAL PRIMARY KEY,
nombre VARCHAR(255) NOT NULL,
url TEXT NOT NULL UNIQUE,
categoria_id INTEGER REFERENCES categorias(id) ON DELETE SET NULL,
pais_id INTEGER REFERENCES paises(id) ON DELETE SET NULL,
idioma CHAR(2) DEFAULT 'es',
last_check TIMESTAMP WITHOUT TIME ZONE,
last_status VARCHAR(50),
status_message TEXT,
last_http_code INTEGER,
active BOOLEAN DEFAULT TRUE
);
CREATE TABLE IF NOT EXISTS noticias (id VARCHAR(32) PRIMARY KEY, titulo TEXT, resumen TEXT, url TEXT NOT NULL UNIQUE, fecha TIMESTAMP, imagen_url TEXT, fuente_nombre VARCHAR(255), categoria_id INTEGER REFERENCES categorias(id) ON DELETE SET NULL, pais_id INTEGER REFERENCES paises(id) ON DELETE SET NULL, tsv tsvector);
ALTER TABLE noticias ADD COLUMN IF NOT EXISTS tsv tsvector;
ALTER TABLE noticias ADD COLUMN IF NOT EXISTS topics_processed BOOLEAN DEFAULT FALSE;
CREATE OR REPLACE FUNCTION noticias_tsv_trigger() RETURNS trigger AS $$
BEGIN
new.tsv := setweight(to_tsvector('spanish', coalesce(new.titulo,'')), 'A') ||
setweight(to_tsvector('spanish', coalesce(new.resumen,'')), 'B');
return new;
END
$$ LANGUAGE plpgsql;
DROP TRIGGER IF EXISTS tsvectorupdate ON noticias;
CREATE TRIGGER tsvectorupdate
BEFORE INSERT OR UPDATE ON noticias
FOR EACH ROW EXECUTE PROCEDURE noticias_tsv_trigger();
CREATE INDEX IF NOT EXISTS noticias_tsv_idx ON noticias USING gin(tsv);

9
init-db/02-continentes.sql Executable file
View file

@ -0,0 +1,9 @@
INSERT INTO continentes (id, nombre) VALUES
(1, 'África'),
(2, 'América'),
(3, 'Asia'),
(4, 'Europa'),
(5, 'Oceanía'),
(6, 'Antártida')
ON CONFLICT (id) DO NOTHING;

18
init-db/03-categorias.sql Executable file
View file

@ -0,0 +1,18 @@
INSERT INTO categorias (nombre) VALUES
('Ciencia'),
('Cultura'),
('Deportes'),
('Economía'),
('Educación'),
('Entretenimiento'),
('Internacional'),
('Medio Ambiente'),
('Moda'),
('Opinión'),
('Política'),
('Salud'),
('Sociedad'),
('Tecnología'),
('Viajes')
ON CONFLICT DO NOTHING;

198
init-db/04-paises.sql Executable file
View file

@ -0,0 +1,198 @@
INSERT INTO paises (nombre, continente_id) VALUES
('Afganistán', 3),
('Albania', 4),
('Alemania', 4),
('Andorra', 4),
('Angola', 1),
('Antigua y Barbuda', 2),
('Arabia Saudita', 3),
('Argelia', 1),
('Argentina', 2),
('Armenia', 3),
('Australia', 5),
('Austria', 4),
('Azerbaiyán', 3),
('Bahamas', 2),
('Bangladés', 3),
('Barbados', 2),
('Baréin', 3),
('Bélgica', 4),
('Belice', 2),
('Benín', 1),
('Bielorrusia', 4),
('Birmania', 3),
('Bolivia', 2),
('Bosnia y Herzegovina', 4),
('Botsuana', 1),
('Brasil', 2),
('Brunéi', 3),
('Bulgaria', 4),
('Burkina Faso', 1),
('Burundi', 1),
('Bután', 3),
('Cabo Verde', 1),
('Camboya', 3),
('Camerún', 1),
('Canadá', 2),
('Catar', 3),
('Chad', 1),
('Chile', 2),
('China', 3),
('Chipre', 3),
('Colombia', 2),
('Comoras', 1),
('Corea del Norte', 3),
('Corea del Sur', 3),
('Costa de Marfil', 1),
('Costa Rica', 2),
('Croacia', 4),
('Cuba', 2),
('Dinamarca', 4),
('Dominica', 2),
('Ecuador', 2),
('Egipto', 1),
('El Salvador', 2),
('Emiratos Árabes Unidos', 3),
('Eritrea', 1),
('Eslovaquia', 4),
('Eslovenia', 4),
('España', 4),
('Estados Unidos', 2),
('Estonia', 4),
('Esuatini', 1),
('Etiopía', 1),
('Filipinas', 3),
('Finlandia', 4),
('Fiyi', 5),
('Francia', 4),
('Gabón', 1),
('Gambia', 1),
('Georgia', 3),
('Ghana', 1),
('Granada', 2),
('Grecia', 4),
('Guatemala', 2),
('Guinea', 1),
('Guinea-Bisáu', 1),
('Guinea Ecuatorial', 1),
('Guyana', 2),
('Haití', 2),
('Honduras', 2),
('Hungría', 4),
('India', 3),
('Indonesia', 3),
('Irak', 3),
('Irán', 3),
('Irlanda', 4),
('Islandia', 4),
('Islas Marshall', 5),
('Islas Salomón', 5),
('Israel', 3),
('Italia', 4),
('Jamaica', 2),
('Japón', 3),
('Jordania', 3),
('Kazajistán', 3),
('Kenia', 1),
('Kirguistán', 3),
('Kiribati', 5),
('Kuwait', 3),
('Laos', 3),
('Lesoto', 1),
('Letonia', 4),
('Líbano', 3),
('Liberia', 1),
('Libia', 1),
('Liechtenstein', 4),
('Lituania', 4),
('Luxemburgo', 4),
('Macedonia del Norte', 4),
('Madagascar', 1),
('Malasia', 3),
('Malaui', 1),
('Maldivas', 3),
('Malí', 1),
('Malta', 4),
('Marruecos', 1),
('Mauricio', 1),
('Mauritania', 1),
('México', 2),
('Micronesia', 5),
('Moldavia', 4),
('Mónaco', 4),
('Mongolia', 3),
('Montenegro', 4),
('Mozambique', 1),
('Namibia', 1),
('Nauru', 5),
('Nepal', 3),
('Nicaragua', 2),
('Níger', 1),
('Nigeria', 1),
('Noruega', 4),
('Nueva Zelanda', 5),
('Omán', 3),
('Países Bajos', 4),
('Pakistán', 3),
('Palaos', 5),
('Palestina', 3),
('Panamá', 2),
('Papúa Nueva Guinea', 5),
('Paraguay', 2),
('Perú', 2),
('Polonia', 4),
('Portugal', 4),
('Reino Unido', 4),
('República Centroafricana', 1),
('República Checa', 4),
('República del Congo', 1),
('República Democrática del Congo', 1),
('República Dominicana', 2),
('Ruanda', 1),
('Rumanía', 4),
('Rusia', 3),
('Samoa', 5),
('San Cristóbal y Nieves', 2),
('San Marino', 4),
('San Vicente y las Granadinas', 2),
('Santa Lucía', 2),
('Santo Tomé y Príncipe', 1),
('Senegal', 1),
('Serbia', 4),
('Seychelles', 1),
('Sierra Leona', 1),
('Singapur', 3),
('Siria', 3),
('Somalia', 1),
('Sri Lanka', 3),
('Sudáfrica', 1),
('Sudán', 1),
('Sudán del Sur', 1),
('Suecia', 4),
('Suiza', 4),
('Surinam', 2),
('Tailandia', 3),
('Tanzania', 1),
('Tayikistán', 3),
('Timor Oriental', 3),
('Togo', 1),
('Tonga', 5),
('Trinidad y Tobago', 2),
('Túnez', 1),
('Turkmenistán', 3),
('Turquía', 3),
('Tuvalu', 5),
('Ucrania', 4),
('Uganda', 1),
('Uruguay', 2),
('Uzbekistán', 3),
('Vanuatu', 5),
('Vaticano', 4),
('Venezuela', 2),
('Vietnam', 3),
('Yemen', 3),
('Yibuti', 1),
('Zambia', 1),
('Zimbabue', 1)
ON CONFLICT DO NOTHING;

15
init-db/05-traducciones.sql Normal file
View file

@ -0,0 +1,15 @@
CREATE TABLE IF NOT EXISTS traducciones (
id SERIAL PRIMARY KEY,
noticia_id VARCHAR(32) REFERENCES noticias(id) ON DELETE CASCADE,
lang_from CHAR(5),
lang_to CHAR(5) NOT NULL,
titulo_trad TEXT,
resumen_trad TEXT,
status VARCHAR(16) DEFAULT 'done',
error TEXT,
created_at TIMESTAMP DEFAULT NOW(),
UNIQUE (noticia_id, lang_to)
);
CREATE INDEX IF NOT EXISTS traducciones_to_idx ON traducciones (lang_to);

24
init-db/06-tags.sql Normal file
View file

@ -0,0 +1,24 @@
-- init-db/06-tags.sql (modelo simple compatible con ner_worker.py)
-- Tabla de tags
CREATE TABLE IF NOT EXISTS tags (
id SERIAL PRIMARY KEY,
valor TEXT NOT NULL,
tipo TEXT NOT NULL, -- 'persona','organizacion','lugar', ...
UNIQUE (valor, tipo)
);
-- Relación tag <-> traducción
CREATE TABLE IF NOT EXISTS tags_noticia (
id SERIAL PRIMARY KEY,
traduccion_id INT NOT NULL REFERENCES traducciones(id) ON DELETE CASCADE,
tag_id INT NOT NULL REFERENCES tags(id) ON DELETE CASCADE,
UNIQUE (traduccion_id, tag_id)
);
-- Índices útiles
CREATE INDEX IF NOT EXISTS idx_tags_valor ON tags(valor);
CREATE INDEX IF NOT EXISTS idx_tags_tipo ON tags(tipo);
CREATE INDEX IF NOT EXISTS idx_tags_noticia_trid ON tags_noticia(traduccion_id);
CREATE INDEX IF NOT EXISTS idx_tags_noticia_tag ON tags_noticia(tag_id);

42
init-db/07-tags-views.sql Normal file
View file

@ -0,0 +1,42 @@
-- init-db/07-tags-views.sql
-- Vista de Top tags (24h) para el esquema:
-- tags(id, valor, tipo)
-- tags_noticia(id, traduccion_id, tag_id)
-- traducciones(id, noticia_id, lang_to, status, ...)
-- noticias(id, fecha, ...)
CREATE OR REPLACE VIEW public.v_tag_counts_24h AS
SELECT
tg.id,
tg.valor,
tg.tipo,
COUNT(*) AS apariciones
FROM public.tags tg
JOIN public.tags_noticia tn ON tn.tag_id = tg.id
JOIN public.traducciones t ON t.id = tn.traduccion_id
JOIN public.noticias n ON n.id = t.noticia_id
WHERE t.status = 'done'
AND t.lang_to = 'es'
AND n.fecha >= now() - INTERVAL '24 hours'
GROUP BY tg.id, tg.valor, tg.tipo
ORDER BY apariciones DESC, tg.valor;
-- Índices recomendados para acelerar la vista (idempotentes)
CREATE INDEX IF NOT EXISTS idx_noticias_fecha
ON public.noticias (fecha);
CREATE INDEX IF NOT EXISTS idx_traducciones_noticia_lang_status
ON public.traducciones (noticia_id, lang_to, status);
CREATE INDEX IF NOT EXISTS idx_tags_noticia_traduccion
ON public.tags_noticia (traduccion_id);
CREATE INDEX IF NOT EXISTS idx_tags_noticia_tag
ON public.tags_noticia (tag_id);
-- (Opcionales si no existen ya, pero ayudan en búsquedas ad hoc)
CREATE INDEX IF NOT EXISTS idx_tags_valor
ON public.tags (valor);
CREATE INDEX IF NOT EXISTS idx_tags_tipo
ON public.tags (tipo);

45
init-db/08-embeddings.sql Normal file
View file

@ -0,0 +1,45 @@
CREATE TABLE IF NOT EXISTS traduccion_embeddings (
id SERIAL PRIMARY KEY,
traduccion_id INT NOT NULL REFERENCES traducciones(id) ON DELETE CASCADE,
model TEXT NOT NULL,
dim INT NOT NULL,
embedding DOUBLE PRECISION[] NOT NULL,
created_at TIMESTAMP DEFAULT NOW(),
UNIQUE (traduccion_id, model)
);
CREATE INDEX IF NOT EXISTS idx_tr_emb_traduccion_id ON traduccion_embeddings(traduccion_id);
CREATE INDEX IF NOT EXISTS idx_tr_emb_model ON traduccion_embeddings(model);
DO $$
BEGIN
IF EXISTS (
SELECT 1 FROM information_schema.tables
WHERE table_schema = 'public' AND table_name = 'embeddings'
) THEN
EXECUTE 'ALTER TABLE embeddings RENAME TO embeddings_legacy';
END IF;
EXCEPTION WHEN others THEN
NULL;
END$$;
CREATE OR REPLACE VIEW embeddings AS
SELECT
te.traduccion_id,
te.dim,
te.embedding AS vec
FROM traduccion_embeddings te
WHERE te.model = 'sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2';
CREATE TABLE IF NOT EXISTS related_noticias (
traduccion_id INT NOT NULL REFERENCES traducciones(id) ON DELETE CASCADE,
related_traduccion_id INT NOT NULL REFERENCES traducciones(id) ON DELETE CASCADE,
score DOUBLE PRECISION NOT NULL,
created_at TIMESTAMP DEFAULT NOW(),
PRIMARY KEY (traduccion_id, related_traduccion_id),
CHECK (traduccion_id <> related_traduccion_id)
);
CREATE INDEX IF NOT EXISTS idx_related_by_tr ON related_noticias (traduccion_id);
CREATE INDEX IF NOT EXISTS idx_related_by_relatedtr ON related_noticias (related_traduccion_id);

62
init-db/09-eventos.sql Normal file
View file

@ -0,0 +1,62 @@
BEGIN;
CREATE TABLE IF NOT EXISTS eventos (
id BIGSERIAL PRIMARY KEY,
creado_en TIMESTAMPTZ NOT NULL DEFAULT NOW(),
actualizado_en TIMESTAMPTZ NOT NULL DEFAULT NOW(),
titulo TEXT,
fecha_inicio TIMESTAMPTZ,
fecha_fin TIMESTAMPTZ,
n_noticias INTEGER NOT NULL DEFAULT 0,
centroid JSONB NOT NULL,
total_traducciones INTEGER NOT NULL DEFAULT 1
);
ALTER TABLE traducciones
ADD COLUMN IF NOT EXISTS evento_id BIGINT REFERENCES eventos(id);
CREATE TABLE IF NOT EXISTS eventos_noticias (
evento_id BIGINT NOT NULL REFERENCES eventos(id) ON DELETE CASCADE,
noticia_id VARCHAR(32) NOT NULL REFERENCES noticias(id) ON DELETE CASCADE,
traduccion_id INTEGER NOT NULL REFERENCES traducciones(id) ON DELETE CASCADE,
PRIMARY KEY (evento_id, noticia_id)
);
CREATE INDEX IF NOT EXISTS idx_traducciones_evento
ON traducciones(evento_id);
CREATE INDEX IF NOT EXISTS idx_traducciones_evento_fecha
ON traducciones(evento_id, noticia_id);
CREATE INDEX IF NOT EXISTS idx_trad_id
ON traducciones(id);
CREATE INDEX IF NOT EXISTS idx_eventos_fecha_inicio
ON eventos (fecha_inicio DESC NULLS LAST);
CREATE INDEX IF NOT EXISTS idx_eventos_noticias_evento
ON eventos_noticias (evento_id);
CREATE INDEX IF NOT EXISTS idx_eventos_noticias_noticia
ON eventos_noticias (noticia_id);
CREATE INDEX IF NOT EXISTS idx_eventos_noticias_traduccion
ON eventos_noticias (traduccion_id);
CREATE OR REPLACE FUNCTION actualizar_evento_modificado()
RETURNS TRIGGER AS $$
BEGIN
NEW.actualizado_en = NOW();
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
DROP TRIGGER IF EXISTS trg_evento_modificado ON eventos;
CREATE TRIGGER trg_evento_modificado
BEFORE UPDATE ON eventos
FOR EACH ROW
EXECUTE FUNCTION actualizar_evento_modificado();
COMMIT;

10
init-db/10-favoritos.sql Normal file
View file

@ -0,0 +1,10 @@
-- Favorites table for saving news
CREATE TABLE IF NOT EXISTS favoritos (
id SERIAL PRIMARY KEY,
session_id VARCHAR(64) NOT NULL,
noticia_id VARCHAR(32) REFERENCES noticias(id) ON DELETE CASCADE,
created_at TIMESTAMP DEFAULT NOW(),
UNIQUE (session_id, noticia_id)
);
CREATE INDEX IF NOT EXISTS idx_favoritos_session ON favoritos(session_id);

5
init-db/10-indexes.sql Normal file
View file

@ -0,0 +1,5 @@
-- Optimización de índices
CREATE INDEX IF NOT EXISTS idx_noticias_pais ON noticias(pais_id);
CREATE INDEX IF NOT EXISTS idx_noticias_categoria ON noticias(categoria_id);
CREATE INDEX IF NOT EXISTS idx_traducciones_created_at ON traducciones(created_at);
CREATE INDEX IF NOT EXISTS idx_news_topics_topic_id ON news_topics(topic_id);

18
init-db/11-performance-indexes.sql Normal file
View file

@ -0,0 +1,18 @@
-- Índices de optimización de rendimiento
-- Creados: 2025-12-16
-- Propósito: Acelerar consultas frecuentes de conteo y filtrado
-- Índices parciales para estados de traducciones
CREATE INDEX IF NOT EXISTS idx_traducciones_status_partial_done
ON traducciones(status) WHERE status = 'done';
CREATE INDEX IF NOT EXISTS idx_traducciones_status_partial_pending
ON traducciones(status) WHERE status = 'pending';
-- Índice compuesto para feeds activos/inactivos con fallos
CREATE INDEX IF NOT EXISTS idx_feeds_activo_fallos
ON feeds(activo, fallos);
-- Índice compuesto para páginas de noticias con filtros comunes
CREATE INDEX IF NOT EXISTS idx_noticias_fecha_pais_categoria
ON noticias(fecha DESC, pais_id, categoria_id);

79
init-db/11-topics-data.sql Normal file
View file

@ -0,0 +1,79 @@
-- Create Topics Table
CREATE TABLE IF NOT EXISTS topics (
id SERIAL PRIMARY KEY,
slug VARCHAR(50) UNIQUE NOT NULL,
name VARCHAR(100) NOT NULL,
weight INTEGER DEFAULT 1,
keywords TEXT,
group_name VARCHAR(50)
);
-- Create News Topics Relation Table
CREATE TABLE IF NOT EXISTS news_topics (
noticia_id VARCHAR(32) REFERENCES noticias(id) ON DELETE CASCADE,
topic_id INTEGER REFERENCES topics(id) ON DELETE CASCADE,
score INTEGER DEFAULT 0,
created_at TIMESTAMP DEFAULT NOW(),
PRIMARY KEY (noticia_id, topic_id)
);
CREATE INDEX IF NOT EXISTS idx_news_topics_score ON news_topics(score DESC);
-- Insert Initial Topics Data
-- Uses ON CONFLICT to update if exists.
INSERT INTO topics (slug, name, weight, keywords) VALUES
('middle_east', 'Oriente Medio', 5, 'israel,estado de israel,tel aviv,jerusalén,al quds,gaza,franja de gaza,rafah,jan yunis,cisjordania,territorios ocupados,palestina,autoridad nacional palestina,anp,ramala,iran,república islámica de iran,teherán,isfahán,qom,iraq,irak,bagdad,basora,kurdistán iraquí,erbil,siria,damasco,aleppo,idlib,raqqa,líbano,beirut,sur del líbano,jordania,ammán,arabia saudí,riad,la meca,medina,emiratos árabes,emiratos árabes unidos,uae,dubái,abudabi,sharjah,qatar,doha,kuwait,bahrein,bahréin,manama,oman,yemen,saná,aden,hamas,hamás,yihad islámica,islamic jihad,hezbolá,hizbulá,hezbollah,hutíes,rebeldes hutíes,houthi,ansar allah,isis,estado islámico,daesh,al qaeda,talibanes,fatah,peshmerga,ypg,fds,milicias chiíes,pmu,pasdarán,guardia revolucionaria iraní,irgc,bombardeo,bombardeos,ataque aéreo,ataque con drones,drones suicidas,misiles,cohetes,misil balístico,misil de crucero,iron dome,cúpula de hierro,interceptores,sirenas antiaéreas,incursión terrestre,operación militar,ofensiva,contraofensiva,combates,enfrentamientos,hostilidades,escalada militar,movilización militar,fuerzas armadas,retirada de tropas,zona desmilitarizada,frontera norte,frontera sur,rehenes,liberación de rehenes,intercambio de prisioneros,secuestro,negociación de rehenes,crisis humanitaria,desplazados,refugiados,campamentos,asedio,bloqueo,corte de suministros,hambruna,escasez de agua,ayuda humanitaria,unrwa,alto el fuego,tregua,mediación egipcia,mediación qatarí,acuerdos de abraham,normalización diplomática,liga árabe,cumbre árabe,cumbre del golfo,negociaciones israelo-palestinas,solución de dos estados,relaciones árabe-israelíes,relaciones palestino-israelíes,países del golfo,monarquías del golfo,injerencia iraní,influencia saudí,diplomacia regional,petróleo,crudo,brent,wti,oleoducto,gasoducto,refinería,infraestructura energética,opep,opec,opep+,producción petrolera,gas natural,catar gas,estrecho de hormuz,mar rojo,golfo pérsico,golfo de aden,suní,chií,chiita,wahabismo,salafismo,conflicto sectario,tensión sectaria,lugares sagrados,peregrinación,ramadán,hajj,terrorismo,atentado,explosión,radicalización,células terroristas,operación antiterrorista,servicios secretos,inteligencia militar,contrainteligencia,oriente medio,medio oriente,mashreq,levant,inestabilidad regional,crisis del golfo,conflicto en oriente medio')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('ukraine_russia', 'Ucrania / Rusia', 5, 'ucrania,estado ucraniano,kyiv,kiev,odesa,lviv,rusia,federación rusa,moscú,san petersburgo,zelensky,zelenski,volodímir zelenski,putin,vladímir putin,kremlin,dimitri peskov,sergei lavrov,donbás,donbas,donetsk,donesk,oblast de donetsk,lugansk,luhansk,oblast de lugansk,crimea,sebastopol,península de crimea,mariúpol,jersón,zaporizhzhia,jarkov,sumy,bahmut,avdiivka,lyman,soledar,invasión,invadir,ataque ruso,agresión rusa,contraofensiva,ofensiva ucraniana,ofensiva rusa,bombardeo,ataques masivos,ataques nocturnos,artillería,ataque con misiles,ataque con drones,drones kamikaze,shahed,geran-2,lanzadores múltiples,misiles hipersónicos,kizhal,iskander,kalibr,sistema antiaéreo,patriot,nasams,s-300,s-400,defensa aérea,interceptores,sirenas antiaéreas,fuerzas armadas ucranianas,fuerzas armadas rusas,wagner,grupo wagner,rosgvardia,militares movilizados,reservistas,mercenarios,voluntarios internacionales,anexión,territorios anexionados,referéndum falso,integración forzada,administración ocupante,rusificación,pasaporte ruso obligatorio,tanques leopard,abrams,challenger,vehículos blindados,bradley,artillería autopropulsada,munición de racimo,munición guiada,misiles tácticos,drones de reconocimiento,guerra electrónica,ciberataque ruso,guerra híbrida,desinformación,propaganda rusa,operaciones encubiertas,hackers prorrusos,ataques informáticos masivos,movilización,movilización parcial,llamamiento a filas,despliegue,reservistas,retirada,bajas,pérdidas militares,deserción,frente oriental,línea de contacto,trincheras,alianza occidental,apoyo militar occidental,otan,nato,unión europea,g7,sanciones,embargo,tope al petróleo ruso,precio del gas,negociaciones de paz,alto el fuego,mediación,acusaciones de crímenes de guerra,crímenes contra la humanidad,refugiados ucranianos,desplazados internos,crisis humanitaria,corte de electricidad,infraestructura destruida,ataques a civiles,bombardeos a infraestructura crítica,corredores humanitarios,evacuaciones masivas,gas ruso,nord stream,nord stream 2,oleoducto,gasoducto,corte de suministro,crisis energética europea,acuerdo de exportación de grano,corredor del mar negro,bloqueo portuario,ataques a puertos ucranianos,osce,onu en ucrania,observadores internacionales,ue apoyo a ucrania,fondo europeo de defensa,escalada nuclear,amenaza nuclear,retórica nuclear,conflicto en ucrania,guerra de ucrania,agresión rusa,resistencia ucraniana,estancamiento militar,frente de batalla,situación en el donbás')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('china', 'China / Asia Oriental', 5, 'china,república popular china,rpc,beijing,pekin,shanghai,guangzhou,shenzhen,hong kong,macau,tíbet,xinjiang,mongolia interior,xi jinping,líder chino,secretario general,partido comunista chino,pcc,comité central,politburó,congreso nacional del pueblo,asamblea nacional popular,primer ministro chino,consejo de estado,taiwán,taipei,estrecho de taiwán,islas kinmen,islas matsu,reunificación,independencia de taiwán,incursiones aéreas,zona de identificación de defensa aérea,adiz,ejercicios militares chinos,bloqueo simulado,flota del pacífico,tensiones sino-taiwanesas,corea del sur,seúl,japón,tokio,mar de china meridional,islas spratly,islas paracel,filipinas,vietnam,disputas territoriales en asia,acuartelamiento indo-pacífico,acuerdos en asia oriental,asean+3,diplomacia china,soft power chino,poder blando,guerra comercial,relaciones sino estadounidenses,relaciones china rusia,alianza estratégica china rusia,cumbre de la unasur china,foros regionales asiáticos,g20,brics,brics+,ruta de la seda,nueva ruta de la seda,belt and road,bri,iniciativa de la franja y la ruta,gdi,global development initiative,gsi,global security initiative,gci,global civilization initiative,hecho en china 2025,made in china 2025,dual circulation,aiib,asian infrastructure investment bank,sco,ocsh,shanghai cooperation organisation,rcep,regional comprehensive economic partnership,asean china,foros del este asiático,apec,cooperación asia-pacífico,semiconductores chinos,industria de chips,litografía china,huawei,zte,bytedance,tiktok,dji,supercomputación china,chips avanzados,restricciones de chips,bloqueo tecnológico eeuu china,ciberespionaje,ataques chinos,apt chino,hackers chinos,piratería estatal,robo tecnológico,ciberataque,gran cortafuegos,gran firewall de china,control de internet,vigilancia digital,ejército chino,pla,ejército de liberación popular,armada china,fuerza aérea china,misiles hipersónicos chinos,modernización militar china,cibercomando chino,marina del epl,guardia costera china,zona de exclusión aérea,maniobras militares,xinjiang,uigur,minorías uigures,reeducación,control social,vigilancia masiva,cámaras de reconocimiento facial,tíbet,libertades civiles en china,economía china,crecimiento chino,exportaciones chinas,industria manufacturera,crisis inmobiliaria china,evergrande,country garden,mercado inmobiliario chino,inversiones chinas,fondos soberanos de china,asia oriental,asia pacífico,indo pacífico,potencia asiática,superpotencia china,expansión china')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('eurasia_russia', 'Eurasia / Influencia Rusa', 4, 'unión euroasiática,eaeu,ueea,eurasian economic union,csto,otsc,collective security treaty organization,comunidad de estados independientes,cei,cis,organización del tratado de seguridad colectiva,parlamento euroasiático,espacio económico euroasiático,asia central,asia central rusa,antiguas repúblicas soviéticas,kazajistán,kazakhstan,astana,almaty,uzbekistán,uzbekistan,tashkent,kirguistán,kirguistan,kirguizistán,bishkek,tayikistán,tayikistan,dusambé,turkmenistán,turkmenistan,ashgabat,armenia,ereván,georgia,tiflis,moldavia,moldova,chisinau,bielorrusia,belarus,minsk,cáucaso sur,cáucaso norte,nagorno karabaj,artsaj,osetia del sur,abjasia,transnistria,donbás euroasiático,frontera ruso-georgiana,bases militares rusas,presencia militar rusa en asia central,fuerzas de paz rusas,operaciones de seguridad regional,ejercicios militares conjuntos,vostok,centr,organización del tratado de amistad y cooperación,cooperación policial euroasiática,centrado en seguridad,unión aduanera,aranceles euroasiáticos,bloque económico euroasiático,intercambio comercial con rusia,dependencia energética de rusia,corredores energéticos,oleoductos euroasiáticos,gasoductos rusos,acuerdos bilaterales con moscú,política económica euroasiática,gazprom,rosneft,transneft,lukoil,gasoducto fuerza de siberia,power of siberia,gasoducto asia central rusia,oleoducto bakú-tiflis-ceyhan,btc pipeline,energía euroasiática,seguridad energética del cáucaso,organización de cooperación de shanghái,sco,ocsh,alianza estratégica china rusia,eje pekín-moscú,rusia en asia central,influencia rusa en el cáucaso,geopolítica euroasiática,integración postsoviética,proyectos euroasiáticos,visitas de estado en asia central,migrantes de asia central en rusia,remesas a asia central,dependencia laboral,crisis fronterizas,rotación laboral regional,eurasia,espacio postsoviético,antiguo bloque soviético,influencia rusa,hegemonía rusa,zona de influencia rusa,vecindario cercano de rusia,near abroad,orden euroasiático,esfera rusa de influencia')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('organismos_globales', 'Organismos Globales', 5, 'onu,naciones unidas,naciones-unidas,asamblea general,consejo de seguridad,secretario general,resolución de la onu,misiones de paz,cascos azules,ecosoc,consejo económico y social,pnuma,programa de naciones unidas para el medio ambiente,pnud,programa de naciones unidas para el desarrollo,onu mujeres,fondo de población de la onu,unfpa,unrwa,agencia de onu para refugiados palestinos,unhabitat,unops,unesco,unido,oms,organización mundial de la salud,ops,organización panamericana de la salud,unicef,fao,acnur,oim,oit,oms,cruz roja internacional,cicr,robos humanitarios internacionales,fmi,fondo monetario internacional,banco mundial,bm,banco internacional de reconstrucción y fomento,bird,asociación internacional de fomento,aif,banco de pagos internacionales,bis,omc,organización mundial del comercio,ocde,organización para la cooperación y el desarrollo económicos,unctad,comercio y desarrollo,foro de davos,wef,foro económico mundial,g7,g20,club de parís,club de londres,corte penal internacional,cpi,tribunal internacional de justicia,tij,corte internacional de justicia,corte permanente de arbitraje,cpa,tribunales de la haya,la haya,oiea,organismo internacional de energía atómica,ctbto,organismo de control de pruebas nucleares,interpol,oficina internacional de policía criminal,onuad,desarme,convención sobre armas químicas,opaq,ipcc,panel intergubernamental del cambio climático,cop,cumbres climáticas,acuerdo de parís,onu clima,pnuma,programa medioambiental de la onu,unesco,organización de naciones unidas para la educación,oms,oms investigación,onu ciencia,oms cooperación global,movimiento de países no alineados,no aligned movement,nam,alianza global,cooperación multilateral,instituciones multilaterales,gobernanza global')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('organismos_occidente', 'Organismos Occidente', 5, 'unión europea,ue,comisión europea,ejecutivo comunitario,parlamento europeo,eurocámara,consejo europeo,consejo de la unión europea,consejo de ministros,tribunal de justicia de la unión europea,tjue,tribunal de cuentas europeo,servicio europeo de acción exterior,seae,alto representante de la ue,alto representante para asuntos exteriores,bce,banco central europeo,eurogrupo,mecanismo europeo de estabilidad,mee,rescate europeo,eurozona,zona euro,banco europeo de inversiones,bei,banco europeo de reconstrucción y desarrollo,berd,europol,oficina europea de policía,eurojust,cooperación judicial europea,frontex,agencia europea de fronteras,olaf,oficina europea de lucha contra el fraude,easa,agencia europea de seguridad aérea,ema,agencia europea del medicamento,enisa,agencia europea de ciberseguridad,eu-osha,agencia europea para la seguridad y salud en el trabajo,consejo de europa,tribunal europeo de derechos humanos,tedh,convención europea de derechos humanos,otan,nato,alianza atlántica,alianza del atlántico norte,mando aliado,ejercicios de la otan,osce,organización para la seguridad y la cooperación en europa,agencia europea de defensa,eda,ocde,organización para la cooperación y el desarrollo económicos,g7,cumbre del g7,g7 ampliado,club de países industrializados,efta,aelc,asociación europea de libre comercio,espacio económico europeo,eee,schengen,acuerdos de schengen,zona schengen,política de vecindad europea,vecindad oriental,pilar europeo de derechos sociales,estado de derecho en la ue,mecanismo del estado de derecho,cumbre eu-usa,relaciones transatlánticas,bloque occidental,alianza occidental,instituciones europeas,burocracia de bruselas,estructura comunitaria,marco institucional europeo')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('organismos_america', 'Organismos América', 4, 'oea,organización de los estados americanos,cidh,comisión interamericana de derechos humanos,corte idh,corte interamericana de derechos humanos,bid,banco interamericano de desarrollo,bcie,banco centroamericano de integración económica,caf,banco de desarrollo de américa latina,cepal,comisión económica para américa latina y el caribe,fonplata,fondo financiero para el desarrollo de la cuenca del plata,mercosur,mercosul,mercosur ampliado,unasur,unión de naciones suramericanas,alianza del pacífico,apec latinoamérica,alap,alba,alba-tcp,alternativa bolivariana para las américas,prosur,foro para el progreso de américa del sur,sica,sistema de la integración centroamericana,parlacen,parlamento centroamericano,caricom,comunidad del caribe,acs,asociación de estados del caribe,sela,sistema económico latinoamericano y caribeño,usmca,tmec,nafta,tratado de libre comercio de américa del norte,cumbre de líderes de américa del norte,alianza para la prosperidad,alianza energética norteamericana,junta interamericana de defensa,consejo de defensa suramericano,seguridad hemisférica,cooperación militar regional,celac,comunidad de estados latinoamericanos y caribeños,cumbre iberoamericana,secretaría general iberoamericana,segib,organismo andino de integración,comunidad andina,can,ops,organización panamericana de la salud,panam sports,odepa,organización deportiva panamericana,oit américas,unesco américa latina,retrofit latinoamérica,infraestructura regional,integración latinoamericana,cooperación regional,foros latinoamericanos,mecanismos regionales,agenda hemisférica,diplomacia regional')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('organismos_china_rusia', 'Org. China/Rusia/BRICS', 5, 'brics,brics+,nuevos brics,expansión de los brics,sco,ocsh,shanghai cooperation organisation,organización de cooperación de shanghái,belt and road,belt & road,bri,iniciativa de la franja y la ruta,ruta de la seda,nueva ruta de la seda,silk road,gdi,global development initiative,gsi,global security initiative,gci,global civilization initiative,made in china 2025,dual circulation strategy,aiib,asian infrastructure investment bank,nuevo banco de desarrollo,new development bank,ndb,banco euroasiático de desarrollo,banco asiático de inversión en infraestructura,csto,otsc,collective security treaty organization,organización del tratado de seguridad colectiva,eaeu,ueea,unión económica euroasiática,eurasian economic union,cei,cis,comunidad de estados independientes,rosatom,gazprom forum,foro energético ruso,foro de boao,boao forum for asia,asean+3,asean plus three,asia cooperation dialogue,acd,cica,conference on interaction and confidence building measures in asia,organización del tratado de amistad y cooperación,otl del caspio,caspian summit,consejo turco,turkic council,organización de estados túrquicos,ejercicios conjuntos china rusia,alianza militar euroasiática,cooperación militar sino-rusa,joint sea naval exercises,vostok ejercicios militares,rcep,regional comprehensive economic partnership,asian cooperation forum,cinturón económico de la ruta de la seda,eurasian land bridge,foro energético del caspio,acuerdos energéticos china rusia,gasoducto fuerza de siberia,power of siberia pipeline,foro petrolero euroasiático,multipolaridad,orden multipolar,alternativa a occidente,bloque euroasiático,cooperación sino-rusa,alianza estratégica china rusia')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('big_tech', 'Big Tech / Gigantes Tecnológicos', 4, 'apple,google,alphabet,tesla,spacex,amazon,meta,facebook,microsoft,netflix,nvidia,intel,amd,samsung,huawei,tiktok,bytedance,oracle,ibm,salesforce,adobe,alibaba,tencent,baidu,uber,airbnb,spotify,tim cook,sundar pichai,elon musk,mark zuckerberg,satya nadella,jeff bezos,jensen huang,reed hastings,jack ma,pony ma,zhang yiming,iphone,ipad,macbook,ios,macos,app store,android,google play,chrome,chromebook,gmail,google cloud,aws,amazon web services,azure,microsoft 365,office 365,teams,windows,xbox,meta quest,oculus,realidad virtual,realidad aumentada,tesla model 3,tesla model y,autopilot,full self driving,fsd,prime video,netflix,hbo max,disney+,tiktok app,instagram,whatsapp,messenger,youtube,youtube premium,plataforma digital,marketplace,ecommerce,comercio electrónico,suscripción,modelo freemium,publicidad digital,anuncios online,economía de plataforma,gig economy,economía colaborativa,cloud,computación en la nube,centros de datos,data center,edge computing,cdn,infraestructura cloud,paas,saas,iaas,kubernetes,docker,microservicios,vehículo eléctrico,coche eléctrico,supercargadores,red de carga,conducción autónoma,software de conducción,baterías,gigafactory,modelo de lenguaje,servicio de ia,ia en la nube,plataformas de inteligencia artificial,api de ia,servicios cognitivos,vision artificial en la nube,fusión,adquisición,m&a,compra de startup,venta de activos,spin-off,scisión empresarial,salida a bolsa,opv,ipo,valoración multimillonaria,unicornio,capital riesgo,posición dominante,monopolio digital,antimonopolio,antitrust,regulación tecnológica,ley de mercados digitales,protección de datos,privacidad,rgpd,gdpr,investigación regulatoria,multa antimonopolio,control de contenidos,moderación de contenidos,big tech,gigantes tecnológicos,empresas tecnológicas,multinacional tecnológica,ecosistema tecnológico,resultados trimestrales,beneficios récord,capitalización bursátil')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('economia_global', 'Economía Global', 4, 'economía,macroeconomía,pib,producto interior bruto,inflación,deflación,estanflación,recesión,desaceleración,crecimiento económico,actividad económica,balanza comercial,déficit,superávit,deuda pública,deuda soberana,estímulo fiscal,austeridad,ajuste estructural,mercados financieros,bolsa,acciones,índice bursátil,ibex,nasdaq,dow jones,sp500,ftse,nikkei,bonos,renta fija,renta variable,divisas,tipos de cambio,volatilidad,inversores,capitalización,crisis financiera,burbuja financiera,corrección del mercado,banca central,banco central,tipos de interés,política monetaria,quantitative easing,qe,subida de tipos,bce,fed,reserva federal,banco de inglaterra,banco de japón,tasa de referencia,inflación subyacente,petróleo,crudo,brent,wti,gas natural,carbón,energía,matérias primas,commodities,minería,cobre,litio,oro,plata,energía renovable,transición energética,opep,opep+,precio del petróleo,producción petrolera,comercio internacional,aranceles,exportaciones,importaciones,barreras comerciales,guerra comercial,organización mundial del comercio,omc,rcep,nafta,usmca,tratado de libre comercio,logística,cadena de suministro,supply chain,puertos,fletes,g7,g20,brics,fmi,fondo monetario internacional,banco mundial,ocde,foro de davos,wef,banco asiático de inversión,aiib,banco interamericano de desarrollo,bid,cepal,mercosur,unión europea económica,inversión,capital riesgo,private equity,fusiones y adquisiciones,m&a,inversión extranjera directa,ied,empresas multinacionales,gigantes empresariales,beneficios,dividendos,resultados trimestrales,balances,rentabilidad,bitcoin,ethereum,criptomonedas,criptoactivos,blockchain,fintech,banca digital,tokenización,defi,criptoexchange,volatilidad cripto,minería de bitcoin,crisis económica,crisis de deuda,crisis bancaria,riesgo país,tensiones económicas,colapso financiero,fuga de capitales,corralito,intervención estatal,desempleo,paro,ocupación,mercado laboral,salarios,negociación colectiva,coste de vida,pobreza,desigualdad,clase media,economía global,sistema financiero,competitividad,inestabilidad económica,política económica')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('desastres_y_crisis', 'Desastres y Crisis', 5, 'terremoto,sismo,seísmo,epicentro,magnitud,réplica,tsunami,maremoto,inundación,riada,lluvias torrenciales,crecida de río,huracán,tormenta tropical,tifón,ciclón,tornado,tormenta eléctrica,erupción volcánica,volcán,lava,ceniza volcánica,deslizamiento de tierra,corrimiento de tierras,alud,avalancha,sequía,ola de calor,ola de frío,incendio forestal,fuego,desastre natural,explosión,fuga tóxica,derrame químico,accidente industrial,planta química,accidente nuclear,reactor nuclear,radiación,fuga nuclear,contaminación,derrame petrolero,marea negra,colapso estructural,derrumbamiento,explosión de gas,accidente minero,atentado,ataque terrorista,terrorismo,bomba,artefacto explosivo,yihadista,estado islámico,isis,al qaeda,coche bomba,suicida,atacante,tiroteo masivo,radicalización,extremismo violento,guerra,conflicto armado,combates,batalla,frente de guerra,ofensiva,contraofensiva,bombardeo,incursión militar,ataque aéreo,ataque con drones,misiles,artillería,fuerzas armadas,tropas,movilización militar,invasión,ocupación,escalada,armamento,armas pesadas,genocidio,limpieza étnica,violaciones de derechos humanos,epidemia,pandemia,brote,virus,infección,covid,ebola,zika,gripe aviar,sars,mers,alerta sanitaria,cuarentena,aislamiento,contagio,colapso sanitario,emergencia de salud pública,crisis humanitaria,refugiados,desplazados,campamentos,hambruna,inseguridad alimentaria,falta de agua,ayuda humanitaria,emergencia humanitaria,crisis migratoria,socorro internacional,organizaciones de socorro,accidente,tragedia,fatalidades,víctimas,heridos,rescate,accidente de tráfico,accidente de carretera,accidente vial,colisión,choque frontal,alcance,salida de vía,autopista,carretera,caravana,atasco,retención,conductor herido,peatón atropellado,atropello,multitudinario,cadena de colisiones,choque múltiple,accidente de autobús,autobús volcado,accidente de camión,camión cisterna,vehículo incendiado,accidente mortal,accidente de avión,accidente aéreo,siniestralidad aérea,accidente ferroviario,descarrilamiento,tren siniestrado,accidente marítimo,naufragio,barco volcado,catástrofe,desastre,emergencia,alerta roja,alerta meteorológica,evacuación,crisis,devastación,pérdidas humanas,operativo de rescate')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('conflictos', 'Conflictos y Seguridad', 5, 'conflicto armado,guerra,guerra civil,combates,batalla,frente,frente de batalla,ofensiva,contraofensiva,incursión,incursión militar,invasión,ocupación,asedio,bombardeo,ataque aéreo,ataque terrestre,ataque con drones,misil,artillería,fuego cruzado,tropas,armamento,armas pesadas,militares,movilización,despliegue militar,zona de conflicto,golpe de estado,intentona golpista,junta militar,derrocamiento,toma del poder,ruptura institucional,estado de excepción,toque de queda,represión estatal,levantamiento,insurrección,motín,disturbios,protestas masivas,rebelión,sublevación,conflicto étnico,violencia sectaria,tensiones étnicas,limpieza étnica,persecución étnica,enfrentamiento tribal,violencia intercomunitaria,minorías perseguidas,atentado,ataque terrorista,terrorismo,extremismo,radicalización,yihadista,estado islámico,isis,al qaeda,talibanes,coche bomba,artefacto explosivo,suicida,milicia,guerrilla,grupo insurgente,insurgencia,paramilitares,señores de la guerra,cártel,mafia,crimen organizado,narcotráfico,tráfico de armas,tráfico de personas,extorsión,sicarios,bandas armadas,ciberataque,ciberataque masivo,hackeo,ataque informático,ataque ransomware,infiltración informática,phishing,ciberespionaje,filtración de datos,inteligencia militar,operación encubierta,guerra híbrida,desinformación,propaganda,sanciones,sanciones económicas,embargo,bloqueo económico,bloqueo comercial,castigo diplomático,retirada de embajadores,secuestro,rapto,toma de rehenes,ejecución,ejecución extrajudicial,asesinato político,magnicidio,intento de asesinato,masacre,tiroteo,fuerza letal,ataque coordinado,cascos azules,misión de paz,intervención militar,zona desmilitarizada,alto el fuego,tregua,acuerdo de paz,escalada,escalada militar,tensión internacional,amenaza,hostilidades,crisis de seguridad,conflicto internacional')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('elecciones_politica', 'Elecciones y Política', 3, 'elecciones,elección presidencial,elección parlamentaria,elecciones generales,elecciones regionales,elecciones locales,urna,votación,voto,recuento,escrutinio,participación electoral,abstención,jornada electoral,segunda vuelta,balotaje,candidato,candidatura,lista electoral,victoria electoral,derrota electoral,coalición electoral,campaña,mitin,debate electoral,debate televisado,programa electoral,promesas electorales,encuesta,sondeo,intención de voto,tracking electoral,eje izquierda-derecha,eslogan político,gira electoral,referéndum,plebiscito,consulta popular,consulta vinculante,autodeterminación,reforma constitucional,cambio de constitución,estatuto,referendo de independencia,fraude electoral,manipulación electoral,irregularidades,compra de votos,clientelismo,intimidación electoral,impugnación de resultados,protestas post-electorales,observadores internacionales,acusaciones de fraude,presidente,primer ministro,jefe de estado,jefe de gobierno,gabinete,ministro,secretario de estado,portavoz,alcalde,gobernador,diputado,senador,legislador,parlamento,asamblea,congreso,senado,cámara baja,cámara alta,comité parlamentario,mayoría absoluta,mayoría simple,oposición,disolución del parlamento,moción de censura,investidura,votación parlamentaria,partido político,coalición,alianza,bloque parlamentario,oposición política,izquierda,derecha,centro,extrema derecha,extrema izquierda,liberal,conservador,socialdemócrata,populismo,crisis política,dimisión,renuncia,interpelación,gobierno interino,vacancia,caída del gobierno,bloqueo institucional,parálisis política,estado de excepción político,política exterior,relaciones diplomáticas,acuerdos bilaterales,visita oficial,reconocimiento internacional,tensiones diplomáticas,embajador,ministerio de exteriores,corrupción,soborno,malversación,tráfico de influencias,escándalo político,investigación judicial,audiencia parlamentaria,comisión de investigación,imputación,procesamiento,manifestación,protesta,movilización,huelga general,huelga política,movimientos ciudadanos,activistas,revolución de colores,presión social,derechos civiles,gobierno,administración,estabilidad política,modelo político,transición política,proceso democrático,instituciones,estado de derecho,crisis institucional')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;
INSERT INTO topics (slug, name, weight, keywords) VALUES
('tecnologia', 'Tecnología', 3, 'inteligencia artificial,ia,algoritmo,machine learning,deep learning,red neuronal,modelo de lenguaje,modelo generativo,llm,transformer,genai,openai,chatgpt,gpt,anthropic,claude,google gemini,llama,metallama,hugging face,inferencias,entrenamiento de modelos,fine tuning,datasets,vectorización,embeddings,visión artificial,nlp,procesamiento de lenguaje natural,chips,semiconductores,nanómetros,oblea,gpu,cpu,asic,intel,amd,nvidia,arm,tsmc,samsung semiconductors,litografía,europa chips act,chiplets,memoria hbm,vrm,arquitectura computacional,supercomputador,hpc,robot,robótica,robot humanoide,automatización,drones,vehículos autónomos,coche autónomo,autopilot,industria 4.0,digital twins,iot,internet de las cosas,sensores inteligentes,domótica,smart home,ciberseguridad,ciberataque,ciberdefensa,phishing,ransomware,malware,spyware,vulnerabilidad,cve,zero-day,hackeo,intrusión,filtración de datos,brecha de seguridad,criptografía,seguridad informática,firewall,5g,6g,fibra óptica,redes móviles,torres de telecomunicaciones,infraestructura de red,satélites,starlink,orbital,ancho de banda,latencia,internet global,operadores de telecomunicaciones,redes privadas,software,aplicación,plataforma digital,startup,ecosistema tech,innovación,transformación digital,saas,paas,iaas,cloud,nube,computación en la nube,servidores,microservicios,contenedores,docker,kubernetes,devops,código abierto,open source,repositorio,api,microchips,firmware,computación cuántica,qubits,enfriamiento criogénico,superposición cuántica,enlace cuántico,computación distribuida,edge computing,fog computing,holografía,realidad aumentada,realidad virtual,metaverso,xr,visión por computador,apple,google,alphabet,tesla,meta,amazon,microsoft,tim cook,sundar pichai,elon musk,mark zuckerberg,silicon valley,gigante tecnológico,unicornios,big data,data mining,análisis predictivo,modelos estadísticos,data science,científico de datos,pipelines de datos,lagos de datos,etl,warehouse,baterías,ion-litio,carga rápida,movilidad eléctrica,supercargadores,vehículo eléctrico,eficiencia energética,tecnologías verdes,energía inteligente,tecnología,sector tecnológico,ecosistema digital,innovación disruptiva,avance tecnológico,desarrollo tecnológico')
ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name, weight = EXCLUDED.weight, keywords = EXCLUDED.keywords;

8
init-db/12-stats.sql Normal file
View file

@ -0,0 +1,8 @@
CREATE TABLE IF NOT EXISTS translation_stats (
id SERIAL PRIMARY KEY,
created_at TIMESTAMP DEFAULT NOW(),
lang_to VARCHAR(10)
);
CREATE INDEX IF NOT EXISTS idx_trans_stats_date ON translation_stats(created_at);
CREATE INDEX IF NOT EXISTS idx_trans_stats_lang ON translation_stats(lang_to);

8
init-db/13-entity-images.sql Normal file
View file

@ -0,0 +1,8 @@
CREATE TABLE IF NOT EXISTS entity_images (
id SERIAL PRIMARY KEY,
entity_name TEXT UNIQUE NOT NULL,
image_url TEXT,
summary TEXT,
source TEXT DEFAULT 'wikipedia',
last_checked TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

41
init-db/20-usuarios.sql Normal file
View file

@ -0,0 +1,41 @@
-- Tabla de usuarios
-- Almacena información de autenticación y perfil de usuarios
CREATE TABLE IF NOT EXISTS usuarios (
id SERIAL PRIMARY KEY,
username VARCHAR(50) NOT NULL UNIQUE,
email VARCHAR(255) NOT NULL UNIQUE,
password_hash VARCHAR(255) NOT NULL,
created_at TIMESTAMP DEFAULT NOW(),
updated_at TIMESTAMP DEFAULT NOW(),
last_login TIMESTAMP,
is_active BOOLEAN DEFAULT TRUE,
CONSTRAINT username_min_length CHECK (LENGTH(username) >= 3),
CONSTRAINT email_format CHECK (email ~* '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$')
);
-- Índices para búsquedas rápidas
CREATE INDEX IF NOT EXISTS idx_usuarios_username ON usuarios(username);
CREATE INDEX IF NOT EXISTS idx_usuarios_email ON usuarios(email);
CREATE INDEX IF NOT EXISTS idx_usuarios_active ON usuarios(is_active) WHERE is_active = TRUE;
-- Trigger para actualizar updated_at
CREATE OR REPLACE FUNCTION update_usuario_timestamp()
RETURNS TRIGGER AS $$
BEGIN
NEW.updated_at = NOW();
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
CREATE TRIGGER trigger_update_usuario_timestamp
BEFORE UPDATE ON usuarios
FOR EACH ROW
EXECUTE FUNCTION update_usuario_timestamp();
-- Comentarios
COMMENT ON TABLE usuarios IS 'Usuarios registrados del sistema';
COMMENT ON COLUMN usuarios.username IS 'Nombre de usuario único';
COMMENT ON COLUMN usuarios.email IS 'Correo electrónico único';
COMMENT ON COLUMN usuarios.password_hash IS 'Hash bcrypt de la contraseña';
COMMENT ON COLUMN usuarios.is_active IS 'Indica si la cuenta está activa';

27
init-db/21-search-history.sql Normal file
View file

@ -0,0 +1,27 @@
-- Tabla de historial de búsquedas
-- Registra todas las búsquedas realizadas por usuarios autenticados
CREATE TABLE IF NOT EXISTS search_history (
id SERIAL PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES usuarios(id) ON DELETE CASCADE,
query TEXT NOT NULL,
results_count INTEGER DEFAULT 0,
searched_at TIMESTAMP DEFAULT NOW(),
CONSTRAINT query_not_empty CHECK (LENGTH(TRIM(query)) > 0)
);
-- Índices para queries eficientes
CREATE INDEX IF NOT EXISTS idx_search_history_user_date
ON search_history(user_id, searched_at DESC);
CREATE INDEX IF NOT EXISTS idx_search_history_user_id
ON search_history(user_id);
-- Índice para buscar búsquedas populares
CREATE INDEX IF NOT EXISTS idx_search_history_query
ON search_history(query);
-- Comentarios
COMMENT ON TABLE search_history IS 'Historial de búsquedas de usuarios';
COMMENT ON COLUMN search_history.user_id IS 'Usuario que realizó la búsqueda';
COMMENT ON COLUMN search_history.query IS 'Término de búsqueda';
COMMENT ON COLUMN search_history.results_count IS 'Cantidad de resultados encontrados';

34
init-db/22-favoritos-migration.sql Normal file
View file

@ -0,0 +1,34 @@
-- Migración: Actualizar tabla favoritos para soportar usuarios autenticados
-- Añade columna user_id manteniendo retrocompatibilidad con session_id
-- Agregar columna user_id si no existe
DO $$
BEGIN
IF NOT EXISTS (
SELECT 1 FROM information_schema.columns
WHERE table_name = 'favoritos' AND column_name = 'user_id'
) THEN
ALTER TABLE favoritos ADD COLUMN user_id INTEGER REFERENCES usuarios(id) ON DELETE CASCADE;
END IF;
END $$;
-- Modificar constraint UNIQUE para incluir user_id
-- Primero eliminar constraint existente si existe
ALTER TABLE favoritos DROP CONSTRAINT IF EXISTS favoritos_session_id_noticia_id_key;
ALTER TABLE favoritos DROP CONSTRAINT IF EXISTS favoritos_unique_favorite;
-- Crear nuevo constraint que permite favoritos por user_id O session_id
ALTER TABLE favoritos ADD CONSTRAINT favoritos_unique_favorite
UNIQUE NULLS NOT DISTINCT (user_id, session_id, noticia_id);
-- Agregar check constraint: debe tener user_id O session_id (no ambos nulos)
ALTER TABLE favoritos DROP CONSTRAINT IF EXISTS favoritos_user_or_session;
ALTER TABLE favoritos ADD CONSTRAINT favoritos_user_or_session
CHECK (user_id IS NOT NULL OR session_id IS NOT NULL);
-- Crear índice en user_id para búsquedas rápidas
CREATE INDEX IF NOT EXISTS idx_favoritos_user_id ON favoritos(user_id);
-- Comentarios
COMMENT ON COLUMN favoritos.user_id IS 'Usuario autenticado (NULL si es favorito anónimo)';
COMMENT ON COLUMN favoritos.session_id IS 'ID de sesión anónima (NULL si usuario autenticado)';

2
init-db/30-add_avatar_url.sql Normal file
View file

@ -0,0 +1,2 @@
-- Add avatar_url column to users table if it doesn't exist
ALTER TABLE usuarios ADD COLUMN IF NOT EXISTS avatar_url TEXT;

38
init-db/31-add_feeds_pending_table.sql Normal file
View file

@ -0,0 +1,38 @@
-- Migration: Add pending feeds table for review workflow
-- This table stores discovered feeds that need manual review/approval
CREATE TABLE IF NOT EXISTS feeds_pending (
id SERIAL PRIMARY KEY,
fuente_url_id INTEGER REFERENCES fuentes_url(id) ON DELETE CASCADE,
feed_url TEXT NOT NULL UNIQUE,
feed_title VARCHAR(255),
feed_description TEXT,
feed_language CHAR(5),
feed_type VARCHAR(20),
entry_count INTEGER DEFAULT 0,
detected_country_id INTEGER REFERENCES paises(id),
suggested_categoria_id INTEGER REFERENCES categorias(id),
categoria_id INTEGER REFERENCES categorias(id),
pais_id INTEGER REFERENCES paises(id),
idioma CHAR(2),
discovered_at TIMESTAMP DEFAULT NOW(),
reviewed BOOLEAN DEFAULT FALSE,
approved BOOLEAN DEFAULT FALSE,
reviewed_at TIMESTAMP,
reviewed_by VARCHAR(100),
notes TEXT
);
CREATE INDEX IF NOT EXISTS idx_feeds_pending_reviewed ON feeds_pending(reviewed, approved);
CREATE INDEX IF NOT EXISTS idx_feeds_pending_fuente ON feeds_pending(fuente_url_id);
-- Add constraint to fuentes_url to require categoria_id or pais_id for processing
ALTER TABLE fuentes_url
ADD COLUMN IF NOT EXISTS require_review BOOLEAN DEFAULT TRUE,
ADD COLUMN IF NOT EXISTS auto_approve BOOLEAN DEFAULT FALSE;
COMMENT ON TABLE feeds_pending IS 'Feeds discovered but pending review/approval before being added to active feeds';
COMMENT ON COLUMN feeds_pending.detected_country_id IS 'Country detected automatically from feed language/domain';
COMMENT ON COLUMN feeds_pending.suggested_categoria_id IS 'Category suggested based on feed content/keywords';
COMMENT ON COLUMN fuentes_url.require_review IS 'If TRUE, feeds from this URL need manual approval';
COMMENT ON COLUMN fuentes_url.auto_approve IS 'If TRUE, feeds are automatically approved and activated';

7
init-db/32-add_traceability_cols.sql Normal file
View file

@ -0,0 +1,7 @@
-- Add fuente_url_id to feeds table for traceability
ALTER TABLE feeds
ADD COLUMN IF NOT EXISTS fuente_url_id INTEGER REFERENCES fuentes_url(id) ON DELETE SET NULL;
CREATE INDEX IF NOT EXISTS idx_feeds_fuente_url ON feeds(fuente_url_id);
COMMENT ON COLUMN feeds.fuente_url_id IS 'ID of the URL source that discovered this feed';

90
init-db/33-create_video_parrillas.sql Normal file
View file

@ -0,0 +1,90 @@
-- Script SQL para crear tablas de parrillas de noticias para videos
-- Tabla principal de parrillas/programaciones
CREATE TABLE IF NOT EXISTS video_parrillas (
id SERIAL PRIMARY KEY,
nombre VARCHAR(255) NOT NULL UNIQUE,
descripcion TEXT,
tipo_filtro VARCHAR(50) NOT NULL, -- 'pais', 'categoria', 'entidad', 'continente', 'custom'
-- Filtros
pais_id INTEGER REFERENCES paises(id),
categoria_id INTEGER REFERENCES categorias(id),
continente_id INTEGER REFERENCES continentes(id),
entidad_nombre VARCHAR(255), -- Para filtrar por persona/organización específica
entidad_tipo VARCHAR(50), -- 'persona', 'organizacion'
-- Configuración de generación
max_noticias INTEGER DEFAULT 5, -- Número máximo de noticias por video
duracion_maxima INTEGER DEFAULT 180, -- Duración máxima en segundos
idioma_voz VARCHAR(10) DEFAULT 'es', -- Idioma del TTS
voz_modelo VARCHAR(100), -- Modelo de voz específico a usar
-- Configuración de diseño
template VARCHAR(50) DEFAULT 'standard', -- 'standard', 'modern', 'minimal'
include_images BOOLEAN DEFAULT true,
include_subtitles BOOLEAN DEFAULT true,
-- Programación
frecuencia VARCHAR(20), -- 'daily', 'weekly', 'manual'
ultima_generacion TIMESTAMP,
proxima_generacion TIMESTAMP,
-- Estado
activo BOOLEAN DEFAULT true,
created_at TIMESTAMP DEFAULT NOW(),
updated_at TIMESTAMP DEFAULT NOW()
);
-- Tabla de videos generados
CREATE TABLE IF NOT EXISTS video_generados (
id SERIAL PRIMARY KEY,
parrilla_id INTEGER REFERENCES video_parrillas(id) ON DELETE CASCADE,
titulo VARCHAR(500) NOT NULL,
descripcion TEXT,
fecha_generacion TIMESTAMP DEFAULT NOW(),
-- Archivos
video_path VARCHAR(500),
audio_path VARCHAR(500),
subtitles_path VARCHAR(500),
thumbnail_path VARCHAR(500),
-- Metadata
duracion INTEGER, -- en segundos
num_noticias INTEGER,
noticias_ids TEXT[], -- Array de IDs de noticias incluidas
-- Estado de procesamiento
status VARCHAR(20) DEFAULT 'pending', -- 'pending', 'processing', 'completed', 'error'
error_message TEXT,
-- Estadísticas
views INTEGER DEFAULT 0,
created_at TIMESTAMP DEFAULT NOW()
);
-- Tabla de noticias en videos (relación muchos a muchos)
CREATE TABLE IF NOT EXISTS video_noticias (
id SERIAL PRIMARY KEY,
video_id INTEGER REFERENCES video_generados(id) ON DELETE CASCADE,
noticia_id VARCHAR(100) NOT NULL,
traduccion_id INTEGER REFERENCES traducciones(id),
orden INTEGER NOT NULL, -- Orden de aparición en el video
timestamp_inicio FLOAT, -- Segundo donde comienza esta noticia
timestamp_fin FLOAT, -- Segundo donde termina esta noticia
created_at TIMESTAMP DEFAULT NOW()
);
-- Índices para mejorar performance
CREATE INDEX IF NOT EXISTS idx_parrillas_tipo ON video_parrillas(tipo_filtro);
CREATE INDEX IF NOT EXISTS idx_parrillas_activo ON video_parrillas(activo);
CREATE INDEX IF NOT EXISTS idx_parrillas_proxima ON video_parrillas(proxima_generacion);
CREATE INDEX IF NOT EXISTS idx_videos_parrilla ON video_generados(parrilla_id);
CREATE INDEX IF NOT EXISTS idx_videos_status ON video_generados(status);
CREATE INDEX IF NOT EXISTS idx_videos_fecha ON video_generados(fecha_generacion DESC);
-- Comentarios para documentación
COMMENT ON TABLE video_parrillas IS 'Configuraciones de parrillas de noticias para generar videos automáticos';
COMMENT ON TABLE video_generados IS 'Videos generados a partir de parrillas de noticias';
COMMENT ON TABLE video_noticias IS 'Relación entre videos y las noticias que contienen';

49
init-db/34-add-search-vectors-es.sql Normal file
View file

@ -0,0 +1,49 @@
-- Add search_vector_es columns for full-text search in Spanish
-- This migration adds missing columns referenced in search.py
-- Add search_vector_es to noticias table
ALTER TABLE noticias ADD COLUMN IF NOT EXISTS search_vector_es tsvector;
-- Add search_vector_es to traducciones table
ALTER TABLE traducciones ADD COLUMN IF NOT EXISTS search_vector_es tsvector;
-- Create function to update noticias search_vector_es
CREATE OR REPLACE FUNCTION noticias_search_vector_es_trigger() RETURNS trigger AS $$
BEGIN
new.search_vector_es := setweight(to_tsvector('spanish', coalesce(new.titulo,'')), 'A') ||
setweight(to_tsvector('spanish', coalesce(new.resumen,'')), 'B');
return new;
END
$$ LANGUAGE plpgsql;
-- Create trigger for noticias
DROP TRIGGER IF EXISTS search_vector_es_update_noticias ON noticias;
CREATE TRIGGER search_vector_es_update_noticias
BEFORE INSERT OR UPDATE ON noticias
FOR EACH ROW EXECUTE PROCEDURE noticias_search_vector_es_trigger();
-- Create function to update traducciones search_vector_es
CREATE OR REPLACE FUNCTION traducciones_search_vector_es_trigger() RETURNS trigger AS $$
BEGIN
new.search_vector_es := setweight(to_tsvector('spanish', coalesce(new.titulo_trad,'')), 'A') ||
setweight(to_tsvector('spanish', coalesce(new.resumen_trad,'')), 'B');
return new;
END
$$ LANGUAGE plpgsql;
-- Create trigger for traducciones
DROP TRIGGER IF EXISTS search_vector_es_update_traducciones ON traducciones;
CREATE TRIGGER search_vector_es_update_traducciones
BEFORE INSERT OR UPDATE ON traducciones
FOR EACH ROW EXECUTE PROCEDURE traducciones_search_vector_es_trigger();
-- Create GIN indexes for fast full-text search
CREATE INDEX IF NOT EXISTS noticias_search_vector_es_idx ON noticias USING gin(search_vector_es);
CREATE INDEX IF NOT EXISTS traducciones_search_vector_es_idx ON traducciones USING gin(search_vector_es);
-- Update existing data
UPDATE noticias SET search_vector_es = to_tsvector('spanish', coalesce(titulo,'') || ' ' || coalesce(resumen,'')) WHERE search_vector_es IS NULL;
UPDATE traducciones SET search_vector_es = to_tsvector('spanish', coalesce(titulo_trad,'') || ' ' || coalesce(resumen_trad,'')) WHERE search_vector_es IS NULL;
-- Add composite index for traducciones search optimization
CREATE INDEX IF NOT EXISTS traducciones_search_composite_idx ON traducciones(lang_to, status) WHERE search_vector_es IS NOT NULL;

235
init-db/99_stable_keys.sql Normal file
View file

@ -0,0 +1,235 @@
-- 99_stable_keys.sql
-- Claves estables para continentes, categorías y países + índices
-- ===== Continentes: code estable =====
ALTER TABLE continentes
ADD COLUMN IF NOT EXISTS code TEXT UNIQUE;
UPDATE continentes SET code = CASE nombre
WHEN 'África' THEN 'AF'
WHEN 'América' THEN 'AM'
WHEN 'Asia' THEN 'AS'
WHEN 'Europa' THEN 'EU'
WHEN 'Oceanía' THEN 'OC'
WHEN 'Antártida' THEN 'AN'
END
WHERE code IS NULL;
-- ===== Categorías: slug estable =====
ALTER TABLE categorias
ADD COLUMN IF NOT EXISTS slug TEXT UNIQUE;
UPDATE categorias
SET slug = lower(regexp_replace(nombre, '\s+', '-', 'g'))
WHERE slug IS NULL;
-- ===== Países: ISO2 / ISO3 =====
ALTER TABLE paises
ADD COLUMN IF NOT EXISTS iso2 CHAR(2) UNIQUE,
ADD COLUMN IF NOT EXISTS iso3 CHAR(3) UNIQUE;
-- Mapeo ISO-3166 (alpha-2 / alpha-3) para TODOS los países de 04-paises.sql
-- Europa/Asia/África/Américas/Oceanía (nombres en español tal como en tu seed)
UPDATE paises SET iso2='AF', iso3='AFG' WHERE nombre='Afganistán' AND iso2 IS NULL;
UPDATE paises SET iso2='AL', iso3='ALB' WHERE nombre='Albania' AND iso2 IS NULL;
UPDATE paises SET iso2='DE', iso3='DEU' WHERE nombre='Alemania' AND iso2 IS NULL;
UPDATE paises SET iso2='AD', iso3='AND' WHERE nombre='Andorra' AND iso2 IS NULL;
UPDATE paises SET iso2='AO', iso3='AGO' WHERE nombre='Angola' AND iso2 IS NULL;
UPDATE paises SET iso2='AG', iso3='ATG' WHERE nombre='Antigua y Barbuda' AND iso2 IS NULL;
UPDATE paises SET iso2='SA', iso3='SAU' WHERE nombre='Arabia Saudita' AND iso2 IS NULL;
UPDATE paises SET iso2='DZ', iso3='DZA' WHERE nombre='Argelia' AND iso2 IS NULL;
UPDATE paises SET iso2='AR', iso3='ARG' WHERE nombre='Argentina' AND iso2 IS NULL;
UPDATE paises SET iso2='AM', iso3='ARM' WHERE nombre='Armenia' AND iso2 IS NULL;
UPDATE paises SET iso2='AU', iso3='AUS' WHERE nombre='Australia' AND iso2 IS NULL;
UPDATE paises SET iso2='AT', iso3='AUT' WHERE nombre='Austria' AND iso2 IS NULL;
UPDATE paises SET iso2='AZ', iso3='AZE' WHERE nombre='Azerbaiyán' AND iso2 IS NULL;
UPDATE paises SET iso2='BS', iso3='BHS' WHERE nombre='Bahamas' AND iso2 IS NULL;
UPDATE paises SET iso2='BD', iso3='BGD' WHERE nombre='Bangladés' AND iso2 IS NULL;
UPDATE paises SET iso2='BB', iso3='BRB' WHERE nombre='Barbados' AND iso2 IS NULL;
UPDATE paises SET iso2='BH', iso3='BHR' WHERE nombre='Baréin' AND iso2 IS NULL;
UPDATE paises SET iso2='BE', iso3='BEL' WHERE nombre='Bélgica' AND iso2 IS NULL;
UPDATE paises SET iso2='BZ', iso3='BLZ' WHERE nombre='Belice' AND iso2 IS NULL;
UPDATE paises SET iso2='BJ', iso3='BEN' WHERE nombre='Benín' AND iso2 IS NULL;
UPDATE paises SET iso2='BY', iso3='BLR' WHERE nombre='Bielorrusia' AND iso2 IS NULL;
UPDATE paises SET iso2='MM', iso3='MMR' WHERE nombre='Birmania' AND iso2 IS NULL;
UPDATE paises SET iso2='BO', iso3='BOL' WHERE nombre='Bolivia' AND iso2 IS NULL;
UPDATE paises SET iso2='BA', iso3='BIH' WHERE nombre='Bosnia y Herzegovina' AND iso2 IS NULL;
UPDATE paises SET iso2='BW', iso3='BWA' WHERE nombre='Botsuana' AND iso2 IS NULL;
UPDATE paises SET iso2='BR', iso3='BRA' WHERE nombre='Brasil' AND iso2 IS NULL;
UPDATE paises SET iso2='BN', iso3='BRN' WHERE nombre='Brunéi' AND iso2 IS NULL;
UPDATE paises SET iso2='BG', iso3='BGR' WHERE nombre='Bulgaria' AND iso2 IS NULL;
UPDATE paises SET iso2='BF', iso3='BFA' WHERE nombre='Burkina Faso' AND iso2 IS NULL;
UPDATE paises SET iso2='BI', iso3='BDI' WHERE nombre='Burundi' AND iso2 IS NULL;
UPDATE paises SET iso2='BT', iso3='BTN' WHERE nombre='Bután' AND iso2 IS NULL;
UPDATE paises SET iso2='CV', iso3='CPV' WHERE nombre='Cabo Verde' AND iso2 IS NULL;
UPDATE paises SET iso2='KH', iso3='KHM' WHERE nombre='Camboya' AND iso2 IS NULL;
UPDATE paises SET iso2='CM', iso3='CMR' WHERE nombre='Camerún' AND iso2 IS NULL;
UPDATE paises SET iso2='CA', iso3='CAN' WHERE nombre='Canadá' AND iso2 IS NULL;
UPDATE paises SET iso2='QA', iso3='QAT' WHERE nombre='Catar' AND iso2 IS NULL;
UPDATE paises SET iso2='TD', iso3='TCD' WHERE nombre='Chad' AND iso2 IS NULL;
UPDATE paises SET iso2='CL', iso3='CHL' WHERE nombre='Chile' AND iso2 IS NULL;
UPDATE paises SET iso2='CN', iso3='CHN' WHERE nombre='China' AND iso2 IS NULL;
UPDATE paises SET iso2='CY', iso3='CYP' WHERE nombre='Chipre' AND iso2 IS NULL;
UPDATE paises SET iso2='CO', iso3='COL' WHERE nombre='Colombia' AND iso2 IS NULL;
UPDATE paises SET iso2='KM', iso3='COM' WHERE nombre='Comoras' AND iso2 IS NULL;
UPDATE paises SET iso2='KP', iso3='PRK' WHERE nombre='Corea del Norte' AND iso2 IS NULL;
UPDATE paises SET iso2='KR', iso3='KOR' WHERE nombre='Corea del Sur' AND iso2 IS NULL;
UPDATE paises SET iso2='CI', iso3='CIV' WHERE nombre='Costa de Marfil' AND iso2 IS NULL;
UPDATE paises SET iso2='CR', iso3='CRI' WHERE nombre='Costa Rica' AND iso2 IS NULL;
UPDATE paises SET iso2='HR', iso3='HRV' WHERE nombre='Croacia' AND iso2 IS NULL;
UPDATE paises SET iso2='CU', iso3='CUB' WHERE nombre='Cuba' AND iso2 IS NULL;
UPDATE paises SET iso2='DK', iso3='DNK' WHERE nombre='Dinamarca' AND iso2 IS NULL;
UPDATE paises SET iso2='DM', iso3='DMA' WHERE nombre='Dominica' AND iso2 IS NULL;
UPDATE paises SET iso2='EC', iso3='ECU' WHERE nombre='Ecuador' AND iso2 IS NULL;
UPDATE paises SET iso2='EG', iso3='EGY' WHERE nombre='Egipto' AND iso2 IS NULL;
UPDATE paises SET iso2='SV', iso3='SLV' WHERE nombre='El Salvador' AND iso2 IS NULL;
UPDATE paises SET iso2='AE', iso3='ARE' WHERE nombre='Emiratos Árabes Unidos' AND iso2 IS NULL;
UPDATE paises SET iso2='ER', iso3='ERI' WHERE nombre='Eritrea' AND iso2 IS NULL;
UPDATE paises SET iso2='SK', iso3='SVK' WHERE nombre='Eslovaquia' AND iso2 IS NULL;
UPDATE paises SET iso2='SI', iso3='SVN' WHERE nombre='Eslovenia' AND iso2 IS NULL;
UPDATE paises SET iso2='ES', iso3='ESP' WHERE nombre='España' AND iso2 IS NULL;
UPDATE paises SET iso2='US', iso3='USA' WHERE nombre='Estados Unidos' AND iso2 IS NULL;
UPDATE paises SET iso2='EE', iso3='EST' WHERE nombre='Estonia' AND iso2 IS NULL;
UPDATE paises SET iso2='SZ', iso3='SWZ' WHERE nombre='Esuatini' AND iso2 IS NULL;
UPDATE paises SET iso2='ET', iso3='ETH' WHERE nombre='Etiopía' AND iso2 IS NULL;
UPDATE paises SET iso2='PH', iso3='PHL' WHERE nombre='Filipinas' AND iso2 IS NULL;
UPDATE paises SET iso2='FI', iso3='FIN' WHERE nombre='Finlandia' AND iso2 IS NULL;
UPDATE paises SET iso2='FJ', iso3='FJI' WHERE nombre='Fiyi' AND iso2 IS NULL;
UPDATE paises SET iso2='FR', iso3='FRA' WHERE nombre='Francia' AND iso2 IS NULL;
UPDATE paises SET iso2='GA', iso3='GAB' WHERE nombre='Gabón' AND iso2 IS NULL;
UPDATE paises SET iso2='GM', iso3='GMB' WHERE nombre='Gambia' AND iso2 IS NULL;
UPDATE paises SET iso2='GE', iso3='GEO' WHERE nombre='Georgia' AND iso2 IS NULL;
UPDATE paises SET iso2='GH', iso3='GHA' WHERE nombre='Ghana' AND iso2 IS NULL;
UPDATE paises SET iso2='GD', iso3='GRD' WHERE nombre='Granada' AND iso2 IS NULL;
UPDATE paises SET iso2='GR', iso3='GRC' WHERE nombre='Grecia' AND iso2 IS NULL;
UPDATE paises SET iso2='GT', iso3='GTM' WHERE nombre='Guatemala' AND iso2 IS NULL;
UPDATE paises SET iso2='GN', iso3='GIN' WHERE nombre='Guinea' AND iso2 IS NULL;
UPDATE paises SET iso2='GW', iso3='GNB' WHERE nombre='Guinea-Bisáu' AND iso2 IS NULL;
UPDATE paises SET iso2='GQ', iso3='GNQ' WHERE nombre='Guinea Ecuatorial' AND iso2 IS NULL;
UPDATE paises SET iso2='GY', iso3='GUY' WHERE nombre='Guyana' AND iso2 IS NULL;
UPDATE paises SET iso2='HT', iso3='HTI' WHERE nombre='Haití' AND iso2 IS NULL;
UPDATE paises SET iso2='HN', iso3='HND' WHERE nombre='Honduras' AND iso2 IS NULL;
UPDATE paises SET iso2='HU', iso3='HUN' WHERE nombre='Hungría' AND iso2 IS NULL;
UPDATE paises SET iso2='IN', iso3='IND' WHERE nombre='India' AND iso2 IS NULL;
UPDATE paises SET iso2='ID', iso3='IDN' WHERE nombre='Indonesia' AND iso2 IS NULL;
UPDATE paises SET iso2='IQ', iso3='IRQ' WHERE nombre='Irak' AND iso2 IS NULL;
UPDATE paises SET iso2='IR', iso3='IRN' WHERE nombre='Irán' AND iso2 IS NULL;
UPDATE paises SET iso2='IE', iso3='IRL' WHERE nombre='Irlanda' AND iso2 IS NULL;
UPDATE paises SET iso2='IS', iso3='ISL' WHERE nombre='Islandia' AND iso2 IS NULL;
UPDATE paises SET iso2='MH', iso3='MHL' WHERE nombre='Islas Marshall' AND iso2 IS NULL;
UPDATE paises SET iso2='SB', iso3='SLB' WHERE nombre='Islas Salomón' AND iso2 IS NULL;
UPDATE paises SET iso2='IL', iso3='ISR' WHERE nombre='Israel' AND iso2 IS NULL;
UPDATE paises SET iso2='IT', iso3='ITA' WHERE nombre='Italia' AND iso2 IS NULL;
UPDATE paises SET iso2='JM', iso3='JAM' WHERE nombre='Jamaica' AND iso2 IS NULL;
UPDATE paises SET iso2='JP', iso3='JPN' WHERE nombre='Japón' AND iso2 IS NULL;
UPDATE paises SET iso2='JO', iso3='JOR' WHERE nombre='Jordania' AND iso2 IS NULL;
UPDATE paises SET iso2='KZ', iso3='KAZ' WHERE nombre='Kazajistán' AND iso2 IS NULL;
UPDATE paises SET iso2='KE', iso3='KEN' WHERE nombre='Kenia' AND iso2 IS NULL;
UPDATE paises SET iso2='KG', iso3='KGZ' WHERE nombre='Kirguistán' AND iso2 IS NULL;
UPDATE paises SET iso2='KI', iso3='KIR' WHERE nombre='Kiribati' AND iso2 IS NULL;
UPDATE paises SET iso2='KW', iso3='KWT' WHERE nombre='Kuwait' AND iso2 IS NULL;
UPDATE paises SET iso2='LA', iso3='LAO' WHERE nombre='Laos' AND iso2 IS NULL;
UPDATE paises SET iso2='LS', iso3='LSO' WHERE nombre='Lesoto' AND iso2 IS NULL;
UPDATE paises SET iso2='LV', iso3='LVA' WHERE nombre='Letonia' AND iso2 IS NULL;
UPDATE paises SET iso2='LB', iso3='LBN' WHERE nombre='Líbano' AND iso2 IS NULL;
UPDATE paises SET iso2='LR', iso3='LBR' WHERE nombre='Liberia' AND iso2 IS NULL;
UPDATE paises SET iso2='LY', iso3='LBY' WHERE nombre='Libia' AND iso2 IS NULL;
UPDATE paises SET iso2='LI', iso3='LIE' WHERE nombre='Liechtenstein' AND iso2 IS NULL;
UPDATE paises SET iso2='LT', iso3='LTU' WHERE nombre='Lituania' AND iso2 IS NULL;
UPDATE paises SET iso2='LU', iso3='LUX' WHERE nombre='Luxemburgo' AND iso2 IS NULL;
UPDATE paises SET iso2='MK', iso3='MKD' WHERE nombre='Macedonia del Norte' AND iso2 IS NULL;
UPDATE paises SET iso2='MG', iso3='MDG' WHERE nombre='Madagascar' AND iso2 IS NULL;
UPDATE paises SET iso2='MY', iso3='MYS' WHERE nombre='Malasia' AND iso2 IS NULL;
UPDATE paises SET iso2='MW', iso3='MWI' WHERE nombre='Malaui' AND iso2 IS NULL;
UPDATE paises SET iso2='MV', iso3='MDV' WHERE nombre='Maldivas' AND iso2 IS NULL;
UPDATE paises SET iso2='ML', iso3='MLI' WHERE nombre='Malí' AND iso2 IS NULL;
UPDATE paises SET iso2='MT', iso3='MLT' WHERE nombre='Malta' AND iso2 IS NULL;
UPDATE paises SET iso2='MA', iso3='MAR' WHERE nombre='Marruecos' AND iso2 IS NULL;
UPDATE paises SET iso2='MU', iso3='MUS' WHERE nombre='Mauricio' AND iso2 IS NULL;
UPDATE paises SET iso2='MR', iso3='MRT' WHERE nombre='Mauritania' AND iso2 IS NULL;
UPDATE paises SET iso2='MX', iso3='MEX' WHERE nombre='México' AND iso2 IS NULL;
UPDATE paises SET iso2='FM', iso3='FSM' WHERE nombre='Micronesia' AND iso2 IS NULL;
UPDATE paises SET iso2='MD', iso3='MDA' WHERE nombre='Moldavia' AND iso2 IS NULL;
UPDATE paises SET iso2='MC', iso3='MCO' WHERE nombre='Mónaco' AND iso2 IS NULL;
UPDATE paises SET iso2='MN', iso3='MNG' WHERE nombre='Mongolia' AND iso2 IS NULL;
UPDATE paises SET iso2='ME', iso3='MNE' WHERE nombre='Montenegro' AND iso2 IS NULL;
UPDATE paises SET iso2='MZ', iso3='MOZ' WHERE nombre='Mozambique' AND iso2 IS NULL;
UPDATE paises SET iso2='NA', iso3='NAM' WHERE nombre='Namibia' AND iso2 IS NULL;
UPDATE paises SET iso2='NR', iso3='NRU' WHERE nombre='Nauru' AND iso2 IS NULL;
UPDATE paises SET iso2='NP', iso3='NPL' WHERE nombre='Nepal' AND iso2 IS NULL;
UPDATE paises SET iso2='NI', iso3='NIC' WHERE nombre='Nicaragua' AND iso2 IS NULL;
UPDATE paises SET iso2='NE', iso3='NER' WHERE nombre='Níger' AND iso2 IS NULL;
UPDATE paises SET iso2='NG', iso3='NGA' WHERE nombre='Nigeria' AND iso2 IS NULL;
UPDATE paises SET iso2='NO', iso3='NOR' WHERE nombre='Noruega' AND iso2 IS NULL;
UPDATE paises SET iso2='NZ', iso3='NZL' WHERE nombre='Nueva Zelanda' AND iso2 IS NULL;
UPDATE paises SET iso2='OM', iso3='OMN' WHERE nombre='Omán' AND iso2 IS NULL;
UPDATE paises SET iso2='NL', iso3='NLD' WHERE nombre='Países Bajos' AND iso2 IS NULL;
UPDATE paises SET iso2='PK', iso3='PAK' WHERE nombre='Pakistán' AND iso2 IS NULL;
UPDATE paises SET iso2='PW', iso3='PLW' WHERE nombre='Palaos' AND iso2 IS NULL;
UPDATE paises SET iso2='PS', iso3='PSE' WHERE nombre='Palestina' AND iso2 IS NULL;
UPDATE paises SET iso2='PA', iso3='PAN' WHERE nombre='Panamá' AND iso2 IS NULL;
UPDATE paises SET iso2='PG', iso3='PNG' WHERE nombre='Papúa Nueva Guinea' AND iso2 IS NULL;
UPDATE paises SET iso2='PY', iso3='PRY' WHERE nombre='Paraguay' AND iso2 IS NULL;
UPDATE paises SET iso2='PE', iso3='PER' WHERE nombre='Perú' AND iso2 IS NULL;
UPDATE paises SET iso2='PL', iso3='POL' WHERE nombre='Polonia' AND iso2 IS NULL;
UPDATE paises SET iso2='PT', iso3='PRT' WHERE nombre='Portugal' AND iso2 IS NULL;
UPDATE paises SET iso2='GB', iso3='GBR' WHERE nombre='Reino Unido' AND iso2 IS NULL;
UPDATE paises SET iso2='CF', iso3='CAF' WHERE nombre='República Centroafricana' AND iso2 IS NULL;
UPDATE paises SET iso2='CZ', iso3='CZE' WHERE nombre='República Checa' AND iso2 IS NULL;
UPDATE paises SET iso2='CG', iso3='COG' WHERE nombre='República del Congo' AND iso2 IS NULL;
UPDATE paises SET iso2='CD', iso3='COD' WHERE nombre='República Democrática del Congo' AND iso2 IS NULL;
UPDATE paises SET iso2='DO', iso3='DOM' WHERE nombre='República Dominicana' AND iso2 IS NULL;
UPDATE paises SET iso2='RW', iso3='RWA' WHERE nombre='Ruanda' AND iso2 IS NULL;
UPDATE paises SET iso2='RO', iso3='ROU' WHERE nombre='Rumanía' AND iso2 IS NULL;
UPDATE paises SET iso2='RU', iso3='RUS' WHERE nombre='Rusia' AND iso2 IS NULL;
UPDATE paises SET iso2='WS', iso3='WSM' WHERE nombre='Samoa' AND iso2 IS NULL;
UPDATE paises SET iso2='KN', iso3='KNA' WHERE nombre='San Cristóbal y Nieves' AND iso2 IS NULL;
UPDATE paises SET iso2='SM', iso3='SMR' WHERE nombre='San Marino' AND iso2 IS NULL;
UPDATE paises SET iso2='VC', iso3='VCT' WHERE nombre='San Vicente y las Granadinas' AND iso2 IS NULL;
UPDATE paises SET iso2='LC', iso3='LCA' WHERE nombre='Santa Lucía' AND iso2 IS NULL;
UPDATE paises SET iso2='ST', iso3='STP' WHERE nombre='Santo Tomé y Príncipe' AND iso2 IS NULL;
UPDATE paises SET iso2='SN', iso3='SEN' WHERE nombre='Senegal' AND iso2 IS NULL;
UPDATE paises SET iso2='RS', iso3='SRB' WHERE nombre='Serbia' AND iso2 IS NULL;
UPDATE paises SET iso2='SC', iso3='SYC' WHERE nombre='Seychelles' AND iso2 IS NULL;
UPDATE paises SET iso2='SL', iso3='SLE' WHERE nombre='Sierra Leona' AND iso2 IS NULL;
UPDATE paises SET iso2='SG', iso3='SGP' WHERE nombre='Singapur' AND iso2 IS NULL;
UPDATE paises SET iso2='SY', iso3='SYR' WHERE nombre='Siria' AND iso2 IS NULL;
UPDATE paises SET iso2='SO', iso3='SOM' WHERE nombre='Somalia' AND iso2 IS NULL;
UPDATE paises SET iso2='LK', iso3='LKA' WHERE nombre='Sri Lanka' AND iso2 IS NULL;
UPDATE paises SET iso2='ZA', iso3='ZAF' WHERE nombre='Sudáfrica' AND iso2 IS NULL;
UPDATE paises SET iso2='SD', iso3='SDN' WHERE nombre='Sudán' AND iso2 IS NULL;
UPDATE paises SET iso2='SS', iso3='SSD' WHERE nombre='Sudán del Sur' AND iso2 IS NULL;
UPDATE paises SET iso2='SE', iso3='SWE' WHERE nombre='Suecia' AND iso2 IS NULL;
UPDATE paises SET iso2='CH', iso3='CHE' WHERE nombre='Suiza' AND iso2 IS NULL;
UPDATE paises SET iso2='SR', iso3='SUR' WHERE nombre='Surinam' AND iso2 IS NULL;
UPDATE paises SET iso2='TH', iso3='THA' WHERE nombre='Tailandia' AND iso2 IS NULL;
UPDATE paises SET iso2='TZ', iso3='TZA' WHERE nombre='Tanzania' AND iso2 IS NULL;
UPDATE paises SET iso2='TJ', iso3='TJK' WHERE nombre='Tayikistán' AND iso2 IS NULL;
UPDATE paises SET iso2='TL', iso3='TLS' WHERE nombre='Timor Oriental' AND iso2 IS NULL;
UPDATE paises SET iso2='TG', iso3='TGO' WHERE nombre='Togo' AND iso2 IS NULL;
UPDATE paises SET iso2='TO', iso3='TON' WHERE nombre='Tonga' AND iso2 IS NULL;
UPDATE paises SET iso2='TT', iso3='TTO' WHERE nombre='Trinidad y Tobago' AND iso2 IS NULL;
UPDATE paises SET iso2='TN', iso3='TUN' WHERE nombre='Túnez' AND iso2 IS NULL;
UPDATE paises SET iso2='TM', iso3='TKM' WHERE nombre='Turkmenistán' AND iso2 IS NULL;
UPDATE paises SET iso2='TR', iso3='TUR' WHERE nombre='Turquía' AND iso2 IS NULL;
UPDATE paises SET iso2='TV', iso3='TUV' WHERE nombre='Tuvalu' AND iso2 IS NULL;
UPDATE paises SET iso2='UA', iso3='UKR' WHERE nombre='Ucrania' AND iso2 IS NULL;
UPDATE paises SET iso2='UG', iso3='UGA' WHERE nombre='Uganda' AND iso2 IS NULL;
UPDATE paises SET iso2='UY', iso3='URY' WHERE nombre='Uruguay' AND iso2 IS NULL;
UPDATE paises SET iso2='UZ', iso3='UZB' WHERE nombre='Uzbekistán' AND iso2 IS NULL;
UPDATE paises SET iso2='VU', iso3='VUT' WHERE nombre='Vanuatu' AND iso2 IS NULL;
UPDATE paises SET iso2='VA', iso3='VAT' WHERE nombre='Vaticano' AND iso2 IS NULL;
UPDATE paises SET iso2='VE', iso3='VEN' WHERE nombre='Venezuela' AND iso2 IS NULL;
UPDATE paises SET iso2='VN', iso3='VNM' WHERE nombre='Vietnam' AND iso2 IS NULL;
UPDATE paises SET iso2='YE', iso3='YEM' WHERE nombre='Yemen' AND iso2 IS NULL;
UPDATE paises SET iso2='DJ', iso3='DJI' WHERE nombre='Yibuti' AND iso2 IS NULL;
UPDATE paises SET iso2='ZM', iso3='ZMB' WHERE nombre='Zambia' AND iso2 IS NULL;
UPDATE paises SET iso2='ZW', iso3='ZWE' WHERE nombre='Zimbabue' AND iso2 IS NULL;
-- ===== Índices útiles =====
CREATE INDEX IF NOT EXISTS idx_continentes_code ON continentes(code);
CREATE INDEX IF NOT EXISTS idx_categorias_slug ON categorias(slug);
CREATE INDEX IF NOT EXISTS idx_paises_iso2 ON paises(iso2);
CREATE INDEX IF NOT EXISTS idx_paises_iso3 ON paises(iso3);

2
migrations/add_avatar_url.sql Normal file
View file

@ -0,0 +1,2 @@
-- Add avatar_url column to users table if it doesn't exist
ALTER TABLE usuarios ADD COLUMN IF NOT EXISTS avatar_url TEXT;

38
migrations/add_feeds_pending_table.sql Normal file
View file

@ -0,0 +1,38 @@
-- Migration: Add pending feeds table for review workflow
-- This table stores discovered feeds that need manual review/approval
CREATE TABLE IF NOT EXISTS feeds_pending (
id SERIAL PRIMARY KEY,
fuente_url_id INTEGER REFERENCES fuentes_url(id) ON DELETE CASCADE,
feed_url TEXT NOT NULL UNIQUE,
feed_title VARCHAR(255),
feed_description TEXT,
feed_language CHAR(5),
feed_type VARCHAR(20),
entry_count INTEGER DEFAULT 0,
detected_country_id INTEGER REFERENCES paises(id),
suggested_categoria_id INTEGER REFERENCES categorias(id),
categoria_id INTEGER REFERENCES categorias(id),
pais_id INTEGER REFERENCES paises(id),
idioma CHAR(2),
discovered_at TIMESTAMP DEFAULT NOW(),
reviewed BOOLEAN DEFAULT FALSE,
approved BOOLEAN DEFAULT FALSE,
reviewed_at TIMESTAMP,
reviewed_by VARCHAR(100),
notes TEXT
);
CREATE INDEX IF NOT EXISTS idx_feeds_pending_reviewed ON feeds_pending(reviewed, approved);
CREATE INDEX IF NOT EXISTS idx_feeds_pending_fuente ON feeds_pending(fuente_url_id);
-- Add constraint to fuentes_url to require categoria_id or pais_id for processing
ALTER TABLE fuentes_url
ADD COLUMN IF NOT EXISTS require_review BOOLEAN DEFAULT TRUE,
ADD COLUMN IF NOT EXISTS auto_approve BOOLEAN DEFAULT FALSE;
COMMENT ON TABLE feeds_pending IS 'Feeds discovered but pending review/approval before being added to active feeds';
COMMENT ON COLUMN feeds_pending.detected_country_id IS 'Country detected automatically from feed language/domain';
COMMENT ON COLUMN feeds_pending.suggested_categoria_id IS 'Category suggested based on feed content/keywords';
COMMENT ON COLUMN fuentes_url.require_review IS 'If TRUE, feeds from this URL need manual approval';
COMMENT ON COLUMN fuentes_url.auto_approve IS 'If TRUE, feeds are automatically approved and activated';

7
migrations/add_traceability_cols.sql Normal file
View file

@ -0,0 +1,7 @@
-- Add fuente_url_id to feeds table for traceability
ALTER TABLE feeds
ADD COLUMN IF NOT EXISTS fuente_url_id INTEGER REFERENCES fuentes_url(id) ON DELETE SET NULL;
CREATE INDEX IF NOT EXISTS idx_feeds_fuente_url ON feeds(fuente_url_id);
COMMENT ON COLUMN feeds.fuente_url_id IS 'ID of the URL source that discovered this feed';

90
migrations/create_video_parrillas.sql Normal file
View file

@ -0,0 +1,90 @@
-- Script SQL para crear tablas de parrillas de noticias para videos
-- Tabla principal de parrillas/programaciones
CREATE TABLE IF NOT EXISTS video_parrillas (
id SERIAL PRIMARY KEY,
nombre VARCHAR(255) NOT NULL UNIQUE,
descripcion TEXT,
tipo_filtro VARCHAR(50) NOT NULL, -- 'pais', 'categoria', 'entidad', 'continente', 'custom'
-- Filtros
pais_id INTEGER REFERENCES paises(id),
categoria_id INTEGER REFERENCES categorias(id),
continente_id INTEGER REFERENCES continentes(id),
entidad_nombre VARCHAR(255), -- Para filtrar por persona/organización específica
entidad_tipo VARCHAR(50), -- 'persona', 'organizacion'
-- Configuración de generación
max_noticias INTEGER DEFAULT 5, -- Número máximo de noticias por video
duracion_maxima INTEGER DEFAULT 180, -- Duración máxima en segundos
idioma_voz VARCHAR(10) DEFAULT 'es', -- Idioma del TTS
voz_modelo VARCHAR(100), -- Modelo de voz específico a usar
-- Configuración de diseño
template VARCHAR(50) DEFAULT 'standard', -- 'standard', 'modern', 'minimal'
include_images BOOLEAN DEFAULT true,
include_subtitles BOOLEAN DEFAULT true,
-- Programación
frecuencia VARCHAR(20), -- 'daily', 'weekly', 'manual'
ultima_generacion TIMESTAMP,
proxima_generacion TIMESTAMP,
-- Estado
activo BOOLEAN DEFAULT true,
created_at TIMESTAMP DEFAULT NOW(),
updated_at TIMESTAMP DEFAULT NOW()
);
-- Tabla de videos generados
CREATE TABLE IF NOT EXISTS video_generados (
id SERIAL PRIMARY KEY,
parrilla_id INTEGER REFERENCES video_parrillas(id) ON DELETE CASCADE,
titulo VARCHAR(500) NOT NULL,
descripcion TEXT,
fecha_generacion TIMESTAMP DEFAULT NOW(),
-- Archivos
video_path VARCHAR(500),
audio_path VARCHAR(500),
subtitles_path VARCHAR(500),
thumbnail_path VARCHAR(500),
-- Metadata
duracion INTEGER, -- en segundos
num_noticias INTEGER,
noticias_ids TEXT[], -- Array de IDs de noticias incluidas
-- Estado de procesamiento
status VARCHAR(20) DEFAULT 'pending', -- 'pending', 'processing', 'completed', 'error'
error_message TEXT,
-- Estadísticas
views INTEGER DEFAULT 0,
created_at TIMESTAMP DEFAULT NOW()
);
-- Tabla de noticias en videos (relación muchos a muchos)
CREATE TABLE IF NOT EXISTS video_noticias (
id SERIAL PRIMARY KEY,
video_id INTEGER REFERENCES video_generados(id) ON DELETE CASCADE,
noticia_id VARCHAR(100) NOT NULL,
traduccion_id INTEGER REFERENCES traducciones(id),
orden INTEGER NOT NULL, -- Orden de aparición en el video
timestamp_inicio FLOAT, -- Segundo donde comienza esta noticia
timestamp_fin FLOAT, -- Segundo donde termina esta noticia
created_at TIMESTAMP DEFAULT NOW()
);
-- Índices para mejorar performance
CREATE INDEX IF NOT EXISTS idx_parrillas_tipo ON video_parrillas(tipo_filtro);
CREATE INDEX IF NOT EXISTS idx_parrillas_activo ON video_parrillas(activo);
CREATE INDEX IF NOT EXISTS idx_parrillas_proxima ON video_parrillas(proxima_generacion);
CREATE INDEX IF NOT EXISTS idx_videos_parrilla ON video_generados(parrilla_id);
CREATE INDEX IF NOT EXISTS idx_videos_status ON video_generados(status);
CREATE INDEX IF NOT EXISTS idx_videos_fecha ON video_generados(fecha_generacion DESC);
-- Comentarios para documentación
COMMENT ON TABLE video_parrillas IS 'Configuraciones de parrillas de noticias para generar videos automáticos';
COMMENT ON TABLE video_generados IS 'Videos generados a partir de parrillas de noticias';
COMMENT ON TABLE video_noticias IS 'Relación entre videos y las noticias que contienen';

12
models/categorias.py
View file

@ -1,9 +1,19 @@
from psycopg2 import extras
from typing import List, Dict
from cache import cache_get, cache_set
def get_categorias(conn) -> List[Dict]:
# Intentar desde caché primero (datos casi estáticos)
cached_data = cache_get("categorias:all")
if cached_data:
return cached_data
with conn.cursor(cursor_factory=extras.DictCursor) as cur:
cur.execute("SELECT id, nombre FROM categorias ORDER BY nombre;")
return cur.fetchall()
result = cur.fetchall()
# Cachear por 1 hora (son datos estáticos)
cache_set("categorias:all", result, ttl_seconds=3600)
return result

337
models/describe.txt
View file

@ -1,337 +0,0 @@
models/
├── __init__.py # Paquete Python (vacío)
├── categorias.py # Operaciones con categorías
├── feeds.py # Operaciones con feeds RSS
├── noticias.py # Búsqueda y consulta de noticias
└── paises.py # Operaciones con países
└── traducciones.py # Operaciones con traducciones
init.py
Propósito: Archivo necesario para que Python reconozca este directorio como un paquete.
Contenido: Vacío o comentario explicativo.
Uso: Permite importar módulos desde models:
python
from models.noticias import buscar_noticias
categorias.py
Propósito: Maneja todas las operaciones relacionadas con categorías de noticias.
Funciones principales:
get_categorias(conn) -> List[Dict]
Descripción: Obtiene todas las categorías disponibles ordenadas alfabéticamente.
Parámetros:
conn: Conexión a PostgreSQL activa
Consulta SQL:
sql
SELECT id, nombre FROM categorias ORDER BY nombre;
Retorna: Lista de diccionarios con estructura:
python
[
{"id": 1, "nombre": "Política"},
{"id": 2, "nombre": "Deportes"},
...
]
Uso típico: Para llenar dropdowns de filtrado en la interfaz web.
feeds.py
Propósito: Maneja operaciones relacionadas con feeds RSS.
Funciones principales:
get_feed_by_id(conn, feed_id: int) -> Optional[Dict]
Descripción: Obtiene un feed específico por su ID.
Parámetros:
conn: Conexión a PostgreSQL
feed_id: ID numérico del feed
Consulta SQL:
sql
SELECT * FROM feeds WHERE id = %s;
Retorna: Un diccionario con todos los campos del feed o None si no existe.
get_feeds_activos(conn) -> List[Dict]
Descripción: Obtiene todos los feeds activos y no caídos.
Criterios de activos:
activo = TRUE
fallos < 5 (o NULL)
Consulta SQL:
sql
SELECT id, nombre, url, categoria_id, pais_id, fallos, activo
FROM feeds
WHERE activo = TRUE
AND (fallos IS NULL OR fallos < 5)
ORDER BY id;
Retorna: Lista de feeds activos para el ingestor RSS.
Uso crítico: Esta función es utilizada por rss_ingestor.py para determinar qué feeds procesar.
noticias.py
Propósito: Módulo más complejo que maneja todas las operaciones de búsqueda y consulta de noticias.
Funciones auxiliares:
_extraer_tags_por_traduccion(cur, traduccion_ids: List[int]) -> Dict[int, List[tuple]]
Descripción: Función privada que obtiene tags agrupados por ID de traducción.
Parámetros:
cur: Cursor de base de datos
traduccion_ids: Lista de IDs de traducciones
Consulta SQL:
sql
SELECT tn.traduccion_id, tg.valor, tg.tipo
FROM tags_noticia tn
JOIN tags tg ON tg.id = tn.tag_id
WHERE tn.traduccion_id = ANY(%s);
Retorna: Diccionario donde:
Clave: traduccion_id
Valor: Lista de tuplas (valor_tag, tipo_tag)
Optimización: Evita el problema N+1 al cargar tags.
Funciones principales:
buscar_noticias(...) -> Tuple[List[Dict], int, int, Dict]
Descripción: Búsqueda avanzada con múltiples filtros, paginación y traducciones.
Parámetros:
conn: Conexión a PostgreSQL
page: Número de página (1-based)
per_page: Noticias por página
q: Término de búsqueda (opcional)
categoria_id: Filtrar por categoría (opcional)
continente_id: Filtrar por continente (opcional)
pais_id: Filtrar por país (opcional)
fecha: Filtrar por fecha exacta YYYY-MM-DD (opcional)
lang: Idioma objetivo para traducciones (default: "es")
use_tr: Incluir traducciones en búsqueda (default: True)
Retorna: Tupla con 4 elementos:
noticias: Lista de noticias con datos completos
total_results: Total de resultados (sin paginación)
total_pages: Total de páginas calculado
tags_por_tr: Diccionario de tags por traducción
Características de búsqueda:
Filtrado por fecha: Coincidencia exacta de fecha
Filtrado geográfico: País o continente (jerárquico)
Filtrado por categoría: Selección única
Búsqueda de texto:
Búsqueda full-text con PostgreSQL (websearch_to_tsquery)
Búsqueda ILIKE en múltiples campos
Incluye campos originales y traducidos
Paginación: Offset/Limit estándar
Traducciones: JOIN condicional con tabla traducciones
Optimización: Single query para contar y obtener datos
Consulta SQL principal (simplificada):
sql
-- Contar total
SELECT COUNT(DISTINCT n.id)
FROM noticias n
-- joins con categorias, paises, traducciones
WHERE [condiciones dinámicas]
-- Obtener datos paginados
SELECT
n.id, n.titulo, n.resumen, n.url, n.fecha,
n.imagen_url, n.fuente_nombre,
c.nombre AS categoria,
p.nombre AS pais,
t.id AS traduccion_id,
t.titulo_trad AS titulo_traducido,
t.resumen_trad AS resumen_traducido,
-- flag de traducción disponible
CASE WHEN t.id IS NOT NULL THEN TRUE ELSE FALSE END AS tiene_traduccion,
-- campos originales
n.titulo AS titulo_original,
n.resumen AS resumen_original
FROM noticias n
-- joins...
WHERE [condiciones dinámicas]
ORDER BY n.fecha DESC NULLS LAST, n.id DESC
LIMIT %s OFFSET %s
Campos retornados por noticia:
python
{
"id": 123,
"titulo": "Título original",
"resumen": "Resumen original",
"url": "https://ejemplo.com/noticia",
"fecha": datetime(...),
"imagen_url": "https://.../imagen.jpg",
"fuente_nombre": "BBC News",
"categoria": "Política",
"pais": "España",
"traduccion_id": 456, # o None
"titulo_traducido": "Título en español",
"resumen_traducido": "Resumen en español",
"tiene_traduccion": True, # o False
"titulo_original": "Original title",
"resumen_original": "Original summary"
}
Uso en la aplicación: Esta función es el corazón de la búsqueda en la web, utilizada por los blueprints de Flask.
paises.py
Propósito: Maneja operaciones relacionadas con países.
Funciones principales:
get_paises(conn) -> List[Dict]
Descripción: Obtiene todos los países ordenados alfabéticamente.
Parámetros:
conn: Conexión a PostgreSQL
Consulta SQL:
sql
SELECT id, nombre FROM paises ORDER BY nombre;
Retorna: Lista de diccionarios con id y nombre de cada país.
Uso típico: Para dropdowns de filtrado por país en la interfaz web.
traducciones.py
Propósito: Maneja operaciones relacionadas con traducciones específicas.
Funciones principales:
get_traduccion(conn, traduccion_id: int) -> Optional[Dict]
Descripción: Obtiene una traducción específica por su ID.
Parámetros:
conn: Conexión a PostgreSQL
traduccion_id: ID numérico de la traducción
Consulta SQL:
sql
SELECT * FROM traducciones WHERE id = %s;
Retorna: Diccionario con todos los campos de la traducción o None.
Campos incluidos: id, noticia_id, lang_from, lang_to, titulo_trad, resumen_trad, status, error, created_at, etc.
Uso típico: Para páginas de detalle de traducciones o debugging.
Patrones de Diseño Observados
1. Separación de Responsabilidades
Cada archivo maneja una entidad específica de la base de datos
Lógica de consultas separada de lógica de negocio
2. Interfaz Consistente
Todas las funciones reciben conn como primer parámetro
Retornan diccionarios (usando DictCursor)
Nombres descriptivos y consistentes
3. Optimización de Consultas
Uso de _extraer_tags_por_traduccion para evitar N+1 queries
Consultas COUNT y SELECT en la misma transacción
Índices implícitos en ORDER BY fecha DESC
4. Manejo de Traducciones
JOIN condicional con tabla traducciones
Flag tiene_traduccion para fácil verificación en frontend
Campos originales siempre disponibles como fallback
5. Seguridad
Uso de parámetros preparados (%s)
No concatenación directa de strings en SQL
Validación implícita de tipos
Flujo de Datos Típico
python
# En un blueprint de Flask
from db import get_conn
from models.noticias import buscar_noticias
def ruta_buscar():
conn = get_conn()
try:
noticias, total, paginas, tags = buscar_noticias(
conn=conn,
page=request.args.get('page', 1, type=int),
per_page=20,
q=request.args.get('q', ''),
categoria_id=request.args.get('categoria_id'),
pais_id=request.args.get('pais_id'),
lang='es'
)
# Procesar resultados...
finally:
conn.close()
Dependencias y Relaciones
Requisito: psycopg2.extras.DictCursor para retornar diccionarios
Usado por: Todos los blueprints en routers/
Base de datos: Asume estructura de tablas específica (feeds, noticias, traducciones, etc.)
Índices necesarios: Para optimizar búsquedas, se recomiendan índices en:
noticias(fecha DESC, id DESC)
traducciones(noticia_id, lang_to, status)
feeds(activo, fallos)

28
models/noticias.py
View file

@ -1,8 +1,7 @@
from psycopg2 import extras
from typing import List, Dict, Optional, Tuple, Any
import os
import torch
from sentence_transformers import SentenceTransformer
# from sentence_transformers import SentenceTransformer (Moved to functions to avoid heavy start-up)
def _extraer_tags_por_traduccion(cur, traduccion_ids: List[int]) -> Dict[int, List[tuple]]:
@ -74,33 +73,21 @@ def buscar_noticias(
where.append("p.continente_id = %s")
params.append(int(continente_id))
# Búsqueda
# Búsqueda optimizada usando FTS (Full Text Search)
if q:
search_like = f"%{q}%"
if use_tr:
where.append(
"""
(
n.tsv @@ websearch_to_tsquery('spanish', %s)
OR t.titulo_trad ILIKE %s
OR t.resumen_trad ILIKE %s
OR n.titulo ILIKE %s
OR n.resumen ILIKE %s
n.search_vector_es @@ websearch_to_tsquery('spanish', %s)
OR t.search_vector_es @@ websearch_to_tsquery('spanish', %s)
)
"""
)
params.extend([q, search_like, search_like, search_like, search_like])
params.extend([q, q])
else:
where.append(
"""
(
n.tsv @@ websearch_to_tsquery('spanish', %s)
OR n.titulo ILIKE %s
OR n.resumen ILIKE %s
)
"""
)
params.extend([q, search_like, search_like])
where.append("n.search_vector_es @@ websearch_to_tsquery('spanish', %s)")
params.append(q)
where_sql = " AND ".join(where)
@ -192,6 +179,7 @@ def buscar_noticias(
_model_cache = {}
def _get_emb_model():
from sentence_transformers import SentenceTransformer
model_name = os.environ.get("EMB_MODEL", "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
if model_name not in _model_cache:
device = "cuda" if torch.cuda.is_available() else "cpu"

12
models/paises.py
View file

@ -1,9 +1,19 @@
from typing import List, Dict
from psycopg2 import extras
from cache import cache_get, cache_set
def get_paises(conn) -> List[Dict]:
# Intentar desde caché primero (datos casi estáticos)
cached_data = cache_get("paises:all")
if cached_data:
return cached_data
with conn.cursor(cursor_factory=extras.DictCursor) as cur:
cur.execute("SELECT id, nombre FROM paises ORDER BY nombre;")
return cur.fetchall()
result = cur.fetchall()
# Cachear por 1 hora (son datos estáticos)
cache_set("paises:all", result, ttl_seconds=3600)
return result

4
nginx.conf
View file

@ -65,8 +65,8 @@ http {
location /static/ {
alias /app/static/;
expires 7d;
add_header Cache-Control "public, immutable";
access_log off;
add_header Cache-Control "no-cache, must-revalidate";
access_log on;
}
# Proxy pass a Gunicorn para todo lo demás

494
routers/describe.txt
View file

@ -1,494 +0,0 @@
routers/
├── __init__.py # Paquete Python (vacío)
├── home.py # Página principal y búsqueda de noticias
├── feeds.py # Gestión de feeds RSS
├── urls.py # Gestión de fuentes de URL
├── noticia.py # Página de detalle de noticia
├── eventos.py # Visualización de eventos por país
└── backup.py # Importación/exportación de feeds
init.py
Propósito: Archivo necesario para que Python reconozca este directorio como un paquete.
Contenido: Vacío o comentario explicativo.
Uso: Permite importar blueprints desde routers:
python
from routers.home import home_bp
home.py
Propósito: Blueprint para la página principal y búsqueda de noticias.
Ruta base: / y /home
Blueprints definidos:
home_bp = Blueprint("home", __name__)
Rutas:
@home_bp.route("/") y @home_bp.route("/home")
Método: GET
Descripción: Página principal con sistema de búsqueda avanzada.
Parámetros de consulta soportados:
page: Número de página (default: 1)
per_page: Resultados por página (default: 20, range: 10-100)
q: Término de búsqueda
categoria_id: Filtrar por categoría
continente_id: Filtrar por continente
pais_id: Filtrar por país
fecha: Filtrar por fecha (YYYY-MM-DD)
lang: Idioma para mostrar (default: "es")
orig: Si está presente, mostrar sólo originales sin traducciones
Funcionalidades:
Paginación: Sistema robusto con límites
Búsqueda avanzada: Usa models.noticias.buscar_noticias()
Soporte AJAX: Si X-Requested-With: XMLHttpRequest, retorna solo _noticias_list.html
Filtros combinados: Todos los filtros pueden usarse simultáneamente
Manejo de fechas: Conversión segura de strings a date
Variables de contexto para template:
noticias: Lista de noticias con datos completos
total_results: Total de resultados
total_pages: Total de páginas
categorias, paises: Para dropdowns de filtros
tags_por_tr: Diccionario de tags por traducción
Templates utilizados:
noticias.html: Página completa (HTML)
_noticias_list.html: Fragmento para AJAX (solo lista de noticias)
Características especiales:
use_tr = not bool(request.args.get("orig")): Controla si mostrar traducciones
lang = (request.args.get("lang") or DEFAULT_TRANSLATION_LANG or DEFAULT_LANG).lower()[:5]: Manejo seguro de idioma
feeds.py
Propósito: Blueprint para la gestión completa de feeds RSS.
Ruta base: /feeds
Blueprints definidos:
feeds_bp = Blueprint("feeds", __name__, url_prefix="/feeds")
Rutas:
@feeds_bp.route("/") - list_feeds()
Método: GET
Descripción: Listado paginado de feeds con filtros avanzados.
Parámetros de filtro:
pais_id: Filtrar por país
categoria_id: Filtrar por categoría
estado: "activos", "inactivos", "errores" o vacío para todos
Características:
Paginación (50 feeds por página)
Contador de totales
Ordenamiento: país → categoría → nombre
@feeds_bp.route("/add", methods=["GET", "POST"]) - add_feed()
Método: GET y POST
Descripción: Formulario para añadir nuevo feed.
Campos del formulario:
nombre: Nombre del feed (requerido)
descripcion: Descripción opcional
url: URL del feed RSS (requerido)
categoria_id: Categoría (select dropdown)
pais_id: País (select dropdown)
idioma: Código de idioma (2 letras, opcional)
Validaciones:
idioma se normaliza a minúsculas y máximo 2 caracteres
Campos opcionales convertidos a None si vacíos
@feeds_bp.route("/<int:feed_id>/edit", methods=["GET", "POST"]) - edit_feed(feed_id)
Método: GET y POST
Descripción: Editar feed existente.
Funcionalidades:
Pre-carga datos actuales del feed
Mismo formulario que add_feed pero con datos existentes
Campo adicional: activo (checkbox)
@feeds_bp.route("/<int:feed_id>/delete") - delete_feed(feed_id)
Método: GET
Descripción: Eliminar feed por ID.
Nota: DELETE simple sin confirmación en frontend (depende de template).
@feeds_bp.route("/<int:feed_id>/reactivar") - reactivar_feed(feed_id)
Método: GET
Descripción: Reactivar feed que tiene fallos.
Acción: Establece activo=TRUE y fallos=0.
Templates utilizados:
feeds_list.html: Listado principal
add_feed.html: Formulario de añadir
edit_feed.html: Formulario de editar
urls.py
Propósito: Blueprint para gestión de fuentes de URL (no feeds RSS).
Ruta base: /urls
Blueprints definidos:
urls_bp = Blueprint("urls", __name__, url_prefix="/urls")
Rutas:
@urls_bp.route("/") - manage_urls()
Método: GET
Descripción: Lista todas las fuentes de URL registradas.
Datos mostrados: ID, nombre, URL, categoría, país, idioma.
@urls_bp.route("/add_source", methods=["GET", "POST"]) - add_url_source()
Método: GET y POST
Descripción: Añadir/actualizar fuente de URL.
Características únicas:
Usa ON CONFLICT (url) DO UPDATE: Si la URL ya existe, actualiza
idioma default: "es" si no se especifica
Mismos campos que feeds pero para URLs individuales
Templates utilizados:
urls_list.html: Listado
add_url_source.html: Formulario
noticia.py
Propósito: Blueprint para página de detalle de noticia individual.
Ruta base: /noticia
Blueprints definidos:
noticia_bp = Blueprint("noticia", __name__)
Rutas:
@noticia_bp.route("/noticia") - noticia()
Método: GET
Descripción: Muestra detalle completo de una noticia.
Parámetros de consulta:
tr_id: ID de traducción (prioritario)
id: ID de noticia original (si no hay tr_id)
Flujo de datos:
Si hay tr_id: Obtiene datos combinados de traducción y noticia original
Si solo hay id: Obtiene solo datos originales
Si no hay ninguno: Redirige a home con mensaje de error
Datos obtenidos:
Información básica: título, resumen, URL, fecha, imagen, fuente
Datos de traducción (si aplica): idiomas, títulos/resúmenes traducidos
Metadatos: categoría, país
Tags: Etiquetas asociadas a la traducción
Noticias relacionadas: Hasta 8, ordenadas por score de similitud
Consultas adicionales (solo si hay traducción):
Tags: SELECT tg.valor, tg.tipo FROM tags_noticia...
Noticias relacionadas: SELECT n2.url, n2.titulo... FROM related_noticias...
Templates utilizados:
noticia.html: Página de detalle completa
eventos.py
Propósito: Blueprint para visualización de eventos agrupados por país.
Ruta base: /eventos_pais
Blueprints definidos:
eventos_bp = Blueprint("eventos", __name__, url_prefix="/eventos_pais")
Rutas:
@eventos_bp.route("/") - eventos_pais()
Método: GET
Descripción: Lista eventos (clusters de noticias) filtrados por país.
Parámetros de consulta:
pais_id: ID del país (obligatorio para ver eventos)
page: Número de página (default: 1)
lang: Idioma para traducciones (default: "es")
Funcionalidades:
Lista de países: Siempre visible para selección
Eventos paginados: 30 por página
Noticias por evento: Agrupadas bajo cada evento
Datos completos: Cada noticia con originales y traducidos
Estructura de datos:
Países: Lista completa para dropdown
Eventos: Paginados, con título, fechas, conteo de noticias
Noticias por evento: Diccionario {evento_id: [noticias...]}
Consultas complejas:
Agrupación con GROUP BY y MAX(p.nombre)
JOIN múltiple: eventos ↔ traducciones ↔ noticias ↔ países
Subconsulta para noticias por evento usando ANY(%s)
Variables de contexto:
paises, eventos, noticias_por_evento
pais_nombre: Nombre del país seleccionado
total_eventos, total_pages, page, lang
Templates utilizados:
eventos_pais.html: Página principal
backup.py
Propósito: Blueprint para importación y exportación de feeds en CSV.
Ruta base: /backup_feeds y /restore_feeds
Blueprints definidos:
backup_bp = Blueprint("backup", __name__)
Rutas:
@backup_bp.route("/backup_feeds") - backup_feeds()
Método: GET
Descripción: Exporta todos los feeds a CSV.
Características:
Incluye joins con categorías y países para nombres legibles
Codificación UTF-8 con BOM
Nombre de archivo: feeds_backup.csv
Usa io.StringIO y io.BytesIO para evitar archivos temporales
Campos exportados:
Todos los campos de feeds más nombres de categoría y país
@backup_bp.route("/restore_feeds", methods=["GET", "POST"]) - restore_feeds()
Método: GET y POST
Descripción: Restaura feeds desde CSV (reemplazo completo).
Flujo de restauración:
GET: Muestra formulario de subida
POST:
Valida archivo y encabezados CSV
TRUNCATE feeds RESTART IDENTITY CASCADE: Borra todo antes de importar
Procesa cada fila con validación
Estadísticas: importados, saltados, fallidos
Validaciones:
Encabezados exactos esperados
URL y nombre no vacíos
Conversión segura de tipos (int, bool)
Normalización de idioma (2 caracteres minúsculas)
Limpieza de datos:
python
row = {k: (v.strip().rstrip("ç") if v else "") for k, v in row.items()}
Manejo de booleanos:
python
activo = str(row["activo"]).lower() in ("true", "1", "t", "yes", "y")
Templates utilizados:
restore_feeds.html: Formulario de subida
Patrones de Diseño Comunes
1. Estructura de Blueprints
python
# Definición estándar
bp = Blueprint("nombre", __name__, url_prefix="/ruta")
# Registro en app.py
app.register_blueprint(bp)
2. Manejo de Conexiones a BD
python
with get_conn() as conn:
# Usar conn para múltiples operaciones
# conn.autocommit = True si es necesario
3. Paginación Consistente
python
page = max(int(request.args.get("page", 1)), 1)
per_page = 50 # o variable
offset = (page - 1) * per_page
4. Manejo de Parámetros de Filtro
python
where = []
params = []
if pais_id:
where.append("f.pais_id = %s")
params.append(int(pais_id))
where_sql = "WHERE " + " AND ".join(where) if where else ""
5. Flash Messages
python
flash("Operación exitosa", "success")
flash("Error: algo salió mal", "error")
6. Redirecciones
python
return redirect(url_for("blueprint.funcion"))
7. Manejo de Formularios
python
if request.method == "POST":
# Procesar datos
return redirect(...)
# GET: mostrar formulario
return render_template("form.html", datos=...)
Seguridad y Validaciones
1. SQL Injection
Todos los parámetros usan %s con psycopg2
No hay concatenación de strings en SQL
2. Validación de Entrada
Conversión segura a int: int(valor) if valor else None
Limpieza de strings: .strip(), normalización
Rangos: min(max(per_page, 10), 100)
3. Manejo de Archivos
Validación de tipo de contenido
Decodificación UTF-8 con manejo de BOM
Uso de io para evitar archivos temporales
Optimizaciones
1. JOINs Eficientes
LEFT JOIN para datos opcionales
GROUP BY cuando es necesario
Uso de índices implícitos en ORDER BY
2. Batch Operations
TRUNCATE ... RESTART IDENTITY más rápido que DELETE
Inserción fila por fila con validación
3. Manejo de Memoria
io.StringIO para CSV en memoria
Cursors con DictCursor para acceso por nombre
Dependencias entre Blueprints
text
home.py
└── usa: models.noticias.buscar_noticias()
└── usa: _extraer_tags_por_traduccion()
feeds.py
└── usa: models.categorias.get_categorias()
└── usa: models.paises.get_paises()
urls.py
└── usa: models.categorias.get_categorias()
└── usa: models.paises.get_paises()
noticia.py
└── consultas directas (no usa models/)
eventos.py
└── consultas directas (no usa models/)
backup.py
└── consultas directas (no usa models/)

2
routers/feeds.py
View file

@ -4,12 +4,14 @@ from psycopg2 import extras
from models.categorias import get_categorias
from models.paises import get_paises
from utils.feed_discovery import discover_feeds, validate_feed, get_feed_metadata
from cache import cached
# Blueprint correcto
feeds_bp = Blueprint("feeds", __name__, url_prefix="/feeds")
@feeds_bp.route("/")
@cached(ttl_seconds=300, prefix="feeds") # 5 minutos para listados
def list_feeds():
"""Listado con filtros"""
page = max(int(request.args.get("page", 1)), 1)

220
routers/home.py
View file

@ -6,14 +6,14 @@ from utils.auth import get_current_user
from config import DEFAULT_TRANSLATION_LANG, DEFAULT_LANG, NEWS_PER_PAGE_DEFAULT
from models.categorias import get_categorias
from models.paises import get_paises
from models.noticias import buscar_noticias, buscar_noticias_semantica
from cache import cached
from models.noticias import buscar_noticias
home_bp = Blueprint("home", __name__)
@home_bp.route("/")
@home_bp.route("/home")
def home():
"""Simplified home page to avoid timeouts."""
page = max(int(request.args.get("page", 1)), 1)
per_page = int(request.args.get("per_page", NEWS_PER_PAGE_DEFAULT))
per_page = min(max(per_page, 10), 100)
@ -27,7 +27,6 @@ def home():
lang = (request.args.get("lang") or DEFAULT_TRANSLATION_LANG or DEFAULT_LANG).lower()[:5]
use_tr = not bool(request.args.get("orig"))
fecha_str = request.args.get("fecha") or ""
fecha_filtro = None
if fecha_str:
try:
@ -35,129 +34,28 @@ def home():
except ValueError:
fecha_filtro = None
from utils.qdrant_search import semantic_search
# Logic for semantic search enabled by default if query exists, unless explicitly disabled
# If the user passed 'semantic=' explicitly as empty string, it might mean False, but for UX speed default to True is better.
# However, let's respect the flag if it's explicitly 'false' or '0'.
# If key is missing, default to True. If key is present but empty, treat as False (standard HTML form behavior unfortunately).
# But wait, the previous log showed 'semantic='. HTML checkboxes send nothing if unchecked, 'on' if checked.
# So if it appears as empty string, it might be a hidden input or unassigned var.
# Let's check 'semantic' param presence.
raw_semantic = request.args.get("semantic")
if raw_semantic is None:
use_semantic = True # Default to semantic if not specified
elif raw_semantic == "" or raw_semantic.lower() in ["false", "0", "off"]:
use_semantic = False
else:
use_semantic = True
# Búsqueda semántica solo si se solicita explícitamente y hay query
use_semantic = bool(request.args.get("semantic")) and bool(q)
with get_read_conn() as conn:
conn.autocommit = True
categorias = get_categorias(conn)
paises = get_paises(conn)
noticias = []
total_results = 0
total_pages = 0
tags_por_tr = {}
# 1. Intentar búsqueda semántica si hay query y está habilitado
semantic_success = False
if use_semantic and q:
try:
# Obtener más resultados para 'llenar' la página si hay IDs no encontrados
limit_fetch = per_page * 2
sem_results = semantic_search(
query=q,
limit=limit_fetch, # Pedimos más para asegurar
score_threshold=0.30
if use_semantic:
from models.noticias import buscar_noticias_semantica
noticias, total_results, total_pages, tags_por_tr = buscar_noticias_semantica(
conn=conn,
page=page,
per_page=per_page,
q=q,
categoria_id=categoria_id,
continente_id=continente_id,
pais_id=pais_id,
fecha=fecha_filtro,
lang=lang,
)
if sem_results:
# Extraer IDs
news_ids = [r['news_id'] for r in sem_results]
# Traer datos completos de PostgreSQL (igual que en search.py)
with conn.cursor(cursor_factory=extras.DictCursor) as cur:
query_sql = """
SELECT
n.id,
n.titulo,
n.resumen,
n.url,
n.fecha,
n.imagen_url,
n.fuente_nombre,
c.nombre AS categoria,
p.nombre AS pais,
-- traducciones
t.id AS traduccion_id,
t.titulo_trad AS titulo_traducido,
t.resumen_trad AS resumen_traducido,
CASE WHEN t.id IS NOT NULL THEN TRUE ELSE FALSE END AS tiene_traduccion,
-- originales
n.titulo AS titulo_original,
n.resumen AS resumen_original
FROM noticias n
LEFT JOIN categorias c ON c.id = n.categoria_id
LEFT JOIN paises p ON p.id = n.pais_id
LEFT JOIN traducciones t
ON t.noticia_id = n.id
AND t.lang_to = %s
AND t.status = 'done'
WHERE n.id = ANY(%s)
"""
cur.execute(query_sql, (lang, news_ids))
rows = cur.fetchall()
# Convertimos a lista para poder ordenar por fecha
rows_list = list(rows)
# Ordenar cronológicamente (más reciente primero)
sorted_rows = sorted(
rows_list,
key=lambda x: x['fecha'] if x['fecha'] else datetime.min,
reverse=True
)
# Aplicar paginación manual sobre los resultados ordenados
# Nota: semantic_search ya devolvió los "top" globales (aproximadamente).
# Para paginación real profunda con Qdrant se necesita scroll/offset,
# aquí asumimos que page request mapea al limit/offset enviado a Qdrant.
# Pero `semantic_search` simple en utils no tiene offset.
# Arreglo temporal: Solo mostramos la primera "tanda" de resultados semánticos.
# Si el usuario quiere paginar profundo, Qdrant search debe soportar offset.
# utils/qdrant_search.py NO tiene offset.
# ASÍ QUE: Solo funcionará bien para la página 1.
# Si page > 1, semantic_search simple no sirve sin offset.
# Fallback: Si page > 1, usamos búsqueda tradicional O implementamos offset en Qdrant (mejor).
# Por ahora: Usamos lo que devolvió semantic_search y cortamos localmente
# si page=1.
if len(sorted_rows) > 0:
noticias = sorted_rows
total_results = len(noticias) # Aproximado
total_pages = 1 # Qdrant simple no pagina bien aun
# Extraer tags
tr_ids = [n["traduccion_id"] for n in noticias if n["traduccion_id"]]
from models.noticias import _extraer_tags_por_traduccion
tags_por_tr = _extraer_tags_por_traduccion(cur, tr_ids)
semantic_success = True
except Exception as e:
print(f"⚠️ Error en semántica home, fallback: {e}")
semantic_success = False
# 2. Si no hubo búsqueda semántica (o falló, o no había query, o usuario la desactivó), usar la tradicional
if not semantic_success:
else:
noticias, total_results, total_pages, tags_por_tr = buscar_noticias(
conn=conn,
page=page,
@ -171,82 +69,22 @@ def home():
use_tr=use_tr,
)
# Record search history for logged-in users (only on first page to avoid dupes)
if (q or categoria_id or pais_id) and page == 1:
user = get_current_user()
if user:
try:
with get_write_conn() as w_conn:
with w_conn.cursor() as w_cur:
# Check if it's the same as the last search to avoid immediate duplicates
w_cur.execute("""
SELECT query, pais_id, categoria_id
FROM search_history
WHERE user_id = %s
ORDER BY searched_at DESC LIMIT 1
""", (user['id'],))
last_search = w_cur.fetchone()
current_search = (q or None, int(pais_id) if pais_id else None, int(categoria_id) if categoria_id else None)
if not last_search or (last_search[0], last_search[1], last_search[2]) != current_search:
w_cur.execute("""
INSERT INTO search_history (user_id, query, pais_id, categoria_id, results_count)
VALUES (%s, %s, %s, %s, %s)
""", (user['id'], current_search[0], current_search[1], current_search[2], total_results))
w_conn.commit()
except Exception as e:
# Log error but don't break the page load
print(f"Error saving search history: {e}")
pass
user = get_current_user()
# Historial de búsqueda (solo para usuarios logueados y en primera página)
recent_searches_with_results = []
if user and not q and not categoria_id and not pais_id and page == 1:
with get_read_conn() as conn:
user = get_current_user()
if user and page == 1 and not q:
with conn.cursor(cursor_factory=extras.DictCursor) as cur:
# Fetch unique latest searches using DISTINCT ON
cur.execute("""
SELECT sub.id, query, pais_id, categoria_id, results_count, searched_at,
SELECT sh.id, sh.query, sh.searched_at, sh.results_count,
p.nombre as pais_nombre, c.nombre as categoria_nombre
FROM (
SELECT DISTINCT ON (COALESCE(query, ''), COALESCE(pais_id, 0), COALESCE(categoria_id, 0))
id, query, pais_id, categoria_id, results_count, searched_at
FROM search_history
WHERE user_id = %s
ORDER BY COALESCE(query, ''), COALESCE(pais_id, 0), COALESCE(categoria_id, 0), searched_at DESC
) sub
LEFT JOIN paises p ON p.id = sub.pais_id
LEFT JOIN categorias c ON c.id = sub.categoria_id
ORDER BY searched_at DESC
LIMIT 6
FROM search_history sh
LEFT JOIN paises p ON p.id = sh.pais_id
LEFT JOIN categorias c ON c.id = sh.categoria_id
WHERE sh.user_id = %s
ORDER BY sh.searched_at DESC
LIMIT 10
""", (user['id'],))
recent_searches = cur.fetchall()
for s in recent_searches:
# Fetch top 6 news for this search
news_items, _, _, _ = buscar_noticias(
conn=conn,
page=1,
per_page=6,
q=s['query'] or "",
pais_id=s['pais_id'],
categoria_id=s['categoria_id'],
lang=lang,
use_tr=use_tr,
skip_count=True
)
recent_searches_with_results.append({
'id': s['id'],
'query': s['query'],
'pais_id': s['pais_id'],
'pais_nombre': s['pais_nombre'],
'categoria_id': s['categoria_id'],
'categoria_nombre': s['categoria_nombre'],
'results_count': s['results_count'],
'searched_at': s['searched_at'],
'noticias': news_items
})
recent_searches_with_results = cur.fetchall()
context = dict(
noticias=noticias,
@ -259,6 +97,7 @@ def home():
q=q,
cat_id=int(categoria_id) if categoria_id else None,
pais_id=int(pais_id) if pais_id else None,
cont_id=int(continente_id) if continente_id else None,
fecha_filtro=fecha_str,
lang=lang,
use_tr=use_tr,
@ -282,7 +121,6 @@ def delete_search(search_id):
try:
with get_write_conn() as conn:
with conn.cursor() as cur:
# Direct deletion ensuring ownership
cur.execute(
"DELETE FROM search_history WHERE id = %s AND user_id = %s",
(search_id, user["id"])

11
routers/noticia.py
View file

@ -112,5 +112,14 @@ def noticia():
)
relacionadas = cur.fetchall()
return render_template("noticia.html", dato=dato, tags=tags, relacionadas=relacionadas)
# Preparar datos para el template clásico
context = {
'dato': dato,
'etiquetas': ', '.join([tag['valor'] for tag in tags]) if tags else '',
'related_news': relacionadas,
'categorias': [], # Podríamos añadir categorías populares si quisiéramos
'idioma_orig': dato['lang_from'] if dato else None
}
return render_template("noticia_classic.html", **context)

76
routers/resumen.py
View file

@ -1,76 +0,0 @@
"""
Resumen router - Daily summary of news.
"""
from flask import Blueprint, render_template, request
from psycopg2 import extras
from db import get_conn
from datetime import datetime, timedelta
resumen_bp = Blueprint("resumen", __name__, url_prefix="/resumen")
@resumen_bp.route("/")
def diario():
"""Daily summary page."""
# Default to today
date_str = request.args.get("date")
if date_str:
try:
target_date = datetime.strptime(date_str, "%Y-%m-%d").date()
except ValueError:
target_date = datetime.utcnow().date()
else:
target_date = datetime.utcnow().date()
prev_date = target_date - timedelta(days=1)
next_date = target_date + timedelta(days=1)
if next_date > datetime.utcnow().date():
next_date = None
with get_conn() as conn:
with conn.cursor(cursor_factory=extras.DictCursor) as cur:
# Fetch top news for the day grouped by category
# We'll limit to 5 per category to keep it concise
cur.execute("""
WITH ranked_news AS (
SELECT
n.id, n.titulo, n.resumen, n.url, n.fecha, n.imagen_url, n.fuente_nombre,
c.id as cat_id, c.nombre as categoria,
t.titulo_trad, t.resumen_trad,
ROW_NUMBER() OVER (PARTITION BY n.categoria_id ORDER BY n.fecha DESC) as rn
FROM noticias n
LEFT JOIN categorias c ON c.id = n.categoria_id
LEFT JOIN traducciones t ON t.noticia_id = n.id
AND t.lang_to = 'es' AND t.status = 'done'
WHERE n.fecha >= %s AND n.fecha < %s + INTERVAL '1 day'
)
SELECT * FROM ranked_news WHERE rn <= 5 ORDER BY categoria, rn
""", (target_date, target_date))
rows = cur.fetchall()
# Group by category
noticias_by_cat = {}
for r in rows:
cat = r["categoria"] or "Sin Categoría"
if cat not in noticias_by_cat:
noticias_by_cat[cat] = []
noticias_by_cat[cat].append({
"id": r["id"],
"titulo": r["titulo_trad"] or r["titulo"],
"resumen": r["resumen_trad"] or r["resumen"],
"url": r["url"],
"fecha": r["fecha"],
"imagen_url": r["imagen_url"],
"fuente": r["fuente_nombre"]
})
return render_template(
"resumen.html",
noticias_by_cat=noticias_by_cat,
current_date=target_date,
prev_date=prev_date,
next_date=next_date
)

1
routers/stats.py
View file

@ -511,6 +511,7 @@ def get_cpu_info():
return None
@stats_bp.route("/api/system/info")
@cached(ttl_seconds=40, prefix="system_info")
def system_info_api():
"""Endpoint for real-time system monitoring."""
return jsonify({

59
routers/traducciones.py
View file

@ -1,59 +0,0 @@
from flask import Blueprint, render_template, request
from db import get_read_conn
traducciones_bp = Blueprint("traducciones", __name__)
@traducciones_bp.route("/traducciones")
def ultimas_traducciones():
"""Muestra las últimas noticias traducidas."""
page = max(int(request.args.get("page", 1)), 1)
per_page = min(max(int(request.args.get("per_page", 20)), 10), 100)
offset = (page - 1) * per_page
with get_read_conn() as conn:
conn.autocommit = True
with conn.cursor() as cur:
# Total count
cur.execute("""
SELECT COUNT(*) FROM traducciones WHERE status = 'done'
""")
total = cur.fetchone()[0]
# Fetch latest translations
cur.execute("""
SELECT
t.id,
t.noticia_id,
t.titulo_trad,
t.resumen_trad,
t.lang_from,
t.lang_to,
t.created_at AS updated_at,
n.url AS link,
n.imagen_url AS imagen,
n.fuente_nombre AS feed_nombre,
c.nombre AS categoria_nombre,
p.nombre AS pais_nombre
FROM traducciones t
JOIN noticias n ON n.id = t.noticia_id
LEFT JOIN categorias c ON c.id = n.categoria_id
LEFT JOIN paises p ON p.id = n.pais_id
WHERE t.status = 'done'
ORDER BY t.created_at DESC
LIMIT %s OFFSET %s
""", (per_page, offset))
columns = [desc[0] for desc in cur.description]
traducciones = [dict(zip(columns, row)) for row in cur.fetchall()]
total_pages = (total + per_page - 1) // per_page
return render_template(
"traducciones.html",
traducciones=traducciones,
page=page,
per_page=per_page,
total=total,
total_pages=total_pages,
)

93
scripts/download_llm_model.sh Executable file
View file

@ -0,0 +1,93 @@
#!/bin/bash
# Script para descargar modelo LLM compatible con RTX 3060 12GB
set -e
MODEL_DIR="/home/x/rss2/models/llm"
export PATH="$HOME/.local/bin:$PATH"
echo "=== Descarga de Modelo LLM para Categorización de Noticias ==="
echo ""
echo "Para RTX 3060 12GB, se recomienda un modelo 7B cuantizado."
echo ""
echo "Opciones disponibles:"
echo ""
echo "1) Mistral-7B-Instruct-v0.2 (GPTQ 4-bit) - RECOMENDADO"
echo " - Tamaño: ~4.5GB"
echo " - Calidad: Excelente para clasificación"
echo " - VRAM: ~6-7GB"
echo ""
echo "2) Mistral-7B-Instruct-v0.2 (EXL2 4.0bpw)"
echo " - Tamaño: ~4.2GB"
echo " - Calidad: Excelente (optimizado para ExLlamaV2)"
echo " - VRAM: ~5-6GB"
echo ""
echo "3) OpenHermes-2.5-Mistral-7B (GPTQ 4-bit)"
echo " - Tamaño: ~4.5GB"
echo " - Calidad: Muy buena para tareas generales"
echo " - VRAM: ~6-7GB"
echo ""
echo "4) Neural-Chat-7B-v3-1 (GPTQ 4-bit)"
echo " - Tamaño: ~4.5GB"
echo " - Calidad: Buena para español"
echo " - VRAM: ~6-7GB"
echo ""
read -p "Selecciona una opción (1-4) [1]: " CHOICE
CHOICE=${CHOICE:-1}
case $CHOICE in
1)
MODEL_REPO="TheBloke/Mistral-7B-Instruct-v0.2-GPTQ"
MODEL_FILE="model.safetensors"
;;
2)
MODEL_REPO="turboderp/Mistral-7B-instruct-exl2"
MODEL_FILE="4.0bpw"
;;
3)
MODEL_REPO="TheBloke/OpenHermes-2.5-Mistral-7B-GPTQ"
MODEL_FILE="model.safetensors"
;;
4)
MODEL_REPO="TheBloke/neural-chat-7B-v3-1-GPTQ"
MODEL_FILE="model.safetensors"
;;
*)
echo "Opción inválida"
exit 1
;;
esac
echo ""
echo "Descargando: $MODEL_REPO"
echo "Destino: $MODEL_DIR"
echo ""
# Crear directorio si no existe
mkdir -p "$MODEL_DIR"
# Verificar si huggingface-cli está instalado
# Verificar si huggingface-cli está instalado o si el modulo existe
# Forzamos actualización a una versión reciente para asegurar soporte de CLI
echo "Actualizando huggingface-hub..."
pip3 install -U "huggingface_hub[cli]>=0.23.0" --break-system-packages
# Descargar modelo usando script de python directo para evitar problemas de CLI
echo "Iniciando descarga..."
python3 -c "
from huggingface_hub import snapshot_download
print(f'Descargando { \"$MODEL_REPO\" } a { \"$MODEL_DIR\" }...')
snapshot_download(repo_id='$MODEL_REPO', local_dir='$MODEL_DIR', local_dir_use_symlinks=False)
"
echo ""
echo "✓ Modelo descargado exitosamente en: $MODEL_DIR"
echo ""
echo "Información del modelo:"
echo "----------------------"
ls -lh "$MODEL_DIR"
echo ""
echo "Para usar este modelo, actualiza docker-compose.yml con:"
echo " LLM_MODEL_PATH=/app/models/llm"
echo ""

140
scripts/test_llm_categorizer.py Executable file
View file

@ -0,0 +1,140 @@
#!/usr/bin/env python3
"""
Script de prueba para el LLM Categorizer
Prueba la categorización con datos de ejemplo sin necesidad del contenedor
"""
import os
import sys
# Datos de prueba
TEST_NEWS = [
{
'id': 'test_1',
'titulo': 'El gobierno anuncia nuevas medidas económicas para combatir la inflación',
'resumen': 'El presidente del gobierno ha presentado un paquete de medidas económicas destinadas a reducir la inflación y proteger el poder adquisitivo de las familias.'
},
{
'id': 'test_2',
'titulo': 'Nueva vacuna contra el cáncer muestra resultados prometedores',
'resumen': 'Investigadores de la Universidad de Stanford han desarrollado una vacuna experimental que ha mostrado una eficacia del 85% en ensayos clínicos con pacientes con melanoma.'
},
{
'id': 'test_3',
'titulo': 'El Real Madrid gana la Champions League por decimoquinta vez',
'resumen': 'El equipo blanco se impuso por 2-1 en la final celebrada en Wembley, consolidándose como el club más laureado de la competición europea.'
},
{
'id': 'test_4',
'titulo': 'OpenAI lanza GPT-5 con capacidades multimodales mejoradas',
'resumen': 'La nueva versión del modelo de lenguaje incorpora mejor comprensión de imágenes, video y audio, además de un razonamiento más avanzado.'
},
{
'id': 'test_5',
'titulo': 'Crisis diplomática entre Estados Unidos y China por aranceles',
'resumen': 'Las tensiones comerciales se intensifican después de que Washington impusiera nuevos aranceles del 25% a productos tecnológicos chinos.'
}
]
def test_without_llm():
"""Prueba básica sin LLM (categorización basada en keywords)"""
print("=== Prueba de Categorización Básica (sin LLM) ===\n")
# Categorías con palabras clave simples
CATEGORIES_KEYWORDS = {
'Política': ['gobierno', 'presidente', 'político', 'parlamento', 'elecciones'],
'Economía': ['económic', 'inflación', 'aranceles', 'bolsa', 'financiero'],
'Salud': ['vacuna', 'hospital', 'médico', 'tratamiento', 'enfermedad'],
'Deportes': ['fútbol', 'champions', 'equipo', 'partido', 'gana'],
'Tecnología': ['tecnológic', 'digital', 'software', 'ai', 'gpt', 'openai'],
'Internacional': ['estados unidos', 'china', 'rusia', 'diplomática', 'crisis'],
}
for news in TEST_NEWS:
text = (news['titulo'] + ' ' + news['resumen']).lower()
best_category = 'Otros'
max_score = 0
for category, keywords in CATEGORIES_KEYWORDS.items():
score = sum(1 for kw in keywords if kw in text)
if score > max_score:
max_score = score
best_category = category
print(f"ID: {news['id']}")
print(f"Título: {news['titulo']}")
print(f"Categoría: {best_category} (score: {max_score})")
print()
def test_with_llm():
"""Prueba con el LLM real (requiere modelo descargado)"""
print("\n=== Prueba de Categorización con LLM ===\n")
# Configurar path del modelo
MODEL_PATH = os.environ.get("LLM_MODEL_PATH", "/home/x/rss2/models/llm")
if not os.path.exists(MODEL_PATH):
print(f"❌ Error: No se encuentra el modelo en {MODEL_PATH}")
print(f"Por favor ejecuta primero: ./scripts/download_llm_model.sh")
return
# Verificar si exllamav2 está instalado
try:
import exllamav2
print(f"✓ ExLlamaV2 instalado: {exllamav2.__version__}")
except ImportError:
print("❌ Error: ExLlamaV2 no está instalado")
print("Instalar con: pip install exllamav2")
return
# Importar el categorizer
sys.path.insert(0, '/home/x/rss2')
from workers.llm_categorizer_worker import ExLlamaV2Categorizer
print(f"Cargando modelo desde: {MODEL_PATH}")
print("(Esto puede tardar unos minutos...)\n")
try:
categorizer = ExLlamaV2Categorizer(MODEL_PATH)
print("✓ Modelo cargado exitosamente\n")
results = categorizer.categorize_news(TEST_NEWS)
print("\n=== Resultados ===\n")
for i, news in enumerate(TEST_NEWS):
result = results[i]
print(f"ID: {news['id']}")
print(f"Título: {news['titulo']}")
print(f"Categoría: {result['categoria']}")
print(f"Confianza: {result['confianza']:.2f}")
print()
except Exception as e:
print(f"❌ Error: {e}")
import traceback
traceback.print_exc()
def main():
print("=" * 60)
print("Script de Prueba del LLM Categorizer")
print("=" * 60)
print()
# Prueba básica siempre funciona
test_without_llm()
# Preguntar si probar con LLM
print("\n¿Deseas probar con el LLM real? (requiere modelo descargado)")
print("Esto cargará el modelo en GPU y puede tardar varios minutos.")
response = input("Continuar? [s/N]: ").strip().lower()
if response in ['s', 'si', 'y', 'yes']:
test_with_llm()
else:
print("\nPrueba finalizada. Para probar con el LLM:")
print("1. Descarga el modelo: ./scripts/download_llm_model.sh")
print("2. Ejecuta este script de nuevo y acepta probar con LLM")
if __name__ == "__main__":
main()

1731
static/style.css
View file

File diff suppressed because it is too large Load diff

57
templates/add_feeds.html
View file

@ -1,57 +0,0 @@
{% extends "base.html" %}
{% block title %}Añadir Nuevo Feed{% endblock %}
{% block content %}
<header>
<h1>Añadir Nuevo Feed</h1>
<p class="subtitle">Introduce los detalles de la nueva fuente de noticias RSS.</p>
<a href="{{ url_for('dashboard') }}" class="top-link" style="margin-top:15px;">← Volver al Dashboard</a>
</header>
<div class="form-section">
<form action="{{ url_for('add_feed') }}" method="post" autocomplete="off">
<div>
<label for="nombre">Nombre del feed</label>
<input id="nombre" name="nombre" type="text" placeholder="Ej: Noticias de Tecnología" required>
</div>
<div style="margin-top:15px;">
<label for="url">URL del RSS</label>
<input id="url" name="url" type="url" placeholder="https://ejemplo.com/rss" required>
</div>
<div style="margin-top:15px;">
<label for="descripcion">Descripción</label>
<textarea id="descripcion" name="descripcion" rows="2" placeholder="Breve descripción del contenido del feed"></textarea>
</div>
<div style="display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 15px; margin-top: 15px;">
<div>
<label for="categoria_id">Categoría</label>
<select id="categoria_id" name="categoria_id" required>
<option value="">— Elige categoría —</option>
{% for cat in categorias %}
<option value="{{ cat.id }}">{{ cat.nombre }}</option>
{% endfor %}
</select>
</div>
<div>
<label for="pais_id">País</label>
<select name="pais_id" id="pais_id">
<option value="">— Global / No aplica —</option>
{% for pais in paises %}
<option value="{{ pais.id }}">{{ pais.nombre }}</option>
{% endfor %}
</select>
</div>
<div>
<label for="idioma">Idioma (código)</label>
<input id="idioma" name="idioma" type="text" maxlength="2" placeholder="ej: es, en">
</div>
</div>
<button type="submit" class="btn" style="margin-top: 25px; width: 100%;">Añadir Feed</button>
</form>
</div>
{% endblock %}

59
templates/add_url.html
View file

@ -1,59 +0,0 @@
{% extends "base.html" %}
{% block title %}Añadir Noticia desde URL{% endblock %}
{% block content %}
<div class="container mt-4">
<div class="row justify-content-center">
<div class="col-md-8">
<div class="card">
<div class="card-header bg-info text-white">
<h4 class="mb-0">Añadir Noticia desde URL</h4>
</div>
<div class="card-body">
<p class="card-text text-muted">Pega la URL de un artículo de noticias. El sistema intentará extraer el título, resumen e imagen automáticamente.</p>
<form action="{{ url_for('add_url') }}" method="post" class="mt-3">
<!-- Campo para la URL -->
<div class="mb-3">
<label for="url" class="form-label"><strong>URL de la Noticia</strong></label>
<input type="url" class="form-control" id="url" name="url" required placeholder="https://ejemplo.com/noticia-a-scrapear">
</div>
<!-- Selector de Categoría -->
<div class="mb-3">
<label for="categoria_id" class="form-label"><strong>Categoría</strong></label>
<select class="form-select" id="categoria_id" name="categoria_id" required>
<option value="" disabled selected>-- Selecciona una categoría --</option>
{% for categoria in categorias %}
<option value="{{ categoria.id }}">{{ categoria.nombre }}</option>
{% endfor %}
</select>
</div>
<!-- Selector de País -->
<div class="mb-3">
<label for="pais_id" class="form-label"><strong>País</strong></label>
<select class="form-select" id="pais_id" name="pais_id" required>
<option value="" disabled selected>-- Selecciona un país --</option>
{% for pais in paises %}
<option value="{{ pais.id }}">{{ pais.nombre }}</option>
{% endfor %}
</select>
</div>
<!-- Botones de Acción -->
<div class="d-flex justify-content-end pt-3">
<a href="{{ url_for('dashboard') }}" class="btn btn-secondary me-2">Cancelar</a>
<button type="submit" class="btn btn-primary">Añadir Noticia</button>
</div>
</form>
</div>
</div>
</div>
</div>
</div>
{% endblock %}

14
templates/base.html
View file

@ -4,15 +4,15 @@
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{% block title %}Agregador de Noticias RSS{% endblock %}</title>
<title>{% block title %}El Observador - Noticias{% endblock %}</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link
href="https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;500;600;700&family=Roboto:wght@300;400;500;700&display=swap"
href="https://fonts.googleapis.com/css2?family=Old+Standard+TT:wght@400;700&family=Playfair+Display:wght@400;700;900&family=Merriweather:wght@300;400;700&family=Lato:wght@300;400;700&display=swap"
rel="stylesheet">
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}?v=10">
<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}?v=11">
<!-- TomSelect CSS -->
<link href="https://cdn.jsdelivr.net/npm/tom-select@2.2.2/dist/css/tom-select.css" rel="stylesheet">
@ -80,7 +80,7 @@
<!-- Mobile/Global Nav Elements -->
<div class="mobile-header">
<div class="logo-mobile">
<a href="/">THE DAILY FEED</a>
<a href="/">EL OBSERVADOR</a>
</div>
<button class="mobile-menu-toggle" id="mobile-menu-toggle" aria-label="Abrir menú">
<i class="fas fa-bars"></i>
@ -93,7 +93,7 @@
<header class="desktop-header">
<div class="header-top-row">
<div class="header-title-wrapper">
<h1><a href="/" style="text-decoration: none; color: inherit;">THE DAILY FEED</a></h1>
<h1><a href="/" style="text-decoration: none; color: inherit;">EL OBSERVADOR</a></h1>
</div>
<div class="header-user-menu">
@ -341,7 +341,7 @@
if (data.has_news) {
lastCheck = data.timestamp;
new Notification("The Daily Feed", {
new Notification("El Observador", {
body: data.message,
icon: "/static/favicon.ico" // Assuming generic icon
});
@ -381,7 +381,7 @@
Notification.requestPermission().then(permission => {
if (permission === "granted") {
btn.style.display = 'none';
new Notification("The Daily Feed", { body: "¡Notificaciones activadas!" });
new Notification("El Observador", { body: "¡Notificaciones activadas!" });
}
});
};

144
templates/dashboard.html
View file

@ -1,144 +0,0 @@
{% extends "base.html" %}
{% block title %}Dashboard{% endblock %}
{% block content %}
<div class="dashboard-grid">
<div class="stat-card">
<div class="stat-number">{{ stats.feeds_totales }}</div>
<div class="stat-label">Feeds Totales</div>
</div>
<div class="stat-card">
<div class="stat-number">{{ stats.noticias_totales }}</div>
<div class="stat-label">Noticias Totales</div>
</div>
<div class="stat-card">
<div class="stat-number">{{ stats.feeds_caidos }}</div>
<div class="stat-label">Feeds Caídos</div>
</div>
</div>
<div class="row">
<div class="col-md-6 mb-4">
<div class="card">
<div class="card-header">
<h3>Gestión de Feeds RSS</h3>
</div>
<div class="card-body">
<p>
Exporta tu lista de feeds RSS o restaura/importa desde un archivo CSV.
Además, puedes ir al organizador avanzado de feeds para filtrarlos
por país, categoría y estado.
</p>
<div style="display:flex; flex-wrap:wrap; gap:10px; margin-bottom:10px;">
<a href="{{ url_for('feeds.list_feeds') }}" class="btn btn-secondary">
<i class="fas fa-list"></i> Ver / Gestionar Feeds
</a>
</div>
<div style="display:flex; flex-wrap:wrap; gap:8px; margin-bottom:15px;">
<a href="{{ url_for('feeds.list_feeds', estado='activos') }}" class="btn btn-small">
<i class="fas fa-check-circle"></i> Feeds activos
</a>
<a href="{{ url_for('feeds.list_feeds', estado='inactivos') }}" class="btn btn-small btn-danger">
<i class="fas fa-times-circle"></i> Feeds caídos/inactivos
</a>
<a href="{{ url_for('feeds.list_feeds', estado='errores') }}" class="btn btn-small btn-info">
<i class="fas fa-exclamation-triangle"></i> Feeds con errores
</a>
</div>
<hr style="margin: 15px 0; border: 0; border-top: 1px solid var(--border-color);">
<a href="{{ url_for('backup_feeds') }}" class="btn">
<i class="fas fa-download"></i> Exportar Feeds
</a>
<a href="{{ url_for('restore_feeds') }}" class="btn btn-info">
<i class="fas fa-upload"></i> Importar Feeds
</a>
</div>
</div>
</div>
<div class="col-md-6 mb-4">
<div class="card">
<div class="card-header">
<h3>Gestión de Fuentes URL</h3>
</div>
<div class="card-body">
<p>Exporta tu lista de fuentes URL o restaura/importa desde un archivo CSV.</p>
<a href="{{ url_for('backup_urls') }}" class="btn">
<i class="fas fa-download"></i> Exportar URLs
</a>
<a href="{{ url_for('restore_urls') }}" class="btn btn-info">
<i class="fas fa-upload"></i> Importar Fuentes URL
</a>
</div>
</div>
</div>
</div>
<div class="card">
<div class="card-header">
<h3>Operaciones del Sistema</h3>
</div>
<div class="card-body">
<p>Genera o restaura una copia de seguridad completa de todas tus fuentes y noticias.</p>
<div style="display:flex; gap:10px; flex-wrap:wrap;">
<a href="{{ url_for('backup_completo') }}" class="btn btn-secondary">
<i class="fas fa-archive"></i> Backup Completo (.zip)
</a>
<a href="{{ url_for('restore_completo') }}" class="btn btn-info">
<i class="fas fa-upload"></i> Restaurar Backup (.zip)
</a>
</div>
</div>
</div>
{% if top_tags and top_tags|length > 0 %}
<div class="card">
<div class="card-header">
<h3>Top tags (últimas 24h)</h3>
</div>
<div class="card-body" style="padding:0;">
<table style="width:100%; border-collapse: collapse;">
<thead>
<tr style="background-color: rgba(0,0,0,0.05);">
<th style="padding: 12px 15px; text-align: left;">Tag</th>
<th style="padding: 12px 15px; text-align: left;">Tipo</th>
<th style="padding: 12px 15px; text-align: right;">Apariciones</th>
</tr>
</thead>
<tbody>
{% for t in top_tags %}
<tr>
<td style="padding: 12px 15px; border-top: 1px solid var(--border-color);">
{{ t.valor }}
</td>
<td style="padding: 12px 15px; border-top: 1px solid var(--border-color); text-transform: capitalize;">
{{ t.tipo }}
</td>
<td style="padding: 12px 15px; border-top: 1px solid var(--border-color); text-align: right;">
{{ t.apariciones }}
</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
{% else %}
<div class="card">
<div class="card-header">
<h3>Top tags (últimas 24h)</h3>
</div>
<div class="card-body">
<p style="color: var(--text-color-light); margin: 0;">No hay tags para mostrar todavía.</p>
</div>
</div>
{% endif %}
{% endblock %}

48
templates/edit_url_source.html
View file

@ -1,48 +0,0 @@
{% extends "base.html" %}
{% block title %}Editar Fuente URL{% endblock %}
{% block content %}
<h1>Editar Fuente: {{ fuente.nombre }}</h1>
<div class="card">
<form action="{{ url_for('edit_url_source', url_id=fuente.id) }}" method="post">
<label for="nombre">Nombre</label>
<input type="text" id="nombre" name="nombre" value="{{ fuente.nombre }}" required>
<label for="url" style="margin-top:15px;">URL</label>
<input type="url" id="url" name="url" value="{{ fuente.url }}" required>
<label for="categoria_id" style="margin-top:15px;">Categoría</label>
<select id="categoria_id" name="categoria_id">
<option value="">— Sin categoría —</option>
{% for c in categorias %}
<option value="{{ c.id }}" {% if c.id == fuente.categoria_id %}selected{% endif %}>
{{ c.nombre }}
</option>
{% endfor %}
</select>
<label for="pais_id" style="margin-top:15px;">País</label>
<select id="pais_id" name="pais_id">
<option value="">— Sin país —</option>
{% for p in paises %}
<option value="{{ p.id }}" {% if p.id == fuente.pais_id %}selected{% endif %}>
{{ p.nombre }}
</option>
{% endfor %}
</select>
<label for="idioma" style="margin-top:15px;">Idioma (2 letras)</label>
<input id="idioma" name="idioma" value="{{ fuente.idioma }}" maxlength="2" required>
<div style="display:flex;justify-content:end;gap:10px;margin-top:20px;">
<a href="{{ url_for('manage_urls') }}" class="btn btn-secondary">Cancelar</a>
<button class="btn" type="submit">Actualizar</button>
</div>
</form>
</div>
{% endblock %}

138
templates/index.html
View file

@ -1,138 +0,0 @@
{% extends "base.html" %}
{% block title %}Gestión de Feeds RSS{% endblock %}
{% block content %}
<h1>Gestión de Feeds RSS</h1>
<a href="/" class="top-link">← Volver a últimas noticias</a>
<div class="card">
<h2>Añadir un nuevo feed</h2>
<form action="/add" method="post" autocomplete="off">
<label for="nombre">Nombre del feed</label>
<input id="nombre" name="nombre" placeholder="Nombre del feed" required>
<label for="descripcion">Descripción</label>
<textarea id="descripcion" name="descripcion" placeholder="Breve descripción del feed" rows="2"></textarea>
<label for="url">URL del RSS</label>
<input id="url" name="url" placeholder="URL del RSS" required>
<label for="categoria_id">Categoría</label>
<select id="categoria_id" name="categoria_id" required>
<option value="">— Elige categoría —</option>
{% for cid, cnom in categorias %}
<option value="{{ cid }}">{{ cnom }}</option>
{% endfor %}
</select>
<label for="continente_id">Continente</label>
<select name="continente_id" id="continente_id" onchange="filtrarPaisesPorContinente()">
<option value="">— Elige continente —</option>
{% for coid, conom in continentes %}
<option value="{{ coid }}">{{ conom }}</option>
{% endfor %}
</select>
<label for="pais_id">País</label>
<select name="pais_id" id="pais_id">
<option value="">— N/A —</option>
{% for pid, pnom, contid in paises %}
<option value="{{ pid }}">{{ pnom }}</option>
{% endfor %}
</select>
<!-- Nuevo campo: idioma -->
<label for="idioma">Idioma</label>
<input id="idioma" name="idioma" maxlength="2" placeholder="Ej: es, en, fr">
<button class="btn" type="submit">Añadir</button>
<!-- Datos en JSON para el filtro dinámico de países -->
<script type="application/json" id="paises-data">{{ paises|tojson }}</script>
</form>
</div>
<div class="card">
<h2>Lista de Feeds</h2>
<a href="/backup_feeds" target="_blank" class="btn">⬇️ Descargar backup de feeds (CSV)</a>
<a href="/restore_feeds" class="btn" style="margin-left:10px;">🔄 Restaurar feeds desde backup</a>
<table>
<thead>
<tr>
<th>Nombre y descripción</th>
<th>URL</th>
<th>Categoría</th>
<th>País</th>
<th style="min-width: 80px;">Estado</th>
<th style="min-width: 60px;">Fallos</th>
<th>Acciones</th>
</tr>
</thead>
<tbody>
{% for id, nombre, descripcion, url, categoria_id, pais_id, activo, fallos, cat_nom, pais_nom in feeds %}
<tr>
<td>
<strong>{{ nombre }}</strong>
{% if descripcion %}
<div style="font-size:0.95em; color:#64748b;">{{ descripcion }}</div>
{% endif %}
</td>
<td><a href="{{ url }}" target="_blank">{{ url }}</a></td>
<td>{{ cat_nom or 'N/A' }}</td>
<td>{{ pais_nom or 'N/A' }}</td>
<td>
{% if not activo %}
<span class="badge-ko" title="Inactivo: {{ fallos }} fallos">KO</span>
{% elif fallos > 0 %}
<span class="badge-warn" title="{{ fallos }} fallos recientes">⚠️</span>
{% else %}
<span class="badge-ok">OK</span>
{% endif %}
</td>
<td>
{% if fallos > 0 %}
<span style="color:orange;">{{ fallos }}</span>
{% else %}
0
{% endif %}
</td>
<td class="actions">
<a href="/edit/{{ id }}">Editar</a> |
<a href="/delete/{{ id }}" onclick="return confirm('¿Seguro que quieres eliminar este feed?');">Eliminar</a>
{% if not activo %}
| <a href="/reactivar_feed/{{ id }}" style="color:#198754;" title="Reactivar feed">Reactivar</a>
{% endif %}
</td>
</tr>
{% else %}
<tr>
<td colspan="7">No hay feeds aún.</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
<a href="/" class="top-link">← Volver a últimas noticias</a>
<script>
function filtrarPaisesPorContinente() {
const continenteId = document.getElementById('continente_id').value;
const paises = JSON.parse(document.getElementById('paises-data').textContent);
const selectPais = document.getElementById('pais_id');
selectPais.innerHTML = '';
// Opción N/A siempre presente
const optionNA = document.createElement('option');
optionNA.value = '';
optionNA.textContent = '— N/A —';
selectPais.appendChild(optionNA);
paises.forEach(([id, nombre, contId]) => {
if (!continenteId || contId == continenteId || contId == Number(continenteId)) {
const opt = document.createElement('option');
opt.value = id;
opt.textContent = nombre;
selectPais.appendChild(opt);
}
});
}
</script>
{% endblock %}

316
templates/noticia.html
View file

@ -1,316 +0,0 @@
{% extends "base.html" %}
{% block title %}
{{ dato.titulo_trad or dato.titulo_orig or 'Detalle de Noticia' }}
{% endblock %}
{% block content %}
{% set d = dato %}
{% if not d %}
<div class="card">
<p>No se encontró la noticia solicitada.</p>
</div>
{% else %}
<div class="card" id="main-article">
<div class="feed-header">
<h2 style="margin:0;">{{ d.titulo_trad or d.titulo_orig }}
{% if d.lang_to %}
<span class="badge">{{ d.lang_to|upper }}</span>
{% endif %}
</h2>
<div class="header-actions">
<a href="{{ url_for('pdf.export_noticia', noticia_id=d.noticia_id) }}" class="btn btn-small"
title="Exportar PDF" target="_blank">
<i class="fas fa-file-pdf"></i>
</a>
<button class="btn btn-small" onclick="toggleReadingMode()" title="Modo lectura">
<i class="fas fa-book-reader"></i>
</button>
{% if d.url %}
<a href="{{ d.url }}" target="_blank" class="btn btn-small">Ver fuente</a>
{% endif %}
</div>
</div>
<div class="feed-body">
<div class="noticia-meta">
{% if d.fecha %}
<i class="far fa-calendar-alt"></i>
{% if d.fecha is string %}
{{ d.fecha }}
{% else %}
{{ d.fecha.strftime('%d-%m-%Y %H:%M') }}
{% endif %}
{% endif %}
{% if d.fuente_nombre %} | <i class="fas fa-newspaper"></i> {{ d.fuente_nombre }}{% endif %}
{% if d.categoria %} | <i class="fas fa-tag"></i> {{ d.categoria }}{% endif %}
{% if d.pais %} | <i class="fas fa-globe"></i> {{ d.pais }}{% endif %}
</div>
{% if d.imagen_url %}
<div style="text-align:center;margin-bottom:16px;">
<img src="{{ d.imagen_url }}" alt="" loading="lazy" onerror="this.style.display='none';"
style="max-width: 100%; height: auto; border-radius: 8px;">
</div>
{% endif %}
{% if d.resumen_trad %}
<h3>Resumen (traducido)</h3>
<div>{{ d.resumen_trad|safe_html }}</div>
<hr>
{% endif %}
{% if d.resumen_orig %}
<h3>Resumen (original)</h3>
<div>{{ d.resumen_orig|safe_html }}</div>
{% endif %}
{% if tags %}
<div style="margin-top:12px;">
{% for t in tags %}
<span class="badge" title="{{ t.tipo }}">{{ t.valor }}</span>
{% endfor %}
</div>
{% endif %}
<!-- Share Buttons -->
<div class="share-section">
<span class="share-label">Compartir:</span>
<div class="share-buttons">
<a href="https://twitter.com/intent/tweet?text={{ (d.titulo_trad or d.titulo_orig)|urlencode }}&url={{ request.url|urlencode }}"
target="_blank" class="share-btn share-twitter" title="Twitter">
<i class="fab fa-twitter"></i>
</a>
<a href="https://wa.me/?text={{ (d.titulo_trad or d.titulo_orig)|urlencode }}%20{{ request.url|urlencode }}"
target="_blank" class="share-btn share-whatsapp" title="WhatsApp">
<i class="fab fa-whatsapp"></i>
</a>
<a href="https://t.me/share/url?url={{ request.url|urlencode }}&text={{ (d.titulo_trad or d.titulo_orig)|urlencode }}"
target="_blank" class="share-btn share-telegram" title="Telegram">
<i class="fab fa-telegram"></i>
</a>
<button class="share-btn share-copy" onclick="copyLink()" title="Copiar enlace">
<i class="fas fa-link"></i>
</button>
</div>
</div>
</div>
</div>
<style>
.share-section {
display: flex;
align-items: center;
gap: 1rem;
margin-top: 1.5rem;
padding-top: 1rem;
border-top: 1px solid var(--border-color, #eee);
}
.share-label {
font-size: 0.85rem;
color: var(--text-muted, #666);
font-weight: 500;
}
.share-buttons {
display: flex;
gap: 0.5rem;
}
.share-btn {
display: flex;
align-items: center;
justify-content: center;
width: 36px;
height: 36px;
border-radius: 50%;
border: none;
cursor: pointer;
text-decoration: none;
color: #fff;
font-size: 1rem;
transition: transform 0.2s, box-shadow 0.2s;
}
.share-btn:hover {
transform: scale(1.1);
box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
}
.share-twitter {
background: #1DA1F2;
}
.share-whatsapp {
background: #25D366;
}
.share-telegram {
background: #0088cc;
}
.share-copy {
background: #111;
}
.dark-mode .share-copy {
background: #fff;
color: #111;
}
/* Reading Mode Styles */
.header-actions {
display: flex;
gap: 0.5rem;
}
body.reading-mode header,
body.reading-mode .main-nav,
body.reading-mode .share-section,
body.reading-mode .card:not(#main-article),
body.reading-mode .noticia-meta,
body.reading-mode .header-actions .btn:not([onclick*="Reading"]) {
display: none !important;
}
body.reading-mode {
background: #faf9f5;
}
body.reading-mode #main-article {
max-width: 700px;
margin: 2rem auto;
padding: 3rem;
font-size: 1.15rem;
line-height: 1.9;
box-shadow: none;
border: none;
}
body.reading-mode #main-article h2 {
font-size: 2.2rem;
line-height: 1.3;
margin-bottom: 1.5rem;
font-family: 'Playfair Display', Georgia, serif;
}
body.reading-mode #main-article img {
max-width: 100%;
height: auto;
border-radius: 8px;
}
body.reading-mode.dark-mode {
background: #111;
}
body.reading-mode.dark-mode #main-article {
background: #1a1a1a;
color: #e0e0e0;
}
/* Exit reading mode button */
.exit-reading-btn {
position: fixed;
top: 1rem;
right: 1rem;
background: #111;
color: #fff;
border: none;
padding: 0.75rem 1rem;
border-radius: 8px;
cursor: pointer;
font-size: 0.85rem;
z-index: 1000;
display: none;
}
body.reading-mode .exit-reading-btn {
display: flex;
align-items: center;
gap: 0.5rem;
}
</style>
<button class="exit-reading-btn" onclick="toggleReadingMode()">
<i class="fas fa-times"></i> Salir
</button>
<script>
function copyLink() {
navigator.clipboard.writeText(window.location.href).then(() => {
const btn = document.querySelector('.share-copy');
const icon = btn.querySelector('i');
icon.className = 'fas fa-check';
setTimeout(() => { icon.className = 'fas fa-link'; }, 2000);
});
}
function toggleReadingMode() {
document.body.classList.toggle('reading-mode');
// Scroll to top in reading mode
if (document.body.classList.contains('reading-mode')) {
window.scrollTo({ top: 0, behavior: 'smooth' });
}
}
// ESC key to exit reading mode
document.addEventListener('keydown', (e) => {
if (e.key === 'Escape' && document.body.classList.contains('reading-mode')) {
toggleReadingMode();
}
});
</script>
{% if relacionadas %}
<div class="card" style="margin-top:16px;">
<div class="card-header">
<h3>Noticias relacionadas</h3>
</div>
<ul class="noticias-list">
{% for r in relacionadas %}
<li class="noticia-item">
{% if r.imagen_url %}
<div class="noticia-imagen"
style="width: 120px; height: 80px; flex-shrink: 0; overflow: hidden; border-radius: 4px;">
<img src="{{ r.imagen_url }}" loading="lazy" onerror="this.parentElement.style.display='none'"
style="width: 100%; height: 100%; object-fit: cover;">
</div>
{% endif %}
<div class="noticia-texto">
<h3 class="m0">
<a href="{{ url_for('noticia.noticia', tr_id=r.related_tr_id) if r.related_tr_id else r.url }}" {%
if not r.related_tr_id %}target="_blank" {% endif %}>
{{ r.titulo_trad or r.titulo }}
</a>
</h3>
<div class="noticia-meta">
{% if r.fecha %}
<i class="far fa-calendar-alt"></i>
{% if r.fecha is string %}
{{ r.fecha }}
{% else %}
{{ r.fecha.strftime('%d-%m-%Y %H:%M') }}
{% endif %}
{% endif %}
{% if r.fuente_nombre %} | {{ r.fuente_nombre }}{% endif %}
{% if r.score is defined %} | score {{ "%.3f"|format(r.score) }}{% endif %}
</div>
</div>
</li>
{% endfor %}
</ul>
</div>
{% endif %}
{% endif %}
{% endblock %}

345
templates/noticia_classic.html Normal file
View file

@ -0,0 +1,345 @@
{% extends "base.html" %}
{% block title %}
{{ dato.titulo_trad or dato.titulo_orig or 'Detalle de Noticia' }} - El Observador
{% endblock %}
{% block content %}
{% set d = dato %}
{% if not d %}
<div class="container">
<div class="card">
<h2>Artículo No Encontrado</h2>
<p>No se encontró la noticia solicitada.</p>
<a href="{{ url_for('home.home') }}" class="btn">← Volver al inicio</a>
</div>
</div>
{% else %}
<div class="container">
<!-- Encabezado del artículo -->
<header class="article-header">
<div class="article-breadcrumb">
<a href="{{ url_for('home.home') }}">Inicio</a> →
{% if d.categoria %}
<a href="{{ url_for('home.home', categoria_id=d.categoria_id) }}">{{ d.categoria }}</a> →
{% endif %}
Artículo
</div>
<h1 class="article-title">{{ d.titulo_trad or d.titulo_orig }}</h1>
<div class="article-meta">
{% if d.categoria %}
<span class="badge">{{ d.categoria }}</span>
{% endif %}
{% if d.pais %}
<span class="meta-item"><i class="fas fa-globe"></i> {{ d.pais }}</span>
{% endif %}
<span class="meta-item"><i class="fas fa-newspaper"></i> {{ d.fuente_nombre }}</span>
<span class="meta-item"><i class="fas fa-clock"></i>
{% if d.fecha %}
{{ d.fecha.strftime('%d de %B de %Y - %H:%M') }}
{% endif %}
</span>
{% if d.lang_to %}
<span class="meta-item"><i class="fas fa-language"></i> Traducido al {{ d.lang_to|upper }}</span>
{% endif %}
</div>
</header>
<!-- Contenido principal -->
<div class="row">
<div class="col-md-8 main-section">
<article class="article-content">
{% if d.imagen_url %}
<div class="article-image">
<img src="{{ d.imagen_url }}" alt="{{ d.titulo_trad or d.titulo_orig }}"
style="width: 100%; max-height: 400px; object-fit: cover; border: 1px solid var(--border-color);">
{% if d.imagen_credit %}
<p class="image-credit">Foto: {{ d.imagen_credit }}</p>
{% endif %}
</div>
{% endif %}
<div class="article-body">
{% if d.resumen_trad or d.resumen_orig %}
<div class="article-summary">
<strong>Resumen:</strong>
<p>{{ (d.resumen_trad or d.resumen_orig) | safe_html }}</p>
</div>
{% endif %}
{% if d.contenido_trad or d.contenido_orig %}
<div class="article-full-content">
{{ (d.contenido_trad or d.contenido_orig) | safe_html }}
</div>
{% else %}
<div class="article-excerpt">
<p>{{ (d.resumen_trad or d.resumen_orig) | safe_html }}</p>
{% if d.url %}
<div style="margin-top: 20px; padding-top: 20px; border-top: 1px solid var(--border-color);">
<a href="{{ d.url }}" target="_blank" class="btn">
<i class="fas fa-external-link-alt"></i> Leer artículo completo en {{ d.fuente_nombre }}
</a>
</div>
{% endif %}
</div>
{% endif %}
</div>
</article>
<!-- Acciones del artículo -->
<div class="article-actions">
<div class="action-buttons">
<button class="btn" onclick="toggleReadingMode()" title="Modo lectura">
<i class="fas fa-book-reader"></i> Modo Lectura
</button>
<a href="{{ url_for('pdf.export_noticia', noticia_id=d.noticia_id) }}" class="btn" title="Exportar PDF"
target="_blank">
<i class="fas fa-file-pdf"></i> PDF
</a>
<button class="btn" onclick="shareArticle()" title="Compartir">
<i class="fas fa-share-alt"></i> Compartir
</button>
{% if session.get('user_id') %}
<button class="btn" onclick="toggleFavorite()" title="Añadir a favoritos">
<i class="fas fa-star"></i> Favorito
</button>
{% endif %}
</div>
<div class="article-tags">
{% if d.etiquetas %}
<h4>Etiquetas:</h4>
{% for tag in d.etiquetas.split(',') %}
<span class="tag">{{ tag.strip() }}</span>
{% endfor %}
{% endif %}
</div>
</div>
</div>
<!-- Sidebar del artículo -->
<div class="col-md-4 sidebar">
<!-- Información de la fuente -->
<div class="card">
<h3>Información de la Fuente</h3>
<div class="source-info">
<p><strong>Medio:</strong> {{ d.fuente_nombre }}</p>
{% if d.idioma_orig %}
<p><strong>Idioma original:</strong> {{ d.idioma_orig|upper }}</p>
{% endif %}
{% if d.url %}
<p><strong>URL original:</strong></p>
<a href="{{ d.url }}" target="_blank" class="url-original"
style="word-break: break-all; color: var(--accent-color);">
{{ d.url }}
</a>
{% endif %}
</div>
</div>
<!-- Artículos relacionados -->
{% if related_news %}
<div class="card">
<h3>Artículos Relacionados</h3>
<ul>
{% for related in related_news[:5] %}
<li>
{% if related.traduccion_id %}
<a href="{{ url_for('noticia.noticia', tr_id=related.traduccion_id) }}">
{% else %}
<a href="{{ url_for('noticia.noticia', id=related.id) }}">
{% endif %}
{{ related.titulo_trad if related.tiene_traduccion else related.titulo_original }}
</a>
<small style="color: var(--muted-color);">
{{ related.fecha.strftime('%d/%m %H:%M') if related.fecha else '' }}
</small>
</li>
{% endfor %}
</ul>
</div>
{% endif %}
<!-- Categorías populares -->
{% if categorias %}
<div class="card">
<h3>Más Noticias</h3>
<ul>
{% for cat in categorias[:8] %}
<li>
<a href="{{ url_for('home.home', categoria_id=cat.id) }}">{{ cat.nombre }}</a>
</li>
{% endfor %}
</ul>
</div>
{% endif %}
</div>
</div>
</div>
{% endif %}
<script>
function toggleReadingMode() {
document.body.classList.toggle('reading-mode');
}
function shareArticle() {
if (navigator.share) {
navigator.share({
title: '{{ d.titulo_trad or d.titulo_orig }}',
text: '{{ d.resumen_trad or d.resumen_orig }}',
url: window.location.href
});
} else {
// Fallback para navegadores que no soportan Web Share API
navigator.clipboard.writeText(window.location.href);
alert('Enlace copiado al portapapeles');
}
}
function toggleFavorite() {
// Implementar funcionalidad de favoritos
fetch('/api/favorites/toggle', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
noticia_id: '{{ d.noticia_id }}'
})
})
.then(response => response.json())
.then(data => {
if (data.success) {
const btn = event.target.closest('button');
const icon = btn.querySelector('i');
if (data.is_favorite) {
icon.classList.remove('far');
icon.classList.add('fas');
btn.innerHTML = '<i class="fas fa-star"></i> Eliminar de Favoritos';
} else {
icon.classList.remove('fas');
icon.classList.add('far');
btn.innerHTML = '<i class="far fa-star"></i> Añadir a Favoritos';
}
}
})
.catch(error => console.error('Error:', error));
}
// Estilo adicional para modo lectura
const style = document.createElement('style');
style.textContent = `
.reading-mode .container {
max-width: 800px;
margin: 20px auto;
padding: 40px;
background: var(--paper-color);
border: none;
box-shadow: none;
}
.reading-mode .article-content {
column-count: 1;
font-size: 1.2rem;
line-height: 1.9;
}
.reading-mode .sidebar {
display: none;
}
.reading-mode .article-actions {
margin-top: 40px;
padding-top: 30px;
border-top: 2px solid var(--border-color);
}
.reading-mode .article-title {
font-size: 2.5rem;
line-height: 1.2;
margin-bottom: 20px;
}
.reading-mode .article-meta {
margin-bottom: 30px;
}
.article-image {
margin: 30px 0;
}
.image-credit {
font-size: 0.85rem;
color: var(--muted-color);
margin-top: 8px;
font-style: italic;
}
.article-summary {
background: var(--bg-color);
padding: 20px;
border-left: 4px solid var(--accent-color);
margin: 20px 0;
font-size: 1.1rem;
}
.article-breadcrumb {
font-size: 0.9rem;
color: var(--muted-color);
margin-bottom: 15px;
}
.article-breadcrumb a {
color: var(--muted-color);
text-decoration: none;
}
.article-breadcrumb a:hover {
color: var(--accent-color);
}
.action-buttons {
display: flex;
gap: 10px;
flex-wrap: wrap;
margin-bottom: 20px;
}
.article-tags {
margin-top: 20px;
}
.article-tags h4 {
margin-bottom: 10px;
color: var(--accent-color);
}
.source-info p {
margin-bottom: 10px;
}
.url-original {
display: block;
margin-top: 5px;
font-size: 0.9rem;
}
`;
document.head.appendChild(style);
</script>
{% endblock %}

17
templates/noticias.html
View file

@ -1,5 +1,5 @@
{% extends "base.html" %}
{% block title %}Últimas Noticias RSS{% endblock %}
{% block title %}El Observador - Últimas Noticias{% endblock %}
{% block content %}
<div class="card" style="padding: 1.5rem;">
@ -18,11 +18,11 @@
<div class="filter-main-row" style="display: flex; gap: 10px; width: 100%;">
<div class="filter-search-box" style="flex: 1;">
<input type="search" name="q" id="q" placeholder="Buscar noticias..." value="{{ q or '' }}"
style="width: 100%; padding: 0.8rem 1rem; font-size: 1.1rem; border-radius: 8px; border: 1px solid var(--border-color);">
style="width: 100%; padding: 0.8rem 1rem; font-size: 1.1rem; border-radius: 0; border: 1px solid var(--ink-black);">
</div>
<div class="filter-actions" style="display: flex; gap: 5px;">
<button type="submit" class="btn" style="padding: 0.8rem 1.2rem; border-radius: 8px;" title="Buscar">
<button type="submit" class="btn" style="padding: 0.8rem 1.2rem; border-radius: 0;" title="Buscar">
<i class="fas fa-search"></i>
</button>
<a href="{{ url_for('home.home') }}" class="btn btn-secondary"
@ -163,10 +163,17 @@
</div>
<style>
:root {
--accent-color: var(--accent-red);
--text-color: var(--newspaper-gray);
--bg-color: var(--paper-cream);
--card-bg: var(--paper-white);
}
.timeline-container {
position: relative;
padding-left: 30px;
border-left: 2px solid rgba(108, 99, 255, 0.3);
border-left: 2px solid var(--accent-red);
/* Var accent-color opacity */
margin-left: 10px;
}
@ -182,7 +189,7 @@
top: 20px;
width: 12px;
height: 12px;
background: var(--accent-color, #6c63ff);
background: var(--accent-red);
border-radius: 50%;
border: 2px solid var(--bg-color, #f4f6f8);
box-shadow: 0 0 0 4px rgba(108, 99, 255, 0.2);

16
templates/restore_urls.html
View file

@ -1,16 +0,0 @@
{% extends "base.html" %}
{% block title %}Importar Fuentes URL{% endblock %}
{% block content %}
<h1>Importar Fuentes URL</h1>
<div class="card">
<form method="post" enctype="multipart/form-data" action="{{ url_for('restore_urls') }}">
<label>Archivo CSV:</label>
<input type="file" name="file" required>
<button class="btn" style="margin-top:15px;">Importar</button>
<a href="{{ url_for('dashboard') }}" class="btn btn-secondary">Cancelar</a>
</form>
</div>
{% endblock %}

156
templates/resumen.html
View file

@ -1,156 +0,0 @@
{% extends "base.html" %}
{% block title %}Resumen Diario - {{ current_date.strftime('%d/%m/%Y') }}{% endblock %}
{% block content %}
<div class="summary-header">
<div class="date-nav">
<a href="{{ url_for('resumen.diario', date=prev_date) }}" class="btn btn-small btn-secondary">
<i class="fas fa-chevron-left"></i> Anterior
</a>
<h1>Resumen Diario <small>{{ current_date.strftime('%d/%m/%Y') }}</small></h1>
{% if next_date %}
<a href="{{ url_for('resumen.diario', date=next_date) }}" class="btn btn-small btn-secondary">
Siguiente <i class="fas fa-chevron-right"></i>
</a>
{% else %}
<span style="width: 100px;"></span>
{% endif %}
</div>
</div>
{% if not noticias_by_cat %}
<div class="card" style="text-align: center; padding: 40px;">
<i class="far fa-newspaper" style="font-size: 3rem; color: #ccc; margin-bottom: 20px;"></i>
<h3>No hay noticias para este día</h3>
<p>Prueba navegando a días anteriores.</p>
</div>
{% else %}
<div class="summary-grid">
{% for categoria, noticias in noticias_by_cat.items() %}
<div class="category-block card">
<h2 class="category-title">{{ categoria }}</h2>
<ul class="summary-list">
{% for n in noticias %}
<li class="summary-item">
{% if n.imagen_url %}
<div class="summary-img">
<img src="{{ n.imagen_url }}" loading="lazy" onerror="this.style.display='none'">
</div>
{% endif %}
<div class="summary-content">
<h3><a href="{{ url_for('noticia.detalle_noticia', noticia_id=n.id) }}">{{ n.titulo }}</a></h3>
<div class="meta">
{{ n.time_str }} | {{ n.fuente }}
</div>
</div>
</li>
{% endfor %}
</ul>
<div style="text-align: center; margin-top: 15px;">
<a href="{{ url_for('home.home', categoria_id=noticias[0].categoria_id, fecha=current_date) }}"
class="btn btn-small btn-outline">Ver más de {{ categoria }}</a>
</div>
</div>
{% endfor %}
</div>
{% endif %}
<style>
.summary-header {
text-align: center;
margin-bottom: 30px;
}
.date-nav {
display: flex;
justify-content: space-between;
align-items: center;
max-width: 800px;
margin: 0 auto;
}
.date-nav h1 {
margin: 0;
font-family: var(--primary-font);
}
.date-nav h1 small {
display: block;
font-size: 0.5em;
color: #777;
font-family: var(--secondary-font);
margin-top: 5px;
}
.summary-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
gap: 20px;
}
.category-title {
border-bottom: 2px solid var(--accent-color);
padding-bottom: 10px;
margin-top: 0;
margin-bottom: 20px;
font-family: var(--primary-font);
}
.summary-list {
list-style: none;
padding: 0;
margin: 0;
}
.summary-item {
display: flex;
gap: 15px;
margin-bottom: 20px;
border-bottom: 1px dotted var(--border-color);
padding-bottom: 20px;
}
.summary-item:last-child {
border-bottom: none;
margin-bottom: 0;
padding-bottom: 0;
}
.summary-img {
width: 80px;
height: 80px;
flex-shrink: 0;
border-radius: 4px;
overflow: hidden;
}
.summary-img img {
width: 100%;
height: 100%;
object-fit: cover;
}
.summary-content h3 {
margin: 0 0 5px 0;
font-size: 1.1rem;
line-height: 1.3;
}
.summary-content h3 a {
text-decoration: none;
color: var(--text-color);
}
.summary-content h3 a:hover {
color: var(--accent-color);
}
.meta {
font-size: 0.8rem;
color: #888;
}
</style>
{% endblock %}

2
templates/stats.html
View file

@ -552,7 +552,7 @@
}
updateSystemInfo();
setInterval(updateSystemInfo, 10000);
setInterval(updateSystemInfo, 40000);
});
</script>

795
templates/stats_entities.html
View file

File diff suppressed because it is too large Load diff

109
templates/traducciones.html
View file

@ -1,109 +0,0 @@
{% extends "base.html" %}
{% block title %}Últimas Traducciones{% endblock %}
{% block content %}
<div class="card">
<h2><i class="fas fa-language" style="color: var(--accent-color); margin-right: 10px;"></i>Últimas Traducciones</h2>
<p style="color: #666; margin-bottom: 20px;">
Mostrando las {{ traducciones|length }} traducciones más recientes de un total de {{ total }}.
</p>
</div>
<div id="traducciones-grid" style="margin-top: 20px;">
{% for t in traducciones %}
<article class="noticia-card">
{% if t.imagen %}
<img src="{{ t.imagen }}" alt="{{ t.titulo_trad }}" onerror="this.src='/static/placeholder.svg'; this.onerror=null;">
{% else %}
<img src="/static/placeholder.svg" alt="Sin imagen">
{% endif %}
<div class="noticia-meta">
<span class="lang-badge">{{ t.lang_from|upper }} → {{ t.lang_to|upper }}</span>
{% if t.categoria_nombre %}
<span class="category-badge">{{ t.categoria_nombre }}</span>
{% endif %}
{% if t.pais_nombre %}
• {{ t.pais_nombre }}
{% endif %}
</div>
<h3>
<a href="{{ t.link }}" target="_blank" rel="noopener">{{ t.titulo_trad or 'Sin título' }}</a>
</h3>
<p class="noticia-summary">
{{ t.resumen_trad[:300] }}{% if t.resumen_trad|length > 300 %}...{% endif %}
</p>
<div class="noticia-footer">
<small>
<i class="fas fa-rss"></i> {{ t.feed_nombre or 'Desconocido' }}
• <i class="fas fa-clock"></i> {{ t.updated_at|format_date if t.updated_at else 'Fecha desconocida' }}
</small>
</div>
</article>
{% else %}
<div class="card" style="text-align: center; padding: 40px;">
<i class="fas fa-inbox fa-3x" style="color: #ccc; margin-bottom: 20px;"></i>
<p>No hay traducciones disponibles aún.</p>
</div>
{% endfor %}
</div>
{% if total_pages > 1 %}
<div class="pagination" style="margin-top: 30px; text-align: center;">
{% if page > 1 %}
<a href="?page={{ page - 1 }}&per_page={{ per_page }}" class="btn btn-secondary">
<i class="fas fa-chevron-left"></i> Anterior
</a>
{% endif %}
<span style="margin: 0 20px;">Página {{ page }} de {{ total_pages }}</span>
{% if page < total_pages %}
<a href="?page={{ page + 1 }}&per_page={{ per_page }}" class="btn">
Siguiente <i class="fas fa-chevron-right"></i>
</a>
{% endif %}
</div>
{% endif %}
<style>
#traducciones-grid {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(320px, 1fr));
gap: 25px;
}
.lang-badge {
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
padding: 3px 8px;
border-radius: 4px;
font-size: 0.75rem;
font-weight: bold;
}
.category-badge {
background: var(--accent-color);
color: white;
padding: 3px 8px;
border-radius: 4px;
font-size: 0.75rem;
margin-left: 8px;
}
.noticia-footer {
margin-top: 15px;
padding-top: 10px;
border-top: 1px solid var(--border-color);
color: #888;
font-size: 0.85rem;
}
.pagination .btn {
margin: 0 5px;
}
</style>
{% endblock %}

10
utils/helpers.py
View file

@ -13,8 +13,14 @@ def safe_html(texto: Optional[str]) -> str:
return ""
# Sanitize content to prevent layout breakage (e.g. unclosed divs)
allowed_tags = ['b', 'i', 'strong', 'em', 'p', 'br', 'span', 'a']
allowed_attrs = {'a': ['href', 'target', 'rel']}
allowed_tags = [
'b', 'i', 'strong', 'em', 'p', 'br', 'span', 'a', 'img',
'h1', 'h2', 'h3', 'h4', 'ul', 'ol', 'li', 'blockquote'
]
allowed_attrs = {
'a': ['href', 'target', 'rel', 'title'],
'img': ['src', 'alt', 'title', 'width', 'height', 'style']
}
cleaned = bleach.clean(texto, tags=allowed_tags, attributes=allowed_attrs, strip=True)
return Markup(cleaned)

7
utils/qdrant_search.py
View file

@ -6,7 +6,7 @@ import os
import time
from typing import List, Dict, Any, Optional
from qdrant_client import QdrantClient
from sentence_transformers import SentenceTransformer
# from sentence_transformers import SentenceTransformer (Moved to function)
# Configuración
QDRANT_HOST = os.environ.get("QDRANT_HOST", "localhost")
@ -16,7 +16,7 @@ EMB_MODEL = os.environ.get("EMB_MODEL", "sentence-transformers/paraphrase-multil
# Singleton para clientes globales
_qdrant_client: Optional[QdrantClient] = None
_embedding_model: Optional[SentenceTransformer] = None
_embedding_model: Optional[Any] = None
def get_qdrant_client() -> QdrantClient:
@ -40,12 +40,13 @@ def get_qdrant_client() -> QdrantClient:
return _qdrant_client
def get_embedding_model() -> SentenceTransformer:
def get_embedding_model() -> Any:
"""
Obtiene el modelo de embeddings (singleton).
"""
global _embedding_model
if _embedding_model is None:
from sentence_transformers import SentenceTransformer
_embedding_model = SentenceTransformer(EMB_MODEL, device='cpu')
return _embedding_model

482
workers/llm_categorizer_worker.py Normal file
View file

@ -0,0 +1,482 @@
#!/usr/bin/env python3
"""
LLM Categorizer Worker - Categoriza noticias usando ExLlamaV2 (local)
Este worker:
1. Lee 10 noticias sin categorizar de la base de datos
2. Las envía a un LLM local (ExLlamaV2) para que determine la categoría
3. Actualiza la base de datos con las categorías asignadas
Modelo recomendado para RTX 3060 12GB:
- Mistral-7B-Instruct-v0.2 (GPTQ/AWQ/EXL2)
- OpenHermes-2.5-Mistral-7B
- Neural-Chat-7B
"""
import os
import sys
import time
import logging
import json
from typing import List, Dict, Optional
import psycopg2
from psycopg2.extras import execute_values
# Configuración de logging
logging.basicConfig(
level=logging.INFO,
format='[llm_categorizer] %(asctime)s %(levelname)s: %(message)s'
)
log = logging.getLogger(__name__)
# Configuración de base de datos
DB_CONFIG = {
"host": os.environ.get("DB_HOST", "localhost"),
"port": int(os.environ.get("DB_PORT", 5432)),
"dbname": os.environ.get("DB_NAME", "rss"),
"user": os.environ.get("DB_USER", "rss"),
"password": os.environ.get("DB_PASS", ""),
}
# Configuración del worker
BATCH_SIZE = int(os.environ.get("LLM_BATCH_SIZE", 10)) # 10 noticias por lote
SLEEP_IDLE = int(os.environ.get("LLM_SLEEP_IDLE", 30)) # segundos
MODEL_PATH = os.environ.get("LLM_MODEL_PATH", "/app/models/llm")
GPU_SPLIT = os.environ.get("LLM_GPU_SPLIT", "auto")
MAX_SEQ_LEN = int(os.environ.get("LLM_MAX_SEQ_LEN", 4096))
CACHE_MODE = os.environ.get("LLM_CACHE_MODE", "FP16")
# Categorías predefinidas
CATEGORIES = [
"Política",
"Economía",
"Tecnología",
"Ciencia",
"Salud",
"Deportes",
"Entretenimiento",
"Internacional",
"Nacional",
"Sociedad",
"Cultura",
"Medio Ambiente",
"Educación",
"Seguridad",
"Otros"
]
class ExLlamaV2Categorizer:
"""Wrapper para el modelo ExLlamaV2"""
def __init__(self, model_path: str):
"""
Inicializa el modelo ExLlamaV2
Args:
model_path: Ruta al modelo descargado (formato EXL2, GPTQ, etc.)
"""
self.model_path = model_path
self.model = None
self.tokenizer = None
self.cache = None
self.generator = None
log.info(f"Inicializando ExLlamaV2 desde: {model_path}")
self._load_model()
def _load_model(self):
"""Carga el modelo y componentes necesarios"""
try:
from exllamav2 import (
ExLlamaV2,
ExLlamaV2Config,
ExLlamaV2Cache,
ExLlamaV2Tokenizer,
)
from exllamav2.generator import (
ExLlamaV2StreamingGenerator,
ExLlamaV2Sampler
)
# Configuración del modelo
config = ExLlamaV2Config()
config.model_dir = self.model_path
config.prepare()
# Optimizaciones para RTX 3060 12GB
config.max_seq_len = MAX_SEQ_LEN
config.scale_pos_emb = 1.0
config.scale_alpha_value = 1.0
# Cargar modelo
self.model = ExLlamaV2(config)
log.info("Cargando modelo en GPU...")
# Configurar GPU split (auto para single GPU)
if GPU_SPLIT.lower() == "auto":
self.model.load_autosplit(cache=None)
else:
split = [float(x.strip()) for x in GPU_SPLIT.split(",")]
self.model.load(split)
# Tokenizer
self.tokenizer = ExLlamaV2Tokenizer(config)
# Cache
if CACHE_MODE == "FP16":
self.cache = ExLlamaV2Cache(self.model, lazy=True)
elif CACHE_MODE == "Q4":
from exllamav2 import ExLlamaV2Cache_Q4
self.cache = ExLlamaV2Cache_Q4(self.model, lazy=True)
else:
self.cache = ExLlamaV2Cache(self.model, lazy=True)
# Generator
self.generator = ExLlamaV2StreamingGenerator(
self.model,
self.cache,
self.tokenizer
)
# Configuración de sampling
self.settings = ExLlamaV2Sampler.Settings()
self.settings.temperature = 0.1 # Determinista para clasificación
self.settings.top_k = 10
self.settings.top_p = 0.9
self.settings.token_repetition_penalty = 1.05
log.info("✓ Modelo cargado exitosamente")
except ImportError as e:
log.error(f"Error: ExLlamaV2 no está instalado. Instalar con: pip install exllamav2")
log.error(f"Detalles: {e}")
raise
except Exception as e:
log.error(f"Error cargando modelo: {e}")
raise
def categorize_news(self, news_items: List[Dict]) -> List[Dict]:
"""
Categoriza un lote de noticias
Args:
news_items: Lista de diccionarios con 'id', 'titulo', 'resumen'
Returns:
Lista de diccionarios con 'id', 'categoria', 'confianza'
"""
results = []
for item in news_items:
categoria, confianza = self._categorize_single(
item['titulo'],
item['resumen']
)
results.append({
'id': item['id'],
'categoria': categoria,
'confianza': confianza
})
log.info(f"Noticia {item['id']}: {categoria} (confianza: {confianza:.2f})")
return results
def _categorize_single(self, titulo: str, resumen: str) -> tuple:
"""
Categoriza una noticia individual
Returns:
(categoria, confianza)
"""
# Construir prompt
prompt = self._build_prompt(titulo, resumen)
# Generar respuesta
try:
self.generator.set_stop_conditions([self.tokenizer.eos_token_id])
output = self.generator.generate_simple(
prompt,
self.settings,
max_new_tokens=50, # Solo necesitamos la categoría
seed=1234
)
# Parsear respuesta
categoria, confianza = self._parse_response(output)
return categoria, confianza
except Exception as e:
log.error(f"Error durante la generación: {e}")
return "Otros", 0.0
def _build_prompt(self, titulo: str, resumen: str) -> str:
"""
Construye el prompt para el LLM
Usa el formato Mistral/ChatML
"""
categories_str = ", ".join(CATEGORIES)
# Prompt optimizado para clasificación
prompt = f"""<s>[INST] Eres un asistente experto en clasificación de noticias.
Tu tarea es categorizar la siguiente noticia en UNA de estas categorías:
{categories_str}
Reglas:
1. Responde SOLO con el nombre de la categoría
2. Elige la categoría que MEJOR represente el contenido principal
3. Si no estás seguro, usa "Otros"
Noticia:
Título: {titulo}
Contenido: {resumen[:500]}
Categoría: [/INST]"""
return prompt
def _parse_response(self, output: str) -> tuple:
"""
Parsea la respuesta del LLM
Returns:
(categoria, confianza)
"""
# Limpiar respuesta
response = output.strip()
# Buscar la categoría en la respuesta
for cat in CATEGORIES:
if cat.lower() in response.lower():
# Confianza simple basada en si es exacta
confianza = 0.9 if cat in response else 0.7
return cat, confianza
# Si no se encuentra, usar "Otros"
return "Otros", 0.5
def get_db_connection():
"""Obtiene conexión a la base de datos"""
return psycopg2.connect(**DB_CONFIG)
def initialize_schema(conn):
"""
Asegura que existan las tablas necesarias
"""
log.info("Verificando esquema de base de datos...")
with conn.cursor() as cur:
# Agregar columnas si no existen
cur.execute("""
ALTER TABLE noticias
ADD COLUMN IF NOT EXISTS llm_categoria VARCHAR(100),
ADD COLUMN IF NOT EXISTS llm_confianza FLOAT,
ADD COLUMN IF NOT EXISTS llm_processed BOOLEAN DEFAULT FALSE,
ADD COLUMN IF NOT EXISTS llm_processed_at TIMESTAMP;
""")
# Crear índice para procesamiento eficiente
cur.execute("""
CREATE INDEX IF NOT EXISTS idx_noticias_llm_processed
ON noticias(llm_processed)
WHERE llm_processed = FALSE;
""")
conn.commit()
log.info("✓ Esquema verificado")
def fetch_unprocessed_news(conn, limit: int = 10) -> List[Dict]:
"""
Obtiene noticias sin procesar, agrupadas por feed_id
Estrategia:
1. Obtiene una muestra de feeds con noticias pendientes
2. Selecciona un feed aleatorio de esa muestra
3. Obtiene hasta 'limit' noticias de ese feed específico
Args:
conn: Conexión a la base de datos
limit: Número máximo de noticias a obtener
Returns:
Lista de diccionarios con noticias
"""
import random
with conn.cursor() as cur:
# Paso 1: Identificar feeds candidatos
# Tomamos una muestra de las noticias más recientes pendientes
cur.execute("""
SELECT feed_id
FROM noticias
WHERE llm_processed = FALSE
ORDER BY fecha DESC
LIMIT 100
""")
candidates = cur.fetchall()
if not candidates:
return []
# Extraer IDs únicos de feeds y elegir uno al azar
# Esto evita que un solo feed sature el worker (Round Robin pseudo-aleatorio)
unique_feeds = list(set(r[0] for r in candidates if r[0] is not None))
if not unique_feeds:
return []
target_feed_id = random.choice(unique_feeds)
# Paso 2: Obtener lote del feed seleccionado
cur.execute("""
SELECT id, titulo, resumen
FROM noticias
WHERE llm_processed = FALSE
AND feed_id = %s
AND titulo IS NOT NULL
AND resumen IS NOT NULL
ORDER BY fecha DESC
LIMIT %s
""", (target_feed_id, limit))
rows = cur.fetchall()
log.info(f"Seleccionado feed_id {target_feed_id} para procesamiento ({len(rows)} items)")
return [
{
'id': row[0],
'titulo': row[1],
'resumen': row[2]
}
for row in rows
]
def update_categorizations(conn, results: List[Dict]):
"""
Actualiza las categorizaciones en la base de datos
Args:
conn: Conexión a la base de datos
results: Lista de resultados de categorización
"""
if not results:
return
with conn.cursor() as cur:
# Preparar datos para update
update_data = [
(
r['categoria'],
r['confianza'],
r['id']
)
for r in results
]
# Actualizar en lote
execute_values(cur, """
UPDATE noticias AS n
SET
llm_categoria = v.categoria,
llm_confianza = v.confianza,
llm_processed = TRUE,
llm_processed_at = NOW()
FROM (VALUES %s) AS v(categoria, confianza, id)
WHERE n.id = v.id
""", update_data)
conn.commit()
log.info(f"✓ Actualizadas {len(results)} noticias")
def main():
"""Main loop del worker"""
log.info("=== Iniciando LLM Categorizer Worker ===")
log.info(f"Batch size: {BATCH_SIZE}")
log.info(f"Model path: {MODEL_PATH}")
# Verificar que existe el modelo
if not os.path.exists(os.path.join(MODEL_PATH, "config.json")):
log.error(f"❌ Error: No se encuentra el modelo (config.json) en {MODEL_PATH}")
log.error(f"Por favor descarga un modelo compatible (ej: Mistral-7B-Instruct-v0.2-GPTQ)")
log.error(f"Ejecuta: ./scripts/download_llm_model.sh")
# Dormir para no saturar logs si reinicia rápido
time.sleep(60)
sys.exit(1)
# Inicializar esquema de base de datos
try:
with get_db_connection() as conn:
initialize_schema(conn)
except Exception as e:
log.error(f"❌ Error inicializando esquema: {e}")
sys.exit(1)
# Cargar modelo
try:
categorizer = ExLlamaV2Categorizer(MODEL_PATH)
except Exception as e:
log.error(f"❌ Error cargando modelo: {e}")
sys.exit(1)
log.info("✓ Worker inicializado correctamente")
log.info("Entrando en loop principal...")
# Main loop
while True:
try:
with get_db_connection() as conn:
# Obtener noticias sin procesar
news_items = fetch_unprocessed_news(conn, BATCH_SIZE)
if not news_items:
log.debug(f"No hay noticias pendientes. Esperando {SLEEP_IDLE}s...")
time.sleep(SLEEP_IDLE)
continue
log.info(f"Procesando {len(news_items)} noticias...")
# Categorizar
results = categorizer.categorize_news(news_items)
# Actualizar base de datos
update_categorizations(conn, results)
# Estadísticas
categories_count = {}
for r in results:
cat = r['categoria']
categories_count[cat] = categories_count.get(cat, 0) + 1
log.info(f"Distribución: {categories_count}")
# Si procesamos el lote completo, continuar inmediatamente
if len(news_items) < BATCH_SIZE:
time.sleep(SLEEP_IDLE)
except KeyboardInterrupt:
log.info("Deteniendo worker...")
break
except Exception as e:
log.exception(f"❌ Error en loop principal: {e}")
time.sleep(SLEEP_IDLE)
log.info("Worker finalizado")
if __name__ == "__main__":
main()

226
workers/simple_categorizer_worker.py Normal file
View file

@ -0,0 +1,226 @@
#!/usr/bin/env python3
"""
Simple Categorizer Worker - Categoriza noticias usando keywords
Procesa 10 noticias por feed de manera balanceada
"""
import os
import sys
import time
import logging
import random
import psycopg2
from psycopg2.extras import execute_values
from typing import List, Dict
logging.basicConfig(
level=logging.INFO,
format='[simple_categorizer] %(asctime)s %(levelname)s: %(message)s'
)
log = logging.getLogger(__name__)
DB_CONFIG = {
"host": os.environ.get("DB_HOST", "localhost"),
"port": int(os.environ.get("DB_PORT", 5432)),
"dbname": os.environ.get("DB_NAME", "rss"),
"user": os.environ.get("DB_USER", "rss"),
"password": os.environ.get("DB_PASS", ""),
}
BATCH_SIZE = int(os.environ.get("CATEGORIZER_BATCH_SIZE", 10))
SLEEP_IDLE = int(os.environ.get("CATEGORIZER_SLEEP_IDLE", 5))
# Mapeo de keywords a categorías
CATEGORY_KEYWORDS = {
"Ciencia": ["científico", "investigación", "estudio", "descubrimiento", "laboratorio", "experimento", "universidad", "研究", "science"],
"Cultura": ["museo", "arte", "exposición", "artista", "cultura", "patrimonio", "文化", "culture"],
"Deportes": ["fútbol", "deporte", "equipo", "partido", "jugador", "liga", "campeonato", "运动", "sport", "football"],
"Economía": ["economía", "mercado", "empresa", "inversión", "bolsa", "financiero", "banco", "经济", "economy"],
"Educación": ["educación", "escuela", "universidad", "estudiante", "profesor", "教育", "education"],
"Entretenimiento": ["cine", "película", "actor", "música", "concierto", "娱乐", "entertainment", "film"],
"Internacional": ["internacional", "país", "gobierno", "ministro", "外交", "international", "foreign"],
"Medio Ambiente": ["clima", "ambiental", "contaminación", "ecología", "sostenible", "环境", "environment", "climate"],
"Política": ["político", "gobierno", "presidente", "ministro", "parlamento", "elecciones", "政治", "politics"],
"Salud": ["salud", "hospital", "médico", "enfermedad", "tratamiento", "健康", "health"],
"Sociedad": ["social", "comunidad", "ciudadano", "población", "社会", "society"],
"Tecnología": ["tecnología", "digital", "software", "internet", "app", "技术", "technology", "tech"],
}
def get_db_connection():
return psycopg2.connect(**DB_CONFIG)
def categorize_by_keywords(titulo: str, resumen: str) -> tuple:
"""
Returns: (category_name, confidence)
"""
text = f"{titulo} {resumen}".lower()
scores = {}
for category, keywords in CATEGORY_KEYWORDS.items():
score = sum(1 for kw in keywords if kw.lower() in text)
if score > 0:
scores[category] = score
if not scores:
return "Sociedad", 0.3 # Default
best_category = max(scores, key=scores.get)
max_score = scores[best_category]
confidence = min(0.95, 0.5 + (max_score * 0.1))
return best_category, confidence
def fetch_unprocessed_news(conn, limit: int = 10) -> List[Dict]:
"""Obtiene noticias que tienen traducción al español pero no han sido categorizadas"""
with conn.cursor() as cur:
# Obtener fuentes con noticias pendientes que tengan traducción 'done' en español
cur.execute("""
SELECT n.fuente_nombre
FROM noticias n
JOIN traducciones t ON n.id = t.noticia_id
WHERE n.llm_processed = FALSE
AND t.lang_to = 'es'
AND t.status = 'done'
ORDER BY n.fecha DESC
LIMIT 100
""")
candidates = cur.fetchall()
if not candidates:
return []
unique_sources = list(set(r[0] for r in candidates if r[0] is not None))
if not unique_sources:
return []
target_source = random.choice(unique_sources)
# Obtener lote de la fuente seleccionada usando el texto traducido
cur.execute("""
SELECT n.id, t.titulo_trad, t.resumen_trad
FROM noticias n
JOIN traducciones t ON n.id = t.noticia_id
WHERE n.llm_processed = FALSE
AND n.fuente_nombre = %s
AND t.lang_to = 'es'
AND t.status = 'done'
AND t.titulo_trad IS NOT NULL
ORDER BY n.fecha DESC
LIMIT %s
""", (target_source, limit))
rows = cur.fetchall()
log.info(f"Seleccionada fuente '{target_source}' → {len(rows)} items (USANDO TRADUCCIÓN ES)")
return [{'id': r[0], 'titulo': r[1], 'resumen': r[2]} for r in rows]
def update_categorizations(conn, results: List[Dict]):
"""Actualiza las categorizaciones"""
if not results:
return
with conn.cursor() as cur:
update_data = [
(r['categoria'], r['confianza'], r['id'])
for r in results
]
execute_values(cur, """
UPDATE noticias AS n
SET
llm_categoria = v.categoria,
llm_confianza = v.confianza,
llm_processed = TRUE,
llm_processed_at = NOW()
FROM (VALUES %s) AS v(categoria, confianza, id)
WHERE n.id = v.id
""", update_data)
conn.commit()
log.info(f"✓ {len(results)} noticias categorizadas")
def main():
log.info("=== Simple Categorizer Worker ===")
log.info(f"Batch: {BATCH_SIZE} | Sleep: {SLEEP_IDLE}s")
# Inicializar esquema
try:
log.info("Conectando a la base de datos para verificar esquema...")
with get_db_connection() as conn:
log.info("Conexión establecida. Verificando columnas...")
with conn.cursor() as cur:
cur.execute("""
ALTER TABLE noticias
ADD COLUMN IF NOT EXISTS llm_categoria VARCHAR(100),
ADD COLUMN IF NOT EXISTS llm_confianza FLOAT,
ADD COLUMN IF NOT EXISTS llm_processed BOOLEAN DEFAULT FALSE,
ADD COLUMN IF NOT EXISTS llm_processed_at TIMESTAMP;
""")
cur.execute("""
CREATE INDEX IF NOT EXISTS idx_noticias_llm_processed
ON noticias(llm_processed)
WHERE llm_processed = FALSE;
""")
conn.commit()
log.info("✓ Esquema verificado")
except Exception as e:
log.error(f"❌ Error inicializando: {e}")
sys.exit(1)
log.info("Entrando en loop principal...")
while True:
try:
with get_db_connection() as conn:
news_items = fetch_unprocessed_news(conn, BATCH_SIZE)
if not news_items:
log.debug(f"Sin noticias pendientes. Sleep {SLEEP_IDLE}s...")
time.sleep(SLEEP_IDLE)
continue
log.info(f"Procesando {len(news_items)} noticias...")
results = []
for item in news_items:
categoria, confianza = categorize_by_keywords(
item['titulo'],
item['resumen']
)
results.append({
'id': item['id'],
'categoria': categoria,
'confianza': confianza
})
update_categorizations(conn, results)
# Estadísticas
stats = {}
for r in results:
cat = r['categoria']
stats[cat] = stats.get(cat, 0) + 1
log.info(f"Distribución: {stats}")
if len(news_items) < BATCH_SIZE:
time.sleep(SLEEP_IDLE)
except KeyboardInterrupt:
log.info("Deteniendo worker...")
break
except Exception as e:
log.exception(f"❌ Error: {e}")
time.sleep(SLEEP_IDLE)
log.info("Worker finalizado")
if __name__ == "__main__":
main()

4
workers/translation_worker.py
View file

@ -73,7 +73,7 @@ MAX_NEW_TOKENS_TITLE = _env_int("MAX_NEW_TOKENS_TITLE", 96)
MAX_NEW_TOKENS_BODY = _env_int("MAX_NEW_TOKENS_BODY", 512)
NUM_BEAMS_TITLE = _env_int("NUM_BEAMS_TITLE", 2)
NUM_BEAMS_BODY = _env_int("NUM_BEAMS_BODY", 1)
NUM_BEAMS_BODY = _env_int("NUM_BEAMS_BODY", 2)
# HuggingFace model name (used for tokenizer)
UNIVERSAL_MODEL = _env_str("UNIVERSAL_MODEL", "facebook/nllb-200-distilled-600M")
@ -304,6 +304,8 @@ def _translate_texts(src, tgt, texts, beams, max_new_tokens):
target_prefix=target_prefix,
beam_size=beams,
max_decoding_length=max_new,
repetition_penalty=1.1,
no_repeat_ngram_size=4,
)
dt = time.time() - start