astro-plasma 1.0.1__tar.gz

astro_plasma-1.0.1/.gitattributes

@@ -0,0 +1,3 @@
+cloudy-codes/** linguist-vendored=true
+misc/** linguist-vendored=true
+example-scripts/** linguist-vendored=true

astro_plasma-1.0.1/.github/scripts/loc_badge.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+Count the lines of code in the repository and render the badge SVG.
+
+Replaces shadowmoose/GHA-LoC-Badge, which is pinned at its only release (1.0.0,
+2020), still declares ``using: node12`` and reports its results with the retired
+``set-output`` command.  There is no newer tag to upgrade to, so the behaviour is
+reproduced here instead: the same badge layout, and results written to
+``$GITHUB_OUTPUT``.
+
+Only files tracked by git are counted, which keeps the total independent of
+whatever untracked material happens to sit in the working tree on a runner.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+# Layout constants taken from the badge this replaces, so the rendered SVG is
+# unchanged for a given count.  The label is fixed, hence a fixed text length;
+# digits and separators in the value each advance by 64 units at font-size 110.
+LABEL_TEXT_LENGTH = 747
+VALUE_ADVANCE_PER_CHAR = 64
+TEXT_SIDE_PADDING = 100
+
+SVG_TEMPLATE = """<svg width="{width}" height="20" viewBox="0 0 {total} 200" xmlns="http://www.w3.org/2000/svg">
+  <linearGradient id="a" x2="0" y2="100%">
+    <stop offset="0" stop-opacity=".1" stop-color="#EEE"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <mask id="m"><rect width="{total}" height="200" rx="30" fill="#FFF"/></mask>
+  <g mask="url(#m)">
+    <rect width="{label_w}" height="200" fill="#555"/>
+    <rect width="{value_w}" height="200" fill="{color}" x="{label_w}"/>
+    <rect width="{total}" height="200" fill="url(#a)"/>
+  </g>
+  <g fill="#fff" text-anchor="start" font-family="Verdana,DejaVu Sans,sans-serif" font-size="110">
+    <text x="60" y="148" textLength="{label_len}" fill="#000" opacity="0.25">{label}</text>
+    <text x="50" y="138" textLength="{label_len}">{label}</text>
+    <text x="{value_shadow_x}" y="148" textLength="{value_len}" fill="#000" opacity="0.25">{value}</text>
+    <text x="{value_x}" y="138" textLength="{value_len}">{value}</text>
+  </g>
+{gap}
+</svg>"""
+
+# The replaced action emitted a two-space line before the closing tag and no
+# final newline.  Kept as a placeholder so the badge stays byte-identical
+# without leaving trailing whitespace in this file for the linters to strip.
+SVG_GAP = "  "
+
+
+def tracked_files(root: Path) -> list[str]:
+    out = subprocess.run(
+        ["git", "-C", str(root), "ls-files", "-z"],
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout
+    return [name for name in out.split("\0") if name]
+
+
+def is_hidden(name: str) -> bool:
+    """
+    True when any component of the path starts with a dot.
+
+    The action being replaced walked the working tree and skipped dot-prefixed
+    entries, so .github, .gitignore and friends never reached the total.
+    """
+    return any(part.startswith(".") for part in name.split("/"))
+
+
+def count_lines(path: Path) -> int | None:
+    """
+    Line count for a text file, or None when the file looks binary.
+    """
+    try:
+        data = path.read_bytes()
+    except OSError:
+        return None
+    if b"\0" in data:
+        return None
+    # Matches the replaced action, which split the text on newlines and took the
+    # length -- so a trailing newline contributes a final empty line.
+    return data.count(b"\n") + 1
+
+
+def render(label: str, value: str, color: str) -> str:
+    label_w = LABEL_TEXT_LENGTH + TEXT_SIDE_PADDING
+    value_len = VALUE_ADVANCE_PER_CHAR * len(value)
+    value_w = value_len + TEXT_SIDE_PADDING
+    total = label_w + value_w
+    return SVG_TEMPLATE.format(
+        width=f"{total / 10:g}",
+        total=total,
+        label_w=label_w,
+        value_w=value_w,
+        color=color,
+        label_len=LABEL_TEXT_LENGTH,
+        label=label,
+        value_len=value_len,
+        value=value,
+        value_x=label_w + 45,
+        value_shadow_x=label_w + 55,
+        gap=SVG_GAP,
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", default=".", help="Repository root (default: %(default)s)")
+    parser.add_argument("--ignore", default="", help="Regex alternation of paths to skip")
+    parser.add_argument("--badge", required=True, help="Path of the SVG to write")
+    parser.add_argument("--label", default="Lines of Code", help="Badge label (default: %(default)s)")
+    parser.add_argument("--color", default="#08C", help="Badge value colour (default: %(default)s)")
+    args = parser.parse_args()
+
+    root = Path(args.root).resolve()
+    ignore = re.compile(args.ignore) if args.ignore else None
+
+    total_lines = 0
+    counted_files = 0
+    for name in tracked_files(root):
+        if is_hidden(name):
+            continue
+        if ignore is not None and ignore.search(name):
+            continue
+        lines = count_lines(root / name)
+        if lines is None:
+            continue
+        total_lines += lines
+        counted_files += 1
+
+    badge_path = Path(args.badge)
+    badge_path.parent.mkdir(parents=True, exist_ok=True)
+    badge_path.write_text(render(args.label, f"{total_lines:,}", args.color))
+
+    print(f"Scanned: {counted_files}")
+    print(f"Line Count: {total_lines}")
+
+    # Environment files, the supported replacement for the set-output command.
+    github_output = os.environ.get("GITHUB_OUTPUT")
+    if github_output:
+        with open(github_output, "a") as handle:
+            handle.write(f"counted_files={counted_files}\n")
+            handle.write(f"total_lines={total_lines}\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

astro_plasma-1.0.1/.github/scripts/register_freya_runner.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Register a GitHub self-hosted runner for this repository on Freya.
+#
+# Required:
+#   RUNNER_TOKEN   One-time registration token from:
+#                  Repo -> Settings -> Actions -> Runners -> New self-hosted runner
+#
+# Optional env vars:
+#   REPO_URL            default: https://github.com/dutta-alankar/AstroPlasma
+#   RUNNER_ROOT         default: $HOME/actions-runner-astroplasma
+#   RUNNER_VERSION      default: 2.326.0
+#   RUNNER_NAME         default: <hostname>-gpu
+#   RUNNER_LABELS       default: self-hosted,linux,freya,gpu,slurm
+#   RUNNER_WORKDIR      default: _work
+#   START_MODE          default: interactive (interactive|nohup)
+#   FORCE_RECONFIGURE   default: 0 (set to 1 to re-run config with --replace)
+
+REPO_URL="${REPO_URL:-https://github.com/dutta-alankar/AstroPlasma}"
+RUNNER_ROOT="${RUNNER_ROOT:-$HOME/actions-runner-astroplasma}"
+RUNNER_VERSION="${RUNNER_VERSION:-2.326.0}"
+RUNNER_NAME="${RUNNER_NAME:-$(hostname -s)-gpu}"
+RUNNER_LABELS="${RUNNER_LABELS:-self-hosted,linux,freya,gpu,slurm}"
+RUNNER_WORKDIR="${RUNNER_WORKDIR:-_work}"
+START_MODE="${START_MODE:-interactive}"
+FORCE_RECONFIGURE="${FORCE_RECONFIGURE:-0}"
+
+if [[ -z "${RUNNER_TOKEN:-}" ]]; then
+  echo "error: RUNNER_TOKEN is required." >&2
+  exit 1
+fi
+
+mkdir -p "${RUNNER_ROOT}"
+cd "${RUNNER_ROOT}"
+
+RUNNER_TGZ="actions-runner-linux-x64-${RUNNER_VERSION}.tar.gz"
+RUNNER_URL="https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/${RUNNER_TGZ}"
+
+if [[ ! -x "./config.sh" ]]; then
+  echo "Downloading GitHub Actions runner ${RUNNER_VERSION}..."
+  curl -fsSL -o "${RUNNER_TGZ}" "${RUNNER_URL}"
+  tar xzf "${RUNNER_TGZ}"
+  rm -f "${RUNNER_TGZ}"
+fi
+
+if [[ -f ./.runner && "${FORCE_RECONFIGURE}" != "1" ]]; then
+  echo "Runner already configured in ${RUNNER_ROOT}."
+  echo "Set FORCE_RECONFIGURE=1 to reconfigure with --replace."
+else
+  echo "Configuring runner ${RUNNER_NAME} for ${REPO_URL}..."
+  ./config.sh \
+    --url "${REPO_URL}" \
+    --token "${RUNNER_TOKEN}" \
+    --name "${RUNNER_NAME}" \
+    --labels "${RUNNER_LABELS}" \
+    --work "${RUNNER_WORKDIR}" \
+    --unattended \
+    --replace
+fi
+
+case "${START_MODE}" in
+  interactive)
+    cat <<MSG
+Runner is configured.
+Start it in the current shell with:
+  cd ${RUNNER_ROOT}
+  ./run.sh
+MSG
+    ;;
+  nohup)
+    LOG_FILE="${RUNNER_ROOT}/runner-nohup.log"
+    nohup ./run.sh >"${LOG_FILE}" 2>&1 &
+    echo "Runner started in background (nohup)."
+    echo "Log: ${LOG_FILE}"
+    ;;
+  *)
+    echo "error: START_MODE must be 'interactive' or 'nohup'" >&2
+    exit 1
+    ;;
+esac

astro_plasma-1.0.1/.github/scripts/submit_freya_gpu_test.sh

@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Submit GPU tests to Freya Slurm and block until completion.
+
+if ! command -v sbatch >/dev/null 2>&1; then
+  echo "error: sbatch not found. This job must run on a Freya node with Slurm available." >&2
+  exit 1
+fi
+
+REPO_ROOT="${GITHUB_WORKSPACE:-$(pwd)}"
+SLURM_SCRIPT="$(mktemp -t astroplasma-gpu-XXXXXX.sbatch)"
+
+cat >"${SLURM_SCRIPT}" <<EOF
+#!/usr/bin/env bash
+#SBATCH --job-name=astroplasma-gpu-ci
+#SBATCH --partition=p.gpu
+#SBATCH --nodes=1            # Request 1 or more full nodes
+#SBATCH --constraint="gpu"   #   providing GPUs.
+#SBATCH --gres=gpu:1    # Request 1 GPU per node.
+#SBATCH --ntasks-per-node=1  # Run one task per GPU
+#SBATCH --cpus-per-task=1    #   using 1 cores for each task.
+#SBATCH --mail-type=none
+#SBATCH --time=00:45:00
+#SBATCH --output=${REPO_ROOT}/slurm-%j.out
+
+set -euo pipefail
+
+module purge
+module load cuda/12.8 gcc/12 openmpi/4.1
+
+export LD_LIBRARY_PATH="/mpcdf/soft/SLE_15/packages/skylake/openmpi/gcc_12-12.1.0/4.1.8/lib:${LD_LIBRARY_PATH:-}"
+
+cd "${REPO_ROOT}"
+
+if [[ ! -f .venv/bin/activate ]]; then
+  echo "error: .venv is missing in ${REPO_ROOT}. Ensure workflow step 'Prepare virtual environment' ran." >&2
+  exit 1
+fi
+
+source .venv/bin/activate
+
+if [[ -x .venv/bin/uv ]]; then
+  UV_BIN=.venv/bin/uv
+elif command -v uv >/dev/null 2>&1; then
+  UV_BIN="$(command -v uv)"
+else
+  echo "error: uv is unavailable. Ensure workflow prep step installs dependencies with uv." >&2
+  exit 1
+fi
+
+# Derive the header location from the venv interpreter itself, so this keeps
+# working when the Python version changes.
+PY_INCLUDE="\$(python -c 'import sysconfig; print(sysconfig.get_paths()["include"])')"
+MPICC=/mpcdf/soft/SLE_15/packages/skylake/openmpi/gcc_12-12.1.0/4.1.8/bin/mpicc
+
+MPICC="\${MPICC}" \
+CPPFLAGS="-I\${PY_INCLUDE}" \
+CFLAGS="-I\${PY_INCLUDE}" \
+"\${UV_BIN}" pip install --python "${REPO_ROOT}/.venv/bin/python" \
+  --force-reinstall --no-cache-dir --no-binary=mpi4py mpi4py
+
+export RUN_ON_CUDA=1
+python -m pytest tests/test_cuda.py -v
+EOF
+
+chmod +x "${SLURM_SCRIPT}"
+
+echo "Submitting Slurm job with script: ${SLURM_SCRIPT}"
+JOB_ID="$(sbatch --parsable "${SLURM_SCRIPT}" | cut -d';' -f1)"
+
+if [[ -z "${JOB_ID}" ]]; then
+  echo "error: failed to parse Slurm job id from sbatch output" >&2
+  exit 1
+fi
+
+echo "Submitted job id: ${JOB_ID}"
+
+LOG_FILE="${REPO_ROOT}/slurm-${JOB_ID}.out"
+
+while true; do
+  STATE="$(sacct -j "${JOB_ID}" --format=State --noheader 2>/dev/null | head -n1 | awk '{print $1}')"
+  if [[ -z "${STATE}" ]]; then
+    STATE="$(squeue -j "${JOB_ID}" -h -o "%T" 2>/dev/null | head -n1 || true)"
+  fi
+
+  echo "Job ${JOB_ID} state: ${STATE:-UNKNOWN}"
+
+  case "${STATE}" in
+    COMPLETED)
+      break
+      ;;
+    FAILED|CANCELLED|TIMEOUT|PREEMPTED|NODE_FAIL|OUT_OF_MEMORY|BOOT_FAIL|DEADLINE)
+      if [[ -f "${LOG_FILE}" ]]; then
+        echo "--- Slurm log tail (${LOG_FILE}) ---"
+        tail -n 200 "${LOG_FILE}" || true
+      fi
+      exit 1
+      ;;
+    PENDING|CONFIGURING|RUNNING|COMPLETING|"")
+      ;;
+    *)
+      ;;
+  esac
+
+  sleep 20
+done
+
+if [[ -f "${LOG_FILE}" ]]; then
+  echo "--- Slurm log tail (${LOG_FILE}) ---"
+  tail -n 200 "${LOG_FILE}" || true
+fi
+
+echo "Slurm GPU test job ${JOB_ID} completed successfully."

astro_plasma-1.0.1/.github/workflows/AstroPlasma.yml

@@ -0,0 +1,29 @@
+name: AstroPlasma Unit tests
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  python-env:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v5
+    - uses: actions/setup-python@v6
+      with:
+        python-version: '3.11'
+    # The working directory used to be captured with mathiasvr/command-output,
+    # which is Node 16 and has had no release since 2023.  It only ever ran
+    # `pwd`, which after checkout is exactly github.workspace, so the step goes
+    # rather than being replaced.
+    - name: Install AstroPlasma dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install uv
+        uv pip install --system -r requirements/requirements-dev.txt
+    - name: Test AstroPlasma
+      run: |
+        export PYTHONPATH=${{ github.workspace }}
+        pytest

astro_plasma-1.0.1/.github/workflows/freya-slurm-gpu.yml

@@ -0,0 +1,70 @@
+name: Freya Slurm GPU Test
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+  PYTHON_VERSION: '3.14'
+
+on:
+  workflow_dispatch:
+    inputs:
+      approvers:
+        description: Comma-separated GitHub usernames allowed to approve this run
+        required: false
+        default: dutta-alankar
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+
+jobs:
+  approval-gate:
+    name: Await Approval
+    runs-on: ubuntu-latest
+    if: github.event_name == 'workflow_dispatch' || github.event.pull_request.draft == false
+    steps:
+    - name: Manual approval
+      uses: trstringer/manual-approval@v1
+      with:
+        secret: ${{ github.token }}
+        approvers: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.approvers || github.repository_owner }}
+        minimum-approvals: 1
+        issue-title: Approve Freya Slurm GPU test
+        issue-body: |
+          Approve this run to submit a GPU test job to Freya Slurm.
+          Ref: ${{ github.ref }}
+          SHA: ${{ github.sha }}
+
+  freya-gpu-slurm-test:
+    name: Submit Slurm GPU Test
+    needs: approval-gate
+    runs-on: [self-hosted, linux, freya]
+    timeout-minutes: 90
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v5
+
+    - name: Prepare virtual environment (CUDA + test deps)
+      run: |
+        set -euo pipefail
+        module purge
+        module load cuda/12.8 gcc/12 openmpi/4.1
+
+        if ! command -v uv >/dev/null 2>&1; then
+          echo "error: uv is not available on this runner PATH" >&2
+          exit 1
+        fi
+
+        # 'module purge' drops conda from PATH, leaving the system python3 (3.6),
+        # which uv refuses to use. Let uv provide the interpreter instead.
+        uv python install "${PYTHON_VERSION}"
+        uv venv --python "${PYTHON_VERSION}" .venv
+        .venv/bin/python --version
+
+        uv pip install --python .venv/bin/python -r requirements/requirements-dev.txt
+        uv pip install --python .venv/bin/python cupy-cuda12x
+
+        .venv/bin/python -c "import cupy as cp; print('cupy', cp.__version__)"
+
+    - name: Ensure submit script is executable
+      run: chmod +x .github/scripts/submit_freya_gpu_test.sh
+
+    - name: Submit and monitor Slurm GPU job
+      run: .github/scripts/submit_freya_gpu_test.sh

astro_plasma-1.0.1/.github/workflows/lines_of_code.yml

@@ -0,0 +1,47 @@
+name: Count lines of code
+on:
+  push:
+    branches: [main]
+
+jobs:
+  lines_of_code_job:
+    runs-on: ubuntu-latest
+    name: Count lines of code
+    # Needed so the built-in GITHUB_TOKEN may push the badge to the badges
+    # branch; the default token is read-only when the repository opts into
+    # restricted workflow permissions.
+    permissions:
+      contents: write
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v5
+
+    # Was shadowmoose/GHA-LoC-Badge@1.0.0, which is pinned at its only release
+    # (2020), still declares Node 12 and reports through the retired set-output
+    # command -- six of this job's seven deprecation warnings came from it, and
+    # there is no newer tag to move to.  The script reproduces it exactly: the
+    # same files counted, the same total, and a byte-identical SVG.
+    - name: Count lines of code
+      id: badge
+      env:
+        LOC_IGNORE: misc|example-scripts|cloudy-codes|requirements|astro_plasma/data|README.md|codemeta.json|LICENSE|poetry.lock|poetry.toml|tests/sample_spectrum.txt|pyproject.toml
+      run: |
+        python3 .github/scripts/loc_badge.py \
+          --ignore "$LOC_IGNORE" \
+          --badge ./misc/lines_of_code.svg
+
+    - name: Print the output
+      run: |
+        echo "Scanned: ${{ steps.badge.outputs.counted_files }}";
+        echo "Line Count: ${{ steps.badge.outputs.total_lines }}";
+
+    - name: Deploy to badges branch
+      uses: peaceiris/actions-gh-pages@v4
+      with:
+        publish_dir: ./misc
+        publish_branch: badges
+        # The built-in token, rather than a personal access token that has to be
+        # rotated by hand and silently breaks this job when it lapses.
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        user_name: github-actions[bot]
+        user_email: github-actions[bot]@users.noreply.github.com

astro_plasma-1.0.1/.github/workflows/release.yml

@@ -0,0 +1,134 @@
+name: Release
+
+# Pushing a release_v* tag is the whole trigger: the tag is the source of truth
+# for the version, and the job refuses to go further if it disagrees with
+# pyproject.toml.  Order is deliberate -- build once, rehearse on TestPyPI, then
+# the irreversible upload to PyPI, and only then the GitHub release.
+on:
+  push:
+    tags: [release_v*]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build distributions
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v5
+
+    - uses: actions/setup-python@v6
+      with:
+        python-version: '3.11'
+
+    - name: Check the tag matches the packaged version
+      run: |
+        tag_version="${GITHUB_REF_NAME#release_v}"
+        pkg_version="$(python -c 'import tomllib; print(tomllib.load(open("pyproject.toml","rb"))["project"]["version"])')"
+        echo "tag: $GITHUB_REF_NAME -> $tag_version, pyproject.toml: $pkg_version"
+        if [ "$tag_version" != "$pkg_version" ]; then
+          echo "::error::Tag $GITHUB_REF_NAME implies version $tag_version but pyproject.toml declares $pkg_version"
+          exit 1
+        fi
+
+    - name: Build the sdist and the wheel
+      run: |
+        python -m pip install --upgrade pip build twine
+        python -m build
+
+    - name: Check the metadata
+      run: twine check dist/*
+
+    # PyPI versions are permanent, so verify the payload before it is uploaded
+    # rather than after.  The bulk Cloudy tables are downloaded on demand and
+    # must never be packaged; the two small tables the code reads at runtime
+    # must always be.
+    - name: Check the wheel contents
+      run: |
+        python - <<'PY'
+        import glob
+        import sys
+        import zipfile
+
+        wheel = glob.glob("dist/*.whl")[0]
+        names = zipfile.ZipFile(wheel).namelist()
+
+        leaked = [n for n in names if n.endswith((".h5", ".h5data"))]
+        required = ["astro_plasma/data/solar_GASS10.abn", "astro_plasma/data/cooltable.dat"]
+        missing = [n for n in required if n not in names]
+
+        if leaked:
+            print(f"::error::Cloudy data files must not be packaged, found: {leaked[:5]}")
+        for name in missing:
+            print(f"::error::{name} is read at runtime and is missing from the wheel")
+        if leaked or missing:
+            sys.exit(1)
+        print(f"{wheel}: {len(names)} entries, runtime tables present, no Cloudy data")
+        PY
+
+    - uses: actions/upload-artifact@v7
+      with:
+        name: distributions
+        path: dist/
+        if-no-files-found: error
+
+  testpypi:
+    name: Publish to TestPyPI
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/astro-plasma
+    permissions:
+      id-token: write  # mints the OIDC token for trusted publishing
+    steps:
+    - uses: actions/download-artifact@v8
+      with:
+        name: distributions
+        path: dist/
+
+    - uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        repository-url: https://test.pypi.org/legacy/
+        # A re-run of a tag that already reached TestPyPI should not fail here;
+        # the real PyPI step below is deliberately left strict.
+        skip-existing: true
+
+  pypi:
+    name: Publish to PyPI
+    needs: testpypi
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/astro-plasma
+    permissions:
+      id-token: write
+    steps:
+    - uses: actions/download-artifact@v8
+      with:
+        name: distributions
+        path: dist/
+
+    - uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    name: Create the GitHub release
+    needs: pypi
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write  # gh release create writes a tag-backed release
+    steps:
+    - uses: actions/download-artifact@v8
+      with:
+        name: distributions
+        path: dist/
+
+    - name: Create the release and attach the distributions
+      env:
+        GH_TOKEN: ${{ github.token }}
+      run: |
+        gh release create "$GITHUB_REF_NAME" dist/* \
+          --repo "$GITHUB_REPOSITORY" \
+          --title "AstroPlasma ${GITHUB_REF_NAME#release_}" \
+          --generate-notes