Update app.py

app.py

@@ -2,6 +2,8 @@ import os
 import logging
 import sys
 from datetime import datetime
+from typing import List, Optional
+
 import tidalapi
 from tidalapi import Track, Quality
 from fastapi import FastAPI, HTTPException, Query
@@ -9,6 +11,7 @@ from fastapi.responses import JSONResponse
 
 app = FastAPI()
 
+# --- Logging Setup ---
 logger = logging.getLogger("tidalapi_app")
 logger.setLevel(logging.INFO)
 handler = logging.StreamHandler(sys.stdout)
@@ -16,6 +19,7 @@ formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
 handler.setFormatter(formatter)
 logger.addHandler(handler)
 
+# --- Authentication ---
 def load_tokens_from_secret(session):
     secret = os.getenv("TIDAL_OAUTH_TOKENS")
     if not secret:
@@ -34,7 +38,6 @@ def load_tokens_from_secret(session):
     logger.info("OAuth tokens loaded successfully from secret")
     return True
 
-# Initialize session globally
 session = tidalapi.Session()
 
 if not load_tokens_from_secret(session):
@@ -43,7 +46,7 @@ if not load_tokens_from_secret(session):
 if not session.check_login():
     raise RuntimeError("Failed to login with saved tokens")
 
-# Map client quality strings to tidalapi Quality enums
+# --- Constants ---
 QUALITY_MAP = {
     "LOW": Quality.low_96k,
     "HIGH": Quality.low_320k,
@@ -51,6 +54,55 @@ QUALITY_MAP = {
     "HI_RES": Quality.hi_res_lossless,
 }
 
+# --- Helper Functions ---
+def _extract_stream_info(track_id: int):
+    """
+    Internal helper to fetch stream info for a specific track ID.
+    Returns a dictionary or raises an exception/returns None on failure.
+    """
+    try:
+        track = Track(session, track_id)
+        # Verify track exists/can be fetched
+        _ = track.name 
+    except Exception as e:
+        logger.error(f"Track lookup failed for ID {track_id}: {e}")
+        return None
+
+    try:
+        stream = track.get_stream()
+        manifest = stream.get_stream_manifest()
+    except Exception as e:
+        logger.error(f"Stream fetching failed for {track.name} ({track_id}): {e}")
+        return None
+
+    result = {
+        "track_id": track_id,
+        "track_name": track.name,
+        "artist_name": track.artist.name,
+        "album_name": track.album.name if track.album else "Unknown",
+        "audio_quality": str(stream.audio_quality),
+        "stream_type": None,
+        "download_urls": [],
+        "mpd_manifest": None
+    }
+
+    if stream.is_bts:
+        urls = manifest.get_urls()
+        if urls:
+            result["stream_type"] = "bts"
+            result["download_urls"] = urls
+    elif stream.is_mpd:
+        mpd_manifest = stream.get_manifest_data()
+        result["stream_type"] = "mpd"
+        result["mpd_manifest"] = mpd_manifest
+    else:
+        logger.warning(f"Unsupported stream type for track {track_id}")
+        return None
+
+    return result
+
+# --- Endpoints ---
+
 @app.get("/")
 async def root():
     logger.info("GET /")
@@ -59,55 +111,100 @@ async def root():
         "author": "made by Cody from chrunos.com"
     }
 
-@app.get("/track/")
-def get_track_download_url(
-    id: int = Query(..., description="TIDAL Track ID"),
+@app.get("/search")
+def search_tracks(
+    query: str = Query(..., description="Search query (e.g., song title)"),
+    limit: int = Query(10, description="Max results to return", ge=1, le=50),
+    offset: int = Query(0, description="Pagination offset", ge=0)
+):
+    """
+    Search for tracks on Tidal.
+    """
+    logger.info(f"Searching for: {query} (limit={limit}, offset={offset})")
+    
+    try:
+        # models=[Track] ensures we only get tracks back
+        search_results = session.search(query, models=[Track], limit=limit, offset=offset)
+        tracks = search_results.get('tracks', [])
+        
+        results = []
+        for t in tracks:
+            results.append({
+                "id": t.id,
+                "title": t.name,
+                "artist": t.artist.name,
+                "album": t.album.name if t.album else None,
+                "duration": t.duration,
+                "explicit": t.explicit
+            })
+            
+        return JSONResponse(content={"query": query, "count": len(results), "results": results})
+        
+    except Exception as e:
+        logger.error(f"Search failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/playlist")
+def get_playlist(
+    id: str = Query(..., description="Tidal Playlist UUID"),
     quality: str = Query("HI_RES", description="Audio quality", pattern="^(LOW|HIGH|LOSSLESS|HI_RES)$"),
+    limit: int = Query(50, description="Max tracks to process (prevent timeouts)", ge=1, le=100),
+    offset: int = Query(0, description="Track offset", ge=0)
 ):
-    logger.info(f"Request received for track_id: {id} with quality: {quality}")
+    """
+    Fetch a playlist and return download URLs for its tracks.
+    """
+    logger.info(f"Request received for playlist: {id} with quality: {quality}")
 
     if quality not in QUALITY_MAP:
-        logger.error(f"Invalid quality requested: {quality}")
         raise HTTPException(status_code=400, detail=f"Invalid quality. Available: {list(QUALITY_MAP.keys())}")
 
     session.audio_quality = QUALITY_MAP[quality]
 
     try:
-        track = Track(session, id)
-        logger.info(f"Track found: {track.name} by {track.artist.name}")
+        playlist = session.playlist(id)
+        # Fetch tracks from the playlist
+        tracks = playlist.tracks(limit=limit, offset=offset)
+        logger.info(f"Found {len(tracks)} tracks in playlist {playlist.name}")
     except Exception as e:
-        logger.error(f"Track lookup failed: {e}")
-        raise HTTPException(status_code=404, detail="Track not found")
+        logger.error(f"Playlist lookup failed: {e}")
+        raise HTTPException(status_code=404, detail="Playlist not found or API error")
+
+    processed_tracks = []
+    failed_tracks = []
+
+    for t in tracks:
+        # Reuse the helper to get stream info
+        stream_info = _extract_stream_info(t.id)
+        if stream_info:
+            processed_tracks.append(stream_info)
+        else:
+            failed_tracks.append({"id": t.id, "name": t.name})
+
+    return JSONResponse(content={
+        "playlist_id": id,
+        "playlist_name": playlist.name,
+        "processed_count": len(processed_tracks),
+        "failed_count": len(failed_tracks),
+        "tracks": processed_tracks,
+        "failed": failed_tracks
+    })
 
-    stream = track.get_stream()
-    manifest = stream.get_stream_manifest()
-
-    result = {
-        "track_id": id,
-        "track_name": track.name,
-        "artist_name": track.artist.name,
-        "audio_quality": str(stream.audio_quality),
-        "stream_type": None,
-        "download_urls": [],
-    }
+@app.get("/track/")
+def get_track_download_url(
+    id: int = Query(..., description="TIDAL Track ID"),
+    quality: str = Query("HI_RES", description="Audio quality", pattern="^(LOW|HIGH|LOSSLESS|HI_RES)$"),
+):
+    logger.info(f"Request received for track_id: {id} with quality: {quality}")
 
-    if stream.is_bts:
-        urls = manifest.get_urls()
-        if not urls:
-            logger.error("No direct URLs found in manifest")
-            raise HTTPException(status_code=500, detail="No downloadable URLs found")
-        result["stream_type"] = "bts"
-        result["download_urls"] = urls
-        logger.info(f"Returning {len(urls)} direct download URL(s)")
+    if quality not in QUALITY_MAP:
+        raise HTTPException(status_code=400, detail=f"Invalid quality. Available: {list(QUALITY_MAP.keys())}")
 
-    elif stream.is_mpd:
-        mpd_manifest = stream.get_manifest_data()
-        result["stream_type"] = "mpd"
-        result["mpd_manifest"] = mpd_manifest
-        logger.info("Returning MPEG-DASH (MPD) manifest data")
+    session.audio_quality = QUALITY_MAP[quality]
 
-    else:
-        logger.error("Unsupported stream type")
-        raise HTTPException(status_code=500, detail="Unsupported stream type")
+    result = _extract_stream_info(id)
+    
+    if not result:
+        raise HTTPException(status_code=404, detail="Track not found or no stream available")
 
-    return JSONResponse(content=result)
+    return JSONResponse(content=result)