Spaces:

FredyHoundayi
/

JANGG_AI_API

Sleeping

App Files Files Community

FredyHoundayi commited on Feb 1

Commit

49e494e

1 Parent(s): 23f994a

Refactor: Nettoyage et organisation du code pour le déploiement

Browse files

Files changed (9) hide show

.gitignore +14 -70
README.md +25 -11
app/main.py +0 -118
app/untitled0.py +0 -160
main.py +31 -2
requirements.txt +12 -44
test_api.py +0 -88
total_api.py +0 -702
total_api_standalone.py +0 -175

.gitignore CHANGED Viewed

@@ -1,75 +1,19 @@
-# 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
-MANIFEST
-# Virtual environments
-.env
-.venv
-env/
 venv/
-ENV/
-env.bak/
-venv.bak/
-demo-env/
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-# OS
-.DS_Store
-.DS_Store?
-._*
-.Spotlight-V100
-.Trashes
-ehthumbs.db
-Thumbs.db
-# Logs
-*.log
-logs/
-# Database
-*.db
-*.sqlite3
-# Jupyter Notebook
-.ipynb_checkpoints
-# pytest
-.coverage
-.pytest_cache/
-htmlcov/
-# mypy
 .mypy_cache/
-.dmypy.json
-dmypy.json
-# Audio files
-app/static/audio/
 *.mp3
 *.wav
-*.ogg

 __pycache__/
+.venv/
 venv/
+env/
+.env
+*.pyc
+*.pyo
+*.pyd
+.Python
 .mypy_cache/
+.pytest_cache/
 *.mp3
+*.mp4
 *.wav
+*.jpg
+*.png
+*.gif
+*.log

README.md CHANGED Viewed

@@ -1,11 +1,25 @@
----
-title: JANGG AI API
-emoji: 🌖
-colorFrom: indigo
-colorTo: pink
-sdk: docker
-pinned: false
-short_description: demo friday 30/01/2026
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

+# JANGG API
+API complète pour la génération de contenu éducatif avec IA
+## Installation
+1. Cloner le dépôt
+2. Créer un environnement virtuel : `python -m venv venv`
+3. Activer l'environnement :
+   - Windows: `venv\Scripts\activate`
+   - Linux/Mac: `source venv/bin/activate`
+4. Installer les dépendances : `pip install -r requirements.txt`
+5. Copier `.env.example` vers `.env` et configurer les variables
+6. Lancer l'API : `uvicorn main:app --reload`
+## Structure
+- `app/` - Code source principal
+  - `routers/` - Définition des routes API
+  - `schemas/` - Modèles Pydantic
+  - `services/` - Logique métier
+  - `prompts/` - Templates pour les prompts IA
+- `static/` - Fichiers statiques (images, audio, vidéos)
+- `main.py` - Point d'entrée de l'application

app/main.py DELETED Viewed

@@ -1,118 +0,0 @@
-from fastapi import FastAPI
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import HTMLResponse
-from app.routers import chat, quiz, audio, video, integrated
-app = FastAPI(title="JANGG AI API", description="Intelligent API for interactive learning with AI")
-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():
-    html_content = """
-    <!DOCTYPE html>
-    <html>
-    <head>
-        <title>JANGG AI API</title>
-        <style>
-            body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
-            .header { text-align: center; color: #2c3e50; margin-bottom: 30px; }
-            .endpoint { background: #f8f9fa; padding: 15px; margin: 10px 0; border-radius: 5px; border-left: 4px solid #3498db; }
-            .method { color: #27ae60; font-weight: bold; }
-            .path { color: #2980b9; font-family: monospace; }
-            .description { color: #34495e; margin-top: 5px; }
-            .docs-link { background: #3498db; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px; display: inline-block; margin-top: 20px; }
-        </style>
-    </head>
-    <body>
-        <div class="header">
-            <h1>🤖 JANGG AI API</h1>
-            <p>Intelligent API for interactive learning with AI</p>
-        </div>
-        <h2>📚 Available Endpoints</h2>
-        <div class="endpoint">
-            <span class="method">GET</span> <span class="path">/</span>
-            <div class="description">API home page</div>
-        </div>
-        <div class="endpoint">
-            <span class="method">GET</span> <span class="path">/health</span>
-            <div class="description">API health check</div>
-        </div>
-        <div class="endpoint">
-            <span class="method">POST</span> <span class="path">/chat/</span>
-            <div class="description">AI chat interface for interactive conversations</div>
-        </div>
-        <div class="endpoint">
-            <span class="method">POST</span> <span class="path">/quiz/generate</span>
-            <div class="description">Generate personalized quizzes based on a topic</div>
-        </div>
-        <div class="endpoint">
-            <span class="method">POST</span> <span class="path">/quiz/validate</span>
-            <div class="description">Validate quiz answers</div>
-        </div>
-        <div class="endpoint">
-            <span class="method">POST</span> <span class="path">/audio/text-to-speech</span>
-            <div class="description">Convert text to speech</div>
-        </div>
-        <div class="endpoint">
-            <span class="method">POST</span> <span class="path">/audio/speech-to-text</span>
-            <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>
-            <a href="/redoc" class="docs-link">📋 Alternative Documentation (ReDoc)</a>
-        </div>
-        <div style="text-align: center; margin-top: 30px; color: #7f8c8d;">
-            <p>© 2026 JANGG AI API - Intelligent Learning Platform</p>
-        </div>
-    </body>
-    </html>
-    """
-    return HTMLResponse(content=html_content)
-@app.get("/health")
-async def health_check():
-    return {"status": "healthy", "api": "JANGG AI API", "version": "1.0.0"}

app/untitled0.py DELETED Viewed

@@ -1,160 +0,0 @@
-# -*- 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)

main.py CHANGED Viewed

@@ -1,5 +1,34 @@
-from app.main import app
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)

+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.routers import chat, quiz, audio, video, integrated
+app = FastAPI(
+    title="🤖 JANGG AI API",
+    description="API complète pour la génération de contenu éducatif avec IA",
+    version="1.0.0"
+)
+# Configuration CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+# Inclusion des routeurs
+app.include_router(chat.router, prefix="/chat", tags=["Chat"])
+app.include_router(quiz.router, prefix="/quiz", tags=["Quiz"])
+app.include_router(audio.router, prefix="/audio", tags=["Audio"])
+app.include_router(video.router, prefix="/video", tags=["Video"])
+app.include_router(integrated.router, prefix="/integrated", tags=["Integrated"])
+@app.get("/", include_in_schema=False)
+async def root():
+    return {"message": "Bienvenue sur l'API JANGG AI"}
 if __name__ == "__main__":
     import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

requirements.txt CHANGED Viewed

@@ -1,45 +1,13 @@
-# 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
-# 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

+fastapi>=0.68.0
+uvicorn>=0.15.0
+pydantic>=1.8.0
+gtts>=2.3.0
+pydub>=0.25.1
+python-dotenv>=0.19.0
+diffusers>=0.10.0
+torch>=1.12.0
+torchvision>=0.13.0
+transformers>=4.21.0
+accelerate>=0.12.0
+python-multipart>=0.0.5

test_api.py DELETED Viewed

@@ -1,88 +0,0 @@
-#!/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 DELETED Viewed

@@ -1,702 +0,0 @@
-#!/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 DELETED Viewed

@@ -1,175 +0,0 @@
-#!/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)