deepeval 3.4.7__py3-none-any.whl → 3.4.9__py3-none-any.whl

deepeval/cli/utils.py

@@ -1,7 +1,13 @@
-from rich import print
+from __future__ import annotations
+
+import os
 import webbrowser
 import pyfiglet
-from typing import Optional
+
+from enum import Enum
+from pathlib import Path
+from rich import print
+from typing import Optional, Dict, Iterable, List, Tuple, Union
 from opentelemetry.trace import Span
 
 from deepeval.key_handler import (
@@ -14,8 +20,25 @@ from deepeval.test_run.test_run import (
     global_test_run_manager,
 )
 from deepeval.confident.api import get_confident_api_key, set_confident_api_key
+from deepeval.cli.dotenv_handler import DotenvHandler
 
+
+StrOrEnum = Union[str, "Enum"]
 PROD = "https://app.confident-ai.com"
+# List all mutually exclusive USE_* keys
+USE_MODEL_KEYS: List[ModelKeyValues | EmbeddingKeyValues] = [
+    ModelKeyValues.USE_OPENAI_MODEL,
+    ModelKeyValues.USE_AZURE_OPENAI,
+    ModelKeyValues.USE_LOCAL_MODEL,
+    ModelKeyValues.USE_GROK_MODEL,
+    ModelKeyValues.USE_MOONSHOT_MODEL,
+    ModelKeyValues.USE_DEEPSEEK_MODEL,
+    ModelKeyValues.USE_GEMINI_MODEL,
+    ModelKeyValues.USE_LITELLM,
+    EmbeddingKeyValues.USE_AZURE_OPENAI_EMBEDDING,
+    EmbeddingKeyValues.USE_LOCAL_EMBEDDINGS,
+    # MAINTENANCE: add more if new USE_* keys appear
+]
 
 
 def render_login_message():
@@ -65,3 +88,94 @@ def clear_evaluation_model_keys():
 def clear_embedding_model_keys():
     for key in EmbeddingKeyValues:
         KEY_FILE_HANDLER.remove_key(key)
+
+
+def _to_str_key(k: StrOrEnum) -> str:
+    return k.value if hasattr(k, "value") else str(k)
+
+
+def _normalize_kv(updates: Dict[StrOrEnum, str]) -> Dict[str, str]:
+    return {_to_str_key(k): v for k, v in updates.items()}
+
+
+def _normalize_keys(keys: Iterable[StrOrEnum]) -> list[str]:
+    return [_to_str_key(k) for k in keys]
+
+
+def _parse_save_option(
+    save_opt: str | None, default_path: str = ".env.local"
+) -> Tuple[bool, str | None]:
+    if not save_opt:
+        return False, None
+    kind, *rest = save_opt.split(":", 1)
+    if kind != "dotenv":
+        return False, None
+    path = rest[0] if rest else default_path
+    return True, path
+
+
+def resolve_save_target(save_opt: Optional[str]) -> Optional[str]:
+    """
+    Returns a normalized save target string like 'dotenv:.env.local' or None.
+    Precedence:
+      1) --save=...
+      2) DEEPEVAL_DEFAULT_SAVE (opt-in project default)
+      3) None (no save)
+    """
+    if save_opt:
+        return save_opt
+
+    env_default = os.getenv("DEEPEVAL_DEFAULT_SAVE")
+    if env_default and env_default.strip():
+        return env_default.strip()
+
+    return None
+
+
+def save_environ_to_store(
+    save_opt: str | None, updates: Dict[StrOrEnum, str]
+) -> Tuple[bool, str | None]:
+    """
+    Save 'updates' into the selected store (currently only dotenv). Idempotent upsert.
+    Returns (handled, path).
+    """
+    ok, path = _parse_save_option(save_opt)
+    if not ok:
+        return False, None
+    if updates:
+        DotenvHandler(path).upsert(_normalize_kv(updates))
+    return True, path
+
+
+def unset_environ_in_store(
+    save_opt: str | None, keys: Iterable[StrOrEnum]
+) -> Tuple[bool, str | None]:
+    """
+    Remove keys from the selected store (currently only dotenv).
+    Returns (handled, path).
+    """
+    ok, path = _parse_save_option(save_opt)
+    if not ok:
+        return False, None
+    norm = _normalize_keys(keys)
+    if norm:
+        DotenvHandler(path).unset(norm)
+    return True, path
+
+
+def switch_model_provider(target: ModelKeyValues, save: str = None) -> None:
+    """
+    Ensure exactly one USE_* model flag is set to "YES" and the rest to "NO",
+    both in the .deepeval json store and in a dotenv file (if save is provided).
+    """
+    if target not in USE_MODEL_KEYS:
+        raise ValueError(f"{target} is not a recognized USE_* model key")
+
+    for key in USE_MODEL_KEYS:
+        value = "YES" if key == target else "NO"
+        KEY_FILE_HANDLER.write_key(key, value)
+
+        if save:
+            handled, path = save_environ_to_store(save, {key: value})
+            if not handled:
+                print("Unsupported --save option. Use --save=dotenv[:path].")

deepeval/confident/api.py

@@ -14,6 +14,8 @@ from tenacity import (
 import deepeval
 from deepeval.key_handler import KEY_FILE_HANDLER, KeyValues
 from deepeval.confident.types import ApiResponse, ConfidentApiError
+from deepeval.config.settings import get_settings
+
 
 CONFIDENT_API_KEY_ENV_VAR = "CONFIDENT_API_KEY"
 DEEPEVAL_BASE_URL = "https://deepeval.confident-ai.com"
@@ -31,20 +33,33 @@ def get_base_api_url():
         return API_BASE_URL
 
 
-def get_confident_api_key():
-    return os.getenv(CONFIDENT_API_KEY_ENV_VAR) or KEY_FILE_HANDLER.fetch_data(
-        KeyValues.API_KEY
-    )
-
-
-def set_confident_api_key(api_key: Union[str, None]):
-    if api_key is None:
-        KEY_FILE_HANDLER.remove_key(KeyValues.API_KEY)
-        os.environ.pop(CONFIDENT_API_KEY_ENV_VAR, None)
-        return
-
-    KEY_FILE_HANDLER.write_key(KeyValues.API_KEY, api_key)
-    os.environ[CONFIDENT_API_KEY_ENV_VAR] = api_key
+def get_confident_api_key() -> Optional[str]:
+    s = get_settings()
+    key: Optional[SecretStr] = s.CONFIDENT_API_KEY or s.API_KEY
+    return key.get_secret_value() if key else None
+
+
+def set_confident_api_key(api_key: Optional[str]) -> None:
+    """
+    - Always updates runtime (os.environ) via settings.edit()
+    - If DEEPEVAL_DEFAULT_SAVE is set, also persists to dotenv
+    - Never writes secrets to the legacy JSON keystore (your Settings logic already skips secrets)
+    """
+    s = get_settings()
+    save = (
+        s.DEEPEVAL_DEFAULT_SAVE or None
+    )  # e.g. "dotenv" or "dotenv:/path/.env"
+
+    # If you *only* want runtime changes unless a default save is present:
+    if save is None:
+        with s.edit(persist=False):
+            s.CONFIDENT_API_KEY = SecretStr(api_key) if api_key else None
+            s.API_KEY = SecretStr(api_key) if api_key else None
+    else:
+        # Respect default save: update runtime + write to dotenv, but not JSON
+        with s.edit(save=save, persist=None):
+            s.CONFIDENT_API_KEY = SecretStr(api_key) if api_key else None
+            s.API_KEY = SecretStr(api_key) if api_key else None
 
 
 def is_confident():