upload files

.dockerignore

@@ -0,0 +1,8 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+*.txt

Dockerfile

@@ -0,0 +1,29 @@
+# Usa una imagen base de Python
+FROM python:3.10-slim
+
+# Crea un usuario no root
+RUN useradd -m -u 1000 user
+
+# Instala dependencias del sistema, incluyendo ffmpeg
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Establece el directorio de trabajo
+WORKDIR /code
+
+# Copia los archivos de requisitos
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copia el resto de los archivos del proyecto
+COPY . .
+
+# Cambia al usuario no root
+USER user
+
+# Expone el puerto 5000 (el que usa Flask)
+EXPOSE 5000
+
+# Ejecuta la aplicación
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,716 @@
+import os
+import cv2
+import mediapipe as mp
+import pandas as pd
+import numpy as np
+import logging
+import subprocess
+import tempfile
+from flask import Flask, render_template, request, jsonify
+from werkzeug.utils import secure_filename
+import atexit
+import shutil
+
+# Configuración de logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Inicializa la aplicación de Flask
+app = Flask(__name__)
+
+# Configuración de Flask
+app.config['SECRET_KEY'] = 'facial-analyzer-demo-2024-super-secret-key-12345'
+app.config['WTF_CSRF_ENABLED'] = False  # Deshabilitar CSRF para este ejemplo
+
+# Configura las rutas para guardar los archivos temporales
+UPLOAD_FOLDER = 'temp_files'
+if not os.path.exists(UPLOAD_FOLDER):
+    os.makedirs(UPLOAD_FOLDER)
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024  # 100MB max
+
+# Inicializa MediaPipe Face Mesh
+mp_face_mesh = mp.solutions.face_mesh
+face_mesh = mp_face_mesh.FaceMesh(
+    static_image_mode=False,
+    max_num_faces=1,
+    min_detection_confidence=0.5,
+    min_tracking_confidence=0.5
+)
+
+
+def download_youtube_video(youtube_url, output_path):
+    """
+    Descarga video de YouTube usando múltiples métodos (PyTube, yt-dlp).
+
+    Args:
+        youtube_url (str): URL del video de YouTube.
+        output_path (str): Carpeta donde guardar el video.
+
+    Returns:
+        tuple: (video_path, video_info) o (None, error_message).
+    """
+    logger.info(f"Intentando descargar: {youtube_url}")
+
+    # Convertir URLs de Shorts a formato normal
+    if '/shorts/' in youtube_url:
+        video_id = youtube_url.split('/shorts/')[-1].split('?')[0]
+        youtube_url = f"https://www.youtube.com/watch?v={video_id}"
+        logger.info(f"Convertido de Shorts a: {youtube_url}")
+
+    # Método 1: Intentar con PyTube
+    try:
+        # Intentar importar PyTube (múltiples versiones)
+        try:
+            from pytubefix import YouTube, exceptions
+            logger.info("📦 Usando PyTubeFix")
+        except ImportError:
+            from pytube import YouTube, exceptions
+            logger.info("📦 Usando PyTube estándar")
+
+        logger.info("Probando método 1: PyTube")
+        yt = YouTube(
+            youtube_url,
+            use_oauth=False,
+            allow_oauth_cache=False
+        )
+
+        # Obtener información del video
+        video_info = {
+            'title': yt.title,
+            'duration': yt.length,
+            'author': yt.author
+        }
+
+        logger.info(f"Video encontrado: {video_info['title']} ({video_info['duration']}s)")
+
+        # Obtener stream
+        stream = None
+        streams = yt.streams.filter(progressive=True, file_extension='mp4')
+        if streams:
+            stream = streams.order_by('resolution').desc().first()
+
+        if not stream:
+            streams = yt.streams.filter(adaptive=True, file_extension='mp4', only_video=True)
+            if streams:
+                stream = streams.order_by('resolution').desc().first()
+
+        if not stream:
+            raise Exception("No se encontraron streams compatibles")
+
+        # Descargar
+        video_id = yt.video_id
+        safe_filename = secure_filename(f"{video_id}.mp4")
+        video_path = os.path.join(output_path, safe_filename)
+
+        stream.download(output_path=output_path, filename=safe_filename)
+
+        if os.path.exists(video_path):
+            logger.info("✅ Descarga exitosa con PyTube")
+            return video_path, video_info
+        else:
+            raise Exception("Archivo no se creó correctamente")
+
+    except Exception as e:
+        logger.warning(f"PyTube falló: {e}")
+
+    # Método 2: Intentar con yt-dlp (más robusto)
+    try:
+        logger.info("Probando método 2: yt-dlp")
+
+        # Extraer ID del video para nombre de archivo
+        if 'watch?v=' in youtube_url:
+            video_id = youtube_url.split('watch?v=')[-1].split('&')[0]
+        elif 'youtu.be/' in youtube_url:
+            video_id = youtube_url.split('youtu.be/')[-1].split('?')[0]
+        else:
+            video_id = 'video'
+
+        safe_filename = secure_filename(f"{video_id}.mp4")
+        video_path = os.path.join(output_path, safe_filename)
+
+        # Comando yt-dlp
+        cmd = [
+             'yt-dlp',
+             '--format', 'mp4[height<=720]/best[height<=720]/best',
+             '--output', video_path,
+             '--no-playlist',
+             youtube_url
+        ]
+        logger.info(f"Ejecutando: {' '.join(cmd)}")
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+
+        if result.returncode == 0 and os.path.exists(video_path):
+            # Obtener información del video
+            info_cmd = [
+                'yt-dlp',
+                '--print', 'title',
+                '--print', 'duration',
+                '--print', 'uploader',
+                '--no-download',
+                youtube_url
+            ]
+
+            info_result = subprocess.run(info_cmd, capture_output=True, text=True, timeout=30)
+
+            if info_result.returncode == 0:
+                lines = info_result.stdout.strip().split('\n')
+                video_info = {
+                    'title': lines[0] if len(lines) > 0 else 'Título desconocido',
+                    'duration': int(float(lines[1])) if len(lines) > 1 and lines[1].replace('.', '').isdigit() else 0,
+                    'author': lines[2] if len(lines) > 2 else 'Autor desconocido'
+                }
+            else:
+                video_info = {
+                    'title': 'Video de YouTube',
+                    'duration': 0,
+                    'author': 'Desconocido'
+                }
+
+            logger.info("✅ Descarga exitosa con yt-dlp")
+            return video_path, video_info
+        else:
+            raise Exception(f"yt-dlp falló: {result.stderr}")
+
+    except subprocess.TimeoutExpired:
+        logger.warning("yt-dlp timeout")
+    except FileNotFoundError:
+        logger.warning("yt-dlp no está instalado")
+    except Exception as e:
+        logger.warning(f"yt-dlp falló: {e}")
+
+    # Si todos los métodos fallan
+    return None, "No se pudo descargar el video. Verifica que la URL sea correcta y el video sea público."
+
+
+# Puntos clave específicos que necesitamos (optimización)
+REQUIRED_LANDMARKS = {
+    'mouth': [13, 14, 61, 291],
+    'eyes': [386, 374, 362, 263],
+    'head': [4, 152, 234, 454],
+    'eyebrows': [107, 336, 17, 268]  # Añadimos puntos para cejas
+}
+
+
+def cleanup_temp_files():
+    """Limpia archivos temporales al cerrar la aplicación."""
+    if os.path.exists(UPLOAD_FOLDER):
+        try:
+            shutil.rmtree(UPLOAD_FOLDER)
+            logger.info("Archivos temporales limpiados")
+        except Exception as e:
+            logger.error(f"Error limpiando archivos temporales: {e}")
+
+
+atexit.register(cleanup_temp_files)
+
+
+def get_video_info(video_path):
+    """
+    Obtiene información básica del video como FPS y duración.
+
+    Args:
+        video_path (str): Ruta al archivo de video.
+
+    Returns:
+        tuple: (fps, frame_count, duration)
+    """
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return None, None, None
+
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    duration = frame_count / fps if fps > 0 else 0
+
+    cap.release()
+    return fps, frame_count, duration
+
+
+def extract_required_landmarks(landmarks):
+    """
+    Extrae solo los landmarks necesarios para optimizar memoria.
+
+    Args:
+        landmarks: Landmarks de MediaPipe.
+
+    Returns:
+        dict: Diccionario con coordenadas de puntos específicos.
+    """
+    result = {}
+    all_points = []
+    for category, indices in REQUIRED_LANDMARKS.items():
+        all_points.extend(indices)
+
+    for i in all_points:
+        if i < len(landmarks.landmark):
+            landmark = landmarks.landmark[i]
+            result[f'x_{i}'] = landmark.x
+            result[f'y_{i}'] = landmark.y
+
+    return result
+
+
+def get_video_landmarks(video_path):
+    """
+    Procesa un video y extrae los puntos faciales clave (optimizado).
+
+    Args:
+        video_path (str): Ruta al archivo de video.
+
+    Returns:
+        pd.DataFrame: Un DataFrame de pandas con los puntos clave por fotograma.
+    """
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        logger.error(f"No se pudo abrir el video: {video_path}")
+        return None
+
+    # Obtener información del video
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    logger.info(f"Procesando video: {total_frames} frames a {fps} FPS")
+
+    data = []
+    frame_count = 0
+    processed_frames = 0
+
+    # Procesar cada frame
+    while cap.isOpened():
+        success, image = cap.read()
+        if not success:
+            break
+
+        # Preprocesar imagen
+        image.flags.writeable = False
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        results = face_mesh.process(image)
+
+        # Extraer datos del frame
+        row_data = {'frame': frame_count, 'fps': fps}
+
+        if results.multi_face_landmarks:
+            landmarks_data = extract_required_landmarks(results.multi_face_landmarks[0])
+            row_data.update(landmarks_data)
+            processed_frames += 1
+        else:
+            # Llenar con NaN si no se detecta cara
+            for category, indices in REQUIRED_LANDMARKS.items():
+                for i in indices:
+                    row_data[f'x_{i}'] = np.nan
+                    row_data[f'y_{i}'] = np.nan
+
+        data.append(row_data)
+        frame_count += 1
+
+        # Log progreso cada 100 frames
+        if frame_count % 100 == 0:
+            logger.info(f"Procesados {frame_count}/{total_frames} frames")
+
+    cap.release()
+
+    if processed_frames == 0:
+        logger.warning("No se detectaron caras en ningún frame")
+        return None
+
+    logger.info(f"Análisis completado: {processed_frames}/{frame_count} frames con detección facial")
+    return pd.DataFrame(data)
+
+
+def calculate_metrics(df):
+    """
+    Calcula las métricas de comportamiento a partir del DataFrame de puntos.
+
+    Args:
+        df (pd.DataFrame): DataFrame con los puntos faciales por fotograma.
+
+    Returns:
+        dict: Diccionario con todas las métricas calculadas.
+    """
+    if df.empty or 'fps' not in df.columns:
+        return {'error': 'DataFrame vacío o sin información de FPS'}
+
+    total_frames = len(df)
+    video_fps = df['fps'].iloc[0] if not df['fps'].isna().all() else 30
+    total_video_time_seconds = total_frames / video_fps if total_frames > 0 else 0
+
+    # Filtrar frames válidos (con detección facial)
+    valid_frames = df.dropna()
+    if valid_frames.empty:
+        return {'error': 'No hay frames válidos con detección facial'}
+
+    # === ANÁLISIS DE SONRISAS ===
+    try:
+        y1, y2 = valid_frames['y_13'], valid_frames['y_14']
+        x1, x2 = valid_frames['x_61'], valid_frames['x_291']
+
+        # Calcular MAR (Mouth Aspect Ratio)
+        distancia_vertical = np.abs(y1 - y2)
+        distancia_horizontal = np.abs(x1 - x2)
+        mar = distancia_vertical / (distancia_horizontal + 1e-6)
+
+        # Detectar sonrisas
+        smiles = []
+        is_smiling = False
+        start_frame = 0
+        smile_threshold = 0.2
+
+        for i, (idx, row) in enumerate(valid_frames.iterrows()):
+            current_mar = mar.iloc[i]
+            current_frame = row['frame']
+
+            if current_mar > smile_threshold and not is_smiling:
+                is_smiling = True
+                start_frame = current_frame
+            elif current_mar <= smile_threshold and is_smiling:
+                is_smiling = False
+                end_frame = current_frame
+                duration = (end_frame - start_frame) / video_fps
+                if duration > 0.1:  # Filtrar sonrisas muy cortas
+                    smiles.append(duration)
+
+        total_smiles = len(smiles)
+        avg_smile_duration = np.mean(smiles) if smiles else 0
+        total_smile_time = sum(smiles) if smiles else 0
+
+    except Exception as e:
+        logger.error(f"Error en análisis de sonrisas: {e}")
+        total_smiles = 0
+        avg_smile_duration = 0
+        total_smile_time = 0
+
+    # === ANÁLISIS DE PARPADEOS ===
+    try:
+        # Calcular EAR (Eye Aspect Ratio)
+        dist_vert = np.abs(valid_frames['y_386'] - valid_frames['y_374'])
+        dist_horiz = np.abs(valid_frames['x_362'] - valid_frames['x_263'])
+        ear = dist_vert / (dist_horiz + 1e-6)
+
+        # Detectar parpadeos
+        blinks = 0
+        blink_threshold = 0.25
+        min_blink_frames = 2
+        blinks_consecutive_frames = 0
+
+        for value in ear:
+            if value < blink_threshold:
+                blinks_consecutive_frames += 1
+            else:
+                if blinks_consecutive_frames >= min_blink_frames:
+                    blinks += 1
+                blinks_consecutive_frames = 0
+
+        blink_rate_per_minute = (blinks / total_video_time_seconds) * 60 if total_video_time_seconds > 0 else 0
+
+    except Exception as e:
+        logger.error(f"Error en análisis de parpadeos: {e}")
+        blinks = 0
+        blink_rate_per_minute = 0
+
+    # === ANÁLISIS DE MOVIMIENTO DE CABEZA ===
+    try:
+        movimiento_vertical_cabeza = valid_frames['y_4'] - valid_frames['y_152']
+        movimiento_horizontal_cabeza = valid_frames['x_234'] - valid_frames['x_454']
+
+        std_vertical_head = np.std(movimiento_vertical_cabeza)
+        std_horizontal_head = np.std(movimiento_horizontal_cabeza)
+
+        # Calcular movimiento total
+        total_head_movement = np.sqrt(std_vertical_head**2 + std_horizontal_head**2)
+
+    except Exception as e:
+        logger.error(f"Error en análisis de movimiento de cabeza: {e}")
+        std_vertical_head = 0
+        std_horizontal_head = 0
+        total_head_movement = 0
+
+    # === ANÁLISIS DE EMOCIONES NEGATIVAS ===
+    try:
+        # Cejas (diferencia vertical entre 107 y 336 para enojo/furioso)
+        brow_diff = np.abs(valid_frames['y_107'] - valid_frames['y_336'])
+        # Boca (usamos MAR ajustado para tensión)
+        mar_tension = mar  # Reusamos MAR pero con umbral diferente
+        # Gruñón (diferencia vertical entre 17 y 268, boca neutral)
+        mouth_neutral = np.abs(valid_frames['y_17'] - valid_frames['y_268'])
+
+        # Detectar enojado (cejas fruncidas + boca tensa)
+        angry_events = []
+        is_angry = False
+        start_frame = 0
+        angry_brow_threshold = 0.05  # Umbral para cejas fruncidas
+        angry_mar_threshold = 0.15   # Umbral para boca tensa
+        for i, (idx, row) in enumerate(valid_frames.iterrows()):
+            current_brow = brow_diff.iloc[i]
+            current_mar = mar_tension.iloc[i]
+            current_frame = row['frame']
+            if current_brow < angry_brow_threshold and current_mar < angry_mar_threshold and not is_angry:
+                is_angry = True
+                start_frame = current_frame
+            elif (current_brow >= angry_brow_threshold or current_mar >= angry_mar_threshold) and is_angry:
+                is_angry = False
+                end_frame = current_frame
+                duration = (end_frame - start_frame) / video_fps
+                if duration > 0.1:
+                    angry_events.append(duration)
+
+        total_angry = len(angry_events)
+        avg_angry_duration = np.mean(angry_events) if angry_events else 0
+        total_angry_time = sum(angry_events) if angry_events else 0
+
+        # Detectar gruñón (cejas ligeramente fruncidas + boca neutral)
+        grumpy_events = []
+        is_grumpy = False
+        start_frame = 0
+        grumpy_brow_threshold = 0.08  # Umbral más suave
+        grumpy_mouth_threshold = 0.03  # Diferencia vertical baja para neutral
+        for i, (idx, row) in enumerate(valid_frames.iterrows()):
+            current_brow = brow_diff.iloc[i]
+            current_mouth = mouth_neutral.iloc[i]
+            current_frame = row['frame']
+            if current_brow < grumpy_brow_threshold and current_mouth < grumpy_mouth_threshold and not is_grumpy:
+                is_grumpy = True
+                start_frame = current_frame
+            elif (current_brow >= grumpy_brow_threshold or current_mouth >= grumpy_mouth_threshold) and is_grumpy:
+                is_grumpy = False
+                end_frame = current_frame
+                duration = (end_frame - start_frame) / video_fps
+                if duration > 0.1:
+                    grumpy_events.append(duration)
+
+        total_grumpy = len(grumpy_events)
+        avg_grumpy_duration = np.mean(grumpy_events) if grumpy_events else 0
+        total_grumpy_time = sum(grumpy_events) if grumpy_events else 0
+
+        # Detectar furioso (cejas muy fruncidas + boca tensa intensa)
+        furious_events = []
+        is_furious = False
+        start_frame = 0
+        furious_brow_threshold = 0.03  # Umbral más estricto
+        furious_mar_threshold = 0.10   # Umbral más bajo para tensión fuerte
+        for i, (idx, row) in enumerate(valid_frames.iterrows()):
+            current_brow = brow_diff.iloc[i]
+            current_mar = mar_tension.iloc[i]
+            current_frame = row['frame']
+            if current_brow < furious_brow_threshold and current_mar < furious_mar_threshold and not is_furious:
+                is_furious = True
+                start_frame = current_frame
+            elif (current_brow >= furious_brow_threshold or current_mar >= furious_mar_threshold) and is_furious:
+                is_furious = False
+                end_frame = current_frame
+                duration = (end_frame - start_frame) / video_fps
+                if duration > 0.1:
+                    furious_events.append(duration)
+
+        total_furious = len(furious_events)
+        avg_furious_duration = np.mean(furious_events) if furious_events else 0
+        total_furious_time = sum(furious_events) if furious_events else 0
+
+    except Exception as e:
+        logger.error(f"Error en análisis de emociones negativas: {e}")
+        total_angry = 0
+        avg_angry_duration = 0
+        total_angry_time = 0
+        total_grumpy = 0
+        avg_grumpy_duration = 0
+        total_grumpy_time = 0
+        total_furious = 0
+        avg_furious_duration = 0
+        total_furious_time = 0
+
+    # === MÉTRICAS ADICIONALES ===
+    face_detection_rate = len(valid_frames) / total_frames * 100
+
+    return {
+        'video_info': {
+            'duracion_total': round(total_video_time_seconds, 2),
+            'fps': round(video_fps, 1),
+            'frames_totales': total_frames,
+            'frames_con_deteccion': len(valid_frames),
+            'tasa_deteccion_facial': round(face_detection_rate, 2)
+        },
+        'sonrisas': {
+            'total_sonrisas': total_smiles,
+            'duracion_promedio_sonrisas': round(avg_smile_duration, 2),
+            'tiempo_total_sonriendo': round(total_smile_time, 2),
+            'porcentaje_tiempo_sonriendo': round((total_smile_time / total_video_time_seconds) * 100, 2) if total_video_time_seconds > 0 else 0
+        },
+        'parpadeos': {
+            'total_parpadeos': blinks,
+            'tasa_parpadeo_por_minuto': round(blink_rate_per_minute, 2)
+        },
+        'movimiento_cabeza': {
+            'estabilidad_vertical': round(std_vertical_head, 4),
+            'estabilidad_horizontal': round(std_horizontal_head, 4),
+            'movimiento_total': round(total_head_movement, 4)
+        },
+        'emociones_negativas': {
+            'total_enojado': total_angry,
+            'duracion_promedio_enojado': round(avg_angry_duration, 2),
+            'porcentaje_tiempo_enojado': round((total_angry_time / total_video_time_seconds) * 100, 2) if total_video_time_seconds > 0 else 0,
+            'total_grunon': total_grumpy,
+            'duracion_promedio_grunon': round(avg_grumpy_duration, 2),
+            'porcentaje_tiempo_grunon': round((total_grumpy_time / total_video_time_seconds) * 100, 2) if total_video_time_seconds > 0 else 0,
+            'total_furioso': total_furious,
+            'duracion_promedio_furioso': round(avg_furious_duration, 2),
+            'porcentaje_tiempo_furioso': round((total_furious_time / total_video_time_seconds) * 100, 2) if total_video_time_seconds > 0 else 0
+        }
+    }
+
+
+@app.route('/', methods=['GET'])
+def index():
+    return render_template('index.html')
+
+
+@app.route('/test', methods=['GET', 'POST'])
+def test():
+    """Ruta de prueba para debugging."""
+    if request.method == 'GET':
+        return jsonify({'status': 'success', 'message': 'Test endpoint working'})
+    else:
+        data = request.get_json() if request.is_json else request.form.to_dict()
+        return jsonify({'status': 'success', 'received_data': data})
+
+
+@app.route('/health', methods=['GET'])
+def health():
+    """Health check endpoint."""
+    return jsonify({'status': 'healthy', 'message': 'Server is running'})
+
+
+@app.before_request
+def log_request_info():
+    """Log información de cada request."""
+    logger.info(f"Request: {request.method} {request.url}")
+    logger.info(f"Headers: {dict(request.headers)}")
+    if request.method == 'POST':
+        logger.info(f"Content-Type: {request.content_type}")
+        logger.info(f"Content-Length: {request.content_length}")
+
+
+@app.route('/analyze', methods=['POST'])
+def analyze():
+    try:
+        # Intentar obtener datos del form primero, luego JSON
+        if request.content_type and 'application/json' in request.content_type:
+            data = request.get_json()
+            youtube_url = data.get('youtube_url', '').strip() if data else ''
+        else:
+            youtube_url = request.form.get('youtube_url', '').strip()
+
+        logger.info(f"Received URL: {youtube_url}")
+        logger.info(f"Content-Type: {request.content_type}")
+
+        # Validaciones de entrada
+        if not youtube_url:
+            return jsonify({
+                'status': 'error',
+                'message': 'Por favor, introduce una URL de YouTube válida.'
+            }), 400
+
+        if 'youtube.com' not in youtube_url and 'youtu.be' not in youtube_url:
+            return jsonify({
+                'status': 'error',
+                'message': 'La URL debe ser de YouTube.'
+            }), 400
+
+    except Exception as e:
+        logger.error(f"Error procesando request: {e}")
+        return jsonify({
+            'status': 'error',
+            'message': 'Error procesando la petición.'
+        }), 400
+
+    video_path = None
+    try:
+        logger.info(f"Iniciando análisis de: {youtube_url}")
+
+        # Descargar video usando método robusto
+        video_path, video_info = download_youtube_video(youtube_url, app.config['UPLOAD_FOLDER'])
+
+        if video_path is None:
+            return jsonify({
+                'status': 'error',
+                'message': video_info  # video_info contiene el mensaje de error
+            })
+
+        logger.info(f"Video descargado: {video_info['title']}")
+
+        # Validar duración
+        if video_info['duration'] > 600:  # 10 minutos
+            return jsonify({
+                'status': 'error',
+                'message': f'El video es demasiado largo ({video_info["duration"]//60} min). Máximo 10 minutos permitidos.'
+            })
+
+        # Verificar que el archivo se descargó correctamente
+        if not os.path.exists(video_path):
+            return jsonify({
+                'status': 'error',
+                'message': 'Error al descargar el video.'
+            })
+
+        logger.info("Video descargado. Iniciando análisis facial...")
+
+        # Procesar video
+        landmarks_df = get_video_landmarks(video_path)
+
+        if landmarks_df is None or landmarks_df.empty:
+            return jsonify({
+                'status': 'error',
+                'message': 'No se pudieron extraer los puntos faciales. Asegúrate de que el video muestre claramente una cara.'
+            })
+
+        logger.info("Análisis facial completado. Calculando métricas...")
+
+        # Calcular métricas
+        report_data = calculate_metrics(landmarks_df)
+
+        if 'error' in report_data:
+            return jsonify({
+                'status': 'error',
+                'message': f'Error en el cálculo de métricas: {report_data["error"]}'
+            })
+
+        # Agregar información del video
+        report_data['video_title'] = video_info['title']
+        report_data['video_url'] = youtube_url
+
+        logger.info("Análisis completado exitosamente")
+        return jsonify({'status': 'success', 'data': report_data})
+
+    except Exception as e:
+        logger.error(f"Error inesperado: {e}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Error inesperado: {str(e)}'
+        })
+    finally:
+        # Limpiar archivo temporal
+        if video_path and os.path.exists(video_path):
+            try:
+                os.remove(video_path)
+                logger.info("Archivo temporal eliminado")
+            except Exception as e:
+                logger.error(f"Error eliminando archivo temporal: {e}")
+
+
+@app.errorhandler(413)
+def too_large(e):
+    return jsonify({
+        'status': 'error',
+        'message': 'El archivo es demasiado grande.'
+    }), 413
+
+
+@app.errorhandler(500)
+def internal_error(e):
+    return jsonify({
+        'status': 'error',
+        'message': 'Error interno del servidor.'
+    }), 500
+
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)