Update app.py

app.py

@@ -90,30 +90,101 @@ def validate_url(url):
     except:
         return False
 
+def detect_video_source(url):
+    """Detect video source (MidJourney, Civitai, or unknown)"""
+    if "image.civitai.com" in url:
+        return "civitai"
+    elif "cdn.midjourney.com" in url or "midjourney" in url.lower():
+        return "midjourney"
+    else:
+        return "unknown"
+
+def download_civitai_video(civitai_url):
+    """Direct download for Civitai videos (no proxy needed)"""
+    try:
+        # Civitai videos können oft direkt geladen werden
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Referer': 'https://civitai.com/',
+            'Accept': 'video/webm,video/mp4,video/*;q=0.9,*/*;q=0.8',
+        }
+        
+        # Try direct download first
+        print(f"DEBUG: Trying direct download from Civitai: {civitai_url}")
+        
+        response = requests.get(civitai_url, headers=headers, stream=True, timeout=30)
+        response.raise_for_status()
+        
+        # Create filename based on URL
+        try:
+            parsed_url = urlparse(civitai_url)
+            # Extract filename from URL path
+            path_parts = parsed_url.path.split('/')
+            if len(path_parts) > 1:
+                # Get the last part that might be a filename
+                filename_part = path_parts[-1]
+                if '.' in filename_part:
+                    temp_path = f"temp_civitai_{filename_part}"
+                else:
+                    temp_path = f"temp_civitai_{int(time.time())}.webm"
+            else:
+                temp_path = f"temp_civitai_{int(time.time())}.webm"
+        except:
+            import time
+            temp_path = f"temp_civitai_{int(time.time())}.webm"
+        
+        # Download the file
+        with open(temp_path, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+        
+        print(f"DEBUG: Civitai video downloaded to: {temp_path}")
+        return temp_path
+        
+    except Exception as e:
+        raise RuntimeError(f"Failed to download Civitai video: {e}")
+
 def download_video_from_url(original_url):
-    """Download video through proxy with error handling"""
+    """Universal video downloader for MJ, Civitai, and others"""
     try:
         if not validate_url(original_url):
             raise ValueError("Invalid URL format")
+        
+        # Detect source and use appropriate method
+        source = detect_video_source(original_url)
+        print(f"DEBUG: Detected video source: {source}")
+        
+        if source == "civitai":
+            return download_civitai_video(original_url)
+        elif source == "midjourney":
+            return download_midjourney_video(original_url)
+        else:
+            return download_generic_video(original_url)
             
+    except Exception as e:
+        raise RuntimeError(f"Failed to download video: {e}")
+
+def download_midjourney_video(mj_url):
+    """Download MidJourney videos via proxy"""
+    try:
         proxy_base = "https://9cee417c-5874-4e53-939a-52ad3f6f2f30-00-16i6nbwyeqga.picard.replit.dev/"
-        proxy_url = f"{proxy_base}?url={original_url}"
+        proxy_url = f"{proxy_base}?url={mj_url}"
         
-        # Try to get a better filename from the URL
+        # Create filename
         try:
-            parsed_url = urlparse(original_url)
+            parsed_url = urlparse(mj_url)
             url_filename = os.path.basename(parsed_url.path)
             if url_filename and '.' in url_filename:
-                # Use URL filename
-                temp_path = f"temp_{url_filename}"
+                temp_path = f"temp_mj_{url_filename}"
             else:
-                # Fallback to numbered temp file
                 import time
-                temp_path = f"temp_video_{int(time.time())}.mp4"
+                temp_path = f"temp_mj_{int(time.time())}.mp4"
         except:
-            temp_path = "temp_video.mp4"
+            import time
+            temp_path = f"temp_mj_{int(time.time())}.mp4"
         
-        print(f"DEBUG: Downloading to: {temp_path}")
+        print(f"DEBUG: Downloading MJ video via proxy: {proxy_url}")
         
         with requests.get(proxy_url, stream=True, timeout=30) as response:
             response.raise_for_status()
@@ -122,8 +193,31 @@ def download_video_from_url(original_url):
                     if chunk:
                         f.write(chunk)
         return temp_path
+        
     except Exception as e:
-        raise RuntimeError(f"Failed to download video: {e}")
+        raise RuntimeError(f"Failed to download MJ video: {e}")
+
+def download_generic_video(url):
+    """Fallback for unknown video sources"""
+    try:
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+        
+        response = requests.get(url, headers=headers, stream=True, timeout=30)
+        response.raise_for_status()
+        
+        import time
+        temp_path = f"temp_generic_{int(time.time())}.mp4"
+        
+        with open(temp_path, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+        return temp_path
+        
+    except Exception as e:
+        raise RuntimeError(f"Failed to download generic video: {e}")
 
 # --- Global variables for toggling ---
 current_video_file = None
@@ -311,7 +405,7 @@ def on_video_upload_change(video_file, use_blip):
         return "uploaded_video", error_msg
 
 def on_video_url_change(url, use_blip):
-    """Handle URL input change with safe error handling"""
+    """Handle URL input change with support for MJ and Civitai"""
     global current_video_file, current_video_url, blip_generated_name, original_filename
     
     if not url or url.strip() == "":
@@ -319,32 +413,43 @@ def on_video_url_change(url, use_blip):
         current_video_url = None
         blip_generated_name = ""
         original_filename = ""
-        return None, "", "Enter a valid video URL"
+        return None, "", "Enter a video URL (MidJourney or Civitai supported)"
     
     try:
-        print(f"Downloading video from URL: {url}")
+        source = detect_video_source(url)
+        print(f"Downloading {source} video from URL: {url}")
+        
         video_path = download_video_from_url(url)
         
         # Store the current video info
         current_video_file = None  # Clear file when using URL
         current_video_url = video_path
         
-        # Set original filename for URL downloads
+        # Set original filename based on source
         try:
-            # Try to extract filename from URL
-            parsed_url = urlparse(url)
-            url_filename = os.path.basename(parsed_url.path)
-            if url_filename and '.' in url_filename:
-                url_name = os.path.splitext(url_filename)[0]
-                original_filename = "".join(c for c in url_name if c.isalnum() or c in "_-")[:30]
-                if not original_filename:  # If cleaning removed everything
-                    original_filename = "downloaded_video"
+            if source == "civitai":
+                # Extract filename from Civitai URL
+                parsed_url = urlparse(url)
+                path_parts = parsed_url.path.split('/')
+                # Look for meaningful filename in path
+                for part in reversed(path_parts):
+                    if part and '.' not in part and len(part) > 3:
+                        cleaned = "".join(c for c in part if c.isalnum() or c in "_-")[:20]
+                        if cleaned:
+                            original_filename = f"civitai_{cleaned}"
+                            break
+                else:
+                    original_filename = "civitai_video"
+                    
+            elif source == "midjourney":
+                original_filename = "midjourney_video"
             else:
                 original_filename = "downloaded_video"
+                
         except:
-            original_filename = "downloaded_video"
+            original_filename = f"{source}_video" if source != "unknown" else "downloaded_video"
         
-        print(f"DEBUG: URL original filename set to: '{original_filename}'")
+        print(f"DEBUG: {source.title()} original filename set to: '{original_filename}'")
         
         blip_generated_name = ""
         
@@ -355,15 +460,16 @@ def on_video_url_change(url, use_blip):
                 if len(frames) > 0:
                     frame = frames[len(frames) // 2]
                     blip_generated_name = generate_blip_name(frame)
-                    print(f"DEBUG: URL BLIP name generated: '{blip_generated_name}'")
+                    print(f"DEBUG: {source.title()} BLIP name generated: '{blip_generated_name}'")
             except Exception as e:
                 print(f"BLIP naming failed: {e}")
                 blip_generated_name = ""
         
         # Return appropriate name
         final_name = blip_generated_name if (use_blip and blip_generated_name) else original_filename
-        print(f"DEBUG: URL final name returned: '{final_name}' (BLIP: {use_blip})")
-        return video_path, final_name, "Video downloaded successfully!"
+        success_msg = f"✅ {source.title()} video downloaded successfully!"
+        print(f"DEBUG: {source.title()} final name returned: '{final_name}' (BLIP: {use_blip})")
+        return video_path, final_name, success_msg
         
     except Exception as e:
         error_msg = f"Download failed: {str(e)}"
@@ -456,7 +562,7 @@ with gr.Blocks(analytics_enabled=False, title="Video Depth Anything") as demo:
     with gr.Row():
         video_url = gr.Textbox(
             label="🔗 Video URL", 
-            placeholder="Paste video URL here...",
+            placeholder="Paste MidJourney or Civitai video URL here...",
             scale=4
         )
         use_blip = gr.Checkbox(