bartorch 0.0.2__tar.gz

bartorch-0.0.2/.github/workflows/copilot-setup-steps.yml

@@ -0,0 +1,34 @@
+name: "Copilot Setup Steps"
+
+on:
+  workflow_dispatch:
+  push:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+  pull_request:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+
+jobs:
+  copilot-setup-steps:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install compiler and CMake
+        run: sudo apt-get install -y cmake clang
+
+      - name: Install torch (CPU) and the build backend
+        run: |
+          pip install scikit-build-core setuptools-scm numpy pytest scipy ruff
+          pip install torch --index-url https://download.pytorch.org/whl/cpu
+
+      - name: Build and install bartorch
+        env:
+          CC: clang
+          CXX: clang++
+        run: pip install -e . --no-build-isolation

bartorch-0.0.2/.github/workflows/docs.yml

@@ -0,0 +1,88 @@
+name: Docs
+
+# Builds the reference on every pull request, and publishes it to GitHub Pages
+# from `main`.  Both use the same `./scripts/build_docs.sh` a contributor runs,
+# so a page that renders here rendered for them too.
+#
+# One-time setup: Settings -> Pages -> Source: "GitHub Actions".  Nothing else;
+# the deploy job below carries its own permissions and environment.
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "docs/**"
+      - "src/**"
+      - "*.md"
+      - "*.rst"
+  pull_request:
+    branches: [main]
+    paths:
+      - "docs/**"
+      - "src/**"
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+
+jobs:
+  # -------------------------------------------------------------------------
+  # Job 1: validate that the docs build (runs on every PR and push)
+  # Nothing is compiled: docs/conf.py extracts the reference from the checkout
+  # rather than from an installed package, and the gallery is rendered without
+  # being executed unless BARTORCH_DOCS_EXECUTE says otherwise.  This is what
+  # ./scripts/build_docs.sh runs locally.
+  # -------------------------------------------------------------------------
+  build-docs:
+    name: Build Sphinx docs
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # For `docs/misc/license.rst`, which includes BART's own.
+          submodules: recursive
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+          cache: pip
+
+      - name: Install the documentation requirements
+        run: pip install -r docs/requirements.txt
+
+      - name: Build Sphinx HTML
+        run: ./scripts/build_docs.sh
+
+      - name: Upload docs artifact
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: sphinx-html
+          path: docs/_build/html/
+          retention-days: 7
+
+      # The same HTML again, in the layout Pages deploys from.  Uploaded on
+      # pull requests too, so that a change which breaks the packaging step
+      # says so on the pull request rather than on main.
+      - name: Package the site for Pages
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: docs/_build/html/
+
+  # Only from `main`, and only on a push: a pull request builds the site and
+  # says whether it would deploy, but does not publish it.
+  deploy:
+    name: Publish to GitHub Pages
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    needs: build-docs
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy
+        id: deployment
+        uses: actions/deploy-pages@v4

bartorch-0.0.2/.github/workflows/lint.yml

@@ -0,0 +1,26 @@
+name: Lint
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install ruff
+        run: pip install ruff
+
+      - name: Ruff
+        run: ./scripts/lint.sh

bartorch-0.0.2/.github/workflows/publish.yml

@@ -0,0 +1,241 @@
+name: Publish to PyPI
+
+# Wheels carry a Python-independent C library, so one wheel per platform
+# serves every interpreter and every torch version.  They are built with
+# cibuildwheel from a pure-Python "py3" target and published through PyPI's
+# trusted publisher on a version tag.
+#
+# One-time setup on PyPI: add a trusted publisher for owner mcencini,
+# repository bartorch, workflow publish.yml, environment pypi, and create the
+# "pypi" environment in this repository's settings.
+
+on:
+  push:
+    tags:
+      - "v*"
+  # A tag is the one thing that cannot be taken back: the version it builds
+  # can never be reused on PyPI, and nothing else in the repository runs this
+  # file, so every defect in it waits until a release to appear.  Running it
+  # by hand builds, repairs and tests every wheel exactly as a tag would;
+  # what it does not do is publish, because the two jobs that hand anything
+  # over ask for a tag ref and a branch is not one.
+  workflow_dispatch:
+
+jobs:
+  sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          # setuptools-scm reads the version from the tag history.
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build --sdist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  wheels:
+    name: Build wheels (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # No Linux aarch64 wheel.  FINUFFT computes every non-Cartesian
+        # transform here and ships no wheel for that platform, so a wheel
+        # built for it would install a bartorch that cannot do non-Cartesian
+        # work -- and requiring the source build instead would ask for CMake,
+        # ninja and a C++ compiler from someone installing a wheel.  aarch64
+        # is served by the sdist, where that toolchain is already the price of
+        # entry.
+        os: [ubuntu-latest, macos-latest]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          # setuptools-scm reads the version from the tag history.
+          fetch-depth: 0
+      - uses: pypa/cibuildwheel@v2.23
+        env:
+          # One build per platform: the wheel is tagged py3 and carries no
+          # interpreter, so building it once per Python would only produce the
+          # same file under the same name.  What the interpreters get is the
+          # test matrix below.
+          CIBW_BUILD: "cp312-*"
+          CIBW_SKIP: "*-musllinux_*"
+          # cibuildwheel's Linux default is auto64 *and* auto32, so an x86_64
+          # runner also builds a 32-bit i686 wheel -- in the i686 image, which
+          # is still manylinux2014 and its GCC 10.  Nobody could install that
+          # wheel in any case: torch publishes no i686 build, and it is a hard
+          # dependency here.
+          CIBW_ARCHS_LINUX: x86_64
+          # BART's nested functions need heap trampolines -- GCC 14 -- or
+          # clang's Blocks.  cibuildwheel's default Linux image has neither:
+          # manylinux2014 is CentOS 7, whose GCC is 10 and whose `clang` is
+          # 3.4.2, so old that it cannot link a hello world against the
+          # devtoolset runtime it is installed beside.  manylinux_2_28 is the
+          # image the CUDA wheel below already builds in, and its default cc
+          # is GCC 14.2.1: nothing to install, and no compiler to override.
+          # The floor it sets, glibc 2.28, is the one torch and FINUFFT
+          # already ship their own Linux wheels against.
+          CIBW_MANYLINUX_X86_64_IMAGE: manylinux_2_28
+          # FINUFFT is a dependency, so installing the wheel brings it and the
+          # non-Cartesian tests run.
+          CIBW_TEST_REQUIRES: pytest numpy scipy
+          CIBW_TEST_COMMAND: pip install torch --index-url https://download.pytorch.org/whl/cpu && pytest {project}/tests -q
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  # The wheel carries no interpreter, so what has to be checked across Python
+  # versions is that the package drives it: ctypes signatures, the torch and
+  # numpy APIs it uses, and the tools' generated wrappers.
+  test-wheels:
+    name: Test ${{ matrix.os }} on Python ${{ matrix.python }}
+    needs: [wheels]
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - uses: actions/download-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse
+      - shell: bash
+        run: |
+          python -m pip install --upgrade pip
+          pip install torch --index-url https://download.pytorch.org/whl/cpu \
+            --extra-index-url https://pypi.org/simple
+          pip install pytest numpy scipy wheelhouse/*.whl
+          pytest tests -q
+
+  # A CUDA wheel carries BART's device code and links the runtime libraries
+  # dynamically, so it stays a few megabytes rather than bundling cuFFT and
+  # cuBLAS.  It has the same name, version and platform tag as the CPU wheel,
+  # which PyPI cannot hold twice, so it goes to the release instead:
+  #
+  #     pip install https://github.com/mcencini/bartorch/releases/download/<tag>/<wheel>
+  #
+  # The runners have no card, so this proves the wheel loads and reports the
+  # absence of one; scripts/check_device.py is what a machine with a card runs.
+  wheels-cuda:
+    name: Build CUDA wheel (linux x86_64)
+    runs-on: ubuntu-latest
+    container:
+      image: quay.io/pypa/manylinux_2_28_x86_64
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          # setuptools-scm reads the version from the tag history.
+          fetch-depth: 0
+      - name: Install the CUDA toolkit
+        run: |
+          dnf install -y dnf-plugins-core
+          dnf config-manager --add-repo \
+            https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo
+          dnf install -y --nogpgcheck cuda-nvcc-12-8 cuda-cudart-devel-12-8 \
+            libcufft-devel-12-8 libcublas-devel-12-8
+          echo /usr/local/cuda-12.8/bin >> $GITHUB_PATH
+          echo /opt/python/cp312-cp312/bin >> $GITHUB_PATH
+      # BART needs GCC 14 for -ftrampoline-impl=heap, or clang 16+ for Blocks;
+      # the manylinux image's default toolchain is checked at configure time
+      # and the build fails loudly if it is older.
+      # The pair kernels are cuFFTDx, whose headers come with MathDx: only the
+      # build reads them, and the wheel carries what they compile to, so a
+      # machine running it needs the driver and nothing else.  The sizes they
+      # are compiled for are BARTORCH_PAIRED_SIZES's default (CMakeLists.txt).
+      - name: Fetch MathDx
+        run: |
+          python -m pip install nvidia-mathdx==25.6.0
+          echo "MATHDX_DIR=$(python -c 'import os, sysconfig; print(os.path.join(sysconfig.get_paths()["purelib"], "nvidia", "mathdx"))')" >> $GITHUB_ENV
+      - name: Build the wheel
+        env:
+          CUDACXX: /usr/local/cuda-12.8/bin/nvcc
+        run: |
+          cc --version
+          python -m pip install build
+          python -m build --wheel --outdir dist/ \
+            -C cmake.define.BARTORCH_CUDA=ON \
+            -C "cmake.define.BARTORCH_MATHDX_DIR=$MATHDX_DIR"
+      # The CUDA runtimes are excluded rather than vendored: torch already
+      # brings them, and bundling them would add hundreds of megabytes.
+      - name: Repair to a manylinux tag
+        run: |
+          /opt/python/cp312-cp312/bin/python -m pip install auditwheel
+          LD_LIBRARY_PATH=/usr/local/cuda-12.8/lib64 \
+          /opt/python/cp312-cp312/bin/python -m auditwheel repair dist/*.whl \
+            -w wheelhouse/ --plat manylinux_2_28_x86_64 \
+            --exclude libcudart.so.12 --exclude libcufft.so.11 \
+            --exclude libcublas.so.12 --exclude libcublasLt.so.12
+      - name: Check that it loads without a card
+        run: |
+          /opt/python/cp312-cp312/bin/python -m pip install wheelhouse/*.whl \
+            torch --index-url https://download.pytorch.org/whl/cpu \
+            --extra-index-url https://pypi.org/simple
+          /opt/python/cp312-cp312/bin/python -c "
+          import bartorch
+          from bartorch import _cuda
+          info = bartorch.build_info()
+          print(info)
+          assert 'cuda=ON' in info, info
+          print('devices:', _cuda.device_count())
+          "
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cuda-wheel
+          path: wheelhouse/*.whl
+
+  publish:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    needs: [sdist, wheels, test-wheels]
+    if: startsWith(github.ref, 'refs/tags/v')
+    environment:
+      name: pypi
+      url: https://pypi.org/p/bartorch
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: sdist
+          path: dist
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheels-*
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+  # The CUDA wheel cannot go to PyPI beside the CPU one, so it is attached to
+  # the release the tag made.
+  release-cuda:
+    name: Attach the CUDA wheel to the release
+    runs-on: ubuntu-latest
+    needs: [wheels-cuda]
+    if: startsWith(github.ref, 'refs/tags/v')
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: cuda-wheel
+          path: wheelhouse
+      - uses: softprops/action-gh-release@v2
+        with:
+          files: wheelhouse/*.whl

bartorch-0.0.2/.github/workflows/tests.yml

@@ -0,0 +1,138 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+
+jobs:
+  # libbartorch is a clang build: BART's nested functions become Blocks.
+  tests:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            python-version: "3.10"
+            cc: clang
+          - os: ubuntu-latest
+            python-version: "3.12"
+            cc: clang
+          - os: ubuntu-latest
+            python-version: "3.12"
+            cc: gcc-14
+            extras: "[mkl,deepinv]"
+          - os: macos-latest
+            python-version: "3.12"
+            cc: clang
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          # setuptools-scm reads the version from the tag history.
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      - name: Install compiler, OpenMP and CMake (Linux)
+        if: runner.os == 'Linux'
+        run: sudo apt-get install -y cmake ${{ matrix.cc }} libomp-dev
+
+      - name: Install CMake (macOS)
+        if: runner.os == 'macOS'
+        run: brew install cmake
+
+      - name: Install torch (CPU) and the build backend
+        run: |
+          pip install scikit-build-core setuptools-scm numpy scipy pytest
+          pip install torch --index-url https://download.pytorch.org/whl/cpu
+
+      # deepinv pulls in torchvision, whose compiled operators are built
+      # against one particular torch.  Left to PyPI it takes the default
+      # build while torch here is the CPU one, and the mismatch shows up as
+      # `operator torchvision::nms does not exist` the moment deepinv is
+      # imported.  Taking it from the same index makes the pair agree.
+      # Linux only: that index publishes no macOS wheel, and no macOS entry
+      # in the matrix asks for the deepinv extra.
+      - name: Install torchvision from the same index as torch
+        if: runner.os == 'Linux' && contains(matrix.extras, 'deepinv')
+        run: pip install torchvision --index-url https://download.pytorch.org/whl/cpu
+
+      - name: Build and install bartorch
+        env:
+          CC: ${{ matrix.cc }}
+          CXX: ${{ matrix.cc == 'gcc-14' && 'g++-14' || 'clang++' }}
+        run: pip install -e ".${{ matrix.extras }}" --no-build-isolation -v
+
+      # Before the suite, because the suite is where the information goes
+      # missing: bringing the library up is what installs the FINUFFT
+      # substitution, and that probes itself by running `bart nufft` both
+      # ways.  When that aborts -- as it does on macOS -- pytest has stdout
+      # and stderr captured for collection and the process dies with the
+      # reason unprinted.  Run it once with the log going straight to the
+      # console, so a failure says what it was.
+      - name: Report what the library came up with
+        run: |
+          python - <<'EOF'
+          import logging, traceback
+          logging.basicConfig(level=logging.DEBUG, format="%(name)s: %(message)s")
+          import bartorch
+          print("build:", bartorch.build_info())
+          print("backends:", bartorch.backend_sources())
+          try:
+              from bartorch import _finufft
+              print("finufft available:", _finufft.available())
+              print("finufft in tools:", _finufft.used_in_tools())
+          except Exception:
+              # A diagnostic must not be able to fail the thing it is
+              # diagnosing.  An abort still ends the job, which is the point;
+              # a name that moved should not.
+              traceback.print_exc()
+          EOF
+
+      - name: Run the test suite
+        run: pytest tests/ -v
+
+  # The runners have no GPU, so the CUDA build is checked as far as a machine
+  # without a card allows: it compiles, links, loads, and runs the host suite.
+  cuda-build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          # setuptools-scm reads the version from the tag history.
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      - name: Install the CUDA toolkit, clang and OpenMP
+        run: sudo apt-get update -qq && sudo apt-get install -y --no-install-recommends cmake clang libomp-dev nvidia-cuda-toolkit
+
+      - name: Install torch (CPU) and the build backend
+        run: |
+          pip install scikit-build-core setuptools-scm numpy scipy pytest
+          pip install torch --index-url https://download.pytorch.org/whl/cpu
+
+      - name: Build with BART's CUDA kernels
+        env:
+          CC: clang
+          CXX: clang++
+        run: pip install -e . --no-build-isolation --config-settings=cmake.define.BARTORCH_CUDA=ON
+
+      - name: The CUDA build must report its device code and run on the host
+        run: |
+          python -c "import bartorch; assert 'cuda=ON' in bartorch.build_info()"
+          pytest tests/ -v

bartorch-0.0.2/.github/workflows/typos.yml

@@ -0,0 +1,30 @@
+name: Typos
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+
+jobs:
+  typos:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install codespell
+        run: pip install codespell
+
+      - name: Run codespell
+        # The skips need the `./` codespell prints, or they match nothing:
+        # `external/` did not exclude `./external/bart`, which is why this
+        # check had never passed.  `nd` and `optin` are identifiers rather
+        # than typos -- BART writes `int ND` for a doubled dimension count,
+        # and CUDA spells its own attribute
+        # `cudaDevAttrMaxSharedMemoryPerBlockOptin`.  `build` and
+        # `docs/_build` are outputs a fresh checkout does not have and a
+        # local run does.
+        run: codespell --skip="./attic,./external,./.git,./build,./docs/_build,*.ipynb,pyproject.toml" --ignore-words-list=ist,te,reconet,pyramide,nd,optin,lamda

bartorch-0.0.2/.gitignore

@@ -0,0 +1,45 @@
+__pycache__
+*/__pycache__
+.pytest_cache/
+.ruff_cache/
+dist/
+bartpy.egg-info/
+bartorch.egg-info/
+.vscode/
+
+# Build trees.  A named one -- build-cpu, build-cuda -- is how two
+# configurations are kept side by side; build_tools/ is source and is not one.
+build/
+build-*/
+_skbuild/
+.venv/
+
+# Compiled output
+*.so
+*.so.*
+*.dylib
+*.dll
+*.pyd
+*.o
+*.a
+*.obj
+*.lib
+
+# CFL data files
+*.cfl
+*.hdr
+
+# CMake build artifacts
+bartorch/csrc/build/
+CMakeCache.txt
+CMakeFiles/
+cmake_install.cmake
+Makefile
+
+# Docs build
+docs/_build/
+docs/_templates/
+
+# Attic / legacy demos
+attic/demos/.ipynb_checkpoints/
+**/.DS_Store

bartorch-0.0.2/.gitmodules

@@ -0,0 +1,9 @@
+[submodule "bart"]
+	path = external/bart
+	# Canonical upstream: https://codeberg.org/mrirecon/bart.git
+	# The GitHub mirror (https://github.com/mrirecon/bart) is used here
+	# because Codeberg may not be reachable in all CI/CD environments.
+	# To switch to Codeberg, run:
+	#   git config submodule.bart.url https://codeberg.org/mrirecon/bart.git
+	#   git submodule update --remote
+	url = https://github.com/mrirecon/bart.git

bartorch-0.0.2/.pre-commit-config.yaml

@@ -0,0 +1,20 @@
+repos:
+  - repo: https://github.com/kynan/nbstripout
+    rev: 0.7.1
+    hooks:
+      - id: nbstripout
+
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.3.0
+    hooks:
+      - id: codespell
+        args:
+          - --skip=attic/,.git/,bart/,*.ipynb,pyproject.toml
+          - --ignore-words-list=ist,te,reconet,pyramide
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.4.4
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format