# Adaptation du moniteur système pour le nouvel emplacement Ollama

Ce guide explique comment modifier le moniteur système de LLM Lab pour qu'il détecte et affiche correctement l'emplacement des modèles Ollama sur un disque séparé.

## 1. Modifications nécessaires dans system_monitor.py

Ouvrez le fichier `system_monitor.py` et apportez les modifications suivantes pour détecter l'emplacement des modèles Ollama sur un disque séparé.

### Fonction de détection du chemin des modèles

Ajoutez cette nouvelle fonction au début de la classe `SystemMonitor`:

```python
def _get_ollama_models_path(self):
    """Détecte l'emplacement des modèles Ollama"""
    models_path = None
    
    # Vérifier si la variable d'environnement est définie
    if 'OLLAMA_MODELS' in os.environ:
        models_path = os.environ['OLLAMA_MODELS']
        self._log(f"Chemin des modèles Ollama trouvé via variable d'environnement: {models_path}")
        return models_path
    
    # Vérifier le chemin par défaut
    default_path = os.path.expanduser(os.path.join("~", ".ollama", "models"))
    
    if platform.system() == "Windows":
        # Vérifier si c'est un lien symbolique sous Windows
        try:
            import subprocess
            result = subprocess.run(['dir', '/al', default_path], 
                                  shell=True, capture_output=True, text=True)
            
            if "<SYMLINK>" in result.stdout:
                # Extraire la cible du lien symbolique
                for line in result.stdout.splitlines():
                    if "<SYMLINK>" in line and "[" in line and "]" in line:
                        target = line.split("[")[1].split("]")[0]
                        models_path = target
                        self._log(f"Lien symbolique détecté pour les modèles Ollama: {models_path}")
                        return models_path
        except:
            pass
    
    # Si aucune redirection n'est trouvée, utiliser le chemin par défaut
    if os.path.exists(default_path):
        models_path = default_path
    
    return models_path or default_path
```

### Afficher l'emplacement des modèles dans l'interface

Modifiez la méthode `_create_widgets` pour ajouter un affichage de l'emplacement des modèles dans l'onglet Ollama:

```python
# Dans _create_widgets, après la création de url_frame
models_path_frame = ttk.Frame(server_frame)
models_path_frame.pack(fill=tk.X, padx=5, pady=2)
ttk.Label(models_path_frame, text="Modèles:").pack(side=tk.LEFT, padx=5)
self.models_path_label = ttk.Label(models_path_frame, text="Vérification...")
self.models_path_label.pack(side=tk.LEFT, padx=5)
```

### Mettre à jour l'information dans _update_ollama_info

Ajoutez ce code au début de la méthode `_update_ollama_info`:

```python
# Mettre à jour l'emplacement des modèles
models_path = self._get_ollama_models_path()
self.models_path_label.config(text=models_path)

# Vérifier l'espace disque pour les modèles
if models_path and os.path.exists(models_path):
    try:
        import shutil
        total, used, free = shutil.disk_usage(os.path.dirname(models_path))
        total_gb = total / (1024**3)
        used_gb = used / (1024**3)
        free_gb = free / (1024**3)
        
        disk_info = f"{models_path} ({free_gb:.1f} GB libres / {total_gb:.1f} GB)"
        self.models_path_label.config(text=disk_info)
        
        # Afficher un avertissement si l'espace libre est faible
        if free_gb < 10:  # Moins de 10 GB libres
            self.models_path_label.config(foreground="orange")
            self._log(f"Avertissement: espace disque limité pour les modèles: {free_gb:.1f} GB")
        elif free_gb < 5:  # Moins de 5 GB libres
            self.models_path_label.config(foreground="red")
            self._log(f"Alerte: espace disque très limité pour les modèles: {free_gb:.1f} GB")
        else:
            self.models_path_label.config(foreground="green")
    except Exception as e:
        self._log(f"Erreur lors de la vérification de l'espace disque: {str(e)}")
```

## 2. Ajout d'un onglet d'information sur les disques

Pour un monitoring plus complet, ajoutez un nouvel onglet dédié à l'affichage de l'état des disques:

```python
# Dans _create_widgets, après la création de logs_frame
# Onglet 5: Disques
self.disks_frame = ttk.Frame(self.notebook)
self.notebook.add(self.disks_frame, text="Disques")

# Configuration de l'onglet Disques
disks_label = ttk.Label(self.disks_frame, text="Stockage", font=("Arial", 14, "bold"))
disks_label.pack(pady=10)

# Tableau des disques
disks_table_frame = ttk.LabelFrame(self.disks_frame, text="Volumes")
disks_table_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)

self.disks_tree = ttk.Treeview(disks_table_frame, 
                               columns=("Lettre", "Total", "Utilisé", "Libre", "Type"),
                               show='headings')
self.disks_tree.heading("Lettre", text="Disque")
self.disks_tree.heading("Total", text="Taille")
self.disks_tree.heading("Utilisé", text="Utilisé")
self.disks_tree.heading("Libre", text="Libre")
self.disks_tree.heading("Type", text="Type")
self.disks_tree.column("Lettre", width=70)
self.disks_tree.column("Total", width=100)
self.disks_tree.column("Utilisé", width=100)
self.disks_tree.column("Libre", width=100)
self.disks_tree.column("Type", width=150)
self.disks_tree.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
```

### Ajouter une méthode pour mettre à jour les informations de disque

```python
def _update_disks_info(self):
    """Met à jour les informations sur les disques"""
    try:
        # Effacer le tableau
        for item in self.disks_tree.get_children():
            self.disks_tree.delete(item)
        
        if platform.system() == "Windows":
            # Obtenir la liste des lecteurs
            import string
            import ctypes
            
            drives = []
            bitmask = ctypes.windll.kernel32.GetLogicalDrives()
            for letter in string.ascii_uppercase:
                if bitmask & 1:
                    drives.append(f"{letter}:")
                bitmask >>= 1
            
            # Pour chaque lecteur, obtenir les informations
            for drive in drives:
                try:
                    total, used, free = shutil.disk_usage(drive)
                    total_gb = total / (1024**3)
                    used_gb = used / (1024**3)
                    free_gb = free / (1024**3)
                    
                    # Déterminer le type de disque
                    drive_type = ctypes.windll.kernel32.GetDriveTypeW(drive)
                    types = {
                        0: "Inconnu",
                        1: "Inexistant",
                        2: "Amovible",
                        3: "Fixe",
                        4: "Réseau",
                        5: "CD-ROM",
                        6: "RAM Disk"
                    }
                    drive_type_str = types.get(drive_type, "Inconnu")
                    
                    # Ajouter au tableau
                    percent = (used / total) * 100 if total > 0 else 0
                    
                    # Couleur selon l'espace libre
                    if percent > 90:
                        tag = "critical"
                    elif percent > 75:
                        tag = "warning"
                    else:
                        tag = ""
                    
                    self.disks_tree.insert("", tk.END, 
                                          values=(drive, 
                                                  f"{total_gb:.1f} GB",
                                                  f"{used_gb:.1f} GB ({percent:.1f}%)",
                                                  f"{free_gb:.1f} GB",
                                                  drive_type_str),
                                          tags=(tag,))
                    
                    # Vérifier si c'est le disque des modèles Ollama
                    models_path = self._get_ollama_models_path()
                    if models_path and drive in models_path:
                        self._log(f"Disque des modèles Ollama: {drive} - {free_gb:.1f} GB libres")
                        
                except Exception as e:
                    self.disks_tree.insert("", tk.END, 
                                          values=(drive, "Erreur", "Erreur", "Erreur", str(e)),
                                          tags=("error",))
            
            # Configurer les couleurs
            self.disks_tree.tag_configure("critical", background="#ffcccc")
            self.disks_tree.tag_configure("warning", background="#ffffcc")
            self.disks_tree.tag_configure("error", background="#ff9999")
            
        else:
            # Code pour Linux/Mac
            # Utiliser psutil.disk_partitions() pour lister les partitions
            for part in psutil.disk_partitions(all=False):
                try:
                    usage = psutil.disk_usage(part.mountpoint)
                    total_gb = usage.total / (1024**3)
                    used_gb = usage.used / (1024**3)
                    free_gb = usage.free / (1024**3)
                    
                    # Ajouter au tableau
                    self.disks_tree.insert("", tk.END, 
                                          values=(part.mountpoint, 
                                                  f"{total_gb:.1f} GB",
                                                  f"{used_gb:.1f} GB ({usage.percent}%)",
                                                  f"{free_gb:.1f} GB",
                                                  f"{part.fstype}"))
                    
                except Exception as e:
                    pass
    except Exception as e:
        self._log(f"Erreur lors de la mise à jour des informations disque: {str(e)}")
```

### Ajouter l'appel à la nouvelle méthode dans _update_loop

Ajoutez cet appel dans la méthode `_update_loop` pour mettre à jour les informations disque régulièrement:

```python
# Dans _update_loop
self._update_system_info()
self._update_ollama_info()
self._update_gpu_info()
self._update_disks_info()  # Ajouter cette ligne
```

## 3. Test de la mise à jour

Pour tester ces modifications:

1. Appliquez les changements au fichier system_monitor.py
2. Redémarrez le moniteur système
3. Vérifiez que le chemin des modèles Ollama est correctement affiché
4. Assurez-vous que l'espace disque est correctement détecté
5. Testez avec différentes configurations (variable d'environnement, lien symbolique)

## 4. Intégration avec le reste de LLM Lab

Modifiez les autres fichiers qui pourraient avoir besoin de connaître l'emplacement des modèles:

### Ajouter une fonction utilitaire dans utils/ollama_utils.py

```python
def get_ollama_models_path():
    """Détecte l'emplacement des modèles Ollama de manière cohérente dans tout le projet"""
    # Vérifier la variable d'environnement
    if 'OLLAMA_MODELS' in os.environ:
        return os.environ['OLLAMA_MODELS']
    
    # Vérifier si c'est un lien symbolique sous Windows
    default_path = os.path.expanduser(os.path.join("~", ".ollama", "models"))
    
    if platform.system() == "Windows":
        try:
            import subprocess
            result = subprocess.run(['dir', '/al', default_path], 
                                  shell=True, capture_output=True, text=True)
            
            if "<SYMLINK>" in result.stdout:
                for line in result.stdout.splitlines():
                    if "<SYMLINK>" in line and "[" in line and "]" in line:
                        return line.split("[")[1].split("]")[0]
        except:
            pass
    
    return default_path
```

Utilisez cette fonction dans les autres parties du code qui ont besoin de connaître l'emplacement des modèles.

## Utilisation dans l'interface graphique

Ces modifications permettront à l'utilisateur de voir clairement où sont stockés les modèles Ollama et de surveiller l'espace disque disponible pour éviter les problèmes lors du téléchargement de nouveaux modèles.