Update app.py

app.py

@@ -2,11 +2,16 @@ from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks, Q
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 import os
-import shutil  # Add missing import
+import shutil
 import uuid
 import time
 from typing import Dict, List, Optional
 import threading
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # Import processing functions and variables
 from processing_logic import (
@@ -25,14 +30,16 @@ app = FastAPI(title="MP4 Processing API", description="API for uploading, proces
 # Configure CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Allows all origins
+    allow_origins=["*"],
     allow_credentials=True,
-    allow_methods=["*"],  # Allows all methods
-    allow_headers=["*"],  # Allows all headers
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
 # Define MP4_UPLOAD_FOLDER if not imported from processing_logic
-MP4_UPLOAD_FOLDER = os.path.join(UPLOAD_DIRECTORY, "uploads")
+MP4_UPLOAD_FOLDER = os.path.join(UPLOAD_DIRECTORY, "uploads") if 'UPLOAD_DIRECTORY' in globals() else "uploads"
+os.makedirs(MP4_UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(MP4_OUTPUT_FOLDER, exist_ok=True)
 
 processing_thread = None
 
@@ -43,6 +50,10 @@ def save_file(uploaded_file: UploadFile, save_path: str):
     with open(save_path, "wb") as f:
         shutil.copyfileobj(uploaded_file.file, f)
 
+def log_request(endpoint: str, params: dict = None):
+    """Log API requests for debugging"""
+    logger.info(f"API Request: {endpoint} - Params: {params}")
+
 # === ROUTES ===
 
 @app.get("/")
@@ -51,88 +62,149 @@ async def root():
     return {
         "message": "MP4 Processing API",
         "version": "1.0.0",
+        "status": "running",
         "endpoints": {
             "upload": "POST /upload - Upload MP4 file",
-            "download": "GET /download/{mp4_path:path} - Download MP4 file",
+            "download": "GET /download?course={course}&file={file} - Download MP4 file",
             "list": "GET /list - List uploaded files", 
             "courses": "GET /courses - List all course folders",
             "images": "GET /images/{course_folder:path} - List MP4s in course",
-            "start_processing": "POST /process/start - Start HF processing",
-            "processing_status": "GET /process/status - Get processing status",
-            "stop_processing": "POST /process/stop - Stop processing"
+            "debug": "GET /debug/structure - Debug file structure"
         }
     }
 
 @app.post("/upload/")
 async def upload_file(file: UploadFile = File(...)):
     """Uploads a file and stores it by filename inside the upload folder"""
+    log_request("upload", {"filename": file.filename})
+    
+    if not file.filename.lower().endswith('.mp4'):
+        raise HTTPException(status_code=400, detail="Only MP4 files are allowed")
+    
     save_path = os.path.join(MP4_UPLOAD_FOLDER, file.filename)
     save_file(file, save_path)
-    return {"status": "uploaded", "filename": file.filename}
+    
+    logger.info(f"File uploaded successfully: {file.filename}")
+    return {"status": "uploaded", "filename": file.filename, "size": os.path.getsize(save_path)}
 
 @app.get("/list")
 async def list_uploaded_files():
     """List uploaded MP4 files"""
+    log_request("list")
+    
     files = []
     if os.path.exists(MP4_UPLOAD_FOLDER):
         for file in os.listdir(MP4_UPLOAD_FOLDER):
             if file.lower().endswith(".mp4"):
-                files.append(file)
+                file_path = os.path.join(MP4_UPLOAD_FOLDER, file)
+                files.append({
+                    "filename": file,
+                    "size": os.path.getsize(file_path),
+                    "modified": os.path.getmtime(file_path)
+                })
+    
+    logger.info(f"Listed {len(files)} uploaded files")
     return JSONResponse(content=files)
 
-@app.get("/download/{mp4_path:path}")
-async def download_file(mp4_path: str):
+@app.get("/download")
+async def download_file(course: str = Query(..., description="Course folder name"), 
+                       file: str = Query(..., description="MP4 filename")):
     """
     Download any MP4 under processed_mp4s, including nested course folders.
-    e.g. GET /download/MDS_CGAdventure_DownloadPirate.com/1.mp4
+    Usage: GET /download?course=MDS_CGAdventure_DownloadPirate.com&file=1.mp4
     """
-    print(f"[DEBUG] Download request for: {mp4_path}")
+    log_request("download", {"course": course, "file": file})
+    
+    logger.info(f"[DOWNLOAD] Request for course: {course}, file: {file}")
     
-    # Compose the full file path
-    full_path = os.path.join(MP4_OUTPUT_FOLDER, mp4_path)
-    print(f"[DEBUG] Full path: {full_path}")
+    # Validate inputs
+    if not course or not file:
+        raise HTTPException(status_code=400, detail="Both course and file parameters are required")
+    
+    if not file.lower().endswith('.mp4'):
+        raise HTTPException(status_code=400, detail="File must be an MP4")
+    
+    # Security: Clean the inputs
+    course = course.strip().replace('..', '').replace('\\', '/')
+    file = file.strip().replace('..', '').replace('\\', '/')
+    
+    # Prevent path traversal in individual components
+    if '/' in file or '\\' in file:
+        raise HTTPException(status_code=400, detail="File parameter cannot contain path separators")
+    
+    # Construct the path
+    mp4_path = f"{course}/{file}"
+    full_path = os.path.join(MP4_OUTPUT_FOLDER, course, file)
+    
+    logger.info(f"[DOWNLOAD] Constructed path: {mp4_path}")
+    logger.info(f"[DOWNLOAD] Full system path: {full_path}")
 
-    # Security: Prevent escaping outside of MP4_OUTPUT_FOLDER
+    # Security: Prevent directory traversal
     full_path = os.path.normpath(full_path)
-    if not full_path.startswith(os.path.abspath(MP4_OUTPUT_FOLDER)):
-        print(f"[ERROR] Security violation - path outside output folder")
-        raise HTTPException(status_code=400, detail="Invalid path")
+    base_path = os.path.abspath(MP4_OUTPUT_FOLDER)
+    
+    if not full_path.startswith(base_path):
+        logger.warning(f"[SECURITY] Path traversal attempt - course: {course}, file: {file}")
+        raise HTTPException(status_code=400, detail="Invalid path - security violation")
 
-    print(f"[DEBUG] Normalized path: {full_path}")
-    print(f"[DEBUG] File exists: {os.path.exists(full_path)}")
-    print(f"[DEBUG] Is MP4: {full_path.lower().endswith('.mp4')}")
+    logger.info(f"[DOWNLOAD] Normalized path: {full_path}")
+    logger.info(f"[DOWNLOAD] File exists: {os.path.exists(full_path)}")
     
     if not os.path.exists(full_path):
-        # Try to find the file in subdirectories
-        print(f"[DEBUG] File not found at expected path, searching...")
+        logger.warning(f"[DOWNLOAD] File not found: {full_path}")
         
-        # List what's actually in the MP4_OUTPUT_FOLDER
-        if os.path.exists(MP4_OUTPUT_FOLDER):
-            print(f"[DEBUG] Contents of {MP4_OUTPUT_FOLDER}:")
-            for root, dirs, files in os.walk(MP4_OUTPUT_FOLDER):
-                for file in files:
-                    if file.lower().endswith('.mp4'):
-                        rel_path = os.path.relpath(os.path.join(root, file), MP4_OUTPUT_FOLDER)
-                        print(f"[DEBUG]   Found MP4: {rel_path}")
+        # Debug: Show what's actually in the course folder
+        course_path = os.path.join(MP4_OUTPUT_FOLDER, course)
+        logger.info(f"[DOWNLOAD] Checking course folder: {course_path}")
         
-        raise HTTPException(status_code=404, detail=f"File not found: {mp4_path}")
-    
-    if not full_path.lower().endswith(".mp4"):
-        raise HTTPException(status_code=400, detail="File is not an MP4")
+        if os.path.exists(course_path):
+            logger.info(f"[DOWNLOAD] Course folder exists, contents:")
+            try:
+                for item in os.listdir(course_path):
+                    item_path = os.path.join(course_path, item)
+                    if os.path.isfile(item_path):
+                        logger.info(f"[DOWNLOAD]   File: {item} ({os.path.getsize(item_path)} bytes)")
+                    else:
+                        logger.info(f"[DOWNLOAD]   Directory: {item}")
+            except Exception as e:
+                logger.error(f"[DOWNLOAD] Error listing course contents: {e}")
+        else:
+            logger.info(f"[DOWNLOAD] Course folder does not exist")
+            
+            # Show available courses
+            logger.info("[DOWNLOAD] Available courses:")
+            if os.path.exists(MP4_OUTPUT_FOLDER):
+                for item in os.listdir(MP4_OUTPUT_FOLDER):
+                    item_path = os.path.join(MP4_OUTPUT_FOLDER, item)
+                    if os.path.isdir(item_path):
+                        logger.info(f"[DOWNLOAD]   Course: {item}")
+        
+        raise HTTPException(
+            status_code=404, 
+            detail=f"File not found: {file} in course {course}"
+        )
 
-    print(f"[DEBUG] Serving file: {full_path}")
+    file_size = os.path.getsize(full_path)
+    logger.info(f"[DOWNLOAD] Serving file: {full_path} ({file_size} bytes)")
+    
     return FileResponse(
         path=full_path, 
-        filename=os.path.basename(full_path), 
-        media_type="video/mp4"
+        filename=file, 
+        media_type="video/mp4",
+        headers={
+            "Content-Length": str(file_size),
+            "Accept-Ranges": "bytes"
+        }
     )
 
 @app.get("/courses")
 async def list_courses():
     """List all unique course folder names based on extracted MP4 paths."""
+    log_request("courses")
+    
     course_folders = set()
     
-    print(f"[DEBUG] Scanning {MP4_OUTPUT_FOLDER} for courses")
+    logger.info(f"[COURSES] Scanning {MP4_OUTPUT_FOLDER} for courses")
 
     if os.path.exists(MP4_OUTPUT_FOLDER):
         for root, dirs, files in os.walk(MP4_OUTPUT_FOLDER):
@@ -142,29 +214,33 @@ async def list_courses():
                     course_folder = os.path.dirname(rel_path)
                     if course_folder and course_folder != ".":
                         course_folders.add(course_folder)
-                        print(f"[DEBUG] Found course: {course_folder} (from file: {rel_path})")
+                        logger.info(f"[COURSES] Found course: {course_folder} (from file: {rel_path})")
 
     courses_list = sorted(course_folders)
-    print(f"[DEBUG] Returning courses: {courses_list}")
+    logger.info(f"[COURSES] Returning {len(courses_list)} courses: {courses_list}")
     return JSONResponse(content={"courses": courses_list, "total": len(courses_list)})
 
 @app.get("/images/{course_folder:path}")
 async def list_mp4s_in_course(course_folder: str):
     """List MP4s available for a specific course folder"""
-    print(f"[DEBUG] Listing MP4s for course: {course_folder}")
+    log_request("images", {"course_folder": course_folder})
+    
+    logger.info(f"[IMAGES] Listing MP4s for course: {course_folder}")
     
     course_path = os.path.join(MP4_OUTPUT_FOLDER, course_folder)
-    print(f"[DEBUG] Course path: {course_path}")
-    print(f"[DEBUG] Path exists: {os.path.exists(course_path)}")
+    logger.info(f"[IMAGES] Course path: {course_path}")
+    logger.info(f"[IMAGES] Path exists: {os.path.exists(course_path)}")
     
     if not os.path.exists(course_path):
+        logger.warning(f"[IMAGES] Course folder not found: {course_folder}")
+        
         # List what's actually available
-        print(f"[DEBUG] Course folder not found. Available folders:")
+        logger.info("[IMAGES] Available course folders:")
         if os.path.exists(MP4_OUTPUT_FOLDER):
             for item in os.listdir(MP4_OUTPUT_FOLDER):
                 item_path = os.path.join(MP4_OUTPUT_FOLDER, item)
                 if os.path.isdir(item_path):
-                    print(f"[DEBUG]   {item}")
+                    logger.info(f"[IMAGES]   {item}")
         
         raise HTTPException(status_code=404, detail=f"Course folder not found: {course_folder}")
 
@@ -173,19 +249,24 @@ async def list_mp4s_in_course(course_folder: str):
         for file in os.listdir(course_path):
             if file.lower().endswith(".mp4"):
                 mp4s.append(file)
-                print(f"[DEBUG] Found MP4: {file}")
+                file_path = os.path.join(course_path, file)
+                file_size = os.path.getsize(file_path)
+                logger.info(f"[IMAGES] Found MP4: {file} ({file_size} bytes)")
     except Exception as e:
-        print(f"[ERROR] Failed to list files in {course_path}: {e}")
+        logger.error(f"[IMAGES] Failed to list files in {course_path}: {e}")
         raise HTTPException(status_code=500, detail="Failed to list files")
 
-    print(f"[DEBUG] Returning MP4s: {mp4s}")
+    logger.info(f"[IMAGES] Returning {len(mp4s)} MP4s: {mp4s}")
     return JSONResponse(content=mp4s)
 
-# Add debug endpoint to help troubleshoot
 @app.get("/debug/structure")
 async def debug_file_structure():
     """Debug endpoint to show the actual file structure"""
+    log_request("debug/structure")
+    
     structure = {}
+    total_files = 0
+    total_size = 0
     
     if os.path.exists(MP4_OUTPUT_FOLDER):
         for root, dirs, files in os.walk(MP4_OUTPUT_FOLDER):
@@ -193,15 +274,39 @@ async def debug_file_structure():
             if rel_root == ".":
                 rel_root = "/"
             
+            mp4_files = []
+            other_files = []
+            
+            for file in files:
+                file_path = os.path.join(root, file)
+                file_size = os.path.getsize(file_path)
+                total_size += file_size
+                
+                file_info = {
+                    "name": file,
+                    "size": file_size,
+                    "modified": os.path.getmtime(file_path)
+                }
+                
+                if file.lower().endswith('.mp4'):
+                    mp4_files.append(file_info)
+                    total_files += 1
+                else:
+                    other_files.append(file_info)
+            
             structure[rel_root] = {
                 "directories": dirs,
-                "mp4_files": [f for f in files if f.lower().endswith('.mp4')],
-                "other_files": [f for f in files if not f.lower().endswith('.mp4')]
+                "mp4_files": mp4_files,
+                "other_files": other_files
             }
     
+    logger.info(f"[DEBUG] File structure scan complete - {total_files} MP4 files, {total_size} bytes total")
+    
     return JSONResponse(content={
         "mp4_output_folder": MP4_OUTPUT_FOLDER,
         "folder_exists": os.path.exists(MP4_OUTPUT_FOLDER),
+        "total_mp4_files": total_files,
+        "total_size_bytes": total_size,
         "structure": structure
     })
 
@@ -209,8 +314,10 @@ async def debug_file_structure():
 async def startup_event():
     """Run the processing loop in the background when the API starts"""
     global processing_thread
+    logger.info("Starting up MP4 Processing API...")
+    
     if not (processing_thread and processing_thread.is_alive()):
-        # log_message("🚀 Starting RAR extraction, frame extraction, and vision analysis pipeline in background...")
+        logger.info("🚀 Starting background processing thread...")
         processing_thread = threading.Thread(target=process_hf_files_background)
         processing_thread.daemon = True
         processing_thread.start()