pyflightstream 0.34.0__tar.gz → 0.35.0__tar.gz

{pyflightstream-0.34.0/src/pyflightstream.egg-info → pyflightstream-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyflightstream
-Version: 0.34.0
+Version: 0.35.0
 Summary: Version-aware, didactic Python driver for the FlightStream panel-method solver
 Author: Geovana Neves
 License: MIT
@@ -61,7 +61,7 @@ Version-aware Python driver for the FlightStream panel-method solver: write a
 run matrix, and pyflightstream plans, runs and post-processes every point,
 from your workstation or a cluster. MIT licensed.
 
-Status: v0.34.0 is the current release; CHANGELOG.md carries the history.
+Status: v0.35.0 is the current release; CHANGELOG.md carries the history.
 
 **Documentation: [nevesgeovana.github.io/pyflightstream](https://nevesgeovana.github.io/pyflightstream/)**
 

{pyflightstream-0.34.0 → pyflightstream-0.35.0}/README.md

@@ -8,7 +8,7 @@ Version-aware Python driver for the FlightStream panel-method solver: write a
 run matrix, and pyflightstream plans, runs and post-processes every point,
 from your workstation or a cluster. MIT licensed.
 
-Status: v0.34.0 is the current release; CHANGELOG.md carries the history.
+Status: v0.35.0 is the current release; CHANGELOG.md carries the history.
 
 **Documentation: [nevesgeovana.github.io/pyflightstream](https://nevesgeovana.github.io/pyflightstream/)**
 

{pyflightstream-0.34.0 → pyflightstream-0.35.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyflightstream"
-version = "0.34.0"
+version = "0.35.0"
 description = "Version-aware, didactic Python driver for the FlightStream panel-method solver"
 readme = "README.md"
 license = {text = "MIT"}
@@ -249,7 +249,7 @@ exclude_also = [
 # RE-COUNTED at 0.8.0.dev0 (OPS-2006.11.01), because the sentence above is a
 # fact about 2026-08-03 and was being read as a fact about today. With every
 # override below turned off:
-#     mypy recount 2026-10-02: 160 errors in 16 of 236 modules, the
+#     mypy recount 2026-10-02: 160 errors in 16 of 260 modules, the
 #     0.34.0 branch rel/0-34 with the wave-2 packages merged: two modules
 #     more than the wave-1 tip, both clean (the wave-1 tip read 160 in 16 of
 #     234: fifteen modules more than 0.33.0, each clean, the cuts of WP8,
@@ -259,7 +259,7 @@ exclude_also = [
 #     of 219, when pyflightstream.run left the exempted set (decision 7)
 #     with its 930 errors; 1122 in 18 of 196 before WP5 and WP6, and 1122
 #     in 18 of 173 before WP4)
-# The package has grown from the 53 modules of the first run to 236, and no
+# The package has grown from the 53 modules of the first run to 260, and no
 # module outside the exempted set is dirty. THE EXEMPTED SET DID MOVE, and
 # down: `pyflightstream.results.tables` was excused on 2026-08-03 and is
 # clean now, so its override was deleted on evidence (see the note where it

{pyflightstream-0.34.0 → pyflightstream-0.35.0}/src/pyflightstream/_digest.py

@@ -137,6 +137,11 @@ CANONICAL_FORMS = {
         "grid counts, then space-separated .17g finite values, LF between rows "
         "and one final LF. Source/effective paths are provenance, not hash input."
     ),
+    "run/_batch_exec.py": (
+        "the UTF-8 encoding of the grouping receipt's JSON form, rendered with "
+        "sorted keys and ASCII escaping, so the same receipt always hashes alike. "
+        "No path or clock enters the text."
+    ),
     "run/_continuation_frame.py": (
         "pending input bytes unchanged, or UTF-8 encoded pending text. For text, "
         "both the unmodified encoding and its LF-to-CRLF replacement are compared "
@@ -174,6 +179,12 @@ CANONICAL_FORMS = {
         "storage recipe (inputs/management/m<id>.toml), always the source file's "
         "bytes and never a JSON rendering of its parsed content."
     ),
+    "workspace/_ledger_history.py": (
+        "the raw bytes of a recorded script file, read whole and never decoded, "
+        "compared with the script_sha256 the run record states: the same "
+        "canonical form as the manifest checksum above. It selects which script "
+        "to compare and writes nothing."
+    ),
 }
 
 __all__ = [

{pyflightstream-0.34.0 → pyflightstream-0.35.0}/src/pyflightstream/cases/ccs_wing.py

@@ -338,13 +338,16 @@ def _emit_file_route(script: Script, case: SimCase, names: Sequence[str]) -> Non
 
 
 def _refuse_the_real_control_surface_form(case: SimCase, spec: CcsImportOptions) -> None:
-    """Refuse a control surface written with REAL spanwise limits (RPT-097, POL 3205).
+    """Refuse a control surface written with REAL spanwise limits (RPT-097, POL 3205, RPT-126).
 
     Licensed round 2 on FlightStream 26.124 ran the same aileron in the two
     forms through the package route: the PARAMETRIC form completed and saved a
     simulation that differs from the wing without it (POL 3204), and the REAL
     form ended ``FAILED_EXECUTION`` with no saved simulation (POL 3205). No
     other build measured the REAL form, so it is refused on every build.
+    RPT-126 then separated the cause (FR-336 R4, ``refusal_stays``): the limits
+    2.0 and 3.6 end the solver process in both spaces, the REAL token does not,
+    and the message states it.
     """
     for surface in spec.control_surfaces:
         if surface.space != "REAL":
@@ -353,9 +356,12 @@ def _refuse_the_real_control_surface_form(case: SimCase, spec: CcsImportOptions)
             f"case {case.sim_id!r}: the control surface {surface.name!r} is written with REAL "
             "spanwise limits, and the plan refuses that form. On FlightStream 26.124 the REAL "
             "form ended FAILED_EXECUTION with no saved simulation, where the same surface in "
-            "the PARAMETRIC form completed (licensed round 2, RPT-097), and no other build "
-            "measured it. Write the limits as fractions of the span between 0 and 1 and "
-            'space = "PARAMETRIC" (the default) in the sidecar\'s [[import.ccs.control_surfaces]].'
+            "the PARAMETRIC form completed (licensed round 2, RPT-097). RPT-126 measured the "
+            "cause: the limits 2.0 and 3.6 end the solver process (0xC0000005) in both spaces, "
+            "so the REAL token is not the cause; the refusal stays because that row neither "
+            "solved nor saved, and no other build measured the form. Write the limits as "
+            'fractions of the span between 0 and 1 and space = "PARAMETRIC" (the default) in '
+            "the sidecar's [[import.ccs.control_surfaces]]."
         )
 
 

{pyflightstream-0.34.0 → pyflightstream-0.35.0}/src/pyflightstream/cases/workflows/__init__.py

@@ -310,6 +310,12 @@ from ._vocabulary import (
 from ._vocabulary import (
     ALPHA_VARIABLE as ALPHA_VARIABLE,
 )
+from ._vocabulary import (
+    BATCH_DIR as BATCH_DIR,
+)
+from ._vocabulary import (
+    BATCH_STEM_PREFIX as BATCH_STEM_PREFIX,
+)
 from ._vocabulary import (
     BETA_VARIABLE as BETA_VARIABLE,
 )
@@ -334,6 +340,9 @@ from ._vocabulary import (
 from ._vocabulary import (
     CONVERTER_PREFIX as CONVERTER_PREFIX,
 )
+from ._vocabulary import (
+    CUMULATIVE_LOG_SUFFIX as CUMULATIVE_LOG_SUFFIX,
+)
 from ._vocabulary import (
     FLAT_RPM_KEY as FLAT_RPM_KEY,
 )
@@ -343,6 +352,15 @@ from ._vocabulary import (
 from ._vocabulary import (
     FREESTREAM_UNITS_VARIABLE as FREESTREAM_UNITS_VARIABLE,
 )
+from ._vocabulary import (
+    FULL_POLAR_STEM as FULL_POLAR_STEM,
+)
+from ._vocabulary import (
+    JOB_END_SUFFIX as JOB_END_SUFFIX,
+)
+from ._vocabulary import (
+    JOB_LOG_SUFFIX as JOB_LOG_SUFFIX,
+)
 from ._vocabulary import (
     MOVING_BC_ALIAS_VARIABLE as MOVING_BC_ALIAS_VARIABLE,
 )
@@ -429,6 +447,12 @@ from ._vocabulary import (
 )
 
 __all__ = [
+    "BATCH_DIR",
+    "BATCH_STEM_PREFIX",
+    "CUMULATIVE_LOG_SUFFIX",
+    "FULL_POLAR_STEM",
+    "JOB_END_SUFFIX",
+    "JOB_LOG_SUFFIX",
     "row_symmetry_loads",
     "ACTUATOR_KEYS",
     "ACTUATOR_PROFILE_COPY_SUFFIX",
@@ -477,6 +501,7 @@ __all__ = [
     "SYMMETRY_VARIABLE",
     "TIME_ITERATIONS_VARIABLE",
     "VELOCITY_VARIABLE",
+    "WALLTIME_VARIABLE",
     "LAST_ITERS_AVG_VARIABLE",
     "LAST_REVS_AVG_VARIABLE",
     "WORKFLOWS",

pyflightstream-0.35.0/src/pyflightstream/cases/workflows/_batch_actions.py

@@ -0,0 +1,468 @@
+"""The action programs of a grouped job: one counter and one clock for many points (FR-B5a, FR-B19).
+
+A grouped job (``--batch`` or ``--polar-sweep``, 0.35.0) runs several points
+in ONE solver instance. The unsteady actions are registered ONCE per instance
+(MEASURED, DESIGN-0350 Test 2: the actions survive ``REMOVE_INITIALIZATION``
+and ``NEW_SIMULATION``, and a second registration runs every action twice per
+step), so the counter and the clock the job registers serve every point of it.
+The solver hands an action nothing, so these programs re-index the job's
+invocation count into (point, the point's own step) from a schedule written
+beside them, and write each point's own count and clock state into the
+point's own folder, in the shape a point run alone leaves.
+
+Both programs stand alone: no package import, every path taken from their
+own file's folder (the job's ``actions/``) and from the schedule, every write
+with an explicit LF, like ``run/_actions_counter.py:TEMPLATE``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from pathlib import PurePath, PureWindowsPath
+from typing import Protocol
+
+from pyflightstream.cases._unsteady_actions import (
+    UNSTEADY_ACTION_COUNT,
+    UNSTEADY_ACTION_SCRIPT,
+    WALLTIME_CLOCK_STATE,
+    WALLTIME_STOP_SCRIPT,
+)
+
+from ._vocabulary import CUMULATIVE_LOG_SUFFIX
+
+__all__ = [
+    "JOB_CURRENT",
+    "JOB_PROGRESS",
+    "JOB_SCHEDULE",
+    "SchedulePoint",
+    "absolute_output_lines",
+    "is_absolute_target",
+    "job_schedule",
+    "render_job_clock_program",
+    "render_job_counter_program",
+]
+
+#: The schedule the two programs read, relative to the job folder.
+JOB_SCHEDULE = "actions/pfs_batch_schedule.json"
+#: The configuration of the point now running, rewritten at its first step.
+JOB_CURRENT = "actions/pfs_batch_current.json"
+#: The job's progress, rewritten at every step; collect reads its mismatches.
+JOB_PROGRESS = "actions/pfs_batch_progress.json"
+
+#: The schema of the schedule, so a reader refuses one it does not know.
+SCHEDULE_SCHEMA = "pyfs-batch-schedule/1"
+
+
+class SchedulePoint(Protocol):
+    """The fields of a job point the schedule reads (``JobPoint`` satisfies it)."""
+
+    @property
+    def run_id(self) -> str:
+        """The point's run id."""
+        ...
+
+    @property
+    def datapoint_dir(self) -> PurePath:
+        """The point's absolute datapoint folder."""
+        ...
+
+    @property
+    def outputs(self) -> tuple[str, ...]:
+        """The outputs its script names, relative."""
+        ...
+
+    @property
+    def action_exports(self) -> str:
+        """Its per-step export lines, relative."""
+        ...
+
+    @property
+    def first_export_step(self) -> int | None:
+        """The first step of its per-step exports, from its own step 1."""
+        ...
+
+    @property
+    def stop_text(self) -> str:
+        """What the clock writes when it stops this point, relative."""
+        ...
+
+    @property
+    def time_steps(self) -> int:
+        """The time steps the point marches."""
+        ...
+
+
+def is_absolute_target(target: str) -> bool:
+    """Whether a script's path argument is absolute, on Windows or on a POSIX cluster.
+
+    Parameters
+    ----------
+    target : str
+        A path argument as the script writes it.
+
+    Returns
+    -------
+    bool
+        True for a drive or UNC path and for a path from the POSIX root.
+    """
+    return target.startswith("/") or PureWindowsPath(target).is_absolute()
+
+
+def _log_stem(name: str) -> str:
+    """Return the stem of a point's log name: ``<stem>_log.txt`` gives ``<stem>``."""
+    return name.removesuffix("_log.txt") if name.endswith("_log.txt") else PurePath(name).stem
+
+
+def absolute_output_lines(text: str, datapoint_dir: PurePath, names: Iterable[str]) -> str:
+    """Return ``text`` with every line naming an output made absolute under ``datapoint_dir``.
+
+    A line equal to one of ``names`` becomes ``<datapoint_dir>/<name>``. The
+    target of an ``EXPORT_LOG`` (the line after it) becomes
+    ``<datapoint_dir>/<stem>`` followed by
+    :data:`~pyflightstream.cases.workflows._vocabulary.CUMULATIVE_LOG_SUFFIX`,
+    because a log exported inside a job holds every point run before it
+    (MEASURED); collect writes the point's own log from its slice.
+
+    Parameters
+    ----------
+    text : str
+        A script text, an exports script or a stop text.
+    datapoint_dir : PurePath
+        The point's absolute datapoint folder.
+    names : iterable of str
+        The point's output names as its script names them, relative.
+
+    Returns
+    -------
+    str
+        The text with those lines replaced; every other line unchanged.
+    """
+    wanted = set(names)
+    lines = text.split("\n")
+    out: list[str] = []
+    for index, line in enumerate(lines):
+        bare = line.strip()
+        after_log = index > 0 and lines[index - 1].strip() == "EXPORT_LOG"
+        if after_log and bare and not is_absolute_target(bare):
+            out.append(str(datapoint_dir / (_log_stem(bare) + CUMULATIVE_LOG_SUFFIX)))
+        elif bare in wanted:
+            out.append(str(datapoint_dir / bare))
+        else:
+            out.append(line)
+    return "\n".join(out)
+
+
+def _saved_simulation(point: SchedulePoint) -> str | None:
+    """Return the absolute path of the simulation the point saves, or None when it saves none."""
+    for name in point.outputs:
+        if name.lower().endswith(".fsm"):
+            return str(point.datapoint_dir / name)
+    return None
+
+
+def job_schedule(points: Sequence[SchedulePoint], *, deadline_s: float | None) -> dict[str, object]:
+    """Return the schedule the job's counter and clock read, every path absolute.
+
+    Parameters
+    ----------
+    points : sequence of SchedulePoint
+        The job's points in the order the job runs them (``JobPoint``).
+    deadline_s : float or None
+        The job's elapsed time at which the clock stops the current point
+        (the job's walltime minus its margin); None for a job without one.
+
+    Returns
+    -------
+    dict
+        ``{"schema", "deadline_s", "total_steps", "points": [...]}``, each
+        point with ``run_id``, ``datapoint_dir``, ``time_steps``,
+        ``first_export_step``, ``exports``, ``stop_text`` and ``fsm``.
+    """
+    entries: list[dict[str, object]] = []
+    for point in points:
+        entries.append(
+            {
+                "run_id": point.run_id,
+                "datapoint_dir": str(point.datapoint_dir),
+                "time_steps": point.time_steps,
+                "first_export_step": point.first_export_step,
+                "exports": absolute_output_lines(
+                    point.action_exports, point.datapoint_dir, point.outputs
+                ),
+                "stop_text": absolute_output_lines(
+                    point.stop_text, point.datapoint_dir, point.outputs
+                ),
+                "fsm": _saved_simulation(point),
+            }
+        )
+    return {
+        "schema": SCHEDULE_SCHEMA,
+        "deadline_s": deadline_s,
+        "total_steps": sum(point.time_steps for point in points),
+        "points": entries,
+    }
+
+
+#: The job's counter. Registered FIRST, so it runs before the exports SCRIPT
+#: and the clock of the same step: it decides which point is running and
+#: which of its steps this is, and everything after it reads that.
+COUNTER_TEMPLATE = '''"""Counter of the unsteady solver actions of one pyflightstream grouped job.
+
+Written by pyflightstream (FR-B5a, FR-B19). The solver runs this program after
+every unsteady time step of the job and passes it nothing. The job count kept
+in COUNT_FILE is the job's step; the schedule turns it into the point running
+and that point's own step, writes the point's own count where a point run
+alone writes it, and rewrites the exports script with that point's exports
+from its own first export step. At a point's first step it records the point
+as current, empties the exports and the stop scripts, and checks that the
+previous point saved its simulation. Every path is taken from this file's own
+location and from the schedule, never from the working directory.
+"""
+
+import json
+import time
+from pathlib import Path
+
+#: Written by pyflightstream when the job was assembled.
+TIME_ITERATIONS = <TIME_ITERATIONS>
+INTERPRETER = <INTERPRETER>
+
+HERE = Path(__file__).resolve().parent
+JOB = HERE.parent
+SCHEDULE = JOB / <SCHEDULE>
+CURRENT = JOB / <CURRENT>
+PROGRESS = JOB / <PROGRESS>
+COUNT_FILE = JOB / <COUNT>
+EXPORTS_FILE = JOB / <EXPORTS>
+STOP_FILE = JOB / <STOP>
+POINT_COUNT = <COUNT>
+
+
+def read(path, default):
+    if not path.is_file():
+        return default
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except ValueError:
+        return default
+
+
+def write(path, text):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8", newline="\\n")
+
+
+def locate(points, count):
+    """Return (index, step): the point the job count falls in and its own step."""
+    before = 0
+    for index, point in enumerate(points):
+        if count <= before + int(point["time_steps"]):
+            return index, count - before
+        before += int(point["time_steps"])
+    last = len(points) - 1
+    return last, count - (before - int(points[last]["time_steps"]))
+
+
+def start_point(points, index, now):
+    """The point's first step: record it, empty both scripts, check the previous save."""
+    point = points[index]
+    write(EXPORTS_FILE, "")
+    write(STOP_FILE, "")
+    current = {
+        "point": index + 1,
+        "run_id": point["run_id"],
+        "datapoint_dir": point["datapoint_dir"],
+        "first_export_step": point["first_export_step"],
+        "exports": point["exports"],
+        "stop_text": point["stop_text"],
+        "started_at": now,
+    }
+    write(CURRENT, json.dumps(current, indent=2))
+    if index == 0:
+        return None
+    saved = points[index - 1]["fsm"]
+    if saved is not None and not Path(saved).is_file():
+        return {"previous": index, "point": index + 1, "missing": saved}
+    return None
+
+
+def main():
+    points = read(SCHEDULE, {})["points"]
+    count = int(read(COUNT_FILE, {"count": 0})["count"]) + 1
+    write(COUNT_FILE, json.dumps({"count": count}))
+    index, step = locate(points, count)
+    point = points[index]
+    progress = read(PROGRESS, {})
+    mismatches = list(progress.get("mismatches", []))
+    if step == 1:
+        found = start_point(points, index, time.time())
+        if found is not None:
+            mismatches.append(found)
+    write(Path(point["datapoint_dir"]) / POINT_COUNT, json.dumps({"count": step}))
+    first = point["first_export_step"]
+    exporting = first is not None and step >= int(first)
+    write(EXPORTS_FILE, point["exports"] if exporting else "")
+    progress = {
+        "point": index + 1,
+        "run_id": point["run_id"],
+        "step": step,
+        "job_count": count,
+        "mismatch": bool(mismatches),
+        "mismatches": mismatches,
+    }
+    write(PROGRESS, json.dumps(progress, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+'''
+
+#: The job's clock (D3). Its start is its first invocation; when the job's
+#: elapsed time reaches the schedule's deadline it writes the CURRENT point's
+#: stop text into the stop script, once, and records where it stopped in the
+#: job's state and in the point's own, in the shape a point run alone leaves.
+CLOCK_TEMPLATE = '''"""Wall clock of one pyflightstream grouped job.
+
+Written by pyflightstream (FR-B5a, D3). The solver cannot be asked how long
+the job has been going, so this program keeps its own state: the first
+invocation writes the start, every later one asks whether the job's elapsed
+time reached the schedule's deadline. When it does, the CURRENT point's stop
+text goes into the stop script, once, and the point's own clock state records
+the step it stopped at. Every path is taken from this file's own location and
+from the schedule and the counter's current point, never from the working
+directory.
+"""
+
+import json
+import time
+from pathlib import Path
+
+INTERPRETER = <INTERPRETER>
+
+HERE = Path(__file__).resolve().parent
+JOB = HERE.parent
+SCHEDULE = JOB / <SCHEDULE>
+CURRENT = JOB / <CURRENT>
+PROGRESS = JOB / <PROGRESS>
+STATE = JOB / <STATE>
+STOP_FILE = JOB / <STOP>
+POINT_STATE = <STATE>
+
+
+def read(path, default):
+    if not path.is_file():
+        return default
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except ValueError:
+        return default
+
+
+def write(path, text):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8", newline="\\n")
+
+
+def main():
+    deadline = read(SCHEDULE, {}).get("deadline_s")
+    current = read(CURRENT, None)
+    step = int(read(PROGRESS, {}).get("step", 0))
+    now = time.time()
+    state = {"started_at": None, "steps": 0, "fired": False}
+    state.update(read(STATE, {}))
+    if state["started_at"] is None:
+        state["started_at"] = now
+    state["steps"] = int(state["steps"]) + 1
+    elapsed = now - float(state["started_at"])
+    state["elapsed_s"] = elapsed
+    fire = deadline is not None and not state["fired"] and elapsed >= float(deadline)
+    if fire and current is not None:
+        write(STOP_FILE, current["stop_text"])
+        state["fired"] = True
+        state["stopped_at"] = {
+            "step": state["steps"], "elapsed_s": elapsed, "point": current["point"]
+        }
+    write(STATE, json.dumps(state, indent=2))
+    if current is None:
+        return 0
+    own_path = Path(current["datapoint_dir"]) / POINT_STATE
+    own = read(own_path, {"fired": False})
+    own["started_at"] = current["started_at"]
+    own["steps"] = step
+    own["elapsed_s"] = now - float(current["started_at"])
+    if fire:
+        own["fired"] = True
+        own["stopped_at"] = {"step": step, "elapsed_s": own["elapsed_s"]}
+    write(own_path, json.dumps(own, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+'''
+
+
+def _filled(template: str, values: dict[str, object]) -> str:
+    """Return ``template`` with each ``<NAME>`` replaced by the repr of its value."""
+    text = template
+    for name, value in values.items():
+        text = text.replace(f"<{name}>", repr(value))
+    return text
+
+
+def render_job_counter_program(*, total_steps: int, interpreter: str) -> str:
+    """Return the job's counter program, written where the counter registration points.
+
+    Parameters
+    ----------
+    total_steps : int
+        The time steps of every point of the job, summed: the local progress
+        bar reads ``TIME_ITERATIONS`` off the program as it reads a point's.
+    interpreter : str
+        The Python the registration line names, recorded in the program.
+
+    Returns
+    -------
+    str
+        The program text.
+    """
+    return _filled(
+        COUNTER_TEMPLATE,
+        {
+            "TIME_ITERATIONS": int(total_steps),
+            "INTERPRETER": interpreter,
+            "SCHEDULE": JOB_SCHEDULE,
+            "CURRENT": JOB_CURRENT,
+            "PROGRESS": JOB_PROGRESS,
+            "COUNT": UNSTEADY_ACTION_COUNT,
+            "EXPORTS": UNSTEADY_ACTION_SCRIPT,
+            "STOP": WALLTIME_STOP_SCRIPT,
+        },
+    )
+
+
+def render_job_clock_program(*, interpreter: str) -> str:
+    """Return the job's clock program, written where the clock registration points.
+
+    Parameters
+    ----------
+    interpreter : str
+        The Python the registration line names, recorded in the program.
+
+    Returns
+    -------
+    str
+        The program text; its deadline is read from the schedule.
+    """
+    return _filled(
+        CLOCK_TEMPLATE,
+        {
+            "INTERPRETER": interpreter,
+            "SCHEDULE": JOB_SCHEDULE,
+            "CURRENT": JOB_CURRENT,
+            "PROGRESS": JOB_PROGRESS,
+            "STATE": WALLTIME_CLOCK_STATE,
+            "STOP": WALLTIME_STOP_SCRIPT,
+        },
+    )