Delete app.py

app.py

@@ -1,627 +0,0 @@
-import gradio as gr
-import spaces
-import torch
-from transformers import T5Tokenizer, T5ForConditionalGeneration, AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForCausalLM, AutoModel, pipeline
-from transformers import logging as hflogging
-import languagecodes
-import httpx, os
-import polars as pl 
-
-hflogging.set_verbosity_error()
-favourite_langs = {"German": "de", "Romanian": "ro", "English": "en", "-----": "-----"}
-df = pl.read_parquet("isolanguages.parquet")
-non_empty_isos = df.slice(1).filter(pl.col("ISO639-1") != "").rows()
-# all_langs = languagecodes.iso_languages_byname
-all_langs = {iso[0]: (iso[1], iso[2], iso[3]) for iso in non_empty_isos} # {'Romanian': ('ro', 'rum', 'ron')}
-# iso1_to_name = {codes[0]: lang for entry in all_langs for lang, codes in entry.items()} # {'ro': 'Romanian', 'de': 'German'}
-iso1_to_name = {iso[1]: iso[0] for iso in non_empty_isos} # {'ro': 'Romanian', 'de': 'German'}
-langs = list(favourite_langs.keys())
-langs.extend(list(all_langs.keys())) # Language options as list, add favourite languages first
-
-models = ["Helsinki-NLP", "QUICKMT", "Argos", "Google", "HPLT", "HPLT-OPUS",
-          "Helsinki-NLP/opus-mt-tc-bible-big-mul-mul", "Helsinki-NLP/opus-mt-tc-bible-big-mul-deu_eng_nld",
-          "Helsinki-NLP/opus-mt-tc-bible-big-mul-deu_eng_fra_por_spa", "Helsinki-NLP/opus-mt-tc-bible-big-deu_eng_fra_por_spa-mul",
-          "Helsinki-NLP/opus-mt-tc-bible-big-roa-deu_eng_fra_por_spa", "Helsinki-NLP/opus-mt-tc-bible-big-deu_eng_fra_por_spa-roa", "Helsinki-NLP/opus-mt-tc-bible-big-roa-en",
-          "facebook/nllb-200-distilled-600M", "facebook/nllb-200-distilled-1.3B", "facebook/nllb-200-1.3B", "facebook/nllb-200-3.3B",
-          "facebook/mbart-large-50-many-to-many-mmt", "facebook/mbart-large-50-one-to-many-mmt", "facebook/mbart-large-50-many-to-one-mmt",
-          "facebook/m2m100_418M", "facebook/m2m100_1.2B", "Lego-MT/Lego-MT",
-          "bigscience/mt0-small", "bigscience/mt0-base", "bigscience/mt0-large", "bigscience/mt0-xl",
-          "bigscience/bloomz-560m", "bigscience/bloomz-1b1", "bigscience/bloomz-1b7", "bigscience/bloomz-3b",
-          "google-t5/t5-small", "google-t5/t5-base", "google-t5/t5-large",
-          "google/flan-t5-small", "google/flan-t5-base", "google/flan-t5-large", "google/flan-t5-xl",
-          "google/madlad400-3b-mt", "jbochi/madlad400-3b-mt",
-          "HuggingFaceTB/SmolLM3-3B", "winninghealth/WiNGPT-Babel-2",
-          "utter-project/EuroLLM-1.7B", "utter-project/EuroLLM-1.7B-Instruct",
-          "Unbabel/Tower-Plus-2B", "Unbabel/TowerInstruct-7B-v0.2", "Unbabel/TowerInstruct-Mistral-7B-v0.2"
-          ]
-DEFAULTS = [langs[0], langs[1], models[0]]
-
-def model_to_cuda(model):
-    # Move the model to GPU if available
-    if torch.cuda.is_available():
-        model = model.to('cuda')
-        print("CUDA is available! Using GPU.")
-    else:
-        print("CUDA not available! Using CPU.")
-    return model
-
-def HelsinkiNLPAutoTokenizer(sl, tl, input_text): # deprecated
-    if model_name == "Helsinki-NLP":
-        message_text = f'Translated from {sl} to {tl} with {model_name}.'
-        try:
-            model_name = f"Helsinki-NLP/opus-mt-{sl}-{tl}"
-            tokenizer = AutoTokenizer.from_pretrained(model_name)
-            model = model_to_cuda(AutoModelForSeq2SeqLM.from_pretrained(model_name))
-        except EnvironmentError:
-            try:   
-                model_name = f"Helsinki-NLP/opus-tatoeba-{sl}-{tl}"
-                tokenizer = AutoTokenizer.from_pretrained(model_name)
-                model = model_to_cuda(AutoModelForSeq2SeqLM.from_pretrained(model_name))
-                input_ids = tokenizer.encode(prompt, return_tensors="pt")
-                output_ids = model.generate(input_ids, max_length=512)
-                translated_text = tokenizer.decode(output_ids[0], skip_special_tokens=True)
-                return translated_text, message_text
-            except EnvironmentError as error:
-                return f"Error finding model: {model_name}! Try other available language combination.", error
-                      
-class Translators:
-    def __init__(self, model_name: str, sl: str, tl: str, input_text: str):
-        self.model_name = model_name
-        self.sl, self.tl = sl, tl
-        self.input_text = input_text
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        
-    def google(self):  
-        url = os.environ['GCLIENT'] + f'sl={self.sl}&tl={self.tl}&q={self.input_text}'
-        response = httpx.get(url)
-        return response.json()[0][0][0]
-    
-    def simplepipe(self):
-        try:
-            pipe = pipeline("translation", model=self.model_name, device=self.device)                
-            translation = pipe(self.input_text)
-            message = f'Translated from {iso1_to_name[self.sl]} to {iso1_to_name[self.tl]} with {self.model_name}.'
-            return translation[0]['translation_text'], message
-        except Exception as error:
-            return f"Error translating with model: {self.model_name}! Try other available language combination or model.", error
-    
-    def hplt(self, opus = False):
-        # langs = ['ar', 'bs', 'ca', 'en', 'et', 'eu', 'fi', 'ga', 'gl', 'hi', 'hr', 'is', 'mt', 'nn', 'sq', 'sw', 'zh_hant']
-        hplt_models = ['ar-en', 'bs-en', 'ca-en', 'en-ar', 'en-bs', 'en-ca', 'en-et', 'en-eu', 'en-fi',
-                  'en-ga', 'en-gl', 'en-hi', 'en-hr', 'en-is', 'en-mt', 'en-nn', 'en-sq', 'en-sw',
-                  'en-zh_hant', 'et-en', 'eu-en', 'fi-en', 'ga-en', 'gl-en', 'hi-en', 'hr-en',
-                  'is-en', 'mt-en', 'nn-en', 'sq-en', 'sw-en', 'zh_hant-en']
-        if opus:
-            hplt_model = f'HPLT/translate-{self.sl}-{self.tl}-v1.0-hplt_opus' # HPLT/translate-en-hr-v1.0-hplt_opus
-        else:
-            hplt_model = f'HPLT/translate-{self.sl}-{self.tl}-v1.0-hplt' # HPLT/translate-en-hr-v1.0-hplt
-        if f'{self.sl}-{self.tl}' in hplt_models:
-            pipe = pipeline("translation", model=hplt_model, device=self.device)
-            translation = pipe(self.input_text)
-            translated_text = translation[0]['translation_text']
-            message_text = f'Translated from {iso1_to_name[self.sl]} to {iso1_to_name[self.tl]} with {hplt_model}.'
-        else:
-            translated_text = f'HPLT model from {iso1_to_name[self.sl]} to {iso1_to_name[self.tl]} not available!'
-            message_text = f"Available models: {', '.join(hplt_models)}"
-        return translated_text, message_text
-
-    @staticmethod
-    def download_argos_model(from_code, to_code):
-        import argostranslate.package
-        print('Downloading model', from_code, to_code) 
-        # Download and install Argos Translate package
-        argostranslate.package.update_package_index()
-        available_packages = argostranslate.package.get_available_packages()
-        package_to_install = next(
-            filter(lambda x: x.from_code == from_code and x.to_code == to_code, available_packages)
-        )
-        argostranslate.package.install_from_path(package_to_install.download())
-    
-    def argos(self):
-        import argostranslate.translate, argostranslate.package
-        try:
-            Translators.download_argos_model(self.sl, self.tl) # Download model
-            translated_text = argostranslate.translate.translate(self.input_text, self.sl, self.tl) # Translate
-        except StopIteration:
-            # packages_info = ', '.join(f"{pkg.get_description()}->{str(pkg.links)} {str(pkg.source_languages)}" for pkg in argostranslate.package.get_available_packages())
-            packages_info = ', '.join(f"{pkg.from_name} ({pkg.from_code}) -> {pkg.to_name} ({pkg.to_code})" for pkg in argostranslate.package.get_available_packages())
-            translated_text = f"No Argos model for {self.sl} to {self.tl}. Try other model or languages combination from the available Argos models: {packages_info}."
-        except Exception as error:
-            translated_text = error
-        return translated_text
-
-    @staticmethod
-    def quickmttranslate(model_path, input_text):
-        from quickmt import Translator
-        # 'auto' auto-detects GPU, set to "cpu" to force CPU inference
-        device = 'gpu' if torch.cuda.is_available() else 'cpu'
-        translator = Translator(str(model_path), device = device)       
-        # translation = Translator(f"./quickmt-{self.sl}-{self.tl}/", device="auto", inter_threads=2)       
-        # set beam size to 1 for faster speed (but lower quality)
-        translation = translator(input_text, beam_size=5, max_input_length = 512, max_decoding_length = 512)
-        # print(model_path, input_text, translation)
-        return translation
-
-    @staticmethod
-    def quickmtdownload(model_name):
-        from quickmt.hub import hf_download
-        from pathlib import Path
-        model_path = Path("/quickmt/models") / model_name
-        if not model_path.exists():
-            hf_download(
-            model_name = f"quickmt/{model_name}",
-            output_dir=Path("/quickmt/models") / model_name,
-        )
-        return model_path
-            
-    def quickmt(self):
-        model_name = f"quickmt-{self.sl}-{self.tl}"
-        # from quickmt.hub import hf_list
-        # quickmt_models = [i.split("/quickmt-")[1] for i in hf_list()]
-        # quickmt_models.sort()
-        # print(quickmt_models)
-        quickmt_models = ['ar-en', 'bn-en', 'cs-en', 'da-en', 'de-en', 'el-en', 'en-ar', 'en-bn', 'en-cs', 'en-de', 'en-el', 'en-es',
-                  'en-fa', 'en-fr', 'en-he', 'en-hi', 'en-hu', 'en-id', 'en-it', 'en-ja', 'en-ko', 'en-lv', 'en-pl', 'en-pt',
-                  'en-ro', 'en-ru', 'en-th', 'en-tr', 'en-ur', 'en-vi', 'en-zh', 'es-en', 'fa-en', 'fr-en', 'he-en', 'hi-en',
-                  'hu-en', 'id-en', 'it-en', 'ja-en', 'ko-en', 'lv-en', 'pl-en', 'pt-en', 'ro-en', 'ru-en', 'th-en', 'tr-en', 'ur-en', 'vi-en', 'zh-en']
-        # available_languages = list(set([lang for model in quickmt_models for lang in model.split('-')]))
-        # available_languages.sort()
-        available_languages = ['ar', 'bn', 'cs', 'da', 'de', 'el', 'en', 'es', 'fa', 'fr', 'he', 'hi', 'hu',
-                               'id', 'it', 'ja', 'ko', 'lv', 'pl', 'pt', 'ro', 'ru', 'th', 'tr', 'ur', 'vi', 'zh']
-        # Direct translation model
-        if f"{self.sl}-{self.tl}" in quickmt_models:
-            model_path = Translators.quickmtdownload(model_name)
-            translated_text = Translators.quickmttranslate(model_path, self.input_text)
-            message = f'Translated from {iso1_to_name[self.sl]} to {iso1_to_name[self.tl]} with {model_name}.'
-        # Pivot language English
-        elif self.sl in available_languages and self.tl in available_languages:
-            model_name = f"quickmt-{self.sl}-en"
-            model_path = Translators.quickmtdownload(model_name)
-            entranslation = Translators.quickmttranslate(model_path, self.input_text)
-            model_name = f"quickmt-en-{self.tl}"
-            model_path = Translators.quickmtdownload(model_name)
-            translated_text = Translators.quickmttranslate(model_path, entranslation)
-            message = f'Translated from {iso1_to_name[self.sl]} to {iso1_to_name[self.tl]} with Quickmt using pivot language English.'
-        else:
-            translated_text = f'No Quickmt model available for translation from {iso1_to_name[self.sl]} to {iso1_to_name[self.tl]}!'
-            message = f"Available models: {', '.join(quickmt_models)}"
-        return translated_text, message
-        
-    def HelsinkiNLP_mulroa(self):
-        try:
-            pipe = pipeline("translation", model=self.model_name, device=self.device)                
-            iso1to3 = {iso[1]: iso[3] for iso in non_empty_isos} # {'ro': 'ron'}
-            iso3tl = iso1to3.get(self.tl) # 'deu', 'ron', 'eng', 'fra'
-            translation = pipe(f'>>{iso3tl}<< {self.input_text}')
-            return translation[0]['translation_text'], f'Translated from {iso1_to_name[self.sl]} to {iso1_to_name[self.tl]} with {self.model_name}.'
-        except Exception as error:
-            return f"Error translating with model: {self.model_name}! Try other available language combination.", error
-    
-    def HelsinkiNLP(self):
-        try: # Standard bilingual model
-            model_name = f"Helsinki-NLP/opus-mt-{self.sl}-{self.tl}"
-            pipe = pipeline("translation", model=model_name, device=self.device)
-            translation = pipe(self.input_text)
-            return translation[0]['translation_text'], f'Translated from {iso1_to_name[self.sl]} to {iso1_to_name[self.tl]} with {model_name}.'
-        except EnvironmentError:
-            try: # Tatoeba models
-                model_name = f"Helsinki-NLP/opus-tatoeba-{self.sl}-{self.tl}"
-                pipe = pipeline("translation", model=model_name, device=self.device)
-                translation = pipe(self.input_text)
-                return translation[0]['translation_text'], f'Translated from {iso1_to_name[self.sl]} to {iso1_to_name[self.tl]} with {model_name}.'
-            except EnvironmentError as error:
-                self.model_name = "Helsinki-NLP/opus-mt-tc-bible-big-mul-mul" # Last resort: try multi to multi
-                return self.HelsinkiNLP_mulroa()
-        except KeyError as error:
-            return f"Error: Translation direction {self.sl} to {self.tl} is not supported by Helsinki Translation Models", error
-  
-    def LegoMT(self):
-        from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer
-        model = M2M100ForConditionalGeneration.from_pretrained(self.model_name) # "Lego-MT/Lego-MT"
-        tokenizer = M2M100Tokenizer.from_pretrained(self.model_name)
-        tokenizer.src_lang = self.sl
-        encoded = tokenizer(self.input_text, return_tensors="pt")
-        generated_tokens = model.generate(**encoded, forced_bos_token_id=tokenizer.get_lang_id(self.tl))
-        return tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
-        
-    def madlad(self):
-        model = T5ForConditionalGeneration.from_pretrained(self.model_name, device_map="auto")
-        tokenizer = T5Tokenizer.from_pretrained(self.model_name)
-        text = f"<2{self.tl}> {self.input_text}"
-        # input_ids = tokenizer(text, return_tensors="pt").input_ids.to(model.device)
-        # outputs = model.generate(input_ids=input_ids, max_new_tokens=512)    
-        # return tokenizer.decode(outputs[0], skip_special_tokens=True)
-        # return tokenizer.batch_decode(outputs, skip_special_tokens=True)
-        # Use a pipeline as a high-level helper
-        translator = pipeline('translation', model=model, tokenizer=tokenizer, src_lang=self.sl, tgt_lang=self.tl)
-        translated_text = translator(text, max_length=512)
-        return translated_text[0]['translation_text']
-    
-    def smollm(self):
-        tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-        model = AutoModelForCausalLM.from_pretrained(self.model_name)
-        prompt = f"""Translate the following {self.sl} text to {self.tl}, generating only the translated text and maintaining the original meaning and tone:
-        {self.input_text}
-        Translation:"""
-        inputs = tokenizer(prompt, return_tensors="pt")
-        outputs = model.generate(
-            inputs.input_ids,
-            max_length=len(inputs.input_ids[0]) + 150,
-            temperature=0.3,
-            do_sample=True
-        ) 
-        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        print(response)
-        return response.split("Translation:")[-1].strip()
-
-    def flan(self):
-        tokenizer = T5Tokenizer.from_pretrained(self.model_name, legacy=False)
-        model = T5ForConditionalGeneration.from_pretrained(self.model_name)
-        prompt = f"translate {self.sl} to {self.tl}: {self.input_text}"
-        input_ids = tokenizer(prompt, return_tensors="pt").input_ids
-        outputs = model.generate(input_ids)
-        return tokenizer.decode(outputs[0], skip_special_tokens=True).strip()
-
-    def tfive(self):
-        tokenizer = T5Tokenizer.from_pretrained(self.model_name)
-        model = T5ForConditionalGeneration.from_pretrained(self.model_name, device_map="auto")
-        prompt = f"translate {self.sl} to {self.tl}: {self.input_text}"
-        input_ids = tokenizer.encode(prompt, return_tensors="pt")
-        output_ids = model.generate(input_ids, max_length=512)
-        translated_text = tokenizer.decode(output_ids[0], skip_special_tokens=True).strip()
-        return translated_text
-    
-    def mbart_many_to_many(self):
-        from transformers import MBartForConditionalGeneration, MBart50TokenizerFast
-        model = MBartForConditionalGeneration.from_pretrained(self.model_name)
-        tokenizer = MBart50TokenizerFast.from_pretrained(self.model_name)
-        # translate source to target
-        tokenizer.src_lang = languagecodes.mbart_large_languages[self.sl]
-        encoded = tokenizer(self.input_text, return_tensors="pt")
-        generated_tokens = model.generate(
-            **encoded,
-            forced_bos_token_id=tokenizer.lang_code_to_id[languagecodes.mbart_large_languages[self.tl]]
-        )
-        return tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
-    
-    def mbart_one_to_many(self):
-        # translate from English
-        from transformers import MBartForConditionalGeneration, MBart50TokenizerFast
-        model = MBartForConditionalGeneration.from_pretrained(self.model_name)
-        tokenizer = MBart50TokenizerFast.from_pretrained(self.model_name, src_lang="en_XX")
-        model_inputs = tokenizer(self.input_text, return_tensors="pt")
-        langid = languagecodes.mbart_large_languages[self.tl]
-        generated_tokens = model.generate(
-            **model_inputs,
-            forced_bos_token_id=tokenizer.lang_code_to_id[langid]
-        )
-        return tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
-    
-    def mbart_many_to_one(self):
-        # translate to English
-        from transformers import MBartForConditionalGeneration, MBart50TokenizerFast
-        model = MBartForConditionalGeneration.from_pretrained(self.model_name)
-        tokenizer = MBart50TokenizerFast.from_pretrained(self.model_name)
-        tokenizer.src_lang = languagecodes.mbart_large_languages[self.sl]
-        encoded = tokenizer(self.input_text, return_tensors="pt")
-        generated_tokens = model.generate(**encoded)
-        return tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
-        
-    def mtom(self):
-        from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer
-        model = M2M100ForConditionalGeneration.from_pretrained(self.model_name)
-        tokenizer = M2M100Tokenizer.from_pretrained(self.model_name)
-        tokenizer.src_lang = self.sl
-        encoded = tokenizer(self.input_text, return_tensors="pt")
-        generated_tokens = model.generate(**encoded, forced_bos_token_id=tokenizer.get_lang_id(self.tl))
-        return tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
-
-    def bigscience(self):  
-        tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-        model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name)
-        self.input_text = self.input_text if self.input_text.endswith('.') else f'{self.input_text}.'
-        inputs = tokenizer.encode(f"Translate to {self.tl}: {self.input_text}", return_tensors="pt")
-        outputs = model.generate(inputs)
-        translation = tokenizer.decode(outputs[0])
-        translation = translation.replace('<pad> ', '').replace('</s>', '')
-        return translation
-    
-    def bloomz(self):  
-        tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-        model = AutoModelForCausalLM.from_pretrained(self.model_name)
-        self.input_text = self.input_text if self.input_text.endswith('.') else f'{self.input_text}.'
-        # inputs = tokenizer.encode(f"Translate from {self.sl} to {self.tl}: {self.input_text} Translation:", return_tensors="pt")
-        inputs = tokenizer.encode(f"Translate to {self.tl}: {self.input_text}", return_tensors="pt")
-        outputs = model.generate(inputs)
-        translation = tokenizer.decode(outputs[0])
-        translation = translation.replace('<pad> ', '').replace('</s>', '')
-        translation = translation.split('Translation:')[-1].strip() if 'Translation:' in translation else translation.strip()
-        return translation
-    
-    def nllb(self):
-        tokenizer = AutoTokenizer.from_pretrained(self.model_name, src_lang=self.sl)
-        # model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name, device_map="auto", torch_dtype=torch.bfloat16)
-        model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name)
-        translator = pipeline('translation', model=model, tokenizer=tokenizer, src_lang=self.sl, tgt_lang=self.tl)
-        translated_text = translator(self.input_text, max_length=512)
-        return translated_text[0]['translation_text']
-    
-    def wingpt(self):
-        model = AutoModelForCausalLM.from_pretrained(
-           self.model_name,
-           torch_dtype="auto",
-           device_map="auto"
-        )
-        tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-        # input_json = '{"input_text": self.input_text}'
-        messages = [
-           {"role": "system", "content": f"Translate this to {self.tl} language"}, 
-           {"role": "user", "content": self.input_text}
-        ]
-        
-        text = tokenizer.apply_chat_template(
-           messages,
-           tokenize=False,
-           add_generation_prompt=True
-        )
-        model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
-        
-        generated_ids = model.generate(
-           **model_inputs,
-           max_new_tokens=512,
-           temperature=0.1
-        )
-        
-        generated_ids = [
-           output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
-        ]
-        print(tokenizer.batch_decode(generated_ids, skip_special_tokens=True))
-        output = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
-        result = output.split('\n')[-1].strip() if '\n' in output else output.strip()
-        return result
-    
-    def eurollm(self):
-        tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-        model = AutoModelForCausalLM.from_pretrained(self.model_name)  
-        prompt = f"{self.sl}: {self.input_text} {self.tl}:"
-        inputs = tokenizer(prompt, return_tensors="pt")
-        outputs = model.generate(**inputs, max_new_tokens=512)
-        output = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        print(output)
-        # result = output.rsplit(f'{self.tl}:')[-1].strip() if f'{self.tl}:' in output else output.strip()
-        result = output.rsplit(f'{self.tl}:')[-1].strip() if '\n' in output or f'{self.tl}:' in output else output.strip()
-        return result
-    
-    def eurollm_instruct(self):
-        tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-        model = AutoModelForCausalLM.from_pretrained(self.model_name)
-        text = f'<|im_start|>system\n<|im_end|>\n<|im_start|>user\nTranslate the following {self.sl} source text to {self.tl}:\n{self.sl}: {self.input_text} \n{self.tl}: <|im_end|>\n<|im_start|>assistant\n'
-        inputs = tokenizer(text, return_tensors="pt")
-        outputs = model.generate(**inputs, max_new_tokens=512)
-        output = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        if f'{self.tl}:' in output:
-            output = output.rsplit(f'{self.tl}:')[-1].strip().replace('assistant\n', '').strip()
-        return output
-
-    def unbabel(self):
-        pipe = pipeline("text-generation", model=self.model_name, torch_dtype=torch.bfloat16, device_map="auto")
-        messages = [{"role": "user",
-                     "content": f"Translate the following text from {self.sl} into {self.tl}.\n{self.sl}: {self.input_text}.\n{self.tl}:"}]
-        prompt = pipe.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
-        tokenized_input = pipe.tokenizer(self.input_text, return_tensors="pt")
-        num_input_tokens = len(tokenized_input["input_ids"][0])
-        max_new_tokens = round(num_input_tokens + 0.5 * num_input_tokens)
-        outputs = pipe(prompt, max_new_tokens=max_new_tokens, do_sample=False)
-        translated_text = outputs[0]["generated_text"]
-        print(f"Input chars: {len(self.input_text)}", f"Input tokens: {num_input_tokens}", f"max_new_tokens: {max_new_tokens}",
-              "Chars to tokens ratio:", round(len(self.input_text) / num_input_tokens, 2), f"Raw translation: {translated_text}")
-        markers = ["<end_of_turn>", "<|im_end|>", "<|im_start|>assistant"] # , "\n" 
-        for marker in markers:
-            if marker in translated_text:
-                translated_text = translated_text.split(marker)[1].strip()
-        translated_text = translated_text.replace('Answer:', '', 1).strip() if translated_text.startswith('Answer:') else translated_text
-        translated_text = translated_text.split("Translated text:")[0].strip() if "Translated text:" in translated_text else translated_text
-        split_translated_text = translated_text.split('\n', translated_text.count('\n'))
-        translated_text = '\n'.join(split_translated_text[:self.input_text.count('\n')+1])
-        return translated_text
-
-    def bergamot(model_name: str = 'deen', sl: str = 'de', tl: str = 'en', input_text: str = 'Hallo, mein Freund'):
-        try:
-            import bergamot
-            # input_text = [input_text] if isinstance(input_text, str) else input_text           
-            config = bergamot.ServiceConfig(numWorkers=4)
-            service = bergamot.Service(config)
-            model = service.modelFromConfigPath(f"./{model_name}/bergamot.config.yml")
-            options = bergamot.ResponseOptions(alignment=False, qualityScores=False, HTML=False)
-            rawresponse = service.translate(model, bergamot.VectorString(input_text), options)
-            translated_text: str = next(iter(rawresponse)).target.text
-            message_text = f"Translated from {sl} to {tl} with Bergamot {model_name}."
-        except Exception as error:
-            response = error
-        return translated_text, message_text
-
-@spaces.GPU
-def translate_text(input_text: str, s_language: str, t_language: str, model_name: str) -> tuple[str, str]:
-    """
-    Translates the input text from the source language to the target language  using a specified model.
-
-    Parameters:
-        input_text (str): The source text to be translated
-        s_language (str): The source language of the input text
-        t_language (str): The target language in which the input text is translated
-        model_name (str): The selected translation model name
-
-    Returns:
-        tuple: 
-            translated_text(str): The input text translated to the selected target language
-            message_text(str):  A descriptive message summarizing the translation process. Example: "Translated from English to German with Helsinki-NLP."
-    
-    Example:
-        >>> translate_text("Hello world", "English", "German", "Helsinki-NLP")
-        ("Hallo Welt", "Translated from English to German with Helsinki-NLP.")
-    """
-    
-    sl = all_langs[s_language][0]
-    tl = all_langs[t_language][0]
-    message_text = f'Translated from {s_language} to {t_language} with {model_name}'
-    if not input_text or input_text.strip() == '':
-        translated_text = f'No input text entered!'
-        message_text = 'Please enter a text to translate!'
-        return translated_text, message_text
-    if sl == tl:
-        translated_text = f'Source language {s_language} identical to target language {t_language}!'
-        message_text = 'Please choose different target and source language!'
-        return translated_text, message_text 
-    translated_text = None
-    try:    
-        if "-mul" in model_name.lower() or "mul-" in model_name.lower() or "-roa" in model_name.lower():
-            translated_text, message_text = Translators(model_name, sl, tl, input_text).HelsinkiNLP_mulroa()
-        
-        elif model_name == "Helsinki-NLP":
-            translated_text, message_text = Translators(model_name, sl, tl, input_text).HelsinkiNLP()
-        
-        elif model_name == 'Argos':
-            translated_text = Translators(model_name, sl, tl, input_text).argos()
-
-        elif model_name == "QUICKMT":
-            translated_text, message_text = Translators(model_name, sl, tl, input_text).quickmt()
-    
-        elif model_name == 'Google':
-            translated_text = Translators(model_name, sl, tl, input_text).google()
-    
-        elif model_name == "Helsinki-NLP/opus-mt-tc-bible-big-roa-en":
-            translated_text, message_text = Translators(model_name, sl, tl, input_text).simplepipe()
-        
-        elif "m2m" in model_name.lower():
-            translated_text = Translators(model_name, sl, tl, input_text).mtom()
-
-        elif "lego" in model_name.lower():
-            translated_text = Translators(model_name, sl, tl, input_text).LegoMT()
-        
-        elif model_name.startswith('google-t5'):
-            translated_text = Translators(model_name, s_language, t_language, input_text).tfive()
-            
-        elif 'flan' in model_name.lower():
-            translated_text = Translators(model_name, s_language, t_language, input_text).flan()
-
-        elif 'madlad' in model_name.lower():
-            translated_text = Translators(model_name, sl, tl, input_text).madlad()
-            
-        elif 'mt0' in model_name.lower():
-            translated_text = Translators(model_name, s_language, t_language, input_text).bigscience()
-    
-        elif 'bloomz' in model_name.lower():
-            translated_text = Translators(model_name, s_language, t_language, input_text).bloomz()
-            
-        elif 'nllb' in model_name.lower():
-            nnlbsl, nnlbtl = languagecodes.nllb_language_codes[s_language], languagecodes.nllb_language_codes[t_language]
-            translated_text = Translators(model_name, nnlbsl, nnlbtl, input_text).nllb()
-        
-        elif model_name == "facebook/mbart-large-50-many-to-many-mmt":
-            translated_text = Translators(model_name, s_language, t_language, input_text).mbart_many_to_many()
-    
-        elif model_name == "facebook/mbart-large-50-one-to-many-mmt":
-            translated_text = Translators(model_name, s_language, t_language, input_text).mbart_one_to_many()
-    
-        elif model_name == "facebook/mbart-large-50-many-to-one-mmt":
-            translated_text = Translators(model_name, s_language, t_language, input_text).mbart_many_to_one()
-          
-        elif model_name == "utter-project/EuroLLM-1.7B-Instruct":
-            translated_text = Translators(model_name, s_language, t_language, input_text).eurollm_instruct()
-        
-        elif model_name == "utter-project/EuroLLM-1.7B":
-            translated_text = Translators(model_name, s_language, t_language, input_text).eurollm()
-                
-        elif 'Unbabel' in model_name:   
-            translated_text = Translators(model_name, s_language, t_language, input_text).unbabel()
-            
-        elif model_name == "HuggingFaceTB/SmolLM3-3B":
-            translated_text = Translators(model_name, s_language, t_language, input_text).smollm()
-
-        elif model_name == "winninghealth/WiNGPT-Babel-2":      
-            translated_text = Translators(model_name, s_language, t_language, input_text).wingpt()
-
-        elif "HPLT" in model_name:
-            if model_name == "HPLT-OPUS":
-                translated_text, message_text = Translators(model_name, sl, tl, input_text).hplt(opus = True)
-            else:
-                translated_text, message_text = Translators(model_name, sl, tl, input_text).hplt()
-        
-        elif model_name == "Bergamot":
-            translated_text, message_text = Translators(model_name, s_language, t_language, input_text).bergamot()
-            
-    except Exception as error:
-        translated_text = error
-    finally:
-        print(input_text, translated_text, message_text)
-        return translated_text, message_text
-
-# Function to swap dropdown values
-def swap_languages(src_lang, tgt_lang):
-    return tgt_lang, src_lang 
-
-def get_info(model_name: str, sl: str = None, tl: str = None):
-    helsinki = '### [Helsinki-NLP](https://huggingface.co/Helsinki-NLP "Helsinki-NLP")'
-    if model_name == "Helsinki-NLP" and sl and tl:
-        url = f'https://huggingface.co/{model_name}/opus-mt-{sl}-{tl}/raw/main/README.md'
-        response = httpx.get(url).text
-        if 'Repository not found' in response or 'Invalid username or password' in response:
-            return helsinki
-        return response
-    elif model_name == "Argos":
-        return httpx.get(f'https://huggingface.co/TiberiuCristianLeon/Argostranslate/raw/main/README.md').text
-    elif "HPLT" in model_name:
-        return """[HPLT Uni direction translation models](https://huggingface.co/collections/HPLT/hplt-12-uni-direction-translation-models)
-            ['ar-en', 'bs-en', 'ca-en', 'en-ar', 'en-bs', 'en-ca', 'en-et', 'en-eu', 'en-fi',
-            'en-ga', 'en-gl', 'en-hi', 'en-hr', 'en-is', 'en-mt', 'en-nn', 'en-sq', 'en-sw',
-            'en-zh_hant', 'et-en', 'eu-en', 'fi-en', 'ga-en', 'gl-en', 'hi-en', 'hr-en',
-            'is-en', 'mt-en', 'nn-en', 'sq-en', 'sw-en', 'zh_hant-en']"""
-    elif "QUICKMT" in model_name:
-        return """[QUICKMT](https://huggingface.co/quickmt)
-            ['ar-en', 'bn-en', 'cs-en', 'da-en', 'de-en', 'el-en', 'en-ar', 'en-bn', 'en-cs', 'en-de', 'en-el', 'en-es',
-            'en-fa', 'en-fr', 'en-he', 'en-hi', 'en-hu', 'en-id', 'en-it', 'en-ja', 'en-ko', 'en-lv', 'en-pl', 'en-pt',
-            'en-ro', 'en-ru', 'en-th', 'en-tr', 'en-ur', 'en-vi', 'en-zh', 'es-en', 'fa-en', 'fr-en', 'he-en', 'hi-en',
-            'hu-en', 'id-en', 'it-en', 'ja-en', 'ko-en', 'lv-en', 'pl-en', 'pt-en', 'ro-en', 'ru-en', 'th-en', 'tr-en', 'ur-en', 'vi-en', 'zh-en']"""
-    elif model_name == "Google":
-        return "Google Translate Online"
-    else:
-        return httpx.get(f'https://huggingface.co/{model_name}/raw/main/README.md').text
-
-def create_interface():
-    with gr.Blocks() as interface:
-        gr.Markdown("### Machine Text Translation with Gradio API and MCP Server")
-        input_text = gr.Textbox(label="Enter text to translate:", placeholder="Type your text here, maximum 512 tokens", autofocus=True, submit_btn='Translate', max_length=512)
-        
-        with gr.Row(variant="compact"):
-            s_language = gr.Dropdown(choices=langs, value = DEFAULTS[0], label="Source language", interactive=True, scale=2)
-            t_language = gr.Dropdown(choices=langs, value = DEFAULTS[1], label="Target language", interactive=True, scale=2)
-            swap_btn = gr.Button("Swap Languages", size="md", scale=1)
-            swap_btn.click(fn=swap_languages, inputs=[s_language, t_language], outputs=[s_language, t_language], api_name=False, show_api=False)
-        # with gr.Row(equal_height=True):
-            model_name = gr.Dropdown(choices=models, label=f"Select a model. Default is {DEFAULTS[2]}.", value=DEFAULTS[2], interactive=True, scale=2)
-            # translate_btn = gr.Button(value="Translate", scale=1)
-
-        translated_text = gr.Textbox(label="Translated text:", placeholder="Display field for translation", interactive=False, show_copy_button=True, lines=2)
-        message_text = gr.Textbox(label="Messages:", placeholder="Display field for status and error messages", interactive=False,
-                                  value=f'Default translation settings: from {s_language.value} to {t_language.value} with {model_name.value}.')
-        allmodels = gr.HTML(label="Model links:", value=', '.join([f'<a href="https://huggingface.co/{model}">{model}</a>' for model in models]))
-        model_info = gr.Markdown(label="Model info:", value=get_info(DEFAULTS[2], DEFAULTS[0], DEFAULTS[1]), show_copy_button=True)
-        model_name.change(fn=get_info, inputs=[model_name, s_language, t_language], outputs=model_info, api_name=False, show_api=False)
-
-        # translate_btn.click(
-        #     fn=translate_text, 
-        #     inputs=[input_text, s_language, t_language, model_name], 
-        #     outputs=[translated_text, message_text]
-        # )
-        input_text.submit(
-        fn=translate_text,
-        inputs=[input_text, s_language, t_language, model_name],
-        outputs=[translated_text, message_text]
-        )
-
-    return interface
-
-interface = create_interface()
-if __name__ == "__main__":
-    interface.launch(mcp_server=True)
-    # interface.queue().launch(server_name="0.0.0.0", show_error=True, server_port=7860, mcp_server=True)