Update src/main-backup.py

src/main-backup.py

@@ -1,8 +1,15 @@
+# app.py
 import display_gloss as dg
 import synonyms_preprocess as sp
 from NLP_Spacy_base_translator import NlpSpacyBaseTranslator 
-from flask import Flask, render_template, Response, request, jsonify
+from flask import Flask, render_template, Response, request, send_file
+import io
+import cv2
+import numpy as np
+import os
 import requests
+from urllib.parse import quote, unquote
+import tempfile
 
 app = Flask(__name__, static_folder='static')
 app.config['TITLE'] = 'Sign Language Translate'
@@ -11,16 +18,57 @@ nlp, dict_docs_spacy = sp.load_spacy_values()
 dataset, list_2000_tokens = dg.load_data()
 
 def translate_korean_to_english(text):
-    url = "https://translate.googleapis.com/translate_a/single"
-    params = {
-        "client": "gtx",
-        "sl": "ko",
-        "tl": "en",
-        "dt": "t",
-        "q": text
-    }
-    response = requests.get(url, params=params)
-    return response.json()[0][0][0]
+    try:
+        url = "https://translate.googleapis.com/translate_a/single"
+        params = {
+            "client": "gtx", 
+            "sl": "ko",
+            "tl": "en",
+            "dt": "t",
+            "q": text.strip()
+        }
+        response = requests.get(url, params=params)
+        if response.status_code == 200:
+            translated_text = ' '.join(item[0] for item in response.json()[0] if item[0])
+            return translated_text
+        else:
+            raise Exception(f"Translation API returned status code: {response.status_code}")
+    except Exception as e:
+        print(f"Translation error: {e}")
+        return text
+
+def generate_complete_video(gloss_list, dataset, list_2000_tokens):
+    try:
+        frames = []
+        for frame in dg.generate_video(gloss_list, dataset, list_2000_tokens):
+            frame_data = frame.split(b'\r\n\r\n')[1]
+            nparr = np.frombuffer(frame_data, np.uint8)
+            img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+            frames.append(img)
+        
+        if not frames:
+            raise Exception("No frames generated")
+
+        height, width = frames[0].shape[:2]
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        
+        with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as temp_file:
+            temp_path = temp_file.name
+            
+        out = cv2.VideoWriter(temp_path, fourcc, 25, (width, height))
+        
+        for frame in frames:
+            out.write(frame)
+        out.release()
+        
+        with open(temp_path, 'rb') as f:
+            video_bytes = f.read()
+        
+        os.remove(temp_path)
+        return video_bytes
+    except Exception as e:
+        print(f"Error generating video: {str(e)}")
+        raise
 
 @app.route('/')
 def index():
@@ -29,10 +77,16 @@ def index():
 @app.route('/translate/', methods=['POST'])
 def result():
     if request.method == 'POST':
-        korean_sentence = request.form['inputSentence']
+        input_text = request.form['inputSentence'].strip()
+        if not input_text:
+            return render_template('error.html', error="Please enter text to translate")
+        
         try:
-            english_translation = translate_korean_to_english(korean_sentence)
-            eng_to_asl_translator = NlpSpacyBaseTranslator(sentence=english_translation)
+            english_text = translate_korean_to_english(input_text)
+            if not english_text:
+                raise Exception("Translation failed")
+                
+            eng_to_asl_translator = NlpSpacyBaseTranslator(sentence=english_text)
             generated_gloss = eng_to_asl_translator.translate_to_gloss()
             
             gloss_list_lower = [gloss.lower() for gloss in generated_gloss.split() if gloss.isalnum()]
@@ -44,12 +98,12 @@ def result():
             
             return render_template('result.html',
                                 title=app.config['TITLE'],
-                                original_sentence=korean_sentence,
-                                english_translation=english_translation,
+                                original_sentence=input_text,
+                                english_translation=english_text,
                                 gloss_sentence_before_synonym=gloss_sentence_before_synonym,
                                 gloss_sentence_after_synonym=gloss_sentence_after_synonym)
         except Exception as e:
-            return render_template('error.html', error=str(e))
+            return render_template('error.html', error=f"Translation error: {str(e)}")
 
 @app.route('/video_feed')
 def video_feed():
@@ -58,5 +112,29 @@ def video_feed():
     return Response(dg.generate_video(gloss_list, dataset, list_2000_tokens), 
                    mimetype='multipart/x-mixed-replace; boundary=frame')
 
+@app.route('/download_video/<path:gloss_sentence>')
+def download_video(gloss_sentence):
+    try:
+        decoded_sentence = unquote(gloss_sentence)
+        gloss_list = decoded_sentence.split()
+        
+        if not gloss_list:
+            return "No gloss provided", 400
+            
+        video_bytes = generate_complete_video(gloss_list, dataset, list_2000_tokens)
+        
+        if not video_bytes:
+            return "Failed to generate video", 500
+            
+        return send_file(
+            io.BytesIO(video_bytes),
+            mimetype='video/mp4',
+            as_attachment=True,
+            download_name='sign_language.mp4'
+        )
+    except Exception as e:
+        print(f"Download error: {str(e)}")
+        return f"Error downloading video: {str(e)}", 500
+
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=5000, debug=True)
+    app.run(host="0.0.0.0", port=7860, debug=True)