Déploiement propre initial sans fichiers volumineux

Dockerfile

@@ -0,0 +1,27 @@
+# Utiliser une image Python officielle comme base
+FROM python:3.9-slim
+
+# Définir le répertoire de travail dans le conteneur
+WORKDIR /code
+
+# Copier le fichier des dépendances
+COPY ./requirements.txt /code/requirements.txt
+
+# Mettre à jour pip et installer les dépendances
+# --no-cache-dir réduit la taille de l'image
+# --default-timeout augmente le délai pour les gros téléchargements comme torch
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir --default-timeout=300 -r /code/requirements.txt
+
+# Copier le reste du code de l'application
+# On copie le dossier 'app' qui contient main.py, processing.py, etc.
+# et les dossiers static/templates
+COPY ./app /code/app
+
+# Le port sur lequel Uvicorn écoutera.
+# Hugging Face Spaces injecte la variable $PORT (souvent 7860 par défaut).
+# EXPOSE ${PORT:-7860} # Pas strictement nécessaire car Spaces gère le mapping
+
+# Commande pour lancer l'application
+# Uvicorn écoutera sur toutes les interfaces (0.0.0.0) sur le port fourni par Spaces.
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "${PORT:-7860}"]

README.md

@@ -1,11 +0,0 @@
----
-title: Autocaption App
-emoji: 🚀
-colorFrom: indigo
-colorTo: indigo
-sdk: docker
-pinned: false
-short_description: Création de description d'images
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/main.py

@@ -0,0 +1,179 @@
+import os
+import shutil
+import uuid
+import secrets # Pour la comparaison sécurisée des identifiants
+
+from fastapi import Depends, FastAPI, File, UploadFile, Request, HTTPException, status
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+from passlib.context import CryptContext # Pour hacher les mots de passe
+from typing import List
+
+from . import processing  # Contient la logique du modèle
+from . import utils
+
+# Configuration de l'application FastAPI
+app = FastAPI(title="AutoCaption IA - Studio Luxe")
+
+# Configuration pour l'authentification Basic Auth
+security = HTTPBasic()
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# Lire les identifiants depuis les variables d'environnement (pour Hugging Face Spaces Secrets)
+# Fournir des valeurs par défaut UNIQUEMENT pour le test local si les variables ne sont pas définies.
+# EN PRODUCTION SUR SPACES, CES VALEURS SERONT IGNORÉES AU PROFIT DES SECRETS DU SPACE.
+APP_USERNAME_DEFAULT = "admin"
+APP_PASSWORD_DEFAULT = "changezceci" # Changez ce mot de passe par défaut si vous testez localement
+
+APP_USERNAME = os.environ.get("APP_USERNAME", APP_USERNAME_DEFAULT)
+APP_PASSWORD_RAW = os.environ.get("APP_PASSWORD", APP_PASSWORD_DEFAULT)
+
+# Hasher le mot de passe une seule fois au démarrage si disponible
+CORRECT_PASSWORD_HASH = pwd_context.hash(APP_PASSWORD_RAW) if APP_PASSWORD_RAW else None
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    if hashed_password is None:
+        return False
+    return pwd_context.verify(plain_password, hashed_password)
+
+async def get_current_username(credentials: HTTPBasicCredentials = Depends(security)):
+    current_username_bytes = credentials.username.encode("utf8")
+    correct_username_bytes = APP_USERNAME.encode("utf8")
+    
+    is_correct_username = secrets.compare_digest(current_username_bytes, correct_username_bytes)
+    is_correct_password = verify_password(credentials.password, CORRECT_PASSWORD_HASH)
+    
+    if not (is_correct_username and is_correct_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Nom d'utilisateur ou mot de passe incorrect",
+            headers={"WWW-Authenticate": "Basic"},
+        )
+    return credentials.username
+
+# Configuration des chemins
+BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # Répertoire /app
+PROJECT_ROOT = os.path.dirname(BASE_DIR) # Répertoire AUTOCAPTION
+
+UPLOAD_DIR = os.path.join(PROJECT_ROOT, "uploads")
+OUTPUT_IMAGE_DIR = os.path.join(PROJECT_ROOT, "outputs", "images")
+OUTPUT_CAPTION_DIR = os.path.join(PROJECT_ROOT, "outputs", "captions")
+
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(OUTPUT_IMAGE_DIR, exist_ok=True)
+os.makedirs(OUTPUT_CAPTION_DIR, exist_ok=True)
+
+app.mount("/static", StaticFiles(directory=os.path.join(BASE_DIR, "static")), name="static")
+templates = Jinja2Templates(directory=os.path.join(BASE_DIR, "templates"))
+
+# Pré-chargement optionnel du modèle (commenté par défaut pour Spaces pour un démarrage plus rapide du conteneur)
+# print("Tentative de pré-chargement du modèle actif au démarrage de l'application...")
+# try:
+#     processing.load_active_model()
+#     if processing.is_active_model_loaded():
+#         print(f"Modèle actif ({processing.ACTIVE_MODEL}) pré-chargé avec succès.")
+#     else:
+#         print(f"AVERTISSEMENT: Le modèle actif ({processing.ACTIVE_MODEL}) n'a pas pu être pré-chargé.")
+# except Exception as e:
+#     print(f"AVERTISSEMENT: Erreur lors du pré-chargement du modèle actif ({processing.ACTIVE_MODEL}): {e}")
+
+@app.get("/", response_class=HTMLResponse)
+async def get_root(request: Request, current_user: str = Depends(get_current_username)):
+    return templates.TemplateResponse("index.html", {"request": request, "title": "Générateur de Descriptions IA"})
+
+@app.post("/api/upload-images/")
+async def upload_images_for_captioning(
+    files: List[UploadFile] = File(...), 
+    current_user: str = Depends(get_current_username) # Authentification
+):
+    if not files:
+        raise HTTPException(status_code=400, detail="Aucun fichier n'a été téléversé.")
+
+    processed_files_info = []
+
+    if not processing.is_active_model_loaded():
+        print(f"Le modèle actif ({processing.ACTIVE_MODEL}) n'est pas chargé. Tentative de chargement maintenant...")
+        try:
+            processing.load_active_model()
+            if not processing.is_active_model_loaded():
+                 raise HTTPException(status_code=503, detail=f"Le modèle IA ({processing.ACTIVE_MODEL}) n'a pas pu être chargé (vérification post-tentative).")
+            print(f"Modèle actif ({processing.ACTIVE_MODEL}) chargé avec succès à la demande.")
+        except Exception as e:
+            error_detail_str = str(e) if str(e) else f"Le modèle IA ({processing.ACTIVE_MODEL}) n'a pas pu être chargé."
+            raise HTTPException(status_code=503, detail=f"Erreur serveur critique : {error_detail_str}")
+
+    for file in files:
+        temp_file_path = None
+        try:
+            if not file.content_type or not file.content_type.startswith("image/"):
+                print(f"Fichier ignoré (type non supporté: {file.content_type}): {file.filename}")
+                continue
+
+            unique_base_name = utils.generate_simple_unique_name()
+            original_extension = os.path.splitext(file.filename)[1].lower()
+            
+            if not original_extension and file.content_type: # Déduction d'extension
+                ext_map = {"image/jpeg": ".jpg", "image/png": ".png", "image/gif": ".gif", "image/webp": ".webp"}
+                original_extension = ext_map.get(file.content_type, ".img")
+            elif not original_extension:
+                original_extension = ".jpg"
+
+            unique_image_name = f"{unique_base_name}{original_extension}"
+            unique_caption_name = f"{unique_base_name}.txt"
+            
+            temp_upload_filename = f"temp_{uuid.uuid4().hex}{original_extension}" # Nom temporaire unique
+            temp_file_path = os.path.join(UPLOAD_DIR, temp_upload_filename)
+            
+            with open(temp_file_path, "wb") as buffer:
+                shutil.copyfileobj(file.file, buffer)
+            
+            image_description = "Description non générée par défaut."
+            if processing.is_active_model_loaded():
+                print(f"Génération de description pour {temp_file_path} avec le modèle {processing.ACTIVE_MODEL}")
+                image_description = processing.generate_active_description(temp_file_path)
+            else:
+                print(f"ERREUR: Tentative de génération alors que le modèle {processing.ACTIVE_MODEL} n'est pas chargé.")
+                image_description = f"ERREUR CRITIQUE: Le modèle IA ({processing.ACTIVE_MODEL}) n'est pas disponible."
+            
+            output_image_path = os.path.join(OUTPUT_IMAGE_DIR, unique_image_name)
+            shutil.copy(temp_file_path, output_image_path)
+
+            output_caption_path = os.path.join(OUTPUT_CAPTION_DIR, unique_caption_name)
+            with open(output_caption_path, "w", encoding="utf-8") as caption_file:
+                caption_file.write(image_description)
+            
+            processed_files_info.append({
+                "original_name": file.filename,
+                "image_name": unique_image_name,
+                "caption_name": unique_caption_name,
+                "description_preview": (image_description[:100] + "..." if image_description and len(image_description) > 100 else image_description) or "Vide"
+            })
+
+        except HTTPException: # Laisser remonter les erreurs HTTP (ex: 503 du chargement modèle)
+            raise
+        except Exception as e:
+            print(f"Erreur inattendue lors du traitement du fichier {file.filename}: {e}")
+            processing.traceback.print_exc() # Afficher la trace complète pour les erreurs inattendues
+        finally:
+            if hasattr(file, 'file') and file.file and not file.file.closed:
+                file.file.close()
+            if temp_file_path and os.path.exists(temp_file_path):
+                try:
+                    os.remove(temp_file_path)
+                except Exception as e_remove:
+                    print(f"Erreur lors de la suppression du fichier temporaire {temp_file_path}: {e_remove}")
+        
+    return JSONResponse(
+        content={
+            "message": f"{len(processed_files_info)} image(s) traitée(s) avec succès sur {len(files)} fichier(s) reçu(s).",
+            "processed_files": processed_files_info
+        },
+        status_code=200
+    )
+
+if __name__ == "__main__":
+    print("Pour lancer l'application, utilisez la commande : uvicorn app.main:app --host 0.0.0.0 --port 8000")
+    # import uvicorn
+    # uvicorn.run(app, host="127.0.0.1", port=8000) # Pour test local direct

app/processing.py

@@ -0,0 +1,195 @@
+import torch
+from PIL import Image, ImageDraw # ImageDraw pour la section de test
+import os
+import traceback
+
+# Imports spécifiques pour LLaVA
+from transformers import LlavaNextProcessor, LlavaNextForConditionalGeneration
+
+# --- Configuration du modèle LLaVA-NeXT ---
+LLAVA_MODEL_NAME = "llava-hf/llava-v1.6-mistral-7b-hf"
+# Hash de commit de la branche 'main' de LLaVA au moment des tests.
+# Vérifiez le plus récent sur https://huggingface.co/llava-hf/llava-v1.6-mistral-7b-hf/commits/main
+LLAVA_REVISION = "082142fd2997099498027732cf8e945044bf48c3" 
+
+llava_processor = None
+llava_model = None
+llava_model_loaded = False
+
+# Détection du device (CPU, CUDA, ou MPS pour Mac Apple Silicon)
+if torch.cuda.is_available():
+    device = "cuda"
+elif torch.backends.mps.is_available() and torch.backends.mps.is_built():
+    device = "mps"
+else:
+    device = "cpu"
+print(f"Utilisation du device : {device} pour les modèles d'IA.")
+
+def load_llava_model():
+    global llava_processor, llava_model, llava_model_loaded, device
+    if llava_model_loaded:
+        print(f"Modèle LLaVA ({LLAVA_MODEL_NAME} rev {LLAVA_REVISION}) déjà chargé.")
+        return
+
+    try:
+        print(f"Chargement du processor pour LLaVA ({LLAVA_MODEL_NAME} rev {LLAVA_REVISION})...")
+        llava_processor = LlavaNextProcessor.from_pretrained(
+            LLAVA_MODEL_NAME,
+            revision=LLAVA_REVISION # Épinglage de la révision
+        )
+        print("Processor LLaVA chargé.")
+
+        print(f"Chargement du modèle LLaVA ({LLAVA_MODEL_NAME} rev {LLAVA_REVISION}) sur '{device}'...")
+        model_args = {
+            "revision": LLAVA_REVISION, # Épinglage de la révision
+            "low_cpu_mem_usage": True,
+        }
+        if device == "cpu":
+            # Pas de torch_dtype pour CPU, utilise float32 par défaut pour plus de stabilité
+            print(f"Configuration de LLaVA pour CPU (float32 par défaut).")
+        elif device == "cuda":
+            model_args["torch_dtype"] = torch.float16 # ou torch.bfloat16 si GPU récent (Ampere+)
+            print(f"Configuration de LLaVA pour CUDA ({model_args['torch_dtype']}).")
+        elif device == "mps":
+            # Pour MPS, float16 est souvent utilisé, mais float32 est plus sûr pour commencer.
+            # Laisser float32 par défaut (pas de torch_dtype) est une option.
+            # Ou essayez float16 :
+            model_args["torch_dtype"] = torch.float16
+            print(f"Configuration de LLaVA pour MPS ({model_args['torch_dtype']}).")
+        
+        llava_model = LlavaNextForConditionalGeneration.from_pretrained(
+            LLAVA_MODEL_NAME, 
+            **model_args
+        ).to(device).eval()
+        
+        llava_model_loaded = True
+        print(f"Modèle LLaVA ({LLAVA_MODEL_NAME} rev {LLAVA_REVISION}) chargé avec succès sur '{device}'.")
+
+    except Exception as e:
+        print(f"Erreur critique lors du chargement du modèle LLaVA ({LLAVA_MODEL_NAME} rev {LLAVA_REVISION}): {e}")
+        traceback.print_exc()
+        llava_model_loaded = False
+
+
+def generate_description_llava(image_path: str) -> str:
+    global llava_processor, llava_model, llava_model_loaded, device
+
+    if not llava_model_loaded:
+        print("Modèle LLaVA non chargé. Tentative de chargement...")
+        load_llava_model()
+        if not llava_model_loaded:
+            return "Erreur: Le modèle LLaVA n'a pas pu être chargé."
+    
+    if not os.path.exists(image_path):
+        return f"Erreur: Le fichier image {image_path} n'existe pas."
+
+    try:
+        image = Image.open(image_path).convert("RGB")
+        
+        # Choix du prompt (anglais par défaut, comme demandé)
+        user_prompt = "Describe this image in English with precision and detail."
+        # user_prompt = "Décris cette image en français avec précision et de manière détaillée." # Si vous voulez du français
+
+        prompt_text = f"<s>[INST] <image>\n{user_prompt} [/INST]"
+        
+        print(f"Préparation des entrées pour LLaVA avec le prompt: {user_prompt}")
+        inputs_on_cpu = llava_processor(text=prompt_text, images=image, return_tensors="pt")
+        
+        inputs = {}
+        for key, value in inputs_on_cpu.items():
+            if torch.is_tensor(value):
+                inputs[key] = value.to(device)
+            else:
+                inputs[key] = value
+        
+        if (device == "cuda" or device == "mps") and hasattr(llava_model, 'dtype') and \
+           (llava_model.dtype == torch.float16 or llava_model.dtype == torch.bfloat16):
+            for k_tensor, v_tensor in inputs.items():
+                if torch.is_tensor(v_tensor) and torch.is_floating_point(v_tensor):
+                    inputs[k_tensor] = v_tensor.to(llava_model.dtype)
+        
+        input_dtypes_log = {k: v.dtype for k,v in inputs.items() if torch.is_tensor(v)}
+        print(f"Génération de la description LLaVA pour {image_path} (device: {device}, input dtypes: {input_dtypes_log})...")
+        
+        generation_kwargs = {
+            "max_new_tokens": 768,
+            "num_beams": 3,       
+            "early_stopping": True
+        }
+        
+        generated_ids = llava_model.generate(**inputs, **generation_kwargs)
+        
+        input_token_len = inputs.get('input_ids', torch.tensor([])).shape[-1]
+        generated_ids_only = generated_ids[0, input_token_len:]
+        
+        cleaned_text = llava_processor.decode(generated_ids_only, skip_special_tokens=True).strip()
+        
+        # Nettoyage supplémentaire si nécessaire (ex: enlever des marqueurs résiduels)
+        inst_marker_space = " [/INST]" # Avec espace avant, comme souvent produit
+        inst_marker_no_space = "[/INST]"
+        if cleaned_text.startswith(inst_marker_space):
+            cleaned_text = cleaned_text[len(inst_marker_space):].strip()
+        elif cleaned_text.startswith(inst_marker_no_space):
+             cleaned_text = cleaned_text[len(inst_marker_no_space):].strip()
+
+        print(f"Description (nettoyée) de LLaVA: {cleaned_text}")
+        return cleaned_text if cleaned_text and cleaned_text.strip() else "Aucune description textuelle distincte n'a été générée par LLaVA."
+
+    except Exception as e:
+        print(f"Erreur détaillée lors de la génération de la description avec LLaVA:")
+        traceback.print_exc() 
+        if torch.cuda.is_available() or device == "mps": # Vider le cache si GPU/MPS
+            if device == "cuda": torch.cuda.empty_cache()
+            # if device == "mps": torch.mps.empty_cache() # Si disponible et nécessaire
+        return f"Erreur lors de la génération de la description avec LLaVA: {type(e).__name__} - {str(e)}"
+
+ACTIVE_MODEL = "llava" 
+
+def load_active_model():
+    print(f"Tentative de chargement du modèle actif: {ACTIVE_MODEL}")
+    if ACTIVE_MODEL == "llava":
+        load_llava_model()
+    else:
+        print(f"Modèle actif inconnu: {ACTIVE_MODEL}. Aucun modèle ne sera chargé.")
+
+def generate_active_description(image_path: str) -> str:
+    if ACTIVE_MODEL == "llava":
+        return generate_description_llava(image_path)
+    else:
+        error_msg = f"Erreur: Modèle actif inconnu ({ACTIVE_MODEL}). Impossible de générer une description."
+        print(error_msg)
+        return error_msg
+
+def is_active_model_loaded() -> bool:
+    if ACTIVE_MODEL == "llava":
+        return llava_model_loaded
+    return False
+
+if __name__ == '__main__':
+    print("Début du test de processing.py...")
+    dummy_image_name = "dummy_test_image.png"
+    if not os.path.exists(dummy_image_name):
+        try:
+            img = Image.new('RGB', (200, 150), color = 'skyblue')
+            draw = ImageDraw.Draw(img)
+            draw.text((10, 10), "Test Image", fill='black')
+            img.save(dummy_image_name)
+            print(f"Image de test '{dummy_image_name}' créée.")
+        except Exception as e_img:
+            print(f"Impossible de créer l'image de test : {e_img}")
+
+    if os.path.exists(dummy_image_name):
+        print(f"Utilisation du modèle actif : {ACTIVE_MODEL}")
+        print("Chargement du modèle actif (peut prendre du temps)...")
+        load_active_model()
+        if is_active_model_loaded():
+            print(f"\nGénération de la description pour l'image de test '{dummy_image_name}'...")
+            description = generate_active_description(dummy_image_name)
+            print(f"\n--- Description Générée ---")
+            print(description)
+            print(f"--------------------------")
+        else:
+            print("Le modèle actif n'a pas pu être chargé. Test de description annulé.")
+    else:
+        print(f"Image de test '{dummy_image_name}' non trouvée. Test de description annulé.")
+    print("Fin du test de processing.py.")

app/static/css/style.css

@@ -0,0 +1,171 @@
+/* Réinitialisation de base et variables de couleur */
+:root {
+    --font-primary: 'Montserrat', sans-serif;
+    --font-secondary: 'Cormorant Garamond', serif;
+    --color-text: #333333; /* Un gris foncé doux */
+    --color-primary: #0A0A0A; /* Presque noir pour l'élégance */
+    --color-secondary: #B08D57; /* Un doré/bronze doux */
+    --color-background: #FDFDFD; /* Blanc cassé très clair */
+    --color-light-gray: #e9e9e9;
+    --color-border: #d1d1d1;
+}
+
+body {
+    font-family: var(--font-secondary); /* Police principale pour le corps */
+    line-height: 1.7;
+    margin: 0;
+    padding: 0;
+    background-color: var(--color-background);
+    color: var(--color-text);
+    font-weight: 400; /* Poids standard pour Cormorant Garamond */
+}
+
+h1, h2, h3, h4, h5, h6 {
+    font-family: var(--font-primary); /* Police pour les titres */
+    font-weight: 500; /* Un peu plus affirmé */
+    color: var(--color-primary);
+}
+
+header {
+    background: var(--color-primary);
+    color: var(--color-background);
+    padding: 2rem 1rem; /* Plus d'espace */
+    text-align: center;
+    border-bottom: 3px solid var(--color-secondary);
+}
+
+header h1 {
+    font-weight: 300; /* Léger pour le titre principal */
+    letter-spacing: 2px; /* Espacement des lettres */
+    font-size: 2.5em;
+    color: var(--color-background); /* S'assurer que le h1 hérite bien */
+}
+
+main {
+    padding: 30px;
+    max-width: 900px; /* Un peu plus large */
+    margin: 30px auto;
+    background: #ffffff; /* Blanc pur pour le contenu principal */
+    box-shadow: 0 5px 25px rgba(0,0,0,0.05); /* Ombre subtile */
+    border-radius: 8px;
+}
+
+section {
+    margin-bottom: 30px;
+    padding: 25px;
+    border: 1px solid var(--color-light-gray);
+    border-radius: 5px;
+}
+
+h2 {
+    font-size: 1.8em;
+    font-weight: 400;
+    margin-bottom: 20px;
+    padding-bottom: 10px;
+    border-bottom: 1px solid var(--color-light-gray);
+    color: var(--color-primary);
+}
+
+input[type="file"] {
+    font-family: var(--font-primary);
+    padding: 10px;
+    border: 1px solid var(--color-border);
+    border-radius: 4px;
+    background-color: #fff;
+    margin-bottom: 20px; /* Plus d'espace */
+    display: block; /* Pour prendre toute la largeur */
+    width: calc(100% - 22px); /* Ajuster pour le padding et la bordure */
+}
+
+button[type="submit"] {
+    font-family: var(--font-primary);
+    background: var(--color-secondary);
+    color: white;
+    border: none;
+    padding: 12px 25px;
+    cursor: pointer;
+    border-radius: 4px;
+    text-transform: uppercase; /* Lettres capitales pour les boutons */
+    font-weight: 500;
+    letter-spacing: 1px;
+    transition: background-color 0.3s ease;
+}
+
+button[type="submit"]:hover {
+    background: #9c7b4d; /* Un doré un peu plus foncé au survol */
+}
+
+#message-area {
+    margin-bottom: 15px;
+    padding: 15px;
+    border-radius: 4px;
+    font-family: var(--font-primary);
+    font-size: 0.95em;
+}
+
+#message-area.success {
+    background-color: #e6f4ea; /* Vert pastel */
+    color: #3d8b50;
+    border: 1px solid #c3e0c9;
+}
+
+#message-area.error {
+    background-color: #f8d7da; /* Rouge pastel */
+    color: #721c24;
+    border: 1px solid #f5c6cb;
+}
+
+#file-list {
+    padding-left: 0; /* Pas de puces par défaut */
+}
+#file-list li {
+    list-style: none;
+    padding: 10px;
+    border-bottom: 1px var(--color-light-gray) dashed;
+    font-size: 0.9em;
+    font-family: var(--font-secondary); /* Police élégante pour les items */
+}
+#file-list li:last-child {
+    border-bottom: none;
+}
+
+footer {
+    text-align: center;
+    padding: 20px;
+    background: var(--color-primary);
+    color: var(--color-light-gray);
+    margin-top: 40px;
+    font-family: var(--font-primary);
+    font-size: 0.9em;
+    font-weight: 300;
+}
+
+/* Styles pour le Spinner / Chargeur */
+#progress-indicator {
+    /* text-align: center; */
+}
+
+.loader-container {
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+    padding: 20px;
+    min-height: 100px;
+    font-family: var(--font-primary); /* Police pour le texte du loader */
+}
+
+.spinner {
+    border: 6px solid var(--color-light-gray); /* Contour du spinner */
+    border-top: 6px solid var(--color-secondary); /* Couleur "active" du spinner (doré) */
+    border-radius: 50%;
+    width: 50px;
+    height: 50px;
+    animation: spin 1s linear infinite;
+    margin-bottom: 15px;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}

app/static/js/script.js

@@ -0,0 +1,72 @@
+document.addEventListener('DOMContentLoaded', () => {
+    const uploadForm = document.getElementById('upload-form');
+    const imageFilesInput = document.getElementById('image-files');
+    const messageArea = document.getElementById('message-area');
+    const fileList = document.getElementById('file-list');
+    const progressIndicator = document.getElementById('progress-indicator');
+    // Récupérer l'élément <p> à l'intérieur de progressIndicator pour mettre à jour son texte
+    const progressText = progressIndicator.querySelector('p');
+
+
+    uploadForm.addEventListener('submit', async (event) => {
+        event.preventDefault();
+        messageArea.textContent = '';
+        messageArea.className = ''; // Effacer les classes précédentes
+        fileList.innerHTML = ''; // Effacer les résultats précédents
+
+        const numFiles = imageFilesInput.files.length;
+
+        if (numFiles === 0) {
+            messageArea.textContent = 'Veuillez sélectionner au moins une image.';
+            messageArea.classList.add('error');
+            return;
+        }
+
+        if (progressText) { // Vérifier si l'élément p existe
+            progressText.textContent = `Traitement de ${numFiles} image(s) en cours, veuillez patienter...`;
+        } else { // Fallback si la structure HTML a changé et que p n'est plus là
+            progressIndicator.textContent = `Traitement de ${numFiles} image(s) en cours, veuillez patienter...`;
+        }
+        progressIndicator.style.display = 'block';
+
+
+        const formData = new FormData();
+        for (const file of imageFilesInput.files) {
+            formData.append('files', file);
+        }
+
+        try {
+            const response = await fetch('/api/upload-images/', {
+                method: 'POST',
+                body: formData,
+            });
+
+            // Masquer l'indicateur de progression une fois la réponse reçue
+            progressIndicator.style.display = 'none';
+            const result = await response.json();
+
+            if (response.ok) {
+                messageArea.textContent = result.message || 'Traitement terminé avec succès !';
+                messageArea.classList.add('success');
+                if (result.processed_files && result.processed_files.length > 0) {
+                    result.processed_files.forEach(file => {
+                        const listItem = document.createElement('li');
+                        listItem.textContent = `Image: ${file.image_name}, Description (début): ${file.description_preview || file.caption_name}`;
+                        fileList.appendChild(listItem);
+                    });
+                } else if (result.processed_files && result.processed_files.length === 0 && numFiles > 0) {
+                     messageArea.textContent = result.message || "Aucun fichier n'a été traité avec succès parmi ceux envoyés.";
+                     messageArea.classList.add('error'); // Ou une classe 'warning'
+                }
+            } else {
+                messageArea.textContent = result.detail || 'Une erreur est survenue lors du traitement.';
+                messageArea.classList.add('error');
+            }
+        } catch (error) {
+            progressIndicator.style.display = 'none';
+            messageArea.textContent = 'Erreur de connexion ou le serveur ne répond pas. Vérifiez la console du navigateur et du serveur.';
+            messageArea.classList.add('error');
+            console.error('Upload error:', error);
+        }
+    });
+});

app/templates/index.html

@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AutoCaption IA - Studio Luxe</title> <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Cormorant+Garamond:wght@300;400;500;700&family=Montserrat:wght@300;400;500;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="{{ url_for('static', path='/css/style.css') }}">
+</head>
+<body>
+    <header>
+        <h1>Générateur de Descriptions d'Images</h1>
+    </header>
+    <main>
+        <section id="upload-section">
+            <h2>Téléverser des Images</h2>
+            <form id="upload-form" enctype="multipart/form-data">
+                <input type="file" id="image-files" name="files" multiple accept="image/*">
+                <button type="submit">Générer les Descriptions</button>
+            </form>
+            <div id="progress-indicator" style="display:none;">
+                <div class="loader-container">
+                    <div class="spinner"></div>
+                    <p>Traitement des images en cours, veuillez patienter...</p>
+                </div>
+            </div>
+        </section>
+        <section id="results-section">
+            <h2>Résultats</h2>
+            <div id="message-area"></div>
+            <ul id="file-list">
+                </ul>
+        </section>
+    </main>
+    <footer>
+        <p>&copy; 2025 Votre Application AutoCaption</p>
+    </footer>
+    <script src="{{ url_for('static', path='/js/script.js') }}"></script>
+</body>
+</html>

app/utils.py

@@ -0,0 +1,26 @@
+import uuid
+import time
+
+# Compteur global pour les noms simples (si on préfère des numéros séquentiels par session)
+# Pour une persistance entre redémarrages, il faudrait stocker ce compteur ailleurs (fichier, base de données)
+# Pour la simplicité, on le réinitialise à chaque démarrage du serveur.
+# Une meilleure approche pour des noms uniques simples pourrait être un timestamp précis.
+_counter = 0 
+
+def generate_simple_unique_name() -> str:
+    """Génère un nom de base unique simple basé sur un timestamp et un compteur."""
+    global _counter
+    _counter += 1
+    # timestamp_ms = int(time.time() * 1000)
+    # return f"img_{timestamp_ms}_{_counter:03d}"
+    return f"img_{uuid.uuid4().hex[:8]}" # Plus robuste pour l'unicité
+
+def generate_uuid_name() -> str:
+    """Génère un nom de base basé sur UUID (plus long mais garanti unique)."""
+    return str(uuid.uuid4())
+
+if __name__ == '__main__':
+    # Test
+    print(generate_simple_unique_name())
+    print(generate_simple_unique_name())
+    print(generate_uuid_name())

environment.yml

@@ -0,0 +1,23 @@
+# environment.yml
+name: autocaption_env
+channels:
+  - pytorch
+  - defaults
+dependencies:
+  - python=3.9
+  - pytorch
+  - torchvision
+  - torchaudio
+  - cpuonly # Important si installé depuis le canal pytorch pour la version CPU
+  - fastapi
+  - uvicorn
+  - python-multipart
+  - jinja2
+  - pillow
+  - pip
+  - pip:
+    - transformers
+    - sentencepiece
+    - accelerate
+    - matplotlib
+    - tiktoken

requirements.txt

@@ -0,0 +1,20 @@
+fastapi
+uvicorn[standard]
+python-multipart
+jinja2
+torch
+torchvision
+transformers
+Pillow
+accelerate
+einops
+# Dépendances potentiellement requises par les scripts distants de LLaVA
+# Il est bon de les inclure si vous avez eu des erreurs sans elles précédemment.
+# transformers_stream_generator # Si vous l'aviez ajouté pour une erreur précédente
+matplotlib
+tiktoken
+# Pour l'authentification Basic Auth
+python-jose[cryptography]
+passlib[bcrypt]
+
+# bitsandbytes # Optionnel pour la quantification (non utilisé pour l'instant)