Update app.py

app.py

@@ -14,6 +14,8 @@ from typing import Optional, Dict, Tuple
 import urllib.parse
 from fastapi.responses import JSONResponse
 import re
+from ytmusicapi import YTMusic
+
 
 # Configure logging
 logging.basicConfig(
@@ -105,6 +107,23 @@ def get_spotify_token() -> str:
         logger.error(f"Unexpected error during token request: {str(e)}")
         raise HTTPException(status_code=500, detail="Internal server error")
 
+async def get_download_url(url):
+    loop = asyncio.get_running_loop()
+    url = "https://chrunos-ytdl2.hf.space/download"
+    data = {"url": url}
+    try:
+        response = await loop.run_in_executor(None, requests.post, url, {'json': data})
+        if response.status_code == 200:
+            result = response.json()
+            return result.get('download_url')
+        else:
+            logger.error(f"请求失败，状态码: {response.status_code}")
+            return None
+    except requests.RequestException as e:
+        logger.error(f"发生客户端错误: {e}")
+        return None
+
+
 def extract_album_id(album_url: str) -> str:
     """Extract album ID from Spotify URL."""
     try:
@@ -112,6 +131,39 @@ def extract_album_id(album_url: str) -> str:
     except Exception as e:
         logger.error(f"Failed to extract album ID from URL {album_url}: {str(e)}")
         raise HTTPException(status_code=400, detail="Invalid Spotify album URL format")
+        
+
+async def fetch_spotify_track_info(track_id: str) -> Dict:
+    """
+    Asynchronously fetch Spotify track title, artist, and cover art URL.
+    """
+    token = get_spotify_token()
+    headers = {
+        'Authorization': f'Bearer {token}'
+    }
+    url = f"{SPOTIFY_API_URL}/tracks/{track_id}"
+    try:
+        loop = asyncio.get_running_loop()
+        response = await loop.run_in_executor(None, requests.get, url, {'headers': headers})
+        if response.status_code == 200:
+            track_data = response.json()
+            title = track_data.get('name')
+            artists = [artist.get('name') for artist in track_data.get('artists', [])]
+            cover_art_url = track_data.get('album', {}).get('images', [{}])[0].get('url')
+
+            return {
+                'title': title,
+                'artists': artists,
+                'cover_art_url': cover_art_url
+            }
+        else:
+            raise SpotifyAPIError(f"Failed to fetch track information: {response.text}")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Network error during track information request: {str(e)}")
+        raise HTTPException(status_code=503, detail="Spotify API service unavailable")
+    except Exception as e:
+        logger.error(f"Unexpected error during track information request: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal server error")
 
 
 @app.post("/album")
@@ -290,7 +342,7 @@ def get_url(track_data, cookie):
     except:
         return None
 
-
+'''
 @app.get("/{track_id}")
 async def download_track(track_id: str):
     cookie = get_cookie()
@@ -306,11 +358,91 @@ async def download_track(track_id: str):
         return {"error": "Failed to get download URL"}, 500
 
     return {"url": download_link}
+'''
+
+@app.get("/{track_id}")
+async def download_track(track_id: str):
+    url = f'https://open.spotify.com/track/{track_id}'
+    track_data = get_song_link_info(url)
+    if not track_data:
+        track_data = fetch_spotify_track_info(track_id)
+        title = track_data["title"]
+        artist = track_data["artist"]
+        query = f'{title}+{artist}'
+            logger.info(f"search 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 {}
+            if 'videoId' in first_song:
+                videoId = first_song["videoId"]
+                ym_url = f'https://www.youtube.com/watch?v={videoId}'
+                d_data = get_download_url(ym_url)
+                track_data['download_url'] = d_data
+                return track_data
+    else:
+        yt_url = track_data['url']
+        d_data = get_download_url(yt_url)
+        track_data['download_url'] = d_data
+        return track_data
+        
 
+    download_link = get_url(track_data, cookie)
+    if not download_link:
+        return {"error": "Failed to get download URL"}, 500
 
+    return {"url": download_link}
 
+# 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:
+        track_info = response
+        if not track_info:
+            raise HTTPException(status_code=404, detail="Could not fetch track info")
+        entityUniqueId = track_info["entityUniqueId"]
+        title = track_info["entitiesByUniqueId"][entityUniqueId]["title"]
+        artist = track_info["entitiesByUniqueId"][entityUniqueId]["artistName"]
+        filename = f"{title} - {artist}"
+        
+        #extract YouTube URL
+        youtube_url = extract_url(track_info["linksByPlatform"], "youtube")
+        if youtube_url:
+            
+            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:
+            return None                      
+    else:
+        return None
 
 
+'''
+else:
+            query = f'{title}+{artist}'
+            logger.info(f"search 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 {}
+            if 'videoId' in first_song:
+                videoId = first_song["videoId"]
+                ym_url = f'https://www.youtube.com/watch?v={videoId}'
+                return {"filename": filename, "url": ym_url, "track_id": videoId}
+'''
 
 @app.get("/")
 async def health_check():