Update app.py

app.py

@@ -1,4 +1,3 @@
-import gradio as gr
 import base64
 import mimetypes
 import os
@@ -6,10 +5,10 @@ import re
 import struct
 import time
 import zipfile
-import traceback # For detailed error logging if needed
-from google import genai
-from google.genai import types as genai_types 
+import shutil # برای حذف فایل‌ها و پوشه‌ها
 
+from google import genai
+from google.genai import types
 try:
     from pydub import AudioSegment
     PYDUB_AVAILABLE = True
@@ -17,360 +16,481 @@ except ImportError:
     PYDUB_AVAILABLE = False
     print("⚠️ pydub در دسترس نیست. فایل‌های صوتی به صورت جداگانه ذخیره می‌شوند.")
 
-# --- Constants ---
-SPEAKER_VOICES_LIST = [
-    "Achird", "Zubenelgenubi", "Vindemiatrix", "Sadachbia", "Sadaltager",
-    "Sulafat", "Laomedeia", "Achernar", "Alnilam", "Schedar", "Gacrux",
-    "Pulcherrima", "Umbriel", "Algieba", "Despina", "Erinome", "Algenib",
-    "Rasalthgeti", "Orus", "Aoede", "Callirrhoe", "Autonoe", "Enceladus",
-    "Iapetus", "Zephyr", "Puck", "Charon", "Kore", "Fenrir", "Leda"
-]
-MODELS_LIST = ["gemini-2.5-flash-preview-tts", "gemini-2.5-pro-preview-tts"]
-
-OUTPUT_DIR = "generated_audio"
-if not os.path.exists(OUTPUT_DIR):
-    os.makedirs(OUTPUT_DIR)
-
-# --- Helper functions (unchanged) ---
-def log_message(msg, current_logs):
-    print(msg)
-    return f"{current_logs}\n{msg}".strip()
-
-def save_binary_file(file_name, data, log_func, current_logs):
-    full_path = os.path.join(OUTPUT_DIR, file_name)
-    try:
-        with open(full_path, "wb") as f: f.write(data)
-        current_logs = log_func(f"✅ فایل: {full_path}", current_logs)
-        return full_path, current_logs
-    except Exception as e:
-        current_logs = log_func(f"❌ خطا ذخیره {file_name}: {e}", current_logs)
-        return None, current_logs
+import gradio as gr
+
+# --- Helper functions (mostly from your Colab notebook) ---
+
+def save_binary_file(file_name, data):
+    # Ensure output directory exists
+    output_dir = "outputs"
+    os.makedirs(output_dir, exist_ok=True)
+    full_file_path = os.path.join(output_dir, file_name)
+    with open(full_file_path, "wb") as f:
+        f.write(data)
+    print(f"✅ فایل در مسیر زیر ذخیره شد: {full_file_path}")
+    return full_file_path
 
 def convert_to_wav(audio_data: bytes, mime_type: str) -> bytes:
     parameters = parse_audio_mime_type(mime_type)
-    bits_per_sample, sample_rate = parameters["bits_per_sample"], parameters["rate"]
-    num_channels, data_size = 1, len(audio_data)
+    bits_per_sample = parameters["bits_per_sample"]
+    sample_rate = parameters["rate"]
+    num_channels = 1
+    data_size = len(audio_data)
     bytes_per_sample = bits_per_sample // 8
     block_align = num_channels * bytes_per_sample
     byte_rate = sample_rate * block_align
     chunk_size = 36 + data_size
-    header = struct.pack("<4sI4s4sIHHIIHH4sI", b"RIFF", chunk_size, b"WAVE", b"fmt ", 16, 1, num_channels, sample_rate, byte_rate, block_align, bits_per_sample, b"data", data_size)
+
+    header = struct.pack(
+        "<4sI4s4sIHHIIHH4sI",
+        b"RIFF",
+        chunk_size,
+        b"WAVE",
+        b"fmt ",
+        16,
+        1,
+        num_channels,
+        sample_rate,
+        byte_rate,
+        block_align,
+        bits_per_sample,
+        b"data",
+        data_size
+    )
     return header + audio_data
 
 def parse_audio_mime_type(mime_type: str) -> dict[str, int | None]:
-    bits_per_sample, rate = 16, 24000
-    for param in mime_type.split(";"):
+    bits_per_sample = 16
+    rate = 24000
+    parts = mime_type.split(";")
+    for param in parts:
         param = param.strip()
         if param.lower().startswith("rate="):
-            try: rate = int(param.split("=", 1)[1])
-            except: pass
+            try:
+                rate_str = param.split("=", 1)[1]
+                rate = int(rate_str)
+            except (ValueError, IndexError):
+                pass
         elif param.startswith("audio/L"):
-            try: bits_per_sample = int(param.split("L", 1)[1])
-            except: pass
+            try:
+                bits_per_sample = int(param.split("L", 1)[1])
+            except (ValueError, IndexError):
+                pass
     return {"bits_per_sample": bits_per_sample, "rate": rate}
 
-def load_text_from_file(file_obj, log_func, current_logs):
-    if file_obj is None: return "", log_func("❌ فایل آپلود نشد.", current_logs)
-    file_path = file_obj.name
-    current_logs = log_func(f"✅ فایل '{os.path.basename(file_path)}' دریافت.", current_logs)
+def load_text_from_gradio_file(file_obj):
+    if file_obj is None:
+        return ""
     try:
-        with open(file_path, 'r', encoding='utf-8') as f: content = f.read().strip()
-        current_logs = log_func(f"📖 متن: {len(content)} کاراکتر. نمونه: '{content[:100]}{'...' if len(content) > 100 else ''}'", current_logs)
-        return content, current_logs
-    except Exception as e: return "", log_func(f"❌ خطا خواندن فایل: {e}", current_logs)
+        with open(file_obj.name, 'r', encoding='utf-8') as f:
+            content = f.read().strip()
+        print(f"📖 متن بارگذاری شده: {len(content)} کاراکتر")
+        print(f"📝 نمونه متن: '{content[:100]}{'...' if len(content) > 100 else ''}'")
+        return content
+    except Exception as e:
+        print(f"❌ خطا در خواندن فایل: {e}")
+        return ""
 
 def smart_text_split(text, max_size=3800):
-    if len(text) <= max_size: return [text]
-    chunks, current_chunk = [], ""
-    sentences = re.split(r'(?<=[.!?؟۔])\s+', text)
+    if len(text) <= max_size:
+        return [text]
+    chunks = []
+    current_chunk = ""
+    sentences = re.split(r'(?<=[.!?])\s+', text)
     for sentence in sentences:
         if len(current_chunk) + len(sentence) + 1 > max_size:
-            if current_chunk: chunks.append(current_chunk.strip())
-            if len(sentence) > max_size:
-                words, temp_word_chunk = sentence.split(), ""
-                for word in words:
-                    if len(temp_word_chunk) + len(word) + 1 > max_size:
-                        if temp_word_chunk: chunks.append(temp_word_chunk.strip())
-                        if len(word) > max_size:
-                            for i in range(0, len(word), max_size): chunks.append(word[i:i+max_size])
-                            temp_word_chunk = ""
-                        else: temp_word_chunk = word
-                    else: temp_word_chunk += (" " if temp_word_chunk else "") + word
-                if temp_word_chunk: chunks.append(temp_word_chunk.strip())
-                current_chunk = ""
-            else: current_chunk = sentence
-        else: current_chunk += (" " if current_chunk else "") + sentence
-    if current_chunk: chunks.append(current_chunk.strip())
-    return [c for c in chunks if c]
-
-def merge_audio_files_func(file_paths, output_filename, log_func, current_logs):
-    if not PYDUB_AVAILABLE: return None, log_func("❌ pydub نیست.", current_logs)
-    output_path = os.path.join(OUTPUT_DIR, output_filename)
+            if current_chunk:
+                chunks.append(current_chunk.strip())
+            current_chunk = sentence
+            # Handle very long sentences by splitting words/characters
+            while len(current_chunk) > max_size:
+                # Find a good split point (e.g., space) within max_size
+                split_at = current_chunk[:max_size].rfind(' ')
+                if split_at == -1 or split_at < max_size // 2 : # if no space or space is too early, force split
+                    split_at = max_size
+                chunks.append(current_chunk[:split_at].strip())
+                current_chunk = current_chunk[split_at:].strip()
+        else:
+            current_chunk += (" " if current_chunk else "") + sentence
+    if current_chunk:
+        chunks.append(current_chunk.strip())
+    return chunks
+
+
+def merge_audio_files_func(file_paths, output_path):
+    if not PYDUB_AVAILABLE:
+        print("❌ pydub در دسترس نیست. نمی‌توان فایل‌ها را ادغام کرد.")
+        return None, "خطا: کتابخانه pydub برای ادغام فایل‌ها در دسترس نیست."
+    if not file_paths:
+        return None, "خطا: هیچ فایلی برای ادغام وجود ندارد."
+    
+    # Ensure output directory exists
+    output_dir = os.path.dirname(output_path)
+    if output_dir: # If output_path includes a directory
+        os.makedirs(output_dir, exist_ok=True)
+
     try:
-        current_logs = log_func(f"🔗 ادغام {len(file_paths)} فایل...", current_logs)
+        print(f"🔗 در حال ادغام {len(file_paths)} فایل صوتی...")
+        log_messages = [f"🔗 در حال ادغام {len(file_paths)} فایل صوتی..."]
+        
         combined = AudioSegment.empty()
+        valid_files_merged = 0
         for i, file_path in enumerate(file_paths):
-            if os.path.exists(file_path):
-                current_logs = log_func(f"📎 فایل {i+1}: {file_path}", current_logs)
+            if os.path.exists(file_path) and os.path.getsize(file_path) > 0:
                 try:
+                    print(f"📎 اضافه کردن فایل {i+1}: {file_path}")
+                    log_messages.append(f"📎 اضافه کردن فایل {i+1}: {os.path.basename(file_path)}")
                     audio = AudioSegment.from_file(file_path)
                     combined += audio
-                    if i < len(file_paths) - 1: combined += AudioSegment.silent(duration=500)
-                except Exception as e_pydub:
-                    current_logs = log_func(f"⚠️ خطا pydub {file_path}: {e_pydub}. رد شد.", current_logs)
-                    continue
-            else: current_logs = log_func(f"⚠️ فایل نیست: {file_path}", current_logs)
-        if not combined: return None, log_func("❌ فایل معتبری برای ادغام نبود.", current_logs)
+                    if i < len(file_paths) - 1: # Add silence between segments, except for the last one
+                        combined += AudioSegment.silent(duration=200) # 200ms silence
+                    valid_files_merged += 1
+                except Exception as e:
+                    print(f"⚠️ خطا در خواندن یا اضافه کردن فایل {file_path}: {e}")
+                    log_messages.append(f"⚠️ خطا در خواندن یا اضافه کردن فایل {os.path.basename(file_path)}: {e}")
+            else:
+                print(f"⚠️ فایل پیدا نشد یا خالی است: {file_path}")
+                log_messages.append(f"⚠️ فایل پیدا نشد یا خالی است: {os.path.basename(file_path)}")
+        
+        if valid_files_merged == 0:
+             return None, "\n".join(log_messages) + "\n❌ هیچ فایل معتبری برای ادغام پیدا نشد."
+
         combined.export(output_path, format="wav")
-        return output_path, log_func(f"✅ ادغام شد: {output_path}", current_logs)
-    except Exception as e: return None, log_func(f"❌ خطا ادغام: {e}", current_logs)
+        print(f"✅ فایل ادغام شده ذخیره شد: {output_path}")
+        log_messages.append(f"✅ فایل ادغام شده ذخیره شد: {os.path.basename(output_path)}")
+        return output_path, "\n".join(log_messages)
+    except Exception as e:
+        print(f"❌ خطا در ادغام فایل‌ها: {e}")
+        log_messages.append(f"❌ خطا در ادغام فایل‌ها: {e}")
+        return None, "\n".join(log_messages)
 
-def create_zip_file(file_paths, zip_name_base, log_func, current_logs):
-    zip_filename = os.path.join(OUTPUT_DIR, f"{zip_name_base}.zip")
+def create_zip_file(file_paths, zip_name_base):
+    output_dir = "outputs"
+    os.makedirs(output_dir, exist_ok=True)
+    zip_path = os.path.join(output_dir, f"{zip_name_base}.zip")
+    log_messages = []
     try:
-        with zipfile.ZipFile(zip_filename, 'w') as zipf:
+        with zipfile.ZipFile(zip_path, 'w') as zipf:
             for file_path in file_paths:
-                if os.path.exists(file_path): zipf.write(file_path, os.path.basename(file_path))
-        return zip_filename, log_func(f"📦 ZIP شد: {zip_filename}", current_logs)
-    except Exception as e: return None, log_func(f"❌ خطا ZIP: {e}", current_logs)
-
-# --- Main generation function ---
-def generate_audio_from_text_gradio(
-    api_key_hf_secret, input_method, text_to_speak_ui, uploaded_file_ui,
-    speech_prompt_ui, model_name_ui, speaker_voice_ui, temperature_ui,
-    max_chunk_size_ui, sleep_between_requests_ui, output_filename_base_ui,
-    merge_audio_files_ui, delete_partial_files_ui
+                if os.path.exists(file_path):
+                    zipf.write(file_path, os.path.basename(file_path))
+        log_messages.append(f"📦 فایل ZIP ایجاد شد: {os.path.basename(zip_path)}")
+        return zip_path, "\n".join(log_messages)
+    except Exception as e:
+        log_messages.append(f"❌ خطا در ایجاد فایل ZIP: {e}")
+        return None, "\n".join(log_messages)
+
+def cleanup_temp_files(files_to_delete):
+    if not files_to_delete:
+        return
+    print("🧹 در حال پاکسازی فایل‌های موقت...")
+    for f_path in files_to_delete:
+        if f_path and os.path.exists(f_path):
+            try:
+                os.remove(f_path)
+                print(f"🗑️ فایل موقت حذف شد: {f_path}")
+            except Exception as e:
+                print(f"⚠️ خطا در حذف فایل {f_path}: {e}")
+    # Clean up the 'outputs' directory content as well, but not the directory itself
+    output_dir_content = "outputs"
+    if os.path.exists(output_dir_content):
+        for item in os.listdir(output_dir_content):
+            item_path = os.path.join(output_dir_content, item)
+            try:
+                if os.path.isfile(item_path) or os.path.islink(item_path):
+                    os.unlink(item_path)
+                elif os.path.isdir(item_path):
+                    shutil.rmtree(item_path) # Danger: be careful with rmtree
+                print(f"🗑️ آیتم حذف شده از outputs: {item_path}")
+            except Exception as e:
+                print(f"⚠️ خطا در حذف {item_path} از outputs: {e}")
+
+
+# --- Main generation function for Gradio ---
+def generate_audio_gradio(
+    use_file_input, text_file_obj, text_to_speak, speech_prompt,
+    selected_voice, output_filename_base, model_name, temperature,
+    max_chunk_size, sleep_between_requests, merge_audio_files, delete_partial_files,
+    progress=gr.Progress(track_tqdm=True)
 ):
-    logs = "⏳ شروع فرآیند..."
-    if not api_key_hf_secret:
-        return log_message("❌ کلید API جمینای در Secrets نیست.", logs), None, None, gr.update(visible=False)
+    log_messages = ["🚀 شروع فرآیند تبدیل متن به گفتار...\n"]
     
-    os.environ["GEMINI_API_KEY"] = api_key_hf_secret 
-    logs = log_message("🔑 کلید API از Secrets بارگذاری شد.", logs)
-
-    client = None
-    try:
-        logs = log_message("🛠️ ایجاد کلاینت `genai.Client()`...", logs)
-        client = genai.Client(api_key=api_key_hf_secret)
-        logs = log_message("✅ کلاینت ایجاد شد.", logs)
-    except Exception as e:
-        return log_message(f"❌ خطا ایجاد کلاینت: {type(e).__name__} - {e}", logs), None, None, gr.update(visible=False)
+    # Cleanup previous run files from 'outputs' if any, except for permanent ones.
+    # It's better to generate files in a unique temp dir per request or clean up specifically.
+    # For simplicity here, we'll clean up 'outputs' at the start of each run.
+    # Ensure 'outputs' directory exists for this run
+    os.makedirs("outputs", exist_ok=True)
+    
+    # It's safer to delete specific files from previous runs rather than wiping the whole dir
+    # For now, let's skip aggressive auto-deletion of 'outputs' and rely on specific file deletion.
 
-    text_input_content = ""
-    if input_method == "آپلود فایل":
-        text_input_content, logs = load_text_from_file(uploaded_file_ui, log_message, logs)
-        if not text_input_content: return logs, None, None, gr.update(visible=False)
+    text_input = ""
+    if use_file_input:
+        log_messages.append("📁 حالت فایل فعال است. در حال خواندن فایل...")
+        if text_file_obj is None:
+            log_messages.append("❌ خطا: هیچ فایلی آپلود نشده است.")
+            return None, None, "\n".join(log_messages)
+        text_input = load_text_from_gradio_file(text_file_obj)
+        if not text_input:
+            log_messages.append("❌ خطا: متن استخراج شده از فایل خالی است.")
+            return None, None, "\n".join(log_messages)
+        log_messages.append("✅ متن از فایل با موفقیت بارگذاری شد.")
     else:
-        text_input_content = text_to_speak_ui
+        log_messages.append("⌨️ حالت ورودی دستی فعال است.")
+        text_input = text_to_speak
+
+    if not text_input or text_input.strip() == "":
+        log_messages.append("❌ خطا: متن ورودی برای تبدیل به گفتار خالی است.")
+        return None, None, "\n".join(log_messages)
+
+    api_key = os.environ.get("GEMINI_API_KEY")
+    if not api_key:
+        log_messages.append("❌ خطا: کلید API جمینای (GEMINI_API_KEY) پیدا نشد.")
+        log_messages.append("لطفاً کلید API خود را در بخش Secrets این Space تنظیم کنید.")
+        return None, None, "\n".join(log_messages)
     
-    if not text_input_content or not text_input_content.strip():
-        return log_message("❌ متن ورودی خالی است.", logs), None, None, gr.update(visible=False)
+    # os.environ["GEMINI_API_KEY"] = api_key # Not needed if genai client picks it up directly
+    log_messages.append("🔑 کلید API از Hugging Face Secrets بارگذاری شد.")
 
-    text_chunks = smart_text_split(text_input_content, max_chunk_size_ui)
-    logs = log_message(f"📊 متن به {len(text_chunks)} قطعه تقسیم شد.", logs)
-    for i, chunk_text in enumerate(text_chunks):
-        logs = log_message(f"📝 قطعه {i+1}: {len(chunk_text)} کاراکتر", logs)
+    try:
+        log_messages.append("🛠️ در حال ایجاد کلاینت جمینای...")
+        client = genai.Client(api_key=api_key)
+        log_messages.append("✅ کلاینت جمینای با موفقیت ایجاد شد.")
+    except Exception as e:
+        log_messages.append(f"❌ خطا در ایجاد کلاینت جمینای: {e}")
+        return None, None, "\n".join(log_messages)
+
+    text_chunks = smart_text_split(text_input, int(max_chunk_size))
+    log_messages.append(f"📊 متن به {len(text_chunks)} قطعه تقسیم شد.")
+    for i, chunk in enumerate(text_chunks):
+        log_messages.append(f"📝 قطعه {i+1}: {len(chunk)} کاراکتر")
 
     generated_files = []
-    for i, chunk_for_api in enumerate(text_chunks): 
-        logs = log_message(f"\n🔊 تولید صدا قطعه {i+1}/{len(text_chunks)}...", logs)
+    total_chunks = len(text_chunks)
+
+    for i, chunk in enumerate(progress.tqdm(text_chunks, desc="تولید قطعات صوتی")):
+        current_log = [f"\n🔊 تولید صدا برای قطعه {i+1}/{total_chunks}..."]
         
-        # REVERTING to adding speech_prompt to the text, as per Colab's presumed successful logic
-        # Using a simple concatenation. The Colab might have had a more specific format.
-        # If speech_prompt_ui is "شاد و پر انرژی" and chunk_for_api is "سلام دنیا"
-        # final_text_for_api will be "شاد و پر انرژی\nسلام دنیا"
-        if speech_prompt_ui and speech_prompt_ui.strip():
-            final_text_for_api = f"{speech_prompt_ui.strip()}\n{chunk_for_api}"
-            logs = log_message(f"ℹ️ پرامپت سبک '{speech_prompt_ui.strip()}' به متن اضافه شد.", logs)
-        else:
-            final_text_for_api = chunk_for_api
+        final_text_for_api = f'"{speech_prompt}"\n{chunk}' if speech_prompt and speech_prompt.strip() else chunk
 
-        api_contents = [
-            genai_types.Content(
-                role="user",
-                parts=[genai_types.Part.from_text(text=final_text_for_api)],
+        contents = [types.Content(role="user", parts=[types.Part.from_text(text=final_text_for_api)])]
+        generate_content_config = types.GenerateContentConfig(
+            temperature=float(temperature),
+            response_modalities=["audio"],
+            speech_config=types.SpeechConfig(
+                voice_config=types.VoiceConfig(
+                    prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name=selected_voice)
+                )
             ),
-        ]
-
-        genai_speech_config = genai_types.SpeechConfig(
-            voice_config=genai_types.VoiceConfig(
-                prebuilt_voice_config=genai_types.PrebuiltVoiceConfig(voice_name=speaker_voice_ui)
-            )
         )
         
-        stream_generation_config = genai_types.GenerateContentConfig(
-            temperature=temperature_ui,
-            response_modalities=["audio"],
-            speech_config=genai_speech_config
-        )
+        chunk_filename_base = f"{output_filename_base}_part_{i+1:03d}"
         
         try:
-            if not hasattr(client, 'models') or not hasattr(client.models, 'generate_content_stream'): # type: ignore
-                logs = log_message(f"❌ کلاینت (`{type(client)}`) متد `models.generate_content_stream` ندارد.", logs)
-                continue 
-            
-            stream_iterator = client.models.generate_content_stream( # type: ignore
-                model=model_name_ui, contents=api_contents, config=stream_generation_config,
+            response_stream = client.models.generate_content_stream(
+                model=model_name,
+                contents=contents,
+                config=generate_content_config,
             )
+            
+            audio_data_buffer = b""
+            final_mime_type = None
 
-            chunk_filename_base = f"{output_filename_base_ui}_part_{i+1:03d}"
-            audio_data_buffer, mime_type_from_api = b"", "audio/wav" 
-
-            for chunk_response in stream_iterator:
-                if (chunk_response.candidates and chunk_response.candidates[0].content and
-                    chunk_response.candidates[0].content.parts and 
-                    chunk_response.candidates[0].content.parts[0].inline_data):
+            for chunk_response in response_stream:
+                if (
+                    chunk_response.candidates and chunk_response.candidates[0].content and
+                    chunk_response.candidates[0].content.parts and
+                    chunk_response.candidates[0].content.parts[0].inline_data
+                ):
                     inline_data = chunk_response.candidates[0].content.parts[0].inline_data
-                    audio_data_buffer += inline_data.data
-                    mime_type_from_api = inline_data.mime_type
+                    audio_data_buffer += inline_data.data # Accumulate data if streamed in parts
+                    final_mime_type = inline_data.mime_type # Mime type should be consistent
                 elif chunk_response.text:
-                    log_text = f"💬 پیام API قطعه {i+1}: {chunk_response.text}"
-                    # Check if it's an error that might indicate the prompt was misunderstood or caused an issue
-                    if "error" in chunk_response.text.lower() or "failed" in chunk_response.text.lower() or "invalid input" in chunk_response.text.lower():
-                        logs = log_message(f"❌ {log_text} (ممکن است به دلیل پرامپت سبک باشد)", logs)
-                    else:
-                        logs = log_message(f"ℹ️ {log_text}", logs)
-
-
-            if audio_data_buffer:
-                file_extension = mimetypes.guess_extension(mime_type_from_api)
-                final_audio_data = audio_data_buffer
-                if file_extension is None or file_extension.lower() not in ['.wav', '.mp3', '.ogg', '.aac']:
-                    if "audio/L" in mime_type_from_api or "audio/raw" in mime_type_from_api:
-                        logs = log_message(f"ℹ️ Mime: {mime_type_from_api}. تبدیل به WAV...", logs)
-                        final_audio_data = convert_to_wav(audio_data_buffer, mime_type_from_api)
-                        file_extension = ".wav"
-                    else:
-                        logs = log_message(f"ℹ️ Mime ناشناخته: {mime_type_from_api}. ذخیره .bin.", logs)
-                        file_extension = ".bin"
-                if mime_type_from_api == "audio/wav" and (file_extension != ".wav" and file_extension != ".wave"): file_extension = ".wav"
-                elif mime_type_from_api == "audio/mpeg" and file_extension != ".mp3": file_extension = ".mp3"
-                elif mime_type_from_api == "audio/ogg" and file_extension != ".ogg": file_extension = ".ogg"
-                if file_extension is None: file_extension = ".audio"
-
-                saved_file_path, logs = save_binary_file(f"{chunk_filename_base}{file_extension}", final_audio_data, log_message, logs)
-                if saved_file_path:
-                    generated_files.append(saved_file_path)
-                    logs = log_message(f"✅ قطعه {i+1} تولید شد: {saved_file_path}", logs)
+                    current_log.append(f"ℹ️ پیام متنی از API: {chunk_response.text}")
+            
+            if audio_data_buffer and final_mime_type:
+                file_extension = mimetypes.guess_extension(final_mime_type)
+                if file_extension is None or file_extension == ".bin": # .bin is often default for unknown binary
+                    file_extension = ".wav" # Force wav if unknown
+                    processed_data_buffer = convert_to_wav(audio_data_buffer, final_mime_type)
+                else:
+                    processed_data_buffer = audio_data_buffer
+                
+                generated_file_path = save_binary_file(f"{chunk_filename_base}{file_extension}", processed_data_buffer)
+                generated_files.append(generated_file_path)
+                current_log.append(f"✅ قطعه {i+1} تولید شد: {os.path.basename(generated_file_path)}")
             else:
-                if not f"❌ پیام API قطعه {i+1}" in logs:
-                    logs = log_message(f"❌ قطعه {i+1} بدون داده صوتی.", logs)
-                    
+                current_log.append(f"❌ داده صوتی برای قطعه {i+1} دریافت نشد.")
+
+
         except Exception as e:
-            error_msg = f"❌ خطا تولید قطعه {i+1}: {type(e).__name__} - {e}"
-            # Check if the error message from API (if any in e.args) mentions input format or similar
-            if hasattr(e, 'args') and e.args and isinstance(e.args[0], str) and ("input" in e.args[0].lower() or "parse" in e.args[0].lower()):
-                error_msg += "\n   (ممکن است خطا به دلیل فرمت پرامپت سبک الحاق شده به متن باشد)"
-
-            if "API_KEY_INVALID" in str(e): error_msg += "\n🔑 کلید API نامعتبر."
-            elif "permission" in str(e).lower() or "403" in str(e): error_msg += f"\n🚫 عدم دسترسی به {model_name_ui}."
-            elif "429" in str(e) or "quota" in str(e).lower(): error_msg += f"\n🐢 محدودیت Quota."
-            elif "DeadlineExceeded" in str(e) or "504" in str(e): error_msg += f"\n⏱️ Timeout."
-            logs = log_message(error_msg, logs)
-            # logs = log_message(traceback.format_exc(), logs) # DEBUG
-            continue
-
-        if i < len(text_chunks) - 1 and sleep_between_requests_ui > 0:
-            logs = log_message(f"⏱️ انتظار {sleep_between_requests_ui} ثانیه...", logs)
-            time.sleep(sleep_between_requests_ui)
+            current_log.append(f"❌ خطا در تولید قطعه {i+1}: {e}")
+            # Attempt to get more details from the error if it's a GenAI specific one
+            if hasattr(e, 'message'):
+                current_log.append(f"   جزئیات خطا: {e.message}")
+            if "API key not valid" in str(e):
+                 current_log.append("   🔑 به نظر می‌رسد کلید API نامعتبر است. لطفاً آن را در بخش Secrets بررسی کنید.")
+
+        log_messages.extend(current_log)
 
+        if i < total_chunks - 1:
+            log_messages.append(f"⏱️ انتظار {sleep_between_requests} ثانیه...")
+            time.sleep(float(sleep_between_requests))
+    
     if not generated_files:
-        return log_message("❌ هیچ فایل صوتی تولید نشد!", logs), None, None, gr.update(visible=False)
+        log_messages.append("\n❌ هیچ فایل صوتی تولید نشد!")
+        return None, None, "\n".join(log_messages)
 
-    logs = log_message(f"\n🎉 {len(generated_files)} فایل صوتی تولید شد!", logs)
-    final_audio_path, zip_file_path, zip_visible = None, None, False
+    log_messages.append(f"\n🎉 {len(generated_files)} فایل صوتی با موفقیت تولید شد!")
 
-    if merge_audio_files_ui and len(generated_files) > 1:
-        if not PYDUB_AVAILABLE:
-            logs = log_message("⚠️ pydub نیست. ارائه ZIP.", logs)
-            zip_file_path, logs = create_zip_file(generated_files, f"{output_filename_base_ui}_all", log_message, logs)
-            if zip_file_path: zip_visible = True
-            if generated_files: final_audio_path = generated_files[0]
+    final_audio_output_path = None
+    zip_file_output_path = None
+
+    if merge_audio_files and len(generated_files) > 1:
+        merged_filename_path = os.path.join("outputs", f"{output_filename_base}_merged.wav")
+        merged_path, merge_log = merge_audio_files_func(generated_files, merged_filename_path)
+        log_messages.append(merge_log)
+        if merged_path:
+            final_audio_output_path = merged_path
+            log_messages.append(f"🎵 فایل نهایی ادغام شده: {os.path.basename(final_audio_output_path)}")
+            if delete_partial_files:
+                log_messages.append("🗑️ حذف فایل‌های جزئی فعال است...")
+                files_to_remove = [f for f in generated_files if f != final_audio_output_path]
+                cleanup_temp_files(files_to_remove)
         else:
-            final_audio_path, logs = merge_audio_files_func(generated_files, f"{output_filename_base_ui}_merged.wav", log_message, logs)
-            if final_audio_path:
-                logs = log_message(f"🎵 ادغام شده: {final_audio_path}", logs)
-                if delete_partial_files_ui:
-                    for fp_del in generated_files:
-                        if fp_del != final_audio_path:
-                            try: os.remove(fp_del); logs = log_message(f"🗑️ حذف: {fp_del}", logs)
-                            except Exception as e_del: logs = log_message(f"⚠️ خطا حذف {fp_del}: {e_del}", logs)
-            else:
-                logs = log_message("⚠️ ادغام ناموفق. ارائه ZIP.", logs)
-                zip_file_path, logs = create_zip_file(generated_files, f"{output_filename_base_ui}_all", log_message, logs)
-                if zip_file_path: zip_visible = True
-                if generated_files: final_audio_path = generated_files[0]
+            log_messages.append("⚠️ ادغام ممکن نبود یا موفقیت آمیز نبود. فایل‌های جداگانه در صورت وجود حفظ شدند.")
+            # If merge fails, offer zip of parts
+            zip_path, zip_log = create_zip_file(generated_files, f"{output_filename_base}_all_parts")
+            log_messages.append(zip_log)
+            zip_file_output_path = zip_path
+
     elif len(generated_files) == 1:
-        final_audio_path = generated_files[0]
-        logs = log_message(f"🎵 فایل نهایی: {final_audio_path}", logs)
-    elif len(generated_files) > 1: # Not merging
-        zip_file_path, logs = create_zip_file(generated_files, f"{output_filename_base_ui}_all", log_message, logs)
-        if zip_file_path: zip_visible = True
-        if generated_files: final_audio_path = generated_files[0]
-
-    if not final_audio_path and not zip_file_path:
-         return log_message("🛑 خروجی صوتی نیست.", logs), None, None, gr.update(visible=False)
-    return logs, final_audio_path, zip_file_path, gr.update(visible=zip_visible)
-
-# --- Gradio UI (unchanged) ---
+        final_audio_output_path = generated_files[0]
+        log_messages.append(f"🎵 فقط یک فایل تولید شد: {os.path.basename(final_audio_output_path)}")
+    
+    else: # Multiple files but merge_audio_files is False
+        log_messages.append("📦 چون ادغام فایل‌ها انتخاب نشده، فایل‌ها به صورت ZIP ارائه می‌شوند.")
+        zip_path, zip_log = create_zip_file(generated_files, f"{output_filename_base}_all_parts")
+        log_messages.append(zip_log)
+        zip_file_output_path = zip_path
+        # Optionally, provide the first audio file for direct listening if no zip
+        if not zip_file_output_path and generated_files:
+             final_audio_output_path = generated_files[0]
+
+
+    # Determine what to return for audio and file download components
+    # Priority: Merged Audio > First Chunk Audio (if no merge/zip)
+    # Zip file is always offered if multiple parts exist and not merged, or if merge fails
+    
+    primary_audio_to_play = final_audio_output_path
+    downloadable_file = None
+
+    if final_audio_output_path: # Merged or single file
+        downloadable_file = final_audio_output_path
+    elif zip_file_output_path: # Zip of multiple parts
+        downloadable_file = zip_file_output_path
+        # If we have a zip, maybe don't auto-play anything or play the first part?
+        # For now, let's not auto-play if only zip is available.
+        # primary_audio_to_play = None
+        if generated_files: # Still offer first part for playing
+            primary_audio_to_play = generated_files[0]
+
+
+    if not primary_audio_to_play and not downloadable_file:
+         log_messages.append("🛑 هیچ خروجی صوتی یا فایل دانلودی برای ارائه وجود ندارد.")
+    
+    # Cleanup non-primary generated files if delete_partial_files is True AND merge was successful
+    # This part is tricky because `generated_files` might be what `downloadable_file` or `primary_audio_to_play` points to.
+    # The `merge_audio_files_func` already handles deletion if `delete_partial_files` is true AND merge is successful.
+    # If not merging, and delete_partial_files is true, it means we shouldn't delete anything as they are the final product (in a zip).
+    # So, the logic inside merge_audio_files_func for deletion is probably sufficient.
+
+    return primary_audio_to_play, downloadable_file, "\n".join(log_messages)
+
+
+# --- Gradio Interface ---
 css = """
-body { direction: rtl; }
-.rtl_override { direction: rtl !important; text-align: right !important; }
-.gr-input, .gr-output, .gr-radio label span { text-align: right !important; direction: rtl !important;}
-.gr-checkbox label span { text-align: right !important; direction: rtl !important; margin-right: 0.5em;}
-footer { display: none !important; }
+body { font-family: 'Tahoma', sans-serif; }
 .gradio-container { max-width: 800px !important; margin: auto !important; }
+footer { display: none !important; }
+.gr-button { background-color: #4CAF50 !important; color: white !important; }
+.gr-button:hover { background-color: #45a049 !important; }
 """
-API_KEY_FROM_ENV = os.environ.get("GEMINI_API_KEY")
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="orange"), css=css) as demo:
-    gr.Markdown(
-        """
-        <div style='text-align: center; font-family: "Arial", sans-serif;'>
-            <h1 class='rtl_override'>تبدیل متن به گفتار با Gemini API</h1>
-            <p class='rtl_override'>توجه: تاثیر "پرامپت سبک گفتار" به نحوه تفسیر مدل بستگی دارد.</p>
-        </div>
-        """
-    )
-    api_key_status_text = "⚠️ کلید API جمینای (GEMINI_API_KEY) در Secrets این اسپیس تنظیم نشده است."
-    if API_KEY_FROM_ENV: api_key_status_text = "✅ کلید API جمینای از Secrets بارگذاری شد."
-    gr.Markdown(f"<p style='text-align:center; color: {'green' if API_KEY_FROM_ENV else 'red'};' class='rtl_override'>{api_key_status_text}</p>")
+
+# استخراج نام گویندگان از کد شما
+speaker_choices = ["Achird", "Zubenelgenubi", "Vindemiatrix", "Sadachbia", "Sadaltager", "Sulafat", "Laomedeia", "Achernar", "Alnilam", "Schedar", "Gacrux", "Pulcherrima", "Umbriel", "Algieba", "Despina", "Erinome", "Algenib", "Rasalthgeti", "Orus", "Aoede", "Callirrhoe", "Autonoe", "Enceladus", "Iapetus", "Zephyr", "Puck", "Charon", "Kore", "Fenrir", "Leda"]
+model_choices = ["gemini-1.5-flash-latest", "gemini-1.5-pro-latest"] # Updated model names
+
+# لوگوی Base64 (اختیاری)
+aigolden_logo_encoded = "Q3JlYXRlIGJ5IDogYWlnb2xkZW4="
+aigolden_logo_decoded = base64.b64decode(aigolden_logo_encoded.encode()).decode()
+
+
+with gr.Blocks(css=css, theme=gr.themes.Soft(primary_hue="green", secondary_hue="lightGreen")) as demo:
+    gr.Markdown(f"<h1 style='text-align: center; color: #2E7D32;'>تبدیل متن به گفتار با Gemini گوگل</h1>")
+    gr.Markdown(f"<p style='text-align: center; color: gray;'>{aigolden_logo_decoded}</p>")
+    gr.Markdown("⚠️ **توجه:** برای استفاده از این ابزار، نیاز به یک کلید API از Google AI Studio دارید. لطفاً کلید خود را در بخش `Settings` -> `Secrets` این Space با نام `GEMINI_API_KEY` ذخیره کنید.")
+
     with gr.Row():
         with gr.Column(scale=2):
-            gr.Markdown("<h3 class='rtl_override'>تنظیمات ورودی</h3>", elem_classes="rtl_override")
-            input_method_radio = gr.Radio(["ورودی متنی", "آپلود فایل"], label="روش ورودی", value="ورودی متنی", elem_classes="rtl_override")
-            text_to_speak_area = gr.Textbox(label="متن مورد نظر", placeholder="متن خود را اینجا وارد کنید...", lines=5, visible=True, elem_classes="rtl_override")
-            uploaded_file_input = gr.File(label="فایل متنی (.txt)", file_types=[".txt"], visible=False, elem_classes="rtl_override") # type: ignore
-            speech_prompt_area = gr.Textbox(label="پرامپت سبک گفتار (اختیاری)", placeholder="مثال: شاد و پر انرژی", lines=2, elem_classes="rtl_override")
-            gr.Markdown("<h3 class='rtl_override'>تنظیمات مدل و خروجی</h3>", elem_classes="rtl_override")
-            model_name_dropdown = gr.Dropdown(MODELS_LIST, label="مدل", value=MODELS_LIST[0], elem_classes="rtl_override")
-            speaker_voice_dropdown = gr.Dropdown(SPEAKER_VOICES_LIST, label="گوینده", value="Charon", elem_classes="rtl_override")
-            temperature_slider = gr.Slider(minimum=0, maximum=2, step=0.05, value=1.0, label="دما", elem_classes="rtl_override")
-            output_filename_base_input = gr.Textbox(value="gemini_tts_output", label="نام پایه فایل خروجی", elem_classes="rtl_override")
+            gr.Markdown("### ⚙️ تنظیمات اصلی")
+            use_file_input_cb = gr.Checkbox(label="استفاده از فایل متنی ورودی (.txt)", value=False, info="اگر فعال شود، متن از فایل آپلود شده خوانده می‌شود.")
+            
+            # نمایش شرطی برای آپلود فایل یا ورود متن دستی
+            text_file_upload = gr.File(label="آپلو�� فایل متنی (.txt)", file_types=[".txt"], visible=False)
+            text_to_speak_input = gr.Textbox(lines=7, label="متن برای تبدیل به گفتار (اگر فایل آپلود نشده باشد)", placeholder="متن خود را اینجا وارد کنید...", visible=True)
+
+            def toggle_input_method(use_file):
+                return {
+                    text_file_upload: gr.update(visible=use_file),
+                    text_to_speak_input: gr.update(visible=not use_file)
+                }
+            use_file_input_cb.change(toggle_input_method, inputs=use_file_input_cb, outputs=[text_file_upload, text_to_speak_input])
+
+            speech_prompt_input = gr.Textbox(label="پرامپت راهنمای سبک گفتار (اختیاری)", placeholder="مثال: از زبان یک یوتوبر پر انرژی و حرفه ای", info="این پرامپت به مدل کمک می‌کند تا سبک و لحن گفتار را تنظیم کند.")
+            output_filename_base_input = gr.Textbox(label="نام پایه فایل خروجی (بدون پسوند)", value="gemini_tts_output", info="برای نامگذاری فایل‌های صوتی تولید شده استفاده می‌شود.")
+            
+            gr.Markdown("### 🗣️ تنظیمات مدل و گوینده")
+            model_name_dd = gr.Dropdown(model_choices, label="انتخاب مدل Gemini", value=model_choices[0], info="مدل‌های جدیدتر ممکن است کیفیت بهتری داشته باشند.")
+            speaker_voice_dd = gr.Dropdown(speaker_choices, label="انتخاب گوینده", value="Charon", info="گوینده مورد نظر را برای تولید صدا انتخاب کنید.")
+            temperature_slider = gr.Slider(minimum=0.0, maximum=2.0, step=0.05, value=0.7, label="دمای مدل (Temperature)", info="مقادیر بالاتر منجر به خروجی خلاقانه‌تر و متنوع‌تر می‌شود، مقادیر پایین‌تر خروجی قابل پیش‌بینی‌تری دارد.")
+
         with gr.Column(scale=1):
-            gr.Markdown("<h3 class='rtl_override'>تنظیمات پیشرفته</h3>", elem_classes="rtl_override")
-            max_chunk_size_slider = gr.Slider(minimum=2000, maximum=4000, step=100, value=3800, label="حداکثر کاراکتر در قطعه", elem_classes="rtl_override")
-            sleep_between_requests_slider = gr.Slider(minimum=0, maximum=20, step=0.5, value=14, label="فاصله بین درخواست‌ها (ثانیه)", info="برای جلوگیری از Rate Limit (0 برای بدون تاخیر).", elem_classes="rtl_override")
-            merge_audio_files_checkbox = gr.Checkbox(value=True, label="ادغام فایل‌های صوتی", elem_classes="rtl_override")
-            pydub_warn_lbl = " (pydub نیست!)" if not PYDUB_AVAILABLE else ""
-            del_partial_lbl = f"حذف فایل‌های جزئی{pydub_warn_lbl}"
-            delete_partial_files_checkbox = gr.Checkbox(value=False, label=del_partial_lbl, interactive=PYDUB_AVAILABLE, elem_classes="rtl_override")
-    submit_button = gr.Button("🎤 تولید صدا", variant="primary", elem_id="submit_button_custom")
-    gr.Markdown("<h3 class='rtl_override'>خروجی</h3>", elem_classes="rtl_override")
-    status_output_area = gr.Textbox(label="پیام‌های وضعیت", lines=10, interactive=False, elem_classes="rtl_override")
-    with gr.Row():
-        audio_player_output = gr.Audio(label="فایل صوتی نهایی/اولین قطعه", type="filepath", elem_classes="rtl_override") # type: ignore
-        zip_file_output = gr.File(label="دانلود همه قطعات (ZIP)", type="filepath", visible=False, elem_classes="rtl_override") # type: ignore
-    def toggle_input_method_visibility(method): return (gr.update(visible=True), gr.update(visible=False)) if method == "ورودی متنی" else (gr.update(visible=False), gr.update(visible=True))
-    input_method_radio.change(fn=toggle_input_method_visibility, inputs=input_method_radio, outputs=[text_to_speak_area, uploaded_file_input])
-    def update_delete_partials_interactive(merge_checked): return gr.update(interactive=merge_checked and PYDUB_AVAILABLE)
-    merge_audio_files_checkbox.change(fn=update_delete_partials_interactive, inputs=merge_audio_files_checkbox, outputs=delete_partial_files_checkbox)
-    def trigger_generation_with_api_key(*args_from_ui):
-        hf_secret_key = os.environ.get("GEMINI_API_KEY")
-        return generate_audio_from_text_gradio(hf_secret_key, *args_from_ui)
-    submit_inputs = [input_method_radio, text_to_speak_area, uploaded_file_input, speech_prompt_area, model_name_dropdown, speaker_voice_dropdown, temperature_slider, max_chunk_size_slider, sleep_between_requests_slider, output_filename_base_input, merge_audio_files_checkbox, delete_partial_files_checkbox]
-    submit_outputs = [status_output_area, audio_player_output, zip_file_output, zip_file_output]
-    submit_button.click(fn=trigger_generation_with_api_key, inputs=submit_inputs, outputs=submit_outputs)
-    def initial_delete_partials_state(merge_init): return gr.update(interactive=PYDUB_AVAILABLE and merge_init)
-    demo.load(fn=initial_delete_partials_state, inputs=[merge_audio_files_checkbox], outputs=delete_partial_files_checkbox)
-
-demo.launch()
+            gr.Markdown("### 分割 و خروجی") # Corrected title
+            max_chunk_size_slider = gr.Slider(minimum=2000, maximum=4000, step=100, value=3800, label="حداکثر کاراکتر در هر قطعه", info="متن‌های طولانی به قطعات کوچکتر تقسیم می‌شوند.")
+            sleep_between_requests_slider = gr.Slider(minimum=5, maximum=20, step=0.5, value=12, label="فاصله زمانی بین درخواست‌ها (ثانیه)", info="برای جلوگیری از خطاهای مربوط به محدودیت تعداد درخواست به API.")
+            
+            merge_audio_files_cb = gr.Checkbox(label="ادغام فایل‌های صوتی جزئی", value=True, info="اگر متن طولانی باشد و به چند بخش تقسیم شود، فایل‌های صوتی این بخش‌ها ادغام می‌شوند.")
+            delete_partial_files_cb = gr.Checkbox(label="حذف فایل‌های جزئی پس از ادغام (در صورت انتخاب ادغام)", value=False, info="فقط در صورتی اعمال می‌شود که ادغام فایل‌ها فعال باشد.")
+
+    submit_button = gr.Button("🎧 تبدیل متن به گفتار 🎧", variant="primary")
+    
+    gr.Markdown("### 🔊 خروجی و گزارش")
+    audio_output = gr.Audio(label="فایل صوتی نهایی", type="filepath")
+    file_download_output = gr.File(label="دانلود فایل (ادغام شده یا ZIP)", type="filepath")
+    status_output = gr.Textbox(label="وضعیت و گزارش‌ها", lines=10, interactive=False)
+
+    # اتصال دکمه به تابع اصلی
+    submit_button.click(
+        generate_audio_gradio,
+        inputs=[
+            use_file_input_cb, text_file_upload, text_to_speak_input, speech_prompt_input,
+            speaker_voice_dd, output_filename_base_input, model_name_dd, temperature_slider,
+            max_chunk_size_slider, sleep_between_requests_slider, merge_audio_files_cb, delete_partial_files_cb
+        ],
+        outputs=[audio_output, file_download_output, status_output]
+    )
+
+    gr.Markdown("---")
+    gr.Markdown("ℹ️ **نکات مهم:**")
+    gr.Markdown("- **کلید API:** مطمئن شوید که کلید API جمینای شما معتبر است و در بخش Secrets این Space به درستی تنظیم شده است.")
+    gr.Markdown("- **محدودیت‌های API:** گوگل ممکن است محدودیت‌هایی برای تعداد درخواست‌ها در دقیقه اعمال کند. اگر با خطا مواجه شدید، کمی صبر کنید و دوباره تلاش کنید یا فاصله زمانی بین درخواست‌ها را افزایش دهید.")
+    gr.Markdown("- **فایل‌های حجیم:** پردازش متن‌های بسیار طولانی ممکن است زمان‌بر باشد و به دلیل محدودیت‌های منابع در Spaces با مشکل مواجه شود.")
+    gr.Markdown("- **پاکسازی:** فایل‌های تولید شده در هر اجرا در پوشه `outputs` در سرور ذخیره می‌شوند. برای جلوگیری از پر شدن فضا، بهتر است فایل‌ها را پس از دانلود، از بخش Files and versions اسپیس خود مدیریت کنید یا از قابلیت حذف فایل‌های جزئی استفاده کنید.")
+
+
+if __name__ == "__main__":
+    # ایجاد پوشه outputs اگر وجود ندارد (برای اجرای محلی)
+    if not os.path.exists("outputs"):
+        os.makedirs("outputs")
+    demo.launch(debug=True) # share=True برای اشتراک گذاری لینک عمومی در اجرای محلی