Update main.py

main.py

@@ -13,6 +13,11 @@ from flask_cors import CORS, cross_origin
 from firebase_admin import credentials, db, storage, auth
 import firebase_admin
 
+import logging
+import traceback
+
+
+
 # Initialize Flask app and CORS
 app = Flask(__name__)
 CORS(app)
@@ -21,6 +26,9 @@ CORS(app)
 Firebase_DB = os.getenv("Firebase_DB")
 Firebase_Storage = os.getenv("Firebase_Storage")
 
+
+LOG_FILE_PATH = "/tmp/video_gen.log"
+
 try:
     # Retrieve the JSON content from the secret
     credentials_json_string = os.environ.get("FIREBASE")
@@ -169,6 +177,16 @@ def get_user_profile():
         return jsonify({'error': str(e)}), 500
 
 
+def upload_log():
+    """Uploads the log file to Firebase Storage and returns the download URL."""
+    try:
+        log_blob_name = f"logs/{uuid.uuid4().hex}.log"
+        log_url = upload_to_storage(LOG_FILE_PATH, log_blob_name)
+        return log_url
+    except Exception as e:
+        logging.error(f"❌ ERROR: Failed to upload log file: {e}")
+        return None
+
 
 # -----------------------
 # Content
@@ -334,60 +352,64 @@ def generate_story_endpoint():
         return jsonify({'error': str(e)}), 500
 
 # ---------- Video Generation Endpoint ----------
+
+
+# Configure logging to write to a file
+logging.basicConfig(filename=LOG_FILE_PATH, level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s")
+
 @app.route('/api/video/generate', methods=['POST'])
 def generate_video_endpoint():
     try:
-        print("➡️ Received video generation request...")
-        
-        # Verify user token
+        logging.info("➡️ Received video generation request...")
+
         auth_header = request.headers.get('Authorization', '')
         if not auth_header.startswith('Bearer '):
-            print("❌ ERROR: Missing or invalid token")
-            return jsonify({'error': 'Missing or invalid token'}), 401
+            logging.error("❌ ERROR: Missing or invalid token")
+            return jsonify({'error': 'Missing or invalid token', 'log_url': upload_log()}), 401
 
         token = auth_header.split(' ')[1]
         uid = verify_token(token)
         if not uid:
-            print("❌ ERROR: Invalid or expired token")
-            return jsonify({'error': 'Invalid or expired token'}), 401
+            logging.error("❌ ERROR: Invalid or expired token")
+            return jsonify({'error': 'Invalid or expired token', 'log_url': upload_log()}), 401
 
         data = request.get_json()
         story_id = data.get('story_id')
         if not story_id:
-            print("❌ ERROR: story_id is required")
-            return jsonify({'error': 'story_id is required'}), 400
+            logging.error("❌ ERROR: story_id is required")
+            return jsonify({'error': 'story_id is required', 'log_url': upload_log()}), 400
 
-        print(f"Fetching story {story_id} from Firebase...")
+        logging.info(f"Fetching story {story_id} from Firebase...")
         story_ref = db.reference(f"stories/{story_id}")
         story_data = story_ref.get()
 
         if not story_data:
-            print("❌ ERROR: Story not found")
-            return jsonify({'error': 'Story not found'}), 404
+            logging.error("❌ ERROR: Story not found")
+            return jsonify({'error': 'Story not found', 'log_url': upload_log()}), 404
 
         sections = story_data.get("sections", [])
         if not sections:
-            print("❌ ERROR: No sections found in the story")
-            return jsonify({'error': 'No sections found in the story'}), 404
+            logging.error("❌ ERROR: No sections found in the story")
+            return jsonify({'error': 'No sections found in the story', 'log_url': upload_log()}), 404
 
         image_files = []
         audio_files = []
-        
-        print(f"Processing {len(sections)} sections...")
+
+        logging.info(f"Processing {len(sections)} sections...")
 
         for section in sections:
             image_url = section.get("image_url")
             audio_url = section.get("audio_url")
 
-            print(f"➡️ Downloading image from: {image_url}")
+            logging.info(f"➡️ Downloading image from: {image_url}")
             img_resp = requests.get(image_url)
             if img_resp.status_code == 200:
                 img = Image.open(io.BytesIO(img_resp.content))
                 image_files.append(img)
             else:
-                print(f"❌ ERROR: Failed to download image {image_url}")
+                logging.error(f"❌ ERROR: Failed to download image {image_url}")
 
-            print(f"➡️ Downloading audio from: {audio_url}")
+            logging.info(f"➡️ Downloading audio from: {audio_url}")
             aud_resp = requests.get(audio_url)
             if aud_resp.status_code == 200:
                 aud_path = f"/tmp/{uuid.uuid4().hex}.mp3"
@@ -395,66 +417,26 @@ def generate_video_endpoint():
                     f.write(aud_resp.content)
                 audio_files.append(aud_path)
             else:
-                print(f"❌ ERROR: Failed to download audio {audio_url}")
+                logging.error(f"❌ ERROR: Failed to download audio {audio_url}")
 
         if not image_files:
-            print("❌ ERROR: No valid images found")
-            return jsonify({'error': 'No images available for video generation'}), 500
+            logging.error("❌ ERROR: No valid images found")
+            return jsonify({'error': 'No images available for video generation', 'log_url': upload_log()}), 500
 
-        # Generate video
         video_output_path = f"/tmp/{uuid.uuid4().hex}.mp4"
         video_file = create_silent_video(image_files, [5.0] * len(image_files), video_output_path)
 
         if not video_file:
-            print("❌ ERROR: Video generation failed")
-            return jsonify({'error': 'Video generation failed'}), 500
+            logging.error("❌ ERROR: Video generation failed")
+            return jsonify({'error': 'Video generation failed', 'log_url': upload_log()}), 500
 
-        print(f"✅ Video generated successfully: {video_file}")
+        logging.info(f"✅ Video generated successfully: {video_file}")
 
-        return jsonify({"video_url": video_file})
+        return jsonify({"video_url": video_file, "log_url": upload_log()})
 
     except Exception as e:
-        print(f"❌ ERROR: {e}")
-        return jsonify({'error': str(e)}), 500
-
-
-# ---------- Audio Generation Endpoint ----------
-@app.route('/api/audio/generate', methods=['POST'])
-def generate_audio_edit():
-    try:
-        auth_header = request.headers.get('Authorization', '')
-        if not auth_header.startswith('Bearer '):
-            return jsonify({'error': 'Authorization header missing or malformed'}), 401
-        token = auth_header.split(' ')[1]
-        uid = verify_token(token)
-        if not uid:
-            return jsonify({'error': 'Invalid token'}), 401
-
-        # Get user data and check credits
-        user_ref = db.reference(f'users/{uid}')
-        user_data = user_ref.get()
-        if not user_data or user_data.get('credits', 0) < 1:
-            return jsonify({'error': 'Insufficient credits'}), 400
-
-        # Deduct one credit
-        new_credits = user_data.get('credits', 0) - 1
-        user_ref.update({'credits': new_credits})
-
-        # Get prompt and generate video (simulation using Gemini)
-        req_data = request.get_json()
-        prompt = req_data.get('prompt', '')
-        if not prompt:
-            return jsonify({'error': 'Prompt is required'}), 400
-
-        
-
-        return jsonify({
-            'success': True,
-            'audio': generated_audio,
-            'remaining_credits': new_credits
-        })
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
+        logging.error(f"❌ ERROR: {e}\n{traceback.format_exc()}")
+        return jsonify({'error': str(e), 'log_url': upload_log()}), 500
 
 
 #----------Image Generation Endpoint ----------