V5

app/main.py

@@ -4,7 +4,7 @@ import uuid
 import secrets
 import zipfile
 import io
-import re # Toujours utile pour obtenir une extension propre
+import re # Pour nettoyer les noms de fichiers
 
 from fastapi import Depends, FastAPI, File, UploadFile, Request, HTTPException, status
 from fastapi.responses import HTMLResponse, StreamingResponse
@@ -12,7 +12,7 @@ from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from fastapi.security import HTTPBasic, HTTPBasicCredentials
 from passlib.context import CryptContext
-from typing import List
+from typing import List, Tuple # Ajout de Tuple pour le type de retour
 
 from . import processing
 from . import utils
@@ -23,7 +23,7 @@ security = HTTPBasic()
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
 APP_USERNAME_DEFAULT = "admin"
-APP_PASSWORD_DEFAULT = "changezceci"
+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)
@@ -66,14 +66,30 @@ 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"))
 
-def get_safe_extension(filename: str) -> str:
-    """Extrait et nettoie l'extension d'un nom de fichier."""
-    name, ext = os.path.splitext(filename)
-    # Garder uniquement les caractères alphanumériques pour l'extension, et s'assurer qu'elle commence par un point.
-    safe_ext = re.sub(r'[^a-zA-Z0-9]', '', ext).lower()
-    if not safe_ext: # Si pas d'extension valide trouvée (ex: fichier sans extension ou avec des caractères bizarres)
-        return ".img" # Extension par défaut
-    return f".{safe_ext}"
+def sanitize_basename_and_get_ext(filename: str) -> Tuple[str, str]:
+    """
+    Nettoie le nom de base d'un fichier et retourne (nom_base_nettoye, .extension_nette).
+    Exemple: "Mon Image Bizarre!!.JPEG" -> ("Mon_Image_Bizarre", ".jpeg")
+    """
+    name_part, ext_part = os.path.splitext(filename)
+    
+    # Nettoyer le nom de base
+    # Garder les alphanumériques, espaces, tirets, underscores, points (non finaux pour le nom)
+    safe_name = re.sub(r'[^\w\s.-]', '', name_part).strip()
+    # Remplacer les espaces et séquences de points/tirets par un seul underscore
+    safe_name = re.sub(r'[\s._-]+', '_', safe_name)
+    # Enlever les underscores au début ou à la fin après remplacement
+    safe_name = safe_name.strip('_')
+
+    if not safe_name: # Si le nom est vide après nettoyage (ex: "!!.jpg")
+        safe_name = f"image_{uuid.uuid4().hex[:8]}" # Nom de fallback
+    
+    # Nettoyer l'extension
+    safe_ext = re.sub(r'[^a-zA-Z0-9]', '', ext_part).lower()
+    if not safe_ext:
+        safe_ext = "img" # Extension par défaut si l'originale n'est pas valide/présente
+        
+    return safe_name, f".{safe_ext}"
 
 
 @app.get("/", response_class=HTMLResponse)
@@ -101,7 +117,10 @@ async def upload_images_for_captioning(
 
     zip_buffer = io.BytesIO()
     files_added_to_zip = 0
-    image_counter = 1 # Initialiser le compteur pour le nommage séquentiel
+    
+    # Pour gérer les noms de fichiers dupliqués (basés sur l'original) dans le ZIP
+    # Clé: "basename.ext", Valeur: compteur pour ce nom de fichier
+    filenames_in_zip_tracker = {} 
 
     with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
         for file in files:
@@ -111,17 +130,28 @@ async def upload_images_for_captioning(
                     print(f"Fichier ignoré (type non supporté: {file.content_type}): {file.filename}")
                     continue
 
-                # Obtenir l'extension du fichier original de manière sécurisée
-                original_extension = get_safe_extension(file.filename)
-                if not original_extension and file.content_type: # Déduction d'extension via MIME type si get_safe_extension échoue
-                    ext_map = {"image/jpeg": ".jpg", "image/png": ".png", "image/gif": ".gif", "image/webp": ".webp"}
-                    original_extension = ext_map.get(file.content_type, ".img") # .img comme fallback
+                # Nettoyer le nom de base et obtenir l'extension à partir du nom de fichier original
+                original_base_name, original_extension = sanitize_basename_and_get_ext(file.filename)
 
-                # Créer les noms de fichiers séquentiels pour le ZIP
-                image_filename_in_zip = f"photo{image_counter}{original_extension}"
-                caption_filename_in_zip = f"photo{image_counter}.txt"
+                # Gérer les noms dupliqués pour l'image
+                # Le nom de base pour la déduplication est le nom original nettoyé sans extension
+                dedup_key_base = original_base_name 
                 
-                # Utiliser une extension temporaire basée sur l'original pour le fichier sur disque
+                image_arcname_final = f"{original_base_name}{original_extension}"
+                caption_arcname_final = f"{original_base_name}.txt"
+
+                # Vérifier si cette combinaison nom_base + extension image existe déjà
+                # Ou si nom_base + .txt existe (car ils partagent le même nom de base)
+                # On numérote le nom de base si nécessaire.
+                count = filenames_in_zip_tracker.get(dedup_key_base, 0)
+                if count > 0: # Si dedup_key_base a déjà été vu, on ajoute le compteur
+                    image_arcname_final = f"{original_base_name}({count}){original_extension}"
+                    caption_arcname_final = f"{original_base_name}({count}).txt"
+                
+                filenames_in_zip_tracker[dedup_key_base] = count + 1
+
+
+                # Utiliser une extension temporaire basée sur l'original pour le fichier sur disque serveur
                 temp_upload_filename = f"temp_{uuid.uuid4().hex}{original_extension}"
                 temp_file_path = os.path.join(UPLOAD_DIR, temp_upload_filename)
                 
@@ -130,26 +160,25 @@ async def upload_images_for_captioning(
                 
                 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} (sera {image_filename_in_zip} dans ZIP) avec le modèle {processing.ACTIVE_MODEL}")
+                    print(f"Génération de description pour {temp_file_path} (sera {image_arcname_final} dans ZIP) 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."
                 
-                # Ajouter l'image au ZIP avec son nom séquentiel
-                zf.write(temp_file_path, arcname=image_filename_in_zip)
+                # Ajouter l'image au ZIP avec son nom (original nettoyé, potentiellement dédupliqué)
+                zf.write(temp_file_path, arcname=image_arcname_final)
                 
-                # Ajouter le fichier de description au ZIP avec son nom séquentiel
-                zf.writestr(caption_filename_in_zip, image_description)
+                # Ajouter le fichier de description au ZIP (même nom de base, potentiellement dédupliqué, extension .txt)
+                zf.writestr(caption_arcname_final, image_description)
                 
                 files_added_to_zip += 1
-                image_counter += 1 # Incrémenter pour le prochain fichier
 
-            except HTTPException: # Laisser remonter les erreurs HTTP (ex: 503 du chargement modèle)
+            except HTTPException: 
                 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
+                processing.traceback.print_exc() 
             finally:
                 if hasattr(file, 'file') and file.file and not file.file.closed:
                     file.file.close()

app/processing.py

@@ -8,10 +8,7 @@ from transformers import LlavaNextProcessor, LlavaNextForConditionalGeneration
 
 # --- Configuration du modèle LLaVA-NeXT ---
 LLAVA_MODEL_NAME = "llava-hf/llava-v1.6-mistral-7b-hf"
-# La variable LLAVA_REVISION est définie ici au cas où nous voudrions épingler une version spécifique plus tard,
-# une fois que nous aurons confirmé que tout fonctionne bien avec la version 'main'.
-# Pour l'instant, elle n'est PAS utilisée dans les appels from_pretrained().
-LLAVA_REVISION = "082142fd2997099498027732cf8e945044bf48c3" # Exemple de hash, non utilisé ci-dessous
+# LLAVA_REVISION = "main" # On utilise la branche principale par défaut
 
 llava_processor = None
 llava_model = None
@@ -20,7 +17,7 @@ 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():
+elif torch.backends.mps.is_available() and torch.backends.mps.is_built(): # Pour Apple Silicon
     device = "mps"
 else:
     device = "cpu"
@@ -31,42 +28,43 @@ 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}, depuis branche 'main') déjà chargé.")
+        print(f"Modèle LLaVA ({LLAVA_MODEL_NAME}) déjà chargé.")
         return
 
     try:
-        print(f"Chargement du processor pour LLaVA ({LLAVA_MODEL_NAME}, depuis branche 'main')...")
+        print(f"Chargement du processor pour LLaVA ({LLAVA_MODEL_NAME})...")
         llava_processor = LlavaNextProcessor.from_pretrained(
             LLAVA_MODEL_NAME
-            # Pas de 'revision' ici, on charge depuis la branche 'main'
+            # revision=LLAVA_REVISION # Décommenter si vous voulez épingler une révision
         )
         print("Processor LLaVA chargé.")
 
-        print(f"Chargement du modèle LLaVA ({LLAVA_MODEL_NAME}, depuis branche 'main') sur '{device}'...")
+        print(f"Chargement du modèle LLaVA ({LLAVA_MODEL_NAME}) sur '{device}'...")
         model_args = {
-            # Pas de 'revision' ici non plus pour le moment
-            "low_cpu_mem_usage": True, # Utile pour réduire l'utilisation de la RAM CPU lors du chargement initial
+            "low_cpu_mem_usage": True, # Utile pour réduire l'utilisation de la RAM CPU
+            # revision=LLAVA_REVISION # Décommenter si vous voulez épingler une révision
         }
 
-        if device == "cpu":
+        if device == "cuda":
+            model_args["torch_dtype"] = torch.float16 # Précision pour GPU NVIDIA
+            # Pour les GPU plus récents (Ampere+), torch.bfloat16 peut aussi être une option
+            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
+            # Si des problèmes de stabilité surviennent avec float16 sur MPS, commenter la ligne suivante
+            model_args["torch_dtype"] = torch.float16 
+            print(f"Configuration de LLaVA pour MPS ({model_args.get('torch_dtype', 'par défaut float32')}).")
+        else: # CPU
             # Pas de torch_dtype spécifique, PyTorch utilisera 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.get('torch_dtype', 'par défaut')}).")
-        elif device == "mps":
-            # Pour MPS, float16 peut offrir des gains de vitesse. float32 est plus sûr pour commencer.
-            # Laisser float32 par défaut (pas de torch_dtype) est une option, ou essayer float16.
-            model_args["torch_dtype"] = torch.float16 # Essayons float16 pour MPS
-            print(f"Configuration de LLaVA pour MPS ({model_args.get('torch_dtype', 'par défaut')}).")
         
         llava_model = LlavaNextForConditionalGeneration.from_pretrained(
             LLAVA_MODEL_NAME, 
             **model_args
-        ).to(device).eval()
+        ).to(device).eval() # Mettre le modèle en mode évaluation
         
         llava_model_loaded = True
-        print(f"Modèle LLaVA ET Processeur ({LLAVA_MODEL_NAME}, tous deux depuis branche 'main') chargés avec succès sur '{device}'.")
+        print(f"Modèle LLaVA ET Processeur ({LLAVA_MODEL_NAME}) chargés avec succès sur '{device}'.")
 
     except Exception as e:
         print(f"Erreur critique lors du chargement du modèle LLaVA ({LLAVA_MODEL_NAME}): {e}")
@@ -78,96 +76,109 @@ 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é dans generate_description_llava. Tentative de chargement...")
+        print("Modèle LLaVA non chargé. Tentative de chargement à la demande...")
         load_llava_model()
         if not llava_model_loaded: 
-            return "Erreur: Le modèle LLaVA n'a pas pu être chargé (échec lors de la tentative à la demande)."
-    
+            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")
         
-        # Prompt en anglais par défaut
-        user_prompt = "Describe this image in English with precision and detail."
-        # Pour du français :
-        # user_prompt = "Décris cette image en français avec précision et de manière détaillée."
-
-        # Format de prompt pour LLaVA v1.6
-        prompt_text = f"<s>[INST] <image>\n{user_prompt} [/INST]"
+        # --- PROMPT AMÉLIORÉ ---
+        user_prompt_fr = (
+            "Analyse cette image en tant qu'œuvre d'art. "
+            "Fournis une description objective, factuelle et très détaillée en français. "
+            "Concentre-toi sur les éléments visuels : la scène globale, les sujets et personnages (y compris leur apparence, posture, expression, et toute forme de nudité si présente), "
+            "les objets, l'arrière-plan, les formes, les couleurs, la lumière, la composition et la technique artistique apparente. "
+            "Évite toute interprétation subjective ou jugement moral, et décris ce qui est visible de manière exhaustive."
+        )
+        
+        # Format de prompt spécifique à LLaVA v1.5+ (Mistral utilise ce format)
+        prompt_template = f"<s>[INST] <image>\n{user_prompt_fr} [/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")
+        print(f"Préparation des entrées pour LLaVA avec le prompt utilisateur (condensé): \"{user_prompt_fr[:100]}...\"")
         
+        # Le processeur gère la tokenisation du texte et le prétraitement de l'image
+        inputs_on_cpu = llava_processor(text=prompt_template, images=image, return_tensors="pt")
+        
+        # Déplacer les tenseurs sur le bon device
         inputs = {}
         for key, value in inputs_on_cpu.items():
             if torch.is_tensor(value):
                 inputs[key] = value.to(device)
             else:
-                inputs[key] = value # Conserver d'autres types si présents
+                inputs[key] = value 
         
-        # S'assurer que les types de tenseurs correspondent au modèle sur GPU/MPS
+        # S'assurer que les types de tenseurs correspondent au modèle sur GPU/MPS (si float16/bfloat16)
         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):
+                if torch.is_tensor(v_tensor) and torch.is_floating_point(v_tensor): # Appliquer seulement aux tenseurs flottants
                     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})...")
         
+        # Paramètres de génération (ajustables si nécessaire)
         generation_kwargs = {
-            "max_new_tokens": 768,
-            "num_beams": 3,       
-            "early_stopping": True 
+            "max_new_tokens": 768,  # Augmenté légèrement pour des descriptions potentiellement plus longues
+            "num_beams": 3,         # Un peu de beam search peut améliorer la cohérence
+            "early_stopping": True,
+            "do_sample": False      # Pour des descriptions plus factuelles et moins "créatives" aléatoirement. Mettre True avec temperature si on veut plus de variété.
+            # "temperature": 0.7,   # À utiliser avec do_sample=True si on veut de la créativité
+            # "top_p": 0.9,         # À utiliser avec do_sample=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:] # Extraire seulement les tokens générés
+        # Pour LLaVA, il est important de décoder uniquement les tokens générés *après* le prompt.
+        # Certains processeurs/modèles gèrent cela différemment.
+        # Pour LLaVA-NeXT, le décodage de la séquence complète et le nettoyage du prompt est une approche courante.
+        # Ou, si l'on connaît la longueur des tokens d'entrée :
+        # 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()
         
-        cleaned_text = llava_processor.decode(generated_ids_only, skip_special_tokens=True).strip()
+        # Approche plus simple : décoder toute la séquence et enlever manuellement le prompt si besoin.
+        # Souvent, pour les formats [INST]...[/INST], le modèle génère directement la réponse.
+        full_text = llava_processor.decode(generated_ids[0], skip_special_tokens=True).strip()
         
-        # Nettoyage supplémentaire si le marqueur [/INST] est toujours présent (peu probable avec ce décodage)
-        inst_marker_space = " [/INST]"
-        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()
+        # Nettoyage du texte généré pour enlever le prompt s'il est répété (spécifique au format de sortie du modèle)
+        # Le format "[INST] <image> \n {prompt} [/INST] {réponse}" fait que la réponse est souvent propre.
+        inst_marker = "[/INST]"
+        if inst_marker in full_text:
+            cleaned_text = full_text.split(inst_marker, 1)[-1].strip()
+        else:
+            cleaned_text = full_text # Si le marqueur n'est pas là, prendre tout (peut arriver)
 
-        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."
+        print(f"Description (nettoyée) de LLaVA: {cleaned_text[:200]}...") # Log tronqué
+        return cleaned_text if cleaned_text 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":
             if device == "cuda": torch.cuda.empty_cache()
-            # if device == "mps" and hasattr(torch, 'mps') and hasattr(torch.mps, 'empty_cache'): torch.mps.empty_cache() # Pour PyTorch >= 1.13
+            # if device == "mps" and hasattr(torch, 'mps') and hasattr(torch.mps, 'empty_cache'): torch.mps.empty_cache()
         return f"Erreur lors de la génération de la description avec LLaVA: {type(e).__name__} - {str(e)}"
 
 
 # --- Fonctions de gestion du modèle actif ---
-ACTIVE_MODEL = "llava" 
+ACTIVE_MODEL = "llava" # Pour l'instant, seul LLaVA est configuré
 
 def load_active_model():
     print(f"Tentative de chargement du modèle actif: {ACTIVE_MODEL}")
     if ACTIVE_MODEL == "llava":
         load_llava_model()
-    # Ajoutez d'autres conditions ici si vous réactivez d'autres modèles
-    # elif ACTIVE_MODEL == "florence":
-    #     load_florence_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)
-    # elif ACTIVE_MODEL == "florence":
-    #     return generate_description_florence(image_path)
     else:
         error_msg = f"Erreur: Modèle actif inconnu ({ACTIVE_MODEL}). Impossible de générer une description."
         print(error_msg)
@@ -176,31 +187,30 @@ def generate_active_description(image_path: str) -> str:
 def is_active_model_loaded() -> bool:
     if ACTIVE_MODEL == "llava":
         return llava_model_loaded
-    # elif ACTIVE_MODEL == "florence":
-    #     return florence_model_loaded
     return False
 
 # --- Section de Test (pour exécution directe de ce fichier) ---
 if __name__ == '__main__':
     print("Début du test de processing.py...")
     
-    # Créer une image de test factice si elle n'existe pas
-    dummy_image_name = "dummy_test_image.png" # S'assure qu'elle est bien ignorée par .gitignore si elle est créée
+    dummy_image_name = "dummy_test_image.png" 
     if not os.path.exists(dummy_image_name):
         try:
-            # ImageDraw a été importé en haut avec PIL
             img = Image.new('RGB', (200, 150), color = 'skyblue')
             draw = ImageDraw.Draw(img)
-            draw.text((10, 10), "Test Image", fill='black')
+            draw.text((10, 10), "Test Image for LLaVA", fill='black')
+            # Ajouter quelques formes pour le test
+            draw.ellipse((30, 50, 90, 110), fill='red', outline='black')
+            draw.rectangle((100, 40, 170, 120), fill='lightgreen', outline='blue')
             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 (vérifiez Pillow) : {e_img}")
 
     if os.path.exists(dummy_image_name):
-        print(f"Utilisation du modèle actif : {ACTIVE_MODEL}")
+        print(f"Utilisation du modèle actif : {ACTIVE_MODEL} sur device {device}")
         print("Chargement du modèle actif (peut prendre du temps, surtout la première fois)...")
-        load_active_model() # Tente de charger le modèle
+        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)

requirements.txt

@@ -4,8 +4,8 @@ python-multipart
 jinja2
 torch
 torchvision
-# torchaudio # Si vous ne l'utilisez pas activement, il peut être omis
-transformers
+# torchaudio # Optionnel
+transformers>=4.38.0 # Assurer une version récente pour LLaVA-NeXT et autres modèles récents
 Pillow
 accelerate
 einops
@@ -15,6 +15,7 @@ tiktoken
 # Pour l'authentification Basic Auth
 python-jose[cryptography]>=3.3.0
 passlib[bcrypt]>=1.7.4
-bcrypt>=3.2.0,<4.1.0 # Force une plage compatible pour bcrypt
+bcrypt>=3.2.0,<4.1.0
 
-# bitsandbytes # Optionnel, décommentez si vous en avez besoin pour la quantification
+# bitsandbytes # Optionnel pour la quantification
+sentencepiece # Souvent requis par les tokenizers de transformers