# Import guards - availability flags for external dependencies
try:
import requests
REQUESTS_AVAILABLE = True
except ImportError:
REQUESTS_AVAILABLE = False
print(f' requests non disponible - certaines fonctionnalites seront limitees')
# Paramètres Papermill - JAMAIS modifier ce commentaire
# Configuration validation
notebook_mode = "interactive" # "interactive" ou "batch"
skip_widgets = False # True pour mode batch MCP
debug_level = "INFO"
# Tests à effectuer
test_apis = True # Test connexions API
test_docker = True # Test services Docker
test_notebooks = True # Test exécution notebooks
test_mcp = True # Test compatibilité MCP
# Configuration rapport
generate_report = True # Générer rapport final
save_results = True # Sauvegarder résultats
export_config = True # Exporter configuration validéeEnvironment Validation - GenAI
Navigation : Index | << Précédent | Suivant >>
Module : 00-GenAI-Environment
Niveau : 🟢 Débutant
Technologies : Validation complète, Tests d’intégration
Durée estimée : 20 minutes
🎯 Objectifs d’Apprentissage
📚 Prérequis
- Environment Setup (notebook 00-1) complété
- Docker Services (notebook 00-2) complété
- API Configuration (notebook 00-3) complété
Initialisation de l’environnement de validation
Cette cellule prepare l’environnement Python pour les tests de validation.
Opérations effectuees : 1. Import des librairies standard (os, sys, json, requests, pathlib, logging) 2. Recherche et import des helpers GenAI personnalisés 3. Configuration du système de logging 4. Affichage du resume de la configuration
Helpers GenAI : - setup_genai_logging : Configuration avancee du logging - load_genai_config : Chargement de la configuration depuis .env - validate_apis : Validation des connexions API
Variables définies : - GENAI_ROOT : Chemin racine du module GenAI (detecte automatiquement) - logger : Logger pour les messages de validation
Note technique : Le helper GenAI est optionnel. S’il n’est pas disponible, le notebook fonctionne quand même avec les fonctionnalites standard de Python.
# Setup environnement et imports
import os
import sys
import json
import requests
from pathlib import Path
from datetime import datetime
from typing import Dict, List, Any
import logging
# Import helpers GenAI
GENAI_ROOT = Path.cwd()
while GENAI_ROOT.name != 'GenAI' and len(GENAI_ROOT.parts) > 1:
GENAI_ROOT = GENAI_ROOT.parent
HELPERS_PATH = GENAI_ROOT / 'shared' / 'helpers'
if HELPERS_PATH.exists():
sys.path.insert(0, str(HELPERS_PATH.parent))
try:
from helpers.genai_helpers import setup_genai_logging, load_genai_config, validate_apis
print("✅ Helpers GenAI importés")
except ImportError:
print("⚠️ Helpers GenAI non disponibles")
# Configuration logging
logging.basicConfig(level=getattr(logging, debug_level))
logger = logging.getLogger('env_validation')
print(f"✅ Environment Validation GenAI")
print(f"📅 {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print(f"🔍 Tests: API={test_apis}, Docker={test_docker}, Notebooks={test_notebooks}, MCP={test_mcp}")✅ Helpers GenAI importés
✅ Environment Validation GenAI
📅 2026-05-10 00:50:00
🔍 Tests: API=True, Docker=True, Notebooks=True, MCP=TruePreparation de la validation
Cette section va executer une serie de tests pour valider tous les composants de l’environnement GenAI.
Tests qui vont etre effectues :
- APIs : Verification de la connexion aux services OpenRouter et OpenAI
- Docker : Verification de l’installation Docker et des services actifs
- MCP : Verification des variables d’environnement et de la structure de fichiers
- Notebooks : Comptage des notebooks par module pour verifier l’installation complete
Variables de configuration : - test_apis : Activer/desactiver les tests API - test_docker : Activer/desactiver les tests Docker - test_notebooks : Activer/desactiver le comptage des notebooks - test_mcp : Activer/desactiver les tests de compatibilite MCP
Note technique : Si Docker n’est pas installe sur votre machine, vous pouvez desactiver
test_dockerpour eviter les erreurs. L’environnement cloud (OpenRouter/OpenAI) peut fonctionner independamment de Docker.
# Validation complète de l'environnement
print("\n" + "="*60)
print("🔍 VALIDATION COMPLÈTE ENVIRONNEMENT GENAI")
print("="*60)
validation_results = {
'timestamp': datetime.now().isoformat(),
'tests': {},
'overall_status': 'unknown',
'recommendations': []
}
# 1. Test APIs
if test_apis:
print("\n🌐 TEST CONNEXIONS API")
api_results = {'status': 'passed', 'details': {}}
# OpenRouter
try:
openrouter_key = os.getenv('OPENROUTER_API_KEY')
if openrouter_key:
headers = {'Authorization': f'Bearer {openrouter_key}'}
response = requests.get('https://openrouter.ai/api/v1/models',
headers=headers, timeout=10)
if response.status_code == 200:
models_count = len(response.json().get('data', []))
print(f" ✅ OpenRouter: {models_count} modèles disponibles")
api_results['details']['openrouter'] = {'status': 'ok', 'models': models_count}
else:
print(f" ❌ OpenRouter: HTTP {response.status_code}")
api_results['details']['openrouter'] = {'status': 'error', 'code': response.status_code}
api_results['status'] = 'failed'
else:
print(" ⚠️ OpenRouter: Clé API manquante")
api_results['details']['openrouter'] = {'status': 'missing_key'}
except Exception as e:
print(f" ❌ OpenRouter: {str(e)[:50]}...")
api_results['details']['openrouter'] = {'status': 'error', 'message': str(e)}
api_results['status'] = 'failed'
# OpenAI (optionnel)
openai_key = os.getenv('OPENAI_API_KEY')
if openai_key:
try:
headers = {'Authorization': f'Bearer {openai_key}'}
response = requests.get('https://api.openai.com/v1/models',
headers=headers, timeout=10)
if response.status_code == 200:
print(" ✅ OpenAI: Accessible")
api_results['details']['openai'] = {'status': 'ok'}
else:
print(f" ⚠️ OpenAI: HTTP {response.status_code}")
api_results['details']['openai'] = {'status': 'warning'}
except Exception as e:
print(f" ⚠️ OpenAI: {str(e)[:50]}...")
api_results['details']['openai'] = {'status': 'warning'}
else:
print(" ℹ️ OpenAI: Non configuré (optionnel)")
api_results['details']['openai'] = {'status': 'not_configured'}
validation_results['tests']['apis'] = api_results
# 2. Test Docker
if test_docker:
print("\n🐳 TEST SERVICES DOCKER")
docker_results = {'status': 'passed', 'details': {}}
try:
import subprocess
result = subprocess.run(['docker', '--version'],
capture_output=True, text=True, timeout=5)
if result.returncode == 0:
print(f" ✅ Docker: {result.stdout.strip()}")
docker_results['details']['docker_cli'] = {'status': 'ok'}
# Test services communs
import socket
services_ports = {'ComfyUI': 8188, 'Ollama': 11434, 'Jupyter': 8888}
for service, port in services_ports.items():
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(1)
result = sock.connect_ex(('localhost', port))
sock.close()
if result == 0:
print(f" ✅ {service} (:{port}): Accessible")
docker_results['details'][service.lower()] = {'status': 'running', 'port': port}
else:
print(f" ⚠️ {service} (:{port}): Non accessible")
docker_results['details'][service.lower()] = {'status': 'stopped', 'port': port}
except Exception:
print(f" ❓ {service} (:{port}): Test échoué")
docker_results['details'][service.lower()] = {'status': 'unknown', 'port': port}
else:
print(" ❌ Docker: CLI non accessible")
docker_results['status'] = 'failed'
docker_results['details']['docker_cli'] = {'status': 'error'}
except Exception as e:
print(f" ❌ Docker: {str(e)[:50]}...")
docker_results['status'] = 'failed'
docker_results['details']['error'] = str(e)
validation_results['tests']['docker'] = docker_results
print(f"\n📊 Tests complétés à {datetime.now().strftime('%H:%M:%S')}")
============================================================
🔍 VALIDATION COMPLÈTE ENVIRONNEMENT GENAI
============================================================
🌐 TEST CONNEXIONS API
⚠️ OpenRouter: Clé API manquante
ℹ️ OpenAI: Non configuré (optionnel)
🐳 TEST SERVICES DOCKER
✅ Docker: Docker version 29.4.1, build 055a478
✅ ComfyUI (:8188): Accessible
⚠️ Ollama (:11434): Non accessible
⚠️ Jupyter (:8888): Non accessible
📊 Tests complétés à 00:50:02Analyse des tests de validation
La validation complete a verifie les composantes critiques de l’environnement GenAI.
Résultats des tests API : - OpenRouter : api_results['details']['openrouter']['status'] (ok/error/missing_key) - OpenAI : api_results['details']['openai']['status'] (ok/warning/not_configured)
Résultats des tests Docker : - Docker CLI : docker_results['details']['docker_cli']['status'] (ok/error) - Services : ComfyUI (8188), Ollama (11434), Jupyter (8888)
Variables exportees : - validation_results['tests'] : Résultats detailles de tous les tests - validation_results['overall_status'] : Statut global (success/partial/failed)
Note technique : Si Docker n’est pas installe ou demarre, seuls les tests API et MCP seront effectues. Le statut global peut etre ‘partial’ même si l’environnement cloud fonctionne correctement.
# Test compatibilité MCP et notebooks
if test_mcp or test_notebooks:
print("\n🔧 TEST COMPATIBILITÉ MCP ET NOTEBOOKS")
# Test MCP
if test_mcp:
mcp_results = {'status': 'passed', 'details': {}}
# Test variables d'environnement MCP
mcp_vars = ['GENAI_ROOT', 'GENAI_OUTPUT_DIR']
for var in mcp_vars:
value = os.getenv(var)
if value:
print(f" ✅ {var}: {value}")
mcp_results['details'][var.lower()] = {'status': 'ok', 'value': value}
else:
print(f" ⚠️ {var}: Non défini")
mcp_results['details'][var.lower()] = {'status': 'missing'}
# Test structure de fichiers
expected_paths = [
GENAI_ROOT / 'shared' / 'helpers',
GENAI_ROOT / '.env.template',
GENAI_ROOT / 'requirements.txt'
]
for path in expected_paths:
if path.exists():
print(f" ✅ Structure: {path.name}")
mcp_results['details'][f"path_{path.name}"] = {'status': 'ok'}
else:
print(f" ❌ Structure: {path.name} manquant")
mcp_results['details'][f"path_{path.name}"] = {'status': 'missing'}
mcp_results['status'] = 'failed'
validation_results['tests']['mcp'] = mcp_results
# Test notebooks
if test_notebooks:
notebook_results = {'status': 'passed', 'details': {}}
# Compter notebooks par module
modules = ['00-GenAI-Environment', '01-Images-Foundation',
'02-Images-Advanced', '03-Images-Orchestration', '04-Images-Applications']
total_notebooks = 0
for module in modules:
module_path = GENAI_ROOT / module
if module_path.exists():
notebooks = list(module_path.glob('*.ipynb'))
count = len(notebooks)
total_notebooks += count
print(f" ✅ {module}: {count} notebooks")
notebook_results['details'][module] = {'status': 'ok', 'count': count}
else:
print(f" ❌ {module}: Module manquant")
notebook_results['details'][module] = {'status': 'missing', 'count': 0}
notebook_results['status'] = 'failed'
print(f" 📊 Total: {total_notebooks} notebooks trouvés")
notebook_results['total_count'] = total_notebooks
validation_results['tests']['notebooks'] = notebook_results
🔧 TEST COMPATIBILITÉ MCP ET NOTEBOOKS
⚠️ GENAI_ROOT: Non défini
⚠️ GENAI_OUTPUT_DIR: Non défini
✅ Structure: helpers
❌ Structure: .env.template manquant
✅ Structure: requirements.txt
✅ 00-GenAI-Environment: 6 notebooks
❌ 01-Images-Foundation: Module manquant
❌ 02-Images-Advanced: Module manquant
❌ 03-Images-Orchestration: Module manquant
❌ 04-Images-Applications: Module manquant
📊 Total: 6 notebooks trouvésInterpretation des tests MCP et notebooks
Les tests de compatibilite MCP et le comptage des notebooks permettent de verifier la structure du projet GenAI.
Résultats des tests MCP : - Variables d’environnement : GENAI_ROOT, GENAI_OUTPUT_DIR - Structure de fichiers : helpers, .env.template, requirements.txt - Si .env.template est manquant, créer le fichier a partir de .env.example
Résultats des tests notebooks : - Modules attendus : 5 (Environment, Foundation, Advanced, Orchestration, Applications) - Total attendu : 16 notebooks minimum - Si certains modules sont manquants, cela indique une installation incomplete
Variables exportees : - mcp_results['status'] : passed/failed (compatibilite MCP) - notebook_results['total_count'] : nombre total de notebooks trouves
Note technique : Les variables d’environnement MCP (GENAI_ROOT, GENAI_OUTPUT_DIR) sont utilisees par les scripts d’automatisation. Elles peuvent etre définies dans le fichier .env ou dans le profile du système.
# Génération du rapport final
print("\n" + "="*60)
print("📋 RAPPORT FINAL - VALIDATION ENVIRONNEMENT")
print("="*60)
# Calculer le statut global
total_tests = len(validation_results['tests'])
passed_tests = sum(1 for test in validation_results['tests'].values()
if test['status'] == 'passed')
failed_tests = total_tests - passed_tests
if failed_tests == 0:
validation_results['overall_status'] = 'success'
status_icon = "✅"
status_color = "Green"
elif failed_tests <= total_tests // 2:
validation_results['overall_status'] = 'partial'
status_icon = "⚠️"
status_color = "Yellow"
else:
validation_results['overall_status'] = 'failed'
status_icon = "❌"
status_color = "Red"
print(f"\n{status_icon} STATUT GLOBAL: {validation_results['overall_status'].upper()}")
print(f"📊 Tests réussis: {passed_tests}/{total_tests}")
print(f"⚠️ Tests échoués: {failed_tests}/{total_tests}")
# Recommandations
recommendations = []
if validation_results['tests'].get('apis', {}).get('status') == 'failed':
recommendations.append("Vérifier les clés API dans le fichier .env")
if validation_results['tests'].get('docker', {}).get('status') == 'failed':
recommendations.append("Installer et démarrer Docker Desktop")
recommendations.append("Lancer les services: docker compose -f docker-compose.genai.yml up -d")
if validation_results['tests'].get('notebooks', {}).get('total_count', 0) < 16:
expected = 16
actual = validation_results['tests'].get('notebooks', {}).get('total_count', 0)
recommendations.append(f"Compléter les templates notebooks ({actual}/{expected})")
if recommendations:
print("\n💡 RECOMMANDATIONS:")
for i, rec in enumerate(recommendations, 1):
print(f"{i}. {rec}")
validation_results['recommendations'] = recommendations
# Prochaines étapes
print("\n🚀 PROCHAINES ÉTAPES:")
if validation_results['overall_status'] == 'success':
next_steps = [
"Environnement validé - Prêt pour la génération d'images",
"Commencer avec le notebook 01-1-OpenAI-DALL-E-3",
"Explorer les notebooks avancés selon vos besoins"
]
else:
next_steps = [
"Corriger les problèmes identifiés",
"Relancer la validation après corrections",
"Consulter la documentation de dépannage si nécessaire"
]
for i, step in enumerate(next_steps, 1):
print(f"{i}. {step}")
print(f"\n⏰ Validation terminée: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
============================================================
📋 RAPPORT FINAL - VALIDATION ENVIRONNEMENT
============================================================
⚠️ STATUT GLOBAL: PARTIAL
📊 Tests réussis: 2/4
⚠️ Tests échoués: 2/4
💡 RECOMMANDATIONS:
1. Compléter les templates notebooks (6/16)
🚀 PROCHAINES ÉTAPES:
1. Corriger les problèmes identifiés
2. Relancer la validation après corrections
3. Consulter la documentation de dépannage si nécessaire
⏰ Validation terminée: 2026-05-10 00:50:02Interpretation du rapport de validation
Le rapport final synthetise l’etat de validation de l’environnement GenAI.
Statuts possibles : - success : Tous les tests ont passe (vert) - partial : Certains tests ont echoue (jaune) - failed : La plupart des tests ont echoue (rouge)
Tests effectues : 1. APIs : Connexions OpenRouter et OpenAI 2. Docker : Disponibilite Docker et services actifs 3. MCP : Variables d’environnement et structure de fichiers 4. Notebooks : Comptage des notebooks par module
Prochaines étapes selon le statut : - Success : Passer aux notebooks de generation d’images - Partial/Failed : Suivre les recommandations affichees ci-dessus
Note technique : Le rapport est sauvegarde dans
outputs/environment_validation_<timestamp>.json. Vous pouvez le recharger pour analyse ulterieure avecjson.load().
# Sauvegarde des résultats
if save_results:
try:
output_dir = Path(os.getenv('GENAI_OUTPUT_DIR', GENAI_ROOT / 'outputs'))
output_dir.mkdir(parents=True, exist_ok=True)
# Rapport JSON
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
report_file = output_dir / f'environment_validation_{timestamp}.json'
with open(report_file, 'w', encoding='utf-8') as f:
json.dump(validation_results, f, indent=2, ensure_ascii=False, default=str)
print(f"💾 Rapport sauvegardé: {report_file}")
# Export configuration validée
if export_config and validation_results['overall_status'] == 'success':
config_export = {
'genai_environment': {
'version': '2.1.0',
'validated_at': validation_results['timestamp'],
'status': 'ready',
'apis': {
'openrouter': validation_results['tests'].get('apis', {}).get('details', {}).get('openrouter', {}),
'openai': validation_results['tests'].get('apis', {}).get('details', {}).get('openai', {})
},
'docker_services': validation_results['tests'].get('docker', {}).get('details', {}),
'notebooks_count': validation_results['tests'].get('notebooks', {}).get('total_count', 0)
}
}
config_file = output_dir / f'genai_config_validated_{timestamp}.json'
with open(config_file, 'w', encoding='utf-8') as f:
json.dump(config_export, f, indent=2, ensure_ascii=False, default=str)
print(f"⚙️ Configuration exportée: {config_file}")
except Exception as e:
print(f"❌ Erreur sauvegarde: {str(e)[:100]}...")
# Export final pour autres notebooks
ENVIRONMENT_VALIDATION_RESULT = validation_results
print(f"\n📊 Variables exportées: ENVIRONMENT_VALIDATION_RESULT")
print(f"🏁 Environment Validation complété - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print(f"➡️ Module Environment terminé - Passer aux notebooks Images Foundation")💾 Rapport sauvegardé: D:\Dev\CoursIA\MyIA.AI.Notebooks\GenAI\outputs\environment_validation_20260510_005002.json
📊 Variables exportées: ENVIRONMENT_VALIDATION_RESULT
🏁 Environment Validation complété - 2026-05-10 00:50:02
➡️ Module Environment terminé - Passer aux notebooks Images FoundationConclusion du module Environment
Ce notebook a realise une validation complete de l’environnement GenAI, verifiant tous les composants necessaires a la generation d’images.
Bilan de la validation :
| Composant | Statut | Action requise |
|---|---|---|
| APIs (OpenRouter/OpenAI) | validation_results['tests']['apis']['status'] |
Configurer .env si erreur |
| Docker & Services | validation_results['tests']['docker']['status'] |
Demarrer Docker Desktop si erreur |
| Structure MCP | validation_results['tests']['mcp']['status'] |
Verifier paths si erreur |
| Notebooks | validation_results['tests']['notebooks']['total_count'] |
Completer templates si < 16 |
Prochaine étape : Si le statut global est “success”, vous pouvez passer au module 01-Images-Foundation pour commencer la generation d’images avec DALL-E 3.
Note technique : Conservez le fichier
environment_validation_<timestamp>.jsoncomme reference. Il peut etre utilise pour diagnostiquer des problemes futurs ou pour verifier la configuration sur une autre machine.