Update app.py

app.py

@@ -3,19 +3,22 @@ import re
 import threading
 import uuid
 import requests
+import logging
 from flask import Flask, request, jsonify
 from urllib.parse import quote
 
-# Initialize Flask App
+# --- Logging Configuration ---
+# This will print logs to the console, which you can view in your Space's "Logs" tab.
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# --- Flask App Initialization ---
 app = Flask(__name__)
 
 # --- Secret Management ---
 # Get the base domain of your downloader service from Hugging Face secrets.
-# You must set a secret named 'YTDLP_DOMAIN' in your Space settings.
-# The value should be, for example, 'https://ytdlp.online'
 YTDLP_DOMAIN = os.environ.get("YTDLP_DOMAIN")
 
-# In-memory "database" to store task status
+# --- In-memory Task Storage ---
 tasks = {}
 tasks_lock = threading.Lock()
 
@@ -32,53 +35,64 @@ def get_format_code(quality: str) -> str:
 def process_video_task(task_id: str, video_url: str, quality: str):
     """
     This function runs in a background thread. It calls the external API,
-    processes the streaming response, extracts the download URL, and updates the task status.
+    waits for the stream to complete, then parses the full response to find the
+    download URL and updates the task status.
     """
+    app.logger.info(f"Task {task_id}: Starting for URL '{video_url}' with quality '{quality}'.")
+
     if not YTDLP_DOMAIN:
+        app.logger.error(f"Task {task_id}: Failed. YTDLP_DOMAIN secret is not set in the Space settings.")
         with tasks_lock:
             tasks[task_id]['status'] = 'error'
-            tasks[task_id]['message'] = "YTDLP_DOMAIN secret is not set in the Space settings."
+            tasks[task_id]['message'] = "Server configuration error: YTDLP_DOMAIN secret is not set."
         return
 
-    found_url = None
     try:
         format_code = get_format_code(quality)
         command = f"{video_url} -f {format_code}"
         encoded_command = quote(command)
-        
-        # The endpoint that provides the streaming response
         stream_api_url = f"{YTDLP_DOMAIN}/stream?command={encoded_command}"
 
-        # Use stream=True to handle the server-sent event stream
+        app.logger.info(f"Task {task_id}: Calling stream API: {stream_api_url}")
+        
+        # Collect the full response from the stream
+        full_response_lines = []
         with requests.get(stream_api_url, stream=True, timeout=300) as response:
             response.raise_for_status()
-            
-            # Process each line of the streaming response
             for line_bytes in response.iter_lines():
                 if line_bytes:
                     line = line_bytes.decode('utf-8')
-                    
-                    # Use regex to find the relative download link
-                    match = re.search(r'href="(/download/download/[^"]+)"', line)
-                    if match:
-                        relative_url = match.group(1)
-                        # Construct the final, absolute URL
-                        final_stream_url = f"{YTDLP_DOMAIN}{relative_url}"
-                        found_url = final_stream_url
-                        # Once found, no need to process the rest of the stream
-                        break 
+                    full_response_lines.append(line)
         
-        # After checking the whole stream, update the status
+        app.logger.info(f"Task {task_id}: Stream completed. Searching for download link in the response.")
+        
+        # Now, parse the complete response to find the link
+        found_url = None
+        for line in full_response_lines:
+            match = re.search(r'href="(/download/download/[^"]+)"', line)
+            if match:
+                relative_url = match.group(1)
+                final_stream_url = f"{YTDLP_DOMAIN}{relative_url}"
+                found_url = final_stream_url
+                app.logger.info(f"Task {task_id}: Found download link: {final_stream_url}")
+                break # Found the link, no need to keep searching
+
+        # After checking the whole response, update the task status
         with tasks_lock:
             if found_url:
                 tasks[task_id]['status'] = 'completed'
                 tasks[task_id]['result'] = found_url
+                app.logger.info(f"Task {task_id}: Marked as COMPLETED.")
             else:
-                # If the loop finished but no URL was found
                 tasks[task_id]['status'] = 'error'
-                tasks[task_id]['message'] = "Command executed, but no download link was found in the response."
+                tasks[task_id]['message'] = "Command executed, but no download link was found in the API response."
+                app.logger.warning(f"Task {task_id}: Marked as ERROR, no download link found.")
+                # Log the last few lines for debugging, in case of an error message from the service
+                app.logger.info(f"Task {task_id}: Last 5 lines of response: {full_response_lines[-5:]}")
+
 
     except requests.exceptions.RequestException as e:
+        app.logger.error(f"Task {task_id}: A request exception occurred. Error: {e}")
         with tasks_lock:
             tasks[task_id]['status'] = 'error'
             tasks[task_id]['message'] = str(e)
@@ -86,19 +100,17 @@ def process_video_task(task_id: str, video_url: str, quality: str):
 
 @app.route('/process', methods=['POST'])
 def start_processing():
-    """
-    Endpoint to start a new video processing task.
-    Accepts a JSON payload with 'video_url' and 'quality'.
-    Returns a task_id immediately.
-    """
+    """Endpoint to start a new video processing task."""
     data = request.get_json()
     if not data or 'video_url' not in data or 'quality' not in data:
         return jsonify({"error": "Missing 'video_url' or 'quality' in request body"}), 400
 
+    task_id = str(uuid.uuid4())
+    app.logger.info(f"Received new job. Assigning Task ID: {task_id}")
+
     video_url = data['video_url']
     quality = data.get('quality', 'best')
 
-    task_id = str(uuid.uuid4())
     with tasks_lock:
         tasks[task_id] = {'status': 'processing'}
 
@@ -110,23 +122,15 @@ def start_processing():
 
 @app.route('/api/<string:task_id>', methods=['GET'])
 def get_task_status(task_id: str):
-    """
-    Endpoint to check the status and result of a task.
-    Returns the task's current state. If completed, includes the final URL.
-    """
+    """Endpoint to check the status and result of a task."""
+    app.logger.info(f"Status check for Task ID: {task_id}")
     with tasks_lock:
         task = tasks.get(task_id)
 
     if task is None:
+        app.logger.warning(f"Status check for non-existent Task ID: {task_id}")
         return jsonify({'error': 'Task not found'}), 404
-
-    # If the task completed but has no 'result' key, it's an error
-    if task['status'] == 'completed' and 'result' not in task:
-        return jsonify({
-            'status': 'error',
-            'message': 'Task completed but no result URL was generated.'
-        }), 500
-
+    
     return jsonify(task)
 
 @app.route('/')
@@ -136,5 +140,6 @@ def index():
         return "<h1>Video Processing API Error</h1><p>Server is missing the YTDLP_DOMAIN secret.</p>", 500
     return "<h1>Video Processing API is running!</h1><p>Use /process and /api/&lt;task_id&gt; endpoints.</p>"
 
+# This part is for local testing. Gunicorn runs the app in your Space.
 if __name__ == '__main__':
     app.run(debug=True, host='0.0.0.0', port=int(os.environ.get("PORT", 7860)))