I. 🎄 Présentation Générale du Projet

Ce projet est un système complet, basé sur Python, Flask et Tkinter, conçu pour animer un événement (probablement Noël, comme suggéré par les noms de dossiers noel2025_prod). Il combine un serveur web interactif pour la gestion de médias (photos et musique) avec un contrôleur d’affichage dédié pour une présentation dynamique et autonome.

L’objectif principal est de permettre aux participants de l’événement de contribuer en temps réel (via QR code/web upload) des photos et des requêtes audio, tandis que le serveur gère l’affichage des images, l’archivage, la planification des captures automatiques et le téléchargement audio de manière sécurisée et organisée.

Le système est modulaire et s’appuie fortement sur le multithreading pour dissocier l’interface web (Flask) de la logique d’affichage plein écran (Tkinter) et des tâches lourdes (téléchargement, surveillance de dossiers, capture).

II. 🧩 Architecture Technique et Organisation des Fichiers

L’architecture est structurée autour de deux scripts principaux et d’une organisation stricte des dossiers :

1. Structure des Scripts

Script	Rôle Principal	Technologies Clés
`serveur_15.py`	Cœur du système : serveur web, gestionnaire de médias (photos/MP3), contrôleur d’affichage (Tkinter), planification des tâches.	Flask, Tkinter, `threading`, `subprocess`, `yt-dlp`.
`gen_qr.py`	Utilitaire d’installation : détection d’IP, génération de QR code, superposition sur un fond pour créer l’image permanente de connexion.	`qrcode`, PIL (Pillow), `socket`.

2. Organisation des Dossiers (Définis dans `serveur_15.py`)

Dossier	Chemin Relatif	Description
Photos à traiter	`static/photos` (UPLOAD_FOLDER)	Photos nouvellement téléchargées ou capturées, en attente d’être affichées.
Archives	`static/archives_photos` (ARCHIVE_FOLDER)	Répertoire de stockage permanent des photos originales après leur affichage.
Vignettes	`static/thumbnails` (THUMBNAIL_FOLDER)	Miniatures des photos archivées, utilisées pour la page `/archives`.
Affichage permanent	`static/permanent` (PERMANENT_FOLDER)	Contient des images (ex: QR code) affichées en permanence, contrôlées par leur nom de fichier (`screen_x_y_filename`).
MP3 Téléchargés	`../noel2025_prod/mp3_download` (MP3_FOLDER)	Fichiers MP3 convertis depuis YouTube via l’interface web.
MP3 Catalogue	`../noel2025_prod/mp3_catalog` (MP3_FOLDER_CATALOG)	Fichiers MP3 gérés manuellement (e.g., liste de lecture de base).

III. ⚙️ Fonctionnalités du Serveur (`serveur_15.py`)

1. Contrôle d’Affichage Multithreadé (Tkinter)

Le composant ImageDisplayController est essentiel :

Séparation des préoccupations : Il maintient l’affichage graphique complètement séparé du serveur web Flask, évitant les blocages.
Mécanisme de Queue : Les demandes d’affichage sont envoyées via une queue thread-safe (display_queue) que la boucle principale Tkinter surveille.
Affichage Dynamique : Les images du dossier photos sont traitées, redimensionnées à la volée (_load_and_resize_to_fit à 1066×600), affichées pendant SHOW_DURATION (5 secondes), puis archivées et converties en vignette.
Affichage Statistique : Gère l’affichage des images du dossier permanent (e.g., le QR code) en utilisant leurs coordonnées encodées dans le nom de fichier (screen_x_y_filename).

2. Gestion et Traitement des Photos (Tâches de Fond)

Deux tâches de fond (threads daemon) assurent le flux continu :

process_photos_task : Le gestionnaire de flux de photos. Il poll le dossier d’upload toutes les 10 secondes, prend la plus ancienne photo pour garantir l’ordre de traitement, la redimensionne, l’affiche, crée une vignette et la déplace ensuite vers le dossier d’archive.
scheduled_capture_task : La capture planifiée. Elle utilise l’utilitaire fswebcam pour prendre une photo haute résolution (1920×1080) toutes les 10 minutes (600 secondes), assurant un contenu continu même sans interaction utilisateur.

3. Gestion Audio (Module YouTube MP3)

Ce module est un ajout sophistiqué permettant de transformer l’interface web en un jukebox :

Recherche Filtrée : La route /youtube utilise yt-dlp pour rechercher des vidéos et applique un filtre strict pour n’afficher que celles dont la durée est inférieure à 10 minutes (MAX_DURATION_SECONDS).
Téléchargement Asynchrone : La route /youtube/download/<video_id> lance le processus de conversion YouTube vers MP3 dans un thread de travail séparé (download_worker) pour ne pas bloquer le serveur web.
Nommage Sécurisé : Le titre de la vidéo est récupéré, nettoyé des caractères illégaux par nettoyer_nom_fichier, et utilisé pour générer un nom de fichier horodaté et lisible : AAAAmmjj_HHMMSS_titre_nettoye.mp3.
Suivi de Statut : Le statut du téléchargement est suivi via un dictionnaire global (DOWNLOAD_STATUS) protégé par un verrou (DOWNLOAD_LOCK), et exposé via l’endpoint /youtube/check/<video_id> pour le polling AJAX depuis la page d’attente.

4. Gestion des MP3 Téléchargés

Le module /mp3_manager permet une administration centralisée :

list_mp3_files : Agrége les fichiers MP3 des dossiers download et catalog, fournissant leur taille et leur origine.
Sécurité de Suppression : Le formulaire POST utilise un mécanisme de vérification de chemin absolu (en comparant os.path.abspath(folder) avec les dossiers autorisés) pour garantir que l’utilisateur ne peut supprimer que les fichiers présents dans les deux répertoires MP3 désignés, empêchant ainsi les attaques de traversée de répertoire.

IV. 🚀 Utilitaire QR Code (`gen_qr.py`)

Le rôle de ce script est d’assurer une installation sans friction en générant l’outil de connexion pour les participants.

1. Connexion Dynamique

Détection d’IP : La fonction _detect_local_ip trouve l’adresse IP du serveur sur le réseau local, garantissant que le QR code est utilisable immédiatement sans configuration manuelle de l’IP.
Génération Précise : La fonction generate_qr_jpg crée le code QR pour l’URL complète (http://[IP]:5000/photos) avec une taille en pixels et une bordure exactes.

2. Personnalisation Visuelle

Superposition : La fonction superpose_qr_on_frame prend le QR code généré et le place automatiquement au centre d’une image de fond prédéfinie (e.g., un cadre de Noël), créant une image finale conviviale et thématique.
Déploiement : Cette image finale est sauvegardée dans le dossier static/permanent/ avec le nom structuré (e.g., 0_5_5_qr.jpg), permettant au ImageDisplayController de l’afficher en permanence dès le démarrage du serveur.

V. Synthèse et Perspectives d’Évolution du Projet

🌟 Conclusion : Un Système Multimédia Robuste et Engageant

Le projet actuel, articulé autour de serveur_15.py et gen_qr.py, représente une solution d’animation événementielle remarquablement intégrée et thread-safe. En dissociant habilement l’interface web (Flask) du moteur d’affichage (Tkinter), il garantit à la fois une haute disponibilité du serveur et une expérience utilisateur fluide pour la projection plein écran.

La gestion automatique du flux de photos (upload, redimensionnement, affichage temporaire, archivage) et la mise en place d’un jukebox YouTube-to-MP3 asynchrone créent une plateforme interactive et dynamique. L’initialisation sécurisée et visuellement attrayante grâce au générateur de QR code (gen_qr.py) complète ce tableau en fournissant un point d’entrée immédiat pour les participants.

Ce système est une base solide et opérationnelle pour un événement tel que Noël 2025, prouvant l’efficacité de l’intégration de technologies disparates (Web, GUI, Utilitaires Système) au sein d’une architecture Python maîtrisée.

📈 Perspectives d’Amélioration et Pistes d’Évolution

Pour pérenniser le projet et en étendre les capacités, plusieurs pistes d’amélioration pourraient être explorées, touchant la performance, l’expérience utilisateur et la modularité :

1. Amélioration de la Robustesse et de la Performance

Remplacement du Polling par des Notifications : L’actuelle process_photos_task s’appuie sur le polling du dossier static/photos toutes les 10 secondes. Une amélioration majeure serait d’utiliser des bibliothèques comme watchdog pour mettre en place une surveillance des événements de système de fichiers. Cela permettrait de déclencher le traitement photo immédiatement après l’upload, réduisant le délai d’affichage et libérant des ressources CPU.
Contrôle de l’Audio : Actuellement, le système télécharge les MP3 mais ne les lit pas. L’intégration d’un lecteur audio (potentiellement dans un thread dédié ou via une bibliothèque comme pygame.mixer) permettrait de lire les MP3 téléchargés ou ceux du catalogue, offrant un contrôle complet de l’ambiance sonore.

2. Amélioration de l’Expérience Utilisateur (UX)

Interface d’Administration : Développer une interface web protégée par mot de passe pour le panneau d’administration. Cela permettrait de :
- Modifier les variables de configuration (durée d’affichage, intervalle de capture, etc.) sans redémarrer le serveur.
- Gérer et prévisualiser les images permanentes.
- Lancer/arrêter la lecture audio.
Retour Visuel pour les Téléchargements : Améliorer la page d’attente /youtube/wait pour inclure des informations plus détaillées sur la progression du téléchargement (si possible avec yt-dlp en mode verbeux, mais filtré pour l’utilisateur), plutôt qu’un simple statut ‘PENDING’.

3. Modularité et Déploiement

Conteneurisation (Docker) : Le déploiement actuel nécessite l’installation des dépendances Python (qrcode[pil], Flask, yt-dlp, etc.) ainsi que des utilitaires systèmes (fswebcam) et de l’environnement graphique (Tkinter). L’encapsulation du projet dans un conteneur Docker simplifierait massivement le déploiement sur différents systèmes, rendant le projet portable.
Abstraction de l’Affichage : Remplacer le contrôleur d’affichage basé sur Tkinter (qui nécessite un environnement X-Windows) par une solution plus légère ou headless pour l’affichage (par exemple, en utilisant un navigateur en mode kiosque contrôlé à distance ou une bibliothèque graphique plus orientée vers le média comme PyQt ou Kivy) pourrait offrir plus de flexibilité pour le choix du moniteur et de la plateforme hôte.

Source gen_qr.py

Python

import socket
import os
from typing import Optional

try:
    import qrcode
    from PIL import Image
except ImportError as e:
    raise ImportError("Dépendances manquantes : installez 'qrcode[pil]'") from e

def _detect_local_ip() -> str:
    """Détecte automatiquement l'IP locale non-loopback"""
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
            s.connect(("8.8.8.8", 80))
            ip = s.getsockname()[0]
            if ip and not ip.startswith("127."):
                return ip
    except Exception:
        pass
    try:
        ip = socket.gethostbyname(socket.gethostname())
        if ip and not ip.startswith("127."):
            return ip
    except Exception:
        pass
    raise RuntimeError("Impossible de détecter l'IP locale.")


def generate_qr_jpg(
    output_path: str,
    port: int = 80,
    url_suffix: str = "",
    host_ip: Optional[str] = None,
    qr_size_px: int = 400,
    border_px: int = 20,
    jpeg_quality: int = 85
) -> str:
    """
    Génère un QRCode JPG avec taille exacte en pixels.

    Paramètres :
      – output_path: chemin du fichier JPG
      – port: port à inclure dans l'URL
      – url_suffix: complément d'URL
      – host_ip: si fourni, utilise cette IP, sinon détecte automatiquement
      – qr_size_px: largeur/hauteur totale du QRCode en pixels
      – border_px: largeur de la bordure en pixels
      – jpeg_quality: qualité JPEG (1..95)
    """
    if not host_ip:
        host_ip = _detect_local_ip()

    suffix = (url_suffix or "").lstrip("/")
    url = f"http://{host_ip}:{port}/{suffix}" if suffix else f"http://{host_ip}:{port}"

    # créer QRCode sans taille fixe
    qr = qrcode.QRCode(
        version=None,
        error_correction=qrcode.constants.ERROR_CORRECT_M,
        box_size=10,  # temporaire, sera redimensionné
        border=4
    )
    qr.add_data(url)
    qr.make(fit=True)

    # nombre de "cases" dans le QR
    num_boxes = qr.modules_count

    # calcul du box_size pour atteindre qr_size_px
    box_size = (qr_size_px – 2 * border_px) // num_boxes
    border_boxes = border_px // box_size

    qr = qrcode.QRCode(
        version=qr.version,
        error_correction=qrcode.constants.ERROR_CORRECT_M,
        box_size=box_size,
        border=border_boxes
    )
    qr.add_data(url)
    qr.make(fit=True)
    img = qr.make_image(fill_color="black", back_color="white").convert("RGB")

    # redimensionner exactement à qr_size_px (pour ajuster arrondi)
    img = img.resize((qr_size_px, qr_size_px), Image.NEAREST)

    # créer dossier si nécessaire
    os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)

    # sauvegarde
    img.save(output_path, format="JPEG", quality=jpeg_quality)
    return output_path

from PIL import Image

def superpose_qr_on_frame(qr_path, frame_path, output_path):
    """
    Superpose une image QR code sur une image de fond et sauvegarde le résultat.

    Args:
        qr_path (str): Chemin de l'image QR code (doit être un carré, PNG ou JPG).
        frame_path (str): Chemin de l'image de fond.
        output_path (str): Chemin de sortie pour l'image finale.
    """
    # Ouvrir les images
    qr_img = Image.open(qr_path).convert("RGBA")
    frame_img = Image.open(frame_path).convert("RGBA")

    # Redimensionner le QR code si nécessaire pour qu'il tienne dans l'image de fond
    frame_width, frame_height = frame_img.size
    qr_width, qr_height = qr_img.size

    # Réduire le QR code si plus grand que le fond
    scale = min(frame_width / qr_width, frame_height / qr_height, 1.0)
    new_qr_size = (int(qr_width * scale), int(qr_height * scale))
    qr_img = qr_img.resize(new_qr_size, Image.Resampling.LANCZOS)

    # Calculer la position pour centrer le QR code
    qr_width, qr_height = qr_img.size
    pos_x = (frame_width – qr_width) // 2
    pos_y = (frame_height – qr_height) // 2

    # Superposer le QR code sur la fond
    frame_img.paste(qr_img, (pos_x, pos_y), qr_img)  # utilisation du canal alpha

    # Sauvegarder l'image finale
    frame_img.convert("RGB").save(output_path, "JPEG")
    print(f"Image finale générée : {output_path}")

# Exemple :
output_path="static/permanent/0_5_5_qr.jpg"
frame_path="static/modeles_fond_qr/noel2.jpeg"
generate_qr_jpg("temp.jpg", port=5000, url_suffix="/photos", qr_size_px=111, border_px=2)
superpose_qr_on_frame("temp.jpg", frame_path, output_path)

Source serveur_15.py

Python

import re
import os
import time
import threading
import queue
import tkinter as tk
from flask import Flask, request, render_template, redirect, url_for, flash
from datetime import datetime
from werkzeug.utils import secure_filename
from PIL import Image, ImageTk
from screeninfo import get_monitors
import subprocess
import yt_dlp
import urllib.parse
import os.path

# ==============================================================================
# ⚙️ CONFIGURATION GÉNÉRALE
# ==============================================================================

STATIC_FOLDER = 'static'
UPLOAD_FOLDER = os.path.join(STATIC_FOLDER, 'photos')
ARCHIVE_FOLDER = os.path.join(STATIC_FOLDER, 'archives_photos')
PERMANENT_FOLDER = os.path.join(STATIC_FOLDER, 'permanent')
THUMBNAIL_FOLDER = os.path.join(STATIC_FOLDER, 'thumbnails')
CURRENT_PHOTO_NAME = 'current.jpg'

POLLING_INTERVAL = 10
SHOW_DURATION = 5
TARGET_WIDTH = 1066
TARGET_HEIGHT = 600
TARGET_SCREEN = 0
TARGET_X = None
TARGET_Y = 0

ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif'}

app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['SECRET_KEY'] = 'ma_super_cle_secrete_de_noel'
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024

# Dossier où stocker les fichiers MP3
MP3_FOLDER = os.path.join('', "../noel2025_prod/mp3_download")
# Assurez-vous que les chemins absolus sont cohérents pour la vérification de sécurité
os.makedirs(MP3_FOLDER, exist_ok=True)

# Dossier où stocker les fichiers MP3 provenant du catalogue
MP3_FOLDER_CATALOG = os.path.join('', "../noel2025_prod/mp3_catalog")
# Assurez-vous que le chemin absolu est cohérent
os.makedirs(MP3_FOLDER_CATALOG, exist_ok=True)

# chemin vers le script à exécuter
script_path = "gen_qr.py"

# exécuter le script et attendre qu'il se termine
result = subprocess.run(["python3", script_path], capture_output=True, text=True)

# accéder au code de retour
print("Code retour :", result.returncode)

# afficher stdout et stderr si besoin
print("Sortie standard:\n", result.stdout)
print("Erreurs éventuelles:\n", result.stderr)

def nettoyer_nom_fichier(chaine: str) -> str:
    """
    Remplace tous les caractères incompatibles avec les chemins de fichiers
    sous Windows, Linux et macOS par des espaces.

    Paramètres:
        chaine (str): Le texte d'entrée.

    Retourne:
        str: Une chaîne nettoyée, sûre pour les chemins de fichiers.
    """
    # Liste des caractères interdits sur Windows/Linux/macOS
    caracteres_interdits = r'[<>:"/\\|?*\x00-\x1F]'
    
    # Remplace les caractères interdits par des espaces
    chaine_nettoyee = re.sub(caracteres_interdits, ' ', chaine)
    
    # Supprime les espaces inutiles au début et à la fin
    return chaine_nettoyee.strip()

def capture_image_high_quality(output_dir="static/photos"):
    # Génération du nom de fichier
    timestamp = time.strftime("%Y%m%d_%H%M%S")
    filename = f"PHOTO_{timestamp}.jpg"
    filepath = os.path.join(output_dir, filename)

    # Commande fswebcam
    # -d /dev/video0 : Spécifie le périphérique (adaptez si besoin)
    # -r 1920×1080 : Définit la résolution
    # –jpeg 100 : Qualité du JPEG (0-100)
    # –skip 30 : Saute les 30 premières images pour laisser le temps à la caméra de s'ajuster (équivalent à votre boucle)
    # –no-banner : Supprime la bannière d'information ajoutée par défaut sur l'image
    command = [
        "fswebcam",
        "-d", "/dev/video0",
        "-r", "1920×1080",
        "–jpeg", "95",
        "–skip", "30",
        "–no-banner",
        filepath
    ]

    try:
        # Exécute la commande
        subprocess.run(command, check=True, capture_output=True, text=True)
        print(f"✅ Image capturée : {filepath}")
        return filepath
    except subprocess.CalledProcessError as e:
        # Gère les erreurs si fswebcam échoue
        print(f"❌ Erreur lors de la capture avec fswebcam.")
        print(f"   Erreur : {e.stderr}")
        return None
            
# ==============================================================================
# 🖥️ CONTRÔLEUR D’AFFICHAGE TKINTER (THREAD-SAFE)
# ==============================================================================

class ImageDisplayController:
    def __init__(self):
        self.monitors = get_monitors()
        self._permanent_windows = []
        self._permanent_photo_refs = []
        self.display_queue = queue.Queue()

        threading.Thread(target=self._tk_mainloop, daemon=True).start()

    # ———————————————————————-
    def _tk_mainloop(self):
        """Boucle principale Tkinter : gère les affichages via une queue."""
        self.tk_root = tk.Tk()
        self.tk_root.withdraw()
        self.tk_root.after(100, self._process_queue)
        self.tk_root.mainloop()

    def _process_queue(self):
        """Traite les demandes d'affichage envoyées depuis d'autres threads."""
        try:
            while True:
                image_path, duration_s, screen_index, x_coord, y_coord = self.display_queue.get_nowait()
                self._show_image_internal(image_path, duration_s, screen_index, x_coord, y_coord)
        except queue.Empty:
            pass
        self.tk_root.after(200, self._process_queue)

    # ———————————————————————-
    def _load_and_resize_to_fit(self, image_path, max_width, max_height):
        """Charge et redimensionne l'image pour s'adapter à la taille cible."""
        with Image.open(image_path) as img:
            orig_w, orig_h = img.size
            if orig_w == 0 or orig_h == 0:
                return None, (0, 0)

            ratio_w = max_width / orig_w
            ratio_h = max_height / orig_h
            scale_ratio = min(ratio_w, ratio_h)
            new_w = int(orig_w * scale_ratio)
            new_h = int(orig_h * scale_ratio)

            resized = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
            return resized, (new_w, new_h)

    # ———————————————————————-
    def _show_image_internal(self, image_path, duration_s, screen_index, x_coord, y_coord):
        """Affiche une image depuis le bon thread Tkinter."""
        monitor = self.monitors[screen_index]
        try:
            img = Image.open(image_path)
            photo_ref = ImageTk.PhotoImage(img)
        except Exception as e:
            print(f"Erreur de chargement de {image_path}: {e}")
            return

        img_w, img_h = img.size

        if x_coord is None:
            x = monitor.x + (monitor.width – img_w) // 2
            log_x = 'Centré'
        else:
            x = monitor.x + x_coord
            log_x = x_coord

        if y_coord is None:
            y = monitor.y + (monitor.height – img_h) // 2
            log_y = 'Centré'
        else:
            y = monitor.y + y_coord
            log_y = y_coord

        print(f"🖥️ Affichage réel à X: {log_x}, Y: {log_y}")

        win = tk.Toplevel(self.tk_root)
        win.overrideredirect(True)
        win.attributes("-topmost", True)
        win.geometry(f"{img_w}x{img_h}+{x}+{y}")

        label = tk.Label(win, image=photo_ref, borderwidth=0, bg="black")
        label.image = photo_ref
        label.pack()

        win.after(duration_s * 1000, win.destroy)

    # ———————————————————————-
    def show_image_for_duration(self, image_path, duration_s, screen_index, x_coord=TARGET_X, y_coord=TARGET_Y):
        """Demande l'affichage d'une image (thread-safe)."""
        self.display_queue.put((image_path, duration_s, screen_index, x_coord, y_coord))

    # ———————————————————————-
    def show_permanent_image(self, image_path, screen_index, x, y):
        """Affiche une image permanente (dans le même thread Tk)."""
        monitor = self.monitors[screen_index]
        abs_x = monitor.x + x
        abs_y = monitor.y + y

        def _show():
            try:
                img = Image.open(image_path)
                img_w, img_h = img.size

                root = tk.Toplevel(self.tk_root)
                root.overrideredirect(True)
                root.attributes("-topmost", False)
                root.geometry(f"{img_w}x{img_h}+{abs_x}+{abs_y}")
                root._is_permanent = True

                photo_ref = ImageTk.PhotoImage(img)
                label = tk.Label(root, image=photo_ref, borderwidth=0, bg="black")
                label.image = photo_ref
                label.pack()

                # ✅ Garde les références pour éviter le GC
                root._photo_ref = photo_ref
                self._permanent_photo_refs.append(photo_ref)
                self._permanent_windows.append(root)

            except Exception as e:
                print(f"Erreur d'affichage permanent de {image_path}: {e}")

        if hasattr(self, 'tk_root'):
            self.tk_root.after(0, _show)
        else:
            print("⚠️ Tkinter non initialisé encore pour affichage permanent.")


# ==============================================================================
# 🖼️ GESTION DES VIGNETTES
# ==============================================================================

def generate_thumbnail(image_path, thumbnail_path, size=(150, 150)):
    """Crée une vignette et l'enregistre."""
    try:
        with Image.open(image_path) as img:
            # Créer une vignette carrée en recadrant le centre de l'image
            # Pour l'instant, on se contente de la redimensionner tout en conservant le ratio
            img.thumbnail(size) 
            img.save(thumbnail_path, quality=85)
            return True
    except Exception as e:
        print(f"Erreur lors de la création de la vignette pour {image_path}: {e}")
        return False


# ==============================================================================
# 🔄 TÂCHE DE FOND
# ==============================================================================

def process_photos_task(controller):
    """Surveille le dossier 'photos' et affiche les nouvelles images."""
    print("✅ Tâche de fond de surveillance des photos démarrée.")
    while True:
        try:
            photos = sorted(
                [f for f in os.listdir(UPLOAD_FOLDER) if f.lower().endswith(tuple(ALLOWED_EXTENSIONS))]
            )

            if not photos:
                time.sleep(POLLING_INTERVAL)
                continue

            oldest_photo = photos[0]
            source_path = os.path.join(UPLOAD_FOLDER, oldest_photo)
            print(f"🖼️  Traitement de : {oldest_photo}")

            current_photo_path = os.path.join(STATIC_FOLDER, CURRENT_PHOTO_NAME)

            # 1. Redimensionner la photo pour l'affichage plein écran
            image, _ = controller._load_and_resize_to_fit(
                source_path, max_width=TARGET_WIDTH, max_height=TARGET_HEIGHT
            )

            if image:
                image.save(current_photo_path)
                controller.show_image_for_duration(current_photo_path, SHOW_DURATION, TARGET_SCREEN)
                
                # 2. Créer la vignette
                thumbnail_path = os.path.join(THUMBNAIL_FOLDER, oldest_photo)
                # On utilise la source originale (source_path) car current_photo_path est déjà redimensionnée
                generate_thumbnail(source_path, thumbnail_path)

                # 3. Archiver l'original
                archive_path = os.path.join(ARCHIVE_FOLDER, oldest_photo)
                os.rename(source_path, archive_path)
                print(f"🗄️  '{oldest_photo}' archivée avec succès.")

        except Exception as e:
            print(f"Erreur dans la tâche de fond : {e}")

        time.sleep(POLLING_INTERVAL)

# — TÂCHE DE FOND : Capture planifiée —
def scheduled_capture_task():
    """Capture une image toutes les 10 minutes (600 secondes)."""
    # Délai initial pour ne pas capturer immédiatement au démarrage
    time.sleep(10) 
    
    # 10 minutes = 600 secondes
    CAPTURE_INTERVAL = 600
    print(f"📸 Tâche de capture planifiée démarrée. Intervalle : {CAPTURE_INTERVAL} secondes.")
    
    while True:
        try:
            # Appel de la fonction de capture
            capture_image_high_quality()
        except Exception as e:
            print(f"❌ Erreur lors de la capture planifiée : {e}")

        # Attendre la durée définie avant la prochaine capture
        time.sleep(CAPTURE_INTERVAL)
# —————————–

def display_permanent_photos(controller):
    """Scanne le dossier 'permanent' et affiche les images permanentes."""
    print("🔎 Recherche d'images permanentes…")
    if not os.path.exists(PERMANENT_FOLDER):
        return

    for filename in os.listdir(PERMANENT_FOLDER):
        if not filename.lower().endswith(('.jpg', '.jpeg', '.png')):
            continue
        try:
            parts = filename.split('_')
            if len(parts) < 4:
                print(f"Nom de fichier permanent invalide (ignoré) : {filename}")
                continue

            screen = int(parts[0])
            x = int(parts[1])
            y = int(parts[2])

            image_path = os.path.join(PERMANENT_FOLDER, filename)
            print(f"📍 Affichage permanent de '{filename}' sur l'écran {screen} à ({x},{y})")
            controller.show_permanent_image(image_path, screen, x, y)

        except (ValueError, IndexError) as e:
            print(f"Erreur de parsage du nom de fichier '{filename}': {e}")


# ==============================================================================
# 🌐 FLASK
# ==============================================================================

def allowed_file(filename):
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS


@app.route('/photos', methods=['GET', 'POST'])
def photo_shooter():
    if request.method == 'POST':
        if 'photo_file' not in request.files:
            flash('Erreur : Aucun fichier trouvé.', 'error')
            return redirect(request.url)

        file = request.files['photo_file']

        if file.filename == '':
            flash('Erreur : Aucune photo sélectionnée.', 'error')
            return redirect(request.url)

        if file and allowed_file(file.filename):
            original_filename = secure_filename(file.filename)
            ext = original_filename.rsplit('.', 1)[1].lower()
            timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S")
            new_filename = f"PHOTO_{timestamp_str}.{ext}"

            save_path = os.path.join(app.config['UPLOAD_FOLDER'], new_filename)
            try:
                file.save(save_path)
                flash(f'📸 Photo "{new_filename}" enregistrée avec succès !', 'success')
            except Exception as e:
                flash(f'Erreur serveur : {e}', 'error')

            return redirect(url_for('photo_shooter'))
        else:
            flash('Erreur : Format non autorisé.', 'error')
            return redirect(request.url)

    return render_template('photo_page.html')

@app.route('/archives')
def archives():
    # Chemin absolu vers le dossier des photos originales archivées
    archive_dir = os.path.join(app.root_path, ARCHIVE_FOLDER)
    
    if not os.path.exists(archive_dir):
        photo_files = []
    else:
        # Lister tous les fichiers (filtrer si nécessaire)
        photo_files = [f for f in os.listdir(archive_dir) if f.endswith(('.jpg', '.jpeg', '.png', '.gif'))]
        
        # 💡 TRI INVERSE CHRONOLOGIQUE : La plus récente d'abord
        photo_files.sort(reverse=True)

    # Renvoyer le template en lui passant la liste des fichiers
    return render_template('archives.html', photo_files=photo_files)

# ==============================================================
# MODULE : Téléchargement audio YouTube → MP3
# ==============================================================

# ⚙️ PARAMÈTRES YOUTUBE
MAX_DURATION_SECONDS = 600    # 10 minutes
MAX_SEARCH_RESULTS = 50       # Nombre de vidéos demandées à YouTube
MAX_DISPLAY_RESULTS = 20       # Nombre de résultats max à afficher sur la page

# ⚙️ GESTION DU STATUT DE TÉLÉCHARGEMENT
# Structure: {'video_id': 'statut'} -> Statuts: 'PENDING', 'SUCCESS:filename', 'ERROR'
DOWNLOAD_STATUS = {}
DOWNLOAD_LOCK = threading.Lock()


@app.route('/youtube', methods=['GET', 'POST'])
def youtube_search():
    """
    Recherche des vidéos sur YouTube, les filtre par durée maximale (MAX_DURATION_SECONDS),
    et inclut la durée formatée dans les résultats.
    """
    videos = []
    query = ""
    message = None

    if request.method == 'POST':
        query = request.form.get('query', '').strip()

        if query:
            try:
                # 1. Configuration yt-dlp pour recherche/filtrage
                ydl_opts = {
                    'quiet': True,
                    'dump_single_json': True,
                    'extract_flat': True,
                    'force_generic_extractor': True,
                    'skip_download': True,
                    'ignore_errors': True,
                    'match_filter': f'duration <= {MAX_DURATION_SECONDS}',
                }
                
                search_term = f"ytsearch{MAX_SEARCH_RESULTS}:{query}"
                
                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                    info = ydl.extract_info(search_term, download=False)
                    
                    processed_videos = []
                    count = 0 
                    
                    for entry in info.get('entries', []):
                        if count >= MAX_DISPLAY_RESULTS:
                            break
                        
                        # Double vérification : si la durée existe et est bien filtrée
                        if entry and entry.get('duration') is not None and entry.get('duration') <= MAX_DURATION_SECONDS:
                            
                            duration_s = entry.get('duration')
                            duration_hms = time.strftime('%H:%M:%S', time.gmtime(duration_s))
                            
                            video_data = entry.copy()
                            video_data['display_duration'] = duration_hms 
                            processed_videos.append(video_data)
                            count += 1
                            
                    videos = processed_videos
                    
            except Exception as e:
                message = f"Erreur lors de la recherche : {e}"

    return render_template('youtube_search.html', videos=videos, query=query, message=message)


def download_worker(video_id):
    """ Tâche de fond pour exécuter yt-dlp. """
    url = f"https://www.youtube.com/watch?v={video_id}"
    mp3_file = ""
    success = False
    
    # 🔒 Démarrage: Enregistrer le statut 'PENDING'
    with DOWNLOAD_LOCK:
        DOWNLOAD_STATUS[video_id] = 'PENDING'

    try:
        # — DÉBUT MODIFICATION POUR NOM DE FICHIER NORMALISÉ —
        
        # 1. Obtenir l'objet info SANS le télécharger (utile pour le titre)
        ydl_info_opts = {'quiet': True, 'skip_download': True}
        with yt_dlp.YoutubeDL(ydl_info_opts) as ydl_info:
            info = ydl_info.extract_info(url, download=False)
            # Récupérer le titre
            title = info.get('title', 'sans_titre')
            #sanitized_title = title.replace('/', '_').replace('\\', '_').replace('\n', ' ').strip()
            sanitized_title=nettoyer_nom_fichier(title)
            
        # 2. Créer le préfixe de date/heure (AAAAmmjj_hhmmss)
        timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S")
        
        # 3. Construire le template de sortie (AAAAmmjj_hhmmss_le_nom_de_la_video.ext)
        output_template = f"{timestamp_str}_{sanitized_title}"
        
        # 4. Définir les options de téléchargement avec le nouveau template
        ydl_opts = {
            'format': 'bestaudio/best',
            # Utilisation du template construit
            'outtmpl': os.path.join(MP3_FOLDER, f"{output_template}.%(ext)s"), 
            'postprocessors': [{
                'key': 'FFmpegExtractAudio',
                'preferredcodec': 'mp3',
                'preferredquality': '192',
            }],
            'quiet': False, # Afficher la progression dans les logs du serveur
            'noplaylist': True
        }
        # — FIN MODIFICATION POUR NOM DE FICHIER NORMALISÉ —

        print(f"[YouTube] Démarrage du téléchargement pour {video_id}…")
        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
            # Lancement du téléchargement réel
            info = ydl.extract_info(url, download=True)
            
            # Le nom du fichier final est prévisible grâce au template
            mp3_file = os.path.join(MP3_FOLDER, f"{output_template}.mp3")
        
        success = True
        print(f"[YouTube] Terminé : {mp3_file}")

    except Exception as e:
        print(f"[ERREUR YouTube] Échec du téléchargement {video_id} : {e}")
    
    # 🔒 Fin: Enregistrer le statut final
    with DOWNLOAD_LOCK:
        if success:
            # On utilise le nom de base pour le statut de succès
            DOWNLOAD_STATUS[video_id] = f'SUCCESS:{os.path.basename(mp3_file)}'
        else:
            DOWNLOAD_STATUS[video_id] = 'ERROR'


@app.route('/youtube/download/<video_id>')
def youtube_download(video_id):
    """
    Démarre le téléchargement en tâche de fond et redirige vers la page d'attente.
    """
    # 1. Lance le téléchargement en tâche de fond (Worker)
    # Vérifie si la tâche n'est pas déjà en cours
    with DOWNLOAD_LOCK:
        if video_id not in DOWNLOAD_STATUS or DOWNLOAD_STATUS[video_id] not in ['PENDING']:
            thread = threading.Thread(target=download_worker, args=(video_id,))
            thread.start()
        
    # 2. Redirige immédiatement l'utilisateur vers la page d'attente
    return redirect(url_for('youtube_wait', video_id=video_id))


@app.route('/youtube/wait/<video_id>')
def youtube_wait(video_id):
    """ Affiche la page d'attente (spinner). """
    # Rendu du nouveau template youtube_wait.html
    return render_template('youtube_wait.html', video_id=video_id)


@app.route('/youtube/check/<video_id>')
def youtube_check(video_id):
    """ Vérifie le statut du téléchargement pour le polling AJAX. """
    status = 'NOT_FOUND'
    filename = ''

    with DOWNLOAD_LOCK:
        current_status = DOWNLOAD_STATUS.get(video_id)
        
        if current_status:
            # Séparer le statut et le nom du fichier si SUCCESS
            if current_status.startswith('SUCCESS:'):
                status, filename = current_status.split(':', 1)
                # Supprimer l'entrée après la première vérification de succès pour nettoyage
                del DOWNLOAD_STATUS[video_id] 
            elif current_status in ['PENDING', 'ERROR']:
                status = current_status
            
            if status == 'ERROR':
                # Supprimer l'entrée après la première vérification d'erreur
                del DOWNLOAD_STATUS[video_id] 

    # Renvoyer une réponse JSON simple
    return {'status': status, 'filename': filename}

# ==============================================================
# NOUVEAU MODULE : GESTION DES MP3 TÉLÉCHARGÉS
# ==============================================================

# NOTE: Assurez-vous d'avoir défini MP3_FOLDER_CATALOG plus haut dans le script
# (e.g., MP3_FOLDER_CATALOG = os.path.join('', "../noel2025_prod/mp3_catalog"))

def list_mp3_files():
    """
    Liste les fichiers MP3 dans les dossiers MP3_FOLDER et MP3_FOLDER_CATALOG.
    Retourne une liste de dictionnaires avec nom, taille, et un indicateur d'origine.
    """
    mp3_list = []
    
    # Définir les dossiers à scanner avec un indicateur pour l'origine
    # Le chemin est absolu pour garantir la sécurité lors de la suppression
    target_folders = [
        {'path': MP3_FOLDER, 'is_catalog': False, 'label': 'Téléchargé'},
        {'path': MP3_FOLDER_CATALOG, 'is_catalog': True, 'label': 'Catalogue'}
    ]

    for folder_info in target_folders:
        folder_path = folder_info['path']
        label = folder_info['label']
        is_catalog = folder_info['is_catalog']
        
        if not os.path.exists(folder_path):
            continue

        for filename in os.listdir(folder_path):
            if filename.lower().endswith('.mp3'):
                filepath = os.path.join(folder_path, filename)
                try:
                    size_bytes = os.path.getsize(filepath)
                    # Convertir en Mo (pour l'affichage)
                    size_mb = size_bytes / (1024 * 1024)
                    
                    mp3_list.append({
                        'name': filename,
                        'size_mb': f"{size_mb:.2f} Mo",
                        # Ajout d'un champ pour identifier le dossier source
                        'source_folder': folder_path, 
                        'source_label': label,
                        'is_catalog': is_catalog
                    })
                except Exception as e:
                    print(f"Erreur de lecture de la taille pour {filename} ({label}): {e}")

    # Tri par nom (implicitement chronologique grâce au format AAAAmmjj_hhmmss)
    # Les fichiers du catalogue peuvent ne pas avoir ce format, le tri reste alphabétique.
    mp3_list.sort(key=lambda x: x['name'], reverse=True) 
    return mp3_list

@app.route('/mp3_manager', methods=['GET', 'POST'])
def mp3_manager():
    """
    Affiche la liste des MP3 téléchargés et gère la suppression.
    """
    # Chemins absolus des dossiers MP3 pour la vérification de sécurité
    ABSOLUTE_MP3_FOLDER = os.path.abspath(MP3_FOLDER)
    # AJOUTER LE NOUVEAU CHEMIN ABSOLU
    ABSOLUTE_MP3_CATALOG_FOLDER = os.path.abspath(MP3_FOLDER_CATALOG)
    
    # Mettre tous les dossiers autorisés dans un ensemble pour une vérification rapide
    ALLOWED_FOLDERS = {ABSOLUTE_MP3_FOLDER, ABSOLUTE_MP3_CATALOG_FOLDER}

    if request.method == 'POST':
        # Gérer la suppression
        # On reçoit maintenant une liste de "nom_fichier|chemin_du_dossier"
        files_to_delete_with_path = request.form.getlist('delete_file_with_path')
        
        if not files_to_delete_with_path:
            flash("❌ Veuillez sélectionner au moins un fichier à supprimer.", 'error')
            return redirect(url_for('mp3_manager'))

        deleted_count = 0
        for item in files_to_delete_with_path:
            # Séparer le nom du fichier du chemin du dossier
            try:
                # La division se fait sur le dernier "|" au cas où le nom du fichier en contiendrait un
                filename, folder_to_delete = item.rsplit('|', 1) 
            except ValueError:
                flash(f"⚠️ Format de suppression invalide pour: '{item}'.", 'warning')
                continue

            # Construction des chemins
            filepath = os.path.join(folder_to_delete, filename)
            absolute_filepath = os.path.abspath(filepath) 
            absolute_folder_to_delete = os.path.abspath(folder_to_delete)

            # Mesure de sécurité corrigée:
            # 1. Vérifier si le chemin absolu du dossier est un des dossiers autorisés
            # 2. Vérifier si le chemin absolu du fichier COMMENCE par le chemin absolu du dossier
            if absolute_folder_to_delete in ALLOWED_FOLDERS and absolute_filepath.startswith(absolute_folder_to_delete):
                if os.path.exists(filepath):
                    try:
                        os.remove(filepath)
                        deleted_count += 1
                    except Exception as e:
                        flash(f"❌ Erreur lors de la suppression de '{filename}' dans '{folder_to_delete}': {e}", 'error')
                else:
                    # Le fichier n'existe plus (suppression concurrente ?)
                    continue
            else:
                flash(f"⚠️ Tentative de suppression non autorisée dans le chemin: '{folder_to_delete}'.", 'warning')

        if deleted_count > 0:
            flash(f"✅ {deleted_count} fichier(s) MP3 supprimé(s) avec succès.", 'success')
        
        return redirect(url_for('mp3_manager'))

    # Afficher la liste des fichiers
    mp3_files = list_mp3_files()
    return render_template('mp3_manager.html', mp3_files=mp3_files)


# ==============================================================================
# 🚀 POINT D’ENTRÉE
# ==============================================================================

if __name__ == '__main__':
    # On ajoute MP3_FOLDER_CATALOG à la liste
    for folder in [UPLOAD_FOLDER, ARCHIVE_FOLDER, PERMANENT_FOLDER, THUMBNAIL_FOLDER, MP3_FOLDER, MP3_FOLDER_CATALOG]:
        if not os.path.exists(folder):
            os.makedirs(folder)
            print(f"📁 Dossier '{folder}' créé.")

    display_controller = ImageDisplayController()

    while not hasattr(display_controller, 'tk_root'):
        time.sleep(0.2)

    display_permanent_photos(display_controller)

    threading.Thread(target=process_photos_task, args=(display_controller,), daemon=True).start()
    threading.Thread(target=scheduled_capture_task, daemon=True).start()

    print("🚀 Démarrage du serveur Flask sur http://0.0.0.0:5000")
    app.run(debug=False, host='0.0.0.0', port=5000)

Serveur de Médias Interactif

Published by geo on 5 novembre 20255 novembre 2025

I. 🎄 Présentation Générale du Projet

II. 🧩 Architecture Technique et Organisation des Fichiers

1. Structure des Scripts

2. Organisation des Dossiers (Définis dans `serveur_15.py`)

III. ⚙️ Fonctionnalités du Serveur (`serveur_15.py`)

1. Contrôle d’Affichage Multithreadé (Tkinter)

2. Gestion et Traitement des Photos (Tâches de Fond)

3. Gestion Audio (Module YouTube MP3)

4. Gestion des MP3 Téléchargés

IV. 🚀 Utilitaire QR Code (`gen_qr.py`)

1. Connexion Dynamique

2. Personnalisation Visuelle

V. Synthèse et Perspectives d’Évolution du Projet

🌟 Conclusion : Un Système Multimédia Robuste et Engageant

📈 Perspectives d’Amélioration et Pistes d’Évolution

1. Amélioration de la Robustesse et de la Performance

2. Amélioration de l’Expérience Utilisateur (UX)

3. Modularité et Déploiement

Source gen_qr.py

0 commentaire

Laisser un commentaire Annuler la réponse

Audio Downloader Pro

Flux de Production Karaoké Haute Fidélité

Project Zipper (Partenaire de Code)

Serveur de Médias Interactif

Published by geo on 5 novembre 20255 novembre 2025

I. 🎄 Présentation Générale du Projet

II. 🧩 Architecture Technique et Organisation des Fichiers

1. Structure des Scripts

2. Organisation des Dossiers (Définis dans serveur_15.py)

III. ⚙️ Fonctionnalités du Serveur (serveur_15.py)

1. Contrôle d’Affichage Multithreadé (Tkinter)

2. Gestion et Traitement des Photos (Tâches de Fond)

3. Gestion Audio (Module YouTube MP3)

4. Gestion des MP3 Téléchargés

IV. 🚀 Utilitaire QR Code (gen_qr.py)

1. Connexion Dynamique

2. Personnalisation Visuelle

V. Synthèse et Perspectives d’Évolution du Projet

🌟 Conclusion : Un Système Multimédia Robuste et Engageant

📈 Perspectives d’Amélioration et Pistes d’Évolution

1. Amélioration de la Robustesse et de la Performance

2. Amélioration de l’Expérience Utilisateur (UX)

3. Modularité et Déploiement

Source gen_qr.py

0 commentaire

Laisser un commentaire Annuler la réponse

Articles similaires

Audio Downloader Pro

Flux de Production Karaoké Haute Fidélité

Project Zipper (Partenaire de Code)

2. Organisation des Dossiers (Définis dans `serveur_15.py`)

III. ⚙️ Fonctionnalités du Serveur (`serveur_15.py`)

IV. 🚀 Utilitaire QR Code (`gen_qr.py`)