dh-cli 0.11.2__tar.gz → 0.12.0__tar.gz

{dh_cli-0.11.2 → dh_cli-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dh-cli
-Version: 0.11.2
+Version: 0.12.0
 Summary: Dayhoff Labs developer CLI
 Author-email: Dayhoff Labs <dev@dayhofflabs.com>
 License: # PolyForm Noncommercial License 1.0.0

{dh_cli-0.11.2 → dh_cli-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dh-cli"
-version = "0.11.2"
+version = "0.12.0"
 description = "Dayhoff Labs developer CLI"
 requires-python = ">=3.11"
 readme = "README.md"

{dh_cli-0.11.2 → dh_cli-0.12.0}/src/dh_cli/batch/__init__.py

@@ -28,7 +28,6 @@ from .commands.retry import retry
 from .commands.rfd3 import rfd3
 from .commands.status import status
 from .commands.submit import submit
-from .commands.train import train
 from .commands.wait_for import wait_for
 
 
@@ -62,10 +61,6 @@ def batch_cli():
       protmpnn          Design sequences with ProtMPNN/LigandMPNN
       protmpnn-to-boltz Convert top variants to Boltz validation YAMLs
 
-    \b
-    ML Training:
-      train      Submit hatchery ML training jobs
-
     \b
     Examples:
       # Submit an embedding job
@@ -111,6 +106,5 @@ batch_cli.add_command(orca)
 batch_cli.add_command(protmpnn_to_boltz, name="protmpnn-to-boltz")
 batch_cli.add_command(rfd3)
 batch_cli.add_command(disco)
-batch_cli.add_command(train)
 
 __all__ = ["batch_cli"]

{dh_cli-0.11.2 → dh_cli-0.12.0}/src/dh_cli/batch/commands/submit.py

@@ -1,5 +1,7 @@
 """Submit command for generic batch jobs."""
 
+import os
+
 import click
 import yaml
 from click.core import ParameterSource
@@ -122,13 +124,20 @@ def submit(
             param_hint="--image",
         )
 
-    # Parse environment variables
+    # Parse environment variables. The submitter's MLFLOW_TRACKING_URI is
+    # forwarded so runtime-clone jobs reach the tracking server without an
+    # endpoint constant in any config; an explicit `env:` entry overrides it.
+    # Resolved before the plan is rendered so the summary matches what is sent.
     job_env = dict(config.get("env", {}))
     for e in env:
         if "=" in e:
             key, value = e.split("=", 1)
             job_env[key] = value
 
+    mlflow_tracking_uri = os.environ.get("MLFLOW_TRACKING_URI", "")
+    if mlflow_tracking_uri:
+        job_env.setdefault("MLFLOW_TRACKING_URI", mlflow_tracking_uri)
+
     # Generate job ID
     job_id = generate_job_id("batch")
 
@@ -149,6 +158,8 @@ def submit(
         click.echo(f"Image:       {job_image}")
     if job_env:
         click.echo(f"Environment: {len(job_env)} variables")
+        if job_env.get("MLFLOW_TRACKING_URI"):
+            click.echo(f"             MLFLOW_TRACKING_URI={job_env['MLFLOW_TRACKING_URI']}")
 
     if dry_run:
         click.echo()
@@ -182,7 +193,6 @@ def submit(
 
         client = BatchClient()
 
-        # Prepare environment
         submit_env = {
             "JOB_DIR": str(job_dir),
             "JOB_ID": job_id,

dh_cli-0.12.0/tests/batch/test_no_train_command.py

@@ -0,0 +1,34 @@
+"""Pins the removal of `dh batch train` (plan D-24).
+
+The command was orphaned by the 2026-06-22 runtime-clone conversion: the dojo
+launches training through `dh batch submit` with a wrapper YAML, and
+`dh batch train` submitted the `dayhoff-train` job definition with no `command`,
+so the container ran the image's default `CMD ["python","main.py","--help"]` and
+exited 0 — green submit, green job, no training. These tests keep a future merge
+from silently resurrecting it.
+"""
+
+import re
+
+import pytest
+from click.testing import CliRunner
+
+
+def test_train_not_registered():
+    """`train` is neither a registered subcommand nor offered in the help."""
+    from dh_cli.batch import batch_cli
+
+    assert "train" not in batch_cli.commands
+
+    result = CliRunner().invoke(batch_cli, ["--help"])
+    assert result.exit_code == 0, result.output
+    # Match `train` only as a standalone word, not inside a hyphenated identifier:
+    # `\btrain\b` treats `-` as a boundary, so it would false-positive on a
+    # legitimate future mention of e.g. the `dayhoff-train` job definition.
+    assert re.search(r"(?<![-\w])train(?![-\w])", result.output) is None, result.output
+
+
+def test_train_module_absent():
+    """The module is gone, not merely unregistered."""
+    with pytest.raises(ModuleNotFoundError):
+        import dh_cli.batch.commands.train  # noqa: F401

dh_cli-0.12.0/tests/batch/test_submit_mlflow_env.py

@@ -0,0 +1,196 @@
+"""Tests for MLFLOW_TRACKING_URI passthrough in `dh batch submit`.
+
+Pins the seam that Part 3 (D-23) owns on the command the dojo actually uses.
+`dh batch submit` forwards the submitter's own ``MLFLOW_TRACKING_URI`` into the
+AWS Batch job environment (mirroring the ``WANDB_API_KEY`` passthrough pattern),
+so a runtime-clone dojo job launched from a ``batch-submit-*.yaml`` wrapper
+reaches the tracking server with no endpoint constant in any config.
+
+Task 01 implemented the same passthrough in `dh batch train`, which the dojo
+never calls — see plan D-23.
+
+When the submitter's environment does not set ``MLFLOW_TRACKING_URI`` (or sets
+it empty), nothing is injected and the dojo config ``tracking_uri`` fallback
+applies inside the job. An explicit ``env:`` entry in the wrapper YAML is an
+operator override and must win over the passthrough.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+import yaml
+from click.testing import CliRunner
+
+WRAPPER_ENV = {
+    "GH_TOKEN": "ghp_fake_for_test",
+    "DOJO_GIT_REF": "mlflow3",
+}
+
+
+@pytest.fixture
+def cli_runner():
+    return CliRunner()
+
+
+def _invoke(cli_runner, tmp_path, env, config=None):
+    """Invoke `dh batch submit` with BatchClient and the submitter env mocked."""
+    base = tmp_path / "jobs"
+    if config is None:
+        args = ["--command", "echo hi"]
+    else:
+        config_path = tmp_path / "job.yaml"
+        config_path.write_text(yaml.dump(config))
+        args = ["-f", str(config_path)]
+
+    with (
+        patch("dh_cli.batch.commands.submit.get_aws_username", return_value="jason"),
+        patch("dh_cli.batch.commands.submit.BatchClient") as mock_batch_cls,
+        patch(
+            "dh_cli.batch.commands.submit.generate_job_id",
+            return_value="jason-batch-20260725-mlf00001",
+        ),
+        patch.dict("dh_cli.batch.commands.submit.os.environ", env, clear=True),
+    ):
+        mock_client = MagicMock()
+        mock_client.submit_job.return_value = "aws-uuid-mlflow"
+        mock_batch_cls.return_value = mock_client
+
+        from dh_cli.batch.commands.submit import submit
+
+        result = cli_runner.invoke(submit, args + ["--base-path", str(base)])
+        return result, mock_client
+
+
+def _submitted_env(mock_client):
+    return mock_client.submit_job.call_args[1]["environment"]
+
+
+class TestTrackingUriPassthrough:
+    def test_env_var_forwarded_when_set(self, cli_runner, tmp_path):
+        """When the submitter has MLFLOW_TRACKING_URI set, the job inherits it."""
+        uri = "http://internal-mlflow-dev-1099724111.us-east-1.elb.amazonaws.com:5000"
+        result, mock_client = _invoke(cli_runner, tmp_path, {"MLFLOW_TRACKING_URI": uri})
+        assert result.exit_code == 0, result.output
+        assert _submitted_env(mock_client).get("MLFLOW_TRACKING_URI") == uri
+
+    def test_forwards_arbitrary_value(self, cli_runner, tmp_path):
+        """The value is passed through verbatim, not matched against a literal."""
+        uri = "http://some-other-endpoint.internal:5000"
+        result, mock_client = _invoke(cli_runner, tmp_path, {"MLFLOW_TRACKING_URI": uri})
+        assert result.exit_code == 0, result.output
+        assert _submitted_env(mock_client).get("MLFLOW_TRACKING_URI") == uri
+
+    def test_absent_when_submitter_unset(self, cli_runner, tmp_path):
+        """With no MLFLOW_TRACKING_URI in the submitter env, none is injected."""
+        result, mock_client = _invoke(cli_runner, tmp_path, {})
+        assert result.exit_code == 0, result.output
+        assert "MLFLOW_TRACKING_URI" not in _submitted_env(mock_client)
+
+    def test_empty_value_not_injected(self, cli_runner, tmp_path):
+        """An empty MLFLOW_TRACKING_URI is treated as unset (no blank injection)."""
+        result, mock_client = _invoke(cli_runner, tmp_path, {"MLFLOW_TRACKING_URI": ""})
+        assert result.exit_code == 0, result.output
+        assert "MLFLOW_TRACKING_URI" not in _submitted_env(mock_client)
+
+    def test_wrapper_env_wins_over_passthrough(self, cli_runner, tmp_path):
+        """An explicit wrapper `env:` entry is an operator override and survives."""
+        wrapper_uri = "http://operator-chosen-endpoint.internal:5000"
+        result, mock_client = _invoke(
+            cli_runner,
+            tmp_path,
+            {"MLFLOW_TRACKING_URI": "http://submitter-shell-endpoint.internal:5000"},
+            config={
+                "command": "echo hi",
+                "env": {**WRAPPER_ENV, "MLFLOW_TRACKING_URI": wrapper_uri},
+            },
+        )
+        assert result.exit_code == 0, result.output
+        assert _submitted_env(mock_client)["MLFLOW_TRACKING_URI"] == wrapper_uri
+
+    def test_passthrough_does_not_disturb_other_env(self, cli_runner, tmp_path):
+        """Injection is additive: JOB_DIR/JOB_ID and wrapper env are untouched."""
+        uri = "http://internal-mlflow-dev-1099724111.us-east-1.elb.amazonaws.com:5000"
+        result, mock_client = _invoke(
+            cli_runner,
+            tmp_path,
+            {"MLFLOW_TRACKING_URI": uri},
+            config={"command": "echo hi", "env": dict(WRAPPER_ENV)},
+        )
+        assert result.exit_code == 0, result.output
+        env = _submitted_env(mock_client)
+        assert env["MLFLOW_TRACKING_URI"] == uri
+        assert env["JOB_ID"] == "jason-batch-20260725-mlf00001"
+        assert env["JOB_DIR"] == str(tmp_path / "jobs" / "jason-batch-20260725-mlf00001")
+        for key, value in WRAPPER_ENV.items():
+            assert env[key] == value
+
+
+class TestSubmitSummaryReportsInjection:
+    """The printed plan must not contradict what is actually submitted.
+
+    The release gate saw ``Environment: 2 variables`` on a job whose AWS
+    environment held three, because the summary counted only the wrapper's
+    ``env:`` before the passthrough was merged in. Harmless to the job, but it
+    reads as if the injection did not happen — the exact signal an operator
+    checks the line for.
+    """
+
+    def test_summary_counts_the_injected_variable(self, cli_runner, tmp_path):
+        uri = "http://internal-mlflow-dev-1099724111.us-east-1.elb.amazonaws.com:5000"
+        result, mock_client = _invoke(
+            cli_runner,
+            tmp_path,
+            {"MLFLOW_TRACKING_URI": uri},
+            config={"command": "echo hi", "env": dict(WRAPPER_ENV)},
+        )
+        assert result.exit_code == 0, result.output
+
+        submitted = _submitted_env(mock_client)
+        operator_visible = {k: v for k, v in submitted.items() if k not in ("JOB_DIR", "JOB_ID")}
+        assert len(operator_visible) == 3, operator_visible
+        assert f"Environment: {len(operator_visible)} variables" in result.output
+
+    def test_summary_names_the_tracking_uri(self, cli_runner, tmp_path):
+        """The URI is echoed so the operator can confirm the endpoint, not just the count."""
+        uri = "http://internal-mlflow-dev-1099724111.us-east-1.elb.amazonaws.com:5000"
+        result, _mock_client = _invoke(cli_runner, tmp_path, {"MLFLOW_TRACKING_URI": uri})
+        assert result.exit_code == 0, result.output
+        assert f"MLFLOW_TRACKING_URI={uri}" in result.output
+
+    def test_summary_unchanged_when_no_uri_to_inject(self, cli_runner, tmp_path):
+        """With nothing to forward, the count is just the wrapper's own env."""
+        result, _mock_client = _invoke(
+            cli_runner, tmp_path, {}, config={"command": "echo hi", "env": dict(WRAPPER_ENV)}
+        )
+        assert result.exit_code == 0, result.output
+        assert "Environment: 2 variables" in result.output
+        assert "MLFLOW_TRACKING_URI" not in result.output
+
+    def test_dry_run_reports_the_injection(self, cli_runner, tmp_path):
+        """``--dry-run`` returns before submission, so its summary is the only
+        evidence the operator gets; it must still show the passthrough."""
+        uri = "http://internal-mlflow-dev-1099724111.us-east-1.elb.amazonaws.com:5000"
+        base = tmp_path / "jobs"
+        config_path = tmp_path / "job.yaml"
+        config_path.write_text(yaml.dump({"command": "echo hi", "env": dict(WRAPPER_ENV)}))
+
+        with (
+            patch("dh_cli.batch.commands.submit.get_aws_username", return_value="jason"),
+            patch("dh_cli.batch.commands.submit.BatchClient"),
+            patch(
+                "dh_cli.batch.commands.submit.generate_job_id",
+                return_value="jason-batch-20260725-mlf00001",
+            ),
+            patch.dict(
+                "dh_cli.batch.commands.submit.os.environ",
+                {"MLFLOW_TRACKING_URI": uri},
+                clear=True,
+            ),
+        ):
+            from dh_cli.batch.commands.submit import submit
+
+            result = cli_runner.invoke(submit, ["-f", str(config_path), "--base-path", str(base), "--dry-run"])
+
+        assert result.exit_code == 0, result.output
+        assert "Environment: 3 variables" in result.output
+        assert f"MLFLOW_TRACKING_URI={uri}" in result.output

{dh_cli-0.11.2 → dh_cli-0.12.0}/tests/test_disco_jobdef.py

@@ -28,18 +28,29 @@ SPIKE_VCPU = "8"
 SPIKE_MEMORY = "30000"
 
 
-def _find_dma_root() -> Path:
+def _find_dma_root() -> Path | None:
     """Walk up from this test file to the workspace root that holds both the
-    `dayhoff-tools` and `blueprints` sibling repos."""
+    `dayhoff-tools` and `blueprints` sibling repos.
+
+    Returns ``None`` when the sibling `blueprints` repo is not checked out
+    alongside `dayhoff-tools` (e.g. standalone CI of this repo), so the module
+    can skip rather than crash at collection time.
+    """
     for parent in Path(__file__).resolve().parents:
         if (parent / "blueprints").is_dir() and (parent / "dayhoff-tools").is_dir():
             return parent
-    raise RuntimeError("could not locate the dma workspace root")
+    return None
 
 
 DMA_ROOT = _find_dma_root()
-TF_DIR = DMA_ROOT / "blueprints" / "terraform" / "environments" / "dev"
-TF_FILE = TF_DIR / "batch_job_definitions.tf"
+
+pytestmark = pytest.mark.skipif(
+    DMA_ROOT is None,
+    reason="blueprints sibling repo not checked out; cross-repo job-def test needs the dma monorepo layout",
+)
+
+TF_DIR = DMA_ROOT / "blueprints" / "terraform" / "environments" / "dev" if DMA_ROOT else None
+TF_FILE = TF_DIR / "batch_job_definitions.tf" if TF_DIR else None
 
 
 def _extract_block(text: str, header: str) -> str: