feat: fST external API istemci için AI music detection eklendi

app/services/fst_client.py

@@ -13,8 +13,11 @@ Gracefully returns unavailable result on timeout or error.
 
 from __future__ import annotations
 
+import asyncio
 import io
+import os
 import tempfile
+import time
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional, Union
@@ -29,7 +32,13 @@ FST_API_URL = f"https://{FST_SPACE_ID.replace('/', '-')}.hf.space"
 
 # Timeouts
 FST_CONNECT_TIMEOUT = 10.0   # seconds
-FST_PREDICT_TIMEOUT = 120.0  # seconds (model inference can be slow)
+FST_PREDICT_TIMEOUT = float(os.getenv("FST_PREDICT_TIMEOUT", "60"))
+# After a failed connect, try again this much later instead of never.
+FST_RETRY_AFTER = 300.0
+# Calls in flight at once; a timed-out call keeps its thread until the
+# remote answers, so this also bounds how many threads can pile up.
+FST_MAX_CONCURRENT = 2
+FST_ENABLED = os.getenv("FST_ENABLED", "1") != "0"
 
 
 @dataclass
@@ -56,9 +65,13 @@ class FSTClientService:
     def __init__(self) -> None:
         self._client = None
         self._available: Optional[bool] = None
+        self._failed_at = 0.0
+        self._gate: Optional[asyncio.Semaphore] = None
 
     def _ensure_client(self) -> bool:
-        """Lazy-initialize Gradio client."""
+        """Lazy-initialize Gradio client (blocking: call from a thread)."""
+        if self._available is False and time.monotonic() - self._failed_at > FST_RETRY_AFTER:
+            self._available = None
         if self._available is not None:
             return self._available
 
@@ -76,15 +89,18 @@ class FSTClientService:
                 "gradio_client not installed — FST layer disabled"
             )
             self._available = False
+            self._failed_at = float("inf")
             return False
         except Exception as e:
             logger.warning(f"FST client init failed: {e}")
             self._available = False
+            self._failed_at = time.monotonic()
             return False
 
     async def predict(
         self,
         source: Union[Path, bytes, io.BytesIO],
+        suffix: str = ".wav",
     ) -> FSTResult:
         """
         Submit audio to FST Space for AI detection.
@@ -95,29 +111,37 @@ class FSTClientService:
         Returns:
             FSTResult with detection outcome.
         """
-        if not self._ensure_client():
-            return FSTResult(
-                available=False,
-                error="fst_client_unavailable",
-            )
+        if not FST_ENABLED:
+            return FSTResult(available=False, error="fst_disabled")
+        if self._gate is None:
+            self._gate = asyncio.Semaphore(FST_MAX_CONCURRENT)
 
+        audio_path: Optional[Path] = None
         try:
-            audio_path = self._to_file_path(source)
-            return await self._call_api(audio_path)
+            async with self._gate:
+                # Connecting fetches the remote config over the network.
+                if not await asyncio.to_thread(self._ensure_client):
+                    return FSTResult(
+                        available=False,
+                        error="fst_client_unavailable",
+                    )
+                audio_path = self._to_file_path(source, suffix)
+                return await self._call_api(audio_path)
         except Exception as e:
             logger.warning(f"FST prediction failed: {e}")
             return FSTResult(
                 available=False,
                 error=str(e),
             )
+        finally:
+            if audio_path is not None and not isinstance(source, Path):
+                audio_path.unlink(missing_ok=True)
 
     async def _call_api(self, audio_path: Path) -> FSTResult:
         """Call the FST Gradio API."""
-        import asyncio
-
         try:
             # Run synchronous Gradio client in executor
-            loop = asyncio.get_event_loop()
+            loop = asyncio.get_running_loop()
             result = await asyncio.wait_for(
                 loop.run_in_executor(
                     None,
@@ -251,14 +275,15 @@ class FSTClientService:
     @staticmethod
     def _to_file_path(
         source: Union[Path, bytes, io.BytesIO],
+        suffix: str = ".wav",
     ) -> Path:
-        """Convert source to a file path for Gradio upload."""
+        """Convert source to a file path for Gradio upload (caller deletes it)."""
         if isinstance(source, Path):
             return source
         if isinstance(source, bytes):
             source = io.BytesIO(source)
         tmp = tempfile.NamedTemporaryFile(
-            suffix=".wav", delete=False,
+            suffix=suffix or ".wav", delete=False,
         )
         tmp.write(source.read())
         tmp.flush()