Update app.py

app.py

@@ -7,11 +7,12 @@ from bs4 import BeautifulSoup
 import os
 from datetime import datetime, timedelta
 import time
-import requests
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 import asyncio
 from typing import Optional, Dict, Tuple
+import urllib.parse
+from fastapi.responses import JSONResponse
 
 # Configure logging
 logging.basicConfig(
@@ -25,7 +26,7 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 app = FastAPI(title="Spotify Track API",
-             description="API for retrieving Spotify track information and download URLs")
+              description="API for retrieving Spotify track information and download URLs")
 
 # Constants
 SPOTIFY_API_URL = "https://api.spotify.com/v1"
@@ -38,25 +39,27 @@ class TokenCache:
     def __init__(self):
         self.token: Optional[str] = None
         self.expiry_time: Optional[datetime] = None
-    
+
     def set_token(self, token: str):
         self.token = token
         self.expiry_time = datetime.now() + timedelta(seconds=TOKEN_EXPIRY)
-    
+
     def get_token(self) -> Optional[str]:
         if not self.token or not self.expiry_time or datetime.now() >= self.expiry_time:
             return None
         return self.token
-    
+
     def is_expired(self) -> bool:
         return not self.token or not self.expiry_time or datetime.now() >= self.expiry_time
 
+
 token_cache = TokenCache()
 
 # Custom exception for Spotify API errors
 class SpotifyAPIError(Exception):
     pass
 
+
 def get_spotify_token() -> str:
     """
     Get Spotify access token with expiration handling.
@@ -71,29 +74,29 @@ def get_spotify_token() -> str:
 
         logger.info("Requesting new Spotify access token")
         start_time = time.time()
-        
+
         if not SPOTIFY_CLIENT_ID or not SPOTIFY_CLIENT_SECRET:
             raise SpotifyAPIError("Spotify credentials not configured")
-        
+
         auth_string = f"{SPOTIFY_CLIENT_ID}:{SPOTIFY_CLIENT_SECRET}"
         auth_bytes = base64.b64encode(auth_string.encode()).decode()
-        
+
         auth_response = requests.post(
             'https://accounts.spotify.com/api/token',
             data={'grant_type': 'client_credentials'},
             headers={'Authorization': f'Basic {auth_bytes}'},
             timeout=10
         )
-        
+
         if auth_response.status_code != 200:
             raise SpotifyAPIError(f"Failed to get token: {auth_response.text}")
-        
+
         new_token = auth_response.json()['access_token']
         token_cache.set_token(new_token)
-        
+
         logger.info(f"New token obtained successfully in {time.time() - start_time:.2f}s")
         return new_token
-        
+
     except requests.exceptions.RequestException as e:
         logger.error(f"Network error during token request: {str(e)}")
         raise HTTPException(status_code=503, detail="Spotify authentication service unavailable")
@@ -101,6 +104,98 @@ def get_spotify_token() -> str:
         logger.error(f"Unexpected error during token request: {str(e)}")
         raise HTTPException(status_code=500, detail="Internal server error")
 
+def extract_album_id(album_url: str) -> str:
+    """Extract album ID from Spotify URL."""
+    try:
+        return album_url.split("/")[-1].split("?")[0]
+    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")
+
+
+@app.post("/album")
+async def get_album_data(request: Request):
+    try:
+        # Get the JSON data from the request
+        data = await request.json()
+        album_url = data.get('album_url')
+        if not album_url:
+            raise HTTPException(status_code=400, detail="Missing 'album_url' in JSON data")
+
+        # Extract the album ID from the URL
+        album_id = extract_album_id(album_url)
+
+        # Get the Spotify access token
+        access_token = get_spotify_token()
+
+        # Make a request to the Spotify API to get album data
+        headers = {
+            'Authorization': f'Bearer {access_token}'
+        }
+        album_api_url = f"{SPOTIFY_API_URL}/albums/{album_id}"
+        response = requests.get(album_api_url, headers=headers, timeout=10)
+
+        if response.status_code != 200:
+            raise SpotifyAPIError(f"Failed to get album data: {response.text}")
+
+        album_data = response.json()
+        return album_data
+
+    except SpotifyAPIError as e:
+        logger.error(f"Spotify API error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+
+def extract_playlist_id(playlist_url: str) -> str:
+    """Extract playlist ID from Spotify URL."""
+    try:
+        return playlist_url.split("/")[-1].split("?")[0]
+        
+    except Exception as e:
+        logger.error(f"Failed to extract playlist ID from URL {playlist_url}: {str(e)}")
+        raise HTTPException(status_code=400, detail="Invalid Spotify playlist URL format")
+
+
+@app.post("/playlist")
+async def get_playlist_data(request: Request):
+    try:
+        # Get the JSON data from the request
+        data = await request.json()
+        playlist_url = data.get('playlist_url')
+        if not playlist_url:
+            raise HTTPException(status_code=400, detail="Missing 'playlist_url' in JSON data")
+
+        # Extract the playlist ID from the URL
+        playlist_id = extract_playlist_id(playlist_url)
+        logger.info(f"Extracted playlist ID: {playlist_id}")
+
+        # Get the Spotify access token
+        access_token = get_spotify_token()
+
+        # Make a request to the Spotify API to get playlist data
+        headers = {
+            'Authorization': f'Bearer {access_token}'
+        }
+        playlist_api_url = f"{SPOTIFY_API_URL}/playlists/{playlist_id}/tracks"
+        response = requests.get(playlist_api_url, headers=headers, timeout=10)
+
+        if response.status_code != 200:
+            raise SpotifyAPIError(f"Failed to get playlist data: {response.text}")
+
+        playlist_data = response.json()
+        return playlist_data
+
+    except SpotifyAPIError as e:
+        logger.error(f"Spotify API error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Unexpected error: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+
 def extract_track_id(track_url: str) -> str:
     """Extract track ID from Spotify URL."""
     try:
@@ -109,83 +204,71 @@ def extract_track_id(track_url: str) -> str:
         logger.error(f"Failed to extract track ID from URL {track_url}: {str(e)}")
         raise HTTPException(status_code=400, detail="Invalid Spotify URL format")
 
-# Constants
-DOWNLOAD_TIMEOUT = 30  # Increased timeout for download URLs
-MAX_RETRIES = 3
-BACKOFF_FACTOR = 0.5  # Will sleep for [0.5, 1.0, 2.0] seconds between retries
-
-# Create a session with retry strategy
-def create_request_session() -> requests.Session:
-    session = requests.Session()
-    retry_strategy = Retry(
-        total=MAX_RETRIES,
-        backoff_factor=BACKOFF_FACTOR,
-        status_forcelist=[408, 429, 500, 502, 503, 504],
-    )
-    adapter = HTTPAdapter(max_retries=retry_strategy)
-    session.mount("http://", adapter)
-    session.mount("https://", adapter)
-    return session
-
-# Create a session to be reused
-session = create_request_session()
-
-async def get_track_download_url(track_id: str) -> Tuple[str, str]:
-    """
-    Get download URL with fallback and retry logic.
-    Returns tuple of (url, api_version) where api_version is 'v1' or 'v2'
-    """
-    apis = [
-        ("https://spotisongdownloader.vercel.app/", "v2"),
-        ("https://spotisongdownloader.vercel.app/", "v1")
-    ]
-    
-    errors = []
-    
-    for api_base, version in apis:
-        api_url = f"{api_base}{track_id}"
-        try:
-            logger.info(f"Attempting to get download URL from: {api_url}")
-            
-            # Make the request with increased timeout and session
-            response = session.get(
-                api_url,
-                timeout=DOWNLOAD_TIMEOUT,
-                headers={'User-Agent': 'Mozilla/5.0'} # Adding user agent to prevent some blocks
-            )
-            
-            if response.status_code == 200:
-                download_url = response.json().get("url")
-                if download_url:
-                    logger.info(f"Successfully obtained download URL from {api_url}")
-                    return download_url, version
-                else:
-                    logger.warning(f"No URL in response from {api_url}")
-                    errors.append(f"{version}: Empty URL in response")
-            else:
-                logger.warning(f"Failed response from {api_url}: {response.status_code}")
-                errors.append(f"{version}: Status {response.status_code}")
-                
-        except requests.exceptions.Timeout as e:
-            logger.warning(f"Timeout for {api_url}: {str(e)}")
-            errors.append(f"{version}: Timeout after {DOWNLOAD_TIMEOUT}s")
-            continue
-        except requests.exceptions.RequestException as e:
-            logger.warning(f"Failed to get download URL from {api_url}: {str(e)}")
-            errors.append(f"{version}: {str(e)}")
-            continue
-        except Exception as e:
-            logger.error(f"Unexpected error for {api_url}: {str(e)}")
-            errors.append(f"{version}: Unexpected error - {str(e)}")
-            continue
-    
-    # If we get here, both APIs failed
-    error_msg = " | ".join(errors)
-    logger.error(f"All download URL attempts failed for track {track_id}: {error_msg}")
-    raise HTTPException(
-        status_code=404,
-        detail=f"Download URL not found. Errors: {error_msg}"
-    )
+
+
+
+
+
+def get_cookie():
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36'
+    }
+
+    try:
+        session = requests.Session()
+        response = session.get('https://spotisongdownloader.to/', headers=headers)
+        response.raise_for_status()
+        cookies = session.cookies.get_dict()
+        return f"PHPSESSID={cookies['PHPSESSID']}; quality=m4a"
+
+    except requests.exceptions.RequestException as e:
+        print(f"Error getting cookie: {e}")
+        return None
+
+
+def get_data(track_id):
+    link = f"https://open.spotify.com/track/{track_id}"
+    try:
+        response = requests.get(
+            'https://spotisongdownloader.to/api/composer/spotify/xsingle_track.php',
+            params={'url': link}
+        )
+        return response.json()
+
+    except Exception as error:
+        print(f'Error getting track data: {error}')
+        return None
+
+
+def get_url(track_data, cookie):
+    url = 'https://spotisongdownloader.to/api/composer/spotify/wertyuht3456.php'
+
+    payload = {
+        'song_name': track_data['song_name'],
+        'artist_name': track_data['artist'],
+        'url': track_data['url']
+    }
+
+    headers = {
+        'Accept': 'application/json, text/javascript, */*; q=0.01',
+        'Cookie': cookie,
+        'Origin': 'https://spotisongdownloader.to',
+        'Referer': 'https://spotisongdownloader.to/track.php',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36'
+    }
+
+    try:
+        response = requests.post(url, data=payload, headers=headers)
+        response.raise_for_status()
+        download_data = response.json()
+
+        encoded_link = urllib.parse.quote(download_data['dlink'], safe=':/?=')
+        return encoded_link
+
+    except requests.RequestException as e:
+        print(f'Error getting download URL: {e}')
+        return None
+
 
 @app.get("/get-track")
 async def get_track(
@@ -194,10 +277,8 @@ async def get_track(
     track_url: Optional[str] = None
 ):
     """Get track information and download URL."""
-    request_id = datetime.now().strftime('%Y%m%d%H%M%S%f')
-    logger.info(f"Request {request_id} started - Track ID: {track_id}, URL: {track_url}")
+    logger.info(f"Request started - Track ID: {track_id}, URL: {track_url}")
     
-    start_time = time.time()
     
     try:
         # Input validation
@@ -207,68 +288,29 @@ async def get_track(
         # Extract track ID from URL if provided
         if track_url:
             track_id = extract_track_id(track_url)
-        
-        # Get Spotify API token
-        access_token = get_spotify_token()
-        
-        # Get track metadata from Spotify
-        logger.info(f"Request {request_id} - Fetching track metadata for {track_id}")
-        response = requests.get(
-            f"{SPOTIFY_API_URL}/tracks/{track_id}",
-            headers={"Authorization": f"Bearer {access_token}"},
-            timeout=10
-        )
-        
-        # Handle token expiration
-        if response.status_code == 401:
-            logger.info("Token expired, requesting new token")
-            token_cache.token = None  # Clear expired token
-            access_token = get_spotify_token()
-            # Retry the request with new token
-            response = requests.get(
-                f"{SPOTIFY_API_URL}/tracks/{track_id}",
-                headers={"Authorization": f"Bearer {access_token}"},
-                timeout=10
-            )
-        
-        if response.status_code != 200:
-            logger.error(f"Request {request_id} - Spotify API error: {response.text}")
-            raise HTTPException(
-                status_code=response.status_code,
-                detail="Failed to fetch track information from Spotify"
-            )
-        
-        track_data = response.json()
-        
-        # Get track metadata from Spotify
-        spotify_response = track_data
-        
-        # Get download URL with version info
-        download_url, api_version = await get_track_download_url(track_id)
-        
-        # Prepare response
-        result = {
-            "track_id": track_id,
-            "name": spotify_response["name"],
-            "album": spotify_response["album"]["name"],
-            "artist": spotify_response["artists"][0]["name"],
-            "release_date": spotify_response["album"]["release_date"],
-            "duration_ms": spotify_response["duration_ms"],
-            "url": download_url,
-            "download_api_version": api_version
-        }
-        
-        duration = time.time() - start_time
-        logger.info(f"Request {request_id} completed successfully in {duration:.2f}s using API {api_version}")
-        return result
-        
-    except HTTPException:
-        raise
+        logger.info(f'track_id: {track_id}')
+        cookie = get_cookie()
+        if not cookie:
+            return JSONResponse(content={"error": "Failed to get session cookie"}, status_code=500)
+    
+        track_data = get_data(track_id)
+        logger.info(track_data)
+        if not track_data:
+            return JSONResponse(content={"error": "Failed to get track data"}, status_code=404)
+    
+        download_link = get_url(track_data, cookie)
+        if not download_link:
+            return JSONResponse(content={"error": "Failed to get download URL"}, status_code=500)
+    
+        return JSONResponse(content={"url": download_link})
     except Exception as e:
-        logger.error(f"Request {request_id} failed with error: {str(e)}")
-        raise HTTPException(status_code=500, detail="Internal server error")
+        # 可以根据具体情况记录日志或者返回不同的错误信息
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+
+
+
+
 
-# ... (rest of the code remains the same)
 @app.get("/")
 async def health_check():
     """Health check endpoint."""
@@ -282,4 +324,4 @@ async def health_check():
         }
     except Exception as e:
         logger.error(f"Health check failed: {str(e)}")
-        return {"status": "unhealthy", "error": str(e)}
+        return {"status": "unhealthy", "error": str(e)}