init

.gitattributes

@@ -18,6 +18,7 @@
 *.parquet filter=lfs diff=lfs merge=lfs -text
 *.pb filter=lfs diff=lfs merge=lfs -text
 *.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
 *.rar filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1 +0,0 @@
-.idea

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.11-slim
+
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME="/home/user"
+ENV PATH="${HOME}/.local/bin:$PATH"
+WORKDIR $HOME/app
+
+
+
+# --- ✅ Cloner le repo privé avec authentification
+# --- https://huggingface.co/docs/hub/en/spaces-sdks-docker#secrets-and-variables-management
+RUN --mount=type=secret,id=GITHUB_TOKEN,mode=0444,required=true \
+    git clone https://sawadogosalif:$(cat /run/secrets/GITHUB_TOKEN)@github.com/BurkimbIA/spaces.git
+
+
+RUN cp -r leaderboards/mt/* .
+
+RUN pip install -r requirements.txt
+
+
+CMD ["python", "app.py"]

README.md

@@ -1,12 +1,12 @@
 ---
-title: MooreFr SaChi Demo
-emoji: 💬
+title: Moore MT Leaderboard
+emoji: 🚗
 colorFrom: red
 colorTo: green
-sdk: gradio
-sdk_version: 5.34.2
+sdk: docker
 app_file: app.py
 pinned: false
+short_description: Text2text Machine Translation for Moore language
 ---
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,285 +0,0 @@
-import re
-import gradio as gr
-import spaces
-from inference import NLLBTranslator, MistralTranslator, ParlerTTSGenerator
-from utils import load_css
-from loguru import logger
-
-
-
-
-translator_nllb = NLLBTranslator()
-translator_mistral = MistralTranslator("sawadogosalif/SaChi_by_Mistral")
-tts_generator = ParlerTTSGenerator("burkimbia/BIA-ParlerTTS-mini")
-
-@spaces.GPU(duration=15)
-def translate_text(message, model_choice, src_lang, tgt_lang):
-    """Fonction de traduction"""
-    
-    if model_choice == "SaChi-MT0.5 (NLLB)":
-        translator = translator_nllb
-    else:
-        translator = translator_mistral
-    
-    return translator.translate(
-        text=message,
-        src_lang=src_lang,
-        tgt_lang=tgt_lang
-    )
-
-@spaces.GPU(duration=15)
-def tts_speech(text, speaker_choice):
-    """Fonction de génération de la synthèse vocale"""
-    
-    sample_rate, audio_arr = tts_generator.generate_speech(
-        text,
-        speaker_type=speaker_choice
-    )
-    
-    if audio_arr is not None:
-        return sample_rate, audio_arr
-    return None
-
-@spaces.GPU(duration=30)  
-def response_with_tts(message, history, model_choice, direction_choice, enable_tts, speaker_choice):
-    """Fonction de réponse avec traduction et TTS optionnel"""
-    
-    if direction_choice == "French to Moore":
-        src_lang, tgt_lang = "fra_Latn", "moor_Latn"
-    else:
-        src_lang, tgt_lang = "moor_Latn", "fra_Latn"
-    
-    try:
-        translated_text = translate_text(message, model_choice, src_lang, tgt_lang)
-    except Exception as e:
-        logger.error(f"Erreur de traduction: {str(e)}")
-        return f"Erreur de traduction: {str(e)}", None
-    
-    # Génération TTS si activée et si on traduit vers le mooré
-    audio_output = None
-    if enable_tts and direction_choice == "French to Moore" and translated_text:
-        try:
-            logger.info("Génération de la synthèse vocale...")
-            tts_result = tts_speech(translated_text, speaker_choice)
-            
-            if tts_result is not None:
-                audio_output = tts_result
-                logger.info("Synthèse vocale générée avec succès")
-            else:
-                logger.warning("Échec de la génération TTS")
-                
-        except Exception as e:
-            logger.error(f"Erreur TTS: {str(e)}")
-    
-    return translated_text, audio_output
-
-
-# Thème personnalisé
-theme = gr.themes.Soft(
-    primary_hue=gr.themes.colors.purple,
-    secondary_hue=gr.themes.colors.blue,
-    neutral_hue=gr.themes.colors.slate,
-    font=gr.themes.GoogleFont("Inter"),
-    radius_size=gr.themes.sizes.radius_lg,
-)
-
-with gr.Blocks(theme=theme, css=load_css(), title="SaChi Multi-Modèles Demo") as demo:
-    
-    # En-tête principal
-    with gr.Row(elem_classes="main-container"):
-        with gr.Column():
-            gr.HTML("""
-            <div class="header-section">
-                <h1 style="margin: 0; font-size: 2.5em; font-weight: 700;">
-                    🎯 SaChi Multi-Modèles Demo avec Synthèse Vocale
-                </h1>
-                <div style="margin-top: 20px;">
-                    <div class="feature-item" style="justify-content: center;">
-                        <span class="feature-icon">🔄</span>
-                        <span>Traduction bidirectionnelle Français ↔ Mooré</span>
-                    </div>
-                    <div class="feature-item" style="justify-content: center;">
-                        <span class="feature-icon">🗣️</span>
-                        <span>Synthèse vocale en mooré avec différentes voix</span>
-                    </div>
-                </div>
-                <div style="margin-top: 25px; padding-top: 20px; border-top: 1px solid rgba(255,255,255,0.2);">
-                    <div style="display: flex; justify-content: center; gap: 30px; flex-wrap: wrap;">
-                        <div class="model-item" style="color: rgba(255,255,255,0.9);">
-                            <span class="feature-icon">📝</span>
-                            <strong>Traduction:</strong> SaChi-MT0.5 (NLLB) / SaChi-MT1.5 (Mistral-Instruct)
-                        </div>
-                        <div class="model-item" style="color: rgba(255,255,255,0.9);">
-                            <span class="feature-icon">🎤</span>
-                            <strong>TTS:</strong> BIA-ParlerTTS-mini (mooré uniquement)
-                        </div>
-                    </div>
-                </div>
-            </div>
-            """)
-    
-    # Interface principale
-    with gr.Row(elem_classes="main-container equal-height-row"):
-        # Colonne de gauche - Configuration
-        with gr.Column(scale=1, elem_classes="equal-height-column"):
-            with gr.Column(elem_classes="config-card"):
-                gr.HTML('<h2 class="section-title"><span class="section-icon">⚙️</span>Configuration</h2>')
-                
-                model_choice = gr.Dropdown(
-                    choices=["SaChi-MT0.5 (NLLB)", "SaChi-MT1.5 (Mistral-Instruct)"],
-                    label="🤖 Modèle de traduction",
-                    value="SaChi-MT1.5 (Mistral-Instruct)",
-                    info="Choisissez le modèle de traduction",
-                    container=True
-                )
-                
-                direction_choice = gr.Dropdown(
-                    choices=["French to Moore", "Moore to French"],
-                    label="🔄 Direction de traduction",
-                    value="French to Moore",
-                    info="Sens de la traduction",
-                    container=True
-                )
-                
-                gr.HTML('<hr style="margin: 20px 0; border: none; border-top: 1px solid #e2e8f0;">')
-                
-                enable_tts = gr.Checkbox(
-                    label="🎤 Activer la synthèse vocale",
-                    value=True,
-                    info="Uniquement pour français → mooré"
-                )
-                
-                speaker_choice = gr.Dropdown(
-                    choices=["default", "male", "female"],
-                    label="👤 Type de voix",
-                    value="default",
-                    info="Type de locuteur pour le TTS",
-                    visible=True,
-                    container=True
-                )
-        
-        # Colonne de droite - Interface de traduction
-        with gr.Column(scale=2, elem_classes="equal-height-column"):
-            with gr.Column(elem_classes="translation-card"):
-                gr.HTML('<h2 class="section-title"><span class="section-icon">💬</span>Traduction</h2>')
-                
-                text_input = gr.Textbox(
-                    label="📝 Texte à traduire",
-                    placeholder="Ex: Bonjour, comment allez-vous ?",
-                    value="Bonjour, comment allez-vous ?",
-                    lines=4,
-                    max_lines=8,
-                    container=True
-                )
-                
-                with gr.Row():
-                    translate_btn = gr.Button(
-                        "🚀 Traduire", 
-                        variant="primary", 
-                        size="lg",
-                        elem_classes="button-primary"
-                    )
-                    clear_btn = gr.Button(
-                        "🗑️ Effacer", 
-                        variant="secondary",
-                        elem_classes="button-secondary"
-                    )
-                
-                text_output = gr.Textbox(
-                    label="📄 Traduction",
-                    lines=4,
-                    max_lines=8,
-                    interactive=False,
-                    container=True
-                )
-                
-                generate_audio_btn = gr.Button(
-                    "🎤 Générer l'audio",
-                    variant="secondary",
-                    size="lg",
-                    visible=True,
-                    elem_classes="button-secondary"
-                )
-                
-                audio_output = gr.Audio(
-                    label="🔊 Synthèse vocale (mooré)",
-                    visible=True,
-                    autoplay=False
-                )
-
-    # Fonctions de traitement
-    def translate_only(message, model_choice, direction_choice):
-        if direction_choice == "French to Moore":
-            src_lang, tgt_lang = "fra_Latn", "moor_Latn"
-        else:
-            src_lang, tgt_lang = "moor_Latn", "fra_Latn"
-        try:
-            translated_text = translate_text(message, model_choice, src_lang, tgt_lang)
-            return translated_text, gr.update(visible=direction_choice == "French to Moore")
-        except Exception as e:
-            logger.error(f"Erreur de traduction: {str(e)}")
-            return f"Erreur de traduction: {str(e)}", gr.update(visible=False)
-
-    def generate_audio(translated_text, speaker_choice):
-        try:
-            logger.info("Génération de la synthèse vocale...")
-            tts_result = tts_speech(translated_text, speaker_choice)
-            if tts_result is not None:
-                logger.info("Synthèse vocale générée avec succès")
-                return tts_result
-            else:
-                logger.warning("Échec de la génération TTS")
-                return None
-        except Exception as e:
-            logger.error(f"Erreur TTS: {str(e)}")
-            return None
-
-    def clear_fields():
-        return (
-            "Bonjour, comment allez-vous ?",
-            "",
-            None,
-            gr.update(visible=True)
-        )
-    
-    def toggle_tts_options(direction, tts_enabled):
-        show_tts = (direction == "French to Moore" and tts_enabled)
-        return {
-            speaker_choice: gr.update(visible=show_tts),
-            audio_output: gr.update(visible=show_tts),
-            generate_audio_btn: gr.update(visible=show_tts)
-        }
-
-    # Événements
-    translate_btn.click(
-        fn=translate_only,
-        inputs=[text_input, model_choice, direction_choice],
-        outputs=[text_output, generate_audio_btn]
-    )
-
-    generate_audio_btn.click(
-        fn=generate_audio,
-        inputs=[text_output, speaker_choice],
-        outputs=[audio_output]
-    )
-
-    clear_btn.click(
-        fn=clear_fields,
-        inputs=[],
-        outputs=[text_input, text_output, audio_output, generate_audio_btn]
-    )
-    
-    direction_choice.change(
-        fn=lambda d, t: toggle_tts_options(d, t),
-        inputs=[direction_choice, enable_tts],
-        outputs=[speaker_choice, audio_output, generate_audio_btn]
-    )
-    
-    enable_tts.change(
-        fn=lambda t, d: toggle_tts_options(d, t),
-        inputs=[enable_tts, direction_choice],
-        outputs=[speaker_choice, audio_output, generate_audio_btn]
-    )
-
-if __name__ == "__main__":
-    demo.launch()

inference/__init__.py

@@ -1,3 +0,0 @@
-from .mistral import MistralTranslator
-from .nllb import NLLBTranslator
-from .parle_tts import ParlerTTSGenerator

inference/mistral.py

@@ -1,53 +0,0 @@
-import os
-import re
-from peft import AutoPeftModelForCausalLM
-from transformers import AutoTokenizer
-
-
-class MistralTranslator:
-    """
-    Wrapper around a Mistral-Instruct-based model fine-tuned for French↔Mooré translation.
-    """
-    def __init__(self, model_id: str, hf_token_env: str = "HF_TOKEN"):
-        hf_token = os.environ.get(hf_token_env)
-        if hf_token is None:
-            raise ValueError(f"Please set the environment variable {hf_token_env} with your HuggingFace token.")
-        self.model = AutoPeftModelForCausalLM.from_pretrained(
-            model_id,
-            token=hf_token,
-            device_map="auto"
-        )
-        self.tokenizer = AutoTokenizer.from_pretrained(model_id)
-        self.prompt_template = (
-            """
-<s>
-
-You are an expert Moore translator. Translate the provided {src_name} text to {tgt_name}.
-The Moore alphabet is: a, ã, b, d, e, ẽ, ɛ, f, g, h, i, ĩ, ɩ, k, l, m, n, o, õ, p, r, s, t, u, ũ, ʋ, v, w, y, z.
-Based on source language ({src_name}), provide the {tgt_name} text.
-[INST]
-### {src_name}: 
-{text}
-[/INST]
-
-### {tgt_name}:
-"""
-        )
-
-    def translate(self, text: str, src_lang: str, tgt_lang: str) -> str:
-        lang_map = {"fra_Latn": "French", "moor_Latn": "Moore"}
-        src_name = lang_map.get(src_lang, src_lang)
-        tgt_name = lang_map.get(tgt_lang, tgt_lang)
-        prompt = self.prompt_template.format(src_name=src_name, tgt_name=tgt_name, text=text)
-        inputs = self.tokenizer(prompt, return_tensors="pt").to("cuda")
-        outputs = self.model.generate(
-            input_ids=inputs.input_ids,
-            attention_mask=inputs.attention_mask,
-            max_new_tokens=512,
-            do_sample=False
-        )
-        decoded = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-        pattern = rf"### {tgt_name}:\s*(.+)"
-        match = re.search(pattern, decoded, re.DOTALL)
-        return match.group(1).strip() if match else decoded
-

inference/nllb.py

@@ -1,98 +0,0 @@
-import re
-import os
-import sys
-import typing as tp
-import unicodedata
-
-import torch
-from sacremoses import MosesPunctNormalizer
-from transformers import AutoModelForSeq2SeqLM, NllbTokenizer
-
-MODEL_URL = "sawadogosalif/SaChi-MT"
-
-
-from huggingface_hub import login
-auth_token = os.getenv('HF_TOKEN')
-login(token=auth_token)
-
-
-
-
-
-class TextPreprocessor:
-    """
-    Mimic the text preprocessing made for the NLLB model.
-    This code is adapted from the Stopes repo of the NLLB team:
-    https://github.com/facebookresearch/stopes/blob/main/stopes/pipelines/monolingual/monolingual_line_processor.py#L214
-    """
-
-    def __init__(self, lang="fr"):
-        self.mpn = MosesPunctNormalizer(lang=lang)
-        self.mpn.substitutions = [
-            (re.compile(r), sub) for r, sub in self.mpn.substitutions
-        ]
-
-    def __call__(self, text: str) -> str:
-        clean = self.mpn.normalize(text)
-        clean = unicodedata.normalize("NFKC", clean)
-        clean = clean[0].lower() + clean[1:]
-        return clean
-
-
-def fix_tokenizer(tokenizer, new_lang):
-    """
-    Ajoute un nouveau token de langue au tokenizer et met à jour les mappings d’identifiants.
-
-    - Ajoute le token spécial s'il n'existe pas déjà.
-    - Initialise ou met à jour `lang_code_to_id` et `id_to_lang_code` en utilisant `getattr` pour éviter les vérifications répétitives.
-    """
-    if new_lang not in tokenizer.additional_special_tokens:
-        tokenizer.add_special_tokens({'additional_special_tokens': [new_lang]})
-
-    tokenizer.lang_code_to_id = getattr(tokenizer, 'lang_code_to_id', {})
-    tokenizer.id_to_lang_code = getattr(tokenizer, 'id_to_lang_code', {})
-
-    if new_lang not in tokenizer.lang_code_to_id:
-        new_lang_id = tokenizer.convert_tokens_to_ids(new_lang)
-        tokenizer.lang_code_to_id[new_lang] = new_lang_id
-        tokenizer.id_to_lang_code[new_lang_id] = new_lang
-
-    return tokenizer
-
-
-
-class NLLBTranslator:
-    def __init__(self):
-        self.model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_URL)
-        if torch.cuda.is_available():
-            self.model.cuda()
-        self.tokenizer = NllbTokenizer.from_pretrained(MODEL_URL)
-        self.tokenizer = fix_tokenizer(self.tokenizer, "moor_Latn")
-
-        self.preprocessor = TextPreprocessor()
-
-    def translate(self, text, src_lang='fr_Latn', tgt_lang='moor_Latn', a=32, b=3, max_input_length=1024, num_beams=5, **kwargs):
-        # 🩹 temporary 
-        tmp = tgt_lang
-        src_lang = tgt_lang
-        tgt_lang = tmp
-
-
-        self.tokenizer.src_lang = src_lang
-        self.tokenizer.tgt_lang = tgt_lang
-        text_clean = self.preprocessor(text)
-
-        inputs = self.tokenizer(text_clean, return_tensors='pt', padding=True, truncation=True, max_length=max_input_length)
-        result = self.model.generate(
-            **inputs.to(self.model.device),
-            forced_bos_token_id=self.tokenizer.convert_tokens_to_ids(tgt_lang),
-            max_new_tokens=int(a + b * inputs.input_ids.shape[1]),
-            num_beams=num_beams,
-            **kwargs
-        )
-        output = self.tokenizer.batch_decode(result, skip_special_tokens=True)[0]
-        if text.endswith('?') or text.endswith('!'):
-            output += text[-1]  # Ajouter le dernier caractère  (soit "?" ou "!")
-
-
-        return output.capitalize()

inference/parle_tts.py

@@ -1,197 +0,0 @@
-import os
-import torch
-import numpy as np
-from transformers import AutoTokenizer
-from parler_tts import ParlerTTSForConditionalGeneration
-from loguru import logger
-
-from huggingface_hub import login
-auth_token = os.getenv('HF_TOKEN')
-login(token=auth_token)
-
-
-class ParlerTTSGenerator:
-    """Générateur TTS pour le mooré utilisant ParlerTTS"""
-    
-    def __init__(self, model_checkpoint="burkimbia/BIA-ParlerTTS-mini"):
-        """
-        Initialiser le générateur TTS
-        
-        Args:
-            model_checkpoint (str): Nom du modèle HuggingFace
-        """
-        self.model_checkpoint = model_checkpoint
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.model = None
-        self.tokenizer = None
-        self.description_tokenizer = None
-        
-        # Configuration par défaut pour la génération
-        self.gen_kwargs = {
-            'do_sample': True, 
-            'temperature': 1.0, 
-            'max_length': 2580, 
-            'min_new_tokens': 10
-        }
-        
-        # Descriptions des locuteurs par défaut
-        self.speaker_descriptions = {
-            "default": "Christian speaks very slowly but has an animated delivery in a room with background",
-            "male": "A male voice speaking in Moore language with calm intonation and clear pronunciation.",
-            "female": "A female voice speaking in Moore language with gentle tone and clear articulation."
-        }
-        
-        self.current_speaker = "default"
-        
-    def load_model(self):
-        """Charger le modèle TTS de manière lazy"""
-        try:
-            if self.model is None:
-                logger.info(f"Chargement du modèle TTS: {self.model_checkpoint}")
-                
-                self.model = ParlerTTSForConditionalGeneration.from_pretrained(
-                    self.model_checkpoint,
-                    use_auth_token=True,  # Pour les repos privés
-                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
-                ).to(self.device)
-                
-                self.tokenizer = AutoTokenizer.from_pretrained(
-                    self.model_checkpoint,
-                    use_auth_token=True
-                )
-                
-                self.description_tokenizer = AutoTokenizer.from_pretrained(
-                    self.model_checkpoint,
-                    use_auth_token=True
-                )
-                
-                logger.info("Modèle TTS chargé avec succès")
-                
-        except Exception as e:
-            logger.error(f"Erreur lors du chargement du modèle TTS: {str(e)}")
-            raise
-    
-    def set_speaker(self, speaker_type="default"):
-        """
-        Définir le type de locuteur
-        
-        Args:
-            speaker_type (str): Type de locuteur ("default", "male", "female")
-        """
-        if speaker_type in self.speaker_descriptions:
-            self.current_speaker = speaker_type
-        else:
-            logger.warning(f"Type de locuteur '{speaker_type}' non reconnu, utilisation de 'default'")
-            self.current_speaker = "default"
-    
-    def set_custom_description(self, description):
-        """
-        Définir une description personnalisée pour le locuteur
-        
-        Args:
-            description (str): Description personnalisée du locuteur
-        """
-        self.speaker_descriptions["custom"] = description
-        self.current_speaker = "custom"
-    
-    def generate_speech(self, text, speaker_type=None):
-        """
-        Générer la parole à partir du texte
-        
-        Args:
-            text (str): Texte à synthétiser
-            speaker_type (str, optional): Type de locuteur à utiliser
-            
-        Returns:
-            tuple: (sample_rate, audio_array) ou (None, None) en cas d'erreur
-        """
-        try:
-            if self.model is None:
-                self.load_model()
-            
-            if speaker_type:
-                self.set_speaker(speaker_type)
-            
-            speaker_description = self.speaker_descriptions[self.current_speaker]
-            
-            text = self._preprocess_text(text)
-            
-            input_ids = self.description_tokenizer(
-                speaker_description,
-                return_tensors="pt",
-                padding=True,
-                truncation=True
-            ).input_ids.to(self.device)
-            
-            prompt_input_ids = self.tokenizer(
-                text,
-                return_tensors="pt",
-                padding=True,
-                truncation=True
-            ).input_ids.to(self.device)
-            
-            logger.info(f"Génération TTS pour: '{text[:50]}...'")
-            
-            with torch.no_grad():
-                generation = self.model.generate(
-                    input_ids=input_ids,
-                    prompt_input_ids=prompt_input_ids,
-                    **self.gen_kwargs
-                )
-            
-            audio_arr = generation.cpu().numpy().squeeze()
-            sample_rate = self.model.config.sampling_rate
-            
-            logger.info("Synthèse vocale réussie")
-            return sample_rate, audio_arr
-            
-        except Exception as e:
-            logger.error(f"Erreur lors de la synthèse vocale: {str(e)}")
-            return None, None
-    
-    def _preprocess_text(self, text):
-        """
-        Préprocesser le texte avant la synthèse
-        
-        Args:
-            text (str): Texte original
-            
-        Returns:
-            str: Texte préprocessé
-        """
-        # Nettoyer le texte si nécessaire
-        text = text.strip()
-        # to improve        
-        return text
-    
-    def is_model_loaded(self):
-        """Vérifier si le modèle est chargé"""
-        return self.model is not None
-    
-    def unload_model(self):
-        """Décharger le modèle pour libérer la mémoire"""
-        if self.model is not None:
-            del self.model
-            del self.tokenizer
-            del self.description_tokenizer
-            self.model = None
-            self.tokenizer = None
-            self.description_tokenizer = None
-            
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
-            
-            logger.info("Modèle TTS déchargé")
-    
-    def get_available_speakers(self):
-        """Obtenir la liste des types de locuteurs disponibles"""
-        return list(self.speaker_descriptions.keys())
-    
-    def get_model_info(self):
-        """Obtenir des informations sur le modèle"""
-        return {
-            "model_checkpoint": self.model_checkpoint,
-            "device": self.device,
-            "is_loaded": self.is_model_loaded(),
-            "available_speakers": self.get_available_speakers()
-        }

requirements.txt

@@ -1,10 +0,0 @@
-accelerate==1.6.0
-bitsandbytes==0.45.5
-peft==0.15.0
-gradio>=3.18.0
-torch
-loguru
-sacremoses
-sentencepiece
-spaces
-git+https://github.com/huggingface/parler-tts.git

styles.css

@@ -1,172 +0,0 @@
-
-.main-container {
-    max-width: 1200px;
-    margin: 0 auto;
-    padding: 20px;
-}
-
-.header-section {
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    color: white;
-    padding: 30px;
-    border-radius: 15px;
-    margin-bottom: 30px;
-    text-align: center;
-    box-shadow: 0 10px 30px rgba(0,0,0,0.1);
-}
-
-.config-card {
-    background: white;
-    border-radius: 15px;
-    padding: 25px;
-    box-shadow: 0 5px 20px rgba(0,0,0,0.08);
-    border: 1px solid #e2e8f0;
-    margin-bottom: 20px;
-    height: 100%;
-    display: flex;
-    flex-direction: column;
-}
-
-.translation-card {
-    background: white;
-    border-radius: 15px;
-    padding: 25px;
-    box-shadow: 0 5px 20px rgba(0,0,0,0.08);
-    border: 1px solid #e2e8f0;
-    height: 100%;
-    display: flex;
-    flex-direction: column;
-}
-
-/* Assurer que les colonnes ont la même hauteur */
-.equal-height-row {
-    display: flex;
-    align-items: stretch;
-}
-
-.equal-height-column {
-    display: flex;
-    flex-direction: column;
-}
-
-.feature-item {
-    display: flex;
-    align-items: center;
-    margin: 10px 0;
-    font-size: 16px;
-}
-
-.feature-icon {
-    margin-right: 10px;
-    font-size: 18px;
-}
-
-.model-item {
-    display: flex;
-    align-items: center;
-    margin: 8px 0;
-    font-size: 14px;
-    color: #64748b;
-}
-
-.section-title {
-    font-size: 20px;
-    font-weight: 600;
-    margin-bottom: 20px;
-    color: #1e293b;
-    display: flex;
-    align-items: center;
-}
-
-.section-icon {
-    margin-right: 10px;
-    font-size: 22px;
-}
-
-.button-primary {
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
-    border: none !important;
-    color: white !important;
-    font-weight: 600 !important;
-    padding: 12px 24px !important;
-    border-radius: 8px !important;
-    transition: all 0.3s ease !important;
-}
-
-.button-primary:hover {
-    transform: translateY(-2px) !important;
-    box-shadow: 0 10px 25px rgba(102, 126, 234, 0.3) !important;
-}
-
-.button-secondary {
-    background: #f8fafc !important;
-    border: 2px solid #e2e8f0 !important;
-    color: #64748b !important;
-    font-weight: 600 !important;
-    padding: 12px 24px !important;
-    border-radius: 8px !important;
-    transition: all 0.3s ease !important;
-}
-
-.button-secondary:hover {
-    background: #f1f5f9 !important;
-    border-color: #cbd5e1 !important;
-}
-
-/* Styles responsifs */
-@media (max-width: 768px) {
-    .main-container {
-        padding: 10px;
-    }
-    
-    .header-section {
-        padding: 20px;
-    }
-    
-    .config-card,
-    .translation-card {
-        padding: 20px;
-    }
-    
-    .equal-height-row {
-        flex-direction: column;
-    }
-}
-
-/* Amélioration des composants Gradio */
-.gradio-container {
-    font-family: 'Inter', sans-serif;
-}
-
-/* Styling pour les dropdowns */
-.gr-dropdown {
-    border-radius: 8px !important;
-    border: 1px solid #e2e8f0 !important;
-}
-
-/* Styling pour les textboxes */
-.gr-textbox {
-    border-radius: 8px !important;
-    border: 1px solid #e2e8f0 !important;
-}
-
-/* Styling pour les checkboxes */
-.gr-checkbox {
-    border-radius: 4px !important;
-}
-
-/* Animation de chargement */
-.loading-spinner {
-    display: inline-block;
-    width: 20px;
-    height: 20px;
-    border: 3px solid #f3f3f3;
-    border-top: 3px solid #667eea;
-    border-radius: 50%;
-    animation: spin 1s linear infinite;
-}
-
-@keyframes spin {
-    0% { transform: rotate(0deg); }
-    100% { transform: rotate(360deg); }
-}

utils.py

@@ -1,13 +0,0 @@
-
-import os
-
-
-def load_css():
-    """Charge le fichier CSS externe"""
-    css_path = os.path.join(os.path.dirname(__file__), "styles.css")
-    try:
-        with open(css_path, "r", encoding="utf-8") as f:
-            return f.read()
-    except FileNotFoundError:
-        logger.warning(f"Fichier CSS non trouvé: {css_path}")
-        return ""