Configuration reference¶

@dataclass(frozen=True)
class AppConfig:
    environment: str = "development"
    host: str = "127.0.0.1"
    port: int = 8791
    data_dir: Path = field(default_factory=lambda: default_data_dir())
    database_url: str | None = None
    public_base_url: str = "http://127.0.0.1:8791"
    token_pepper: str = DEV_SECRET
    admin_session_secret: str = DEV_SECRET
    admin_cidr_allowlist: tuple[str, ...] = ("127.0.0.1/32", "::1/128")
    cors_origins: tuple[str, ...] = ()
    max_upload_bytes: int = 25 * 1024 * 1024
    max_sync_audio_seconds: int = 120
    max_async_audio_seconds: int = 900
    max_audio_channels: int = 2
    max_sample_rate_hz: int = 48_000
    audio_probe_timeout_seconds: int = 15
    max_process_rss_bytes: int = 0
    max_concurrent_transcriptions: int = 1
    max_model_downloads: int = 1
    max_running_jobs: int = 1
    max_queued_jobs: int = 100
    default_max_concurrent_async_jobs: int = 3
    model_idle_ttl_seconds: int = 900
    max_loaded_models: int = 1
    default_async_retention_hours: int = 24
    output_cache_enabled: bool = False
    request_timeout_seconds: int = 900
    async_job_runner: str = "background"
    cleanup_interval_seconds: int = 3600
    orphan_upload_retention_seconds: int = 3600
    audit_retention_days: int = 90
    preload_models: tuple[str, ...] = ()
    warmup_audio_path: str | None = None
    allow_trust_remote_code: bool = False

    @property
    def resolved_database_url(self) -> str:
        if self.database_url:
            return self.database_url
        return f"sqlite:///{self.data_dir / 'audiotext.sqlite3'}"

    @property
    def is_production(self) -> bool:
        return self.environment.lower() in {"prod", "production"}

    def ensure_directories(self) -> None:
        self.data_dir.mkdir(parents=True, exist_ok=True)
        (self.data_dir / "uploads").mkdir(parents=True, exist_ok=True)
        (self.data_dir / "results").mkdir(parents=True, exist_ok=True)
        (self.data_dir / "logs").mkdir(parents=True, exist_ok=True)

    def validate_for_startup(self) -> None:
        if self.port < 1 or self.port > 65535:
            raise ValueError("port must be between 1 and 65535")
        if self.max_upload_bytes < 1:
            raise ValueError("max_upload_bytes must be positive")
        if self.audio_probe_timeout_seconds < 1:
            raise ValueError("audio_probe_timeout_seconds must be positive")
        if self.max_audio_channels < 1:
            raise ValueError("max_audio_channels must be positive")
        if self.max_sample_rate_hz < 1:
            raise ValueError("max_sample_rate_hz must be positive")
        if self.max_process_rss_bytes < 0:
            raise ValueError("max_process_rss_bytes must be zero or positive")
        if self.max_concurrent_transcriptions < 1:
            raise ValueError("max_concurrent_transcriptions must be positive")
        if self.max_model_downloads < 1:
            raise ValueError("max_model_downloads must be positive")
        if self.max_running_jobs < 1:
            raise ValueError("max_running_jobs must be positive")
        if self.max_queued_jobs < 1:
            raise ValueError("max_queued_jobs must be positive")
        if self.default_max_concurrent_async_jobs < 1:
            raise ValueError("default_max_concurrent_async_jobs must be positive")
        if self.max_loaded_models < 1:
            raise ValueError("max_loaded_models must be positive")
        if self.async_job_runner not in {"background", "external"}:
            raise ValueError("async_job_runner must be 'background' or 'external'")
        if self.cleanup_interval_seconds < 0:
            raise ValueError("cleanup_interval_seconds must be zero or positive")
        if self.orphan_upload_retention_seconds < 1:
            raise ValueError("orphan_upload_retention_seconds must be positive")
        if self.audit_retention_days < 1:
            raise ValueError("audit_retention_days must be positive")
        if self.is_production:
            missing = []
            if not self.token_pepper or self.token_pepper == DEV_SECRET:
                missing.append(f"{ENV_PREFIX}TOKEN_PEPPER")
            if not self.admin_session_secret or self.admin_session_secret == DEV_SECRET:
                missing.append(f"{ENV_PREFIX}ADMIN_SESSION_SECRET")
            if missing:
                raise ValueError("production requires configured secrets: " + ", ".join(missing))

    def safe_dict(self) -> dict[str, object]:
        payload = asdict(self)
        payload["data_dir"] = str(self.data_dir)
        payload["database_url"] = redact_secret(self.resolved_database_url)
        payload["token_pepper"] = configured_state(self.token_pepper)
        payload["admin_session_secret"] = configured_state(self.admin_session_secret)
        return payload