Update app.py

app.py

@@ -5,20 +5,14 @@ from deezspot.spotloader import SpoLogin
 import requests
 import os
 import logging
-import json
 from typing import Optional
 from fastapi.staticfiles import StaticFiles
 from dotenv import load_dotenv
 from pydantic import BaseModel, Field, HttpUrl
 from urllib.parse import quote
-from pathlib import Path
 import uuid
-from fastapi import BackgroundTasks
-from collections import defaultdict
-import time
-from datetime import timedelta
 import gc
-from typing import Dict, Union, Literal
+from typing import Literal
 import urllib.parse
 from fastapi.responses import JSONResponse
 
@@ -31,7 +25,6 @@ app = FastAPI(title="Deezer API")
 load_dotenv()
 
 # Mount a static files directory to serve downloaded files
-
 os.makedirs("downloads", exist_ok=True)
 app.mount("/downloads", StaticFiles(directory="downloads"), name="downloads")
 
@@ -56,6 +49,7 @@ def convert_deezer_short_link_async(short_link: str) -> str:
         print(f"An error occurred: {e}")
         return ""
 
+
 @app.middleware("http")
 async def log_errors_middleware(request: Request, call_next):
     try:
@@ -91,71 +85,11 @@ def get_track(track_id: str):
     return get_track_info(track_id)
 
 
-# Rate limiting dictionary
-class RateLimiter:
-    def __init__(self, max_requests: int, time_window: timedelta):
-        self.max_requests = max_requests
-        self.time_window = time_window
-        self.requests: Dict[str, list] = defaultdict(list)
-
-    def _cleanup_old_requests(self, user_ip: str) -> None:
-        """Remove requests that are outside the time window."""
-        current_time = time.time()
-        self.requests[user_ip] = [
-            timestamp for timestamp in self.requests[user_ip]
-            if current_time - timestamp < self.time_window.total_seconds()
-        ]
-
-    def is_rate_limited(self, user_ip: str) -> bool:
-        """Check if the user has exceeded their rate limit."""
-        self._cleanup_old_requests(user_ip)
-
-        # Get current count after cleanup
-        current_count = len(self.requests[user_ip])
-
-        # Add current request timestamp (incrementing the count)
-        current_time = time.time()
-        self.requests[user_ip].append(current_time)
-
-        # Check if user has exceeded the maximum requests
-        return (current_count + 1) > self.max_requests
-
-    def get_current_count(self, user_ip: str) -> int:
-        """Get the current request count for an IP."""
-        self._cleanup_old_requests(user_ip)
-        return len(self.requests[user_ip])
-
-
-# Initialize rate limiter with 25 requests per day
-rate_limiter = RateLimiter(
-    max_requests=5,
-    time_window=timedelta(days=1)
-)
-
-
-def get_user_ip(request: Request) -> str:
-    """Helper function to get user's IP address."""
-    forwarded = request.headers.get("X-Forwarded-For")
-    if forwarded:
-        return forwarded.split(",")[0]
-    return request.client.host
-
-
-# Download a track and return a download URL
+# Download a track and return a download URL (NO RATE LIMITS)
 @app.post("/download/track")
 def download_track(request: Request, download_request: DownloadRequest):
     try:
-        user_ip = get_user_ip(request)
-
-        if rate_limiter.is_rate_limited(user_ip):
-            current_count = rate_limiter.get_current_count(user_ip)
-            raise HTTPException(
-                status_code=429,
-                detail={
-                    "detail": "You have exceeded the maximum number of requests per day. Please try again tomorrow or get the Premium version for unlimited downloads at https://chrunos.com/premium-shortcuts/.",
-                    "help": "https://t.me/chrunoss"
-                }
-            )
+        # Use provided ARL or fallback to env
         if download_request.arl is None or download_request.arl.strip() == "":
             ARL = ARL_TOKEN
         else:
@@ -171,7 +105,7 @@ def download_track(request: Request, download_request: DownloadRequest):
         if quality not in ["MP3_320", "MP3_128", "FLAC"]:
             raise HTTPException(status_code=400, detail="Invalid quality specified")
 
-        # 提取 track_id （假设 url 格式为 https://api.deezer.com/track/{track_id}）
+        # Extract track_id
         track_id = url.split("/")[-1]
 
         # Fetch track info
@@ -184,7 +118,6 @@ def download_track(request: Request, download_request: DownloadRequest):
         track_title = track_info.get("title", "track")
         artist_name = track_info.get("artist", {}).get("name", "unknown")
         file_extension = "flac" if quality == "FLAC" else "mp3"
-        expected_filename = f"{artist_name} - {track_title}.{file_extension}".replace("/", "_")  # Sanitize filename
 
         # Clear the downloads directory
         for root, dirs, files in os.walk("downloads"):
@@ -193,21 +126,16 @@ def download_track(request: Request, download_request: DownloadRequest):
             for dir in dirs:
                 shutil.rmtree(os.path.join(root, dir))
 
-        # Download the track using deezspot
-        try:
-            # 下载文件的代码
-            dl.download_trackdee(
-                link_track=track_link,
-                output_dir="downloads",
-                quality_download=quality,
-                recursive_quality=False,
-                recursive_download=False
-            )
-        except Exception as e:
-            logger.error(f"Error downloading file: {e}")
-            raise HTTPException(status_code=500, detail="File download failed")
-
-        # Recursively search for the file in the downloads directory
+        # Download the track
+        dl.download_trackdee(
+            link_track=track_link,
+            output_dir="downloads",
+            quality_download=quality,
+            recursive_quality=False,
+            recursive_download=False
+        )
+
+        # Find the file
         filepath = None
         for root, dirs, files in os.walk("downloads"):
             for file in files:
@@ -219,25 +147,22 @@ def download_track(request: Request, download_request: DownloadRequest):
 
         if not filepath:
             raise HTTPException(status_code=500, detail=f"{file_extension} file not found after download")
-        if filepath:
-            file_size = os.path.getsize(filepath)
-            logger.info(f"Downloaded file size: {file_size} bytes")
+
+        file_size = os.path.getsize(filepath)
+        logger.info(f"Downloaded file size: {file_size} bytes")
 
         # Return the download URL
         relative_path = quote(str(os.path.relpath(filepath, "downloads")))
-        # Remove spaces from the relative path
-        # Auto-detect base URL from request
         base_url = str(request.base_url).rstrip('/')
         download_url = f"{base_url}/downloads/{relative_path}"
         logger.info(f"Download successful: {download_url}")
         gc.collect()
-        return {"download_url": download_url, "requests_remaining": rate_limiter.max_requests - rate_limiter.get_current_count(user_ip)}
+        return {"download_url": download_url}
     except Exception as e:
         logger.error(f"Error downloading track: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
-
 # Pydantic model for album request
 class AlbumRequest(BaseModel):
     id: str
@@ -302,7 +227,6 @@ def fetch_playlist(request: PlaylistRequest):
         raise HTTPException(status_code=500, detail=str(e))
 
 
-
 # Search tracks using Deezer API
 @app.get("/z_search")
 def search_tracks(query: str, limit: Optional[int] = 10):
@@ -318,7 +242,6 @@ def search_tracks(query: str, limit: Optional[int] = 10):
 
 
 # --- Request Body Model ---
-# Defines the expected structure and validation for the request body.
 class SpotDlRequest(BaseModel):
     url: HttpUrl = Field(..., description="The URL to be processed.")
     quality: Literal["128", "320", "FLAC"] = Field(
@@ -327,12 +250,10 @@ class SpotDlRequest(BaseModel):
     )
 
 # --- Response Body Model ---
-# Defines the structure for a successful response.
 class SpotDlResponse(BaseModel):
     download_url: str
 
 # --- Error Response Model ---
-# Defines the structure for an error response.
 class ErrorResponse(BaseModel):
     detail: str
 
@@ -349,34 +270,19 @@ class ErrorResponse(BaseModel):
                 "otherwise returns an error for higher qualities."
 )
 async def create_spot_dl_link(request: SpotDlRequest = Body(...)):
-    """
-    Processes a URL and quality to generate a download link.
-
-    - **url**: The URL to process (must be a valid HTTP/HTTPS URL).
-    - **quality**: The desired quality. Must be one of "128", "320", "FLAC".
-                   Currently, only "128" will result in a successful link generation.
-    """
-    # Log the received request for debugging (optional)
     print(f"Received request: url='{request.url}', quality='{request.quality}'")
 
-    # Check the quality
     if request.quality == "128":
-        # URL-encode the input URL
         encoded_url = urllib.parse.quote(str(request.url), safe='')
-        # Construct the target URL
         output_url = f"https://velynapi.vercel.app/api/downloader/spotifydl?url={encoded_url}"
         return SpotDlResponse(download_url=output_url)
     elif request.quality == "320" or request.quality == "FLAC":
-        # If quality is 320 or FLAC, return an error as per requirements
         raise HTTPException(
             status_code=400,
             detail=f"Quality '{request.quality}' is for Premium Users Only. '128' is allowed."
         )
     else:
-        # This case should ideally be caught by Pydantic's Literal validation,
-        # but as a fallback or for more general invalid quality values:
         raise HTTPException(
             status_code=400,
             detail=f"Invalid quality value: '{request.quality}'. Allowed values are '128', '320', 'FLAC'."
         )
-