vexor 0.19.0a1__py3-none-any.whl → 0.21.0__py3-none-any.whl

vexor/cli.py

@@ -31,6 +31,7 @@ from .config import (
     DEFAULT_MODEL,
     DEFAULT_PROVIDER,
     DEFAULT_RERANK,
+    SUPPORTED_EXTRACT_BACKENDS,
     SUPPORTED_PROVIDERS,
     SUPPORTED_RERANKERS,
     flashrank_cache_dir,
@@ -389,6 +390,11 @@ def search(
         "--format",
         help=Messages.HELP_SEARCH_FORMAT,
     ),
+    no_cache: bool = typer.Option(
+        False,
+        "--no-cache",
+        help=Messages.HELP_NO_CACHE,
+    ),
 ) -> None:
     """Run the semantic search."""
     config = load_config()
@@ -396,6 +402,8 @@ def search(
     model_name = resolve_default_model(provider, config.model)
     batch_size = config.batch_size if config.batch_size is not None else DEFAULT_BATCH_SIZE
     embed_concurrency = config.embed_concurrency
+    extract_concurrency = config.extract_concurrency
+    extract_backend = config.extract_backend
     base_url = config.base_url
     api_key = config.api_key
     auto_index = bool(config.auto_index)
@@ -433,6 +441,8 @@ def search(
         model_name=model_name,
         batch_size=batch_size,
         embed_concurrency=embed_concurrency,
+        extract_concurrency=extract_concurrency,
+        extract_backend=extract_backend,
         provider=provider,
         base_url=base_url,
         api_key=api_key,
@@ -440,20 +450,35 @@ def search(
         exclude_patterns=normalized_excludes,
         extensions=normalized_exts,
         auto_index=auto_index,
+        no_cache=no_cache,
         rerank=rerank,
         flashrank_model=flashrank_model,
         remote_rerank=remote_rerank,
     )
     if output_format == SearchOutputFormat.rich:
-        should_index_first = _should_index_before_search(request) if auto_index else False
-        if should_index_first:
+        if no_cache:
             console.print(
-                _styled(Messages.INFO_INDEX_RUNNING.format(path=directory), Styles.INFO)
+                _styled(
+                    Messages.INFO_SEARCH_RUNNING_NO_CACHE.format(path=directory),
+                    Styles.INFO,
+                )
             )
         else:
-            console.print(
-                _styled(Messages.INFO_SEARCH_RUNNING.format(path=directory), Styles.INFO)
+            should_index_first = (
+                _should_index_before_search(request) if auto_index else False
             )
+            if should_index_first:
+                console.print(
+                    _styled(
+                        Messages.INFO_INDEX_RUNNING.format(path=directory), Styles.INFO
+                    )
+                )
+            else:
+                console.print(
+                    _styled(
+                        Messages.INFO_SEARCH_RUNNING.format(path=directory), Styles.INFO
+                    )
+                )
     try:
         response = perform_search(request)
     except FileNotFoundError:
@@ -557,6 +582,8 @@ def index(
     model_name = resolve_default_model(provider, config.model)
     batch_size = config.batch_size if config.batch_size is not None else DEFAULT_BATCH_SIZE
     embed_concurrency = config.embed_concurrency
+    extract_concurrency = config.extract_concurrency
+    extract_backend = config.extract_backend
     base_url = config.base_url
     api_key = config.api_key
 
@@ -653,6 +680,8 @@ def index(
             model_name=model_name,
             batch_size=batch_size,
             embed_concurrency=embed_concurrency,
+            extract_concurrency=extract_concurrency,
+            extract_backend=extract_backend,
             provider=provider,
             base_url=base_url,
             api_key=api_key,
@@ -714,6 +743,16 @@ def config(
         "--set-embed-concurrency",
         help=Messages.HELP_SET_EMBED_CONCURRENCY,
     ),
+    set_extract_concurrency_option: int | None = typer.Option(
+        None,
+        "--set-extract-concurrency",
+        help=Messages.HELP_SET_EXTRACT_CONCURRENCY,
+    ),
+    set_extract_backend_option: str | None = typer.Option(
+        None,
+        "--set-extract-backend",
+        help=Messages.HELP_SET_EXTRACT_BACKEND,
+    ),
     set_provider_option: str | None = typer.Option(
         None,
         "--set-provider",
@@ -790,6 +829,8 @@ def config(
         raise typer.BadParameter(Messages.ERROR_BATCH_NEGATIVE)
     if set_embed_concurrency_option is not None and set_embed_concurrency_option < 1:
         raise typer.BadParameter(Messages.ERROR_CONCURRENCY_INVALID)
+    if set_extract_concurrency_option is not None and set_extract_concurrency_option < 1:
+        raise typer.BadParameter(Messages.ERROR_EXTRACT_CONCURRENCY_INVALID)
     if set_base_url_option and clear_base_url:
         raise typer.BadParameter(Messages.ERROR_BASE_URL_CONFLICT)
     flashrank_model_reset = False
@@ -815,6 +856,16 @@ def config(
         if not normalized_remote_key:
             raise typer.BadParameter(Messages.ERROR_REMOTE_RERANK_API_KEY_EMPTY)
         set_remote_rerank_api_key_option = normalized_remote_key
+    if set_extract_backend_option is not None:
+        normalized_backend = set_extract_backend_option.strip().lower()
+        if normalized_backend not in SUPPORTED_EXTRACT_BACKENDS:
+            allowed = ", ".join(SUPPORTED_EXTRACT_BACKENDS)
+            raise typer.BadParameter(
+                Messages.ERROR_EXTRACT_BACKEND_INVALID.format(
+                    value=set_extract_backend_option, allowed=allowed
+                )
+            )
+        set_extract_backend_option = normalized_backend
     if clear_remote_rerank and any(
         (
             set_remote_rerank_url_option is not None,
@@ -830,6 +881,8 @@ def config(
             set_model_option is not None,
             set_batch_option is not None,
             set_embed_concurrency_option is not None,
+            set_extract_concurrency_option is not None,
+            set_extract_backend_option is not None,
             set_provider_option is not None,
             set_base_url_option is not None,
             clear_base_url,
@@ -942,6 +995,8 @@ def config(
         model=set_model_option,
         batch_size=set_batch_option,
         embed_concurrency=set_embed_concurrency_option,
+        extract_concurrency=set_extract_concurrency_option,
+        extract_backend=set_extract_backend_option,
         provider=set_provider_option,
         base_url=set_base_url_option,
         clear_base_url=clear_base_url,
@@ -973,6 +1028,22 @@ def config(
                 Styles.SUCCESS,
             )
         )
+    if updates.extract_concurrency_set and set_extract_concurrency_option is not None:
+        console.print(
+            _styled(
+                Messages.INFO_EXTRACT_CONCURRENCY_SET.format(
+                    value=set_extract_concurrency_option
+                ),
+                Styles.SUCCESS,
+            )
+        )
+    if updates.extract_backend_set and set_extract_backend_option is not None:
+        console.print(
+            _styled(
+                Messages.INFO_EXTRACT_BACKEND_SET.format(value=set_extract_backend_option),
+                Styles.SUCCESS,
+            )
+        )
     if updates.provider_set and set_provider_option is not None:
         console.print(
             _styled(Messages.INFO_PROVIDER_SET.format(value=set_provider_option), Styles.SUCCESS)
@@ -1119,6 +1190,8 @@ def config(
                     model=resolve_default_model(provider, cfg.model),
                     batch=cfg.batch_size if cfg.batch_size is not None else DEFAULT_BATCH_SIZE,
                     concurrency=cfg.embed_concurrency,
+                    extract_concurrency=cfg.extract_concurrency,
+                    extract_backend=cfg.extract_backend,
                     auto_index="yes" if cfg.auto_index else "no",
                     rerank=rerank,
                     flashrank_line=flashrank_line,

vexor/config.py

@@ -5,23 +5,30 @@ from __future__ import annotations
 import json
 import os
 from dataclasses import dataclass
+from collections.abc import Mapping
 from pathlib import Path
 from typing import Any, Dict
 from urllib.parse import urlparse, urlunparse
 
-CONFIG_DIR = Path(os.path.expanduser("~")) / ".vexor"
+from .text import Messages
+
+DEFAULT_CONFIG_DIR = Path(os.path.expanduser("~")) / ".vexor"
+CONFIG_DIR = DEFAULT_CONFIG_DIR
 CONFIG_FILE = CONFIG_DIR / "config.json"
 DEFAULT_MODEL = "text-embedding-3-small"
 DEFAULT_GEMINI_MODEL = "gemini-embedding-001"
 DEFAULT_LOCAL_MODEL = "intfloat/multilingual-e5-small"
 DEFAULT_BATCH_SIZE = 64
-DEFAULT_EMBED_CONCURRENCY = 2
+DEFAULT_EMBED_CONCURRENCY = 4
+DEFAULT_EXTRACT_CONCURRENCY = max(1, min(4, os.cpu_count() or 1))
+DEFAULT_EXTRACT_BACKEND = "auto"
 DEFAULT_PROVIDER = "openai"
 DEFAULT_RERANK = "off"
 DEFAULT_FLASHRANK_MODEL = "ms-marco-TinyBERT-L-2-v2"
 DEFAULT_FLASHRANK_MAX_LENGTH = 256
 SUPPORTED_PROVIDERS: tuple[str, ...] = (DEFAULT_PROVIDER, "gemini", "custom", "local")
 SUPPORTED_RERANKERS: tuple[str, ...] = ("off", "bm25", "flashrank", "remote")
+SUPPORTED_EXTRACT_BACKENDS: tuple[str, ...] = ("auto", "thread", "process")
 ENV_API_KEY = "VEXOR_API_KEY"
 REMOTE_RERANK_ENV = "VEXOR_REMOTE_RERANK_API_KEY"
 LEGACY_GEMINI_ENV = "GOOGLE_GENAI_API_KEY"
@@ -41,6 +48,8 @@ class Config:
     model: str = DEFAULT_MODEL
     batch_size: int = DEFAULT_BATCH_SIZE
     embed_concurrency: int = DEFAULT_EMBED_CONCURRENCY
+    extract_concurrency: int = DEFAULT_EXTRACT_CONCURRENCY
+    extract_backend: str = DEFAULT_EXTRACT_BACKEND
     provider: str = DEFAULT_PROVIDER
     base_url: str | None = None
     auto_index: bool = True
@@ -77,6 +86,10 @@ def load_config() -> Config:
         model=raw.get("model") or DEFAULT_MODEL,
         batch_size=int(raw.get("batch_size", DEFAULT_BATCH_SIZE)),
         embed_concurrency=int(raw.get("embed_concurrency", DEFAULT_EMBED_CONCURRENCY)),
+        extract_concurrency=int(
+            raw.get("extract_concurrency", DEFAULT_EXTRACT_CONCURRENCY)
+        ),
+        extract_backend=_coerce_extract_backend(raw.get("extract_backend")),
         provider=raw.get("provider") or DEFAULT_PROVIDER,
         base_url=raw.get("base_url") or None,
         auto_index=bool(raw.get("auto_index", True)),
@@ -96,6 +109,8 @@ def save_config(config: Config) -> None:
         data["model"] = config.model
     data["batch_size"] = config.batch_size
     data["embed_concurrency"] = config.embed_concurrency
+    data["extract_concurrency"] = config.extract_concurrency
+    data["extract_backend"] = config.extract_backend
     if config.provider:
         data["provider"] = config.provider
     if config.base_url:
@@ -129,6 +144,38 @@ def flashrank_cache_dir(*, create: bool = True) -> Path:
     return cache_dir
 
 
+def set_config_dir(path: Path | str | None) -> None:
+    global CONFIG_DIR, CONFIG_FILE
+    if path is None:
+        CONFIG_DIR = DEFAULT_CONFIG_DIR
+    else:
+        dir_path = Path(path).expanduser().resolve()
+        if dir_path.exists() and not dir_path.is_dir():
+            raise NotADirectoryError(f"Path is not a directory: {dir_path}")
+        CONFIG_DIR = dir_path
+    CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def config_from_json(
+    payload: str | Mapping[str, object], *, base: Config | None = None
+) -> Config:
+    """Return a Config from a JSON string or mapping without saving it."""
+    data = _coerce_config_payload(payload)
+    config = Config() if base is None else _clone_config(base)
+    _apply_config_payload(config, data)
+    return config
+
+
+def update_config_from_json(
+    payload: str | Mapping[str, object], *, replace: bool = False
+) -> Config:
+    """Update config from a JSON string or mapping and persist it."""
+    base = None if replace else load_config()
+    config = config_from_json(payload, base=base)
+    save_config(config)
+    return config
+
+
 def set_api_key(value: str | None) -> None:
     config = load_config()
     config.api_key = value
@@ -153,6 +200,18 @@ def set_embed_concurrency(value: int) -> None:
     save_config(config)
 
 
+def set_extract_concurrency(value: int) -> None:
+    config = load_config()
+    config.extract_concurrency = value
+    save_config(config)
+
+
+def set_extract_backend(value: str) -> None:
+    config = load_config()
+    config.extract_backend = _normalize_extract_backend(value)
+    save_config(config)
+
+
 def set_provider(value: str) -> None:
     config = load_config()
     config.provider = value
@@ -281,3 +340,182 @@ def resolve_remote_rerank_api_key(configured: str | None) -> str | None:
     if env_key:
         return env_key
     return None
+
+
+def _coerce_config_payload(payload: str | Mapping[str, object]) -> Mapping[str, object]:
+    if isinstance(payload, str):
+        try:
+            data = json.loads(payload)
+        except json.JSONDecodeError as exc:
+            raise ValueError(Messages.ERROR_CONFIG_JSON_INVALID) from exc
+    elif isinstance(payload, Mapping):
+        data = dict(payload)
+    else:
+        raise ValueError(Messages.ERROR_CONFIG_JSON_INVALID)
+    if not isinstance(data, Mapping):
+        raise ValueError(Messages.ERROR_CONFIG_JSON_INVALID)
+    return data
+
+
+def _clone_config(config: Config) -> Config:
+    remote = config.remote_rerank
+    return Config(
+        api_key=config.api_key,
+        model=config.model,
+        batch_size=config.batch_size,
+        embed_concurrency=config.embed_concurrency,
+        extract_concurrency=config.extract_concurrency,
+        extract_backend=config.extract_backend,
+        provider=config.provider,
+        base_url=config.base_url,
+        auto_index=config.auto_index,
+        local_cuda=config.local_cuda,
+        rerank=config.rerank,
+        flashrank_model=config.flashrank_model,
+        remote_rerank=(
+            None
+            if remote is None
+            else RemoteRerankConfig(
+                base_url=remote.base_url,
+                api_key=remote.api_key,
+                model=remote.model,
+            )
+        ),
+    )
+
+
+def _apply_config_payload(config: Config, payload: Mapping[str, object]) -> None:
+    if "api_key" in payload:
+        config.api_key = _coerce_optional_str(payload["api_key"], "api_key")
+    if "model" in payload:
+        config.model = _coerce_required_str(payload["model"], "model", DEFAULT_MODEL)
+    if "batch_size" in payload:
+        config.batch_size = _coerce_int(
+            payload["batch_size"], "batch_size", DEFAULT_BATCH_SIZE
+        )
+    if "embed_concurrency" in payload:
+        config.embed_concurrency = _coerce_int(
+            payload["embed_concurrency"],
+            "embed_concurrency",
+            DEFAULT_EMBED_CONCURRENCY,
+        )
+    if "extract_concurrency" in payload:
+        config.extract_concurrency = _coerce_int(
+            payload["extract_concurrency"],
+            "extract_concurrency",
+            DEFAULT_EXTRACT_CONCURRENCY,
+        )
+    if "extract_backend" in payload:
+        config.extract_backend = _normalize_extract_backend(payload["extract_backend"])
+    if "provider" in payload:
+        config.provider = _coerce_required_str(
+            payload["provider"], "provider", DEFAULT_PROVIDER
+        )
+    if "base_url" in payload:
+        config.base_url = _coerce_optional_str(payload["base_url"], "base_url")
+    if "auto_index" in payload:
+        config.auto_index = _coerce_bool(payload["auto_index"], "auto_index")
+    if "local_cuda" in payload:
+        config.local_cuda = _coerce_bool(payload["local_cuda"], "local_cuda")
+    if "rerank" in payload:
+        config.rerank = _normalize_rerank(payload["rerank"])
+    if "flashrank_model" in payload:
+        config.flashrank_model = _coerce_optional_str(
+            payload["flashrank_model"], "flashrank_model"
+        )
+    if "remote_rerank" in payload:
+        config.remote_rerank = _coerce_remote_rerank(payload["remote_rerank"])
+
+
+def _coerce_optional_str(value: object, field: str) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, str):
+        cleaned = value.strip()
+        return cleaned or None
+    raise ValueError(Messages.ERROR_CONFIG_VALUE_INVALID.format(field=field))
+
+
+def _coerce_required_str(value: object, field: str, default: str) -> str:
+    if value is None:
+        return default
+    if isinstance(value, str):
+        cleaned = value.strip()
+        return cleaned or default
+    raise ValueError(Messages.ERROR_CONFIG_VALUE_INVALID.format(field=field))
+
+
+def _coerce_int(value: object, field: str, default: int) -> int:
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        raise ValueError(Messages.ERROR_CONFIG_VALUE_INVALID.format(field=field))
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        if value.is_integer():
+            return int(value)
+        raise ValueError(Messages.ERROR_CONFIG_VALUE_INVALID.format(field=field))
+    if isinstance(value, str):
+        cleaned = value.strip()
+        if not cleaned:
+            return default
+        try:
+            return int(cleaned)
+        except ValueError as exc:
+            raise ValueError(Messages.ERROR_CONFIG_VALUE_INVALID.format(field=field)) from exc
+    raise ValueError(Messages.ERROR_CONFIG_VALUE_INVALID.format(field=field))
+
+
+def _coerce_bool(value: object, field: str) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, int) and value in (0, 1):
+        return bool(value)
+    if isinstance(value, str):
+        cleaned = value.strip().lower()
+        if cleaned in {"true", "1", "yes", "on"}:
+            return True
+        if cleaned in {"false", "0", "no", "off"}:
+            return False
+    raise ValueError(Messages.ERROR_CONFIG_VALUE_INVALID.format(field=field))
+
+
+def _normalize_extract_backend(value: object) -> str:
+    if value is None:
+        return DEFAULT_EXTRACT_BACKEND
+    if isinstance(value, str):
+        normalized = value.strip().lower() or DEFAULT_EXTRACT_BACKEND
+        if normalized in SUPPORTED_EXTRACT_BACKENDS:
+            return normalized
+    raise ValueError(Messages.ERROR_CONFIG_VALUE_INVALID.format(field="extract_backend"))
+
+
+def _coerce_extract_backend(value: object) -> str:
+    if value is None:
+        return DEFAULT_EXTRACT_BACKEND
+    if isinstance(value, str):
+        normalized = value.strip().lower()
+        if normalized in SUPPORTED_EXTRACT_BACKENDS:
+            return normalized
+    return DEFAULT_EXTRACT_BACKEND
+
+
+def _normalize_rerank(value: object) -> str:
+    if value is None:
+        normalized = DEFAULT_RERANK
+    elif isinstance(value, str):
+        normalized = value.strip().lower() or DEFAULT_RERANK
+    else:
+        raise ValueError(Messages.ERROR_CONFIG_VALUE_INVALID.format(field="rerank"))
+    if normalized not in SUPPORTED_RERANKERS:
+        normalized = DEFAULT_RERANK
+    return normalized
+
+
+def _coerce_remote_rerank(value: object) -> RemoteRerankConfig | None:
+    if value is None:
+        return None
+    if isinstance(value, Mapping):
+        return _parse_remote_rerank(dict(value))
+    raise ValueError(Messages.ERROR_CONFIG_VALUE_INVALID.format(field="remote_rerank"))

vexor/providers/gemini.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from concurrent.futures import ThreadPoolExecutor, as_completed
+import time
 from typing import Iterator, Sequence
 
 import numpy as np
@@ -38,14 +39,19 @@ class GeminiEmbeddingBackend:
         if base_url:
             client_kwargs["http_options"] = genai_types.HttpOptions(base_url=base_url)
         self._client = genai.Client(**client_kwargs)
+        self._executor: ThreadPoolExecutor | None = None
 
     def embed(self, texts: Sequence[str]) -> np.ndarray:
         if not texts:
             return np.empty((0, 0), dtype=np.float32)
-        batches = list(_chunk(texts, self.chunk_size))
-        if self.concurrency > 1 and len(batches) > 1:
-            vectors_by_batch: list[list[np.ndarray] | None] = [None] * len(batches)
-            with ThreadPoolExecutor(max_workers=min(self.concurrency, len(batches))) as executor:
+        if self.concurrency > 1:
+            batches = list(_chunk(texts, self.chunk_size))
+            if len(batches) > 1:
+                vectors_by_batch: list[list[np.ndarray] | None] = [None] * len(batches)
+                executor = self._executor
+                if executor is None:
+                    executor = ThreadPoolExecutor(max_workers=self.concurrency)
+                    self._executor = executor
                 future_map = {
                     executor.submit(self._embed_batch, batch): idx
                     for idx, batch in enumerate(batches)
@@ -53,23 +59,34 @@ class GeminiEmbeddingBackend:
                 for future in as_completed(future_map):
                     idx = future_map[future]
                     vectors_by_batch[idx] = future.result()
-            vectors = [vec for batch in vectors_by_batch if batch for vec in batch]
+                vectors = [vec for batch in vectors_by_batch if batch for vec in batch]
+            else:
+                vectors = []
+                for batch in batches:
+                    vectors.extend(self._embed_batch(batch))
         else:
             vectors = []
-            for batch in batches:
+            for batch in _chunk(texts, self.chunk_size):
                 vectors.extend(self._embed_batch(batch))
         if not vectors:
             raise RuntimeError(Messages.ERROR_NO_EMBEDDINGS)
         return np.vstack(vectors)
 
     def _embed_batch(self, batch: Sequence[str]) -> list[np.ndarray]:
-        try:
-            response = self._client.models.embed_content(
-                model=self.model_name,
-                contents=list(batch),
-            )
-        except genai_errors.ClientError as exc:
-            raise RuntimeError(_format_genai_error(exc)) from exc
+        attempt = 0
+        while True:
+            try:
+                response = self._client.models.embed_content(
+                    model=self.model_name,
+                    contents=list(batch),
+                )
+                break
+            except genai_errors.ClientError as exc:
+                if _should_retry_genai_error(exc) and attempt < _MAX_RETRIES:
+                    _sleep(_backoff_delay(attempt))
+                    attempt += 1
+                    continue
+                raise RuntimeError(_format_genai_error(exc)) from exc
         embeddings = getattr(response, "embeddings", None)
         if not embeddings:
             raise RuntimeError(Messages.ERROR_NO_EMBEDDINGS)
@@ -90,6 +107,55 @@ def _chunk(items: Sequence[str], size: int | None) -> Iterator[Sequence[str]]:
         yield items[idx : idx + size]
 
 
+_RETRYABLE_STATUS_CODES = {408, 429, 500, 502, 503, 504}
+_MAX_RETRIES = 2
+_RETRY_BASE_DELAY = 0.5
+_RETRY_MAX_DELAY = 4.0
+
+
+def _sleep(seconds: float) -> None:
+    time.sleep(seconds)
+
+
+def _backoff_delay(attempt: int) -> float:
+    return min(_RETRY_MAX_DELAY, _RETRY_BASE_DELAY * (2**attempt))
+
+
+def _extract_status_code(exc: Exception) -> int | None:
+    for attr in ("status_code", "status", "http_status"):
+        value = getattr(exc, attr, None)
+        if isinstance(value, int):
+            return value
+    response = getattr(exc, "response", None)
+    if response is not None:
+        value = getattr(response, "status_code", None)
+        if isinstance(value, int):
+            return value
+    return None
+
+
+def _should_retry_genai_error(exc: Exception) -> bool:
+    status = _extract_status_code(exc)
+    if status in _RETRYABLE_STATUS_CODES:
+        return True
+    name = exc.__class__.__name__.lower()
+    if "ratelimit" in name or "timeout" in name or "temporarily" in name:
+        return True
+    message = str(exc).lower()
+    return any(
+        token in message
+        for token in (
+            "rate limit",
+            "timeout",
+            "temporar",
+            "overload",
+            "try again",
+            "too many requests",
+            "service unavailable",
+        )
+    )
+
+
 def _format_genai_error(exc: genai_errors.ClientError) -> str:
     message = getattr(exc, "message", None) or str(exc)
     if "API key" in message: