Update app.py

app.py

@@ -13,7 +13,6 @@ from typing import Dict, List, Set, Optional
 from fastapi import FastAPI, BackgroundTasks, HTTPException, Form
 from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
 from huggingface_hub import HfApi, list_repo_files
 from huggingface_hub.utils import HfHubHTTPError
 
@@ -25,13 +24,13 @@ DEST_REPO_ID_RAR = os.getenv("DEST_REPO_RAR", "") # Destination for extracted RA
 
 DOWNLOAD_FOLDER = "downloads"
 EXTRACT_FOLDER = "extracted_tmp"
-VIDEO_FRAMES_EXTRACT_FOLDER = "video_frames"  # Changed to keep frames permanently
-# ZIPPED_FRAMES_FOLDER = "zipped_frames"  # No longer needed since we're not zipping
+VIDEO_FRAMES_EXTRACT_FOLDER = "video_frames_tmp"
+ZIPPED_FRAMES_FOLDER = "zipped_frames"  # This will now store files for download instead of upload
 
 DOWNLOAD_STATE_FILE = "download_progress.json"
 PROCESS_STATE_FILE = "process_progress.json"
 UPLOADED_FOLDERS_FILE = "uploaded_folders.json"  # Track uploaded folder hashes for BG2
-PROCESSED_VIDEO_COURSES_FILE = "processed_video_courses.json" # Track processed video course folders
+PROCESSED_VIDEO_COURSES_FILE = "processed_video_courses.json" # Track processed video course folders for BG3
 FAILED_FILES_LOG = "failed_files.txt"
 
 CHUNK_SIZE = 3  # Smaller chunks for Space environment
@@ -41,6 +40,7 @@ VIDEO_FRAME_FPS = 3 # Frames per second to extract from videos
 os.makedirs(DOWNLOAD_FOLDER, exist_ok=True)
 os.makedirs(EXTRACT_FOLDER, exist_ok=True)
 os.makedirs(VIDEO_FRAMES_EXTRACT_FOLDER, exist_ok=True)
+os.makedirs(ZIPPED_FRAMES_FOLDER, exist_ok=True)
 
 api = HfApi(token=HF_TOKEN)
 
@@ -227,6 +227,22 @@ def extract_frames(video_path: str, output_folder: str, fps: int) -> bool:
         log_message(f"❌ Error extracting frames from {os.path.basename(video_path)}: {e.stderr}")
         return False
 
+def zip_folder(folder_path: str, output_zip_path: str) -> bool:
+    """Zips the contents of a folder."""
+    log_message(f"📦 Compressing {folder_path} to {output_zip_path}...")
+    try:
+        with zipfile.ZipFile(output_zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for root, _, files in os.walk(folder_path):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arcname = os.path.relpath(file_path, folder_path)
+                    zipf.write(file_path, arcname)
+        log_message(f"✅ Successfully zipped {folder_path}")
+        return True
+    except Exception as e:
+        log_message(f"❌ Error zipping {folder_path}: {e}")
+        return False
+
 def upload_file_to_hf(local_path: str, path_in_repo: str, repo_id: str, max_retries: int = 5, initial_delay: int = 5) -> bool:
     """Uploads a single file to Hugging Face Hub with retry logic and exponential backoff."""
     log_message(f"⬆️ Uploading {os.path.basename(local_path)} to {repo_id}/{path_in_repo}")
@@ -256,7 +272,7 @@ def upload_file_to_hf(local_path: str, path_in_repo: str, repo_id: str, max_retr
     return False
 
 def process_video_frames_for_download(extracted_rar_folder: str, processed_video_courses_set: Set[str]) -> bool:
-    """Scans an extracted RAR folder for MP4s, extracts frames, and saves them for download (no zipping)."""
+    """Scans an extracted RAR folder for MP4s, extracts frames, zips, and saves for download."""
     video_processed_successfully = False
     
     # Use the top-level folder name of the extracted RAR as the course folder name
@@ -298,16 +314,24 @@ def process_video_frames_for_download(extracted_rar_folder: str, processed_video
 
     # Check if any frames were extracted for the entire course folder
     if frames_extracted_count == 0:
-        log_message(f"⚠️ No frames extracted for any video in {course_folder_name}.")
+        log_message(f"⚠️ No frames extracted for any video in {course_folder_name}. Skipping zipping.")
         if os.path.exists(course_video_extract_dir):
             shutil.rmtree(course_video_extract_dir)
         return False
 
-    # No zipping - just keep the frames in the folder for direct access
-    log_message(f"✅ Successfully processed video frames for {course_folder_name} - frames available for download")
-    processed_video_courses_set.add(course_folder_name) # Mark as processed
-    save_processed_video_courses(processed_video_courses_set) # Save state
-    video_processed_successfully = True
+    course_zip_path = os.path.join(ZIPPED_FRAMES_FOLDER, f"{course_folder_name}_frames.zip")
+    if zip_folder(course_video_extract_dir, course_zip_path):
+        log_message(f"✅ Successfully processed video frames and saved {course_folder_name}_frames.zip for download")
+        processed_video_courses_set.add(course_folder_name) # Mark as processed
+        save_processed_video_courses(processed_video_courses_set) # Save state
+        video_processed_successfully = True
+        
+        # Clean up the temporary extraction folder but keep the zip file for download
+        log_message(f"🧹 Cleaning up temporary video frame files for {course_folder_name}")
+        if os.path.exists(course_video_extract_dir):
+            shutil.rmtree(course_video_extract_dir)
+    else:
+        log_message(f"❌ Failed to zip video frames for {course_folder_name}")
 
     return video_processed_successfully
 
@@ -529,9 +553,6 @@ def continuous_processing(start_download_index: Optional[int] = None):
         processing_status["current_file"] = None
         log_message("🏁 Processing stopped")
 
-# Mount the video frames directory as static files for direct access
-app.mount("/frames", StaticFiles(directory=VIDEO_FRAMES_EXTRACT_FOLDER), name="frames")
-
 @app.get("/", response_class=HTMLResponse)
 async def root():
     """Serve the main HTML interface"""
@@ -564,8 +585,6 @@ async def root():
             .download-list { max-height: 300px; overflow-y: auto; }
             .download-item { display: flex; justify-content: space-between; align-items: center; padding: 10px; border-bottom: 1px solid #eee; }
             .download-item:last-child { border-bottom: none; }
-            .folder-link { color: #2196F3; text-decoration: none; }
-            .folder-link:hover { text-decoration: underline; }
         </style>
     </head>
     <body>
@@ -607,7 +626,6 @@ async def root():
                 <input type=\"number\" id=\"start-index-input\" placeholder=\"Enter start index (e.g., 0)\" value=\"0\">
                 <button onclick=\"startProcessingWithIndex()\">Start from Index</button>
             </div>
-
             <div>
                 <button class=\"button\" onclick=\"startProcessing()\" id=\"start-btn\">Start Processing (from last saved index)</button>
                 <button class=\"button stop-button\" onclick=\"stopProcessing()\" id=\"stop-btn\" disabled>Stop Processing</button>
@@ -616,8 +634,7 @@ async def root():
             </div>
             
             <div class=\"downloads-section\">
-                <h3>Available Frame Folders</h3>
-                <p>Click on folder names to browse extracted video frames directly</p>
+                <h3>Available Downloads</h3>
                 <div class=\"download-list\" id=\"download-list\">
                     <p>Loading...</p>
                 </div>
@@ -638,7 +655,6 @@ async def root():
                     alert(\"Error starting processing: \" + error.message);
                 }
             }
-
             async function startProcessingWithIndex() {
                 const index = document.getElementById(\"start-index-input\").value;
                 if (index === \"\" || isNaN(index)) {
@@ -697,23 +713,23 @@ async def root():
             
             async function refreshDownloads() {
                 try {
-                    const response = await fetch(\"/frame-folders\");
-                    const folders = await response.json();
+                    const response = await fetch(\"/downloads\");
+                    const downloads = await response.json();
                     
                     const downloadList = document.getElementById(\"download-list\");
-                    if (folders.folders.length === 0) {
-                        downloadList.innerHTML = \"<p>No frame folders available yet.</p>\";
+                    if (downloads.files.length === 0) {
+                        downloadList.innerHTML = \"<p>No downloads available yet.</p>\";
                     } else {
-                        downloadList.innerHTML = folders.folders.map(folder => 
+                        downloadList.innerHTML = downloads.files.map(file => 
                             `<div class=\"download-item\">
-                                <span>${folder.name} (${folder.video_count} videos, ${folder.frame_count} frames)</span>
-                                <a href=\"/frames/${folder.name}/\" class=\"folder-link\" target=\"_blank\">Browse Frames</a>
+                                <span>${file.name} (${file.size})</span>
+                                <a href=\"/download/${file.name}\" class=\"button download-button\" download>Download</a>
                             </div>`
                         ).join(\"\");
                     }
                 } catch (error) {
                     console.error(\"Error refreshing downloads:\", error);
-                    document.getElementById(\"download-list\").innerHTML = \"<p>Error loading frame folders.</p>\";
+                    document.getElementById(\"download-list\").innerHTML = \"<p>Error loading downloads.</p>\";
                 }
             }
             
@@ -782,43 +798,66 @@ async def get_processed_video_courses():
     processed_video_courses = load_processed_video_courses()
     return {"processed_video_course_count": len(processed_video_courses), "course_names": list(processed_video_courses)}
 
-@app.get("/frame-folders")
-async def list_frame_folders():
-    """List available frame folders with statistics"""
+@app.get("/downloads")
+async def list_downloads():
+    """List available frame downloads"""
     try:
-        if not os.path.exists(VIDEO_FRAMES_EXTRACT_FOLDER):
-            return {"folders": []}
+        if not os.path.exists(ZIPPED_FRAMES_FOLDER):
+            return {"files": []}
         
-        folders = []
-        for folder_name in os.listdir(VIDEO_FRAMES_EXTRACT_FOLDER):
-            folder_path = os.path.join(VIDEO_FRAMES_EXTRACT_FOLDER, folder_name)
-            if os.path.isdir(folder_path):
-                # Count video folders and total frames
-                video_count = 0
-                frame_count = 0
-                
-                for video_folder in os.listdir(folder_path):
-                    video_folder_path = os.path.join(folder_path, video_folder)
-                    if os.path.isdir(video_folder_path):
-                        video_count += 1
-                        # Count frames in this video folder
-                        frame_files = [f for f in os.listdir(video_folder_path) if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
-                        frame_count += len(frame_files)
+        files = []
+        for filename in os.listdir(ZIPPED_FRAMES_FOLDER):
+            if filename.endswith('.zip'):
+                file_path = os.path.join(ZIPPED_FRAMES_FOLDER, filename)
+                file_size = os.path.getsize(file_path)
+                # Convert size to human readable format
+                if file_size < 1024:
+                    size_str = f"{file_size} B"
+                elif file_size < 1024 * 1024:
+                    size_str = f"{file_size / 1024:.1f} KB"
+                elif file_size < 1024 * 1024 * 1024:
+                    size_str = f"{file_size / (1024 * 1024):.1f} MB"
+                else:
+                    size_str = f"{file_size / (1024 * 1024 * 1024):.1f} GB"
                 
-                folders.append({
-                    "name": folder_name,
-                    "video_count": video_count,
-                    "frame_count": frame_count,
-                    "path": folder_path
+                files.append({
+                    "name": filename,
+                    "size": size_str,
+                    "path": file_path
                 })
         
-        # Sort by folder name
-        folders.sort(key=lambda x: x["name"])
-        return {"folders": folders}
+        # Sort by filename
+        files.sort(key=lambda x: x["name"])
+        return {"files": files}
+    except Exception as e:
+        log_message(f"❌ Error listing downloads: {e}")
+        return {"files": [], "error": str(e)}
+
+@app.get("/download/{filename}")
+async def download_file(filename: str):
+    """Download a specific frame zip file"""
+    try:
+        # Sanitize filename to prevent directory traversal
+        safe_filename = os.path.basename(filename)
+        file_path = os.path.join(ZIPPED_FRAMES_FOLDER, safe_filename)
+        
+        if not os.path.exists(file_path):
+            raise HTTPException(status_code=404, detail="File not found")
+        
+        if not file_path.endswith('.zip'):
+            raise HTTPException(status_code=400, detail="Only zip files can be downloaded")
+        
+        log_message(f"📥 Serving download: {safe_filename}")
+        return FileResponse(
+            path=file_path,
+            filename=safe_filename,
+            media_type='application/zip'
+        )
+    except HTTPException:
+        raise
     except Exception as e:
-        log_message(f"❌ Error listing frame folders: {e}")
-        return {"folders": [], "error": str(e)}
+        log_message(f"❌ Error serving download {filename}: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
 
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)
-