[PERF] Ajout de systèmes de cache pour optimiser les performances

- Cache thumbnail base64 (évite re-encodage à chaque update)
- Cache skin actif (évite lecture fichier HTML à chaque requête)
- Cache liste des skins (TTL 60s côté serveur, 30s côté GUI)
- Cache images preview dans GUI (évite rechargement images)
- Placeholder créé une seule fois et réutilisé

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: mm-elmazani

server.py

@@ -171,8 +171,16 @@ def get_skin_html(skin_name):
         return None
 
 
-def list_available_skins():
-    """Liste tous les skins disponibles avec leurs informations"""
+def list_available_skins(force_refresh=False):
+    """Liste tous les skins disponibles avec leurs informations (avec cache)"""
+    global _skins_list_cache
+
+    # Utiliser le cache s'il est valide (cache de 60 secondes ou jusqu'à invalidation)
+    if (not force_refresh
+            and _skins_list_cache["skins"] is not None
+            and (time.time() - _skins_list_cache["last_update"]) < 60):
+        return _skins_list_cache["skins"]
+
     skins_dir = Path("skins")
     available_skins = []
 
@@ -212,11 +220,17 @@ def list_available_skins():
 
             available_skins.append(skin_info)
 
+    # Mettre à jour le cache
+    _skins_list_cache["skins"] = available_skins
+    _skins_list_cache["last_update"] = time.time()
+
     return available_skins
 
 
 def set_active_skin(skin_name):
     """Change le skin actif et le sauvegarde dans la configuration"""
+    global _active_skin_cache
+
     skin_config_file = Path("config") / "active_skin.json"
 
     # Vérifier que le skin existe
@@ -232,6 +246,10 @@ def set_active_skin(skin_name):
         with open(skin_config_file, 'w', encoding='utf-8') as f:
             json.dump(config, f, indent=2, ensure_ascii=False)
 
+        # Invalider le cache du skin
+        _active_skin_cache["skin_id"] = None
+        _active_skin_cache["html_content"] = None
+
         print(f"[OK] Skin actif change pour : {skin_name}")
         return True, f"Skin changé pour : {skin_name}"
     except Exception as e:
@@ -272,6 +290,28 @@ def set_active_skin(skin_name):
 # Event pour le graceful shutdown
 shutdown_event = threading.Event()
 
+# ============================================================================
+# CACHE SYSTÈME
+# ============================================================================
+
+# Cache pour le thumbnail (évite de re-encoder en base64 si la piste n'a pas changé)
+_thumbnail_cache = {
+    "track_key": None,  # (title, artist, album) pour identifier la piste
+    "thumbnail": ""     # Le thumbnail en base64
+}
+
+# Cache pour le skin actif (évite de relire le fichier à chaque requête)
+_active_skin_cache = {
+    "skin_id": None,
+    "html_content": None
+}
+
+# Cache pour la liste des skins
+_skins_list_cache = {
+    "skins": None,
+    "last_update": 0
+}
+
 # ============================================================================
 # FILTRE MÉDIA
 # ============================================================================
@@ -320,6 +360,8 @@ def is_app_allowed(app_id: str) -> bool:
 
 async def get_media_info() -> Optional[Dict]:
     """Récupère les informations de la piste en cours depuis Windows Media API"""
+    global _thumbnail_cache
+
     try:
         sessions = await MediaManager.request_async()
         current_session = sessions.get_current_session()
@@ -339,45 +381,60 @@ async def get_media_info() -> Optional[Dict]:
             playback_info = current_session.get_playback_info()
             timeline_props = current_session.get_timeline_properties()
 
-            # Récupérer la pochette d'album
-            thumbnail_base64 = ""
-            if info.thumbnail:  # type: ignore[union-attr]
-                try:
-                    thumb_stream_ref = info.thumbnail  # type: ignore[union-attr]
-                    thumb_read_buffer = await thumb_stream_ref.open_read_async()
-
-                    buffer = Buffer(thumb_read_buffer.size)
-                    await thumb_read_buffer.read_async(
-                        buffer,
-                        buffer.capacity,
-                        InputStreamOptions.READ_AHEAD
-                    )
-
-                    reader = DataReader.from_buffer(buffer)
-                    byte_array = bytearray(buffer.length)
-                    reader.read_bytes(byte_array)
-
-                    thumbnail_base64 = "data:image/jpeg;base64," + base64.b64encode(byte_array).decode('utf-8')
-                except Exception as e:
-                    # Pas grave si la pochette n'est pas disponible
-                    pass
+            # Extraire les infos de base
+            title = info.title or "Unknown Title"  # type: ignore[union-attr]
+            artist = info.artist or "Unknown Artist"  # type: ignore[union-attr]
+            album = info.album_title or ""  # type: ignore[union-attr]
+
+            # Clé unique pour identifier la piste
+            track_key = (title, artist, album)
+
+            # Utiliser le cache du thumbnail si la piste n'a pas changé
+            if _thumbnail_cache["track_key"] == track_key and _thumbnail_cache["thumbnail"]:
+                thumbnail_base64 = _thumbnail_cache["thumbnail"]
+            else:
+                # Nouvelle piste, récupérer la pochette
+                thumbnail_base64 = ""
+                if info.thumbnail:  # type: ignore[union-attr]
+                    try:
+                        thumb_stream_ref = info.thumbnail  # type: ignore[union-attr]
+                        thumb_read_buffer = await thumb_stream_ref.open_read_async()
+
+                        buffer = Buffer(thumb_read_buffer.size)
+                        await thumb_read_buffer.read_async(
+                            buffer,
+                            buffer.capacity,
+                            InputStreamOptions.READ_AHEAD
+                        )
+
+                        reader = DataReader.from_buffer(buffer)
+                        byte_array = bytearray(buffer.length)
+                        reader.read_bytes(byte_array)
+
+                        thumbnail_base64 = "data:image/jpeg;base64," + base64.b64encode(byte_array).decode('utf-8')
+                    except Exception:
+                        pass
+
+                # Mettre à jour le cache
+                _thumbnail_cache["track_key"] = track_key
+                _thumbnail_cache["thumbnail"] = thumbnail_base64
 
             # Convertir les temps (timedelta) en secondes
             position_seconds = int(timeline_props.position.total_seconds()) if timeline_props.position else 0
             duration_seconds = int(timeline_props.end_time.total_seconds()) if timeline_props.end_time else 0
 
             return {
-                "title": info.title or "Unknown Title",  # type: ignore[union-attr]
-                "artist": info.artist or "Unknown Artist",  # type: ignore[union-attr]
-                "album": info.album_title or "",  # type: ignore[union-attr]
+                "title": title,
+                "artist": artist,
+                "album": album,
                 "thumbnail": thumbnail_base64,
                 "is_playing": playback_info.playback_status == 4,  # 4 = Playing
                 "position": position_seconds,
                 "duration": duration_seconds,
                 "source_app": source_app_id
             }
 
-    except Exception as e:
+    except Exception:
         # Pas de musique en cours ou erreur
         return None
 
@@ -647,15 +704,28 @@ def update_track_info():
 
 @app.route('/')
 def index():
-    """Page d'accueil avec l'overlay - charge le skin actif"""
+    """Page d'accueil avec l'overlay - charge le skin actif (avec cache)"""
+    global _active_skin_cache
+
     active_skin = load_active_skin()
+
+    # Utiliser le cache si le skin n'a pas changé
+    if (_active_skin_cache["skin_id"] == active_skin
+            and _active_skin_cache["html_content"] is not None):
+        return _active_skin_cache["html_content"]
+
+    # Charger le nouveau skin
     skin_html = get_skin_html(active_skin)
 
     # Si le skin n'est pas trouvé, utiliser le template par défaut
     if skin_html is None:
         print(f"[WARN] Skin {active_skin} introuvable, utilisation du template par defaut")
         return render_template_string(OVERLAY_HTML)
 
+    # Mettre à jour le cache
+    _active_skin_cache["skin_id"] = active_skin
+    _active_skin_cache["html_content"] = skin_html
+
     return skin_html
 
 

src/gui.py

@@ -43,6 +43,12 @@ def __init__(self, root):
         # Référence pour l'image de preview (éviter garbage collection)
         self.preview_image = None
 
+        # Cache pour les images de preview {skin_id: PhotoImage}
+        self._preview_cache: Dict[str, any] = {}
+
+        # Cache pour le placeholder par défaut
+        self._placeholder_image = None
+
         # System Tray
         self.tray_icon = None
         self.setup_system_tray()
@@ -574,9 +580,16 @@ def update_preview(self, skin):
         self.load_preview_image(skin.get('id', ''))
 
     def load_preview_image(self, skin_id):
-        """Charge l'image de preview si disponible, sinon affiche un placeholder"""
+        """Charge l'image de preview si disponible, sinon affiche un placeholder (avec cache)"""
         if not skin_id:
-            self.create_placeholder_preview("Aucun skin")
+            self._show_placeholder()
+            return
+
+        # Vérifier le cache
+        if skin_id in self._preview_cache:
+            photo = self._preview_cache[skin_id]
+            self.preview_image_label.config(image=photo)
+            self.preview_image = photo
             return
 
         # Chercher preview.png dans le dossier du skin
@@ -593,17 +606,28 @@ def load_preview_image(self, skin_id):
 
                 photo = ImageTk.PhotoImage(img)
 
+                # Mettre en cache
+                self._preview_cache[skin_id] = photo
+
                 self.preview_image_label.config(image=photo)
                 self.preview_image = photo  # Garder la référence
             except Exception:
                 # En cas d'erreur, afficher le placeholder
-                self.create_placeholder_preview(skin_id)
+                self._show_placeholder()
         else:
-            # Pas de preview.png, créer un placeholder
-            self.create_placeholder_preview(skin_id)
+            # Pas de preview.png, afficher le placeholder
+            self._show_placeholder()
 
-    def create_placeholder_preview(self, text):
-        """Crée une image placeholder avec le texte donné"""
+    def _show_placeholder(self):
+        """Affiche le placeholder en utilisant le cache"""
+        if self._placeholder_image is None:
+            self._placeholder_image = self._create_placeholder_image()
+
+        self.preview_image_label.config(image=self._placeholder_image)
+        self.preview_image = self._placeholder_image
+
+    def _create_placeholder_image(self):
+        """Crée l'image placeholder une seule fois"""
         # Créer une image de fond (taille augmentée)
         width, height = 500, 300
         img = Image.new('RGB', (width, height), color='#1a1a2e')
@@ -639,9 +663,11 @@ def create_placeholder_preview(self, text):
         draw.text((x, y), label, fill='#888888', font=font)
 
         # Convertir en PhotoImage
-        photo = ImageTk.PhotoImage(img)
-        self.preview_image_label.config(image=photo)
-        self.preview_image = photo  # Garder la référence
+        return ImageTk.PhotoImage(img)
+
+    def create_placeholder_preview(self, text):
+        """Crée une image placeholder (utilise le cache)"""
+        self._show_placeholder()
 
     # ========================================================================
     # MÉTHODES DE GESTION DES PARAMÈTRES (utilise ConfigManager)

src/skin_manager.py

@@ -4,6 +4,7 @@
 """
 
 import json
+import time
 import requests
 from pathlib import Path
 
@@ -19,6 +20,11 @@ def __init__(self, base_dir=None):
         self.config_dir = self.base_dir / "config"
         self.active_skin_file = self.config_dir / "active_skin.json"
 
+        # Cache pour la liste des skins
+        self._skins_cache = None
+        self._skins_cache_time = 0
+        self._cache_ttl = 30  # 30 secondes de TTL
+
     def load_skins_from_api(self, server_url):
         """
         Charge la liste des skins depuis l'API Flask
@@ -38,13 +44,30 @@ def load_skins_from_api(self, server_url):
             pass
         return None
 
-    def load_skins_from_files(self):
+    def load_skins_from_files(self, force_refresh=False):
         """
-        Charge la liste des skins directement depuis les fichiers (fallback)
+        Charge la liste des skins directement depuis les fichiers (avec cache)
+
+        Args:
+            force_refresh: Forcer le rechargement du cache
 
         Returns:
             dict: {"skins": [...], "active_skin": "..."}
         """
+        current_time = time.time()
+
+        # Utiliser le cache s'il est valide
+        if (not force_refresh
+                and self._skins_cache is not None
+                and (current_time - self._skins_cache_time) < self._cache_ttl):
+            # Mettre à jour le skin actif (peut changer sans que la liste change)
+            active_skin = self.get_active_skin_id()
+            return {
+                "skins": self._skins_cache,
+                "active_skin": active_skin,
+                "count": len(self._skins_cache)
+            }
+
         skins = []
 
         if not self.skins_dir.exists():
@@ -78,6 +101,10 @@ def load_skins_from_files(self):
 
                 skins.append(skin_info)
 
+        # Mettre à jour le cache
+        self._skins_cache = skins
+        self._skins_cache_time = current_time
+
         # Charger le skin actif
         active_skin = self.get_active_skin_id()
 
@@ -87,6 +114,11 @@ def load_skins_from_files(self):
             "count": len(skins)
         }
 
+    def invalidate_cache(self):
+        """Invalide le cache des skins"""
+        self._skins_cache = None
+        self._skins_cache_time = 0
+
     def get_active_skin_id(self):
         """
         Lit le skin actif depuis le fichier de configuration