hyperun 0.2.2__tar.gz → 0.2.4__tar.gz

{hyperun-0.2.2 → hyperun-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperun
-Version: 0.2.2
+Version: 0.2.4
 Summary: Submit a GPU job and get results back. No kubectl, no cloud account.
 Author: DDPS Lab
 License-Expression: Apache-2.0

{hyperun-0.2.2 → hyperun-0.2.4}/hyperun/cli.py

@@ -116,9 +116,10 @@ def job_arguments() -> argparse.ArgumentParser:
         "--vendor", action="append", metavar="NAME",
         help="who the machine may be bought from. Repeat it to allow several; "
         "omit it entirely for no restriction, which is what every job did before "
-        "this flag existed. aws and runpod can actually run a job; gcp, azure, "
-        "lambda and nebius can only be PRICED, so name one of those only with "
-        "--placement-mode compare.",
+        "this flag existed. aws, runpod and shadeform can actually run a job, "
+        "and `hyperun estimate` prices all three and names the cheapest; gcp, "
+        "azure, lambda and nebius can only be PRICED, so name one of those only "
+        "with --placement-mode compare.",
     )
     # DDPSRUN-REGIONS. Missing until 2026-09-08, so every job this CLI submitted
     # ran in the operator's one default region and there was no way to say
@@ -279,6 +280,34 @@ def build_parser() -> argparse.ArgumentParser:
         "the job's result path are NOT deleted.",
     )
     cancel.add_argument("job_id", help="the id `submit` printed")
+
+    # HYPERUN-JOB-STOP. `pause` and `resume` are two verbs over one boolean, because that
+    # is how a person thinks about it -- `stop --undo` would be one verb and two readings.
+    pause = sub.add_parser(
+        "pause",
+        help="pause a running job, KEEPING its machine",
+        description="Asks for the job's machine to be paused. Compute billing stops; the "
+        "disk keeps costing, and on RunPod a stopped volume costs MORE than a running one "
+        "($0.20/GB-month against $0.10). Unlike `delete`, the job stays in the list and "
+        "everything it has produced stays on the machine.\n\n"
+        "IT ASKS. The pause happens seconds to a minute later, and on some vendors it "
+        "cannot happen at all: Shadeform has no stop API, a spot instance has no stopped "
+        "state, and a RunPod pod with no volume disk would lose everything it has "
+        "produced -- so the driver refuses rather than destroying the run, and says why "
+        "in the job's log. `hyperun status` shows the phase reaching Stopped when it "
+        "actually did.",
+    )
+    pause.add_argument("job_id", help="the id `submit` printed")
+
+    resume = sub.add_parser(
+        "resume",
+        help="let a paused job run again",
+        description="Asks for a paused job to run again on the machine it kept. If the "
+        "vendor cannot give the machine back -- RunPod says plainly that a restarted pod "
+        "may be allocated zero GPUs -- the job STAYS paused and says so, rather than going "
+        "to buy a different machine, which would be a recovery wearing a resume's name.",
+    )
+    resume.add_argument("job_id", help="the id `submit` printed")
     cancel.add_argument(
         "--yes", "-y", action="store_true",
         help="skip the confirmation. For scripts, which have nobody to answer it.",
@@ -1076,6 +1105,47 @@ def cmd_delete(args: argparse.Namespace) -> int:
     return EXIT_OK
 
 
+def _pause_or_resume(args: argparse.Namespace, stopped: bool) -> int:
+    """One boolean, two verbs. HYPERUN-JOB-STOP.
+
+    ★ IT PRINTS WHAT WAS ASKED AND WHAT HAS HAPPENED, and they are different things. The
+    request lands immediately; the machine pauses seconds to a minute later, because the
+    controller writes an annotation and the kubelet copies it into the driver pod on its
+    own period. On the vendors where a pause cannot happen it never will, and the reason
+    reaches the job's log rather than this reply -- only the driver, which holds the cloud
+    credential, knows which of those it is.
+    """
+    verb = "pause" if stopped else "resume"
+    try:
+        job = client_from_config().set_stopped(args.job_id, stopped)
+    except ServerError as exc:
+        print(str(exc), file=sys.stderr)
+        return EXIT_SERVER
+    phase = job.get("phase", "?")
+    print(f"asked to {verb} {args.job_id}; it is {phase} right now")
+    if stopped:
+        print("  the machine pauses in up to a minute. `hyperun status "
+              f"{args.job_id}` shows Stopped when it actually has, and the job's log says "
+              "so if this vendor cannot pause it.")
+        print("  the disk keeps costing while it is paused, and the orphan sweep stops "
+              "protecting a job left paused for 7 days.")
+    else:
+        print(f"  `hyperun status {args.job_id}` shows it Running again once the machine "
+              "comes back. If the vendor has no GPU to give, it STAYS Stopped and says so "
+              "rather than buying a different machine.")
+    return EXIT_OK
+
+
+def cmd_pause(args: argparse.Namespace) -> int:
+    """Pause a running job, keeping its machine."""
+    return _pause_or_resume(args, True)
+
+
+def cmd_resume(args: argparse.Namespace) -> int:
+    """Let a paused job run again."""
+    return _pause_or_resume(args, False)
+
+
 def bar(percent: float, width: int = 20) -> str:
     """Draw a progress bar.
 
@@ -1382,6 +1452,8 @@ COMMANDS = {
     "delete": cmd_delete,
     # The old spelling, kept as an alias -- see the comment on the parser.
     "cancel": cmd_delete,
+    "pause": cmd_pause,
+    "resume": cmd_resume,
     "logout": cmd_logout,
     "explain": cmd_explain,
     "schema": cmd_schema,

{hyperun-0.2.2 → hyperun-0.2.4}/hyperun/client.py

@@ -132,6 +132,27 @@ class Client:
         """
         self._call("DELETE", f"/v1/jobs/{job_id}")
 
+    def set_stopped(self, job_id: str, stopped: bool) -> dict:
+        """Ask for a job to be PAUSED, keeping its machine -- or to run again.
+
+        ★ IT ASKS. The machine pauses seconds to a minute later, and on some vendors it
+        cannot pause at all. What comes back carries both: `stopped` is the request,
+        `phase` is what has actually happened.
+
+        Args:
+            job_id: an id the server issued.
+            stopped: True to pause, False to resume.
+
+        Returns:
+            The job as it now reads.
+
+        Raises:
+            ServerError: 404 for no such job of yours, 409 for one that has finished,
+                502 when the cluster could not be reached.
+        """
+        suffix = "" if stopped else "?resume=true"
+        return self._call("POST", f"/v1/jobs/{job_id}/stop{suffix}") or {}
+
     def status(self, job_id: str) -> dict[str, Any]:
         """Read one job's state."""
         return self._call("GET", f"/v1/jobs/{job_id}").json()

{hyperun-0.2.2 → hyperun-0.2.4}/hyperun.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperun
-Version: 0.2.2
+Version: 0.2.4
 Summary: Submit a GPU job and get results back. No kubectl, no cloud account.
 Author: DDPS Lab
 License-Expression: Apache-2.0

{hyperun-0.2.2 → hyperun-0.2.4}/pyproject.toml

@@ -34,7 +34,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hyperun"
-version = "0.2.2"
+version = "0.2.4"
 description = "Submit a GPU job and get results back. No kubectl, no cloud account."
 requires-python = ">=3.9"
 dependencies = ["requests>=2.31", "PyYAML>=6.0"]

{hyperun-0.2.2 → hyperun-0.2.4}/tests/test_cli.py

@@ -1222,3 +1222,53 @@ def test_a_failure_that_is_not_a_lost_session_is_not_retried(fake, monkeypatch,
     assert run(["shell", "job-a8acdef80a07"]) == 0
     assert calls["n"] == 1, "retrying an unrelated failure would double every bad command"
     assert "did not answer in JSON" in capsys.readouterr().err
+
+
+# ------------------------------------------------------------- HYPERUN-JOB-STOP
+
+
+def test_pause_and_resume_are_two_verbs_over_one_boolean(monkeypatch, capsys):
+    """★ `pause` AND `resume` RATHER THAN `stop --undo`. One verb with a flag is one verb
+    and two readings; a person asking to pause a job and a person asking to resume one are
+    doing opposite things and should type opposite words."""
+    calls = []
+
+    class FakeClient:
+        def set_stopped(self, job_id, stopped):
+            calls.append((job_id, stopped))
+            return {"phase": "Stopped" if stopped else "Running", "stopped": stopped}
+
+    monkeypatch.setattr(cli, "client_from_config", lambda: FakeClient())
+
+    assert cli.main(["pause", "job-abc123abc123"]) == 0
+    assert cli.main(["resume", "job-abc123abc123"]) == 0
+    assert calls == [("job-abc123abc123", True), ("job-abc123abc123", False)]
+
+
+def test_pause_says_it_asked_rather_than_that_it_stopped(monkeypatch, capsys):
+    """★★ THE WORD MATTERS. The machine pauses up to a minute later, and on some vendors it
+    never does. "paused" here would tell somebody a $6/hour machine had stopped billing when
+    it had not."""
+    class FakeClient:
+        def set_stopped(self, job_id, stopped):
+            return {"phase": "Running", "stopped": True}
+
+    monkeypatch.setattr(cli, "client_from_config", lambda: FakeClient())
+    cli.main(["pause", "job-abc123abc123"])
+    out = capsys.readouterr().out
+    assert "asked to pause" in out
+    assert "Running right now" in out, "the phase has to be the real one, not the request"
+    # And the two things a person needs to know next.
+    assert "cannot pause" in out
+    assert "7 days" in out, "a job left paused stops being protected, and that has to be said"
+
+
+def test_a_refusal_from_the_server_is_not_swallowed(monkeypatch, capsys):
+    class FakeClient:
+        def set_stopped(self, job_id, stopped):
+            raise cli.ServerError("this job has finished (Succeeded)")
+
+    monkeypatch.setattr(cli, "client_from_config", lambda: FakeClient())
+    assert cli.main(["pause", "job-abc123abc123"]) != 0
+    assert "Succeeded" in capsys.readouterr().err
+