Upload 5 files

Dockerfile

@@ -0,0 +1,55 @@
+# ÉTAPE 1: Image de base
+FROM python:3.11-slim
+
+# ÉTAPE 2: Configuration et Dossier de travail
+# Ligne supprimée (ENV PORT 8080) pour laisser Hugging Face Spaces injecter le port correct ($PORT, généralement 7860).
+ENV FLASK_APP app.py
+ENV GUNICORN_WORKERS 4
+ENV GUNICORN_THREADS 2
+
+# Création et utilisation du répertoire /app
+WORKDIR /app
+
+# ÉTAPE 3: Installation des dépendances (OPTIMISATION CACHING)
+# Copie uniquement de requirements.txt pour mettre en cache l'installation
+COPY requirements.txt .
+
+# Installation des dépendances du système (eSpeak) et Python
+RUN apt-get update && \
+    apt-get install -y espeak libespeak1 && \
+    pip install --no-cache-dir -r requirements.txt \
+    && rm requirements.txt
+
+# ÉTAPE 4: Copie de l'Application et des Fichiers
+# Nous copions tous les fichiers de l'application et nous assurons que
+# l'utilisateur 'user' en est le propriétaire.
+
+# CORRECTION MAJEURE : Ajout du dossier templates
+# Ceci est l'étape essentielle pour que Flask trouve vos fichiers HTML
+COPY templates /app/templates
+
+# Copie des autres fichiers (y compris app.py, votre point d'entrée)
+COPY app.py .
+COPY tts_engine.py .
+
+# Copie du script d'entrée
+COPY entrypoint.sh .
+
+# NOUVEAU: CORRECTION DES FINS DE LIGNE (Résout 'exec ./entrypoint.sh: no such file or directory')
+# Supprime le caractère de retour chariot (\r)
+RUN sed -i 's/\r$//' entrypoint.sh
+
+# Le rendre exécutable
+RUN chmod +x entrypoint.sh
+
+# ÉTAPE 5: Sécurité et Exécution
+# Création et bascule vers l'utilisateur non-root ('user') pour la sécurité
+RUN useradd -ms /bin/bash user
+RUN chown -R user:user /app
+USER user
+
+# Indique à Docker que le conteneur écoute sur ce port
+EXPOSE $PORT
+
+# Lance l'application via le script d'entrée
+CMD ["./entrypoint.sh"]

app.py

@@ -0,0 +1,81 @@
+# app.py
+from flask import Flask, render_template, request, send_file, redirect, url_for
+from werkzeug.utils import secure_filename
+from tts_engine import get_available_languages, text_to_audio_file
+import os
+import io
+import tempfile
+# Note: Nous allons ignorer les autres imports inutilisés (config, auth, etc.) du Dockerfile pour simplifier.
+
+app = Flask(__name__)
+
+# Configuration simple pour l'upload
+UPLOAD_FOLDER = 'uploads'
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # Limite 16MB
+
+# Fichier temporaire pour l'audio généré
+TEMP_AUDIO_FILE = "tts_output.wav"
+
+@app.route('/', methods=['GET'])
+def index():
+    """Route principale: Affiche le formulaire et la liste des langues."""
+    # Récupérer les langues pour le menu déroulant
+    languages = get_available_languages()
+    
+    # Afficher la template HTML
+    return render_template('index.html', languages=languages)
+
+@app.route('/read', methods=['POST'])
+def read_text():
+    """Route de traitement: Reçoit le texte/fichier et la langue, génère l'audio."""
+    
+    # 1. Récupération des données
+    text_input = request.form.get('text_input', '').strip()
+    voice_id = request.form.get('language_select')
+    uploaded_file = request.files.get('file_input')
+    
+    text_to_speak = ""
+    
+    # 2. Logique de lecture de fichier/texte
+    if uploaded_file and uploaded_file.filename != '':
+        filename = secure_filename(uploaded_file.filename)
+        # Gestion simple pour les fichiers .txt uniquement pour l'instant
+        if filename.endswith('.txt'):
+            try:
+                # Lecture du contenu du fichier
+                text_to_speak = uploaded_file.read().decode('utf-8')
+            except Exception as e:
+                return f"Erreur de lecture du fichier: {e}", 400
+        else:
+            # Le PDF nécessiterait l'installation de PyPDF2 et un traitement plus complexe.
+            return "Type de fichier non supporté. Veuillez utiliser un fichier .txt.", 400
+            
+    elif text_input:
+        text_to_speak = text_input
+    
+    if not text_to_speak:
+        return "Veuillez entrer du texte ou télécharger un fichier.", 400
+    
+    if not voice_id:
+        # Fallback au cas où aucune voix n'est sélectionnée (devrait être géré par l'interface)
+        voices = get_available_languages()
+        voice_id = next(iter(voices.values()), None)
+
+    # 3. Génération du fichier audio
+    try:
+        # Utiliser un fichier temporaire unique dans le conteneur
+        temp_dir = tempfile.gettempdir()
+        audio_path = os.path.join(temp_dir, TEMP_AUDIO_FILE)
+        
+        text_to_audio_file(text_to_speak, voice_id, audio_path)
+        
+        # 4. Envoi du fichier audio au client
+        # Flask envoie le fichier et le supprime après (mieux que de le garder sur le disque)
+        return send_file(audio_path, mimetype="audio/wav", as_attachment=False)
+        
+    except Exception as e:
+        print(f"Erreur lors de la synthèse vocale: {e}")
+        return f"Erreur lors de la génération de l'audio: {e}", 500
+

entrypoint.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+# entrypoint.sh
+
+# ... (Afficher les commandes exécutées, set -e, etc.)
+
+echo "--- Démarrage de l'Application Gunicorn (Base de Données Baserow) ---"
+
+# Définir le port par défaut de Hugging Face si $PORT est vide
+export APP_PORT=${PORT:-7860} 
+
+# 1. Démarrer le serveur Flask/Gunicorn en premier plan
+echo "Démarrage du serveur Gunicorn sur le port $APP_PORT avec Eventlet..."
+
+# MODIFICATION MAJEURE: Utiliser le worker 'eventlet' pour supporter SocketIO (WebSockets)
+# Nous pointons toujours vers app:app, mais Gunicorn utilise le worker Eventlet
+# qui enveloppera l'application Flask et SocketIO.
+exec gunicorn --workers 1 --worker-class eventlet app:app -b 0.0.0.0:$APP_PORT
+# Note sur les workers: Eventlet et Gevent sont monocœurs, donc on met workers=1
+# ou on s'assure que le nombre de workers est bas pour éviter des conflits de PTY.

requirements.txt

@@ -0,0 +1,12 @@
+flask
+bcrypt
+requests
+gunicorn
+Flask-CORS
+python-dotenv
+stripe
+dnspython
+werkzeug
+flask-socketio
+eventlet
+pyttsx3

tts_engine.py

@@ -0,0 +1,70 @@
+# tts_engine.py
+import pyttsx3
+import os
+import io
+
+# Initialisation du moteur pyttsx3
+# Attention: L'initialisation du moteur est lente. Il est préférable de le faire une seule fois.
+_engine = None
+
+def get_tts_engine():
+    """Initialise et retourne le moteur pyttsx3."""
+    global _engine
+    if _engine is None:
+        try:
+            # Utilise 'espeak' comme moteur par défaut sur Linux (via Docker)
+            _engine = pyttsx3.init()
+            # Optimisation: Réglage des propriétés du moteur (optionnel)
+            _engine.setProperty('rate', 150) # Vitesse de lecture
+        except Exception as e:
+            print(f"Erreur d'initialisation pyttsx3: {e}")
+            _engine = None # S'assure qu'on ne garde pas une référence cassée
+    return _engine
+
+def get_available_languages():
+    """Récupère la liste des langues/voix disponibles."""
+    engine = get_tts_engine()
+    if not engine:
+        return {}
+    
+    voices = engine.getProperty('voices')
+    languages = {}
+    
+    # On essaie de mapper la voix eSpeak à un code de langue/nom
+    for voice in voices:
+        # L'ID de la voix eSpeak contient souvent le code de langue (ex: 'french', 'en-us')
+        voice_id = voice.id.split('+')[0].replace(' ', '').lower()
+        
+        if 'en' in voice_id or 'english' in voice.name.lower():
+            languages['English'] = voice.id
+        elif 'fr' in voice_id or 'french' in voice.name.lower():
+            languages['Français'] = voice.id
+        elif 'es' in voice_id or 'spanish' in voice.name.lower():
+            languages['Español'] = voice.id
+        
+        # Ajout d'une entrée par défaut pour chaque voix, si non déjà mappée
+        if voice.name not in languages and voice.name != 'default':
+            languages[voice.name] = voice.id
+
+    # S'assurer d'avoir au moins une option si le mapping est faible
+    if not languages and voices:
+         languages['Default'] = voices[0].id
+         
+    return languages
+
+def text_to_audio_file(text, voice_id, output_path="output.wav"):
+    """Convertit le texte en fichier audio avec la voix spécifiée."""
+    engine = get_tts_engine()
+    if not engine:
+        raise Exception("Moteur TTS non initialisé.")
+
+    # 1. Sélection de la voix
+    engine.setProperty('voice', voice_id)
+
+    # 2. Sauvegarde du fichier
+    engine.save_to_file(text, output_path)
+    engine.runAndWait()
+
+    # NOTE: eSpeak génère par défaut un fichier .wav.
+    return os.path.abspath(output_path)
+