Update app.py

app.py

@@ -10,33 +10,121 @@ import tempfile
 import re
 
 def download_from_google_drive(url):
-    """Download file from Google Drive URL"""
+    """Download file from Google Drive URL with improved parsing"""
     try:
-        # Extract file ID from Google Drive URL
+        if not url or not isinstance(url, str):
+            raise ValueError("Invalid URL provided")
+            
+        print(f"Processing URL: {url}")
+        
+        # Clean up the URL
+        url = url.strip()
+        
         if 'drive.google.com' in url:
-            if '/file/d/' in url:
-                file_id = url.split('/file/d/')[1].split('/')[0]
-            elif 'id=' in url:
-                file_id = url.split('id=')[1].split('&')[0]
-            else:
-                return None
+            # Multiple patterns to handle different Google Drive URL formats
+            patterns = [
+                r'/file/d/([a-zA-Z0-9-_]+)',
+                r'id=([a-zA-Z0-9-_]+)',
+                r'/d/([a-zA-Z0-9-_]+)',
+                r'file/d/([a-zA-Z0-9-_]+)/view',
+                r'open\?id=([a-zA-Z0-9-_]+)'
+            ]
+            
+            file_id = None
+            for pattern in patterns:
+                match = re.search(pattern, url)
+                if match:
+                    file_id = match.group(1)
+                    break
             
-            download_url = f"https://drive.google.com/uc?id={file_id}"
+            if not file_id:
+                # Try alternative extraction method
+                if '/file/d/' in url:
+                    try:
+                        file_id = url.split('/file/d/')[1].split('/')[0]
+                    except IndexError:
+                        pass
+                elif 'id=' in url:
+                    try:
+                        file_id = url.split('id=')[1].split('&')[0]
+                    except IndexError:
+                        pass
+            
+            if not file_id:
+                raise ValueError("Could not extract file ID from Google Drive URL")
+            
+            print(f"Extracted file ID: {file_id}")
+            
+            # Create download URL
+            download_url = f"https://drive.google.com/uc?export=download&id={file_id}"
+            
+            # Download using gdown
             output_path = tempfile.mktemp(suffix='.mp4')
-            gdown.download(download_url, output_path, quiet=False)
-            return output_path
+            try:
+                gdown.download(download_url, output_path, quiet=False)
+                if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
+                    return output_path
+                else:
+                    # Try alternative download method
+                    gdown.download(f"https://drive.google.com/file/d/{file_id}/view?usp=sharing", 
+                                 output_path, quiet=False, fuzzy=True)
+                    return output_path
+            except Exception as e:
+                print(f"gdown failed: {e}")
+                # Fallback to direct requests
+                try:
+                    response = requests.get(download_url, stream=True)
+                    response.raise_for_status()
+                    with open(output_path, 'wb') as f:
+                        for chunk in response.iter_content(chunk_size=8192):
+                            f.write(chunk)
+                    return output_path
+                except Exception as e2:
+                    print(f"Direct download also failed: {e2}")
+                    raise e2
         else:
-            # Direct download for other URLs
-            response = requests.get(url)
+            # Handle direct URLs
             output_path = tempfile.mktemp(suffix='.mp4')
+            response = requests.get(url, stream=True)
+            response.raise_for_status()
             with open(output_path, 'wb') as f:
-                f.write(response.content)
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
             return output_path
+            
     except Exception as e:
         print(f"Error downloading file: {e}")
         return None
 
-def calculate_font_size(text, max_width, max_height, font_path):
+def download_audio_file(url):
+    """Download audio file from URL"""
+    try:
+        if not url or not url.strip():
+            return None
+            
+        url = url.strip()
+        
+        # Determine file extension
+        if url.lower().endswith(('.mp3', '.wav', '.m4a', '.aac')):
+            ext = url.split('.')[-1]
+        else:
+            ext = 'mp3'
+            
+        output_path = tempfile.mktemp(suffix=f'.{ext}')
+        
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        
+        with open(output_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+                
+        return output_path
+    except Exception as e:
+        print(f"Error downloading audio: {e}")
+        return None
+
+def calculate_font_size(text, max_width, max_height, font_path=None):
     """Calculate optimal font size based on text length and video dimensions"""
     char_count = len(text)
     
@@ -69,9 +157,12 @@ def create_text_clip(text, font_size, video_size, position, duration, start_time
         else:
             # Try to use a system font that supports Unicode
             try:
-                font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", font_size)
+                font = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", font_size)
             except:
-                font = ImageFont.load_default()
+                try:
+                    font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", font_size)
+                except:
+                    font = ImageFont.load_default()
     except:
         font = ImageFont.load_default()
     
@@ -110,27 +201,49 @@ def create_text_clip(text, font_size, video_size, position, duration, start_time
 def process_video(video_url, music_url, poem_verse, poet_name, username, progress=gr.Progress()):
     """Main function to process video with text overlays and animations"""
     
-    progress(0.1, desc="Downloading video...")
-    
-    # Download video
-    video_path = download_from_google_drive(video_url)
-    if not video_path:
-        return "Error: Could not download video"
-    
     try:
-        # Load video
+        if not video_url or not video_url.strip():
+            return "Error: Please provide a video URL"
+        
+        if not poem_verse or not poem_verse.strip():
+            return "Error: Please provide a poem verse"
+            
+        if not poet_name or not poet_name.strip():
+            return "Error: Please provide a poet name"
+            
+        if not username or not username.strip():
+            return "Error: Please provide a username"
+        
+        progress(0.1, desc="Downloading video...")
+        
+        # Download video
+        video_path = download_from_google_drive(video_url)
+        if not video_path or not os.path.exists(video_path):
+            return "Error: Could not download video. Please check the URL and ensure the file is publicly accessible."
+        
         progress(0.2, desc="Loading video...")
+        
+        # Load video
         video = mp.VideoFileClip(video_path)
         
         # Download and process audio if music URL provided
+        audio = None
         if music_url and music_url.strip():
             progress(0.3, desc="Processing audio...")
-            if music_url.startswith('http'):
-                music_path = tempfile.mktemp(suffix='.mp3')
-                response = requests.get(music_url)
-                with open(music_path, 'wb') as f:
-                    f.write(response.content)
-                audio = mp.AudioFileClip(music_path)
+            audio_path = download_audio_file(music_url)
+            if audio_path and os.path.exists(audio_path):
+                try:
+                    audio = mp.AudioFileClip(audio_path)
+                    # Match audio duration to video duration
+                    if audio.duration > video.duration:
+                        audio = audio.subclip(0, video.duration)
+                    elif audio.duration < video.duration:
+                        # Loop audio if shorter than video
+                        loops_needed = int(video.duration / audio.duration) + 1
+                        audio = mp.concatenate_audioclips([audio] * loops_needed).subclip(0, video.duration)
+                except Exception as e:
+                    print(f"Audio processing failed: {e}")
+                    audio = video.audio
             else:
                 audio = video.audio
         else:
@@ -143,7 +256,7 @@ def process_video(video_url, music_url, poem_verse, poet_name, username, progres
         duration = video.duration
         
         # Calculate font sizes
-        verse_font_size = calculate_font_size(poem_verse, video.w, video.h, None)
+        verse_font_size = calculate_font_size(poem_verse, video.w, video.h)
         poet_font_size = max(20, verse_font_size // 2)
         username_font_size = max(18, verse_font_size // 3)
         
@@ -207,7 +320,7 @@ def process_video(video_url, music_url, poem_verse, poet_name, username, progres
             output_path,
             codec='libx264',
             audio_codec='aac',
-            fps=video.fps,
+            fps=min(video.fps, 30),  # Limit FPS for better performance
             preset='medium',
             ffmpeg_params=['-crf', '23']
         )
@@ -216,13 +329,16 @@ def process_video(video_url, music_url, poem_verse, poet_name, username, progres
         
         # Clean up
         video.close()
-        if audio:
+        if audio and audio != video.audio:
             audio.close()
         final_video.close()
         
         # Clean up temporary files
-        if os.path.exists(video_path):
-            os.remove(video_path)
+        try:
+            if os.path.exists(video_path):
+                os.remove(video_path)
+        except:
+            pass
         
         return output_path
         
@@ -242,7 +358,7 @@ def create_interface():
                 video_url = gr.Textbox(
                     label="Video URL (Google Drive)",
                     placeholder="https://drive.google.com/file/d/your-file-id/view",
-                    lines=1
+                    lines=2
                 )
                 
                 music_url = gr.Textbox(
@@ -276,7 +392,9 @@ def create_interface():
                 
                 gr.Markdown("""
                 ### 📝 Instructions:
-                1. **Video URL**: Paste Google Drive video link (make sure it's publicly accessible)
+                1. **Video URL**: Paste Google Drive video link 
+                   - Format: `https://drive.google.com/file/d/FILE_ID/view`
+                   - Make sure the file is publicly accessible
                 2. **Music URL**: Optional background music (or leave empty for original audio)
                 3. **Poem Verse**: Your poetry text (supports Unicode/RTL languages)
                 4. **Poet Name**: Will appear at bottom with "- " prefix
@@ -288,6 +406,11 @@ def create_interface():
                 - Smooth zoom animation for video focus
                 - RTL language support
                 - Clean, professional output
+                
+                ### 🔧 Troubleshooting:
+                - Ensure Google Drive file is publicly accessible
+                - Check that the URL format is correct
+                - Video should be in MP4 format for best results
                 """)
         
         create_btn.click(