xmanager-slurm 0.4.19__py3-none-any.whl

xm_slurm/templates/slurm/library/retry.bash

@@ -0,0 +1,62 @@
+# retry: rerun a command if it exits with certain codes
+# Options:
+#   -c CODE   Retry on this exit code (repeatable).
+#   -n N      Max attempts (incl. first). Default: unlimited
+#   -d SECS   Initial delay before first retry. Default: 1
+#   -b FACTOR Integer backoff multiplier per retry. Default: 1 (no backoff)
+#   -q        Quiet (no logs)
+# Usage:
+#   retry [-c CODE ...] [-n N] [-d SECS] [-b FACTOR] [-q] -- cmd arg1 arg2 ...
+retry() {
+  local -a codes=()
+  local -i max=-1 delay=1 backoff=1 quiet=0 status
+  local opt OPTIND=1
+
+  while getopts ":c:n:d:b:q" opt; do
+    case "$opt" in
+      c) codes+=("$OPTARG") ;;
+      n) max=$OPTARG ;;
+      d) delay=$OPTARG ;;
+      b) backoff=$OPTARG ;;
+      q) quiet=1 ;;
+      :) printf 'retry: option -%s requires an argument\n' "$OPTARG" >&2; return 2 ;;
+      \?) printf 'retry: invalid option -- %s\n' "$OPTARG" >&2; return 2 ;;
+    esac
+  done
+  shift $((OPTIND-1))
+  (( $# )) || { printf 'retry: missing command\n' >&2; return 2; }
+
+  ((${#codes[@]})) || { printf 'retry: no return codes specified\n' >&2; return 2; }
+
+  for ((attempt=1; ; attempt++)); do
+    if "$@"; then                    # safe with set -e (exception context)
+      return 0
+    else
+      status=$?                       # capture failing status immediately
+    fi
+
+    # retryable?
+    local retryable=0 c
+    for c in "${codes[@]}"; do
+      (( status == c )) && { retryable=1; break; }
+    done
+
+    # stop if not retryable OR we've just hit the max attempt
+    if (( !retryable )) || (( max >= 0 && attempt >= max )); then
+      (( quiet )) || {
+        if (( attempt > 1 )); then
+          printf 'retry: giving up after %d attempts; last exit=%d\n' "$attempt" "$status" >&2
+        else
+          printf 'retry: command failed; exit=%d\n' "$status" >&2
+        fi
+      }
+      return "$status"               # propagate exact code; errexit will catch
+    fi
+
+    (( quiet )) || printf 'retry: attempt %d failed with %d; retrying in %ds...\n' \
+                          "$attempt" "$status" "$delay" >&2
+    sleep "$delay" || :              # never trip set -e if sleep errors
+    (( delay *= backoff ))
+  done
+}
+export -f retry

xm_slurm/templates/slurm/runtimes/apptainer.bash.j2

@@ -0,0 +1,73 @@
+{% macro run(cluster, job) -%}
+{%- set runtime = (cluster.runtime | string | lower) -%}
+
+# Bundle will be where our built sandbox image is stored
+# container-workdir will be our container's scratch directory
+# TODO(jfarebro): We can make this more efficient by doing an srun per node and downloading the container once per node.
+# but this requires apptainer support to have an overlay per procid
+mkdir -p "$SLURM_TMPDIR"/{container-"$SLURM_PROCID",container-workdir-"$SLURM_PROCID",container-overlay-"$SLURM_PROCID"}
+
+retry -c 255 -n 10 -d 1 -b 2 -- \
+{% if job.executable.credentials %}
+  env {{ runtime | upper }}_DOCKER_USERNAME="{{ job.executable.credentials.username }}" {{ runtime | upper }}_DOCKER_PASSWORD="{{ job.executable.credentials.password }}" time {{ runtime }} build \
+{% else %}
+  time {{ runtime }} build \
+{% endif %}
+    --force \
+    --sandbox \
+    --fix-perms \
+    "$SLURM_TMPDIR"/container-"$SLURM_PROCID" \
+    docker://{{ job.executable.image }}
+
+{% if runtime == "singularity" and cluster.mounts %}
+{% for source, dest in cluster.mounts.items() %}
+mkdir -p "$SLURM_TMPDIR"/container-"$SLURM_PROCID"/{{ dest | trim('/') }}
+{% endfor %}
+{% endif %}
+
+cat << 'ENTRYPOINT_EOF' > "$SLURM_TMPDIR"/container-"$SLURM_PROCID"/xm-slurm-entrypoint.sh
+{{ entrypoint(cluster, job) }}
+ENTRYPOINT_EOF
+chmod +x "$SLURM_TMPDIR"/container-"$SLURM_PROCID"/xm-slurm-entrypoint.sh
+
+for var in "${!SLURM_@}"; do export "{{ runtime | upper }}ENV_${var}=${!var}"; done
+
+exec {{ runtime }} exec \
+{% if job.executor.requirements.accelerator %}
+  --nv \
+{% endif %}
+  --no-init \
+  --no-umask \
+  --no-home \
+  --cleanenv \
+{% if runtime == "apptainer" %}
+  --no-eval \
+{% endif %}
+  --containall \
+{% if cluster.mounts %}
+{% for source, dest in cluster.mounts.items() %}
+  --bind {{ source }}:{{ dest }} \
+{% endfor %}
+{% endif %}
+  --workdir "$SLURM_TMPDIR"/container-workdir-"$SLURM_PROCID" \
+{% if (cluster.runtime | string) == "apptainer" %}
+  --overlay "$SLURM_TMPDIR"/container-overlay-"$SLURM_PROCID" \
+{% else %}
+  --writable \
+{% endif %}
+{% if job.executable.workdir %}
+  --pwd {{ job.executable.workdir }} \
+{% endif %}
+  "$SLURM_TMPDIR"/container-"$SLURM_PROCID" \
+  /xm-slurm-entrypoint.sh \
+{% for arg in job.executable.args.to_list() %}
+  {{ arg }} \
+{% endfor %}
+{% for arg in job.args.to_list() %}
+  {{ arg }} \
+{% endfor %}
+{% if caller %}
+  {{- caller() -}}
+{% endif %}
+  "$@"
+{%- endmacro %}

xm_slurm/templates/slurm/runtimes/podman.bash.j2

@@ -0,0 +1,43 @@
+{% macro run(cluster, job) -%}
+retry -c 255 -n 10 -d 1 -b 2 -- \
+  time podman pull \
+{% if job.executable.credentials %}
+    --creds {{ job.executable.credentials.username }}:{{ job.executable.credentials.password }} \
+{% endif %}
+    {{ job.executable.image }}
+
+cat << 'ENTRYPOINT_EOF' > "$SLURM_TMPDIR"/xm-slurm-entrypoint.sh
+{{ entrypoint(cluster, job) }}
+ENTRYPOINT_EOF
+chmod +x "$SLURM_TMPDIR"/xm-slurm-entrypoint.sh
+
+exec podman run \
+  --mount type=bind,src="$SLURM_TMPDIR"/xm-slurm-entrypoint.sh,dst=/xm-slurm-entrypoint.sh,ro \
+  --entrypoint /xm-slurm-entrypoint.sh \
+  --pull never \
+  --restart no \
+  --env "SLURM_*" \
+  --rm \
+{% if job.executor.requirements.accelerator %}
+  --device nvidia.com/gpu=all \
+{% endif %}
+{% if cluster.mounts %}
+{% for source, dest in cluster.mounts.items() %}
+  --mount type=bind,src={{ source }},dst={{ dest }} \
+{% endfor %}
+{% endif %}
+{% if job.executable.workdir %}
+  --workdir {{ job.executable.workdir }} \
+{% endif %}
+  {{ job.executable.image }} \
+{% for arg in job.executable.args.to_list() %}
+  {{ arg }} \
+{% endfor %}
+{% for arg in job.args.to_list() %}
+  {{ arg }} \
+{% endfor %}
+{% if caller %}
+  {{- caller() -}}
+{% endif %}
+  "$@"
+{% endmacro %}

xm_slurm/types.py

@@ -0,0 +1,23 @@
+import typing as tp
+
+InstanceT_contra = tp.TypeVar("InstanceT_contra", contravariant=True)
+GetterT_co = tp.TypeVar("GetterT_co", covariant=True)
+SetterT_co = tp.TypeVar("SetterT_co", contravariant=True)
+
+
+class Descriptor(tp.Protocol[GetterT_co, SetterT_co]):
+    def __set_name__(self, owner: tp.Type[tp.Any], name: str) -> None: ...
+
+    @tp.overload
+    def __get__(
+        self, instance: InstanceT_contra, owner: tp.Type[InstanceT_contra] | None = None
+    ) -> GetterT_co: ...
+
+    @tp.overload
+    def __get__(self, instance: None, owner: tp.Type[InstanceT_contra]) -> GetterT_co: ...
+
+    def __get__(
+        self, instance: InstanceT_contra | None, owner: tp.Type[InstanceT_contra] | None = None
+    ) -> GetterT_co: ...
+
+    def __set__(self, instance: tp.Any, value: SetterT_co) -> None: ...

xm_slurm/utils.py

@@ -0,0 +1,196 @@
+import asyncio
+import datetime as dt
+import functools
+import logging
+import os
+import pathlib
+import pty
+import re
+import select
+import shutil
+import subprocess
+import sys
+import typing as tp
+
+from xmanager import xm
+
+T = tp.TypeVar("T")
+P = tp.ParamSpec("P")
+
+logger = logging.getLogger(__name__)
+
+
+class CachedAwaitable(tp.Awaitable[T]):
+    def __init__(self, awaitable: tp.Awaitable[T]):
+        self.awaitable = awaitable
+        self.result: asyncio.Future[T] | None = None
+
+    def __await__(self):
+        if not self.result:
+            future = asyncio.get_event_loop().create_future()
+            self.result = future
+            try:
+                result = yield from self.awaitable.__await__()
+                future.set_result(result)
+            except Exception as e:
+                future.set_exception(e)
+
+        if not self.result.done():
+            yield from self.result
+        return self.result.result()
+
+
+def reawaitable(f: tp.Callable[P, tp.Awaitable[T]]) -> tp.Callable[P, CachedAwaitable[T]]:
+    @functools.wraps(f)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> CachedAwaitable[T]:
+        return CachedAwaitable(f(*args, **kwargs))
+
+    return wrapper
+
+
+@functools.cache
+def find_project_root() -> pathlib.Path:
+    launch_script_path: pathlib.Path | None = None
+    launch_script_path = pathlib.Path(sys.argv[0])
+
+    if sys.argv[0].endswith(".py"):
+        launch_script_path = pathlib.Path(sys.argv[0]).resolve()
+    else:
+        main_file_path = getattr(sys.modules["__main__"], "__file__", None)
+        if main_file_path and os.access(main_file_path, os.R_OK):
+            launch_script_path = pathlib.Path(main_file_path).resolve()
+
+    pdir = launch_script_path.parent if launch_script_path else pathlib.Path.cwd().resolve()
+    while pdir != pdir.parent:
+        if (
+            (pdir / "pyproject.toml").exists()
+            or (pdir / "setup.py").exists()
+            or (pdir / "setup.cfg").exists()
+            or (pdir / "requirements.txt").exists()
+            or (pdir / "requirements.in").exists()
+            or (pdir / "uv.lock").exists()
+            or (pdir / ".venv").exists()
+        ):
+            return pdir
+        pdir = pdir.parent
+
+    raise RuntimeError(f"Could not find project root from {sys.argv[0]}. Please specify `context`.")
+
+
+# Cursor commands to filter out from the command data stream
+_CURSOR_ESCAPE_SEQUENCES_REGEX = re.compile(
+    rb"\x1b\[\?25[hl]"  # Matches cursor show/hide commands (CSI ?25h and CSI ?25l)
+    rb"|\x1b\[[0-9;]*[Hf]"  # Matches cursor position commands (CSI n;mH and CSI n;mf)
+    rb"|\x1b\[s"  # Matches cursor save position (CSI s)
+    rb"|\x1b\[u"  # Matches cursor restore position (CSI u)
+    rb"|\x1b\[2J"  # Matches clear screen (CSI 2J)
+    rb"|\x1b\[K"  # Matches clear line (CSI K)
+)
+
+
+def run_command(
+    args: tp.Sequence[str] | xm.SequentialArgs,
+    env: dict[str, str] | None = None,
+    tty: bool = False,
+    cwd: str | os.PathLike[str] | None = None,
+    stdin: tp.IO[tp.AnyStr] | str | None = None,
+    check: bool = False,
+    return_stdout: bool = False,
+    return_stderr: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    if isinstance(args, xm.SequentialArgs):
+        args = args.to_list()
+    args = list(args)
+
+    executable = shutil.which(args[0])
+    if not executable:
+        raise RuntimeError(f"Couldn't find executable {args[0]}")
+    executable = pathlib.Path(executable)
+
+    subprocess_env = os.environ.copy() | (env if env else {})
+    if executable.name == "docker" and args[1] == "buildx":
+        subprocess_env |= {"DOCKER_CLI_EXPERIMENTAL": "enabled"}
+
+    logger.debug(f"command: {' '.join(args)}")
+
+    stdout_master, stdout_slave = pty.openpty()
+    stderr_master, stderr_slave = pty.openpty()
+
+    stdout_data, stderr_data = b"", b""
+    with subprocess.Popen(
+        executable=executable,
+        args=args,
+        shell=False,
+        text=True,
+        bufsize=0,
+        stdin=subprocess.PIPE if stdin else None,
+        stdout=stdout_slave,
+        stderr=stderr_slave,
+        start_new_session=True,
+        close_fds=True,
+        cwd=cwd,
+        env=subprocess_env,
+    ) as process:
+        os.close(stdout_slave)
+        os.close(stderr_slave)
+
+        if stdin and process.stdin:
+            process.stdin.write(stdin if isinstance(stdin, str) else tp.cast(str, stdin.read()))
+            process.stdin.close()
+
+        fds = [stdout_master, stderr_master]
+        while fds:
+            rlist, _, _ = select.select(fds, [], [])
+            for fd in rlist:
+                try:
+                    data = os.read(fd, 1024)
+                except OSError:
+                    data = None
+
+                if not data:
+                    os.close(fd)
+                    fds.remove(fd)
+                    continue
+
+                data = _CURSOR_ESCAPE_SEQUENCES_REGEX.sub(b"", data)
+
+                if fd == stdout_master:
+                    if return_stdout:
+                        stdout_data += data
+                    if tty:
+                        os.write(pty.STDOUT_FILENO, data)
+                elif fd == stderr_master:
+                    if return_stderr:
+                        stderr_data += data
+                    if tty:
+                        os.write(pty.STDERR_FILENO, data)
+                else:
+                    raise RuntimeError("Unexpected file descriptor")
+
+    stdout = stdout_data.decode(errors="replace") if stdout_data else ""
+    stderr = stderr_data.decode(errors="replace") if stderr_data else ""
+
+    logger.debug(f"return code: {process.returncode}")
+    if stdout:
+        logger.debug(f"stdout: {stdout}")
+    if stderr:
+        logger.debug(f"stderr: {stderr}")
+
+    retcode = process.poll()
+    assert retcode is not None
+
+    if check and retcode:
+        raise subprocess.CalledProcessError(retcode, process.args)
+    return subprocess.CompletedProcess(
+        process.args,
+        retcode,
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+
+def timestr_from_timedelta(time: dt.timedelta) -> str:
+    days = time.days
+    hours, remainder = divmod(time.seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    return f"{days}-{hours:02}:{minutes:02}:{seconds:02}"

xmanager_slurm-0.4.19.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: xmanager-slurm
+Version: 0.4.19
+Summary: Slurm backend for XManager.
+Project-URL: GitHub, https://github.com/jessefarebro/xm-slurm
+Author-email: Jesse Farebrother <jfarebro@cs.mcgill.ca>
+License: MIT
+License-File: LICENSE.md
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: aiofile>=3.9.0
+Requires-Dist: asyncssh>=2.19.0
+Requires-Dist: backoff>=2.2.1
+Requires-Dist: cloudpickle>=3.0.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: humanize>=4.8.0
+Requires-Dist: jinja2>=3.1.2
+Requires-Dist: more-itertools>=10.2.0
+Requires-Dist: rich>=13.5.2
+Requires-Dist: toml>=0.10.2
+Requires-Dist: wrapt>=1.16.0
+Requires-Dist: xmanager>=0.5.0

xmanager_slurm-0.4.19.dist-info/RECORD

@@ -0,0 +1,52 @@
+xm_slurm/__init__.py,sha256=VNbvBLbv5ccbPxQUpbiwgoo72qI3FrATTloevufstzY,1112
+xm_slurm/batching.py,sha256=ynbMRItxNtBn0SbkhHbrv5ugYuHeMw-7BP7a_-I6Oqg,4384
+xm_slurm/config.py,sha256=srM8_UZSweYmMdaZzQ25FWTTutZbpc5CkQThUvXxmgQ,5944
+xm_slurm/console.py,sha256=UpMqeJ0C8i0pkue1AHnnyyX0bFJ9zZeJ7HBR6yhuA8A,54
+xm_slurm/constants.py,sha256=zefVtlFdflgSolie5g_rVxWV-Zpydxapchm3y0a2FDc,999
+xm_slurm/dependencies.py,sha256=G-8vfmvSptZH6c_Ow51SwT84Dr6LI1clRj8F8wOUkiw,6421
+xm_slurm/executables.py,sha256=fGmrFBl-258bMn6ip5adYeM7xxUHAeIbDN9zD2FDGtY,6373
+xm_slurm/execution.py,sha256=htX4nZyLYexIwmFeT79Vta0SiUmcnq1YQJBc04zDyU0,37653
+xm_slurm/executors.py,sha256=27oiMwF84axeTcrcwL0f5seeLL_1j79OjiM_JZjioFs,9112
+xm_slurm/experiment.py,sha256=32FCtG9USi4rMKPFY2B4wt8_JB01VH1ozWcznCyxc50,39878
+xm_slurm/filesystems.py,sha256=4rKtq3t-KDgxJbSGt6JVyRJT_3lCN_vIKTcwKHpTo3I,4389
+xm_slurm/job_blocks.py,sha256=BFOOYgeodoGIQsB5PdC7SsOUou5aZx-1qbQ7lcqqylI,604
+xm_slurm/metadata_context.py,sha256=mksVRbVUuistL1uE7TC-fkW-Y69On52jN_svP1e1kiQ,7841
+xm_slurm/packageables.py,sha256=aEZUQpddfq4FK6h4f6kgGEI4XcOufhm68MjoDFOYR4U,12261
+xm_slurm/resources.py,sha256=G1rkZ1tBnTFpF9ZUb3Ui7NFrLYgRwe1GPW2g8Aap1Qk,12359
+xm_slurm/status.py,sha256=JIBCJPOYsmeJOQbzdACXA2vTWK7g8YWWhzpGP79e7JE,6911
+xm_slurm/types.py,sha256=TsVykDm-LazVkrjeJrTwCMs4Q8APKhy7BTk0yKIhFNg,805
+xm_slurm/utils.py,sha256=9w98HlXF0U9cKKtoB8QtGm0CnB0MnnzBARKlbbVNNpU,6211
+xm_slurm/api/__init__.py,sha256=cyao3LZ3uLftu1wIv1aN7Qvsl6gYzYpkxeehTHZ0fA8,1089
+xm_slurm/api/abc.py,sha256=-lS2OndnOuEiwNdr8ccQKkwMd1iDmKMmkBOSTvo5H5w,1816
+xm_slurm/api/models.py,sha256=_INVh0j-4-rRs0WASyg4fNB6NF1L1nUeGgQ6-XnbwsM,1610
+xm_slurm/api/sqlite/client.py,sha256=jAesCKDuYwnNcAxwJk_1b1TB8cT_QGbSjo1UE3mZjEQ,14037
+xm_slurm/api/web/client.py,sha256=uO67Y7fnQ-w__Vm_A5BEuy7Qi8wQcWk3vIsBGEBkyfk,6261
+xm_slurm/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xm_slurm/contrib/clusters/__init__.py,sha256=lIEHCVADz2zzMnT2ecZFJMu9YpLDbhntRDTiqPM_mTo,2279
+xm_slurm/contrib/clusters/drac.py,sha256=cTgayyBLQmYL5RVwjmImO9UXnsiYftT4JDOLms_UOAg,7546
+xm_slurm/experimental/parameter_controller.py,sha256=IrFzq104LkZrhzuirit5GUZDXDvv2bBSYNMh3orsiPY,8518
+xm_slurm/packaging/__init__.py,sha256=dh307yLpUT9KN7rJ1e9fYC6hegGKfZcGboUq9nGpDVQ,233
+xm_slurm/packaging/docker.py,sha256=-DWcB9qqbeHmIEqyfF0-v6xOT25ae90u2x-QZ7kluOw,13579
+xm_slurm/packaging/registry.py,sha256=Hq56KhqsQRxgr_y1EQhcZORlnrs13xY5vDGge5WEgYU,1134
+xm_slurm/packaging/router.py,sha256=ORBbY4oNPDUXsWgEvQzBmbWq1HEFFgTN_BnRVK0nads,2140
+xm_slurm/packaging/utils.py,sha256=KlU_GGkFH1Xu5VZkAMqRilmq6SV1iLai80beEZ3UQmw,616
+xm_slurm/scripts/_cloudpickle.py,sha256=dlJYf2SceOuUn8wi-ozuoYAQg71wqD2MUVOUCyOwWIY,647
+xm_slurm/scripts/cli.py,sha256=zzsQpvkx9VThAeQPM34iDK9wAWfCVCIIvLNI12UaMhw,2577
+xm_slurm/templates/docker/docker-bake.hcl.j2,sha256=7qSJl2VN5poz-Hh8Gjo7--qR-k3lmfGtBu2mNbfG2uA,1499
+xm_slurm/templates/docker/mamba.Dockerfile,sha256=Sgxr5IA5T-pT1Shumb5k3JngoG4pgCdBXjzqslFJdZI,753
+xm_slurm/templates/docker/python.Dockerfile,sha256=U4b4QVkopckQ0o9jJIE7d_M6TvExEYlYDirNwCoZ7W4,865
+xm_slurm/templates/docker/uv.Dockerfile,sha256=L2UJMX2c8waMdrRhiqPytQe3pTBu6u5PpMhJYsKkbEg,1040
+xm_slurm/templates/slurm/entrypoint.bash.j2,sha256=MRdSVwgGrgQdpEhqfkP35IidgsblrtVXB1YWzvE9hkk,666
+xm_slurm/templates/slurm/job-array.bash.j2,sha256=7cc0nZvEcHhZoo7jXI3fJWgMcc6z5H5FmopPRaklylI,637
+xm_slurm/templates/slurm/job-group.bash.j2,sha256=9H3zfJy8RZGFf00ZQJGmMEPyWQ9YMZfvGoD4Q8hMx9Y,1244
+xm_slurm/templates/slurm/job.bash.j2,sha256=GBKY3DPCODPTtEBfuvfaZAua_ZEd5cqPrShtPGE_IpY,2174
+xm_slurm/templates/slurm/fragments/monitor.bash.j2,sha256=ri5FgoKs6_bQVf5DO8SL4rJf4UsLxV34aOV-OD8VWDU,2526
+xm_slurm/templates/slurm/fragments/proxy.bash.j2,sha256=VJLglZo-Nvx9R-qe3rHTxr07CylTQ6Z9NwBzvIpAZrA,814
+xm_slurm/templates/slurm/library/retry.bash,sha256=bLe59qvfWEk17rE1wZ4EHiHba3RvR2WWZPq-kSe8RAA,2164
+xm_slurm/templates/slurm/runtimes/apptainer.bash.j2,sha256=XxAQWLxZogL7zjn7tuzKn-DkYUJMx_HjaRzpVkz97lM,2414
+xm_slurm/templates/slurm/runtimes/podman.bash.j2,sha256=8N1ZtwHyXxP-Cjo4HBPsJiZXcTvf7q2GzvW9ao8_aok,1208
+xmanager_slurm-0.4.19.dist-info/METADATA,sha256=paJPyvR8SoMbGEo2SAvGTiYK2JHXJLdbC9KEGRLqnXs,1007
+xmanager_slurm-0.4.19.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+xmanager_slurm-0.4.19.dist-info/entry_points.txt,sha256=_HLGmLgxuQLOPmF2gOFYDVq2HqtMVD_SzigHvUh8TCY,49
+xmanager_slurm-0.4.19.dist-info/licenses/LICENSE.md,sha256=IxstXr3MPHwTJ5jMrByHrQsR1ZAGQ2U_uz_4qzI_15Y,11756
+xmanager_slurm-0.4.19.dist-info/RECORD,,

xmanager_slurm-0.4.19.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

xmanager_slurm-0.4.19.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+xm = xm_slurm.scripts.cli:main