feat(core): Refonte Architecture, QMediaPlayer (multithread) & AioPresence

Séparation de la logique de l'UI (ui.py, core). Remplacement de pygame par QtMultimedia. Isolation de Discord RPC (AioPresence) sans threads. Sauvegarde playlist locale (Appdata). Ajout Workflow Actions CI/CD Windows/Linux/Mac

Author: Paullux

.env

@@ -0,0 +1,83 @@
+name: Build Music Player
+
+on:
+  push:
+    branches: [ "main", "master" ]
+  pull_request:
+    branches: [ "main", "master" ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: ["3.11"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    # Installation des dépendances selon l'OS
+    - name: Install dependencies (Windows)
+      if: matrix.os == 'windows-latest'
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install pyinstaller
+
+    - name: Install dependencies (macOS)
+      if: matrix.os == 'macos-latest'
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements-mac.txt
+        pip install pyinstaller
+
+    - name: Install dependencies (Linux/Ubuntu)
+      if: matrix.os == 'ubuntu-latest'
+      run: |
+        # Les dépendances systèmes PyQt5/Audio
+        sudo apt-get update
+        sudo apt-get install -y python3-pyqt5 python3-pyqt5.qtwebengine libsdl2-mixer-2.0-0 libsdl2-image-2.0-0 libsdl2-2.0-0 
+        python -m pip install --upgrade pip
+        # Installe les requirements globaux + linux (qui rajoute numba, scipy, etc.)
+        pip install -r requirements.txt
+        pip install -r requirements-Linux.txt
+        pip install pyinstaller
+
+    # Création de l'exécutable
+    - name: Build executable (Windows/Linux)
+      if: matrix.os == 'windows-latest' || matrix.os == 'ubuntu-latest'
+      run: pyinstaller main.spec --clean
+
+    - name: Build executable (macOS)
+      if: matrix.os == 'macos-latest'
+      run: pyinstaller main-macos.spec --clean
+
+    # Upload des Artifacts générés par PyInstaller
+    - name: Upload Windows executable
+      if: matrix.os == 'windows-latest'
+      uses: actions/upload-artifact@v4
+      with:
+        name: Musique-Windows
+        path: |
+          dist/*.exe
+          dist/*/
+
+    - name: Upload macOS App Bundle
+      if: matrix.os == 'macos-latest'
+      uses: actions/upload-artifact@v4
+      with:
+        name: Musique-macOS
+        path: dist/BIT_SCRIPTS_-_Musique.app/
+
+    - name: Upload Linux executable
+      if: matrix.os == 'ubuntu-latest'
+      uses: actions/upload-artifact@v4
+      with:
+        name: Musique-Linux
+        path: dist/*/

.github/workflows/build.yml

@@ -2,4 +2,6 @@ build/
 dist/
 venv-lecteur-multimedia/
 requirements-Test.txt
-main-test.py
+main-test.pyenv/
+env/
+.env

.gitignore

@@ -0,0 +1,117 @@
+import os
+import numpy as np
+from pydub import AudioSegment
+from PyQt5.QtCore import QObject, QTimer, pyqtSignal, QUrl, QThread
+from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent
+
+class WaveformWorker(QThread):
+    """
+    QThread asynchrone pour la génération du visuel spectral audio (Waveform) 
+    qui empêche le blocage de l'interface principale durant le chargement.
+    """
+    waveformReady = pyqtSignal(np.ndarray)
+
+    def __init__(self, audio_file):
+        super().__init__()
+        self.audio_file = audio_file
+        self.is_running = True
+
+    def run(self):
+        try:
+            # Traitement parfois long selon la taille du fichier
+            ext = os.path.splitext(self.audio_file)[-1].lower()
+            format_map = {'.flac': 'flac', '.mp3': 'mp3', '.ogg': 'ogg', '.wav': 'wav'}
+            audio_format = format_map.get(ext, 'mp3')
+            
+            # TODO : Utiliser un cache pour éviter de recalculer "samples" chaque fois
+            # pour la même chanson.
+            if self.is_running:
+                audio = AudioSegment.from_file(self.audio_file, format=audio_format)
+                samples = np.array(audio.get_array_of_samples())[::1000]
+                self.waveformReady.emit(samples)
+        except Exception as e:
+            print(f"Erreur WaveForm pour {self.audio_file} : {e}")
+        finally:
+            audio = None
+
+    def stop(self):
+        self.is_running = False
+        self.wait()
+
+
+class AudioEngine(QObject):
+    """
+    Moteur audio basé sur PyQt5.QtMultimedia (QMediaPlayer).
+    Remplace pygame.mixer pour une meilleure gestion native asynchrone
+    et des capacités de lecture directes plus permissives pour PyQt5.
+    """
+    positionChanged = pyqtSignal(int)
+    durationChanged = pyqtSignal(int)
+    trackFinished = pyqtSignal()
+
+    def __init__(self):
+        super().__init__()
+        self.player = QMediaPlayer()
+        
+        self.is_playing = False
+        self._current_position = 0
+        self._total_duration = 0
+        self.current_filepath = ""
+
+        # Signaux du lecteur vers l'interface
+        self.player.positionChanged.connect(self._on_position_changed)
+        self.player.durationChanged.connect(self._on_duration_changed)
+        self.player.stateChanged.connect(self._on_state_changed)
+
+    def load_track(self, filepath):
+        """Charge une piste dans le lecteur."""
+        self.current_filepath = filepath
+        self.is_playing = False  # Prévient l'émission intempestive de 'trackFinished' en cas de skip manuel
+        url = QUrl.fromLocalFile(filepath)
+        self.player.setMedia(QMediaContent(url))
+        self.player.stop()
+
+    def play(self, start_pos_ms=0):
+        if self.current_filepath:
+            if start_pos_ms > 0:
+                self.player.setPosition(start_pos_ms)
+            self.player.play()
+            self.is_playing = True
+
+    def pause(self):
+        self.is_playing = False
+        self.player.pause()
+
+    def stop(self):
+        self.is_playing = False
+        self.player.stop()
+
+    def set_position(self, pos_ms):
+        self.player.setPosition(pos_ms)
+
+    def set_volume(self, volume):
+        """Volume entre 0 et 100."""
+        self.player.setVolume(volume)
+
+    @property
+    def current_position(self):
+        return self._current_position
+
+    @property
+    def total_duration(self):
+        return self._total_duration
+
+    # --- Écouteurs Internes ---
+    def _on_position_changed(self, pos):
+        self._current_position = pos
+        self.positionChanged.emit(pos)
+
+    def _on_duration_changed(self, duration):
+        self._total_duration = duration
+        self.durationChanged.emit(duration)
+
+    def _on_state_changed(self, state):
+        if state == QMediaPlayer.StoppedState and self.is_playing:
+            # Si le lecteur s'arrête de lui-même (non pressé par l'utilisateur), fin de piste.
+            self.is_playing = False
+            self.trackFinished.emit()

core/__pycache__/audio_engine.cpython-311.pyc

@@ -0,0 +1,100 @@
+import os
+import asyncio
+import pyimgur
+from pypresence import AioPresence
+
+class DiscordRPCManager:
+    """Gestionnaire asynchrone pour la Rich Presence Discord et l'upload Imgur."""
+    
+    def __init__(self, client_id_discord, client_id_imgur):
+        self.client_id_discord = client_id_discord
+        self.client_id_imgur = client_id_imgur
+        self.rpc = None
+        self.uploaded_images_cache = {}
+
+    async def connect(self):
+        """Initialise la connexion à Discord RPC."""
+        if not self.client_id_discord:
+            print("Discord RPC désactivé : Aucun Client ID fourni.")
+            return
+
+        try:
+            self.rpc = AioPresence(self.client_id_discord)
+            await self.rpc.connect()
+            print("Connecté à Discord RPC via AioPresence.")
+        except Exception as e:
+            print(f"Erreur d'initialisation Discord RPC (Discord fermé ?) : {e}")
+            self.rpc = None
+
+    async def update_rpc(self, title, artist, image_url):
+        """Met à jour la présence Discord de manière asynchrone."""
+        if self.rpc is None:
+            return
+
+        try:
+            if not title and not artist:
+                await self.rpc.clear()
+                return
+            
+            await self.rpc.update(
+                details=title or "Inconnu",
+                state=artist or "Inconnu",
+                large_image=image_url or "music_bot",
+                large_text="Entrain d'écouter"
+            )
+            print("Présence Discord mise à jour.")
+        except Exception as e:
+            print(f"Erreur de mise à jour RPC : {e}")
+
+    async def upload_image_and_update_rpc(self, image_path, title, artist):
+        """Gère intelligemment l'upload Imgur et met à jour Discord."""
+        if self.rpc is None:
+            return
+
+        if not title and not artist:
+            await self.update_rpc("", "", "")
+            return
+
+        image_url = "music_bot"
+
+        # On n'upload que si une image est réellement fournie
+        if image_path and os.path.exists(image_path):
+            safe_image_path = image_path.replace("file://", "")
+            
+            if safe_image_path in self.uploaded_images_cache:
+                image_url = self.uploaded_images_cache[safe_image_path]
+            elif self.client_id_imgur:
+                try:
+                    def upload():
+                        im = pyimgur.Imgur(self.client_id_imgur)
+                        return im.upload_image(safe_image_path, title="Cover").link
+                        
+                    url = await asyncio.to_thread(upload)
+                    self.uploaded_images_cache[safe_image_path] = url
+                    image_url = url
+                    print(f"Upload Imgur réussi : {image_url}")
+                except Exception as e:
+                    print(f"Échec de l'upload Imgur : {e}")
+        
+        await self.update_rpc(title, artist, image_url)
+        
+    async def close_async(self):
+        """Purge asynchrone de la présence sur les serveurs Discord avant la coupure locale."""
+        if self.rpc:
+            try:
+                await self.rpc.clear()
+            except Exception:
+                pass
+            try:
+                self.rpc.close()
+            except Exception:
+                pass
+
+    def close(self):
+        """Sécurité."""
+        if self.rpc:
+            try:
+                self.rpc.close()
+            except:
+                pass
+