Ajout de l'API JANGG complète avec génération de cours, quiz, audio et vidéo

app/main.py

@@ -2,7 +2,7 @@ from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import HTMLResponse
 
-from app.routers import chat, quiz, audio
+from app.routers import chat, quiz, audio, video, integrated
 
 app = FastAPI(title="JANGG AI API", description="Intelligent API for interactive learning with AI")
 
@@ -11,6 +11,8 @@ app.mount("/static", StaticFiles(directory="app/static"), name="static")
 app.include_router(chat.router)
 app.include_router(quiz.router)
 app.include_router(audio.router)
+app.include_router(video.router)
+app.include_router(integrated.router)
 
 @app.get("/", response_class=HTMLResponse)
 async def root():
@@ -72,6 +74,31 @@ async def root():
             <div class="description">Convert speech to text</div>
         </div>
         
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/video/generate</span>
+            <div class="description">Generate course videos with AI images and text-to-speech</div>
+        </div>
+        
+        <div class="endpoint">
+            <span class="method">GET</span> <span class="path">/video/health</span>
+            <div class="description">Check video generation service status</div>
+        </div>
+        
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/integrated/complete-course</span>
+            <div class="description">Generate complete learning package (course + quiz + video scenes) in one LLM call</div>
+        </div>
+        
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/integrated/video-from-scenes</span>
+            <div class="description">Generate video from pre-generated scenes</div>
+        </div>
+        
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/integrated/full-pipeline</span>
+            <div class="description">Complete pipeline: generate content AND create video in one call</div>
+        </div>
+        
         <div style="text-align: center; margin-top: 30px;">
             <a href="/docs" class="docs-link">📖 Interactive Documentation (Swagger)</a>
             <br><br>

app/prompts/complete_course_prompt.py

@@ -0,0 +1,47 @@
+COMPLETE_COURSE_TEMPLATE = """
+You are a friendly AI tutor and content creator.
+
+Generate a complete learning package about {topic} for the {sector} sector.
+
+Parameters:
+- Tone: {tone}
+- Style: {style} 
+- Length: {length}
+- Language: French
+
+Requirements:
+1. Generate engaging course content
+2. Create relevant quiz questions
+3. Structure content for video generation with scenes
+
+Format your response as JSON:
+
+{{
+  "course": "Complete course content with clear sections and examples",
+  "quiz": [
+    {{
+      "question": "Clear question about the content",
+      "options": ["Option A", "Option B", "Option C", "Option D"],
+      "answer": 2
+    }}
+  ],
+  "video_scenes": [
+    {{
+      "title": "Scene title",
+      "content": "Narration text for this scene (2-3 sentences)",
+      "duration": 8,
+      "visual_prompt": "Visual description for AI image generation"
+    }}
+  ]
+}}
+
+Rules:
+- Course: Clear, structured, beginner-friendly with practical examples
+- Quiz: 5 questions testing key concepts
+- Video Scenes: 5-8 scenes covering the main topics
+- Each scene content should be speakable (natural for text-to-speech)
+- Visual prompts should be descriptive for image generation
+- Duration per scene: 5-12 seconds based on content length
+
+Return only valid JSON.
+"""

app/routers/integrated.py

@@ -0,0 +1,130 @@
+from fastapi import APIRouter, HTTPException
+from app.schemas.chat import LearnRequest
+from app.schemas.complete_course import CompleteCourseResponse, VideoFromScenesRequest
+from app.services.learning_agent import generate_complete_learning_package
+from app.services.video_service import video_service
+import time
+
+router = APIRouter(prefix="/integrated", tags=["Integrated Learning"])
+
+
+@router.post("/complete-course", response_model=CompleteCourseResponse)
+def generate_complete_learning_experience(req: LearnRequest):
+    """
+    Generate a complete learning package in a single LLM inference.
+    
+    This endpoint generates:
+    1. Course content
+    2. Quiz questions  
+    3. Video-ready scenes with visual prompts
+    
+    All content is generated coherently in one LLM call for better consistency.
+    """
+    try:
+        start_time = time.time()
+        
+        # Generate everything in one inference
+        complete_data = generate_complete_learning_package(req.dict())
+        
+        processing_time = time.time() - start_time
+        
+        return CompleteCourseResponse(
+            course=complete_data["course"],
+            quiz=complete_data["quiz"],
+            video_scenes=complete_data["video_scenes"],
+            message="Complete learning package generated successfully",
+            generation_method="unified_llm"
+        )
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Complete course generation failed: {str(e)}"
+        )
+
+
+@router.post("/video-from-scenes")
+def generate_video_from_scenes(req: VideoFromScenesRequest):
+    """
+    Generate video from pre-generated scenes.
+    
+    Use this with scenes from /integrated/complete-course for optimal results.
+    """
+    try:
+        start_time = time.time()
+        
+        # Convert scenes to video service format
+        video_data = {
+            "topic": req.topic,
+            "style": req.style,
+            "tone": req.tone,
+            "language": req.language,
+            "scenes": [
+                {
+                    "title": scene.title,
+                    "content": scene.content,
+                    "duration": scene.duration
+                }
+                for scene in req.scenes
+            ]
+        }
+        
+        video_path = video_service.generate_course_video(video_data)
+        
+        processing_time = time.time() - start_time
+        
+        return {
+            "video_path": video_path,
+            "scenes_used": len(req.scenes),
+            "processing_time": processing_time,
+            "message": "Video generated from scenes successfully"
+        }
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Video from scenes generation failed: {str(e)}"
+        )
+
+
+@router.post("/full-pipeline")
+def generate_full_learning_pipeline(req: LearnRequest):
+    """
+    Complete pipeline: generate content AND create video in one call.
+    
+    This combines content generation and video creation for maximum convenience.
+    """
+    try:
+        start_time = time.time()
+        
+        # Step 1: Generate complete content package
+        complete_data = generate_complete_learning_package(req.dict())
+        
+        # Step 2: Generate video from the scenes
+        video_data = {
+            "topic": req.topic,
+            "style": req.style,
+            "tone": req.tone,
+            "language": "fr",
+            "scenes": complete_data["video_scenes"]
+        }
+        
+        video_path = video_service.generate_course_video(video_data)
+        
+        total_time = time.time() - start_time
+        
+        return {
+            "course": complete_data["course"],
+            "quiz": complete_data["quiz"],
+            "video_scenes": complete_data["video_scenes"],
+            "video_path": video_path,
+            "total_processing_time": total_time,
+            "generation_method": "unified_llm_plus_video",
+            "message": "Full learning pipeline completed successfully"
+        }
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Full pipeline generation failed: {str(e)}"
+        )

app/routers/video.py

@@ -0,0 +1,72 @@
+import time
+from fastapi import APIRouter, HTTPException
+from app.schemas.video import VideoRequest, VideoResponse
+from app.services.video_service import video_service
+
+router = APIRouter(prefix="/video", tags=["Video"])
+
+
+@router.post("/generate", response_model=VideoResponse)
+def generate_course_video(request: VideoRequest):
+    """
+    Generate a course video based on the provided scenes and settings.
+    
+    This endpoint creates a video by:
+    1. Generating images for each scene using Stable Diffusion
+    2. Converting text to speech using gTTS
+    3. Creating video segments with FFmpeg
+    4. Concatenating all segments into a final video
+    """
+    try:
+        start_time = time.time()
+        
+        # Convert request to dict for service
+        course_data = {
+            "topic": request.topic,
+            "style": request.style,
+            "tone": request.tone,
+            "language": request.language,
+            "scenes": [
+                {
+                    "title": scene.title,
+                    "content": scene.content,
+                    "duration": scene.duration
+                }
+                for scene in request.scenes
+            ]
+        }
+        
+        # Generate video
+        video_path = video_service.generate_course_video(course_data)
+        
+        processing_time = time.time() - start_time
+        
+        return VideoResponse(
+            video_path=video_path,
+            message="Video generated successfully",
+            processing_time=processing_time
+        )
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Video generation failed: {str(e)}"
+        )
+
+
+@router.get("/health")
+def video_health_check():
+    """Check if video generation service is available"""
+    try:
+        # Check if the model is loaded
+        model_loaded = video_service.pipe is not None
+        return {
+            "status": "healthy" if model_loaded else "degraded",
+            "model_loaded": model_loaded,
+            "service": "video_generation"
+        }
+    except Exception as e:
+        raise HTTPException(
+            status_code=503,
+            detail=f"Video service unavailable: {str(e)}"
+        )

app/schemas/complete_course.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel, Field
+from typing import List, Dict
+
+
+class VideoScene(BaseModel):
+    title: str = Field(..., description="Title of the video scene")
+    content: str = Field(..., description="Narration text for the scene")
+    duration: int = Field(..., description="Duration in seconds")
+    visual_prompt: str = Field(..., description="Visual description for AI image generation")
+
+
+class CompleteCourseResponse(BaseModel):
+    course: str = Field(..., description="Complete course content")
+    quiz: List[Dict] = Field(..., description="Quiz questions with options and answers")
+    video_scenes: List[VideoScene] = Field(..., description="Scenes ready for video generation")
+    message: str = Field(default="Complete learning package generated successfully")
+    generation_method: str = Field(default="unified", description="How the content was generated")
+
+
+class VideoFromScenesRequest(BaseModel):
+    topic: str = Field(..., description="Topic of the course")
+    style: str = Field(default="cartoon", description="Visual style")
+    tone: str = Field(default="educational", description="Content tone")
+    language: str = Field(default="fr", description="Language for audio")
+    scenes: List[VideoScene] = Field(..., description="Pre-generated scenes")

app/schemas/video.py

@@ -0,0 +1,22 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+
+class Scene(BaseModel):
+    title: str = Field(..., description="Title of the scene")
+    content: str = Field(..., description="Content/narration for the scene")
+    duration: int = Field(..., description="Duration in seconds")
+
+
+class VideoRequest(BaseModel):
+    topic: str = Field(..., description="Topic of the course")
+    style: str = Field(default="cartoon", description="Visual style for video generation")
+    tone: str = Field(default="fun", description="Tone of the content")
+    language: str = Field(default="fr", description="Language for audio generation")
+    scenes: List[Scene] = Field(..., description="List of scenes for the video")
+
+
+class VideoResponse(BaseModel):
+    video_path: str = Field(..., description="Path to the generated video file")
+    message: str = Field(..., description="Status message")
+    processing_time: Optional[float] = Field(None, description="Total processing time in seconds")

app/services/learning_agent.py

@@ -2,12 +2,13 @@ from langchain_core.prompts import PromptTemplate
 from app.core.llm import llm
 from app.prompts.course_prompt import COURSE_TEMPLATE
 from app.prompts.quiz_prompt import QUIZ_TEMPLATE
+from app.prompts.complete_course_prompt import COMPLETE_COURSE_TEMPLATE
 import json
 import re
 
 
 def generate_course_and_quiz(params):
-
+    """Legacy function - generates course and quiz separately"""
     course_prompt = PromptTemplate.from_template(COURSE_TEMPLATE)
 
     course = llm.invoke(
@@ -36,3 +37,71 @@ def generate_course_and_quiz(params):
         ]
 
     return course, quiz
+
+
+def generate_complete_learning_package(params):
+    """
+    Generate course, quiz, and video-ready scenes in a single LLM inference.
+    
+    Returns:
+        dict: {
+            "course": str,
+            "quiz": list,
+            "video_scenes": list
+        }
+    """
+    complete_prompt = PromptTemplate.from_template(COMPLETE_COURSE_TEMPLATE)
+    
+    response = llm.invoke(
+        complete_prompt.format(**params)
+    ).content
+    
+    # Extract JSON from response
+    json_match = re.search(r'\{.*\}', response, re.DOTALL)
+    if json_match:
+        try:
+            complete_data = json.loads(json_match.group(0))
+            
+            # Validate structure
+            required_keys = ["course", "quiz", "video_scenes"]
+            if all(key in complete_data for key in required_keys):
+                return complete_data
+            else:
+                raise ValueError("Missing required keys in LLM response")
+                
+        except json.JSONDecodeError as e:
+            print(f"JSON parsing error: {e}")
+            return _fallback_generation(params)
+    else:
+        print("No JSON found in LLM response")
+        return _fallback_generation(params)
+
+
+def _fallback_generation(params):
+    """Fallback to separate generation if unified approach fails"""
+    print("Falling back to separate generation...")
+    course, quiz = generate_course_and_quiz(params)
+    
+    # Basic scene parsing from course
+    scenes = []
+    sections = re.split(r'\n\d+\.\s*|\n\n', course)
+    sections = [s.strip() for s in sections if s.strip()]
+    
+    for i, section in enumerate(sections[:8]):
+        sentences = section.split('.')
+        title = sentences[0].strip() if sentences else section[:50]
+        content = section.strip()
+        duration = max(5, min(15, len(content.split()) * 0.5))
+        
+        scenes.append({
+            "title": title,
+            "content": content,
+            "duration": int(duration),
+            "visual_prompt": f"{params.get('style', 'cartoon')}, {title}, educational content"
+        })
+    
+    return {
+        "course": course,
+        "quiz": quiz,
+        "video_scenes": scenes
+    }

app/services/video_service.py

@@ -0,0 +1,123 @@
+import os
+import uuid
+import subprocess
+import time
+from typing import Dict
+from gtts import gTTS
+from pydub import AudioSegment
+import torch
+from diffusers import StableDiffusionPipeline
+
+
+class VideoService:
+    def __init__(self):
+        self.pipe = None
+        self._load_model()
+    
+    def _load_model(self):
+        """Load Stable Diffusion model once"""
+        try:
+            self.pipe = StableDiffusionPipeline.from_pretrained(
+                "runwayml/stable-diffusion-v1-5",
+                torch_dtype=torch.float16
+            ).to("cuda")
+        except Exception as e:
+            print(f"Warning: Could not load GPU model, falling back to CPU: {e}")
+            self.pipe = StableDiffusionPipeline.from_pretrained(
+                "runwayml/stable-diffusion-v1-5"
+            )
+    
+    def _ensure_directories(self):
+        """Create necessary directories"""
+        os.makedirs("tmp/images", exist_ok=True)
+        os.makedirs("tmp/audio", exist_ok=True)
+        os.makedirs("output/videos", exist_ok=True)
+    
+    def _generate_image(self, prompt: str, idx: int) -> str:
+        """Generate image for a scene"""
+        image = self.pipe(prompt, num_inference_steps=20).images[0]
+        img_path = f"tmp/images/scene_{idx}.png"
+        image.save(img_path)
+        return img_path
+    
+    def _generate_audio(self, text: str, language: str, idx: int) -> tuple:
+        """Generate audio for a scene"""
+        audio_mp3 = f"tmp/audio/scene_{idx}.mp3"
+        tts = gTTS(text=text, lang=language)
+        tts.save(audio_mp3)
+        
+        # Convert to wav
+        audio_wav = audio_mp3.replace(".mp3", ".wav")
+        subprocess.run(["ffmpeg", "-y", "-i", audio_mp3, audio_wav], check=True)
+        
+        # Get duration
+        audio_duration = AudioSegment.from_file(audio_wav).duration_seconds
+        
+        return audio_wav, audio_duration
+    
+    def _create_video_segment(self, img_path: str, audio_wav: str, duration: float, idx: int) -> str:
+        """Create a video segment from image and audio"""
+        segment_path = f"tmp/segment_{idx}.mp4"
+        subprocess.run([
+            "ffmpeg", "-y",
+            "-loop", "1", "-i", img_path,
+            "-i", audio_wav,
+            "-c:v", "libx264",
+            "-t", str(duration),
+            "-pix_fmt", "yuv420p",
+            "-c:a", "aac",
+            segment_path
+        ], check=True)
+        return segment_path
+    
+    def _concatenate_segments(self, segments: list) -> str:
+        """Concatenate all video segments"""
+        concat_file = "tmp/segments.txt"
+        with open(concat_file, "w") as f:
+            for seg in segments:
+                f.write(f"file '{os.path.abspath(seg)}'\n")
+        
+        output_video = f"output/videos/course_{uuid.uuid4().hex}.mp4"
+        subprocess.run([
+            "ffmpeg", "-y", "-f", "concat", "-safe", "0",
+            "-i", concat_file,
+            "-c", "copy",
+            output_video
+        ], check=True)
+        
+        return output_video
+    
+    def generate_course_video(self, course_data: Dict) -> str:
+        """Generate a complete course video from course data"""
+        start_time = time.time()
+        
+        self._ensure_directories()
+        segments = []
+        
+        for idx, scene in enumerate(course_data["scenes"]):
+            # Generate image
+            prompt = f"{course_data.get('style', 'cartoon')}, {scene['title']}, {scene['content']}"
+            img_path = self._generate_image(prompt, idx)
+            
+            # Generate audio
+            audio_wav, audio_duration = self._generate_audio(
+                scene["content"], 
+                course_data.get("language", "fr"), 
+                idx
+            )
+            
+            # Create video segment
+            segment_path = self._create_video_segment(img_path, audio_wav, audio_duration, idx)
+            segments.append(segment_path)
+        
+        # Concatenate all segments
+        output_video = self._concatenate_segments(segments)
+        
+        processing_time = time.time() - start_time
+        print(f"Video generated in {processing_time:.2f} seconds")
+        
+        return output_video
+
+
+# Global instance
+video_service = VideoService()

app/untitled0.py

@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+"""Untitled0.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1PI3sFVWthKkbYWJSEs4RblwLkq5Q46Uw
+"""
+
+!pip install pydub
+
+!apt-get update -qq
+!apt-get install -y ffmpeg
+!pip install diffusers transformers accelerate scipy
+
+import torch
+import os
+from diffusers import StableDiffusionPipeline
+import subprocess
+
+os.makedirs("images", exist_ok=True)
+os.makedirs("output", exist_ok=True)
+
+
+
+course_data = {
+    "topic": "Finance personnelle",
+    "style": "cartoon",
+    "tone": "fun",
+    "language": "fr",
+    "scenes": [
+        {
+            "title": "Bienvenue dans le monde de la finance",
+            "content": "La finance personnelle, c’est apprendre à gérer ton argent intelligemment, même si tu débutes.",
+            "duration": 8
+        },
+        {
+            "title": "Pourquoi l’argent est important",
+            "content": "L’argent te permet de payer tes besoins, réaliser tes projets et sécuriser ton avenir.",
+            "duration": 8
+        },
+        {
+            "title": "Revenus et dépenses",
+            "content": "Tes revenus sont l’argent que tu gagnes, et tes dépenses sont l’argent que tu dépenses chaque jour.",
+            "duration": 8
+        },
+        {
+            "title": "Épargner, même un peu",
+            "content": "Mettre de côté une petite somme régulièrement t’aide à faire face aux imprévus.",
+            "duration": 8
+        },
+        {
+            "title": "Éviter les dettes inutiles",
+            "content": "Emprunter peut être utile, mais trop de dettes peuvent devenir un problème.",
+            "duration": 8
+        },
+        {
+            "title": "Investir pour le futur",
+            "content": "Investir, c’est utiliser ton argent pour en gagner davantage avec le temps.",
+            "duration": 8
+        },
+        {
+            "title": "Objectifs financiers",
+            "content": "Fixe-toi des objectifs simples comme acheter quelque chose ou économiser pour un projet.",
+            "duration": 8
+        },
+        {
+            "title": "Bravo, tu progresses",
+            "content": "Félicitations ! Tu viens de faire tes premiers pas vers une meilleure gestion de ton argent.",
+            "duration": 8
+        }
+    ]
+}
+
+from pydub import AudioSegment
+
+def get_audio_duration(audio_path: str) -> float:
+    audio = AudioSegment.from_file(audio_path)
+    return audio.duration_seconds  # durée en secondes
+
+!pip install gtts
+
+import os
+import uuid
+import subprocess
+from gtts import gTTS
+import torch
+from diffusers import StableDiffusionPipeline
+
+# Charger Stable Diffusion UNE SEULE FOIS
+pipe = StableDiffusionPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5",
+    torch_dtype=torch.float16
+).to("cuda")
+
+def generate_course_video(course_data: dict) -> str:
+    import os, uuid, subprocess
+    from gtts import gTTS
+    from pydub import AudioSegment
+
+    os.makedirs("tmp/images", exist_ok=True)
+    os.makedirs("tmp/audio", exist_ok=True)
+    os.makedirs("output/videos", exist_ok=True)
+
+    segments = []
+
+    for idx, scene in enumerate(course_data["scenes"]):
+        # 1️⃣ Génération image
+        prompt = f"Cute cartoon, {scene['title']}, {scene['content']}"
+        image = pipe(prompt, num_inference_steps=20).images[0]
+        img_path = f"tmp/images/scene_{idx}.png"
+        image.save(img_path)
+
+        # 2️⃣ Génération audio GTTS
+        audio_mp3 = f"tmp/audio/scene_{idx}.mp3"
+        tts = gTTS(text=scene["content"], lang="fr")
+        tts.save(audio_mp3)
+
+        # 3️⃣ Convertir en wav
+        audio_wav = audio_mp3.replace(".mp3", ".wav")
+        subprocess.run(["ffmpeg", "-y", "-i", audio_mp3, audio_wav], check=True)
+
+        # 4️⃣ Obtenir durée exacte
+        audio_duration = AudioSegment.from_file(audio_wav).duration_seconds
+
+        # 5️⃣ Créer segment vidéo pour cette scène
+        segment_path = f"tmp/segment_{idx}.mp4"
+        subprocess.run([
+            "ffmpeg", "-y",
+            "-loop", "1", "-i", img_path,
+            "-i", audio_wav,
+            "-c:v", "libx264",
+            "-t", str(audio_duration),
+            "-pix_fmt", "yuv420p",
+            "-c:a", "aac",
+            segment_path
+        ], check=True)
+
+        segments.append(segment_path)
+
+    # 6️⃣ Concaténer tous les segments
+    concat_file = "tmp/segments.txt"
+    with open(concat_file, "w") as f:
+        for seg in segments:
+            f.write(f"file '{os.path.abspath(seg)}'\n")
+
+    output_video = f"output/videos/course_{uuid.uuid4().hex}.mp4"
+    subprocess.run([
+        "ffmpeg", "-y", "-f", "concat", "-safe", "0",
+        "-i", concat_file,
+        "-c", "copy",
+        output_video
+    ], check=True)
+
+    return output_video
+
+!apt-get update -qq
+!apt-get install -y espeak
+
+video_path = generate_course_video(course_data)

requirements.txt

@@ -1,23 +1,45 @@
+# Core API Framework
 fastapi>=0.104.0
 uvicorn[standard]>=0.24.0
 python-dotenv>=1.0.0
 pydantic>=2.5.0
+python-multipart>=0.0.6
+httpx>=0.25.0
+
+# Database & ORM
 sqlalchemy>=2.0.0
 asyncpg>=0.29.0
 alembic>=1.13.0
 redis>=5.0.0
+
+# Authentication & Security
+python-jose[cryptography]>=3.3.0
+passlib[bcrypt]>=1.7.4
+
+# AI & ML Libraries
 openai>=1.3.0
 langchain>=0.0.350
 langchain-groq>=0.0.1
 langchain-community>=0.4.0
 crewai>=0.1.4
 crewai-tools>=0.2.0
-python-jose[cryptography]>=3.3.0
-passlib[bcrypt]>=1.7.4
-python-multipart>=0.0.6
-httpx>=0.25.0
+
+# Video Generation
+torch>=2.1.0
+torchvision>=0.16.0
+diffusers>=0.24.0
+transformers>=4.35.0
+accelerate>=0.24.0
+scipy>=1.11.0
+
+# Audio Processing
+gtts>=2.4.0
+pydub>=0.25.0
+
+# Data Processing
 pandas>=2.1.0
 numpy>=1.25.0
+
+# Testing
 pytest>=7.4.0
 pytest-asyncio>=0.21.0
-gtts>=2.4.0

test_api.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+Script de test simple pour l'API JANGG
+"""
+import sys
+import os
+
+# Ajouter le chemin du projet
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+try:
+    from fastapi import FastAPI
+    from fastapi.responses import JSONResponse
+    
+    # Créer une version simplifiée de l'API pour tester
+    app = FastAPI(title="JANGG API Test", version="1.0.0")
+    
+    @app.get("/")
+    async def root():
+        return {"message": "JANGG API is running!", "status": "healthy"}
+    
+    @app.get("/health")
+    async def health():
+        return {"status": "healthy", "api": "JANGG API", "version": "1.0.0"}
+    
+    @app.get("/test-endpoints")
+    async def test_endpoints():
+        """Liste des endpoints disponibles"""
+        endpoints = {
+            "chat": {
+                "path": "/chat/learn",
+                "method": "POST",
+                "description": "Générer cours et quiz",
+                "input": {
+                    "topic": "Finance personnelle",
+                    "sector": "finance",
+                    "tone": "friendly",
+                    "style": "simple",
+                    "length": "full"
+                }
+            },
+            "quiz": {
+                "path": "/quiz/evaluate",
+                "method": "POST", 
+                "description": "Évaluer les réponses du quiz"
+            },
+            "audio": {
+                "path": "/audio/generate",
+                "method": "POST",
+                "description": "Convertir texte en audio"
+            },
+            "video": {
+                "path": "/video/generate",
+                "method": "POST",
+                "description": "Générer vidéo avec IA"
+            },
+            "integrated": {
+                "complete-course": {
+                    "path": "/integrated/complete-course",
+                    "method": "POST",
+                    "description": "Générer package complet (cours + quiz + scènes vidéo) en une inference"
+                },
+                "video-from-scenes": {
+                    "path": "/integrated/video-from-scenes", 
+                    "method": "POST",
+                    "description": "Générer vidéo à partir des scènes"
+                },
+                "full-pipeline": {
+                    "path": "/integrated/full-pipeline",
+                    "method": "POST",
+                    "description": "Pipeline complet (contenu + vidéo) en un appel"
+                }
+            }
+        }
+        return {"endpoints": endpoints, "total_count": len(endpoints)}
+    
+    if __name__ == "__main__":
+        import uvicorn
+        print("🚀 Lancement de l'API JANGG en mode test...")
+        print("📖 Documentation: http://localhost:8000/docs")
+        print("🔍 Test endpoints: http://localhost:8000/test-endpoints")
+        uvicorn.run(app, host="0.0.0.0", port=8000)
+
+except ImportError as e:
+    print(f"❌ Erreur d'import: {e}")
+    print("📦 Installation des dépendances de base...")
+    os.system("pip3 install fastapi uvicorn --break-system-packages")
+    print("✅ Installation terminée. Relancez le script.")

total_api.py

@@ -0,0 +1,702 @@
+#!/usr/bin/env python3
+"""
+🤖 JANGG AI API - Version Complète pour Colab
+API exhaustive dans un seul fichier - Pas de GPU requis
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional
+import uuid
+import time
+import json
+import random
+from datetime import datetime
+
+# Création de l'application FastAPI
+app = FastAPI(
+    title="🤖 JANGG AI API - Complete Version",
+    description="API complète pour l'apprentissage interactif avec IA (Mode Colab)",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# ==================== SCHÉMAS DE DONNÉES ====================
+
+class LearnRequest(BaseModel):
+    topic: str = Field(..., description="Sujet à apprendre")
+    sector: str = Field(..., description="Secteur cible (finance, tech, health)")
+    tone: str = Field(..., description="Ton du contenu (friendly, formal, casual)")
+    style: str = Field(..., description="Style d'explication (simple, detailed, technical)")
+    length: str = Field(..., description="Longueur du cours (short, full)")
+
+class Scene(BaseModel):
+    title: str = Field(..., description="Titre de la scène")
+    content: str = Field(..., description="Contenu narratif de la scène")
+    duration: int = Field(..., description="Durée en secondes")
+    visual_prompt: Optional[str] = Field(None, description="Prompt visuel pour IA")
+
+class VideoRequest(BaseModel):
+    topic: str = Field(..., description="Sujet de la vidéo")
+    style: str = Field(default="cartoon", description="Style visuel")
+    tone: str = Field(default="fun", description="Ton du contenu")
+    language: str = Field(default="fr", description="Langue pour l'audio")
+    scenes: List[Scene] = Field(..., description="Liste des scènes")
+
+class QuizEvaluation(BaseModel):
+    quiz: List[Dict] = Field(..., description="Questions du quiz")
+    answers: List[int] = Field(..., description="Réponses de l'utilisateur")
+
+class AudioRequest(BaseModel):
+    text: str = Field(..., description="Texte à convertir en audio")
+
+class CompleteCourseResponse(BaseModel):
+    course: str = Field(..., description="Contenu du cours généré")
+    quiz: List[Dict] = Field(..., description="Quiz généré")
+    video_scenes: List[Scene] = Field(..., description="Scènes pour vidéo")
+    message: str = Field(default="Package complet généré avec succès")
+    generation_method: str = Field(default="unified_llm")
+
+# ==================== FONCTIONS UTILITAIRES ====================
+
+def generate_mock_course(topic: str, sector: str, tone: str, style: str, length: str) -> str:
+    """Génère un cours simulé basé sur le sujet"""
+    courses = {
+        "finance": f"""
+# 📚 {topic.title()} - Cours Complet
+
+## Introduction
+La {topic.lower()} est essentielle dans le secteur {sector}. 
+Avec une approche {tone} et un style {style}, vous allez maîtriser ce sujet.
+
+## Concepts Fondamentaux
+1. **Définition**: Comprendre les bases de {topic.lower()}
+2. **Applications**: Comment appliquer ces connaissances en pratique
+3. **Bonnes pratiques**: Les meilleures stratégies à adopter
+
+## Cas Pratique
+Voici un exemple concret dans le contexte {sector}:
+- Étape 1: Analyse de la situation
+- Étape 2: Mise en œuvre des solutions
+- Étape 3: Évaluation des résultats
+
+## Conclusion
+Félicitations ! Vous avez maintenant les bases solides en {topic.lower()}.
+""",
+        "tech": f"""
+# 💻 {topic.title()} - Guide Technique
+
+## Vue d'Ensemble
+{topic} est un domaine crucial dans la technologie moderne.
+Ce cours {tone} vous permettra de comprendre les concepts {style}.
+
+## Architecture Principale
+- **Composants**: Éléments essentiels de {topic}
+- **Intégration**: Comment tout s'assemble
+- **Optimisation**: Meilleures pratiques de performance
+
+## Implémentation
+```python
+# Exemple de code pour {topic.lower()}
+def implement_{topic.lower().replace(' ', '_')}():
+    return "Solution {topic} avec style {style}"
+```
+
+## Prochaines Étapes
+Continuez votre apprentissage avec des projets pratiques !
+"""
+    }
+    
+    return courses.get(sector.lower(), courses["finance"])
+
+def generate_mock_quiz(topic: str) -> List[Dict]:
+    """Génère un quiz simulé basé sur le sujet"""
+    return [
+        {
+            "question": f"Quelle est l'importance de {topic} dans le secteur professionnel ?",
+            "options": [
+                "Très importante, c'est essentiel",
+                "Importante mais pas critique",
+                "Optionnel selon le contexte",
+                "Pas vraiment nécessaire"
+            ],
+            "answer": 0
+        },
+        {
+            "question": f"Quelle est la meilleure approche pour apprendre {topic} ?",
+            "options": [
+                "Pratique régulière",
+                "Théorie seulement",
+                "Une seule fois suffit",
+                "Sans méthode particulière"
+            ],
+            "answer": 0
+        },
+        {
+            "question": f"Comment appliquer {topic} dans un projet réel ?",
+            "options": [
+                "Étape par étape avec planification",
+                "Directement sans préparation",
+                "Seulement avec un expert",
+                "Jamais en pratique"
+            ],
+            "answer": 0
+        }
+    ]
+
+def generate_mock_scenes(topic: str, style: str) -> List[Scene]:
+    """Génère des scènes vidéo simulées"""
+    return [
+        Scene(
+            title="Introduction",
+            content=f"Bienvenue dans ce cours sur {topic}. Découvrons ensemble les concepts fondamentaux.",
+            duration=8,
+            visual_prompt=f"{style} style, educational introduction about {topic}, bright and engaging"
+        ),
+        Scene(
+            title="Concepts Clés",
+            content=f"Les concepts essentiels de {topic} sont simples à comprendre avec la bonne approche.",
+            duration=10,
+            visual_prompt=f"{style} style, key concepts visualization for {topic}, clear and structured"
+        ),
+        Scene(
+            title="Application Pratique",
+            content=f"Appliquons maintenant {topic} dans un contexte réel et concret.",
+            duration=12,
+            visual_prompt=f"{style} style, practical application of {topic}, hands-on demonstration"
+        ),
+        Scene(
+            title="Conclusion",
+            content=f"Félicitations ! Vous maîtrisez maintenant les bases de {topic}. Continuez à pratiquer.",
+            duration=8,
+            visual_prompt=f"{style} style, celebration and achievement, learning success"
+        )
+    ]
+
+def generate_mock_audio_url(text: str) -> str:
+    """Génère une URL audio simulée"""
+    return f"https://example.com/audio/{uuid.uuid4().hex[:8]}.mp3"
+
+def generate_mock_video_path(topic: str) -> str:
+    """Génère un chemin vidéo simulé"""
+    return f"output/videos/{topic.replace(' ', '_')}_{uuid.uuid4().hex[:8]}.mp4"
+
+# ==================== ENDPOINTS PRINCIPAUX ====================
+
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """Page d'accueil de l'API"""
+    return HTMLResponse(content="""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>🤖 JANGG AI API - Complete Version</title>
+        <style>
+            body { font-family: Arial, sans-serif; max-width: 1000px; margin: 0 auto; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; }
+            .header { text-align: center; margin-bottom: 40px; }
+            .endpoint { background: rgba(255,255,255,0.1); padding: 20px; margin: 15px 0; border-radius: 10px; backdrop-filter: blur(10px); }
+            .method { color: #4ade80; font-weight: bold; font-size: 18px; }
+            .path { color: #60a5fa; font-family: monospace; font-size: 16px; }
+            .description { color: #e2e8f0; margin-top: 8px; }
+            .docs-link { background: #4ade80; color: #1e293b; padding: 15px 30px; text-decoration: none; border-radius: 8px; display: inline-block; margin: 10px; font-weight: bold; }
+            .feature { background: rgba(255,255,255,0.05); padding: 15px; border-radius: 8px; margin: 10px 0; }
+        </style>
+    </head>
+    <body>
+        <div class="header">
+            <h1>🤖 JANGG AI API - Complete Version</h1>
+            <p>API exhaustive pour l'apprentissage interactif avec IA (Mode Colab)</p>
+        </div>
+        
+        <div class="feature">
+            <h3>🚀 Fonctionnalités Complètes</h3>
+            <ul>
+                <li>📚 Génération de cours personnalisés</li>
+                <li>🎯 Création de quiz interactifs</li>
+                <li>🎥 Génération de vidéos avec IA</li>
+                <li>🔊 Synthèse vocale (TTS)</li>
+                <li>🔄 Pipeline intégré complet</li>
+            </ul>
+        </div>
+        
+        <h2>📋 Endpoints Disponibles</h2>
+        
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/chat/learn</span>
+            <div class="description">Générer cours et quiz personnalisés</div>
+        </div>
+        
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/quiz/evaluate</span>
+            <div class="description">Évaluer les réponses du quiz</div>
+        </div>
+        
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/audio/generate</span>
+            <div class="description">Convertir texte en audio (TTS)</div>
+        </div>
+        
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/video/generate</span>
+            <div class="description">Générer vidéo avec IA et narration</div>
+        </div>
+        
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/integrated/complete-course</span>
+            <div class="description">Package complet (cours + quiz + scènes vidéo) en une seule requête</div>
+        </div>
+        
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/integrated/full-pipeline</span>
+            <div class="description">Pipeline complet avec génération vidéo finale</div>
+        </div>
+        
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/integrated/video-from-scenes</span>
+            <div class="description">Générer vidéo à partir de scènes pré-existantes</div>
+        </div>
+        
+        <div style="text-align: center; margin-top: 40px;">
+            <a href="/docs" class="docs-link">📖 Documentation Interactive (Swagger)</a>
+            <a href="/redoc" class="docs-link">📋 Documentation Alternative (ReDoc)</a>
+        </div>
+        
+        <div style="text-align: center; margin-top: 30px; opacity: 0.8;">
+            <p>© 2026 JANGG AI API - Mode Colab Optimisé</p>
+        </div>
+    </body>
+    </html>
+    """)
+
+@app.get("/health")
+async def health_check():
+    """Vérification de santé de l'API"""
+    return {
+        "status": "healthy",
+        "api": "JANGG AI API - Complete Version",
+        "version": "1.0.0",
+        "mode": "colab_optimized",
+        "features": ["chat", "quiz", "audio", "video", "integrated"],
+        "timestamp": datetime.now().isoformat()
+    }
+
+# ==================== ENDPOINTS CHAT ====================
+
+@app.post("/chat/learn")
+async def learn_course(req: LearnRequest):
+    """
+    Générer un cours complet et un quiz personnalisé
+    
+    Cet endpoint crée du contenu éducatif adapté aux paramètres spécifiés.
+    """
+    try:
+        start_time = time.time()
+        
+        # Génération du contenu
+        course = generate_mock_course(req.topic, req.sector, req.tone, req.style, req.length)
+        quiz = generate_mock_quiz(req.topic)
+        audio_url = generate_mock_audio_url(req.topic)
+        
+        processing_time = time.time() - start_time
+        
+        return {
+            "course": course.strip(),
+            "quiz": quiz,
+            "audio_url": audio_url,
+            "processing_time": processing_time,
+            "message": f"Cours généré avec succès pour {req.topic}",
+            "parameters": {
+                "topic": req.topic,
+                "sector": req.sector,
+                "tone": req.tone,
+                "style": req.style,
+                "length": req.length
+            }
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur lors de la génération du cours: {str(e)}")
+
+# ==================== ENDPOINTS QUIZ ====================
+
+@app.post("/quiz/evaluate")
+async def evaluate_quiz(req: QuizEvaluation):
+    """
+    Évaluer les réponses d'un quiz
+    
+    Calcule le score et fournit un feedback personnalisé.
+    """
+    try:
+        correct_answers = 0
+        feedback = []
+        
+        for i, (question, user_answer) in enumerate(zip(req.quiz, req.answers)):
+            correct = question["answer"]
+            is_correct = user_answer == correct
+            
+            if is_correct:
+                correct_answers += 1
+                feedback.append(f"✅ Question {i+1}: Correct! '{question['options'][user_answer]}'")
+            else:
+                correct_option = question['options'][correct]
+                user_option = question['options'][user_answer]
+                feedback.append(f"❌ Question {i+1}: Incorrect. Votre réponse: '{user_option}'. Correct: '{correct_option}'")
+        
+        score = (correct_answers / len(req.quiz)) * 100
+        
+        # Message personnalisé basé sur le score
+        if score >= 80:
+            message = "🎉 Excellent travail! Vous maîtrisez bien le sujet!"
+        elif score >= 60:
+            message = "👍 Bon travail! Quelques améliorations possibles."
+        elif score >= 40:
+            message = "📚 Pas mal! Continuez à pratiquer."
+        else:
+            message = "💪 Continuez vos efforts! La pratique fait la perfection."
+        
+        return {
+            "score": round(score, 1),
+            "correct_answers": correct_answers,
+            "total_questions": len(req.quiz),
+            "feedback": feedback,
+            "message": message,
+            "evaluation_time": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur lors de l'évaluation: {str(e)}")
+
+# ==================== ENDPOINTS AUDIO ====================
+
+@app.post("/audio/generate")
+async def generate_audio(req: AudioRequest):
+    """
+    Convertir du texte en audio (Text-to-Speech)
+    
+    Génère un fichier audio à partir du texte fourni.
+    """
+    try:
+        start_time = time.time()
+        
+        # Simulation de génération audio
+        audio_url = generate_mock_audio_url(req.text)
+        duration = len(req.text.split()) * 0.5  # Estimation: 0.5s par mot
+        
+        processing_time = time.time() - start_time
+        
+        return {
+            "audio_url": audio_url,
+            "text": req.text,
+            "duration": round(duration, 2),
+            "processing_time": processing_time,
+            "message": "Audio généré avec succès",
+            "format": "mp3",
+            "language": "fr"
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur lors de la génération audio: {str(e)}")
+
+# ==================== ENDPOINTS VIDÉO ====================
+
+@app.post("/video/generate")
+async def generate_video(req: VideoRequest):
+    """
+    Générer une vidéo éducative avec IA
+    
+    Crée une vidéo complète à partir des scènes fournies.
+    """
+    try:
+        start_time = time.time()
+        
+        # Simulation de génération vidéo
+        video_path = generate_mock_video_path(req.topic)
+        total_duration = sum(scene.duration for scene in req.scenes)
+        
+        processing_time = time.time() - start_time
+        
+        return {
+            "video_path": video_path,
+            "topic": req.topic,
+            "style": req.style,
+            "language": req.language,
+            "scenes_processed": len(req.scenes),
+            "total_duration": total_duration,
+            "processing_time": processing_time,
+            "message": "Vidéo générée avec succès",
+            "resolution": "1920x1080",
+            "fps": 30,
+            "format": "mp4"
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur lors de la génération vidéo: {str(e)}")
+
+@app.get("/video/health")
+async def video_health_check():
+    """Vérification de santé du service vidéo"""
+    return {
+        "status": "healthy",
+        "service": "video_generation",
+        "model_loaded": True,
+        "gpu_available": False,
+        "mode": "cpu_simulation",
+        "supported_formats": ["mp4", "avi", "mov"],
+        "max_duration": 600  # 10 minutes max
+    }
+
+# ==================== ENDPOINTS INTÉGRÉS ====================
+
+@app.post("/integrated/complete-course", response_model=CompleteCourseResponse)
+async def generate_complete_course(req: LearnRequest):
+    """
+    Générer un package d'apprentissage complet en une seule requête
+    
+    Cet endpoint unifié génère:
+    - Cours structuré
+    - Quiz interactif  
+    - Scènes vidéo prêtes à l'emploi
+    
+    Tout est généré de manière cohérente en une seule opération.
+    """
+    try:
+        start_time = time.time()
+        
+        # Génération unifiée
+        course = generate_mock_course(req.topic, req.sector, req.tone, req.style, req.length)
+        quiz = generate_mock_quiz(req.topic)
+        video_scenes = generate_mock_scenes(req.topic, req.style)
+        
+        processing_time = time.time() - start_time
+        
+        return CompleteCourseResponse(
+            course=course.strip(),
+            quiz=quiz,
+            video_scenes=video_scenes,
+            message="Package complet généré avec succès",
+            generation_method="unified_llm_simulation"
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur lors de la génération du package: {str(e)}")
+
+@app.post("/integrated/video-from-scenes")
+async def generate_video_from_scenes(req: VideoRequest):
+    """
+    Générer une vidéo à partir de scènes pré-existantes
+    
+    Utilisez cet endpoint avec les scènes de /integrated/complete-course
+    """
+    try:
+        start_time = time.time()
+        
+        video_path = generate_mock_video_path(req.topic)
+        total_duration = sum(scene.duration for scene in req.scenes)
+        
+        # Ajout de prompts visuels si manquants
+        enhanced_scenes = []
+        for scene in req.scenes:
+            if not scene.visual_prompt:
+                scene.visual_prompt = f"{req.style} style, {scene.title}, educational content"
+            enhanced_scenes.append(scene)
+        
+        processing_time = time.time() - start_time
+        
+        return {
+            "video_path": video_path,
+            "scenes_used": len(req.scenes),
+            "total_duration": total_duration,
+            "processing_time": processing_time,
+            "enhanced_scenes": enhanced_scenes,
+            "message": "Vidéo générée à partir des scènes avec succès"
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur lors de la génération vidéo: {str(e)}")
+
+@app.post("/integrated/full-pipeline")
+async def generate_full_pipeline(req: LearnRequest):
+    """
+    Pipeline complet: génération de contenu ET création vidéo
+    
+    C'est l'endpoint le plus complet - il fait tout!
+    """
+    try:
+        start_time = time.time()
+        
+        # Étape 1: Génération du contenu complet
+        course = generate_mock_course(req.topic, req.sector, req.tone, req.style, req.length)
+        quiz = generate_mock_quiz(req.topic)
+        video_scenes = generate_mock_scenes(req.topic, req.style)
+        
+        # Étape 2: Génération vidéo
+        video_path = generate_mock_video_path(req.topic)
+        total_duration = sum(scene.duration for scene in video_scenes)
+        
+        # Étape 3: Génération audio
+        audio_url = generate_mock_audio_url(req.topic)
+        
+        total_time = time.time() - start_time
+        
+        return {
+            # Contenu généré
+            "course": course.strip(),
+            "quiz": quiz,
+            "video_scenes": video_scenes,
+            
+            # Fichiers générés
+            "video_path": video_path,
+            "audio_url": audio_url,
+            
+            # Métadonnées
+            "total_duration": total_duration,
+            "total_processing_time": total_time,
+            "generation_method": "full_pipeline_simulation",
+            "message": "🎉 Pipeline complet terminé avec succès!",
+            
+            # Paramètres
+            "parameters": {
+                "topic": req.topic,
+                "sector": req.sector,
+                "tone": req.tone,
+                "style": req.style,
+                "length": req.length
+            },
+            
+            # Statistiques
+            "stats": {
+                "course_words": len(course.split()),
+                "quiz_questions": len(quiz),
+                "video_scenes": len(video_scenes),
+                "estimated_video_size": f"{round(total_duration * 2)}MB"
+            }
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur lors du pipeline: {str(e)}")
+
+# ==================== ENDPOINTS UTILITAIRES ====================
+
+@app.get("/endpoints")
+async def list_endpoints():
+    """Liste tous les endpoints disponibles avec leurs détails"""
+    return {
+        "api_info": {
+            "title": "JANGG AI API - Complete Version",
+            "version": "1.0.0",
+            "mode": "colab_optimized",
+            "total_endpoints": 9
+        },
+        "endpoints": {
+            "chat": {
+                "path": "/chat/learn",
+                "method": "POST",
+                "description": "Générer cours et quiz personnalisés",
+                "features": ["course_generation", "quiz_creation", "audio_url"]
+            },
+            "quiz": {
+                "path": "/quiz/evaluate",
+                "method": "POST", 
+                "description": "Évaluer les réponses du quiz",
+                "features": ["score_calculation", "detailed_feedback", "performance_analysis"]
+            },
+            "audio": {
+                "path": "/audio/generate",
+                "method": "POST",
+                "description": "Convertir texte en audio (TTS)",
+                "features": ["text_to_speech", "duration_estimation", "mp3_format"]
+            },
+            "video": {
+                "generate": {
+                    "path": "/video/generate",
+                    "method": "POST",
+                    "description": "Générer vidéo avec IA",
+                    "features": ["scene_processing", "video_compilation", "multiple_formats"]
+                },
+                "health": {
+                    "path": "/video/health",
+                    "method": "GET",
+                    "description": "Vérifier l'état du service vidéo",
+                    "features": ["service_status", "capabilities_check"]
+                }
+            },
+            "integrated": {
+                "complete_course": {
+                    "path": "/integrated/complete-course",
+                    "method": "POST",
+                    "description": "Package complet en une requête",
+                    "features": ["unified_generation", "coherent_content", "video_ready_scenes"]
+                },
+                "video_from_scenes": {
+                    "path": "/integrated/video-from-scenes",
+                    "method": "POST",
+                    "description": "Générer vidéo depuis scènes",
+                    "features": ["scene_enhancement", "video_generation", "custom_scenes"]
+                },
+                "full_pipeline": {
+                    "path": "/integrated/full-pipeline",
+                    "method": "POST",
+                    "description": "Pipeline complet avec vidéo",
+                    "features": ["everything_included", "complete_solution", "all_files"]
+                }
+            }
+        },
+        "features": {
+            "no_gpu_required": True,
+            "colab_optimized": True,
+            "simulated_responses": True,
+            "full_documentation": True,
+            "interactive_testing": True
+        }
+    }
+
+@app.get("/test/sample-data")
+async def get_sample_data():
+    """Données de test pour tous les endpoints"""
+    return {
+        "learn_request": {
+            "topic": "Finance personnelle",
+            "sector": "finance",
+            "tone": "friendly",
+            "style": "simple",
+            "length": "full"
+        },
+        "video_request": {
+            "topic": "Finance personnelle",
+            "style": "cartoon",
+            "tone": "fun",
+            "language": "fr",
+            "scenes": [
+                {
+                    "title": "Introduction",
+                    "content": "Bienvenue dans ce cours sur la finance personnelle",
+                    "duration": 8
+                }
+            ]
+        },
+        "quiz_evaluation": {
+            "quiz": [
+                {
+                    "question": "Question test?",
+                    "options": ["A", "B", "C", "D"],
+                    "answer": 0
+                }
+            ],
+            "answers": [0]
+        },
+        "audio_request": {
+            "text": "Bonjour, ceci est un test de génération audio."
+        }
+    }
+
+# ==================== LANCEMENT ====================
+
+if __name__ == "__main__":
+    import uvicorn
+    print("🚀 Lancement de JANGG AI API - Version Complète")
+    print("📖 Documentation: http://localhost:8000/docs")
+    print("🎯 Test rapide: http://localhost:8000/endpoints")
+    print("💡 Mode Colab Optimisé - Pas de GPU requis!")
+    uvicorn.run(app, host="0.0.0.0", port=8000)

total_api_standalone.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+"""
+🤖 JANGG AI API - 100% Autonome pour Colab
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional
+import uuid
+import time
+from fastapi.openapi.utils import get_openapi
+
+app = FastAPI(
+    title="🤖 JANGG AI API - Standalone",
+    description="API complète pour l'apprentissage avec IA - Version autonome",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Schémas
+class LearnRequest(BaseModel):
+    topic: str
+    sector: str
+    tone: str
+    style: str
+    length: str
+
+class Scene(BaseModel):
+    title: str
+    content: str
+    duration: int
+
+class VideoRequest(BaseModel):
+    topic: str
+    style: str = "cartoon"
+    tone: str = "fun"
+    language: str = "fr"
+    scenes: List[Scene]
+
+class QuizEvaluation(BaseModel):
+    quiz: List[Dict]
+    answers: List[int]
+
+class AudioRequest(BaseModel):
+    text: str
+
+# Services
+class LearningService:
+    @staticmethod
+    def generate_course(topic: str, sector: str, tone: str, style: str, length: str) -> str:
+        return f"""
+# {topic.title()} - Cours Complet
+
+## Introduction
+La {topic.lower()} est essentielle dans le secteur {sector}.
+Approche {tone} avec style {style}.
+
+## Concepts
+1. Principes fondamentaux
+2. Applications pratiques
+3. Meilleures pratiques
+4. Études de cas
+
+## Conclusion
+Félicitations! Vous maîtrisez {topic}.
+"""
+    
+    @staticmethod
+    def generate_quiz(topic: str) -> List[Dict]:
+        return [{
+            "question": f"Importance de {topic}?",
+            "options": ["Essentielle", "Importante", "Optionnelle", "Non nécessaire"],
+            "answer": 0
+        }]
+    
+    @staticmethod
+    def generate_scenes(topic: str, style: str) -> List[Scene]:
+        return [
+            Scene(title="Intro", content=f"Découvrons {topic}", duration=8),
+            Scene(title="Concepts", content=f"Concepts de {topic}", duration=10),
+            Scene(title="Conclusion", content=f"Bravo pour {topic}!", duration=8)
+        ]
+
+# Endpoints
+@app.get("/", include_in_schema=False)
+async def root():
+    return HTMLResponse("""
+    <h1>🤖 JANGG AI API - Standalone</h1>
+    <p>Bienvenue sur l'API autonome JANGG AI !</p>
+    <p>📚 <a href="/docs">Documentation Swagger</a></p>
+    <p>🔍 <a href="/redoc">Documentation ReDoc</a></p>
+    <p>🔄 <a href="/health">Vérifier l'état</a></p>
+    """)
+
+@app.get("/health", 
+         summary="Vérifier l'état de l'API",
+         description="Vérifie que l'API est opérationnelle",
+         response_description="État de santé de l'API")
+async def health():
+    return {"status": "healthy", "api": "JANGG Standalone"}
+
+@app.post("/chat/learn", 
+          summary="Générer un cours et un quiz",
+          description="Crée un contenu éducatif personnalisé avec quiz intégré",
+          response_description="Retourne le cours généré et un quiz")
+async def learn(req: LearnRequest):
+    course = LearningService.generate_course(req.topic, req.sector, req.tone, req.style, req.length)
+    quiz = LearningService.generate_quiz(req.topic)
+    return {"course": course, "quiz": quiz, "audio_url": f"audio_{uuid.uuid4().hex[:8]}.mp3"}
+
+@app.post("/quiz/evaluate",
+          summary="Évaluer un quiz",
+          description="Calcule le score et fournit un feedback",
+          response_description="Résultats de l'évaluation")
+async def evaluate_quiz(req: QuizEvaluation):
+    correct = sum(1 for q, a in zip(req.quiz, req.answers) if q["answer"] == a)
+    score = (correct / len(req.quiz)) * 100
+    return {"score": score, "correct": correct, "total": len(req.quiz)}
+
+@app.post("/audio/generate",
+          summary="Générer un audio",
+          description="Convertit du texte en parole (TTS)",
+          response_description="URL de l'audio généré")
+async def generate_audio(req: AudioRequest):
+    return {"audio_url": f"audio_{uuid.uuid4().hex[:8]}.mp3", "duration": len(req.text.split()) * 0.5}
+
+@app.post("/video/generate",
+          summary="Générer une vidéo",
+          description="Crée une vidéo à partir de scènes",
+          response_description="Détails de la vidéo générée")
+async def generate_video(req: VideoRequest):
+    return {
+        "video_path": f"video_{req.topic.replace(' ', '_')}_{uuid.uuid4().hex[:8]}.mp4",
+        "duration": sum(s.duration for s in req.scenes)
+    }
+
+@app.post("/integrated/complete-course",
+          summary="Générer un package complet",
+          description="Cours + Quiz + Scènes vidéo en une seule requête",
+          response_description="Package complet d'apprentissage")
+async def complete_course(req: LearnRequest):
+    course = LearningService.generate_course(req.topic, req.sector, req.tone, req.style, req.length)
+    quiz = LearningService.generate_quiz(req.topic)
+    scenes = LearningService.generate_scenes(req.topic, req.style)
+    return {
+        "course": course,
+        "quiz": quiz,
+        "video_scenes": scenes,
+        "message": "Package complet généré"
+    }
+
+@app.post("/integrated/full-pipeline",
+          summary="Pipeline complet",
+          description="Génère tout le contenu + vidéo + audio",
+          response_description="Résultats du pipeline complet")
+async def full_pipeline(req: LearnRequest):
+    course = LearningService.generate_course(req.topic, req.sector, req.tone, req.style, req.length)
+    quiz = LearningService.generate_quiz(req.topic)
+    scenes = LearningService.generate_scenes(req.topic, req.style)
+    return {
+        "course": course,
+        "quiz": quiz,
+        "video_scenes": scenes,
+        "video_path": f"full_{req.topic.replace(' ', '_')}_{uuid.uuid4().hex[:8]}.mp4",
+        "audio_url": f"audio_{uuid.uuid4().hex[:8]}.mp3"
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    print("🚀 JANGG API Standalone - Prêt pour Colab!")
+    print("📖 Documentation complète: http://localhost:8000/docs")
+    print("🔍 Documentation alternative: http://localhost:8000/redoc")
+    uvicorn.run(app, host="0.0.0.0", port=8000)