Update app.py

app.py

@@ -1,97 +1,159 @@
 import os
+import sys
+import time
 import threading
-import queue
-import re
-import json
-import requests
 from flask import Flask, render_template, request, jsonify, Response
+import numpy as np
+import requests
+import re
+import queue
 import april_asr as april
+import json
 
-# Flask uygulaması
+# Google çeviri için farklı yaklaşım
+try:
+    from googletrans import Translator
+    GOOGLE_TRANSLATE_AVAILABLE = True
+except Exception as e:
+    print(f"Google Translate loading error: {e}")
+    GOOGLE_TRANSLATE_AVAILABLE = False
+
+try:
+    import deepl
+    DEEPL_AVAILABLE = True
+except ImportError:
+    DEEPL_AVAILABLE = False
+
+# Flask uygulamasını başlat
 app = Flask(__name__)
 
-# Global değişkenler
+# Global değişkenler ve nesneler
 live_caption_instance = None
 is_running = False
 asr_queue = queue.Queue()
-translator = None
+translator = None # Translator nesnesini global tanımla
 
-# Basit Google Translate sınıfı (HTTP GET ile)
 class SimpleGoogleTranslator:
     def __init__(self):
         self.session = requests.Session()
         self.session.headers.update({
-            'User-Agent': 'Mozilla/5.0'
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
         })
-
+        
     def translate(self, text, target_lang='tr', source_lang='en'):
         try:
             url = "https://translate.googleapis.com/translate_a/single"
-            params = {'client': 'gtx', 'sl': source_lang, 'tl': target_lang, 'dt': 't', 'q': text}
-            resp = self.session.get(url, params=params, timeout=10)
-            if resp.status_code == 200:
-                result = resp.json()
-                return ''.join([item[0] for item in result[0] if item[0]])
+            params = {
+                'client': 'gtx',
+                'sl': source_lang,
+                'tl': target_lang,
+                'dt': 't',
+                'q': text
+            }
+            response = self.session.get(url, params=params, timeout=10)
+            if response.status_code == 200:
+                result = response.json()
+                if result and len(result) > 0 and len(result[0]) > 0:
+                    translated_text = ''.join([item[0] for item in result[0] if item[0]])
+                    return translated_text
+            return None
         except Exception as e:
             print(f"Simple Google Translate error: {e}")
-        return "[Translation failed]"
+            return None
 
 class ImprovedTranslator:
     def __init__(self):
+        self.google_translator = None
         self.simple_translator = SimpleGoogleTranslator()
-
+        self.deepl_translator = None
+        
     def translate(self, text, target_lang, service="Google Translate", deepl_key=""):
+        if not text or not text.strip():
+            return ""
+            
+        try:
+            cleaned_text = self._clean_text(text)
+            
+            if service == "Google Translate":
+                return self._google_translate(cleaned_text, target_lang)
+            elif service == "DeepL" and DEEPL_AVAILABLE and deepl_key:
+                return self._deepl_translate(cleaned_text, target_lang, deepl_key)
+            else:
+                return f"[{service} not available]"
+                
+        except Exception as e:
+            return f"[Translation error: {str(e)[:50]}...]"
+    
+    def _clean_text(self, text):
         text = text.strip()
-        if not text: return ""
-        if service == "Google Translate":
-            return self.simple_translator.translate(text, target_lang)
-        elif service == "DeepL" and deepl_key:
+        text = re.sub(r'\s+', ' ', text)
+        return text
+    
+    def _google_translate(self, text, target_lang):
+        try:
+            result = self.simple_translator.translate(text, target_lang)
+            if result:
+                return result
+        except Exception as e:
+            print(f"Simple translator failed: {e}")
+        
+        if GOOGLE_TRANSLATE_AVAILABLE:
             try:
-                import deepl
-                translator = deepl.Translator(deepl_key)
-                deepl_lang_map = {
-                    'tr': 'TR', 'fr': 'FR', 'de': 'DE', 'es': 'ES',
-                    'it': 'IT', 'ru': 'RU', 'ja': 'JA', 'zh-CN': 'ZH',
-                    'pt': 'PT', 'nl': 'NL', 'ko': 'KO'
-                }
-                target = deepl_lang_map.get(target_lang, target_lang.upper())
-                result = translator.translate_text(text, target_lang=target)
-                return result.text if result else "[DeepL failed]"
+                if self.google_translator is None:
+                    self.google_translator = Translator()
+                result = self.google_translator.translate(text, dest=target_lang, src='en')
+                if result and result.text:
+                    return result.text
             except Exception as e:
-                return f"[DeepL error]"
-        else:
-            return "[Translation service not available]"
+                print(f"Googletrans failed: {e}")
+        
+        return "[Google translation failed]"
+    
+    def _deepl_translate(self, text, target_lang, deepl_key):
+        try:
+            if self.deepl_translator is None:
+                self.deepl_translator = deepl.Translator(deepl_key)
+            
+            deepl_lang_map = {
+                'tr': 'TR', 'fr': 'FR', 'de': 'DE', 'es': 'ES', 
+                'it': 'IT', 'ru': 'RU', 'ja': 'JA', 'zh-CN': 'ZH',
+                'pt': 'PT', 'nl': 'NL', 'ko': 'KO'
+            }
+            deepl_target = deepl_lang_map.get(target_lang, target_lang.upper())
+            
+            result = self.deepl_translator.translate_text(text, target_lang=deepl_target)
+            return result.text if result else "[DeepL no result]"
+            
+        except Exception as e:
+            return f"[DeepL error]"
 
-# ASR modelini başlat
 def init_asr():
+    """ASR modelini başlatır."""
     global live_caption_instance
-    if live_caption_instance is not None:
-        return
-    try:
-        model_path = "april-english-dev-01110_en.april"
-        if not os.path.exists(model_path):
-            print(f"[HATA] Model bulunamadı: {model_path}")
-            return
-
-        model = april.Model(model_path)
-
-        def asr_handler(result_type, tokens):
-            text = "".join(token.token for token in tokens).strip()
-            if not text: return
-            typ = "partial" if result_type == april.Result.PARTIAL_RECOGNITION else "final"
-            asr_queue.put({"english": text, "type": typ})
-
-        live_caption_instance = april.Session(model, asr_handler, asynchronous=True)
-        print("ASR Model başarıyla başlatıldı.")
-    except Exception as e:
-        print(f"[HATA] ASR yükleme hatası: {e}")
-        live_caption_instance = None
-
-def init_asr_thread():
-    t = threading.Thread(target=init_asr)
-    t.start()
+    if live_caption_instance is None:
+        try:
+            model_path = "april-english-dev-01110_en.april"
+            if not os.path.exists(model_path):
+                print(f"[HATA] Model dosyası bulunamadı: {model_path}")
+                return
+                
+            model = april.Model(model_path)
+            
+            def asr_handler(result_type, tokens):
+                text = "".join(token.token for token in tokens).strip()
+                if not text:
+                    return
+                if result_type == april.Result.PARTIAL_RECOGNITION:
+                    asr_queue.put({"english": text, "type": "partial"})
+                elif result_type == april.Result.FINAL_RECOGNITION:
+                    asr_queue.put({"english": text, "type": "final"})
+            
+            live_caption_instance = april.Session(model, asr_handler, asynchronous=True)
+            print("ASR Model başarıyla başlatıldı.")
+        except Exception as e:
+            print(f"[HATA] ASR Model yükleme hatası: {e}")
+            live_caption_instance = None # Hata durumunda nesneyi None yap
 
-# Routes
 @app.route('/')
 def index():
     return render_template('index.html')
@@ -100,7 +162,7 @@ def index():
 def start_stream():
     global is_running, translator
     if not is_running:
-        init_asr_thread()
+        init_asr()
         translator = ImprovedTranslator()
         is_running = True
     return jsonify({"status": "started"})
@@ -110,18 +172,21 @@ def stop_stream():
     global is_running, live_caption_instance
     if is_running:
         is_running = False
-        live_caption_instance = None
+        if live_caption_instance:
+            live_caption_instance = None
     return jsonify({"status": "stopped"})
 
 @app.route('/upload_audio', methods=['POST'])
 def upload_audio():
     audio_data = request.data
+    
     if live_caption_instance:
         try:
             live_caption_instance.feed_pcm16(audio_data)
         except Exception as e:
             print(f"[HATA] ASR feed hatası: {e}")
             return jsonify({"status": "error", "message": str(e)}), 500
+
     return '', 204
 
 @app.route('/stream_results')
@@ -129,18 +194,35 @@ def stream_results():
     target_lang = request.args.get("target_lang", "tr")
     service = request.args.get("service", "Google Translate")
     deepl_key = request.args.get("deepl_key", "")
-
+    
     def generate():
         while is_running:
             try:
                 result = asr_queue.get(timeout=0.1)
-                translated = translator.translate(result["english"], target_lang, service, deepl_key)
-                data = {"english": result["english"], "type": result["type"], "translation": translated}
-                yield f"data: {json.dumps(data)}\n\n"
+                english_text = result["english"]
+                result_type = result["type"]
+                
+                translated_text = ""
+                if result_type == "partial":
+                    translated_text = translator.translate(english_text, target_lang, "Google Translate", "")
+                elif result_type == "final":
+                    translated_text = translator.translate(english_text, target_lang, service, deepl_key)
+                    
+                response_data = {
+                    "english": english_text,
+                    "type": result_type,
+                    "translation": translated_text,
+                }
+                yield f"data: {json.dumps(response_data)}\n\n"
+                
             except queue.Empty:
                 continue
             except Exception as e:
                 print(f"SSE hatası: {e}")
                 break
-
+    
     return Response(generate(), mimetype='text/event-stream')
+
+if __name__ == '__main__':
+    init_asr()
+    app.run(host='0.0.0.0', port=5000, threaded=True)