# Adaptations spécifiques des scripts Python pour Windows

Ce document détaille les adaptations nécessaires pour chaque script Python du projet LLM Lab lors de la migration vers Windows.

## Modifications communes à tous les scripts

### 1. Gestion des chemins

Pour tous les scripts, remplacez les chemins absolus par des chemins relatifs:

```python
# Avant
DATA_DIR = '/home/fgras-ca/llm_lab/data'

# Après
import os
# Obtenir le chemin absolu du répertoire contenant le script
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DATA_DIR = os.path.join(BASE_DIR, 'data')
```

### 2. Installation des dépendances Windows

Ces dépendances sont nécessaires pour Windows:

```cmd
pip install wmi psutil requests pillow
pip install pywin32  # Pour l'accès aux API Windows
```

## Adaptations spécifiques par fichier

### 1. chat_gui.py

```python
# Avant de créer la fenêtre principale:
import os
import platform

# Pour éviter les problèmes d'échelle sur les écrans haute résolution
if platform.system() == 'Windows':
    import ctypes
    try:
        ctypes.windll.shcore.SetProcessDpiAwareness(1)
    except:
        pass
    
    # Configuration CUDA pour Ollama
    os.environ["CUDA_VISIBLE_DEVICES"] = "0"
    os.environ["OMP_NUM_THREADS"] = "8"
```

### 2. monitor.py

```python
def _update_system_info(self):
    """Met à jour les informations système"""
    # Informations système
    self.os_label.config(text=f"{platform.system()} {platform.release()}")
    self.cpu_label.config(text=f"{psutil.cpu_count(logical=False)} cœurs ({psutil.cpu_count()} threads)")
    
    # Détection avancée de la RAM
    try:
        if platform.system() == "Windows":
            # Utiliser WMI pour Windows
            import wmi
            computer = wmi.WMI()
            for os_info in computer.Win32_OperatingSystem():
                total_ram = float(os_info.TotalVisibleMemorySize) / (1024 * 1024)  # en GB
        else:
            # Utiliser psutil pour Linux/Mac
            ram = psutil.virtual_memory()
            total_ram = ram.total / (1024 * 1024 * 1024)  # GB
        
        self.ram_label.config(text=f"{total_ram:.1f} GB")
    except Exception as e:
        self._log(f"Erreur lors de la détection de la RAM: {str(e)}")
        self.ram_label.config(text="Détection impossible")
```

### 3. utils/system_monitor.py

```python
def _check_gpu_available(self):
    """Vérifie si un GPU NVIDIA est disponible"""
    try:
        if platform.system() == "Windows":
            import wmi
            computer = wmi.WMI()
            # Vérifier les contrôleurs vidéo
            for gpu in computer.Win32_VideoController():
                if "NVIDIA" in gpu.Name:
                    return True
            return False
        else:
            # Pour Linux/Mac, utiliser nvidia-smi
            result = subprocess.run(['nvidia-smi'], capture_output=True, text=True)
            return result.returncode == 0
    except:
        return False

def _update_gpu_info(self):
    """Met à jour les informations GPU"""
    if not self.gpu_available:
        return
        
    try:
        if platform.system() == "Windows":
            # Utiliser WMI pour Windows
            import wmi
            computer = wmi.WMI()
            
            # Obtenir le nom du modèle GPU
            for gpu in computer.Win32_VideoController():
                if "NVIDIA" in gpu.Name:
                    model_name = gpu.Name
                    self.gpu_model_label.config(text=model_name)
                    break
            
            # Utiliser nvidia-smi pour les métriques détaillées même sous Windows
            result = subprocess.run(
                ['nvidia-smi', '--query-gpu=memory.total,memory.used,utilization.gpu,temperature.gpu', 
                 '--format=csv,noheader,nounits'],
                capture_output=True, 
                text=True, 
                check=True
            )
            
            if result.returncode == 0:
                # Analyser les résultats
                gpu_data = result.stdout.strip().split(',')
                
                if len(gpu_data) >= 4:
                    # Mémoire totale et utilisée
                    total_memory = float(gpu_data[0].strip())
                    used_memory = float(gpu_data[1].strip())
                    memory_percent = (used_memory / total_memory) * 100 if total_memory > 0 else 0
                    
                    self.gpu_memory_label.config(text=f"{used_memory:.0f} MiB / {total_memory:.0f} MiB")
                    self.gpu_mem_progress["value"] = memory_percent
                    self.gpu_mem_percent.config(text=f"{memory_percent:.1f}%")
                    
                    # Utilisation GPU
                    gpu_util = float(gpu_data[2].strip())
                    self.gpu_compute_progress["value"] = gpu_util
                    self.gpu_compute_percent.config(text=f"{gpu_util:.1f}%")
                    
                    # Température
                    temp = float(gpu_data[3].strip())
                    self.gpu_temp_progress["value"] = temp
                    self.gpu_temp_label.config(text=f"{temp:.1f}°C")
        else:
            # Code existant pour Linux/Mac
            # ...
    except Exception as e:
        self._log(f"Erreur de mise à jour GPU: {str(e)}")
```

### 4. utils/ollama_api.py

```python
import os
import platform
import requests
import json

# Optimisations pour Windows
if platform.system() == "Windows":
    os.environ["CUDA_VISIBLE_DEVICES"] = "0"
    os.environ["OMP_NUM_THREADS"] = str(os.cpu_count())

class OllamaAPI:
    def __init__(self, base_url="http://localhost:11434"):
        self.base_url = base_url
        
        # Charger la configuration optimisée si elle existe
        config_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 
                                  "ollama_config.json")
        self.default_params = {}
        
        if os.path.exists(config_path):
            try:
                with open(config_path, 'r') as f:
                    self.default_params = json.load(f)
            except:
                pass

    def generate(self, model, prompt, params=None):
        """Génère une réponse du modèle"""
        url = f"{self.base_url}/api/generate"
        
        # Fusionner les paramètres par défaut avec ceux fournis
        request_params = self.default_params.copy()
        if params:
            request_params.update(params)
            
        data = {
            "model": model,
            "prompt": prompt,
            **request_params
        }
        
        response = requests.post(url, json=data)
        response.raise_for_status()
        
        return response.json()
```

### 5. installer.bat - Script d'installation Windows

```batch
@echo off
setlocal

echo Installation de LLM Lab pour Windows...

REM Vérifier si Python est installé
python --version > nul 2>&1
if %ERRORLEVEL% NEQ 0 (
    echo Python n'est pas installé. Veuillez installer Python 3.10 ou supérieur.
    echo Téléchargez Python depuis https://www.python.org/downloads/
    exit /b 1
)

REM Créer l'environnement virtuel
if not exist venv (
    echo Création de l'environnement virtuel...
    python -m venv venv
)

REM Activer l'environnement virtuel
call venv\Scripts\activate

REM Installer les dépendances
echo Installation des dépendances...
pip install -r requirements.txt
pip install wmi psutil requests pillow pywin32

REM Vérifier si CUDA est disponible
where nvidia-smi > nul 2>&1
if %ERRORLEVEL% EQU 0 (
    echo Détection de CUDA: NVIDIA GPU disponible
    nvidia-smi
) else (
    echo Aucun GPU NVIDIA détecté
)

REM Vérifier si Ollama est installé
curl -s http://localhost:11434/api/tags > nul 2>&1
if %ERRORLEVEL% EQU 0 (
    echo Ollama est en cours d'exécution
) else (
    echo Ollama n'est pas en cours d'exécution ou n'est pas installé
    echo Téléchargez Ollama depuis https://ollama.com/download/windows
)

REM Créer les dossiers nécessaires
if not exist data mkdir data
if not exist logs mkdir logs
if not exist presets mkdir presets
if not exist history mkdir history

echo.
echo Installation terminée ! Pour lancer LLM Lab:
echo   - Activez l'environnement: venv\Scripts\activate
echo   - Lancez l'interface GUI: run.bat gui
echo   - Lancez le moniteur: run.bat monitor
echo.

endlocal
```

## Configuration des modèles Ollama

Pour optimiser les performances des modèles, créez des fichiers Modelfile pour chaque modèle:

### Modelfile pour modèles Llama 3 (exemple)

```
FROM llama3:latest

# Optimisations pour Windows
PARAMETER temperature 0.7
PARAMETER num_ctx 8192
PARAMETER num_gpu 100
PARAMETER num_thread 8
PARAMETER num_batch 512
```

Pour appliquer:
```cmd
ollama create llama3-optimized -f Modelfile
```

## Monitoring des performances

Pour un monitoring plus précis sous Windows, ajoutez ces fonctions à `system_monitor.py`:

```python
def _get_windows_process_info(self, process_name):
    """Récupère les informations d'un processus Windows"""
    if platform.system() != "Windows":
        return None
        
    import wmi
    computer = wmi.WMI()
    
    processes = []
    for process in computer.Win32_Process():
        if process_name.lower() in process.Name.lower():
            processes.append({
                'pid': process.ProcessId,
                'name': process.Name,
                'cpu': 0,  # À calculer
                'memory': float(process.WorkingSetSize) / (1024 * 1024)  # MB
            })
    
    return processes

def _get_ollama_performance(self):
    """Récupère les performances d'Ollama"""
    processes = []
    
    if platform.system() == "Windows":
        processes = self._get_windows_process_info("ollama")
    else:
        # Code Linux existant
        pass
        
    return processes
```

## Test de la migration

Créez un script `test_windows.py` pour vérifier que tout fonctionne correctement:

```python
import os
import platform
import psutil
import tkinter as tk
import requests

def check_system():
    print(f"Système: {platform.system()} {platform.release()}")
    print(f"Python: {platform.python_version()}")
    
    # Vérifier RAM
    ram = psutil.virtual_memory()
    print(f"RAM: {ram.total / (1024**3):.1f} GB")
    
    # Vérifier GPU
    try:
        import wmi
        computer = wmi.WMI()
        for gpu in computer.Win32_VideoController():
            print(f"GPU: {gpu.Name}")
    except:
        print("Erreur lors de la détection du GPU via WMI")
    
    # Vérifier Ollama
    try:
        response = requests.get("http://localhost:11434/api/tags")
        if response.status_code == 200:
            print("Ollama: En ligne")
            models = response.json().get("models", [])
            print(f"Modèles installés: {len(models)}")
            for model in models:
                print(f"  - {model.get('name')}")
        else:
            print(f"Ollama: Erreur {response.status_code}")
    except:
        print("Ollama: Hors ligne")
    
    # Vérifier Tkinter
    try:
        root = tk.Tk()
        root.title("Test Tkinter")
        tk.Label(root, text="Tkinter fonctionne correctement").pack(padx=20, pady=20)
        print("Tkinter: OK")
        return root
    except:
        print("Tkinter: Erreur")
        return None

if __name__ == "__main__":
    print("=== Test d'installation LLM Lab sur Windows ===")
    root = check_system()
    if root:
        print("\nTout est correctement configuré!")
        print("Fermer la fenêtre Tkinter pour terminer le test.")
        root.mainloop()
    else:
        print("\nDes erreurs ont été détectées dans l'installation.")
```

## Recommandations spécifiques pour Windows

1. **Performances optimales**:
   - Réglez le plan d'alimentation sur "Hautes performances"
   - Désactivez l'économiseur d'écran et la mise en veille pendant l'utilisation

2. **GPU NVIDIA**:
   - Utilisez le Panneau de configuration NVIDIA pour régler les performances sur "Préférer les performances maximales"
   - Mettez à jour les pilotes régulièrement

3. **Antivirus**:
   - Ajoutez le dossier LLM_Lab aux exceptions de l'antivirus
   - Excluez `ollama.exe` du scan en temps réel