Update main.py

main.py

@@ -1,517 +1,137 @@
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException
 from fastapi.staticfiles import StaticFiles
-from concurrent.futures import ThreadPoolExecutor
-import asyncio
-import aiohttp
-import tempfile
+from pydantic import BaseModel, HttpUrl
+from typing import List
+import os
+import subprocess
 import uuid
+import requests
+import re
+from urllib.parse import urlparse
 import shutil
-import os
-import random
-import traceback
-import string
 
+# Create FastAPI app
 app = FastAPI()
 
-def generate_hash(length=12):
-    # Characters that can appear in the hash
-    characters = string.ascii_lowercase + string.digits
-    # Generate a random string of the specified length
-    hash_string = ''.join(random.choice(characters) for _ in range(length))
-    return hash_string
-
-@app.get("/")
-async def read_root():
-    return {"message": "Saqib's API"}
-
-# Create a directory to store MP3 files if it doesn't exist
-AUDIO_DIR = "audio_files"
-os.makedirs(AUDIO_DIR, exist_ok=True)
-
-# Create a directory for storing output files
-OUTPUT_DIR = "output"
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-
-# Mount the audio directory
-app.mount("/audio", StaticFiles(directory=AUDIO_DIR), name="audio")
+# Create and mount staticfiles directory
+os.makedirs("staticfiles", exist_ok=True)
+app.mount("/static", StaticFiles(directory="staticfiles"), name="static")
 
-# Mount the output directory
-app.mount("/output", StaticFiles(directory=OUTPUT_DIR), name="output")
+# Define input model for the request
+class SlideshowRequest(BaseModel):
+    image_urls: List[HttpUrl]
+    audio_url: HttpUrl
+    duration: int
 
-thread_pool = ThreadPoolExecutor(max_workers=2)
+def extract_google_drive_id(url):
+    """Extract file ID from a Google Drive URL"""
+    pattern = r'(?:/file/d/|id=|/open\?id=)([^/&]+)'
+    match = re.search(pattern, str(url))
+    return match.group(1) if match else None
 
-async def run_ffmpeg_async(ffmpeg_command):
-    loop = asyncio.get_running_loop()
-    await loop.run_in_executor(thread_pool, ffmpeg_command)
-
-async def download_file(url: str, suffix: str):
-    async with aiohttp.ClientSession() as session:
-        async with session.get(url) as response:
-            if response.status != 200:
-                raise HTTPException(status_code=400, detail=f"Failed to download file from {url}")
-            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
-                temp_file.write(await response.read())
-                return temp_file.name
-
-
-@app.post("/add_audio_to_image")
-async def add_audio_to_image(request: Request):
+def download_file(url, local_path):
+    """Download a file from URL to local path"""
     try:
-        # Generate a unique filename
-        output_filename = f"{uuid.uuid4()}.mp4"
-        output_path = os.path.join(OUTPUT_DIR, output_filename)
-
-        # Call the modal API with the request data and download the output file
-        data = await request.json()
-        image_url = data.get("image_url")
-        audio_url = data.get("audio_url")
-
-        if not image_url or not audio_url:
-            raise HTTPException(status_code=400, detail="Missing image_url or audio_url in request")
-
-        image_file = await download_file(image_url, ".jpg")
-        audio_file = await download_file(audio_url, ".mp3")
-
-        # Run ffmpeg command with improved audio detection parameters
-        ffmpeg_cmd = f"ffmpeg -loop 1 -i {image_file} -analyzeduration 10000000 -probesize 10000000 -i {audio_file} -c:v libx264 -tune stillimage -c:a aac -b:a 192k -strict experimental -shortest -pix_fmt yuv420p {output_path}"
-        process = await asyncio.create_subprocess_shell(
-            ffmpeg_cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        _, stderr = await process.communicate()
-
-        if process.returncode != 0:
-            print(f"FFmpeg error: {stderr.decode()}")
-            raise HTTPException(status_code=500, detail=f"FFmpeg failed: {stderr.decode()}")
-
-        # Clean up temporary files
-        os.remove(image_file)
-        os.remove(audio_file)
-
-        # Return the URL path to the output file
-        return f"/output/{output_filename}"
-    except Exception as e:
-        print(f"An error occurred: {str(e)}")
-        print(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
-
-@app.post("/add_audio_to_video")
-async def add_audio_to_video(request: Request):
-    try:
-        # Generate a unique filename
-        output_filename = f"{uuid.uuid4()}.mp4"
-        output_path = os.path.join(OUTPUT_DIR, output_filename)
-
-        # Call the modal API with the request data and download the output file
-        data = await request.json()
-        video_url = data.get("video_url")
-        audio_url = data.get("audio_url")
-
-        if not video_url or not audio_url:
-            raise HTTPException(status_code=400, detail="Missing video_url or audio_url in request")
-
-        video_file = await download_file(video_url, ".mp4")
-        audio_file = await download_file(audio_url, ".mp3")
-
-        # Run ffmpeg command with improved audio detection parameters
-        ffmpeg_cmd = f"ffmpeg -analyzeduration 10000000 -probesize 10000000 -i {video_file} -analyzeduration 10000000 -probesize 10000000 -i {audio_file} -c:v copy -c:a aac -strict experimental -shortest {output_path}"
-        process = await asyncio.create_subprocess_shell(
-            ffmpeg_cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        _, stderr = await process.communicate()
-
-        if process.returncode != 0:
-            print(f"FFmpeg error: {stderr.decode()}")
-            raise HTTPException(status_code=500, detail=f"FFmpeg failed: {stderr.decode()}")
-
-        # Clean up temporary files
-        os.remove(video_file)
-        os.remove(audio_file)
-
-        # Return the URL path to the output file
-        return f"/output/{output_filename}"
+        # Handle Google Drive URLs
+        if "drive.google.com" in str(url):
+            file_id = extract_google_drive_id(url)
+            if file_id:
+                url = f"https://drive.google.com/uc?export=download&id={file_id}"
+        
+        response = requests.get(str(url), stream=True)
+        response.raise_for_status()
+        
+        with open(local_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+        return True
     except Exception as e:
-        print(f"An error occurred: {str(e)}")
-        print(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
-
-@app.post("/concatenate_videos")
-async def concatenate_videos(request: Request):
-    try:
-        # Generate a unique filename for the output
-        output_filename = f"{uuid.uuid4()}.mp4"
-        output_path = os.path.join(OUTPUT_DIR, output_filename)
-
-        # Call the modal API with the request data and download the output file
-        data = await request.json()
-        video_urls = data.get("video_urls")
+        print(f"Error downloading {url}: {str(e)}")
+        return False
 
-        if not video_urls or not isinstance(video_urls, list):
-            raise HTTPException(status_code=400, detail="Invalid video_urls in request. Must be a list of URLs.")
-
-        # Download the video files
-        video_files = []
-        for i, url in enumerate(video_urls):
-            video_file = await download_file(url, f"_{i}.mp4")
-            video_files.append(video_file)
-
-        # Create a temporary file with the list of input files
-        concat_list_path = os.path.join(OUTPUT_DIR, "concat_list.txt")
-        with open(concat_list_path, "w") as f:
-            for file in video_files:
-                f.write(f"file '{file}'\n")
-
-        # Run ffmpeg command
-        ffmpeg_cmd = f"ffmpeg -f concat -safe 0 -i {concat_list_path} -c copy {output_path}"
-        process = await asyncio.create_subprocess_shell(
-            ffmpeg_cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        _, stderr = await process.communicate()
-
-        if process.returncode != 0:
-            print(f"FFmpeg error: {stderr.decode()}")
-            raise HTTPException(status_code=500, detail=f"FFmpeg failed: {stderr.decode()}")
-
-        # Clean up temporary files
-        for file in video_files:
-            os.remove(file)
-        os.remove(concat_list_path)
-
-        # Return the URL path to the output file
-        return f"/output/{output_filename}"
-
-    except Exception as e:
-        print(f"An error occurred: {str(e)}")
-        print(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
+def create_slideshow(image_paths, audio_path, output_path, duration):
+    """Generate slideshow from images and audio using ffmpeg"""
+    # Create temporary file list for ffmpeg concat
+    concat_file = "temp_concat.txt"
+    
+    with open(concat_file, "w") as f:
+        for img in image_paths:
+            f.write(f"file '{img}'\n")
+            f.write(f"duration {duration}\n")
+        
+        # Add the last image again without duration (required by ffmpeg)
+        if image_paths:
+            f.write(f"file '{image_paths[-1]}'\n")
+    
+    # Run ffmpeg command to create slideshow with audio
+    cmd = [
+        "ffmpeg",
+        "-f", "concat",
+        "-safe", "0",
+        "-i", concat_file,
+        "-i", audio_path,
+        "-c:v", "libx264",
+        "-pix_fmt", "yuv420p",
+        "-c:a", "aac",
+        "-shortest",
+        "-y",
+        output_path
+    ]
     
-@app.post("/concatenate_audio")
-async def concatenate_audio(request: Request):
     try:
-        # Generate a unique filename for the output
-        output_filename = f"{uuid.uuid4()}.mp3"
-        output_path = os.path.join(AUDIO_DIR, output_filename)
-
-        # Call the modal API with the request data and download the output file
-        data = await request.json()
-        audio_urls = data.get("audio_urls")
-
-        if not audio_urls or not isinstance(audio_urls, list):
-            raise HTTPException(status_code=400, detail="Invalid audio_urls in request. Must be a list of URLs.")
-
-        # Download the audio files
-        audio_files = []
-        for i, url in enumerate(audio_urls):
-            audio_file = await download_file(url, f"_{i}.mp3")
-            audio_files.append(audio_file)
-
-        # Create a temporary file with the list of input files
-        concat_list_path = os.path.join(AUDIO_DIR, "concat_list.txt")
-        with open(concat_list_path, "w") as f:
-            for file in audio_files:
-                f.write(f"file '{file}'\n")
-
-        # Run ffmpeg command with improved audio parameters
-        ffmpeg_cmd = f"ffmpeg -f concat -safe 0 -i {concat_list_path} -c:a aac -b:a 192k -strict experimental {output_path}"
-        process = await asyncio.create_subprocess_shell(
-            ffmpeg_cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        _, stderr = await process.communicate()
-
-        if process.returncode != 0:
-            print(f"FFmpeg error: {stderr.decode()}")
-            raise HTTPException(status_code=500, detail=f"FFmpeg failed: {stderr.decode()}")
-
-        # Clean up temporary files
-        for file in audio_files:
-            os.remove(file)
-        os.remove(concat_list_path)
-
-        # Return the URL path to the output file
-        return f"/audio/{output_filename}"
-
-    except Exception as e:
-        print(f"An error occurred: {str(e)}")
-        print(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
-
-@app.post("/make_video")
-async def make_video(request: Request):
+        subprocess.run(cmd, check=True, capture_output=True)
+        os.remove(concat_file)
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"FFmpeg error: {e.stderr.decode()}")
+        if os.path.exists(concat_file):
+            os.remove(concat_file)
+        return False
+
+@app.post("/make_slideshow")
+async def make_slideshow(request: SlideshowRequest):
+    """
+    Create a slideshow from images and audio with specified duration per image.
+    Returns the URL of the generated video.
+    """
+    # Create unique directory for this request
+    request_id = str(uuid.uuid4())
+    request_dir = os.path.join("staticfiles", request_id)
+    os.makedirs(request_dir, exist_ok=True)
+    
     try:
-        # Generate a unique filename for the output
-        output_filename = f"{uuid.uuid4()}.mp4"
-        output_path = os.path.join(OUTPUT_DIR, output_filename)
-        temp_dir = os.path.join(tempfile.gettempdir(), generate_hash())
-        os.makedirs(temp_dir, exist_ok=True)
-
-        data = await request.json()
-        assets = data.get("assets", {})
-        clips = assets.get("clips", [])
-        music_url = assets.get("music_url")
-        volume_adjustment = data.get("volume_adjustment", 1.0)  # Default to normal volume if not specified
-
-        if not clips or not isinstance(clips, list):
-            raise HTTPException(status_code=400, detail="Invalid clips in request.")
-
-        # Create a list to hold clip video files that we'll concatenate later
-        clip_videos = []
-        segment_list_path = os.path.join(temp_dir, "segment_list.txt")
+        # Download images
+        image_paths = []
+        for i, url in enumerate(request.image_urls):
+            image_path = os.path.join(request_dir, f"image_{i:03d}.png")
+            if download_file(url, image_path):
+                image_paths.append(image_path)
+            else:
+                raise HTTPException(status_code=400, detail=f"Failed to download image: {url}")
         
-        with open(segment_list_path, "w") as segment_file:
-            # Process each clip: combine image with its audio
-            for i, clip in enumerate(clips):
-                image_url = clip.get("image_url")
-                audio_url = clip.get("audio_url")
-                
-                if not image_url or not audio_url:
-                    raise HTTPException(status_code=400, detail=f"Missing image_url or audio_url in clip {i}")
-                
-                # Download files
-                image_file = await download_file(image_url, ".jpg")
-                audio_file = await download_file(audio_url, ".mp3")
-                
-                # Create segment video
-                segment_output = os.path.join(temp_dir, f"segment_{i}.mp4")
-                
-                # Run ffmpeg command to create video segment
-                segment_cmd = f'ffmpeg -loop 1 -i {image_file} -i {audio_file} -c:v libx264 -tune stillimage -c:a aac -b:a 192k -shortest -pix_fmt yuv420p {segment_output}'
-                proc = await asyncio.create_subprocess_shell(
-                    segment_cmd,
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE
-                )
-                _, stderr = await proc.communicate()
-                
-                if proc.returncode != 0:
-                    print(f"FFmpeg error for segment {i}: {stderr.decode()}")
-                    raise HTTPException(status_code=500, detail=f"FFmpeg failed for segment {i}: {stderr.decode()}")
-                
-                # Add to list for concatenation
-                clip_videos.append(segment_output)
-                segment_file.write(f"file '{segment_output}'\n")
-                
-                # Clean up individual files
-                os.remove(image_file)
-                os.remove(audio_file)
+        # Download audio
+        audio_path = os.path.join(request_dir, "audio.mp3")
+        if not download_file(request.audio_url, audio_path):
+            raise HTTPException(status_code=400, detail=f"Failed to download audio: {request.audio_url}")
         
-        # Concatenate all segment videos
-        concat_output = os.path.join(temp_dir, "concat_output.mp4")
-        concat_cmd = f'ffmpeg -f concat -safe 0 -i {segment_list_path} -c copy {concat_output}'
+        # Output video path
+        output_path = os.path.join(request_dir, "slideshow.mp4")
         
-        proc = await asyncio.create_subprocess_shell(
-            concat_cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        _, stderr = await proc.communicate()
+        # Generate slideshow
+        if not create_slideshow(image_paths, audio_path, output_path, request.duration):
+            raise HTTPException(status_code=500, detail="Failed to create slideshow")
         
-        if proc.returncode != 0:
-            print(f"FFmpeg concat error: {stderr.decode()}")
-            raise HTTPException(status_code=500, detail=f"FFmpeg concat failed: {stderr.decode()}")
-        
-        # If there's a music URL, download it and mix with the video
-        if music_url:
-            music_file = await download_file(music_url, ".wav")
-            
-            # Final command to mix music with video at specified volume
-            final_cmd = (
-                f'ffmpeg -i {concat_output} -i {music_file} -filter_complex '
-                f'"[1:a]volume={volume_adjustment}[music];[0:a][music]amix=inputs=2:duration=longest" '
-                f'-c:v copy {output_path}'
-            )
-            
-            proc = await asyncio.create_subprocess_shell(
-                final_cmd,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
-            )
-            _, stderr = await proc.communicate()
-            
-            if proc.returncode != 0:
-                print(f"FFmpeg final mix error: {stderr.decode()}")
-                raise HTTPException(status_code=500, detail=f"FFmpeg music mixing failed: {stderr.decode()}")
-            
-            os.remove(music_file)
-        else:
-            # If no music, just copy the concatenated output
-            shutil.copy(concat_output, output_path)
-        
-        # Clean up temporary files and directory
-        for video_file in clip_videos:
-            os.remove(video_file)
-        os.remove(segment_list_path)
-        os.remove(concat_output)
-        os.rmdir(temp_dir)
-
-        # Return the URL path to the output file
-        return f"/output/{output_filename}"
-
-    except Exception as e:
-        print(f"An error occurred: {str(e)}")
-        print(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
-
-@app.post("/create_slideshow")
-async def create_slideshow(request: Request):
-    try:
-        # Generate a unique filename for the output
-        output_filename = f"{uuid.uuid4()}.mp4"
-        output_path = os.path.join(OUTPUT_DIR, output_filename)
-        temp_dir = os.path.join(tempfile.gettempdir(), generate_hash())
-        os.makedirs(temp_dir, exist_ok=True)
-
-        data = await request.json()
-        image_urls = data.get("image_urls")
-        audio_url = data.get("audio_url")
-        duration = data.get("duration", 4)  # Default to 4 seconds per image if not specified
-
-        if not image_urls or not isinstance(image_urls, list):
-            raise HTTPException(status_code=400, detail="Invalid image_urls in request. Must be a list of URLs.")
-
-        if not audio_url:
-            raise HTTPException(status_code=400, detail="Missing audio_url in request.")
-
-        # Download the images
-        image_files = []
-        for i, url in enumerate(image_urls):
-            image_file = await download_file(url, f"_{i}.jpg")
-            image_files.append(image_file)
-
-        # Download audio file
-        audio_file = await download_file(audio_url, ".mp3")
-        
-        # Pre-process audio file to ensure it's valid
-        normalized_audio = os.path.join(temp_dir, "normalized_audio.wav")
-        audio_check_cmd = (
-            f'ffmpeg -i {audio_file} -af "aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo" '
-            f'-y {normalized_audio}'
-        )
-        audio_process = await asyncio.create_subprocess_shell(
-            audio_check_cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        _, audio_stderr = await audio_process.communicate()
-
-        # If audio normalization fails, create a silent audio track
-        if audio_process.returncode != 0:
-            print(f"Audio normalization failed: {audio_stderr.decode()}")
-            print("Creating silent audio track instead...")
-            
-            # Calculate total video duration based on number of images and duration per image
-            total_duration = len(image_urls) * duration
-            
-            silent_cmd = (
-                f'ffmpeg -f lavfi -i anullsrc=r=44100:cl=stereo -t {total_duration} '
-                f'-y {normalized_audio}'
-            )
-            silent_process = await asyncio.create_subprocess_shell(
-                silent_cmd,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
-            )
-            _, silent_stderr = await silent_process.communicate()
-            
-            if silent_process.returncode != 0:
-                print(f"Silent audio creation failed: {silent_stderr.decode()}")
-                # Fall back to no audio if even silent audio fails
-                normalized_audio = None
-
-        # Create a text file with the list of images and their duration
-        images_list_path = os.path.join(temp_dir, "images_list.txt")
-        with open(images_list_path, "w") as f:
-            for file in image_files:
-                f.write(f"file '{file}'\n")
-                f.write(f"duration {duration}\n")
-            # Add the last image again with a small duration to prevent ffmpeg from cutting it off
-            f.write(f"file '{image_files[-1]}'\n")
-            f.write(f"duration 0.1\n")
-
-        # Create intermediate video without audio
-        intermediate_video = os.path.join(temp_dir, "intermediate.mp4")
-        # Use the complex concat demuxer for images to create a slideshow
-        concat_cmd = (
-            f'ffmpeg -f concat -safe 0 -i {images_list_path} -vsync vfr '
-            f'-pix_fmt yuv420p -c:v libx264 -r 30 {intermediate_video}'
-        )
-        process = await asyncio.create_subprocess_shell(
-            concat_cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        _, stderr = await process.communicate()
-
-        if process.returncode != 0:
-            print(f"FFmpeg slideshow creation error: {stderr.decode()}")
-            raise HTTPException(status_code=500, detail=f"FFmpeg slideshow creation failed: {stderr.decode()}")
-
-        # Add audio to the slideshow only if normalized_audio is available
-        if normalized_audio:
-            final_cmd = (
-                f'ffmpeg -i {intermediate_video} -i {normalized_audio} '
-                f'-c:v copy -c:a aac -b:a 192k -shortest {output_path}'
-            )
-            process = await asyncio.create_subprocess_shell(
-                final_cmd,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
-            )
-            _, stderr = await process.communicate()
-
-            if process.returncode != 0:
-                print(f"FFmpeg audio addition error: {stderr.decode()}")
-                # If adding audio fails, use just the video
-                shutil.copy(intermediate_video, output_path)
-        else:
-            # If no normalized audio available, use just the video
-            shutil.copy(intermediate_video, output_path)
-
-        # Clean up temporary files
-        for file in image_files:
-            if os.path.exists(file):
-                os.remove(file)
-        
-        if os.path.exists(images_list_path):
-            os.remove(images_list_path)
-        
-        if os.path.exists(intermediate_video):
-            os.remove(intermediate_video)
-            
-        if os.path.exists(audio_file):
-            os.remove(audio_file)
-            
-        if normalized_audio and os.path.exists(normalized_audio):
-            os.remove(normalized_audio)
-            
-        try:
-            os.rmdir(temp_dir)
-        except OSError:
-            # Directory might not be empty, try to clean up remaining files
-            for remaining_file in os.listdir(temp_dir):
-                try:
-                    os.remove(os.path.join(temp_dir, remaining_file))
-                except:
-                    pass
-            try:
-                os.rmdir(temp_dir)
-            except:
-                pass
-
-        # Return the URL path to the output file
-        return f"/output/{output_filename}"
-
+        # Return URL to the video
+        base_url = "/static"
+        video_url = f"{base_url}/{request_id}/slideshow.mp4"
+        return {"url": video_url}
+    
     except Exception as e:
-        print(f"An error occurred: {str(e)}")
-        print(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
+        # Clean up on error
+        if os.path.exists(request_dir):
+            shutil.rmtree(request_dir)
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=8000)