Update app.py

app.py

@@ -207,7 +207,12 @@ def parse_bt_manifest(manifest_data):
 
 @app.get("/download/{track_id}")
 async def download_track(track_id: int, quality: str = "LOSSLESS"):
-    """Download a TIDAL track in specified quality"""
+    """Download a TIDAL track in specified quality.
+    
+    Returns JSON with track info and download URL.
+    - HIGH/LOW: Returns direct TIDAL CDN URL (time-limited)
+    - LOSSLESS/HI_RES_LOSSLESS: Downloads, decrypts, merges, returns mounted file URL
+    """
     try:
         print(f"🔍 Download request: track_id={track_id}, quality={quality}")
         
@@ -254,7 +259,7 @@ async def download_track(track_id: int, quality: str = "LOSSLESS"):
         manifest_mime = data.get('manifestMimeType', '')
         manifest_data = base64.b64decode(data.get('manifest', ''))
         
-        print(f"✅ Got playback data: audioQuality={audio_quality}")
+        print(f"✅ Got playback data: audioQuality={audio_quality}, manifestType={manifest_mime}")
         
         if audio_quality != quality:
             print(f"⚠️ Requested {quality} but got {audio_quality}")
@@ -268,22 +273,29 @@ async def download_track(track_id: int, quality: str = "LOSSLESS"):
         
         title = track_info.get('title', f"track_{track_id}")
         artist = track_info.get('artist', {}).get('name', 'Unknown')
+        duration = track_info.get('duration', 0)
+        album = track_info.get('album', {}).get('title', '')
+        album_artist = track_info.get('album', {}).get('artist', {}).get('name', '')
+        track_number = track_info.get('trackNumber', 1)
+        isrc = track_info.get('isrc', '')
         
-        security_token = data.get('securityToken')
-        key = None
-        nonce = None
-        
-        if security_token:
-            print("🔐 Decrypting security token...")
-            key, nonce = decrypt_security_token(security_token)
-        
-        download_dir = "./downloads"
-        os.makedirs(download_dir, exist_ok=True)
-        
-        tmpdir = tempfile.mkdtemp(prefix="tidal-api-")
+        is_lossless = 'dash+xml' in manifest_mime
         
-        try:
-            if 'dash+xml' in manifest_mime:
+        if is_lossless:
+            security_token = data.get('securityToken')
+            key = None
+            nonce = None
+            
+            if security_token:
+                print("🔐 Decrypting security token...")
+                key, nonce = decrypt_security_token(security_token)
+            
+            download_dir = "./downloads"
+            os.makedirs(download_dir, exist_ok=True)
+            
+            tmpdir = tempfile.mkdtemp(prefix="tidal-api-")
+            
+            try:
                 print("📦 Parsing DASH manifest...")
                 base_url, segments = parse_dash_manifest(manifest_data)
                 print(f"✅ Found {len(segments)} segments")
@@ -315,7 +327,8 @@ async def download_track(track_id: int, quality: str = "LOSSLESS"):
                     print(f"   Segment {i+1}/{len(segments)} downloaded")
                 
                 print("🔐 Decrypting and merging segments...")
-                output_path = os.path.join(download_dir, f"{artist} - {title}.flac")
+                output_filename = f"{artist} - {title}.flac"
+                output_path = os.path.join(download_dir, output_filename)
                 
                 with open(output_path, 'wb') as out:
                     for i in range(len(segments)):
@@ -334,43 +347,57 @@ async def download_track(track_id: int, quality: str = "LOSSLESS"):
                 
                 print(f"✅ Download complete: {output_path}")
                 
-                return FileResponse(
-                    output_path,
-                    media_type="audio/flac",
-                    filename=f"{artist} - {title}.flac"
-                )
-            
-            elif 'tidal.bt' in manifest_mime:
-                print("📦 Parsing BT manifest...")
-                base_url, segments = parse_bt_manifest(manifest_data)
-                print(f"✅ Found {len(segments)} URLs")
-                
-                if not segments:
-                    raise HTTPException(status_code=500, detail="No URLs found in BT manifest")
-                
-                output_path = os.path.join(download_dir, f"{artist} - {title}.m4a")
-                
-                with open(output_path, 'wb') as out:
-                    for i, seg_url in enumerate(segments):
-                        resp = requests.get(seg_url, headers=headers, timeout=60)
-                        if resp.status_code != 200:
-                            raise HTTPException(status_code=500, detail=f"Failed to download part {i}")
-                        out.write(resp.content)
-                        print(f"   Downloaded part {i+1}/{len(segments)}")
-                
-                print(f"✅ Download complete: {output_path}")
+                file_size = os.path.getsize(output_path)
                 
-                return FileResponse(
-                    output_path,
-                    media_type="audio/mp4",
-                    filename=f"{artist} - {title}.m4a"
-                )
+                return {
+                    "success": True,
+                    "track": {
+                        "id": track_id,
+                        "title": title,
+                        "artist": artist,
+                        "album": album,
+                        "albumArtist": album_artist,
+                        "trackNumber": track_number,
+                        "duration": duration,
+                        "isrc": isrc,
+                        "quality": audio_quality,
+                        "fileSize": file_size,
+                        "format": "flac"
+                    },
+                    "downloadUrl": f"/download_file/{output_filename}",
+                    "message": "File downloaded and ready for download"
+                }
+            finally:
+                import shutil
+                shutil.rmtree(tmpdir, ignore_errors=True)
+        
+        else:
+            print("📦 Parsing BT manifest...")
+            base_url, segments = parse_bt_manifest(manifest_data)
+            print(f"✅ Found {len(segments)} URLs")
             
-            else:
-                raise HTTPException(status_code=500, detail=f"Unsupported manifest type: {manifest_mime}")
-        finally:
-            import shutil
-            shutil.rmtree(tmpdir, ignore_errors=True)
+            if not segments:
+                raise HTTPException(status_code=500, detail="No URLs found in BT manifest")
+            
+            download_url = segments[0] if segments else None
+            
+            return {
+                "success": True,
+                "track": {
+                    "id": track_id,
+                    "title": title,
+                    "artist": artist,
+                    "album": album,
+                    "albumArtist": album_artist,
+                    "trackNumber": track_number,
+                    "duration": duration,
+                    "isrc": isrc,
+                    "quality": audio_quality,
+                    "format": "m4a"
+                },
+                "downloadUrl": download_url,
+                "message": "Direct TIDAL CDN URL (time-limited)"
+            }
     
     except HTTPException:
         raise
@@ -378,6 +405,28 @@ async def download_track(track_id: int, quality: str = "LOSSLESS"):
         print(f"❌ Unexpected error: {type(e).__name__}: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/download_file/{filename}")
+async def download_file(filename: str):
+    """Serve downloaded file for LOSSLESS/HI_RES tracks"""
+    try:
+        file_path = os.path.join("./downloads", filename)
+        
+        if not os.path.exists(file_path):
+            raise HTTPException(status_code=404, detail="File not found")
+        
+        ext = os.path.splitext(filename)[1].lower()
+        media_type = "audio/flac" if ext == ".flac" else "audio/mp4"
+        
+        return FileResponse(
+            file_path,
+            media_type=media_type,
+            filename=filename
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 @app.get("/search")
 async def search_tracks(query: str = Query(..., description="Search query"), limit: int = 5):
     """Search for TIDAL tracks"""