Update modules/app.py

modules/app.py

@@ -1,17 +1,15 @@
-from fastapi import FastAPI, HTTPException, Request, Depends
+from fastapi import FastAPI, HTTPException, Request
 from fastapi.staticfiles import StaticFiles
 from pytubefix import YouTube
 from pytubefix.exceptions import PytubeFixError
 from concurrent.futures import ThreadPoolExecutor
 import ffmpeg
-from pydantic import BaseModel, HttpUrl
-from typing import List
 import asyncio
+import aiohttp
+import aiofiles
 import requests
 import tempfile
-import time
 import uuid
-import aiohttp
 import base64
 import io
 import os
@@ -22,14 +20,7 @@ import json
 
 app = FastAPI()
 
-whisper_origin = os.getenv("WHISPER_ORIGIN")
-whisper_base_url = os.getenv("WHISPER_BASE_URL")
-img2location_name = os.getenv("IMG2LOCATION_NAME")
-img2location_origin = os.getenv("IMG2LOCATION_ORIGIN")
-img2location_base_url = os.getenv("IMG2LOCATION_BASE_URL")
-pixart_sigma_base_url = os.getenv("PIXART_SIGMA_BASE_URL")
-allowed_user_agent = os.getenv("ALLOWED_USER_AGENT")
-
+MODAL_BASE_URL = "https://sxqib--api-fastapi-app.modal.run"
 
 def generate_hash(length=12):
     # Characters that can appear in the hash
@@ -56,13 +47,6 @@ app.mount("/audio", StaticFiles(directory=AUDIO_DIR), name="audio")
 # Mount the output directory
 app.mount("/output", StaticFiles(directory=OUTPUT_DIR), name="output")
 
-class AudioImageInput(BaseModel):
-    image_url: HttpUrl
-    audio_url: HttpUrl
-
-class VideosInput(BaseModel):
-    video_urls: List[HttpUrl]
-
 thread_pool = ThreadPoolExecutor(max_workers=2)
 
 async def run_ffmpeg_async(ffmpeg_command):
@@ -79,27 +63,21 @@ async def download_file(url: str, suffix: str):
                 return temp_file.name
 
 @app.post("/add_audio_to_image")
-async def add_audio_to_image(input_data: AudioImageInput):
+async def add_audio_to_image(request: Request):
     try:
-        # Download image and audio files
-        temp_image_path = await download_file(str(input_data.image_url), ".png")
-        temp_audio_path = await download_file(str(input_data.audio_url), ".mp3")
-
         # Generate a unique filename
         output_filename = f"{uuid.uuid4()}.mp4"
         output_path = os.path.join(OUTPUT_DIR, output_filename)
 
-        # Use ffmpeg to combine image and audio into a video
-        input_image = ffmpeg.input(temp_image_path, loop=1, t=5)  # 5 seconds duration
-        input_audio = ffmpeg.input(temp_audio_path)
-        ffmpeg_command = ffmpeg.concat(input_image, input_audio, v=1, a=1).output(output_path, vcodec='libx264', acodec='aac')
-
-        # Run ffmpeg asynchronously
-        await run_ffmpeg_async(ffmpeg_command.run)
-
-        # Clean up temporary files
-        os.unlink(temp_image_path)
-        os.unlink(temp_audio_path)
+        # Call the modal API with the request data and download the output file
+        data = await request.json()
+        async with aiohttp.ClientSession() as session:
+            async with session.post(f"{MODAL_BASE_URL}/add_audio_to_image", json=data) as response:
+                if response.status != 200:
+                    raise HTTPException(status_code=500, detail="Failed to process request")
+                output_data = await response.read()
+                async with aiofiles.open(output_path, "wb") as f:
+                    await f.write(output_data)
 
         # Return the URL path to the output file
         return f"https://sxqib-api.hf.space/output/{output_filename}"
@@ -109,86 +87,51 @@ async def add_audio_to_image(input_data: AudioImageInput):
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 @app.post("/concatenate_videos")
-async def concatenate_videos(input_data: VideosInput):
+async def concatenate_videos(request: Request):
     try:
-        temp_video_paths = []
-        # Download videos to temporary files
-        for video_url in input_data.video_urls:
-            temp_video_paths.append(await download_file(str(video_url), ".mp4"))
-
         # Generate a unique filename for the output
         output_filename = f"{uuid.uuid4()}.mp4"
         output_path = os.path.join(OUTPUT_DIR, output_filename)
 
-        # Separate video and audio streams
-        video_and_audio_streams = []
-        for path in temp_video_paths:
-            video = ffmpeg.input(path).video
-            audio = ffmpeg.input(path).audio
-            video_and_audio_streams.append(video)
-            video_and_audio_streams.append(audio)
-
-        # Concatenate video and audio streams
-        joined = ffmpeg.concat(*video_and_audio_streams, v=1, a=1).node
-
-        # Merge video and audio
-        ffmpeg_command = ffmpeg.output(joined[0], joined[1], output_path, vcodec='libx264', acodec='aac')
-
-        # Run ffmpeg asynchronously
-        await run_ffmpeg_async(ffmpeg_command.run)
-
-        # Clean up temporary files
-        for path in temp_video_paths:
-            os.remove(path)
+        # Call the modal API with the request data and download the output file
+        data = await request.json()
+        async with aiohttp.ClientSession() as session:
+            async with session.post(f"{MODAL_BASE_URL}/concatenate_videos", json=data) as response:
+                if response.status != 200:
+                    raise HTTPException(status_code=500, detail="Failed to process request")
+                output_data = await response.read()
+                async with aiofiles.open(output_path, "wb") as f:
+                    await f.write(output_data)
 
         # Return the URL path to the output file
         return f"https://sxqib-api.hf.space/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.get("/get_audio")
-async def get_audio(url: str):    
-    if not url:
-        raise HTTPException(status_code=400, detail="URL is required")
-
+async def get_audio(request: Request):  
     try:
-        print(f"Attempting to process YouTube URL: {url}")
-        yt = YouTube(url)
-        video = yt.streams.filter(only_audio=True).first()
-        
-        if not video:
-            print(f"No audio stream found for URL: {url}")
-            raise HTTPException(status_code=404, detail="No audio stream found for this video")
-        
         # Generate a unique filename
         unique_filename = f"{uuid.uuid4().hex}.mp3"
         out_file = os.path.join(AUDIO_DIR, unique_filename)
 
-        print((f"Downloading audio to: {out_file}"))
-        
-        # Download the audio
-        video.download(output_path=AUDIO_DIR, filename=unique_filename, timeout=30)
-        
-        file_stats = os.stat(out_file)
-        print(f'Size of audio file in Bytes: {file_stats.st_size}')
-        
-        if file_stats.st_size <= 30000000:
-            # Construct the URL for the MP3 file
-            mp3_url = f"https://sxqib-api.hf.space/audio/{unique_filename}"
-            return mp3_url
-        else:
-            os.remove(out_file)
-            raise HTTPException(status_code=413, detail="Audio file is too large. Limited to about 1.5 hours.")
-    except PytubeFixError as e:
-        print(f"PytubeError occurred: {str(e)}")
-        raise HTTPException(status_code=400, detail=f"Error processing YouTube video: {str(e)}")
-    except HTTPException as he:
-        # Re-raise HTTP exceptions
-        raise he
+        # Call the modal API with the request data and download the output file
+        data = await request.json()
+        async with aiohttp.ClientSession() as session:
+            async with session.post(f"{MODAL_BASE_URL}/get_audio", json=data) as response:
+                if response.status != 200:
+                    raise HTTPException(status_code=500, detail="Failed to process request")
+                output_data = await response.read()
+                async with aiofiles.open(out_file, "wb") as f:
+                    await f.write(output_data)
+
+        # Return the URL path to the output file
+        return f"https://sxqib-api.hf.space/audio/{unique_filename}"
     except Exception as e:
-        print(f"Unexpected error occurred: {str(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)}")
 
@@ -206,9 +149,9 @@ async def whisper(request: Request):
         'Connection': 'keep-alive',
         'Content-Type': 'application/json',
         'DNT': '1',
-        'Origin': whisper_origin,
+		'Origin': 'https://deepinfra.com',
         'Pragma': 'no-cache',
-        'Referer': f'{whisper_origin}/',
+		'Referer': 'https://deepinfra.com/',
         'Sec-Fetch-Dest': 'empty',
         'Sec-Fetch-Mode': 'cors',
         'Sec-Fetch-Site': 'same-site',
@@ -231,7 +174,7 @@ async def whisper(request: Request):
             json_data = '{"audio": "' + audio_base64 + '"}'
 
             # Post request to the API
-            async with session.post(f'{whisper_base_url}/v1/inference/openai/whisper-large', headers=headers, data=json_data) as post_resp:
+            async with session.post(f'https://api.deepinfra.com/v1/inference/openai/whisper-large', headers=headers, data=json_data) as post_resp:
                 if post_resp.status != 200:
                     return f"API request failed: {post_resp.status}"
                 return await post_resp.json()
@@ -249,10 +192,10 @@ async def img2location(request: Request):
         'accept-language': 'en-US,en;q=0.9',
         'cache-control': 'no-cache',
         'dnt': '1',
-        'origin': img2location_origin,
+        'origin': 'https://geospy.ai',
         'pragma': 'no-cache',
         'priority': 'u=1, i',
-        'referer': f'{img2location_origin}/',
+        'referer': 'https://geospy.ai/',
         'sec-ch-ua': '"Chromium";v="124", "Microsoft Edge";v="124", "Not-A.Brand";v="99"',
         'sec-ch-ua-mobile': '?0',
         'sec-ch-ua-platform': '"Windows"',
@@ -274,7 +217,7 @@ async def img2location(request: Request):
         data.add_field('image', io.BytesIO(image_data), filename="image.png", content_type='image/png')
 
         # Sending the POST request
-        async with session.post(img2location_base_url, headers=headers, data=data) as response:
+        async with session.post("https://locate-image-7cs5mab6na-uc.a.run.app/", headers=headers, data=data) as response:
             if response.status != 200:
                 return f"Failed to upload image: HTTP {response.status}"
             json_response = await response.json()
@@ -335,14 +278,14 @@ async def pixart_sigma(request: Request):
     }
 
     async with aiohttp.ClientSession() as session:
-        async with session.post(f'{pixart_sigma_base_url}/queue/join', params=params, headers=headers, json=json_data, ssl=False) as response:
+        async with session.post(f'https://pixart-alpha-pixart-sigma.hf.space/queue/join', params=params, headers=headers, json=json_data, ssl=False) as response:
             print(response.status)
 
         params = {
             'session_hash': hash,
         }
 
-        async with session.get(f'{pixart_sigma_base_url}/queue/data', params=params, headers=headers, ssl=False) as response:
+        async with session.get(f'https://pixart-alpha-pixart-sigma.hf.space/queue/data', params=params, headers=headers, ssl=False) as response:
             async for line in response.content:
                 try:
                     if line: