Upload 2 files

app.py

@@ -1,277 +1,248 @@
 import os
+import asyncio
+import wave
+import tempfile
 import logging
-import base64
 import json
-import uuid
-import google.generativeai as genai
-from datetime import datetime
-from functools import wraps
-from flask import Flask, render_template, request, jsonify, session, redirect
-from dotenv import load_dotenv
-from werkzeug.utils import secure_filename
+import time
+from flask import Flask, render_template, request, jsonify, send_file, stream_with_context, Response
+from google import genai
+import aiohttp
+from pydub import AudioSegment
 
 # Configure logging
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 
-# Load environment variables
-load_dotenv()
+app = Flask(__name__)
+app.secret_key = os.environ.get("SESSION_SECRET", "default-secret-key")
 
-# Configure Google Gemini API
+# Configure Gemini API
 api_key = os.environ.get("GEMINI_API_KEY")
 if not api_key:
-    logger.warning("GEMINI_API_KEY not found in environment variables")
-else:
-    logger.info("GEMINI_API_KEY found. API configured successfully.")
-
-genai.configure(api_key=api_key)
+    logger.warning("GEMINI_API_KEY not found in environment variables. Using default value for development.")
+    api_key = "YOUR_API_KEY"  # This will be replaced with env var in production
 
-# Initialize Flask app
-app = Flask(__name__)
-app.secret_key = os.environ.get("SESSION_SECRET", "default-dev-secret-key")
-app.config['UPLOAD_FOLDER'] = 'static/uploads'
-app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024  # 10 MB max
+# Define available voices
+AVAILABLE_VOICES = [
+    "Puck", "Charon", "Kore", "Fenrir", 
+    "Aoede", "Leda", "Orus", "Zephyr"
+]
+language_code="fr-FR"
 
-# Middleware to ensure user has a session_id
-def session_required(f):
-    @wraps(f)
-    def decorated_function(*args, **kwargs):
-        if 'session_id' not in session:
-            session['session_id'] = str(uuid.uuid4())
-            logger.info(f"Created new session: {session['session_id']}")
-        return f(*args, **kwargs)
-    return decorated_function
+# Global variable to track generation progress
+generation_progress = {
+    "status": "idle",
+    "current": 0,
+    "total": 0,
+    "message": ""
+}
 
-# Ensure upload directory exists
-os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-
-# Configure Gemini model with specific parameters for better responses
-model = genai.GenerativeModel(
-    model_name='gemini-2.0-flash',
-    generation_config={
-        'temperature': 0.7,  # Slightly creative but still focused
-        'top_p': 0.9,        # Diverse output but not too random
-        'top_k': 40,         # Reasonable range of tokens to consider
-        'max_output_tokens': 2048  # Allow longer responses
+def update_progress(current, total, message):
+    """Update the global progress tracker."""
+    global generation_progress
+    generation_progress = {
+        "status": "in_progress" if current < total else "complete",
+        "current": current,
+        "total": total,
+        "message": message
     }
-)
+def create_async_enumerate(async_iterator):
+    """Create an async enumerate function since it's not built-in."""
+    i = 0
+    async def async_iter():
+        nonlocal i
+        async for item in async_iterator:
+            yield i, item
+            i += 1
+    return async_iter()
 
-# Configure Gemini vision model for image processing
-vision_model = genai.GenerativeModel('gemini-2.0-vision-flash')
+async def generate_speech(text, selected_voice):
+    """Generate speech from text using Gemini AI."""
+    try:
+        client = genai.Client(api_key=api_key)
+        model = "gemini-2.0-flash-live-001"
+        
+        # Configure the voice settings
+        speech_config = genai.types.SpeechConfig(
+            language_code=language_code,
+            voice_config=genai.types.VoiceConfig(
+                prebuilt_voice_config=genai.types.PrebuiltVoiceConfig(
+                    voice_name=selected_voice
+                )
+            )
+        )
+        
+        config = genai.types.LiveConnectConfig(
+            response_modalities=["AUDIO"],
+            speech_config=speech_config
+        )
+        
+        # Create a temporary file to store the audio
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
+            temp_filename = tmp_file.name
+            
+            async with client.aio.live.connect(model=model, config=config) as session:
+                # Open the WAV file for writing
+                wf = wave.open(temp_filename, "wb")
+                wf.setnchannels(1)
+                wf.setsampwidth(2)
+                wf.setframerate(24000)
+                
+                # Send the text to Gemini
+                await session.send_client_content(
+                    turns={"role": "user", "parts": [{"text": text}]}, 
+                    turn_complete=True
+                )
+                
+                # Receive the audio data and write it to the file
+                async for idx, response in create_async_enumerate(session.receive()):
+                    if response.data is not None:
+                        wf.writeframes(response.data)
+                
+                wf.close()
+            
+            return temp_filename
+    
+    except Exception as e:
+        logger.error(f"Error generating speech: {str(e)}")
+        raise e
 
 @app.route('/')
-@session_required
 def index():
-    """Render the chat interface."""
-    return render_template('index.html')
+    """Render the main page."""
+    return render_template('index.html', voices=AVAILABLE_VOICES)
 
-@app.route('/api/chat', methods=['POST'])
-@session_required
-def chat():
-    """Process chat messages and get responses from Gemini API."""
+@app.route('/generate', methods=['POST'])
+async def generate():
+    """Generate speech from text."""
     try:
         data = request.json
-        user_message = data.get('message', '')
-        chat_history = data.get('history', [])
-        image_data = data.get('image', None)
+        text = data.get('text', '')
+        voice = data.get('voice', 'Kore')  # Default voice
         
-        if not user_message and not image_data:
-            return jsonify({'error': 'Veuillez entrer un message ou joindre une image.'}), 400
+        if not text:
+            return jsonify({"error": "Text is required"}), 400
         
-        # Log the incoming request (but not full chat history for privacy)
-        session_id = session.get('session_id')
-        logger.info(f"Received chat request from session {session_id}. Message length: {len(user_message)}")
+        if voice not in AVAILABLE_VOICES:
+            return jsonify({"error": "Invalid voice selection"}), 400
         
-        # Format conversation history for context
-        formatted_history = []
-        for msg in chat_history[-15:]:  # Use the last 15 messages for more context
-            role = "user" if msg['sender'] == 'user' else "model"
-            formatted_history.append({"role": role, "parts": [msg['text']]})
+        # Generate the speech
+        audio_file = await generate_speech(text, voice)
         
-        # Handle image processing if images are included
-        if image_data:
-            try:
-                parts = []
-                
-                # Process single image or multiple images
-                if isinstance(image_data, list):
-                    # Handle multiple images
-                    for img in image_data:
-                        if isinstance(img, str) and ',' in img:
-                            # Extract the base64 part after the comma
-                            image_base64 = img.split(',')[1]
-                            # Create image part
-                            image = genai.types.Part.from_data(
-                                data=base64.b64decode(image_base64),
-                                mime_type="image/jpeg"
-                            )
-                            parts.append(image)
-                            
-                            # Save each image
-                            session_id = session.get('session_id')
-                            session_dir = os.path.join(app.config['UPLOAD_FOLDER'], session_id)
-                            os.makedirs(session_dir, exist_ok=True)
-                            
-                            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-                            filename = secure_filename(f"image_{timestamp}_{len(parts)}.jpg")
-                            filepath = os.path.join(session_dir, filename)
-                            with open(filepath, "wb") as f:
-                                f.write(base64.b64decode(image_base64))
-                else:
-                    # Handle single image
-                    image_base64 = image_data.split(',')[1]
-                    image = genai.types.Part.from_data(
-                        data=base64.b64decode(image_base64),
-                        mime_type="image/jpeg"
-                    )
-                    parts.append(image)
-                    
-                    # Save image with timestamp in the session directory
-                    session_id = session.get('session_id')
-                    session_dir = os.path.join(app.config['UPLOAD_FOLDER'], session_id)
-                    os.makedirs(session_dir, exist_ok=True)
-                    
-                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-                    filename = secure_filename(f"image_{timestamp}.jpg")
-                    filepath = os.path.join(session_dir, filename)
-                    with open(filepath, "wb") as f:
-                        f.write(base64.b64decode(image_base64))
-                
-                # Add text message if provided
-                if user_message:
-                    parts.append(user_message)
-                
-                # Generate response using vision model
-                response = vision_model.generate_content(parts)
-                return jsonify({'response': response.text})
-            
-            except Exception as img_error:
-                logger.error(f"Error processing image: {str(img_error)}")
-                return jsonify({
-                    'error': 'Désolé, une erreur est survenue lors du traitement de l\'image. Veuillez réessayer.'
-                }), 500
-        else:
-            # Text-only processing
-            # Create a chat session with history
-            chat = model.start_chat(history=formatted_history)
-            
-            # Generate response
-            response = chat.send_message(user_message)
-            
-            # Log successful response
-            logger.info(f"Generated response successfully. Response length: {len(response.text)}")
-            
-            # Return the response
-            return jsonify({'response': response.text})
-    
-    except genai.types.generation_types.BlockedPromptException as be:
-        logger.warning(f"Content blocked: {str(be)}")
         return jsonify({
-            'error': 'Votre message ou la conversation ne peut pas être traitée car elle contient du contenu potentiellement inapproprié.'
-        }), 400
-        
+            "status": "success",
+            "message": "Audio generated successfully",
+            "audioUrl": f"/audio/{os.path.basename(audio_file)}"
+        })
+    
     except Exception as e:
-        logger.error(f"Error in chat endpoint: {str(e)}")
-        return jsonify({
-            'error': 'Désolé, j\'ai rencontré une erreur lors du traitement de votre demande. Veuillez réessayer.'
-        }), 500
+        logger.error(f"Error in generate endpoint: {str(e)}")
+        return jsonify({"error": str(e)}), 500
 
-@app.route('/api/save-chat', methods=['POST'])
-@session_required
-def save_chat():
-    """Save the current chat history."""
+@app.route('/audio/<filename>')
+def get_audio(filename):
+    """Serve the generated audio file."""
     try:
-        session_id = session.get('session_id')
-        
-        # Create session-specific directory
-        session_dir = os.path.join(app.config['UPLOAD_FOLDER'], session_id)
-        os.makedirs(session_dir, exist_ok=True)
-        
-        data = request.json
-        chat_history = data.get('history', [])
-        
-        if not chat_history:
-            return jsonify({'error': 'Aucune conversation à sauvegarder.'}), 400
-        
-        # Generate filename with timestamp
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"chat_{timestamp}.json"
-        filepath = os.path.join(session_dir, filename)
+        temp_dir = tempfile.gettempdir()
+        file_path = os.path.join(temp_dir, filename)
         
-        # Save chat history to file
-        with open(filepath, 'w', encoding='utf-8') as f:
-            json.dump(chat_history, f, ensure_ascii=False, indent=2)
+        if not os.path.exists(file_path):
+            return jsonify({"error": "Audio file not found"}), 404
         
-        return jsonify({'success': True, 'filename': filename})
+        return send_file(file_path, mimetype="audio/wav", as_attachment=False)
     
     except Exception as e:
-        logger.error(f"Error saving chat: {str(e)}")
-        return jsonify({
-            'error': 'Désolé, une erreur est survenue lors de la sauvegarde de la conversation.'
-        }), 500
+        logger.error(f"Error serving audio file: {str(e)}")
+        return jsonify({"error": str(e)}), 500
 
-@app.route('/api/load-chats', methods=['GET'])
-@session_required
-def load_chats():
-    """Get a list of saved chat files for current session."""
+@app.route('/generate-podcast', methods=['POST'])
+async def generate_podcast_route():
+    """Generate a podcast from a scenario."""
     try:
-        session_id = session.get('session_id')
+        scenario = request.json
+        
+        # Reset progress tracker
+        global generation_progress
+        generation_progress = {
+            "status": "in_progress",
+            "current": 0,
+            "total": len(scenario.get('characters', [])),
+            "message": "Démarrage de la génération..."
+        }
+        
+        # Generate audio for each character
+        characters = scenario.get('characters', [])
+        total_characters = len(characters)
+        update_progress(0, total_characters, f"Préparation du podcast avec {total_characters} personnages...")
+        
+        audio_segments = []
+        
+        for idx, character in enumerate(characters):
+            character_name = character.get('name', 'Unknown')
+            voice = character.get('voice', 'Kore')
+            text = character.get('text', '')
+            
+            update_progress(idx, total_characters, f"Génération de l'audio pour {character_name} ({idx+1}/{total_characters})...")
+            
+            if voice not in AVAILABLE_VOICES:
+                logger.warning(f"Voice {voice} not available. Using default voice Kore for {character_name}.")
+                voice = 'Kore'
+            
+            # Generate speech for this character
+            audio_file = await generate_speech(text, voice)
+            audio_segments.append(audio_file)
+        
+        update_progress(total_characters, total_characters, "Assemblage des segments audio...")
         
-        # Get session-specific directory
-        session_dir = os.path.join(app.config['UPLOAD_FOLDER'], session_id)
+        # Combine all audio segments into one file
+        combined = AudioSegment.empty()
         
-        # If the directory doesn't exist yet, return empty list
-        if not os.path.exists(session_dir):
-            return jsonify({'chats': []})
+        for audio_file in audio_segments:
+            segment = AudioSegment.from_wav(audio_file)
+            combined += segment
+            # Add a short silence between segments (500ms)
+            combined += AudioSegment.silent(duration=500)
         
-        chat_files = []
-        for filename in os.listdir(session_dir):
-            if filename.startswith('chat_') and filename.endswith('.json'):
-                # Extract timestamp from filename
-                timestamp = filename[5:-5]  # Remove 'chat_' and '.json'
-                # Add to list
-                chat_files.append({
-                    'filename': filename,
-                    'timestamp': timestamp
-                })
+        # Export the combined audio
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as output_file:
+            output_filename = output_file.name
+            combined.export(output_filename, format="wav")
         
-        # Sort by timestamp (newest first)
-        chat_files.sort(key=lambda x: x['timestamp'], reverse=True)
+        update_progress(total_characters + 1, total_characters + 1, "Podcast généré avec succès!")
         
-        logger.info(f"Loaded {len(chat_files)} chats for session {session_id}")
-        return jsonify({'chats': chat_files})
+        return jsonify({
+            "status": "success",
+            "message": "Podcast generated successfully",
+            "audioUrl": f"/audio/{os.path.basename(output_filename)}"
+        })
     
     except Exception as e:
-        logger.error(f"Error loading chat list: {str(e)}")
-        return jsonify({
-            'error': 'Désolé, une erreur est survenue lors du chargement des conversations.'
-        }), 500
+        logger.error(f"Error in generate-podcast endpoint: {str(e)}")
+        update_progress(0, 0, f"Erreur: {str(e)}")
+        return jsonify({"error": str(e)}), 500
 
-@app.route('/api/load-chat/<filename>', methods=['GET'])
-@session_required
-def load_chat(filename):
-    """Load a specific chat history file."""
+@app.route('/generation-progress')
+def get_generation_progress():
+    """Get the current progress of podcast generation."""
+    return jsonify(generation_progress)
+
+@app.route('/download/<filename>')
+def download_audio(filename):
+    """Download the generated audio file."""
     try:
-        session_id = session.get('session_id')
-        
-        # Load from session-specific directory
-        session_dir = os.path.join(app.config['UPLOAD_FOLDER'], session_id)
-        filepath = os.path.join(session_dir, secure_filename(filename))
+        temp_dir = tempfile.gettempdir()
+        file_path = os.path.join(temp_dir, filename)
         
-        if not os.path.exists(filepath):
-            return jsonify({'error': 'Conversation introuvable.'}), 404
+        if not os.path.exists(file_path):
+            return jsonify({"error": "Audio file not found"}), 404
         
-        with open(filepath, 'r', encoding='utf-8') as f:
-            chat_history = json.load(f)
+        # Check if this is a podcast or simple speech
+        download_name = "gemini_podcast.wav"
         
-        logger.info(f"Loaded chat {filename} for session {session_id}")
-        return jsonify({'history': chat_history})
+        return send_file(file_path, mimetype="audio/wav", as_attachment=True, 
+                         download_name=download_name)
     
     except Exception as e:
-        logger.error(f"Error loading chat file: {str(e)}")
-        return jsonify({
-            'error': 'Désolé, une erreur est survenue lors du chargement de la conversation.'
-        }), 500
-
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=5000, debug=True)
+        logger.error(f"Error downloading audio file: {str(e)}")
+        return jsonify({"error": str(e)}), 500

main.py

@@ -1,4 +1,4 @@
-from app import app  # noqa: F401
+from app import app
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=5000, debug=True)