Update app.py

app.py

@@ -3,139 +3,176 @@ import gradio as gr
 import google.generativeai as genai
 import os
 import io
-from scipy.io.wavfile import write as write_wav # برای ذخیره فایل صوتی
+# از scipy.io.wavfile استفاده نمی‌کنیم اگر API مستقیم بایت‌های WAV برمی‌گرداند
+# یا اگر فرمت دیگری برمی‌گرداند و ما با روش دیگری به WAV تبدیل می‌کنیم.
+# فعلاً آن را نگه می‌داریم تا ببینیم خروجی API چیست.
+from scipy.io.wavfile import write as write_wav
+import numpy as np # برای کار با آرایه‌های صوتی اگر لازم شد
 
-# دریافت API Key از Secrets هاگینگ فیس
-# مطمئن شوید که یک Secret به نام GOOGLE_API_KEY در اسپیس خود تعریف کرده‌اید
 GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
-
 if not GOOGLE_API_KEY:
-    raise ValueError("GOOGLE_API_KEY not found in environment variables. Please set it in Hugging Face Secrets.")
-
+    raise ValueError("GOOGLE_API_KEY not found in environment variables.")
 genai.configure(api_key=GOOGLE_API_KEY)
 
-# انتخاب مدل TTS
-# گزینه ها: "gemini-2.5-flash-preview-tts" یا "gemini-2.5-pro-preview-tts"
-# برای شروع، از flash استفاده می‌کنیم
-TTS_MODEL_NAME = "gemini-2.5-flash-preview-tts" # یا "tts-1" اگر نام‌های ساده‌تر هم کار می‌کنند (باید مستندات دقیق را چک کرد)
-                                                # بر اساس مستندات جدید، نام دقیق مدل‌ها به این شکل است.
-
-# لیستی از صداهای موجود (این لیست ممکن است نیاز به بروزرسانی بر اساس مستندات دقیق مدل TTS داشته باشد)
-# این فقط یک مثال است، باید نام‌های دقیق voice ها را از مستندات پیدا کنید.
-# مستندات قبلی برای Live API صداهایی مانند Puck, Charon, Kore, Fenrir, Aoede, Leda, Orus, and Zephyr را ذکر کرده بود.
-# اما برای مدل‌های TTS اختصاصی، ممکن است لیست متفاوت باشد یا اصلاً نیازی به انتخاب voice نباشد و مدل خودش بهینه عمل کند.
-# فعلاً این بخش را ساده نگه می‌داریم و به مدل اجازه می‌دهیم voice را انتخاب کند.
-AVAILABLE_VOICES = ["Default"] # یا لیستی از نام‌های واقعی voice اگر دارید
-
-def generate_audio(text_to_speak, voice_selection="Default"):
-    """
-    متن را به صدا تبدیل می‌کند با استفاده از Gemini API.
-    """
+TTS_MODEL_NAME = "gemini-2.5-flash-preview-tts" # بر اساس پیام خطا، پیشوند models/ لازم است
+
+def generate_audio(text_to_speak):
     if not text_to_speak:
         raise gr.Error("لطفاً متنی را برای تبدیل به صدا وارد کنید.")
-    print(f"درخواست TTS برای متن: '{text_to_speak[:50]}...' با voice: {voice_selection}")
+    print(f"درخواست TTS برای متن: '{text_to_speak[:50]}...'")
 
     try:
-        # ایجاد مدل
-        # توجه: نحوه فراخوانی مدل TTS ممکن است با generate_content متفاوت باشد.
-        # باید مستندات دقیق را برای "Text-to-speech (TTS)" با Gemini 2.5 Flash/Pro بررسی کنیم.
-        # فرض می‌کنیم که می‌توانیم با generate_content و ارسال متن، خروجی صوتی بگیریم.
-        # این بخش احتمالاً نیاز به اصلاح بر اساس API دقیق TTS دارد.
-
-        # بر اساس مستندات قیمت‌گذاری، مدل‌های TTS ورودی متن و خروجی صدا دارند.
-        # نحوه دقیق فراخوانی برای دریافت بایت‌های صوتی ممکن است به این شکل باشد:
-        model = genai.GenerativeModel(TTS_MODEL_NAME)
-
-        # برای مدل‌های TTS، "prompt" همان متنی است که می‌خواهیم به صدا تبدیل شود.
-        # ممکن است نیاز به پارامترهای خاصی در generation_config برای صدا باشد.
-        response = model.generate_content(
-            text_to_speak,
-            # generation_config=genai.types.GenerationConfig(
-            #     # پارامترهای خاص TTS در اینجا قرار می‌گیرند، اگر وجود داشته باشد
-            #     # مثلاً voice، سرعت، لحن و ...
-            #     # response_mime_type="audio/wav" or "audio/mp3" ???
-            # )
-        )
-
-        # پاسخ مدل‌های TTS معمولاً شامل بایت‌های صوتی است.
-        # باید بررسی کنیم که پاسخ در چه فرمتی است.
-        # فرض می‌کنیم پاسخ دارای یک پراپرتی audio_content یا مشابه است که بایت‌ها را دارد.
-        # این بخش کاملاً به خروجی واقعی API بستگی دارد.
-
-        # --- این بخش حدسی است و باید با مستندات API تطبیق داده شود ---
-        if hasattr(response, 'audio_content') and response.audio_content:
-            audio_bytes = response.audio_content
-        elif hasattr(response, 'candidates') and response.candidates[0].content.parts[0].inline_data:
-            # این ساختار برای inline_data در پاسخ‌های چندوجهی است
-            audio_part = response.candidates[0].content.parts[0]
-            if audio_part.inline_data.mime_type.startswith("audio/"):
-                audio_bytes = audio_part.inline_data.data
-            else:
-                raise gr.Error(f"فرمت پاسخ صوتی نامعتبر: {audio_part.inline_data.mime_type}")
-        elif hasattr(response, 'text'): # اگر به اشتباه پاسخ متنی گرفتیم
-             raise gr.Error(f"مدل پاسخ متنی برگرداند به جای صدا: {response.text}")
+        model = genai.GenerativeModel(f"models/{TTS_MODEL_NAME}") # اضافه کردن پیشوند models/
+
+        # --- اصلاح کلیدی: تنظیم صریح response_modalities ---
+        # مستندات اخیر برای Live API از response_modalities در config اصلی استفاده می‌کرد.
+        # اما برای generate_content، معمولاً در generation_config است.
+        # همچنین، پیام خطا به "combination of response modalities" اشاره دارد.
+        # SDK پایتون ممکن است به response_mime_type یا چیز مشابهی نیاز داشته باشد.
+
+        # بر اساس پیام خطا، مدل فقط AUDIO را به عنوان response modality می‌پذیرد.
+        # نحوه دقیق تنظیم این در SDK پایتون برای TTS API باید از مستندات TTS API بررسی شود.
+        # یک تلاش ممکن:
+        # response = model.generate_content(text_to_speak, request_options={"response_mime_type": "audio/wav"})
+        # یا اگر generation_config پارامتر خاصی برای این دارد.
+
+        # با توجه به پیام خطا، به نظر می‌رسد API انتظار دارد که بداند خروجی فقط AUDIO است.
+        # ممکن است نیازی به generation_config نباشد اگر مدل ذاتاً فقط صدا تولید می‌کند.
+        # اما اگر API عمومی generate_content استفاده می‌شود، باید مشخص کنیم.
+
+        # === شروع بخش مهم برای اصلاح ===
+        # تلاش برای استفاده از ساختاری که در مستندات Live API برای response_modalities دیدیم،
+        # اما اعمال آن به generate_content ممکن است نیاز به تطبیق داشته باشد.
+        # کتابخانه google-generativeai برای TTS ممکن است روش خاص خود را داشته باشد.
+        #
+        # یک فرض این است که اگر مدل فقط صدا تولید می‌کند، نیازی به تنظیم خاصی نیست
+        # و مشکل از جای دیگری است. اما پیام خطا صریحاً به response_modalities اشاره دارد.
+        #
+        # بیایید سعی کنیم generation_config را با response_mime_type تنظیم کنیم،
+        # چون این روشی رایج برای درخواست فرمت خاص خروجی در API های گوگل است.
+        # مقدار دقیق mime_type (audio/wav, audio/mpeg, audio/opus) باید از مستندات TTS API بیاید.
+        # فرض می‌کنیم WAV:
+
+        # --- تلاش 1: استفاده از generation_config با response_mime_type ---
+        # این یک حدس است و باید مستندات API را برای TTS بررسی کنید.
+        # response = model.generate_content(
+        # text_to_speak,
+        # generation_config=genai.types.GenerationConfig(
+        # response_mime_type="audio/wav" # یا "audio/mpeg" یا هر فرمتی که مدل پشتیبانی می‌کند
+        # )
+        # )
+        # اگر این کار نکرد، شاید مدل TTS یک متد خاص به جز generate_content دارد، مثلاً model.synthesize_speech()
+
+        # --- تلاش 2: ساده‌ترین حالت، با فرض اینکه مدل خودش می‌داند باید صدا تولید کند ---
+        # و مشکل از پیشوند models/ بوده.
+        # در پیام خطا آمده: "models/gemini-2.5-flash-preview-tts accepts..."
+        # پس نام مدل باید با models/ باشد.
+
+        response = model.generate_content(text_to_speak) # بدون generation_config خاص فعلاً
+
+
+        # --- پردازش پاسخ ---
+        # این بخش همچنان حدسی است و به ساختار واقعی پاسخ API بستگی دارد.
+        audio_bytes = None
+        generated_mime_type = None
+
+        if hasattr(response, 'candidates') and response.candidates and \
+           hasattr(response.candidates[0], 'content') and response.candidates[0].content and \
+           hasattr(response.candidates[0].content, 'parts') and response.candidates[0].content.parts:
+            for part in response.candidates[0].content.parts:
+                if hasattr(part, 'inline_data') and part.inline_data and \
+                   hasattr(part.inline_data, 'mime_type') and part.inline_data.mime_type.startswith("audio/"):
+                    audio_bytes = part.inline_data.data
+                    generated_mime_type = part.inline_data.mime_type
+                    print(f"داده صوتی با MIME type: {generated_mime_type} دریافت شد.")
+                    break # اولین بخش صوتی را می‌گیریم
+        
+        if audio_bytes is None and hasattr(response, 'audio_content'): # برخی API ها ممکن است این فیلد را داشته باشند
+             audio_bytes = response.audio_content
+             generated_mime_type = "audio/wav" # فرض می‌کنیم WAV است اگر mime_type مشخص نیست
+             print("داده صوتی از فیلد audio_content دریافت شد.")
+
+
+        if audio_bytes is None:
+            print("پاسخ کامل مدل (برای دیباگ):", response)
+            try:
+                # اگر پاسخ خطا بود، متن خطا را نشان بده
+                error_text = response.prompt_feedback if hasattr(response, 'prompt_feedback') else str(response)
+                raise gr.Error(f"پاسخ صوتی از مدل دریافت نشد. پاسخ مدل: {error_text}")
+            except Exception as e_resp:
+                 raise gr.Error(f"پاسخ صوتی از مدل دریافت نشد یا فرمت ناشناخته است. خطای داخلی: {e_resp}")
+
+
+        # --- ذخیره و برگرداندن فایل صوتی ---
+        # نرخ نمونه‌برداری پیش‌فرض برای اکثر مدل‌های TTS گوگل 24000 هرتز است.
+        # این را از مستندات دقیق مدل خود چک کنید.
+        sample_rate = 24000
+
+        output_filename = "output.wav" # همیشه با پسوند wav ذخیره می‌کنیم
+
+        # اگر API بایت‌های خام PCM برمی‌گرداند، باید آنها را به WAV تبدیل کنیم.
+        # فرض می‌کنیم audio_bytes بایت‌های یک فایل WAV کامل است،
+        # یا بایت‌های خام PCM که نیاز به تبدیل به WAV با هدر مناسب دارند.
+        # برای سادگی فعلاً مستقیم می‌نویسیم، اگر فرمت فایل صوتی کامل باشد.
+        if "pcm" in (generated_mime_type or "").lower():
+            # اگر PCM خام است، باید هدر WAV را اضافه کنیم
+            print("داده PCM خام دریافت شد، در حال تبدیل به WAV...")
+            # فرض می‌کنیم 16-bit mono PCM
+            audio_np = np.frombuffer(audio_bytes, dtype=np.int16)
+            wav_io = io.BytesIO()
+            write_wav(wav_io, sample_rate, audio_np)
+            wav_io.seek(0)
+            with open(output_filename, "wb") as f:
+                f.write(wav_io.read())
         else:
-            print("پاسخ کامل مدل:", response) # برای دیباگ
-            raise gr.Error("پاسخ صوتی از مدل دریافت نشد یا فرمت آن ناشناخته است.")
-        # --- پایان بخش حدسی ---
-
-        # ذخیره بایت‌های صوتی در یک فایل WAV موقت
-        # ما به نرخ نمونه‌برداری (sample rate) صدای خروجی نیاز داریم.
-        # مدل‌های TTS معمولاً با نرخ نمونه‌برداری مشخصی خروجی می‌دهند (مثلاً 24000 Hz).
-        # این مقدار باید از مستندات API گرفته شود. فرض می‌کنیم 24000 Hz است.
-        sample_rate = 24000 # هرتز - این را از مستندات API برای مدل TTS خود چک کنید!
-
-        # تبدیل بایت‌ها به فرمتی که Gradio بتواند پخش کند (فایل WAV)
-        # کتابخانه google-generativeai ممکن است مستقیماً فایل صوتی برنگرداند، بلکه بایت‌های خام PCM.
-        # یا ممکن است یک آبجکت خاص Audio برگرداند.
-        # ساده‌ترین حالت این است که API مستقیماً بایت‌های یک فایل WAV را برگرداند.
-        # اگر بایت‌های خام PCM برمی‌گرداند، باید آنها را به WAV تبدیل کنیم.
-
-        # فرض می‌کنیم audio_bytes حاوی داده‌های یک فایل WAV کامل است
-        # یا باید با استفاده از scipy.io.wavfile یا wave آن را بسازیم.
-        # اگر audio_bytes داده خام PCM16 است:
-        # import numpy as np
-        # audio_np = np.frombuffer(audio_bytes, dtype=np.int16)
-        # wav_io = io.BytesIO()
-        # write_wav(wav_io, sample_rate, audio_np)
-        # output_audio_path = wav_io # Gradio می‌تواند BytesIO را به عنوان فایل صوتی بپذیرد
-
-        # برای سادگی، فرض می‌کنیم audio_bytes بایت‌های یک فایل صوتی قابل پخش است (مثلاً WAV)
-        # و Gradio می‌تواند آن را مستقیماً به عنوان (sample_rate, np_array) یا مسیر فایل یا BytesIO بپذیرد.
-        # اگر API یک آبجکت خاص برمی‌گرداند، باید آن را مطابق مستندات پردازش کنید.
-
-        # برای اینکه Gradio بتواند پخش کند، ما به (sample_rate, numpy_array) نیاز داریم
-        # یا مسیر یک فایل. اگر بایت‌های خام PCM داریم:
-        # این بخش نیاز به کار بیشتری دارد اگر API بایت‌های خام PCM برمی‌گرداند.
-        # فعلاً فرض می‌کنیم API یک فرمت قابل قبول برای Gradio برمی‌گرداند یا ما آن را تبدیل می‌کنیم.
-
-        # ساده‌ترین راه برای تست اولیه: ذخیره بایت‌ها در فایل و برگرداندن مسیر فایل
-        output_filename = "output_audio.wav"
-        with open(output_filename, "wb") as f:
-            f.write(audio_bytes)
+            # اگر فرمت دیگری است (مثلاً خود WAV یا MP3)، مستقیم می‌نویسیم
+            print(f"داده صوتی با فرمت {generated_mime_type} دریافت شد، مستقیم ذخیره می‌شود.")
+            with open(output_filename, "wb") as f:
+                f.write(audio_bytes)
 
         print(f"فایل صوتی در {output_filename} ذخیره شد.")
-        return output_filename # Gradio می‌تواند مسیر فایل را برای Audio output بگیرد
+        return output_filename
 
+    except genai.types.BlockedPromptException as bpe:
+        print(f"درخواست توسط مدل بلاک شد: {bpe}")
+        raise gr.Error(f"محتوای شما توسط مدل پذیرفته نشد. لطفاً متن دیگری را امتحان کنید. دلیل: {bpe}")
     except Exception as e:
         print(f"خطا در تولید صدا: {e}")
-        # نمایش جزئیات بیشتر خطا برای دیباگ
         import traceback
         traceback.print_exc()
-        raise gr.Error(f"خطا در ارتباط با Gemini API یا پردازش صدا: {str(e)}")
+        # نمایش پیام خطای اصلی از API اگر موجود است
+        error_message_from_api = ""
+        if hasattr(e, 'message') and isinstance(e.message, str) and "HttpError" in e.message: # نمونه
+            try:
+                # تلاش برای استخراج جزئیات بیشتر از خطای API
+                import json
+                details_start = e.message.find('{')
+                if details_start != -1:
+                    error_details_json = e.message[details_start:]
+                    error_obj = json.loads(error_details_json.strip().replace('\n', '').replace('\\n', ''))
+                    if 'error' in error_obj and 'message' in error_obj['error']:
+                        error_message_from_api = error_obj['error']['message']
+            except:
+                pass # اگر نشد، مهم نیست
+
+        final_error_message = f"خطا در ارتباط با Gemini API یا پردازش صدا: {str(e)}"
+        if error_message_from_api:
+            final_error_message += f" | پیام API: {error_message_from_api}"
+
+        raise gr.Error(final_error_message)
+
 
-# ایجاد رابط کاربری Gradio
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    # ... (بقیه کد رابط کاربری Gradio بدون تغییر) ...
     gr.Markdown("# تبدیل متن به صدا با Gemini ♊")
     gr.Markdown("متن خود را وارد کنید تا با استفاده از مدل‌های جدید Gemini به صدا تبدیل شود.")
 
     with gr.Row():
         with gr.Column(scale=2):
             text_input = gr.Textbox(lines=5, label="متن ورودی", placeholder="متن خود را اینجا بنویسید...")
-            # voice_dropdown = gr.Dropdown(choices=AVAILABLE_VOICES, value="Default", label="انتخاب صدا (اختیاری)") # فعلاً ساده
             submit_button = gr.Button("🔊 تبدیل به صدا", variant="primary")
         with gr.Column(scale=1):
-            audio_output = gr.Audio(label="خروجی صدا", type="filepath") # یا type="numpy" اگر آرایه برمی‌گردانید
+            audio_output = gr.Audio(label="خروجی صدا", type="filepath")
 
     gr.Examples(
         examples=[
@@ -148,13 +185,15 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
 
     submit_button.click(
         fn=generate_audio,
-        inputs=[text_input], # voice_dropdown اگر فعال بود
+        inputs=[text_input],
         outputs=[audio_output],
         api_name="text_to_speech"
     )
 
     gr.Markdown("---")
-    gr.Markdown(f"مدل مورد استفاده: `{TTS_MODEL_NAME}`")
+    # نمایش نام مدل با پیشوند models/ بر اساس پیام خطا
+    gr.Markdown(f"مدل مورد استفاده: `models/{TTS_MODEL_NAME}`")
+
 
 if __name__ == "__main__":
-    demo.launch(debug=True) # debug=True برای دیدن لاگ‌های بیشتر در کنسول
+    demo.launch(debug=True)