snakemake-executor-plugin-aws-batch-flex 0.1.0__py3-none-any.whl

snakemake_executor_plugin_aws_batch_flex/headjob.py

@@ -0,0 +1,244 @@
+"""Runs inside the head job that `smkflex run` submits: restores Snakemake's .snakemake state,
+runs Snakemake on the unpacked workflow, then saves the state for the next run.
+
+`smkflex run` copies this file into the workflow bundle, so it only uses the standard library
+(and boto3, which comes with the S3 storage plugin)."""
+
+import io
+import os
+import signal
+import sqlite3
+import subprocess
+import sys
+import tarfile
+import tempfile
+import threading
+
+# The parts of .snakemake that make a rerun behave like one on the same machine: what was
+# made with which code and parameters, and which jobs didn't finish. Conda envs, local
+# copies of storage files and the like are left out.
+STATE_DIRS = ("metadata", "incomplete", "log")
+# The same records with Snakemake's --persistence-backend db (SQLite at its default place)
+DB = os.path.join(".snakemake", "metadata.db")
+SAVE_EVERY = 300  # seconds between saves of the state while Snakemake runs (unchanged: skipped)
+WRAPPER_PREFIX = "https://github.com/snakemake/snakemake-wrappers/raw/"
+
+
+def _s3(url):
+    import boto3
+
+    bucket, _, key = url[len("s3://"):].partition("/")
+    return boto3.client("s3"), bucket, key
+
+
+def get(url):
+    """The file at an s3:// URL or local path, or None if there is none."""
+    if url.startswith("s3://"):
+        s3, bucket, key = _s3(url)
+        try:
+            return s3.get_object(Bucket=bucket, Key=key)["Body"].read()
+        except s3.exceptions.NoSuchKey:
+            return None
+    try:
+        with open(url, "rb") as f:
+            return f.read()
+    except FileNotFoundError:
+        return None
+
+
+def put(url, data):
+    if url.startswith("s3://"):
+        s3, bucket, key = _s3(url)
+        s3.put_object(Bucket=bucket, Key=key, Body=data)
+    else:
+        os.makedirs(os.path.dirname(url) or ".", exist_ok=True)
+        with open(url, "wb") as f:
+            f.write(data)
+
+
+def delete(url):
+    if url.startswith("s3://"):
+        s3, bucket, key = _s3(url)
+        s3.delete_object(Bucket=bucket, Key=key)
+    elif os.path.exists(url):
+        os.remove(url)
+
+
+def unpack(data, dest):
+    with tarfile.open(fileobj=io.BytesIO(data)) as t:
+        if hasattr(tarfile, "data_filter"):
+            t.extractall(dest, filter="data")
+        else:
+            t.extractall(dest)
+
+
+def _state_files():
+    """[(path, stat)] of the state files now; files removed meanwhile (a job ended) are left out.
+    The database's write-ahead log counts too: recent changes can be only there."""
+    out = []
+    for p in (DB, DB + "-wal"):
+        try:
+            out.append((p, os.stat(p)))
+        except OSError:
+            pass
+    for d in STATE_DIRS:
+        for root, _dirs, names in os.walk(os.path.join(".snakemake", d)):
+            for n in names:
+                p = os.path.join(root, n)
+                try:
+                    out.append((p, os.stat(p)))
+                except OSError:
+                    pass
+    return sorted(out, key=lambda f: f[0])
+
+
+def save_state(url, last=None):
+    """Upload the state. Snakemake may still be running, so files can change or go while they're
+    read; those are left for the next save. Returns what was saved: pass it back as `last` and
+    an unchanged state isn't uploaded again."""
+    files = _state_files()
+    saved = [(p, st.st_size, st.st_mtime_ns) for p, st in files]
+    if saved == last:
+        return last
+    buf = io.BytesIO()
+    with tarfile.open(fileobj=buf, mode="w:gz") as t:
+        for p, st in files:
+            if p == DB + "-wal":
+                continue  # in the snapshot of the database
+            try:
+                if p == DB:
+                    data = _db_snapshot()
+                else:
+                    with open(p, "rb") as f:
+                        data = f.read()
+            except (OSError, sqlite3.Error):
+                continue
+            info = tarfile.TarInfo(p)
+            info.size, info.mtime, info.mode = len(data), int(st.st_mtime), st.st_mode & 0o777
+            t.addfile(info, io.BytesIO(data))
+    put(url, buf.getvalue())
+    return saved
+
+
+def _db_snapshot():
+    """The database as one consistent file, with what's in its write-ahead log, although
+    Snakemake may be writing to it: copying the file itself could catch it halfway."""
+    fd, tmp = tempfile.mkstemp(suffix=".db")
+    os.close(fd)
+    try:
+        src, dst = sqlite3.connect(DB), sqlite3.connect(tmp)
+        try:
+            src.backup(dst)
+        finally:
+            src.close()
+            dst.close()
+        with open(tmp, "rb") as f:
+            return f.read()
+    finally:
+        os.remove(tmp)
+
+
+class StateSaver:
+    """Saves the state every `every` seconds while Snakemake runs, and at once after wake.set(),
+    so a head job that dies (out of memory, instance lost) or is killed while stopping keeps
+    most of it."""
+
+    def __init__(self, url, every):
+        self.url, self.every, self.last = url, every, None
+        self.wake, self.done = threading.Event(), threading.Event()
+        self.thread = threading.Thread(target=self._run, daemon=True)
+        self.thread.start()
+
+    def _run(self):
+        while True:
+            self.wake.wait(self.every)
+            self.wake.clear()
+            if self.done.is_set():
+                return
+            self._save()
+
+    def _save(self):
+        try:
+            self.last = save_state(self.url, self.last)
+            return True
+        except Exception as e:
+            print(f"[smkflex] could not save .snakemake state: {e!r}", file=sys.stderr)
+            return False
+
+    def finish(self):
+        """Stop the saves in the background, then save the final state. True if it was saved."""
+        self.done.set()
+        self.wake.set()
+        self.thread.join()
+        return self._save()
+
+
+GIT_SHIM = """#!{python}
+# Stand-in for git, which the image doesn't have: Snakemake runs `git ls-files` to find the
+# workflow's source files, and these are exactly the files smkflex sent.
+import sys
+if sys.argv[1:2] == ["ls-files"]:
+    sys.stdout.write(open({files!r}).read())
+else:
+    sys.exit("git is not installed in the head job's image (smkflex only provides git ls-files)")
+"""
+
+
+def git_shim():
+    """Directory with a stand-in `git`, or None when the image has a real one."""
+    import shutil
+
+    if shutil.which("git"):
+        return None
+    d = os.path.abspath(os.path.join(".smkflex", "bin"))
+    os.makedirs(d, exist_ok=True)
+    path = os.path.join(d, "git")
+    with open(path, "w") as f:
+        f.write(GIT_SHIM.format(python=sys.executable, files=os.path.abspath(".smkflex/files.txt")))
+    os.chmod(path, 0o755)
+    return d
+
+
+def main(argv):
+    state_url, args = argv[0], argv[1:]
+    state = get(state_url)
+    if state:
+        unpack(state, ".")
+        print("[smkflex] restored .snakemake state from the previous run", file=sys.stderr)
+    site = os.path.abspath(os.path.join(".smkflex", "site"))
+    env = dict(os.environ)
+    env["PYTHONPATH"] = site + (os.pathsep + env["PYTHONPATH"] if env.get("PYTHONPATH") else "")
+    shim = git_shim()
+    if shim:
+        env["PATH"] = shim + os.pathsep + env.get("PATH", "")
+    cmd = [sys.executable, "-m", "snakemake", "--profile", ".smkflex/profile", *args]
+    if not any(a == "--wrapper-prefix" or a.startswith("--wrapper-prefix=") for a in args):
+        # Without a prefix, Snakemake fetches version-tagged wrappers with git clone, and the
+        # head job's image usually has no git; the same files are on GitHub over plain HTTPS.
+        cmd += ["--wrapper-prefix", WRAPPER_PREFIX]
+    print("[smkflex] " + " ".join(cmd), file=sys.stderr, flush=True)
+    proc = subprocess.Popen(cmd, env=env)
+    saver = StateSaver(state_url, SAVE_EVERY)
+
+    # `smkflex cancel` (Batch's terminate) sends SIGTERM; Snakemake cancels its jobs on SIGINT.
+    # The state is saved at once too, in case the head job is killed before Snakemake is done.
+    def stop(_sig, _frame):
+        proc.send_signal(signal.SIGINT)
+        saver.wake.set()
+
+    signal.signal(signal.SIGTERM, stop)
+    rc = proc.wait()
+    if saver.finish():
+        print("[smkflex] saved .snakemake state", file=sys.stderr)
+    bundle = os.environ.get("SMKFLEX_BUNDLE_URL")
+    if bundle:  # the uploaded workflow isn't needed any more
+        try:
+            delete(bundle)
+        except Exception as e:
+            print(f"[smkflex] could not remove {bundle}: {e!r}", file=sys.stderr)
+    print(f"[smkflex] snakemake exited with {rc}", file=sys.stderr)
+    return rc
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

snakemake_executor_plugin_aws_batch_flex/hints.py

@@ -0,0 +1,75 @@
+"""Plain-language hints for job failures with a known cause, from the end of the job's log."""
+
+import re
+from typing import List
+
+
+def known_problem_hints(log_lines: List[str]) -> List[str]:
+    """Plain-language explanations for failures with a known cause, from the job's log."""
+    text = "\n".join(log_lines)
+    hints = []
+    bad = " ".join(re.findall(r"unrecognized arguments:(.*)", text))
+    plugins = sorted(set(re.findall(r"--storage-([a-z0-9]+)-", bad)))
+    for name in plugins:
+        hints.append(
+            f"  hint: this machine has snakemake-storage-plugin-{name} installed but the job's "
+            f"Snakemake (from the AMI, or installed at job start) doesn't, and Snakemake passes "
+            f"every installed storage "
+            f"plugin's options to its jobs. Uninstall it here (pip uninstall "
+            f"snakemake-storage-plugin-{name}) or bake an AMI with --storage-plugin {name}."
+        )
+    if "pandas of Snakemake's env can't load in this image" in text and "pandas" in text.split("can't load in this image", 1)[1]:
+        hints.append(
+            "  hint: the image lacks a system library (named above) that the numpy and pandas of the AMI's "
+            "Snakemake need, and no conda from the AMI was there to lend one (aws-batch-flex-conda-path, EC2). "
+            "Many bioconda images keep theirs inside their own environment. If the Snakefile imports pandas, "
+            "set aws-batch-flex-conda-path, or use a Debian- or Ubuntu-based image for this rule."
+        )
+    missing = sorted(set(re.findall(r"ModuleNotFoundError: No module named '([A-Za-z0-9_.]+)'", text)))
+    for mod in missing:
+        hints.append(
+            f"  hint: Python couldn't import {mod}. If the Snakefile (or a file it includes) imports "
+            f"it, it's needed in every job too, because Snakemake reads the Snakefile there as well: "
+            f"add it to the AMI with scripts/update-ami.sh --extra-package {mod.split('.')[0]} (the pip "
+            f"name can differ), or to --aws-batch-flex-extra-packages for jobs that install Snakemake "
+            f"at start. If a script: imports it, it belongs in the rule's image or conda env."
+        )
+    if re.search(r"\(403\).*(HeadObject|GetObject|PutObject|ListObjects).*Forbidden|AccessDenied.*(GetObject|PutObject)", text):
+        hints.append(
+            "  hint: the job wasn't allowed to read or write the bucket. Jobs use the job role "
+            "(aws-batch-flex-job-role-arn), not your own login, and the Terraform setup only lets "
+            "it use the s3_prefix folder (s3://BUCKET/snakemake/...). Keep default-storage-prefix "
+            "inside that folder, or give the role access to the other one."
+        )
+    if "No space left on device" in text:
+        hints.append(
+            "  hint: the job ran out of disk. On EC2, all jobs on an instance share its disk "
+            "(root_volume_gib in Terraform), and disk_mb isn't enforced there: use a bigger "
+            "volume, a queue with bigger disks for this rule (batch_queue), or fewer jobs per "
+            "instance. On Fargate, raise the rule's disk_mb (up to 200 GiB)."
+        )
+    if re.search(r"SyntaxError: .*(in file /bin/sh\b|source code cannot contain null bytes)", text):
+        hints.append(
+            "  hint: the image has a Python ENTRYPOINT (such as [\"python3\"]) that the plugin "
+            "couldn't read from its registry (see the warning at the start), so Python was handed "
+            "/bin/sh as a script to run. Give the rule the entrypoint: "
+            "resources: batch_entrypoint='[\"python3\"]'."
+        )
+    # a script a shell: command runs that wasn't sent: python, Rscript, sh/bash
+    scripts = re.findall(r"can't open file '(?:/tmp/snakemake-job-\d+/)?([^']+)'", text)
+    scripts += re.findall(r"cannot open file '([^']+\.[Rr])': No such file", text)
+    scripts += re.findall(r"(?:^|\s)(\S+\.(?:sh|py|R|pl|rb|jl)): No such file", text, re.M)
+    scripts += re.findall(r"Can't open (\S+\.(?:sh|py|R|pl|rb|jl))", text)  # older dash
+    if scripts:
+        hints.append(
+            f"  hint: {', '.join(sorted(set(scripts)))} wasn't sent to the job. Jobs get the workflow folder "
+            "snakemake runs in, except what .gitignore excludes and single files over 10 MB. Is it "
+            "git-ignored, outside that folder, or made by an earlier rule without being its output?"
+        )
+    if not plugins and "unrecognized arguments" in text:
+        hints.append(
+            "  hint: the job's Snakemake didn't understand an option from this machine's "
+            "Snakemake; the two versions are probably too far apart (compare "
+            "`snakemake --version` here with the job's; 9.5 to 9.27 are known to mix fine)."
+        )
+    return hints

snakemake_executor_plugin_aws_batch_flex/hostenv.py

@@ -0,0 +1,221 @@
+"""Builds the Snakemake env that gets baked into the AMI and mounted into jobs.
+
+Python comes from uv's standalone builds and lives inside the env directory, so the env works
+in any glibc image as long as it's mounted at the same path. `.ready` is written last and jobs
+wait for it."""
+
+import argparse
+import email
+import os
+import re
+import shlex
+import sys
+import textwrap
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+
+DEFAULT_PATH = "/opt/snakemake-env"
+
+_SCRIPT = r"""#!/bin/bash
+set -euo pipefail
+ENV=@@ENV@@
+mkdir -p "$ENV"
+if [ -f "$ENV/.ready" ] && [ "$(cat "$ENV/.ready")" = @@STAMP@@ ]; then
+  echo "snakemake host env already up to date at $ENV"; exit 0
+fi
+rm -f "$ENV/.ready"
+export UV_CACHE_DIR="$ENV/.cache" UV_PYTHON_INSTALL_DIR="$ENV/python" UV_PYTHON_PREFERENCE=only-managed
+@@UV@@
+[ -n "$UV" ] || { echo "need curl, wget or python3+pip to install uv" >&2; exit 1; }
+$UV python install @@PYVER@@
+$UV venv --clear --python @@PYVER@@ "$ENV/venv"
+# exactly the versions on the machine that made this script (see bootstrap.locked)
+cat > "$ENV/constraints.txt" <<'SMK_PINS_EOF'
+@@PINS@@
+SMK_PINS_EOF
+$UV pip install --python "$ENV/venv/bin/python" -c "$ENV/constraints.txt" @@REQS@@
+"$ENV/venv/bin/python" -c "import snakemake; print('snakemake', snakemake.__version__)"
+rm -rf "$ENV/.cache"
+chmod -R a+rX "$ENV"
+echo @@STAMP@@ > "$ENV/.ready"
+echo "snakemake host env ready at $ENV"
+"""
+
+
+def _packages(storage_plugins: list[str]) -> list[str]:
+    return ["snakemake"] + [f"snakemake-storage-plugin-{p}" for p in storage_plugins]
+
+
+def default_requirements(storage_plugins: list[str], extra: list[str]) -> list[str]:
+    from .bootstrap import pinned
+
+    return [pinned(p) for p in _packages(storage_plugins)] + list(extra)
+
+
+def default_constraints(storage_plugins: list[str], extra: list[str] = ()) -> list[str]:
+    """Pins for the env: this machine's versions of Snakemake, the storage plugins and the extra
+    packages (e.g. pandas), and of everything they need."""
+    from packaging.requirements import InvalidRequirement, Requirement
+    from packaging.utils import canonicalize_name
+
+    from .bootstrap import locked
+
+    asked = {}
+    for r in extra:
+        try:
+            req = Requirement(r)
+        except InvalidRequirement:  # a URL or a path: installed as given, not pinned
+            continue
+        asked[canonicalize_name(req.name)] = req.specifier
+    pins, skipped = locked(_packages(storage_plugins) + list(asked))
+    # a version here that doesn't fit what's asked for (pandas<3 with pandas 3 here) isn't pinned
+    fits = [p for p in pins if asked.get(p.split("==")[0], None) is None
+            or asked[p.split("==")[0]].contains(p.split("==")[1], prereleases=True)]
+    skipped += [p for p in pins if p not in fits]
+    pins = fits
+    if skipped:
+        print(f"note: not pinned, since this machine's version doesn't fit what the packages ask for: "
+              f"{', '.join(skipped)}", file=sys.stderr)
+    return pins
+
+
+def install_script(env_path: str, python_version: str, requirements: list[str],
+                   constraints: list[str] = ()) -> str:
+    from .bootstrap import uv_snippet
+
+    stamp = shlex.quote("|".join([python_version, *sorted(requirements), *sorted(constraints)]))
+    return (
+        _SCRIPT.replace("@@ENV@@", shlex.quote(env_path))
+        .replace("@@STAMP@@", stamp)
+        .replace("@@PYVER@@", shlex.quote(python_version))
+        .replace("@@PINS@@", "\n".join(constraints))
+        .replace("@@REQS@@", " ".join(shlex.quote(r) for r in requirements))
+        .replace("@@UV@@", uv_snippet("$ENV/.uv", "$ENV/.uvlib"))
+    )
+
+
+_CONDA = r"""#!/bin/bash
+set -euo pipefail
+ROOT=@ROOT@
+if [ ! -x "$ROOT/bin/conda" ]; then
+  mkdir -p "$(dirname "$ROOT")"
+  case "$(uname -m)" in
+    x86_64) SUM=@X86_64@ ;;
+    aarch64) SUM=@AARCH64@ ;;
+    *) echo "no Miniforge checksum for $(uname -m)" >&2; exit 1 ;;
+  esac
+  curl -fsSL -o /tmp/miniforge.sh "https://github.com/conda-forge/miniforge/releases/download/@MINIFORGE@/Miniforge3-@MINIFORGE@-Linux-$(uname -m).sh"
+  echo "$SUM  /tmp/miniforge.sh" | sha256sum -c -
+  bash /tmp/miniforge.sh -b -p "$ROOT"
+  rm -f /tmp/miniforge.sh
+fi
+@ENVS@
+# git for jobs whose image has none: Snakemake needs it for pipelines loaded from GitHub
+# (module ... github(...), what snakedeploy sets up). conda-forge's git brings its own libraries,
+# so it works in any image; smkflex-bin holds only a link to it, for the end of jobs' PATH.
+if [ ! -x "$ROOT/envs/smkflex-git/bin/git" ]; then
+  "$ROOT/bin/conda" create -y -q -p "$ROOT/envs/smkflex-git" -c conda-forge git
+fi
+mkdir -p "$ROOT/smkflex-bin" && ln -sf ../envs/smkflex-git/bin/git "$ROOT/smkflex-bin/git"
+"$ROOT/bin/conda" clean -a -y -q || true
+chmod -R a+rX "$ROOT"
+echo "conda ready at $ROOT"
+"""
+
+# Miniforge for the AMI, with the sha256 of its installers (from its GitHub release)
+MINIFORGE = "26.7.2-0"
+MINIFORGE_SHA256 = {
+    "X86_64": "281b0ac7d550802efc81af633225a5e6116d29ae72f3ab4eae7168c3931a4c05",
+    "AARCH64": "89b786c8d2c8b0fda7553914c1314ae4ddaa094503802f279377b19ac4463cb2",
+}
+
+_CONDA_ENV = r"""cat > /tmp/env-@NAME@.yaml <<'SMK_ENV_EOF'
+@YAML@
+SMK_ENV_EOF
+if [ -d "$ROOT/envs/@NAME@" ]; then "$ROOT/bin/conda" env update -n @NAME@ -f /tmp/env-@NAME@.yaml --prune -q
+else "$ROOT/bin/conda" env create -n @NAME@ -f /tmp/env-@NAME@.yaml -q; fi"""
+
+
+def conda_script(conda_path: str, envs: list) -> str:
+    """Install Miniforge at conda_path and create the named environments (name, yaml text).
+    Named environments land in <conda_path>/envs/<name>, so `conda: "<name>"` finds them."""
+    blocks = []
+    for name, yaml_text in envs:
+        if not re.fullmatch(r"[A-Za-z0-9_.-]+", name):
+            raise ValueError(f"invalid environment name {name!r}")
+        blocks.append(_CONDA_ENV.replace("@NAME@", name).replace("@YAML@", yaml_text.rstrip()))
+    script = _CONDA.replace("@ROOT@", shlex.quote(conda_path)).replace("@MINIFORGE@", MINIFORGE)
+    for arch, sha in MINIFORGE_SHA256.items():
+        script = script.replace(f"@{arch}@", sha)
+    return script.replace("@ENVS@", "\n".join(blocks))
+
+
+def launch_template_userdata(script: str, includes: tuple = ()) -> str:
+    """MIME multipart user-data, the format AWS Batch launch templates require.
+
+    `includes` are existing user-data documents (e.g. the one in your current launch
+    template): multipart documents are merged part by part, untouched; a plain script is
+    wrapped as a shell-script part. Our installer is appended as the LAST part.
+    """
+    msg = MIMEMultipart("mixed", boundary="==SMKBOUNDARY==")
+    for text in includes:
+        parsed = email.message_from_string(text)
+        if parsed.is_multipart():
+            for part in parsed.get_payload():
+                msg.attach(part)
+        elif text.lstrip().startswith("#cloud-config"):
+            msg.attach(MIMEText(text, "cloud-config", "us-ascii"))
+        else:
+            msg.attach(MIMEText(text, "x-shellscript", "us-ascii"))
+    msg.attach(MIMEText(script, "x-shellscript", "us-ascii"))
+    del msg["MIME-Version"]  # re-added first, matching AWS's documented layout
+    return "MIME-Version: 1.0\n" + msg.as_string()
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(
+        prog="snakemake-batch-flex-host-env",
+        description=textwrap.dedent(__doc__).split("\n\n")[0],
+    )
+    ap.add_argument("what", choices=["script", "userdata", "conda"],
+                    help="script: shell script to run on an instance/AMI build; "
+                    "userdata: same, wrapped for an EC2 launch template; "
+                    "conda: script that installs Miniforge and creates --conda-env environments")
+    ap.add_argument("--path", default=DEFAULT_PATH, help=f"install dir (default {DEFAULT_PATH}); "
+                    "must match --aws-batch-flex-host-env-path")
+    ap.add_argument("--storage-plugin", action="append", default=[], metavar="NAME",
+                    help="storage plugin to include, e.g. s3 (repeatable)")
+    ap.add_argument("--extra-package", action="append", default=[], metavar="REQ",
+                    help="additional pip requirement (repeatable)")
+    ap.add_argument("--include", action="append", default=[], metavar="FILE",
+                    help="userdata only: existing user-data file to keep (repeatable), e.g. the "
+                    "decoded user-data of your current launch template. Our installer is "
+                    "appended after it.")
+    ap.add_argument("--conda-path", default="/opt/miniforge3", help="conda: install dir (mounted into jobs)")
+    ap.add_argument("--conda-env", action="append", default=[], metavar="FILE",
+                    help="conda: environment YAML to create (repeatable); the name is the file name")
+    ap.add_argument("--python-version", default=f"{sys.version_info[0]}.{sys.version_info[1]}")
+    a = ap.parse_args(argv)
+    if a.what == "conda":
+        envs = [(os.path.splitext(os.path.basename(f))[0], open(f).read()) for f in a.conda_env]
+        sys.stdout.write(conda_script(a.conda_path, envs))
+        return
+    if a.include and a.what != "userdata":
+        ap.error("--include only applies to 'userdata'")
+    includes = []
+    for f in a.include:
+        try:
+            includes.append(open(f, encoding="ascii").read())
+        except (OSError, UnicodeDecodeError) as e:
+            ap.error(f"cannot read --include {f}: {e} (user-data must be plain ASCII)")
+    script = install_script(
+        a.path, a.python_version, default_requirements(a.storage_plugin, a.extra_package),
+        default_constraints(a.storage_plugin, a.extra_package),
+    )
+    sys.stdout.write(
+        launch_template_userdata(script, tuple(includes)) if a.what == "userdata" else script
+    )
+
+
+if __name__ == "__main__":
+    main()