Update server.py

server.py

@@ -108,22 +108,22 @@ def compress_video(input_path: str, output_path: str) -> Dict:
     original_size = os.path.getsize(input_path) / (1024**2)
     
     print(f"Original: {original_size:.1f} MB | Duration: {duration:.1f}s")
-    print(f"Target: ~50MB with high quality preservation")
+    print(f"Target: ~80MB with high quality preservation")
     
-    # Calculate target bitrate for ~50MB file
-    target_mb = 50
+    # Calculate target bitrate for ~80MB file
+    target_mb = 80
     target_bitrate_kbps = int((target_mb * 8 * 1024) / max(duration, 1))
     video_bitrate = max(400, min(target_bitrate_kbps, 1200))
     
     print(f"Calculated bitrate: {video_bitrate}kbps")
     
-    # H.265 encoding with aggressive compression targeting ~50MB
+    # H.265 encoding with balanced compression targeting ~80MB
     ffmpeg_cmd = [
         "ffmpeg", "-y",
         "-i", input_path,
         "-c:v", "libx265",
-        "-preset", "slow",
-        "-crf", "28",
+        "-preset", "medium",
+        "-crf", "26",
         "-b:v", f"{video_bitrate}k",
         "-maxrate", f"{int(video_bitrate * 1.2)}k",
         "-bufsize", f"{int(video_bitrate * 2)}k",
@@ -136,7 +136,7 @@ def compress_video(input_path: str, output_path: str) -> Dict:
     ]
     
     try:
-        result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True, timeout=3600)
+        result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True, timeout=14400)
         
         if result.returncode != 0:
             print(f"✗ Encoding failed with code {result.returncode}")
@@ -164,7 +164,7 @@ def compress_video(input_path: str, output_path: str) -> Dict:
             "duration_seconds": duration
         }
     except subprocess.TimeoutExpired:
-        print(f"✗ Compression timed out (>1 hour)")
+        print(f"✗ Compression timed out (>4 hours)")
         return None
     except Exception as e:
         print(f"✗ Compression error: {e}")
@@ -236,12 +236,112 @@ async def scan_and_compress_videos():
         # Load progress file
         progress = await load_progress_file()
         compressed_files = {item["path"] for item in progress.get("compressed", [])}
-        failed_files = {item["path"] for item in progress.get("failed", [])}
+        failed_files = progress.get("failed", [])
+        failed_paths = {item["path"] for item in failed_files}
         
         print(f"Current state: {len(compressed_files)} compressed, {len(failed_files)} failed")
         
         print("\n" + "="*80)
-        print("SCANNING FOR LARGE VIDEOS")
+        print("RETRYING PREVIOUSLY FAILED FILES")
+        print("="*80)
+        
+        # Retry failed files (max 2 attempts per file)
+        files_to_retry = []
+        for failed_item in failed_files:
+            retry_count = failed_item.get("retry_count", 0)
+            if retry_count < 2:
+                files_to_retry.append(failed_item)
+                print(f"  ⟳ {failed_item['file_name']} (attempt {retry_count + 1}/2)")
+            else:
+                print(f"  ✗ {failed_item['file_name']} (max retries reached)")
+        
+        # Process retry files
+        for failed_item in files_to_retry:
+            compression_state["current_video"] = failed_item["file_name"]
+            video_info = {
+                "path": failed_item["path"],
+                "movie_name": failed_item["path"].split("/")[1],
+                "file_name": failed_item["file_name"]
+            }
+            
+            try:
+                # Download
+                print(f"\nRetrying: {video_info['path']}")
+                video_path = hf_hub_download(
+                    repo_id=HF_DATASET_REPO,
+                    filename=video_info["path"],
+                    repo_type="dataset",
+                    token=HF_TOKEN,
+                    cache_dir=CACHE_DIR
+                )
+                
+                if os.path.islink(video_path):
+                    video_path = os.path.realpath(video_path)
+                
+                file_size_mb = os.path.getsize(video_path) / (1024**2)
+                print(f"✓ Downloaded: {file_size_mb:.1f} MB")
+                
+                # Compress
+                output_path = TEMP_DIR / f"{Path(video_info['file_name']).stem}_compressed.mp4"
+                compression_stats = compress_video(video_path, str(output_path))
+                
+                if not compression_stats:
+                    raise Exception("Compression failed")
+                
+                compression_state["total_compressed"] += 1
+                
+                # Upload compressed video
+                upload_filename = f"{Path(video_info['file_name']).stem}_compressed.mp4"
+                upload_path = f"{COMPRESSED_FOLDER}/{video_info['movie_name']}/{upload_filename}"
+                
+                print(f"Uploading: {upload_path}")
+                upload_file(
+                    path_or_fileobj=str(output_path),
+                    path_in_repo=upload_path,
+                    repo_id=HF_DATASET_REPO,
+                    repo_type="dataset",
+                    token=HF_TOKEN,
+                    commit_message=f"Add H.265 compressed video: {upload_filename}"
+                )
+                
+                compression_state["total_uploaded"] += 1
+                compression_state["total_space_saved_mb"] += compression_stats["saved_mb"]
+                
+                # Remove from failed list and add to compressed
+                progress["failed"] = [f for f in progress["failed"] if f["path"] != video_info["path"]]
+                progress["compressed"].append({
+                    "path": video_info["path"],
+                    "file_name": video_info["file_name"],
+                    "upload_path": upload_path,
+                    "status": "compressed_uploaded",
+                    "stats": compression_stats,
+                    "retry_success": True,
+                    "timestamp": datetime.now().isoformat()
+                })
+                
+                print(f"✓ Retry successful!")
+                
+                # Cleanup
+                try:
+                    os.remove(output_path)
+                except:
+                    pass
+                
+            except Exception as e:
+                print(f"✗ Retry failed: {e}")
+                # Increment retry count
+                for i, f in enumerate(progress["failed"]):
+                    if f["path"] == video_info["path"]:
+                        progress["failed"][i]["retry_count"] = f.get("retry_count", 0) + 1
+                        progress["failed"][i]["last_error"] = str(e)
+                        progress["failed"][i]["last_attempt"] = datetime.now().isoformat()
+                        break
+            
+            # Save progress after each retry attempt
+            await save_progress_file(progress)
+        
+        print("\n" + "="*80)
+        print("SCANNING FOR NEW LARGE VIDEOS")
         print("="*80)
         
         try:
@@ -259,7 +359,7 @@ async def scan_and_compress_videos():
             compression_state["is_polling"] = False
             return
         
-        # Find unprocessed video files
+        # Find unprocessed video files (excluding those we just retried)
         video_files = []
         for f in files:
             if f.startswith(f"{READY_VIDEOS_FOLDER}/") and f.endswith(".mp4"):
@@ -268,12 +368,14 @@ async def scan_and_compress_videos():
                     print(f"  ⊘ {f.split('/')[-1]} (already compressed file)")
                     continue
                 
-                # Skip if already handled
+                # Skip if already compressed
                 if f in compressed_files:
                     print(f"  ⊘ {f.split('/')[-1]} (already processed)")
                     continue
-                if f in failed_files:
-                    print(f"  ✗ {f.split('/')[-1]} (previously failed)")
+                
+                # Skip if it was just retried (don't retry again in this cycle)
+                if f in failed_paths:
+                    print(f"  ⊘ {f.split('/')[-1]} (queued for retry next scan)")
                     continue
                 
                 try: