karaoke-gen 0.75.54__py3-none-any.whl

karaoke_gen/lyrics_processor.py

@@ -0,0 +1,474 @@
+import os
+import re
+import logging
+import shutil
+import json
+from lyrics_transcriber import LyricsTranscriber, OutputConfig, TranscriberConfig, LyricsConfig
+from lyrics_transcriber.core.controller import LyricsControllerResult
+from dotenv import load_dotenv
+from .utils import sanitize_filename
+
+
+# Placeholder class or functions for lyrics processing
+class LyricsProcessor:
+    # Standard countdown padding duration used by LyricsTranscriber
+    COUNTDOWN_PADDING_SECONDS = 3.0
+    
+    def __init__(
+        self, logger, style_params_json, lyrics_file, skip_transcription, skip_transcription_review, render_video, subtitle_offset_ms
+    ):
+        self.logger = logger
+        self.style_params_json = style_params_json
+        self.lyrics_file = lyrics_file
+        self.skip_transcription = skip_transcription
+        self.skip_transcription_review = skip_transcription_review
+        self.render_video = render_video
+        self.subtitle_offset_ms = subtitle_offset_ms
+
+    def _detect_countdown_padding_from_lrc(self, lrc_filepath):
+        """
+        Detect if countdown padding was applied by checking for countdown text in the LRC file.
+        
+        The countdown segment has the text "3... 2... 1..." at timestamp 0.1-2.9s.
+        We detect this by looking for the countdown text pattern.
+        
+        Args:
+            lrc_filepath: Path to the LRC file
+            
+        Returns:
+            Tuple of (countdown_padding_added: bool, countdown_padding_seconds: float)
+        """
+        try:
+            with open(lrc_filepath, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            # Method 1: Check for countdown text pattern "3... 2... 1..."
+            # This is the most reliable detection method since the countdown text is unique
+            countdown_text = "3... 2... 1..."
+            if countdown_text in content:
+                self.logger.info(f"Detected countdown padding from LRC: found countdown text '{countdown_text}'")
+                return (True, self.COUNTDOWN_PADDING_SECONDS)
+            
+            # Method 2 (fallback): Check if first lyric timestamp is >= 3 seconds
+            # This handles cases where countdown text format might differ
+            # LRC timestamps: [mm:ss.xx] or [mm:ss.xxx]
+            timestamp_pattern = r'\[(\d{1,2}):(\d{2})\.(\d{2,3})\]'
+            matches = re.findall(timestamp_pattern, content)
+            
+            if not matches:
+                self.logger.debug("No timestamps found in LRC file")
+                return (False, 0.0)
+            
+            # Parse the first timestamp
+            first_timestamp = matches[0]
+            minutes = int(first_timestamp[0])
+            seconds = int(first_timestamp[1])
+            # Handle both .xx and .xxx formats
+            centiseconds = first_timestamp[2]
+            if len(centiseconds) == 2:
+                milliseconds = int(centiseconds) * 10
+            else:
+                milliseconds = int(centiseconds)
+            
+            first_lyric_time = minutes * 60 + seconds + milliseconds / 1000.0
+            
+            self.logger.debug(f"First lyric timestamp in LRC: {first_lyric_time:.3f}s")
+            
+            # If first lyric is at or after 3 seconds, countdown padding was applied
+            # Use a small buffer (2.5s) to account for songs that naturally start a bit late
+            if first_lyric_time >= 2.5:
+                self.logger.info(f"Detected countdown padding from LRC: first lyric at {first_lyric_time:.2f}s")
+                return (True, self.COUNTDOWN_PADDING_SECONDS)
+            
+            return (False, 0.0)
+            
+        except Exception as e:
+            self.logger.warning(f"Failed to detect countdown padding from LRC file: {e}")
+            return (False, 0.0)
+
+    def find_best_split_point(self, line):
+        """
+        Find the best split point in a line based on the specified criteria.
+        """
+
+        self.logger.debug(f"Finding best_split_point for line: {line}")
+        words = line.split()
+        mid_word_index = len(words) // 2
+        self.logger.debug(f"words: {words} mid_word_index: {mid_word_index}")
+
+        # Check for a comma within one or two words of the middle word
+        if "," in line:
+            mid_point = len(" ".join(words[:mid_word_index]))
+            comma_indices = [i for i, char in enumerate(line) if char == ","]
+
+            for index in comma_indices:
+                if abs(mid_point - index) < 20 and len(line[: index + 1].strip()) <= 36:
+                    self.logger.debug(
+                        f"Found comma at index {index} which is within 20 characters of mid_point {mid_point} and results in a suitable line length, accepting as split point"
+                    )
+                    return index + 1  # Include the comma in the first line
+
+        # Check for 'and'
+        if " and " in line:
+            mid_point = len(line) // 2
+            and_indices = [m.start() for m in re.finditer(" and ", line)]
+            for index in sorted(and_indices, key=lambda x: abs(x - mid_point)):
+                if len(line[: index + len(" and ")].strip()) <= 36:
+                    self.logger.debug(f"Found 'and' at index {index} which results in a suitable line length, accepting as split point")
+                    return index + len(" and ")
+
+        # If no better split point is found, try splitting at the middle word
+        if len(words) > 2 and mid_word_index > 0:
+            split_at_middle = len(" ".join(words[:mid_word_index]))
+            if split_at_middle <= 36:
+                self.logger.debug(f"Splitting at middle word index: {mid_word_index}")
+                return split_at_middle
+
+        # If the line is still too long, forcibly split at the maximum length
+        forced_split_point = 36
+        if len(line) > forced_split_point:
+            self.logger.debug(f"Line is still too long, forcibly splitting at position {forced_split_point}")
+            return forced_split_point
+
+    def process_line(self, line):
+        """
+        Process a single line to ensure it's within the maximum length,
+        and handle parentheses.
+        """
+        processed_lines = []
+        iteration_count = 0
+        max_iterations = 100  # Failsafe limit
+
+        while len(line) > 36:
+            if iteration_count > max_iterations:
+                self.logger.error(f"Maximum iterations exceeded in process_line for line: {line}")
+                break
+
+            # Check if the line contains parentheses
+            if "(" in line and ")" in line:
+                start_paren = line.find("(")
+                end_paren = line.find(")") + 1
+                if end_paren < len(line) and line[end_paren] == ",":
+                    end_paren += 1
+
+                if start_paren > 0:
+                    processed_lines.append(line[:start_paren].strip())
+                processed_lines.append(line[start_paren:end_paren].strip())
+                line = line[end_paren:].strip()
+            else:
+                split_point = self.find_best_split_point(line)
+                processed_lines.append(line[:split_point].strip())
+                line = line[split_point:].strip()
+
+            iteration_count += 1
+
+        if line:  # Add the remaining part if not empty
+            processed_lines.append(line)
+
+        return processed_lines
+
+    def _check_transcription_providers(self) -> dict:
+        """
+        Check which transcription providers are configured and return their status.
+        
+        Returns:
+            dict with 'configured' (list of provider names) and 'missing' (list of missing configs)
+        """
+        load_dotenv()
+        
+        configured = []
+        missing = []
+        
+        # Check AudioShake
+        audioshake_token = os.getenv("AUDIOSHAKE_API_TOKEN")
+        if audioshake_token:
+            configured.append("AudioShake")
+            self.logger.debug("AudioShake transcription provider: configured")
+        else:
+            missing.append("AudioShake (AUDIOSHAKE_API_TOKEN)")
+            self.logger.debug("AudioShake transcription provider: not configured (missing AUDIOSHAKE_API_TOKEN)")
+        
+        # Check Whisper via RunPod
+        runpod_key = os.getenv("RUNPOD_API_KEY")
+        whisper_id = os.getenv("WHISPER_RUNPOD_ID")
+        if runpod_key and whisper_id:
+            configured.append("Whisper (RunPod)")
+            self.logger.debug("Whisper transcription provider: configured")
+        elif runpod_key:
+            missing.append("Whisper (missing WHISPER_RUNPOD_ID)")
+            self.logger.debug("Whisper transcription provider: partially configured (missing WHISPER_RUNPOD_ID)")
+        elif whisper_id:
+            missing.append("Whisper (missing RUNPOD_API_KEY)")
+            self.logger.debug("Whisper transcription provider: partially configured (missing RUNPOD_API_KEY)")
+        else:
+            missing.append("Whisper (RUNPOD_API_KEY + WHISPER_RUNPOD_ID)")
+            self.logger.debug("Whisper transcription provider: not configured")
+        
+        return {"configured": configured, "missing": missing}
+
+    def _build_transcription_provider_error_message(self, missing_providers: list) -> str:
+        """Build a helpful error message when no transcription providers are configured."""
+        return (
+            "No transcription providers configured!\n"
+            "\n"
+            "Karaoke video generation requires at least one transcription provider to create "
+            "synchronized lyrics. Without a transcription provider, the system cannot generate "
+            "the word-level timing data needed for the karaoke video.\n"
+            "\n"
+            "AVAILABLE TRANSCRIPTION PROVIDERS:\n"
+            "\n"
+            "1. AudioShake (Recommended - Commercial, high-quality)\n"
+            "   - Set environment variable: AUDIOSHAKE_API_TOKEN=your_token\n"
+            "   - Get an API key at: https://www.audioshake.ai/\n"
+            "\n"
+            "2. Whisper via RunPod (Open-source alternative)\n"
+            "   - Set environment variables:\n"
+            "     RUNPOD_API_KEY=your_key\n"
+            "     WHISPER_RUNPOD_ID=your_endpoint_id\n"
+            "   - Set up a Whisper endpoint at: https://www.runpod.io/\n"
+            "\n"
+            "ALTERNATIVES:\n"
+            "\n"
+            "- Use --skip-lyrics flag to generate instrumental-only karaoke (no synchronized lyrics)\n"
+            "- Use --lyrics_file to provide pre-timed lyrics (still needs transcription for timing)\n"
+            "\n"
+            f"Missing provider configurations: {', '.join(missing_providers)}\n"
+            "\n"
+            "See README.md 'Transcription Providers' section for detailed setup instructions."
+        )
+
+    def transcribe_lyrics(self, input_audio_wav, artist, title, track_output_dir, lyrics_artist=None, lyrics_title=None):
+        """
+        Transcribe lyrics for a track.
+        
+        Args:
+            input_audio_wav: Path to the audio file
+            artist: Original artist name (used for filename generation)
+            title: Original title (used for filename generation)
+            track_output_dir: Output directory path
+            lyrics_artist: Artist name for lyrics processing (defaults to artist if None)
+            lyrics_title: Title for lyrics processing (defaults to title if None)
+            
+        Raises:
+            ValueError: If transcription is enabled but no providers are configured
+        """
+        # Use original artist/title for filename generation
+        filename_artist = artist
+        filename_title = title
+        
+        # Use lyrics_artist/lyrics_title for actual lyrics processing, fall back to originals if not provided
+        processing_artist = lyrics_artist or artist
+        processing_title = lyrics_title or title
+        
+        self.logger.info(
+            f"Transcribing lyrics for track {processing_artist} - {processing_title} from audio file: {input_audio_wav} with output directory: {track_output_dir}"
+        )
+
+        # Check for existing files first using sanitized names from ORIGINAL artist/title for consistency
+        sanitized_artist = sanitize_filename(filename_artist)
+        sanitized_title = sanitize_filename(filename_title)
+        parent_video_path = os.path.join(track_output_dir, f"{sanitized_artist} - {sanitized_title} (With Vocals).mkv")
+        parent_lrc_path = os.path.join(track_output_dir, f"{sanitized_artist} - {sanitized_title} (Karaoke).lrc")
+
+        # Check lyrics directory for existing files
+        lyrics_dir = os.path.join(track_output_dir, "lyrics")
+        lyrics_video_path = os.path.join(lyrics_dir, f"{sanitized_artist} - {sanitized_title} (With Vocals).mkv")
+        lyrics_lrc_path = os.path.join(lyrics_dir, f"{sanitized_artist} - {sanitized_title} (Karaoke).lrc")
+
+        # If files exist in parent directory, return early (but detect countdown padding first)
+        if os.path.exists(parent_video_path) and os.path.exists(parent_lrc_path):
+            self.logger.info("Found existing video and LRC files in parent directory, skipping transcription")
+            
+            # Detect countdown padding from existing LRC file
+            countdown_padding_added, countdown_padding_seconds = self._detect_countdown_padding_from_lrc(parent_lrc_path)
+            
+            if countdown_padding_added:
+                self.logger.info(f"Existing files have countdown padding: {countdown_padding_seconds}s")
+            
+            return {
+                "lrc_filepath": parent_lrc_path,
+                "ass_filepath": parent_video_path,
+                "countdown_padding_added": countdown_padding_added,
+                "countdown_padding_seconds": countdown_padding_seconds,
+                "padded_audio_filepath": None,  # Original padded audio may not exist
+            }
+
+        # If files exist in lyrics directory, copy to parent and return (but detect countdown padding first)
+        if os.path.exists(lyrics_video_path) and os.path.exists(lyrics_lrc_path):
+            self.logger.info("Found existing video and LRC files in lyrics directory, copying to parent")
+            os.makedirs(track_output_dir, exist_ok=True)
+            shutil.copy2(lyrics_video_path, parent_video_path)
+            shutil.copy2(lyrics_lrc_path, parent_lrc_path)
+            
+            # Detect countdown padding from existing LRC file
+            countdown_padding_added, countdown_padding_seconds = self._detect_countdown_padding_from_lrc(parent_lrc_path)
+            
+            if countdown_padding_added:
+                self.logger.info(f"Existing files have countdown padding: {countdown_padding_seconds}s")
+            
+            return {
+                "lrc_filepath": parent_lrc_path,
+                "ass_filepath": parent_video_path,
+                "countdown_padding_added": countdown_padding_added,
+                "countdown_padding_seconds": countdown_padding_seconds,
+                "padded_audio_filepath": None,  # Original padded audio may not exist
+            }
+
+        # Check transcription provider configuration if transcription is not being skipped
+        # Do this AFTER checking for existing files, since existing files don't need transcription
+        if not self.skip_transcription:
+            provider_status = self._check_transcription_providers()
+            
+            if provider_status["configured"]:
+                self.logger.info(f"Transcription providers configured: {', '.join(provider_status['configured'])}")
+            else:
+                error_msg = self._build_transcription_provider_error_message(provider_status["missing"])
+                raise ValueError(error_msg)
+
+        # Create lyrics directory if it doesn't exist
+        os.makedirs(lyrics_dir, exist_ok=True)
+        self.logger.info(f"Created lyrics directory: {lyrics_dir}")
+
+        # Set render_video to False if explicitly disabled
+        render_video = self.render_video
+        if not render_video:
+            self.logger.info("Video rendering disabled, skipping video output")
+
+        # Load environment variables
+        load_dotenv()
+        env_config = {
+            "audioshake_api_token": os.getenv("AUDIOSHAKE_API_TOKEN"),
+            "genius_api_token": os.getenv("GENIUS_API_TOKEN"),
+            "spotify_cookie": os.getenv("SPOTIFY_COOKIE_SP_DC"),
+            "runpod_api_key": os.getenv("RUNPOD_API_KEY"),
+            "whisper_runpod_id": os.getenv("WHISPER_RUNPOD_ID"),
+            "rapidapi_key": os.getenv("RAPIDAPI_KEY"),  # Add missing RAPIDAPI_KEY
+        }
+
+        # Create config objects for LyricsTranscriber
+        transcriber_config = TranscriberConfig(
+            audioshake_api_token=env_config.get("audioshake_api_token"),
+        )
+
+        lyrics_config = LyricsConfig(
+            genius_api_token=env_config.get("genius_api_token"),
+            spotify_cookie=env_config.get("spotify_cookie"),
+            rapidapi_key=env_config.get("rapidapi_key"),
+            lyrics_file=self.lyrics_file,
+        )
+        
+        # Debug logging for lyrics_config
+        self.logger.info(f"LyricsConfig created with:")
+        self.logger.info(f"  genius_api_token: {env_config.get('genius_api_token')[:3] + '...' if env_config.get('genius_api_token') else 'None'}")
+        self.logger.info(f"  spotify_cookie: {env_config.get('spotify_cookie')[:3] + '...' if env_config.get('spotify_cookie') else 'None'}")
+        self.logger.info(f"  rapidapi_key: {env_config.get('rapidapi_key')[:3] + '...' if env_config.get('rapidapi_key') else 'None'}")
+        self.logger.info(f"  lyrics_file: {self.lyrics_file}")
+
+        # Detect if we're running in a serverless environment (Modal)
+        # Modal sets specific environment variables we can check for
+        is_serverless = (
+            os.getenv("MODAL_TASK_ID") is not None or 
+            os.getenv("MODAL_FUNCTION_NAME") is not None or
+            os.path.exists("/.modal")  # Modal creates this directory in containers
+        )
+        
+        # In serverless environment, disable interactive review even if skip_transcription_review=False
+        # This preserves CLI behavior while fixing serverless hanging
+        enable_review_setting = not self.skip_transcription_review and not is_serverless
+        
+        if is_serverless and not self.skip_transcription_review:
+            self.logger.info("Detected serverless environment - disabling interactive review to prevent hanging")
+        
+        # In serverless environment, disable video generation during Phase 1 to save compute
+        # Video will be generated in Phase 2 after human review
+        serverless_render_video = render_video and not is_serverless
+        
+        if is_serverless and render_video:
+            self.logger.info("Detected serverless environment - deferring video generation until after review")
+        
+        output_config = OutputConfig(
+            output_styles_json=self.style_params_json,
+            output_dir=lyrics_dir,
+            render_video=serverless_render_video,  # Disable video in serverless Phase 1
+            fetch_lyrics=True,
+            run_transcription=not self.skip_transcription,
+            run_correction=True,
+            generate_plain_text=True,
+            generate_lrc=True,
+            generate_cdg=False,  # Also defer CDG generation to Phase 2 
+            video_resolution="4k",
+            enable_review=enable_review_setting,
+            subtitle_offset_ms=self.subtitle_offset_ms,
+        )
+
+        # Add this log entry to debug the OutputConfig
+        self.logger.info(f"Instantiating LyricsTranscriber with OutputConfig: {output_config}")
+
+        # Initialize transcriber with new config objects - use PROCESSING artist/title for lyrics work
+        transcriber = LyricsTranscriber(
+            audio_filepath=input_audio_wav,
+            artist=processing_artist,  # Use lyrics_artist for processing
+            title=processing_title,   # Use lyrics_title for processing
+            transcriber_config=transcriber_config,
+            lyrics_config=lyrics_config,
+            output_config=output_config,
+            logger=self.logger,
+        )
+
+        # Process and get results
+        results: LyricsControllerResult = transcriber.process()
+        self.logger.info(f"Transcriber Results Filepaths:")
+        for key, value in results.__dict__.items():
+            if key.endswith("_filepath"):
+                self.logger.info(f"  {key}: {value}")
+
+        # Build output dictionary
+        transcriber_outputs = {}
+        if results.lrc_filepath:
+            transcriber_outputs["lrc_filepath"] = results.lrc_filepath
+            self.logger.info(f"Moving LRC file from {results.lrc_filepath} to {parent_lrc_path}")
+            shutil.copy2(results.lrc_filepath, parent_lrc_path)
+
+        if results.ass_filepath:
+            transcriber_outputs["ass_filepath"] = results.ass_filepath
+            self.logger.info(f"Moving video file from {results.video_filepath} to {parent_video_path}")
+            shutil.copy2(results.video_filepath, parent_video_path)
+
+        if results.transcription_corrected:
+            transcriber_outputs["corrected_lyrics_text"] = "\n".join(
+                segment.text for segment in results.transcription_corrected.corrected_segments
+            )
+            transcriber_outputs["corrected_lyrics_text_filepath"] = results.corrected_txt
+
+            # Save correction data to JSON file for review interface
+            # Use the expected filename format: "{artist} - {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
+            correction_data = results.transcription_corrected.to_dict()
+            
+            with open(corrections_filepath, 'w') as f:
+                json.dump(correction_data, f, indent=2)
+            
+            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():
+                if key.endswith("_filepath"):
+                    self.logger.info(f"  {key}: {value}")
+
+        return transcriber_outputs

karaoke_gen/metadata.py

@@ -0,0 +1,160 @@
+import logging
+
+
+def extract_info_for_online_media(input_url, input_artist, input_title, logger, cookies_str=None):
+    """
+    Creates metadata info dict from provided artist and title.
+    
+    Note: This function no longer supports URL-based metadata extraction.
+    Audio search and download is now handled by the AudioFetcher class using flacfetch.
+    
+    When both artist and title are provided, this creates a metadata dict that can be
+    used by the rest of the pipeline.
+    
+    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
+        
+    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,
+        "extractor": None,
+        "media_id": None,
+        "artist": current_artist,
+        "title": current_title,
+    }
+
+    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:
+        # 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:
+        # Default to flacfetch if no extractor specified
+        parsed_data["extractor"] = "flacfetch"
+
+    if "id" in extracted_info:
+        parsed_data["media_id"] = extracted_info["id"]
+
+    # Example: "Artist - Title"
+    if "title" in extracted_info and "-" in extracted_info["title"]:
+        try:
+            metadata_artist, metadata_title = extracted_info["title"].split("-", 1)
+            metadata_artist = metadata_artist.strip()
+            metadata_title = metadata_title.strip()
+        except ValueError:
+             logger.warning(f"Could not split title '{extracted_info['title']}' on '-', using full title.")
+             metadata_title = extracted_info["title"].strip()
+             if "uploader" in extracted_info:
+                 metadata_artist = extracted_info["uploader"]
+
+    elif "uploader" in extracted_info:
+        # Fallback to uploader as artist if title parsing fails
+        metadata_artist = extracted_info["uploader"]
+        if "title" in extracted_info:
+            metadata_title = extracted_info["title"].strip()
+
+    # If unable to parse, log an appropriate message
+    if not metadata_artist or not metadata_title:
+        logger.warning("Could not parse artist and title from the input media metadata.")
+
+    if not parsed_data["artist"] and metadata_artist:
+        logger.warning(f"Artist not provided as input, setting to {metadata_artist} from input media metadata...")
+        parsed_data["artist"] = metadata_artist
+
+    if not parsed_data["title"] and metadata_title:
+        logger.warning(f"Title not provided as input, setting to {metadata_title} from input media metadata...")
+        parsed_data["title"] = metadata_title
+
+    if persistent_artist:
+        logger.debug(
+            f"Resetting artist from {parsed_data['artist']} to persistent artist: {persistent_artist} for consistency while processing playlist..."
+        )
+        parsed_data["artist"] = persistent_artist
+
+    if parsed_data["artist"] and 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.")
+
+    return parsed_data