Create app.py

app.py

@@ -0,0 +1,189 @@
+import os
+import uuid
+import threading
+import time
+from flask import Flask, request, jsonify, send_file
+from flask_cors import CORS
+from werkzeug.utils import secure_filename
+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"
+
+# Configuration
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+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
+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 = {}
+
+def allowed_file(filename):
+    return "." in filename and filename.rsplit(".", 1)[1].lower() in ALLOWED_EXTENSIONS
+
+def get_user_folder(session_id):
+    user_path = os.path.join(USER_FOLDERS, session_id)
+    os.makedirs(user_path, exist_ok=True)
+    return user_path
+
+# --- COMPRESSOR LOGIC ---
+def compress_video_task(input_path, output_path, quality, session_id):
+    try:
+        compression_progress[session_id] = {"status": "processing", "progress": 10}
+        
+        clip = VideoFileClip(input_path)
+        
+        # Bitrate settings
+        presets = {
+            "low": {"bitrate": "500k", "height": 480},
+            "medium": {"bitrate": "1000k", "height": 720},
+            "high": {"bitrate": "2000k", "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
+        
+        clip.write_videofile(
+            output_path,
+            bitrate=settings["bitrate"],
+            codec="libx264",
+            audio_codec="aac",
+            preset="ultrafast",  # Fast compression for free tier CPU
+            logger=None
+        )
+        
+        clip.close()
+        compression_progress[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)
+
+# --- DOWNLOADER LOGIC ---
+def download_video_task(url, output_path, session_id):
+    try:
+        download_progress[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
+
+        ydl_opts = {
+            'outtmpl': os.path.join(output_path, '%(title)s.%(ext)s'),
+            'format': 'best[height<=1080]',
+            'progress_hooks': [progress_hook],
+        }
+
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([url])
+
+        download_progress[session_id] = {"status": "completed", "progress": 100}
+
+    except Exception as e:
+        download_progress[session_id] = {"status": "error", "error": str(e)}
+
+# --- ENDPOINTS ---
+
+@app.route('/')
+def health_check():
+    return jsonify({"status": "active", "service": "HugSpace Backend"})
+
+@app.route('/upload', methods=['POST'])
+def upload_file():
+    if 'file' not in request.files:
+        return jsonify({"error": "No file part"}), 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()))
+    
+    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)
+        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))
+        thread.start()
+        
+        return jsonify({"success": True, "session_id": session_id})
+    
+    return jsonify({"error": "Invalid file type"}), 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)
+    
+    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('/files/<session_id>', methods=['GET'])
+def list_files(session_id):
+    user_folder = get_user_folder(session_id)
+    files = []
+    if os.path.exists(user_folder):
+        for f in os.listdir(user_folder):
+            path = os.path.join(user_folder, f)
+            size = os.path.getsize(path) / (1024 * 1024)
+            files.append({"name": f, "size": f"{size:.2f} MB"})
+    return jsonify({"files": files})
+
+@app.route('/get_file/<session_id>/<filename>', methods=['GET'])
+def get_file(session_id, filename):
+    user_folder = get_user_folder(session_id)
+    path = os.path.join(user_folder, secure_filename(filename))
+    if os.path.exists(path):
+        return send_file(path, as_attachment=True)
+    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)