updated

app.py

@@ -133,33 +133,56 @@ def process_url(url):
                 video_path = downloader.download_from_url(url)
 
                 if not video_path:
-                    raise RuntimeError("Video download failed")
-
+                    st.error("Video download failed")
+                    return
+
+                # Add extensive logging and checks
+                #st.write(f"Downloaded video path: {video_path}")
+                #st.write(f"Video file exists: {os.path.exists(video_path)}")
+
+                try:
+                    video_file_size = os.path.getsize(video_path)
+                    #
+                    #(f"Video file size: {video_file_size} bytes")
+
+                    if video_file_size == 0:
+                        st.error("Downloaded video file is empty")
+                        return
+                except Exception as size_error:
+                    st.error(f"Error checking file size: {size_error}")
+                    return
+
+            # Rest of the processing remains the same...
             st.info("Processing video...")
             process_dir = Path(temp_dir) / "output"
             process_dir.mkdir(exist_ok=True)
 
             video_proc = VideoProcessor(video_path, process_dir)
             audio_path = video_proc.extract_audio()
+
             if not audio_path:
-                raise RuntimeError("Audio extraction failed")
+                st.error("Audio extraction failed")
+                return
 
             st.info("Separating vocals...")
             audio_proc = AudioProcessor(audio_path, process_dir)
             if not audio_proc.run_demucs():
-                raise RuntimeError("Demucs processing failed")
+                st.error("Demucs processing failed")
+                return
 
             vocals_path = audio_proc.get_vocals_path()
             no_vocals_path = audio_proc.get_no_vocals_path()
 
             if not vocals_path or not no_vocals_path:
-                raise FileNotFoundError("Processed audio files not found")
+                st.error("Processed audio files not found")
+                return
 
             st.info("Creating final video...")
             final_video_path = video_proc.combine_video_audio(vocals_path)
 
             if not final_video_path:
-                raise RuntimeError("Final video creation failed")
+                st.error("Final video creation failed")
+                return
 
             col1, col2 = st.columns(2)
             if final_video_path:
@@ -185,8 +208,8 @@ def process_url(url):
 
         except Exception as e:
             st.error(f"An error occurred: {str(e)}")
-            reset_processing_state()
-            raise
+            import traceback
+            traceback.print_exc()  # This will print the full traceback
 
 
 # Page config

link_processor.py

@@ -2,46 +2,83 @@ from pathlib import Path
 import yt_dlp
 import os
 from concurrent.futures import ThreadPoolExecutor
-import streamlit as st
+import logging
+import shutil
 
 
 class LinkDownloader:
-    def __init__(self, output_dir):
+    def __init__(self, output_dir, max_workers=2):
         self.output_dir = Path(output_dir)
         self.output_dir.mkdir(parents=True, exist_ok=True)
-        self.executor = ThreadPoolExecutor(max_workers=2)
+        self.executor = ThreadPoolExecutor(max_workers=max_workers)
+
+        # Setup logging
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s'
+        )
+        self.logger = logging.getLogger(__name__)
 
     def download_from_url(self, url):
-        try:
-            temp_filepath = str(self.output_dir / 'downloaded_video.%(ext)s')
-
-            ydl_opts = {
-                'format': 'best[height<=1080]',
-                'outtmpl': temp_filepath,
-                'quiet': True,
-                'no_warnings': True,
-                'extract_audio': False,
-                'concurrent_fragment_downloads': 3,
-                'file_access_retries': 3,
-                'retries': 3,
-                'socket_timeout': 30,
-                'nocheckcertificate': True,
-            }
+        """Downloads a video from the given URL using yt_dlp."""
+        # Create a unique subdirectory to prevent file conflicts
+        unique_download_dir = self.output_dir / "download"
+        unique_download_dir.mkdir(parents=True, exist_ok=True)
+
+        temp_filepath = str(unique_download_dir / 'downloaded_video.%(ext)s')
 
+        ydl_opts = {
+            'format': 'best[height<=1080]',
+            'outtmpl': temp_filepath,
+            'quiet': False,
+            'no_warnings': True,
+            'extract_audio': False,
+            'concurrent_fragment_downloads': 3,
+            'file_access_retries': 3,
+            'retries': 3,
+            'socket_timeout': 30,
+            'nocheckcertificate': True,
+        }
+
+        try:
             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                # Get video information
                 info = ydl.extract_info(url, download=False)
                 ext = info.get('ext', 'mp4')
 
-                # Download in a separate thread
+                # Submit download task to executor
                 future = self.executor.submit(ydl.download, [url])
-                future.result()
+                future.result()  # Wait for download to complete
 
-                actual_filepath = str(self.output_dir / f"downloaded_video.{ext}")
-                return actual_filepath if os.path.exists(actual_filepath) else None
+                # Find the downloaded file
+                downloaded_files = list(unique_download_dir.glob(f'downloaded_video.{ext}'))
 
+                if not downloaded_files:
+                    self.logger.error("No files found after download.")
+                    return None
+
+                # Take the first file (should be the only one)
+                actual_filepath = str(downloaded_files[0])
+
+                if os.path.exists(actual_filepath):
+                    # Copy the file to the main output directory to prevent deletion
+                    final_filepath = str(self.output_dir / f"downloaded_video.{ext}")
+                    shutil.copy2(actual_filepath, final_filepath)
+
+                    self.logger.info(f"Download completed: {final_filepath}")
+                    return final_filepath
+                else:
+                    self.logger.error("File not found after download.")
+                    return None
+
+        except yt_dlp.DownloadError as e:
+            self.logger.error(f"yt_dlp error: {e}")
         except Exception as e:
-            print(f"Download error: {e}")
-            return None
+            self.logger.error(f"Unexpected error: {e}")
+
+        return None
 
     def __del__(self):
-        self.executor.shutdown(wait=False)
+        """Ensure proper shutdown of the executor."""
+        self.executor.shutdown(wait=True)
+        self.logger.info("ThreadPoolExecutor shut down.")

requirements.txt

@@ -7,4 +7,4 @@ demucs==4.0.1
 soundfile==0.12.1
 diffq==0.2.4
 ffmpeg-python==0.2.0
-yt-dlp==2023.10.07
+yt-dlp==2024.12.23

video_processor.py

@@ -21,51 +21,65 @@ class VideoProcessor:
 
             # Print file size and check if it's not empty
             file_size = os.path.getsize(self.input_video)
-            print(f"Input video file size: {file_size} bytes")
+            #st.info(f"Input video file size: {file_size} bytes")
             if file_size == 0:
                 st.error("Input video file is empty")
                 return None
 
+            # Ensure output directory exists
+            self.temp_audio.parent.mkdir(parents=True, exist_ok=True)
+
             # Construct FFmpeg command with detailed logging
             command = [
                 "ffmpeg",
-                "-v", "verbose",  # Enable verbose logging
+                "-v", "error",  # Change to error to reduce verbose output
                 "-i", str(self.input_video),
                 "-vn",  # No video
-                "-acodec", "pcm_s16le",
-                "-ar", "44100",
+                "-acodec", "pcm_s16le",  # 16-bit PCM
+                "-ar", "44100",  # 44.1kHz sample rate
+                "-ac", "2",  # Stereo
                 "-y",  # Overwrite output file if it exists
                 str(self.temp_audio)
             ]
 
             # Run FFmpeg command and capture output
-            process = subprocess.run(
-                command,
-                capture_output=True,
-                text=True,
-                check=False  # Don't raise exception immediately
-            )
-
-            # Print FFmpeg output for debugging
-            print("FFmpeg stdout:", process.stdout)
-            print("FFmpeg stderr:", process.stderr)
-
-            # Check if the command was successful
-            if process.returncode != 0:
-                st.error(f"FFmpeg error: {process.stderr}")
+            try:
+                # Use subprocess.run with timeout to prevent hanging
+                process = subprocess.run(
+                    command,
+                    capture_output=True,
+                    text=True,
+                    timeout=60  # 60 seconds timeout
+                )
+
+                # Check for any errors
+                if process.returncode != 0:
+                    st.error(f"FFmpeg error: {process.stderr}")
+                    st.error(f"FFmpeg command: {' '.join(command)}")
+                    return None
+
+            except subprocess.TimeoutExpired:
+                st.error("Audio extraction timed out")
+                return None
+            except Exception as e:
+                st.error(f"Unexpected error during FFmpeg execution: {str(e)}")
                 return None
 
             # Verify the output audio file exists and is not empty
-            if not self.temp_audio.exists() or os.path.getsize(self.temp_audio) == 0:
-                st.error("Audio extraction failed: Output file is missing or empty")
+            if not self.temp_audio.exists():
+                st.error("Audio extraction failed: Output file is missing")
                 return None
 
-            print(f"Audio extracted successfully to {self.temp_audio}")
+            file_size = os.path.getsize(self.temp_audio)
+            if file_size == 0:
+                st.error("Audio extraction failed: Output file is empty")
+                return None
+
+            #st.success(f"Audio extracted successfully to {self.temp_audio}")
             return str(self.temp_audio)
 
         except Exception as e:
-            st.error(f"Error during audio extraction: {str(e)}")
-            print(f"Exception details: {str(e)}")
+            st.error(f"Unexpected error during audio extraction: {str(e)}")
             return None
 
     def combine_video_audio(self, vocals_path):