Update app.py

app.py

@@ -1,12 +1,11 @@
 import base64
 import logging
-from typing import Optional
-from functools import lru_cache
+from typing import Optional, Dict
 from fastapi import FastAPI, HTTPException, Request
 import requests
 from bs4 import BeautifulSoup
 import os
-from datetime import datetime
+from datetime import datetime, timedelta
 import time
 
 # Configure logging
@@ -27,16 +26,44 @@ app = FastAPI(title="Spotify Track API",
 SPOTIFY_API_URL = "https://api.spotify.com/v1"
 SPOTIFY_CLIENT_ID = os.getenv("SPOTIFY_CLIENT_ID")
 SPOTIFY_CLIENT_SECRET = os.getenv("SPOTIFY_CLIENT_SECRET")
-TOKEN_EXPIRY = 3600  # Spotify token expires in 1 hour
+TOKEN_EXPIRY = 3500  # Slightly less than 1 hour to ensure token refresh before expiration
+
+# Token cache
+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
 
-# Cache token for 1 hour
-@lru_cache(maxsize=1)
-def get_spotify_token():
+def get_spotify_token() -> str:
+    """
+    Get Spotify access token with expiration handling.
+    Returns a valid token, either from cache or by requesting a new one.
+    """
     try:
+        # Check if we have a valid cached token
+        cached_token = token_cache.get_token()
+        if cached_token:
+            logger.info("Using cached Spotify token")
+            return cached_token
+
         logger.info("Requesting new Spotify access token")
         start_time = time.time()
         
@@ -56,9 +83,11 @@ def get_spotify_token():
         if auth_response.status_code != 200:
             raise SpotifyAPIError(f"Failed to get token: {auth_response.text}")
         
-        token = auth_response.json()['access_token']
-        logger.info(f"Token obtained successfully in {time.time() - start_time:.2f}s")
-        return token
+        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)}")
@@ -85,7 +114,7 @@ async def get_track_download_url(track_id: str) -> str:
     for api_url in apis:
         try:
             logger.info(f"Attempting to get download URL from: {api_url}")
-            response = requests.get(api_url, timeout=20)
+            response = requests.get(api_url, timeout=10)
             if response.status_code == 200:
                 download_url = response.json().get("url")
                 if download_url:
@@ -133,6 +162,18 @@ async def get_track(
             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(
@@ -171,7 +212,11 @@ async def health_check():
     try:
         # Test Spotify API token generation
         token = get_spotify_token()
-        return {"status": "healthy", "spotify_auth": "ok"}
+        return {
+            "status": "healthy",
+            "spotify_auth": "ok",
+            "token_expires_in": token_cache.expiry_time.timestamp() - datetime.now().timestamp() if token_cache.expiry_time else None
+        }
     except Exception as e:
         logger.error(f"Health check failed: {str(e)}")
         return {"status": "unhealthy", "error": str(e)}