fix: load diarization backend configuration safely

app/services/diarization_service.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 import math
+import os
 from pathlib import Path
 from typing import Any
 
@@ -19,9 +20,13 @@ class DiarizationService:
     def __init__(self, settings: Settings) -> None:
         self.settings = settings
 
+    @property
+    def url(self) -> str:
+        return os.getenv("DIARIZATION_URL", "").strip()
+
     @property
     def is_configured(self) -> bool:
-        return bool(self.settings.diarization_url.strip())
+        return bool(self.url)
 
     async def diarize(self, path: Path, mime_type: str, filename: str) -> list[dict[str, Any]]:
         if not self.is_configured:
@@ -35,33 +40,35 @@ class DiarizationService:
             size = path.stat().st_size
         except OSError as exc:
             raise ProcessingError("Unable to inspect diarization input") from exc
-        if size > self.settings.diarization_max_input_bytes:
+
+        max_input = self._int_env("DIARIZATION_MAX_INPUT_BYTES", 1_073_741_824, 1_048_576)
+        if size > max_input:
             raise InputError("Diarization input exceeds the configured size limit")
 
         headers = {
             "Content-Type": mime_type or "application/octet-stream",
             "X-Filename": filename[:255],
         }
-        token = (
-            self.settings.diarization_api_key.get_secret_value()
-            if self.settings.diarization_api_key
-            else ""
-        )
+        token = os.getenv("DIARIZATION_API_KEY", "").strip()
         if token:
             headers["Authorization"] = f"Bearer {token}"
 
+        connect_timeout = self._float_env("DIARIZATION_CONNECT_TIMEOUT_SECONDS", 10.0, 0.1)
+        timeout_seconds = self._float_env("DIARIZATION_TIMEOUT_SECONDS", 300.0, 1.0)
+        max_response = self._int_env("DIARIZATION_MAX_RESPONSE_BYTES", 1_048_576, 1024)
+
         timeout = httpx.Timeout(
-            connect=self.settings.diarization_connect_timeout_seconds,
-            read=self.settings.diarization_timeout_seconds,
-            write=self.settings.diarization_timeout_seconds,
-            pool=self.settings.diarization_connect_timeout_seconds,
+            connect=connect_timeout,
+            read=timeout_seconds,
+            write=timeout_seconds,
+            pool=connect_timeout,
         )
 
         try:
             async with httpx.AsyncClient(timeout=timeout, follow_redirects=False) as client:
                 with path.open("rb") as handle:
                     response = await client.post(
-                        self.settings.diarization_url.strip(),
+                        self.url,
                         content=handle,
                         headers=headers,
                     )
@@ -72,7 +79,7 @@ class DiarizationService:
             raise ProcessingError(
                 f"Diarization backend returned HTTP {response.status_code}"
             )
-        if len(response.content) > self.settings.diarization_max_response_bytes:
+        if len(response.content) > max_response:
             raise ProcessingError("Diarization backend response exceeds the configured limit")
 
         try:
@@ -102,3 +109,29 @@ class DiarizationService:
             normalized.append(span.model_dump())
 
         return normalized
+
+    @staticmethod
+    def _int_env(name: str, default: int, minimum: int) -> int:
+        raw = os.getenv(name, "")
+        if not raw:
+            return default
+        try:
+            value = int(raw)
+        except ValueError as exc:
+            raise ProcessingError(f"{name} must be an integer") from exc
+        if value < minimum:
+            raise ProcessingError(f"{name} is below its minimum allowed value")
+        return value
+
+    @staticmethod
+    def _float_env(name: str, default: float, minimum: float) -> float:
+        raw = os.getenv(name, "")
+        if not raw:
+            return default
+        try:
+            value = float(raw)
+        except ValueError as exc:
+            raise ProcessingError(f"{name} must be a number") from exc
+        if not math.isfinite(value) or value < minimum:
+            raise ProcessingError(f"{name} is below its minimum allowed value")
+        return value