Update app.py

app.py

@@ -15,54 +15,103 @@ load_dotenv()
 B_KEY = os.getenv("B_KEY")
 
 # URLs
-API_URL = os.getenv("API_URL")
-UPLOAD_URL = os.getenv("UPLOAD_URL")  # Make sure to add this to your .env file
+API_URL = "https://api.sync.so/v2/generate"  # Updated API endpoint
 
 def lipsync_api_call(video_url, audio_url):
+    print(f"\n[DEBUG] Starting lipsync_api_call")
+    print(f"[DEBUG] Video URL: {video_url}")
+    print(f"[DEBUG] Audio URL: {audio_url}")
+    
     headers = {
         "Content-Type": "application/json",
         "x-api-key": B_KEY
     }
     
     data = {
-        "audioUrl": audio_url,
-        "videoUrl": video_url,
-        "maxCredits": 1000,
         "model": "lipsync-1.8.0-beta",
-        "synergize": True,
-        "pads": [0, 5, 0, 0],
-        "synergizerStrength": 1
+        "input": [
+            {
+                "type": "video",
+                "url": video_url
+            },
+            {
+                "type": "audio",
+                "url": audio_url
+            }
+        ],
+        "options": {
+            "pads": [0, 5, 0, 0],
+            "speedup": 1,
+            "output_format": "mp4",
+            "sync_mode": "bounce",
+            "fps": 24,
+            "output_resolution": [1280, 720]
+        }
     }
     
-    response = requests.post(API_URL, headers=headers, data=json.dumps(data))
-    return response.json()
+    print(f"[DEBUG] Request payload: {json.dumps(data, indent=2)}")
+    
+    try:
+        response = requests.post(API_URL, headers=headers, data=json.dumps(data))
+        print(f"[DEBUG] API Response status code: {response.status_code}")
+        print(f"[DEBUG] API Response: {response.text}")
+        return response.json()
+    except Exception as e:
+        print(f"[ERROR] API call failed: {str(e)}")
+        raise
 
 def check_job_status(job_id):
+    print(f"\n[DEBUG] Checking job status for ID: {job_id}")
     headers = {"x-api-key": B_KEY}
-    max_attempts = 3000  # Limit the number of attempts
+    max_attempts = 3000
+    attempt = 0
     
-    for _ in range(max_attempts):
-        response = requests.get(f"{API_URL}/{job_id}", headers=headers)
-        data = response.json()
-        
-        if data["status"] == "COMPLETED":
-            return data["videoUrl"]
-        elif data["status"] == "FAILED":
+    while attempt < max_attempts:
+        try:
+            response = requests.get(f"{API_URL}/{job_id}", headers=headers)
+            print(f"[DEBUG] Status check attempt {attempt + 1}")
+            print(f"[DEBUG] Status response: {response.text}")
+            
+            data = response.json()
+            status = data.get("status")
+            print(f"[DEBUG] Current status: {status}")
+            
+            if status == "COMPLETED":
+                print(f"[DEBUG] Job completed. Output URL: {data.get('outputUrl')}")
+                return data.get("outputUrl")
+            elif status == "FAILED" or status == "CANCELED":
+                print(f"[ERROR] Job failed or was canceled. Error: {data.get('error')}")
+                return None
+            
+            attempt += 1
+            time.sleep(10)
+            
+        except Exception as e:
+            print(f"[ERROR] Status check failed: {str(e)}")
             return None
-        
-        time.sleep(10)
+    
+    print("[ERROR] Max attempts reached")
     return None
 
 def get_media_duration(file_path):
+    print(f"\n[DEBUG] Getting duration for: {file_path}")
     cmd = ['ffprobe', '-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', file_path]
     result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    return float(result.stdout.strip())
+    duration = float(result.stdout.strip())
+    print(f"[DEBUG] Media duration: {duration} seconds")
+    return duration
 
 def combine_audio_video(video_path, audio_path, output_path):
+    print(f"\n[DEBUG] Combining audio and video")
+    print(f"[DEBUG] Video path: {video_path}")
+    print(f"[DEBUG] Audio path: {audio_path}")
+    print(f"[DEBUG] Output path: {output_path}")
+    
     video_duration = get_media_duration(video_path)
     audio_duration = get_media_duration(audio_path)
 
     if video_duration > audio_duration:
+        print("[DEBUG] Video longer than audio - trimming video")
         cmd = [
             'ffmpeg', '-i', video_path, '-i', audio_path,
             '-t', str(audio_duration),
@@ -71,6 +120,7 @@ def combine_audio_video(video_path, audio_path, output_path):
             '-y', output_path
         ]
     else:
+        print("[DEBUG] Audio longer than video - looping video")
         loop_count = int(audio_duration // video_duration) + 1
         cmd = [
             'ffmpeg', '-stream_loop', str(loop_count), '-i', video_path, '-i', audio_path,
@@ -80,54 +130,84 @@ def combine_audio_video(video_path, audio_path, output_path):
             '-shortest', '-y', output_path
         ]
 
-    subprocess.run(cmd, check=True)
+    print(f"[DEBUG] FFmpeg command: {' '.join(cmd)}")
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    print(f"[DEBUG] FFmpeg stdout: {result.stdout}")
+    print(f"[DEBUG] FFmpeg stderr: {result.stderr}")
 
 def is_image_url(url):
     parsed = urlparse(url)
     path = parsed.path.lower()
-    return path.endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp', '.tiff', '.webp', '.heic', '.svg', '.ico'))
+    result = path.endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp', '.tiff', '.webp', '.heic', '.svg', '.ico'))
+    print(f"\n[DEBUG] Checking if URL is image: {url}")
+    print(f"[DEBUG] Result: {result}")
+    return result
 
 def create_video_from_image(image_url, output_path, duration=10):
-    # Download the image
+    print(f"\n[DEBUG] Creating video from image")
+    print(f"[DEBUG] Image URL: {image_url}")
+    print(f"[DEBUG] Output path: {output_path}")
+    
     response = requests.get(image_url)
     if response.status_code != 200:
+        print(f"[ERROR] Failed to download image. Status code: {response.status_code}")
         raise Exception("Failed to download the image")
     
     temp_image_path = f"temp_image_{uuid.uuid4()}.jpg"
+    print(f"[DEBUG] Temporary image path: {temp_image_path}")
+    
     with open(temp_image_path, 'wb') as f:
         f.write(response.content)
     
-    # Create a 10-second video from the image
     cmd = [
         'ffmpeg', '-loop', '1', '-i', temp_image_path,
         '-c:v', 'libx264', '-t', str(duration), '-pix_fmt', 'yuv420p',
         '-vf', 'scale=trunc(iw/2)*2:trunc(ih/2)*2',
         '-y', output_path
     ]
-    subprocess.run(cmd, check=True)
     
-    # Clean up the temporary image file
+    print(f"[DEBUG] FFmpeg command: {' '.join(cmd)}")
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    print(f"[DEBUG] FFmpeg stdout: {result.stdout}")
+    print(f"[DEBUG] FFmpeg stderr: {result.stderr}")
+    
     os.remove(temp_image_path)
+    print(f"[DEBUG] Temporary image removed")
     
     return output_path
 
 def upload_file(file_path):
+    print(f"\n[DEBUG] Uploading file: {file_path}")
+    
     with open(file_path, 'rb') as file:
         files = {'fileToUpload': (os.path.basename(file_path), file)}
         data = {'reqtype': 'fileupload'}
-        response = requests.post(UPLOAD_URL, files=files, data=data)
-    
-    if response.status_code == 200:
-        return response.text.strip()
-    return None
+        try:
+            response = requests.post(UPLOAD_URL, files=files, data=data)
+            print(f"[DEBUG] Upload response status code: {response.status_code}")
+            print(f"[DEBUG] Upload response: {response.text}")
+            
+            if response.status_code == 200:
+                return response.text.strip()
+            return None
+        except Exception as e:
+            print(f"[ERROR] File upload failed: {str(e)}")
+            return None
 
 def process_video(video_url, audio_url, progress=gr.Progress()):
+    print(f"\n[DEBUG] Starting video processing")
+    print(f"[DEBUG] Video URL: {video_url}")
+    print(f"[DEBUG] Audio URL: {audio_url}")
+    
     if not audio_url:
+        print("[ERROR] No audio URL provided")
         return None, "No audio URL provided"
     if not video_url:
+        print("[ERROR] No video URL provided")
         return None, "No video URL provided"
         
     session_id = str(uuid.uuid4())
+    print(f"[DEBUG] Session ID: {session_id}")
     
     progress(0.2, desc="Processing media...")
     
@@ -146,27 +226,36 @@ def process_video(video_url, audio_url, progress=gr.Progress()):
         job_data = lipsync_api_call(video_url, audio_url)
         
         if "error" in job_data or "message" in job_data:
-            raise Exception(job_data.get("error", job_data.get("message", "Unknown error")))
+            error_msg = job_data.get("error", job_data.get("message", "Unknown error"))
+            print(f"[ERROR] API error: {error_msg}")
+            raise Exception(error_msg)
         
         job_id = job_data["id"]
+        print(f"[DEBUG] Job ID: {job_id}")
         
         progress(0.6, desc="Processing lipsync...")
         result_url = check_job_status(job_id)
         
         if result_url:
             progress(0.9, desc="Downloading result...")
+            print(f"[DEBUG] Downloading from: {result_url}")
             response = requests.get(result_url)
             output_path = f"output_{session_id}.mp4"
+            
             with open(output_path, "wb") as f:
                 f.write(response.content)
+            
+            print(f"[DEBUG] Result saved to: {output_path}")
             progress(1.0, desc="Complete!")
             return output_path, "Lipsync completed successfully!"
         else:
             raise Exception("Lipsync processing failed or timed out")
             
     except Exception as e:
+        print(f"[ERROR] Main process failed: {str(e)}")
         progress(0.8, desc="Falling back to simple combination...")
         try:
+            print("[DEBUG] Attempting fallback method")
             video_response = requests.get(video_url)
             temp_video_path = f"temp_video_{session_id}.mp4"
             with open(temp_video_path, "wb") as f:
@@ -186,6 +275,7 @@ def process_video(video_url, audio_url, progress=gr.Progress()):
             progress(1.0, desc="Complete!")
             return output_path, f"Used fallback method. Original error: {str(e)}"
         except Exception as fallback_error:
+            print(f"[ERROR] Fallback method failed: {str(fallback_error)}")
             return None, f"All methods failed. Error: {str(fallback_error)}"
 
 def create_interface():
@@ -193,7 +283,7 @@ def create_interface():
     
     """
     with gr.Blocks(css=css) as app:
-        gr.Markdown("# JSON 2")
+        gr.Markdown("# Lipsync Video Generator")
         with gr.Row():
             with gr.Column():
                 video_url_input = gr.Textbox(label="Video or Image URL")
@@ -212,5 +302,6 @@ def create_interface():
     return app
 
 if __name__ == "__main__":
+    print("[DEBUG] Starting application")
     app = create_interface()
     app.launch()