Add turnkey container build/push + model-fetch scripts for NIS submission

Since the automated session cannot build/push the GPU container or reach
quay.io/pytorch (no Docker daemon, blocked hosts) nor open the cross-repo PR
(GitHub scope), provide everything pre-filled so the maintainer can run it in
one sitting on a GPU/Docker host:

- containers/nis/build_and_push.sh: build + push the container, with the cu128
  LibTorch URL from cpp/README.md / build_main_hummer.sh baked in.
- containers/nis/fetch_models.sh: gdown the TorchScript model weights from the
  G-drive folder documented in cpp/README.md (runtime models + Zenodo test data).
- docs/nfcore_submission.md: concrete prerequisite commands using both scripts.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TRbz5C1u1pxcvB5DGYVZMo

Author: claude

containers/nis/build_and_push.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+#
+# Build and push the CellPheno NIS GPU container referenced by
+# modules/nf-core/cellpheno/nis (container "quay.io/nf-core/cellpheno-nis:1.0.0").
+#
+# Run this on a machine with Docker + a CUDA GPU + push access to the target
+# registry. It is the step the automated session cannot do (no Docker daemon,
+# blocked registry hosts). Once the image is pushed, the module's only remaining
+# lint failure (container-not-reachable) clears.
+#
+# Usage:
+#   bash containers/nis/build_and_push.sh [REGISTRY_IMAGE] [VERSION]
+# Examples:
+#   bash containers/nis/build_and_push.sh quay.io/nf-core/cellpheno-nis 1.0.0
+#   bash containers/nis/build_and_push.sh ghcr.io/chrisa142857/cellpheno-nis 1.0.0
+set -euo pipefail
+
+IMAGE="${1:-quay.io/nf-core/cellpheno-nis}"
+VERSION="${2:-1.0.0}"
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+
+# LibTorch CUDA build. The repo's cpp/README.md downloads LibTorch from
+# download.pytorch.org; cpp/build_main_hummer.sh targets CUDA 12.8 (cu128).
+# The Dockerfile defaults to the matching cu128 LibTorch; override via build-arg
+# if you need a different CUDA/LibTorch version.
+LIBTORCH_URL="${LIBTORCH_URL:-https://download.pytorch.org/libtorch/cu128/libtorch-cxx11-abi-shared-with-deps-2.7.0%2Bcu128.zip}"
+
+echo ">> Building ${IMAGE}:${VERSION} (LibTorch: ${LIBTORCH_URL})"
+docker build \
+    -f "${REPO_ROOT}/containers/nis/Dockerfile" \
+    --build-arg "LIBTORCH_URL=${LIBTORCH_URL}" \
+    --build-arg "NIS_VERSION=${VERSION}" \
+    -t "${IMAGE}:${VERSION}" \
+    "${REPO_ROOT}"
+
+echo ">> Pushing ${IMAGE}:${VERSION}"
+echo "   (run 'docker login quay.io' first if pushing to quay.io/nf-core)"
+docker push "${IMAGE}:${VERSION}"
+
+echo ">> Done. If you used a registry other than quay.io/nf-core/cellpheno-nis,"
+echo "   update the container line in modules/nf-core/cellpheno/nis/main.nf to match."

containers/nis/fetch_models.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+#
+# Fetch the TorchScript model weights the CellPheno NIS binary loads at runtime.
+# These are NOT baked into the container; they are passed to the module as the
+# `models` input (and are needed to prepare real test data for nf-core).
+#
+# Source: cpp/README.md -> G-drive model folder.
+#
+# Usage:
+#   pip install gdown
+#   bash containers/nis/fetch_models.sh [DEST_DIR]
+set -euo pipefail
+
+DEST="${1:-downloads/resource}"
+# G-drive folder with the NIS .pt models (see cpp/README.md).
+GDRIVE_MODELS_FOLDER="https://drive.google.com/drive/folders/12YGRtoW4DHftVyhaGoZMl-xdc02Mj9SB"
+
+mkdir -p "${DEST}"
+echo ">> Downloading NIS models into ${DEST}"
+gdown --folder "${GDRIVE_MODELS_FOLDER}" -O "${DEST}"
+
+echo ">> Expected files (loaded by cpp/main.cpp):"
+echo "   nis_unet_cpu.pt  grad_2Dto3D_<device>.pt  gnn_message_passing_<device>.pt"
+echo "   gnn_classifier_<device>.pt  flow_3DtoSeed.pt"
+echo ">> Note: only cuda:0 and cuda:1 device variants are provided."

docs/nfcore_submission.md

@@ -9,23 +9,37 @@ Reference: <https://nf-co.re/docs/contributing/contribute-components>
 
 ## One-time prerequisites (resolve the two external items)
 
-1. **Publish the container.** Build and push the image referenced by the module.
-   For the upstream PR the cleanest registry is the nf-core org namespace
-   (passes the lint registry-prefix check without an allowlist entry):
+1. **Publish the container.** Build and push the image on a machine with Docker +
+   a CUDA GPU + push access. A turnkey script is provided
+   ([`containers/nis/build_and_push.sh`](../containers/nis/build_and_push.sh)),
+   pre-filled with the cu128 LibTorch source (`cpp/README.md` /
+   `cpp/build_main_hummer.sh`):
 
    ```bash
-   docker build -f containers/nis/Dockerfile -t quay.io/nf-core/cellpheno-nis:1.0.0 .
-   docker push quay.io/nf-core/cellpheno-nis:1.0.0
-   # then set `container "quay.io/nf-core/cellpheno-nis:1.0.0"` in modules/nf-core/cellpheno/nis/main.nf
+   docker login quay.io                                   # nf-core push access
+   bash containers/nis/build_and_push.sh quay.io/nf-core/cellpheno-nis 1.0.0
    ```
 
-   (Building needs a CUDA host; the image is large.)
+   (The image is large — CUDA base + LibTorch. If you don't have nf-core quay
+   access yet, push to `ghcr.io/chrisa142857/cellpheno-nis` and update the
+   `container` line, or ask the nf-core team to host it.)
 
 2. **Add minimal test data** to a branch of
    [nf-core/test-datasets](https://github.com/nf-core/test-datasets) (the
-   `numorph/3dunet` precedent): a tiny lightsheet tile directory and the
-   TorchScript `.pt` models, then reference them via
-   `params.modules_testdata_base_path` and add a real, `gpu`-tagged test.
+   `numorph/3dunet` precedent). The fixtures and their layout are in
+   [`tests/testdata/cellpheno_nis`](../tests/testdata/cellpheno_nis). The real
+   TorchScript model weights come from the G-drive folder in `cpp/README.md`:
+
+   ```bash
+   pip install gdown
+   bash containers/nis/fetch_models.sh downloads/resource   # G-drive NIS models
+   ```
+
+   Put the tiny tile under
+   `data/imaging/segmentation/cellpheno_nis/tile/` on test-datasets; host the
+   large `.pt` weights on Zenodo (numorph precedent) and reference them in the
+   `gpu`-tagged test. Then run it on a GPU runner to add its snapshot entry:
+   `nf-test test modules/nf-core/cellpheno/nis/... --profile docker,gpu --update-snapshot`.
 
 ## Open the PR