Update detection_api.py

detection_api.py

@@ -501,17 +501,17 @@ async def detect_video(
         file: UploadFile = File(..., description="Video file to analyze"),
         frame_skip: int = Form(5, ge=1, le=30, description="Process every Nth frame"),
         max_frames: int = Form(1000, ge=10, le=5000, description="Maximum frames to process"),
-        enable_fight_detection: bool = Form(True, description="Enable fight detection"),
-        save_processed: bool = Form(False, description="Save processed video with annotations")
+        enable_fight_detection: bool = Form(True, description="Enable fight detection")
 ):
     """
     Detect weapons (knife/dao/gun), fights, and NSFW content in videos
-
     Supports: MP4, AVI, MOV, MKV, WEBM, FLV, WMV
     Max size: 500MB
+    Note: Videos are automatically deleted after processing to save disk space
     """
     request_id = generate_request_id()
     start_time = datetime.now()
+    upload_path = None
 
     try:
         # Validate file extension
@@ -528,7 +528,6 @@ async def detect_video(
         # Get file size
         file_size = upload_path.stat().st_size
         if not validate_file_size(file_size, config.MAX_VIDEO_SIZE):
-            upload_path.unlink()  # Delete the file
             raise HTTPException(
                 status_code=400,
                 detail=f"File too large. Maximum size: {config.MAX_VIDEO_SIZE / (1024 * 1024):.1f}MB"
@@ -557,19 +556,6 @@ async def detect_video(
             "size_mb": round(file_size / (1024 * 1024), 2)
         }
 
-        # Prepare output video if requested
-        out_writer = None
-        processed_video_path = None
-        if save_processed:
-            processed_video_path = config.PROCESSED_DIR / "videos" / f"{request_id}_processed.mp4"
-            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-            out_writer = cv2.VideoWriter(
-                str(processed_video_path),
-                fourcc,
-                fps,
-                (width, height)
-            )
-
         # Process video frames
         logger.info(f"Processing video {request_id}: {total_frames} frames, skip={frame_skip}")
 
@@ -636,21 +622,12 @@ async def detect_video(
                     all_nsfw.extend(processed['nsfw'])
                     all_fights.extend(processed['fights'])
 
-                # Write annotated frame if saving video
-                if out_writer and 'annotated_image' in result:
-                    out_writer.write(result['annotated_image'])
-            elif out_writer:
-                # Write original frame if no detections
-                out_writer.write(frame)
-
             # Log progress every 100 frames
             if processed_count % 100 == 0:
                 logger.info(f"Processed {processed_count} frames...")
 
         # Release resources
         cap.release()
-        if out_writer:
-            out_writer.release()
 
         # Calculate summary
         knife_count = sum(1 for w in all_weapons if 'knife' in w.class_name.lower() or 'dao' in w.class_name.lower())
@@ -689,11 +666,6 @@ async def detect_video(
         # Calculate processing time
         processing_time = (datetime.now() - start_time).total_seconds() * 1000
 
-        # Prepare processed video URL if saved
-        processed_video_url = None
-        if save_processed and processed_video_path and processed_video_path.exists():
-            processed_video_url = f"/results/videos/{request_id}_processed.mp4"
-
         return VideoDetectionResponse(
             success=True,
             request_id=request_id,
@@ -704,7 +676,7 @@ async def detect_video(
             summary=summary,
             risk_level=risk_level,
             action_required=(summary["total_detections"] > 0),
-            processed_video_url=processed_video_url,
+            processed_video_url=None,  # Always None since we don't save processed videos
             processing_time_ms=processing_time
         )
 
@@ -718,67 +690,47 @@ async def detect_video(
             detail=f"Internal server error: {str(e)}"
         )
     finally:
-        # Cleanup uploaded file if needed
-        if upload_path.exists() and not save_processed:
+        # Always cleanup uploaded video file after processing
+        if upload_path and upload_path.exists():
             try:
                 upload_path.unlink()
-            except:
-                pass
-
-
-@app.get("/results/images/{filename}")
-async def get_processed_image(filename: str):
-    """Get processed/annotated image"""
-    file_path = config.PROCESSED_DIR / "images" / filename
-    if not file_path.exists():
-        raise HTTPException(status_code=404, detail="File not found")
-    return FileResponse(file_path)
-
-
-@app.get("/results/videos/{filename}")
-async def get_processed_video(filename: str):
-    """Get processed/annotated video"""
-    file_path = config.PROCESSED_DIR / "videos" / filename
-    if not file_path.exists():
-        raise HTTPException(status_code=404, detail="File not found")
-    return FileResponse(file_path)
-
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    if moderator:
-        status = moderator.get_model_status()
-        return {
-            "status": "healthy",
-            "models_loaded": True,
-            "model_details": status
-        }
-    else:
-        return {
-            "status": "initializing",
-            "models_loaded": False
-        }
+                logger.info(f"Cleaned up uploaded video: {upload_path}")
+            except Exception as cleanup_error:
+                logger.warning(f"Failed to cleanup uploaded video {upload_path}: {cleanup_error}")
 
 
 @app.delete("/cleanup")
 async def cleanup_old_files(hours: int = 24):
-    """Clean up old files from upload and results directories"""
+    """Clean up old files from upload and results directories (excluding videos from uploads as they are auto-deleted)"""
     try:
         from datetime import timedelta
         cutoff_time = datetime.now() - timedelta(hours=hours)
 
         deleted_count = 0
+        
+        # Clean up images from all directories
         for directory in [config.UPLOAD_DIR, config.RESULTS_DIR, config.PROCESSED_DIR]:
-            for subdir in ["images", "videos"]:
-                path = directory / subdir
-                if path.exists():
-                    for file in path.iterdir():
-                        if file.is_file():
-                            file_time = datetime.fromtimestamp(file.stat().st_mtime)
-                            if file_time < cutoff_time:
-                                file.unlink()
-                                deleted_count += 1
+            images_path = directory / "images"
+            if images_path.exists():
+                for file in images_path.iterdir():
+                    if file.is_file():
+                        file_time = datetime.fromtimestamp(file.stat().st_mtime)
+                        if file_time < cutoff_time:
+                            file.unlink()
+                            deleted_count += 1
+
+        # Clean up any remaining uploaded videos (should be rare since they're auto-deleted)
+        upload_videos_path = config.UPLOAD_DIR / "videos"
+        if upload_videos_path.exists():
+            for file in upload_videos_path.iterdir():
+                if file.is_file():
+                    file_time = datetime.fromtimestamp(file.stat().st_mtime)
+                    if file_time < cutoff_time:
+                        file.unlink()
+                        deleted_count += 1
+                        logger.info(f"Cleaned up old uploaded video: {file}")
+
+        # Note: No need to clean processed videos since we don't save them anymore
 
         return {
             "success": True,