Update app.py

app.py

@@ -7,6 +7,8 @@ from datetime import datetime, timedelta
 import time
 import asyncio
 import cloudscraper
+from pydantic import BaseModel
+from urllib.parse import urlparse, parse_qs
 
 app = Flask(__name__)
 ytmusic = YTMusic()
@@ -29,11 +31,106 @@ def search():
 @app.route('/searcht', methods=['POST'])
 def searcht(): 
     query = request.json.get('query', '')
+    logger.info(f"serch query: {query}")
     search_results = ytmusic.search(query, filter="songs")
     first_song = next((song for song in search_results if 'videoId' in song and song['videoId']), {}) if search_results else {}
     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]
+    
+    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
+    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"
+        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"
+    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:
+        return response.json()
+    else:
+        return None
+
+# Function to extract Tidal or YouTube URL
+def extract_url(links_by_platform: dict, platform: str):
+    if platform in links_by_platform:
+        return links_by_platform[platform]["url"]
+    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
+    track_url = data.get('url')
+
+    if not track_url:
+        raise HTTPException(status_code=400, detail="No URL provided")
+
+    track_info = get_song_link_info(track_url)
+    if not track_info:
+        raise HTTPException(status_code=404, detail="Could not fetch track info")
+
+    youtube_url = extract_url(track_info["linksByPlatform"], "youtube")
+    if youtube_url:
+        title, artist = extract_track_info(track_info["entitiesByUniqueId"], "youtube")
+        if title and artist:
+            filename = f"{title} - {artist}"
+            return {"url": youtube_url, "filename": filename}
+        else:
+            return {"url": youtube_url, "filename": "Unknown Track - Unknown Artist"}
+    else:
+        entityUniqueId = track_info["entityUniqueId"]
+        logger.info(f"songlink info: {entityUniqueId}")
+        title = track_info["entitiesByUniqueId"][entityUniqueId]["title"]
+        artist = track_info["entitiesByUniqueId"][entityUniqueId]["artistName"]
+        search_query = f'{title}+{artist}'
+        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": title, "url": ym_url}
+        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")
+
+    
+
 class ApiRotator:
     def __init__(self, apis):
         self.apis = apis
@@ -56,16 +153,16 @@ class ApiRotator:
 # In your function:
 api_rotator = ApiRotator([
     "https://cobalt-api.ayo.tf",
+    "https://cobalt-api.kwiatekmiki.com",
     "http://34.107.254.11",
     "https://dwnld.nichind.dev",
-    "https://cobalt-api.kwiatekmiki.com",
     "https://yt.edd1e.xyz/"
     
 ])
 
 
 
-async def get_track_download_url(track_id: str) -> str:
+async def get_track_download_url(track_id: str, quality: str) -> str:
     apis = api_rotator.get_prioritized_apis()
     session = cloudscraper.create_scraper()  # Requires cloudscraper package
     headers = {
@@ -81,7 +178,7 @@ async def get_track_download_url(track_id: str) -> str:
             response = session.post(
                 api_url,
                 timeout=20,
-                json={"url": y_url, "audioFormat": "mp3", "downloadMode": "audio"},
+                json={"url": y_url, "audioFormat": "mp3", "downloadMode": "audio", "audioBitrate": quality},
                 headers=headers
             )
             logger.info(f"Response status: {response.status_code}")
@@ -110,16 +207,21 @@ async def get_track_download_url(track_id: str) -> str:
 
     
 @app.route('/track_dl', methods=['POST'])
-async def track_dl():
-    track_id = request.json.get('track_id')
-    dl_url = await get_track_download_url(track_id)
-    if dl_url and "http" in dl_url:
-        result = {"url": dl_url}
-        return jsonify(result)
-    else:
-        return {
-                "error": "Failed to Fetch the Track."
-            }
+async def track_dl(request: Request):
+    data = await request.json()
+    track_id = data.get('track_id')
+    quality = data.get('quality', '128')
+    try:
+        quality_num = int(quality)
+        if quality_num > 128 or quality.upper() == 'FLAC':
+            return {"error": "Quality above 128 or FLAC is for Premium Users Only."}
+        dl_url = await get_track_download_url(track_id, quality)
+        if dl_url and "http" in dl_url:
+            return {"url": dl_url}
+        else:
+            return {"error": "Failed to Fetch the Track."}
+    except ValueError:
+        return {"error": "Invalid quality value provided. It should be a valid integer or FLAC."}