Update app.py

app.py

@@ -1,14 +1,10 @@
 import os
 import zipfile
-import shutil
 from ultralytics import YOLO
 import cv2
 from moviepy.video.io.VideoFileClip import VideoFileClip
-from fastapi import FastAPI, File, UploadFile, HTTPException
-from fastapi.responses import FileResponse
-from fastapi.staticfiles import StaticFiles
-from io import BytesIO
-import tempfile
+import gradio as gr
+from huggingface_hub import hf_hub_download
 
 # Directories for uploaded videos and output clips
 UPLOAD_FOLDER = 'uploaded_videos'
@@ -17,14 +13,12 @@ os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 os.makedirs(OUTPUT_FOLDER, exist_ok=True)
 
 # Load YOLO model
-MODEL_PATH = os.path.join(os.path.dirname(__file__), 'mlbb-ai-clipper-model', 'train_size_n', 'weights', 'best.pt')
-model = YOLO(MODEL_PATH)
+MODEL_WEIGHTS = hf_hub_download(
+    repo_id="frendyrachman/mlbb-ai-clipper",
+    filename="train_size_n/weights/best.pt"
+)
 
-# Create FastAPI instance
-app = FastAPI()
-
-# Mount a static directory to serve the output clips
-app.mount("/static", StaticFiles(directory=OUTPUT_FOLDER), name="static")
+model = YOLO(MODEL_WEIGHTS)
 
 def process_video(video_path):
     """Process the video to generate highlights"""
@@ -33,7 +27,7 @@ def process_video(video_path):
 
     cap = cv2.VideoCapture(video_path)
     if not cap.isOpened():
-        raise HTTPException(status_code=400, detail="Cannot open video file")
+        return "Error: Cannot open video file"
 
     frame_rate = cap.get(cv2.CAP_PROP_FPS)
     frame_skip = int(frame_rate * 1.5)  # Process every 1.5 seconds
@@ -93,50 +87,76 @@ def process_video(video_path):
     # Save highlights as video
     zip_path = os.path.join(OUTPUT_FOLDER, 'highlights.zip')
     clip_count = 0
+    completion_message = ""
 
-    try:
-        with zipfile.ZipFile(zip_path, 'w') as zipf:
-            for moment in highlight_moments:
-                start_time = max(moment['start'], 0)
-                end_time = min(moment['end'], VideoFileClip(video_path).duration)
+    with zipfile.ZipFile(zip_path, 'w') as zipf:
+        for moment in highlight_moments:
+            start_time = max(moment['start'], 0)
+            end_time = min(moment['end'], VideoFileClip(video_path).duration)
 
+            try:
+                clip_count += 1
                 # Create a new VideoFileClip for the segment
                 with VideoFileClip(video_path) as video_segment:
                     clip = video_segment.subclip(start_time, end_time)
                     clip_filename = os.path.join(clip_output_folder, f"highlight_{clip_count}.mp4")
                     clip.write_videofile(clip_filename, codec="libx264", audio_codec="aac")
                     zipf.write(clip_filename, arcname=f"highlight_{clip_count}.mp4")
-                    clip_count += 1
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error during video processing: {str(e)}")
+            except Exception as e:
+                print(f"Error saving clip from {start_time} to {end_time}: {e}")
 
-    return f"Rendering complete. {clip_count} highlights were generated.", zip_path
+    completion_message = f"Rendering complete. {clip_count} highlights were generated."
+    print(completion_message)
+    return completion_message, zip_path  # Return pesan dan path
 
-@app.post("/upload-video/")
-async def upload_video(file: UploadFile = File(...)):
-    """Endpoint to upload a video and generate highlights"""
+def gradio_interface(video):
+    """Interface function for Gradio"""
     try:
-        # Save uploaded file
-        video_path = os.path.join(UPLOAD_FOLDER, file.filename)
-        with open(video_path, "wb") as f:
-            f.write(await file.read())
-
-        # Process video and generate highlights
-        result_message, result_path = process_video(video_path)
+        if isinstance(video, str):
+            file_path = video
+        else:
+            file_path = os.path.join(UPLOAD_FOLDER, "uploaded_video.mp4")
+            video.save(file_path)
 
-        # Return the generated highlights zip file as a response
+        result_message, result_path = process_video(file_path)
         if result_path.endswith(".zip"):
-            return FileResponse(result_path, media_type='application/zip', filename="highlights.zip")
-
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
-
-@app.get("/")
-async def read_root():
-    """Root endpoint"""
-    return {"message": "Welcome to the Mobile Legends AI Highlights Generator API"}
+            return f"{result_message}\n\nDownload Highlights:", result_path
+        return "Error processing video"
+
+    except Exception as e:  # Handle all other exceptions
+        print(f"Error occurred: {e}")
+        return "An unexpected error occurred during processing."
+
+# Gradio Interface
+interface = gr.Interface(
+    fn=gradio_interface,
+    inputs=gr.Video(label="Upload Video (MP4/AVI/MOV/MKV)"),
+    outputs=[
+        gr.Textbox(label="Status"),
+        gr.File(label="Download Highlights ZIP")
+    ],
+    title="Mobile Legends AI Highlights Generator",
+    description=
+    """
+    Welcome to the Mobile Legends AI Highlights Generator!
+    
+    This tool uses a YOLOv8n model to analyze your gameplay video and generate highlights automatically. If you prefer a larger model, such as YOLOv8m, or want to download the model for local use, please visit the following page:
+    [https://huggingface.co/frendyrachman/mlbb-ai-clipper](https://huggingface.co/frendyrachman/mlbb-ai-clipper)
+    
+    **How to use this tool:**
+    1. Upload your gameplay video (formats supported: MP4, AVI, MOV, MKV).
+    2. Click "Submit" and wait for the processing to complete.
+    3. Once done, download the "highlight.zip" file containing your video highlights.
+    
+    **Important Notes:**
+    - This tool runs on a free Hugging Face Space with hardware specifications of 2 vCPUs and 16GB RAM.
+    - Processing time depends on the following factors:
+      - **Video duration:** Longer videos require more time.
+      - **Video resolution:** Higher resolutions take longer to process, while lower resolutions may result in reduced clip quality.
+    Thank you for using this tool! We hope it enhances your gaming experience.
+    """
+
+)
 
-# Running the app with FastAPI's Uvicorn server
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    interface.launch()