Update app.py

app.py

@@ -1,97 +1,60 @@
 import os
-import json
-import re
-from collections.abc import Iterator
-from threading import Thread
-
 import gradio as gr
-import spaces
 import torch
 import librosa
-from transformers import (
-    AutoModelForSpeechSeq2Seq, 
-    AutoProcessor, 
-    pipeline,
-    AutoModelForMultimodalLM,
-    BatchFeature,
-    StoppingCriteria
-)
-from transformers.generation.streamers import TextIteratorStreamer
+import json
+from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor, pipeline
+import spaces
 
-# ==========================================
-# 1. تنظیمات و بارگذاری مدل تبدیل صدا به متن (Whisper)
-# ==========================================
-whisper_model_id = "openai/whisper-large-v3"  
+# انتخاب نسخه مرجع جهانی چندزبانه OpenAI Whisper V3
+model_id = "openai/whisper-large-v3"  
 
+# ۱. انتخاب بهینه‌ترین فرمت عددی برای سخت‌افزار A100/H200
 if torch.cuda.is_available() and torch.cuda.is_bf16_supported():
-    whisper_dtype = torch.bfloat16
-    print("Whisper: Using optimized BFloat16 for A100/H200")
+    torch_dtype = torch.bfloat16
+    print("Using optimized BFloat16 for A100/H200")
 else:
-    whisper_dtype = torch.float16
-    print("Whisper: Using Float16")
+    torch_dtype = torch.float16
+    print("Using Float16")
 
+# ۲. فعال‌سازی مکانیسم شتاب‌دهنده توجه (Attention)
 attn_implementation = "sdpa"
 try:
     import flash_attn
     attn_implementation = "flash_attention_2"
-    print("Whisper: Using Flash Attention 2")
+    print("Using Flash Attention 2 for maximum hardware utilization")
 except ImportError:
-    print("Whisper: Flash Attention 2 not found. Falling back to SDPA")
+    print("Flash Attention 2 not found. Falling back to high-performance PyTorch SDPA")
 
-whisper_model = AutoModelForSpeechSeq2Seq.from_pretrained(
-    whisper_model_id,
-    torch_dtype=whisper_dtype,
+# ۳. بارگذاری بهینه مدل چندزبانه با تکیه بر Safetensors و Memory optimization
+model = AutoModelForSpeechSeq2Seq.from_pretrained(
+    model_id,
+    torch_dtype=torch_dtype,
     low_cpu_mem_usage=True,
     use_safetensors=True,
     attn_implementation=attn_implementation
 )
 
-whisper_device = "cuda" if torch.cuda.is_available() else "cpu"
-whisper_model.to(whisper_device)
-whisper_processor = AutoProcessor.from_pretrained(whisper_model_id)
+# انتقال مدل به حافظه گرافیکی در صورت در دسترس بودن
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model.to(device)
 
-whisper_pipe = pipeline(
-    "automatic-speech-recognition",
-    model=whisper_model,
-    tokenizer=whisper_processor.tokenizer,
-    feature_extractor=whisper_processor.feature_extractor,
-    dtype=whisper_dtype,
-    device=whisper_device,
-)
-
-# ==========================================
-# 2. تنظیمات و بارگذاری مدل زبانی چندرسانه‌ای (Gemma)
-# ==========================================
-gemma_model_id = "google/gemma-4-e4b-it"
-
-gemma_processor = AutoProcessor.from_pretrained(gemma_model_id, use_fast=False)
-gemma_model = AutoModelForMultimodalLM.from_pretrained(
-    gemma_model_id, 
-    device_map="auto", 
-    dtype=torch.bfloat16
-)
-
-IMAGE_FILE_TYPES = (".jpg", ".jpeg", ".png", ".webp")
-AUDIO_FILE_TYPES = (".wav", ".mp3", ".flac", ".ogg")
-VIDEO_FILE_TYPES = (".mp4", ".mov", ".avi", ".webm")
-MAX_INPUT_TOKENS = int(os.getenv("MAX_INPUT_TOKENS", "10_000"))
+processor = AutoProcessor.from_pretrained(model_id)
 
-THINKING_START = "<|channel>"
-THINKING_END = "<channel|>"
+# تعریف متن راهنمای پرامپت فارسی به صورت سراسری
+prompt_text = "کلمات دقیقاً همان‌طور که تلفظ می‌شوند، با رعایت حروف اضافه و ساختار عامیانه، محاوره‌ای و شکسته نوشته شوند."
 
-_KEEP_TOKENS = {THINKING_START, THINKING_END}
-_STRIP_TOKENS = sorted(
-    (t for t in gemma_processor.tokenizer.all_special_tokens if t not in _KEEP_TOKENS),
-    key=len,
-    reverse=True,
+# ۴. ساخت پایپ‌لاین تشخیص گفتار چندزبانه با استفاده از پارامتر اصلاح شده‌ی dtype
+pipe = pipeline(
+    "automatic-speech-recognition",
+    model=model,
+    tokenizer=processor.tokenizer,
+    feature_extractor=processor.feature_extractor,
+    dtype=torch_dtype,
+    device=device,
 )
 
-
-# ==========================================
-# توابع کمکی تبدیل صدا به متن (Whisper)
-# ==========================================
-prompt_text = "کلمات دقیقاً همان‌طور که تلفظ می‌شوند، با رعایت حروف اضافه و ساختار عامیانه، محاوره‌ای و شکسته نوشته شوند."
-
+# نقشه کدهای زبانی برای منوی کشویی انتخاب زبان
 LANGUAGE_MAPPING = {
     "Auto-Detect (تشخیص خودکار)": None,
     "Persian / فارسی": "fa",
@@ -108,6 +71,7 @@ LANGUAGE_MAPPING = {
     "Korean / کره‌ای": "ko"
 }
 
+# تابع کمکی برای فرمت‌بندی زمان در ساختار استاندارد زیرنویس (HH:MM:SS,mmm)
 def format_timestamp(seconds):
     hours = int(seconds // 3600)
     minutes = int((seconds % 3600) // 60)
@@ -115,49 +79,7 @@ def format_timestamp(seconds):
     millis = int(round((seconds % 1) * 1000))
     return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}"
 
-def create_srt_from_json_data(word_items, max_words_per_segment=6, max_duration_per_segment=3.0):
-    """تولید استاندارد فایل زیرنویس SRT بر پایه داده‌های جیسون بازنویسی شده کلمات"""
-    srt_lines = []
-    segment_idx = 1
-    current_segment_words = []
-    current_start = None
-    
-    for item in word_items:
-        text = item.get("word", "").strip()
-        start = item.get("start")
-        end = item.get("end")
-        
-        if not text or start is None:
-            continue
-        if end is None:
-            end = start + 0.3
-            
-        if current_start is None:
-            current_start = start
-            
-        current_segment_words.append(text)
-        duration = end - current_start
-        
-        if len(current_segment_words) >= max_words_per_segment or duration >= max_duration_per_segment:
-            line_text = " ".join(current_segment_words)
-            srt_lines.append(f"{segment_idx}")
-            srt_lines.append(f"{format_timestamp(current_start)} --> {format_timestamp(end)}")
-            srt_lines.append(line_text)
-            srt_lines.append("")
-            segment_idx += 1
-            current_segment_words = []
-            current_start = None
-            
-    if current_segment_words:
-        last_end = word_items[-1].get("end") if word_items and word_items[-1].get("end") else current_start + 1.0
-        line_text = " ".join(current_segment_words)
-        srt_lines.append(f"{segment_idx}")
-        srt_lines.append(f"{format_timestamp(current_start)} --> {format_timestamp(last_end)}")
-        srt_lines.append(line_text)
-        srt_lines.append("")
-        
-    return "\n".join(srt_lines)
-
+# مبدل داده‌های کلمه به کلمه ویسپر به ساختار استاندارد خوانای SRT
 def create_srt_from_chunks(chunks, max_words_per_segment=6, max_duration_per_segment=3.0):
     srt_lines = []
     segment_idx = 1
@@ -175,7 +97,7 @@ def create_srt_from_chunks(chunks, max_words_per_segment=6, max_duration_per_seg
         if start is None:
             continue
         if end is None:
-            end = start + 0.3
+            end = start + 0.3  # مقدار جایگزین در صورت عدم ثبت زمان پایان توکن
             
         if current_start is None:
             current_start = start
@@ -183,6 +105,7 @@ def create_srt_from_chunks(chunks, max_words_per_segment=6, max_duration_per_seg
         current_segment_words.append(text)
         duration = end - current_start
         
+        # دسته‌بندی کلمات در قالب خطوط زیرنویس خوانا (مثلا حداکثر ۶ کلمه یا ۳ ثانیه برای هر خط)
         if len(current_segment_words) >= max_words_per_segment or duration >= max_duration_per_segment:
             line_text = " ".join(current_segment_words)
             srt_lines.append(f"{segment_idx}")
@@ -203,6 +126,7 @@ def create_srt_from_chunks(chunks, max_words_per_segment=6, max_duration_per_seg
         
     return "\n".join(srt_lines)
 
+# تابع تولید دیتای خام زمان‌بندی کلمات (JSON) برای دسترسی توسعه‌دهندگان
 def get_raw_word_timestamps(chunks):
     word_timestamps = []
     for chunk in chunks:
@@ -216,392 +140,123 @@ def get_raw_word_timestamps(chunks):
             })
     return json.dumps(word_timestamps, ensure_ascii=False, indent=2)
 
-@spaces.GPU(duration=120)
+@spaces.GPU
 def transcribe_audio(audio_path, language_selection, optimize_persian):
     if audio_path is None:
         return "Please upload or record an audio file first. / لطفاً ابتدا فایل صوتی را آپلود یا ضبط کنید.", "", ""
     
     try:
-        # پردازش Whisper
+        # ۱. بارگذاری ایمن فایل صوتی به فرکانس ۱۶۰۰۰ هرتز (سازگار با همه فرمت‌ها مانند میکروفون وب‌ام یا m4a)
         audio_data, sampling_rate = librosa.load(audio_path, sr=16000)
+        
+        # ۲. پیکربندی پویا بر اساس زبان انتخاب شده توسط کاربر
         lang_code = LANGUAGE_MAPPING.get(language_selection, None)
         
+        # تنظیمات پایه تولید متن با استفاده از روش پیشرفته Beam Search برای افزایش حداکثری دقت تفکیک کلمات
         generate_kwargs = {
             "task": "transcribe",
             "do_sample": False,
-            "num_beams": 5
+            "num_beams": 5  # ارزیابی موازی ۵ مسیر واژگانی برای کاهش خطاهای شنیداری صوتی
         }
         
+        # اگر کاربر زبانی به جز تشخیص خودکار انتخاب کرده باشد
         if lang_code is not None:
             generate_kwargs["language"] = lang_code
             
+        # ۳. اعمال پرامپت اختصاصی فارسی فقط در صورت تمایل کاربر (به عنوان تانسور ۱ بعدی پایتورچِ روی GPU)
         if optimize_persian:
-            prompt_ids = whisper_processor.get_prompt_ids(prompt_text, return_tensors="pt")
-            prompt_ids = prompt_ids.to(whisper_device)
+            prompt_ids = processor.get_prompt_ids(prompt_text, return_tensors="pt")
+            prompt_ids = prompt_ids.to(device)
             generate_kwargs["prompt_ids"] = prompt_ids
-            generate_kwargs["language"] = "fa"
+            generate_kwargs["language"] = "fa"  # اجبار به فارسی در صورت فعال بودن این گزینه
         
-        result = whisper_pipe(
+        # ۴. پردازش نهایی با حداکثر ظرفیت سخت‌افزاری روی A100/H200 و درخواست ثبت تایم‌استمپ کلمات
+        result = pipe(
             {"raw": audio_data, "sampling_rate": sampling_rate},
             chunk_length_s=30,
             stride_length_s=(6, 6),
             batch_size=24,
-            return_timestamps="word",
+            return_timestamps="word",  # فعال‌سازی ثبت دقیق زمان‌بندی برای هر کلمه
             generate_kwargs=generate_kwargs
         )
         
         full_text = result["text"].strip()
         chunks = result.get("chunks", [])
         
+        # ۵. تولید ساختارهای سه‌گانه دیتای خروجی
         srt_content = create_srt_from_chunks(chunks)
         word_timestamps_json = get_raw_word_timestamps(chunks)
         
-        # فرآیند اصلاح هوشمند اجباری با هدایت مستقیم مدل زبانی روی ساختار کد JSON
-        if word_timestamps_json:
-            correction_prompt = (
-                "You are an expert subtitle corrector. Below is a JSON array representing words with their exact start and end timestamps in Persian. "
-                "Your task is ONLY to fix spelling, grammatical, or listening errors inside the 'word' field of each item. "
-                "CRITICAL RULES:\n"
-                "1. Keep the JSON structure exactly the same. Do NOT translate or summarize.\n"
-                "2. The start and end timestamps must NOT be modified under any circumstance.\n"
-                "3. Do NOT add or remove items. The list length must remain exactly identical.\n"
-                "4. Output ONLY the corrected valid JSON array starting with '[' and ending with ']'. "
-                "Do NOT include any markdown code blocks, conversational text, explanations, or introductory sentences. Output raw JSON only.\n\n"
-                f"JSON:\n{word_timestamps_json}"
-            )
-            
-            messages = [{"role": "user", "content": [{"type": "text", "text": correction_prompt}]}]
-            
-            inputs = gemma_processor.apply_chat_template(
-                messages, 
-                tokenize=True,
-                add_generation_prompt=True, 
-                return_dict=True, 
-                return_tensors="pt"
-            )
-            inputs = inputs.to(device=gemma_model.device, dtype=torch.bfloat16)
-            
-            with torch.inference_mode():
-                outputs = gemma_model.generate(
-                    **inputs, 
-                    max_new_tokens=4000, 
-                    disable_compile=True
-                )
-            
-            input_length = inputs["input_ids"].shape[1]
-            generated_tokens = outputs[0][input_length:]
-            corrected_text = gemma_processor.decode(generated_tokens, skip_special_tokens=True).strip()
-            
-            # پاکسازی و استخراج ایمن بلاک JSON
-            start_idx = corrected_text.find('[')
-            end_idx = corrected_text.rfind(']')
-            
-            if start_idx != -1 and end_idx != -1:
-                clean_json_str = corrected_text[start_idx:end_idx+1]
-                try:
-                    corrected_data = json.loads(clean_json_str)
-                    
-                    # بازسازی تمام خروجی‌ها از روی دیتای تصحیح‌شده
-                    full_text = " ".join([item["word"] for item in corrected_data])
-                    srt_content = create_srt_from_json_data(corrected_data)
-                    word_timestamps_json = json.dumps(corrected_data, ensure_ascii=False, indent=2)
-                except Exception as je:
-                    print(f"Failed to parse corrected JSON from Gemma: {je}")
-                    # در صورت هرگونه خطا، از نتایج خام Whisper استفاده می‌شود تا برنامه متوقف نشود
-
+        # بازگرداندن هر سه خروجی در قالب تاپل
         return full_text, srt_content, word_timestamps_json
         
     except Exception as e:
         return f"An error occurred during processing / خطایی در حین پردازش رخ داد: {str(e)}", "", ""
 
-
-# ==========================================
-# توابع کمکی چت‌بات (Gemma)
-# ==========================================
-def _strip_special_tokens(text: str) -> str:
-    for tok in _STRIP_TOKENS:
-        text = text.replace(tok, "")
-    return text
-
-def _classify_file(path: str) -> str | None:
-    lower = path.lower()
-    if lower.endswith(IMAGE_FILE_TYPES):
-        return "image"
-    if lower.endswith(AUDIO_FILE_TYPES):
-        return "audio"
-    if lower.endswith(VIDEO_FILE_TYPES):
-        return "video"
-    return None
-
-def process_new_user_message(message: dict) -> list[dict]:
-    content: list[dict] = []
-    for path in message.get("files", []):
-        kind = _classify_file(path)
-        if kind:
-            content.append({"type": kind, "url": path})
-    content.append({"type": "text", "text": message.message.get("text", "") if hasattr(message, 'message') else message.get("text", "")})
-    return content
-
-def process_history(history: list[dict]) -> list[dict]:
-    messages: list[dict] = []
-    for item in history:
-        if item["role"] == "assistant":
-            if (item.get("metadata") or {}).get("title") == "Reasoning":
-                continue
-            text_parts = [p["text"] for p in item["content"] if p.get("type") == "text"]
-            messages.append(
-                {
-                    "role": "assistant",
-                    "content": [{"type": "text", "text": " ".join(text_parts)}],
-                }
-            )
-        else:
-            user_content: list[dict] = []
-            for part in item["content"]:
-                if part.get("type") == "text":
-                    user_content.append({"type": "text", "text": part["text"]})
-                elif part.get("type") == "file":
-                    filepath = part["file"]["path"]
-                    kind = _classify_file(filepath)
-                    if kind:
-                        user_content.append({"type": kind, "url": filepath})
-            if user_content:
-                messages.append({"role": "user", "content": user_content})
-    return messages
-
-class StopOnSignal(StoppingCriteria):
-    def __init__(self) -> None:
-        self.stopped = False
-
-    def __call__(self, input_ids: torch.Tensor, scores: torch.Tensor, **kwargs: object) -> bool:
-        return self.stopped
-
-@spaces.GPU(duration=120)
-@torch.inference_mode()
-def _generate_on_gpu(inputs: BatchFeature, max_new_tokens: int, thinking: bool) -> Iterator[str]:
-    inputs = inputs.to(device=gemma_model.device, dtype=torch.bfloat16)
-
-    streamer = TextIteratorStreamer(
-        gemma_processor,
-        timeout=30.0,
-        skip_prompt=True,
-        skip_special_tokens=not thinking,
-    )
-    stop_criteria = StopOnSignal()
-    generate_kwargs = {
-        **inputs,
-        "streamer": streamer,
-        "stopping_criteria": [stop_criteria],
-        "max_new_tokens": max_new_tokens,
-        "disable_compile": True,
-    }
-
-    exception_holder: list[Exception] = []
-
-    def _generate() -> None:
-        try:
-            gemma_model.generate(**generate_kwargs)
-        except Exception as e:
-            exception_holder.append(e)
-
-    thread = Thread(target=_generate)
-    thread.start()
-
-    chunks: list[str] = []
-    try:
-        for text in streamer:
-            chunks.append(text)
-            accumulated = "".join(chunks)
-            if thinking:
-                yield _strip_special_tokens(accumulated)
-            else:
-                yield accumulated
-    except GeneratorExit:
-        stop_criteria.stopped = True
-        for _ in streamer:
-            pass
-        thread.join()
-        raise
-
-    thread.join()
-    if exception_holder:
-        msg = f"Generation failed: {exception_holder[0]}"
-        raise gr.Error(msg)
-
-def validate_input(message: dict) -> dict:
-    has_text = bool(message.get("text", "").strip())
-    has_files = bool(message.get("files"))
-    if not (has_text or has_files):
-        return gr.validate(False, "Please enter a message or upload a file.")
-
-    files = message.get("files", [])
-    kinds = [_classify_file(f) for f in files]
-    kinds = [k for k in kinds if k is not None]
-    unique_kinds = set(kinds)
-
-    if len(unique_kinds) > 1:
-        return gr.validate(False, "Please upload only one type of media at a time.")
-    if kinds.count("audio") > 1:
-        return gr.validate(False, "Only one audio file can be uploaded at a time.")
-    if kinds.count("video") > 1:
-        return gr.validate(False, "Only one video file can be uploaded at a time.")
-
-    return gr.validate(True, "")
-
-def _has_media_type(messages: list[dict], media_type: str) -> bool:
-    return any(c.get("type") == media_type for m in messages for c in m["content"])
-
-def generate(
-    message: dict,
-    history: list[dict],
-    thinking: bool = False,
-    max_new_tokens: int = 1024,
-    max_soft_tokens: int = 280,
-    system_prompt: str = "",
-) -> Iterator[str]:
-    messages: list[dict] = []
-    if system_prompt:
-        messages.append({"role": "system", "content": [{"type": "text", "text": system_prompt}]})
-
-    messages.extend(process_history(history))
-    messages.append({"role": "user", "content": process_new_user_message(message)})
-
-    template_kwargs: dict = {
-        "tokenize": True,
-        "return_dict": True,
-        "return_tensors": "pt",
-        "add_generation_prompt": True,
-        "load_audio_from_video": _has_media_type(messages, "video"),
-        "processor_kwargs": {"images_kwargs": {"max_soft_tokens": max_soft_tokens}},
-    }
-    if thinking:
-        template_kwargs["enable_thinking"] = True
-
-    inputs = gemma_processor.apply_chat_template(messages, **template_kwargs)
-
-    n_tokens = inputs["input_ids"].shape[1]
-    if n_tokens > MAX_INPUT_TOKENS:
-        msg = f"Input too long ({n_tokens} tokens). Maximum is {MAX_INPUT_TOKENS} tokens."
-        raise gr.Error(msg)
-
-    yield from _generate_on_gpu(inputs=inputs, max_new_tokens=max_new_tokens, thinking=thinking)
-
-
-# ==========================================
-# رابط کاربری مشترک (Gradio Blocks)
-# ==========================================
-examples_chat = [
-    [{"text": "What is the capital of France?", "files": []}],
-    [{"text": "Explain quantum entanglement in simple terms.", "files": []}],
-    [{"text": "Describe this image.", "files": ["https://news.bbc.co.uk/media/images/38107000/jpg/_38107299_ronaldogoal_ap_300.jpg"]}],
-    [{"text": "Transcribe the audio.", "files": ["https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3"]}],
-    [{"text": "What is happening in this video?", "files": ["https://huggingface.co/datasets/merve/vlm_test_images/resolve/main/concert.mp4"]}],
-]
-
-with gr.Blocks(theme=gr.themes.Default(primary_hue="blue")) as demo:
+# رابط کاربری چندزبانه و مدرن بر پایه Gradio 6.0
+with gr.Blocks() as demo:
     gr.Markdown(
         """
-        # 🎙️ Multi-Modal Studio & Speech-to-Text
-        ### استودیو هوشمند تبدیل گفتار به متن (Whisper V3) + دستیار هوش مصنوعی (Gemma 4)
+        # 🌐 Global Speech-to-Text & Subtitle Studio (Whisper Large V3)
+        ### سیستم هوشمند و بین‌المللی تبدیل گفتار به متن و زیرنویس خودکار (بهینه‌سازی شده روی A100/H200)
+        
+        *Supports over 99 languages with automatic detection and Word-Level Timestamps.*  
+        *پشتیبانی از بیش از ۹۹ زبان زنده دنیا به همراه تشخیص خودکار زبان و زمان‌بندی دقیق کلمه به کلمه.*
         """
     )
     
-    with gr.Tabs():
-        # -------- TAB 1: Speech to Text --------
-        with gr.Tab("Speech-to-Text / استودیو تبدیل صدا"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    audio_input = gr.Audio(
-                        sources=["upload", "microphone"], 
-                        type="filepath", 
-                        label="Audio Input / ورودی صدا"
+    with gr.Row():
+        with gr.Column(scale=1):
+            audio_input = gr.Audio(
+                sources=["upload", "microphone"], 
+                type="filepath", 
+                label="Audio Input / ورودی صدا"
+            )
+            
+            language_dd = gr.Dropdown(
+                choices=list(LANGUAGE_MAPPING.keys()),
+                value="Auto-Detect (تشخیص خودکار)",
+                label="Select Language / انتخاب زبان صوتی"
+            )
+            
+            optimize_fa_chk = gr.Checkbox(
+                label="Optimize for Spoken Persian / بهینه‌سازی برای محاوره عامیانه فارسی (فقط برای ویس‌های فارسی)",
+                value=False
+            )
+            
+            submit_btn = gr.Button("Transcribe / شروع فرآیند تبدیل", variant="primary")
+            
+        with gr.Column(scale=1):
+            with gr.Tabs():
+                with gr.Tab("Full Text / متن کامل"):
+                    text_output = gr.Textbox(
+                        label="Transcription Output / متن پیوسته", 
+                        lines=14, 
+                        buttons=["copy"],
+                        interactive=False
                     )
-                    
-                    language_dd = gr.Dropdown(
-                        choices=list(LANGUAGE_MAPPING.keys()),
-                        value="Auto-Detect (تشخیص خودکار)",
-                        label="Select Language / انتخاب زبان صوتی"
+                with gr.Tab("SRT Subtitles / زیرنویس استاندارد"):
+                    srt_output = gr.Textbox(
+                        label="Subtitles (SRT Format) / فایل زیرنویس", 
+                        lines=14, 
+                        buttons=["copy"],
+                        interactive=False
                     )
-                    
-                    optimize_fa_chk = gr.Checkbox(
-                        label="Optimize for Spoken Persian / بهینه‌سازی برای محاوره عامیانه فارسی",
-                        value=False
+                with gr.Tab("Word Timestamps / زمان‌بندی کلمات (JSON)"):
+                    json_output = gr.Textbox(
+                        label="Word-Level Timestamps (JSON) / زمان خام کلمات", 
+                        lines=14, 
+                        buttons=["copy"],
+                        interactive=False
                     )
-                    
-                    submit_btn = gr.Button("Transcribe & Correct / شروع تبدیل و اصلاح هوشمند", variant="primary")
-                    
-                with gr.Column(scale=1):
-                    with gr.Tabs():
-                        with gr.Tab("Full Text / متن کامل"):
-                            text_output = gr.Textbox(
-                                label="Transcription Output (AI Corrected) / متن پیوسته (اصلاح شده)", 
-                                lines=14, 
-                                buttons=["copy"],
-                                interactive=False
-                            )
-                        with gr.Tab("SRT Subtitles / زیرنویس استاندارد"):
-                            srt_output = gr.Textbox(
-                                label="Subtitles (SRT Format) / فایل زیرنویس", 
-                                lines=14, 
-                                buttons=["copy"],
-                                interactive=False
-                            )
-                        with gr.Tab("Word Timestamps / زمان‌بندی کلمات (JSON)"):
-                            json_output = gr.Textbox(
-                                label="Word-Level Timestamps (JSON) / زمان خام کلمات", 
-                                lines=14, 
-                                buttons=["copy"],
-                                interactive=False
-                            )
             
-            submit_btn.click(
-                fn=transcribe_audio,
-                inputs=[audio_input, language_dd, optimize_fa_chk],
-                outputs=[text_output, srt_output, json_output],
-                api_name="transcribe"
-            )
-
-        # -------- TAB 2: Chat Interface --------
-        with gr.Tab("AI Chatbot / چت‌بات چندرسانه‌ای"):
-            gr.ChatInterface(
-                fn=generate,
-                validator=validate_input,
-                chatbot=gr.Chatbot(
-                    scale=1,
-                    latex_delimiters=[
-                        {"left": "$$", "right": "$$", "display": True},
-                        {"left": "$", "right": "$", "display": False},
-                        {"left": "\\(", "right": "\\)", "display": False},
-                        {"left": "\\[", "right": "\\]", "display": True},
-                    ],
-                    reasoning_tags=[(THINKING_START, THINKING_END)],
-                ),
-                textbox=gr.MultimodalTextbox(
-                    sources=["upload", "microphone"],
-                    file_types=[*IMAGE_FILE_TYPES, *AUDIO_FILE_TYPES, *VIDEO_FILE_TYPES],
-                    file_count="multiple",
-                    autofocus=True,
-                    stop_btn=True,
-                ),
-                multimodal=True,
-                additional_inputs=[
-                    gr.Checkbox(label="Thinking", value=False),
-                    gr.Slider(label="Max New Tokens", minimum=100, maximum=4000, step=10, value=2000),
-                    gr.Dropdown(
-                        label="Image Token Budget",
-                        info="Higher values preserve more visual detail. Lower values are faster.",
-                        choices=[70, 140, 280, 560, 1120],
-                        value=280,
-                    ),
-                    gr.Textbox(label="System Prompt", value=""),
-                ],
-                additional_inputs_accordion=gr.Accordion("Settings", open=False),
-                title="",
-                examples=examples_chat,
-                run_examples_on_click=False,
-                cache_examples=False,
-                delete_cache=(1800, 1800),
-            )
+    submit_btn.click(
+        fn=transcribe_audio,
+        inputs=[audio_input, language_dd, optimize_fa_chk],
+        outputs=[text_output, srt_output, json_output],
+        api_name="transcribe"  # نام اختصاصی متد برای فراخوانی API کلاینت
+    )
 
 if __name__ == "__main__":
-    demo.launch(max_file_size="20MB")
+    # فعال‌سازی تم آبی‌رنگ در زمان راه‌اندازی بر اساس استانداردهای Gradio 6.0
+    demo.launch(theme=gr.themes.Default(primary_hue="blue"))