setup_environment.py

#!/usr/bin/env python3
"""
setup_environment.py - Script de configuración inicial del entorno

Configura el entorno de desarrollo para fine-tuning de Gemini,
valida dependencias, y prepara la configuración inicial.

Autor: Alex Cerezo
Fecha: 2024
"""

import os
import sys
import json
import shutil
import subprocess
from pathlib import Path
from typing import List, Dict, Any, Optional
import colorama
from colorama import Fore, Style


# Inicializar colorama
colorama.init(autoreset=True)


class EnvironmentSetup:
    """Configurador del entorno de desarrollo."""

    def __init__(self):
        """Inicializa el configurador."""
        self.project_root = Path.cwd()
        self.errors = []
        self.warnings = []
        
        print(f"""
{Fore.CYAN}╔══════════════════════════════════════════════════════════════╗
║                                                              ║
║           🛠️  CONFIGURACIÓN DEL ENTORNO GEMINI              ║
║              Fine-tuning Sign Language                       ║
║                                                              ║
╚══════════════════════════════════════════════════════════════╝{Style.RESET_ALL}
""")

    def check_python_version(self) -> bool:
        """
        Verifica que la versión de Python sea compatible.

        Returns:
            True si la versión es compatible
        """
        print(f"{Fore.BLUE}🔍 Verificando versión de Python...{Style.RESET_ALL}")
        
        version = sys.version_info
        required_major, required_minor = 3, 8
        
        if version.major >= required_major and version.minor >= required_minor:
            print(f"{Fore.GREEN}✅ Python {version.major}.{version.minor}.{version.micro} es compatible{Style.RESET_ALL}")
            return True
        else:
            error_msg = f"Python {version.major}.{version.minor} no es compatible. Se requiere Python {required_major}.{required_minor}+"
            self.errors.append(error_msg)
            print(f"{Fore.RED}❌ {error_msg}{Style.RESET_ALL}")
            return False

    def check_dependencies(self) -> bool:
        """
        Verifica e instala las dependencias requeridas.

        Returns:
            True si todas las dependencias están disponibles
        """
        print(f"{Fore.BLUE}📦 Verificando dependencias...{Style.RESET_ALL}")
        
        requirements_file = self.project_root / "requirements.txt"
        
        if not requirements_file.exists():
            error_msg = "Archivo requirements.txt no encontrado"
            self.errors.append(error_msg)
            print(f"{Fore.RED}❌ {error_msg}{Style.RESET_ALL}")
            return False
        
        try:
            # Instalar dependencias
            print(f"{Fore.YELLOW}📥 Instalando dependencias...{Style.RESET_ALL}")
            result = subprocess.run(
                [sys.executable, "-m", "pip", "install", "-r", str(requirements_file)],
                capture_output=True,
                text=True,
                check=True
            )
            
            print(f"{Fore.GREEN}✅ Dependencias instaladas correctamente{Style.RESET_ALL}")
            return True
            
        except subprocess.CalledProcessError as e:
            error_msg = f"Error al instalar dependencias: {e.stderr}"
            self.errors.append(error_msg)
            print(f"{Fore.RED}❌ {error_msg}{Style.RESET_ALL}")
            return False

    def setup_environment_file(self) -> bool:
        """
        Configura el archivo .env si no existe.

        Returns:
            True si la configuración fue exitosa
        """
        print(f"{Fore.BLUE}⚙️  Configurando archivo de entorno...{Style.RESET_ALL}")
        
        env_file = self.project_root / ".env"
        env_example = self.project_root / ".env.example"
        
        if env_file.exists():
            print(f"{Fore.YELLOW}⚠️  El archivo .env ya existe{Style.RESET_ALL}")
            return True
        
        if not env_example.exists():
            warning_msg = "Archivo .env.example no encontrado"
            self.warnings.append(warning_msg)
            print(f"{Fore.YELLOW}⚠️  {warning_msg}{Style.RESET_ALL}")
            
            # Crear .env básico
            self._create_basic_env_file(env_file)
        else:
            # Copiar desde .env.example
            shutil.copy2(env_example, env_file)
            print(f"{Fore.GREEN}✅ Archivo .env creado desde .env.example{Style.RESET_ALL}")
        
        # Solicitar API key si no está configurada
        self._configure_api_key(env_file)
        
        return True

    def _create_basic_env_file(self, env_file: Path) -> None:
        """
        Crea un archivo .env básico.

        Args:
            env_file: Ruta del archivo .env
        """
        basic_config = """# Google Generative AI Configuration
GOOGLE_API_KEY=your_api_key_here

# Fine-tuning Configuration
GEMINI_MODEL=gemini-1.5-flash
DATASET_DIR=final_datasets
OUTPUT_DIR=models

# Training Parameters
EPOCHS=3
BATCH_SIZE=32
LEARNING_RATE=auto

# Logging Configuration
LOG_LEVEL=INFO
LOG_FILE=fine_tuning.log

# Evaluation Configuration
EVAL_THRESHOLD=0.8
EVAL_SAMPLE_SIZE=100
"""
        
        with open(env_file, 'w', encoding='utf-8') as f:
            f.write(basic_config)
        
        print(f"{Fore.GREEN}✅ Archivo .env básico creado{Style.RESET_ALL}")

    def _configure_api_key(self, env_file: Path) -> None:
        """
        Configura la API key de Google si no está presente.

        Args:
            env_file: Ruta del archivo .env
        """
        # Leer archivo actual
        with open(env_file, 'r', encoding='utf-8') as f:
            content = f.read()
        
        # Verificar si ya tiene una API key válida
        if 'GOOGLE_API_KEY=' in content:
            lines = content.split('\n')
            for line in lines:
                if line.startswith('GOOGLE_API_KEY='):
                    api_key = line.split('=', 1)[1].strip()
                    if api_key and api_key != 'your_api_key_here' and len(api_key) > 30:
                        print(f"{Fore.GREEN}✅ API key ya configurada{Style.RESET_ALL}")
                        return
        
        # Solicitar API key
        print(f"\n{Fore.YELLOW}🔑 Configuración de API Key de Google{Style.RESET_ALL}")
        print(f"{Fore.CYAN}Para obtener tu API key:{Style.RESET_ALL}")
        print(f"   1. Visita: https://aistudio.google.com/app/apikey")
        print(f"   2. Crea una nueva API key")
        print(f"   3. Copia la key generada")
        
        api_key = input(f"\n{Fore.YELLOW}Introduce tu API key de Google (o presiona Enter para omitir): {Style.RESET_ALL}").strip()
        
        if api_key:
            # Actualizar archivo .env
            updated_content = content.replace(
                'GOOGLE_API_KEY=your_api_key_here',
                f'GOOGLE_API_KEY={api_key}'
            )
            
            # Si no encontró la línea, agregarla
            if 'your_api_key_here' not in content:
                if 'GOOGLE_API_KEY=' in content:
                    import re
                    updated_content = re.sub(
                        r'GOOGLE_API_KEY=.*',
                        f'GOOGLE_API_KEY={api_key}',
                        content
                    )
                else:
                    updated_content = f'GOOGLE_API_KEY={api_key}\n' + content
            
            with open(env_file, 'w', encoding='utf-8') as f:
                f.write(updated_content)
            
            print(f"{Fore.GREEN}✅ API key configurada{Style.RESET_ALL}")
        else:
            warning_msg = "API key no configurada. Configúrala manualmente en .env"
            self.warnings.append(warning_msg)
            print(f"{Fore.YELLOW}⚠️  {warning_msg}{Style.RESET_ALL}")

    def validate_project_structure(self) -> bool:
        """
        Valida que la estructura del proyecto sea correcta.

        Returns:
            True si la estructura es válida
        """
        print(f"{Fore.BLUE}📁 Validando estructura del proyecto...{Style.RESET_ALL}")
        
        required_files = [
            "fine_tune_gemini.py",
            "evaluate_model.py", 
            "test_interface.py",
            "utils/gemini_helper.py",
            "requirements.txt"
        ]
        
        required_dirs = [
            "utils",
            "final_datasets",
            "models"
        ]
        
        missing_files = []
        missing_dirs = []
        
        # Verificar archivos
        for file_path in required_files:
            full_path = self.project_root / file_path
            if not full_path.exists():
                missing_files.append(file_path)
        
        # Verificar directorios
        for dir_path in required_dirs:
            full_path = self.project_root / dir_path
            if not full_path.exists():
                missing_dirs.append(dir_path)
                # Crear directorio si es necesario
                full_path.mkdir(parents=True, exist_ok=True)
                print(f"{Fore.YELLOW}📁 Directorio creado: {dir_path}{Style.RESET_ALL}")
        
        # Reportar archivos faltantes
        if missing_files:
            for file_path in missing_files:
                error_msg = f"Archivo requerido no encontrado: {file_path}"
                self.errors.append(error_msg)
                print(f"{Fore.RED}❌ {error_msg}{Style.RESET_ALL}")
        
        # Verificar datasets
        self._validate_datasets()
        
        return len(missing_files) == 0

    def _validate_datasets(self) -> None:
        """Valida que los datasets estén presentes."""
        dataset_dir = self.project_root / "final_datasets"
        required_datasets = ["train.json", "validation.json", "test.json"]
        
        for dataset in required_datasets:
            dataset_path = dataset_dir / dataset
            if dataset_path.exists():
                print(f"{Fore.GREEN}✅ Dataset encontrado: {dataset}{Style.RESET_ALL}")
            else:
                warning_msg = f"Dataset no encontrado: {dataset}"
                self.warnings.append(warning_msg)
                print(f"{Fore.YELLOW}⚠️  {warning_msg}{Style.RESET_ALL}")

    def test_api_connection(self) -> bool:
        """
        Prueba la conexión con la API de Gemini.

        Returns:
            True si la conexión es exitosa
        """
        print(f"{Fore.BLUE}🌐 Probando conexión con API de Gemini...{Style.RESET_ALL}")
        
        try:
            # Importar y probar helper
            from utils.gemini_helper import validate_environment, GeminiHelper
            
            if not validate_environment():
                error_msg = "Validación del entorno falló"
                self.errors.append(error_msg)
                print(f"{Fore.RED}❌ {error_msg}{Style.RESET_ALL}")
                return False
            
            # Probar conexión
            helper = GeminiHelper()
            if helper.validate_api_connection():
                print(f"{Fore.GREEN}✅ Conexión con API exitosa{Style.RESET_ALL}")
                return True
            else:
                error_msg = "No se pudo conectar con la API de Gemini"
                self.errors.append(error_msg)
                print(f"{Fore.RED}❌ {error_msg}{Style.RESET_ALL}")
                return False
                
        except Exception as e:
            error_msg = f"Error al probar conexión: {e}"
            self.errors.append(error_msg)
            print(f"{Fore.RED}❌ {error_msg}{Style.RESET_ALL}")
            return False

    def create_usage_guide(self) -> None:
        """Crea una guía de uso rápida."""
        guide_content = """# 🚀 Guía de Uso Rápida

## Configuración Inicial

1. **Verificar configuración**:
   ```bash
   python setup_environment.py
   ```

2. **Configurar API Key** (si no se hizo automáticamente):
   - Edita el archivo `.env`
   - Cambia `GOOGLE_API_KEY=your_api_key_here` por tu API key real

## Uso Principal

### 1. Fine-tuning del Modelo
```bash
# Fine-tuning completo
python fine_tune_gemini.py

# Solo evaluación del modelo base
python fine_tune_gemini.py --eval-only
```

### 2. Evaluación Detallada
```bash
# Evaluación completa
python evaluate_model.py

# Evaluación con muestra específica
python evaluate_model.py --sample-size 50
```

### 3. Interfaz de Pruebas
```bash
# Modo interactivo
python test_interface.py

# Prueba única
python test_interface.py --single-test "Texto con repeticionesss"

# Testing en lote
python test_interface.py --batch-file datos/test.json
```

## Estructura de Archivos

- `fine_tune_gemini.py` - Script principal de fine-tuning
- `evaluate_model.py` - Sistema de evaluación
- `test_interface.py` - Interfaz interactiva de pruebas
- `utils/gemini_helper.py` - Utilidades para API de Gemini
- `final_datasets/` - Datasets de entrenamiento
- `models/` - Modelos y resultados

## Configuración Avanzada

Edita el archivo `.env` para personalizar:
- Número de epochs
- Tamaño de batch
- Directorios de entrada y salida
- Nivel de logging

## Troubleshooting

### Error de API Key
- Verifica que tu API key sea válida
- Asegúrate de tener créditos en Google AI Studio

### Error de Dependencias
```bash
pip install -r requirements.txt
```

### Datasets No Encontrados
- Verifica que existan los archivos en `final_datasets/`
- Ejecuta `python data_generator.py` si es necesario
"""
        
        guide_file = self.project_root / "QUICK_START.md"
        with open(guide_file, 'w', encoding='utf-8') as f:
            f.write(guide_content)
        
        print(f"{Fore.GREEN}✅ Guía de uso creada: QUICK_START.md{Style.RESET_ALL}")

    def run_setup(self) -> bool:
        """
        Ejecuta la configuración completa del entorno.

        Returns:
            True si la configuración fue exitosa
        """
        print(f"{Fore.CYAN}🚀 Iniciando configuración del entorno...{Style.RESET_ALL}\n")
        
        steps = [
            ("Verificar Python", self.check_python_version),
            ("Instalar dependencias", self.check_dependencies),
            ("Configurar entorno", self.setup_environment_file),
            ("Validar estructura", self.validate_project_structure),
            ("Probar API", self.test_api_connection)
        ]
        
        success_count = 0
        
        for step_name, step_func in steps:
            print(f"\n{Fore.BLUE}{'='*60}{Style.RESET_ALL}")
            print(f"{Fore.BLUE}🔧 {step_name}...{Style.RESET_ALL}")
            print(f"{Fore.BLUE}{'='*60}{Style.RESET_ALL}")
            
            try:
                if step_func():
                    success_count += 1
                    print(f"{Fore.GREEN}✅ {step_name} completado{Style.RESET_ALL}")
                else:
                    print(f"{Fore.RED}❌ {step_name} falló{Style.RESET_ALL}")
            except Exception as e:
                error_msg = f"Error en {step_name}: {e}"
                self.errors.append(error_msg)
                print(f"{Fore.RED}❌ {error_msg}{Style.RESET_ALL}")
        
        # Crear guía de uso
        print(f"\n{Fore.BLUE}{'='*60}{Style.RESET_ALL}")
        print(f"{Fore.BLUE}🔧 Creando guía de uso...{Style.RESET_ALL}")
        print(f"{Fore.BLUE}{'='*60}{Style.RESET_ALL}")
        self.create_usage_guide()
        
        # Mostrar resumen
        self._show_setup_summary(success_count, len(steps))
        
        return success_count == len(steps) and len(self.errors) == 0

    def _show_setup_summary(self, success_count: int, total_steps: int) -> None:
        """
        Muestra un resumen de la configuración.

        Args:
            success_count: Número de pasos exitosos
            total_steps: Total de pasos
        """
        print(f"\n{Fore.CYAN}{'='*80}{Style.RESET_ALL}")
        print(f"{Fore.CYAN}📊 RESUMEN DE CONFIGURACIÓN{Style.RESET_ALL}")
        print(f"{Fore.CYAN}{'='*80}{Style.RESET_ALL}")
        
        print(f"{Fore.YELLOW}Pasos completados: {success_count}/{total_steps}{Style.RESET_ALL}")
        
        if self.errors:
            print(f"\n{Fore.RED}❌ ERRORES ENCONTRADOS:{Style.RESET_ALL}")
            for error in self.errors:
                print(f"   • {error}")
        
        if self.warnings:
            print(f"\n{Fore.YELLOW}⚠️  ADVERTENCIAS:{Style.RESET_ALL}")
            for warning in self.warnings:
                print(f"   • {warning}")
        
        if success_count == total_steps and not self.errors:
            print(f"\n{Fore.GREEN}🎉 ¡CONFIGURACIÓN COMPLETADA EXITOSAMENTE!{Style.RESET_ALL}")
            print(f"\n{Fore.CYAN}🚀 Próximos pasos:{Style.RESET_ALL}")
            print(f"   1. Revisa el archivo QUICK_START.md")
            print(f"   2. Ejecuta: python fine_tune_gemini.py --eval-only")
            print(f"   3. Prueba la interfaz: python test_interface.py")
        else:
            print(f"\n{Fore.RED}⚠️  CONFIGURACIÓN INCOMPLETA{Style.RESET_ALL}")
            print(f"{Fore.YELLOW}Revisa los errores y ejecuta el script nuevamente{Style.RESET_ALL}")


def main():
    """Función principal del script."""
    try:
        setup = EnvironmentSetup()
        success = setup.run_setup()
        
        return 0 if success else 1
        
    except KeyboardInterrupt:
        print(f"\n\n{Fore.YELLOW}⚠️  Configuración cancelada por el usuario{Style.RESET_ALL}")
        return 1
    except Exception as e:
        print(f"\n{Fore.RED}❌ Error fatal durante la configuración: {e}{Style.RESET_ALL}")
        return 1


if __name__ == "__main__":
    exit(main())