slurm-script-generator 0.1__py3-none-any.whl

slurm_script_generator/main.py

@@ -0,0 +1,254 @@
+import argparse
+import json
+
+import slurm_script_generator.sbatch_parser as sbatch_parser
+from slurm_script_generator.sbatch import register_to_parser
+
+
+def add_misc_options(parser):
+
+    parser.add_argument(
+        "--line-length",
+        dest="line_length",
+        type=int,
+        default=40,
+        metavar="LINE_LENGHT",
+        help="line length before start of comment",
+    )
+
+    parser.add_argument(
+        "--modules",
+        dest="modules",
+        type=str,
+        nargs="+",
+        default=[],
+        metavar="MODULES",
+        help="Modules to load (e.g., --modules mod1 mod2 mod3)",
+    )
+
+    parser.add_argument(
+        "--vars",
+        dest="vars",
+        type=str,
+        nargs="+",
+        default=[],
+        metavar="ENVIRONMENT_VARS",
+        help="Environment variables to export (e.g., --vars VAR1=a VAR2=b)",
+    )
+
+    parser.add_argument(
+        "--venv",
+        dest="venv",
+        type=str,
+        default=None,
+        metavar="VENV",
+        help="virtual environment to load with `source VENV/bin/activate`",
+    )
+
+    parser.add_argument(
+        "--printenv",
+        action="store_true",
+        dest="printenv",
+        help="print all environment variables",
+    )
+
+    parser.add_argument(
+        "--print-self",
+        action="store_true",
+        dest="printself",
+        help="print the batch script in the batch script",
+    )
+
+    parser.add_argument(
+        "--likwid",
+        action="store_true",
+        dest="likwid",
+        help="Set up likwid environment variables",
+    )
+
+    parser.add_argument(
+        "--input",
+        dest="input",
+        type=str,
+        default=None,
+        metavar="INPUT_PATH",
+        help="path to input json file",
+    )
+
+    parser.add_argument(
+        "--output",
+        dest="output",
+        type=str,
+        default=None,
+        metavar="OUTPUT_PATH",
+        help="json path to save slurm batch script to",
+    )
+
+    parser.add_argument(
+        "--export-json",
+        dest="export_json",
+        type=str,
+        default=None,
+        metavar="JSON_PATH",
+        help="path to export yaml for generating the slurm script to",
+    )
+    return parser
+
+
+def add_line(line, comment="", line_length=40):
+    if len(line) > line_length:
+        return f"{line} # {comment}\n"
+    else:
+        return f"{line} {' ' * (line_length - len(line))}# {comment}\n"
+
+
+def export_json(args_dict, path):
+    with open(path, "w") as f:
+        json.dump(args_dict, f)
+
+
+def read_yaml(path):
+    with open(path, "r") as f:
+        return json.load(f)
+
+
+def generate_script(args_dict, print_script=True):
+
+    line_length = args_dict.get("line_length", 60)
+
+    # Start generating the SLURM batch script
+    script = "#!/bin/bash\n"
+    script += "#" * (line_length + 2) + "\n"
+
+    for pragma in sbatch_parser.pragmas:
+        # print(f"{pragma.dest = } {list(args_dict.keys()) = }")
+        if pragma.dest in list(args_dict.keys()):
+            # print(f"{pragma.dest = }")
+            val = args_dict.get(pragma.dest)
+            if val not in [None, False]:
+                script += add_line(
+                    f"#SBATCH --{pragma.sbatch_flag} {val}",
+                    pragma.help,
+                    line_length=line_length,
+                )
+    script += "#" * (line_length + 2) + "\n\n"
+
+    vars = args_dict.get("vars", [])
+    if len(vars) > 0:
+        for var in vars:
+            script += add_line(
+                f"export {var}",
+                "Set environment variable",
+                line_length=line_length,
+            )
+
+    if args_dict.get("printself", False):
+        script += add_line(
+            f"cat $0",
+            "print this batch script",
+            line_length=line_length,
+        )
+
+    # Load modules
+    if len(args_dict.get("modules", [])) > 0:
+        script += add_line(
+            "module purge",
+            "Purge modules",
+            line_length=line_length,
+        )
+        script += add_line(
+            f"module load {' '.join(args_dict.get('modules'))}",
+            "modules",
+            line_length=line_length,
+        )
+        script += add_line(
+            "module list",
+            "List loaded modules",
+            line_length=line_length,
+        )
+
+    if args_dict.get("venv", None) is not None:
+        script += add_line(
+            f"source {args_dict.get('venv')}/bin/activate",
+            "virtual environment",
+            line_length=line_length,
+        )
+
+    if args_dict.get("printenv", False):
+        script += add_line(
+            "printenv",
+            "print environment variables",
+            line_length=line_length,
+        )
+
+    if args_dict.get("likwid", False):
+        script += add_line(
+            "LIKWID_PREFIX=$(realpath $(dirname $(which likwid-topology))/..)",
+            "Set LIKWID prefix",
+            line_length=line_length,
+        )
+
+        script += add_line(
+            "export LD_LIBRARY_PATH=$LIKWID_PREFIX/lib",
+            "Set LD_LIBRARY_PATH for LIKWID",
+            line_length=line_length,
+        )
+
+        script += add_line(
+            "likwid-topology > likwid-topology.txt",
+            "Save LIKWID topology information",
+            line_length=line_length,
+        )
+        script += add_line(
+            "likwid-topology -g > likwid-topology-g.txt",
+            "Save graphical LIKWID topology information",
+            line_length=line_length,
+        )
+
+        script += "\n"
+    if args_dict.get("export_json", None) is not None:
+        path = args_dict.pop("export_json")
+        export_json(args_dict=args_dict, path=path)
+    if args_dict.get("output") is not None:
+        with open(args_dict.get("output"), "w") as f:
+            f.write(script)
+
+    if print_script:
+        print(script)
+
+    return script
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Slurm job submission options",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    for p in sbatch_parser.pragmas:
+        register_to_parser(parser, p)
+
+    # slurm_options_dict = {}
+    # for action in parser._actions:
+    #     slurm_options_dict[action.dest] = action.help
+
+    add_misc_options(parser=parser)
+
+    sbatch_args = parser.parse_args()
+
+    if sbatch_args.input is not None:
+        args_dict = read_yaml(sbatch_args.input)
+    else:
+        args_dict = {}
+    for arg in sbatch_args.__dict__:
+        val = sbatch_args.__dict__[arg]
+        if val is not None and val is not False:
+            if isinstance(val, list) and len(val) == 0:
+                continue
+            args_dict.update({arg: val})
+
+    generate_script(args_dict)
+
+
+if __name__ == "__main__":
+    main()

slurm_script_generator/sbatch.py

@@ -0,0 +1,71 @@
+from argparse import ArgumentParser
+from dataclasses import dataclass, field
+from typing import Any, Callable, List, Optional
+
+
+@dataclass
+class Flag:
+    name: str
+    help: str
+
+
+@dataclass
+class Pragma:
+    flags: List[Flag]  # e.g. ['-A', '--account']
+    dest: str  # e.g. 'account'
+    example: Optional[str] = None
+    help: Optional[str] = ""  # e.g. 'charge job to specified account'
+    nargs: Optional[str] = None
+    const: Optional[int] = None
+    choices: Optional[list] = None
+    metavar: Optional[str] = None  # e.g. 'NAME'
+    action: Optional[str] = None  # e.g. 'store_true', 'store_false'
+    default: Optional[str] = None  # Optional default value
+    type: Optional[Callable[[str], Any]] = str  # e.g. str, int, float, etc.
+    env_var: Optional[str] = None  # Environment variable
+
+    def add_argument_to_parser(self, parser: ArgumentParser):
+
+        kwargs = {
+            "dest": self.dest,
+            "type": self.type,
+            "default": self.default,
+            "help": self.help,
+        }
+        parser.add_argument(
+            self.flags[0].name,
+            **kwargs,
+        )
+
+    @property
+    def sbatch_flag(self):
+        return self.dest.replace("_", "-")
+
+
+def register_to_parser(parser, pragma: Pragma):
+    kwargs = {"dest": pragma.dest, "help": pragma.help}
+    if pragma.metavar:
+        kwargs["metavar"] = pragma.metavar
+    if pragma.action:
+        kwargs["action"] = pragma.action
+    if pragma.default:
+        kwargs["default"] = pragma.default
+
+    parser.add_argument(*pragma.flags, **kwargs)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Slurm job submission options",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    p = Pragma(flags=["--nodes"], dest="nodes", help="Number of nodes", type=str)
+
+    register_to_parser(parser, p)
+
+    sbatch_args = parser.parse_args()
+
+    print(p)

slurm_script_generator/sbatch_parser.py

@@ -0,0 +1,572 @@
+import argparse
+
+from slurm_script_generator.sbatch import Pragma
+
+pragmas = [
+    Pragma(
+        flags=["-A", "--account"],
+        dest="account",
+        metavar="NAME",
+        help="charge job to specified account",
+        example="myacct",
+    ),
+    Pragma(
+        flags=["-b", "--begin"],
+        dest="begin",
+        metavar="TIME",
+        help="defer job until HH:MM MM/DD/YY",
+    ),
+    Pragma(
+        flags=["--bell"],
+        dest="bell",
+        action="store_true",
+        help="ring the terminal bell when the job is allocated",
+    ),
+    Pragma(
+        flags=["--no-bell"],
+        dest="bell",
+        action="store_false",
+        help="do NOT ring the terminal bell",
+    ),
+    Pragma(
+        flags=["--bb"],
+        dest="burst_buffer",
+        metavar="SPEC",
+        help="burst buffer specifications",
+    ),
+    Pragma(
+        flags=["--bbf"],
+        dest="bb_file",
+        metavar="FILE_NAME",
+        help="burst buffer specification file",
+    ),
+    Pragma(
+        flags=["-c", "--cpus-per-task"],
+        dest="cpus_per_task",
+        type=int,
+        metavar="NCPUS",
+        help="number of cpus required per task",
+        example=16,
+    ),
+    Pragma(
+        flags=["--comment"],
+        dest="comment",
+        metavar="NAME",
+        help="arbitrary comment",
+    ),
+    Pragma(
+        flags=["--container"],
+        dest="container",
+        metavar="PATH",
+        help="Path to OCI container bundle",
+    ),
+    Pragma(
+        flags=["--container-id"],
+        dest="container_id",
+        metavar="ID",
+        help="OCI container ID",
+    ),
+    Pragma(
+        flags=["--cpu-freq"],
+        dest="cpu_freq",
+        metavar="MIN[-MAX[:GOV]]",
+        help="requested cpu frequency (and governor)",
+    ),
+    Pragma(
+        flags=["--delay-boot"],
+        dest="delay_boot",
+        type=int,
+        metavar="MINS",
+        help="delay boot for desired node features",
+    ),
+    Pragma(
+        flags=["-d", "--dependency"],
+        dest="dependency",
+        metavar="TYPE:JOBID[:TIME]",
+        help="defer job until condition on jobid is satisfied",
+    ),
+    Pragma(
+        flags=["--deadline"],
+        dest="deadline",
+        metavar="TIME",
+        help="remove the job if no ending possible before this deadline",
+    ),
+    Pragma(
+        flags=["-D", "--chdir"],
+        dest="chdir",
+        metavar="PATH",
+        help="change working directory",
+    ),
+    Pragma(
+        flags=["--get-user-env"],
+        dest="get_user_env",
+        action="store_true",
+        help="used by Moab. See srun man page",
+    ),
+    Pragma(
+        flags=["--gres"],
+        dest="gres",
+        metavar="LIST",
+        type=lambda s: s.split(","),
+        help="required generic resources",
+    ),
+    Pragma(
+        flags=["--gres-flags"],
+        dest="gres_flags",
+        metavar="OPTS",
+        help="flags related to GRES management",
+    ),
+    Pragma(
+        flags=["-H", "--hold"],
+        dest="hold",
+        action="store_true",
+        help="submit job in held state",
+    ),
+    Pragma(
+        flags=["-I", "--immediate"],
+        dest="immediate",
+        nargs="?",
+        const=0,
+        metavar="SECS",
+        type=int,
+        help='exit if resources not available in "secs"',
+    ),
+    Pragma(
+        flags=["-J", "--job-name"],
+        dest="job_name",
+        metavar="NAME",
+        help="name of job",
+        example="my_job",
+    ),
+    Pragma(
+        flags=["-k", "--no-kill"],
+        dest="no_kill",
+        action="store_true",
+        help="do not kill job on node failure",
+    ),
+    Pragma(
+        flags=["-K", "--kill-command"],
+        dest="kill_command",
+        nargs="?",
+        const="TERM",
+        metavar="SIGNAL",
+        help="signal to send terminating job",
+    ),
+    Pragma(
+        flags=["-L", "--licenses"],
+        dest="licenses",
+        metavar="NAMES",
+        type=lambda s: s.split(","),
+        help="required license, comma separated",
+    ),
+    Pragma(
+        flags=["-M", "--clusters"],
+        dest="clusters",
+        metavar="NAMES",
+        type=lambda s: s.split(","),
+        help="Comma separated list of clusters to issue commands to",
+    ),
+    Pragma(
+        flags=["-m", "--distribution"],
+        dest="distribution",
+        metavar="TYPE",
+        choices=["block", "cyclic", "arbitrary"],
+        help="distribution method for processes to nodes",
+    ),
+    Pragma(
+        flags=["--mail-type"],
+        dest="mail_type",
+        metavar="TYPE",
+        choices=["BEGIN", "END", "FAIL", "ALL"],
+        help="notify on state change",
+        example="ALL",
+    ),
+    Pragma(
+        flags=["--mail-user"],
+        dest="mail_user",
+        metavar="USER",
+        help="who to send email notification for job state changes",
+        example="example@email.com",
+    ),
+    Pragma(
+        flags=["--mcs-label"],
+        dest="mcs_label",
+        metavar="MCS",
+        help="mcs label if mcs plugin mcs/group is used",
+    ),
+    Pragma(
+        flags=["-n", "--ntasks"],
+        dest="ntasks",
+        type=int,
+        metavar="N",
+        help="number of processors required",
+        example=16,
+    ),
+    Pragma(
+        flags=["--nice"],
+        dest="nice",
+        type=int,
+        metavar="VALUE",
+        help="decrease scheduling priority by value",
+        example=1,
+    ),
+    Pragma(
+        flags=["-N", "--nodes"],
+        dest="nodes",
+        metavar="NODES",
+        help="number of nodes on which to run",
+        example=2,
+    ),
+    Pragma(
+        flags=["--ntasks-per-node"],
+        dest="ntasks_per_node",
+        type=int,
+        metavar="N",
+        help="number of tasks to invoke on each node",
+        example=16,
+    ),
+    Pragma(
+        flags=["--oom-kill-step"],
+        dest="oom_kill_step",
+        nargs="?",
+        const=1,
+        type=int,
+        metavar="0|1",
+        help="set the OOMKillStep behaviour",
+    ),
+    Pragma(
+        flags=["-O", "--overcommit"],
+        dest="overcommit",
+        action="store_true",
+        help="overcommit resources",
+    ),
+    Pragma(
+        flags=["--power"],
+        dest="power",
+        metavar="FLAGS",
+        help="power management options",
+    ),
+    Pragma(
+        flags=["--priority"],
+        dest="priority",
+        metavar="VALUE",
+        type=int,
+        help="set the priority of the job",
+    ),
+    Pragma(
+        flags=["--profile"],
+        dest="profile",
+        metavar="VALUE",
+        help="enable acct_gather_profile for detailed data",
+    ),
+    Pragma(
+        flags=["-p", "--partition"],
+        dest="partition",
+        metavar="PARTITION",
+        help="partition requested",
+    ),
+    Pragma(flags=["-q", "--qos"], dest="qos", metavar="QOS", help="quality of service"),
+    Pragma(
+        flags=["-Q", "--quiet"],
+        dest="quiet",
+        action="store_true",
+        help="quiet mode (suppress informational messages)",
+    ),
+    Pragma(
+        flags=["--reboot"],
+        dest="reboot",
+        action="store_true",
+        help="reboot compute nodes before starting job",
+    ),
+    Pragma(
+        flags=["-s", "--oversubscribe"],
+        dest="oversubscribe",
+        action="store_true",
+        help="oversubscribe resources with other jobs",
+    ),
+    Pragma(
+        flags=["--signal"],
+        dest="signal",
+        metavar="[R:]NUM[@TIME]",
+        help="send signal when time limit within time seconds",
+    ),
+    Pragma(
+        flags=["--spread-job"],
+        dest="spread_job",
+        action="store_true",
+        help="spread job across as many nodes as possible",
+    ),
+    Pragma(
+        flags=["--switches"],
+        dest="switches",
+        metavar="MAX_SWITCHES[@MAX_TIME]",
+        help="optimum switches and max time to wait for optimum",
+    ),
+    Pragma(
+        flags=["-S", "--core-spec"],
+        dest="core_spec",
+        metavar="CORES",
+        help="count of reserved cores",
+    ),
+    Pragma(
+        flags=["--thread-spec"],
+        dest="thread_spec",
+        metavar="THREADS",
+        help="count of reserved threads",
+    ),
+    Pragma(
+        flags=["-t", "--time"],
+        dest="time",
+        metavar="MINUTES",
+        type=int,
+        help="time limit",
+        example="00:45:00",
+    ),
+    Pragma(
+        flags=["--time-min"],
+        dest="time_min",
+        metavar="MINUTES",
+        type=int,
+        help="minimum time limit (if distinct)",
+    ),
+    Pragma(
+        flags=["--tres-bind"],
+        dest="tres_bind",
+        metavar="...",
+        help="task to tres binding options",
+    ),
+    Pragma(
+        flags=["--tres-per-task"],
+        dest="tres_per_task",
+        metavar="LIST",
+        type=lambda s: s.split(","),
+        help="list of tres required per task",
+    ),
+    Pragma(
+        flags=["--use-min-nodes"],
+        dest="use_min_nodes",
+        action="store_true",
+        help="if a range of node counts is given, prefer the smaller count",
+    ),
+    Pragma(
+        flags=["--wckey"], dest="wckey", metavar="WCKEY", help="wckey to run job under"
+    ),
+    Pragma(
+        flags=["--cluster-constraint"],
+        dest="cluster_constraint",
+        metavar="LIST",
+        type=lambda s: s.split(","),
+        help="specify a list of cluster constraints",
+    ),
+    Pragma(
+        flags=["--contiguous"],
+        dest="contiguous",
+        action="store_true",
+        help="demand a contiguous range of nodes",
+    ),
+    Pragma(
+        flags=["-C", "--constraint"],
+        dest="constraint",
+        metavar="LIST",
+        type=lambda s: s.split(","),
+        help="specify a list of constraints",
+    ),
+    Pragma(
+        flags=["-F", "--nodefile"],
+        dest="nodefile",
+        metavar="FILENAME",
+        help="request a specific list of hosts",
+    ),
+    Pragma(
+        flags=["--mem"],
+        dest="mem",
+        metavar="MB",
+        type=int,
+        help="minimum amount of real memory",
+        example="25GB",
+    ),
+    Pragma(
+        flags=["--mincpus"],
+        dest="mincpus",
+        metavar="N",
+        type=int,
+        help="minimum number of logical processors per node",
+    ),
+    Pragma(
+        flags=["--reservation"],
+        dest="reservation",
+        metavar="NAME",
+        help="allocate resources from named reservation",
+    ),
+    Pragma(
+        flags=["--tmp"],
+        dest="tmp",
+        metavar="MB",
+        type=int,
+        help="minimum amount of temporary disk",
+    ),
+    Pragma(
+        flags=["-w", "--nodelist"],
+        dest="nodelist",
+        nargs="+",
+        metavar="HOST",
+        help="request a specific list of hosts",
+    ),
+    Pragma(
+        flags=["-x", "--exclude"],
+        dest="exclude",
+        nargs="+",
+        metavar="HOST",
+        help="exclude a specific list of hosts",
+    ),
+    Pragma(
+        flags=["--exclusive-user"],
+        dest="exclusive_user",
+        action="store_true",
+        help="allocate nodes in exclusive mode for cpu consumable resource",
+    ),
+    Pragma(
+        flags=["--exclusive-mcs"],
+        dest="exclusive_mcs",
+        action="store_true",
+        help="allocate nodes in exclusive mode when mcs plugin is enabled",
+    ),
+    Pragma(
+        flags=["--mem-per-cpu"],
+        dest="mem_per_cpu",
+        metavar="MB",
+        type=int,
+        help="maximum amount of real memory per allocated cpu",
+    ),
+    Pragma(
+        flags=["--resv-ports"],
+        dest="resv_ports",
+        action="store_true",
+        help="reserve communication ports",
+    ),
+    Pragma(
+        flags=["--sockets-per-node"],
+        dest="sockets_per_node",
+        metavar="S",
+        type=int,
+        help="number of sockets per node to allocate",
+    ),
+    Pragma(
+        flags=["--cores-per-socket"],
+        dest="cores_per_socket",
+        metavar="C",
+        type=int,
+        help="number of cores per socket to allocate",
+        example=8,
+    ),
+    Pragma(
+        flags=["--threads-per-core"],
+        dest="threads_per_core",
+        metavar="T",
+        type=int,
+        help="number of threads per core to allocate",
+        example=4,
+    ),
+    Pragma(
+        flags=["-B", "--extra-node-info"],
+        dest="extra_node_info",
+        metavar="S[:C[:T]]",
+        help="combine request of sockets, cores and threads",
+    ),
+    Pragma(
+        flags=["--ntasks-per-core"],
+        dest="ntasks_per_core",
+        metavar="N",
+        type=int,
+        help="number of tasks to invoke on each core",
+        example=16,
+    ),
+    Pragma(
+        flags=["--ntasks-per-socket"],
+        dest="ntasks_per_socket",
+        metavar="N",
+        type=int,
+        help="number of tasks to invoke on each socket",
+        example=8,
+    ),
+    Pragma(
+        flags=["--hint"],
+        dest="hint",
+        metavar="HINT",
+        help="Bind tasks according to application hints",
+    ),
+    Pragma(
+        flags=["--mem-bind"],
+        dest="mem_bind",
+        metavar="BIND",
+        help="Bind memory to locality domains",
+    ),
+    Pragma(
+        flags=["--cpus-per-gpu"],
+        dest="cpus_per_gpu",
+        metavar="N",
+        type=int,
+        help="number of CPUs required per allocated GPU",
+        example=4,
+    ),
+    Pragma(
+        flags=["-G", "--gpus"],
+        dest="gpus",
+        metavar="N",
+        type=int,
+        help="count of GPUs required for the job",
+        example=32,
+    ),
+    Pragma(
+        flags=["--gpu-bind"],
+        dest="gpu_bind",
+        metavar="...",
+        help="task to gpu binding options",
+    ),
+    Pragma(
+        flags=["--gpu-freq"],
+        dest="gpu_freq",
+        metavar="...",
+        help="frequency and voltage of GPUs",
+    ),
+    Pragma(
+        flags=["--gpus-per-node"],
+        dest="gpus_per_node",
+        metavar="N",
+        type=int,
+        help="number of GPUs required per allocated node",
+    ),
+    Pragma(
+        flags=["--gpus-per-socket"],
+        dest="gpus_per_socket",
+        metavar="N",
+        type=int,
+        help="number of GPUs required per allocated socket",
+    ),
+    Pragma(
+        flags=["--gpus-per-task"],
+        dest="gpus_per_task",
+        metavar="N",
+        type=int,
+        help="number of GPUs required per spawned task",
+    ),
+    Pragma(
+        flags=["--mem-per-gpu"],
+        dest="mem_per_gpu",
+        type=str,
+        help="real memory required per allocated GPU",
+        example="8GB",
+    ),
+    Pragma(
+        flags=["--disable-stdout-job-summary"],
+        dest="disable_stdout_job_summary",
+        action="store_true",
+        help="disable job summary in stdout file for the job",
+    ),
+    Pragma(
+        flags=["--nvmps"],
+        dest="nvmps",
+        action="store_true",
+        help="launching NVIDIA MPS for job",
+    ),
+]

slurm_script_generator-0.1.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: slurm-script-generator
+Version: 0.1
+Summary: Generate slurm scripts.
+Author: Max
+Project-URL: Source, https://github.com/max-models/slurm-script-generator
+Keywords: python
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: check-manifest; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+
+# Slurm script generator
+
+## Install
+
+```
+pip install .
+```
+
+## Generate scripts
+
+Generate a slurm script to `slurm_script.sh` with
+
+```bash
+❯ generate-slurm-script --nodes 1 --ntasks-per-node 16 --output slurm_script.sh
+❯ cat slurm_script.sh
+#!/bin/bash
+##########################################
+#SBATCH --nodes 1                        # number of nodes on which to run
+#SBATCH --ntasks_per_node 16             # number of tasks to invoke on each node
+##########################################
+```
+
+To export the settings to a json file you can use `--export-json`:
+
+```bash
+❯ generate-slurm-script --nodes 2 --export-json setup.json
+#!/bin/bash
+##########################################
+#SBATCH --nodes 2                        # number of nodes on which to run
+##########################################
+```
+
+This json file can used as a basis for creating new scripts
+
+```bash
+❯ generate-slurm-script --input setup.json --ntasks-per-node 16
+#!/bin/bash
+##########################################
+#SBATCH --nodes 2                        # number of nodes on which to run
+#SBATCH --ntasks_per_node 16             # number of tasks to invoke on each node
+##########################################
+```
+
+### Add modules
+
+Add modules with
+
+```bash
+❯ generate-slurm-script --modules gcc/13 openmpi/5.0
+#!/bin/bash
+##########################################
+##########################################
+
+module purge                             # Purge modules
+module load gcc/13 openmpi/5.0           # modules
+module list                              # List loaded modules
+```
+
+### Add virtual environment
+
+```bash
+❯ generate-slurm-script --nodes 1 --ntasks-per-node 16 --venv ~/virtual_envs/env
+args_dict.get("modules") = None
+#!/bin/bash
+##########################################
+#SBATCH --nodes 1                        # number of nodes on which to run
+#SBATCH --ntasks_per_node 16             # number of tasks to invoke on each node
+##########################################
+
+source /Users/max/virtual_envs/env/bin/activate # virtual environment
+```
+
+### Other
+
+All optional arguments can be shown with
+
+```bash
+❯ generate-slurm-script -h
+usage: generate-slurm-script [-h] [-A NAME] [-b TIME] [--bell] [--no-bell] [--bb SPEC] [--bbf FILE_NAME] [-c NCPUS] [--comment NAME] [--container PATH] [--container-id ID]
+                             [--cpu-freq MIN[-MAX[:GOV]]] [--delay-boot MINS] [-d TYPE:JOBID[:TIME]] [--deadline TIME] [-D PATH] [--get-user-env] [--gres LIST]
+                             [--gres-flags OPTS] [-H] [-I [SECS]] [-J NAME] [-k] [-K [SIGNAL]] [-L NAMES] [-M NAMES] [-m TYPE] [--mail-type TYPE] [--mail-user USER]
+                             [--mcs-label MCS] [-n N] [--nice [VALUE]] [-N NODES] [--ntasks-per-node N] [--oom-kill-step [0|1]] [-O] [--power FLAGS] [--priority VALUE]
+                             [--profile VALUE] [-p PARTITION] [-q QOS] [-Q] [--reboot] [-s] [--signal [R:]NUM[@TIME]] [--spread-job] [--switches MAX_SWITCHES[@MAX_TIME]]
+                             [-S CORES] [--thread-spec THREADS] [-t MINUTES] [--time-min MINUTES] [--tres-bind ...] [--tres-per-task LIST] [--use-min-nodes] [--wckey WCKEY]
+                             [--cluster-constraint LIST] [--contiguous] [-C LIST] [-F FILENAME] [--mem MB] [--mincpus N] [--reservation NAME] [--tmp MB] [-w HOST [HOST ...]]
+                             [-x HOST [HOST ...]] [--exclusive-user] [--exclusive-mcs] [--mem-per-cpu MB] [--resv-ports] [--sockets-per-node S] [--cores-per-socket C]
+                             [--threads-per-core T] [-B S[:C[:T]]] [--ntasks-per-core N] [--ntasks-per-socket N] [--hint HINT] [--mem-bind BIND] [--cpus-per-gpu N] [-G N]
+                             [--gpu-bind ...] [--gpu-freq ...] [--gpus-per-node N] [--gpus-per-socket N] [--gpus-per-task N] [--mem-per-gpu MEM_PER_GPU]
+                             [--disable-stdout-job-summary] [--nvmps] [--line-length LINE_LENGHT] [--modules MODULES [MODULES ...]] [--venv VENV] [--printenv] [--print-self]
+                             [--likwid] [--input INPUT_PATH] [--output OUTPUT_PATH] [--export-json JSON_PATH]
+
+Slurm job submission options
+
+options:
+  -h, --help            show this help message and exit
+  -A, --account NAME    charge job to specified account (default: None)
+  -b, --begin TIME      defer job until HH:MM MM/DD/YY (default: None)
+  --bell                ring the terminal bell when the job is allocated (default: False)
+  --no-bell             do NOT ring the terminal bell (default: True)
+  --bb SPEC             burst buffer specifications (default: None)
+  --bbf FILE_NAME       burst buffer specification file (default: None)
+  -c, --cpus-per-task NCPUS
+                        number of cpus required per task (default: None)
+  --comment NAME        arbitrary comment (default: None)
+  --container PATH      Path to OCI container bundle (default: None)
+  --container-id ID     OCI container ID (default: None)
+  --cpu-freq MIN[-MAX[:GOV]]
+                        requested cpu frequency (and governor) (default: None)
+  --delay-boot MINS     delay boot for desired node features (default: None)
+  -d, --dependency TYPE:JOBID[:TIME]
+                        defer job until condition on jobid is satisfied (default: None)
+  --deadline TIME       remove the job if no ending possible before this deadline (default: None)
+  -D, --chdir PATH      change working directory (default: None)
+  --get-user-env        used by Moab. See srun man page (default: False)
+  --gres LIST           required generic resources (default: None)
+  --gres-flags OPTS     flags related to GRES management (default: None)
+  -H, --hold            submit job in held state (default: False)
+  -I, --immediate [SECS]
+                        exit if resources not available in "secs" (default: None)
+  -J, --job-name NAME   name of job (default: None)
+  -k, --no-kill         do not kill job on node failure (default: False)
+  -K, --kill-command [SIGNAL]
+                        signal to send terminating job (default: None)
+  -L, --licenses NAMES  required license, comma separated (default: None)
+  -M, --clusters NAMES  Comma separated list of clusters to issue commands to (default: None)
+  -m, --distribution TYPE
+                        distribution method for processes to nodes (default: None)
+  --mail-type TYPE      notify on state change (default: None)
+  --mail-user USER      who to send email notification for job state changes (default: None)
+  --mcs-label MCS       mcs label if mcs plugin mcs/group is used (default: None)
+  -n, --ntasks N        number of processors required (default: None)
+  --nice [VALUE]        decrease scheduling priority by value (default: None)
+  -N, --nodes NODES     number of nodes on which to run (default: None)
+  --ntasks-per-node N   number of tasks to invoke on each node (default: None)
+  --oom-kill-step [0|1]
+                        set the OOMKillStep behaviour (default: None)
+  -O, --overcommit      overcommit resources (default: False)
+  --power FLAGS         power management options (default: None)
+  --priority VALUE      set the priority of the job (default: None)
+  --profile VALUE       enable acct_gather_profile for detailed data (default: None)
+  -p, --partition PARTITION
+                        partition requested (default: None)
+  -q, --qos QOS         quality of service (default: None)
+  -Q, --quiet           quiet mode (suppress informational messages) (default: False)
+  --reboot              reboot compute nodes before starting job (default: False)
+  -s, --oversubscribe   oversubscribe resources with other jobs (default: False)
+  --signal [R:]NUM[@TIME]
+                        send signal when time limit within time seconds (default: None)
+  --spread-job          spread job across as many nodes as possible (default: False)
+  --switches MAX_SWITCHES[@MAX_TIME]
+                        optimum switches and max time to wait for optimum (default: None)
+  -S, --core-spec CORES
+                        count of reserved cores (default: None)
+  --thread-spec THREADS
+                        count of reserved threads (default: None)
+  -t, --time MINUTES    time limit (default: None)
+  --time-min MINUTES    minimum time limit (if distinct) (default: None)
+  --tres-bind ...       task to tres binding options (default: None)
+  --tres-per-task LIST  list of tres required per task (default: None)
+  --use-min-nodes       if a range of node counts is given, prefer the smaller count (default: False)
+  --wckey WCKEY         wckey to run job under (default: None)
+  --cluster-constraint LIST
+                        specify a list of cluster constraints (default: None)
+  --contiguous          demand a contiguous range of nodes (default: False)
+  -C, --constraint LIST
+                        specify a list of constraints (default: None)
+  -F, --nodefile FILENAME
+                        request a specific list of hosts (default: None)
+  --mem MB              minimum amount of real memory (default: None)
+  --mincpus N           minimum number of logical processors per node (default: None)
+  --reservation NAME    allocate resources from named reservation (default: None)
+  --tmp MB              minimum amount of temporary disk (default: None)
+  -w, --nodelist HOST [HOST ...]
+                        request a specific list of hosts (default: None)
+  -x, --exclude HOST [HOST ...]
+                        exclude a specific list of hosts (default: None)
+  --exclusive-user      allocate nodes in exclusive mode for cpu consumable resource (default: False)
+  --exclusive-mcs       allocate nodes in exclusive mode when mcs plugin is enabled (default: False)
+  --mem-per-cpu MB      maximum amount of real memory per allocated cpu (default: None)
+  --resv-ports          reserve communication ports (default: False)
+  --sockets-per-node S  number of sockets per node to allocate (default: None)
+  --cores-per-socket C  number of cores per socket to allocate (default: None)
+  --threads-per-core T  number of threads per core to allocate (default: None)
+  -B, --extra-node-info S[:C[:T]]
+                        combine request of sockets, cores and threads (default: None)
+  --ntasks-per-core N   number of tasks to invoke on each core (default: None)
+  --ntasks-per-socket N
+                        number of tasks to invoke on each socket (default: None)
+  --hint HINT           Bind tasks according to application hints (default: None)
+  --mem-bind BIND       Bind memory to locality domains (default: None)
+  --cpus-per-gpu N      number of CPUs required per allocated GPU (default: None)
+  -G, --gpus N          count of GPUs required for the job (default: None)
+  --gpu-bind ...        task to gpu binding options (default: None)
+  --gpu-freq ...        frequency and voltage of GPUs (default: None)
+  --gpus-per-node N     number of GPUs required per allocated node (default: None)
+  --gpus-per-socket N   number of GPUs required per allocated socket (default: None)
+  --gpus-per-task N     number of GPUs required per spawned task (default: None)
+  --mem-per-gpu MEM_PER_GPU
+                        real memory required per allocated GPU (default: None)
+  --disable-stdout-job-summary
+                        disable job summary in stdout file for the job (default: False)
+  --nvmps               launching NVIDIA MPS for job (default: False)
+  --line-length LINE_LENGHT
+                        line length before start of comment (default: 40)
+  --modules MODULES [MODULES ...]
+                        Modules to load (e.g., --modules mod1 mod2 mod3) (default: [])
+  --venv VENV           virtual environment to load with `source VENV/bin/activate` (default: None)
+  --printenv            print all environment variables (default: False)
+  --print-self          print the batch script in the batch script (default: False)
+  --likwid              Set up likwid environment variables (default: False)
+  --input INPUT_PATH    path to input json file (default: None)
+  --output OUTPUT_PATH  json path to save slurm batch script to (default: None)
+  --export-json JSON_PATH
+                        path to export yaml for generating the slurm script to (default: None)
+```

slurm_script_generator-0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+slurm_script_generator/main.py,sha256=MJ5DJ5QgFoko_B-D1UQHYh2JhG8wjuCglJ5RhXAhJJ4,6670
+slurm_script_generator/sbatch.py,sha256=DcTuzyWkt7mXEcofQbM7ydajBJ4CdTTtGiPW-cQTJMs,1938
+slurm_script_generator/sbatch_parser.py,sha256=BAtuooI5ARRMpIjNfhgGspDmLs9ngITGbQZNEsP0TBU,14699
+slurm_script_generator-0.1.dist-info/METADATA,sha256=bj7GI7TVdWQwHUBIjvTQuwLeKAWVFRZokaBaECrp9rI,13072
+slurm_script_generator-0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+slurm_script_generator-0.1.dist-info/entry_points.txt,sha256=3hkDhrBEjwGBvRoUfVj2M3PVT_tqyvlgixg0EgmN1IM,75
+slurm_script_generator-0.1.dist-info/top_level.txt,sha256=3ltSu_DVIP0Ot4g-cBH-fDyoSTwieTZWDeBuHTX2xuY,23
+slurm_script_generator-0.1.dist-info/RECORD,,

slurm_script_generator-0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

slurm_script_generator-0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+generate-slurm-script = slurm_script_generator.main:main

slurm_script_generator-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+slurm_script_generator