first commit

.dockerignore

@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Git
+.git
+.gitignore
+
+# Tests
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# Local development
+docker-compose.yml
+docker-compose.*.yml
+README.md

.gitignore

@@ -0,0 +1,67 @@
+# Environnements virtuels
+venv/
+env/
+ENV/
+.env
+.venv
+env.bak/
+venv.bak/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Fichiers de test et coverage
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# IDEs et éditeurs
+.idea/
+.vscode/
+*.swp
+*.swo
+.project
+.pydevproject
+.settings
+*.sublime-workspace
+*.sublime-project
+
+# Notebooks Jupyter
+.ipynb_checkpoints
+*/.ipynb_checkpoints/*
+
+# Logs et bases de données
+*.log
+*.sqlite
+*.db
+
+# Fichiers système
+.DS_Store
+Thumbs.db
+*.mp4

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.9-slim
+
+WORKDIR /code
+
+# Copier les fichiers de requirements
+COPY requirements.txt .
+
+# Installer les dépendances
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copier le code de l'application
+COPY . .
+
+# Exposer le port
+EXPOSE 7860
+
+# Commande pour démarrer l'application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"] 

app/api/routes/routes.py

@@ -0,0 +1,107 @@
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+from app.services.video_service import VideoService
+from fastapi import APIRouter, HTTPException
+from app.services.quiz_generator import QuizGenerator
+from app.models.quiz import QuizRequest
+from app.core.config import settings
+import logging
+import uuid
+
+# Configurer le logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Importons le quiz de test
+TEST_QUIZ = {
+    "id": "test-quiz",
+    "theme": "Intelligence Artificielle",
+    "questions": [
+        {
+            "question": "Qu'est-ce que le Machine Learning ?",
+            "options": [
+                "Un type de robot",
+                "Une branche de l'IA permettant aux machines d'apprendre",
+                "Un langage de programmation",
+                "Un système d'exploitation"
+            ],
+            "correct_answer": "Une branche de l'IA permettant aux machines d'apprendre"
+        },
+        {
+            "question": "Qu'est-ce qu'un réseau de neurones ?",
+            "options": [
+                "Un système inspiré du cerveau humain",
+                "Un réseau social",
+                "Un câble ethernet",
+                "Un type de processeur"
+            ],
+            "correct_answer": "Un système inspiré du cerveau humain"
+        },
+        {
+            "question": "Quel est le langage le plus utilisé en IA ?",
+            "options": [
+                "Java",
+                "C++",
+                "Python",
+                "JavaScript"
+            ],
+            "correct_answer": "Python"
+        }
+    ]
+}
+
+
+router = APIRouter()
+router = APIRouter()
+quiz_generator = QuizGenerator(provider=settings.AI_PROVIDER)
+
+@router.post("/quiz")
+async def create_quiz(request: QuizRequest):
+    try:
+        questions = await quiz_generator.generate_quiz(
+            theme=request.theme,
+            num_questions=request.num_questions
+        )
+        # Créer un ID unique pour le quiz
+        quiz_id = f"quiz_{uuid.uuid4().hex[:8]}"
+        
+        quiz_data = {
+            "id": quiz_id,
+            "theme": request.theme,
+            "questions": [
+                {
+                    "question": q.question,
+                    "options": q.options,
+                    "correct_answer": q.correct_answer
+                } for q in questions
+            ]
+        }
+        
+        return quiz_data
+    except Exception as e:
+        logger.error(f"Erreur dans create_quiz: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+    
+
+@router.post("/quiz/{quiz_id}/video")
+async def generate_video(quiz_id: str, quiz_data: dict):
+    try:
+        logger.info(f"Début de la génération de vidéo pour le quiz {quiz_id}")
+        logger.debug(f"Données du quiz reçues: {quiz_data}")
+        
+        # Vérifier que les données nécessaires sont présentes
+        if not quiz_data.get("questions") or quiz_data.get("styleConfig") is None:
+            raise HTTPException(status_code=400, detail="Données du quiz ou style manquants")
+        
+        # Utiliser directement les données reçues
+        video_path = await VideoService.generate_quiz_video(quiz_data)
+        logger.info(f"Vidéo générée avec succès: {video_path}")
+        
+        return FileResponse(
+            path=video_path,
+            media_type="video/mp4",
+            filename=f"quiz_{quiz_id}.mp4"
+        )
+    except Exception as e:
+        logger.error(f"Erreur lors de la génération de la vidéo: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))

app/api/routes/stripe_routes.py

@@ -0,0 +1,135 @@
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import JSONResponse
+import stripe
+from app.core.config import settings
+from pydantic import BaseModel
+
+router = APIRouter()
+stripe.api_key = settings.STRIPE_SECRET_KEY
+
+# Utilisation des variables d'environnement pour les price IDs
+STRIPE_PRICE_IDS = {
+    'starter': settings.STRIPE_PRICE_ID_STARTER,
+    'pro': settings.STRIPE_PRICE_ID_PRO,
+    'business': settings.STRIPE_PRICE_ID_BUSINESS
+}
+
+class SubscriptionRequest(BaseModel):
+    plan_id: str
+    user_id: str
+
+class PaymentSuccessRequest(BaseModel):
+    session_id: str
+
+@router.post("/create-subscription")
+async def create_subscription(request: SubscriptionRequest):
+    try:
+        price_id = STRIPE_PRICE_IDS.get(request.plan_id)
+        print(f"Plan ID reçu: {request.plan_id}")
+        print(f"Price ID trouvé: {price_id}")
+        print(f"Mode Stripe: {stripe.api_key.startswith('sk_test_') and 'TEST' or 'LIVE'}")
+        
+        if not price_id:
+            raise HTTPException(status_code=400, detail=f"Plan non trouvé: {request.plan_id}")
+
+        session = stripe.checkout.Session.create(
+            payment_method_types=['card'],
+            line_items=[{
+                'price': price_id,
+                'quantity': 1,
+            }],
+            mode='subscription',
+            success_url=f"{settings.FRONTEND_URL}/generate?session_id={{CHECKOUT_SESSION_ID}}",
+            cancel_url=f"{settings.FRONTEND_URL}/tokens",
+            metadata={
+                'user_id': request.user_id,
+                'plan_id': request.plan_id
+            }
+        )
+        return {"sessionId": session.id}
+    except Exception as e:
+        print(f"Erreur complète: {str(e)}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/webhook")
+async def stripe_webhook(request: Request):
+    payload = await request.body()
+    sig_header = request.headers.get("stripe-signature")
+    
+    try:
+        event = stripe.Webhook.construct_event(
+            payload, sig_header, settings.STRIPE_WEBHOOK_SECRET
+        )
+        
+        if event["type"] == "checkout.session.completed":
+            session = event["data"]["object"]
+            user_id = session["metadata"]["user_id"]
+            plan_id = session["metadata"]["plan_id"]
+            
+            # Au lieu de mettre à jour Firebase, on renvoie les informations
+            return {
+                "status": "success",
+                "user_id": user_id,
+                "plan_id": plan_id
+            }
+            
+        return {"status": "success"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/create-webhook")
+async def create_webhook_endpoint():
+    try:
+        endpoint = stripe.WebhookEndpoint.create(
+            url=f"{settings.FRONTEND_URL}/api/webhook",
+            enabled_events=[
+                "checkout.session.completed",
+                "customer.subscription.created",
+                "customer.subscription.deleted",
+                "invoice.paid",
+                "invoice.payment_failed"
+            ],
+            description="Endpoint pour la gestion des abonnements"
+        )
+        
+        # Sauvegarder la clé secrète dans les variables d'environnement
+        webhook_secret = endpoint.secret
+        return {
+            "status": "success",
+            "endpoint_id": endpoint.id,
+            "webhook_secret": webhook_secret  # À stocker dans .env
+        }
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/payment-success")
+async def handle_payment_success(request: PaymentSuccessRequest):
+    try:
+        print("=== Début du traitement payment-success ===")
+        print(f"Session ID reçu: {request.session_id}")
+        
+        session = stripe.checkout.Session.retrieve(request.session_id)
+        print(f"Status du paiement: {session.payment_status}")
+        print(f"Customer: {session.customer}")
+        print(f"Metadata complète: {session.metadata}")
+        
+        user_id = session.metadata.get('user_id')
+        plan_id = session.metadata.get('plan_id')
+        
+        if not user_id or not plan_id:
+            raise HTTPException(
+                status_code=400, 
+                detail="Metadata manquante: user_id ou plan_id non trouvé"
+            )
+        
+        print(f"User ID extrait: {user_id}")
+        print(f"Plan ID extrait: {plan_id}")
+        
+        return {
+            "status": "success",
+            "user_id": user_id,
+            "plan_id": plan_id
+        }
+    except Exception as e:
+        print(f"Erreur lors du traitement: {str(e)}")
+        raise HTTPException(status_code=400, detail=str(e))

app/core/config.py

@@ -0,0 +1,40 @@
+from pydantic_settings import BaseSettings
+from typing import Optional
+import os
+
+class Settings(BaseSettings):
+    # Configuration Firebase
+    FIREBASE_API_KEY: str
+    FIREBASE_AUTH_DOMAIN: str
+    FIREBASE_PROJECT_ID: str
+    FIREBASE_STORAGE_BUCKET: str
+    FIREBASE_MESSAGING_SENDER_ID: str
+    FIREBASE_APP_ID: str
+
+    # Configuration Stripe
+    STRIPE_SECRET_KEY: str
+    STRIPE_WEBHOOK_SECRET: str
+    STRIPE_PRICE_ID_STARTER: str = "price_1QmXNE2NCHU0qPWW3A8sEK6l"  # Remplacer par votre ID de prix test
+    STRIPE_PRICE_ID_PRO: str = "price_1QmXNE2NCHU0qPWW3A8sEK6l"         # Remplacer par votre ID de prix test
+    STRIPE_PRICE_ID_BUSINESS: str = "price_1QmXNE2NCHU0qPWW3A8sEK6l" # Remplacer par votre ID de prix test
+
+    # Configuration générale
+    FRONTEND_URL: str = "http://localhost:8080"  # URL du frontend
+    BACKEND_URL: str = "http://localhost:8000"   # URL du backend
+    AI_PROVIDER: str = "openai"
+    # AI_PROVIDER: str = "deepseek"
+
+    # OpenAI
+    OPENAI_API_KEY: str
+    DEEPSEEK_API_KEY: str
+    MODEL_NAME: str = "gpt-3.5-turbo"  # default OpenAI model
+    
+    # Chemins
+    VECTOR_DB_PATH: str = "data/vectors"
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "allow"  # Permet les variables supplémentaires
+
+settings = Settings()

app/main.py

@@ -0,0 +1,22 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.core.config import settings
+from app.api.routes import stripe_routes, routes
+
+app = FastAPI(title="Quiz Video API")
+
+# Configuration CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[settings.FRONTEND_URL],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(routes.router, prefix="/api")
+app.include_router(stripe_routes.router, prefix="/api")
+
+@app.get("/")
+async def root():
+    return {"message": "Quiz Video API"}

app/models/quiz.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+from typing import List
+
+class Question(BaseModel):
+    question: str
+    options: List[str]
+    correct_answer: str
+
+class QuizRequest(BaseModel):
+    theme: str
+    num_questions: int
+    language: str = "fr"
+
+class Quiz(BaseModel):
+    id: str
+    theme: str
+    questions: List[Question]

app/services/font_manager.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+from fontTools.ttLib import TTFont
+import logging
+from typing import Dict
+
+logger = logging.getLogger(__name__)
+
+class FontManager:
+    FONT_MAPPING = {
+        'Gotham Black': 'Gotham-Black.otf',
+        'Montserrat': 'Montserrat-Black.ttf',
+        'Montserrat Bold': 'Montserrat-Bold.ttf',
+        'Montserrat Extra': 'Montserrat-ExtraBold.ttf',
+        'Urbanist Italic': 'Urbanist-Italic.ttf',
+        'Urbanist': 'Urbanist-Variable.ttf'
+    }
+
+    def __init__(self):
+        self.font_dir = Path(__file__).parent.parent / "fonts"
+        self.font_dir.mkdir(exist_ok=True)
+        self.fonts_cache: Dict[str, str] = {}
+        self.default_font = "Montserrat-Black.ttf"
+        self._load_fonts()
+
+    def _load_fonts(self):
+        """Charge et valide toutes les polices disponibles"""
+        for font_path in self.font_dir.glob("*.[ot]tf"):
+            try:
+                font = TTFont(font_path)
+                font_name = font['name'].getName(4, 3, 1, 1033)
+                if font_name:
+                    self.fonts_cache[font_path.name.lower()] = str(font_path)
+                font.close()
+            except Exception as e:
+                logger.warning(f"Impossible de charger la police {font_path}: {e}")
+
+    def get_font_path(self, font_name: str) -> str:
+        """Retourne le chemin de la police demandée ou de la police par défaut"""
+        if not font_name:
+            return str(self.font_dir / self.default_font)
+
+        # Chercher d'abord dans le mapping des noms
+        mapped_name = self.FONT_MAPPING.get(font_name)
+        if mapped_name:
+            font_path = self.fonts_cache.get(mapped_name.lower())
+            if font_path:
+                return font_path
+
+        # Si pas trouvé, essayer avec le nom direct
+        font_name = font_name.lower().replace(" ", "-")
+        font_path = self.fonts_cache.get(f"{font_name}.ttf") or self.fonts_cache.get(f"{font_name}.otf")
+        
+        if not font_path:
+            logger.warning(f"Police {font_name} non trouvée, utilisation de la police par défaut")
+            return str(self.font_dir / self.default_font)
+        
+        return font_path

app/services/quiz_generator.py

@@ -0,0 +1,107 @@
+from typing import List, Dict, Literal
+import json
+from langchain_community.vectorstores import FAISS
+from langchain_openai import OpenAIEmbeddings
+from langchain_openai import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate
+from app.core.config import settings
+from app.models.quiz import Question
+import logging
+
+logger = logging.getLogger(__name__)
+
+class QuizGenerator:
+    def __init__(self, provider: Literal["openai", "deepseek"] = "openai"):
+        self.embeddings = OpenAIEmbeddings(openai_api_key=settings.OPENAI_API_KEY)
+        self.vector_store = FAISS.load_local(
+            settings.VECTOR_DB_PATH, 
+            self.embeddings,
+            allow_dangerous_deserialization=True
+        )
+        
+        # Configuration selon le provider
+        if provider == "deepseek":
+            self.llm = ChatOpenAI(
+                model_name="deepseek-chat",
+                temperature=0.7,
+                openai_api_key=settings.DEEPSEEK_API_KEY,
+                base_url="https://api.deepseek.com"
+            )
+        else:  # openai
+            self.llm = ChatOpenAI(
+                model_name=settings.MODEL_NAME,
+                temperature=0.7,
+                openai_api_key=settings.OPENAI_API_KEY
+            )
+
+    def clean_json_response(self, response_text: str) -> str:
+        """Nettoie la réponse du LLM pour obtenir un JSON valide."""
+        # Supprime les backticks markdown et le mot 'json'
+        cleaned = response_text.replace('```json', '').replace('```', '').strip()
+        # Supprime les espaces et sauts de ligne superflus au début et à la fin
+        return cleaned.strip()
+
+
+    async def generate_quiz(self, theme: str, num_questions: int = 5) -> List[Question]:
+        logger.debug(f"Génération de quiz - Thème: {theme}, Nb questions: {num_questions}")
+
+        try:
+            # Récupérer le contexte pertinent
+            docs = self.vector_store.similarity_search(theme, k=3)
+            context = "\n".join([doc.page_content for doc in docs])
+
+            # Template pour la génération de questions
+            prompt = ChatPromptTemplate.from_template("""
+            Tu es un générateur de quiz intelligent.
+
+            Si tu as du contexte pertinent, utilise-le : {context}
+            Sinon, utilise tes connaissances générales.
+
+            Génère {num_questions} questions de quiz sur le thème: {theme}
+
+            IMPORTANT: Réponds UNIQUEMENT avec un JSON valide sans backticks ni formatage markdown.
+            Format exact attendu:
+            {{
+                "questions": [
+                    {{
+                        "question": "La question",
+                        "options": ["Option A", "Option B", "Option C"],
+                        "correct_answer": "La bonne réponse (qui doit être une des options)"
+                    }}
+                ]
+            }}
+            """)
+
+            # Générer les questions
+            response = await self.llm.agenerate([
+                prompt.format_messages(
+                    context=context,
+                    theme=theme,
+                    num_questions=num_questions
+                )
+            ])
+
+            # Parser le JSON et créer les objets Question
+            response_text = response.generations[0][0].text
+            cleaned_response = self.clean_json_response(response_text)
+            
+            try:
+                response_json = json.loads(cleaned_response)
+            except json.JSONDecodeError as e:
+                logger.error(f"Réponse brute: {response_text}")
+                logger.error(f"Réponse nettoyée: {cleaned_response}")
+                raise Exception(f"Erreur de parsing JSON: {str(e)}")
+            
+            questions = []
+            for q in response_json["questions"]:
+                questions.append(Question(
+                    question=q["question"],
+                    options=q["options"],
+                    correct_answer=q["correct_answer"]
+                ))
+            
+            return questions
+            
+        except Exception as e:
+            print(f"Erreur dans generate_quiz: {str(e)}")
+            raise e

app/services/video_service.py

@@ -0,0 +1,393 @@
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import os
+import logging
+import base64
+from app.services.font_manager import FontManager
+import io
+from moviepy.editor import VideoFileClip, AudioFileClip, CompositeVideoClip
+from moviepy.audio.AudioClip import CompositeAudioClip
+
+logger = logging.getLogger(__name__)
+
+class VideoService:
+    # Initialiser le gestionnaire de polices
+    font_manager = FontManager()
+
+    # Constantes de style
+    COLORS = {
+        'background': (25, 25, 25),
+        'text': (255, 255, 255),
+        'highlight': (64, 156, 255),
+        'correct': (46, 204, 113),
+        'option_bg': (50, 50, 50)
+    }
+
+    @staticmethod
+    async def generate_quiz_video(quiz_data: dict):
+        try:
+            # Configuration
+            WIDTH, HEIGHT = 720, 1280
+            FPS = 24
+            DURATION_QUESTION = 5
+            DURATION_ANSWER = 3
+            
+            # Récupérer les styles depuis quiz_data
+            style_config = quiz_data.get('styleConfig', {})
+            title_style = style_config.get('title', {})
+            questions_style = style_config.get('questions', {})
+            answers_style = style_config.get('answers', {})
+            background_style = style_config.get('background', {})
+            
+            os.makedirs("temp", exist_ok=True)
+            output_path = f"temp/quiz_{quiz_data['id']}.mp4"
+            
+            # Créer une vidéo temporaire sans audio
+            temp_video_path = f"temp/temp_quiz_{quiz_data['id']}.mp4"
+            final_output_path = f"temp/quiz_{quiz_data['id']}.mp4"
+            
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            out = cv2.VideoWriter(temp_video_path, fourcc, FPS, (WIDTH, HEIGHT))
+
+            # Charger l'image de fond si elle existe
+            background_image = None
+            if background_style.get('image'):
+                # Décoder l'image base64 en gardant les couleurs d'origine
+                image_data = base64.b64decode(background_style['image'].split(',')[1])
+                img = Image.open(io.BytesIO(image_data))
+                
+                # Redimensionner en conservant le ratio
+                ratio = img.width / img.height
+                new_height = HEIGHT
+                new_width = int(HEIGHT * ratio)
+                img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+                
+                # Centrer et recadrer si nécessaire
+                if new_width > WIDTH:
+                    left = (new_width - WIDTH) // 2
+                    img = img.crop((left, 0, left + WIDTH, HEIGHT))
+                elif new_width < WIDTH:
+                    new_img = Image.new('RGB', (WIDTH, HEIGHT), (0, 0, 0))
+                    paste_x = (WIDTH - new_width) // 2
+                    new_img.paste(img, (paste_x, 0))
+                    img = new_img
+                
+                # Convertir en array numpy en préservant les couleurs
+                background_image = np.array(img)
+
+            # Liste pour stocker les moments où jouer le son
+            correct_answer_times = []
+            current_time = 0
+
+            # Création des frames
+            for i, question in enumerate(quiz_data["questions"], 1):
+                frame = Image.new('RGB', (WIDTH, HEIGHT))
+                if background_image is not None:
+                    # Utiliser l'image de fond en RGB
+                    frame = Image.fromarray(background_image)
+                    if background_style.get('opacity', 1) < 1:
+                        overlay = Image.new('RGB', (WIDTH, HEIGHT), (0, 0, 0))
+                        frame = Image.blend(frame, overlay, 1 - background_style.get('opacity', 1))
+
+                # Créer les frames
+                question_frame = VideoService._create_question_frame(
+                    frame, question, i, len(quiz_data["questions"]),
+                    title_style, questions_style, answers_style,
+                    WIDTH, HEIGHT, show_answer=False
+                )
+                
+                # Convertir en BGR pour OpenCV
+                frame_cv = cv2.cvtColor(np.array(question_frame), cv2.COLOR_RGB2BGR)
+                
+                for _ in range(int(FPS * DURATION_QUESTION)):
+                    out.write(frame_cv)
+                current_time += DURATION_QUESTION
+
+                # Marquer le moment pour jouer le son
+                correct_answer_times.append(current_time)
+                
+                # Frame de réponse
+                answer_frame = VideoService._create_question_frame(
+                    frame.copy(), question, i, len(quiz_data["questions"]),
+                    title_style, questions_style, answers_style,
+                    WIDTH, HEIGHT, show_answer=True
+                )
+                
+                frame_cv = cv2.cvtColor(np.array(answer_frame), cv2.COLOR_RGB2BGR)
+                
+                for _ in range(int(FPS * DURATION_ANSWER)):
+                    out.write(frame_cv)
+                current_time += DURATION_ANSWER
+
+            out.release()
+
+            # Ajouter l'audio
+            video = VideoFileClip(temp_video_path)
+            correct_sound = AudioFileClip("app/assets/sounds/correct.mp3")
+
+            # Créer plusieurs clips audio, un pour chaque bonne réponse
+            audio_clips = []
+            for time in correct_answer_times:
+                # Créer une nouvelle instance du son pour chaque moment
+                audio_clip = correct_sound.copy()
+                audio_clips.append(audio_clip.set_start(time-0.5))
+
+            # Combiner tous les clips audio
+            if audio_clips:
+                # Fusionner tous les clips audio en un seul
+                final_audio = CompositeAudioClip(audio_clips)
+                # Ajouter l'audio à la vidéo
+                final_video = video.set_audio(final_audio)
+            else:
+                final_video = video
+
+            # Écrire la vidéo finale
+            final_video.write_videofile(
+                final_output_path, 
+                codec='libx264', 
+                audio_codec='aac',
+                fps=FPS
+            )
+
+            # Nettoyer les fichiers temporaires
+            os.remove(temp_video_path)
+            video.close()
+            correct_sound.close()
+            for clip in audio_clips:
+                clip.close()
+
+            return final_output_path
+                
+        except Exception as e:
+            logger.error(f"Erreur dans generate_quiz_video: {str(e)}")
+            raise
+
+    @staticmethod
+    def _scale_size(size, preview_height=170, video_height=720):
+        """
+        Convertit une taille de la preview vers la taille vidéo ou inverse
+        en conservant le ratio
+        """
+        scale_factor = video_height / preview_height
+        return int(size * scale_factor)
+
+    @staticmethod
+    def _create_question_frame(frame, question, current_num, total_questions, 
+                             title_style, questions_style, answers_style, 
+                             width, height, show_answer=False):
+        draw = ImageDraw.Draw(frame)
+        
+        try:
+            # Définir les tailles de base pour la preview (170px)
+            BASE_PREVIEW_HEIGHT = 170
+            
+            # Convertir les tailles de police de la preview vers la taille vidéo
+            title_base_size = int(title_style.get('fontSize', 11))  # taille en px pour preview
+            question_base_size = int(questions_style.get('fontSize', 8))
+            answer_base_size = int(answers_style.get('fontSize', 6))
+
+            # Mettre à l'échelle pour la vidéo
+            title_font_size = VideoService._scale_size(title_base_size)
+            question_font_size = VideoService._scale_size(question_base_size)
+            answer_font_size = VideoService._scale_size(answer_base_size)
+
+            title_font = ImageFont.truetype(
+                VideoService.font_manager.get_font_path(title_style.get('fontFamily')),
+                title_font_size
+            )
+            question_font = ImageFont.truetype(
+                VideoService.font_manager.get_font_path(questions_style.get('fontFamily')),
+                question_font_size
+            )
+            answer_font = ImageFont.truetype(
+                VideoService.font_manager.get_font_path(answers_style.get('fontFamily')),
+                answer_font_size
+            )
+
+            # Position du titre à 10% du haut
+            title_y = int(0.10 * height)
+            title_text = f"Question {current_num}/{total_questions}"
+            VideoService._draw_text(draw, title_text, title_font, title_y, width, title_style)
+
+            # Position de la question à 10% en dessous du titre
+            question_y = int(0.23 * height)  # 10% + 10%
+            question_text = VideoService._wrap_text(question['question'], question_font, width - 100)
+            VideoService._draw_text(draw, question_text, question_font, question_y, width, questions_style)
+
+            # Position des réponses à 10% en dessous de la question
+            start_y = int(0.38 * height)
+            spacing_between_options = int(0.12 * height)  # Espacement entre les centres des blocs
+
+            # Pré-calculer les hauteurs des blocs
+            option_heights = []
+            for option in question['options']:
+                letter = chr(65 + len(option_heights))
+                full_text = f"{letter}. {option}"
+                wrapped_text = VideoService._wrap_text(full_text, answer_font, width - (width * 0.1 + 50))
+                lines = wrapped_text.split('\n')
+                
+                bbox = answer_font.getbbox('Ag')
+                line_height = bbox[3] - bbox[1]
+                text_height = line_height * len(lines)
+                actual_height = max(80, text_height + 40)  # même calcul que dans _draw_option
+                option_heights.append(actual_height)
+
+            # Dessiner chaque option en tenant compte des hauteurs
+            current_y = start_y
+            for i, option in enumerate(question['options']):
+                is_correct = show_answer and option == question['correct_answer']
+                VideoService._draw_option(draw, option, current_y, 
+                                       answer_font, width, answers_style, is_correct, i)
+                
+                # Calculer la position du prochain bloc en tenant compte des hauteurs
+                if i < len(question['options']) - 1:
+                    current_block_half = option_heights[i] / 2
+                    next_block_half = option_heights[i + 1] / 2
+                    current_y += spacing_between_options  # Espacement fixe entre les centres
+
+            return frame
+        
+        except Exception as e:
+            logger.error(f"Erreur dans _create_question_frame: {str(e)}")
+            raise
+
+    @staticmethod
+    def _draw_option(draw, option_text, y_position, font, width, style, is_correct=False, option_index=0):
+        # Hauteur minimale du bloc d'option
+        option_height = 80
+        margin_left = width * 0.1
+        
+        # Calculer la hauteur réelle du texte
+        letter = chr(65 + option_index)
+        full_text = f"{letter}. {option_text}"
+        wrapped_text = VideoService._wrap_text(full_text, font, width - (margin_left + 50))
+        lines = wrapped_text.split('\n')
+        
+        # Calculer la hauteur totale du texte
+        bbox = font.getbbox('Ag')  # Utiliser une ligne de référence pour la hauteur
+        line_height = bbox[3] - bbox[1]
+        text_height = line_height * len(lines)
+        
+        # Utiliser la plus grande valeur entre option_height et text_height
+        actual_height = max(option_height, text_height + 40)  # +40 pour le padding
+        
+        # Dessiner le fond
+        if style.get('backgroundColor'):
+            bg_color = tuple(int(style['backgroundColor'][i:i+2], 16) for i in (1, 3, 5))
+            draw.rectangle(
+                [
+                    (50, y_position - actual_height//2),
+                    (width - 50, y_position + actual_height//2)
+                ],
+                fill=bg_color
+            )
+        
+        # Si c'est la bonne réponse, on force la couleur en vert
+        if is_correct:
+            style = style.copy()
+            style['color'] = '#2ECC71'
+        
+        # Dessiner le texte aligné à gauche avec la marge
+        VideoService._draw_text(draw, wrapped_text, font, y_position, width, style, align_left=True, margin_left=margin_left)
+
+    @staticmethod
+    def _draw_text(draw, text, font, y_position, width, style, align_left=False, margin_left=0):
+        try:
+            lines = text.split('\n')
+            
+            # Calculer la hauteur totale avec plus d'espacement entre les lignes
+            line_heights = []
+            line_widths = []
+            total_height = 0
+            max_width = 0
+            line_spacing = 1  # Facteur d'espacement entre les lignes (1.5 fois la hauteur normale)
+            
+            for line in lines:
+                bbox = font.getbbox(line)
+                line_height = bbox[3] - bbox[1]
+                line_width = bbox[2] - bbox[0]
+                
+                line_heights.append(line_height)
+                line_widths.append(line_width)
+                total_height += line_height * line_spacing  # Multiplier par le facteur d'espacement
+                max_width = max(max_width, line_width)
+
+            # Augmenter le padding autour du texte
+            padding = 20  # Augmenté de 20 à 30
+
+            current_y = y_position - (total_height // 2)
+
+            if style.get('backgroundColor'):
+                corner_radius = 15
+                bg_color = tuple(int(style['backgroundColor'][i:i+2], 16) for i in (1, 3, 5))
+                
+                if align_left:
+                    x1, y1 = 50, current_y - padding
+                    x2, y2 = width - 50, current_y + total_height + padding
+                else:
+                    center_x = width // 2
+                    x1 = center_x - (max_width // 2) - padding
+                    x2 = center_x + (max_width // 2) + padding
+                    y1 = current_y - padding
+                    y2 = current_y + total_height + padding
+
+                # Dessiner un rectangle avec coins arrondis
+                draw.pieslice([x1, y1, x1 + corner_radius * 2, y1 + corner_radius * 2], 180, 270, fill=bg_color)
+                draw.pieslice([x2 - corner_radius * 2, y1, x2, y1 + corner_radius * 2], 270, 0, fill=bg_color)
+                draw.pieslice([x1, y2 - corner_radius * 2, x1 + corner_radius * 2, y2], 90, 180, fill=bg_color)
+                draw.pieslice([x2 - corner_radius * 2, y2 - corner_radius * 2, x2, y2], 0, 90, fill=bg_color)
+                
+                draw.rectangle([x1 + corner_radius, y1, x2 - corner_radius, y2], fill=bg_color)
+                draw.rectangle([x1, y1 + corner_radius, x2, y2 - corner_radius], fill=bg_color)
+
+            # Dessiner chaque ligne de texte avec plus d'espacement
+            for i, line in enumerate(lines):
+                if align_left:
+                    x_position = margin_left
+                else:
+                    x_position = (width - line_widths[i]) // 2
+
+                color = tuple(int(style.get('color', '#FFFFFF')[i:i+2], 16) for i in (1, 3, 5))
+                # Assurer une épaisseur minimale de 1 pour le contour
+                stroke_width = max(1, 8*int(float(style.get('textStrokeWidth', 0))))
+                stroke_color = tuple(int(style.get('textStrokeColor', '#000000')[i:i+2], 16) for i in (1, 3, 5))
+                
+                if float(style.get('textStrokeWidth', 0)) > 0:  # Vérifier la valeur originale
+                    # Dessiner d'abord le contour
+                    draw.text((x_position, current_y), line, 
+                            font=font, fill=stroke_color, stroke_width=stroke_width)
+                
+                # Dessiner le texte principal
+                draw.text((x_position, current_y), line, 
+                        font=font, fill=color)
+                
+                current_y += line_heights[i] * line_spacing  # Multiplier par le facteur d'espacement
+
+        except Exception as e:
+            logger.error(f"Erreur dans _draw_text: {str(e)}")
+            raise
+
+    @staticmethod
+    def _wrap_text(text: str, font: ImageFont, max_width: int) -> str:
+        words = text.split()
+        lines = []
+        current_line = []
+        
+        for word in words:
+            current_line.append(word)
+            line = ' '.join(current_line)
+            bbox = font.getbbox(line)
+            if bbox[2] > max_width:
+                if len(current_line) == 1:
+                    lines.append(line)
+                    current_line = []
+                else:
+                    current_line.pop()
+                    lines.append(' '.join(current_line))
+                    current_line = [word]
+        
+        if current_line:
+            lines.append(' '.join(current_line))
+        
+        return '\n'.join(lines)

requirements.txt

@@ -0,0 +1,13 @@
+fastapi
+uvicorn
+python-dotenv
+langchain
+langchain-community
+langchain-openai
+openai
+faiss-cpu
+numpy
+pydantic
+pydantic-settings
+python-multipart
+moviepy