karaoke-gen 0.57.0__py3-none-any.whl → 0.71.23__py3-none-any.whl

karaoke_gen/karaoke_gen.py

@@ -28,6 +28,8 @@ from .file_handler import FileHandler
 from .audio_processor import AudioProcessor
 from .lyrics_processor import LyricsProcessor
 from .video_generator import VideoGenerator
+from .video_background_processor import VideoBackgroundProcessor
+from .audio_fetcher import create_audio_fetcher, AudioFetcherError, NoResultsError
 
 
 class KaraokePrep:
@@ -67,10 +69,14 @@ class KaraokePrep:
         subtitle_offset_ms=0,
         # Style Configuration
         style_params_json=None,
+        style_overrides=None,
         # Add the new parameter
         skip_separation=False,
-        # YouTube/Online Configuration
-        cookies_str=None,
+        # Video Background Configuration
+        background_video=None,
+        background_video_darkness=0,
+        # Audio Fetcher Configuration
+        auto_download=False,
     ):
         self.log_level = log_level
         self.log_formatter = log_formatter
@@ -124,13 +130,30 @@ class KaraokePrep:
 
         # Style Config - Keep needed ones
         self.render_bounding_boxes = render_bounding_boxes # Passed to VideoGenerator
-        self.style_params_json = style_params_json # Passed to LyricsProcessor
+        self.style_params_json = style_params_json
+        self.style_overrides = style_overrides
+        self.temp_style_file = None
 
-        # YouTube/Online Config
-        self.cookies_str = cookies_str # Passed to metadata extraction and file download
+        # Video Background Config
+        self.background_video = background_video
+        self.background_video_darkness = background_video_darkness
+
+        # Audio Fetcher Config (replaces yt-dlp)
+        self.auto_download = auto_download  # If True, automatically select best audio source
+        
+        # Initialize audio fetcher for searching and downloading audio when no input file is provided
+        self.audio_fetcher = create_audio_fetcher(logger=self.logger)
 
         # Load style parameters using the config module
-        self.style_params = load_style_params(self.style_params_json, self.logger)
+        self.style_params = load_style_params(self.style_params_json, self.style_overrides, self.logger)
+
+        # If overrides were applied, write to a temp file and update the path
+        if self.style_overrides:
+            with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=".json") as temp_file:
+                json.dump(self.style_params, temp_file, indent=2)
+                self.temp_style_file = temp_file.name
+                self.style_params_json = self.temp_style_file
+                self.logger.info(f"Style overrides applied. Using temporary style file: {self.temp_style_file}")
 
         # Set up title and end formats using the config module
         self.title_format = setup_title_format(self.style_params)
@@ -181,6 +204,16 @@ class KaraokePrep:
              output_jpg=self.output_jpg,
         )
 
+        # Instantiate VideoBackgroundProcessor if background_video is provided
+        if self.background_video:
+            self.logger.info(f"Video background enabled: {self.background_video}")
+            self.video_background_processor = VideoBackgroundProcessor(
+                logger=self.logger,
+                ffmpeg_base_command=self.ffmpeg_base_command,
+            )
+        else:
+            self.video_background_processor = None
+
         self.logger.debug(f"Initialized title_format with extra_text: {self.title_format['extra_text']}")
         self.logger.debug(f"Initialized title_format with extra_text_region: {self.title_format['extra_text_region']}")
 
@@ -199,10 +232,19 @@ class KaraokePrep:
         else:
             self.logger.debug(f"Overall output dir {self.output_dir} already exists")
 
+    def __del__(self):
+        # Cleanup the temporary style file if it was created
+        if self.temp_style_file and os.path.exists(self.temp_style_file):
+            try:
+                os.remove(self.temp_style_file)
+                self.logger.debug(f"Removed temporary style file: {self.temp_style_file}")
+            except OSError as e:
+                self.logger.warning(f"Error removing temporary style file {self.temp_style_file}: {e}")
+
     # Compatibility methods for tests - these call the new functions in metadata.py
     def extract_info_for_online_media(self, input_url=None, input_artist=None, input_title=None):
         """Compatibility method that calls the function in metadata.py"""
-        self.extracted_info = extract_info_for_online_media(input_url, input_artist, input_title, self.logger, self.cookies_str)
+        self.extracted_info = extract_info_for_online_media(input_url, input_artist, input_title, self.logger)
         return self.extracted_info
 
     def parse_single_track_metadata(self, input_artist, input_title):
@@ -327,51 +369,77 @@ class KaraokePrep:
                     processed_track["input_audio_wav"] = self.file_handler.convert_to_wav(processed_track["input_media"], output_filename_no_extension)
 
             else:
-                # --- URL or Existing Files Handling ---
+                # --- AudioFetcher or Existing Files Handling ---
                 # Construct patterns using the determined extractor
                 base_pattern = os.path.join(track_output_dir, f"{artist_title} ({self.extractor}*)")
-                input_media_glob = glob.glob(f"{base_pattern}.*webm") + glob.glob(f"{base_pattern}.*mp4") # Add other common formats if needed
+                input_media_glob = glob.glob(f"{base_pattern}.*flac") + glob.glob(f"{base_pattern}.*mp3") + glob.glob(f"{base_pattern}.*wav") + glob.glob(f"{base_pattern}.*webm") + glob.glob(f"{base_pattern}.*mp4")
                 input_png_glob = glob.glob(f"{base_pattern}.png")
                 input_wav_glob = glob.glob(f"{base_pattern}.wav")
 
-                if input_media_glob and input_png_glob and input_wav_glob:
+                if input_media_glob and input_wav_glob:
                     # Existing files found
                     processed_track["input_media"] = input_media_glob[0]
-                    processed_track["input_still_image"] = input_png_glob[0]
+                    processed_track["input_still_image"] = input_png_glob[0] if input_png_glob else None
                     processed_track["input_audio_wav"] = input_wav_glob[0]
                     self.logger.info(f"Found existing media files matching extractor '{self.extractor}', skipping download/conversion.")
-                    # Ensure self.extractor reflects the found files if it was a fallback
-                    # Extract the actual extractor string from the filename if needed, though it should match
-
-                elif self.url: # URL provided and files not found, proceed with download
-                    # Use media_id if available for better uniqueness
-                    filename_suffix = f"{self.extractor} {self.media_id}" if self.media_id else self.extractor
-                    output_filename_no_extension = os.path.join(track_output_dir, f"{artist_title} ({filename_suffix})")
-
-                    self.logger.info(f"Downloading input media from {self.url}...")
-                    # Delegate to FileHandler
-                    processed_track["input_media"] = self.file_handler.download_video(self.url, output_filename_no_extension, self.cookies_str)
 
-                    self.logger.info("Extracting still image from downloaded media (if input is video)...")
-                    # Delegate to FileHandler
-                    processed_track["input_still_image"] = self.file_handler.extract_still_image_from_video(
-                        processed_track["input_media"], output_filename_no_extension
-                    )
-
-                    self.logger.info("Converting downloaded video to WAV for audio processing...")
-                    # Delegate to FileHandler
-                    processed_track["input_audio_wav"] = self.file_handler.convert_to_wav(
-                        processed_track["input_media"], output_filename_no_extension
-                    )
+                elif getattr(self, '_use_audio_fetcher', False):
+                    # Use flacfetch to search and download audio
+                    self.logger.info(f"Using flacfetch to search and download: {self.artist} - {self.title}")
+                    
+                    try:
+                        # Search and download audio using the AudioFetcher
+                        fetch_result = self.audio_fetcher.search_and_download(
+                            artist=self.artist,
+                            title=self.title,
+                            output_dir=track_output_dir,
+                            output_filename=f"{artist_title} (flacfetch)",
+                            auto_select=self.auto_download,
+                        )
+                        
+                        # Update extractor to reflect the actual provider used
+                        self.extractor = f"flacfetch-{fetch_result.provider}"
+                        
+                        # Set up the output paths
+                        output_filename_no_extension = os.path.join(track_output_dir, f"{artist_title} ({self.extractor})")
+                        
+                        # Copy/move the downloaded file to the expected location
+                        processed_track["input_media"] = self.file_handler.download_audio_from_fetcher_result(
+                            fetch_result.filepath, output_filename_no_extension
+                        )
+                        
+                        self.logger.info(f"Audio downloaded from {fetch_result.provider}: {processed_track['input_media']}")
+                        
+                        # Convert to WAV for audio processing
+                        self.logger.info("Converting downloaded audio to WAV for processing...")
+                        processed_track["input_audio_wav"] = self.file_handler.convert_to_wav(
+                            processed_track["input_media"], output_filename_no_extension
+                        )
+                        
+                        # No still image for audio-only downloads
+                        processed_track["input_still_image"] = None
+                        
+                    except NoResultsError as e:
+                        self.logger.error(f"No audio found: {e}")
+                        return None
+                    except AudioFetcherError as e:
+                        self.logger.error(f"Failed to fetch audio: {e}")
+                        return None
+                        
                 else:
-                     # This case means input_media was None, not a URL, and no existing files found
-                     self.logger.error(f"Cannot proceed: No input file, no URL, and no existing files found for {artist_title}.")
-                     return None
+                    # This case means input_media was None, no audio fetcher flag, and no existing files found
+                    self.logger.error(f"Cannot proceed: No input file and no existing files found for {artist_title}.")
+                    self.logger.error("Please provide a local audio file or use artist+title to search for audio.")
+                    return None
 
             if self.skip_lyrics:
                 self.logger.info("Skipping lyrics fetch as requested.")
                 processed_track["lyrics"] = None
                 processed_track["processed_lyrics"] = None
+                # No countdown padding when lyrics are skipped
+                processed_track["countdown_padding_added"] = False
+                processed_track["countdown_padding_seconds"] = 0.0
+                processed_track["padded_vocals_audio"] = None
             else:
                 lyrics_artist = self.lyrics_artist or self.artist
                 lyrics_title = self.lyrics_title or self.title
@@ -463,6 +531,23 @@ class KaraokePrep:
                             if isinstance(transcriber_outputs, dict):
                                 self.lyrics = transcriber_outputs.get("corrected_lyrics_text")
                                 processed_track["lyrics"] = transcriber_outputs.get("corrected_lyrics_text_filepath")
+                                
+                                # Capture countdown padding information
+                                processed_track["countdown_padding_added"] = transcriber_outputs.get("countdown_padding_added", False)
+                                processed_track["countdown_padding_seconds"] = transcriber_outputs.get("countdown_padding_seconds", 0.0)
+                                processed_track["padded_vocals_audio"] = transcriber_outputs.get("padded_audio_filepath")
+                                
+                                # Store ASS filepath for video background processing
+                                processed_track["ass_filepath"] = transcriber_outputs.get("ass_filepath")
+                                
+                                if processed_track["countdown_padding_added"]:
+                                    self.logger.info(
+                                        f"=== COUNTDOWN PADDING DETECTED ==="
+                                    )
+                                    self.logger.info(
+                                        f"Vocals have been padded with {processed_track['countdown_padding_seconds']}s of silence. "
+                                        f"Instrumental tracks will be padded after separation to maintain synchronization."
+                                    )
                             else:
                                 self.logger.warning(f"Unexpected type for transcriber_outputs: {type(transcriber_outputs)}, value: {transcriber_outputs}")
                         else:
@@ -476,7 +561,7 @@ class KaraokePrep:
                 # Check if separation_future was the placeholder or a real task
                 # The result index in `results` depends on whether transcription_future existed
                 separation_result_index = 1 if transcription_future else 0
-                if separation_future is not None and not isinstance(separation_future, asyncio.Task) and len(results) > separation_result_index:
+                if separation_future is not None and isinstance(separation_future, asyncio.Task) and len(results) > separation_result_index:
                     self.logger.info("Processing separation results...")
                     try:
                         separation_results = results[separation_result_index]
@@ -506,6 +591,78 @@ class KaraokePrep:
 
                 self.logger.info("=== Parallel Processing Complete ===")
 
+            # Apply video background if requested and lyrics were processed
+            if self.video_background_processor and processed_track.get("lyrics"):
+                self.logger.info("=== Processing Video Background ===")
+                
+                # Find the With Vocals video file
+                with_vocals_video = os.path.join(track_output_dir, f"{artist_title} (With Vocals).mkv")
+                
+                # Get ASS file from transcriber outputs if available
+                ass_file = processed_track.get("ass_filepath")
+                
+                # If not in processed_track, try to find it in common locations
+                if not ass_file or not os.path.exists(ass_file):
+                    self.logger.info("ASS filepath not found in transcriber outputs, searching for it...")
+                    from .utils import sanitize_filename
+                    sanitized_artist = sanitize_filename(self.artist)
+                    sanitized_title = sanitize_filename(self.title)
+                    lyrics_dir = os.path.join(track_output_dir, "lyrics")
+                    
+                    possible_ass_files = [
+                        os.path.join(lyrics_dir, f"{sanitized_artist} - {sanitized_title}.ass"),
+                        os.path.join(track_output_dir, f"{sanitized_artist} - {sanitized_title}.ass"),
+                        os.path.join(lyrics_dir, f"{artist_title}.ass"),
+                        os.path.join(track_output_dir, f"{artist_title}.ass"),
+                        os.path.join(track_output_dir, f"{artist_title} (Karaoke).ass"),
+                        os.path.join(lyrics_dir, f"{artist_title} (Karaoke).ass"),
+                    ]
+                    
+                    for possible_file in possible_ass_files:
+                        if os.path.exists(possible_file):
+                            ass_file = possible_file
+                            self.logger.info(f"Found ASS subtitle file: {ass_file}")
+                            break
+                
+                if os.path.exists(with_vocals_video) and ass_file and os.path.exists(ass_file):
+                    self.logger.info(f"Found With Vocals video, will replace with video background: {with_vocals_video}")
+                    self.logger.info(f"Using ASS subtitle file: {ass_file}")
+                    
+                    # Get audio duration
+                    audio_duration = self.video_background_processor.get_audio_duration(processed_track["input_audio_wav"])
+                    
+                    # Check if we need to use the padded audio instead
+                    if processed_track.get("countdown_padding_added") and processed_track.get("padded_vocals_audio"):
+                        self.logger.info(f"Using padded vocals audio for video background processing")
+                        audio_for_video = processed_track["padded_vocals_audio"]
+                    else:
+                        audio_for_video = processed_track["input_audio_wav"]
+                    
+                    # Process video background
+                    try:
+                        self.video_background_processor.process_video_background(
+                            video_path=self.background_video,
+                            audio_path=audio_for_video,
+                            ass_subtitles_path=ass_file,
+                            output_path=with_vocals_video,
+                            darkness_percent=self.background_video_darkness,
+                            audio_duration=audio_duration,
+                        )
+                        self.logger.info(f"✓ Video background applied, With Vocals video updated: {with_vocals_video}")
+                    except Exception as e:
+                        self.logger.error(f"Failed to apply video background: {e}")
+                        self.logger.exception("Full traceback:")
+                        # Continue with original video if background processing fails
+                else:
+                    if not os.path.exists(with_vocals_video):
+                        self.logger.warning(f"With Vocals video not found at {with_vocals_video}, skipping video background processing")
+                    elif not ass_file or not os.path.exists(ass_file):
+                        self.logger.warning("Could not find ASS subtitle file, skipping video background processing")
+                        if 'possible_ass_files' in locals():
+                            self.logger.warning("Searched locations:")
+                            for possible_file in possible_ass_files:
+                                self.logger.warning(f"  - {possible_file}")
+
             output_image_filepath_noext = os.path.join(track_output_dir, f"{artist_title} (Title)")
             processed_track["title_image_png"] = f"{output_image_filepath_noext}.png"
             processed_track["title_image_jpg"] = f"{output_image_filepath_noext}.jpg"
@@ -566,16 +723,58 @@ class KaraokePrep:
                     "instrumental": instrumental_path,
                     "vocals": None,
                 }
-            else:
-                # Only run separation if not skipped
-                if not self.skip_separation:
-                    self.logger.info(f"Separating audio for track: {self.title} by {self.artist}")
-                    # Delegate to AudioProcessor (called directly, not in thread here)
-                    separation_results = self.audio_processor.process_audio_separation(
-                        audio_file=processed_track["input_audio_wav"], artist_title=artist_title, track_output_dir=track_output_dir
+                
+                # If countdown padding was added to vocals, pad the custom instrumental too
+                if processed_track.get("countdown_padding_added", False):
+                    padding_seconds = processed_track["countdown_padding_seconds"]
+                    self.logger.info(
+                        f"Countdown padding detected - applying {padding_seconds}s padding to custom instrumental"
                     )
-                    processed_track["separated_audio"] = separation_results
-                # We don't need an else here, if skip_separation is true, separated_audio remains the default empty dict
+                    
+                    base, ext = os.path.splitext(instrumental_path)
+                    padded_instrumental_path = f"{base} (Padded){ext}"
+                    
+                    if not self.file_handler._file_exists(padded_instrumental_path):
+                        self.audio_processor.pad_audio_file(instrumental_path, padded_instrumental_path, padding_seconds)
+                    
+                    # Update the path to use the padded version
+                    processed_track["separated_audio"]["Custom"]["instrumental"] = padded_instrumental_path
+                    self.logger.info(f"✓ Custom instrumental has been padded and synchronized with vocals")
+            elif "separated_audio" not in processed_track or not processed_track["separated_audio"]:
+                # Only run separation if it wasn't already done in parallel processing
+                self.logger.info(f"Separation was not completed in parallel processing, running separation for track: {self.title} by {self.artist}")
+                # Delegate to AudioProcessor (called directly, not in thread here)
+                separation_results = self.audio_processor.process_audio_separation(
+                    audio_file=processed_track["input_audio_wav"], artist_title=artist_title, track_output_dir=track_output_dir
+                )
+                processed_track["separated_audio"] = separation_results
+            else:
+                self.logger.info("Audio separation was already completed in parallel processing, skipping duplicate separation.")
+
+            # Apply countdown padding to instrumental files if needed
+            if processed_track.get("countdown_padding_added", False):
+                padding_seconds = processed_track["countdown_padding_seconds"]
+                self.logger.info(
+                    f"=== APPLYING COUNTDOWN PADDING TO INSTRUMENTALS ==="
+                )
+                self.logger.info(
+                    f"Applying {padding_seconds}s padding to all instrumental files to sync with vocal countdown"
+                )
+                
+                # Apply padding using AudioProcessor
+                padded_separation_result = self.audio_processor.apply_countdown_padding_to_instrumentals(
+                    separation_result=processed_track["separated_audio"],
+                    padding_seconds=padding_seconds,
+                    artist_title=artist_title,
+                    track_output_dir=track_output_dir,
+                )
+                
+                # Update processed_track with padded file paths
+                processed_track["separated_audio"] = padded_separation_result
+                
+                self.logger.info(
+                    f"✓ All instrumental files have been padded and are now synchronized with vocals"
+                )
 
             self.logger.info("Script finished, audio downloaded, lyrics fetched and audio separated!")
 
@@ -680,21 +879,31 @@ class KaraokePrep:
             self.logger.info(f"Input media {self.input_media} is a local folder, processing each file individually...")
             return await self.process_folder()
         elif self.input_media is not None and os.path.isfile(self.input_media):
-            self.logger.info(f"Input media {self.input_media} is a local file, youtube logic will be skipped")
+            self.logger.info(f"Input media {self.input_media} is a local file, audio download will be skipped")
+            return [await self.prep_single_track()]
+        elif self.artist and self.title:
+            # No input file provided - use flacfetch to search and download audio
+            self.logger.info(f"No input file provided, using flacfetch to search for: {self.artist} - {self.title}")
+            
+            # Set up the extracted_info for metadata consistency
+            self.extracted_info = {
+                "title": f"{self.artist} - {self.title}",
+                "artist": self.artist,
+                "track_title": self.title,
+                "extractor_key": "flacfetch",
+                "id": f"flacfetch_{self.artist}_{self.title}".replace(" ", "_"),
+                "url": None,
+                "source": "flacfetch",
+            }
+            self.extractor = "flacfetch"
+            self.url = None  # URL will be determined by flacfetch
+            
+            # Mark that we need to use audio fetcher for download
+            self._use_audio_fetcher = True
+            
             return [await self.prep_single_track()]
         else:
-            self.url = self.input_media
-            # Use the imported extract_info_for_online_media function
-            self.extracted_info = extract_info_for_online_media(
-                input_url=self.url, input_artist=self.artist, input_title=self.title, logger=self.logger, cookies_str=self.cookies_str
+            raise ValueError(
+                "Either a local file path or both artist and title must be provided. "
+                "URL-based input has been replaced with flacfetch audio fetching."
             )
-
-            if self.extracted_info and "playlist_count" in self.extracted_info:
-                self.persistent_artist = self.artist
-                self.logger.info(f"Input URL is a playlist, beginning batch operation with persistent artist: {self.persistent_artist}")
-                return await self.process_playlist()
-            else:
-                self.logger.info(f"Input URL is not a playlist, processing single track")
-                # Parse metadata to extract artist and title before processing
-                self.parse_single_track_metadata(self.artist, self.title)
-                return [await self.prep_single_track()]

karaoke_gen/lyrics_processor.py

@@ -274,7 +274,8 @@ class LyricsProcessor:
 
             # Save correction data to JSON file for review interface
             # Use the expected filename format: "{artist} - {title} (Lyrics Corrections).json"
-            corrections_filename = f"{filename_artist} - {filename_title} (Lyrics Corrections).json"
+            # Use sanitized names to be consistent with all other files created by lyrics_transcriber
+            corrections_filename = f"{sanitized_artist} - {sanitized_title} (Lyrics Corrections).json"
             corrections_filepath = os.path.join(lyrics_dir, corrections_filename)
             
             # Use the CorrectionResult's to_dict() method to serialize
@@ -285,6 +286,17 @@ class LyricsProcessor:
             
             self.logger.info(f"Saved correction data to {corrections_filepath}")
 
+        # Capture countdown padding information for syncing with instrumental audio
+        transcriber_outputs["countdown_padding_added"] = getattr(results, "countdown_padding_added", False)
+        transcriber_outputs["countdown_padding_seconds"] = getattr(results, "countdown_padding_seconds", 0.0)
+        transcriber_outputs["padded_audio_filepath"] = getattr(results, "padded_audio_filepath", None)
+        
+        if transcriber_outputs["countdown_padding_added"]:
+            self.logger.info(
+                f"Countdown padding detected: {transcriber_outputs['countdown_padding_seconds']}s added to vocals. "
+                f"Instrumental audio will need to be padded accordingly."
+            )
+
         if transcriber_outputs:
             self.logger.info(f"*** Transcriber Filepath Outputs: ***")
             for key, value in transcriber_outputs.items():

karaoke_gen/metadata.py

@@ -1,86 +1,67 @@
 import logging
-import yt_dlp.YoutubeDL as ydl
+
 
 def extract_info_for_online_media(input_url, input_artist, input_title, logger, cookies_str=None):
-    """Extracts metadata using yt-dlp, either from a URL or via search."""
-    logger.info(f"Extracting info for input_url: {input_url} input_artist: {input_artist} input_title: {input_title}")
+    """
+    Creates metadata info dict from provided artist and title.
     
-    # Set up yt-dlp options with enhanced anti-detection
-    base_opts = {
-        "quiet": True,
-        # Anti-detection options
-        "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-        "referer": "https://www.youtube.com/",
-        "sleep_interval": 1,
-        "max_sleep_interval": 3,
-        "fragment_retries": 3,
-        "extractor_retries": 3,
-        "retries": 3,
-        # Headers to appear more human
-        "http_headers": {
-            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-            "Accept-Language": "en-us,en;q=0.5",
-            "Accept-Encoding": "gzip, deflate",
-            "DNT": "1",
-            "Connection": "keep-alive",
-            "Upgrade-Insecure-Requests": "1",
-        },
-    }
+    Note: This function no longer supports URL-based metadata extraction.
+    Audio search and download is now handled by the AudioFetcher class using flacfetch.
     
-    # Add cookies if provided
-    if cookies_str:
-        logger.info("Using provided cookies for enhanced YouTube access")
-        # Save cookies to a temporary file
-        import tempfile
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
-            f.write(cookies_str)
-            base_opts['cookiefile'] = f.name
-    else:
-        logger.info("No cookies provided - attempting standard extraction")
+    When both artist and title are provided, this creates a metadata dict that can be
+    used by the rest of the pipeline.
     
-    extracted_info = None
-    try:
-        if input_url is not None:
-            # If a URL is provided, use it to extract the metadata
-            with ydl(base_opts) as ydl_instance:
-                extracted_info = ydl_instance.extract_info(input_url, download=False)
-        else:
-            # If no URL is provided, use the query to search for the top result
-            search_opts = base_opts.copy()
-            search_opts.update({
-                "format": "bestaudio", 
-                "noplaylist": "True", 
-                "extract_flat": True
-            })
-            
-            with ydl(search_opts) as ydl_instance:
-                query = f"{input_artist} {input_title}"
-                search_results = ydl_instance.extract_info(f"ytsearch1:{query}", download=False)
-                if search_results and "entries" in search_results and search_results["entries"]:
-                     extracted_info = search_results["entries"][0]
-                else:
-                    # Raise IndexError to match the expected exception in tests
-                    raise IndexError(f"No search results found on YouTube for query: {input_artist} {input_title}")
-
-        if not extracted_info:
-             raise Exception(f"Failed to extract info for query: {input_artist} {input_title} or URL: {input_url}")
-
-        return extracted_info
+    Args:
+        input_url: Deprecated - URLs should be provided as local file paths or use AudioFetcher
+        input_artist: The artist name
+        input_title: The track title
+        logger: Logger instance
+        cookies_str: Deprecated - no longer used
+        
+    Returns:
+        A dict with metadata if artist and title are provided
         
-    finally:
-        # Clean up temporary cookie file if it was created
-        if cookies_str and 'cookiefile' in base_opts:
-            try:
-                import os
-                os.unlink(base_opts['cookiefile'])
-            except:
-                pass
+    Raises:
+        ValueError: If URL is provided (deprecated) or if artist/title are missing
+    """
+    logger.info(f"Extracting info for input_url: {input_url} input_artist: {input_artist} input_title: {input_title}")
+    
+    # URLs are no longer supported - use AudioFetcher for search and download
+    if input_url is not None:
+        raise ValueError(
+            "URL-based audio fetching has been replaced with flacfetch. "
+            "Please provide a local file path instead, or use artist and title only "
+            "to search for audio via flacfetch."
+        )
+    
+    # When artist and title are provided, create a synthetic metadata dict
+    # The actual search and download is handled by AudioFetcher
+    if input_artist and input_title:
+        logger.info(f"Creating metadata for: {input_artist} - {input_title}")
+        return {
+            "title": f"{input_artist} - {input_title}",
+            "artist": input_artist,
+            "track_title": input_title,
+            "extractor_key": "flacfetch",
+            "id": f"flacfetch_{input_artist}_{input_title}".replace(" ", "_"),
+            "url": None,  # URL will be determined by flacfetch during download
+            "source": "flacfetch",
+        }
+    
+    # No valid input provided
+    raise ValueError(
+        f"Artist and title are required for audio search. "
+        f"Received artist: {input_artist}, title: {input_title}"
+    )
 
 
 def parse_track_metadata(extracted_info, current_artist, current_title, persistent_artist, logger):
     """
     Parses extracted_info to determine URL, extractor, ID, artist, and title.
     Returns a dictionary with the parsed values.
+    
+    This function now supports both legacy yt-dlp style metadata and 
+    the new flacfetch-based metadata format.
     """
     parsed_data = {
         "url": None,
@@ -93,19 +74,43 @@ def parse_track_metadata(extracted_info, current_artist, current_title, persiste
     metadata_artist = ""
     metadata_title = ""
 
+    # Handle flacfetch-style metadata (no URL required)
+    if extracted_info.get("source") == "flacfetch":
+        parsed_data["url"] = None  # URL determined at download time
+        parsed_data["extractor"] = "flacfetch"
+        parsed_data["media_id"] = extracted_info.get("id")
+        
+        # Use the provided artist/title directly
+        if extracted_info.get("artist"):
+            parsed_data["artist"] = extracted_info["artist"]
+        if extracted_info.get("track_title"):
+            parsed_data["title"] = extracted_info["track_title"]
+            
+        if persistent_artist:
+            parsed_data["artist"] = persistent_artist
+            
+        logger.info(f"Using flacfetch metadata: artist: {parsed_data['artist']}, title: {parsed_data['title']}")
+        return parsed_data
+
+    # Legacy yt-dlp style metadata handling (for backward compatibility)
     if "url" in extracted_info:
         parsed_data["url"] = extracted_info["url"]
     elif "webpage_url" in extracted_info:
         parsed_data["url"] = extracted_info["webpage_url"]
     else:
-        raise Exception(f"Failed to extract URL from input media metadata: {extracted_info}")
+        # For flacfetch results without URL, this is now acceptable
+        logger.debug("No URL in extracted info - will be determined at download time")
+        parsed_data["url"] = None
 
     if "extractor_key" in extracted_info:
         parsed_data["extractor"] = extracted_info["extractor_key"]
     elif "ie_key" in extracted_info:
         parsed_data["extractor"] = extracted_info["ie_key"]
+    elif extracted_info.get("source") == "flacfetch":
+        parsed_data["extractor"] = "flacfetch"
     else:
-        raise Exception(f"Failed to find extractor name from input media metadata: {extracted_info}")
+        # Default to flacfetch if no extractor specified
+        parsed_data["extractor"] = "flacfetch"
 
     if "id" in extracted_info:
         parsed_data["media_id"] = extracted_info["id"]
@@ -147,7 +152,7 @@ def parse_track_metadata(extracted_info, current_artist, current_title, persiste
         parsed_data["artist"] = persistent_artist
 
     if parsed_data["artist"] and parsed_data["title"]:
-        logger.info(f"Extracted url: {parsed_data['url']}, artist: {parsed_data['artist']}, title: {parsed_data['title']}")
+        logger.info(f"Parsed metadata - artist: {parsed_data['artist']}, title: {parsed_data['title']}")
     else:
         logger.debug(extracted_info)
         raise Exception("Failed to extract artist and title from the input media metadata.")