Update app.py

app.py

@@ -1,339 +1,151 @@
+import os
 import gradio as gr
 import whisper
-import os
-import asyncio
-import edge_tts
-from transformers import pipeline
-from deep_translator import GoogleTranslator
-from docx import Document
-import tempfile
-from datetime import datetime
-import logging
-import sys
+from transformers import MarianMTModel, MarianTokenizer
+import torch
+from TTS.api import TTS
 
-# إعداد التسجيل
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler('app.log'),
-        logging.StreamHandler(sys.stdout)
-    ]
-)
-logger = logging.getLogger(__name__)
+# تهيئة النماذج
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+whisper_model = whisper.load_model("base")
 
-# قائمة اللغات المدعومة
+# قاموس للغات المدعومة
 SUPPORTED_LANGUAGES = {
-    'ar': 'العربية',
-    'en': 'English',
-    'fr': 'Français',
-    'es': 'Español',
-    'de': 'Deutsch'
+    "ar": "العربية",
+    "en": "English",
+    "fr": "Français",
+    "es": "Español"
 }
 
-# تعيين أصوات لكل لغة
-VOICE_MAPPINGS = {
-    'ar': 'ar-EG-ShakirNeural',
-    'en': 'en-US-EricNeural',
-    'fr': 'fr-FR-HenriNeural',
-    'es': 'es-ES-AlvaroNeural',
-    'de': 'de-DE-ConradNeural'
+# قاموس لنماذج الترجمة
+TRANSLATION_MODELS = {
+    "ar-en": "Helsinki-NLP/opus-mt-ar-en",
+    "en-ar": "Helsinki-NLP/opus-mt-en-ar",
+    "fr-en": "Helsinki-NLP/opus-mt-fr-en",
+    "en-fr": "Helsinki-NLP/opus-mt-en-fr",
+    "es-en": "Helsinki-NLP/opus-mt-es-en",
+    "en-es": "Helsinki-NLP/opus-mt-en-es"
 }
 
-# تحديد اللغات RTL
-RTL_LANGUAGES = ['ar']
-
-async def generate_speech(text, lang):
-    """توليد الصوت باستخدام edge-tts"""
-    try:
-        voice = VOICE_MAPPINGS.get(lang, 'en-US-EricNeural')
-        communicate = edge_tts.Communicate(text, voice)
-        
-        audio_path = tempfile.mktemp(suffix='.mp3')
-        await communicate.save(audio_path)
-        
-        # التحقق من وجود الملف وحجمه
-        if os.path.exists(audio_path) and os.path.getsize(audio_path) > 0:
-            logger.info(f"تم إنشاء ملف صوتي: {audio_path}")
-            return audio_path
-        else:
-            logger.error("فشل إنشاء ملف صوتي صالح")
-            return None
-            
-    except Exception as e:
-        logger.error(f"خطأ في توليد الصوت: {str(e)}")
-        return None
-
-def text_to_speech(text, lang, progress=gr.Progress()):
-    """واجهة لتحويل النص إلى صوت"""
-    if not text:
-        logger.warning("لم يتم تقديم نص للتحويل إلى صوت")
-        return None
-        
-    try:
-        progress(0.2, desc="جاري تجهيز الصوت...")
-        logger.info(f"بدء تحويل النص إلى صوت باللغة: {lang}")
-        
-        # تقسيم النص إلى أجزاء إذا كان طويلاً
-        max_length = 1000
-        text_parts = [text[i:i+max_length] for i in range(0, len(text), max_length)]
-        
-        # إنشاء ملف صوتي لكل جزء
-        audio_files = []
-        for i, part in enumerate(text_parts):
-            progress((i + 1) / len(text_parts), desc=f"معالجة الجزء {i+1} من {len(text_parts)}...")
-            audio_path = asyncio.run(generate_speech(part, lang))
-            if audio_path:
-                audio_files.append(audio_path)
-        
-        if not audio_files:
-            logger.error("لم يتم إنشاء أي ملفات صوتية")
-            return None
-            
-        # إذا كان هناك جزء واحد فقط
-        if len(audio_files) == 1:
-            return audio_files[0]
-            
-        # دمج الملفات الصوتية إذا كان هناك أكثر من جزء
-        from pydub import AudioSegment
-        
-        final_audio = AudioSegment.from_mp3(audio_files[0])
-        for audio_file in audio_files[1:]:
-            final_audio += AudioSegment.from_mp3(audio_file)
-        
-        final_path = tempfile.mktemp(suffix='.mp3')
-        final_audio.export(final_path, format="mp3")
-        
-        # تنظيف الملفات المؤقتة
-        for file in audio_files:
-            try:
-                os.remove(file)
-            except:
-                pass
-        
-        progress(1.0, desc="تم إنشاء الصوت بنجاح!")
-        return final_path
-            
-    except Exception as e:
-        logger.error(f"خطأ في تحويل النص إلى صوت: {str(e)}")
-        return None
-
-def create_document(original_text, translated_text, source_lang, target_lang, progress=gr.Progress()):
-    """إنشاء ملف Word يحتوي على النص الأصلي والترجمة"""
+def transcribe_audio(audio_file, source_lang):
+    """تحويل الصوت إلى نص باستخدام Whisper"""
     try:
-        progress(0, desc="جاري إنشاء المستند...")
-        doc = Document()
-        doc.add_heading('النص الأصلي والترجمة', 0)
-        
-        progress(0.3, desc="جاري إضافة المحتوى...")
-        # إضافة التاريخ والوقت
-        doc.add_paragraph(f'تم الإنشاء في: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}')
-        
-        # إضافة النص الأصلي
-        doc.add_heading(f'النص الأصلي ({SUPPORTED_LANGUAGES[source_lang]})', level=1)
-        doc.add_paragraph(original_text)
-        
-        progress(0.6, desc="جاري إضافة الترجمة...")
-        # إضافة الترجمة
-        doc.add_heading(f'الترجمة ({SUPPORTED_LANGUAGES[target_lang]})', level=1)
-        doc.add_paragraph(translated_text)
-        
-        # حفظ الملف
-        progress(0.9, desc="جاري حفظ المستند...")
-        temp_path = tempfile.mktemp(suffix='.docx')
-        doc.save(temp_path)
-        
-        progress(1.0, desc="تم إنشاء المستند بنجاح!")
-        logger.info(f"تم إنشاء مستند Word: {temp_path}")
-        return temp_path
-        
+        result = whisper_model.transcribe(audio_file, language=source_lang)
+        return result["text"]
     except Exception as e:
-        logger.error(f"خطأ في إنشاء المستند: {str(e)}")
-        return None
+        return f"خطأ في التحويل: {str(e)}"
 
-def translate_text(text, source_lang, target_lang, progress=gr.Progress()):
-    """ترجمة النص باستخدام deep-translator"""
+def translate_text(text, source_lang, target_lang):
+    """ترجمة النص بين اللغات"""
     if source_lang == target_lang:
         return text
     
+    model_key = f"{source_lang}-en" if source_lang != "en" else f"en-{target_lang}"
     try:
-        progress(0.3, desc="جاري الترجمة...")
-        logger.info(f"بدء الترجمة من {source_lang} إلى {target_lang}")
-        
-        translator = GoogleTranslator(source=source_lang, target=target_lang)
-        
-        # تقسيم النص إلى أجزاء إذا كان طويلاً
-        max_length = 5000
-        text_parts = [text[i:i+max_length] for i in range(0, len(text), max_length)]
-        
-        translated_parts = []
-        for i, part in enumerate(text_parts):
-            progress((i + 1) / len(text_parts), desc=f"ترجمة الجزء {i+1} من {len(text_parts)}...")
-            translated_part = translator.translate(part)
-            translated_parts.append(translated_part)
-        
-        translated_text = ' '.join(translated_parts)
-        progress(1.0, desc="تمت الترجمة بنجاح!")
-        
-        return translated_text
+        model_name = TRANSLATION_MODELS[model_key]
+        model = MarianMTModel.from_pretrained(model_name)
+        tokenizer = MarianTokenizer.from_pretrained(model_name)
+        
+        inputs = tokenizer(text, return_tensors="pt", padding=True)
+        translated = model.generate(**inputs)
+        result = tokenizer.decode(translated[0], skip_special_tokens=True)
+        
+        # إذا كانت اللغة المصدر ليست الإنجليزية والهدف ليس الإنجليزية
+        if source_lang != "en" and target_lang != "en":
+            # ترجمة إضافية من الإنجليزية إلى اللغة الهدف
+            model_name = TRANSLATION_MODELS[f"en-{target_lang}"]
+            model = MarianMTModel.from_pretrained(model_name)
+            tokenizer = MarianTokenizer.from_pretrained(model_name)
+            
+            inputs = tokenizer(result, return_tensors="pt", padding=True)
+            translated = model.generate(**inputs)
+            result = tokenizer.decode(translated[0], skip_special_tokens=True)
         
+        return result
     except Exception as e:
-        logger.error(f"خطأ في الترجمة: {str(e)}")
         return f"خطأ في الترجمة: {str(e)}"
 
-def process_video(video, source_lang="en", target_lang="ar", progress=gr.Progress()):
-    """معالجة الفيديو واستخراج النص وترجمته"""
-    if video is None:
-        return {
-            "error": "الرجاء رفع ملف فيديو",
-            "original": "",
-            "translated": "",
-            "document": None
-        }
-    
+def text_to_speech(text, target_lang, gender, style):
+    """تحويل النص إلى صوت"""
     try:
-        # حفظ الفيديو مؤقتاً
-        progress(0.1, desc="جاري تحميل الفيديو...")
-        temp_path = video.name
-        logger.info(f"تم استلام ملف فيديو: {temp_path}")
-        
-        # تحميل نموذج Whisper
-        progress(0.3, desc="جاري تحميل نموذج التعرف على الكلام...")
-        model = whisper.load_model("base")
-        
-        # استخراج النص
-        progress(0.5, desc="جاري استخراج النص من الفيديو...")
-        result = model.transcribe(temp_path, language=source_lang)
-        transcribed_text = result["text"]
-        logger.info("تم استخراج النص بنجاح")
+        # اختيار النموذج المناسب بناءً على اللغة والجنس
+        tts = TTS(model_name="tts_models/multilingual/multi-dataset/your_tts", progress_bar=False)
         
-        # ترجمة النص
-        progress(0.7, desc="جاري ترجمة النص...")
-        translated_text = translate_text(transcribed_text, source_lang, target_lang)
+        # تعيين معرف المتحدث والنمط
+        speaker_id = "female" if gender == "أنثى" else "male"
+        speed = 1.0 if style == "عادي" else 1.3 if style == "سريع" else 0.8
         
-        # إنشاء ملف Word
-        progress(0.9, desc="جاري إنشاء المستند...")
-        doc_path = create_document(transcribed_text, translated_text, source_lang, target_lang)
-        
-        progress(1.0, desc="تمت المعالجة بنجاح!")
-        return {
-            "error": None,
-            "original": transcribed_text,
-            "translated": translated_text,
-            "document": doc_path
-        }
+        output_path = "output.wav"
+        tts.tts_to_file(text=text, speaker=speaker_id, speed=speed, file_path=output_path)
         
+        return output_path
     except Exception as e:
-        logger.error(f"خطأ في معالجة الفيديو: {str(e)}")
-        return {
-            "error": f"حدث خطأ: {str(e)}",
-            "original": "",
-            "translated": "",
-            "document": None
-        }
+        return f"خطأ في تحويل النص إلى صوت: {str(e)}"
 
-def create_ui():
-    """إنشاء واجهة المستخدم"""
-    with gr.Blocks(theme=gr.themes.Soft(
-        primary_hue="blue",
-        secondary_hue="indigo",
-    )) as demo:
-        gr.Markdown(
-            """
-            # 🎥 منصة تحويل الفيديو إلى نص مع الترجمة
-            ### قم برفع فيديو للحصول على النص والترجمة مع إمكانية تحويل النص إلى صوت
-            """
-        )
-        
+# إنشاء واجهة Gradio
+with gr.Blocks(title="معالج الصوت والترجمة", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# معالج الصوت والترجمة متعدد اللغات")
+    
+    with gr.Tab("تحويل الصوت إلى نص"):
         with gr.Row():
-            with gr.Column(scale=2):
-                video_input = gr.File(
-                    label="📁 رفع فيديو",
-                    file_types=["video"],
-                    elem_id="video_input"
-                )
-            with gr.Column(scale=1):
-                source_lang = gr.Dropdown(
-                    choices=list(SUPPORTED_LANGUAGES.keys()),
-                    value="en",
-                    label="🗣️ لغة الفيديو الأصلية"
-                )
-                target_lang = gr.Dropdown(
-                    choices=list(SUPPORTED_LANGUAGES.keys()),
-                    value="ar",
-                    label="🌐 لغة الترجمة"
-                )
-                process_btn = gr.Button("🎯 معالجة الفيديو", variant="primary")
-        
+            audio_input = gr.Audio(type="filepath", label="الملف الصوتي")
+            source_lang = gr.Dropdown(choices=list(SUPPORTED_LANGUAGES.keys()), 
+                                    value="ar", 
+                                    label="لغة الملف الصوتي")
+        
+        transcribe_btn = gr.Button("تحويل إلى نص")
+        transcribed_text = gr.Textbox(label="النص المستخرج", lines=5)
+        
+        transcribe_btn.click(
+            fn=transcribe_audio,
+            inputs=[audio_input, source_lang],
+            outputs=transcribed_text
+        )
+    
+    with gr.Tab("ترجمة النص"):
         with gr.Row():
-            error_output = gr.Textbox(label="⚠️ الأخطاء", visible=False)
-        
-        with gr.Tabs():
-            with gr.TabItem("📝 النص الأصلي"):
-                original_text = gr.Textbox(
-                    label="النص المستخرج من الفيديو",
-                    lines=10,
-                    elem_classes=["ltr"]
-                )
-                with gr.Row():
-                    generate_original_audio = gr.Button("🔊 توليد الصوت", variant="secondary")
-                    original_audio = gr.Audio(label="الصوت", visible=True)
-            
-            with gr.TabItem("🔄 النص المترجم"):
-                translated_text = gr.Textbox(
-                    label="النص المترجم",
-                    lines=10,
-                    elem_classes=["rtl"]
-                )
-                with gr.Row():
-                    generate_translated_audio = gr.Button("🔊 توليد الصوت", variant="secondary")
-                    translated_audio = gr.Audio(label="الصوت", visible=True)
+            input_text = gr.Textbox(label="النص المراد ترجمته", lines=5)
+            translated_text = gr.Textbox(label="النص المترجم", lines=5)
         
         with gr.Row():
-            download_btn = gr.File(
-                label="📥 تحميل المستند (Word)",
-                interactive=False
-            )
-        
-        def update_ui(video, src_lang, tgt_lang):
-            result = process_video(video, src_lang, tgt_lang)
-            
-            # تحديث اتجاه النص
-            original_classes = "rtl" if src_lang in RTL_LANGUAGES else "ltr"
-            translated_classes = "rtl" if tgt_lang in RTL_LANGUAGES else "ltr"
-            
-            return {
-                error_output: gr.update(value=result["error"], visible=bool(result["error"])),
-                original_text: gr.update(value=result["original"], elem_classes=[original_classes]),
-                translated_text: gr.update(value=result["translated"], elem_classes=[translated_classes]),
-                download_btn: result["document"]
-            }
-        
-        # ربط الأحداث
-        process_btn.click(
-            fn=update_ui,
-            inputs=[video_input, source_lang, target_lang],
-            outputs=[error_output, original_text, translated_text, download_btn]
-        )
-        
-        generate_original_audio.click(
-            fn=text_to_speech,
-            inputs=[original_text, source_lang],
-            outputs=[original_audio]
+            trans_source_lang = gr.Dropdown(choices=list(SUPPORTED_LANGUAGES.keys()),
+                                          value="ar",
+                                          label="اللغة المصدر")
+            trans_target_lang = gr.Dropdown(choices=list(SUPPORTED_LANGUAGES.keys()),
+                                          value="en",
+                                          label="اللغة الهدف")
+        
+        translate_btn = gr.Button("ترجمة")
+        
+        translate_btn.click(
+            fn=translate_text,
+            inputs=[input_text, trans_source_lang, trans_target_lang],
+            outputs=translated_text
         )
+    
+    with gr.Tab("تحويل النص إلى صوت"):
+        with gr.Row():
+            tts_text = gr.Textbox(label="النص المراد تحويله إلى صوت", lines=5)
+            tts_output = gr.Audio(label="الصوت الناتج")
         
-        generate_translated_audio.click(
+        with gr.Row():
+            tts_lang = gr.Dropdown(choices=list(SUPPORTED_LANGUAGES.keys()),
+                                 value="ar",
+                                 label="لغة النص")
+            tts_gender = gr.Radio(choices=["ذكر", "أنثى"],
+                                value="ذكر",
+                                label="جنس المتحدث")
+            tts_style = gr.Radio(choices=["سريع", "عادي", "تعليق صوتي"],
+                               value="عادي",
+                               label="نمط الإلقاء")
+        
+        tts_btn = gr.Button("تحويل إلى صوت")
+        
+        tts_btn.click(
             fn=text_to_speech,
-            inputs=[translated_text, target_lang],
-            outputs=[translated_audio]
+            inputs=[tts_text, tts_lang, tts_gender, tts_style],
+            outputs=tts_output
         )
-    
-    return demo
 
-if __name__ == "__main__":
-    try:
-        logger.info("بدء تشغيل التطبيق")
-        demo = create_ui()
-        demo.launch()
-    except Exception as e:
-        logger.error(f"خطأ في تشغيل التطبيق: {str(e)}")
+# تشغيل التطبيق
+demo.launch()