hyperun 0.2.0__tar.gz → 0.2.1__tar.gz

{hyperun-0.2.0 → hyperun-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperun
-Version: 0.2.0
+Version: 0.2.1
 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.0 → hyperun-0.2.1}/hyperun/cli.py

@@ -365,9 +365,10 @@ def build_parser() -> argparse.ArgumentParser:
         "through the job's driver pod into the workload container on the "
         "rented machine and brings the exit code back like ssh. It is NOT a "
         "TTY — no vim, no top, about 25 seconds per command — because the "
-        "server is a Lambda and cannot hold a terminal open. AWS and GCP "
-        "machine rentals only: a RunPod job is a rented container with no "
-        "machine behind it, and the relay refuses it. ★ PUT OPTIONS BEFORE THE "
+        "server is a Lambda and cannot hold a terminal open. AWS, GCP and "
+        "Shadeform machine rentals only: a RunPod job is a rented container "
+        "with no machine behind it, so there is no cluster to attach to and "
+        "the relay refuses it. ★ PUT OPTIONS BEFORE THE "
         "JOB ID -- everything after it is sent to the workload as-is, so "
         "`shell job-x --slot 2` asks pod 0 and passes `--slot 2` to the shell. "
         "That is refused rather than obeyed.",
@@ -826,11 +827,26 @@ def cmd_shell(args: argparse.Namespace) -> int:
     pod onto the rented machine and returns the exit code like ssh. With a
     trailing `-- command` it runs once and exits with that code; without one
     it prompts, which FEELS like a slow shell and is honestly a request loop.
+
+    ★ THE PROMPT USES A SESSION AND THE ONE-SHOT FORM DOES NOT, since
+    2026-09-10. The prompt types into a shell that stays running in the driver
+    pod, so `cd`, an exported variable and an activated venv survive from one
+    line to the next -- which is what a person at a prompt assumes and what
+    every earlier version quietly did not do. A `-- command` invocation is a
+    script's shape and gets the stateless form: it wants no history and should
+    not leave a session behind for the idle timer to close.
     """
     client = client_from_config()
-
-    def run_once(line: str) -> int:
-        answer = client.exec_in_job(args.job, line, slot=args.slot)
+    # The output sequence the session has already shown us. It is here rather
+    # than inside run_once because it has to survive between lines, which is the
+    # whole point.
+    state = {"seq": 0}
+
+    def run_once(line: str, session: bool = False) -> int:
+        answer = client.exec_in_job(args.job, line, slot=args.slot,
+                                    session=session, seq=state["seq"])
+        if session:
+            state["seq"] = int(answer.get("seq", state["seq"]))
         output = answer.get("output") or ""
         if output:
             print(output, end="" if output.endswith("\n") else "\n")
@@ -873,7 +889,8 @@ def cmd_shell(args: argparse.Namespace) -> int:
         return run_once(" ".join(words))
 
     print(
-        f"one command per line, ~25s each; 'exit' or Ctrl-D leaves. Not a TTY.",
+        f"one command per line, ~25s each; 'exit' or Ctrl-D leaves. Not a TTY, "
+        f"but `cd` and exported variables DO survive between lines.",
         file=sys.stderr,
     )
     while True:
@@ -888,10 +905,29 @@ def cmd_shell(args: argparse.Namespace) -> int:
         if line in ("exit", "quit"):
             return EXIT_OK
         try:
-            code = run_once(line)
+            code = run_once(line, session=True)
             if code:
                 print(f"(exit {code})", file=sys.stderr)
         except ServerError as exc:
+            # A SESSION THAT IS GONE IS THE ONE ERROR WORTH ACTING ON. The
+            # server answers 409 when the driver pod has no session for this
+            # slot -- it timed out after ten minutes unread, or the workload
+            # restarted. Reopening is right there and only there: everywhere
+            # else a new shell would silently lose the `cd` the person is
+            # relying on, which is the failure this whole feature exists to
+            # end. The sequence resets with it, because the new shell's
+            # output starts from nothing.
+            if "open one first" in str(exc) or "no session" in str(exc):
+                state["seq"] = 0
+                print("(the session had closed; reopening — `cd` and variables "
+                      "from before are gone)", file=sys.stderr)
+                try:
+                    code = run_once(line, session=True)
+                    if code:
+                        print(f"(exit {code})", file=sys.stderr)
+                    continue
+                except ServerError as retry_exc:
+                    exc = retry_exc
             # One failed command must not end the session: say what the server
             # said and keep the prompt.
             print(f"error: {exc}", file=sys.stderr)
@@ -1079,8 +1115,13 @@ def cmd_watch(args: argparse.Namespace) -> int:
               f"{gpu['memory_used_mib']:,} / {gpu['memory_total_mib']:,} MiB "
               f"({gpu['memory_percent']}%)")
         print(f"  temp, power    {gpu['temperature_c']} C, {gpu['power_w']} W")
-        print(f"  samples        {len(result.get('gpu_series', []))}, "
-              f"last {result['window_seconds']}s")
+        # `sample_count`, not len(gpu_series): the server thins the series to at
+        # most 400 points so a chart can draw it, and job-66b46719b854 printed
+        # 785 readings per card while this line said 393. The screen had the same
+        # defect and was fixed on 2026-09-12. A server too old to send the count
+        # falls back to the thinned length, which is the only number it has.
+        taken = result.get("sample_count") or len(result.get("gpu_series", []))
+        print(f"  samples        {taken}, last {result['window_seconds']}s")
 
     if result.get("note"):
         print(f"  note           {result['note']}")

{hyperun-0.2.0 → hyperun-0.2.1}/hyperun/client.py

@@ -193,7 +193,8 @@ class Client:
         return self._call("GET", "/v1/stats").json()
 
     def exec_in_job(
-        self, job: str, command: str, slot: int = 0, timeout_seconds: int = 20
+        self, job: str, command: str, slot: int = 0, timeout_seconds: int = 20,
+        session: bool = False, seq: int = 0,
     ) -> dict[str, Any]:
         """Run one shell line inside a running job's workload container.
 
@@ -206,6 +207,13 @@ class Client:
             command: one shell line, run as `sh -lc <command>`.
             slot: which pod of a parallel job.
             timeout_seconds: server-side wait, capped at 25 by the server.
+            session: type the line into a shell ALREADY RUNNING in the driver
+                pod, so `cd` and exported variables survive to the next call.
+                False starts a fresh `sh -lc`, which is what a script wants.
+            seq: with `session`, the output sequence this caller last saw. The
+                reply carries the next one. It exists because the caller is a
+                different process on the server's side every time and cannot
+                hold a position in the output.
         """
         return self._call(
             "POST",
@@ -214,6 +222,8 @@ class Client:
                 "command": command,
                 "slot": slot,
                 "timeout_seconds": timeout_seconds,
+                "session": session,
+                "seq": seq,
             },
             # The server may hold the request for timeout_seconds before
             # answering; the read timeout has to outlive that on purpose.

{hyperun-0.2.0 → hyperun-0.2.1}/hyperun.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperun
-Version: 0.2.0
+Version: 0.2.1
 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.0 → hyperun-0.2.1}/pyproject.toml

@@ -34,7 +34,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hyperun"
-version = "0.2.0"
+version = "0.2.1"
 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.0 → hyperun-0.2.1}/tests/test_cli.py

@@ -100,8 +100,8 @@ class FakeClient:
     # DDPSRUN-SHELL. Absent until 2026-09-10, which is exactly why the dispatch
     # bug below survived every release: with no double for this call, no test
     # could reach cmd_shell at all.
-    def exec_in_job(self, job, line, slot=0):
-        self.execed.append((job, line, slot))
+    def exec_in_job(self, job, line, slot=0, session=False, seq=0):
+        self.execed.append((job, line, slot, session, seq))
         return self.exec_result
 
 
@@ -475,6 +475,39 @@ def test_watch_prints_progress_and_gpu(fake, capsys):
     assert "samples        120" in printed
 
 
+def test_samples_counts_the_readings_taken_not_the_chart_points(fake, capsys):
+    # ★ THE SAME DEFECT THE SCREEN HAD. The server thins the series to at most
+    # 400 points so a chart can draw it; job-66b46719b854 printed 785 readings
+    # per card and both surfaces counted the 393 that survived. The mean and the
+    # peak are computed over all 785, so the count beside them has to be 785.
+    fake.metrics_result = {
+        "latest_gpu": {"utilization_percent": 94, "memory_used_mib": 38200,
+                       "memory_total_mib": 45440, "memory_percent": 84.1,
+                       "temperature_c": 71, "power_w": 298.5},
+        "gpu_series": [{}] * 393,
+        "sample_count": 785,
+        "window_seconds": 604800, "note": "",
+    }
+    assert run(["watch", "job-a8acdef80a07"]) == cli.EXIT_OK
+    printed = capsys.readouterr().out
+    assert "samples        785" in printed
+    assert "samples        393" not in printed
+
+
+def test_a_server_too_old_to_send_the_count_still_prints_one(fake, capsys):
+    # The field arrived on 2026-09-12. Against a server that predates it the
+    # thinned length is the only number there is, and a blank is worse.
+    fake.metrics_result = {
+        "latest_gpu": {"utilization_percent": 10, "memory_used_mib": 1,
+                       "memory_total_mib": 2, "memory_percent": 50.0,
+                       "temperature_c": 40, "power_w": 50.0},
+        "gpu_series": [{}] * 12,
+        "window_seconds": 3600, "note": "",
+    }
+    assert run(["watch", "job-a8acdef80a07"]) == cli.EXIT_OK
+    assert "samples        12" in capsys.readouterr().out
+
+
 def test_an_unsettled_projection_is_labelled_rather_than_stated(fake, capsys):
     fake.metrics_result = {
         "progress": {"step": 5, "total_steps": 556, "percent": 0.9,
@@ -820,7 +853,8 @@ def test_the_subcommand_name_survives_the_shell_positional():
 
 def test_shell_with_a_command_runs_it_once_and_returns_its_exit_code(fake, capsys):
     assert run(["shell", "job-a8acdef80a07", "--", "date"]) == 0
-    assert fake.execed == [("job-a8acdef80a07", "date", 0)]
+    assert fake.execed == [("job-a8acdef80a07", "date", 0, False, 0)], (
+        "`-- command` 형태는 stateless 다 — script 는 남길 session 이 없다")
     assert "Sep 10" in capsys.readouterr().out
 
 
@@ -858,3 +892,62 @@ def test_every_other_subcommand_still_dispatches(fake):
     """dest 를 바꾼 것이 나머지를 깨지 않았다는 확인."""
     assert run(["status", "job-a8acdef80a07"]) == 0
     assert run(["secrets"]) == 0
+
+
+def test_the_prompt_uses_a_session_and_carries_the_sequence(fake, monkeypatch, capsys):
+    """★ WHY THE PROMPT DIFFERS FROM `-- command`. A person at a prompt assumes
+    `cd` sticks; a script does not want a session left behind for the idle timer.
+    So the prompt sends session=True and threads the sequence through, and the
+    one-shot form stays stateless."""
+    typed = iter(["cd /workspace", "pwd", "exit"])
+    monkeypatch.setattr("builtins.input", lambda _prompt: next(typed))
+    fake.exec_result = {"output": "/workspace\n", "exit_code": 0, "seq": 11, "lost": False}
+
+    assert run(["shell", "job-a8acdef80a07"]) == 0
+    assert [(line, sess) for _job, line, _slot, sess, _seq in fake.execed] == [
+        ("cd /workspace", True), ("pwd", True)]
+    # The FIRST line starts at 0 and the second carries what the first returned.
+    assert [seq for *_rest, seq in fake.execed] == [0, 11]
+
+
+def test_a_session_that_closed_is_reopened_once_and_the_person_is_told(fake, monkeypatch,
+                                                                       capsys):
+    """The one case where starting a new shell is right: the old one is provably
+    gone (ten minutes unread, or the workload restarted). Everywhere else a new
+    shell silently loses the `cd`, which is the failure this feature exists to end
+    -- so the message says what was lost."""
+    typed = iter(["pwd", "exit"])
+    monkeypatch.setattr("builtins.input", lambda _prompt: next(typed))
+
+    calls = {"n": 0}
+    original = fake.exec_in_job
+
+    def flaky(job, line, slot=0, session=False, seq=0):
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise cli.ServerError("no session for this slot; open one first")
+        return original(job, line, slot=slot, session=session, seq=seq)
+
+    fake.exec_in_job = flaky
+    assert run(["shell", "job-a8acdef80a07"]) == 0
+    assert calls["n"] == 2, "it retried once rather than giving up or looping"
+    err = capsys.readouterr().err
+    assert "reopening" in err and "are gone" in err, (
+        "a silent reopen would let somebody keep typing paths relative to a cd that no "
+        "longer applies")
+
+
+def test_a_failure_that_is_not_a_lost_session_is_not_retried(fake, monkeypatch, capsys):
+    typed = iter(["pwd", "exit"])
+    monkeypatch.setattr("builtins.input", lambda _prompt: next(typed))
+
+    calls = {"n": 0}
+
+    def always_bad(job, line, slot=0, session=False, seq=0):
+        calls["n"] += 1
+        raise cli.ServerError("the driver pod did not answer in JSON")
+
+    fake.exec_in_job = always_bad
+    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-0.2.0 → hyperun-0.2.1}/tests/test_client.py

@@ -65,7 +65,9 @@ def test_shell_sends_the_command_and_waits_longer_than_the_server():
     result = client_with(session).exec_in_job("baseline-c", "nvidia-smi -L", slot=1)
     call = session.calls[0]
     assert call["url"] == "https://run.example/v1/jobs/baseline-c/exec"
-    assert call["json"] == {"command": "nvidia-smi -L", "slot": 1, "timeout_seconds": 20}
+    assert call["json"] == {"command": "nvidia-smi -L", "slot": 1, "timeout_seconds": 20,
+                            "session": False, "seq": 0}, (
+        "PACSRUN-SHELL-SESSION 이후에도 기본은 한 줄짜리 stateless 형태다")
     # The server may hold the request for its whole window, so the client's
     # read timeout must outlive it.
     assert call["timeout"] > 20
@@ -155,3 +157,15 @@ def test_a_submit_is_given_more_patience_than_a_read():
     read_session = FakeSession(FakeResponse(200, {}))
     client_with(read_session).status("job-a8acdef80a07")
     assert submit_session.calls[0]["timeout"] > read_session.calls[0]["timeout"]
+
+
+def test_shell_can_ask_for_the_persistent_session_and_carries_its_sequence():
+    """The prompt loop's shape: the same route, with `session` and the output
+    sequence the caller last saw. Without the sequence the caller would be handed
+    everything the shell has ever printed on every line."""
+    session = FakeSession(FakeResponse(200, {"output": "/workspace\n", "exit_code": 0,
+                                             "seq": 42, "lost": False, "note": ""}))
+    result = client_with(session).exec_in_job("baseline-c", "pwd", session=True, seq=7)
+    assert session.calls[0]["json"]["session"] is True
+    assert session.calls[0]["json"]["seq"] == 7
+    assert result["seq"] == 42, "the reply carries the next one back"