Update app.py

app.py

@@ -39,98 +39,164 @@ def searcht():
     return jsonify(first_song)
 
 
-# Function to extract track ID from Amazon Music URL
 def extract_amazon_track_id(url: str):
-    if "music.amazon.com" in url:
-        # Case 1: URL contains trackAsin (e.g., https://music.amazon.com/albums/B01N48U32A?trackAsin=B01NAE38YO&do=play)
-        parsed_url = urlparse(url)
-        query_params = parse_qs(parsed_url.query)
-        if "trackAsin" in query_params:
-            return query_params["trackAsin"][0]
-        
-        # Case 2: URL is a direct track link (e.g., https://music.amazon.com/tracks/B0DNTPYT5S)
-        if "/tracks/" in url:
-            return url.split("/tracks/")[-1].split("?")[0]
-    
+    """
+    Extracts track ID from various Amazon Music URL formats.
+    """
+    if "music.amazon.com" not in url: # MODIFIED: Slight logic inversion for early exit compared to original, same effective outcome.
+        return None
+
+    parsed_url = urlparse(url)
+    query_params = parse_qs(parsed_url.query)
+
+    if "trackAsin" in query_params:
+        return query_params["trackAsin"][0]
+
+    path_parts = parsed_url.path.split('/') # MODIFIED: Changed from simple `url.split` to more robust path parsing for Case 2.
+    if "tracks" in path_parts:
+        try:
+            track_id_index = path_parts.index("tracks") + 1
+            if track_id_index < len(path_parts):
+                return path_parts[track_id_index] # MODIFIED: Accessing specific part after "tracks".
+        except (ValueError, IndexError):
+            pass
+
+    logger.warning(f"Could not extract Amazon track ID from URL: {url}") # ADDED: Logging for when no ID is found.
     return None
-    
 
-# Function to get track info from Song.link API
+
 def get_song_link_info(url: str):
-     # Check if the URL is from Amazon Music
+    """
+    Fetches track information from the Song.link API.
+    Uses requests.get() which is a blocking call.
+    """
+    api_base_url = "https://api.song.link/v1-alpha.1/links" # ADDED: Defined base URL for clarity.
+    params = {"userCountry": "US"} # MODIFIED: Using a params dictionary for requests.get().
+
     if "music.amazon.com" in url:
         track_id = extract_amazon_track_id(url)
         if track_id:
-            # Use the working format for Amazon Music tracks
-            api_url = f"https://api.song.link/v1-alpha.1/links?type=song&platform=amazonMusic&id={track_id}&userCountry=US"
+            params["platform"] = "amazonMusic" # MODIFIED: Populating params dict.
+            params["id"] = track_id
+            params["type"] = "song"
         else:
-            # If no track ID is found, use the original URL
-            api_url = f"https://api.song.link/v1-alpha.1/links?url={url}&userCountry=US"
+            params["url"] = url # MODIFIED: Populating params dict.
     else:
-        # For non-Amazon Music URLs, use the standard format
-        api_url = f"https://api.song.link/v1-alpha.1/links?url={url}&userCountry=US"
-    
-    # Make the API call
-    response = requests.get(api_url)
-    if response.status_code == 200:
+        params["url"] = url # MODIFIED: Populating params dict.
+
+    try: # ADDED: try-except block for robust error handling during API call.
+        logger.info(f"Querying Song.link API with params: {params}") # ADDED: Logging the API query.
+        response = requests.get(api_base_url, params=params, timeout=10) # MODIFIED: Call uses base_url and params. ADDED: timeout.
+        response.raise_for_status() # ADDED: Checks for HTTP errors (4xx or 5xx responses).
         return response.json()
-    else:
+    except requests.exceptions.RequestException as e: # ADDED: Catching network/request related exceptions.
+        logger.error(f"Error fetching from Song.link API: {e}") # ADDED: Logging the specific error.
         return None
 
-# Function to extract Tidal or YouTube URL
 def extract_url(links_by_platform: dict, platform: str):
-    if platform in links_by_platform:
+    """
+    Extracts a specific platform URL from Song.link API response.
+    """
+    # MODIFIED: Added .get("url") for safer access to prevent KeyError if "url" key is missing.
+    if platform in links_by_platform and links_by_platform[platform].get("url"):
         return links_by_platform[platform]["url"]
+    logger.warning(f"No URL found for platform '{platform}' in links: {links_by_platform.keys()}") # ADDED: Logging if platform URL not found.
     return None
 
-
-# Function to extract track title and artist from entities
-def extract_track_info(entities_by_unique_id: dict, platform: str):
-    for entity in entities_by_unique_id.values():
-        if entity["apiProvider"] == platform:
-            return entity["title"], entity["artistName"]
-    return None, None
-
-
-
 @app.route('/match', methods=['POST'])
-async def match():
-    data = request.json
+def match(): # MODIFIED: Changed from `async def` to `def` for synchronous Flask.
+    """
+    Matches a given music track URL to a YouTube Music URL.
+    Expects a JSON body with "url".
+    """
+    data = request.get_json()
+    if not data: # ADDED: Check for empty JSON payload.
+        logger.error("Match endpoint: No JSON payload received.") # ADDED: Logging.
+        return jsonify({"detail": "No JSON payload received."}), 400 # MODIFIED: Flask-style JSON error response.
+
     track_url = data.get('url')
+    # MODIFIED: Added more specific validation for track_url presence and type.
+    if not track_url or not isinstance(track_url, str):
+        logger.error(f"Match endpoint: Invalid or missing URL: {track_url}") # ADDED: Logging.
+        return jsonify({"detail": "Valid 'url' string is required in request body."}), 400 # MODIFIED: Flask-style JSON error response.
 
-    if not track_url:
-        raise HTTPException(status_code=400, detail="No URL provided")
+    logger.info(f"Match endpoint: Processing URL: {track_url}") # ADDED: Logging.
 
     track_info = get_song_link_info(track_url)
     if not track_info:
-        raise HTTPException(status_code=404, detail="Could not fetch track info")
+        logger.error(f"Match endpoint: Could not fetch track info for URL: {track_url}") # ADDED: Logging.
+        # MODIFIED: Flask-style JSON error response instead of HTTPException.
+        return jsonify({"detail": "Could not fetch track info from Song.link API."}), 404
+
+    entity_unique_id = track_info.get("entityUniqueId") # MODIFIED: Used .get() for safer access.
+    title = None
+    artist = None
+
+    # MODIFIED: More robust extraction of title and artist with checks and logging.
+    if entity_unique_id and entity_unique_id in track_info.get("entitiesByUniqueId", {}):
+        main_entity = track_info["entitiesByUniqueId"][entity_unique_id]
+        title = main_entity.get("title")
+        artist = main_entity.get("artistName")
+        logger.info(f"Match endpoint: Found main entity - Title: '{title}', Artist: '{artist}'") # ADDED: Logging.
+    else:
+        logger.warning(f"Match endpoint: Could not find main entity details for {track_url} using entityUniqueId: {entity_unique_id}") # ADDED: Logging.
+        # ADDED: Fallback logic to find title/artist from other entities if main one fails.
+        for entity_id, entity_data in track_info.get("entitiesByUniqueId", {}).items():
+            if entity_data.get("title") and entity_data.get("artistName"):
+                title = entity_data.get("title")
+                artist = entity_data.get("artistName")
+                logger.info(f"Match endpoint: Using fallback entity - Title: '{title}', Artist: '{artist}' from entity ID {entity_id}") # ADDED: Logging.
+                break
+        if not title or not artist: # ADDED: Check if title/artist still not found after fallback.
+             logger.error(f"Match endpoint: Could not determine title and artist for URL: {track_url}") # ADDED: Logging.
+             return jsonify({"detail": "Could not determine title and artist from Song.link info."}), 404 # MODIFIED: Flask-style JSON error.
+
+
+    youtube_url = extract_url(track_info.get("linksByPlatform", {}), "youtube") # MODIFIED: Used .get() for safer access.
 
-    youtube_url = extract_url(track_info["linksByPlatform"], "youtube")
-    entityUniqueId = track_info["entityUniqueId"]
-    logger.info(f"songlink info: {entityUniqueId}")
-    title = track_info["entitiesByUniqueId"][entityUniqueId]["title"]
-    artist = track_info["entitiesByUniqueId"][entityUniqueId]["artistName"]
     if youtube_url:
-        video_id = youtube_url.split("v=")[1] if "v=" in youtube_url else None
-        if title and artist:
-            filename = f"{title} - {artist}"
-            return {"url": youtube_url, "filename": filename, "track_id": video_id}
-        else:
-            return {"url": youtube_url, "filename": "Unknown Track - Unknown Artist", "track_id": video_id}
+        video_id = None
+        # MODIFIED: Improved video_id extraction from youtube_url, handles direct watch links and youtu.be, and strips extra params.
+        if "v=" in youtube_url:
+            video_id = youtube_url.split("v=")[1].split("&")[0]
+        elif "youtu.be/" in youtube_url: # MODIFIED: Handling for youtu.be links if present in song.link
+            video_id = youtube_url.split("youtu.be/")[1].split("?")[0]
+
+        filename = f"{title} - {artist}" if title and artist else "Unknown Track - Unknown Artist"
+        logger.info(f"Match endpoint: Found direct YouTube URL: {youtube_url}, Video ID: {video_id}") # ADDED: Logging.
+        # MODIFIED: Flask-style JSON response instead of returning dict directly.
+        return jsonify({"url": youtube_url, "filename": filename, "track_id": video_id}), 200
     else:
-               
-        search_query = f'{title}+{artist}'
+        logger.info(f"Match endpoint: No direct YouTube URL. Searching YTMusic with: '{title} - {artist}'") # ADDED: Logging.
+        # ADDED: Explicit check if title or artist is missing before searching.
+        if not title or not artist:
+            logger.error("Match endpoint: Cannot search YTMusic without title and artist.") # ADDED: Logging.
+            return jsonify({"detail": "Cannot search on YouTube Music without title and artist information."}), 400 # MODIFIED: Flask-style JSON error.
+
+        search_query = f'{title} {artist}' # MODIFIED: Changed from '+' to space for a more natural search query.
         search_results = ytmusic.search(search_query, filter="songs")
-        first_song = next((song for song in search_results if 'videoId' in song and song['videoId']), {}) if search_results else {}
-        if 'videoId' in first_song:
-            videoId = first_song["videoId"]
-            ym_url = f'https://www.youtube.com/watch?v={videoId}'
-            return {"filename": search_query, "url": ym_url, "track_id": videoId}
+
+        if search_results:
+            # MODIFIED: Improved logic to pick the first song with a videoId using next() and .get().
+            first_song = next((song for song in search_results if song.get('videoId')), None)
+            if first_song and first_song.get('videoId'):
+                video_id = first_song["videoId"]
+                # MODIFIED: Changed ym_url to a standard YouTube watch URL format.
+                ym_url = f'https://music.youtube.com/watch?v={video_id}'
+                # MODIFIED: More robust filename generation using .get() and providing fallbacks.
+                filename = f"{first_song.get('title', title)} - {first_song.get('artists', [{'name': artist}])[0]['name']}"
+                logger.info(f"Match endpoint: Found YTMusic search result - URL: {ym_url}, Video ID: {video_id}") # ADDED: Logging.
+                # MODIFIED: Flask-style JSON response.
+                return jsonify({"filename": filename, "url": ym_url, "track_id": video_id}), 200
+            else:
+                logger.error(f"Match endpoint: YTMusic search for '{search_query}' yielded no results with a videoId.") # ADDED: Logging.
+                # MODIFIED: Flask-style JSON error response.
+                return jsonify({"detail": "No matching video ID found on YouTube Music after search."}), 404
         else:
-            raise HTTPException(status_code=404, detail="Video ID not found")
-        
-    # If no URLs found, return an error
-    raise HTTPException(status_code=404, detail="No matching URL found")
+            logger.error(f"Match endpoint: YTMusic search for '{search_query}' yielded no results.") # ADDED: Logging.
+            # MODIFIED: Flask-style JSON error response.
+            return jsonify({"detail": "No results found on YouTube Music for the track."}), 404
+    # REMOVED: The final `raise HTTPException` was determined to be unreachable and removed.