Update app.py

app.py

@@ -7,6 +7,11 @@ 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
 
 # Configure logging
 logging.basicConfig(
@@ -104,28 +109,83 @@ 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")
 
-async def get_track_download_url(track_id: str) -> str:
-    """Get download URL with fallback."""
+# 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 = [
-        f"https://downspotifyapis.vercel.app/api/v2/track/{track_id}",
-        f"https://downspotifyapis.vercel.app/api/v1/track/{track_id}"
+        ("https://downspotifyapis.vercel.app/api/v2/track/", "v2"),
+        ("https://downspotifyapis.vercel.app/api/v1/track/", "v1")
     ]
     
-    for api_url in apis:
+    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}")
-            response = requests.get(api_url, timeout=30)
+            
+            # 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
+                    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
     
-    logger.error(f"No download URL found for track {track_id}")
-    raise HTTPException(status_code=404, detail="Download URL not found")
+    # 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}"
+    )
 
 @app.get("/get-track")
 async def get_track(
@@ -133,10 +193,7 @@ async def get_track(
     track_id: Optional[str] = None,
     track_url: Optional[str] = None
 ):
-    """
-    Get track information and download URL.
-    Requires either track_id or track_url parameter.
-    """
+    """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}")
     
@@ -183,21 +240,26 @@ async def get_track(
         
         track_data = response.json()
         
-        # Get download URL
-        download_url = await get_track_download_url(track_id)
+        # 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": track_data["name"],
-            "album": track_data["album"]["name"],
-            "artist": track_data["artists"][0]["name"],
-            "release_date": track_data["album"]["release_date"],
-            "duration_ms": track_data["duration_ms"],
-            "url": download_url
+            "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
         }
         
-        logger.info(f"Request {request_id} completed successfully in {time.time() - start_time:.2f}s")
+        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:
@@ -206,7 +268,8 @@ async def get_track(
         logger.error(f"Request {request_id} failed with error: {str(e)}")
         raise HTTPException(status_code=500, detail="Internal server error")
 
-@app.get("/health")
+# ... (rest of the code remains the same)
+@app.get("/")
 async def health_check():
     """Health check endpoint."""
     try: