stepup-queue 1.0.7__tar.gz → 1.1.0__tar.gz

{stepup_queue-1.0.7/stepup_queue.egg-info → stepup_queue-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stepup-queue
-Version: 1.0.7
+Version: 1.1.0
 Summary: StepUp Queue integrates queued jobs into a StepUp workflow.
 Author-email: Toon Verstraelen <toon.verstraelen@ugent.be>
 License-Expression: GPL-3.0-or-later
@@ -24,7 +24,8 @@ Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: stepup<4.0.0,>=3.1.4
+Requires-Dist: path>=16.14.0
+Requires-Dist: stepup<4.0.0,>=3.2.0
 Provides-Extra: dev
 Requires-Dist: psutil; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

{stepup_queue-1.0.7 → stepup_queue-1.1.0}/pyproject.toml

@@ -28,7 +28,8 @@ classifiers = [
 ]
 dependencies = [
     # Ensure changes to these dependencies are reflected in .github/requirements-old.txt
-    "stepup>=3.1.4,<4.0.0",
+    "path>=16.14.0",
+    "stepup>=3.2.0,<4.0.0",
 ]
 dynamic = ["version"]
 
@@ -56,9 +57,10 @@ sbatch = "stepup.queue.actions:sbatch"
 
 [project.entry-points."stepup.tools"]
 canceljobs = "stepup.queue.canceljobs:canceljobs_subcommand"
+removejobs = "stepup.queue.removejobs:removejobs_subcommand"
 
 [tool.pytest.ini_options]
-addopts = "-n auto -W error -W ignore::ResourceWarning"
+addopts = "-n auto --dist worksteal -W error -W ignore::ResourceWarning"
 asyncio_default_fixture_loop_scope = "function"
 
 [tool.ruff]

{stepup_queue-1.0.7 → stepup_queue-1.1.0}/stepup/queue/actions.py

@@ -28,7 +28,7 @@ from path import Path
 
 from stepup.core.worker import WorkThread
 
-from .canceljobs import read_jobid_cluster
+from .canceljobs import read_jobid_cluster_status
 from .sbatch import InpDigestError, submit_once_and_wait
 
 
@@ -48,7 +48,7 @@ def sbatch(argstr: str, work_thread: WorkThread) -> int:
             return submit_once_and_wait(work_thread, args.ext, args.rc)
         # Cancel running job (if any), clean log and resubmit
         path_log = Path("slurmjob.log")
-        job_id, cluster = read_jobid_cluster(path_log)
+        job_id, cluster, _ = read_jobid_cluster_status(path_log)
         if cluster is None:
             work_thread.runsh(f"scancel {job_id}")
         else:

stepup_queue-1.1.0/stepup/queue/canceljobs.py

@@ -0,0 +1,117 @@
+# StepUp Queue integrates queued jobs into a StepUp workflow.
+# © 2025 Toon Verstraelen
+#
+# This file is part of StepUp Queue.
+#
+# StepUp Queue is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 3
+# of the License, or (at your option) any later version.
+#
+# StepUp Queue is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>
+#
+# --
+"""Tool to cancel jobs."""
+
+import argparse
+import subprocess
+import sys
+
+from path import Path
+
+from .sbatch import DONE_STATES, parse_sbatch, read_log, read_status
+from .utils import search_jobs
+
+
+def canceljobs_tool(args: argparse.Namespace):
+    """Iterate over all slurmjob.log files, read the SLURM job IDs, and cancel them."""
+    jobs = {}
+    for path_log in search_jobs(args.paths, verbose=True):
+        try:
+            job_id, cluster, status = read_jobid_cluster_status(path_log)
+        except ValueError as e:
+            print(f"# WARNING: Could not read job ID from {path_log}: {e}")
+            continue
+        if args.all or status not in DONE_STATES:
+            jobs.setdefault(cluster, []).append((job_id, path_log, status))
+
+    all_good = True
+    for cluster, cluster_jobs in jobs.items():
+        if args.commit:
+            # Cancel at most 100 at a time to avoid exceeding the command line length limit,
+            # and to play nice with SLURM.
+            while len(cluster_jobs) > 0:
+                cancel_jobs = cluster_jobs[:100]
+                cluster_jobs[:] = cluster_jobs[100:]
+
+                command_args = ["scancel"]
+                if cluster is not None:
+                    command_args.extend(["-M", cluster])
+                command_args.extend(str(job_id) for job_id, _, _ in cancel_jobs)
+
+                # Using subprocess.run for better control and error handling
+                print(" ".join(command_args))
+                result = subprocess.run(command_args, check=False)
+                all_good &= result.returncode == 0
+        else:
+            for job_id, path_log, status in cluster_jobs:
+                command = "scancel"
+                if cluster is not None:
+                    command += f" -M {cluster}"
+                command += f" {job_id}  # {path_log} {status}"
+                print(command)
+    if not all_good:
+        print("Some jobs could not be cancelled. See messages above.")
+        sys.exit(1)
+
+
+def read_jobid_cluster_status(path_log: str) -> tuple[int, str | None, str | None]:
+    """Read the job ID, cluster, and job status from the job log file."""
+    lines = read_log(path_log, False)
+    if len(lines) < 1:
+        raise ValueError(f"Incomplete file: {path_log}.")
+    words = lines[0].split()
+    if len(words) != 3:
+        raise ValueError(f"Could not read job ID from first status line: {lines[0]}")
+    _, status, job_id_cluster = words
+    if status != "Submitted":
+        raise ValueError(f"No 'Submitted' on first status line: {lines[0]}")
+    job_id, cluster = parse_sbatch(job_id_cluster)
+    status = read_status(lines[-1:])[1]
+    return job_id, cluster, status
+
+
+def canceljobs_subcommand(subparser: argparse.ArgumentParser) -> callable:
+    parser = subparser.add_parser(
+        "canceljobs",
+        help="Cancel running jobs in the current StepUp workflow.",
+    )
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        default=[Path(".")],
+        type=Path,
+        help="Paths to the jobs to cancel. Subdirectories are searched recursively. "
+        "If not specified, the current directory is used.",
+    )
+    parser.add_argument(
+        "-c",
+        "--commit",
+        action="store_true",
+        default=False,
+        help="Execute the cancellation of jobs instead of only showing what would be done.",
+    )
+    parser.add_argument(
+        "-a",
+        "--all",
+        action="store_true",
+        default=False,
+        help="Select all jobs, including the ones that seem to be done already.",
+    )
+    return canceljobs_tool

stepup_queue-1.1.0/stepup/queue/removejobs.py

@@ -0,0 +1,99 @@
+# StepUp Queue integrates queued jobs into a StepUp workflow.
+# © 2025 Toon Verstraelen
+#
+# This file is part of StepUp Queue.
+#
+# StepUp Queue is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 3
+# of the License, or (at your option) any later version.
+#
+# StepUp Queue is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>
+#
+# --
+"""Tool to remove failed jobs."""
+
+import argparse
+import shutil
+
+from path import Path
+
+from .sbatch import read_log, read_status
+from .utils import search_jobs
+
+FAILED_STATES = {
+    "BOOT_FAIL",
+    "CANCELLED",
+    "DEADLINE",
+    "FAILED",
+    "NODE_FAIL",
+    "OUT_OF_MEMORY",
+    "PREEMPTED",
+    "TIMEOUT",
+    "LAUNCH_FAILED",
+    "RECONFIG_FAIL",
+    "REVOKED",
+    "STOPPED",
+}
+
+
+def removejobs_tool(args: argparse.Namespace):
+    """Iterate over all slurmjob.log files and remove their parent job directories."""
+    jobs = []
+    for path_log in search_jobs(args.paths, verbose=True):
+        try:
+            status = read_last_status(path_log)
+        except ValueError as e:
+            print(f"Warning: Could not read job status from {path_log}: {e}")
+            status = None
+        if args.all or status in FAILED_STATES:
+            jobs.append((path_log, status))
+
+    for path_log, status in jobs:
+        command = f"rm -rf {path_log.parent}  # state={status}"
+        print(command)
+        if args.commit:
+            shutil.rmtree(path_log.parent)
+
+
+def read_last_status(path_log: str) -> str | None:
+    """Read the last job status from the job log file."""
+    lines = read_log(path_log, False)
+    return read_status(lines[-1:])[1]
+
+
+def removejobs_subcommand(subparser: argparse.ArgumentParser) -> callable:
+    parser = subparser.add_parser(
+        "removejobs",
+        help="Remove directories of failed (and optionally all completed) jobs "
+        "in the current StepUp workflow.",
+    )
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        default=[Path(".")],
+        type=Path,
+        help="Paths to the jobs to remove. Subdirectories are searched recursively. "
+        "If not specified, the current directory is used.",
+    )
+    parser.add_argument(
+        "-c",
+        "--commit",
+        action="store_true",
+        default=False,
+        help="Execute the removal of jobs instead of only showing what would be done.",
+    )
+    parser.add_argument(
+        "-a",
+        "--all",
+        action="store_true",
+        default=False,
+        help="Remove all jobs, not only failed jobs.",
+    )
+    return removejobs_tool

{stepup_queue-1.0.7 → stepup_queue-1.1.0}/stepup/queue/sbatch.py

@@ -68,25 +68,26 @@ def submit_once_and_wait(
         The return code of the job.
         0 if successful, 1 if the job failed.
     """
-    # Read previously logged steps
+    # Read previously logged job states
     path_log = Path("slurmjob.log")
     previous_lines = read_log(path_log, validate_inp_digest) if path_log.is_file() else []
 
-    # Go through or skip steps.
-    submit_time, status = read_step(previous_lines)
+    # Go through or skip states.
+    submit_time, status = read_status(previous_lines)
     if status is None:
         # A new job must be submitted.
         submit_time = time.time()
         sbatch_stdout = submit_job(work_thread, job_ext, sbatch_rc)
         # Create a new log file after submitting the job.
         _init_log(path_log)
-        log_step(path_log, f"Submitted {sbatch_stdout}")
+        log_status(path_log, f"Submitted {sbatch_stdout}")
         rndsleep()
     else:
-        # The first step, if present in the log, is the submission.
-        step, sbatch_stdout = status.split()
-        if step != "Submitted":
-            raise ValueError(f"Expected 'Submitted' in log, found '{step}'")
+        # The first state, if present in the log, is the submission.
+        words = status.split()
+        if len(words) != 2 or words[0] != "Submitted":
+            raise ValueError(f"Expected 'Submitted' in log, found '{status}'")
+        sbatch_stdout = words[1]
     jobid, cluster = parse_sbatch(sbatch_stdout)
 
     # Wait for the job to complete
@@ -127,7 +128,7 @@ def read_log(path_log: str, do_inp_digest: bool = True) -> list[str]:
         try:
             inp_digest = next(f).strip()
         except StopIteration as exc:
-            raise ValueError("Existing has no input digest.") from exc
+            raise ValueError("Existing log file has no input digest.") from exc
         if do_inp_digest:
             check_log_inp_digest(inp_digest)
         for line in f:
@@ -136,6 +137,14 @@ def read_log(path_log: str, do_inp_digest: bool = True) -> list[str]:
     return lines
 
 
+def check_log_version(line: str):
+    """Validate the log version, abort if there is a mismatch."""
+    if line != FIRST_LINE:
+        raise ValueError(
+            f"The first line of the log is wrong. Expected: '{FIRST_LINE}' Found: '{line}'"
+        )
+
+
 def _init_log(path_log: str):
     """Initialize a new log file."""
     inp_digest = os.getenv("STEPUP_STEP_INP_DIGEST")
@@ -147,7 +156,7 @@ def _init_log(path_log: str):
 
 
 # From: https://slurm.schedmd.com/job_state_codes.html
-KNOWN_JOB_STATES = [
+KNOWN_JOB_STATES = {
     # -- Job states
     # done
     "BOOT_FAIL",
@@ -187,7 +196,23 @@ KNOWN_JOB_STATES = [
     # to be ignored (same as waiting or running), must not be logged
     "invalid",
     "unlisted",
-]
+}
+
+DONE_STATES = {
+    "BOOT_FAIL",
+    "CANCELLED",
+    "COMPLETED",
+    "DEADLINE",
+    "FAILED",
+    "NODE_FAIL",
+    "OUT_OF_MEMORY",
+    "PREEMPTED",
+    "TIMEOUT",
+    "LAUNCH_FAILED",
+    "RECONFIG_FAIL",
+    "REVOKED",
+    "STOPPED",
+}
 
 
 def _read_or_poll_status(
@@ -226,36 +251,22 @@ def _read_or_poll_status(
     done
         True when the waiting is over.
     """
-    # First try to replay previously logged steps
-    _, status = read_step(previous_lines)
+    # First try to replay previously logged states
+    _, status = read_status(previous_lines)
     if status is None:
-        # All previously logged steps are processed.
+        # All previously logged states are processed.
         # Call sacct and parse its response.
         rndsleep()
         _, status = get_status(work_thread, jobid, cluster)
         # Log only if the status changed, and is not invalid or unlisted.
         # These two statuses are (potentially) transient and should not be logged.
         if status != last_status and status not in ["invalid", "unlisted"]:
-            log_step(path_log, status)
+            log_status(path_log, status)
     if status not in KNOWN_JOB_STATES:
         raise ValueError(f"Unknown job status '{status}' obtained from scheduler.")
 
     # Determine if the job is done
-    done = status in [
-        "BOOT_FAIL",
-        "CANCELLED",
-        "COMPLETED",
-        "DEADLINE",
-        "FAILED",
-        "NODE_FAIL",
-        "OUT_OF_MEMORY",
-        "PREEMPTED",
-        "TIMEOUT",
-        "LAUNCH_FAILED",
-        "RECONFIG_FAIL",
-        "REVOKED",
-        "STOPPED",
-    ]
+    done = status in DONE_STATES
     if status == "unlisted" and time.time() > submit_time + UNLISTED_TIMEOUT:
         # If the job remains unlisted for too long, we declare it failed.
         # This prevents an infinite loop if the job ID was wrong or purged.
@@ -264,14 +275,6 @@ def _read_or_poll_status(
     return status, done
 
 
-def check_log_version(line: str):
-    """Validate the log version, abort if there is a mismatch."""
-    if line != FIRST_LINE:
-        raise ValueError(
-            f"The first line of the log is wrong. Expected: '{FIRST_LINE}' Found: '{line}'"
-        )
-
-
 class InpDigestError(ValueError):
     """The input digest in the log file does not match the one in the environment."""
 
@@ -288,15 +291,15 @@ def check_log_inp_digest(line: str):
         )
 
 
-def read_step(lines: list[str]) -> str | None:
-    """Read a step from the log file."""
+def read_status(lines: list[str]) -> tuple[float | None, str | None]:
+    """Read a status from the log file."""
     if len(lines) == 0:
         return None, None
     line = lines.pop(0)
     words = line.split(maxsplit=1)
     if len(words) != 2:
-        raise ValueError(f"Expected a step in log but found line '{line}'.")
-    return datetime.fromisoformat(words[0]).timestamp(), words[1]
+        raise ValueError(f"Expected a status in log but found line '{line}'.")
+    return datetime.fromisoformat(words[0]).timestamp(), words[1].strip()
 
 
 def rndsleep():
@@ -316,10 +319,16 @@ echo $RETURN_CODE > slurmjob.ret
 exit $RETURN_CODE
 """
 
-RE_SBATCH_STDOUT = re.compile(r"#\s*SBATCH\b.*(--output|-o)")
-RE_SBATCH_STDERR = re.compile(r"#\s*SBATCH\b.*(--error|-e)")
-RE_SBATCH_ARRAY = re.compile(r"#\s*SBATCH\b.*(--array|-a)")
-RE_SBATCH = re.compile(r"#\s*SBATCH\b")
+RE_SBATCH_STDOUT = re.compile(r"\s*#\s*SBATCH\b.*(--output|-o)\b")
+RE_SBATCH_STDERR = re.compile(r"\s*#\s*SBATCH\b.*(--error|-e)\b")
+RE_SBATCH_ARRAY = re.compile(r"\s*#\s*SBATCH\b.*(--array|-a)\b")
+RE_SBATCH = re.compile(r"\s*#\s*SBATCH\b")
+UNSUPPORTED_DIRECTIVES = [
+    re.compile(r"\s*#\s*PBS\b"),
+    re.compile(r"\s*#\s*BSUB\b"),
+    re.compile(r"\s*#\s*COBALT\b"),
+    re.compile(r"\s*#\$"),
+]
 
 
 def submit_job(work_thread: WorkThread, job_ext: str, sbatch_rc: str | None = None) -> str:
@@ -344,6 +353,12 @@ def submit_job(work_thread: WorkThread, job_ext: str, sbatch_rc: str | None = No
                 raise ValueError("StepUp Queue does not support array jobs. (Found -a or --array)")
             if RE_SBATCH.match(line):
                 sbatch_header.append(line.strip())
+            else:
+                for pattern in UNSUPPORTED_DIRECTIVES:
+                    if pattern.match(line):
+                        raise ValueError(
+                            f"Detected unsupported scheduler directive: {line.strip()}."
+                        )
         sbatch_header = "\n".join(sbatch_header)
 
     command = "sbatch --parsable -o slurmjob.out -e slurmjob.err"
@@ -362,11 +377,11 @@ def submit_job(work_thread: WorkThread, job_ext: str, sbatch_rc: str | None = No
     raise RuntimeError(f"sbatch failed {SBATCH_RETRY_NUM} times. Giving up.")
 
 
-def log_step(path_log: Path, step: str):
-    """Write a step to the log."""
+def log_status(path_log: Path, status: str):
+    """Write a status to the log."""
     dt = datetime.now().isoformat()
     with open(path_log, "a") as f:
-        line = f"{dt} {step}"
+        line = f"{dt} {status}"
         f.write(f"{line}\n")
 
 
@@ -380,7 +395,7 @@ def parse_sbatch(stdout: str) -> tuple[int, str | None]:
     raise ValueError(f"Cannot parse sbatch output: {stdout}")
 
 
-def get_status(work_thread: WorkThread, jobid: int, cluster: str | None) -> str:
+def get_status(work_thread: WorkThread, jobid: int, cluster: str | None) -> tuple[float, str]:
     """Load cached sacct output or run sacct if outdated.
 
     Parameters
@@ -394,6 +409,8 @@ def get_status(work_thread: WorkThread, jobid: int, cluster: str | None) -> str:
 
     Returns
     -------
+    timestamp
+        The time when the status was last retrieved.
     status
         A status reported by sacct,
         or `invalid` if sacct failed (retry sacct later),
@@ -401,7 +418,7 @@ def get_status(work_thread: WorkThread, jobid: int, cluster: str | None) -> str:
     """
     # Load cached output or run again
     command = f"sacct -o 'jobid,state' -PXn -S {SACCT_START}"
-    path_out = Path(os.getenv("ROOT")) / ".stepup/queue"
+    path_out = Path(os.getenv("ROOT", ".")) / ".stepup/queue"
     if cluster is None:
         path_out /= "sbatch_wait_sacct.out"
     else:
@@ -472,11 +489,14 @@ def make_cache_header(cache_time: float, returncode: int):
     """Prepare a header for the file containing the cached output of a cached execution."""
     iso = datetime.fromtimestamp(cache_time).isoformat()
     if len(iso) != 26:
-        raise AssertionError
-    return f"v1 datetime={iso} returncode={returncode:+04d}\n"
+        raise RuntimeError("ISO datetime string has unexpected length.")
+    returnstr = f"{returncode:+04d}"
+    if len(returnstr) != 4:
+        raise RuntimeError("Return code string has unexpected length.")
+    return f"v1 datetime={iso} returncode={returnstr}\n"
 
 
-def parse_cache_header(header: str) -> tuple[float, int]:
+def parse_cache_header(header: str) -> tuple[float, int] | tuple[None, None]:
     """Read the header of a cached output and return the timestamp and returncode."""
     if len(header) == 0 or header == "\x00" * CACHE_HEADER_LENGTH:
         return None, None
@@ -504,7 +524,7 @@ def parse_sacct_out(sacct_out: str, jobid: int) -> str:
 
     Returns
     -------
-    jobstate
+    status
         The status of the job. This can be:
 
         - Any of the SLURM job states.

stepup_queue-1.1.0/stepup/queue/utils.py

@@ -0,0 +1,58 @@
+# StepUp Queue integrates queued jobs into a StepUp workflow.
+# © 2025 Toon Verstraelen
+#
+# This file is part of StepUp Queue.
+#
+# StepUp Queue is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 3
+# of the License, or (at your option) any later version.
+#
+# StepUp Queue is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>
+#
+# --
+"""Utility functions for the StepUp queue module."""
+
+from itertools import chain
+
+from path import Path
+
+__all__ = ("search_jobs",)
+
+
+def search_jobs(paths: list[Path], verbose: bool = False) -> list[Path]:
+    """Recursively search for slurmjob.log files in the specified directories.
+
+    Parameters
+    ----------
+    paths
+        List of directories to search in.
+    verbose
+        Whether to print warnings when paths do not exist or are not directories.
+
+    Returns
+    -------
+    paths_log
+        Sorted list of found slurmjob.log file paths.
+    """
+    paths_log = set()
+    for path in paths:
+        if not path.exists():
+            if verbose:
+                print(f"# WARNING: Path {path} does not exist.")
+            continue
+        if not path.is_dir():
+            if verbose:
+                print(f"# WARNING: Path {path} is not a directory.")
+            continue
+        for path_sub in chain([path], path.walkdirs()):
+            path_log = path_sub / "slurmjob.log"
+            if path_log.is_file():
+                paths_log.add(path_log)
+    return sorted(paths_log)

{stepup_queue-1.0.7 → stepup_queue-1.1.0/stepup_queue.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stepup-queue
-Version: 1.0.7
+Version: 1.1.0
 Summary: StepUp Queue integrates queued jobs into a StepUp workflow.
 Author-email: Toon Verstraelen <toon.verstraelen@ugent.be>
 License-Expression: GPL-3.0-or-later
@@ -24,7 +24,8 @@ Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: stepup<4.0.0,>=3.1.4
+Requires-Dist: path>=16.14.0
+Requires-Dist: stepup<4.0.0,>=3.2.0
 Provides-Extra: dev
 Requires-Dist: psutil; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

{stepup_queue-1.0.7 → stepup_queue-1.1.0}/stepup_queue.egg-info/SOURCES.txt

@@ -6,7 +6,9 @@ stepup/queue/__init__.py
 stepup/queue/actions.py
 stepup/queue/api.py
 stepup/queue/canceljobs.py
+stepup/queue/removejobs.py
 stepup/queue/sbatch.py
+stepup/queue/utils.py
 stepup_queue.egg-info/PKG-INFO
 stepup_queue.egg-info/SOURCES.txt
 stepup_queue.egg-info/dependency_links.txt

{stepup_queue-1.0.7 → stepup_queue-1.1.0}/stepup_queue.egg-info/entry_points.txt

@@ -3,3 +3,4 @@ sbatch = stepup.queue.actions:sbatch
 
 [stepup.tools]
 canceljobs = stepup.queue.canceljobs:canceljobs_subcommand
+removejobs = stepup.queue.removejobs:removejobs_subcommand

{stepup_queue-1.0.7 → stepup_queue-1.1.0}/stepup_queue.egg-info/requires.txt

@@ -1,4 +1,5 @@
-stepup<4.0.0,>=3.1.4
+path>=16.14.0
+stepup<4.0.0,>=3.2.0
 
 [dev]
 psutil

stepup_queue-1.0.7/stepup/queue/canceljobs.py

@@ -1,101 +0,0 @@
-# StepUp Queue integrates queued jobs into a StepUp workflow.
-# © 2025 Toon Verstraelen
-#
-# This file is part of StepUp Queue.
-#
-# StepUp Queue is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 3
-# of the License, or (at your option) any later version.
-#
-# StepUp Queue is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <http://www.gnu.org/licenses/>
-#
-# --
-"""Tool to cancel jobs."""
-
-import argparse
-import subprocess
-
-from path import Path
-
-from .sbatch import FIRST_LINE, parse_sbatch
-
-
-def canceljobs_tool(args: argparse.Namespace) -> int:
-    if len(args.paths) == 0:
-        args.paths = [Path(".")]
-
-    # Iterate over all slurmjob.log files in the specified directories, and kill them.
-    job_ids = {}
-    for path in args.paths:
-        if not path.exists():
-            print(f"Path {path} does not exist.")
-            continue
-        if not path.is_dir():
-            print(f"Path {path} is not a directory.")
-            continue
-        print(f"Searching recursively in {path}")
-        paths_log = list(path.glob("**/slurmjob.log"))
-        if (path / "slurmjob.log").is_file():
-            paths_log.append(path / "slurmjob.log")
-        for job_log in paths_log:
-            try:
-                job_id, cluster = read_jobid_cluster(job_log)
-                msg = f"Found job {job_id} in {job_log}"
-                if cluster is not None:
-                    msg += f" on cluster {cluster}"
-                print(msg)
-                job_ids.setdefault(cluster, []).append(job_id)
-            except ValueError as e:
-                print(f"Warning: Could not read job ID from {job_log}: {e}")
-                continue
-
-    returncode = 0
-    # Cancel at most 100 at a time to avoid exceeding the command line length limit,
-    # and to play nice with SLURM.
-    for cluster, cluster_job_ids in job_ids.items():
-        while len(cluster_job_ids) > 0:
-            cancel_ids = cluster_job_ids[:100]
-            cluster_job_ids[:] = cluster_job_ids[100:]
-
-            command_args = ["scancel"]
-            if cluster is not None:
-                command_args.extend(["-M", cluster])
-            command_args.extend(str(job_id) for job_id in cancel_ids)
-
-            # Using subprocess.run for better control and error handling
-            print(f"Executing: {' '.join(command_args)}")
-            result = subprocess.run(command_args, check=False)
-            if result.returncode != 0:
-                returncode = 1
-    return returncode
-
-
-def read_jobid_cluster(job_log: Path) -> tuple[str, str]:
-    """Read the job ID and cluster from the job log file."""
-    with open(job_log) as f:
-        lines = f.readlines()
-        if len(lines) < 3 or lines[0][:-1] != FIRST_LINE:
-            raise ValueError(f"Invalid first line in {job_log}.")
-        return parse_sbatch(lines[2].split()[-1])
-
-
-def canceljobs_subcommand(subparser: argparse.ArgumentParser) -> callable:
-    parser = subparser.add_parser(
-        "canceljobs",
-        help="Cancel running jobs in the current StepUp workflow.",
-    )
-    parser.add_argument(
-        "paths",
-        nargs="*",
-        type=Path,
-        help="Paths to the jobs to cancel. Subdirectories are searched recursively. "
-        "If not specified, the current directory is used.",
-    )
-    return canceljobs_tool