Added support for the seamless-m4t-v2-large T2TT translation model.

app.py

@@ -39,8 +39,9 @@ from src.whisper.abstractWhisperContainer import AbstractWhisperContainer
 from src.whisper.whisperFactory import create_whisper_container
 from src.translation.translationModel import TranslationModel
 from src.translation.translationLangs import (TranslationLang,
-                                              _TO_LANG_CODE_WHISPER, get_lang_whisper_names, get_lang_from_whisper_name, get_lang_from_whisper_code, 
-                                              get_lang_nllb_names, get_lang_from_nllb_name, get_lang_m2m100_names, get_lang_from_m2m100_name, sort_lang_by_whisper_codes)
+                                              _TO_LANG_CODE_WHISPER, sort_lang_by_whisper_codes,
+                                              get_lang_from_whisper_name, get_lang_from_whisper_code, get_lang_from_nllb_name, get_lang_from_m2m100_name, get_lang_from_seamlessTx_name, 
+                                              get_lang_whisper_names, get_lang_nllb_names, get_lang_m2m100_names, get_lang_seamlessTx_names)
 import shutil
 import zhconv
 import tqdm
@@ -235,6 +236,8 @@ class WhisperTranscriber:
             ALMALangName:     str = decodeOptions.pop("ALMALangName")
             madlad400ModelName: str = decodeOptions.pop("madlad400ModelName")
             madlad400LangName:  str = decodeOptions.pop("madlad400LangName")
+            seamlessModelName: str = decodeOptions.pop("seamlessModelName")
+            seamlessLangName:  str = decodeOptions.pop("seamlessLangName")
             
             translationBatchSize:         int  = decodeOptions.pop("translationBatchSize")
             translationNoRepeatNgramSize: int  = decodeOptions.pop("translationNoRepeatNgramSize")
@@ -376,6 +379,11 @@ class WhisperTranscriber:
                     selectedModelName = madlad400ModelName if madlad400ModelName is not None and len(madlad400ModelName) > 0 else "madlad400-3b-mt-ct2-int8_float16/SoybeanMilk"
                     selectedModel = next((modelConfig for modelConfig in self.app_config.models["madlad400"] if modelConfig.name == selectedModelName), None)
                     translationLang = get_lang_from_m2m100_name(madlad400LangName)
+                elif translateInput == "seamless" and seamlessLangName is not None and len(seamlessLangName) > 0:
+                    selectedModelName = seamlessModelName if seamlessModelName is not None and len(seamlessModelName) > 0 else "facebook/seamless-m4t-v2-large"
+                    selectedModel = next((modelConfig for modelConfig in self.app_config.models["seamless"] if modelConfig.name == selectedModelName), None)
+                    translationLang = get_lang_from_seamlessTx_name(seamlessLangName)
+                    
 
                 if translationLang is not None:
                     translationModel = TranslationModel(modelConfig=selectedModel, whisperLang=whisperLang, translationLang=translationLang, batchSize=translationBatchSize, noRepeatNgramSize=translationNoRepeatNgramSize, numBeams=translationNumBeams, torchDtypeFloat16=translationTorchDtypeFloat16, usingBitsandbytes=translationUsingBitsandbytes)
@@ -938,6 +946,7 @@ def create_ui(app_config: ApplicationConfig):
     mt5_models = app_config.get_model_names("mt5")
     ALMA_models = app_config.get_model_names("ALMA")
     madlad400_models = app_config.get_model_names("madlad400")
+    seamless_models = app_config.get_model_names("seamless")
     if not torch.cuda.is_available(): # Loading only quantized or models with medium-low parameters in an environment without GPU support.
         nllb_models = list(filter(lambda nllb: any(name in nllb for name in ["-600M", "-1.3B", "-3.3B-ct2"]), nllb_models))
         m2m100_models = list(filter(lambda m2m100: "12B" not in m2m100, m2m100_models))
@@ -968,6 +977,10 @@ def create_ui(app_config: ApplicationConfig):
         gr.Dropdown(label="madlad400 - Model (for translate)", choices=madlad400_models, elem_id="madlad400ModelName"),
         gr.Dropdown(label="madlad400 - Language", choices=sorted(get_lang_m2m100_names()), elem_id="madlad400LangName"),
     }
+    common_seamless_inputs = lambda : {
+        gr.Dropdown(label="seamless - Model (for translate)", choices=seamless_models, elem_id="seamlessModelName"),
+        gr.Dropdown(label="seamless - Language", choices=sorted(get_lang_seamlessTx_names()), elem_id="seamlessLangName"),
+    }
     
     common_translation_inputs = lambda : {
         gr.Number(label="Translation - Batch Size", precision=0, value=app_config.translation_batch_size, elem_id="translationBatchSize"),
@@ -1054,14 +1067,18 @@ def create_ui(app_config: ApplicationConfig):
                     with gr.Tab(label="ALMA") as simpleALMATab:
                         with gr.Row():
                             simpleInputDict.update(common_ALMA_inputs())
-                    with gr.Tab(label="madlad400") as simplemadlad400Tab:
+                    with gr.Tab(label="madlad400") as simpleMadlad400Tab:
                         with gr.Row():
                             simpleInputDict.update(common_madlad400_inputs())
+                    with gr.Tab(label="seamless") as simpleSeamlessTab:
+                        with gr.Row():
+                            simpleInputDict.update(common_seamless_inputs())
                     simpleM2M100Tab.select(fn=lambda: "m2m100", inputs = [], outputs= [simpleTranslateInput] )
                     simpleNllbTab.select(fn=lambda: "nllb", inputs = [], outputs= [simpleTranslateInput] )
                     simpleMT5Tab.select(fn=lambda: "mt5", inputs = [], outputs= [simpleTranslateInput] )
                     simpleALMATab.select(fn=lambda: "ALMA", inputs = [], outputs= [simpleTranslateInput] )
-                    simplemadlad400Tab.select(fn=lambda: "madlad400", inputs = [], outputs= [simpleTranslateInput] )
+                    simpleMadlad400Tab.select(fn=lambda: "madlad400", inputs = [], outputs= [simpleTranslateInput] )
+                    simpleSeamlessTab.select(fn=lambda: "seamless", inputs = [], outputs= [simpleTranslateInput] )
                 with gr.Column():
                     with gr.Tab(label="URL") as simpleUrlTab:
                         simpleInputDict.update({gr.Text(label="URL (YouTube, etc.)", elem_id = "urlData")})
@@ -1125,14 +1142,18 @@ def create_ui(app_config: ApplicationConfig):
                     with gr.Tab(label="ALMA") as fullALMATab:
                         with gr.Row():
                             fullInputDict.update(common_ALMA_inputs())
-                    with gr.Tab(label="madlad400") as fullmadlad400Tab:
+                    with gr.Tab(label="madlad400") as fullMadlad400Tab:
                         with gr.Row():
                             fullInputDict.update(common_madlad400_inputs())
+                    with gr.Tab(label="seamless") as fullSeamlessTab:
+                        with gr.Row():
+                            fullInputDict.update(common_seamless_inputs())
                     fullM2M100Tab.select(fn=lambda: "m2m100", inputs = [], outputs= [fullTranslateInput] )
                     fullNllbTab.select(fn=lambda: "nllb", inputs = [], outputs= [fullTranslateInput] )
                     fullMT5Tab.select(fn=lambda: "mt5", inputs = [], outputs= [fullTranslateInput] )
                     fullALMATab.select(fn=lambda: "ALMA", inputs = [], outputs= [fullTranslateInput] )
-                    fullmadlad400Tab.select(fn=lambda: "madlad400", inputs = [], outputs= [fullTranslateInput] )
+                    fullMadlad400Tab.select(fn=lambda: "madlad400", inputs = [], outputs= [fullTranslateInput] )
+                    fullSeamlessTab.select(fn=lambda: "seamless", inputs = [], outputs= [fullTranslateInput] )
                 with gr.Column():
                     with gr.Tab(label="URL") as fullUrlTab:
                         fullInputDict.update({gr.Text(label="URL (YouTube, etc.)", elem_id = "urlData")})

config.json5

@@ -269,6 +269,23 @@
         "url": "jbochi/madlad400-10b-mt",
         "type": "huggingface"
       }
+    ],
+    "seamless":  [
+      //{
+      //  "name": "hf-seamless-m4t-medium/facebook",
+      //  "url": "facebook/hf-seamless-m4t-medium",
+      //  "type": "huggingface"
+      //},
+      //{
+      //  "name": "seamless-m4t-large/facebook",
+      //  "url": "facebook/seamless-m4t-large",
+      //  "type": "huggingface"
+      //},
+      {
+        "name": "seamless-m4t-v2-large/facebook",
+        "url": "facebook/seamless-m4t-v2-large",
+        "type": "huggingface"
+      }
     ]
   },
   // Configuration options that will be used if they are not specified in the command line arguments.

docs/translateModel.md

@@ -22,7 +22,7 @@ M2M100 is a multilingual translation model introduced by Facebook AI in October
 |------|------------|------|---------------|---------------|
 | [facebook/m2m100_418M](https://huggingface.co/facebook/m2m100_418M) | 418M | 1.94 GB | float32 | ≈2 GB |
 | [facebook/m2m100_1.2B](https://huggingface.co/facebook/m2m100_1.2B) | 1.2B | 4.96 GB | float32 | ≈5 GB |
-| [facebook/m2m100-12B-last-ckpt](https://huggingface.co/facebook/m2m100-12B-last-ckpt) | 12B | 47.2 GB | float32 | 22.1 GB (torch dtype in float16) |
+| [facebook/m2m100-12B-last-ckpt](https://huggingface.co/facebook/m2m100-12B-last-ckpt) | 12B | 47.2 GB | float32 | ≈22.1 GB (torch dtype in float16) |
 
 ## M2M100-CTranslate2
 
@@ -143,14 +143,14 @@ Text-to-speech translation (T2ST)
 Text-to-text translation (T2TT)  
 Automatic speech recognition (ASR)  
 
-SeamlessM4T-v1 introduced by Seamless Communication team from Meta AI in Aug 2023. The paper is titled "`SeamlessM4T: Massively Multilingual & Multimodal Machine Translation`"([arXiv:2308.11596](https://arxiv.org/abs/2308.11596))  
-SeamlessM4T-v2 introduced by Seamless Communication team from Meta AI in Dec 2023. The paper is titled "`Seamless: Multilingual Expressive and Streaming Speech Translation`"([arXiv:2312.05187](https://arxiv.org/abs/2312.05187))  
+[SeamlessM4T-v1](https://huggingface.co/docs/transformers/main/en/model_doc/seamless_m4t) introduced by Seamless Communication team from Meta AI in Aug 2023. The paper is titled "`SeamlessM4T: Massively Multilingual & Multimodal Machine Translation`"([arXiv:2308.11596](https://arxiv.org/abs/2308.11596))  
+[SeamlessM4T-v2](https://huggingface.co/docs/transformers/main/en/model_doc/seamless_m4t_v2) introduced by Seamless Communication team from Meta AI in Dec 2023. The paper is titled "`Seamless: Multilingual Expressive and Streaming Speech Translation`"([arXiv:2312.05187](https://arxiv.org/abs/2312.05187))  
 
 | Name | Parameters | Size | type/quantize | Required VRAM |
 |------|------------|------|---------------|---------------|
 | [facebook/hf-seamless-m4t-medium](https://huggingface.co/facebook/hf-seamless-m4t-medium) | 1.2B | 4.84 GB | float32 | N/A |
 | [facebook/seamless-m4t-large](https://huggingface.co/facebook/seamless-m4t-large) | 2.3B | 11.4 GB | float32 | N/A |
-| [facebook/seamless-m4t-v2-large](https://huggingface.co/facebook/seamless-m4t-v2-large) | 2.3B | 11.4 GB (safetensors:9.24 GB) | float32 | N/A |
+| [facebook/seamless-m4t-v2-large](https://huggingface.co/facebook/seamless-m4t-v2-large) | 2.3B | 11.4 GB (safetensors:9.24 GB) | float32 | ≈9.2 GB |
 
 
 # Options

src/config.py

@@ -50,7 +50,7 @@ class VadInitialPromptMode(Enum):
             return None
 
 class ApplicationConfig:
-    def __init__(self, models: Dict[Literal["whisper", "m2m100", "nllb", "mt5", "ALMA", "madlad400"], List[ModelConfig]],
+    def __init__(self, models: Dict[Literal["whisper", "m2m100", "nllb", "mt5", "ALMA", "madlad400", "seamless"], List[ModelConfig]],
                  input_audio_max_duration: int = 600, share: bool = False, server_name: str = None, server_port: int = 7860, 
                  queue_concurrency_count: int = 1, delete_uploaded_files: bool = True,
                  whisper_implementation: str = "whisper", default_model_name: str = "medium", 
@@ -185,7 +185,7 @@ class ApplicationConfig:
             # Load using json5
             data = json5.load(f)
             data_models = data.pop("models", [])
-            models: Dict[Literal["whisper", "m2m100", "nllb", "mt5", "ALMA", "madlad400"], List[ModelConfig]] = {
+            models: Dict[Literal["whisper", "m2m100", "nllb", "mt5", "ALMA", "madlad400", "seamless"], List[ModelConfig]] = {
                 key: [ModelConfig(**item) for item in value]
                 for key, value in data_models.items()
             }

src/translation/translationLangs.py

@@ -9,23 +9,36 @@ class Lang():
         return f"code:{self.code}, name:{self.names}"
 
 class TranslationLang():
-    def __init__(self, nllb: Lang, whisper: Lang = None, m2m100: Lang = None):
-        self.nllb    = nllb
-        self.whisper = whisper
+    def __init__(self, code: str, name: str):
+        self.nllb = Lang(code, name)
+        self.whisper = None
         self.m2m100  = None
+        self.seamlessTx = None
         
-        if m2m100 is None: m2m100 = whisper
-        if m2m100 is not None and len(m2m100.names) > 0:
-            self.m2m100  = m2m100
+    def Whisper(self, code: str, *names: str):
+        self.whisper = Lang(code, *names)
+        if self.m2m100 is None:
+            self.m2m100 = self.whisper
+        return self
+    
+    def M2M100(self, code: str, name: str):
+        self.m2m100 = Lang(code, name)
+        return self
+    
+    def SeamlessTx(self, code: str, name: str):
+        self.seamlessTx = Lang(code, name)
+        return self
 
     def __repr__(self):
         result = ""
-        if self.nllb is not None:
+        if self.nllb:
             result += f"NLLB={self.nllb} "
-        if self.whisper is not None:
+        if self.whisper:
             result += f"WHISPER={self.whisper} "
-        if self.m2m100 is not None:
-            result += f"M@M100={self.m2m100} "
+        if self.m2m100:
+            result += f"M2M100={self.m2m100} "
+        if self.seamlessTx:
+            result += f"SeamlessTx={self.seamlessTx} "
         return f"Language {result}"
     
 """
@@ -49,211 +62,211 @@ https://huggingface.co/facebook/m2m100_1.2B
 The available languages for m2m100 and whisper are almost identical. Most of the codes correspond to the ISO 639-1 standard. For detailed information, please refer to the official documentation provided.
 """
 TranslationLangs = [
-    TranslationLang(Lang("ace_Arab", "Acehnese (Arabic script)")),
-    TranslationLang(Lang("ace_Latn", "Acehnese (Latin script)")),
-    TranslationLang(Lang("acm_Arab", "Mesopotamian Arabic"), Lang("ar", "Arabic")),
-    TranslationLang(Lang("acq_Arab", "Ta’izzi-Adeni Arabic"), Lang("ar", "Arabic")),
-    TranslationLang(Lang("aeb_Arab", "Tunisian Arabic")),
-    TranslationLang(Lang("afr_Latn", "Afrikaans"), Lang("af", "Afrikaans")),
-    TranslationLang(Lang("ajp_Arab", "South Levantine Arabic"), Lang("ar", "Arabic")),
-    TranslationLang(Lang("aka_Latn", "Akan")),
-    TranslationLang(Lang("amh_Ethi", "Amharic"), Lang("am", "Amharic")),
-    TranslationLang(Lang("apc_Arab", "North Levantine Arabic"), Lang("ar", "Arabic")),
-    TranslationLang(Lang("arb_Arab", "Modern Standard Arabic"), Lang("ar", "Arabic")),
-    TranslationLang(Lang("arb_Latn", "Modern Standard Arabic (Romanized)")),
-    TranslationLang(Lang("ars_Arab", "Najdi Arabic"), Lang("ar", "Arabic")),
-    TranslationLang(Lang("ary_Arab", "Moroccan Arabic"), Lang("ar", "Arabic")),
-    TranslationLang(Lang("arz_Arab", "Egyptian Arabic"), Lang("ar", "Arabic")),
-    TranslationLang(Lang("asm_Beng", "Assamese"), Lang("as", "Assamese")),
-    TranslationLang(Lang("ast_Latn", "Asturian"), None, Lang("ast", "Asturian")),
-    TranslationLang(Lang("awa_Deva", "Awadhi")),
-    TranslationLang(Lang("ayr_Latn", "Central Aymara")),
-    TranslationLang(Lang("azb_Arab", "South Azerbaijani"), Lang("az", "Azerbaijani")),
-    TranslationLang(Lang("azj_Latn", "North Azerbaijani"), Lang("az", "Azerbaijani")),
-    TranslationLang(Lang("bak_Cyrl", "Bashkir"), Lang("ba", "Bashkir")),
-    TranslationLang(Lang("bam_Latn", "Bambara")),
-    TranslationLang(Lang("ban_Latn", "Balinese")),
-    TranslationLang(Lang("bel_Cyrl", "Belarusian"), Lang("be", "Belarusian")),
-    TranslationLang(Lang("bem_Latn", "Bemba")),
-    TranslationLang(Lang("ben_Beng", "Bengali"), Lang("bn", "Bengali")),
-    TranslationLang(Lang("bho_Deva", "Bhojpuri")),
-    TranslationLang(Lang("bjn_Arab", "Banjar (Arabic script)")),
-    TranslationLang(Lang("bjn_Latn", "Banjar (Latin script)")),
-    TranslationLang(Lang("bod_Tibt", "Standard Tibetan"), Lang("bo", "Tibetan")),
-    TranslationLang(Lang("bos_Latn", "Bosnian"), Lang("bs", "Bosnian")),
-    TranslationLang(Lang("bug_Latn", "Buginese")),
-    TranslationLang(Lang("bul_Cyrl", "Bulgarian"), Lang("bg", "Bulgarian")),
-    TranslationLang(Lang("cat_Latn", "Catalan"), Lang("ca", "Catalan", "valencian")),
-    TranslationLang(Lang("ceb_Latn", "Cebuano"), None, Lang("ceb", "Cebuano")),
-    TranslationLang(Lang("ces_Latn", "Czech"), Lang("cs", "Czech")),
-    TranslationLang(Lang("cjk_Latn", "Chokwe")),
-    TranslationLang(Lang("ckb_Arab", "Central Kurdish")),
-    TranslationLang(Lang("crh_Latn", "Crimean Tatar")),
-    TranslationLang(Lang("cym_Latn", "Welsh"), Lang("cy", "Welsh")),
-    TranslationLang(Lang("dan_Latn", "Danish"), Lang("da", "Danish")),
-    TranslationLang(Lang("deu_Latn", "German"), Lang("de", "German")),
-    TranslationLang(Lang("dik_Latn", "Southwestern Dinka")),
-    TranslationLang(Lang("dyu_Latn", "Dyula")),
-    TranslationLang(Lang("dzo_Tibt", "Dzongkha")),
-    TranslationLang(Lang("ell_Grek", "Greek"), Lang("el", "Greek")),
-    TranslationLang(Lang("eng_Latn", "English"), Lang("en", "English")),
-    TranslationLang(Lang("epo_Latn", "Esperanto")),
-    TranslationLang(Lang("est_Latn", "Estonian"), Lang("et", "Estonian")),
-    TranslationLang(Lang("eus_Latn", "Basque"), Lang("eu", "Basque")),
-    TranslationLang(Lang("ewe_Latn", "Ewe")),
-    TranslationLang(Lang("fao_Latn", "Faroese"), Lang("fo", "Faroese")),
-    TranslationLang(Lang("fij_Latn", "Fijian")),
-    TranslationLang(Lang("fin_Latn", "Finnish"), Lang("fi", "Finnish")),
-    TranslationLang(Lang("fon_Latn", "Fon")),
-    TranslationLang(Lang("fra_Latn", "French"), Lang("fr", "French")),
-    TranslationLang(Lang("fur_Latn", "Friulian")),
-    TranslationLang(Lang("fuv_Latn", "Nigerian Fulfulde"), None, Lang("ff", "Fulah")),
-    TranslationLang(Lang("gla_Latn", "Scottish Gaelic"), None, Lang("gd", "Scottish Gaelic")),
-    TranslationLang(Lang("gle_Latn", "Irish"), None, Lang("ga", "Irish")),
-    TranslationLang(Lang("glg_Latn", "Galician"), Lang("gl", "Galician")),
-    TranslationLang(Lang("grn_Latn", "Guarani")),
-    TranslationLang(Lang("guj_Gujr", "Gujarati"), Lang("gu", "Gujarati")),
-    TranslationLang(Lang("hat_Latn", "Haitian Creole"), Lang("ht", "Haitian creole", "haitian")),
-    TranslationLang(Lang("hau_Latn", "Hausa"), Lang("ha", "Hausa")),
-    TranslationLang(Lang("heb_Hebr", "Hebrew"), Lang("he", "Hebrew")),
-    TranslationLang(Lang("hin_Deva", "Hindi"), Lang("hi", "Hindi")),
-    TranslationLang(Lang("hne_Deva", "Chhattisgarhi")),
-    TranslationLang(Lang("hrv_Latn", "Croatian"), Lang("hr", "Croatian")),
-    TranslationLang(Lang("hun_Latn", "Hungarian"), Lang("hu", "Hungarian")),
-    TranslationLang(Lang("hye_Armn", "Armenian"), Lang("hy", "Armenian")),
-    TranslationLang(Lang("ibo_Latn", "Igbo"), None, Lang("ig", "Igbo")),
-    TranslationLang(Lang("ilo_Latn", "Ilocano"), None, Lang("ilo", "Iloko")),
-    TranslationLang(Lang("ind_Latn", "Indonesian"), Lang("id", "Indonesian")),
-    TranslationLang(Lang("isl_Latn", "Icelandic"), Lang("is", "Icelandic")),
-    TranslationLang(Lang("ita_Latn", "Italian"), Lang("it", "Italian")),
-    TranslationLang(Lang("jav_Latn", "Javanese"), Lang("jw", "Javanese"), Lang("jv", "Javanese")),
-    TranslationLang(Lang("jpn_Jpan", "Japanese"), Lang("ja", "Japanese")),
-    TranslationLang(Lang("kab_Latn", "Kabyle")),
-    TranslationLang(Lang("kac_Latn", "Jingpho")),
-    TranslationLang(Lang("kam_Latn", "Kamba")),
-    TranslationLang(Lang("kan_Knda", "Kannada"), Lang("kn", "Kannada")),
-    TranslationLang(Lang("kas_Arab", "Kashmiri (Arabic script)")),
-    TranslationLang(Lang("kas_Deva", "Kashmiri (Devanagari script)")),
-    TranslationLang(Lang("kat_Geor", "Georgian"), Lang("ka", "Georgian")),
-    TranslationLang(Lang("knc_Arab", "Central Kanuri (Arabic script)")),
-    TranslationLang(Lang("knc_Latn", "Central Kanuri (Latin script)")),
-    TranslationLang(Lang("kaz_Cyrl", "Kazakh"), Lang("kk", "Kazakh")),
-    TranslationLang(Lang("kbp_Latn", "Kabiyè")),
-    TranslationLang(Lang("kea_Latn", "Kabuverdianu")),
-    TranslationLang(Lang("khm_Khmr", "Khmer"), Lang("km", "Khmer")),
-    TranslationLang(Lang("kik_Latn", "Kikuyu")),
-    TranslationLang(Lang("kin_Latn", "Kinyarwanda")),
-    TranslationLang(Lang("kir_Cyrl", "Kyrgyz")),
-    TranslationLang(Lang("kmb_Latn", "Kimbundu")),
-    TranslationLang(Lang("kmr_Latn", "Northern Kurdish")),
-    TranslationLang(Lang("kon_Latn", "Kikongo")),
-    TranslationLang(Lang("kor_Hang", "Korean"), Lang("ko", "Korean")),
-    TranslationLang(Lang("lao_Laoo", "Lao"), Lang("lo", "Lao")),
-    TranslationLang(Lang("lij_Latn", "Ligurian")),
-    TranslationLang(Lang("lim_Latn", "Limburgish")),
-    TranslationLang(Lang("lin_Latn", "Lingala"), Lang("ln", "Lingala")),
-    TranslationLang(Lang("lit_Latn", "Lithuanian"), Lang("lt", "Lithuanian")),
-    TranslationLang(Lang("lmo_Latn", "Lombard")),
-    TranslationLang(Lang("ltg_Latn", "Latgalian")),
-    TranslationLang(Lang("ltz_Latn", "Luxembourgish"), Lang("lb", "Luxembourgish", "letzeburgesch")),
-    TranslationLang(Lang("lua_Latn", "Luba-Kasai")),
-    TranslationLang(Lang("lug_Latn", "Ganda"), None, Lang("lg", "Ganda")),
-    TranslationLang(Lang("luo_Latn", "Luo")),
-    TranslationLang(Lang("lus_Latn", "Mizo")),
-    TranslationLang(Lang("lvs_Latn", "Standard Latvian"), Lang("lv", "Latvian")),
-    TranslationLang(Lang("mag_Deva", "Magahi")),
-    TranslationLang(Lang("mai_Deva", "Maithili")),
-    TranslationLang(Lang("mal_Mlym", "Malayalam"), Lang("ml", "Malayalam")),
-    TranslationLang(Lang("mar_Deva", "Marathi"), Lang("mr", "Marathi")),
-    TranslationLang(Lang("min_Arab", "Minangkabau (Arabic script)")),
-    TranslationLang(Lang("min_Latn", "Minangkabau (Latin script)")),
-    TranslationLang(Lang("mkd_Cyrl", "Macedonian"), Lang("mk", "Macedonian")),
-    TranslationLang(Lang("plt_Latn", "Plateau Malagasy"), Lang("mg", "Malagasy")),
-    TranslationLang(Lang("mlt_Latn", "Maltese"), Lang("mt", "Maltese")),
-    TranslationLang(Lang("mni_Beng", "Meitei (Bengali script)")),
-    TranslationLang(Lang("khk_Cyrl", "Halh Mongolian"), Lang("mn", "Mongolian")),
-    TranslationLang(Lang("mos_Latn", "Mossi")),
-    TranslationLang(Lang("mri_Latn", "Maori"), Lang("mi", "Maori")),
-    TranslationLang(Lang("mya_Mymr", "Burmese"), Lang("my", "Myanmar", "burmese")),
-    TranslationLang(Lang("nld_Latn", "Dutch"), Lang("nl", "Dutch", "flemish")),
-    TranslationLang(Lang("nno_Latn", "Norwegian Nynorsk"), Lang("nn", "Nynorsk")),
-    TranslationLang(Lang("nob_Latn", "Norwegian Bokmål"), Lang("no", "Norwegian")),
-    TranslationLang(Lang("npi_Deva", "Nepali"), Lang("ne", "Nepali")),
-    TranslationLang(Lang("nso_Latn", "Northern Sotho"), None, Lang("ns", "Northern Sotho")),
-    TranslationLang(Lang("nus_Latn", "Nuer")),
-    TranslationLang(Lang("nya_Latn", "Nyanja")),
-    TranslationLang(Lang("oci_Latn", "Occitan"), Lang("oc", "Occitan")),
-    TranslationLang(Lang("gaz_Latn", "West Central Oromo")),
-    TranslationLang(Lang("ory_Orya", "Odia"), None, Lang("or", "Oriya")),
-    TranslationLang(Lang("pag_Latn", "Pangasinan")),
-    TranslationLang(Lang("pan_Guru", "Eastern Panjabi"), Lang("pa", "Punjabi", "panjabi")),
-    TranslationLang(Lang("pap_Latn", "Papiamento")),
-    TranslationLang(Lang("pes_Arab", "Western Persian"), Lang("fa", "Persian")),
-    TranslationLang(Lang("pol_Latn", "Polish"), Lang("pl", "Polish")),
-    TranslationLang(Lang("por_Latn", "Portuguese"), Lang("pt", "Portuguese")),
-    TranslationLang(Lang("prs_Arab", "Dari")),
-    TranslationLang(Lang("pbt_Arab", "Southern Pashto"), Lang("ps", "Pashto", "pushto")),
-    TranslationLang(Lang("quy_Latn", "Ayacucho Quechua")),
-    TranslationLang(Lang("ron_Latn", "Romanian"), Lang("ro", "Romanian", "moldavian", "moldovan")),
-    TranslationLang(Lang("run_Latn", "Rundi")),
-    TranslationLang(Lang("rus_Cyrl", "Russian"), Lang("ru", "Russian")),
-    TranslationLang(Lang("sag_Latn", "Sango")),
-    TranslationLang(Lang("san_Deva", "Sanskrit"), Lang("sa", "Sanskrit")),
-    TranslationLang(Lang("sat_Olck", "Santali")),
-    TranslationLang(Lang("scn_Latn", "Sicilian")),
-    TranslationLang(Lang("shn_Mymr", "Shan")),
-    TranslationLang(Lang("sin_Sinh", "Sinhala"), Lang("si", "Sinhala", "sinhalese")),
-    TranslationLang(Lang("slk_Latn", "Slovak"), Lang("sk", "Slovak")),
-    TranslationLang(Lang("slv_Latn", "Slovenian"), Lang("sl", "Slovenian")),
-    TranslationLang(Lang("smo_Latn", "Samoan")),
-    TranslationLang(Lang("sna_Latn", "Shona"), Lang("sn", "Shona")),
-    TranslationLang(Lang("snd_Arab", "Sindhi"), Lang("sd", "Sindhi")),
-    TranslationLang(Lang("som_Latn", "Somali"), Lang("so", "Somali")),
-    TranslationLang(Lang("sot_Latn", "Southern Sotho")),
-    TranslationLang(Lang("spa_Latn", "Spanish"), Lang("es", "Spanish", "castilian")),
-    TranslationLang(Lang("als_Latn", "Tosk Albanian"), Lang("sq", "Albanian")),
-    TranslationLang(Lang("srd_Latn", "Sardinian")),
-    TranslationLang(Lang("srp_Cyrl", "Serbian"), Lang("sr", "Serbian")),
-    TranslationLang(Lang("ssw_Latn", "Swati"), None, Lang("ss", "Swati")),
-    TranslationLang(Lang("sun_Latn", "Sundanese"), Lang("su", "Sundanese")),
-    TranslationLang(Lang("swe_Latn", "Swedish"), Lang("sv", "Swedish")),
-    TranslationLang(Lang("swh_Latn", "Swahili"), Lang("sw", "Swahili")),
-    TranslationLang(Lang("szl_Latn", "Silesian")),
-    TranslationLang(Lang("tam_Taml", "Tamil"), Lang("ta", "Tamil")),
-    TranslationLang(Lang("tat_Cyrl", "Tatar"), Lang("tt", "Tatar")),
-    TranslationLang(Lang("tel_Telu", "Telugu"), Lang("te", "Telugu")),
-    TranslationLang(Lang("tgk_Cyrl", "Tajik"), Lang("tg", "Tajik")),
-    TranslationLang(Lang("tgl_Latn", "Tagalog"), Lang("tl", "Tagalog")),
-    TranslationLang(Lang("tha_Thai", "Thai"), Lang("th", "Thai")),
-    TranslationLang(Lang("tir_Ethi", "Tigrinya")),
-    TranslationLang(Lang("taq_Latn", "Tamasheq (Latin script)")),
-    TranslationLang(Lang("taq_Tfng", "Tamasheq (Tifinagh script)")),
-    TranslationLang(Lang("tpi_Latn", "Tok Pisin")),
-    TranslationLang(Lang("tsn_Latn", "Tswana"), None, Lang("tn", "Tswana")),
-    TranslationLang(Lang("tso_Latn", "Tsonga")),
-    TranslationLang(Lang("tuk_Latn", "Turkmen"), Lang("tk", "Turkmen")),
-    TranslationLang(Lang("tum_Latn", "Tumbuka")),
-    TranslationLang(Lang("tur_Latn", "Turkish"), Lang("tr", "Turkish")),
-    TranslationLang(Lang("twi_Latn", "Twi")),
-    TranslationLang(Lang("tzm_Tfng", "Central Atlas Tamazight")),
-    TranslationLang(Lang("uig_Arab", "Uyghur")),
-    TranslationLang(Lang("ukr_Cyrl", "Ukrainian"), Lang("uk", "Ukrainian")),
-    TranslationLang(Lang("umb_Latn", "Umbundu")),
-    TranslationLang(Lang("urd_Arab", "Urdu"), Lang("ur", "Urdu")),
-    TranslationLang(Lang("uzn_Latn", "Northern Uzbek"), Lang("uz", "Uzbek")),
-    TranslationLang(Lang("vec_Latn", "Venetian")),
-    TranslationLang(Lang("vie_Latn", "Vietnamese"), Lang("vi", "Vietnamese")),
-    TranslationLang(Lang("war_Latn", "Waray")),
-    TranslationLang(Lang("wol_Latn", "Wolof"), None, Lang("wo", "Wolof")),
-    TranslationLang(Lang("xho_Latn", "Xhosa"), None, Lang("xh", "Xhosa")),
-    TranslationLang(Lang("ydd_Hebr", "Eastern Yiddish"), Lang("yi", "Yiddish")),
-    TranslationLang(Lang("yor_Latn", "Yoruba"), Lang("yo", "Yoruba")),
-    TranslationLang(Lang("yue_Hant", "Yue Chinese"), Lang("yue", "cantonese"), Lang("zh", "Chinese (zh-yue)")),
-    TranslationLang(Lang("zho_Hans", "Chinese (Simplified)"), Lang("zh", "Chinese (Simplified)", "Chinese", "mandarin")),
-    TranslationLang(Lang("zho_Hant", "Chinese (Traditional)"), Lang("zh", "Chinese (Traditional)")),
-    TranslationLang(Lang("zsm_Latn", "Standard Malay"), Lang("ms", "Malay")),
-    TranslationLang(Lang("zul_Latn", "Zulu"), None, Lang("zu", "Zulu")),
-    TranslationLang(None, Lang("br", "Breton")), # Both whisper and m2m100 support the Breton language, but nllb does not have this language.
+    TranslationLang("ace_Arab", "Acehnese (Arabic script)"),
+    TranslationLang("ace_Latn", "Acehnese (Latin script)"),
+    TranslationLang("acm_Arab", "Mesopotamian Arabic").Whisper("ar", "Arabic"),
+    TranslationLang("acq_Arab", "Ta’izzi-Adeni Arabic").Whisper("ar", "Arabic"),
+    TranslationLang("aeb_Arab", "Tunisian Arabic"),
+    TranslationLang("afr_Latn", "Afrikaans").Whisper("af", "Afrikaans").SeamlessTx("afr", "Afrikaans"),
+    TranslationLang("ajp_Arab", "South Levantine Arabic").Whisper("ar", "Arabic"),
+    TranslationLang("aka_Latn", "Akan"),
+    TranslationLang("amh_Ethi", "Amharic").Whisper("am", "Amharic").SeamlessTx("amh", "Amharic"),
+    TranslationLang("apc_Arab", "North Levantine Arabic").Whisper("ar", "Arabic"),
+    TranslationLang("arb_Arab", "Modern Standard Arabic").Whisper("ar", "Arabic").SeamlessTx("arb", "Modern Standard Arabic"),
+    TranslationLang("arb_Latn", "Modern Standard Arabic (Romanized)"),
+    TranslationLang("ars_Arab", "Najdi Arabic").Whisper("ar", "Arabic"),
+    TranslationLang("ary_Arab", "Moroccan Arabic").Whisper("ar", "Arabic").SeamlessTx("ary", "Moroccan Arabic"),
+    TranslationLang("arz_Arab", "Egyptian Arabic").Whisper("ar", "Arabic").SeamlessTx("arz", "Egyptian Arabic"),
+    TranslationLang("asm_Beng", "Assamese").Whisper("as", "Assamese").SeamlessTx("asm", "Assamese"),
+    TranslationLang("ast_Latn", "Asturian").M2M100("ast", "Asturian"),
+    TranslationLang("awa_Deva", "Awadhi"),
+    TranslationLang("ayr_Latn", "Central Aymara"),
+    TranslationLang("azb_Arab", "South Azerbaijani").Whisper("az", "Azerbaijani"),
+    TranslationLang("azj_Latn", "North Azerbaijani").Whisper("az", "Azerbaijani").SeamlessTx("azj", "North Azerbaijani"),
+    TranslationLang("bak_Cyrl", "Bashkir").Whisper("ba", "Bashkir"),
+    TranslationLang("bam_Latn", "Bambara"),
+    TranslationLang("ban_Latn", "Balinese"),
+    TranslationLang("bel_Cyrl", "Belarusian").Whisper("be", "Belarusian").SeamlessTx("bel", "Belarusian"),
+    TranslationLang("bem_Latn", "Bemba"),
+    TranslationLang("ben_Beng", "Bengali").Whisper("bn", "Bengali").SeamlessTx("ben", "Bengali"),
+    TranslationLang("bho_Deva", "Bhojpuri"),
+    TranslationLang("bjn_Arab", "Banjar (Arabic script)"),
+    TranslationLang("bjn_Latn", "Banjar (Latin script)"),
+    TranslationLang("bod_Tibt", "Standard Tibetan").Whisper("bo", "Tibetan"),
+    TranslationLang("bos_Latn", "Bosnian").Whisper("bs", "Bosnian").SeamlessTx("bos", "Bosnian"),
+    TranslationLang("bug_Latn", "Buginese"),
+    TranslationLang("bul_Cyrl", "Bulgarian").Whisper("bg", "Bulgarian").SeamlessTx("bul", "Bulgarian"),
+    TranslationLang("cat_Latn", "Catalan").Whisper("ca", "Catalan", "valencian").SeamlessTx("cat", "Catalan"),
+    TranslationLang("ceb_Latn", "Cebuano").M2M100("ceb", "Cebuano").SeamlessTx("ceb", "Cebuano"),
+    TranslationLang("ces_Latn", "Czech").Whisper("cs", "Czech").SeamlessTx("ces", "Czech"),
+    TranslationLang("cjk_Latn", "Chokwe"),
+    TranslationLang("ckb_Arab", "Central Kurdish").SeamlessTx("ckb", "Central Kurdish"),
+    TranslationLang("crh_Latn", "Crimean Tatar"),
+    TranslationLang("cym_Latn", "Welsh").Whisper("cy", "Welsh").SeamlessTx("cym", "Welsh"),
+    TranslationLang("dan_Latn", "Danish").Whisper("da", "Danish").SeamlessTx("dan", "Danish"),
+    TranslationLang("deu_Latn", "German").Whisper("de", "German").SeamlessTx("deu", "German"),
+    TranslationLang("dik_Latn", "Southwestern Dinka"),
+    TranslationLang("dyu_Latn", "Dyula"),
+    TranslationLang("dzo_Tibt", "Dzongkha"),
+    TranslationLang("ell_Grek", "Greek").Whisper("el", "Greek").SeamlessTx("ell", "Greek"),
+    TranslationLang("eng_Latn", "English").Whisper("en", "English").SeamlessTx("eng", "English"),
+    TranslationLang("epo_Latn", "Esperanto"),
+    TranslationLang("est_Latn", "Estonian").Whisper("et", "Estonian").SeamlessTx("est", "Estonian"),
+    TranslationLang("eus_Latn", "Basque").Whisper("eu", "Basque").SeamlessTx("eus", "Basque"),
+    TranslationLang("ewe_Latn", "Ewe"),
+    TranslationLang("fao_Latn", "Faroese").Whisper("fo", "Faroese"),
+    TranslationLang("fij_Latn", "Fijian"),
+    TranslationLang("fin_Latn", "Finnish").Whisper("fi", "Finnish").SeamlessTx("fin", "Finnish"),
+    TranslationLang("fon_Latn", "Fon"),
+    TranslationLang("fra_Latn", "French").Whisper("fr", "French").SeamlessTx("fra", "French"),
+    TranslationLang("fur_Latn", "Friulian"),
+    TranslationLang("fuv_Latn", "Nigerian Fulfulde").M2M100("ff", "Fulah").SeamlessTx("fuv", "Nigerian Fulfulde"),
+    TranslationLang("gla_Latn", "Scottish Gaelic").M2M100("gd", "Scottish Gaelic"),
+    TranslationLang("gle_Latn", "Irish").M2M100("ga", "Irish").SeamlessTx("gle", "Irish"),
+    TranslationLang("glg_Latn", "Galician").Whisper("gl", "Galician").SeamlessTx("glg", "Galician"),
+    TranslationLang("grn_Latn", "Guarani"),
+    TranslationLang("guj_Gujr", "Gujarati").Whisper("gu", "Gujarati").SeamlessTx("guj", "Gujarati"),
+    TranslationLang("hat_Latn", "Haitian Creole").Whisper("ht", "Haitian creole", "haitian"),
+    TranslationLang("hau_Latn", "Hausa").Whisper("ha", "Hausa"),
+    TranslationLang("heb_Hebr", "Hebrew").Whisper("he", "Hebrew").SeamlessTx("heb", "Hebrew"),
+    TranslationLang("hin_Deva", "Hindi").Whisper("hi", "Hindi").SeamlessTx("hin", "Hindi"),
+    TranslationLang("hne_Deva", "Chhattisgarhi"),
+    TranslationLang("hrv_Latn", "Croatian").Whisper("hr", "Croatian").SeamlessTx("hrv", "Croatian"),
+    TranslationLang("hun_Latn", "Hungarian").Whisper("hu", "Hungarian").SeamlessTx("hun", "Hungarian"),
+    TranslationLang("hye_Armn", "Armenian").Whisper("hy", "Armenian").SeamlessTx("hye", "Armenian"),
+    TranslationLang("ibo_Latn", "Igbo").M2M100("ig", "Igbo").SeamlessTx("ibo", "Igbo"),
+    TranslationLang("ilo_Latn", "Ilocano").M2M100("ilo", "Iloko"),
+    TranslationLang("ind_Latn", "Indonesian").Whisper("id", "Indonesian").SeamlessTx("ind", "Indonesian"),
+    TranslationLang("isl_Latn", "Icelandic").Whisper("is", "Icelandic").SeamlessTx("isl", "Icelandic"),
+    TranslationLang("ita_Latn", "Italian").Whisper("it", "Italian").SeamlessTx("ita", "Italian"),
+    TranslationLang("jav_Latn", "Javanese").Whisper("jw", "Javanese").M2M100("jv", "Javanese").SeamlessTx("jav", "Javanese"),
+    TranslationLang("jpn_Jpan", "Japanese").Whisper("ja", "Japanese").SeamlessTx("jpn", "Japanese"),
+    TranslationLang("kab_Latn", "Kabyle"),
+    TranslationLang("kac_Latn", "Jingpho"),
+    TranslationLang("kam_Latn", "Kamba"),
+    TranslationLang("kan_Knda", "Kannada").Whisper("kn", "Kannada").SeamlessTx("kan", "Kannada"),
+    TranslationLang("kas_Arab", "Kashmiri (Arabic script)"),
+    TranslationLang("kas_Deva", "Kashmiri (Devanagari script)"),
+    TranslationLang("kat_Geor", "Georgian").Whisper("ka", "Georgian").SeamlessTx("kat", "Georgian"),
+    TranslationLang("knc_Arab", "Central Kanuri (Arabic script)"),
+    TranslationLang("knc_Latn", "Central Kanuri (Latin script)"),
+    TranslationLang("kaz_Cyrl", "Kazakh").Whisper("kk", "Kazakh").SeamlessTx("kaz", "Kazakh"),
+    TranslationLang("kbp_Latn", "Kabiyè"),
+    TranslationLang("kea_Latn", "Kabuverdianu"),
+    TranslationLang("khm_Khmr", "Khmer").Whisper("km", "Khmer").SeamlessTx("khm", "Khmer"),
+    TranslationLang("kik_Latn", "Kikuyu"),
+    TranslationLang("kin_Latn", "Kinyarwanda"),
+    TranslationLang("kir_Cyrl", "Kyrgyz").SeamlessTx("kir", "Kyrgyz"),
+    TranslationLang("kmb_Latn", "Kimbundu"),
+    TranslationLang("kmr_Latn", "Northern Kurdish"),
+    TranslationLang("kon_Latn", "Kikongo"),
+    TranslationLang("kor_Hang", "Korean").Whisper("ko", "Korean").SeamlessTx("kor", "Korean"),
+    TranslationLang("lao_Laoo", "Lao").Whisper("lo", "Lao").SeamlessTx("lao", "Lao"),
+    TranslationLang("lij_Latn", "Ligurian"),
+    TranslationLang("lim_Latn", "Limburgish"),
+    TranslationLang("lin_Latn", "Lingala").Whisper("ln", "Lingala"),
+    TranslationLang("lit_Latn", "Lithuanian").Whisper("lt", "Lithuanian").SeamlessTx("lit", "Lithuanian"),
+    TranslationLang("lmo_Latn", "Lombard"),
+    TranslationLang("ltg_Latn", "Latgalian"),
+    TranslationLang("ltz_Latn", "Luxembourgish").Whisper("lb", "Luxembourgish", "letzeburgesch"),
+    TranslationLang("lua_Latn", "Luba-Kasai"),
+    TranslationLang("lug_Latn", "Ganda").M2M100("lg", "Ganda").SeamlessTx("lug", "Ganda"),
+    TranslationLang("luo_Latn", "Luo").SeamlessTx("luo", "Luo"),
+    TranslationLang("lus_Latn", "Mizo"),
+    TranslationLang("lvs_Latn", "Standard Latvian").Whisper("lv", "Latvian").SeamlessTx("lvs", "Standard Latvian"),
+    TranslationLang("mag_Deva", "Magahi"),
+    TranslationLang("mai_Deva", "Maithili").SeamlessTx("mai", "Maithili"),
+    TranslationLang("mal_Mlym", "Malayalam").Whisper("ml", "Malayalam").SeamlessTx("mal", "Malayalam"),
+    TranslationLang("mar_Deva", "Marathi").Whisper("mr", "Marathi").SeamlessTx("mar", "Marathi"),
+    TranslationLang("min_Arab", "Minangkabau (Arabic script)"),
+    TranslationLang("min_Latn", "Minangkabau (Latin script)"),
+    TranslationLang("mkd_Cyrl", "Macedonian").Whisper("mk", "Macedonian").SeamlessTx("mkd", "Macedonian"),
+    TranslationLang("plt_Latn", "Plateau Malagasy").Whisper("mg", "Malagasy"),
+    TranslationLang("mlt_Latn", "Maltese").Whisper("mt", "Maltese").SeamlessTx("mlt", "Maltese"),
+    TranslationLang("mni_Beng", "Meitei (Bengali script)").SeamlessTx("mni", "Meitei"),
+    TranslationLang("khk_Cyrl", "Halh Mongolian").Whisper("mn", "Mongolian").SeamlessTx("khk", "Halh Mongolian"),
+    TranslationLang("mos_Latn", "Mossi"),
+    TranslationLang("mri_Latn", "Maori").Whisper("mi", "Maori"),
+    TranslationLang("mya_Mymr", "Burmese").Whisper("my", "Myanmar", "burmese").SeamlessTx("mya", "Burmese"),
+    TranslationLang("nld_Latn", "Dutch").Whisper("nl", "Dutch", "flemish").SeamlessTx("nld", "Dutch"),
+    TranslationLang("nno_Latn", "Norwegian Nynorsk").Whisper("nn", "Nynorsk").SeamlessTx("nno", "Norwegian Nynorsk"),
+    TranslationLang("nob_Latn", "Norwegian Bokmål").Whisper("no", "Norwegian").SeamlessTx("nob", "Norwegian Bokmål"),
+    TranslationLang("npi_Deva", "Nepali").Whisper("ne", "Nepali").SeamlessTx("npi", "Nepali"),
+    TranslationLang("nso_Latn", "Northern Sotho").M2M100("ns", "Northern Sotho"),
+    TranslationLang("nus_Latn", "Nuer"),
+    TranslationLang("nya_Latn", "Nyanja").SeamlessTx("nya", "Nyanja"),
+    TranslationLang("oci_Latn", "Occitan").Whisper("oc", "Occitan"),
+    TranslationLang("gaz_Latn", "West Central Oromo").SeamlessTx("gaz", "West Central Oromo"),
+    TranslationLang("ory_Orya", "Odia").M2M100("or", "Oriya").SeamlessTx("ory", "Odia"),
+    TranslationLang("pag_Latn", "Pangasinan"),
+    TranslationLang("pan_Guru", "Eastern Panjabi").Whisper("pa", "Punjabi", "panjabi").SeamlessTx("pan", "Punjabi"),
+    TranslationLang("pap_Latn", "Papiamento"),
+    TranslationLang("pes_Arab", "Western Persian").Whisper("fa", "Persian").SeamlessTx("pes", "Western Persian"),
+    TranslationLang("pol_Latn", "Polish").Whisper("pl", "Polish").SeamlessTx("pol", "Polish"),
+    TranslationLang("por_Latn", "Portuguese").Whisper("pt", "Portuguese").SeamlessTx("por", "Portuguese"),
+    TranslationLang("prs_Arab", "Dari"),
+    TranslationLang("pbt_Arab", "Southern Pashto").Whisper("ps", "Pashto", "pushto").SeamlessTx("pbt", "Southern Pashto"),
+    TranslationLang("quy_Latn", "Ayacucho Quechua"),
+    TranslationLang("ron_Latn", "Romanian").Whisper("ro", "Romanian", "moldavian", "moldovan").SeamlessTx("ron", "Romanian"),
+    TranslationLang("run_Latn", "Rundi"),
+    TranslationLang("rus_Cyrl", "Russian").Whisper("ru", "Russian").SeamlessTx("rus", "Russian"),
+    TranslationLang("sag_Latn", "Sango"),
+    TranslationLang("san_Deva", "Sanskrit").Whisper("sa", "Sanskrit"),
+    TranslationLang("sat_Olck", "Santali"),
+    TranslationLang("scn_Latn", "Sicilian"),
+    TranslationLang("shn_Mymr", "Shan"),
+    TranslationLang("sin_Sinh", "Sinhala").Whisper("si", "Sinhala", "sinhalese"),
+    TranslationLang("slk_Latn", "Slovak").Whisper("sk", "Slovak").SeamlessTx("slk", "Slovak"),
+    TranslationLang("slv_Latn", "Slovenian").Whisper("sl", "Slovenian").SeamlessTx("slv", "Slovenian"),
+    TranslationLang("smo_Latn", "Samoan"),
+    TranslationLang("sna_Latn", "Shona").Whisper("sn", "Shona").SeamlessTx("sna", "Shona"),
+    TranslationLang("snd_Arab", "Sindhi").Whisper("sd", "Sindhi").SeamlessTx("snd", "Sindhi"),
+    TranslationLang("som_Latn", "Somali").Whisper("so", "Somali").SeamlessTx("som", "Somali"),
+    TranslationLang("sot_Latn", "Southern Sotho"),
+    TranslationLang("spa_Latn", "Spanish").Whisper("es", "Spanish", "castilian").SeamlessTx("spa", "Spanish"),
+    TranslationLang("als_Latn", "Tosk Albanian").Whisper("sq", "Albanian"),
+    TranslationLang("srd_Latn", "Sardinian"),
+    TranslationLang("srp_Cyrl", "Serbian").Whisper("sr", "Serbian").SeamlessTx("srp", "Serbian"),
+    TranslationLang("ssw_Latn", "Swati").M2M100("ss", "Swati"),
+    TranslationLang("sun_Latn", "Sundanese").Whisper("su", "Sundanese"),
+    TranslationLang("swe_Latn", "Swedish").Whisper("sv", "Swedish").SeamlessTx("swe", "Swedish"),
+    TranslationLang("swh_Latn", "Swahili").Whisper("sw", "Swahili").SeamlessTx("swh", "Swahili"),
+    TranslationLang("szl_Latn", "Silesian"),
+    TranslationLang("tam_Taml", "Tamil").Whisper("ta", "Tamil").SeamlessTx("tam", "Tamil"),
+    TranslationLang("tat_Cyrl", "Tatar").Whisper("tt", "Tatar"),
+    TranslationLang("tel_Telu", "Telugu").Whisper("te", "Telugu").SeamlessTx("tel", "Telugu"),
+    TranslationLang("tgk_Cyrl", "Tajik").Whisper("tg", "Tajik").SeamlessTx("tgk", "Tajik"),
+    TranslationLang("tgl_Latn", "Tagalog").Whisper("tl", "Tagalog").SeamlessTx("tgl", "Tagalog"),
+    TranslationLang("tha_Thai", "Thai").Whisper("th", "Thai").SeamlessTx("tha", "Thai"),
+    TranslationLang("tir_Ethi", "Tigrinya"),
+    TranslationLang("taq_Latn", "Tamasheq (Latin script)"),
+    TranslationLang("taq_Tfng", "Tamasheq (Tifinagh script)"),
+    TranslationLang("tpi_Latn", "Tok Pisin"),
+    TranslationLang("tsn_Latn", "Tswana").M2M100("tn", "Tswana"),
+    TranslationLang("tso_Latn", "Tsonga"),
+    TranslationLang("tuk_Latn", "Turkmen").Whisper("tk", "Turkmen"),
+    TranslationLang("tum_Latn", "Tumbuka"),
+    TranslationLang("tur_Latn", "Turkish").Whisper("tr", "Turkish").SeamlessTx("tur", "Turkish"),
+    TranslationLang("twi_Latn", "Twi"),
+    TranslationLang("tzm_Tfng", "Central Atlas Tamazight"),
+    TranslationLang("uig_Arab", "Uyghur"),
+    TranslationLang("ukr_Cyrl", "Ukrainian").Whisper("uk", "Ukrainian").SeamlessTx("ukr", "Ukrainian"),
+    TranslationLang("umb_Latn", "Umbundu"),
+    TranslationLang("urd_Arab", "Urdu").Whisper("ur", "Urdu").SeamlessTx("urd", "Urdu"),
+    TranslationLang("uzn_Latn", "Northern Uzbek").Whisper("uz", "Uzbek").SeamlessTx("uzn", "Northern Uzbek"),
+    TranslationLang("vec_Latn", "Venetian"),
+    TranslationLang("vie_Latn", "Vietnamese").Whisper("vi", "Vietnamese").SeamlessTx("vie", "Vietnamese"),
+    TranslationLang("war_Latn", "Waray"),
+    TranslationLang("wol_Latn", "Wolof").M2M100("wo", "Wolof"),
+    TranslationLang("xho_Latn", "Xhosa").M2M100("xh", "Xhosa"),
+    TranslationLang("ydd_Hebr", "Eastern Yiddish").Whisper("yi", "Yiddish"),
+    TranslationLang("yor_Latn", "Yoruba").Whisper("yo", "Yoruba").SeamlessTx("yor", "Yoruba"),
+    TranslationLang("yue_Hant", "Yue Chinese").Whisper("yue", "cantonese").M2M100("zh", "Chinese (zh-yue)").SeamlessTx("yue", "Cantonese"),
+    TranslationLang("zho_Hans", "Chinese (Simplified)").Whisper("zh", "Chinese (Simplified)", "Chinese", "mandarin").SeamlessTx("cmn", "Mandarin Chinese (Simplified)"),
+    TranslationLang("zho_Hant", "Chinese (Traditional)").Whisper("zh", "Chinese (Traditional)").SeamlessTx("cmn_Hant", "Mandarin Chinese (Traditional)"),
+    TranslationLang("zsm_Latn", "Standard Malay").Whisper("ms", "Malay").SeamlessTx("zsm", "Standard Malay"),
+    TranslationLang("zul_Latn", "Zulu").M2M100("zu", "Zulu").SeamlessTx("zul", "Zulu"),
+    # TranslationLang(None, None).Whisper("br", "Breton"), # Both whisper and m2m100 support the Breton language, but nllb does not have this language.
 ]
 
 
@@ -263,6 +276,8 @@ _TO_LANG_NAME_M2M100 = {name.lower(): language for language in TranslationLangs
 
 _TO_LANG_NAME_WHISPER = {name.lower(): language for language in TranslationLangs if language.whisper is not None for name in language.whisper.names}
 
+_TO_LANG_NAME_SeamlessTx = {name.lower(): language for language in TranslationLangs if language.seamlessTx is not None for name in language.seamlessTx.names}
+
 _TO_LANG_CODE_WHISPER = {language.whisper.code.lower(): language for language in TranslationLangs if language.whisper is not None and len(language.whisper.code) > 0}
 
 
@@ -278,6 +293,10 @@ def get_lang_from_whisper_name(whisperName, default=None) -> TranslationLang:
     """Return the TranslationLang from the lang_name_whisper name."""
     return _TO_LANG_NAME_WHISPER.get(whisperName.lower() if whisperName else None, default)
 
+def get_lang_from_seamlessTx_name(seamlessTxName, default=None) -> TranslationLang:
+    """Return the TranslationLang from the lang_name_seamlessTx name."""
+    return _TO_LANG_NAME_SeamlessTx.get(seamlessTxName.lower() if seamlessTxName else None, default)
+
 def get_lang_from_whisper_code(whisperCode, default=None) -> TranslationLang:
     """Return the TranslationLang from the lang_code_whisper."""
     return _TO_LANG_CODE_WHISPER.get(whisperCode, default)
@@ -290,6 +309,10 @@ def get_lang_m2m100_names(codes = []):
     """Return a list of m2m100 language names."""
     return list({name.lower(): None for language in TranslationLangs if language.m2m100 is not None and (len(codes) == 0 or any(code in language.m2m100.code for code in codes)) for name in language.m2m100.names}.keys())
 
+def get_lang_seamlessTx_names(codes = []):
+    """Return a list of seamlessTx language names."""
+    return list({name.lower(): None for language in TranslationLangs if language.seamlessTx is not None and (len(codes) == 0 or any(code in language.seamlessTx.code for code in codes)) for name in language.seamlessTx.names}.keys())
+
 def get_lang_whisper_names():
     """Return a list of whisper language names."""
     return list(_TO_LANG_NAME_WHISPER.keys())

src/translation/translationModel.py

@@ -27,7 +27,7 @@ class TranslationModel:
         localFilesOnly: bool = False,
         loadModel: bool = False,
     ):
-        """Initializes the M2M100 / Nllb-200 / mt5 / ALMA / madlad400 translation model.
+        """Initializes the M2M100 / Nllb-200 / mt5 / ALMA / madlad400 / seamless-m4t translation model.
 
         Args:
           modelConfig: Config of the model to use (distilled-600M, distilled-1.3B, 
@@ -212,7 +212,7 @@ class TranslationModel:
             elif "GGUF" in self.modelPath:
                 pass
             elif self.usingBitsandbytes == None:
-                    kwargsPipeline.update({"device": self.device})
+                kwargsPipeline.update({"device": self.device})
             elif self.usingBitsandbytes == "int8":
                 kwargsModel.update({"load_in_8bit": True, "llm_int8_enable_fp32_cpu_offload": True})
             elif self.usingBitsandbytes == "int4":
@@ -277,6 +277,14 @@ class TranslationModel:
                 self.transTokenizer = transformers.T5Tokenizer.from_pretrained(**kwargsTokenizer)
                 self.transModel = transformers.T5ForConditionalGeneration.from_pretrained(**kwargsModel)
                 kwargsPipeline.update({"task": "text2text-generation", "model": self.transModel, "tokenizer": self.transTokenizer})
+            elif "seamless" in self.modelPath:
+                self.transProcessor = transformers.AutoProcessor.from_pretrained(self.modelPath)
+                if "v2" in self.modelPath:
+                    self.transModel = transformers.SeamlessM4Tv2Model.from_pretrained(**kwargsModel)
+                else:
+                    self.transModel = transformers.SeamlessM4TModel.from_pretrained(**kwargsModel)
+                if self.device != "cpu" and "load_in_8bit" not in kwargsModel and "load_in_4bit" not in kwargsModel:
+                    self.transModel.to(self.device)
             else:
                 kwargsTokenizer.update({"pretrained_model_name_or_path": self.modelPath})
                 self.transTokenizer = transformers.AutoTokenizer.from_pretrained(**kwargsTokenizer)
@@ -286,7 +294,7 @@ class TranslationModel:
                     kwargsPipeline.update({"src_lang": self.whisperLang.m2m100.code, "tgt_lang": self.translationLang.m2m100.code})
                 else: #NLLB
                     kwargsPipeline.update({"src_lang": self.whisperLang.nllb.code, "tgt_lang": self.translationLang.nllb.code})
-            if "ct2" not in self.modelPath:
+            if not any(name in self.modelPath for name in ["ct2", "seamless"]):
                 self.transTranslator = transformers.pipeline(**kwargsPipeline)
         except Exception as e:
             self.release_vram()
@@ -310,6 +318,8 @@ class TranslationModel:
                     if getattr(self, "transModel", None) is not None and getattr(self.transModel, "unload_model", None) is not None:
                         self.transModel.unload_model()
                     
+                if getattr(self, "transProcessor") is not None:
+                    del self.transProcessor
                 if getattr(self, "transTokenizer", None) is not None:
                     del self.transTokenizer
                 if getattr(self, "transModel", None) is not None:
@@ -392,6 +402,13 @@ class TranslationModel:
             elif "madlad400" in self.modelPath:
                 output = self.transTranslator(self.madlad400Prefix + text, max_length=max_length, batch_size=self.batchSize, no_repeat_ngram_size=self.noRepeatNgramSize, num_beams=self.numBeams) #, num_return_sequences=2
                 result = output[0]['generated_text']
+            elif "seamless" in self.modelPath:
+                if self.device != "cpu":
+                    text_inputs = self.transProcessor(text = text, src_lang=self.whisperLang.seamlessTx.code, return_tensors="pt").to(self.device)
+                else:
+                    text_inputs = self.transProcessor(text = text, src_lang=self.whisperLang.seamlessTx.code, return_tensors="pt")
+                output_tokens = self.transModel.generate(**text_inputs, tgt_lang=self.translationLang.seamlessTx.code, generate_speech=False, no_repeat_ngram_size=self.noRepeatNgramSize, num_beams=self.numBeams)
+                result = self.transProcessor.decode(output_tokens[0].tolist()[0], skip_special_tokens=True)
             else: #M2M100 & NLLB
                 output = self.transTranslator(text, max_length=max_length, batch_size=self.batchSize, no_repeat_ngram_size=self.noRepeatNgramSize, num_beams=self.numBeams)
                 result = output[0]['translation_text']
@@ -406,7 +423,8 @@ _MODELS = ["nllb-200",
            "m2m100",
            "mt5",
            "ALMA",
-           "madlad400"]
+           "madlad400",
+           "seamless"]
 
 def check_model_name(name):
     return any(allowed_name in name for allowed_name in _MODELS)
@@ -466,7 +484,9 @@ def download_model(
         "model.safetensors.index.json",
         "quantize_config.json",
         "tokenizer.model",
-        "vocabulary.json"
+        "vocabulary.json",
+        "preprocessor_config.json",
+        "added_tokens.json"
     ]
 
     kwargs = {