test_deployment.py

#!/usr/bin/env python3
"""
Script de test pour vérifier le bon fonctionnement de l'application
avant le déploiement sur Hugging Face Spaces.
"""

import os
import sys
import tempfile
import numpy as np
import soundfile as sf
from pathlib import Path

def test_imports():
    """Test des imports nécessaires"""
    print("🔍 Test des imports...")
    
    try:
        import gradio as gr
        print("✅ Gradio importé avec succès")
    except ImportError as e:
        print(f"❌ Erreur import Gradio: {e}")
        return False
    
    try:
        import torch
        import torchaudio
        print("✅ PyTorch et TorchAudio importés avec succès")
    except ImportError as e:
        print(f"❌ Erreur import PyTorch: {e}")
        return False
    
    try:
        from transformers import Wav2Vec2Processor, Wav2Vec2ForCTC
        print("✅ Transformers importé avec succès")
    except ImportError as e:
        print(f"❌ Erreur import Transformers: {e}")
        return False
    
    try:
        from src.transcription import SpeechEncoder
        from src.sentiment import TextEncoder
        print("✅ Modules locaux importés avec succès")
    except ImportError as e:
        print(f"❌ Erreur import modules locaux: {e}")
        return False
    
    return True

def test_audio_generation():
    """Génère un fichier audio de test"""
    print("🎵 Génération d'un fichier audio de test...")
    
    # Créer un signal audio simple (1 seconde de silence avec un bip)
    sample_rate = 16000
    duration = 1.0
    t = np.linspace(0, duration, int(sample_rate * duration))
    
    # Signal simple (440 Hz)
    audio = 0.1 * np.sin(2 * np.pi * 440 * t)
    
    # Sauvegarder
    test_audio_path = "test_audio.wav"
    sf.write(test_audio_path, audio, sample_rate)
    print(f"✅ Fichier audio de test créé: {test_audio_path}")
    
    return test_audio_path

def test_model_loading():
    """Test du chargement des modèles"""
    print("🤖 Test du chargement des modèles...")
    
    try:
        from transformers import Wav2Vec2Processor, Wav2Vec2ForCTC
        
        # Test avec un modèle plus petit pour les tests
        processor = Wav2Vec2Processor.from_pretrained(
            "facebook/wav2vec2-base-960h",
            cache_dir="./test_models"
        )
        model = Wav2Vec2ForCTC.from_pretrained(
            "facebook/wav2vec2-base-960h",
            cache_dir="./test_models"
        )
        print("✅ Modèles chargés avec succès")
        return True
    except Exception as e:
        print(f"❌ Erreur chargement modèles: {e}")
        return False

def test_app_creation():
    """Test de la création de l'application Gradio"""
    print("🎨 Test de la création de l'application...")
    
    try:
        import gradio as gr
        
        # Créer une interface simple
        def dummy_function(audio):
            return "Test transcription", "Test sentiment"
        
        demo = gr.Interface(
            fn=dummy_function,
            inputs=gr.Audio(type="filepath"),
            outputs=[gr.Textbox(), gr.Textbox()],
            title="Test App"
        )
        print("✅ Application Gradio créée avec succès")
        return True
    except Exception as e:
        print(f"❌ Erreur création app: {e}")
        return False

def test_file_structure():
    """Vérifie la structure des fichiers"""
    print("📁 Vérification de la structure des fichiers...")
    
    required_files = [
        "app.py",
        "requirements_hf.txt", 
        "config.yaml",
        "README_HF.md",
        ".gitattributes",
        "src/__init__.py",
        "src/transcription.py",
        "src/sentiment.py",
        "src/multimodal.py",
        "src/inference.py"
    ]
    
    missing_files = []
    for file_path in required_files:
        if not Path(file_path).exists():
            missing_files.append(file_path)
        else:
            print(f"✅ {file_path}")
    
    if missing_files:
        print(f"❌ Fichiers manquants: {missing_files}")
        return False
    
    print("✅ Tous les fichiers requis sont présents")
    return True

def test_requirements():
    """Vérifie le fichier requirements"""
    print("📦 Vérification du fichier requirements...")
    
    try:
        with open("requirements_hf.txt", "r") as f:
            requirements = f.read()
        
        # Vérifier les dépendances essentielles
        essential_deps = ["gradio", "torch", "transformers", "soundfile"]
        missing_deps = []
        
        for dep in essential_deps:
            if dep not in requirements:
                missing_deps.append(dep)
        
        if missing_deps:
            print(f"❌ Dépendances manquantes: {missing_deps}")
            return False
        
        print("✅ Fichier requirements valide")
        return True
    except Exception as e:
        print(f"❌ Erreur lecture requirements: {e}")
        return False

def main():
    """Fonction principale de test"""
    print("🚀 Démarrage des tests de déploiement...\n")
    
    tests = [
        ("Structure des fichiers", test_file_structure),
        ("Fichier requirements", test_requirements),
        ("Imports", test_imports),
        ("Chargement modèles", test_model_loading),
        ("Création app", test_app_creation),
    ]
    
    results = []
    for test_name, test_func in tests:
        print(f"\n{'='*50}")
        print(f"Test: {test_name}")
        print('='*50)
        
        try:
            result = test_func()
            results.append((test_name, result))
        except Exception as e:
            print(f"❌ Erreur inattendue: {e}")
            results.append((test_name, False))
    
    # Résumé
    print(f"\n{'='*50}")
    print("📊 RÉSUMÉ DES TESTS")
    print('='*50)
    
    passed = 0
    total = len(results)
    
    for test_name, result in results:
        status = "✅ PASS" if result else "❌ FAIL"
        print(f"{test_name}: {status}")
        if result:
            passed += 1
    
    print(f"\nRésultat: {passed}/{total} tests réussis")
    
    if passed == total:
        print("🎉 Tous les tests sont passés ! Votre projet est prêt pour le déploiement.")
        return True
    else:
        print("⚠️  Certains tests ont échoué. Corrigez les problèmes avant le déploiement.")
        return False

if __name__ == "__main__":
    success = main()
    sys.exit(0 if success else 1)