Update main.py

main.py

@@ -1,10 +1,5 @@
-import os
-import uuid
-import requests
-from typing import List, Optional
-from fastapi import FastAPI
-from fastapi.staticfiles import StaticFiles
-from pydantic import BaseModel
+from fastapi import FastAPI, UploadFile, File
+from fastapi.responses import FileResponse
 from moviepy.editor import (
     VideoFileClip,
     ImageClip,
@@ -13,112 +8,61 @@ from moviepy.editor import (
     CompositeVideoClip,
     ColorClip
 )
-
+import os
+import uuid
 
 app = FastAPI()
-os.makedirs("/app/output", exist_ok=True)
 
 
-# JSON Schema Models
-class Position(BaseModel):
-    x: int
-    y: int
+@app.get("/")
+async def root():
+    return {"message": "FastAPI with MoviePy is running."}
 
 
-class Track(BaseModel):
-    type: str  # video, image, text, audio
-    src: Optional[str] = None
-    value: Optional[str] = None  # For text
-    start: float
-    duration: Optional[float] = None
-    position: Optional[Position] = None
-    scale: Optional[float] = 1.0
-    color: Optional[str] = "white"
-    size: Optional[int] = 50
-    font: Optional[str] = "Arial"
+@app.post("/generate")
+async def generate_video():
+    # Output video path
+    output_path = f"/app/generated_{uuid.uuid4().hex[:6]}.mp4"
 
+    # Create a colored background clip
+    bg_clip = ColorClip(size=(1280, 720), color=(10, 10, 10), duration=5)
 
-class Canvas(BaseModel):
-    width: int
-    height: int
-    duration: float
+    # Create a text clip
+    txt_clip = TextClip("This is MoviePy via FastAPI", fontsize=70, color='white', font="DejaVu-Serif")
+    txt_clip = txt_clip.set_duration(5)
+    txt_clip = txt_clip.set_position(("center", "center"))
 
+    # Composite the video
+    final_clip = CompositeVideoClip([bg_clip, txt_clip])
 
-class VideoInstruction(BaseModel):
-    canvas: Canvas
-    tracks: List[Track]
+    # Write video to file
+    final_clip.write_videofile(output_path, fps=24, codec="libx264")
 
+    return FileResponse(output_path, media_type="video/mp4", filename=os.path.basename(output_path))
 
-# Serve generated videos via static file mount
-app.mount("/videos", StaticFiles(directory="output"), name="videos")
 
+@app.post("/combine")
+async def combine_video_audio(video_file: UploadFile = File(...), audio_file: UploadFile = File(...)):
+    video_path = f"/app/temp_video_{uuid.uuid4().hex[:6]}.mp4"
+    audio_path = f"/app/temp_audio_{uuid.uuid4().hex[:6]}.mp3"
+    output_path = f"/app/output_{uuid.uuid4().hex[:6]}.mp4"
 
-# Utility to download assets
-def download_file(url, save_dir):
-    filename = url.split("/")[-1].split("?")[0]
-    path = os.path.join(save_dir, filename)
-    with open(path, "wb") as f:
-        f.write(requests.get(url).content)
-    return path
+    # Save the uploaded files
+    with open(video_path, "wb") as f:
+        f.write(await video_file.read())
 
+    with open(audio_path, "wb") as f:
+        f.write(await audio_file.read())
 
-@app.post("/generate")
-def generate_video(job: VideoInstruction):
-    job_id = str(uuid.uuid4())
-    temp_dir = f"/tmp/{job_id}/"
-    os.makedirs(temp_dir, exist_ok=True)
-
-    clips = []
-    audio_clip = None
-
-    # Create solid background to match canvas size/duration
-    bg_clip = ColorClip(size=(job.canvas.width, job.canvas.height), color=(0, 0, 0)).set_duration(job.canvas.duration)
-    clips.append(bg_clip)
-
-    for track in job.tracks:
-        if track.type in ["video", "image", "audio"] and track.src:
-            local_path = download_file(track.src, temp_dir)
-
-        if track.type == "video":
-            clip = VideoFileClip(local_path).set_start(track.start)
-            if track.duration:
-                clip = clip.subclip(0, track.duration)
-            if track.position:
-                clip = clip.set_position((track.position.x, track.position.y))
-            if track.scale:
-                clip = clip.resize(track.scale)
-            clips.append(clip)
-
-        elif track.type == "image":
-            clip = ImageClip(local_path).set_start(track.start)
-            duration = track.duration or job.canvas.duration - track.start
-            clip = clip.set_duration(duration)
-            if track.position:
-                clip = clip.set_position((track.position.x, track.position.y))
-            if track.scale:
-                clip = clip.resize(track.scale)
-            clips.append(clip)
-
-        elif track.type == "text":
-            clip = TextClip(
-                track.value,
-                fontsize=track.size,
-                color=track.color,
-                font=track.font
-            ).set_start(track.start).set_duration(track.duration or 5)
-            if track.position:
-                clip = clip.set_position((track.position.x, track.position.y))
-            clips.append(clip)
-
-        elif track.type == "audio":
-            audio_clip = AudioFileClip(local_path)
-
-    final_clip = CompositeVideoClip(clips, size=(job.canvas.width, job.canvas.height)).set_duration(job.canvas.duration)
-
-    if audio_clip:
-        final_clip = final_clip.set_audio(audio_clip)
-
-    output_file = f"/app/output/{job_id}.mp4"
-    final_clip.write_videofile(output_file, fps=30, codec="libx264")
-
-    return {"video_url": f"/videos/{job_id}.mp4"}
+    # Process with MoviePy
+    videoclip = VideoFileClip(video_path)
+    audioclip = AudioFileClip(audio_path)
+    videoclip = videoclip.set_audio(audioclip)
+
+    videoclip.write_videofile(output_path, codec="libx264", fps=24)
+
+    # Clean temp files
+    os.remove(video_path)
+    os.remove(audio_path)
+
+    return FileResponse(output_path, media_type="video/mp4", filename=os.path.basename(output_path))