Update app.py

app.py

@@ -9,7 +9,6 @@ from moviepy.editor import VideoFileClip
 import yt_dlp
 
 app = Flask(__name__)
-# Allow your GitHub frontend to talk to this backend
 CORS(app) 
 
 app.secret_key = "hugspace-backend-secret"
@@ -20,13 +19,12 @@ UPLOAD_FOLDER = os.path.join(BASE_DIR, "uploads")
 USER_FOLDERS = os.path.join(BASE_DIR, "user_files")
 ALLOWED_EXTENSIONS = {"mp4", "avi", "mov", "mkv", "webm", "flv", "3gp", "wmv"}
 
-# Ensure directories exist with write permissions
+# Ensure directories exist
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 os.makedirs(USER_FOLDERS, exist_ok=True)
 
-# In-memory progress tracking (simple for demo purposes)
-compression_progress = {}
-download_progress = {}
+# Progress tracking
+progress_store = {}
 
 def allowed_file(filename):
     return "." in filename and filename.rsplit(".", 1)[1].lower() in ALLOWED_EXTENSIONS
@@ -36,60 +34,53 @@ def get_user_folder(session_id):
     os.makedirs(user_path, exist_ok=True)
     return user_path
 
-# --- COMPRESSOR LOGIC ---
+# --- TASK: COMPRESS VIDEO ---
 def compress_video_task(input_path, output_path, quality, session_id):
     try:
-        compression_progress[session_id] = {"status": "processing", "progress": 10}
-        
+        progress_store[session_id] = {"status": "processing", "progress": 10}
         clip = VideoFileClip(input_path)
         
-        # Bitrate settings
+        # Presets
         presets = {
             "low": {"bitrate": "500k", "height": 480},
             "medium": {"bitrate": "1000k", "height": 720},
-            "high": {"bitrate": "2000k", "height": 1080},
+            "high": {"bitrate": "2500k", "height": 1080},
         }
         settings = presets.get(quality, presets["medium"])
 
-        # Resize if input is larger than target
         if clip.h > settings["height"]:
             clip = clip.resize(height=settings["height"])
 
-        # Processing... (Simplified progress for stability)
-        compression_progress[session_id]["progress"] = 50
+        progress_store[session_id]["progress"] = 30
         
         clip.write_videofile(
             output_path,
             bitrate=settings["bitrate"],
             codec="libx264",
             audio_codec="aac",
-            preset="ultrafast",  # Fast compression for free tier CPU
+            preset="ultrafast",
             logger=None
         )
         
         clip.close()
-        compression_progress[session_id] = {"status": "completed", "progress": 100}
+        progress_store[session_id] = {"status": "completed", "progress": 100}
         
-        if os.path.exists(input_path):
-            os.remove(input_path)
-
     except Exception as e:
-        compression_progress[session_id] = {"status": "error", "error": str(e)}
-        if os.path.exists(input_path):
-            os.remove(input_path)
+        progress_store[session_id] = {"status": "error", "error": str(e)}
+    finally:
+        if os.path.exists(input_path): os.remove(input_path)
 
-# --- DOWNLOADER LOGIC ---
+# --- TASK: DOWNLOAD VIDEO ---
 def download_video_task(url, output_path, session_id):
     try:
-        download_progress[session_id] = {"status": "processing", "progress": 0}
+        progress_store[session_id] = {"status": "processing", "progress": 0}
 
         def progress_hook(d):
             if d['status'] == 'downloading':
                 p = d.get('_percent_str', '0%').replace('%','')
                 try:
-                    download_progress[session_id]["progress"] = float(p)
-                except:
-                    pass
+                    progress_store[session_id]["progress"] = float(p)
+                except: pass
 
         ydl_opts = {
             'outtmpl': os.path.join(output_path, '%(title)s.%(ext)s'),
@@ -100,70 +91,123 @@ def download_video_task(url, output_path, session_id):
         with yt_dlp.YoutubeDL(ydl_opts) as ydl:
             ydl.download([url])
 
-        download_progress[session_id] = {"status": "completed", "progress": 100}
+        progress_store[session_id] = {"status": "completed", "progress": 100}
+
+    except Exception as e:
+        progress_store[session_id] = {"status": "error", "error": str(e)}
 
+# --- TASK: AUDIO EXTRACTION ---
+def extract_audio_task(input_path, output_path, session_id):
+    try:
+        progress_store[session_id] = {"status": "processing", "progress": 10}
+        clip = VideoFileClip(input_path)
+        
+        progress_store[session_id]["progress"] = 50
+        
+        # Write audio
+        clip.audio.write_audiofile(output_path, logger=None)
+        
+        clip.close()
+        progress_store[session_id] = {"status": "completed", "progress": 100}
+        
     except Exception as e:
-        download_progress[session_id] = {"status": "error", "error": str(e)}
+        progress_store[session_id] = {"status": "error", "error": str(e)}
+    finally:
+        if os.path.exists(input_path): os.remove(input_path)
+
+# --- TASK: GIF MAKER ---
+def create_gif_task(input_path, output_path, session_id):
+    try:
+        progress_store[session_id] = {"status": "processing", "progress": 10}
+        clip = VideoFileClip(input_path)
+        
+        # Optimize for Free Tier CPU (Limit resolution and FPS)
+        if clip.w > 480:
+            clip = clip.resize(width=480)
+        
+        # If video is longer than 10s, take first 10s to prevent crash
+        if clip.duration > 10:
+            clip = clip.subclip(0, 10)
+
+        progress_store[session_id]["progress"] = 40
+        
+        clip.write_gif(output_path, fps=10, logger=None)
+        
+        clip.close()
+        progress_store[session_id] = {"status": "completed", "progress": 100}
+        
+    except Exception as e:
+        progress_store[session_id] = {"status": "error", "error": str(e)}
+    finally:
+        if os.path.exists(input_path): os.remove(input_path)
 
 # --- ENDPOINTS ---
 
 @app.route('/')
-def health_check():
-    return jsonify({"status": "active", "service": "HugSpace Backend"})
+def home():
+    return jsonify({"status": "active", "service": "Fugth Video Backend"})
 
-@app.route('/upload', methods=['POST'])
-def upload_file():
+# UNIVERSAL UPLOAD HANDLER
+@app.route('/process/<task_type>', methods=['POST'])
+def process_media(task_type):
     if 'file' not in request.files:
-        return jsonify({"error": "No file part"}), 400
+        return jsonify({"error": "No file"}), 400
     
     file = request.files['file']
-    quality = request.form.get('quality', 'medium')
-    # Use provided session ID or generate one
     session_id = request.form.get('session_id', str(uuid.uuid4()))
+    quality = request.form.get('quality', 'medium')
     
     if file and allowed_file(file.filename):
         filename = secure_filename(file.filename)
-        unique_name = f"{uuid.uuid4()}_{filename}"
-        input_path = os.path.join(UPLOAD_FOLDER, unique_name)
+        input_path = os.path.join(UPLOAD_FOLDER, f"{uuid.uuid4()}_{filename}")
         file.save(input_path)
         
         user_folder = get_user_folder(session_id)
-        output_path = os.path.join(user_folder, f"compressed_{filename}")
         
-        # Start compression in background thread
-        thread = threading.Thread(target=compress_video_task, args=(input_path, output_path, quality, session_id))
+        # Dispatch Thread based on Task Type
+        if task_type == 'compress':
+            out_name = f"compressed_{filename}"
+            target = compress_video_task
+            args = (input_path, os.path.join(user_folder, out_name), quality, session_id)
+            
+        elif task_type == 'audio':
+            out_name = f"{os.path.splitext(filename)[0]}.mp3"
+            target = extract_audio_task
+            args = (input_path, os.path.join(user_folder, out_name), session_id)
+            
+        elif task_type == 'gif':
+            out_name = f"{os.path.splitext(filename)[0]}.gif"
+            target = create_gif_task
+            args = (input_path, os.path.join(user_folder, out_name), session_id)
+            
+        else:
+            return jsonify({"error": "Invalid task"}), 400
+
+        thread = threading.Thread(target=target, args=args)
         thread.start()
         
         return jsonify({"success": True, "session_id": session_id})
     
-    return jsonify({"error": "Invalid file type"}), 400
+    return jsonify({"error": "Invalid file"}), 400
 
 @app.route('/download_video', methods=['POST'])
 def start_download():
-    # Force JSON parsing even if content-type header is missing
     data = request.get_json(force=True)
     url = data.get('url')
     session_id = data.get('session_id', str(uuid.uuid4()))
     
-    if not url:
-        return jsonify({"error": "No URL provided"}), 400
-        
-    user_folder = get_user_folder(session_id)
+    if not url: return jsonify({"error": "No URL"}), 400
     
+    user_folder = get_user_folder(session_id)
     thread = threading.Thread(target=download_video_task, args=(url, user_folder, session_id))
     thread.start()
     
     return jsonify({"success": True, "session_id": session_id})
 
-@app.route('/progress/<task_type>/<session_id>', methods=['GET'])
-def get_progress(task_type, session_id):
-    if task_type == 'compression':
-        data = compression_progress.get(session_id, {"status": "waiting"})
-        return jsonify(data)
-    elif task_type == 'download':
-        data = download_progress.get(session_id, {"status": "waiting"})
-        return jsonify(data)
-    return jsonify({"error": "Invalid task"}), 400
+@app.route('/progress/<session_id>', methods=['GET'])
+def get_progress(session_id):
+    data = progress_store.get(session_id, {"status": "waiting"})
+    return jsonify(data)
 
 @app.route('/files/<session_id>', methods=['GET'])
 def list_files(session_id):
@@ -185,5 +229,4 @@ def get_file(session_id, filename):
     return jsonify({"error": "File not found"}), 404
 
 if __name__ == "__main__":
-    # Hugging Face Spaces run on port 7860
     app.run(host="0.0.0.0", port=7860)