Upload app.py

app.py

@@ -1,5 +1,5 @@
 """
-YouTube Music API Wrapper — v6  (Production / Render 512 MB)
+YouTube Music API Wrapper — v7  (Production / Render 512 MB)
 =============================================================
 
 WHAT'S NEW IN v6
@@ -61,7 +61,6 @@ from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager
 from typing import Any, Dict, List, Optional
 
-import base64
 import diskcache
 import httpx
 from fastapi import FastAPI, HTTPException, Query, Request, Response
@@ -70,22 +69,20 @@ from fastapi.middleware.gzip import GZipMiddleware
 from slowapi import Limiter, _rate_limit_exceeded_handler
 from slowapi.errors import RateLimitExceeded
 from slowapi.util import get_remote_address
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.responses import Response as StarletteResponse
 from ytmusicapi import YTMusic
+# At the top with your other imports
+import base64
+from starlette.middleware.base import BaseHTTPMiddleware
+from fastapi import Request
+from fastapi.responses import Response
 from download_bp import router as download_router
 
-# ─────────────────────────────────────────────────────────────────────────────
-#  /docs Basic Auth middleware  (registered after app = FastAPI() below)
-# ─────────────────────────────────────────────────────────────────────────────
-
-DOCS_PASSWORD = os.environ.get("DOCS_PASSWORD", "")
+# /docs Basic Auth middleware
+DOCS_PASSWORD = os.environ.get("DOCS_PASSWORD", "prakamya05")
 
 class DocsAuthMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next):
         if request.url.path in ("/docs", "/openapi.json", "/redoc"):
-            if not DOCS_PASSWORD:
-                return await call_next(request)
             auth = request.headers.get("Authorization", "")
             if auth.startswith("Basic "):
                 try:
@@ -95,12 +92,16 @@ class DocsAuthMiddleware(BaseHTTPMiddleware):
                         return await call_next(request)
                 except Exception:
                     pass
-            return StarletteResponse(
+            return Response(
                 "Unauthorized", status_code=401,
                 headers={"WWW-Authenticate": 'Basic realm="Musicanaz Docs"'},
             )
         return await call_next(request)
 
+# Register middleware + router (after app = FastAPI(...))
+app.add_middleware(DocsAuthMiddleware)
+app.include_router(download_router)
+
 # ─────────────────────────────────────────────────────────────────────────────
 #  Logging
 # ─────────────────────────────────────────────────────────────────────────────
@@ -271,13 +272,23 @@ _http_client: httpx.AsyncClient | None = None
 
 
 def _get_http_client() -> httpx.AsyncClient:
+    """
+    Shared async HTTP client for external APIs (iTunes, Deezer).
+    Routes through the rotating proxy when PROXY_USERNAME / PROXY_PASSWORD are set
+    so all outbound traffic uses the same IP pool as ytmusicapi.
+    """
     global _http_client
     if _http_client is None or _http_client.is_closed:
+        proxy_url = (
+            f"http://{_PROXY_USER}:{_PROXY_PASS}@{_PROXY_HOST}:{_PROXY_PORT}"
+            if _PROXY_USER and _PROXY_PASS else None
+        )
         _http_client = httpx.AsyncClient(
             timeout=httpx.Timeout(10.0),
             limits=httpx.Limits(max_connections=20, max_keepalive_connections=10),
             follow_redirects=True,
             headers={"User-Agent": "MusicAPI/6.0 (compatible; ytmusicapi)"},
+            **({"proxy": proxy_url} if proxy_url else {}),
         )
     return _http_client
 
@@ -294,7 +305,7 @@ limiter = Limiter(key_func=get_remote_address, default_limits=["200/minute"])
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     # Startup
-    log.info("Starting YouTube Music API v6 …")
+    log.info("Starting YouTube Music API v7 …")
     asyncio.create_task(_background_warmup())
     asyncio.create_task(_auto_refresh_loop())
     yield
@@ -316,22 +327,19 @@ app = FastAPI(
         "Production-grade FastAPI wrapper for ytmusicapi. "
         "Two-level cache, rate limiting, iTunes + Deezer enrichment, circuit breaker."
     ),
-    version="6.0.0",
+    version="7.0.0",
     lifespan=lifespan,
 )
 
 app.state.limiter = limiter
 app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
-# DocsAuthMiddleware added LAST so it wraps everything (runs first on request)
-app.add_middleware(DocsAuthMiddleware)
 app.add_middleware(GZipMiddleware, minimum_size=300)
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
-    allow_methods=["GET", "POST", "DELETE"],   # POST required for /download/start + /done
+    allow_methods=["GET", "DELETE"],
     allow_headers=["*"],
 )
-app.include_router(download_router)
 
 # 4 workers: ytmusicapi is I/O-bound — more workers waste RAM
 _executor = ThreadPoolExecutor(max_workers=4)
@@ -339,7 +347,15 @@ _executor = ThreadPoolExecutor(max_workers=4)
 
 async def run(fn, *args, **kwargs):
     loop = asyncio.get_running_loop()   # get_event_loop() removed in Python 3.12
-    return await loop.run_in_executor(_executor, lambda: fn(*args, **kwargs))
+    def _safe_call():
+        try:
+            return fn(*args, **kwargs)
+        except StopIteration as exc:
+            # PEP 479: StopIteration raised inside a generator propagated through
+            # run_in_executor causes "TypeError: StopIteration interacts badly with
+            # generators". Convert it to RuntimeError so asyncio handles it cleanly.
+            raise RuntimeError(f"ytmusicapi StopIteration caught: {exc}") from exc
+    return await loop.run_in_executor(_executor, _safe_call)
 
 # ─────────────────────────────────────────────────────────────────────────────
 #  Per-locale YTMusic instance pool  (LRU, capped at 12)
@@ -900,12 +916,18 @@ def _flatten_mood_categories(raw: Any) -> list[dict]:
 #  Health + admin
 # ─────────────────────────────────────────────────────────────────────────────
 
+@app.get("/", include_in_schema=False)
+async def root():
+    """Root route — satisfies HF Spaces / Render health-check pings on /."""
+    return {"name": "Musicanaz API", "version": "6.0.0", "status": "ok", "docs": "/docs"}
+
+
 @app.get("/health", tags=["meta"])
 async def health():
     hits, misses = _disk_cache.stats()
     return {
         "status":         "ok",
-        "version":        "6.0.0",
+        "version":        "7.0.0",
         "uptime_seconds": round(time.monotonic() - _START_TIME),
         "ytm_instances":  len(_ytm_pool),
         "proxy_enabled":  _PROXIES is not None,
@@ -1017,16 +1039,17 @@ async def search_suggestions(
     response: Response,
     query:    str,
     detailed_runs: bool = False,
+    country:  str = Query("ZZ"),
     language: str = Query("en"),
 ):
-    cache_key = f"suggest:{query}:{language}"
+    cache_key = f"suggest:{query}:{country}:{language}"
     cached    = _cache_short.get(cache_key)
     if cached is not None:
         response.headers.update(_cc(30))
         return cached
     try:
         raw = await run(
-            get_ytm("ZZ", language).get_search_suggestions, query, detailed_runs
+            get_ytm(country, language).get_search_suggestions, query, detailed_runs
         )
         suggestions: list[str] = []
         if isinstance(raw, list):
@@ -1053,15 +1076,16 @@ async def get_artist(
     request:   Request,
     response:  Response,
     artist_id: str,
+    country:   str = Query("ZZ"),
     language:  str = Query("en"),
 ):
-    cache_key = f"artist:{artist_id}:{language}"
+    cache_key = f"artist:{artist_id}:{country}:{language}"
     cached    = _cache_long.get(cache_key)
     if cached is not None:
         response.headers.update(_cc(600))
         return cached
     try:
-        data = await run(get_ytm("ZZ", language).get_artist, artist_id)
+        data = await run(get_ytm(country, language).get_artist, artist_id)
         if not data:
             raise HTTPException(404, "Artist not found")
         data["thumbnails"] = best_thumbnails_list(data.get("thumbnails") or [])
@@ -1100,13 +1124,13 @@ async def get_artist_songs(
     limit:     int = Query(500, ge=1, le=5000),
     language:  str = Query("en"),
 ):
-    cache_key = f"artist_songs:{artist_id}:{limit}:{language}"
+    cache_key = f"artist_songs:{artist_id}:{limit}:{country}:{language}"
     cached    = _cache_long.get(cache_key)
     if cached is not None:
         response.headers.update(_cc(600))
         return cached
     try:
-        ytm         = get_ytm("ZZ", language)
+        ytm         = get_ytm(country, language)
         artist_data = await run(ytm.get_artist, artist_id)
         if not artist_data:
             raise HTTPException(404, "Artist not found")
@@ -1200,15 +1224,16 @@ async def get_artist_albums_endpoint(
     request:   Request,
     response:  Response,
     artist_id: str,
+    country:   str = Query("ZZ"),
     language:  str = Query("en"),
 ):
-    cache_key = f"artist_albums:{artist_id}:{language}"
+    cache_key = f"artist_albums:{artist_id}:{country}:{language}"
     cached    = _cache_long.get(cache_key)
     if cached is not None:
         response.headers.update(_cc(600))
         return cached
     try:
-        ytm         = get_ytm("ZZ", language)
+        ytm         = get_ytm(country, language)
         artist_data = await run(ytm.get_artist, artist_id)
         if not artist_data:
             raise HTTPException(404, "Artist not found")
@@ -1297,15 +1322,16 @@ async def get_album(
     request:  Request,
     response: Response,
     album_id: str,
+    country:  str = Query("ZZ"),
     language: str = Query("en"),
 ):
-    cache_key = f"album:{album_id}:{language}"
+    cache_key = f"album:{album_id}:{country}:{language}"
     cached    = _cache_long.get(cache_key)
     if cached is not None:
         response.headers.update(_cc(3600))
         return cached
     try:
-        data = await run(get_ytm("ZZ", language).get_album, album_id)
+        data = await run(get_ytm(country, language).get_album, album_id)
         if not data:
             raise HTTPException(404, "Album not found")
         data["thumbnails"] = best_thumbnails_list(data.get("thumbnails") or [])
@@ -1325,14 +1351,20 @@ async def get_album(
 
 @app.get("/song/{video_id}")
 @limiter.limit("60/minute")
-async def get_song(request: Request, response: Response, video_id: str):
+async def get_song(
+    request:  Request,
+    response: Response,
+    video_id: str,
+    country:  str = Query("ZZ"),
+    language: str = Query("en"),
+):
     cache_key = f"song:{video_id}"
     cached    = _cache_long.get(cache_key)
     if cached is not None:
         response.headers.update(_cc(3600))
         return cached
     try:
-        data = await run(get_ytm().get_song, video_id)
+        data = await run(get_ytm(country, language).get_song, video_id)
         raw  = (
             data.get("thumbnail", {}).get("thumbnails") or
             data.get("thumbnails") or []
@@ -1352,14 +1384,20 @@ async def get_song(request: Request, response: Response, video_id: str):
 
 @app.get("/stream/{video_id}")
 @limiter.limit("60/minute")
-async def get_stream(request: Request, response: Response, video_id: str):
+async def get_stream(
+    request:  Request,
+    response: Response,
+    video_id: str,
+    country:  str = Query("ZZ"),
+    language: str = Query("en"),
+):
     cache_key = f"stream:{video_id}"
     cached    = _cache_long.get(cache_key)
     if cached is not None:
         response.headers.update(_cc(3600))
         return cached
     try:
-        song_data = await run(get_ytm().get_song, video_id)
+        song_data = await run(get_ytm(country, language).get_song, video_id)
         vd = song_data.get("videoDetails", {})
         if not vd:
             raise HTTPException(404, "Video not found")
@@ -1560,17 +1598,18 @@ async def get_playlist(
     limit:        int  = Query(100, ge=1, le=500),
     related:      bool = False,
     suggestions_limit: int = 0,
+    country:      str = Query("ZZ"),
     language:     str = Query("en"),
 ):
     clean_id  = playlist_id[2:] if playlist_id.startswith("VL") else playlist_id
-    cache_key = f"playlist:{clean_id}:{limit}:{language}"
+    cache_key = f"playlist:{clean_id}:{limit}:{country}:{language}"
     cached    = _cache_medium.get(cache_key)
     if cached is not None:
         response.headers.update(_cc(300))
         return cached
     try:
         data = await run(
-            get_ytm("ZZ", language).get_playlist,
+            get_ytm(country, language).get_playlist,
             clean_id, limit, related, suggestions_limit,
         )
         if not data:
@@ -1597,16 +1636,17 @@ async def get_podcast(
     response:   Response,
     podcast_id: str,
     limit:      int = Query(50, ge=1, le=200),
+    country:    str = Query("ZZ"),
     language:   str = Query("en"),
 ):
     clean_id  = podcast_id[2:] if (podcast_id.startswith("VL") and not podcast_id.startswith("VLM")) else podcast_id
-    cache_key = f"podcast:{clean_id}:{limit}:{language}"
+    cache_key = f"podcast:{clean_id}:{limit}:{country}:{language}"
     cached    = _cache_long.get(cache_key)
     if cached is not None:
         response.headers.update(_cc(1800))
         return cached
 
-    ytm          = get_ytm("ZZ", language)
+    ytm          = get_ytm(country, language)
     episodes_raw: list = []
     meta: dict         = {}
 
@@ -1714,14 +1754,19 @@ async def get_watch_playlist(
 # ─────────────────────────────────────────────────────────────────────────────
 
 @app.get("/lyrics/{browse_id}")
-async def get_lyrics(response: Response, browse_id: str):
-    cache_key = f"lyrics:{browse_id}"
+async def get_lyrics(
+    response: Response,
+    browse_id: str,
+    country:  str = Query("ZZ"),
+    language: str = Query("en"),
+):
+    cache_key = f"lyrics:{browse_id}:{country}:{language}"
     cached    = _cache_long.get(cache_key)
     if cached is not None:
         response.headers.update(_cc(7200))
         return cached
     try:
-        data = await run(get_ytm().get_lyrics, browse_id)
+        data = await run(get_ytm(country, language).get_lyrics, browse_id)
         _cache_long.set(cache_key, data)
         response.headers.update(_cc(7200))
         return data
@@ -1730,14 +1775,19 @@ async def get_lyrics(response: Response, browse_id: str):
 
 
 @app.get("/lyrics_by_video/{video_id}")
-async def get_lyrics_by_video(response: Response, video_id: str):
-    cache_key = f"lyrics_vid:{video_id}"
+async def get_lyrics_by_video(
+    response: Response,
+    video_id: str,
+    country:  str = Query("ZZ"),
+    language: str = Query("en"),
+):
+    cache_key = f"lyrics_vid:{video_id}:{country}:{language}"
     cached    = _cache_long.get(cache_key)
     if cached is not None:
         response.headers.update(_cc(7200))
         return cached
 
-    ytm = get_ytm()
+    ytm = get_ytm(country, language)
     try:
         watch     = await run(ytm.get_watch_playlist, video_id, None, 1)
         lyrics_id = watch.get("lyrics")
@@ -2131,14 +2181,15 @@ async def get_explore(
 async def get_user(
     response:   Response,
     channel_id: str,
+    country:    str = Query("ZZ"),
     language:   str = Query("en"),
 ):
-    cache_key = f"user:{channel_id}:{language}"
+    cache_key = f"user:{channel_id}:{country}:{language}"
     cached    = _cache_long.get(cache_key)
     if cached is not None:
         return cached
     try:
-        data = await run(get_ytm("ZZ", language).get_user, channel_id)
+        data = await run(get_ytm(country, language).get_user, channel_id)
         _cache_long.set(cache_key, data)
         return data
     except Exception as e:
@@ -2150,10 +2201,11 @@ async def get_user_playlists(
     response:   Response,
     channel_id: str,
     params:     Optional[str] = None,
+    country:    str = Query("ZZ"),
     language:   str = Query("en"),
 ):
     try:
-        data = await run(get_ytm("ZZ", language).get_user_playlists, channel_id, params)
+        data = await run(get_ytm(country, language).get_user_playlists, channel_id, params)
         return data
     except Exception as e:
         raise HTTPException(500, detail=str(e))