eval-protocol 0.2.84__tar.gz → 0.2.84.dev2__tar.gz

{eval_protocol-0.2.84/eval_protocol.egg-info → eval_protocol-0.2.84.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eval-protocol
-Version: 0.2.84
+Version: 0.2.84.dev2
 Summary: The official Python SDK for Eval Protocol (EP.) EP is an open protocol that standardizes how developers author evals for large language model (LLM) applications.
 Author-email: Fireworks AI <info@fireworks.ai>
 License-Expression: MIT

{eval_protocol-0.2.84 → eval_protocol-0.2.84.dev2}/eval_protocol/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-11-10T00:30:58-0800",
+ "date": "2025-11-10T17:41:27-0800",
  "dirty": false,
  "error": null,
- "full-revisionid": "2d75acf5944468856d9f1bea787fce63dcabc16f",
- "version": "0.2.84"
+ "full-revisionid": "cd9cc91c34f975482fe05b4bf3a60b4a0bcbd746",
+ "version": "0.2.84.dev.2"
 }
 '''  # END VERSION_JSON
 

{eval_protocol-0.2.84 → eval_protocol-0.2.84.dev2}/eval_protocol/auth.py

@@ -136,6 +136,56 @@ def _get_credential_from_config_file(key_name: str) -> Optional[str]:
     return None
 
 
+def _get_credentials_from_config_file() -> Dict[str, Optional[str]]:
+    """
+    Retrieve both api_key and account_id from auth.ini with a single read/parse.
+    Tries simple parsing first for both keys, then falls back to configparser for any missing ones.
+    Returns a dict with up to two keys: 'api_key' and 'account_id'.
+    """
+    results: Dict[str, Optional[str]] = {}
+    auth_ini_path = _get_auth_ini_file()
+    if not auth_ini_path.exists():
+        return results
+
+    # 1) Simple key=value parsing
+    try:
+        simple_creds = _parse_simple_auth_file(auth_ini_path)
+        if "api_key" in simple_creds and simple_creds["api_key"]:
+            results["api_key"] = simple_creds["api_key"]
+        if "account_id" in simple_creds and simple_creds["account_id"]:
+            results["account_id"] = simple_creds["account_id"]
+        if "api_key" in results and "account_id" in results:
+            return results
+    except Exception as e:
+        logger.warning("Error during simple parsing of %s: %s", str(auth_ini_path), e)
+
+    # 2) ConfigParser for any missing keys
+    try:
+        config = configparser.ConfigParser()
+        config.read(auth_ini_path)
+        for key_name in ("api_key", "account_id"):
+            if key_name in results and results[key_name]:
+                continue
+            if "fireworks" in config and config.has_option("fireworks", key_name):
+                value_from_file = config.get("fireworks", key_name)
+                if value_from_file:
+                    results[key_name] = value_from_file
+                    continue
+            if config.has_option(config.default_section, key_name):
+                value_from_default = config.get(config.default_section, key_name)
+                if value_from_default:
+                    results[key_name] = value_from_default
+    except configparser.MissingSectionHeaderError:
+        # Purely key=value file without section headers; simple parsing should have handled it already.
+        logger.debug("%s has no section headers; falling back to simple parsing results.", str(auth_ini_path))
+    except configparser.Error as e_config:
+        logger.warning("Configparser error reading %s: %s", str(auth_ini_path), e_config)
+    except Exception as e_general:
+        logger.warning("Unexpected error reading %s: %s", str(auth_ini_path), e_general)
+
+    return results
+
+
 def get_fireworks_api_key() -> Optional[str]:
     """
     Retrieves the Fireworks API key.
@@ -177,13 +227,15 @@ def get_fireworks_account_id() -> Optional[str]:
     The Account ID is sourced in the following order:
     1. FIREWORKS_ACCOUNT_ID environment variable.
     2. 'account_id' from the [fireworks] section of ~/.fireworks/auth.ini.
+    3. If an API key is available (env or auth.ini), resolve via verifyApiKey.
 
     Returns:
         The Account ID if found, otherwise None.
     """
     # If a profile is active, prefer profile file first, then env
     if _is_profile_active():
-        account_id_from_file = _get_credential_from_config_file("account_id")
+        creds = _get_credentials_from_config_file()
+        account_id_from_file = creds.get("account_id")
         if account_id_from_file:
             return account_id_from_file
         account_id = os.environ.get("FIREWORKS_ACCOUNT_ID")
@@ -196,11 +248,24 @@ def get_fireworks_account_id() -> Optional[str]:
         if account_id:
             logger.debug("Using FIREWORKS_ACCOUNT_ID from environment variable.")
             return account_id
-        account_id_from_file = _get_credential_from_config_file("account_id")
+        creds = _get_credentials_from_config_file()
+        account_id_from_file = creds.get("account_id")
         if account_id_from_file:
             return account_id_from_file
 
-    logger.debug("Fireworks Account ID not found in environment variables or auth.ini.")
+    # 3) Fallback: if API key is present, attempt to resolve via verifyApiKey (env or auth.ini)
+    try:
+        # Intentionally use get_fireworks_api_key to centralize precedence (env vs file)
+        api_key_for_verify = get_fireworks_api_key()
+        if api_key_for_verify:
+            resolved = verify_api_key_and_get_account_id(api_key=api_key_for_verify, api_base=get_fireworks_api_base())
+            if resolved:
+                logger.debug("Using FIREWORKS_ACCOUNT_ID resolved via verifyApiKey: %s", resolved)
+                return resolved
+    except Exception as e:
+        logger.debug("Failed to resolve FIREWORKS_ACCOUNT_ID via verifyApiKey: %s", e)
+
+    logger.debug("Fireworks Account ID not found in environment variables, auth.ini, or via verifyApiKey.")
     return None
 
 

{eval_protocol-0.2.84 → eval_protocol-0.2.84.dev2}/eval_protocol/cli.py

@@ -395,7 +395,7 @@ def parse_args(args=None):
     rft_parser.add_argument("--base-model", help="Base model resource id")
     rft_parser.add_argument("--warm-start-from", help="Addon model to warm start from")
     rft_parser.add_argument("--output-model", help="Output model id (defaults from evaluator)")
-    rft_parser.add_argument("--epochs", type=int, default=8)
+    rft_parser.add_argument("--epochs", type=int, default=1)
     rft_parser.add_argument("--batch-size", type=int, default=128000)
     rft_parser.add_argument("--learning-rate", type=float, default=3e-5)
     rft_parser.add_argument("--max-context-length", type=int, default=65536)
@@ -427,6 +427,27 @@ def parse_args(args=None):
     rft_parser.add_argument("--dry-run", action="store_true", help="Print planned REST calls without sending")
     rft_parser.add_argument("--force", action="store_true", help="Overwrite existing evaluator with the same ID")
 
+    # Local test command
+    local_test_parser = subparsers.add_parser(
+        "local-test",
+        help="Select an evaluation test and run it locally. If a Dockerfile exists, build and run via Docker; otherwise run on host.",
+    )
+    local_test_parser.add_argument(
+        "--entry",
+        help="Entrypoint to run (path::function or path). If not provided, a selector will be shown (unless --yes).",
+    )
+    local_test_parser.add_argument(
+        "--ignore-docker",
+        action="store_true",
+        help="Ignore Dockerfile even if present; run pytest on host",
+    )
+    local_test_parser.add_argument(
+        "--yes",
+        "-y",
+        action="store_true",
+        help="Non-interactive: if multiple tests exist and no --entry, fails with guidance",
+    )
+
     # Run command (for Hydra-based evaluations)
     # This subparser intentionally defines no arguments itself.
     # All arguments after 'run' will be passed to Hydra by parse_known_args.
@@ -559,6 +580,10 @@ def main():
             return create_rft_command(args)
         print("Error: missing subcommand for 'create'. Try: eval-protocol create rft")
         return 1
+    elif args.command == "local-test":
+        from .cli_commands.local_test import local_test_command
+
+        return local_test_command(args)
     elif args.command == "run":
         # For the 'run' command, Hydra takes over argument parsing.
 

eval_protocol-0.2.84.dev2/eval_protocol/cli_commands/local_test.py

@@ -0,0 +1,140 @@
+import argparse
+import os
+import subprocess
+import sys
+from typing import List
+
+from .upload import _discover_tests, _prompt_select
+
+
+def _find_dockerfiles(root: str) -> List[str]:
+    skip_dirs = {".venv", "venv", "node_modules", "dist", "build", "__pycache__", ".git", "vendor"}
+    dockerfiles: List[str] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in skip_dirs and not d.startswith(".")]
+        for name in filenames:
+            if name == "Dockerfile":
+                dockerfiles.append(os.path.join(dirpath, name))
+    return dockerfiles
+
+
+def _run_pytest_host(pytest_target: str) -> int:
+    print(f"Running locally: pytest {pytest_target} -vs")
+    proc = subprocess.run([sys.executable, "-m", "pytest", pytest_target, "-vs"])
+    return proc.returncode
+
+
+def _build_docker_image(dockerfile_path: str, image_tag: str) -> bool:
+    context_dir = os.path.dirname(dockerfile_path)
+    print(f"Building Docker image '{image_tag}' from {dockerfile_path} ...")
+    try:
+        proc = subprocess.run(
+            ["docker", "build", "-t", image_tag, "-f", dockerfile_path, context_dir],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+        print(proc.stdout)
+        return proc.returncode == 0
+    except FileNotFoundError:
+        print("Error: docker not found in PATH. Install Docker or use --ignore-docker.")
+        return False
+
+
+def _run_pytest_in_docker(project_root: str, image_tag: str, pytest_target: str) -> int:
+    workdir = "/workspace"
+    # Mount read-only is safer; but tests may write artifacts. Use read-write.
+    cmd = [
+        "docker",
+        "run",
+        "--rm",
+        "-v",
+        f"{project_root}:{workdir}",
+        "-w",
+        workdir,
+        image_tag,
+        "pytest",
+        pytest_target,
+        "-vs",
+    ]
+    print("Running in Docker:", " ".join(cmd))
+    try:
+        proc = subprocess.run(cmd)
+        return proc.returncode
+    except FileNotFoundError:
+        print("Error: docker not found in PATH. Install Docker or use --ignore-docker.")
+        return 1
+
+
+def local_test_command(args: argparse.Namespace) -> int:
+    project_root = os.getcwd()
+
+    # Selection and pytest target resolution
+    pytest_target: str = ""
+    entry = getattr(args, "entry", None)
+    if entry:
+        if "::" in entry:
+            file_part = entry.split("::", 1)[0]
+            file_path = (
+                file_part if os.path.isabs(file_part) else os.path.abspath(os.path.join(project_root, file_part))
+            )
+            pytest_target = entry
+        else:
+            file_path = entry if os.path.isabs(entry) else os.path.abspath(os.path.join(project_root, entry))
+            # Use path relative to project_root when possible
+            try:
+                rel = os.path.relpath(file_path, project_root)
+            except Exception:
+                rel = file_path
+            pytest_target = rel
+    else:
+        tests = _discover_tests(project_root)
+        if not tests:
+            print("No evaluation tests found.\nHint: Ensure @evaluation_test is applied.")
+            return 1
+        non_interactive = bool(getattr(args, "yes", False))
+        selected = _prompt_select(tests, non_interactive=non_interactive)
+        if not selected:
+            print("No tests selected.")
+            return 1
+        if len(selected) != 1:
+            print("Error: Please select exactly one evaluation test for 'local-test'.")
+            return 1
+        chosen = selected[0]
+        abs_path = os.path.abspath(chosen.file_path)
+        try:
+            rel = os.path.relpath(abs_path, project_root)
+        except Exception:
+            rel = abs_path
+        pytest_target = rel
+
+    ignore_docker = bool(getattr(args, "ignore_docker", False))
+    if ignore_docker:
+        if not pytest_target:
+            print("Error: Failed to resolve a pytest target to run.")
+            return 1
+        return _run_pytest_host(pytest_target)
+
+    dockerfiles = _find_dockerfiles(project_root)
+    if len(dockerfiles) > 1:
+        print("Error: Multiple Dockerfiles found. Only one Dockerfile is allowed for local-test.")
+        for df in dockerfiles:
+            print(f" - {df}")
+        print("Hint: use --ignore-docker to bypass Docker.")
+        return 1
+    if len(dockerfiles) == 1:
+        image_tag = "ep-evaluator:local"
+        ok = _build_docker_image(dockerfiles[0], image_tag)
+        if not ok:
+            print("Docker build failed. See logs above.")
+            return 1
+        if not pytest_target:
+            print("Error: Failed to resolve a pytest target to run.")
+            return 1
+        return _run_pytest_in_docker(project_root, image_tag, pytest_target)
+
+    # No Dockerfile: run on host
+    if not pytest_target:
+        print("Error: Failed to resolve a pytest target to run.")
+        return 1
+    return _run_pytest_host(pytest_target)

{eval_protocol-0.2.84 → eval_protocol-0.2.84.dev2}/eval_protocol/cli_commands/upload.py

@@ -552,6 +552,23 @@ def _load_secrets_from_env_file(env_file_path: str) -> Dict[str, str]:
     return secrets
 
 
+def _mask_secret_value(value: str) -> str:
+    """
+    Return a masked representation of a secret showing only a small prefix/suffix.
+    Example: fw_3Z*******Xgnk
+    """
+    try:
+        if not isinstance(value, str) or not value:
+            return "<empty>"
+        prefix_len = 6
+        suffix_len = 4
+        if len(value) <= prefix_len + suffix_len:
+            return value[0] + "***" + value[-1]
+        return f"{value[:prefix_len]}***{value[-suffix_len:]}"
+    except Exception:
+        return "<masked>"
+
+
 def upload_command(args: argparse.Namespace) -> int:
     root = os.path.abspath(getattr(args, "path", "."))
     entries_arg = getattr(args, "entry", None)
@@ -602,9 +619,9 @@ def upload_command(args: argparse.Namespace) -> int:
         secrets_from_file = _load_secrets_from_env_file(env_file_path)
         secrets_from_env_file = secrets_from_file.copy()  # Track what came from .env file
 
-        # Also ensure FIREWORKS_API_KEY from environment is included
+        # Also consider FIREWORKS_API_KEY from environment, but prefer .env value
         fw_api_key_value = get_fireworks_api_key()
-        if fw_api_key_value:
+        if fw_api_key_value and "FIREWORKS_API_KEY" not in secrets_from_file:
             secrets_from_file["FIREWORKS_API_KEY"] = fw_api_key_value
 
         if not fw_account_id and fw_api_key_value:
@@ -622,7 +639,11 @@ def upload_command(args: argparse.Namespace) -> int:
                 print(f"Loading secrets from: {env_file_path}")
 
             for secret_name, secret_value in secrets_from_file.items():
-                print(f"Ensuring {secret_name} is registered as a secret on Fireworks for rollout...")
+                source = ".env" if secret_name in secrets_from_env_file else "environment"
+                print(
+                    f"Ensuring {secret_name} is registered as a secret on Fireworks for rollout... "
+                    f"({source}: {_mask_secret_value(secret_value)})"
+                )
                 if create_or_update_fireworks_secret(
                     account_id=fw_account_id,
                     key_name=secret_name,

{eval_protocol-0.2.84 → eval_protocol-0.2.84.dev2}/eval_protocol/evaluation.py

@@ -595,7 +595,9 @@ class Evaluator:
             logger.error("Missing requirements.txt in upload directory: %s", source_dir)
             raise ValueError(
                 "Upload requires requirements.txt in the project root. "
-                "Please add requirements.txt and re-run ep upload."
+                "Create a requirements.txt (it can be empty) and rerun 'eval-protocol upload' "
+                "or 'eval-protocol create rft'. If you're running in a notebook (e.g., Colab), "
+                f"create the file in your working directory (e.g., {source_dir}/requirements.txt)."
             )
 
     @staticmethod

{eval_protocol-0.2.84 → eval_protocol-0.2.84.dev2}/eval_protocol/fireworks_rft.py

@@ -5,6 +5,7 @@ import os
 import sys
 import tempfile
 import time
+import uuid
 from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, Optional, Tuple
 
@@ -205,7 +206,8 @@ def build_default_dataset_id(evaluator_id: str) -> str:
 
 def build_default_output_model(evaluator_id: str) -> str:
     base = evaluator_id.lower().replace("_", "-")
-    return f"{base}-rft"
+    uuid_suffix = str(uuid.uuid4())[:4]
+    return f"{base}-rft-{uuid_suffix}"
 
 
 __all__ = [

{eval_protocol-0.2.84 → eval_protocol-0.2.84.dev2}/eval_protocol/pytest/handle_persist_flow.py

@@ -11,6 +11,12 @@ from eval_protocol.common_utils import get_user_agent
 from eval_protocol.directory_utils import find_eval_protocol_dir
 from eval_protocol.models import EvaluationRow
 from eval_protocol.pytest.store_experiment_link import store_experiment_link
+from eval_protocol.auth import (
+    get_fireworks_api_key,
+    get_fireworks_account_id,
+    verify_api_key_and_get_account_id,
+    get_fireworks_api_base,
+)
 
 import requests
 
@@ -90,22 +96,16 @@ def handle_persist_flow(all_results: list[list[EvaluationRow]], test_func_name:
                     if not should_upload:
                         continue
 
-                    def get_auth_value(key: str) -> str | None:
-                        """Get auth value from config file or environment."""
+                    # Resolve credentials using centralized auth helpers with verification fallback
+                    fireworks_api_key = get_fireworks_api_key()
+                    fireworks_account_id = get_fireworks_account_id()
+                    if not fireworks_account_id and fireworks_api_key:
                         try:
-                            config_path = Path.home() / ".fireworks" / "auth.ini"
-                            if config_path.exists():
-                                config = configparser.ConfigParser()  # noqa: F821
-                                config.read(config_path)
-                                for section in ["DEFAULT", "auth"]:
-                                    if config.has_section(section) and config.has_option(section, key):
-                                        return config.get(section, key)
+                            fireworks_account_id = verify_api_key_and_get_account_id(
+                                api_key=fireworks_api_key, api_base=get_fireworks_api_base()
+                            )
                         except Exception:
-                            pass
-                        return os.getenv(key)
-
-                    fireworks_api_key = get_auth_value("FIREWORKS_API_KEY")
-                    fireworks_account_id = get_auth_value("FIREWORKS_ACCOUNT_ID")
+                            fireworks_account_id = None
 
                     if not fireworks_api_key and not fireworks_account_id:
                         store_experiment_link(
@@ -129,7 +129,7 @@ def handle_persist_flow(all_results: list[list[EvaluationRow]], test_func_name:
                         )
                         continue
 
-                    api_base = "https://api.fireworks.ai"
+                    api_base = get_fireworks_api_base()
                     headers = {
                         "Authorization": f"Bearer {fireworks_api_key}",
                         "Content-Type": "application/json",

{eval_protocol-0.2.84 → eval_protocol-0.2.84.dev2/eval_protocol.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eval-protocol
-Version: 0.2.84
+Version: 0.2.84.dev2
 Summary: The official Python SDK for Eval Protocol (EP.) EP is an open protocol that standardizes how developers author evals for large language model (LLM) applications.
 Author-email: Fireworks AI <info@fireworks.ai>
 License-Expression: MIT

{eval_protocol-0.2.84 → eval_protocol-0.2.84.dev2}/eval_protocol.egg-info/SOURCES.txt

@@ -91,6 +91,7 @@ eval_protocol/cli_commands/common.py
 eval_protocol/cli_commands/create_rft.py
 eval_protocol/cli_commands/deploy.py
 eval_protocol/cli_commands/deploy_mcp.py
+eval_protocol/cli_commands/local_test.py
 eval_protocol/cli_commands/logs.py
 eval_protocol/cli_commands/preview.py
 eval_protocol/cli_commands/run_eval_cmd.py
@@ -277,6 +278,7 @@ tests/test_cli.py
 tests/test_cli_agent.py
 tests/test_cli_args.py
 tests/test_cli_create_rft_infer.py
+tests/test_cli_local_test.py
 tests/test_code_execution.py
 tests/test_config.py
 tests/test_control_plane_separation.py

{eval_protocol-0.2.84 → eval_protocol-0.2.84.dev2}/tests/test_auth.py

@@ -255,7 +255,8 @@ def test_get_account_id_not_found(mock_path_exists):
     with patch("eval_protocol.auth._parse_simple_auth_file", return_value={}) as mock_parse_simple:
         assert get_fireworks_account_id() is None
         mock_parse_simple.assert_not_called()
-    mock_path_exists.assert_called_once_with()
+    # With verify fallback using get_fireworks_api_key, exists() may be checked more than once
+    assert mock_path_exists.call_count >= 1
 
 
 @patch("pathlib.Path.exists", return_value=True)
@@ -269,7 +270,8 @@ def test_get_account_id_ini_exists_no_section(mock_parse_simple, mock_ConfigPars
         mock_open(read_data="other_key = some_val_but_no_section_header\nanother=val"),
     ):
         assert get_fireworks_account_id() is None
-    mock_parse_simple.assert_called_once_with(AUTH_INI_FILE)
+    # Fallback verify path may trigger a second simple parse for api_key; ensure at least one call
+    assert mock_parse_simple.call_count >= 1
 
 
 @patch("pathlib.Path.exists", return_value=True)
@@ -283,7 +285,8 @@ def test_get_account_id_ini_exists_no_id_option(mock_parse_simple, mock_ConfigPa
 
     with patch("builtins.open", mock_open(read_data="[fireworks]\nsome_other_key=foo")):
         assert get_fireworks_account_id() is None
-    mock_parse_simple.assert_called_once_with(AUTH_INI_FILE)
+    # Fallback verify path may trigger a second simple parse for api_key; ensure at least one call
+    assert mock_parse_simple.call_count >= 1
 
 
 @patch("pathlib.Path.exists", return_value=True)
@@ -301,7 +304,8 @@ def test_get_account_id_ini_empty_value(mock_parse_simple, mock_ConfigParser_cla
     )
     with patch("builtins.open", mock_open(read_data="[fireworks]\naccount_id=")):
         assert get_fireworks_account_id() is None
-    mock_parse_simple.assert_called_once_with(AUTH_INI_FILE)
+    # Fallback verify path may trigger a second simple parse for api_key; ensure at least one call
+    assert mock_parse_simple.call_count >= 1
 
 
 @patch("pathlib.Path.exists", return_value=True)
@@ -372,7 +376,8 @@ def test_get_account_id_ini_parse_error(mock_parse_simple, mock_ConfigParser_cla
         assert get_fireworks_account_id() is None
     assert "Configparser error reading" in caplog.text
     assert "Mocked Parsing Error" in caplog.text
-    mock_parse_simple.assert_called_once_with(AUTH_INI_FILE)
+    # Fallback verify path may trigger a second simple parse for api_key; ensure at least one call
+    assert mock_parse_simple.call_count >= 1
 
 
 @patch("pathlib.Path.exists", return_value=True)

eval_protocol-0.2.84.dev2/tests/test_cli_local_test.py

@@ -0,0 +1,145 @@
+import os
+from types import SimpleNamespace
+
+import pytest
+
+
+def test_local_test_runs_host_pytest_with_entry(tmp_path, monkeypatch):
+    project = tmp_path / "proj"
+    project.mkdir()
+    monkeypatch.chdir(project)
+
+    # Create a dummy test file
+    test_file = project / "metric" / "test_one.py"
+    test_file.parent.mkdir(parents=True, exist_ok=True)
+    test_file.write_text("def test_dummy():\n    assert True\n", encoding="utf-8")
+
+    # Import module under test
+    from eval_protocol.cli_commands import local_test as lt
+
+    # Avoid Docker path
+    monkeypatch.setattr(lt, "_find_dockerfiles", lambda root: [])
+
+    captured = {"target": ""}
+
+    def _fake_host(target: str) -> int:
+        captured["target"] = target
+        return 0
+
+    monkeypatch.setattr(lt, "_run_pytest_host", _fake_host)
+
+    args = SimpleNamespace(entry=str(test_file), ignore_docker=False, yes=True)
+    rc = lt.local_test_command(args)  # pyright: ignore[reportArgumentType]
+    assert rc == 0
+    # Expect relative path target
+    assert captured["target"] == os.path.relpath(str(test_file), str(project))
+
+
+def test_local_test_ignores_docker_when_flag_set(tmp_path, monkeypatch):
+    project = tmp_path / "proj"
+    project.mkdir()
+    monkeypatch.chdir(project)
+
+    test_file = project / "metric" / "test_two.py"
+    test_file.parent.mkdir(parents=True, exist_ok=True)
+    test_file.write_text("def test_dummy():\n    assert True\n", encoding="utf-8")
+
+    from eval_protocol.cli_commands import local_test as lt
+
+    # Pretend we have Dockerfile(s), but ignore_docker=True should skip
+    monkeypatch.setattr(lt, "_find_dockerfiles", lambda root: [str(project / "Dockerfile")])
+
+    called = {"host": False}
+
+    def _fake_host(target: str) -> int:
+        called["host"] = True
+        return 0
+
+    monkeypatch.setattr(lt, "_run_pytest_host", _fake_host)
+
+    args = SimpleNamespace(entry=str(test_file), ignore_docker=True, yes=True)
+    rc = lt.local_test_command(args)  # pyright: ignore[reportArgumentType]
+    assert rc == 0
+    assert called["host"] is True
+
+
+def test_local_test_errors_on_multiple_dockerfiles(tmp_path, monkeypatch):
+    project = tmp_path / "proj"
+    project.mkdir()
+    monkeypatch.chdir(project)
+
+    test_file = project / "metric" / "test_three.py"
+    test_file.parent.mkdir(parents=True, exist_ok=True)
+    test_file.write_text("def test_dummy():\n    assert True\n", encoding="utf-8")
+
+    from eval_protocol.cli_commands import local_test as lt
+
+    monkeypatch.setattr(
+        lt, "_find_dockerfiles", lambda root: [str(project / "Dockerfile"), str(project / "another" / "Dockerfile")]
+    )
+
+    args = SimpleNamespace(entry=str(test_file), ignore_docker=False, yes=True)
+    rc = lt.local_test_command(args)  # pyright: ignore[reportArgumentType]
+    assert rc == 1
+
+
+def test_local_test_builds_and_runs_in_docker(tmp_path, monkeypatch):
+    project = tmp_path / "proj"
+    project.mkdir()
+    monkeypatch.chdir(project)
+
+    test_file = project / "metric" / "test_four.py"
+    test_file.parent.mkdir(parents=True, exist_ok=True)
+    test_file.write_text("def test_dummy():\n    assert True\n", encoding="utf-8")
+
+    from eval_protocol.cli_commands import local_test as lt
+
+    monkeypatch.setattr(lt, "_find_dockerfiles", lambda root: [str(project / "Dockerfile")])
+    monkeypatch.setattr(lt, "_build_docker_image", lambda dockerfile, tag: True)
+
+    captured = {"target": "", "image": ""}
+
+    def _fake_run_docker(root: str, image_tag: str, pytest_target: str) -> int:
+        captured["target"] = pytest_target
+        captured["image"] = image_tag
+        return 0
+
+    monkeypatch.setattr(lt, "_run_pytest_in_docker", _fake_run_docker)
+
+    args = SimpleNamespace(entry=str(test_file), ignore_docker=False, yes=True)
+    rc = lt.local_test_command(args)  # pyright: ignore[reportArgumentType]
+    assert rc == 0
+    assert captured["image"] == "ep-evaluator:local"
+    assert captured["target"] == os.path.relpath(str(test_file), str(project))
+
+
+def test_local_test_selector_single_test(tmp_path, monkeypatch):
+    project = tmp_path / "proj"
+    project.mkdir()
+    monkeypatch.chdir(project)
+
+    test_file = project / "metric" / "test_sel.py"
+    test_file.parent.mkdir(parents=True, exist_ok=True)
+    test_file.write_text("def test_dummy():\n    assert True\n", encoding="utf-8")
+
+    from eval_protocol.cli_commands import local_test as lt
+    from eval_protocol.cli_commands import upload as up
+
+    # No entry; force discover + selector
+    disc = SimpleNamespace(qualname="metric.test_sel", file_path=str(test_file))
+    monkeypatch.setattr(lt, "_discover_tests", lambda root: [disc])
+    monkeypatch.setattr(up, "_prompt_select", lambda tests, non_interactive=False: tests[:1])
+    monkeypatch.setattr(lt, "_find_dockerfiles", lambda root: [])
+
+    called = {"host": False}
+
+    def _fake_host(target: str) -> int:
+        called["host"] = True
+        return 0
+
+    monkeypatch.setattr(lt, "_run_pytest_host", _fake_host)
+
+    args = SimpleNamespace(entry=None, ignore_docker=False, yes=True)
+    rc = lt.local_test_command(args)  # pyright: ignore[reportArgumentType]
+    assert rc == 0
+    assert called["host"] is True