diff --git a/.coveragerc b/.coveragerc
index 57747ec0d8..f65ab1441f 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -1,9 +1,18 @@
 [run]
 branch = True
-source = nibabel, nisext
-include = */nibabel/*, */nisext/*
+source = nibabel
 omit =
     */externals/*
     */benchmarks/*
-    */tests/*
     nibabel/_version.py
+
+[report]
+exclude_also =
+    def __repr__
+    if (ty\.|typing\.)?TYPE_CHECKING:
+    class .*\((ty\.|typing\.)Protocol\):
+    @(ty\.|typing\.)overload
+    if 0:
+    if __name__ == .__main__.:
+    @(abc\.)?abstractmethod
+    raise NotImplementedError
diff --git a/.flake8 b/.flake8
deleted file mode 100644
index 9fe631ac81..0000000000
--- a/.flake8
+++ /dev/null
@@ -1,9 +0,0 @@
-[flake8]
-max-line-length = 100
-extend-ignore = E203,E266,E402,E731
-exclude =
-    *test*
-    *sphinx*
-    nibabel/externals/*
-per-file-ignores =
-    */__init__.py: F401
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index d0546f627f..7769a5f080 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -1,3 +1,7 @@
+# Sun Jan 12 12:22:13 2025 -0500 - markiewicz@stanford.edu - sty: ruff format [git-blame-ignore-rev]
+40e41208a0f04063b3c4e373a65da1a2a6a275b5
+# Sun Jan 12 11:51:49 2025 -0500 - markiewicz@stanford.edu - STY: ruff format [git-blame-ignore-rev]
+7e5d584910c67851dcfcd074ff307122689b61f5
 # Sun Jan 1 12:38:02 2023 -0500 - effigies@gmail.com - STY: Run pre-commit config on all files
 d14c1cf282a9c3b19189f490f10c35f5739e24d1
 # Thu Dec 29 22:53:17 2022 -0500 - effigies@gmail.com - STY: Reduce array().astype() and similar constructs
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000000..6c9e83fcbf
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    groups:
+      actions-infrastructure:
+        patterns:
+          - "actions/*"
diff --git a/.github/workflows/misc.yml b/.github/workflows/misc.yml
deleted file mode 100644
index ade350aaa7..0000000000
--- a/.github/workflows/misc.yml
+++ /dev/null
@@ -1,70 +0,0 @@
-name: Miscellaneous checks
-
-# This file runs doctests on the documentation and style checks
-
-on:
-  push:
-    branches:
-      - master
-      - maint/*
-  pull_request:
-    branches:
-      - master
-      - maint/*
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  misc:
-    runs-on: 'ubuntu-latest'
-    continue-on-error: true
-    strategy:
-      matrix:
-        python-version: ["3.10"]
-        install: ['pip']
-        check: ['style', 'doctest', 'typing']
-        pip-flags: ['']
-        depends: ['REQUIREMENTS']
-    env:
-      DEPENDS: ${{ matrix.depends }}
-      OPTIONAL_DEPENDS: ${{ matrix.optional-depends }}
-      INSTALL_TYPE: ${{ matrix.install }}
-      CHECK_TYPE: ${{ matrix.check }}
-      EXTRA_PIP_FLAGS: ${{ matrix.pip-flags }}
-
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: recursive
-          fetch-depth: 0
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-          architecture: ${{ matrix.architecture }}
-      - name: Display Python version
-        run: python -c "import sys; print(sys.version)"
-      - name: Create virtual environment
-        run: tools/ci/create_venv.sh
-      - name: Build archive
-        run: |
-          source tools/ci/build_archive.sh
-          echo "ARCHIVE=$ARCHIVE" >> $GITHUB_ENV
-      - name: Install dependencies
-        run: tools/ci/install_dependencies.sh
-      - name: Install NiBabel
-        run: tools/ci/install.sh
-      - name: Run tests
-        run: tools/ci/check.sh
-        if: ${{ matrix.check != 'skiptests' }}
-      - name: Submit coverage
-        run: tools/ci/submit_coverage.sh
-        if: ${{ always() }}
-      - name: Upload pytest test results
-        uses: actions/upload-artifact@v3
-        with:
-          name: pytest-results-${{ matrix.os }}-${{ matrix.python-version }}
-          path: for_testing/test-results.xml
-        if: ${{ always() && matrix.check == 'test' }}
diff --git a/.github/workflows/pre-release.yml b/.github/workflows/pre-release.yml
deleted file mode 100644
index 9ceb4033ae..0000000000
--- a/.github/workflows/pre-release.yml
+++ /dev/null
@@ -1,98 +0,0 @@
-name: Pre-release checks
-
-# This file tests against pre-release wheels for dependencies
-
-on:
-  push:
-    branches:
-      - master
-      - maint/*
-  pull_request:
-    branches:
-      - master
-      - maint/*
-  schedule:
-    - cron: '0 0 * * *'
-
-defaults:
-  run:
-    shell: bash
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  pre-release:
-    # Check pre-releases of dependencies on stable Python
-    runs-on: ${{ matrix.os }}
-    continue-on-error: true
-    strategy:
-      matrix:
-        os: ['ubuntu-latest', 'windows-latest', 'macos-latest']
-        python-version: ["3.9", "3.10", "3.11"]
-        architecture: ['x64', 'x86']
-        install: ['pip']
-        check: ['test']
-        pip-flags: ['PRE_PIP_FLAGS']
-        depends: ['REQUIREMENTS']
-        optional-depends: ['DEFAULT_OPT_DEPENDS']
-        include:
-          # Pydicom master
-          - os: ubuntu-latest
-            python-version: "3.11"
-            install: pip
-            check: test
-            pip-flags: ''
-            depends: REQUIREMENTS
-            optional-depends: PYDICOM_MASTER
-        exclude:
-          - os: ubuntu-latest
-            architecture: x86
-          - os: macos-latest
-            architecture: x86
-
-    env:
-      DEPENDS: ${{ matrix.depends }}
-      OPTIONAL_DEPENDS: ${{ matrix.optional-depends }}
-      INSTALL_TYPE: ${{ matrix.install }}
-      CHECK_TYPE: ${{ matrix.check }}
-      EXTRA_PIP_FLAGS: ${{ matrix.pip-flags }}
-
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: recursive
-          fetch-depth: 0
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-          architecture: ${{ matrix.architecture }}
-      - name: Display Python version
-        run: python -c "import sys; print(sys.version)"
-      - name: Create virtual environment
-        run: tools/ci/create_venv.sh
-      - name: Build archive
-        run: |
-          source tools/ci/build_archive.sh
-          echo "ARCHIVE=$ARCHIVE" >> $GITHUB_ENV
-      - name: Install dependencies
-        run: tools/ci/install_dependencies.sh
-      - name: Install NiBabel
-        run: tools/ci/install.sh
-      - name: Run tests
-        run: tools/ci/check.sh
-        if: ${{ matrix.check != 'skiptests' }}
-      - name: Submit coverage
-        run: tools/ci/submit_coverage.sh
-        if: ${{ always() }}
-      - name: Upload pytest test results
-        uses: actions/upload-artifact@v3
-        with:
-          name: pytest-results-${{ matrix.os }}-${{ matrix.python-version }}
-          path: for_testing/test-results.xml
-        if: ${{ always() && matrix.check == 'test' }}
diff --git a/.github/workflows/stable.yml b/.github/workflows/stable.yml
deleted file mode 100644
index 315534107f..0000000000
--- a/.github/workflows/stable.yml
+++ /dev/null
@@ -1,207 +0,0 @@
-name: Stable tests
-
-# This file tests the claimed support range of NiBabel including
-#
-# * Operating systems: Linux, Windows (x64 & x86), OSX
-# * Dependencies: minimum requirements, optional requirements
-# * Installation methods: setup.py, sdist, wheel, archive
-
-on:
-  push:
-    branches:
-      - master
-      - maint/*
-    tags:
-      - "*"
-  pull_request:
-    branches:
-      - master
-      - maint/*
-  schedule:
-    - cron: '0 0 * * 1'
-
-defaults:
-  run:
-    shell: bash
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3
-      - run: pip install --upgrade build twine
-      - name: Build sdist and wheel
-        run: python -m build
-      - run: twine check dist/*
-      - name: Build git archive
-        run: mkdir archive && git archive -v -o archive/nibabel-archive.tgz HEAD
-      - name: Upload sdist and wheel artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: dist
-          path: dist/
-      - name: Upload git archive artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: archive
-          path: archive/
-
-  test-package:
-    runs-on: ubuntu-latest
-    needs: [build]
-    strategy:
-      matrix:
-        package: ['wheel', 'sdist', 'archive']
-    steps:
-      - name: Download sdist and wheel artifacts
-        if: matrix.package != 'archive'
-        uses: actions/download-artifact@v3
-        with:
-          name: dist
-          path: dist/
-      - name: Download git archive artifact
-        if: matrix.package == 'archive'
-        uses: actions/download-artifact@v3
-        with:
-          name: archive
-          path: archive/
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3
-      - name: Display Python version
-        run: python -c "import sys; print(sys.version)"
-      - name: Update pip
-        run: pip install --upgrade pip
-      - name: Install wheel
-        if: matrix.package == 'wheel'
-        run: pip install dist/nibabel-*.whl
-      - name: Install sdist
-        if: matrix.package == 'sdist'
-        run: pip install dist/nibabel-*.tar.gz
-      - name: Install archive
-        if: matrix.package == 'archive'
-        run: pip install archive/nibabel-archive.tgz
-      - run: python -c 'import nibabel; print(nibabel.__version__)'
-      - name: Install test extras
-        run: pip install nibabel[test]
-      - name: Run tests
-        run: pytest --doctest-modules --doctest-plus -v --pyargs nibabel
-
-  stable:
-    # Check each OS, all supported Python, minimum versions and latest releases
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: ['ubuntu-latest', 'windows-latest', 'macos-latest']
-        python-version: [3.8, 3.9, "3.10", "3.11"]
-        architecture: ['x64', 'x86']
-        install: ['pip']
-        check: ['test']
-        pip-flags: ['']
-        depends: ['REQUIREMENTS']
-        optional-depends: ['DEFAULT_OPT_DEPENDS']
-        include:
-          # Basic dependencies only
-          - os: ubuntu-latest
-            python-version: 3.8
-            install: pip
-            check: test
-            pip-flags: ''
-            depends: REQUIREMENTS
-            optional-depends: ''
-          # Absolute minimum dependencies
-          - os: ubuntu-latest
-            python-version: 3.8
-            install: pip
-            check: test
-            pip-flags: ''
-            depends: MIN_REQUIREMENTS
-            optional-depends: ''
-          # Absolute minimum dependencies plus old MPL, Pydicom, Pillow
-          - os: ubuntu-latest
-            python-version: 3.8
-            install: pip
-            check: test
-            pip-flags: ''
-            depends: MIN_REQUIREMENTS
-            optional-depends: MIN_OPT_DEPENDS
-          # Clean install imports only with package-declared dependencies
-          - os: ubuntu-latest
-            python-version: 3.8
-            install: pip
-            check: skiptests
-            pip-flags: ''
-            depends: ''
-        exclude:
-          - os: ubuntu-latest
-            architecture: x86
-          - os: macos-latest
-            architecture: x86
-    env:
-      DEPENDS: ${{ matrix.depends }}
-      OPTIONAL_DEPENDS: ${{ matrix.optional-depends }}
-      INSTALL_TYPE: ${{ matrix.install }}
-      CHECK_TYPE: ${{ matrix.check }}
-      EXTRA_PIP_FLAGS: ${{ matrix.pip-flags }}
-
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: recursive
-          fetch-depth: 0
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-          architecture: ${{ matrix.architecture }}
-      - name: Display Python version
-        run: python -c "import sys; print(sys.version)"
-      - name: Create virtual environment
-        run: tools/ci/create_venv.sh
-      - name: Build archive
-        run: |
-          source tools/ci/build_archive.sh
-          echo "ARCHIVE=$ARCHIVE" >> $GITHUB_ENV
-      - name: Install dependencies
-        run: tools/ci/install_dependencies.sh
-      - name: Install NiBabel
-        run: tools/ci/install.sh
-      - name: Run tests
-        if: ${{ matrix.check != 'skiptests' }}
-        run: tools/ci/check.sh
-      - name: Submit coverage
-        if: ${{ always() }}
-        run: tools/ci/submit_coverage.sh
-      - name: Upload pytest test results
-        if: ${{ always() && matrix.check == 'test' }}
-        uses: actions/upload-artifact@v3
-        with:
-          name: pytest-results-${{ matrix.os }}-${{ matrix.python-version }}
-          path: for_testing/test-results.xml
-
-  publish:
-    runs-on: ubuntu-latest
-    environment: "Package deployment"
-    needs: [stable, test-package]
-    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
-    steps:
-      - uses: actions/download-artifact@v3
-        with:
-          name: dist
-          path: dist/
-      - uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          user: __token__
-          password: ${{ secrets.PYPI_API_TOKEN }}
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000000..416ce03f54
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,272 @@
+name: Build and test
+
+# This file tests the claimed support range of NiBabel including
+#
+# * Operating systems: Linux, Windows (x64 & x86), OSX
+# * Dependencies: minimum requirements, optional requirements
+# * Installation methods: setup.py, sdist, wheel, archive
+
+on:
+  push:
+    branches:
+      - master
+      - maint/*
+    tags:
+      - "*"
+  pull_request:
+    branches:
+      - master
+      - maint/*
+  schedule:
+    - cron: '0 0 * * 1'
+  # Allow job to be triggered manually from GitHub interface
+  workflow_dispatch:
+
+defaults:
+  run:
+    shell: bash
+
+# Force tox and pytest to use color
+env:
+  FORCE_COLOR: true
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3
+      - run: pip install --upgrade build twine
+      - name: Build sdist and wheel
+        run: python -m build
+      - run: twine check dist/*
+      - name: Build git archive
+        run: mkdir archive && git archive -v -o archive/nibabel-archive.tgz HEAD
+      - name: Upload sdist and wheel artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Upload git archive artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: archive
+          path: archive/
+
+  test-package:
+    runs-on: ubuntu-latest
+    needs: [build]
+    strategy:
+      matrix:
+        package: ['wheel', 'sdist', 'archive']
+    steps:
+      - name: Download sdist and wheel artifacts
+        if: matrix.package != 'archive'
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Download git archive artifact
+        if: matrix.package == 'archive'
+        uses: actions/download-artifact@v4
+        with:
+          name: archive
+          path: archive/
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3
+      - name: Display Python version
+        run: python -c "import sys; print(sys.version)"
+      - name: Update pip
+        run: pip install --upgrade pip
+      - name: Install wheel
+        if: matrix.package == 'wheel'
+        run: pip install dist/nibabel-*.whl
+      - name: Install sdist
+        if: matrix.package == 'sdist'
+        run: pip install dist/nibabel-*.tar.gz
+      - name: Install archive
+        if: matrix.package == 'archive'
+        run: pip install archive/nibabel-archive.tgz
+      - run: python -c 'import nibabel; print(nibabel.__version__)'
+      - name: Install minimum test dependencies
+        run: pip install nibabel[test]
+      - name: Run tests
+        run: pytest --doctest-modules --doctest-plus -v --pyargs nibabel -n auto
+
+  test:
+    # Check each OS, all supported Python, minimum versions and latest releases
+    runs-on: ${{ matrix.os }}
+    continue-on-error: ${{ matrix.dependencies == 'pre' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: ['ubuntu-latest', 'windows-latest', 'macos-13', 'macos-latest']
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.13t"]
+        architecture: ['x86', 'x64', 'arm64']
+        dependencies: ['full', 'pre']
+        include:
+          # Basic dependencies only
+          - os: ubuntu-latest
+            python-version: "3.9"
+            architecture: 'x64'
+            dependencies: 'none'
+          # Absolute minimum dependencies
+          - os: ubuntu-latest
+            python-version: "3.9"
+            architecture: 'x64'
+            dependencies: 'min'
+        exclude:
+          # Use ubuntu-latest to cover the whole range of Python. For Windows
+          # and OSX, checking oldest and newest should be sufficient.
+          - os: windows-latest
+            python-version: "3.10"
+          - os: windows-latest
+            python-version: "3.11"
+          - os: windows-latest
+            python-version: "3.12"
+          - os: macos-13
+            python-version: "3.10"
+          - os: macos-13
+            python-version: "3.11"
+          - os: macos-13
+            python-version: "3.12"
+          - os: macos-latest
+            python-version: "3.10"
+          - os: macos-latest
+            python-version: "3.11"
+          - os: macos-latest
+            python-version: "3.12"
+
+          ## Unavailable architectures
+          # x86 is available for Windows
+          - os: ubuntu-latest
+            architecture: x86
+          - os: macos-latest
+            architecture: x86
+          - os: macos-13
+            architecture: x86
+          # arm64 is available for macos-14+
+          - os: ubuntu-latest
+            architecture: arm64
+          - os: windows-latest
+            architecture: arm64
+          - os: macos-13
+            architecture: arm64
+          # x64 is not available for macos-14+
+          - os: macos-latest
+            architecture: x64
+
+          ## Reduced support
+          # Drop pre tests for macos-13
+          - os: macos-13
+            dependencies: pre
+          # Drop pre tests for SPEC-0-unsupported Python versions
+          - python-version: '3.9'
+            dependencies: pre
+          - python-version: '3.10'
+            dependencies: pre
+
+    env:
+      DEPENDS: ${{ matrix.dependencies }}
+      ARCH: ${{ !contains(fromJSON('["none", "min"]'), matrix.dependencies) && matrix.architecture }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          fetch-depth: 0
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v6
+      - name: Set up Python ${{ matrix.python-version }}
+        if: "!endsWith(matrix.python-version, 't')"
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          architecture: ${{ matrix.architecture }}
+          allow-prereleases: true
+      - name: Set up Python ${{ matrix.python-version }}
+        if: endsWith(matrix.python-version, 't')
+        run: |
+          echo "UV_PYTHON=${IMPL}-${VERSION}-${OS%-*}-${ARCH}-${LIBC}" >> $GITHUB_ENV
+          source $GITHUB_ENV
+          uv python install $UV_PYTHON
+        env:
+          IMPL: cpython
+          VERSION: ${{ matrix.python-version }}
+          # uv expects linux|macos|windows, we can drop the -* but need to rename ubuntu
+          OS: ${{ matrix.os == 'ubuntu-latest' && 'linux' || matrix.os }}
+          # uv expects x86, x86_64, aarch64 (among others)
+          ARCH: ${{ matrix.architecture == 'x64' && 'x86_64' ||
+                    matrix.architecture == 'arm64' && 'aarch64' ||
+                    matrix.architecture }}
+          # windows and macos have no options, gnu is the only option for the archs
+          LIBC: ${{ matrix.os == 'ubuntu-latest' && 'gnu' || 'none' }}
+      - name: Display Python version
+        run: python -c "import sys; print(sys.version)"
+      - name: Install tox
+        run: |
+          uv tool install -v tox --with=git+https://github.com/effigies/tox-gh-actions@abiflags --with=tox-uv
+      - name: Show tox config
+        run: tox c
+      - name: Run tox
+        run: tox -vv --exit-and-dump-after 1200
+      - uses: codecov/codecov-action@v5
+        if: ${{ always() }}
+        with:
+          files: cov.xml
+          token: ${{ secrets.CODECOV_TOKEN }}
+      - name: Upload pytest test results
+        uses: actions/upload-artifact@v4
+        with:
+          name: pytest-results-${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.dependencies }}-${{ matrix.architecture }}
+          path: test-results.xml
+        if: ${{ always() }}
+
+  checks:
+    runs-on: 'ubuntu-latest'
+    continue-on-error: true
+    strategy:
+      matrix:
+        check: ['style', 'doctest', 'typecheck', 'spellcheck']
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: 3
+      - name: Display Python version
+        run: python -c "import sys; print(sys.version)"
+      - name: Show tox config
+        run: pipx run tox c
+      - name: Show tox config (this call)
+        run: pipx run tox c -e ${{ matrix.check }}
+      - name: Run check
+        run: pipx run tox -e ${{ matrix.check }}
+
+  publish:
+    runs-on: ubuntu-latest
+    environment: "Package deployment"
+    needs: [test, test-package]
+    permissions:
+      # Required for trusted publishing
+      id-token: write
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
diff --git a/.gitignore b/.gitignore
index 4e9cf81029..e413527d13 100644
--- a/.gitignore
+++ b/.gitignore
@@ -48,7 +48,9 @@ dist/
 *.egg-info/
 .shelf
 .tox/
-.coverage
+.coverage*
+cov.xml
+test-results.xml
 .ropeproject/
 htmlcov/
 .*_cache/
diff --git a/.gitmodules b/.gitmodules
index cdcef650f1..20e97c2ebb 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -19,3 +19,6 @@
 [submodule "nibabel-data/nitest-dicom"]
 	path = nibabel-data/nitest-dicom
 	url = https://github.com/effigies/nitest-dicom
+[submodule "nibabel-data/dcm_qa_xa30"]
+	path = nibabel-data/dcm_qa_xa30
+	url = https://github.com/neurolabusc/dcm_qa_xa30.git
diff --git a/.mailmap b/.mailmap
index feabaee746..43932c865b 100644
--- a/.mailmap
+++ b/.mailmap
@@ -1,78 +1,88 @@
 # Prevent git from showing duplicate names with commands like "git shortlog"
 # See the manpage of git-shortlog for details.
 # The syntax is:
-# Name that should be used <email that should be used> Bad name <bad email>
 #
-# You can skip Bad name if it is the same as the one that should be used, and is unique.
+# Good Name <good email> [[Bad Name] <bad email>]
+#
+# If multiple names are mapped to the good email, a line without any bad
+# emails will consolidate these names.
+# Likewise, any name mapped to a bad email will be converted to the good name.
+#
+# A contributor with three emails and inconsistent names could be mapped like this:
+#
+# Good Name <email1>
+# Good Name <email1> <email2>
+# Good Name <email1> <email3>
+#
+# If a contributor uses an email that is not unique to them, you will need their
+# name.
+#
+# Good Name <good email>
+# Good Name <good email> Good Name <ambiguous email>
 #
 # This file is up-to-date if the command git log --format="%aN <%aE>" | sort -u
 # gives no duplicates.
-Alexandre Gramfort <alexandre.gramfort@inria.fr> Alexandre Gramfort <alexandre.gramfort@m4x.org>
+Alexandre Gramfort <alexandre.gramfort@inria.fr> <alexandre.gramfort@m4x.org>
 Anibal Sólon <anibalsolon@gmail.com>
-Ariel Rokem <arokem@gmail.com> arokem <arokem@gmail.com>
-B. Nolan Nichols <nolan.nichols@gmail.com> Nolan Nichols <nolan.nichols@gmail.com>
-Basile Pinsard <basile.pinsard@gmail.com> bpinsard <basile.pinsard@gmail.com>
-Basile Pinsard <basile.pinsard@gmail.com> bpinsard <bpinsard@imed.jussieu.fr>
-Ben Cipollini <ben.cipollini@gmail.com> Ben Cipollini <bcipolli@ucsd.edu>
+Ariel Rokem <arokem@gmail.com>
+B. Nolan Nichols <nolan.nichols@gmail.com>
+Basile Pinsard <basile.pinsard@gmail.com>
+Basile Pinsard <basile.pinsard@gmail.com> <bpinsard@imed.jussieu.fr>
+Ben Cipollini <ben.cipollini@gmail.com> <bcipolli@ucsd.edu>
 Benjamin C Darwin <bcdarwin@gmail.com>
-Bertrand Thirion <bertrand.thirion@inria.fr> bthirion <bertrand.thirion@inria.fr>
+Bertrand Thirion <bertrand.thirion@inria.fr>
 Cameron Riddell <cameronriddell1@gmail.com> <31414128+CRiddler@users.noreply.github.com>
-Christian Haselgrove <christian.haselgrove@umassmed.edu> Christian Haselgrove <Christian.Haselgrove@umassmed.edu>
-Christopher J. Markiewicz <markiewicz@stanford.edu> Chris Johnson <effigies@bu.edu>
-Christopher J. Markiewicz <markiewicz@stanford.edu> Chris Markiewicz <effigies@gmail.com>
-Christopher J. Markiewicz <markiewicz@stanford.edu> Chris Markiewicz <markiewicz@stanford.edu>
-Christopher J. Markiewicz <markiewicz@stanford.edu> Christopher J. Markiewicz <effigies@bu.edu>
-Christopher J. Markiewicz <markiewicz@stanford.edu> Christopher J. Markiewicz <effigies@gmail.com>
-Cindee Madison <cindee@berkeley.edu> CindeeM <cindee@berkeley.edu>
-Cindee Madison <cindee@berkeley.edu> cindeem <cindee@berkeley.edu>
-Demian Wassermann <demian@bwh.harvard.edu> Demian Wassermann <demian.wassermann@inria.fr>
+Christian Haselgrove <christian.haselgrove@umassmed.edu> <Christian.Haselgrove@umassmed.edu>
+Christopher J. Markiewicz <markiewicz@stanford.edu>
+Christopher J. Markiewicz <markiewicz@stanford.edu> <effigies@gmail.com>
+Christopher J. Markiewicz <markiewicz@stanford.edu> <effigies@bu.edu>
+Cindee Madison <cindee@berkeley.edu>
+Demian Wassermann <demian@bwh.harvard.edu> <demian.wassermann@inria.fr>
 Dimitri Papadopoulos Orfanos <dimitri.papadopoulos@cea.fr> <DimitriPapadopoulos@users.noreply.github.com>
 Dimitri Papadopoulos Orfanos <dimitri.papadopoulos@cea.fr> <3234522+DimitriPapadopoulos@users.noreply.github.com>
-Eric Larson <larson.eric.d@gmail.com> Eric89GXL <larson.eric.d@gmail.com>
-Eric Larson <larson.eric.d@gmail.com> larsoner <larson.eric.d@gmail.com>
-Fernando Pérez-García <fepegar@gmail.com> Fernando <fepegar@gmail.com>
-Félix C. Morency <felix.morency@gmail.com> Felix C. Morency <felix.c.morency@usherbrooke.ca>
-Félix C. Morency <felix.morency@gmail.com> Félix C. Morency <felix.c.morency@usherbrooke.ca>
-Gael Varoquaux <gael.varoquaux@normalesup.org> GaelVaroquaux <gael.varoquaux@normalesup.org>
-Gregory R. Lee <grlee77@gmail.com> Gregory R. Lee <gregory.lee@cchmc.org>
-Ian Nimmo-Smith <iannimmosmith@gmail.com> Ian Nimmo-Smith <ian.nimmo-smith@mrc-cbu.cam.ac.uk>
-Jaakko Leppäkangas <jaeilepp@student.jyu.fi> jaeilepp <jaeilepp@student.jyu.fi>
-Jacob Roberts <jacobdr@gmail.com>
+Eric Larson <larson.eric.d@gmail.com>
+Fabian Perez <Factral@users.noreply.github.com>
+Fernando Pérez-García <fepegar@gmail.com>
+Félix C. Morency <felix.morency@gmail.com> <felix.c.morency@usherbrooke.ca>
+Gael Varoquaux <gael.varoquaux@normalesup.org>
+Gregory R. Lee <grlee77@gmail.com> <gregory.lee@cchmc.org>
+Ian Nimmo-Smith <iannimmosmith@gmail.com> <ian.nimmo-smith@mrc-cbu.cam.ac.uk>
+Jaakko Leppäkangas <jaeilepp@student.jyu.fi>
 Jacob Roberts <jacobdr@gmail.com> <jacob.roberts@o8t.com>
-Jakub Kaczmarzyk <jakub.kaczmarzyk@gmail.com>
 Jakub Kaczmarzyk <jakub.kaczmarzyk@gmail.com> <jakubk@mit.edu>
-Jasper J.F. van den Bosch <japsai@gmail.com> Jasper <japsai@gmail.com>
-Jean-Baptiste Poline <jbpoline@gmail.com> jbpoline <jbpoline@gmail.com>
+Jasper J.F. van den Bosch <japsai@gmail.com>
+Jean-Baptiste Poline <jbpoline@gmail.com>
 Jérôme Dockès <jerome@dockes.org>
-Jon Haitz Legarreta <jon.haitz.legarreta@gmail.com> Jon Haitz Legarreta Gorroño <jon.haitz.legarreta@gmail.com>
-Jonathan Daniel <jonathand655@gmail.com>
+Jon Haitz Legarreta <jon.haitz.legarreta@gmail.com>
 Jonathan Daniel <jonathand655@gmail.com> <36337649+jond01@users.noreply.github.com>
-Kesshi Jordan <Kesshi.Jordan@ucsf.edu> kesshijordan <Kesshi.Jordan@ucsf.edu>
-Kevin S. Hahn <kevinshahn@gmail.com> Kevin S. Hahn <kshahn@stanford.edu>
-Konstantinos Raktivan <constracti@gmail.com> constracti <constracti@gmail.com>
-Krish Subramaniam <krish.subramaniam@gmail.com> Krish Subramaniam <krish@monster.nmr.mgh.harvard.edu>
+Kesshi Jordan <Kesshi.Jordan@ucsf.edu>
+Kevin S. Hahn <kevinshahn@gmail.com> <kshahn@stanford.edu>
+Konstantinos Raktivan <constracti@gmail.com>
+Krish Subramaniam <krish.subramaniam@gmail.com> <krish@monster.nmr.mgh.harvard.edu>
 Krzysztof J. Gorgolewski <krzysztof.gorgolewski@gmail.com>
 Krzysztof J. Gorgolewski <krzysztof.gorgolewski@gmail.com> <chrisgo@google.com>
-Marc-Alexandre Côté <marc.cote.19@gmail.com> Marc-Alexandre Cote <marc.cote.19@gmail.com>
+Marc-Alexandre Côté <marc.cote.19@gmail.com>
 Mathias Goncalves <mathiasg@mit.edu>
 Mathias Goncalves <mathiasg@mit.edu> <mathiasg@stanford.edu>
-Matthew Cieslak <mattcieslak@gmail.com> Matt Cieslak <mattcieslak@gmail.com>
+Mathieu Scheltienne <mathieu.scheltienne@fcbg.ch> <mathieu.scheltienne@gmail.com>
+Matthew Cieslak <mattcieslak@gmail.com>
 Michael Hanke <michael.hanke@gmail.com> <mhanke-guest@82381867-18eb-0310-98a2-9474e637aba2>
 Michael Hanke <michael.hanke@gmail.com> <michaelhanke@mvpa1.dartmouth.edu>
-Michiel Cottaar <MichielCottaar@protonmail.com>
 Michiel Cottaar <MichielCottaar@protonmail.com> <MichielCottaar@protonmail.ch>
 Michiel Cottaar <MichielCottaar@protonmail.com> <MichielCottaar@gmail.com>
-Ly Nguyen <nguyen60@seattleu.edu> lxn2 <lxn2@uw.edu>
-Oliver P. Hinds <ohinds@gmail.com> ohinds <ohinds@gmail.com>
+Ly Nguyen <nguyen60@seattleu.edu> <lxn2@uw.edu>
+Oliver P. Hinds <ohinds@gmail.com>
 Or Duek <orduek@gmail.com>
 Oscar Esteban <code@oscaresteban.es>
-Paul McCarthy <pauldmccarthy@gmail.com> Paul McCarthy <pauld.mccarthy@gmail.com>
+Paul McCarthy <pauldmccarthy@gmail.com> <pauld.mccarthy@gmail.com>
+Paul McCarthy <pauldmccarthy@gmail.com> <manifest-rules@git.fmrib.ox.ac.uk>
+Reinder Vos de Wael <reinder.vosdewael@gmail.com> <reinder.vosdewael@childmind.org>
 Roberto Guidotti <robbenson18@gmail.com>
 Roberto Guidotti <robbenson18@gmail.com> <guidotr1@cs-087.org.aalto.fi>
-Satrajit Ghosh <satra@mit.edu> Satrajit Ghosh <satrajit.ghosh@gmail.com>
-Serge Koudoro <skab12@gmail.com> skoudoro <skab12@gmail.com>
+Satrajit Ghosh <satra@mit.edu> <satrajit.ghosh@gmail.com>
+Serge Koudoro <skab12@gmail.com>
 Stephan Gerhard <git@unidesign.ch> Stephan Gerhard <git@github.com>
-Thomas Roos <thomasroos@live.nl> Roosted7 <thomasroos@live.nl>
-Venkateswara Reddy Reddam <R3DDY97@users.noreply.github.com> R3DDY97 <R3DDY97@users.noreply.github.com>
+Thomas Roos <thomasroos@live.nl>
+Venkateswara Reddy Reddam <R3DDY97@users.noreply.github.com>
+Yaroslav O. Halchenko <debian@onerussian.com>
 Yaroslav O. Halchenko <debian@onerussian.com> <yoh-guest@82381867-18eb-0310-98a2-9474e637aba2>
-Yaroslav O. Halchenko <debian@onerussian.com> Yaroslav Halchenko <debian@onerussian.com>
diff --git a/.pep8speaks.yml b/.pep8speaks.yml
deleted file mode 100644
index 0a0d8c619f..0000000000
--- a/.pep8speaks.yml
+++ /dev/null
@@ -1,12 +0,0 @@
-scanner:
-    diff_only: True  # Only show errors caused by the patch
-    linter: flake8
-
-message:  # Customize the comment made by the bot
-    opened:  # Messages when a new PR is submitted
-        header: "Hello @{name}, thank you for submitting the Pull Request!"
-        footer: "To test for issues locally, `pip install flake8` and then run `flake8 nibabel`."
-    updated:  # Messages when new commits are added to the PR
-        header: "Hello @{name}, Thank you for updating!"
-        footer: "To test for issues locally, `pip install flake8` and then run `flake8 nibabel`."
-    no_errors: "Cheers! There are no style issues detected in this Pull Request. :beers: "
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 3a66205335..2e6c466f99 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,7 +1,7 @@
 exclude: ".*/data/.*"
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.1.0
+    rev: v5.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
@@ -12,21 +12,16 @@ repos:
       - id: check-case-conflict
       - id: check-merge-conflict
       - id: check-vcs-permalinks
-  - repo: https://github.com/grantjenks/blue
-    rev: v0.9.1
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.9.6
     hooks:
-      - id: blue
-  - repo: https://github.com/pycqa/isort
-    rev: 5.12.0
-    hooks:
-      - id: isort
-  - repo: https://github.com/pycqa/flake8
-    rev: 6.0.0
-    hooks:
-      - id: flake8
-        exclude: "^(doc|nisext|tools)/"
+      - id: ruff
+        args: [ --fix ]
+        exclude: = ["doc", "tools"]
+      - id: ruff-format
+        exclude: = ["doc", "tools"]
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.991
+    rev: v1.15.0
     hooks:
       - id: mypy
         # Sync with project.optional-dependencies.typing
@@ -37,5 +32,12 @@ repos:
           - pydicom
           - numpy
           - pyzstd
+          - importlib_resources
         args: ["nibabel"]
         pass_filenames: false
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.4.1
+    hooks:
+      - id: codespell
+        additional_dependencies:
+          - tomli
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
new file mode 100644
index 0000000000..1b2c531171
--- /dev/null
+++ b/.readthedocs.yaml
@@ -0,0 +1,21 @@
+version: 2
+
+build:
+  os: ubuntu-lts-latest
+  tools:
+    python: latest
+  jobs:
+    pre_create_environment:
+      - asdf plugin add uv
+      - asdf install uv latest
+      - asdf global uv latest
+    create_environment:
+      - uv venv $READTHEDOCS_VIRTUALENV_PATH
+    install:
+      # Use a cache dir in the same mount to halve the install time
+      - VIRTUAL_ENV=$READTHEDOCS_VIRTUALENV_PATH uv pip install --cache-dir $READTHEDOCS_VIRTUALENV_PATH/../../uv_cache .[doc]
+    pre_build:
+      - ( cd doc; python tools/build_modref_templates.py nibabel source/reference False )
+
+sphinx:
+  configuration: doc/source/conf.py
diff --git a/.zenodo.json b/.zenodo.json
index 75dea73eed..250611d54d 100644
--- a/.zenodo.json
+++ b/.zenodo.json
@@ -25,6 +25,11 @@
       "name": "Cipollini, Ben",
       "orcid": "0000-0002-7782-0790"
     },
+    {
+      "affiliation": "CEA",
+      "name": "Papadopoulos Orfanos, Dimitri",
+      "orcid": "0000-0002-1242-8990"
+    },
     {
       "name": "McCarthy, Paul"
     },
@@ -38,6 +43,11 @@
       "name": "Cheng, Christopher P.",
       "orcid": "0000-0001-9112-9464"
     },
+    {
+      "affiliation": "University of Washington: Seattle, WA, United States",
+      "name": "Larson, Eric",
+      "orcid": "0000-0003-4782-5360"
+    },
     {
       "affiliation": "Dartmouth College: Hanover, NH, United States",
       "name": "Halchenko, Yaroslav O.",
@@ -48,11 +58,6 @@
       "name": "Cottaar, Michiel",
       "orcid": "0000-0003-4679-7724"
     },
-    {
-      "affiliation": "University of Washington: Seattle, WA, United States",
-      "name": "Larson, Eric",
-      "orcid": "0000-0003-4782-5360"
-    },
     {
       "affiliation": "MIT, HMS",
       "name": "Ghosh, Satrajit",
@@ -73,6 +78,13 @@
       "name": "Lee, Gregory R.",
       "orcid": "0000-0001-8895-2740"
     },
+    {
+      "name": "Baratz, Zvi",
+      "orcid": "0000-0001-7159-1387"
+    },
+    {
+      "name": "Moloney, Brendan"
+    },
     {
       "name": "Wang, Hao-Ting",
       "orcid": "0000-0003-4078-2038"
@@ -104,19 +116,16 @@
       "orcid": "0000-0003-0679-1985"
     },
     {
-      "name": "Madison, Cindee"
+      "affiliation": "Human Neuroscience Platform, Fondation Campus Biotech Geneva, Geneva, Switzerland",
+      "name": "Mathieu Scheltienne",
+      "orcid": "0000-0001-8316-7436"
     },
     {
-      "affiliation": "CEA",
-      "name": "Papadopoulos Orfanos, Dimitri",
-      "orcid": "0000-0002-1242-8990"
+      "name": "Madison, Cindee"
     },
     {
       "name": "S\u00f3lon, Anibal"
     },
-    {
-      "name": "Moloney, Brendan"
-    },
     {
       "name": "Morency, F\u00e9lix C."
     },
@@ -125,10 +134,6 @@
       "name": "Goncalves, Mathias",
       "orcid": "0000-0002-7252-7771"
     },
-    {
-      "name": "Baratz, Zvi",
-      "orcid": "0000-0001-7159-1387"
-    },
     {
       "affiliation": "Montreal Neurological Institute and Hospital",
       "name": "Markello, Ross",
@@ -172,6 +177,11 @@
     {
       "name": "Van, Andrew"
     },
+    {
+      "affiliation": "Brigham and Women's Hospital, Mass General Brigham/Harvard Medical School",
+      "name": "Legarreta, Jon Haitz",
+      "orcid": "0000-0002-9661-1396"
+    },
     {
       "affiliation": "Google",
       "name": "Gorgolewski, Krzysztof J.",
@@ -187,6 +197,9 @@
       "name": "Klug, Julian",
       "orcid": "0000-0002-4849-9811"
     },
+    {
+      "name": "Vos de Wael, Reinder"
+    },
     {
       "affiliation": "SRI International",
       "name": "Nichols, B. Nolan",
@@ -195,6 +208,9 @@
     {
       "name": "Baker, Eric M."
     },
+    {
+      "name": "Koudoro, Serge"
+    },
     {
       "name": "Hayashi, Soichi"
     },
@@ -212,14 +228,14 @@
       "name": "Esteban, Oscar",
       "orcid": "0000-0001-8435-6191"
     },
-    {
-      "name": "Koudoro, Serge"
-    },
     {
       "affiliation": "University College London",
       "name": "P\u00e9rez-Garc\u00eda, Fernando",
       "orcid": "0000-0001-9090-3024"
     },
+    {
+      "name": "Becq, Guillaume"
+    },
     {
       "name": "Dock\u00e8s, J\u00e9r\u00f4me"
     },
@@ -229,12 +245,18 @@
     {
       "name": "Amirbekian, Bago"
     },
+    {
+      "name": "Christian, Horea"
+    },
     {
       "name": "Nimmo-Smith, Ian"
     },
     {
       "name": "Nguyen, Ly"
     },
+    {
+      "name": "Suter, Peter"
+    },
     {
       "affiliation": "BrainSpec, Boston, MA",
       "name": "Reddigari, Samir",
@@ -256,9 +278,9 @@
       "orcid": "0000-0003-1076-5122"
     },
     {
-      "affiliation": "Universit\u00e9 de Sherbrooke",
-      "name": "Legarreta, Jon Haitz",
-      "orcid": "0000-0002-9661-1396"
+      "affiliation": "Polytechnique Montr\u00e9al, Montr\u00e9al, CA",
+      "name": "Newton, Joshua",
+      "orcid": "0009-0005-6963-3812"
     },
     {
       "name": "Hahn, Kevin S."
@@ -271,9 +293,18 @@
     {
       "name": "Hinds, Oliver P."
     },
+    {
+      "name": "Sandro"
+    },
     {
       "name": "Fauber, Bennet"
     },
+    {
+      "name": "Dewey, Blake"
+    },
+    {
+      "name": "Perez, Fabian"
+    },
     {
       "name": "Roberts, Jacob"
     },
diff --git a/Changelog b/Changelog
index 69e55d1a9c..f75ac8bc29 100644
--- a/Changelog
+++ b/Changelog
@@ -25,6 +25,234 @@ Eric Larson (EL), Demian Wassermann, Stephan Gerhard and Ross Markello (RM).
 
 References like "pr/298" refer to github pull request numbers.
 
+5.3.2 (Wednesday 23 October 2024)
+=================================
+
+Bug-fix release in the 5.3.x series.
+
+Bug fixes
+---------
+* Restore MRS extension type to Nifti1Extension to maintain backwards compatibility.
+  (pr/1380) (CM)
+
+
+5.3.1 (Tuesday 15 October 2024)
+===============================
+
+Bug-fix release in the 5.3.x series.
+
+Bug fixes
+---------
+* Restore access to private attribute ``Nifti1Extension._content`` to unbreak subclasses
+  that did not use public accessor methods. (pr/1378) (CM, reviewed by Basile Pinsard)
+* Remove test order dependency in ``test_api_validators`` (pr/1377) (CM)
+
+
+5.3.0 (Tuesday 8 October 2024)
+==============================
+
+This release primarily adds support for Python 3.13 and Numpy 2.0.
+
+NiBabel 6.0 will drop support for Numpy 1.x.
+
+New features
+------------
+* Update NIfTI extension protocol to include ``.content : bytes``, ``.text : str`` and
+  ``.json() : dict`` properties/methods for accessing extension contents.
+  Exceptions will be raised on ``.text`` and ``.json()`` if conversion fails. (pr/1336) (CM)
+
+Enhancements
+------------
+* Ability to read data from many multiframe DICOM files that previously generated errors (pr/1340)
+  (Brendan Moloney, reviewed by CM)
+* ``nib-nifti-dx`` now supports NIfTI-2 files with a ``--nifti2`` flag (pr/1323) (CM)
+* Update :mod:`nibabel.streamlines.tractogram` to support ragged arrays. (pr/1291)
+  (Serge Koudoro, reviewed by CM)
+* Filter numpy ``UserWarning`` on ``np.finfo(np.longdouble)``. This can occur on
+  Windows systems, but it's done in the context of checking for the problem that
+  is being warned against, so there's no need to be noisy. (pr/1310)
+  (Joshua Newton, reviewed by CM)
+* Improve error message for for dicomwrapper errors in shape calculation (pr/1302)
+  (YOH, reviewed by CM)
+* Support "flat" ASCII-encoded GIFTI DataArrays (pr/1298) (PM, reviewed by CM)
+
+Bug fixes
+---------
+* Fix location initialization/update in OrthoSlicer3D for permuted axes (pr/1319, pr/1350)
+  (Guillaume Becq, reviewed by CM)
+* Fix DICOM scaling, making frame filtering explicit (pr/1342) (Brendan Moloney, reviewed by CM)
+* Fixed multiframe DICOM issue where data could be flipped along slice dimension relative to the
+  affine (pr/1340) (Brendan Moloney, reviewed by CM)
+* Fixed multiframe DICOM issue where ``image_position`` and the translation component in the
+  ``affine`` could be incorrect (pr/1340) (Brendan Moloney, reviewed by CM)
+
+Maintenance
+-----------
+* Numpy 2.0 compatibility and addressing deprecations in numpy API
+  (pr/1304, pr/1330, pr/1331, pr/1334, pr/1337) (Jon Haitz Legarreta Gorroño, CM)
+* Python 3.13 compatibility (pr/1315) (Sandro from the Fedora Project, reviewed by CM)
+* Testing on Python 3.13 with free-threading (pr/1339) (CM)
+* Testing on ARM64 Mac OS runners (pr/1320) (CM)
+* Proactively address deprecations in coming Python versions (pr/1329, pr/1332, pr/1333)
+  (Jon Haitz Legarreta Gorroño, reviewed by CM)
+* Replace nose-era ``setup()`` and ``teardown()`` functions with pytest equivalents
+  (pr/1325) (Sandro from the Fedora Project, reviewed by Étienne Mollier and CM)
+* Transitioned from blue/isort/flake8 to `ruff <https://docs.astral.sh/ruff/>`__. (pr/1289)
+  (Dimitri Papadopoulos, reviewed by CM)
+* Vetted and added various rules to the ruff configuration for auto-formatting and style
+  guide enforcement. (pr/1321, pr/1351, pr/1352, pr/1353, pr/1354, pr/1355, pr/1357, pr/1358,
+  pr/1359, pr/1360, pr/1361, pr/1362, pr/1363, pr/1364, pr/1368, pr/1369)
+  (Dimitri Papadopoulos, reviewed by CM)
+* Fixing typos when found. (pr/1313, pr/1370) (MB, Dimitri Papadopoulos)
+* Applied Repo-Review suggestions (Dimitri Papadopoulos, reviewed by CM)
+
+API changes and deprecations
+----------------------------
+* Raise :class:`~nibabel.spatialimages.HeaderDataError` from
+  :func:`~nibabel.nifti1.Nifti1Header.set_qform` if the affine fails to decompose.
+  This would previously result in :class:`numpy.linalg.LinAlgError`. (pr/1227) (CM)
+* The :func:`nibabel.onetime.auto_attr` module can be replaced by :func:`functools.cached_property`
+  in all supported versions of Python. This alias may be removed in future versions. (pr/1341) (CM)
+* Removed the deprecated ``nisext`` (setuptools extensions) package. (pr/1290) (CM, reviewed by MB)
+
+
+5.2.1 (Monday 26 February 2024)
+===============================
+
+Bug-fix release in the 5.2.x series.
+
+Enhancements
+------------
+* Support "flat" ASCII-encoded GIFTI DataArrays (pr/1298) (PM, reviewed by CM)
+
+Bug fixes
+---------
+* Tolerate missing ``git`` when reporting version info (pr/1286) (CM, reviewed by
+  Yuri Victorovich)
+* Handle Siemens XA30 derived DWI DICOMs (pr/1296) (CM, reviewed by YOH and
+  Mathias Goncalves)
+
+Maintenance
+-----------
+* Add tool for generating GitHub-friendly release notes (pr/1284) (CM)
+* Accommodate pytest 8 changes (pr/1297) (CM)
+
+
+5.2.0 (Monday 11 December 2023)
+===============================
+
+New feature release in the 5.2.x series.
+
+This release requires a minimum Python of 3.8 and NumPy 1.20, and has been
+tested up to Python 3.12 and NumPy 1.26.
+
+New features
+------------
+* Add generic :class:`~nibabel.pointset.Pointset` and regularly spaced
+  :class:`~nibabel.pointset.Grid` data structures in preparation for coordinate
+  transformation and resampling (pr/1251) (CM, reviewed by Oscar Esteban)
+
+Enhancements
+------------
+* Add :meth:`~nibabel.arrayproxy.ArrayProxy.copy` method to
+  :class:`~nibabel.arrayproxy.ArrayProxy` (pr/1255) (CM, reviewed by Paul McCarthy)
+* Permit :meth:`~nibabel.xmlutils.XmlSerializable.to_xml` methods to pass keyword
+  arguments to :func:`xml.etree.ElementTree.tostring` (pr/1258)
+  (CM)
+* Allow user expansion (e.g., ``~/...``) in strings passed to functions that
+  accept paths (pr/1260) (Reinder Vos de Wael, reviewed by CM)
+* Expand CIFTI-2 brain structures to permit synonyms (pr/1256) (CM, reviewed
+  by Mathias Goncalves)
+* Annotate :class:`~nibabel.spatialimages.SpatialImage` as accepting
+  ``affine=None`` argument (pr/1253) (Blake Dewey, reviewed by CM)
+* Warn on invalid MINC2 spacing declarations, treat as missing (pr/1237)
+  (Peter Suter, reviewed by CM)
+* Refactor :func:`~nibabel.nicom.utils.find_private_section` for improved
+  readability and maintainability (pr/1228) (MB, reviewed by CM)
+
+Bug fixes
+---------
+* Resolve test failure related to randomly generated invalid case (pr/1221) (CM)
+
+Documentation
+-------------
+* Remove references to NiPy data packages from documentation (pr/1275)
+  (Dimitri Papadopoulos, reviewed by CM, MB)
+
+Maintenance
+-----------
+* Quality of life improvements for CI, including color output and OIDC publishing
+  (pr/1282) (CM)
+* Patch for NumPy 2.0 pre-release compatibility (pr/1250) (Mathieu
+  Scheltienne and EL, reviewed by CM)
+* Add spellchecking to tox, CI and pre-commit (pr/1266) (CM)
+* Add py312-dev-x64 environment to Tox to test NumPy 2.0 pre-release
+  compatibility (pr/1267) (CM, reviewed by EL)
+* Resurrect tox configuration to cover development workflows and CI checks
+  (pr/1262) (CM)
+* Updates for Python 3.12 support (pr/1247, pr/1261, pr/1273) (CM)
+* Remove uses of deprecated ``numpy.compat.py3k`` module (pr/1243) (Eric
+  Larson, reviewed by CM)
+* Various fixes for typos and style issues detected by Codespell, pyupgrade and
+  refurb (pr/1263, pr/1269, pr/1270, pr/1271, pr/1276) (Dimitri Papadopoulos,
+  reviewed by CM)
+* Use stable argsorts in PARREC tests to ensure consistent behavior on systems
+  with AVX512 SIMD instructions and numpy 1.25 (pr/1234) (CM)
+* Resolve CodeCov submission failures (pr/1224) (CM)
+* Link to logo with full URL to avoid broken links in PyPI (pr/1218) (CM,
+  reviewed by Zvi Baratz)
+
+API changes and deprecations
+----------------------------
+* The :mod:`nibabel.pydicom_compat` module is deprecated and will be removed
+  in NiBabel 7.0. (pr/1280)
+* The :func:`~nibabel.casting.int_to_float` and :func:`~nibabel.casting.as_int`
+  functions are no longer needed to work around NumPy deficiencies and have been
+  deprecated (pr/1272) (CM, reviewed by EL)
+
+
+5.1.0 (Monday 3 April 2023)
+===========================
+
+New feature release in the 5.1.x series.
+
+Enhancements
+------------
+* Make :mod:`nibabel.imagestats` available with ``import nibabel`` (pr/1208)
+  (Fabian Perez, reviewed by CM)
+* Use symmetric threshold for identifying unit quaternions on qform
+  calculations (pr/1182) (CM, reviewed by MB)
+* Type annotations for :mod:`~nibabel.loadsave` (pr/1213) and
+  :class:`~nibabel.spatialimages.SpatialImage` APIs (pr/1179),
+  :mod:`~nibabel.deprecated`, :mod:`~nibabel.deprecator`,
+  :mod:`~nibabel.onetime` and :mod:`~nibabel.optpkg` modules (pr/1188),
+  :mod:`~nibabel.volumeutils` (pr/1189), :mod:`~nibabel.filename_parser` and
+  :mod:`~nibabel.openers` (pr/1197) (CM, reviewed by Zvi Baratz)
+
+Bug fixes
+---------
+* Require explicit overrides to write GIFTI files that contain data arrays
+  with data types not permitted by the GIFTI standard (pr/1199) (CM, reviewed
+  by Alexis Thual)
+
+Maintenance
+-----------
+* Move compression detection logic into a private ``nibabel._compression``
+  module, resolving unexpected errors from pyzstd. (pr/1212) (CM)
+* Improved consistency of docstring formatting (pr/1200) (Zvi Baratz, reviewed
+  by CM)
+* Modernized README text (pr/1195) (Zvi Baratz, reviewed by CM)
+* Updated README badges to include package distributions (pr/1192) (Horea
+  Christian, reviewed by CM)
+* Removed all dependencies on distutils and setuptools (pr/1190) (CM,
+  reviewed by Zvi Baratz)
+* Add a ``_version.pyi`` stub to allow mypy_ to run without building nibabel
+  (pr/1210) (CM)
+
+
+.. _mypy: https://mypy.readthedocs.io/
+
+
 5.0.1 (Sunday 12 February 2023)
 ===============================
 
@@ -1204,7 +1432,7 @@ Special thanks to Chris Burns, Jarrod Millman and Yaroslav Halchenko.
 * Very preliminary, limited and highly experimental DICOM reading support (MB,
   Ian Nimmo Smith).
 * Some functions (:py:mod:`nibabel.funcs`) for basic image shape changes, including
-  the ability to transform to the image with data closest to the cononical
+  the ability to transform to the image with data closest to the canonical
   image orientation (first axis left-to-right, second back-to-front, third
   down-to-up) (MB, Jonathan Taylor)
 * Gifti format read and write support (preliminary) (Stephen Gerhard)
diff --git a/Makefile b/Makefile
index 7d4c6666ae..689ad6a75f 100644
--- a/Makefile
+++ b/Makefile
@@ -233,25 +233,6 @@ bdist_rpm:
 bdist_mpkg:
 	$(PYTHON) tools/mpkg_wrapper.py setup.py install
 
-# Check for files not installed
-check-files:
-	$(PYTHON) -c 'from nisext.testers import check_files; check_files("nibabel")'
-
-# Print out info for possible install methods
-check-version-info:
-	$(PYTHON) -c 'from nisext.testers import info_from_here; info_from_here("nibabel")'
-
-# Run tests from installed code
-installed-tests:
-	$(PYTHON) -c 'from nisext.testers import tests_installed; tests_installed("nibabel")'
-
-# Run tests from packaged distributions
-sdist-tests:
-	$(PYTHON) -c 'from nisext.testers import sdist_tests; sdist_tests("nibabel", doctests=False)'
-
-bdist-egg-tests:
-	$(PYTHON) -c 'from nisext.testers import bdist_egg_tests; bdist_egg_tests("nibabel", doctests=False, label="not script_test")'
-
 sdist-venv: clean
 	rm -rf dist venv
 	unset PYTHONPATH && $(PYTHON) setup.py sdist --formats=zip
@@ -260,7 +241,7 @@ sdist-venv: clean
 	mkdir venv/tmp
 	cd venv/tmp && unzip ../../dist/*.zip
 	. venv/bin/activate && cd venv/tmp/nibabel* && python setup.py install
-	unset PYTHONPATH && . venv/bin/activate && cd venv && nosetests --with-doctest nibabel nisext
+	unset PYTHONPATH && . venv/bin/activate && cd venv && pytest --doctest-modules --doctest-plus --pyargs nibabel
 
 source-release: distclean
 	$(PYTHON) -m compileall .
diff --git a/README.rst b/README.rst
index 1afdbc511a..2043c1d220 100644
--- a/README.rst
+++ b/README.rst
@@ -1,94 +1,171 @@
 .. -*- rest -*-
 .. vim:syntax=rst
 
-.. image:: https://codecov.io/gh/nipy/nibabel/branch/master/graph/badge.svg
-  :target: https://codecov.io/gh/nipy/nibabel
+.. Use raw location to ensure image shows up on PyPI
+.. image:: https://raw.githubusercontent.com/nipy/nibabel/master/doc/pics/logo.png
+   :target: https://nipy.org/nibabel
+   :alt: NiBabel logo
+
+.. list-table::
+   :widths: 20 80
+   :header-rows: 0
+
+   * - Code
+     -
+      .. image:: https://img.shields.io/pypi/pyversions/nibabel.svg
+         :target: https://pypi.python.org/pypi/nibabel/
+         :alt: PyPI - Python Version
+      .. image:: https://img.shields.io/badge/code%20style-blue-blue.svg
+         :target: https://blue.readthedocs.io/en/latest/
+         :alt: code style: blue
+      .. image:: https://img.shields.io/badge/imports-isort-1674b1
+         :target: https://pycqa.github.io/isort/
+         :alt: imports: isort
+      .. image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white
+         :target: https://github.com/pre-commit/pre-commit
+         :alt: pre-commit
+
+   * - Tests
+     -
+      .. image:: https://github.com/nipy/NiBabel/actions/workflows/stable.yml/badge.svg
+         :target: https://github.com/nipy/NiBabel/actions/workflows/stable.yml
+         :alt: stable tests
+      .. image:: https://codecov.io/gh/nipy/NiBabel/branch/master/graph/badge.svg
+         :target: https://codecov.io/gh/nipy/NiBabel
+         :alt: codecov badge
+
+   * - PyPI
+     -
+      .. image:: https://img.shields.io/pypi/v/nibabel.svg
+         :target: https://pypi.python.org/pypi/nibabel/
+         :alt: PyPI version
+      .. image:: https://img.shields.io/pypi/dm/nibabel.svg
+         :target: https://pypistats.org/packages/nibabel
+         :alt: PyPI - Downloads
+
+   * - Packages
+     -
+      .. image:: https://img.shields.io/conda/vn/conda-forge/nibabel
+         :target: https://anaconda.org/conda-forge/nibabel
+         :alt: Conda package
+      .. image:: https://repology.org/badge/version-for-repo/debian_unstable/nibabel.svg?header=Debian%20Unstable
+         :target: https://repology.org/project/nibabel/versions
+         :alt: Debian Unstable package
+      .. image:: https://repology.org/badge/version-for-repo/aur/python:nibabel.svg?header=Arch%20%28%41%55%52%29
+         :target: https://repology.org/project/python:nibabel/versions
+         :alt: Arch (AUR)
+      .. image:: https://repology.org/badge/version-for-repo/gentoo_ovl_science/nibabel.svg?header=Gentoo%20%28%3A%3Ascience%29
+         :target: https://repology.org/project/nibabel/versions
+         :alt: Gentoo (::science)
+      .. image:: https://repology.org/badge/version-for-repo/nix_unstable/python:nibabel.svg?header=nixpkgs%20unstable
+         :target: https://repology.org/project/python:nibabel/versions
+         :alt: nixpkgs unstable
+
+   * - License & DOI
+     -
+      .. image:: https://img.shields.io/pypi/l/nibabel.svg
+         :target: https://github.com/nipy/nibabel/blob/master/COPYING
+         :alt: License
+      .. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.591597.svg
+         :target: https://doi.org/10.5281/zenodo.591597
+         :alt: Zenodo DOI
+
+.. Following contents should be copied from LONG_DESCRIPTION in nibabel/info.py
+
+
+Read and write access to common neuroimaging file formats, including:
+ANALYZE_ (plain, SPM99, SPM2 and later), GIFTI_, NIfTI1_, NIfTI2_, `CIFTI-2`_,
+MINC1_, MINC2_, `AFNI BRIK/HEAD`_, ECAT_ and Philips PAR/REC.
+In addition, NiBabel also supports FreeSurfer_'s MGH_, geometry, annotation and
+morphometry files, and provides some limited support for DICOM_.
+
+NiBabel's API gives full or selective access to header information (metadata),
+and image data is made available via NumPy arrays. For more information, see
+NiBabel's `documentation site`_ and `API reference`_.
+
+.. _API reference: https://nipy.org/nibabel/api.html
+.. _AFNI BRIK/HEAD: https://afni.nimh.nih.gov/pub/dist/src/README.attributes
+.. _ANALYZE: http://www.grahamwideman.com/gw/brain/analyze/formatdoc.htm
+.. _CIFTI-2: https://www.nitrc.org/projects/cifti/
+.. _DICOM: http://medical.nema.org/
+.. _documentation site: http://nipy.org/nibabel
+.. _ECAT: http://xmedcon.sourceforge.net/Docs/Ecat
+.. _Freesurfer: https://surfer.nmr.mgh.harvard.edu
+.. _GIFTI: https://www.nitrc.org/projects/gifti
+.. _MGH: https://surfer.nmr.mgh.harvard.edu/fswiki/FsTutorial/MghFormat
+.. _MINC1:
+    https://en.wikibooks.org/wiki/MINC/Reference/MINC1_File_Format_Reference
+.. _MINC2:
+    https://en.wikibooks.org/wiki/MINC/Reference/MINC2.0_File_Format_Reference
+.. _NIfTI1: http://nifti.nimh.nih.gov/nifti-1/
+.. _NIfTI2: http://nifti.nimh.nih.gov/nifti-2/
 
-.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.591597.svg
-   :target: https://doi.org/10.5281/zenodo.591597
+Installation
+============
 
-.. Following contents should be from LONG_DESCRIPTION in nibabel/info.py
+To install NiBabel's `current release`_ with ``pip``, run::
 
+   pip install nibabel
 
-=======
-NiBabel
-=======
+To install the latest development version, run::
 
-Read / write access to some common neuroimaging file formats
+   pip install git+https://github.com/nipy/nibabel
 
-This package provides read +/- write access to some common medical and
-neuroimaging file formats, including: ANALYZE_ (plain, SPM99, SPM2 and later),
-GIFTI_, NIfTI1_, NIfTI2_, `CIFTI-2`_, MINC1_, MINC2_, `AFNI BRIK/HEAD`_, MGH_ and
-ECAT_ as well as Philips PAR/REC.  We can read and write FreeSurfer_ geometry,
-annotation and morphometry files.  There is some very limited support for
-DICOM_.  NiBabel is the successor of PyNIfTI_.
+When working on NiBabel itself, it may be useful to install in "editable" mode::
 
-.. _ANALYZE: http://www.grahamwideman.com/gw/brain/analyze/formatdoc.htm
-.. _AFNI BRIK/HEAD: https://afni.nimh.nih.gov/pub/dist/src/README.attributes
-.. _NIfTI1: http://nifti.nimh.nih.gov/nifti-1/
-.. _NIfTI2: http://nifti.nimh.nih.gov/nifti-2/
-.. _CIFTI-2: https://www.nitrc.org/projects/cifti/
-.. _MINC1:
-    https://en.wikibooks.org/wiki/MINC/Reference/MINC1_File_Format_Reference
-.. _MINC2:
-    https://en.wikibooks.org/wiki/MINC/Reference/MINC2.0_File_Format_Reference
-.. _PyNIfTI: http://niftilib.sourceforge.net/pynifti/
-.. _GIFTI: https://www.nitrc.org/projects/gifti
-.. _MGH: https://surfer.nmr.mgh.harvard.edu/fswiki/FsTutorial/MghFormat
-.. _ECAT: http://xmedcon.sourceforge.net/Docs/Ecat
-.. _Freesurfer: https://surfer.nmr.mgh.harvard.edu
-.. _DICOM: http://medical.nema.org/
+   git clone https://github.com/nipy/nibabel.git
+   pip install -e ./nibabel
 
-The various image format classes give full or selective access to header
-(meta) information and access to the image data is made available via NumPy
-arrays.
+For more information on previous releases, see the `release archive`_ or
+`development changelog`_.
 
-Website
+.. _current release: https://pypi.python.org/pypi/NiBabel
+.. _release archive: https://github.com/nipy/NiBabel/releases
+.. _development changelog: https://nipy.org/nibabel/changelog.html
+
+Testing
 =======
 
-Current documentation on nibabel can always be found at the `NIPY nibabel
-website <http://nipy.org/nibabel>`_.
+During development, we recommend using tox_ to run nibabel tests::
 
-Mailing Lists
-=============
+    git clone https://github.com/nipy/nibabel.git
+    cd nibabel
+    tox
 
-Please send any questions or suggestions to the `neuroimaging mailing list
-<https://mail.python.org/mailman/listinfo/neuroimaging>`_.
+To test an installed version of nibabel, install the test dependencies
+and run pytest_::
 
-Code
-====
+    pip install nibabel[test]
+    pytest --pyargs nibabel
 
-Install nibabel with::
+For more information, consult the `developer guidelines`_.
 
-    pip install nibabel
+.. _tox: https://tox.wiki
+.. _pytest: https://docs.pytest.org
+.. _developer guidelines: https://nipy.org/nibabel/devel/devguide.html
 
-You may also be interested in:
+Mailing List
+============
 
-* the `nibabel code repository`_ on Github;
-* documentation_ for all releases and current development tree;
-* download the `current release`_ from pypi;
-* download `current development version`_ as a zip file;
-* downloads of all `available releases`_.
-
-.. _nibabel code repository: https://github.com/nipy/nibabel
-.. _Documentation: http://nipy.org/nibabel
-.. _current release: https://pypi.python.org/pypi/nibabel
-.. _current development version: https://github.com/nipy/nibabel/archive/master.zip
-.. _available releases: https://github.com/nipy/nibabel/releases
+Please send any questions or suggestions to the `neuroimaging mailing list
+<https://mail.python.org/mailman/listinfo/neuroimaging>`_.
 
 License
 =======
 
-Nibabel is licensed under the terms of the MIT license. Some code included
-with nibabel is licensed under the BSD license.  Please see the COPYING file
-in the nibabel distribution.
+NiBabel is licensed under the terms of the `MIT license
+<https://github.com/nipy/nibabel/blob/master/COPYING#nibabel>`__.
+Some code included with NiBabel is licensed under the `BSD license`_.
+For more information, please see the COPYING_ file.
 
-Citing nibabel
-==============
+.. _BSD license: https://opensource.org/licenses/BSD-3-Clause
+.. _COPYING: https://github.com/nipy/nibabel/blob/master/COPYING
 
-Please see the `available releases`_ for the release of nibabel that you are
-using.  Recent releases have a Zenodo_ `Digital Object Identifier`_ badge at
-the top of the release notes.  Click on the badge for more information.
+Citation
+========
+
+NiBabel releases have a Zenodo_ `Digital Object Identifier`_ (DOI) badge at
+the top of the release notes. Click on the badge for more information.
 
-.. _zenodo: https://zenodo.org
 .. _Digital Object Identifier: https://en.wikipedia.org/wiki/Digital_object_identifier
+.. _zenodo: https://zenodo.org
diff --git a/bin/parrec2nii b/bin/parrec2nii
index 4a21c6d288..e5ec8bfe38 100755
--- a/bin/parrec2nii
+++ b/bin/parrec2nii
@@ -1,6 +1,5 @@
 #!python
-"""PAR/REC to NIfTI converter
-"""
+"""PAR/REC to NIfTI converter"""
 
 from nibabel.cmdline.parrec2nii import main
 
diff --git a/doc-requirements.txt b/doc-requirements.txt
index 64830ca962..4136b0f815 100644
--- a/doc-requirements.txt
+++ b/doc-requirements.txt
@@ -1,7 +1,7 @@
 # Auto-generated by tools/update_requirements.py
 -r requirements.txt
-matplotlib >= 1.5.3
+sphinx
+matplotlib>=3.5
 numpydoc
-sphinx ~= 5.3
 texext
-tomli; python_version < "3.11"
+tomli; python_version < '3.11'
diff --git a/doc/README.rst b/doc/README.rst
index a19a3c1261..d5fd9765e6 100644
--- a/doc/README.rst
+++ b/doc/README.rst
@@ -3,7 +3,7 @@ Nibabel documentation
 #####################
 
 To build the documentation, change to the root directory (containing
-``setup.py``) and run::
+``pyproject.toml``) and run::
 
     pip install -r doc-requirements.txt
-    make html
+    make -C doc html
diff --git a/doc/pics/logo.png b/doc/pics/logo.png
new file mode 100644
index 0000000000..570d38f476
Binary files /dev/null and b/doc/pics/logo.png differ
diff --git a/doc/source/conf.py b/doc/source/conf.py
index 82fe25adac..9811651223 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # emacs: -*- mode: python-mode; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
@@ -29,6 +28,10 @@
     import tomli as tomllib
 
 # Check for external Sphinx extensions we depend on
+try:
+    import numpy as np
+except ImportError:
+    raise RuntimeError('Need to install "numpy" package for doc build')
 try:
     import numpydoc
 except ImportError:
@@ -46,6 +49,11 @@
         'Need nibabel on Python PATH; consider "make htmldoc" from nibabel root directory'
     )
 
+from packaging.version import Version
+
+if Version(np.__version__) >= Version('1.22'):
+    np.set_printoptions(legacy='1.21')
+
 # -- General configuration ----------------------------------------------------
 
 # We load the nibabel release info into a dict by explicit execution
@@ -94,7 +102,7 @@
 
 # General information about the project.
 project = 'NiBabel'
-copyright = f"2006-2023, {authors['name']} <{authors['email']}>"
+copyright = f"2006, {authors['name']} <{authors['email']}>"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -280,7 +288,12 @@
 
 
 # Example configuration for intersphinx: refer to the Python standard library.
-intersphinx_mapping = {'https://docs.python.org/3/': None}
+intersphinx_mapping = {
+    'python': ('https://docs.python.org/3', None),
+    'numpy': ('https://numpy.org/doc/stable', None),
+    'scipy': ('https://docs.scipy.org/doc/scipy', None),
+    'matplotlib': ('https://matplotlib.org/stable', None),
+}
 
 # Config of plot_directive
 plot_include_source = True
diff --git a/doc/source/devel/biaps/biap_0006.rst b/doc/source/devel/biaps/biap_0006.rst
index 16a3a4833f..effe3d343c 100644
--- a/doc/source/devel/biaps/biap_0006.rst
+++ b/doc/source/devel/biaps/biap_0006.rst
@@ -202,7 +202,7 @@ here is the definition of a "multi-frame image"::
     3.8.9 Multi-frame image:
         Image that contains multiple two-dimensional pixel planes.
 
-From `PS 3.3 of the 2011 DICOM standrd
+From `PS 3.3 of the 2011 DICOM standard
 <http://medical.nema.org/Dicom/2011/11_03pu.pdf>`_.
 
 **********************************
diff --git a/doc/source/devel/data_pkg_design.rst b/doc/source/devel/data_pkg_design.rst
deleted file mode 100644
index eabf2ea7e8..0000000000
--- a/doc/source/devel/data_pkg_design.rst
+++ /dev/null
@@ -1,298 +0,0 @@
-.. _data-package-design:
-
-Design of data packages for the nibabel and the nipy suite
-==========================================================
-
-See :ref:`data-package-discuss` for a more general discussion of design
-issues.
-
-When developing or using nipy, many data files can be useful. We divide the
-data files nipy uses into at least 3 categories
-
-#. *test data* - data files required for routine code testing
-#. *template data* - data files required for algorithms to function,
-   such as templates or atlases
-#. *example data* - data files for running examples, or optional tests
-
-Files used for routine testing are typically very small data files. They are
-shipped with the software, and live in the code repository. For example, in
-the case of ``nipy`` itself, there are some test files that live in the module
-path ``nipy.testing.data``.  Nibabel ships data files in
-``nibabel.tests.data``.  See :doc:`add_test_data` for discussion.
-
-*template data* and *example data* are example of *data packages*.  What
-follows is a discussion of the design and use of data packages.
-
-.. testsetup::
-
-    # Make fake data and template directories
-    import os
-    from os.path import join as pjoin
-    import tempfile
-    tmpdir = tempfile.mkdtemp()
-    os.environ['NIPY_USER_DIR'] = tmpdir
-    for subdir in ('data', 'templates'):
-        files_dir = pjoin(tmpdir, 'nipy', subdir)
-        os.makedirs(files_dir)
-        with open(pjoin(files_dir, 'config.ini'), 'wt') as fobj:
-            fobj.write(
-    """[DEFAULT]
-    version = 0.2
-    """)
-
-Use cases for data packages
-+++++++++++++++++++++++++++
-
-Using the data package
-``````````````````````
-
-The programmer can use the data like this:
-
-.. testcode::
-
-   from nibabel.data import make_datasource
-
-   templates = make_datasource(dict(relpath='nipy/templates'))
-   fname = templates.get_filename('ICBM152', '2mm', 'T1.nii.gz')
-
-where ``fname`` will be the absolute path to the template image
-``ICBM152/2mm/T1.nii.gz``.
-
-The programmer can insist on a particular version of a ``datasource``:
-
->>> if templates.version < '0.4':
-...     raise ValueError('Need datasource version at least 0.4')
-Traceback (most recent call last):
-...
-ValueError: Need datasource version at least 0.4
-
-If the repository cannot find the data, then:
-
->>> make_datasource(dict(relpath='nipy/implausible'))
-Traceback (most recent call last):
- ...
-nibabel.data.DataError: ...
-
-where ``DataError`` gives a helpful warning about why the data was not
-found, and how it should be installed.
-
-Warnings during installation
-````````````````````````````
-
-The example data and template data may be important, and so we want to warn
-the user if NIPY cannot find either of the two sets of data when installing
-the package.  Thus::
-
-   python setup.py install
-
-will import nipy after installation to check whether these raise an error:
-
->>> from nibabel.data import make_datasource
->>> templates = make_datasource(dict(relpath='nipy/templates'))
->>> example_data = make_datasource(dict(relpath='nipy/data'))
-
-and warn the user accordingly, with some basic instructions for how to
-install the data.
-
-.. _find-data:
-
-Finding the data
-````````````````
-
-The routine ``make_datasource`` will look for data packages that have been
-installed.  For the following call:
-
->>> templates = make_datasource(dict(relpath='nipy/templates'))
-
-the code will:
-
-#. Get a list of paths where data is known to be stored with
-   ``nibabel.data.get_data_path()``
-#. For each of these paths, search for directory ``nipy/templates``.  If
-   found, and of the correct format (see below), return a datasource,
-   otherwise raise an Exception
-
-The paths collected by ``nibabel.data.get_data_paths()`` are constructed from
-':' (Unix) or ';' separated strings.  The source of the strings (in the order
-in which they will be used in the search above) are:
-
-#. The value of the ``NIPY_DATA_PATH`` environment variable, if set
-#. A section = ``DATA``, parameter = ``path`` entry in a
-   ``config.ini`` file in ``nipy_dir`` where ``nipy_dir`` is
-   ``$HOME/.nipy`` or equivalent.
-#. Section = ``DATA``, parameter = ``path`` entries in configuration
-   ``.ini`` files, where the ``.ini`` files are found by
-   ``glob.glob(os.path.join(etc_dir, '*.ini')`` and ``etc_dir`` is
-   ``/etc/nipy`` on Unix, and some suitable equivalent on Windows.
-#. The result of ``os.path.join(sys.prefix, 'share', 'nipy')``
-#. If ``sys.prefix`` is ``/usr``, we add ``/usr/local/share/nipy``. We
-   need this because Python >= 2.6 in Debian / Ubuntu does default installs to
-   ``/usr/local``.
-#. The result of ``get_nipy_user_dir()``
-
-Requirements for a data package
-```````````````````````````````
-
-To be a valid NIPY project data package, you need to satisfy:
-
-#. The installer installs the data in some place that can be found using
-   the method defined in :ref:`find-data`.
-
-We recommend that:
-
-#. By default, you install data in a standard location such as
-   ``<prefix>/share/nipy`` where ``<prefix>`` is the standard Python
-   prefix obtained by ``>>> import sys; print sys.prefix``
-
-Remember that there is a distinction between the NIPY project - the
-umbrella of neuroimaging in python - and the NIPY package - the main
-code package in the NIPY project.  Thus, if you want to install data
-under the NIPY *package* umbrella, your data might go to
-``/usr/share/nipy/nipy/packagename`` (on Unix).  Note ``nipy`` twice -
-once for the project, once for the package.  If you want to install data
-under - say - the ``pbrain`` package umbrella, that would go in
-``/usr/share/nipy/pbrain/packagename``.
-
-Data package format
-```````````````````
-
-The following tree is an example of the kind of pattern we would expect
-in a data directory, where the ``nipy-data`` and ``nipy-templates``
-packages have been installed::
-
-  <ROOT>
-  `-- nipy
-      |-- data
-      |   |-- config.ini
-      |   `-- placeholder.txt
-      `-- templates
-          |-- ICBM152
-          |   `-- 2mm
-          |       `-- T1.nii.gz
-          |-- colin27
-          |   `-- 2mm
-          |       `-- T1.nii.gz
-          `-- config.ini
-
-The ``<ROOT>`` directory is the directory that will appear somewhere in
-the list from ``nibabel.data.get_data_path()``.  The ``nipy`` subdirectory
-signifies data for the ``nipy`` package (as opposed to other
-NIPY-related packages such as ``pbrain``).  The ``data`` subdirectory of
-``nipy`` contains files from the ``nipy-data`` package.  In the
-``nipy/data`` or ``nipy/templates`` directories, there is a
-``config.ini`` file, that has at least an entry like this::
-
-  [DEFAULT]
-  version = 0.2
-
-giving the version of the data package.
-
-.. _data-package-design-install:
-
-Installing the data
-```````````````````
-
-We use python distutils to install data packages, and the ``data_files``
-mechanism to install the data.  On Unix, with the following command::
-
-   python setup.py install --prefix=/my/prefix
-
-data will go to::
-
-   /my/prefix/share/nipy
-
-For the example above this will result in these subdirectories::
-
-   /my/prefix/share/nipy/nipy/data
-   /my/prefix/share/nipy/nipy/templates
-
-because ``nipy`` is both the project, and the package to which the data
-relates.
-
-If you install to a particular location, you will need to add that location to
-the output of ``nibabel.data.get_data_path()`` using one of the mechanisms
-above, for example, in your system configuration::
-
-   export NIPY_DATA_PATH=/my/prefix/share/nipy
-
-Packaging for distributions
-```````````````````````````
-
-For a particular data package - say ``nipy-templates`` - distributions
-will want to:
-
-#. Install the data in set location.  The default from ``python setup.py
-   install`` for the data packages will be ``/usr/share/nipy`` on Unix.
-#. Point a system installation of NIPY to these data.
-
-For the latter, the most obvious route is to copy an ``.ini`` file named for
-the data package into the NIPY ``etc_dir``.  In this case, on Unix, we will
-want a file called ``/etc/nipy/nipy_templates.ini`` with contents::
-
-   [DATA]
-   path = /usr/share/nipy
-
-Current implementation
-``````````````````````
-
-This section describes how we (the nipy community) implement data packages at
-the moment.
-
-The data in the data packages will not usually be under source control.  This
-is because images don't compress very well, and any change in the data will
-result in a large extra storage cost in the repository.  If you're pretty
-clear that the data files aren't going to change, then a repository could work
-OK.
-
-The data packages will be available at a central release location.  For now
-this will be: http://nipy.org/data-packages/ .
-
-A package, such as ``nipy-templates-0.2.tar.gz`` will have the following sort
-of structure::
-
-
-  <ROOT>
-    |-- setup.py
-    |-- README.txt
-    |-- MANIFEST.in
-    `-- templates
-        |-- ICBM152
-        |   |-- 1mm
-        |   |   `-- T1_brain.nii.gz
-        |   `-- 2mm
-        |       `-- T1.nii.gz
-        |-- colin27
-        |   `-- 2mm
-        |       `-- T1.nii.gz
-        `-- config.ini
-
-
-There should be only one ``nipy/packagename`` directory delivered by a
-particular package.  For example, this package installs ``nipy/templates``,
-but does not contain ``nipy/data``.
-
-Making a new package tarball is simply:
-
-#. Downloading and unpacking e.g. ``nipy-templates-0.1.tar.gz`` to form the
-   directory structure above;
-#. Making any changes to the directory;
-#. Running ``setup.py sdist`` to recreate the package.
-
-The process of making a release should be:
-
-#. Increment the major or minor version number in the ``config.ini`` file;
-#. Make a package tarball as above;
-#. Upload to distribution site.
-
-There is an example nipy data package ``nipy-examplepkg`` in the
-``examples`` directory of the NIPY repository.
-
-The machinery for creating and maintaining data packages is available at
-https://github.com/nipy/data-packaging.
-
-See the ``README.txt`` file there for more information.
-
-.. testcleanup::
-
-    import shutil
-    shutil.rmtree(tmpdir)
diff --git a/doc/source/devel/data_pkg_uses.rst b/doc/source/devel/data_pkg_uses.rst
deleted file mode 100644
index 8573e06cb7..0000000000
--- a/doc/source/devel/data_pkg_uses.rst
+++ /dev/null
@@ -1,255 +0,0 @@
-.. _data-pkg-uses:
-
-########################################
-Data package usecases and implementation
-########################################
-
-********
-Usecases
-********
-
-We are here working from :doc:`data_pkg_discuss`
-
-Prundles
-========
-
-See :ref:`prundle`.
-
-An *local path* format prundle is a directory on the local file system with prundle data stored in files in a
-on the local filesystem.
-
-Examples
-========
-
-We'll call our package `dang` - data package new generation.
-
-Create local-path prundle
--------------------------
-
-::
-
-    >>> import os
-    >>> import tempfile
-    >>> pth = tempfile.mkdtemp() # temporary directory
-
-Make a pinstance object::
-
-    >>> from dang import Pinstance
-    >>> pri = Prundle(name='my-package')
-    >>> pri.pkg_name
-    'my-package'
-    >>> pri.meta
-    {}
-
-Now we make a prundle.   First a directory to contain it::
-
-    >>> import os
-    >>> import tempfile
-    >>> pth = tempfile.mkdtemp() # temporary directory
-
-    >>> from dang.prundle import LocalPathPrundle
-    >>> prun = LocalPathPrundle(pri, pth)
-
-At the moment there's nothing in the directory.  The 'write' method will write
-the meta information - here just the package name::
-
-    >>> prun.write() # writes meta.ini file
-    >>> os.listdir(pth)
-    ['meta.ini']
-
-The local path prundle data is just the set of files in the temporary directory
-named in ``pth`` above.
-
-Now we've written the package, we can get it by a single call that reads in the
-``meta.ini`` file::
-
-    >>> prun_back = LocalPathPrundle.from_path(pth)
-    >>> prun_back.pkg_name
-    'my-package'
-
-Getting prundle data
---------------------
-
-The file-system prundle formats can return content by file names.
-
-For example, for the local path ``prun`` distribution objects we have seen so
-far, the following should work::
-
-    >>> fobj = prun.get_fileobj('a_file.txt')
-
-In fact, local path distribution objects also have a ``path`` attribute::
-
-    >>> fname = os.path.join(prun.path, 'a_file.txt')
-
-The ``path`` attribute might not make sense for objects with greater
-abstraction over the file-system - for example objects encapsulating web
-content.
-
-*********
-Discovery
-*********
-
-So far, in order to create a prundle object, we have to know where the prundle
-is (the path).
-
-We want to be able to tell the system where prundles are - and the system will
-then be able to return a prundle on request - perhaps by package name.  The
-system here is answering a :ref:`prundle-discovery` query.
-
-We will then want to ask our packaging system whether it knows about the
-prundle we are interested in.
-
-Discovery sources
-=================
-
-A discovery source is an object that can answer a discovery query.
-Specifically, it is an object with a ``discover`` method, like this::
-
-    >>> import dang
-    >>> dsrc = dang.get_source('local-system')
-    >>> dquery_result = dsrc.discover('my-package', version='0')
-    >>> dquery_result[0].pkg_name
-    'my-package'
-    >>> dquery_result = dsrc.discover('implausible-pkg', version='0')
-    >>> len(dquery_result)
-    0
-
-The discovery version number spec may allow comparison operators, as for
-``distutils.version.LooseVersion``::
-
-    >>> res = dsrc.discover(name='my-package', version='>=0')
-    >>> prun = rst[0]
-    >>> prun.pkg_name
-    'my-package'
-    >>> prun.meta['version']
-    '0'
-
-Default discovery sources
-=========================
-
-We've used the ``local-system`` discovery source in this call::
-
-    >>> dsrc = dpkg.get_source('local-system')
-
-The ``get_source`` function is a convenience function that returns default
-discovery sources by name.  There are at least two named discovery sources,
-``local-system``, and ``local-user``.  ``local-system`` is a discovery source
-for packages that are installed system-wide (``/usr/share/data`` type
-installation in \*nix).  ``local-user`` is for packages installed for this user
-only (``/home/user/data`` type installations in \*nix).
-
-Discovery source pools
-======================
-
-We'll typically have more than one source from which we'd like to query.  The
-obvious case is where we want to look for both system and local sources.  For
-this we have a *source pool* which simply returns the first known distribution
-from a list of sources.  Something like this::
-
-    >>> local_sys = dpkg.get_source('local-system')
-    >>> local_usr = dpkg.get_source('local-user')
-    >>> src_pool = dpkg.SourcePool((local_usr, local_sys))
-    >>> dq_res = src_pool.discover('my-package', version='0')
-    >>> dq_res[0].pkg_name
-    'my-package'
-
-We'll often want to do exactly this, so we'll add this source pool to those
-that can be returned from our ``get_source`` convenience function::
-
-    >>> src_pool = dpkg.get_source('local-pool')
-
-Register a prundle
-==================
-
-In order to register a prundle, we need a prundle object and a
-discovery source::
-
-    >>> from dang.prundle import LocalPathPrundle
-    >>> prun = LocalPathDistribution.from_path(path=/a/path')
-    >>> local_usr = dang.get_source('local-user')
-    >>> local_usr.register(prun)
-
-Let us then write the source to disk::
-
-    >>> local_usr.write()
-
-Now, when we start another process as the same user, we can do this::
-
-    >>> import dang
-    >>> local_usr = dang.get_source('local-user')
-    >>> prun = local_usr.discover('my-package', '0')[0]
-
-**************
-Implementation
-**************
-
-Here are some notes.  We had the hope that we could implement something that
-would be simple enough that someone using the system would not need our code,
-but could work from the specification.
-
-Local path prundles
-===================
-
-These are directories accessible on the local filesystem.  The directory needs
-to give information about the prundle name and optionally, version, tag,
-revision id and maybe other metadata.  An ``ini`` file is probably enough for
-this - something like a ``meta.ini`` file in the directory with::
-
-    [DEFAULT]
-    name = my-package
-    version = 0
-
-might be enough to get started.
-
-Discovery sources
-=================
-
-The discovery source has to be able to return prundle objects for the
-prundles it knows about::
-
-    [my-package]
-    0 = /some/path
-    0.1 = /another/path
-    [another-package]
-    0 = /further/path
-
-Registering a package
-=====================
-
-So far we have a local path distribution, that is a directory with some files
-in it, and our own ``meta.ini`` file, containing the package name and version.
-How does this package register itself to the default sources?  Of course, we
-could use ``dpkg`` as above::
-
-    >>> dst = dpkg.LocalPathDistribution.from_path(path='/a/path')
-    >>> local_usr = dpkg.get_source('local-user')
-    >>> local_usr.register(dst)
-    >>> local_usr.save()
-
-but we wanted to be able to avoid using ``dpkg``.  To do this, there might be
-a supporting script, in the distribution directory, called ``register_me.py``,
-of form given in :download:`register_me.py`.
-
-Using discovery sources without dpkg
-====================================
-
-The local discovery sources are ini files, so it would be easy to read and use
-these outside the dpkg system, as long as the locations of the ini files are
-well defined.  Here is the code from ``register_me.py`` defining these files::
-
-    import os
-    import sys
-
-    if sys.platform == 'win32':
-        _home_dpkg_sdir = '_dpkg'
-        _sys_drive, _ = os.path.splitdrive(sys.prefix)
-    else:
-        _home_dpkg_sdir = '.dpkg'
-        _sys_drive = '/'
-    # Can we get the user directory?
-    _home = os.path.expanduser('~')
-    if _home == '~': # if not, the user ini file is undefined
-        HOME_INI = None
-    else:
-        HOME_INI = os.path.join(_home, _home_dpkg_sdir, 'local.dsource')
-    SYS_INI = os.path.join(_sys_drive, 'etc', 'dpkg', 'local.dsource')
diff --git a/doc/source/devel/devdiscuss.rst b/doc/source/devel/devdiscuss.rst
index c864928d60..bc23e823c2 100644
--- a/doc/source/devel/devdiscuss.rst
+++ b/doc/source/devel/devdiscuss.rst
@@ -21,8 +21,5 @@ progress.
 
     spm_use
     modified_images
-    data_pkg_design
-    data_pkg_discuss
-    data_pkg_uses
     scaling
     bv_formats
diff --git a/doc/source/devel/devguide.rst b/doc/source/devel/devguide.rst
index 2747564dbf..8748270f11 100644
--- a/doc/source/devel/devguide.rst
+++ b/doc/source/devel/devguide.rst
@@ -95,6 +95,85 @@ advise that you enable merge summaries within git:
 
 See :ref:`configure-git` for more detail.
 
+Testing
+=======
+
+NiBabel uses tox_ to organize our testing and development workflows.
+tox runs tests in isolated environments that we specify,
+ensuring that we are able to test across many different environments,
+and those environments do not depend on our local configurations.
+
+If you have the pipx_ tool installed, then you may simply::
+
+    pipx run tox
+
+Alternatively, you can install tox and run it::
+
+    python -m pip install tox
+    tox
+
+This will run the tests in several configurations, with multiple sets of
+optional dependencies.
+If you have multiple versions of Python installed in your path, it will
+repeat the process for each version of Python iin our supported range.
+It may be useful to pick a particular version for rapid development::
+
+    tox -e py311-full-x64
+
+This will run the environment using the Python 3.11 interpreter, with the
+full set of optional dependencies that are available for 64-bit
+interpreters. If you are using 32-bit Python, replace ``-x64`` with ``-x86``.
+
+
+Style guide
+===========
+
+To ensure code consistency and readability, NiBabel has adopted the following
+tools:
+
+* blue_ - An auto-formatter that aims to reduce diffs to relevant lines
+* isort_ - An import sorter that groups stdlib, third-party and local imports.
+* flake8_ - A style checker that can catch (but generally not fix) common
+  errors in code.
+* codespell_ - A spell checker targeted at source code.
+* pre-commit_ - A pre-commit hook manager that runs the above and various
+  other checks/fixes.
+
+While some amount of personal preference is involved in selecting and
+configuring auto-formatters, their value lies in largely eliminating the
+need to think or argue about style.
+With pre-commit turned on, you can write in the style that works for you,
+and the NiBabel style will be adopted prior to the commit.
+
+To apply our style checks uniformly, simply run::
+
+    tox -e style,spellcheck
+
+To fix any issues found::
+
+    tox -e style-fix
+    tox -e spellcheck -- -w
+
+Occasionally, codespell has a false positive. To ignore the suggestion, add
+the intended word to ``tool.codespell.ignore-words-list`` in ``pyproject.toml``.
+However, the ignore list is a blunt instrument and could cause a legitimate
+misspelling to be missed. Consider choosing a word that does not trigger
+codespell before adding it to the ignore list.
+
+Pre-commit hooks
+----------------
+
+NiBabel uses pre-commit_ to help committers validate their changes
+before committing. To enable these, you can use pipx_::
+
+    pipx run pre-commit install
+
+Or install and run::
+
+    python -m pip install pre-commit
+    pre-commit install
+
+
 Changelog
 =========
 
@@ -123,3 +202,10 @@ Community guidelines
 Please see `our community guidelines
 <https://github.com/nipy/nibabel/blob/master/.github/CODE_OF_CONDUCT.md>`_.
 Other projects call these guidelines the "code of conduct".
+
+.. _blue: https://blue.readthedocs.io/
+.. _codespell: https://github.com/codespell-project/codespell
+.. _flake8: https://flake8.pycqa.org/
+.. _pipx: https://pypa.github.io/pipx/
+.. _precommit: https://pre-commit.com/
+.. _tox: https://tox.wiki/
diff --git a/doc/source/devel/register_me.py b/doc/source/devel/register_me.py
deleted file mode 100644
index 017f873abf..0000000000
--- a/doc/source/devel/register_me.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import configparser as cfp
-import sys
-from os.path import abspath, dirname, expanduser
-from os.path import join as pjoin
-
-if sys.platform == 'win32':
-    HOME_INI = pjoin(expanduser('~'), '_dpkg', 'local.dsource')
-else:
-    HOME_INI = pjoin(expanduser('~'), '.dpkg', 'local.dsource')
-SYS_INI = pjoin(abspath('etc'), 'dpkg', 'local.dsource')
-OUR_PATH = dirname(__file__)
-OUR_META = pjoin(OUR_PATH, 'meta.ini')
-DISCOVER_INIS = {'user': HOME_INI, 'system': SYS_INI}
-
-
-def main():
-    # Get ini file to which to write
-    try:
-        reg_to = sys.argv[1]
-    except IndexError:
-        reg_to = 'user'
-    if reg_to in ('user', 'system'):
-        ini_fname = DISCOVER_INIS[reg_to]
-    else:  # it is an ini file name
-        ini_fname = reg_to
-
-    # Read parameters for our distribution
-    meta = cfp.ConfigParser()
-    files = meta.read(OUR_META)
-    if len(files) == 0:
-        raise RuntimeError('Missing meta.ini file')
-    name = meta.get('DEFAULT', 'name')
-    version = meta.get('DEFAULT', 'version')
-
-    # Write into ini file
-    dsource = cfp.ConfigParser()
-    dsource.read(ini_fname)
-    if not dsource.has_section(name):
-        dsource.add_section(name)
-    dsource.set(name, version, OUR_PATH)
-    dsource.write(file(ini_fname, 'wt'))
-
-    print(f'Registered package {name}, {version} to {ini_fname}')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/doc/source/dicom/dicom_intro.rst b/doc/source/dicom/dicom_intro.rst
index f1508932c6..e618153396 100644
--- a/doc/source/dicom/dicom_intro.rst
+++ b/doc/source/dicom/dicom_intro.rst
@@ -228,22 +228,22 @@ Here is the start of the relevant section from PS 3.5:
 
   7.8.1 PRIVATE DATA ELEMENT TAGS
 
-  It is possible that multiple implementors may define Private Elements with the
+  It is possible that multiple implementers may define Private Elements with the
   same (odd) group number.  To avoid conflicts, Private Elements shall be
   assigned Private Data Element Tags according to the following rules.
 
   a) Private Creator Data Elements numbered (gggg,0010-00FF) (gggg is odd) shall
   be used to reserve a block of Elements with Group Number gggg for use by an
-  individual implementor.  The implementor shall insert an identification code
+  individual implementer.  The implementer shall insert an identification code
   in the first unused (unassigned) Element in this series to reserve a block of
   Private Elements. The VR of the private identification code shall be LO (Long
   String) and the VM shall be equal to 1.
 
   b) Private Creator Data Element (gggg,0010), is a Type 1 Data Element that
-  identifies the implementor reserving element (gggg,1000-10FF), Private Creator
-  Data Element (gggg,0011) identifies the implementor reserving elements
+  identifies the implementer reserving element (gggg,1000-10FF), Private Creator
+  Data Element (gggg,0011) identifies the implementer reserving elements
   (gggg,1100-11FF), and so on, until Private Creator Data Element (gggg,00FF)
-  identifies the implementor reserving elements (gggg,FF00- FFFF).
+  identifies the implementer reserving elements (gggg,FF00- FFFF).
 
   c) Encoders of Private Data Elements shall be able to dynamically assign
   private data to any available (unreserved) block(s) within the Private group,
diff --git a/doc/source/external/nifti1.h b/doc/source/external/nifti1.h
index 80066fb347..dce3a88c1a 100644
--- a/doc/source/external/nifti1.h
+++ b/doc/source/external/nifti1.h
@@ -869,7 +869,7 @@ typedef struct { unsigned char r,g,b; } rgb_byte ;
      as a displacement field or vector:
        - dataset must have a 5th dimension
        - intent_code must be NIFTI_INTENT_DISPVECT
-       - dim[5] must be the dimensionality of the displacment
+       - dim[5] must be the dimensionality of the displacement
          vector (e.g., 3 for spatial displacement, 2 for in-plane) */
 
 #define NIFTI_INTENT_DISPVECT  1006   /* specifically for displacements */
diff --git a/doc/source/gitwash/development_workflow.rst b/doc/source/gitwash/development_workflow.rst
index 7c117cfcce..696a939ed8 100644
--- a/doc/source/gitwash/development_workflow.rst
+++ b/doc/source/gitwash/development_workflow.rst
@@ -334,7 +334,7 @@ Rewriting commit history
 
    Do this only for your own feature branches.
 
-There's an embarassing typo in a commit you made? Or perhaps the you
+There's an embarrassing typo in a commit you made? Or perhaps the you
 made several false starts you would like the posterity not to see.
 
 This can be done via *interactive rebasing*.
diff --git a/doc/source/index.rst b/doc/source/index.rst
index 8eb8a9c7d5..677e81b331 100644
--- a/doc/source/index.rst
+++ b/doc/source/index.rst
@@ -7,6 +7,10 @@
   #
   ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
 
+=======
+NiBabel
+=======
+
 .. include:: _long_description.inc
 
 Documentation
@@ -51,6 +55,7 @@ contributed code and discussion (in rough order of appearance):
 * JB Poline
 * Basile Pinsard
 * `Satrajit Ghosh`_
+* Eric Larson
 * `Nolan Nichols`_
 * Ly Nguyen
 * Philippe Gervais
@@ -119,6 +124,15 @@ contributed code and discussion (in rough order of appearance):
 * Andrew Van
 * Jérôme Dockès
 * Jacob Roberts
+* Horea Christian
+* Fabian Perez
+* Mathieu Scheltienne
+* Reinder Vos de Wael
+* Peter Suter
+* Blake Dewey
+* Guillaume Becq
+* Joshua Newton
+* Sandro from the Fedora Project
 
 License reprise
 ===============
diff --git a/doc/source/installation.rst b/doc/source/installation.rst
index 65a35ea333..983968c50f 100644
--- a/doc/source/installation.rst
+++ b/doc/source/installation.rst
@@ -81,16 +81,16 @@ is for you.
 Requirements
 ------------
 
-.. check these against pyproject.toml
-
-*  Python_ 3.8 or greater
-*  NumPy_ 1.19 or greater
-*  Packaging_ 17.0 or greater
-*  Setuptools_
-*  SciPy_ (optional, for full SPM-ANALYZE support)
-*  h5py_ (optional, for MINC2 support)
-*  PyDICOM_ 1.0.0 or greater (optional, for DICOM support)
-*  `Python Imaging Library`_ (optional, for PNG conversion in DICOMFS)
+.. check these against pyproject.toml / tox.ini
+
+*  Python_ 3.9 or greater
+*  NumPy_ 1.22 or greater
+*  Packaging_ 20.0 or greater
+*  importlib-resources_ 5.12 or greater (or Python 3.12+)
+*  SciPy_ 1.8 or greater (optional, for full SPM-ANALYZE support)
+*  h5py_ 3.5 or greater (optional, for MINC2 support)
+*  PyDICOM_ 2.3.0 or greater (optional, for DICOM support)
+*  `Python Imaging Library`_ 8.4 or greater (optional, for PNG conversion in DICOMFS)
 *  pytest_ (optional, to run the tests)
 *  sphinx_ (optional, to build the documentation)
 
diff --git a/doc/source/installing_data.rst b/doc/source/installing_data.rst
deleted file mode 100644
index ce32de2375..0000000000
--- a/doc/source/installing_data.rst
+++ /dev/null
@@ -1,80 +0,0 @@
-:orphan:
-
-.. _installing-data:
-
-Installing data packages
-========================
-
-nibabel includes some machinery for using optional data packages.  We use data
-packages for some of the DICOM tests in nibabel.  There are also data packages
-for standard template images, and other packages for components of nipy,
-including the main nipy package.
-
-For more details on data package design, see :ref:`data-package-design`.
-
-We haven't yet made a nice automated way of downloading and installing the
-packages.  For the moment you can find packages for the data and template files
-at http://nipy.org/data-packages.
-
-Data package installation as an administrator
----------------------------------------------
-
-The installation procedure, for now, is very basic.  For example, let us
-say that you want the 'nipy-templates' package at
-http://nipy.org/data-packages/nipy-templates-0.1.tar.gz
-. You simply download this archive, unpack it, and then run the standard
-``python setup.py install`` on it.  On a unix system this might look
-like::
-
-   curl -O http://nipy.org/data-packages/nipy-templates-0.1.tar.gz
-   tar zxvf nipy-templates-0.1.tar.gz
-   cd nipy-templates-0.1
-   sudo python setup.py install
-
-On windows, download the file, extract the archive to a folder using the
-GUI, and then, using the windows shell or similar::
-
-   cd c:\path\to\extracted\files
-   python setup.py install
-
-Non-administrator data package installation
--------------------------------------------
-
-The commands above assume you are installing into the default system
-directories.  If you want to install into a custom directory, then (in
-python, or ipython, or a text editor) look at the help for
-``nipy.utils.data.get_data_path()`` . There are instructions there for
-pointing your nipy installation to the installed data.
-
-On unix
-~~~~~~~
-
-For example, say you installed with::
-
-   cd nipy-templates-0.1
-   python setup.py install --prefix=/home/my-user/some-dir
-
-Then you may want to do make a file ``~/.nipy/config.ini`` with the
-following contents::
-
-   [DATA]
-   /home/my-user/some-dir/share/nipy
-
-On windows
-~~~~~~~~~~
-
-Say you installed with (windows shell)::
-
-   cd nipy-templates-0.1
-   python setup.py install --prefix=c:\some\path
-
-Then first, find out your home directory::
-
-   python -c "import os; print os.path.expanduser('~')"
-
-Let's say that was ``c:\Documents and Settings\My User``.  Then, make a
-new file called ``c:\Documents and Settings\My User\_nipy\config.ini``
-with contents::
-
-   [DATA]
-   c:\some\path\share\nipy
diff --git a/doc/source/links_names.txt b/doc/source/links_names.txt
index 7fbb27b12e..1ab1242c08 100644
--- a/doc/source/links_names.txt
+++ b/doc/source/links_names.txt
@@ -114,6 +114,7 @@
 .. _python imaging library: https://pypi.python.org/pypi/Pillow
 .. _h5py: https://www.h5py.org/
 .. _packaging: https://packaging.pypa.io
+.. _importlib-resources: https://importlib-resources.readthedocs.io/
 
 .. Python imaging projects
 .. _PyMVPA: http://www.pymvpa.org
diff --git a/doc/source/nifti_images.rst b/doc/source/nifti_images.rst
index 9318c062d1..39625e5c58 100644
--- a/doc/source/nifti_images.rst
+++ b/doc/source/nifti_images.rst
@@ -273,8 +273,8 @@ You can get and set the qform affine using the equivalent methods to those for
 the sform: ``get_qform()``, ``set_qform()``.
 
 >>> n1_header.get_qform(coded=True)
-(array([[ -2.  ,   0.  ,   0.  , 117.86],
-       [ -0.  ,   1.97,  -0.36, -35.72],
+(array([[ -2.  ,   0.  ,  -0.  , 117.86],
+       [  0.  ,   1.97,  -0.36, -35.72],
        [  0.  ,   0.32,   2.17,  -7.25],
        [  0.  ,   0.  ,   0.  ,   1.  ]]), 1)
 
diff --git a/doc/source/old/format_design.txt b/doc/source/old/format_design.txt
index 29585866a9..fdbf9419ba 100644
--- a/doc/source/old/format_design.txt
+++ b/doc/source/old/format_design.txt
@@ -13,7 +13,7 @@ The Image and the Format objects form a `bridge pattern
 diagram
 <https://en.wikipedia.org/wiki/File:Bridge_UML_class_diagram.svg>`_ the
 Image class plays the role of the Abstraction, and the Format plays the
-role of the implementor.
+role of the implementer.
 
 The Format object provides an interface to the underlying file format.
 
diff --git a/doc/tools/apigen.py b/doc/tools/apigen.py
index 3167362643..336c81d8d8 100644
--- a/doc/tools/apigen.py
+++ b/doc/tools/apigen.py
@@ -405,10 +405,7 @@ def discover_modules(self):
 
     def write_modules_api(self, modules, outdir):
         # upper-level modules
-        main_module = modules[0].split('.')[0]
-        ulms = [
-            '.'.join(m.split('.')[:2]) if m.count('.') >= 1 else m.split('.')[0] for m in modules
-        ]
+        ulms = ['.'.join(m.split('.')[:2]) for m in modules]
 
         from collections import OrderedDict
 
diff --git a/doc/tools/build_modref_templates.py b/doc/tools/build_modref_templates.py
index 11eae99741..76cf9cdf39 100755
--- a/doc/tools/build_modref_templates.py
+++ b/doc/tools/build_modref_templates.py
@@ -9,7 +9,7 @@
 import sys
 
 # version comparison
-from distutils.version import LooseVersion as V
+from packaging.version import Version as V
 from os.path import join as pjoin
 
 # local imports
@@ -38,7 +38,7 @@ def abort(error):
 
     try:
         __import__(package)
-    except ImportError as e:
+    except ImportError:
         abort('Can not import ' + package)
 
     module = sys.modules[package]
@@ -73,6 +73,8 @@ def abort(error):
                 if re.match('^_version_(major|minor|micro|extra)', v)
             ]
         )
+
+    source_version = V(source_version)
     print('***', source_version)
 
     if source_version != installed_version:
diff --git a/min-requirements.txt b/min-requirements.txt
index 305f16dcbd..455c6c8c62 100644
--- a/min-requirements.txt
+++ b/min-requirements.txt
@@ -1,4 +1,16 @@
-# Auto-generated by tools/update_requirements.py
-numpy ==1.19
-packaging ==17
-setuptools
+# This file was autogenerated by uv via the following command:
+#    uv pip compile --resolution lowest-direct --python 3.9 -o min-requirements.txt pyproject.toml
+importlib-resources==5.12.0
+    # via nibabel (pyproject.toml)
+numpy==1.22.0
+    # via nibabel (pyproject.toml)
+packaging==20.0
+    # via nibabel (pyproject.toml)
+pyparsing==3.2.0
+    # via packaging
+six==1.16.0
+    # via packaging
+typing-extensions==4.6.0
+    # via nibabel (pyproject.toml)
+zipp==3.20.2
+    # via importlib-resources
diff --git a/nibabel-data/dcm_qa_xa30 b/nibabel-data/dcm_qa_xa30
new file mode 160000
index 0000000000..89b2509218
--- /dev/null
+++ b/nibabel-data/dcm_qa_xa30
@@ -0,0 +1 @@
+Subproject commit 89b2509218a6dd021c5d40ddaf2a017ac1bacafc
diff --git a/nibabel/__init__.py b/nibabel/__init__.py
index 4311e3d7bf..c389c603fc 100644
--- a/nibabel/__init__.py
+++ b/nibabel/__init__.py
@@ -39,11 +39,10 @@
 
 # module imports
 from . import analyze as ana
-from . import ecat, mriutils
+from . import ecat, imagestats, mriutils, orientations, streamlines, viewers
 from . import nifti1 as ni1
 from . import spm2analyze as spm2
 from . import spm99analyze as spm99
-from . import streamlines, viewers
 
 # isort: split
 
@@ -171,11 +170,13 @@ def bench(label=None, verbose=1, extra_argv=None):
     code : ExitCode
         Returns the result of running the tests as a ``pytest.ExitCode`` enum
     """
-    from pkg_resources import resource_filename
+    from importlib.resources import as_file, files
 
-    config = resource_filename('nibabel', 'benchmarks/pytest.benchmark.ini')
     args = []
     if extra_argv is not None:
         args.extend(extra_argv)
-    args.extend(['-c', config])
-    return test(label, verbose, extra_argv=args)
+
+    config_path = files('nibabel') / 'benchmarks/pytest.benchmark.ini'
+    with as_file(config_path) as config:
+        args.extend(['-c', str(config)])
+        return test(label, verbose, extra_argv=args)
diff --git a/nibabel/_compression.py b/nibabel/_compression.py
new file mode 100644
index 0000000000..871be2629f
--- /dev/null
+++ b/nibabel/_compression.py
@@ -0,0 +1,51 @@
+# emacs: -*- mode: python-mode; py-indent-offset: 4; indent-tabs-mode: nil -*-
+# vi: set ft=python sts=4 ts=4 sw=4 et:
+### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
+#
+#   See COPYING file distributed along with the NiBabel package for the
+#   copyright and license terms.
+#
+### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
+"""Constants and types for dealing transparently with compression"""
+
+from __future__ import annotations
+
+import bz2
+import gzip
+import typing as ty
+
+from .optpkg import optional_package
+
+if ty.TYPE_CHECKING:
+    import io
+
+    import indexed_gzip  # type: ignore[import]
+    import pyzstd
+
+    HAVE_INDEXED_GZIP = True
+    HAVE_ZSTD = True
+else:
+    indexed_gzip, HAVE_INDEXED_GZIP, _ = optional_package('indexed_gzip')
+    pyzstd, HAVE_ZSTD, _ = optional_package('pyzstd')
+
+
+# Collections of types for isinstance or exception matching
+COMPRESSED_FILE_LIKES: tuple[type[io.IOBase], ...] = (
+    bz2.BZ2File,
+    gzip.GzipFile,
+)
+COMPRESSION_ERRORS: tuple[type[BaseException], ...] = (
+    OSError,  # BZ2File
+    gzip.BadGzipFile,
+)
+
+if HAVE_INDEXED_GZIP:
+    COMPRESSED_FILE_LIKES += (indexed_gzip.IndexedGzipFile,)
+    COMPRESSION_ERRORS += (indexed_gzip.ZranError,)
+    from indexed_gzip import IndexedGzipFile  # type: ignore[import-not-found]
+else:
+    IndexedGzipFile = gzip.GzipFile
+
+if HAVE_ZSTD:
+    COMPRESSED_FILE_LIKES += (pyzstd.ZstdFile,)
+    COMPRESSION_ERRORS += (pyzstd.ZstdError,)
diff --git a/nibabel/_typing.py b/nibabel/_typing.py
new file mode 100644
index 0000000000..8b62031810
--- /dev/null
+++ b/nibabel/_typing.py
@@ -0,0 +1,25 @@
+"""Helpers for typing compatibility across Python versions"""
+
+import sys
+
+if sys.version_info < (3, 10):
+    from typing_extensions import ParamSpec
+else:
+    from typing import ParamSpec
+
+if sys.version_info < (3, 11):
+    from typing_extensions import Self
+else:
+    from typing import Self
+
+if sys.version_info < (3, 13):
+    from typing_extensions import TypeVar
+else:
+    from typing import TypeVar
+
+
+__all__ = [
+    'ParamSpec',
+    'Self',
+    'TypeVar',
+]
diff --git a/nibabel/_version.pyi b/nibabel/_version.pyi
new file mode 100644
index 0000000000..f3c1fd305e
--- /dev/null
+++ b/nibabel/_version.pyi
@@ -0,0 +1,4 @@
+__version__: str
+__version_tuple__: tuple[str, ...]
+version: str
+version_tuple: tuple[str, ...]
diff --git a/nibabel/affines.py b/nibabel/affines.py
index 59b52e768e..4b6001dec0 100644
--- a/nibabel/affines.py
+++ b/nibabel/affines.py
@@ -1,7 +1,7 @@
 # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
-"""Utility routines for working with points and affine transforms
-"""
+"""Utility routines for working with points and affine transforms"""
+
 from functools import reduce
 
 import numpy as np
@@ -100,7 +100,7 @@ def apply_affine(aff, pts, inplace=False):
 
 
 def to_matvec(transform):
-    """Split a transform into its matrix and vector components.
+    """Split a transform into its matrix and vector components
 
     The transformation must be represented in homogeneous coordinates and is
     split into its rotation matrix and translation vector components.
@@ -312,8 +312,7 @@ def voxel_sizes(affine):
 
 
 def obliquity(affine):
-    r"""
-    Estimate the *obliquity* an affine's axes represent.
+    r"""Estimate the *obliquity* an affine's axes represent
 
     The term *obliquity* is defined here as the rotation of those axes with
     respect to the cardinal axes.
@@ -367,7 +366,7 @@ def rescale_affine(affine, shape, zooms, new_shape=None):
         A new affine transform with the specified voxel sizes
 
     """
-    shape = np.array(shape, copy=False)
+    shape = np.asarray(shape)
     new_shape = np.array(new_shape if new_shape is not None else shape)
 
     s = voxel_sizes(affine)
diff --git a/nibabel/analyze.py b/nibabel/analyze.py
index fc44693bc6..d02363c792 100644
--- a/nibabel/analyze.py
+++ b/nibabel/analyze.py
@@ -81,9 +81,8 @@
 can be loaded with and without a default flip, so the saved zoom will not
 constrain the affine.
 """
-from __future__ import annotations
 
-from typing import Type
+from __future__ import annotations
 
 import numpy as np
 
@@ -516,7 +515,9 @@ def data_to_fileobj(self, data, fileobj, rescale=True):
         data = np.asanyarray(data)
         shape = self.get_data_shape()
         if data.shape != shape:
-            raise HeaderDataError('Data should be shape (%s)' % ', '.join(str(s) for s in shape))
+            raise HeaderDataError(
+                'Data should be shape ({})'.format(', '.join(str(s) for s in shape))
+            )
         out_dtype = self.get_data_dtype()
         if rescale:
             try:
@@ -698,7 +699,7 @@ def set_zooms(self, zooms):
         ndim = dims[0]
         zooms = np.asarray(zooms)
         if len(zooms) != ndim:
-            raise HeaderDataError('Expecting %d zoom values for ndim %d' % (ndim, ndim))
+            raise HeaderDataError(f'Expecting {ndim} zoom values for ndim {ndim}')
         if np.any(zooms < 0):
             raise HeaderDataError('zooms must be positive')
         pixdims = hdr['pixdim']
@@ -817,11 +818,11 @@ def _chk_datatype(klass, hdr, fix=False):
             dtype = klass._data_type_codes.dtype[code]
         except KeyError:
             rep.problem_level = 40
-            rep.problem_msg = 'data code %d not recognized' % code
+            rep.problem_msg = f'data code {code} not recognized'
         else:
             if dtype.itemsize == 0:
                 rep.problem_level = 40
-                rep.problem_msg = 'data code %d not supported' % code
+                rep.problem_msg = f'data code {code} not supported'
             else:
                 return hdr, rep
         if fix:
@@ -895,7 +896,8 @@ def may_contain_header(klass, binaryblock):
 class AnalyzeImage(SpatialImage):
     """Class for basic Analyze format image"""
 
-    header_class: Type[AnalyzeHeader] = AnalyzeHeader
+    header_class: type[AnalyzeHeader] = AnalyzeHeader
+    header: AnalyzeHeader
     _meta_sniff_len = header_class.sizeof_hdr
     files_types: tuple[tuple[str, str], ...] = (('image', '.img'), ('header', '.hdr'))
     valid_exts: tuple[str, ...] = ('.img', '.hdr')
@@ -930,7 +932,7 @@ def from_file_map(klass, file_map, *, mmap=True, keep_file_open=None):
         Parameters
         ----------
         file_map : dict
-            Mapping with (kay, value) pairs of (``file_type``, FileHolder
+            Mapping with (key, value) pairs of (``file_type``, FileHolder
             instance giving file-likes for each file needed for this image
             type.
         mmap : {True, False, 'c', 'r'}, optional, keyword only
@@ -1064,5 +1066,5 @@ def to_file_map(self, file_map=None, dtype=None):
             hdr['scl_inter'] = inter
 
 
-load = AnalyzeImage.load
+load = AnalyzeImage.from_filename
 save = AnalyzeImage.instance_to_filename
diff --git a/nibabel/arrayproxy.py b/nibabel/arrayproxy.py
index 7213e65769..82713f639f 100644
--- a/nibabel/arrayproxy.py
+++ b/nibabel/arrayproxy.py
@@ -25,6 +25,7 @@
 
 See :mod:`nibabel.tests.test_proxy_api` for proxy API conformance checks.
 """
+
 from __future__ import annotations
 
 import typing as ty
@@ -56,9 +57,14 @@
 KEEP_FILE_OPEN_DEFAULT = False
 
 
-if ty.TYPE_CHECKING:  # pragma: no cover
+if ty.TYPE_CHECKING:
     import numpy.typing as npt
 
+    from ._typing import Self, TypeVar
+
+    # Taken from numpy/__init__.pyi
+    _DType = TypeVar('_DType', bound=np.dtype[ty.Any])
+
 
 class ArrayLike(ty.Protocol):
     """Protocol for numpy ndarray-like objects
@@ -68,13 +74,19 @@ class ArrayLike(ty.Protocol):
     """
 
     shape: tuple[int, ...]
-    ndim: int
 
-    def __array__(self, dtype: npt.DTypeLike | None = None, /) -> npt.NDArray:
-        ...  # pragma: no cover
+    @property
+    def ndim(self) -> int: ...
 
-    def __getitem__(self, key, /) -> npt.NDArray:
-        ...  # pragma: no cover
+    # If no dtype is passed, any dtype might be returned, depending on the array-like
+    @ty.overload
+    def __array__(self, dtype: None = ..., /) -> np.ndarray[ty.Any, np.dtype[ty.Any]]: ...
+
+    # Any dtype might be passed, and *that* dtype must be returned
+    @ty.overload
+    def __array__(self, dtype: _DType, /) -> np.ndarray[ty.Any, _DType]: ...
+
+    def __getitem__(self, key, /) -> npt.NDArray: ...
 
 
 class ArrayProxy(ArrayLike):
@@ -199,11 +211,30 @@ def __init__(self, file_like, spec, *, mmap=True, order=None, keep_file_open=Non
         self.order = order
         # Flags to keep track of whether a single ImageOpener is created, and
         # whether a single underlying file handle is created.
-        self._keep_file_open, self._persist_opener = self._should_keep_file_open(
-            file_like, keep_file_open
-        )
+        self._keep_file_open, self._persist_opener = self._should_keep_file_open(keep_file_open)
         self._lock = RLock()
 
+    def _has_fh(self) -> bool:
+        """Determine if our file-like is a filehandle or path"""
+        return hasattr(self.file_like, 'read') and hasattr(self.file_like, 'seek')
+
+    def copy(self) -> Self:
+        """Create a new ArrayProxy for the same file and parameters
+
+        If the proxied file is an open file handle, the new ArrayProxy
+        will share a lock with the old one.
+        """
+        spec = self._shape, self._dtype, self._offset, self._slope, self._inter
+        new = self.__class__(
+            self.file_like,
+            spec,
+            mmap=self._mmap,
+            keep_file_open=self._keep_file_open,
+        )
+        if self._has_fh():
+            new._lock = self._lock
+        return new
+
     def __del__(self):
         """If this ``ArrayProxy`` was created with ``keep_file_open=True``,
         the open file object is closed if necessary.
@@ -223,13 +254,13 @@ def __setstate__(self, state):
         self.__dict__.update(state)
         self._lock = RLock()
 
-    def _should_keep_file_open(self, file_like, keep_file_open):
+    def _should_keep_file_open(self, keep_file_open):
         """Called by ``__init__``.
 
         This method determines how to manage ``ImageOpener`` instances,
         and the underlying file handles - the behaviour depends on:
 
-         - whether ``file_like`` is an an open file handle, or a path to a
+         - whether ``self.file_like`` is an an open file handle, or a path to a
            ``'.gz'`` file, or a path to a non-gzip file.
          - whether ``indexed_gzip`` is present (see
            :attr:`.openers.HAVE_INDEXED_GZIP`).
@@ -248,24 +279,24 @@ def _should_keep_file_open(self, file_like, keep_file_open):
             and closed on each file access.
 
         The internal ``_keep_file_open`` flag is only relevant if
-        ``file_like`` is a ``'.gz'`` file, and the ``indexed_gzip`` library is
+        ``self.file_like`` is a ``'.gz'`` file, and the ``indexed_gzip`` library is
         present.
 
         This method returns the values to be used for the internal
         ``_persist_opener`` and ``_keep_file_open`` flags; these values are
         derived according to the following rules:
 
-        1. If ``file_like`` is a file(-like) object, both flags are set to
+        1. If ``self.file_like`` is a file(-like) object, both flags are set to
         ``False``.
 
         2. If ``keep_file_open`` (as passed to :meth:``__init__``) is
            ``True``, both internal flags are set to ``True``.
 
-        3. If ``keep_file_open`` is ``False``, but ``file_like`` is not a path
+        3. If ``keep_file_open`` is ``False``, but ``self.file_like`` is not a path
            to a ``.gz`` file or ``indexed_gzip`` is not present, both flags
            are set to ``False``.
 
-        4. If ``keep_file_open`` is ``False``, ``file_like`` is a path to a
+        4. If ``keep_file_open`` is ``False``, ``self.file_like`` is a path to a
            ``.gz`` file, and ``indexed_gzip`` is present, ``_persist_opener``
            is set to ``True``, and ``_keep_file_open`` is set to ``False``.
            In this case, file handle management is delegated to the
@@ -274,8 +305,6 @@ def _should_keep_file_open(self, file_like, keep_file_open):
         Parameters
         ----------
 
-        file_like : object
-            File-like object or filename, as passed to ``__init__``.
         keep_file_open : { True, False }
             Flag as passed to ``__init__``.
 
@@ -298,10 +327,10 @@ def _should_keep_file_open(self, file_like, keep_file_open):
             raise ValueError('keep_file_open must be one of {None, True, False}')
 
         # file_like is a handle - keep_file_open is irrelevant
-        if hasattr(file_like, 'read') and hasattr(file_like, 'seek'):
+        if self._has_fh():
             return False, False
         # if the file is a gzip file, and we have_indexed_gzip,
-        have_igzip = openers.HAVE_INDEXED_GZIP and file_like.endswith('.gz')
+        have_igzip = openers.HAVE_INDEXED_GZIP and self.file_like.endswith('.gz')
 
         persist_opener = keep_file_open or have_igzip
         return keep_file_open, persist_opener
diff --git a/nibabel/arraywriters.py b/nibabel/arraywriters.py
index 5a0b04925e..1f55263fc3 100644
--- a/nibabel/arraywriters.py
+++ b/nibabel/arraywriters.py
@@ -31,15 +31,7 @@ def __init__(self, array, out_dtype=None)
 
 import numpy as np
 
-from .casting import (
-    as_int,
-    best_float,
-    floor_exact,
-    int_abs,
-    int_to_float,
-    shared_range,
-    type_info,
-)
+from .casting import best_float, floor_exact, int_abs, shared_range, type_info
 from .volumeutils import array_to_file, finite_range
 
 
@@ -153,9 +145,8 @@ def scaling_needed(self):
         # No scaling needed if data already fits in output type
         # But note - we need to convert to ints, to avoid conversion to float
         # during comparisons, and therefore int -> float conversions which are
-        # not exact.  Only a problem for uint64 though.  We need as_int here to
-        # work around a numpy 1.4.1 bug in uint conversion
-        if as_int(mn) >= as_int(info.min) and as_int(mx) <= as_int(info.max):
+        # not exact.  Only a problem for uint64 though.
+        if int(mn) >= int(info.min) and int(mx) <= int(info.max):
             return False
         return True
 
@@ -393,7 +384,7 @@ def _do_scaling(self):
         out_max, out_min = info.max, info.min
         # If left as int64, uint64, comparisons will default to floats, and
         # these are inexact for > 2**53 - so convert to int
-        if as_int(mx) <= as_int(out_max) and as_int(mn) >= as_int(out_min):
+        if int(mx) <= int(out_max) and int(mn) >= int(out_min):
             # already in range
             return
         # (u)int to (u)int scaling
@@ -411,7 +402,7 @@ def _iu2iu(self):
             # that deals with max neg ints. abs problem only arises when all
             # the data is set to max neg integer value
             o_min, o_max = shared_range(self.scaler_dtype, out_dt)
-            if mx <= 0 and int_abs(mn) <= as_int(o_max):  # sign flip enough?
+            if mx <= 0 and int_abs(mn) <= int(o_max):  # sign flip enough?
                 # -1.0 * arr will be in scaler_dtype precision
                 self.slope = -1.0
                 return
@@ -428,7 +419,7 @@ def _range_scale(self, in_min, in_max):
             # not lose precision because min/max are of fp type.
             out_min, out_max = np.array((out_min, out_max), dtype=big_float)
         else:  # (u)int
-            out_min, out_max = (int_to_float(v, big_float) for v in (out_min, out_max))
+            out_min, out_max = (big_float(v) for v in (out_min, out_max))
         if self._out_dtype.kind == 'u':
             if in_min < 0 and in_max > 0:
                 raise WriterError(
@@ -547,14 +538,13 @@ def to_fileobj(self, fileobj, order='F'):
 
     def _iu2iu(self):
         # (u)int to (u)int
-        mn, mx = (as_int(v) for v in self.finite_range())
+        mn, mx = (int(v) for v in self.finite_range())
         # range may be greater than the largest integer for this type.
-        # as_int needed to work round numpy 1.4.1 int casting bug
         out_dtype = self._out_dtype
         # Options in this method are scaling using intercept only.  These will
         # have to pass through ``self.scaler_dtype`` (because the intercept is
         # in this type).
-        o_min, o_max = (as_int(v) for v in shared_range(self.scaler_dtype, out_dtype))
+        o_min, o_max = (int(v) for v in shared_range(self.scaler_dtype, out_dtype))
         type_range = o_max - o_min
         mn2mx = mx - mn
         if mn2mx <= type_range:  # might offset be enough?
@@ -566,12 +556,12 @@ def _iu2iu(self):
             else:  # int output - take midpoint to 0
                 # ceil below increases inter, pushing scale up to 0.5 towards
                 # -inf, because ints have abs min == abs max + 1
-                midpoint = mn + as_int(np.ceil(mn2mx / 2.0))
+                midpoint = mn + int(np.ceil(mn2mx / 2.0))
                 # Floor exact decreases inter, so pulling scaled values more
                 # positive. This may make mx - inter > t_max
                 inter = floor_exact(midpoint, self.scaler_dtype)
             # Need to check still in range after floor_exact-ing
-            int_inter = as_int(inter)
+            int_inter = int(inter)
             assert mn - int_inter >= o_min
             if mx - int_inter <= o_max:
                 self.inter = inter
@@ -595,14 +585,13 @@ def _range_scale(self, in_min, in_max):
             in_min, in_max = np.array([in_min, in_max], dtype=big_float)
             in_range = np.diff([in_min, in_max])
         else:  # max possible (u)int range is 2**64-1 (int64, uint64)
-            # int_to_float covers this range.  On windows longdouble is the
-            # same as double so in_range will be 2**64 - thus overestimating
-            # slope slightly.  Casting to int needed to allow in_max-in_min to
-            # be larger than the largest (u)int value
-            in_min, in_max = as_int(in_min), as_int(in_max)
-            in_range = int_to_float(in_max - in_min, big_float)
+            # On windows longdouble is the same as double so in_range will be 2**64 -
+            # thus overestimating slope slightly.  Casting to int needed to allow
+            # in_max-in_min to be larger than the largest (u)int value
+            in_min, in_max = int(in_min), int(in_max)
+            in_range = big_float(in_max - in_min)
             # Cast to float for later processing.
-            in_min, in_max = (int_to_float(v, big_float) for v in (in_min, in_max))
+            in_min, in_max = (big_float(v) for v in (in_min, in_max))
         if out_dtype.kind == 'f':
             # Type range, these are also floats
             info = type_info(out_dtype)
diff --git a/nibabel/batteryrunners.py b/nibabel/batteryrunners.py
index 30727f3962..860b9b993c 100644
--- a/nibabel/batteryrunners.py
+++ b/nibabel/batteryrunners.py
@@ -252,7 +252,7 @@ def __str__(self):
     def message(self):
         """formatted message string, including fix message if present"""
         if self.fix_msg:
-            return '; '.join((self.problem_msg, self.fix_msg))
+            return f'{self.problem_msg}; {self.fix_msg}'
         return self.problem_msg
 
     def log_raise(self, logger, error_level=40):
diff --git a/nibabel/benchmarks/bench_array_to_file.py b/nibabel/benchmarks/bench_array_to_file.py
index c2bab7e95e..a77ae6cbc9 100644
--- a/nibabel/benchmarks/bench_array_to_file.py
+++ b/nibabel/benchmarks/bench_array_to_file.py
@@ -11,12 +11,12 @@
 """
 
 import sys
-from io import BytesIO  # NOQA
+from io import BytesIO  # noqa: F401
 
 import numpy as np
 from numpy.testing import measure
 
-from nibabel.volumeutils import array_to_file  # NOQA
+from nibabel.volumeutils import array_to_file  # noqa: F401
 
 from .butils import print_git_title
 
@@ -29,24 +29,25 @@ def bench_array_to_file():
     sys.stdout.flush()
     print_git_title('\nArray to file')
     mtime = measure('array_to_file(arr, BytesIO(), np.float32)', repeat)
-    print('%30s %6.2f' % ('Save float64 to float32', mtime))
+    fmt = '{:30s} {:6.2f}'.format
+    print(fmt('Save float64 to float32', mtime))
     mtime = measure('array_to_file(arr, BytesIO(), np.int16)', repeat)
-    print('%30s %6.2f' % ('Save float64 to int16', mtime))
+    print(fmt('Save float64 to int16', mtime))
     # Set a lot of NaNs to check timing
     arr[:, :, :, 1] = np.nan
     mtime = measure('array_to_file(arr, BytesIO(), np.float32)', repeat)
-    print('%30s %6.2f' % ('Save float64 to float32, NaNs', mtime))
+    print(fmt('Save float64 to float32, NaNs', mtime))
     mtime = measure('array_to_file(arr, BytesIO(), np.int16)', repeat)
-    print('%30s %6.2f' % ('Save float64 to int16, NaNs', mtime))
+    print(fmt('Save float64 to int16, NaNs', mtime))
     # Set a lot of infs to check timing
     arr[:, :, :, 1] = np.inf
     mtime = measure('array_to_file(arr, BytesIO(), np.float32)', repeat)
-    print('%30s %6.2f' % ('Save float64 to float32, infs', mtime))
+    print(fmt('Save float64 to float32, infs', mtime))
     mtime = measure('array_to_file(arr, BytesIO(), np.int16)', repeat)
-    print('%30s %6.2f' % ('Save float64 to int16, infs', mtime))
+    print(fmt('Save float64 to int16, infs', mtime))
     # Int16 input, float output
     arr = np.random.random_integers(low=-1000, high=1000, size=img_shape)
     arr = arr.astype(np.int16)
     mtime = measure('array_to_file(arr, BytesIO(), np.float32)', repeat)
-    print('%30s %6.2f' % ('Save Int16 to float32', mtime))
+    print(fmt('Save Int16 to float32', mtime))
     sys.stdout.flush()
diff --git a/nibabel/benchmarks/bench_arrayproxy_slicing.py b/nibabel/benchmarks/bench_arrayproxy_slicing.py
index 958923d7ea..5da6c578f7 100644
--- a/nibabel/benchmarks/bench_arrayproxy_slicing.py
+++ b/nibabel/benchmarks/bench_arrayproxy_slicing.py
@@ -26,7 +26,7 @@
 
 # if memory_profiler is installed, we get memory usage results
 try:
-    from memory_profiler import memory_usage  # type: ignore
+    from memory_profiler import memory_usage  # type: ignore[import]
 except ImportError:
     memory_usage = None
 
@@ -56,7 +56,6 @@
 
 
 def bench_arrayproxy_slicing():
-
     print_git_title('\nArrayProxy gzip slicing')
 
     # each test is a tuple containing
@@ -97,11 +96,10 @@ def fmt_sliceobj(sliceobj):
                 slcstr.append(s)
             else:
                 slcstr.append(str(int(s * SHAPE[i])))
-        return f"[{', '.join(slcstr)}]"
+        return f'[{", ".join(slcstr)}]'
 
     with InTemporaryDirectory():
-
-        print(f'Generating test data... ({int(round(np.prod(SHAPE) * 4 / 1048576.0))} MB)')
+        print(f'Generating test data... ({round(np.prod(SHAPE) * 4 / 1048576.0)} MB)')
 
         data = np.array(np.random.random(SHAPE), dtype=np.float32)
 
@@ -128,7 +126,6 @@ def fmt_sliceobj(sliceobj):
         seeds = [np.random.randint(0, 2**32) for s in SLICEOBJS]
 
         for ti, test in enumerate(tests):
-
             label = get_test_label(test)
             have_igzip, keep_open, sliceobj = test
             seed = seeds[SLICEOBJS.index(sliceobj)]
diff --git a/nibabel/benchmarks/bench_finite_range.py b/nibabel/benchmarks/bench_finite_range.py
index edd839ce61..a4f80f20cb 100644
--- a/nibabel/benchmarks/bench_finite_range.py
+++ b/nibabel/benchmarks/bench_finite_range.py
@@ -15,7 +15,7 @@
 import numpy as np
 from numpy.testing import measure
 
-from nibabel.volumeutils import finite_range  # NOQA
+from nibabel.volumeutils import finite_range  # noqa: F401
 
 from .butils import print_git_title
 
@@ -28,16 +28,17 @@ def bench_finite_range():
     sys.stdout.flush()
     print_git_title('\nFinite range')
     mtime = measure('finite_range(arr)', repeat)
-    print('%30s %6.2f' % ('float64 all finite', mtime))
+    fmt = '{:30s} {:6.2f}'.format
+    print(fmt('float64 all finite', mtime))
     arr[:, :, :, 1] = np.nan
     mtime = measure('finite_range(arr)', repeat)
-    print('%30s %6.2f' % ('float64 many NaNs', mtime))
+    print(fmt('float64 many NaNs', mtime))
     arr[:, :, :, 1] = np.inf
     mtime = measure('finite_range(arr)', repeat)
-    print('%30s %6.2f' % ('float64 many infs', mtime))
+    print(fmt('float64 many infs', mtime))
     # Int16 input, float output
     arr = np.random.random_integers(low=-1000, high=1000, size=img_shape)
     arr = arr.astype(np.int16)
     mtime = measure('finite_range(arr)', repeat)
-    print('%30s %6.2f' % ('int16', mtime))
+    print(fmt('int16', mtime))
     sys.stdout.flush()
diff --git a/nibabel/benchmarks/bench_load_save.py b/nibabel/benchmarks/bench_load_save.py
index 007753ce51..b881c286fb 100644
--- a/nibabel/benchmarks/bench_load_save.py
+++ b/nibabel/benchmarks/bench_load_save.py
@@ -34,20 +34,21 @@ def bench_load_save():
     print_git_title('Image load save')
     hdr.set_data_dtype(np.float32)
     mtime = measure('sio.truncate(0); img.to_file_map()', repeat)
-    print('%30s %6.2f' % ('Save float64 to float32', mtime))
+    fmt = '{:30s} {:6.2f}'.format
+    print(fmt('Save float64 to float32', mtime))
     mtime = measure('img.from_file_map(img.file_map)', repeat)
-    print('%30s %6.2f' % ('Load from float32', mtime))
+    print(fmt('Load from float32', mtime))
     hdr.set_data_dtype(np.int16)
     mtime = measure('sio.truncate(0); img.to_file_map()', repeat)
-    print('%30s %6.2f' % ('Save float64 to int16', mtime))
+    print(fmt('Save float64 to int16', mtime))
     mtime = measure('img.from_file_map(img.file_map)', repeat)
-    print('%30s %6.2f' % ('Load from int16', mtime))
+    print(fmt('Load from int16', mtime))
     # Set a lot of NaNs to check timing
     arr[:, :, :20] = np.nan
     mtime = measure('sio.truncate(0); img.to_file_map()', repeat)
-    print('%30s %6.2f' % ('Save float64 to int16, NaNs', mtime))
+    print(fmt('Save float64 to int16, NaNs', mtime))
     mtime = measure('img.from_file_map(img.file_map)', repeat)
-    print('%30s %6.2f' % ('Load from int16, NaNs', mtime))
+    print(fmt('Load from int16, NaNs', mtime))
     # Int16 input, float output
     arr = np.random.random_integers(low=-1000, high=1000, size=img_shape)
     arr = arr.astype(np.int16)
@@ -57,5 +58,5 @@ def bench_load_save():
     hdr = img.header
     hdr.set_data_dtype(np.float32)
     mtime = measure('sio.truncate(0); img.to_file_map()', repeat)
-    print('%30s %6.2f' % ('Save Int16 to float32', mtime))
+    print(fmt('Save Int16 to float32', mtime))
     sys.stdout.flush()
diff --git a/nibabel/benchmarks/butils.py b/nibabel/benchmarks/butils.py
index 01d6931eba..6231629030 100644
--- a/nibabel/benchmarks/butils.py
+++ b/nibabel/benchmarks/butils.py
@@ -1,11 +1,10 @@
-"""Benchmarking utilities
-"""
+"""Benchmarking utilities"""
 
 from .. import get_info
 
 
 def print_git_title(title):
     """Prints title string with git hash if possible, and underline"""
-    title = f"{title} for git revision {get_info()['commit_hash']}"
+    title = f'{title} for git revision {get_info()["commit_hash"]}'
     print(title)
     print('-' * len(title))
diff --git a/nibabel/brikhead.py b/nibabel/brikhead.py
index 54b6d021f3..cd791adac1 100644
--- a/nibabel/brikhead.py
+++ b/nibabel/brikhead.py
@@ -6,8 +6,7 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""
-Class for reading AFNI BRIK/HEAD datasets
+"""Class for reading AFNI BRIK/HEAD datasets
 
 See https://afni.nimh.nih.gov/pub/dist/doc/program_help/README.attributes.html
 for information on what is required to have a valid BRIK/HEAD dataset.
@@ -27,6 +26,7 @@
 am aware) always be >= 1. This permits sub-brick indexing common in AFNI
 programs (e.g., example4d+orig'[0]').
 """
+
 import os
 import re
 from copy import deepcopy
@@ -198,7 +198,7 @@ def parse_AFNI_header(fobj):
             return parse_AFNI_header(src)
     # unpack variables in HEAD file
     head = fobj.read().split('\n\n')
-    return {key: value for key, value in map(_unpack_var, head)}
+    return dict(map(_unpack_var, head))
 
 
 class AFNIArrayProxy(ArrayProxy):
@@ -391,7 +391,7 @@ def get_affine(self):
         # AFNI default is RAI- == LPS+ == DICOM order.  We need to flip RA sign
         # to align with nibabel RAS+ system
         affine = np.asarray(self.info['IJK_TO_DICOM_REAL']).reshape(3, 4)
-        affine = np.row_stack((affine * [[-1], [-1], [1]], [0, 0, 0, 1]))
+        affine = np.vstack((affine * [[-1], [-1], [1]], [0, 0, 0, 1]))
         return affine
 
     def get_data_scaling(self):
@@ -476,6 +476,7 @@ class AFNIImage(SpatialImage):
     """
 
     header_class = AFNIHeader
+    header: AFNIHeader
     valid_exts = ('.brik', '.head')
     files_types = (('image', '.brik'), ('header', '.head'))
     _compressed_suffixes = ('.gz', '.bz2', '.Z', '.zst')
@@ -554,7 +555,7 @@ def filespec_to_file_map(klass, filespec):
             fname = fholder.filename
             if key == 'header' and not os.path.exists(fname):
                 for ext in klass._compressed_suffixes:
-                    fname = fname[: -len(ext)] if fname.endswith(ext) else fname
+                    fname = fname.removesuffix(ext)
             elif key == 'image' and not os.path.exists(fname):
                 for ext in klass._compressed_suffixes:
                     if os.path.exists(fname + ext):
@@ -564,4 +565,4 @@ def filespec_to_file_map(klass, filespec):
         return file_map
 
 
-load = AFNIImage.load
+load = AFNIImage.from_filename
diff --git a/nibabel/casting.py b/nibabel/casting.py
index 6232c615b5..b279325477 100644
--- a/nibabel/casting.py
+++ b/nibabel/casting.py
@@ -3,14 +3,16 @@
 Most routines work round some numpy oddities in floating point precision and
 casting.  Others work round numpy casting to and from python ints
 """
+
 from __future__ import annotations
 
 import warnings
-from numbers import Integral
 from platform import machine, processor
 
 import numpy as np
 
+from .deprecated import deprecate_with_version
+
 
 class CastingError(Exception):
     pass
@@ -23,6 +25,43 @@ class CastingError(Exception):
 _test_val = 2**63 + 2**11  # Should be exactly representable in float64
 TRUNC_UINT64 = np.float64(_test_val).astype(np.uint64) != _test_val
 
+# np.sctypes is deprecated in numpy 2.0 and np.core.sctypes should not be used instead.
+sctypes = {
+    'int': [
+        getattr(np, dtype) for dtype in ('int8', 'int16', 'int32', 'int64') if hasattr(np, dtype)
+    ],
+    'uint': [
+        getattr(np, dtype)
+        for dtype in ('uint8', 'uint16', 'uint32', 'uint64')
+        if hasattr(np, dtype)
+    ],
+    'float': [
+        getattr(np, dtype)
+        for dtype in ('float16', 'float32', 'float64', 'float96', 'float128')
+        if hasattr(np, dtype)
+    ],
+    'complex': [
+        getattr(np, dtype)
+        for dtype in ('complex64', 'complex128', 'complex192', 'complex256')
+        if hasattr(np, dtype)
+    ],
+    'others': [bool, object, bytes, str, np.void],
+}
+sctypes_aliases = {
+    getattr(np, dtype)
+    for dtype in (
+        'int8', 'byte', 'int16', 'short', 'int32', 'intc', 'int_', 'int64', 'longlong',
+        'uint8', 'ubyte', 'uint16', 'ushort', 'uint32', 'uintc', 'uint', 'uint64', 'ulonglong',
+        'float16', 'half', 'float32', 'single', 'float64', 'double', 'float96', 'float128', 'longdouble',
+        'complex64', 'csingle', 'complex128', 'cdouble', 'complex192', 'complex256', 'clongdouble',
+        # other names of the built-in scalar types
+        'int_', 'float_', 'complex_', 'bytes_', 'str_', 'bool_', 'datetime64', 'timedelta64',
+        # other
+        'object_', 'void',
+    )
+    if hasattr(np, dtype)
+}  # fmt:skip
+
 
 def float_to_int(arr, int_type, nan2zero=True, infmax=False):
     """Convert floating point array `arr` to type `int_type`
@@ -236,7 +275,13 @@ def type_info(np_type):
             nexp=None,
             width=width,
         )
-    info = np.finfo(dt)
+    # Mitigate warning from WSL1 when checking `np.longdouble` (#1309)
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            action='ignore', category=UserWarning, message='Signature.*numpy.longdouble'
+        )
+        info = np.finfo(dt)
+
     # Trust the standard IEEE types
     nmant, nexp = info.nmant, info.nexp
     ret = dict(
@@ -252,7 +297,7 @@ def type_info(np_type):
         return ret
     info_64 = np.finfo(np.float64)
     if dt.kind == 'c':
-        assert np_type is np.longcomplex
+        assert np_type is np.clongdouble
         vals = (nmant, nexp, width / 2)
     else:
         assert np_type is np.longdouble
@@ -280,7 +325,7 @@ def type_info(np_type):
     # Oh dear, we don't recognize the type information.  Try some known types
     # and then give up. At this stage we're expecting exotic longdouble or
     # their complex equivalent.
-    if np_type not in (np.longdouble, np.longcomplex) or width not in (16, 32):
+    if np_type not in (np.longdouble, np.clongdouble) or width not in (16, 32):
         raise FloatingError(f'We had not expected type {np_type}')
     if vals == (1, 1, 16) and on_powerpc() and _check_maxexp(np.longdouble, 1024):
         # double pair on PPC.  The _check_nmant routine does not work for this
@@ -290,13 +335,13 @@ def type_info(np_type):
         # Got float64 despite everything
         pass
     elif _check_nmant(np.longdouble, 112) and _check_maxexp(np.longdouble, 16384):
-        # binary 128, but with some busted type information. np.longcomplex
+        # binary 128, but with some busted type information. np.clongdouble
         # seems to break here too, so we need to use np.longdouble and
         # complexify
         two = np.longdouble(2)
         # See: https://matthew-brett.github.io/pydagogue/floating_point.html
         max_val = (two**113 - 1) / (two**112) * two**16383
-        if np_type is np.longcomplex:
+        if np_type is np.clongdouble:
             max_val += 0j
         ret = dict(
             min=-max_val,
@@ -366,6 +411,7 @@ def _check_maxexp(np_type, maxexp):
         return np.isfinite(two ** (maxexp - 1)) and not np.isfinite(two**maxexp)
 
 
+@deprecate_with_version('as_int() is deprecated. Use int() instead.', '5.2.0', '7.0.0')
 def as_int(x, check=True):
     """Return python integer representation of number
 
@@ -375,9 +421,6 @@ def as_int(x, check=True):
     It is also useful to work around a numpy 1.4.1 bug in conversion of uints
     to python ints.
 
-    This routine will still raise an OverflowError for values that are outside
-    the range of float64.
-
     Parameters
     ----------
     x : object
@@ -403,30 +446,13 @@ def as_int(x, check=True):
     >>> as_int(2.1, check=False)
     2
     """
-    x = np.array(x)
-    if x.dtype.kind in 'iu':
-        # This works around a nasty numpy 1.4.1 bug such that:
-        # >>> int(np.uint32(2**32-1)
-        # -1
-        return int(str(x))
     ix = int(x)
-    if ix == x:
-        return ix
-    fx = np.floor(x)
-    if check and fx != x:
+    if check and ix != x:
         raise FloatingError(f'Not an integer: {x}')
-    if not fx.dtype.type == np.longdouble:
-        return int(x)
-    # Subtract float64 chunks until we have all of the number. If the int is
-    # too large, it will overflow
-    ret = 0
-    while fx != 0:
-        f64 = np.float64(fx)
-        fx -= f64
-        ret += int(f64)
-    return ret
+    return ix
 
 
+@deprecate_with_version('int_to_float(..., dt) is deprecated. Use dt() instead.', '5.2.0', '7.0.0')
 def int_to_float(val, flt_type):
     """Convert integer `val` to floating point type `flt_type`
 
@@ -448,20 +474,13 @@ def int_to_float(val, flt_type):
     -------
     f : numpy scalar
         of type `flt_type`
+
+    Examples
+    --------
+    >>> int_to_float(1, np.float32)
+    1.0
     """
-    if flt_type is not np.longdouble:
-        return flt_type(val)
-    # The following works around a nasty numpy 1.4.1 bug such that:
-    # >>> int(np.uint32(2**32-1)
-    # -1
-    if not isinstance(val, Integral):
-        val = int(str(val))
-    faval = np.longdouble(0)
-    while val != 0:
-        f64 = np.float64(val)
-        faval += f64
-        val -= int(f64)
-    return faval
+    return flt_type(val)
 
 
 def floor_exact(val, flt_type):
@@ -508,14 +527,14 @@ def floor_exact(val, flt_type):
     val = int(val)
     flt_type = np.dtype(flt_type).type
     sign = 1 if val > 0 else -1
-    try:  # int_to_float deals with longdouble safely
-        fval = int_to_float(val, flt_type)
+    try:
+        fval = flt_type(val)
     except OverflowError:
         return sign * np.inf
     if not np.isfinite(fval):
         return fval
     info = type_info(flt_type)
-    diff = val - as_int(fval)
+    diff = val - int(fval)
     if diff >= 0:  # floating point value <= val
         return fval
     # Float casting made the value go up
@@ -599,7 +618,7 @@ def int_abs(arr):
     >>> int_abs(np.array([-128, 127], dtype=np.float32))
     array([128., 127.], dtype=float32)
     """
-    arr = np.array(arr, copy=False)
+    arr = np.asarray(arr)
     dt = arr.dtype
     if dt.kind == 'u':
         return arr
@@ -714,7 +733,7 @@ def ok_floats():
     Remove longdouble if it has no higher precision than float64
     """
     # copy float list so we don't change the numpy global
-    floats = np.sctypes['float'][:]
+    floats = sctypes['float'][:]
     if best_float() != np.longdouble and np.longdouble in floats:
         floats.remove(np.longdouble)
     return sorted(floats, key=lambda f: type_info(f)['nmant'])
@@ -745,15 +764,15 @@ def able_int_type(values):
     >>> able_int_type([-1, 1]) == np.int8
     True
     """
-    if any([v % 1 for v in values]):
+    if any(v % 1 for v in values):
         return None
     mn = min(values)
     mx = max(values)
     if mn >= 0:
-        for ityp in np.sctypes['uint']:
+        for ityp in sctypes['uint']:
             if mx <= np.iinfo(ityp).max:
                 return ityp
-    for ityp in np.sctypes['int']:
+    for ityp in sctypes['int']:
         info = np.iinfo(ityp)
         if mn >= info.min and mx <= info.max:
             return ityp
diff --git a/nibabel/cifti2/cifti2.py b/nibabel/cifti2/cifti2.py
index 423dbfbf9d..7442a91860 100644
--- a/nibabel/cifti2/cifti2.py
+++ b/nibabel/cifti2/cifti2.py
@@ -16,6 +16,7 @@
 
     http://www.nitrc.org/projects/cifti
 """
+
 import re
 from collections import OrderedDict
 from collections.abc import Iterable, MutableMapping, MutableSequence
@@ -30,7 +31,7 @@
 from ..filebasedimages import FileBasedHeader, SerializableImage
 from ..nifti1 import Nifti1Extensions
 from ..nifti2 import Nifti2Header, Nifti2Image
-from ..volumeutils import make_dt_codes
+from ..volumeutils import Recoder, make_dt_codes
 
 
 def _float_01(val):
@@ -80,39 +81,64 @@ class Cifti2HeaderError(Exception):
     'RADIAN',
 )
 
-CIFTI_BRAIN_STRUCTURES = (
-    'CIFTI_STRUCTURE_ACCUMBENS_LEFT',
-    'CIFTI_STRUCTURE_ACCUMBENS_RIGHT',
-    'CIFTI_STRUCTURE_ALL_WHITE_MATTER',
-    'CIFTI_STRUCTURE_ALL_GREY_MATTER',
-    'CIFTI_STRUCTURE_AMYGDALA_LEFT',
-    'CIFTI_STRUCTURE_AMYGDALA_RIGHT',
-    'CIFTI_STRUCTURE_BRAIN_STEM',
-    'CIFTI_STRUCTURE_CAUDATE_LEFT',
-    'CIFTI_STRUCTURE_CAUDATE_RIGHT',
-    'CIFTI_STRUCTURE_CEREBELLAR_WHITE_MATTER_LEFT',
-    'CIFTI_STRUCTURE_CEREBELLAR_WHITE_MATTER_RIGHT',
-    'CIFTI_STRUCTURE_CEREBELLUM',
-    'CIFTI_STRUCTURE_CEREBELLUM_LEFT',
-    'CIFTI_STRUCTURE_CEREBELLUM_RIGHT',
-    'CIFTI_STRUCTURE_CEREBRAL_WHITE_MATTER_LEFT',
-    'CIFTI_STRUCTURE_CEREBRAL_WHITE_MATTER_RIGHT',
-    'CIFTI_STRUCTURE_CORTEX',
-    'CIFTI_STRUCTURE_CORTEX_LEFT',
-    'CIFTI_STRUCTURE_CORTEX_RIGHT',
-    'CIFTI_STRUCTURE_DIENCEPHALON_VENTRAL_LEFT',
-    'CIFTI_STRUCTURE_DIENCEPHALON_VENTRAL_RIGHT',
-    'CIFTI_STRUCTURE_HIPPOCAMPUS_LEFT',
-    'CIFTI_STRUCTURE_HIPPOCAMPUS_RIGHT',
-    'CIFTI_STRUCTURE_OTHER',
-    'CIFTI_STRUCTURE_OTHER_GREY_MATTER',
-    'CIFTI_STRUCTURE_OTHER_WHITE_MATTER',
-    'CIFTI_STRUCTURE_PALLIDUM_LEFT',
-    'CIFTI_STRUCTURE_PALLIDUM_RIGHT',
-    'CIFTI_STRUCTURE_PUTAMEN_LEFT',
-    'CIFTI_STRUCTURE_PUTAMEN_RIGHT',
-    'CIFTI_STRUCTURE_THALAMUS_LEFT',
-    'CIFTI_STRUCTURE_THALAMUS_RIGHT',
+
+def _full_structure(struct: str):
+    """Expands STRUCT_NAME into:
+
+    STRUCT_NAME, CIFTI_STRUCTURE_STRUCT_NAME, StructName
+    """
+    return (
+        struct,
+        f'CIFTI_STRUCTURE_{struct}',
+        ''.join(word.capitalize() for word in struct.split('_')),
+    )
+
+
+CIFTI_BRAIN_STRUCTURES = Recoder(
+    (
+        # For simplicity of comparison, use the ordering from:
+        # https://github.com/Washington-University/workbench/blob/b985f5d/src/Common/StructureEnum.cxx
+        # (name,          ciftiname,                     guiname)
+        # ('CORTEX_LEFT', 'CIFTI_STRUCTURE_CORTEX_LEFT', 'CortexLeft')
+        _full_structure('CORTEX_LEFT'),
+        _full_structure('CORTEX_RIGHT'),
+        _full_structure('CEREBELLUM'),
+        _full_structure('ACCUMBENS_LEFT'),
+        _full_structure('ACCUMBENS_RIGHT'),
+        _full_structure('ALL'),
+        _full_structure('ALL_GREY_MATTER'),
+        _full_structure('ALL_WHITE_MATTER'),
+        _full_structure('AMYGDALA_LEFT'),
+        _full_structure('AMYGDALA_RIGHT'),
+        _full_structure('BRAIN_STEM'),
+        _full_structure('CAUDATE_LEFT'),
+        _full_structure('CAUDATE_RIGHT'),
+        _full_structure('CEREBELLAR_WHITE_MATTER_LEFT'),
+        _full_structure('CEREBELLAR_WHITE_MATTER_RIGHT'),
+        _full_structure('CEREBELLUM_LEFT'),
+        _full_structure('CEREBELLUM_RIGHT'),
+        _full_structure('CEREBRAL_WHITE_MATTER_LEFT'),
+        _full_structure('CEREBRAL_WHITE_MATTER_RIGHT'),
+        _full_structure('CORTEX'),
+        _full_structure('DIENCEPHALON_VENTRAL_LEFT'),
+        _full_structure('DIENCEPHALON_VENTRAL_RIGHT'),
+        _full_structure('HIPPOCAMPUS_LEFT'),
+        _full_structure('HIPPOCAMPUS_RIGHT'),
+        _full_structure('INVALID'),
+        _full_structure('OTHER'),
+        _full_structure('OTHER_GREY_MATTER'),
+        _full_structure('OTHER_WHITE_MATTER'),
+        _full_structure('PALLIDUM_LEFT'),
+        _full_structure('PALLIDUM_RIGHT'),
+        _full_structure('PUTAMEN_LEFT'),
+        _full_structure('PUTAMEN_RIGHT'),
+        ## Also commented out in connectome_wb; unclear if deprecated, planned, or what
+        # _full_structure("SUBCORTICAL_WHITE_MATTER_LEFT")
+        # _full_structure("SUBCORTICAL_WHITE_MATTER_RIGHT")
+        _full_structure('THALAMUS_LEFT'),
+        _full_structure('THALAMUS_RIGHT'),
+    ),
+    fields=('name', 'ciftiname', 'guiname'),
 )
 
 
@@ -268,8 +294,7 @@ def __setitem__(self, key, value):
             self._labels[key] = Cifti2Label(*([key] + list(value)))
         except ValueError:
             raise ValueError(
-                'Key should be int, value should be sequence '
-                'of str and 4 floats between 0 and 1'
+                'Key should be int, value should be sequence of str and 4 floats between 0 and 1'
             )
 
     def __delitem__(self, key):
@@ -943,13 +968,13 @@ def vertex_indices(self, value):
     def _to_xml_element(self):
         brain_model = xml.Element('BrainModel')
 
-        for key in [
+        for key in (
             'IndexOffset',
             'IndexCount',
             'ModelType',
             'BrainStructure',
             'SurfaceNumberOfVertices',
-        ]:
+        ):
             attr = _underscore(key)
             value = getattr(self, attr)
             if value is not None:
@@ -1132,14 +1157,14 @@ def _to_xml_element(self):
         mat_ind_map = xml.Element('MatrixIndicesMap')
         dims_as_strings = [str(dim) for dim in self.applies_to_matrix_dimension]
         mat_ind_map.attrib['AppliesToMatrixDimension'] = ','.join(dims_as_strings)
-        for key in [
+        for key in (
             'IndicesMapToDataType',
             'NumberOfSeriesPoints',
             'SeriesExponent',
             'SeriesStart',
             'SeriesStep',
             'SeriesUnit',
-        ]:
+        ):
             attr = _underscore(key)
             value = getattr(self, attr)
             if value is not None:
@@ -1411,6 +1436,7 @@ class Cifti2Image(DataobjImage, SerializableImage):
     """Class for single file CIFTI-2 format image"""
 
     header_class = Cifti2Header
+    header: Cifti2Header
     valid_exts = Nifti2Image.valid_exts
     files_types = Nifti2Image.files_types
     makeable = False
@@ -1543,7 +1569,7 @@ def to_file_map(self, file_map=None, dtype=None):
 
         self.update_headers()
         header = self._nifti_header
-        extension = Cifti2Extension(content=self.header.to_xml())
+        extension = Cifti2Extension.from_bytes(self.header.to_xml())
         header.extensions = Nifti1Extensions(
             ext for ext in header.extensions if not isinstance(ext, Cifti2Extension)
         )
diff --git a/nibabel/cifti2/cifti2_axes.py b/nibabel/cifti2/cifti2_axes.py
index 0c75190f80..54dfc79179 100644
--- a/nibabel/cifti2/cifti2_axes.py
+++ b/nibabel/cifti2/cifti2_axes.py
@@ -59,7 +59,7 @@
 In this very simple case ``bm_cortex`` describes a left cortical surface skipping the second
 out of four vertices. ``bm_thal`` contains all voxels in a 2x2x2 volume.
 
-Brain structure names automatically get converted to valid CIFTI-2 indentifiers using
+Brain structure names automatically get converted to valid CIFTI-2 identifiers using
 :meth:`BrainModelAxis.to_cifti_brain_structure_name`.
 A 1-dimensional mask will be automatically interpreted as a surface element and a 3-dimensional
 mask as a volume element.
@@ -118,6 +118,7 @@
 ...                                     bm_cortex)))
 <class 'nibabel.cifti2.cifti2.Cifti2Header'>
 """
+
 import abc
 from operator import xor
 
@@ -372,7 +373,7 @@ def from_mask(cls, mask, name='other', affine=None):
         else:
             raise ValueError(
                 'Mask should be either 1-dimensional (for surfaces) or '
-                '3-dimensional (for volumes), not %i-dimensional' % mask.ndim
+                f'3-dimensional (for volumes), not {mask.ndim}-dimensional'
             )
 
     @classmethod
@@ -520,7 +521,7 @@ def to_cifti_brain_structure_name(name):
         ValueError: raised if the input name does not match a known anatomical structure in CIFTI-2
         """
         if name in cifti2.CIFTI_BRAIN_STRUCTURES:
-            return name
+            return cifti2.CIFTI_BRAIN_STRUCTURES.ciftiname[name]
         if not isinstance(name, str):
             if len(name) == 1:
                 structure = name[0]
@@ -554,10 +555,10 @@ def to_cifti_brain_structure_name(name):
             proposed_name = f'CIFTI_STRUCTURE_{structure.upper()}'
         else:
             proposed_name = f'CIFTI_STRUCTURE_{structure.upper()}_{orientation.upper()}'
-        if proposed_name not in cifti2.CIFTI_BRAIN_STRUCTURES:
+        if proposed_name not in cifti2.CIFTI_BRAIN_STRUCTURES.ciftiname:
             raise ValueError(
-                f'{name} was interpreted as {proposed_name}, which is not '
-                'a valid CIFTI brain structure'
+                f'{name} was interpreted as {proposed_name}, '
+                'which is not a valid CIFTI brain structure'
             )
         return proposed_name
 
@@ -633,8 +634,10 @@ def __eq__(self, other):
         return (
             (
                 self.affine is None
-                or np.allclose(self.affine, other.affine)
-                and self.volume_shape == other.volume_shape
+                or (
+                    np.allclose(self.affine, other.affine)
+                    and self.volume_shape == other.volume_shape
+                )
             )
             and self.nvertices == other.nvertices
             and np.array_equal(self.name, other.name)
@@ -1518,7 +1521,6 @@ def get_element(self, index):
             index = self.size + index
         if index >= self.size or index < 0:
             raise IndexError(
-                'index %i is out of range for SeriesAxis with size %i'
-                % (original_index, self.size)
+                f'index {original_index} is out of range for SeriesAxis with size {self.size}'
             )
         return self.start + self.step * index
diff --git a/nibabel/cifti2/parse_cifti2.py b/nibabel/cifti2/parse_cifti2.py
index c7bfb953f9..6ed2a29b52 100644
--- a/nibabel/cifti2/parse_cifti2.py
+++ b/nibabel/cifti2/parse_cifti2.py
@@ -40,19 +40,15 @@
 )
 
 
-class Cifti2Extension(Nifti1Extension):
+class Cifti2Extension(Nifti1Extension[Cifti2Header]):
     code = 32
 
-    def __init__(self, code=None, content=None):
-        Nifti1Extension.__init__(self, code=code or self.code, content=content)
-
-    def _unmangle(self, value):
+    def _unmangle(self, value: bytes) -> Cifti2Header:
         parser = Cifti2Parser()
         parser.parse(string=value)
-        self._content = parser.header
-        return self._content
+        return parser.header
 
-    def _mangle(self, value):
+    def _mangle(self, value: Cifti2Header) -> bytes:
         if not isinstance(value, Cifti2Header):
             raise ValueError('Can only mangle a Cifti2Header.')
         return value.to_xml()
@@ -203,13 +199,13 @@ def StartElementHandler(self, name, attrs):
                 applies_to_matrix_dimension=dimensions,
                 indices_map_to_data_type=attrs['IndicesMapToDataType'],
             )
-            for key, dtype in [
+            for key, dtype in (
                 ('NumberOfSeriesPoints', int),
                 ('SeriesExponent', int),
                 ('SeriesStart', float),
                 ('SeriesStep', float),
                 ('SeriesUnit', str),
-            ]:
+            ):
                 if key in attrs:
                     setattr(mim, _underscore(key), dtype(attrs[key]))
             matrix = self.struct_state[-1]
@@ -366,13 +362,13 @@ def StartElementHandler(self, name, attrs):
                     'BrainModel element can only be a child of a MatrixIndicesMap '
                     'with CIFTI_INDEX_TYPE_BRAIN_MODELS type'
                 )
-            for key, dtype in [
+            for key, dtype in (
                 ('IndexOffset', int),
                 ('IndexCount', int),
                 ('ModelType', str),
                 ('BrainStructure', str),
                 ('SurfaceNumberOfVertices', int),
-            ]:
+            ):
                 if key in attrs:
                     setattr(model, _underscore(key), dtype(attrs[key]))
             if model.brain_structure not in CIFTI_BRAIN_STRUCTURES:
@@ -388,8 +384,7 @@ def StartElementHandler(self, name, attrs):
             model = self.struct_state[-1]
             if not isinstance(model, Cifti2BrainModel):
                 raise Cifti2HeaderError(
-                    'VertexIndices element can only be a child '
-                    'of the CIFTI-2 BrainModel element'
+                    'VertexIndices element can only be a child of the CIFTI-2 BrainModel element'
                 )
             self.fsm_state.append('VertexIndices')
             model.vertex_indices = index
diff --git a/nibabel/cifti2/tests/test_cifti2.py b/nibabel/cifti2/tests/test_cifti2.py
index bf287b8e03..6382dab9d6 100644
--- a/nibabel/cifti2/tests/test_cifti2.py
+++ b/nibabel/cifti2/tests/test_cifti2.py
@@ -1,5 +1,5 @@
-"""Testing CIFTI-2 objects
-"""
+"""Testing CIFTI-2 objects"""
+
 import collections
 from xml.etree import ElementTree
 
@@ -7,7 +7,7 @@
 import pytest
 
 from nibabel import cifti2 as ci
-from nibabel.cifti2.cifti2 import Cifti2HeaderError, _float_01, _value_if_klass
+from nibabel.cifti2.cifti2 import _float_01, _value_if_klass
 from nibabel.nifti2 import Nifti2Header
 from nibabel.tests.test_dataobj_images import TestDataobjAPI as _TDA
 from nibabel.tests.test_image_api import DtypeOverrideMixin, SerializeMixin
@@ -37,7 +37,7 @@ def test_cifti2_metadata():
     assert len(md) == 1
     assert list(iter(md)) == ['a']
     assert md['a'] == 'aval'
-    assert md.data == dict([('a', 'aval')])
+    assert md.data == {'a': 'aval'}
 
     with pytest.warns(FutureWarning):
         md = ci.Cifti2MetaData(metadata={'a': 'aval'})
@@ -57,7 +57,7 @@ def test_cifti2_metadata():
     md['a'] = 'aval'
     assert md['a'] == 'aval'
     assert len(md) == 1
-    assert md.data == dict([('a', 'aval')])
+    assert md.data == {'a': 'aval'}
 
     del md['a']
     assert len(md) == 0
@@ -392,7 +392,7 @@ def test_matrix():
     m[0] = mim_1
     assert list(m.mapped_indices) == [1]
     m.insert(0, mim_0)
-    assert list(sorted(m.mapped_indices)) == [0, 1]
+    assert sorted(m.mapped_indices) == [0, 1]
     assert h.number_of_mapped_indices == 2
     assert h.get_index_map(0) == mim_0
     assert h.get_index_map(1) == mim_1
diff --git a/nibabel/cifti2/tests/test_cifti2io_header.py b/nibabel/cifti2/tests/test_cifti2io_header.py
index 8d393686dd..ecdf0c69a7 100644
--- a/nibabel/cifti2/tests/test_cifti2io_header.py
+++ b/nibabel/cifti2/tests/test_cifti2io_header.py
@@ -7,7 +7,6 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 
-import io
 from os.path import dirname
 from os.path import join as pjoin
 
@@ -38,7 +37,7 @@
 
 
 def test_space_separated_affine():
-    img = ci.Cifti2Image.from_filename(pjoin(NIBABEL_TEST_DATA, 'row_major.dconn.nii'))
+    ci.Cifti2Image.from_filename(pjoin(NIBABEL_TEST_DATA, 'row_major.dconn.nii'))
 
 
 def test_read_nifti2():
@@ -73,7 +72,7 @@ def test_read_and_proxies():
 
 @needs_nibabel_data('nitest-cifti2')
 def test_version():
-    for i, dat in enumerate(datafiles):
+    for dat in datafiles:
         img = nib.load(dat)
         assert Version(img.header.version) == Version('2')
 
diff --git a/nibabel/cifti2/tests/test_new_cifti2.py b/nibabel/cifti2/tests/test_new_cifti2.py
index 0f90b822da..4cf5502ad7 100644
--- a/nibabel/cifti2/tests/test_new_cifti2.py
+++ b/nibabel/cifti2/tests/test_new_cifti2.py
@@ -6,6 +6,7 @@
 These functions are used in the tests to generate most CIFTI file types from
 scratch.
 """
+
 import numpy as np
 import pytest
 
diff --git a/nibabel/cmdline/__init__.py b/nibabel/cmdline/__init__.py
index 6478e5f261..f0744521bc 100644
--- a/nibabel/cmdline/__init__.py
+++ b/nibabel/cmdline/__init__.py
@@ -6,5 +6,4 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Functionality to be exposed in the command line
-"""
+"""Functionality to be exposed in the command line"""
diff --git a/nibabel/cmdline/dicomfs.py b/nibabel/cmdline/dicomfs.py
index 85d7d8dcad..ae81940a1d 100644
--- a/nibabel/cmdline/dicomfs.py
+++ b/nibabel/cmdline/dicomfs.py
@@ -25,7 +25,7 @@ class dummy_fuse:
 
 
 try:
-    import fuse  # type: ignore
+    import fuse  # type: ignore[import]
 
     uid = os.getuid()
     gid = os.getgid()
@@ -37,7 +37,7 @@ class dummy_fuse:
 import nibabel as nib
 import nibabel.dft as dft
 
-encoding = locale.getdefaultlocale()[1]
+encoding = locale.getlocale()[1]
 
 fuse.fuse_python_api = (0, 2)
 
@@ -51,7 +51,7 @@ def __init__(self, fno):
         self.direct_io = False
 
     def __str__(self):
-        return 'FileHandle(%d)' % self.fno
+        return f'FileHandle({self.fno})'
 
 
 class DICOMFS(fuse.Fuse):
@@ -85,11 +85,11 @@ def get_paths(self):
                 series_info += f'UID: {series.uid}\n'
                 series_info += f'number: {series.number}\n'
                 series_info += f'description: {series.description}\n'
-                series_info += 'rows: %d\n' % series.rows
-                series_info += 'columns: %d\n' % series.columns
-                series_info += 'bits allocated: %d\n' % series.bits_allocated
-                series_info += 'bits stored: %d\n' % series.bits_stored
-                series_info += 'storage instances: %d\n' % len(series.storage_instances)
+                series_info += f'rows: {series.rows}\n'
+                series_info += f'columns: {series.columns}\n'
+                series_info += f'bits allocated: {series.bits_allocated}\n'
+                series_info += f'bits stored: {series.bits_stored}\n'
+                series_info += f'storage instances: {len(series.storage_instances)}\n'
                 d[series.number] = {
                     'INFO': series_info.encode('ascii', 'replace'),
                     f'{series.number}.nii': (series.nifti_size, series.as_nifti),
@@ -193,9 +193,7 @@ def release(self, path, flags, fh):
 def get_opt_parser():
     # use module docstring for help output
     p = OptionParser(
-        usage='{} [OPTIONS] <DIRECTORY CONTAINING DICOMSs> <mount point>'.format(
-            os.path.basename(sys.argv[0])
-        ),
+        usage=f'{os.path.basename(sys.argv[0])} [OPTIONS] <DIRECTORY CONTAINING DICOMSs> <mount point>',
         version='%prog ' + nib.__version__,
     )
 
@@ -233,7 +231,7 @@ def main(args=None):
 
     if opts.verbose:
         logger.addHandler(logging.StreamHandler(sys.stdout))
-        logger.setLevel(opts.verbose > 1 and logging.DEBUG or logging.INFO)
+        logger.setLevel(logging.DEBUG if opts.verbose > 1 else logging.INFO)
 
     if len(files) != 2:
         sys.stderr.write(f'Please provide two arguments:\n{parser.usage}\n')
diff --git a/nibabel/cmdline/diff.py b/nibabel/cmdline/diff.py
index b409c7205d..6a44f3ce55 100755
--- a/nibabel/cmdline/diff.py
+++ b/nibabel/cmdline/diff.py
@@ -231,7 +231,6 @@ def get_data_diff(files, max_abs=0, max_rel=0, dtype=np.float64):
         diffs1 = [None] * (i + 1)
 
         for j, d2 in enumerate(data[i + 1 :], i + 1):
-
             if d1.shape == d2.shape:
                 abs_diff = np.abs(d1 - d2)
                 mean_abs = (np.abs(d1) + np.abs(d2)) * 0.5
@@ -247,15 +246,14 @@ def get_data_diff(files, max_abs=0, max_rel=0, dtype=np.float64):
                         sub_thr = rel_diff <= max_rel
                         # Since we operated on sub-selected values already, we need
                         # to plug them back in
-                        candidates[
-                            tuple(indexes[sub_thr] for indexes in np.where(candidates))
-                        ] = False
+                        candidates[tuple(indexes[sub_thr] for indexes in np.where(candidates))] = (
+                            False
+                        )
                     max_rel_diff = np.max(rel_diff)
                 else:
                     max_rel_diff = 0
 
                 if np.any(candidates):
-
                     diff_rec = OrderedDict()  # so that abs goes before relative
 
                     diff_rec['abs'] = max_abs_diff.astype(dtype)
@@ -268,8 +266,7 @@ def get_data_diff(files, max_abs=0, max_rel=0, dtype=np.float64):
                 diffs1.append({'CMP': 'incompat'})
 
         if any(diffs1):
-
-            diffs['DATA(diff %d:)' % (i + 1)] = diffs1
+            diffs[f'DATA(diff {i + 1}:)'] = diffs1
 
     return diffs
 
@@ -296,7 +293,7 @@ def display_diff(files, diff):
     output += field_width.format('Field/File')
 
     for i, f in enumerate(files, 1):
-        output += '%d:%s' % (i, filename_width.format(os.path.basename(f)))
+        output += f'{i}:{filename_width.format(os.path.basename(f))}'
 
     output += '\n'
 
@@ -305,18 +302,18 @@ def display_diff(files, diff):
 
         for item in value:
             if isinstance(item, dict):
-                item_str = ', '.join('%s: %s' % i for i in item.items())
+                item_str = ', '.join('{}: {}'.format(*i) for i in item.items())
             elif item is None:
                 item_str = '-'
             else:
                 item_str = str(item)
             # Value might start/end with some invisible spacing characters so we
             # would "condition" it on both ends a bit
-            item_str = re.sub('^[ \t]+', '<', item_str)
-            item_str = re.sub('[ \t]+$', '>', item_str)
+            item_str = re.sub(r'^[ \t]+', '<', item_str)
+            item_str = re.sub(r'[ \t]+$', '>', item_str)
             # and also replace some other invisible symbols with a question
             # mark
-            item_str = re.sub('[\x00]', '?', item_str)
+            item_str = re.sub(r'[\x00]', '?', item_str)
             output += value_width.format(item_str)
 
         output += '\n'
diff --git a/nibabel/cmdline/ls.py b/nibabel/cmdline/ls.py
index 4f504910a2..8ddc37869b 100755
--- a/nibabel/cmdline/ls.py
+++ b/nibabel/cmdline/ls.py
@@ -73,7 +73,7 @@ def get_opt_parser():
                 action='store_true',
                 dest='all_counts',
                 default=False,
-                help='Output all counts, even if number of unique values > %d' % MAX_UNIQUE,
+                help=f'Output all counts, even if number of unique values > {MAX_UNIQUE}',
             ),
             Option(
                 '-z',
@@ -103,21 +103,21 @@ def proc_file(f, opts):
 
     row += [
         str(safe_get(h, 'data_dtype')),
-        f"@l[{ap(safe_get(h, 'data_shape'), '%3g')}]",
-        f"@l{ap(safe_get(h, 'zooms'), '%.2f', 'x')}",
+        f'@l[{ap(safe_get(h, "data_shape"), "%3g")}]',
+        f'@l{ap(safe_get(h, "zooms"), "%.2f", "x")}',
     ]
     # Slope
     if (
         hasattr(h, 'has_data_slope')
         and (h.has_data_slope or h.has_data_intercept)
-        and not h.get_slope_inter() in [(1.0, 0.0), (None, None)]
+        and not h.get_slope_inter() in ((1.0, 0.0), (None, None))
     ):
-        row += ['@l*%.3g+%.3g' % h.get_slope_inter()]
+        row += ['@l*{:.3g}+{:.3g}'.format(*h.get_slope_inter())]
     else:
         row += ['']
 
     if hasattr(h, 'extensions') and len(h.extensions):
-        row += ['@l#exts: %d' % len(h.extensions)]
+        row += [f'@l#exts: {len(h.extensions)}']
     else:
         row += ['']
 
@@ -166,16 +166,16 @@ def proc_file(f, opts):
                 d = d.reshape(-1)
             if opts.stats:
                 # just # of elements
-                row += ['@l[%d]' % np.prod(d.shape)]
+                row += [f'@l[{np.prod(d.shape)}]']
                 # stats
                 row += [f'@l[{np.min(d):.2g}, {np.max(d):.2g}]' if len(d) else '-']
             if opts.counts:
                 items, inv = np.unique(d, return_inverse=True)
                 if len(items) > 1000 and not opts.all_counts:
-                    counts = _err('%d uniques. Use --all-counts' % len(items))
+                    counts = _err(f'{len(items)} uniques. Use --all-counts')
                 else:
                     freq = np.bincount(inv)
-                    counts = ' '.join('%g:%d' % (i, f) for i, f in zip(items, freq))
+                    counts = ' '.join(f'{i:g}:{f}' for i, f in zip(items, freq))
                 row += ['@l' + counts]
         except OSError as e:
             verbose(2, f'Failed to obtain stats/counts -- {e}')
diff --git a/nibabel/cmdline/nifti_dx.py b/nibabel/cmdline/nifti_dx.py
index 103bbf2640..eb917a04b8 100644
--- a/nibabel/cmdline/nifti_dx.py
+++ b/nibabel/cmdline/nifti_dx.py
@@ -9,8 +9,7 @@
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Print nifti diagnostics for header files"""
 
-import sys
-from optparse import OptionParser
+from argparse import ArgumentParser
 
 import nibabel as nib
 
@@ -21,15 +20,27 @@
 
 def main(args=None):
     """Go go team"""
-    parser = OptionParser(
-        usage=f'{sys.argv[0]} [FILE ...]\n\n' + __doc__, version='%prog ' + nib.__version__
+    parser = ArgumentParser(description=__doc__)
+    parser.add_argument('--version', action='version', version=f'%(prog)s {nib.__version__}')
+    parser.add_argument(
+        '-1',
+        '--nifti1',
+        dest='header_class',
+        action='store_const',
+        const=nib.Nifti1Header,
+        default=nib.Nifti1Header,
     )
-    (opts, files) = parser.parse_args(args=args)
+    parser.add_argument(
+        '-2', '--nifti2', dest='header_class', action='store_const', const=nib.Nifti2Header
+    )
+    parser.add_argument('files', nargs='*', metavar='FILE', help='Nifti file names')
+
+    args = parser.parse_args(args=args)
 
-    for fname in files:
+    for fname in args.files:
         with nib.openers.ImageOpener(fname) as fobj:
-            hdr = fobj.read(nib.nifti1.header_dtype.itemsize)
-        result = nib.Nifti1Header.diagnose_binaryblock(hdr)
+            hdr = fobj.read(args.header_class.template_dtype.itemsize)
+        result = args.header_class.diagnose_binaryblock(hdr)
         if len(result):
             print(f'Picky header check output for "{fname}"\n')
             print(result + '\n')
diff --git a/nibabel/cmdline/parrec2nii.py b/nibabel/cmdline/parrec2nii.py
index c04a6e0196..0ae6b3fb40 100644
--- a/nibabel/cmdline/parrec2nii.py
+++ b/nibabel/cmdline/parrec2nii.py
@@ -1,5 +1,4 @@
-"""Code for PAR/REC to NIfTI converter command
-"""
+"""Code for PAR/REC to NIfTI converter command"""
 
 import csv
 import os
@@ -414,7 +413,7 @@ def main():
 
     verbose.switch = opts.verbose
 
-    if opts.origin not in ['scanner', 'fov']:
+    if opts.origin not in ('scanner', 'fov'):
         error(f"Unrecognized value for --origin: '{opts.origin}'.", 1)
     if opts.dwell_time and opts.field_strength is None:
         error('Need --field-strength for dwell time calculation', 1)
diff --git a/nibabel/cmdline/tck2trk.py b/nibabel/cmdline/tck2trk.py
index d5d29ba430..a73540c446 100644
--- a/nibabel/cmdline/tck2trk.py
+++ b/nibabel/cmdline/tck2trk.py
@@ -1,6 +1,7 @@
 """
 Convert tractograms (TCK -> TRK).
 """
+
 import argparse
 import os
 
diff --git a/nibabel/cmdline/tests/test_conform.py b/nibabel/cmdline/tests/test_conform.py
index 524e81fc79..48014e52e4 100644
--- a/nibabel/cmdline/tests/test_conform.py
+++ b/nibabel/cmdline/tests/test_conform.py
@@ -15,7 +15,7 @@
 import nibabel as nib
 from nibabel.cmdline.conform import main
 from nibabel.optpkg import optional_package
-from nibabel.testing import test_data
+from nibabel.testing import get_test_data
 
 _, have_scipy, _ = optional_package('scipy.ndimage')
 needs_scipy = unittest.skipUnless(have_scipy, 'These tests need scipy')
@@ -23,7 +23,7 @@
 
 @needs_scipy
 def test_default(tmpdir):
-    infile = test_data(fname='anatomical.nii')
+    infile = get_test_data(fname='anatomical.nii')
     outfile = tmpdir / 'output.nii.gz'
     main([str(infile), str(outfile)])
     assert outfile.isfile()
@@ -41,14 +41,14 @@ def test_default(tmpdir):
 
 @needs_scipy
 def test_nondefault(tmpdir):
-    infile = test_data(fname='anatomical.nii')
+    infile = get_test_data(fname='anatomical.nii')
     outfile = tmpdir / 'output.nii.gz'
     out_shape = (100, 100, 150)
     voxel_size = (1, 2, 4)
     orientation = 'LAS'
     args = (
-        f"{infile} {outfile} --out-shape {' '.join(map(str, out_shape))} "
-        f"--voxel-size {' '.join(map(str, voxel_size))} --orientation {orientation}"
+        f'{infile} {outfile} --out-shape {" ".join(map(str, out_shape))} '
+        f'--voxel-size {" ".join(map(str, voxel_size))} --orientation {orientation}'
     )
     main(args.split())
     assert outfile.isfile()
diff --git a/nibabel/cmdline/tests/test_convert.py b/nibabel/cmdline/tests/test_convert.py
index 411726a9ea..d500a717a3 100644
--- a/nibabel/cmdline/tests/test_convert.py
+++ b/nibabel/cmdline/tests/test_convert.py
@@ -13,11 +13,11 @@
 
 import nibabel as nib
 from nibabel.cmdline import convert
-from nibabel.testing import test_data
+from nibabel.testing import get_test_data
 
 
 def test_convert_noop(tmp_path):
-    infile = test_data(fname='anatomical.nii')
+    infile = get_test_data(fname='anatomical.nii')
     outfile = tmp_path / 'output.nii.gz'
 
     orig = nib.load(infile)
@@ -31,7 +31,7 @@ def test_convert_noop(tmp_path):
     assert converted.shape == orig.shape
     assert converted.get_data_dtype() == orig.get_data_dtype()
 
-    infile = test_data(fname='resampled_anat_moved.nii')
+    infile = get_test_data(fname='resampled_anat_moved.nii')
 
     with pytest.raises(FileExistsError):
         convert.main([str(infile), str(outfile)])
@@ -50,7 +50,7 @@ def test_convert_noop(tmp_path):
 
 @pytest.mark.parametrize('data_dtype', ('u1', 'i2', 'float32', 'float', 'int64'))
 def test_convert_dtype(tmp_path, data_dtype):
-    infile = test_data(fname='anatomical.nii')
+    infile = get_test_data(fname='anatomical.nii')
     outfile = tmp_path / 'output.nii.gz'
 
     orig = nib.load(infile)
@@ -71,14 +71,14 @@ def test_convert_dtype(tmp_path, data_dtype):
 
 
 @pytest.mark.parametrize(
-    'ext,img_class',
+    ('ext', 'img_class'),
     [
         ('mgh', nib.MGHImage),
         ('img', nib.Nifti1Pair),
     ],
 )
 def test_convert_by_extension(tmp_path, ext, img_class):
-    infile = test_data(fname='anatomical.nii')
+    infile = get_test_data(fname='anatomical.nii')
     outfile = tmp_path / f'output.{ext}'
 
     orig = nib.load(infile)
@@ -94,7 +94,7 @@ def test_convert_by_extension(tmp_path, ext, img_class):
 
 
 @pytest.mark.parametrize(
-    'ext,img_class',
+    ('ext', 'img_class'),
     [
         ('mgh', nib.MGHImage),
         ('img', nib.Nifti1Pair),
@@ -102,7 +102,7 @@ def test_convert_by_extension(tmp_path, ext, img_class):
     ],
 )
 def test_convert_imgtype(tmp_path, ext, img_class):
-    infile = test_data(fname='anatomical.nii')
+    infile = get_test_data(fname='anatomical.nii')
     outfile = tmp_path / f'output.{ext}'
 
     orig = nib.load(infile)
@@ -118,8 +118,8 @@ def test_convert_imgtype(tmp_path, ext, img_class):
 
 
 def test_convert_nifti_int_fail(tmp_path):
-    infile = test_data(fname='anatomical.nii')
-    outfile = tmp_path / f'output.nii'
+    infile = get_test_data(fname='anatomical.nii')
+    outfile = tmp_path / 'output.nii'
 
     orig = nib.load(infile)
     assert not outfile.exists()
@@ -141,7 +141,7 @@ def test_convert_nifti_int_fail(tmp_path):
 
 
 @pytest.mark.parametrize(
-    'orig_dtype,alias,expected_dtype',
+    ('orig_dtype', 'alias', 'expected_dtype'),
     [
         ('int64', 'mask', 'uint8'),
         ('int64', 'compat', 'int32'),
diff --git a/nibabel/cmdline/tests/test_parrec2nii.py b/nibabel/cmdline/tests/test_parrec2nii.py
index 017df9813a..ccedafb74b 100644
--- a/nibabel/cmdline/tests/test_parrec2nii.py
+++ b/nibabel/cmdline/tests/test_parrec2nii.py
@@ -1,5 +1,5 @@
-"""Tests for the parrec2nii exe code
-"""
+"""Tests for the parrec2nii exe code"""
+
 from os.path import basename, isfile, join
 from unittest.mock import MagicMock, Mock, patch
 
diff --git a/nibabel/cmdline/tests/test_roi.py b/nibabel/cmdline/tests/test_roi.py
index ea3852b4da..4692bbb038 100644
--- a/nibabel/cmdline/tests/test_roi.py
+++ b/nibabel/cmdline/tests/test_roi.py
@@ -1,5 +1,4 @@
 import os
-import unittest
 from unittest import mock
 
 import numpy as np
@@ -120,7 +119,7 @@ def test_nib_roi(tmp_path, inplace):
 
 
 @pytest.mark.parametrize(
-    'args, errmsg',
+    ('args', 'errmsg'),
     (
         (('-i', '1:1'), 'Cannot take zero-length slice'),
         (('-j', '1::2'), 'Downsampling is not supported'),
@@ -139,12 +138,8 @@ def test_nib_roi_bad_slices(capsys, args, errmsg):
 def test_entrypoint(capsys):
     # Check that we handle missing args as expected
     with mock.patch('sys.argv', ['nib-roi', '--help']):
-        try:
-            retval = main()
-        except SystemExit:
-            pass
-        else:
-            assert False, 'argparse exits on --help. If changing to another parser, update test.'
+        with pytest.raises(SystemExit):
+            main()
     captured = capsys.readouterr()
     assert captured.out.startswith('usage: nib-roi')
 
diff --git a/nibabel/cmdline/tests/test_stats.py b/nibabel/cmdline/tests/test_stats.py
index 576a408bce..905114e31b 100644
--- a/nibabel/cmdline/tests/test_stats.py
+++ b/nibabel/cmdline/tests/test_stats.py
@@ -8,9 +8,6 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 
-import sys
-from io import StringIO
-
 import numpy as np
 
 from nibabel import Nifti1Image
diff --git a/nibabel/cmdline/tests/test_utils.py b/nibabel/cmdline/tests/test_utils.py
index 8143d648d9..954a3a2573 100644
--- a/nibabel/cmdline/tests/test_utils.py
+++ b/nibabel/cmdline/tests/test_utils.py
@@ -12,23 +12,53 @@
 import pytest
 
 import nibabel as nib
-from nibabel.cmdline.diff import *
-from nibabel.cmdline.utils import *
+from nibabel.cmdline.diff import (
+    display_diff,
+    get_data_diff,
+    get_data_hash_diff,
+    get_headers_diff,
+    main,
+)
+from nibabel.cmdline.utils import (
+    ap,
+    safe_get,
+    table2string,
+)
 from nibabel.testing import data_path
 
 
 def test_table2string():
-    assert table2string([['A', 'B', 'C', 'D'], ['E', 'F', 'G', 'H']]) == 'A B C D\nE F G H\n'
+    # Trivial case should do something sensible
+    assert table2string([]) == '\n'
     assert (
         table2string(
-            [
-                ["Let's", 'Make', 'Tests', 'And'],
-                ['Have', 'Lots', 'Of', 'Fun'],
-                ['With', 'Python', 'Guys', '!'],
-            ]
+            [['A', 'B', 'C', 'D'],
+             ['E', 'F', 'G', 'H']]
+        ) == (
+            'A B C D\n'
+            'E F G H\n'
         )
-        == "Let's  Make  Tests And\n Have  Lots    Of  Fun" + '\n With Python  Guys  !\n'
-    )
+    )  # fmt: skip
+    assert (
+        table2string(
+            [["Let's", 'Make', 'Tests', 'And'],
+             ['Have', 'Lots', 'Of', 'Fun'],
+             ['With', 'Python', 'Guys', '!']]
+        ) == (
+            "Let's  Make  Tests And\n"
+            'Have   Lots   Of   Fun\n'
+            'With  Python Guys   !\n'
+        )
+    )  # fmt: skip
+    assert (
+        table2string(
+            [['This', 'Table', '@lIs', 'Ragged'],
+             ['And', '@rit', 'uses', '@csome', 'alignment', 'markup']]
+        ) == (
+            'This Table Is   Ragged\n'
+            'And     it uses  some  alignment markup\n'
+        )
+    )  # fmt: skip
 
 
 def test_ap():
diff --git a/nibabel/cmdline/utils.py b/nibabel/cmdline/utils.py
index 8e9d45251e..824ed677a1 100644
--- a/nibabel/cmdline/utils.py
+++ b/nibabel/cmdline/utils.py
@@ -10,13 +10,8 @@
 Helper utilities to be used in cmdline applications
 """
 
-
 # global verbosity switch
 import re
-from io import StringIO
-from math import ceil
-
-import numpy as np
 
 verbose_level = 0
 
@@ -43,61 +38,45 @@ def table2string(table, out=None):
     table : list of lists of strings
       What is aimed to be printed
     out : None or stream
-      Where to print. If None -- will print and return string
+      Where to print. If None, return string
 
     Returns
     -------
     string if out was None
     """
 
-    print2string = out is None
-    if print2string:
-        out = StringIO()
-
     # equalize number of elements in each row
     nelements_max = len(table) and max(len(x) for x in table)
 
+    table = [row + [''] * (nelements_max - len(row)) for row in table]
     for i, table_ in enumerate(table):
         table[i] += [''] * (nelements_max - len(table_))
 
-    # figure out lengths within each column
-    atable = np.asarray(table)
     # eat whole entry while computing width for @w (for wide)
-    markup_strip = re.compile('^@([lrc]|w.*)')
-    col_width = [max(len(markup_strip.sub('', x)) for x in column) for column in atable.T]
-    string = ''
-    for i, table_ in enumerate(table):
-        string_ = ''
-        for j, item in enumerate(table_):
+    markup_strip = re.compile(r'^@([lrc]|w.*)')
+    col_width = [max(len(markup_strip.sub('', x)) for x in column) for column in zip(*table)]
+    trans = str.maketrans('lrcw', '<>^^')
+    lines = []
+    for row in table:
+        line = []
+        for item, width in zip(row, col_width):
             item = str(item)
             if item.startswith('@'):
                 align = item[1]
                 item = item[2:]
-                if align not in ['l', 'r', 'c', 'w']:
+                if align not in ('l', 'r', 'c', 'w'):
                     raise ValueError(f'Unknown alignment {align}. Known are l,r,c')
             else:
                 align = 'c'
 
-            nspacesl = max(ceil((col_width[j] - len(item)) / 2.0), 0)
-            nspacesr = max(col_width[j] - nspacesl - len(item), 0)
-
-            if align in ['w', 'c']:
-                pass
-            elif align == 'l':
-                nspacesl, nspacesr = 0, nspacesl + nspacesr
-            elif align == 'r':
-                nspacesl, nspacesr = nspacesl + nspacesr, 0
-            else:
-                raise RuntimeError(f'Should not get here with align={align}')
-
-            string_ += '%%%ds%%s%%%ds ' % (nspacesl, nspacesr) % ('', item, '')
-        string += string_.rstrip() + '\n'
-    out.write(string)
+            line.append(f'{item:{align.translate(trans)}{width}}')
+        lines.append(' '.join(line).rstrip())
 
-    if print2string:
-        value = out.getvalue()
-        out.close()
-        return value
+    ret = '\n'.join(lines) + '\n'
+    if out is not None:
+        out.write(ret)
+    else:
+        return ret
 
 
 def ap(helplist, format_, sep=', '):
diff --git a/nibabel/conftest.py b/nibabel/conftest.py
index 1f9ecd09cf..1d7389e867 100644
--- a/nibabel/conftest.py
+++ b/nibabel/conftest.py
@@ -1,5 +1,28 @@
+import sys
+
+import numpy as np
 import pytest
 
 # Ignore warning requesting help with nicom
 with pytest.warns(UserWarning):
-    import nibabel.nicom
+    import nibabel.nicom  # noqa: F401
+
+
+@pytest.fixture(scope='session', autouse=True)
+def legacy_printoptions():
+    np.set_printoptions(legacy='1.21')
+
+
+@pytest.fixture
+def max_digits():
+    # Set maximum number of digits for int/str conversion for
+    # duration of a test
+    try:
+        orig_max_str_digits = sys.get_int_max_str_digits()
+        yield sys.set_int_max_str_digits
+        sys.set_int_max_str_digits(orig_max_str_digits)
+    except AttributeError:  # PY310 # pragma: no cover
+        # Nothing to do for versions of Python that lack these methods
+        # They were added as DoS protection in Python 3.11 and backported to
+        # some other versions.
+        yield lambda x: None
diff --git a/nibabel/data.py b/nibabel/data.py
index 42826d2f67..510b4127bc 100644
--- a/nibabel/data.py
+++ b/nibabel/data.py
@@ -1,8 +1,7 @@
 # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
-"""
-Utilities to find files from NIPY data packages
-"""
+"""Utilities to find files from NIPY data packages"""
+
 import configparser
 import glob
 import os
@@ -88,8 +87,7 @@ def list_files(self, relative=True):
         for base, dirs, files in os.walk(self.base_path):
             if relative:
                 base = base[len(self.base_path) + 1 :]
-            for filename in files:
-                out_list.append(pjoin(base, filename))
+            out_list.extend(pjoin(base, filename) for filename in files)
         return out_list
 
 
@@ -292,7 +290,7 @@ def make_datasource(pkg_def, **kwargs):
         pkg_hint = pkg_def.get('install hint', DEFAULT_INSTALL_HINT)
         msg = f'{e}; Is it possible you have not installed a data package?'
         if 'name' in pkg_def:
-            msg += f"\n\nYou may need the package \"{pkg_def['name']}\""
+            msg += f'\n\nYou may need the package "{pkg_def["name"]}"'
         if pkg_hint is not None:
             msg += f'\n\n{pkg_hint}'
         raise DataError(msg)
diff --git a/nibabel/dataobj_images.py b/nibabel/dataobj_images.py
index 4d884be66a..3224376d4a 100644
--- a/nibabel/dataobj_images.py
+++ b/nibabel/dataobj_images.py
@@ -7,25 +7,30 @@
 * returns an array from ``numpy.asanyarray(obj)``;
 * has an attribute or property ``shape``.
 """
+
 from __future__ import annotations
 
 import typing as ty
 
 import numpy as np
 
-from .arrayproxy import ArrayLike
 from .deprecated import deprecate_with_version
-from .filebasedimages import FileBasedHeader, FileBasedImage, FileMap, FileSpec
+from .filebasedimages import FileBasedHeader, FileBasedImage
 
-if ty.TYPE_CHECKING:  # pragma: no cover
+if ty.TYPE_CHECKING:
     import numpy.typing as npt
 
+    from ._typing import Self
+    from .arrayproxy import ArrayLike
+    from .fileholders import FileMap
+    from .filename_parser import FileSpec
+
 
 class DataobjImage(FileBasedImage):
     """Template class for images that have dataobj data stores"""
 
     _data_cache: np.ndarray | None
-    _fdata_cache: np.ndarray | None
+    _fdata_cache: np.ndarray[ty.Any, np.dtype[np.floating]] | None
 
     def __init__(
         self,
@@ -222,7 +227,7 @@ def get_fdata(
         self,
         caching: ty.Literal['fill', 'unchanged'] = 'fill',
         dtype: npt.DTypeLike = np.float64,
-    ) -> np.ndarray:
+    ) -> np.ndarray[ty.Any, np.dtype[np.floating]]:
         """Return floating point image data with necessary scaling applied
 
         The image ``dataobj`` property can be an array proxy or an array.  An
@@ -426,13 +431,13 @@ def from_file_map(
         *,
         mmap: bool | ty.Literal['c', 'r'] = True,
         keep_file_open: bool | None = None,
-    ):
+    ) -> Self:
         """Class method to create image from mapping in ``file_map``
 
         Parameters
         ----------
         file_map : dict
-            Mapping with (kay, value) pairs of (``file_type``, FileHolder
+            Mapping with (key, value) pairs of (``file_type``, FileHolder
             instance giving file-likes for each file needed for this image
             type.
         mmap : {True, False, 'c', 'r'}, optional, keyword only
@@ -465,7 +470,7 @@ def from_filename(
         *,
         mmap: bool | ty.Literal['c', 'r'] = True,
         keep_file_open: bool | None = None,
-    ):
+    ) -> Self:
         """Class method to create image from filename `filename`
 
         Parameters
diff --git a/nibabel/deprecated.py b/nibabel/deprecated.py
index eb3252fe7e..394fb0799a 100644
--- a/nibabel/deprecated.py
+++ b/nibabel/deprecated.py
@@ -1,13 +1,16 @@
-"""Module to help with deprecating objects and classes
-"""
+"""Module to help with deprecating objects and classes"""
+
 from __future__ import annotations
 
+import typing as ty
 import warnings
-from typing import Type
 
+from ._typing import ParamSpec
 from .deprecator import Deprecator
 from .pkg_info import cmp_pkg_version
 
+P = ParamSpec('P')
+
 
 class ModuleProxy:
     """Proxy for module that may not yet have been imported
@@ -30,18 +33,18 @@ class ModuleProxy:
     module.
     """
 
-    def __init__(self, module_name):
+    def __init__(self, module_name: str) -> None:
         self._module_name = module_name
 
-    def __getattr__(self, key):
+    def __getattr__(self, key: str) -> ty.Any:
         mod = __import__(self._module_name, fromlist=[''])
         return getattr(mod, key)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'<module proxy for {self._module_name}>'
 
 
-class FutureWarningMixin:
+class FutureWarningMixin(ty.Generic[P]):
     """Insert FutureWarning for object creation
 
     Examples
@@ -60,7 +63,7 @@ class FutureWarningMixin:
 
     warn_message = 'This class will be removed in future versions'
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: P.args, **kwargs: P.kwargs) -> None:
         warnings.warn(self.warn_message, FutureWarning, stacklevel=2)
         super().__init__(*args, **kwargs)
 
@@ -85,12 +88,12 @@ def alert_future_error(
     msg: str,
     version: str,
     *,
-    warning_class: Type[Warning] = FutureWarning,
-    error_class: Type[Exception] = RuntimeError,
+    warning_class: type[Warning] = FutureWarning,
+    error_class: type[Exception] = RuntimeError,
     warning_rec: str = '',
     error_rec: str = '',
     stacklevel: int = 2,
-):
+) -> None:
     """Warn or error with appropriate messages for changing functionality.
 
     Parameters
diff --git a/nibabel/deprecator.py b/nibabel/deprecator.py
index 251e10d64c..972e5f2a83 100644
--- a/nibabel/deprecator.py
+++ b/nibabel/deprecator.py
@@ -1,12 +1,29 @@
-"""Class for recording and reporting deprecations
-"""
+"""Class for recording and reporting deprecations"""
+
+from __future__ import annotations
 
 import functools
 import re
+import sys
+import typing as ty
 import warnings
+from textwrap import dedent
+
+if ty.TYPE_CHECKING:
+    T = ty.TypeVar('T')
+    P = ty.ParamSpec('P')
 
 _LEADING_WHITE = re.compile(r'^(\s*)')
 
+
+def _dedent_docstring(docstring):
+    """Compatibility with Python 3.13+.
+
+    xref: https://github.com/python/cpython/issues/81283
+    """
+    return '\n'.join([dedent(line) for line in docstring.split('\n')])
+
+
 TESTSETUP = """
 
 .. testsetup::
@@ -27,6 +44,10 @@
 
 """
 
+if sys.version_info >= (3, 13):
+    TESTSETUP = _dedent_docstring(TESTSETUP)
+    TESTCLEANUP = _dedent_docstring(TESTCLEANUP)
+
 
 class ExpiredDeprecationError(RuntimeError):
     """Error for expired deprecation
@@ -38,7 +59,7 @@ class ExpiredDeprecationError(RuntimeError):
     pass
 
 
-def _ensure_cr(text):
+def _ensure_cr(text: str) -> str:
     """Remove trailing whitespace and add carriage return
 
     Ensures that `text` always ends with a carriage return
@@ -46,7 +67,12 @@ def _ensure_cr(text):
     return text.rstrip() + '\n'
 
 
-def _add_dep_doc(old_doc, dep_doc, setup='', cleanup=''):
+def _add_dep_doc(
+    old_doc: str,
+    dep_doc: str,
+    setup: str = '',
+    cleanup: str = '',
+) -> str:
     """Add deprecation message `dep_doc` to docstring in `old_doc`
 
     Parameters
@@ -55,6 +81,10 @@ def _add_dep_doc(old_doc, dep_doc, setup='', cleanup=''):
         Docstring from some object.
     dep_doc : str
         Deprecation warning to add to top of docstring, after initial line.
+    setup : str, optional
+        Doctest setup text
+    cleanup : str, optional
+        Doctest teardown text
 
     Returns
     -------
@@ -76,7 +106,9 @@ def _add_dep_doc(old_doc, dep_doc, setup='', cleanup=''):
     if next_line >= len(old_lines):
         # nothing following first paragraph, just append message
         return old_doc + '\n' + dep_doc
-    indent = _LEADING_WHITE.match(old_lines[next_line]).group()
+    leading_white = _LEADING_WHITE.match(old_lines[next_line])
+    assert leading_white is not None  # Type narrowing, since this always matches
+    indent = leading_white.group()
     setup_lines = [indent + L for L in setup.splitlines()]
     dep_lines = [indent + L for L in [''] + dep_doc.splitlines() + ['']]
     cleanup_lines = [indent + L for L in cleanup.splitlines()]
@@ -113,15 +145,15 @@ class Deprecator:
 
     def __init__(
         self,
-        version_comparator,
-        warn_class=DeprecationWarning,
-        error_class=ExpiredDeprecationError,
-    ):
+        version_comparator: ty.Callable[[str], int],
+        warn_class: type[Warning] = DeprecationWarning,
+        error_class: type[Exception] = ExpiredDeprecationError,
+    ) -> None:
         self.version_comparator = version_comparator
         self.warn_class = warn_class
         self.error_class = error_class
 
-    def is_bad_version(self, version_str):
+    def is_bad_version(self, version_str: str) -> bool:
         """Return True if `version_str` is too high
 
         Tests `version_str` with ``self.version_comparator``
@@ -139,7 +171,14 @@ def is_bad_version(self, version_str):
         """
         return self.version_comparator(version_str) == -1
 
-    def __call__(self, message, since='', until='', warn_class=None, error_class=None):
+    def __call__(
+        self,
+        message: str,
+        since: str = '',
+        until: str = '',
+        warn_class: type[Warning] | None = None,
+        error_class: type[Exception] | None = None,
+    ) -> ty.Callable[[ty.Callable[P, T]], ty.Callable[P, T]]:
         """Return decorator function function for deprecation warning / error
 
         Parameters
@@ -164,8 +203,8 @@ def __call__(self, message, since='', until='', warn_class=None, error_class=Non
         deprecator : func
             Function returning a decorator.
         """
-        warn_class = warn_class or self.warn_class
-        error_class = error_class or self.error_class
+        exception = error_class if error_class is not None else self.error_class
+        warning = warn_class if warn_class is not None else self.warn_class
         messages = [message]
         if (since, until) != ('', ''):
             messages.append('')
@@ -173,20 +212,22 @@ def __call__(self, message, since='', until='', warn_class=None, error_class=Non
             messages.append('* deprecated from version: ' + since)
         if until:
             messages.append(
-                f"* {'Raises' if self.is_bad_version(until) else 'Will raise'} "
-                f'{error_class} as of version: {until}'
+                f'* {"Raises" if self.is_bad_version(until) else "Will raise"} '
+                f'{exception} as of version: {until}'
             )
         message = '\n'.join(messages)
 
-        def deprecator(func):
+        def deprecator(func: ty.Callable[P, T]) -> ty.Callable[P, T]:
             @functools.wraps(func)
-            def deprecated_func(*args, **kwargs):
+            def deprecated_func(*args: P.args, **kwargs: P.kwargs) -> T:
                 if until and self.is_bad_version(until):
-                    raise error_class(message)
-                warnings.warn(message, warn_class, stacklevel=2)
+                    raise exception(message)
+                warnings.warn(message, warning, stacklevel=2)
                 return func(*args, **kwargs)
 
             keep_doc = deprecated_func.__doc__
+            if keep_doc is None:
+                keep_doc = ''
             setup = TESTSETUP
             cleanup = TESTCLEANUP
             # After expiration, remove all but the first paragraph.
diff --git a/nibabel/dft.py b/nibabel/dft.py
index c805128951..23108895b2 100644
--- a/nibabel/dft.py
+++ b/nibabel/dft.py
@@ -7,9 +7,7 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 # Copyright (C) 2011 Christian Haselgrove
-"""DICOM filesystem tools
-"""
-
+"""DICOM filesystem tools"""
 
 import contextlib
 import getpass
@@ -45,7 +43,6 @@ class VolumeError(DFTError):
 
 
 class InstanceStackError(DFTError):
-
     """bad series of instance numbers"""
 
     def __init__(self, series, i, si):
@@ -162,10 +159,10 @@ def as_nifti(self):
         data = numpy.ndarray(
             (len(self.storage_instances), self.rows, self.columns), dtype=numpy.int16
         )
-        for (i, si) in enumerate(self.storage_instances):
+        for i, si in enumerate(self.storage_instances):
             if i + 1 != si.instance_number:
                 raise InstanceStackError(self, i, si)
-            logger.info('reading %d/%d' % (i + 1, len(self.storage_instances)))
+            logger.info(f'reading {i + 1}/{len(self.storage_instances)}')
             d = self.storage_instances[i].dicom()
             data[i, :, :] = d.pixel_array
 
@@ -234,17 +231,17 @@ def __getattribute__(self, name):
                             WHERE storage_instance = ?
                             ORDER BY directory, name"""
                 c.execute(query, (self.uid,))
-                val = ['%s/%s' % tuple(row) for row in c]
+                val = ['{}/{}'.format(*tuple(row)) for row in c]
             self.files = val
         return val
 
     def dicom(self):
-        return pydicom.read_file(self.files[0])
+        return pydicom.dcmread(self.files[0])
 
 
 def _get_subdirs(base_dir, files_dict=None, followlinks=False):
     dirs = []
-    for (dirpath, dirnames, filenames) in os.walk(base_dir, followlinks=followlinks):
+    for dirpath, dirnames, filenames in os.walk(base_dir, followlinks=followlinks):
         abs_dir = os.path.realpath(dirpath)
         if abs_dir in dirs:
             raise CachingError(f'link cycle detected under {base_dir}')
@@ -348,7 +345,7 @@ def _update_dir(c, dir, files, studies, series, storage_instances):
 
 def _update_file(c, path, fname, studies, series, storage_instances):
     try:
-        do = pydicom.read_file(f'{path}/{fname}')
+        do = pydicom.dcmread(f'{path}/{fname}')
     except pydicom.filereader.InvalidDicomError:
         logger.debug('        not a DICOM file')
         return None
diff --git a/nibabel/ecat.py b/nibabel/ecat.py
index 8b11e881a7..f634bcd8a6 100644
--- a/nibabel/ecat.py
+++ b/nibabel/ecat.py
@@ -309,14 +309,14 @@ def get_patient_orient(self):
         """
         code = self._structarr['patient_orientation'].item()
         if code not in self._patient_orient_codes:
-            raise KeyError('Ecat Orientation CODE %d not recognized' % code)
+            raise KeyError(f'Ecat Orientation CODE {code} not recognized')
         return self._patient_orient_codes[code]
 
     def get_filetype(self):
         """Type of ECAT Matrix File from code stored in header"""
         code = self._structarr['file_type'].item()
         if code not in self._ft_codes:
-            raise KeyError('Ecat Filetype CODE %d not recognized' % code)
+            raise KeyError(f'Ecat Filetype CODE {code} not recognized')
         return self._ft_codes[code]
 
     @classmethod
@@ -390,7 +390,7 @@ def read_mlist(fileobj, endianness):
         mlist_index += n_rows
         if mlist_block_no <= 2:  # should block_no in (1, 2) be an error?
             break
-    return np.row_stack(mlists)
+    return np.vstack(mlists)
 
 
 def get_frame_order(mlist):
@@ -514,7 +514,6 @@ def read_subheaders(fileobj, mlist, endianness):
 
 
 class EcatSubHeader:
-
     _subhdrdtype = subhdr_dtype
     _data_type_codes = data_type_codes
 
@@ -747,12 +746,14 @@ def __getitem__(self, sliceobj):
 class EcatImage(SpatialImage):
     """Class returns a list of Ecat images, with one image(hdr/data) per frame"""
 
-    _header = EcatHeader
-    header_class = _header
+    header_class = EcatHeader
+    subheader_class = EcatSubHeader
     valid_exts = ('.v',)
-    _subheader = EcatSubHeader
     files_types = (('image', '.v'), ('header', '.v'))
 
+    header: EcatHeader
+    _subheader: EcatSubHeader
+
     ImageArrayProxy = EcatImageArrayProxy
 
     def __init__(self, dataobj, affine, header, subheader, mlist, extra=None, file_map=None):
@@ -879,14 +880,14 @@ def from_file_map(klass, file_map, *, mmap=True, keep_file_open=None):
         hdr_file, img_file = klass._get_fileholders(file_map)
         # note header and image are in same file
         hdr_fid = hdr_file.get_prepare_fileobj(mode='rb')
-        header = klass._header.from_fileobj(hdr_fid)
+        header = klass.header_class.from_fileobj(hdr_fid)
         hdr_copy = header.copy()
         # LOAD MLIST
         mlist = np.zeros((header['num_frames'], 4), dtype=np.int32)
         mlist_data = read_mlist(hdr_fid, hdr_copy.endianness)
         mlist[: len(mlist_data)] = mlist_data
         # LOAD SUBHEADERS
-        subheaders = klass._subheader(hdr_copy, mlist, hdr_fid)
+        subheaders = klass.subheader_class(hdr_copy, mlist, hdr_fid)
         # LOAD DATA
         # Class level ImageArrayProxy
         data = klass.ImageArrayProxy(subheaders)
@@ -922,7 +923,7 @@ def _write_data(self, data, stream, pos, dtype=None, endianness=None):
             endianness = native_code
 
         stream.seek(pos)
-        make_array_writer(data.newbyteorder(endianness), dtype).to_fileobj(stream)
+        make_array_writer(data.view(data.dtype.newbyteorder(endianness)), dtype).to_fileobj(stream)
 
     def to_file_map(self, file_map=None):
         """Write ECAT7 image to `file_map` or contained ``self.file_map``
@@ -956,7 +957,7 @@ def to_file_map(self, file_map=None):
         hdr.write_to(hdrf)
 
         # Write every frames
-        for index in range(0, self.header['num_frames']):
+        for index in range(self.header['num_frames']):
             # Move to subheader offset
             frame_offset = subheaders._get_frame_offset(index) - 512
             imgf.seek(frame_offset)
diff --git a/nibabel/environment.py b/nibabel/environment.py
index 6f331eed5a..a828ccb865 100644
--- a/nibabel/environment.py
+++ b/nibabel/environment.py
@@ -1,8 +1,6 @@
 # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
-"""
-Settings from the system environment relevant to NIPY
-"""
+"""Settings from the system environment relevant to NIPY"""
 
 import os
 from os.path import join as pjoin
diff --git a/nibabel/externals/conftest.py b/nibabel/externals/conftest.py
new file mode 100644
index 0000000000..472f2f0296
--- /dev/null
+++ b/nibabel/externals/conftest.py
@@ -0,0 +1,25 @@
+import pytest
+
+try:
+    from contextlib import chdir as _chdir
+except ImportError:  # PY310
+    import os
+    from contextlib import contextmanager
+
+    @contextmanager  # type: ignore[no-redef]
+    def _chdir(path):
+        cwd = os.getcwd()
+        os.chdir(path)
+        try:
+            yield
+        finally:
+            os.chdir(cwd)
+
+
+@pytest.fixture(autouse=True)
+def chdir_tmpdir(request, tmp_path):
+    if request.node.__class__.__name__ == "DoctestItem":
+        with _chdir(tmp_path):
+            yield
+    else:
+        yield
diff --git a/nibabel/filebasedimages.py b/nibabel/filebasedimages.py
index 82398bac18..853c394614 100644
--- a/nibabel/filebasedimages.py
+++ b/nibabel/filebasedimages.py
@@ -6,23 +6,25 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Common interface for any image format--volume or surface, binary or xml."""
+"""Common interface for any image format--volume or surface, binary or xml"""
+
 from __future__ import annotations
 
 import io
-import os
 import typing as ty
 from copy import deepcopy
-from typing import Type
 from urllib import request
 
-from .fileholders import FileHolder
-from .filename_parser import TypesFilenamesError, splitext_addext, types_filenames
+from ._compression import COMPRESSION_ERRORS
+from .fileholders import FileHolder, FileMap
+from .filename_parser import TypesFilenamesError, _stringify_path, splitext_addext, types_filenames
 from .openers import ImageOpener
 
-FileSpec = ty.Union[str, os.PathLike]
-FileMap = ty.Mapping[str, FileHolder]
-FileSniff = ty.Tuple[bytes, str]
+if ty.TYPE_CHECKING:
+    from ._typing import Self
+    from .filename_parser import ExtensionSpec, FileSpec
+
+FileSniff = tuple[bytes, str]
 
 
 class ImageFileError(Exception):
@@ -33,7 +35,7 @@ class FileBasedHeader:
     """Template class to implement header protocol"""
 
     @classmethod
-    def from_header(klass, header=None):
+    def from_header(klass, header: FileBasedHeader | ty.Mapping | None = None) -> Self:
         if header is None:
             return klass()
         # I can't do isinstance here because it is not necessarily true
@@ -47,19 +49,19 @@ def from_header(klass, header=None):
         )
 
     @classmethod
-    def from_fileobj(klass, fileobj: io.IOBase):
+    def from_fileobj(klass, fileobj: io.IOBase) -> Self:
         raise NotImplementedError
 
-    def write_to(self, fileobj: io.IOBase):
+    def write_to(self, fileobj: io.IOBase) -> None:
         raise NotImplementedError
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         raise NotImplementedError
 
-    def __ne__(self, other):
+    def __ne__(self, other: object) -> bool:
         return not self == other
 
-    def copy(self) -> FileBasedHeader:
+    def copy(self) -> Self:
         """Copy object to independent representation
 
         The copy should not be affected by any changes to the original
@@ -152,9 +154,9 @@ class FileBasedImage:
     work.
     """
 
-    header_class: Type[FileBasedHeader] = FileBasedHeader
+    header_class: type[FileBasedHeader] = FileBasedHeader
     _meta_sniff_len: int = 0
-    files_types: tuple[tuple[str, str | None], ...] = (('image', None),)
+    files_types: tuple[ExtensionSpec, ...] = (('image', None),)
     valid_exts: tuple[str, ...] = ()
     _compressed_suffixes: tuple[str, ...] = ()
 
@@ -186,7 +188,7 @@ def __init__(
         self._header = self.header_class.from_header(header)
         if extra is None:
             extra = {}
-        self.extra = extra
+        self.extra = dict(extra)
 
         if file_map is None:
             file_map = self.__class__.make_file_map()
@@ -196,7 +198,7 @@ def __init__(
     def header(self) -> FileBasedHeader:
         return self._header
 
-    def __getitem__(self, key):
+    def __getitem__(self, key) -> None:
         """No slicing or dictionary interface for images"""
         raise TypeError('Cannot slice image objects.')
 
@@ -221,7 +223,7 @@ def get_filename(self) -> str | None:
         characteristic_type = self.files_types[0][0]
         return self.file_map[characteristic_type].filename
 
-    def set_filename(self, filename: str):
+    def set_filename(self, filename: str) -> None:
         """Sets the files in the object from a given filename
 
         The different image formats may check whether the filename has
@@ -239,16 +241,16 @@ def set_filename(self, filename: str):
         self.file_map = self.__class__.filespec_to_file_map(filename)
 
     @classmethod
-    def from_filename(klass, filename: FileSpec):
+    def from_filename(klass, filename: FileSpec) -> Self:
         file_map = klass.filespec_to_file_map(filename)
         return klass.from_file_map(file_map)
 
     @classmethod
-    def from_file_map(klass, file_map: FileMap):
+    def from_file_map(klass, file_map: FileMap) -> Self:
         raise NotImplementedError
 
     @classmethod
-    def filespec_to_file_map(klass, filespec: FileSpec):
+    def filespec_to_file_map(klass, filespec: FileSpec) -> FileMap:
         """Make `file_map` for this class from filename `filespec`
 
         Class method
@@ -282,7 +284,7 @@ def filespec_to_file_map(klass, filespec: FileSpec):
             file_map[key] = FileHolder(filename=fname)
         return file_map
 
-    def to_filename(self, filename: FileSpec, **kwargs):
+    def to_filename(self, filename: FileSpec, **kwargs) -> None:
         r"""Write image to files implied by filename string
 
         Parameters
@@ -301,11 +303,11 @@ def to_filename(self, filename: FileSpec, **kwargs):
         self.file_map = self.filespec_to_file_map(filename)
         self.to_file_map(**kwargs)
 
-    def to_file_map(self, file_map: FileMap | None = None, **kwargs):
+    def to_file_map(self, file_map: FileMap | None = None, **kwargs) -> None:
         raise NotImplementedError
 
     @classmethod
-    def make_file_map(klass, mapping: ty.Mapping[str, str | io.IOBase] | None = None):
+    def make_file_map(klass, mapping: ty.Mapping[str, str | io.IOBase] | None = None) -> FileMap:
         """Class method to make files holder for this image type
 
         Parameters
@@ -338,7 +340,7 @@ def make_file_map(klass, mapping: ty.Mapping[str, str | io.IOBase] | None = None
     load = from_filename
 
     @classmethod
-    def instance_to_filename(klass, img: FileBasedImage, filename: FileSpec):
+    def instance_to_filename(klass, img: FileBasedImage, filename: FileSpec) -> None:
         """Save `img` in our own format, to name implied by `filename`
 
         This is a class method
@@ -354,20 +356,20 @@ def instance_to_filename(klass, img: FileBasedImage, filename: FileSpec):
         img.to_filename(filename)
 
     @classmethod
-    def from_image(klass, img: FileBasedImage):
+    def from_image(klass, img: FileBasedImage) -> Self:
         """Class method to create new instance of own class from `img`
 
         Parameters
         ----------
-        img : ``spatialimage`` instance
+        img : ``FileBasedImage`` instance
            In fact, an object with the API of ``FileBasedImage``.
 
         Returns
         -------
-        cimg : ``spatialimage`` instance
+        img : ``FileBasedImage`` instance
            Image, of our own class
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @classmethod
     def _sniff_meta_for(
@@ -375,7 +377,7 @@ def _sniff_meta_for(
         filename: FileSpec,
         sniff_nbytes: int,
         sniff: FileSniff | None = None,
-    ):
+    ) -> FileSniff | None:
         """Sniff metadata for image represented by `filename`
 
         Parameters
@@ -405,7 +407,7 @@ def _sniff_meta_for(
         t_fnames = types_filenames(
             filename, klass.files_types, trailing_suffixes=klass._compressed_suffixes
         )
-        meta_fname = t_fnames.get('header', filename)
+        meta_fname = t_fnames.get('header', _stringify_path(filename))
 
         # Do not re-sniff if it would be from the same file
         if sniff is not None and sniff[1] == meta_fname:
@@ -415,7 +417,7 @@ def _sniff_meta_for(
         try:
             with ImageOpener(meta_fname, 'rb') as fobj:
                 binaryblock = fobj.read(sniff_nbytes)
-        except (OSError, EOFError):
+        except COMPRESSION_ERRORS + (OSError, EOFError):
             return None
         return (binaryblock, meta_fname)
 
@@ -425,7 +427,7 @@ def path_maybe_image(
         filename: FileSpec,
         sniff: FileSniff | None = None,
         sniff_max: int = 1024,
-    ):
+    ) -> tuple[bool, FileSniff | None]:
         """Return True if `filename` may be image matching this class
 
         Parameters
@@ -527,14 +529,14 @@ class SerializableImage(FileBasedImage):
     """
 
     @classmethod
-    def _filemap_from_iobase(klass, io_obj: io.IOBase):
+    def _filemap_from_iobase(klass, io_obj: io.IOBase) -> FileMap:
         """For single-file image types, make a file map with the correct key"""
         if len(klass.files_types) > 1:
             raise NotImplementedError('(de)serialization is undefined for multi-file images')
         return klass.make_file_map({klass.files_types[0][0]: io_obj})
 
     @classmethod
-    def from_stream(klass, io_obj: io.IOBase):
+    def from_stream(klass, io_obj: io.IOBase) -> Self:
         """Load image from readable IO stream
 
         Convert to BytesIO to enable seeking, if input stream is not seekable
@@ -548,7 +550,7 @@ def from_stream(klass, io_obj: io.IOBase):
             io_obj = io.BytesIO(io_obj.read())
         return klass.from_file_map(klass._filemap_from_iobase(io_obj))
 
-    def to_stream(self, io_obj: io.IOBase, **kwargs):
+    def to_stream(self, io_obj: io.IOBase, **kwargs) -> None:
         r"""Save image to writable IO stream
 
         Parameters
@@ -561,7 +563,7 @@ def to_stream(self, io_obj: io.IOBase, **kwargs):
         self.to_file_map(self._filemap_from_iobase(io_obj), **kwargs)
 
     @classmethod
-    def from_bytes(klass, bytestring: bytes):
+    def from_bytes(klass, bytestring: bytes) -> Self:
         """Construct image from a byte string
 
         Class method
@@ -592,7 +594,7 @@ def to_bytes(self, **kwargs) -> bytes:
         return bio.getvalue()
 
     @classmethod
-    def from_url(klass, url: str | request.Request, timeout: float = 5):
+    def from_url(klass, url: str | request.Request, timeout: float = 5) -> Self:
         """Retrieve and load an image from a URL
 
         Class method
diff --git a/nibabel/fileholders.py b/nibabel/fileholders.py
index f2ec992da5..df7c34af63 100644
--- a/nibabel/fileholders.py
+++ b/nibabel/fileholders.py
@@ -8,10 +8,16 @@
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Fileholder class"""
 
+from __future__ import annotations
+
+import typing as ty
 from copy import copy
 
 from .openers import ImageOpener
 
+if ty.TYPE_CHECKING:
+    import io
+
 
 class FileHolderError(Exception):
     pass
@@ -20,7 +26,12 @@ class FileHolderError(Exception):
 class FileHolder:
     """class to contain filename, fileobj and file position"""
 
-    def __init__(self, filename=None, fileobj=None, pos=0):
+    def __init__(
+        self,
+        filename: str | None = None,
+        fileobj: io.IOBase | None = None,
+        pos: int = 0,
+    ):
         """Initialize FileHolder instance
 
         Parameters
@@ -38,7 +49,7 @@ def __init__(self, filename=None, fileobj=None, pos=0):
         self.fileobj = fileobj
         self.pos = pos
 
-    def get_prepare_fileobj(self, *args, **kwargs):
+    def get_prepare_fileobj(self, *args, **kwargs) -> ImageOpener:
         """Return fileobj if present, or return fileobj from filename
 
         Set position to that given in self.pos
@@ -70,7 +81,7 @@ def get_prepare_fileobj(self, *args, **kwargs):
             raise FileHolderError('No filename or fileobj present')
         return obj
 
-    def same_file_as(self, other):
+    def same_file_as(self, other: FileHolder) -> bool:
         """Test if `self` refers to same files / fileobj as `other`
 
         Parameters
@@ -87,12 +98,15 @@ def same_file_as(self, other):
         return (self.filename == other.filename) and (self.fileobj == other.fileobj)
 
     @property
-    def file_like(self):
+    def file_like(self) -> str | io.IOBase | None:
         """Return ``self.fileobj`` if not None, otherwise ``self.filename``"""
         return self.fileobj if self.fileobj is not None else self.filename
 
 
-def copy_file_map(file_map):
+FileMap = ty.Mapping[str, FileHolder]
+
+
+def copy_file_map(file_map: FileMap) -> FileMap:
     r"""Copy mapping of fileholders given by `file_map`
 
     Parameters
@@ -106,7 +120,4 @@ def copy_file_map(file_map):
        Copy of `file_map`, using shallow copy of ``FileHolder``\s
 
     """
-    fm_copy = {}
-    for key, fh in file_map.items():
-        fm_copy[key] = copy(fh)
-    return fm_copy
+    return {key: copy(fh) for key, fh in file_map.items()}
diff --git a/nibabel/filename_parser.py b/nibabel/filename_parser.py
index 77949a6791..a16c13ec22 100644
--- a/nibabel/filename_parser.py
+++ b/nibabel/filename_parser.py
@@ -8,15 +8,22 @@
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Create filename pairs, triplets etc, with expected extensions"""
 
+from __future__ import annotations
+
 import os
 import pathlib
+import typing as ty
+
+if ty.TYPE_CHECKING:
+    FileSpec = str | os.PathLike[str]
+    ExtensionSpec = tuple[str, str | None]
 
 
 class TypesFilenamesError(Exception):
     pass
 
 
-def _stringify_path(filepath_or_buffer):
+def _stringify_path(filepath_or_buffer: FileSpec) -> str:
     """Attempt to convert a path-like object to a string.
 
     Parameters
@@ -29,30 +36,19 @@ def _stringify_path(filepath_or_buffer):
 
     Notes
     -----
-    Objects supporting the fspath protocol (python 3.6+) are coerced
-    according to its __fspath__ method.
-    For backwards compatibility with older pythons, pathlib.Path objects
-    are specially coerced.
-    Any other object is passed through unchanged, which includes bytes,
-    strings, buffers, or anything else that's not even path-like.
-
-    Copied from:
-    https://github.com/pandas-dev/pandas/blob/325dd686de1589c17731cf93b649ed5ccb5a99b4/pandas/io/common.py#L131-L160
+    Adapted from:
+    https://github.com/pandas-dev/pandas/blob/325dd68/pandas/io/common.py#L131-L160
     """
-    if hasattr(filepath_or_buffer, '__fspath__'):
-        return filepath_or_buffer.__fspath__()
-    elif isinstance(filepath_or_buffer, pathlib.Path):
-        return str(filepath_or_buffer)
-    return filepath_or_buffer
+    return pathlib.Path(filepath_or_buffer).expanduser().as_posix()
 
 
 def types_filenames(
-    template_fname,
-    types_exts,
-    trailing_suffixes=('.gz', '.bz2'),
-    enforce_extensions=True,
-    match_case=False,
-):
+    template_fname: FileSpec,
+    types_exts: ty.Sequence[ExtensionSpec],
+    trailing_suffixes: ty.Sequence[str] = ('.gz', '.bz2'),
+    enforce_extensions: bool = True,
+    match_case: bool = False,
+) -> dict[str, str]:
     """Return filenames with standard extensions from template name
 
     The typical case is returning image and header filenames for an
@@ -115,8 +111,7 @@ def types_filenames(
     template_fname = _stringify_path(template_fname)
     if not isinstance(template_fname, str):
         raise TypesFilenamesError('Need file name as input to set_filenames')
-    if template_fname.endswith('.'):
-        template_fname = template_fname[:-1]
+    template_fname = template_fname.removesuffix('.')
     filename, found_ext, ignored, guessed_name = parse_filename(
         template_fname, types_exts, trailing_suffixes, match_case
     )
@@ -153,12 +148,12 @@ def types_filenames(
     # we've found .IMG as the extension, we want .HDR as the matching
     # one.  Let's only do this when the extension is all upper or all
     # lower case.
-    proc_ext = lambda s: s
+    proc_ext: ty.Callable[[str], str] = lambda s: s
     if found_ext:
         if found_ext == found_ext.upper():
-            proc_ext = lambda s: s.upper()
+            proc_ext = str.upper
         elif found_ext == found_ext.lower():
-            proc_ext = lambda s: s.lower()
+            proc_ext = str.lower
     for name, ext in types_exts:
         if name == direct_set_name:
             tfns[name] = template_fname
@@ -172,7 +167,12 @@ def types_filenames(
     return tfns
 
 
-def parse_filename(filename, types_exts, trailing_suffixes, match_case=False):
+def parse_filename(
+    filename: FileSpec,
+    types_exts: ty.Sequence[ExtensionSpec],
+    trailing_suffixes: ty.Sequence[str],
+    match_case: bool = False,
+) -> tuple[str, str, str | None, str | None]:
     """Split filename into fileroot, extension, trailing suffix; guess type.
 
     Parameters
@@ -231,9 +231,9 @@ def parse_filename(filename, types_exts, trailing_suffixes, match_case=False):
             break
     guessed_name = None
     found_ext = None
-    for name, ext in types_exts:
-        if ext and endswith(filename, ext):
-            extpos = -len(ext)
+    for name, type_ext in types_exts:
+        if type_ext and endswith(filename, type_ext):
+            extpos = -len(type_ext)
             found_ext = filename[extpos:]
             filename = filename[:extpos]
             guessed_name = name
@@ -243,15 +243,19 @@ def parse_filename(filename, types_exts, trailing_suffixes, match_case=False):
     return (filename, found_ext, ignored, guessed_name)
 
 
-def _endswith(whole, end):
+def _endswith(whole: str, end: str) -> bool:
     return whole.endswith(end)
 
 
-def _iendswith(whole, end):
+def _iendswith(whole: str, end: str) -> bool:
     return whole.lower().endswith(end.lower())
 
 
-def splitext_addext(filename, addexts=('.gz', '.bz2', '.zst'), match_case=False):
+def splitext_addext(
+    filename: FileSpec,
+    addexts: ty.Sequence[str] = ('.gz', '.bz2', '.zst'),
+    match_case: bool = False,
+) -> tuple[str, str, str]:
     """Split ``/pth/fname.ext.gz`` into ``/pth/fname, .ext, .gz``
 
     where ``.gz`` may be any of passed `addext` trailing suffixes.
diff --git a/nibabel/fileslice.py b/nibabel/fileslice.py
index 87cac05a4a..91ed1f70a1 100644
--- a/nibabel/fileslice.py
+++ b/nibabel/fileslice.py
@@ -1,5 +1,4 @@
-"""Utilities for getting array slices out of file-like objects
-"""
+"""Utilities for getting array slices out of file-like objects"""
 
 import operator
 from functools import reduce
@@ -128,7 +127,7 @@ def canonical_slicers(sliceobj, shape, check_inds=True):
             if slicer < 0:
                 slicer = dim_len + slicer
             elif check_inds and slicer >= dim_len:
-                raise ValueError('Integer index %d to large' % slicer)
+                raise ValueError(f'Integer index {slicer} too large')
         can_slicers.append(slicer)
     # Fill out any missing dimensions
     if n_real < n_dim:
diff --git a/nibabel/fileutils.py b/nibabel/fileutils.py
index da44fe51a9..1defbc62f7 100644
--- a/nibabel/fileutils.py
+++ b/nibabel/fileutils.py
@@ -6,8 +6,7 @@
 #   copyright and license terms.
 #
 # ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Utilities for reading and writing to binary file formats
-"""
+"""Utilities for reading and writing to binary file formats"""
 
 
 def read_zt_byte_strings(fobj, n_strings=1, bufsize=1024):
diff --git a/nibabel/freesurfer/__init__.py b/nibabel/freesurfer/__init__.py
index 806d19a272..1ab3859756 100644
--- a/nibabel/freesurfer/__init__.py
+++ b/nibabel/freesurfer/__init__.py
@@ -1,5 +1,4 @@
-"""Reading functions for freesurfer files
-"""
+"""Reading functions for freesurfer files"""
 
 from .io import (
     read_annot,
diff --git a/nibabel/freesurfer/io.py b/nibabel/freesurfer/io.py
index ec6b474b04..5b3f6a3664 100644
--- a/nibabel/freesurfer/io.py
+++ b/nibabel/freesurfer/io.py
@@ -1,5 +1,4 @@
-"""Read / write FreeSurfer geometry, morphometry, label, annotation formats
-"""
+"""Read / write FreeSurfer geometry, morphometry, label, annotation formats"""
 
 import getpass
 import time
@@ -31,7 +30,7 @@ def _fread3(fobj):
     n : int
         A 3 byte int
     """
-    b1, b2, b3 = np.fromfile(fobj, '>u1', 3)
+    b1, b2, b3 = np.fromfile(fobj, '>u1', 3).astype(np.int64)
     return (b1 << 16) + (b2 << 8) + b3
 
 
@@ -63,7 +62,7 @@ def _read_volume_info(fobj):
             return volume_info
 
     volume_info['head'] = head
-    for key in ['valid', 'filename', 'volume', 'voxelsize', 'xras', 'yras', 'zras', 'cras']:
+    for key in ('valid', 'filename', 'volume', 'voxelsize', 'xras', 'yras', 'zras', 'cras'):
         pair = fobj.readline().decode('utf-8').split('=')
         if pair[0].strip() != key or len(pair) != 2:
             raise OSError('Error parsing volume info.')
@@ -428,7 +427,7 @@ def _read_annot_ctab_old_format(fobj, n_entries):
     for i in range(n_entries):
         # structure name length + string
         name_length = np.fromfile(fobj, dt, 1)[0]
-        name = np.fromfile(fobj, '|S%d' % name_length, 1)[0]
+        name = np.fromfile(fobj, f'|S{name_length}', 1)[0]
         names.append(name)
         # read RGBT for this entry
         ctab[i, :4] = np.fromfile(fobj, dt, 4)
@@ -466,13 +465,13 @@ def _read_annot_ctab_new_format(fobj, ctab_version):
     dt = _ANNOT_DT
     # This code works with a file version == 2, nothing else
     if ctab_version != 2:
-        raise Exception('Unrecognised .annot file version (%i)', ctab_version)
+        raise Exception(f'Unrecognised .annot file version ({ctab_version})')
     # maximum LUT index present in the file
     max_index = np.fromfile(fobj, dt, 1)[0]
     ctab = np.zeros((max_index, 5), dt)
     # orig_tab string length + string
     length = np.fromfile(fobj, dt, 1)[0]
-    np.fromfile(fobj, '|S%d' % length, 1)[0]  # Orig table path
+    np.fromfile(fobj, f'|S{length}', 1)[0]  # Orig table path
     # number of LUT entries present in the file
     entries_to_read = np.fromfile(fobj, dt, 1)[0]
     names = list()
@@ -481,7 +480,7 @@ def _read_annot_ctab_new_format(fobj, ctab_version):
         idx = np.fromfile(fobj, dt, 1)[0]
         # structure name length + string
         name_length = np.fromfile(fobj, dt, 1)[0]
-        name = np.fromfile(fobj, '|S%d' % name_length, 1)[0]
+        name = np.fromfile(fobj, f'|S{name_length}', 1)[0]
         names.append(name)
         # RGBT
         ctab[idx, :4] = np.fromfile(fobj, dt, 4)
@@ -526,7 +525,7 @@ def write(num, dtype=dt):
         def write_string(s):
             s = (s if isinstance(s, bytes) else s.encode()) + b'\x00'
             write(len(s))
-            write(s, dtype='|S%d' % len(s))
+            write(s, dtype=f'|S{len(s)}')
 
         # Generate annotation values for each ctab entry
         if fill_ctab:
diff --git a/nibabel/freesurfer/mghformat.py b/nibabel/freesurfer/mghformat.py
index 6b97056524..1c97fd566c 100644
--- a/nibabel/freesurfer/mghformat.py
+++ b/nibabel/freesurfer/mghformat.py
@@ -10,6 +10,7 @@
 
 Author: Krish Subramaniam
 """
+
 from os.path import splitext
 
 import numpy as np
@@ -56,11 +57,16 @@
 
 # caveat: Note that it's ambiguous to get the code given the bytespervoxel
 # caveat 2: Note that the bytespervox you get is in str ( not an int)
+# FreeSurfer historically defines codes 0-10 [1], but only a subset is well supported.
+# Here we use FreeSurfer's MATLAB loader [2] as an indication of current support.
+# [1] https://github.com/freesurfer/freesurfer/blob/v8.0.0/include/mri.h#L53-L63
+# [2] https://github.com/freesurfer/freesurfer/blob/v8.0.0/matlab/load_mgh.m#L195-L207
 _dtdefs = (  # code, conversion function, dtype, bytes per voxel
     (0, 'uint8', '>u1', '1', 'MRI_UCHAR', np.uint8, np.dtype('u1'), np.dtype('>u1')),
-    (4, 'int16', '>i2', '2', 'MRI_SHORT', np.int16, np.dtype('i2'), np.dtype('>i2')),
     (1, 'int32', '>i4', '4', 'MRI_INT', np.int32, np.dtype('i4'), np.dtype('>i4')),
     (3, 'float', '>f4', '4', 'MRI_FLOAT', np.float32, np.dtype('f4'), np.dtype('>f4')),
+    (4, 'int16', '>i2', '2', 'MRI_SHORT', np.int16, np.dtype('i2'), np.dtype('>i2')),
+    (10, 'uint16', '>u2', '2', 'MRI_USHRT', np.uint16, np.dtype('u2'), np.dtype('>u2')),
 )
 
 # make full code alias bank, including dtype column
@@ -280,7 +286,7 @@ def set_zooms(self, zooms):
         zooms = np.asarray(zooms)
         ndims = self._ndims()
         if len(zooms) > ndims:
-            raise HeaderDataError('Expecting %d zoom values' % ndims)
+            raise HeaderDataError(f'Expecting {ndims} zoom values')
         if np.any(zooms[:3] <= 0):
             raise HeaderDataError(
                 f'Spatial (first three) zooms must be positive; got {tuple(zooms[:3])}'
@@ -462,6 +468,7 @@ class MGHImage(SpatialImage, SerializableImage):
     """Class for MGH format image"""
 
     header_class = MGHHeader
+    header: MGHHeader
     valid_exts = ('.mgh', '.mgz')
     # Register that .mgz extension signals gzip compression
     ImageOpener.compress_ext_map['.mgz'] = ImageOpener.gz_def
@@ -494,7 +501,7 @@ def from_file_map(klass, file_map, *, mmap=True, keep_file_open=None):
         Parameters
         ----------
         file_map : dict
-            Mapping with (kay, value) pairs of (``file_type``, FileHolder
+            Mapping with (key, value) pairs of (``file_type``, FileHolder
             instance giving file-likes for each file needed for this image
             type.
         mmap : {True, False, 'c', 'r'}, optional, keyword only
@@ -568,7 +575,9 @@ def _write_data(self, mghfile, data, header):
         """
         shape = header.get_data_shape()
         if data.shape != shape:
-            raise HeaderDataError('Data should be shape (%s)' % ', '.join(str(s) for s in shape))
+            raise HeaderDataError(
+                'Data should be shape ({})'.format(', '.join(str(s) for s in shape))
+            )
         offset = header.get_data_offset()
         out_dtype = header.get_data_dtype()
         array_to_file(data, mghfile, out_dtype, offset)
@@ -589,5 +598,5 @@ def _affine2header(self):
         hdr['Pxyz_c'] = c_ras
 
 
-load = MGHImage.load
+load = MGHImage.from_filename
 save = MGHImage.instance_to_filename
diff --git a/nibabel/freesurfer/tests/test_io.py b/nibabel/freesurfer/tests/test_io.py
index 2406679d73..d6c9649ca3 100644
--- a/nibabel/freesurfer/tests/test_io.py
+++ b/nibabel/freesurfer/tests/test_io.py
@@ -4,13 +4,13 @@
 import struct
 import time
 import unittest
-import warnings
 from os.path import isdir
 from os.path import join as pjoin
+from pathlib import Path
 
 import numpy as np
 import pytest
-from numpy.testing import assert_allclose, assert_array_equal
+from numpy.testing import assert_allclose
 
 from ...fileslice import strided_scalar
 from ...testing import clear_and_catch_warnings
@@ -46,14 +46,6 @@
 )
 
 
-def _hash_file_content(fname):
-    hasher = hashlib.md5()
-    with open(fname, 'rb') as afile:
-        buf = afile.read()
-        hasher.update(buf)
-    return hasher.hexdigest()
-
-
 @freesurfer_test
 def test_geometry():
     """Test IO of .surf"""
@@ -112,8 +104,10 @@ def test_geometry():
     assert np.array_equal(faces, faces2)
 
     # Validate byte ordering
-    coords_swapped = coords.byteswap().newbyteorder()
-    faces_swapped = faces.byteswap().newbyteorder()
+    coords_swapped = coords.byteswap()
+    coords_swapped = coords_swapped.view(coords_swapped.dtype.newbyteorder())
+    faces_swapped = faces.byteswap()
+    faces_swapped = faces_swapped.view(faces_swapped.dtype.newbyteorder())
     assert np.array_equal(coords_swapped, coords)
     assert np.array_equal(faces_swapped, faces)
 
@@ -179,7 +173,6 @@ def test_annot():
     annots = ['aparc', 'aparc.a2005s']
     for a in annots:
         annot_path = pjoin(data_path, 'label', f'lh.{a}.annot')
-        hash_ = _hash_file_content(annot_path)
 
         labels, ctab, names = read_annot(annot_path)
         assert labels.shape == (163842,)
@@ -190,9 +183,10 @@ def test_annot():
             labels_orig, _, _ = read_annot(annot_path, orig_ids=True)
             np.testing.assert_array_equal(labels == -1, labels_orig == 0)
             # Handle different version of fsaverage
-            if hash_ == 'bf0b488994657435cdddac5f107d21e8':
+            content_hash = hashlib.md5(Path(annot_path).read_bytes()).hexdigest()
+            if content_hash == 'bf0b488994657435cdddac5f107d21e8':
                 assert np.sum(labels_orig == 0) == 13887
-            elif hash_ == 'd4f5b7cbc2ed363ac6fcf89e19353504':
+            elif content_hash == 'd4f5b7cbc2ed363ac6fcf89e19353504':
                 assert np.sum(labels_orig == 1639705) == 13327
             else:
                 raise RuntimeError(
diff --git a/nibabel/freesurfer/tests/test_mghformat.py b/nibabel/freesurfer/tests/test_mghformat.py
index ded1aca8a2..660d3dee97 100644
--- a/nibabel/freesurfer/tests/test_mghformat.py
+++ b/nibabel/freesurfer/tests/test_mghformat.py
@@ -10,6 +10,7 @@
 
 import io
 import os
+import pathlib
 
 import numpy as np
 import pytest
@@ -171,11 +172,11 @@ def test_set_zooms():
 
 def bad_dtype_mgh():
     """This function raises an MGHError exception because
-    uint16 is not a valid MGH datatype.
+    float64 is not a valid MGH datatype.
     """
     # try to write an unsigned short and make sure it
     # raises MGHError
-    v = np.ones((7, 13, 3, 22), np.uint16)
+    v = np.ones((7, 13, 3, 22), np.float64)
     # form a MGHImage object using data
     # and the default affine matrix (Note the "None")
     MGHImage(v, None)
@@ -291,7 +292,7 @@ def test_mgh_load_fileobj():
     # pass the filename to the array proxy, please feel free to change this
     # test.
     img = MGHImage.load(MGZ_FNAME)
-    assert img.dataobj.file_like == MGZ_FNAME
+    assert pathlib.Path(img.dataobj.file_like) == pathlib.Path(MGZ_FNAME)
     # Check fileobj also passed into dataobj
     with ImageOpener(MGZ_FNAME) as fobj:
         contents = fobj.read()
@@ -344,7 +345,7 @@ def test_mghheader_default_structarr():
     for endianness in (None,) + BIG_CODES:
         hdr2 = MGHHeader.default_structarr(endianness=endianness)
         assert hdr2 == hdr
-        assert hdr2.newbyteorder('>') == hdr
+        assert hdr2.view(hdr2.dtype.newbyteorder('>')) == hdr
 
     for endianness in LITTLE_CODES:
         with pytest.raises(ValueError):
@@ -459,6 +460,7 @@ def test_as_byteswapped(self):
         for endianness in (None,) + LITTLE_CODES:
             with pytest.raises(ValueError):
                 hdr.as_byteswapped(endianness)
+
         # Note that contents is not rechecked on swap / copy
         class DC(self.header_class):
             def check_fix(self, *args, **kwargs):
diff --git a/nibabel/funcs.py b/nibabel/funcs.py
index f83ed68709..cda4a5d2ed 100644
--- a/nibabel/funcs.py
+++ b/nibabel/funcs.py
@@ -7,6 +7,7 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Processor functions for images"""
+
 import numpy as np
 
 from .loadsave import load
diff --git a/nibabel/gifti/gifti.py b/nibabel/gifti/gifti.py
index 919e4faef2..ff7a9bdde1 100644
--- a/nibabel/gifti/gifti.py
+++ b/nibabel/gifti/gifti.py
@@ -11,12 +11,14 @@
 The Gifti specification was (at time of writing) available as a PDF download
 from http://www.nitrc.org/projects/gifti/
 """
+
 from __future__ import annotations
 
 import base64
 import sys
 import warnings
-from typing import Type
+from copy import copy
+from typing import cast
 
 import numpy as np
 
@@ -27,6 +29,12 @@
 from ..nifti1 import data_type_codes, intent_codes, xform_codes
 from .util import KIND2FMT, array_index_order_codes, gifti_encoding_codes, gifti_endian_codes
 
+GIFTI_DTYPES = (
+    data_type_codes['NIFTI_TYPE_UINT8'],
+    data_type_codes['NIFTI_TYPE_INT32'],
+    data_type_codes['NIFTI_TYPE_FLOAT32'],
+)
+
 
 class _GiftiMDList(list):
     """List view of GiftiMetaData object that will translate most operations"""
@@ -81,7 +89,8 @@ def _sanitize(args, kwargs):
         <GiftiMetaData {'key': 'val'}>
         >>> GiftiMetaData({"key": "val"})
         <GiftiMetaData {'key': 'val'}>
-        >>> nvpairs = GiftiNVPairs(name='key', value='val')
+        >>> with pytest.deprecated_call():
+        ...     nvpairs = GiftiNVPairs(name='key', value='val')
         >>> with pytest.warns(FutureWarning):
         ...     GiftiMetaData(nvpairs)
         <GiftiMetaData {'key': 'val'}>
@@ -220,7 +229,7 @@ def _to_xml_element(self):
             label = xml.SubElement(labeltable, 'Label')
             label.attrib['Key'] = str(ele.key)
             label.text = ele.label
-            for attr in ['Red', 'Green', 'Blue', 'Alpha']:
+            for attr in ('Red', 'Green', 'Blue', 'Alpha'):
                 if getattr(ele, attr.lower(), None) is not None:
                     label.attrib[attr] = str(getattr(ele, attr.lower()))
         return labeltable
@@ -365,7 +374,7 @@ def _to_xml_element(self):
     def print_summary(self):
         print('Dataspace: ', xform_codes.niistring[self.dataspace])
         print('XFormSpace: ', xform_codes.niistring[self.xformspace])
-        print('Affine Transformation Matrix: \n', self.xform)
+        print('Affine Transformation Matrix:\n', self.xform)
 
 
 def _data_tag_element(dataarray, encoding, dtype, ordering):
@@ -460,7 +469,17 @@ def __init__(
         self.data = None if data is None else np.asarray(data)
         self.intent = intent_codes.code[intent]
         if datatype is None:
-            datatype = 'none' if self.data is None else self.data.dtype
+            if self.data is None:
+                datatype = 'none'
+            elif data_type_codes[self.data.dtype] in GIFTI_DTYPES:
+                datatype = self.data.dtype
+            else:
+                raise ValueError(
+                    f'Data array has type {self.data.dtype}. '
+                    'The GIFTI standard only supports uint8, int32 and float32 arrays.\n'
+                    'Explicitly cast the data array to a supported dtype or pass an '
+                    'explicit "datatype" parameter to GiftiDataArray().'
+                )
         self.datatype = data_type_codes.code[datatype]
         self.encoding = gifti_encoding_codes.code[encoding]
         self.endian = gifti_endian_codes.code[endian]
@@ -503,7 +522,7 @@ def _to_xml_element(self):
             },
         )
         for di, dn in enumerate(self.dims):
-            data_array.attrib['Dim%d' % di] = str(dn)
+            data_array.attrib[f'Dim{di}'] = str(dn)
 
         if self.meta is not None:
             data_array.append(self.meta._to_xml_element())
@@ -579,7 +598,7 @@ class GiftiImage(xml.XmlSerializable, SerializableImage):
     # The parser will in due course be a GiftiImageParser, but we can't set
     # that now, because it would result in a circular import.  We set it after
     # the class has been defined, at the end of the class definition.
-    parser: Type[xml.XmlParser]
+    parser: type[xml.XmlParser]
 
     def __init__(
         self,
@@ -701,8 +720,8 @@ def agg_data(self, intent_code=None):
         Consider a surface GIFTI file:
 
         >>> import nibabel as nib
-        >>> from nibabel.testing import test_data
-        >>> surf_img = nib.load(test_data('gifti', 'ascii.gii'))
+        >>> from nibabel.testing import get_test_data
+        >>> surf_img = nib.load(get_test_data('gifti', 'ascii.gii'))
 
         The coordinate data, which is indicated by the ``NIFTI_INTENT_POINTSET``
         intent code, may be retrieved using any of the following equivalent
@@ -727,7 +746,7 @@ def agg_data(self, intent_code=None):
         >>> triangles_2 = surf_img.agg_data('triangle')
         >>> triangles_3 = surf_img.agg_data(1009)  # Numeric code for pointset
         >>> print(np.array2string(triangles))
-        [0 1 2]
+        [[0 1 2]]
         >>> np.array_equal(triangles, triangles_2)
         True
         >>> np.array_equal(triangles, triangles_3)
@@ -754,7 +773,7 @@ def agg_data(self, intent_code=None):
         The following image is a GIFTI file with ten (10) data arrays of the same
         size, and with intent code 2001 (``NIFTI_INTENT_TIME_SERIES``):
 
-        >>> func_img = nib.load(test_data('gifti', 'task.func.gii'))
+        >>> func_img = nib.load(get_test_data('gifti', 'task.func.gii'))
 
         When aggregating time series data, these arrays are concatenated into
         a single, vertex-by-timestep array:
@@ -834,20 +853,45 @@ def _to_xml_element(self):
             GIFTI.append(dar._to_xml_element())
         return GIFTI
 
-    def to_xml(self, enc='utf-8') -> bytes:
+    def to_xml(self, enc='utf-8', *, mode='strict', **kwargs) -> bytes:
         """Return XML corresponding to image content"""
+        if mode == 'strict':
+            if any(arr.datatype not in GIFTI_DTYPES for arr in self.darrays):
+                raise ValueError(
+                    'GiftiImage contains data arrays with invalid data types; '
+                    'use mode="compat" to automatically cast to conforming types'
+                )
+        elif mode == 'compat':
+            darrays = []
+            for arr in self.darrays:
+                if arr.datatype not in GIFTI_DTYPES:
+                    arr = copy(arr)
+                    # TODO: Better typing for recoders
+                    dtype = cast('np.dtype', data_type_codes.dtype[arr.datatype])
+                    if np.issubdtype(dtype, np.floating):
+                        arr.datatype = data_type_codes['float32']
+                    elif np.issubdtype(dtype, np.integer):
+                        arr.datatype = data_type_codes['int32']
+                    else:
+                        raise ValueError(f'Cannot convert {dtype} to float32/int32')
+                darrays.append(arr)
+            gii = copy(self)
+            gii.darrays = darrays
+            return gii.to_xml(enc=enc, mode='strict')
+        elif mode != 'force':
+            raise TypeError(f'Unknown mode {mode}')
         header = b"""<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE GIFTI SYSTEM "http://www.nitrc.org/frs/download.php/115/gifti.dtd">
 """
-        return header + super().to_xml(enc)
+        return header + super().to_xml(enc, **kwargs)
 
     # Avoid the indirection of going through to_file_map
-    def to_bytes(self, enc='utf-8'):
-        return self.to_xml(enc=enc)
+    def to_bytes(self, enc='utf-8', *, mode='strict'):
+        return self.to_xml(enc=enc, mode=mode)
 
     to_bytes.__doc__ = SerializableImage.to_bytes.__doc__
 
-    def to_file_map(self, file_map=None, enc='utf-8'):
+    def to_file_map(self, file_map=None, enc='utf-8', *, mode='strict'):
         """Save the current image to the specified file_map
 
         Parameters
@@ -863,7 +907,7 @@ def to_file_map(self, file_map=None, enc='utf-8'):
         if file_map is None:
             file_map = self.file_map
         with file_map['image'].get_prepare_fileobj('wb') as f:
-            f.write(self.to_xml(enc=enc))
+            f.write(self.to_xml(enc=enc, mode=mode))
 
     @classmethod
     def from_file_map(klass, file_map, buffer_size=35000000, mmap=True):
diff --git a/nibabel/gifti/parse_gifti_fast.py b/nibabel/gifti/parse_gifti_fast.py
index e4a9be4bd6..5bcd8c8c32 100644
--- a/nibabel/gifti/parse_gifti_fast.py
+++ b/nibabel/gifti/parse_gifti_fast.py
@@ -68,17 +68,21 @@ def read_data_block(darray, fname, data, mmap):
     if mmap is True:
         mmap = 'c'
     enclabel = gifti_encoding_codes.label[darray.encoding]
-    dtype = data_type_codes.type[darray.datatype]
 
+    if enclabel not in ('ASCII', 'B64BIN', 'B64GZ', 'External'):
+        raise GiftiParseError(f'Unknown encoding {darray.encoding}')
+
+    # Encode the endianness in the dtype
+    byteorder = gifti_endian_codes.byteorder[darray.endian]
+    dtype = data_type_codes.dtype[darray.datatype].newbyteorder(byteorder)
+
+    shape = tuple(darray.dims)
+    order = array_index_order_codes.npcode[darray.ind_ord]
+
+    # GIFTI_ENCODING_ASCII
     if enclabel == 'ASCII':
-        # GIFTI_ENCODING_ASCII
-        c = StringIO(data)
-        da = np.loadtxt(c, dtype=dtype)
-        return da  # independent of the endianness
-    elif enclabel not in ('B64BIN', 'B64GZ', 'External'):
-        return 0
-
-    # GIFTI_ENCODING_EXTBIN
+        return np.loadtxt(StringIO(data), dtype=dtype, ndmin=1).reshape(shape, order=order)
+
     # We assume that the external data file is raw uncompressed binary, with
     # the data type/endianness/ordering specified by the other DataArray
     # attributes
@@ -94,12 +98,13 @@ def read_data_block(darray, fname, data, mmap):
         newarr = None
         if mmap:
             try:
-                newarr = np.memmap(
+                return np.memmap(
                     ext_fname,
                     dtype=dtype,
                     mode=mmap,
                     offset=darray.ext_offset,
-                    shape=tuple(darray.dims),
+                    shape=shape,
+                    order=order,
                 )
             # If the memmap fails, we ignore the error and load the data into
             # memory below
@@ -107,13 +112,12 @@ def read_data_block(darray, fname, data, mmap):
                 pass
         # mmap=False or np.memmap failed
         if newarr is None:
-            # We can replace this with a call to np.fromfile in numpy>=1.17,
-            # as an "offset" parameter was added in that version.
-            with open(ext_fname, 'rb') as f:
-                f.seek(darray.ext_offset)
-                nbytes = np.prod(darray.dims) * dtype().itemsize
-                buff = f.read(nbytes)
-                newarr = np.frombuffer(buff, dtype=dtype)
+            return np.fromfile(
+                ext_fname,
+                dtype=dtype,
+                count=np.prod(darray.dims),
+                offset=darray.ext_offset,
+            ).reshape(shape, order=order)
 
     # Numpy arrays created from bytes objects are read-only.
     # Neither b64decode nor decompress will return bytearrays, and there
@@ -121,26 +125,14 @@ def read_data_block(darray, fname, data, mmap):
     # there is not a simple way to avoid making copies.
     # If this becomes a problem, we should write a decoding interface with
     # a tunable chunk size.
+    dec = base64.b64decode(data.encode('ascii'))
+    if enclabel == 'B64BIN':
+        buff = bytearray(dec)
     else:
-        dec = base64.b64decode(data.encode('ascii'))
-        if enclabel == 'B64BIN':
-            # GIFTI_ENCODING_B64BIN
-            buff = bytearray(dec)
-        else:
-            # GIFTI_ENCODING_B64GZ
-            buff = bytearray(zlib.decompress(dec))
-        del dec
-        newarr = np.frombuffer(buff, dtype=dtype)
-
-    sh = tuple(darray.dims)
-    if len(newarr.shape) != len(sh):
-        newarr = newarr.reshape(sh, order=array_index_order_codes.npcode[darray.ind_ord])
-
-    # check if we need to byteswap
-    required_byteorder = gifti_endian_codes.byteorder[darray.endian]
-    if required_byteorder in ('big', 'little') and required_byteorder != sys.byteorder:
-        newarr = newarr.byteswap()
-    return newarr
+        # GIFTI_ENCODING_B64GZ
+        buff = bytearray(zlib.decompress(dec))
+    del dec
+    return np.frombuffer(buff, dtype=dtype).reshape(shape, order=order)
 
 
 def _str2int(in_str):
@@ -292,8 +284,8 @@ def EndElementHandler(self, name):
         if name == 'GIFTI':
             if hasattr(self, 'expected_numDA') and self.expected_numDA != self.img.numDA:
                 warnings.warn(
-                    'Actual # of data arrays does not match '
-                    '# expected: %d != %d.' % (self.expected_numDA, self.img.numDA)
+                    'Actual # of data arrays does not match # expected: '
+                    f'{self.expected_numDA} != {self.img.numDA}.'
                 )
             # remove last element of the list
             self.fsm_state.pop()
@@ -333,7 +325,7 @@ def EndElementHandler(self, name):
             self.fsm_state.pop()
             self.coordsys = None
 
-        elif name in ['DataSpace', 'TransformedSpace', 'MatrixData', 'Name', 'Value', 'Data']:
+        elif name in ('DataSpace', 'TransformedSpace', 'MatrixData', 'Name', 'Value', 'Data'):
             self.write_to = None
 
         elif name == 'Label':
diff --git a/nibabel/gifti/tests/data/ascii_flat_data.gii b/nibabel/gifti/tests/data/ascii_flat_data.gii
new file mode 100644
index 0000000000..26a73fba02
--- /dev/null
+++ b/nibabel/gifti/tests/data/ascii_flat_data.gii
@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE GIFTI SYSTEM "http://www.nitrc.org/frs/download.php/115/gifti.dtd">
+<GIFTI Version="1.0"  NumberOfDataArrays="2">
+   <MetaData>
+      <MD>
+         <Name><![CDATA[Caret-Version]]></Name>
+         <Value><![CDATA[5.512]]></Value>
+      </MD>
+      <MD>
+         <Name><![CDATA[date]]></Name>
+         <Value><![CDATA[Thu Dec 27 14:27:43 2007]]></Value>
+      </MD>
+      <MD>
+         <Name><![CDATA[encoding]]></Name>
+         <Value><![CDATA[XML]]></Value>
+      </MD>
+   </MetaData>
+   <LabelTable/>
+   <DataArray Intent="NIFTI_INTENT_POINTSET"
+              DataType="NIFTI_TYPE_FLOAT32"
+              ArrayIndexingOrder="RowMajorOrder"
+              Dimensionality="2"
+              Dim0="10"
+              Dim1="3"
+              Encoding="ASCII"
+              Endian="LittleEndian"
+              ExternalFileName=""
+              ExternalFileOffset="">
+      <MetaData>
+         <MD>
+            <Name><![CDATA[AnatomicalStructurePrimary]]></Name>
+            <Value><![CDATA[CortexLeft]]></Value>
+         </MD>
+         <MD>
+            <Name><![CDATA[AnatomicalStructureSecondary]]></Name>
+            <Value><![CDATA[Pial]]></Value>
+         </MD>
+         <MD>
+            <Name><![CDATA[GeometricType]]></Name>
+            <Value><![CDATA[Anatomical]]></Value>
+         </MD>
+         <MD>
+            <Name><![CDATA[UniqueID]]></Name>
+            <Value><![CDATA[{70e032e9-4123-47ee-965d-5b29107cbd83}]]></Value>
+         </MD>
+      </MetaData>
+      <CoordinateSystemTransformMatrix>
+         <DataSpace><![CDATA[NIFTI_XFORM_TALAIRACH]]></DataSpace>
+         <TransformedSpace><![CDATA[NIFTI_XFORM_TALAIRACH]]></TransformedSpace>
+         <MatrixData>1.000000 0.000000 0.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000 0.000000 1.000000</MatrixData>
+      </CoordinateSystemTransformMatrix>
+      <Data>155.17539978 135.58103943 98.30715179 140.33973694 190.0491333 73.24776459 157.3598938 196.97969055 83.65809631 171.46174622 137.43661499 78.4709549 148.54592896 97.06752777 65.96373749 123.45701599 111.46841431 66.3571167 135.30892944 202.28720093 36.38148499 178.28155518 162.59469604 37.75128937 178.11087036 115.28820038 57.17986679 142.81582642 82.82115173 31.02205276</Data>
+   </DataArray>
+   <DataArray Intent="NIFTI_INTENT_TRIANGLE"
+              DataType="NIFTI_TYPE_INT32"
+              ArrayIndexingOrder="RowMajorOrder"
+              Dimensionality="2"
+              Dim0="10"
+              Dim1="3"
+              Encoding="ASCII"
+              Endian="LittleEndian"
+              ExternalFileName=""
+              ExternalFileOffset="">
+      <MetaData>
+         <MD>
+            <Name><![CDATA[TopologicalType]]></Name>
+            <Value><![CDATA[CLOSED]]></Value>
+         </MD>
+         <MD>
+            <Name><![CDATA[UniqueID]]></Name>
+            <Value><![CDATA[{747d8015-455b-43ad-82ac-dcfb7606004a}]]></Value>
+         </MD>
+      </MetaData>
+      <Data>6402 17923 25602 14085 25602 17923 25602 14085 4483 17923 1602 14085 4483 25603 25602 25604 25602 25603 25602 25604 6402 25603 3525 25604 1123 17922 12168 25604 12168 17922 </Data>
+   </DataArray>
+</GIFTI>
diff --git a/nibabel/gifti/tests/test_gifti.py b/nibabel/gifti/tests/test_gifti.py
index 49a8cbc07f..416faf3c84 100644
--- a/nibabel/gifti/tests/test_gifti.py
+++ b/nibabel/gifti/tests/test_gifti.py
@@ -1,20 +1,19 @@
-"""Testing gifti objects
-"""
+"""Testing gifti objects"""
+
 import itertools
 import sys
-import warnings
 from io import BytesIO
 
 import numpy as np
 import pytest
-from numpy.testing import assert_array_almost_equal, assert_array_equal
+from numpy.testing import assert_array_equal
 
 from nibabel.tmpdirs import InTemporaryDirectory
 
 from ... import load
 from ...fileholders import FileHolder
 from ...nifti1 import data_type_codes
-from ...testing import test_data
+from ...testing import deprecated_to, expires, get_test_data
 from .. import (
     GiftiCoordSystem,
     GiftiDataArray,
@@ -33,11 +32,13 @@
     DATA_FILE6,
 )
 
+rng = np.random.default_rng()
+
 
 def test_agg_data():
-    surf_gii_img = load(test_data('gifti', 'ascii.gii'))
-    func_gii_img = load(test_data('gifti', 'task.func.gii'))
-    shape_gii_img = load(test_data('gifti', 'rh.shape.curv.gii'))
+    surf_gii_img = load(get_test_data('gifti', 'ascii.gii'))
+    func_gii_img = load(get_test_data('gifti', 'task.func.gii'))
+    shape_gii_img = load(get_test_data('gifti', 'rh.shape.curv.gii'))
     # add timeseries data with intent code ``none``
 
     point_data = surf_gii_img.get_arrays_from_intent('pointset')[0].data
@@ -81,7 +82,7 @@ def test_gifti_image():
     assert gi.numDA == 0
 
     # Test from numpy numeric array
-    data = np.random.random((5,))
+    data = rng.random(5, dtype=np.float32)
     da = GiftiDataArray(data)
     gi.add_gifti_data_array(da)
     assert gi.numDA == 1
@@ -98,7 +99,7 @@ def test_gifti_image():
 
     # Remove one
     gi = GiftiImage()
-    da = GiftiDataArray(np.zeros((5,)), intent=0)
+    da = GiftiDataArray(np.zeros((5,), np.float32), intent=0)
     gi.add_gifti_data_array(da)
 
     gi.remove_gifti_data_array_by_intent(3)
@@ -126,6 +127,42 @@ def assign_metadata(val):
     pytest.raises(TypeError, assign_metadata, 'not-a-meta')
 
 
+@pytest.mark.parametrize('label', data_type_codes.value_set('label'))
+def test_image_typing(label):
+    dtype = data_type_codes.dtype[label]
+    if dtype == np.void:
+        return
+    arr = 127 * rng.random(20)
+    try:
+        cast = arr.astype(label)
+    except TypeError:
+        return
+    darr = GiftiDataArray(cast, datatype=label)
+    img = GiftiImage(darrays=[darr])
+
+    # Force-write always works
+    force_rt = img.from_bytes(img.to_bytes(mode='force'))
+    assert np.array_equal(cast, force_rt.darrays[0].data)
+
+    # Compatibility mode does its best
+    if np.issubdtype(dtype, np.integer) or np.issubdtype(dtype, np.floating):
+        compat_rt = img.from_bytes(img.to_bytes(mode='compat'))
+        compat_darr = compat_rt.darrays[0].data
+        assert np.allclose(cast, compat_darr)
+        assert compat_darr.dtype in ('uint8', 'int32', 'float32')
+    else:
+        with pytest.raises(ValueError):
+            img.to_bytes(mode='compat')
+
+    # Strict mode either works or fails
+    if label in ('uint8', 'int32', 'float32'):
+        strict_rt = img.from_bytes(img.to_bytes(mode='strict'))
+        assert np.array_equal(cast, strict_rt.darrays[0].data)
+    else:
+        with pytest.raises(ValueError):
+            img.to_bytes(mode='strict')
+
+
 def test_dataarray_empty():
     # Test default initialization of DataArray
     null_da = GiftiDataArray()
@@ -195,6 +232,38 @@ def test_dataarray_init():
     assert gda(ext_offset=12).ext_offset == 12
 
 
+@pytest.mark.parametrize('label', data_type_codes.value_set('label'))
+def test_dataarray_typing(label):
+    dtype = data_type_codes.dtype[label]
+    code = data_type_codes.code[label]
+    arr = np.zeros((5,), dtype=dtype)
+
+    # Default interface: accept standards-conformant arrays, reject else
+    if dtype in ('uint8', 'int32', 'float32'):
+        assert GiftiDataArray(arr).datatype == code
+    else:
+        with pytest.raises(ValueError):
+            GiftiDataArray(arr)
+
+    # Explicit override - permit for now, may want to warn or eventually
+    # error
+    assert GiftiDataArray(arr, datatype=label).datatype == code
+    assert GiftiDataArray(arr, datatype=code).datatype == code
+    # Void is how we say we don't know how to do something, so it's not unique
+    if dtype != np.dtype('void'):
+        assert GiftiDataArray(arr, datatype=dtype).datatype == code
+
+    # Side-load data array (as in parsing)
+    # We will probably always want this to load legacy images, but it's
+    # probably not ideal to make it easy to silently propagate nonconformant
+    # arrays
+    gda = GiftiDataArray()
+    gda.data = arr
+    gda.datatype = data_type_codes.code[label]
+    assert gda.data.dtype == dtype
+    assert gda.datatype == data_type_codes.code[label]
+
+
 def test_labeltable():
     img = GiftiImage()
     assert len(img.labeltable.labels) == 0
@@ -205,27 +274,29 @@ def test_labeltable():
     assert len(img.labeltable.labels) == 2
 
 
+@expires('6.0.0')
 def test_metadata():
     md = GiftiMetaData(key='value')
     # Old initialization methods
-    with pytest.warns(DeprecationWarning) as w:
+    with deprecated_to('6.0.0'):
         nvpair = GiftiNVPairs('key', 'value')
     with pytest.warns(FutureWarning) as w:
         md2 = GiftiMetaData(nvpair=nvpair)
     assert len(w) == 1
-    with pytest.warns(DeprecationWarning) as w:
+    with deprecated_to('6.0.0'):
         md3 = GiftiMetaData.from_dict({'key': 'value'})
     assert md == md2 == md3 == {'key': 'value'}
     # .data as a list of NVPairs is going away
-    with pytest.warns(DeprecationWarning) as w:
+    with deprecated_to('6.0.0'):
         assert md.data[0].name == 'key'
+    with deprecated_to('6.0.0'):
         assert md.data[0].value == 'value'
-    assert len(w) == 2
 
 
+@expires('6.0.0')
 def test_metadata_list_interface():
     md = GiftiMetaData(key='value')
-    with pytest.warns(DeprecationWarning):
+    with deprecated_to('6.0.0'):
         mdlist = md.data
     assert len(mdlist) == 1
     assert mdlist[0].name == 'key'
@@ -242,7 +313,7 @@ def test_metadata_list_interface():
     assert md['foo'] == 'bar'
 
     # Append new NVPair
-    with pytest.warns(DeprecationWarning) as w:
+    with deprecated_to('6.0.0'):
         nvpair = GiftiNVPairs('key', 'value')
     mdlist.append(nvpair)
     assert len(mdlist) == 2
@@ -257,7 +328,7 @@ def test_metadata_list_interface():
     assert len(md) == 0
 
     # Extension adds multiple keys
-    with pytest.warns(DeprecationWarning) as w:
+    with deprecated_to('6.0'):
         foobar = GiftiNVPairs('foo', 'bar')
     mdlist.extend([nvpair, foobar])
     assert len(mdlist) == 2
@@ -265,7 +336,7 @@ def test_metadata_list_interface():
     assert md == {'key': 'value', 'foo': 'bar'}
 
     # Insertion updates list order, though we don't attempt to preserve it in the dict
-    with pytest.warns(DeprecationWarning) as w:
+    with deprecated_to('6.0'):
         lastone = GiftiNVPairs('last', 'one')
     mdlist.insert(1, lastone)
     assert len(mdlist) == 3
@@ -288,14 +359,14 @@ def test_metadata_list_interface():
     mypair.value = 'strings'
     assert 'completelynew' not in md
     assert md == {'foo': 'bar', 'last': 'one'}
-    # Check popping from the end (lastone inserted before foobar)
-    lastpair = mdlist.pop()
+    # Check popping from the end (last one inserted before foobar)
+    mdlist.pop()
     assert len(mdlist) == 1
     assert len(md) == 1
     assert md == {'last': 'one'}
 
     # And let's remove an old pair with a new object
-    with pytest.warns(DeprecationWarning) as w:
+    with deprecated_to('6.0'):
         lastoneagain = GiftiNVPairs('last', 'one')
     mdlist.remove(lastoneagain)
     assert len(mdlist) == 0
@@ -303,7 +374,7 @@ def test_metadata_list_interface():
 
 
 def test_gifti_label_rgba():
-    rgba = np.random.rand(4)
+    rgba = rng.random(4)
     kwargs = dict(zip(['red', 'green', 'blue', 'alpha'], rgba))
 
     gl1 = GiftiLabel(**kwargs)
@@ -332,13 +403,17 @@ def assign_rgba(gl, val):
     assert np.all([elem is None for elem in gl4.rgba])
 
 
-def test_print_summary():
-    for fil in [DATA_FILE1, DATA_FILE2, DATA_FILE3, DATA_FILE4, DATA_FILE5, DATA_FILE6]:
-        gimg = load(fil)
-        gimg.print_summary()
+@pytest.mark.parametrize(
+    'fname', [DATA_FILE1, DATA_FILE2, DATA_FILE3, DATA_FILE4, DATA_FILE5, DATA_FILE6]
+)
+def test_print_summary(fname, capsys):
+    gimg = load(fname)
+    gimg.print_summary()
+    captured = capsys.readouterr()
+    assert captured.out.startswith('----start----\n')
 
 
-def test_gifti_coord():
+def test_gifti_coord(capsys):
     from ..gifti import GiftiCoordSystem
 
     gcs = GiftiCoordSystem()
@@ -347,6 +422,16 @@ def test_gifti_coord():
     # Smoke test
     gcs.xform = None
     gcs.print_summary()
+    captured = capsys.readouterr()
+    assert (
+        captured.out
+        == """\
+Dataspace:  NIFTI_XFORM_UNKNOWN
+XFormSpace:  NIFTI_XFORM_UNKNOWN
+Affine Transformation Matrix:
+ None
+"""
+    )
     gcs.to_xml()
 
 
@@ -471,14 +556,14 @@ def test_darray_dtype_coercion_failures():
             datatype=darray_dtype,
         )
         gii = GiftiImage(darrays=[da])
-        gii_copy = GiftiImage.from_bytes(gii.to_bytes())
+        gii_copy = GiftiImage.from_bytes(gii.to_bytes(mode='force'))
         da_copy = gii_copy.darrays[0]
         assert np.dtype(da_copy.data.dtype) == np.dtype(darray_dtype)
         assert_array_equal(da_copy.data, da.data)
 
 
 def test_gifti_file_close(recwarn):
-    gii = load(test_data('gifti', 'ascii.gii'))
+    gii = load(get_test_data('gifti', 'ascii.gii'))
     with InTemporaryDirectory():
         gii.to_filename('test.gii')
     assert not any(isinstance(r.message, ResourceWarning) for r in recwarn)
diff --git a/nibabel/gifti/tests/test_parse_gifti_fast.py b/nibabel/gifti/tests/test_parse_gifti_fast.py
index f08bdd1b17..cfc8ce4ae2 100644
--- a/nibabel/gifti/tests/test_parse_gifti_fast.py
+++ b/nibabel/gifti/tests/test_parse_gifti_fast.py
@@ -39,9 +39,19 @@
 DATA_FILE5 = pjoin(IO_DATA_PATH, 'base64bin.gii')
 DATA_FILE6 = pjoin(IO_DATA_PATH, 'rh.aparc.annot.gii')
 DATA_FILE7 = pjoin(IO_DATA_PATH, 'external.gii')
-
-datafiles = [DATA_FILE1, DATA_FILE2, DATA_FILE3, DATA_FILE4, DATA_FILE5, DATA_FILE6, DATA_FILE7]
-numDA = [2, 1, 1, 1, 2, 1, 2]
+DATA_FILE8 = pjoin(IO_DATA_PATH, 'ascii_flat_data.gii')
+
+datafiles = [
+    DATA_FILE1,
+    DATA_FILE2,
+    DATA_FILE3,
+    DATA_FILE4,
+    DATA_FILE5,
+    DATA_FILE6,
+    DATA_FILE7,
+    DATA_FILE8,
+]
+numDA = [2, 1, 1, 1, 2, 1, 2, 2]
 
 DATA_FILE1_darr1 = np.array(
     [
@@ -50,7 +60,7 @@
         [-17.614349, -65.401642, 21.071466],
     ]
 )
-DATA_FILE1_darr2 = np.array([0, 1, 2])
+DATA_FILE1_darr2 = np.array([[0, 1, 2]])
 
 DATA_FILE2_darr1 = np.array(
     [
@@ -152,6 +162,10 @@
     dtype=np.int32,
 )
 
+DATA_FILE8_darr1 = np.copy(DATA_FILE5_darr1)
+
+DATA_FILE8_darr2 = np.copy(DATA_FILE5_darr2)
+
 
 def assert_default_types(loaded):
     default = loaded.__class__()
@@ -163,9 +177,9 @@ def assert_default_types(loaded):
             continue
         with suppress_warnings():
             loadedtype = type(getattr(loaded, attr))
-        assert (
-            loadedtype == defaulttype
-        ), f'Type mismatch for attribute: {attr} ({loadedtype} != {defaulttype})'
+        assert loadedtype == defaulttype, (
+            f'Type mismatch for attribute: {attr} ({loadedtype} != {defaulttype})'
+        )
 
 
 def test_default_types():
@@ -227,7 +241,7 @@ def test_load_dataarray1():
         me = img.darrays[0].meta
         assert 'AnatomicalStructurePrimary' in me
         assert 'AnatomicalStructureSecondary' in me
-        me['AnatomicalStructurePrimary'] == 'CortexLeft'
+        assert me['AnatomicalStructurePrimary'] == 'CortexLeft'
         assert_array_almost_equal(img.darrays[0].coordsys.xform, np.eye(4, 4))
         assert xform_codes.niistring[img.darrays[0].coordsys.dataspace] == 'NIFTI_XFORM_TALAIRACH'
         assert xform_codes.niistring[img.darrays[0].coordsys.xformspace] == 'NIFTI_XFORM_TALAIRACH'
@@ -265,7 +279,7 @@ def test_load_dataarray4():
 def test_dataarray5():
     img5 = load(DATA_FILE5)
     for da in img5.darrays:
-        gifti_endian_codes.byteorder[da.endian] == 'little'
+        assert gifti_endian_codes.byteorder[da.endian] == 'little'
     assert_array_almost_equal(img5.darrays[0].data, DATA_FILE5_darr1)
     assert_array_almost_equal(img5.darrays[1].data, DATA_FILE5_darr2)
     # Round trip tested below
@@ -433,13 +447,13 @@ def test_external_file_failure_cases():
         shutil.copy(DATA_FILE7, '.')
         filename = pjoin(tmpdir, basename(DATA_FILE7))
         with pytest.raises(GiftiParseError):
-            img = load(filename)
+            load(filename)
     # load from in-memory xml string (parser requires it as bytes)
     with open(DATA_FILE7, 'rb') as f:
         xmldata = f.read()
     parser = GiftiImageParser()
     with pytest.raises(GiftiParseError):
-        img = parser.parse(xmldata)
+        parser.parse(xmldata)
 
 
 def test_load_compressed():
@@ -448,3 +462,9 @@ def test_load_compressed():
         img7 = load(fn)
         assert_array_almost_equal(img7.darrays[0].data, DATA_FILE7_darr1)
         assert_array_almost_equal(img7.darrays[1].data, DATA_FILE7_darr2)
+
+
+def test_load_flat_ascii_data():
+    img = load(DATA_FILE8)
+    assert_array_almost_equal(img.darrays[0].data, DATA_FILE8_darr1)
+    assert_array_almost_equal(img.darrays[1].data, DATA_FILE8_darr2)
diff --git a/nibabel/gifti/util.py b/nibabel/gifti/util.py
index 9393292013..791f133022 100644
--- a/nibabel/gifti/util.py
+++ b/nibabel/gifti/util.py
@@ -10,7 +10,7 @@
 from ..volumeutils import Recoder
 
 # Translate dtype.kind char codes to XML text output strings
-KIND2FMT = {'i': '%i', 'u': '%i', 'f': '%10.6f', 'c': '%10.6f', 'V': ''}
+KIND2FMT = {'i': '%d', 'u': '%d', 'f': '%10.6f', 'c': '%10.6f', 'V': ''}
 
 array_index_order_codes = Recoder(
     (
diff --git a/nibabel/imageclasses.py b/nibabel/imageclasses.py
index ac27a6ecac..66f984e268 100644
--- a/nibabel/imageclasses.py
+++ b/nibabel/imageclasses.py
@@ -8,6 +8,10 @@
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Define supported image classes and names"""
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from .analyze import AnalyzeImage
 from .brikhead import AFNIImage
 from .cifti2 import Cifti2Image
@@ -21,8 +25,12 @@
 from .spm2analyze import Spm2AnalyzeImage
 from .spm99analyze import Spm99AnalyzeImage
 
+if TYPE_CHECKING:
+    from .dataobj_images import DataobjImage
+    from .filebasedimages import FileBasedImage
+
 # Ordered by the load/save priority.
-all_image_classes = [
+all_image_classes: list[type[FileBasedImage]] = [
     Nifti1Pair,
     Nifti1Image,
     Nifti2Pair,
@@ -42,7 +50,7 @@
 # Image classes known to require spatial axes to be first in index ordering.
 # When adding an image class, consider whether the new class should be listed
 # here.
-KNOWN_SPATIAL_FIRST = (
+KNOWN_SPATIAL_FIRST: tuple[type[FileBasedImage], ...] = (
     Nifti1Pair,
     Nifti1Image,
     Nifti2Pair,
@@ -56,7 +64,7 @@
 )
 
 
-def spatial_axes_first(img):
+def spatial_axes_first(img: DataobjImage) -> bool:
     """True if spatial image axes for `img` always precede other axes
 
     Parameters
diff --git a/nibabel/imagestats.py b/nibabel/imagestats.py
index 6f1b68178b..36fbddee0e 100644
--- a/nibabel/imagestats.py
+++ b/nibabel/imagestats.py
@@ -6,9 +6,7 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""
-Functions for computing image statistics
-"""
+"""Functions for computing image statistics"""
 
 import numpy as np
 
diff --git a/nibabel/info.py b/nibabel/info.py
index 96031ac954..87727cab13 100644
--- a/nibabel/info.py
+++ b/nibabel/info.py
@@ -1,7 +1,7 @@
-"""Define distribution parameters for nibabel, including package version
+"""Define static nibabel metadata for nibabel
 
-The long description parameter is used to fill settings in setup.py, the
-nibabel top-level docstring, and in building the docs.
+The long description parameter is used in the nibabel top-level docstring,
+and in building the docs.
 We exec this file in several places, so it cannot import nibabel or use
 relative imports.
 """
@@ -12,86 +12,100 @@
 # We also include this text in the docs by ``..include::`` in
 # ``docs/source/index.rst``.
 long_description = """
-=======
-NiBabel
-=======
-
-Read / write access to some common neuroimaging file formats
+Read and write access to common neuroimaging file formats, including:
+ANALYZE_ (plain, SPM99, SPM2 and later), GIFTI_, NIfTI1_, NIfTI2_, `CIFTI-2`_,
+MINC1_, MINC2_, `AFNI BRIK/HEAD`_, ECAT_ and Philips PAR/REC.
+In addition, NiBabel also supports FreeSurfer_'s MGH_, geometry, annotation and
+morphometry files, and provides some limited support for DICOM_.
 
-This package provides read +/- write access to some common medical and
-neuroimaging file formats, including: ANALYZE_ (plain, SPM99, SPM2 and later),
-GIFTI_, NIfTI1_, NIfTI2_, `CIFTI-2`_, MINC1_, MINC2_, `AFNI BRIK/HEAD`_, MGH_ and
-ECAT_ as well as Philips PAR/REC.  We can read and write FreeSurfer_ geometry,
-annotation and morphometry files.  There is some very limited support for
-DICOM_.  NiBabel is the successor of PyNIfTI_.
+NiBabel's API gives full or selective access to header information (metadata),
+and image data is made available via NumPy arrays. For more information, see
+NiBabel's `documentation site`_ and `API reference`_.
 
-.. _ANALYZE: http://www.grahamwideman.com/gw/brain/analyze/formatdoc.htm
+.. _API reference: https://nipy.org/nibabel/api.html
 .. _AFNI BRIK/HEAD: https://afni.nimh.nih.gov/pub/dist/src/README.attributes
-.. _NIfTI1: http://nifti.nimh.nih.gov/nifti-1/
-.. _NIfTI2: http://nifti.nimh.nih.gov/nifti-2/
+.. _ANALYZE: http://www.grahamwideman.com/gw/brain/analyze/formatdoc.htm
 .. _CIFTI-2: https://www.nitrc.org/projects/cifti/
+.. _DICOM: http://medical.nema.org/
+.. _documentation site: http://nipy.org/nibabel
+.. _ECAT: http://xmedcon.sourceforge.net/Docs/Ecat
+.. _Freesurfer: https://surfer.nmr.mgh.harvard.edu
+.. _GIFTI: https://www.nitrc.org/projects/gifti
+.. _MGH: https://surfer.nmr.mgh.harvard.edu/fswiki/FsTutorial/MghFormat
 .. _MINC1:
     https://en.wikibooks.org/wiki/MINC/Reference/MINC1_File_Format_Reference
 .. _MINC2:
     https://en.wikibooks.org/wiki/MINC/Reference/MINC2.0_File_Format_Reference
-.. _PyNIfTI: http://niftilib.sourceforge.net/pynifti/
-.. _GIFTI: https://www.nitrc.org/projects/gifti
-.. _MGH: https://surfer.nmr.mgh.harvard.edu/fswiki/FsTutorial/MghFormat
-.. _ECAT: http://xmedcon.sourceforge.net/Docs/Ecat
-.. _Freesurfer: https://surfer.nmr.mgh.harvard.edu
-.. _DICOM: http://medical.nema.org/
+.. _NIfTI1: http://nifti.nimh.nih.gov/nifti-1/
+.. _NIfTI2: http://nifti.nimh.nih.gov/nifti-2/
 
-The various image format classes give full or selective access to header
-(meta) information and access to the image data is made available via NumPy
-arrays.
+Installation
+============
 
-Website
-=======
+To install NiBabel's `current release`_ with ``pip``, run::
 
-Current documentation on nibabel can always be found at the `NIPY nibabel
-website <http://nipy.org/nibabel>`_.
+   pip install nibabel
 
-Mailing Lists
-=============
+To install the latest development version, run::
 
-Please send any questions or suggestions to the `neuroimaging mailing list
-<https://mail.python.org/mailman/listinfo/neuroimaging>`_.
+   pip install git+https://github.com/nipy/nibabel
+
+When working on NiBabel itself, it may be useful to install in "editable" mode::
 
-Code
-====
+   git clone https://github.com/nipy/nibabel.git
+   pip install -e ./nibabel
+
+For more information on previous releases, see the `release archive`_ or
+`development changelog`_.
+
+.. _current release: https://pypi.python.org/pypi/NiBabel
+.. _release archive: https://github.com/nipy/NiBabel/releases
+.. _development changelog: https://nipy.org/nibabel/changelog.html
+
+Testing
+=======
 
-Install nibabel with::
+During development, we recommend using tox_ to run nibabel tests::
 
-    pip install nibabel
+    git clone https://github.com/nipy/nibabel.git
+    cd nibabel
+    tox
 
-You may also be interested in:
+To test an installed version of nibabel, install the test dependencies
+and run pytest_::
 
-* the `nibabel code repository`_ on Github;
-* documentation_ for all releases and current development tree;
-* download the `current release`_ from pypi;
-* download `current development version`_ as a zip file;
-* downloads of all `available releases`_.
+    pip install nibabel[test]
+    pytest --pyargs nibabel
 
-.. _nibabel code repository: https://github.com/nipy/nibabel
-.. _Documentation: http://nipy.org/nibabel
-.. _current release: https://pypi.python.org/pypi/nibabel
-.. _current development version: https://github.com/nipy/nibabel/archive/master.zip
-.. _available releases: https://github.com/nipy/nibabel/releases
+For more information, consult the `developer guidelines`_.
+
+.. _tox: https://tox.wiki
+.. _pytest: https://docs.pytest.org
+.. _developer guidelines: https://nipy.org/nibabel/devel/devguide.html
+
+Mailing List
+============
+
+Please send any questions or suggestions to the `neuroimaging mailing list
+<https://mail.python.org/mailman/listinfo/neuroimaging>`_.
 
 License
 =======
 
-Nibabel is licensed under the terms of the MIT license. Some code included
-with nibabel is licensed under the BSD license.  Please see the COPYING file
-in the nibabel distribution.
+NiBabel is licensed under the terms of the `MIT license
+<https://github.com/nipy/nibabel/blob/master/COPYING#nibabel>`__.
+Some code included with NiBabel is licensed under the `BSD license`_.
+For more information, please see the COPYING_ file.
 
-Citing nibabel
-==============
+.. _BSD license: https://opensource.org/licenses/BSD-3-Clause
+.. _COPYING: https://github.com/nipy/nibabel/blob/master/COPYING
 
-Please see the `available releases`_ for the release of nibabel that you are
-using.  Recent releases have a Zenodo_ `Digital Object Identifier`_ badge at
-the top of the release notes.  Click on the badge for more information.
+Citation
+========
+
+NiBabel releases have a Zenodo_ `Digital Object Identifier`_ (DOI) badge at
+the top of the release notes. Click on the badge for more information.
 
-.. _zenodo: https://zenodo.org
 .. _Digital Object Identifier: https://en.wikipedia.org/wiki/Digital_object_identifier
+.. _zenodo: https://zenodo.org
 """
diff --git a/nibabel/loadsave.py b/nibabel/loadsave.py
index 6c1981ca77..e398092abd 100644
--- a/nibabel/loadsave.py
+++ b/nibabel/loadsave.py
@@ -9,6 +9,8 @@
 # module imports
 """Utilities to load and save image objects"""
 
+from __future__ import annotations
+
 import os
 
 import numpy as np
@@ -23,7 +25,22 @@
 _compressed_suffixes = ('.gz', '.bz2', '.zst')
 
 
-def _signature_matches_extension(filename):
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import TypedDict
+
+    from ._typing import ParamSpec
+    from .filebasedimages import FileBasedImage
+    from .filename_parser import FileSpec
+
+    P = ParamSpec('P')
+
+    class Signature(TypedDict):
+        signature: bytes
+        format_name: str
+
+
+def _signature_matches_extension(filename: FileSpec) -> tuple[bool, str]:
     """Check if signature aka magic number matches filename extension.
 
     Parameters
@@ -43,7 +60,7 @@ def _signature_matches_extension(filename):
        the empty string otherwise.
 
     """
-    signatures = {
+    signatures: dict[str, Signature] = {
         '.gz': {'signature': b'\x1f\x8b', 'format_name': 'gzip'},
         '.bz2': {'signature': b'BZh', 'format_name': 'bzip2'},
         '.zst': {'signature': b'\x28\xb5\x2f\xfd', 'format_name': 'ztsd'},
@@ -65,7 +82,7 @@ def _signature_matches_extension(filename):
     return False, f'File {filename} is not a {format_name} file'
 
 
-def load(filename, **kwargs):
+def load(filename: FileSpec, **kwargs) -> FileBasedImage:
     r"""Load file given filename, guessing at file type
 
     Parameters
@@ -127,7 +144,7 @@ def guessed_image_type(filename):
     raise ImageFileError(f'Cannot work out file type of "{filename}"')
 
 
-def save(img, filename, **kwargs):
+def save(img: FileBasedImage, filename: FileSpec, **kwargs) -> None:
     r"""Save an image to file adapting format to `filename`
 
     Parameters
@@ -162,19 +179,17 @@ def save(img, filename, **kwargs):
     from .nifti1 import Nifti1Image, Nifti1Pair
     from .nifti2 import Nifti2Image, Nifti2Pair
 
-    klass = None
-    converted = None
-
+    converted: FileBasedImage
     if type(img) == Nifti1Image and lext in ('.img', '.hdr'):
-        klass = Nifti1Pair
+        converted = Nifti1Pair.from_image(img)
     elif type(img) == Nifti2Image and lext in ('.img', '.hdr'):
-        klass = Nifti2Pair
+        converted = Nifti2Pair.from_image(img)
     elif type(img) == Nifti1Pair and lext == '.nii':
-        klass = Nifti1Image
+        converted = Nifti1Image.from_image(img)
     elif type(img) == Nifti2Pair and lext == '.nii':
-        klass = Nifti2Image
+        converted = Nifti2Image.from_image(img)
     else:  # arbitrary conversion
-        valid_klasses = [klass for klass in all_image_classes if ext in klass.valid_exts]
+        valid_klasses = [klass for klass in all_image_classes if lext in klass.valid_exts]
         if not valid_klasses:  # if list is empty
             raise ImageFileError(f'Cannot work out file type of "{filename}"')
 
@@ -187,13 +202,9 @@ def save(img, filename, **kwargs):
                 break
             except Exception as e:
                 err = e
-        # ... and if none of them work, raise an error.
-        if converted is None:
+        else:
             raise err
 
-    # Here, we either have a klass or a converted image.
-    if converted is None:
-        converted = klass.from_image(img)
     converted.to_filename(filename, **kwargs)
 
 
diff --git a/nibabel/minc1.py b/nibabel/minc1.py
index b9d4bc2074..d0b9fd5375 100644
--- a/nibabel/minc1.py
+++ b/nibabel/minc1.py
@@ -7,10 +7,10 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Read MINC1 format images"""
+
 from __future__ import annotations
 
 from numbers import Integral
-from typing import Type
 
 import numpy as np
 
@@ -307,7 +307,8 @@ class Minc1Image(SpatialImage):
     load.
     """
 
-    header_class: Type[MincHeader] = Minc1Header
+    header_class: type[MincHeader] = Minc1Header
+    header: MincHeader
     _meta_sniff_len: int = 4
     valid_exts: tuple[str, ...] = ('.mnc',)
     files_types: tuple[tuple[str, str], ...] = (('image', '.mnc'),)
@@ -334,4 +335,4 @@ def from_file_map(klass, file_map, *, mmap=True, keep_file_open=None):
         return klass(data, affine, header, extra=None, file_map=file_map)
 
 
-load = Minc1Image.load
+load = Minc1Image.from_filename
diff --git a/nibabel/minc2.py b/nibabel/minc2.py
index cdb567a996..161be5c111 100644
--- a/nibabel/minc2.py
+++ b/nibabel/minc2.py
@@ -25,6 +25,9 @@
 
     mincstats my_funny.mnc
 """
+
+import warnings
+
 import numpy as np
 
 from .minc1 import Minc1File, Minc1Image, MincError, MincHeader
@@ -58,8 +61,13 @@ def __init__(self, mincfile):
         # We don't currently support irregular spacing
         # https://en.wikibooks.org/wiki/MINC/Reference/MINC2.0_File_Format_Reference#Dimension_variable_attributes
         for dim in self._dims:
-            if dim.spacing != b'regular__':
+            # "If this attribute is absent, a value of regular__ should be assumed."
+            spacing = getattr(dim, 'spacing', b'regular__')
+            if spacing == b'irregular':
                 raise ValueError('Irregular spacing not supported')
+            elif spacing != b'regular__':
+                warnings.warn(f'Invalid spacing declaration: {spacing}; assuming regular')
+
         self._spatial_dims = [name for name in self._dim_names if name.endswith('space')]
         self._image_max = image['image-max']
         self._image_min = image['image-min']
@@ -150,12 +158,13 @@ class Minc2Image(Minc1Image):
     # MINC2 does not do compressed whole files
     _compressed_suffixes = ()
     header_class = Minc2Header
+    header: Minc2Header
 
     @classmethod
     def from_file_map(klass, file_map, *, mmap=True, keep_file_open=None):
         # Import of h5py might take awhile for MPI-enabled builds
         # So we are importing it here "on demand"
-        import h5py  # type: ignore
+        import h5py  # type: ignore[import]
 
         holder = file_map['image']
         if holder.filename is None:
@@ -172,4 +181,4 @@ def from_file_map(klass, file_map, *, mmap=True, keep_file_open=None):
         return klass(data, affine, header, extra=None, file_map=file_map)
 
 
-load = Minc2Image.load
+load = Minc2Image.from_filename
diff --git a/nibabel/mriutils.py b/nibabel/mriutils.py
index d993d26a21..09067cc1e9 100644
--- a/nibabel/mriutils.py
+++ b/nibabel/mriutils.py
@@ -6,9 +6,7 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""
-Utilities for calculations related to MRI
-"""
+"""Utilities for calculations related to MRI"""
 
 __all__ = ['calculate_dwell_time']
 
diff --git a/nibabel/nicom/__init__.py b/nibabel/nicom/__init__.py
index 3a389db172..d15e0846ff 100644
--- a/nibabel/nicom/__init__.py
+++ b/nibabel/nicom/__init__.py
@@ -19,6 +19,7 @@
    dwiparams
    structreader
 """
+
 import warnings
 
 warnings.warn(
diff --git a/nibabel/nicom/ascconv.py b/nibabel/nicom/ascconv.py
index be6da9786c..2eca5a1579 100644
--- a/nibabel/nicom/ascconv.py
+++ b/nibabel/nicom/ascconv.py
@@ -3,13 +3,14 @@
 """
 Parse the "ASCCONV" meta data format found in a variety of Siemens MR files.
 """
+
 import ast
 import re
 from collections import OrderedDict
 
 ASCCONV_RE = re.compile(
     r'### ASCCONV BEGIN((?:\s*[^=\s]+=[^=\s]+)*) ###\n(.*?)\n### ASCCONV END ###',
-    flags=re.M | re.S,
+    flags=re.MULTILINE | re.DOTALL,
 )
 
 
@@ -89,10 +90,7 @@ def assign2atoms(assign_ast, default_class=int):
             target = target.value
             prev_target_type = OrderedDict
         elif isinstance(target, ast.Subscript):
-            if isinstance(target.slice, ast.Constant):  # PY39
-                index = target.slice.n
-            else:  # PY38
-                index = target.slice.value.n
+            index = target.slice.value
             atoms.append(Atom(target, prev_target_type, index))
             target = target.value
             prev_target_type = list
@@ -173,12 +171,10 @@ def obj_from_atoms(atoms, namespace):
 
 def _get_value(assign):
     value = assign.value
-    if isinstance(value, ast.Num):
-        return value.n
-    if isinstance(value, ast.Str):
-        return value.s
+    if isinstance(value, ast.Constant):
+        return value.value
     if isinstance(value, ast.UnaryOp) and isinstance(value.op, ast.USub):
-        return -value.operand.n
+        return -value.operand.value
     raise AscconvParseError(f'Unexpected RHS of assignment: {value}')
 
 
diff --git a/nibabel/nicom/csareader.py b/nibabel/nicom/csareader.py
index 40f3f852d9..b98dae7403 100644
--- a/nibabel/nicom/csareader.py
+++ b/nibabel/nicom/csareader.py
@@ -1,5 +1,5 @@
-"""CSA header reader from SPM spec
-"""
+"""CSA header reader from SPM spec"""
+
 import numpy as np
 
 from .structreader import Unpacker
@@ -179,7 +179,7 @@ def get_vector(csa_dict, tag_name, n):
     if len(items) == 0:
         return None
     if len(items) != n:
-        raise ValueError('Expecting %d vector' % n)
+        raise ValueError(f'Expecting {n} vector')
     return np.array(items)
 
 
diff --git a/nibabel/nicom/dicomreaders.py b/nibabel/nicom/dicomreaders.py
index 113af967cc..07362ee47d 100644
--- a/nibabel/nicom/dicomreaders.py
+++ b/nibabel/nicom/dicomreaders.py
@@ -53,7 +53,7 @@ def read_mosaic_dir(dicom_path, globber='*.dcm', check_is_dwi=False, dicom_kwarg
        If True, raises an error if we don't find DWI information in the
        DICOM headers.
     dicom_kwargs : None or dict
-       Extra keyword arguments to pass to the pydicom ``read_file`` function.
+       Extra keyword arguments to pass to the pydicom ``dcmread`` function.
 
     Returns
     -------
@@ -131,7 +131,7 @@ def slices_to_series(wrappers):
                 break
         else:  # no match in current volume lists
             volume_lists.append([dw])
-    print('We appear to have %d Series' % len(volume_lists))
+    print(f'We appear to have {len(volume_lists)} Series')
     # second pass
     out_vol_lists = []
     for vol_list in volume_lists:
@@ -143,7 +143,7 @@ def slices_to_series(wrappers):
                 out_vol_lists += _third_pass(vol_list)
                 continue
         out_vol_lists.append(vol_list)
-    print('We have %d volumes after second pass' % len(out_vol_lists))
+    print(f'We have {len(out_vol_lists)} volumes after second pass')
     # final pass check
     for vol_list in out_vol_lists:
         zs = [s.slice_indicator for s in vol_list]
diff --git a/nibabel/nicom/dicomwrappers.py b/nibabel/nicom/dicomwrappers.py
index 572957f391..26ca75b156 100755
--- a/nibabel/nicom/dicomwrappers.py
+++ b/nibabel/nicom/dicomwrappers.py
@@ -13,16 +13,18 @@
 """
 
 import operator
+import re
 import warnings
+from functools import cached_property
 
 import numpy as np
 
 from nibabel.optpkg import optional_package
 
-from ..onetime import auto_attr as one_time
 from ..openers import ImageOpener
 from . import csareader as csar
 from .dwiparams import B2q, nearest_pos_semi_def, q2bg
+from .utils import Vendor, find_private_section, vendor_from_private
 
 pydicom = optional_package('pydicom')[0]
 
@@ -44,9 +46,9 @@ def wrapper_from_file(file_like, *args, **kwargs):
        filename string or file-like object, pointing to a valid DICOM
        file readable by ``pydicom``
     \*args : positional
-        args to ``dicom.read_file`` command.
+        args to ``dicom.dcmread`` command.
     \*\*kwargs : keyword
-        args to ``dicom.read_file`` command.  ``force=True`` might be a
+        args to ``dicom.dcmread`` command.  ``force=True`` might be a
         likely keyword argument.
 
     Returns
@@ -55,11 +57,11 @@ def wrapper_from_file(file_like, *args, **kwargs):
        DICOM wrapper corresponding to DICOM data type
     """
     with ImageOpener(file_like) as fobj:
-        dcm_data = pydicom.read_file(fobj, *args, **kwargs)
+        dcm_data = pydicom.dcmread(fobj, *args, **kwargs)
     return wrapper_from_data(dcm_data)
 
 
-def wrapper_from_data(dcm_data):
+def wrapper_from_data(dcm_data, frame_filters=None):
     """Create DICOM wrapper from DICOM data object
 
     Parameters
@@ -68,6 +70,9 @@ def wrapper_from_data(dcm_data):
        Object allowing attribute access, with DICOM attributes.
        Probably a dataset as read by ``pydicom``.
 
+    frame_filters
+        Optionally override the `frame_filters` used to create a `MultiFrameWrapper`
+
     Returns
     -------
     dcm_w : ``dicomwrappers.Wrapper`` or subclass
@@ -76,9 +81,8 @@ def wrapper_from_data(dcm_data):
     sop_class = dcm_data.get('SOPClassUID')
     # try to detect what type of dicom object to wrap
     if sop_class == '1.2.840.10008.5.1.4.1.1.4.1':  # Enhanced MR Image Storage
-        # currently only Philips is using Enhanced Multiframe DICOM
-        return MultiframeWrapper(dcm_data)
-    # Check for Siemens DICOM format types
+        return MultiframeWrapper(dcm_data, frame_filters)
+    # Check for non-enhanced (legacy) Siemens DICOM format types
     # Only Siemens will have data for the CSA header
     try:
         csa = csar.get_csa_header(dcm_data)
@@ -103,6 +107,7 @@ class Wrapper:
     Methods:
 
     * get_data()
+    * get_unscaled_data()
     * get_pixel_array()
     * is_same_series(other)
     * __getitem__ : return attributes from `dcm_data`
@@ -120,6 +125,8 @@ class Wrapper:
     * image_position : sequence length 3
     * slice_indicator : float
     * series_signature : tuple
+    * scale_factors : (N, 2) array
+    * vendor : Vendor
     """
 
     is_csa = False
@@ -136,11 +143,35 @@ def __init__(self, dcm_data):
         dcm_data : object
            object should allow 'get' and '__getitem__' access.  Usually this
            will be a ``dicom.dataset.Dataset`` object resulting from reading a
-           DICOM file, but a dictionary should also work.
+           DICOM file.
         """
         self.dcm_data = dcm_data
 
-    @one_time
+    @cached_property
+    def vendor(self):
+        """The vendor of the instrument that produced the DICOM"""
+        # Look at manufacturer tag first
+        mfgr = self.get('Manufacturer')
+        if mfgr:
+            if re.search(r'Siemens', mfgr, re.IGNORECASE):
+                return Vendor.SIEMENS
+            if re.search(r'Philips', mfgr, re.IGNORECASE):
+                return Vendor.PHILIPS
+            if re.search(r'GE Medical', mfgr, re.IGNORECASE):
+                return Vendor.GE
+        # Next look at UID prefixes
+        for uid_src in ('StudyInstanceUID', 'SeriesInstanceUID', 'SOPInstanceUID'):
+            uid = str(self.get(uid_src))
+            if uid.startswith(('1.3.12.2.1007.', '1.3.12.2.1107.')):
+                return Vendor.SIEMENS
+            if uid.startswith(('1.3.46', '1.3.12.2.1017')):
+                return Vendor.PHILIPS
+            if uid.startswith('1.2.840.113619'):
+                return Vendor.GE
+        # Finally look for vendor specific private blocks
+        return vendor_from_private(self.dcm_data)
+
+    @cached_property
     def image_shape(self):
         """The array shape as it will be returned by ``get_data()``"""
         shape = (self.get('Rows'), self.get('Columns'))
@@ -148,7 +179,7 @@ def image_shape(self):
             return None
         return shape
 
-    @one_time
+    @cached_property
     def image_orient_patient(self):
         """Note that this is _not_ LR flipped"""
         iop = self.get('ImageOrientationPatient')
@@ -158,7 +189,7 @@ def image_orient_patient(self):
         iop = np.array(list(map(float, iop)))
         return np.array(iop).reshape(2, 3).T
 
-    @one_time
+    @cached_property
     def slice_normal(self):
         iop = self.image_orient_patient
         if iop is None:
@@ -166,7 +197,7 @@ def slice_normal(self):
         # iop[:, 0] is column index cosine, iop[:, 1] is row index cosine
         return np.cross(iop[:, 1], iop[:, 0])
 
-    @one_time
+    @cached_property
     def rotation_matrix(self):
         """Return rotation matrix between array indices and mm
 
@@ -193,7 +224,7 @@ def rotation_matrix(self):
             raise WrapperPrecisionError('Rotation matrix not nearly orthogonal')
         return R
 
-    @one_time
+    @cached_property
     def voxel_sizes(self):
         """voxel sizes for array as returned by ``get_data()``"""
         # pix space gives (row_spacing, column_spacing).  That is, the
@@ -212,7 +243,7 @@ def voxel_sizes(self):
         pix_space = list(map(float, pix_space))
         return tuple(pix_space + [zs])
 
-    @one_time
+    @cached_property
     def image_position(self):
         """Return position of first voxel in data block
 
@@ -231,7 +262,7 @@ def image_position(self):
             # Values are python Decimals in pydicom 0.9.7
         return np.array(list(map(float, ipp)))
 
-    @one_time
+    @cached_property
     def slice_indicator(self):
         """A number that is higher for higher slices in Z
 
@@ -246,12 +277,12 @@ def slice_indicator(self):
             return None
         return np.inner(ipp, s_norm)
 
-    @one_time
+    @cached_property
     def instance_number(self):
         """Just because we use this a lot for sorting"""
         return self.get('InstanceNumber')
 
-    @one_time
+    @cached_property
     def series_signature(self):
         """Signature for matching slices into series
 
@@ -315,14 +346,30 @@ def affine(self):
         return aff
 
     def get_pixel_array(self):
-        """Return unscaled pixel array from DICOM"""
+        """Return raw pixel array without reshaping or scaling
+
+        Returns
+        -------
+        data : array
+           array with raw pixel data from DICOM
+        """
         data = self.dcm_data.get('pixel_array')
         if data is None:
             raise WrapperError('Cannot find data in DICOM')
         return data
 
+    def get_unscaled_data(self):
+        """Return pixel array that is potentially reshaped, but without any scaling
+
+        Returns
+        -------
+        data : array
+           array with raw pixel data from DICOM
+        """
+        return self.get_pixel_array()
+
     def get_data(self):
-        """Get scaled image data from DICOMs
+        """Get potentially scaled and reshaped image data from DICOMs
 
         We return the data as DICOM understands it, first dimension is
         rows, second dimension is columns
@@ -333,7 +380,7 @@ def get_data(self):
            array with data as scaled from any scaling in the DICOM
            fields.
         """
-        return self._scale_data(self.get_pixel_array())
+        return self._scale_data(self.get_unscaled_data())
 
     def is_same_series(self, other):
         """Return True if `other` appears to be in same series
@@ -372,11 +419,86 @@ def is_same_series(self, other):
                     return False
         return True
 
+    @cached_property
+    def scale_factors(self):
+        """Return (2, N) array of slope/intercept pairs"""
+        scaling = self._get_best_scale_factor(self.dcm_data)
+        if scaling is None:
+            if self.vendor == Vendor.PHILIPS:
+                warnings.warn(
+                    'Unable to find Philips private scale factor, cross-series comparisons may be invalid'
+                )
+            scaling = (1, 0)
+        return np.array((scaling,))
+
+    def _get_rwv_scale_factor(self, dcm_data):
+        """Return the first set of 'real world' scale factors with defined units"""
+        rw_seq = dcm_data.get('RealWorldValueMappingSequence')
+        if rw_seq:
+            for rw_map in rw_seq:
+                try:
+                    units = rw_map.MeasurementUnitsCodeSequence[0].CodeMeaning
+                except (AttributeError, IndexError):
+                    continue
+                if units not in ('', 'no units', 'UNDEFINED'):
+                    return (
+                        rw_map.get('RealWorldValueSlope', 1),
+                        rw_map.get('RealWorldValueIntercept', 0),
+                    )
+
+    def _get_legacy_scale_factor(self, dcm_data):
+        """Return scale factors from older 'Modality LUT' macro
+
+        For Philips data we require RescaleType is defined and not set to 'normalized'
+        """
+        pix_trans_seq = dcm_data.get('PixelValueTransformationSequence')
+        if pix_trans_seq is not None:
+            pix_trans = pix_trans_seq[0]
+            if self.vendor != Vendor.PHILIPS or pix_trans.get('RescaleType', 'US') not in (
+                '',
+                'US',
+                'normalized',
+            ):
+                return (pix_trans.get('RescaleSlope', 1), pix_trans.get('RescaleIntercept', 0))
+        if (
+            dcm_data.get('RescaleSlope') is not None
+            or dcm_data.get('RescaleIntercept') is not None
+        ):
+            if self.vendor != Vendor.PHILIPS or dcm_data.get('RescaleType', 'US') not in (
+                '',
+                'US',
+                'normalized',
+            ):
+                return (dcm_data.get('RescaleSlope', 1), dcm_data.get('RescaleIntercept', 0))
+
+    def _get_philips_scale_factor(self, dcm_data):
+        """Return scale factors from Philips private element
+
+        If we don't have any other scale factors that are tied to real world units, then
+        this is the best scaling to use to enable cross-series comparisons
+        """
+        offset = find_private_section(dcm_data, 0x2005, 'Philips MR Imaging DD 001')
+        priv_scale = None if offset is None else dcm_data.get((0x2005, offset + 0xE))
+        if priv_scale is not None:
+            return (priv_scale.value, 0.0)
+
+    def _get_best_scale_factor(self, dcm_data):
+        """Return the most appropriate scale factor found or None"""
+        scaling = self._get_rwv_scale_factor(dcm_data)
+        if scaling is not None:
+            return scaling
+        scaling = self._get_legacy_scale_factor(dcm_data)
+        if scaling is not None:
+            return scaling
+        if self.vendor == Vendor.PHILIPS:
+            scaling = self._get_philips_scale_factor(dcm_data)
+            if scaling is not None:
+                return scaling
+
     def _scale_data(self, data):
         # depending on pydicom and dicom files, values might need casting from
         # Decimal to float
-        scale = float(self.get('RescaleSlope', 1))
-        offset = float(self.get('RescaleIntercept', 0))
+        scale, offset = self.scale_factors[0]
         return self._apply_scale_offset(data, scale, offset)
 
     def _apply_scale_offset(self, data, scale, offset):
@@ -390,7 +512,7 @@ def _apply_scale_offset(self, data, scale, offset):
             return data + offset
         return data
 
-    @one_time
+    @cached_property
     def b_value(self):
         """Return b value for diffusion or None if not available"""
         q_vec = self.q_vector
@@ -398,7 +520,7 @@ def b_value(self):
             return None
         return q2bg(q_vec)[0]
 
-    @one_time
+    @cached_property
     def b_vector(self):
         """Return b vector for diffusion or None if not available"""
         q_vec = self.q_vector
@@ -407,6 +529,77 @@ def b_vector(self):
         return q2bg(q_vec)[1]
 
 
+class FrameFilter:
+    """Base class for defining how to filter out (ignore) frames from a multiframe file
+
+    It is guaranteed that the `applies` method will called on a dataset before the `keep`
+    method is called on any of the frames inside.
+    """
+
+    def applies(self, dcm_wrp) -> bool:
+        """Returns true if the filter should be applied to a dataset"""
+        return True
+
+    def keep(self, frame_data) -> bool:
+        """Return true if the frame should be kept"""
+        raise NotImplementedError
+
+
+class FilterMultiStack(FrameFilter):
+    """Filter out all but one `StackID`"""
+
+    def __init__(self, keep_id=None):
+        self._keep_id = str(keep_id) if keep_id is not None else None
+
+    def applies(self, dcm_wrp) -> bool:
+        first_fcs = dcm_wrp.frames[0].get('FrameContentSequence', (None,))[0]
+        if first_fcs is None or not hasattr(first_fcs, 'StackID'):
+            return False
+        stack_ids = {frame.FrameContentSequence[0].StackID for frame in dcm_wrp.frames}
+        if self._keep_id is not None:
+            if self._keep_id not in stack_ids:
+                raise WrapperError('Explicitly requested StackID not found')
+            self._selected = self._keep_id
+        if len(stack_ids) > 1:
+            if self._keep_id is None:
+                try:
+                    sids = [int(x) for x in stack_ids]
+                except:
+                    self._selected = dcm_wrp.frames[0].FrameContentSequence[0].StackID
+                else:
+                    self._selected = str(min(sids))
+                warnings.warn(
+                    'A multi-stack file was passed without an explicit filter, '
+                    f'using StackID = {self._selected}'
+                )
+            return True
+        return False
+
+    def keep(self, frame) -> bool:
+        return frame.FrameContentSequence[0].StackID == self._selected
+
+
+class FilterDwiIso(FrameFilter):
+    """Filter out derived ISOTROPIC frames from DWI series"""
+
+    def applies(self, dcm_wrp) -> bool:
+        if not hasattr(dcm_wrp.frames[0], 'MRDiffusionSequence'):
+            return False
+        diff_dirs = {
+            f.MRDiffusionSequence[0].get('DiffusionDirectionality') for f in dcm_wrp.frames
+        }
+        if len(diff_dirs) > 1 and 'ISOTROPIC' in diff_dirs:
+            warnings.warn('Derived images found and removed')
+            return True
+        return False
+
+    def keep(self, frame) -> bool:
+        return frame.MRDiffusionSequence[0].DiffusionDirectionality != 'ISOTROPIC'
+
+
+DEFUALT_FRAME_FILTERS = (FilterMultiStack(), FilterDwiIso())
+
+
 class MultiframeWrapper(Wrapper):
     """Wrapper for Enhanced MR Storage SOP Class
 
@@ -436,17 +629,20 @@ class MultiframeWrapper(Wrapper):
 
     Methods
     -------
+    vendor(self)
+    frame_order(self)
     image_shape(self)
     image_orient_patient(self)
     voxel_sizes(self)
     image_position(self)
     series_signature(self)
+    scale_factors(self)
     get_data(self)
     """
 
     is_multiframe = True
 
-    def __init__(self, dcm_data):
+    def __init__(self, dcm_data, frame_filters=None):
         """Initializes MultiframeWrapper
 
         Parameters
@@ -454,10 +650,13 @@ def __init__(self, dcm_data):
         dcm_data : object
            object should allow 'get' and '__getitem__' access.  Usually this
            will be a ``dicom.dataset.Dataset`` object resulting from reading a
-           DICOM file, but a dictionary should also work.
+           DICOM file.
+
+        frame_filters : Iterable of FrameFilter
+            defines which frames inside the dataset should be ignored. If None then
+            `dicomwrappers.DEFAULT_FRAME_FILTERS` will be used.
         """
         Wrapper.__init__(self, dcm_data)
-        self.dcm_data = dcm_data
         self.frames = dcm_data.get('PerFrameFunctionalGroupsSequence')
         try:
             self.frames[0]
@@ -467,9 +666,59 @@ def __init__(self, dcm_data):
             self.shared = dcm_data.get('SharedFunctionalGroupsSequence')[0]
         except TypeError:
             raise WrapperError('SharedFunctionalGroupsSequence is empty.')
-        self._shape = None
-
-    @one_time
+        # Apply frame filters one at a time in the order provided
+        if frame_filters is None:
+            frame_filters = DEFUALT_FRAME_FILTERS
+        frame_filters = [filt for filt in frame_filters if filt.applies(self)]
+        for filt in frame_filters:
+            self.frames = [f for f in self.frames if filt.keep(f)]
+        # Make sure there is only one StackID remaining
+        first_fcs = self.frames[0].get('FrameContentSequence', (None,))[0]
+        if first_fcs is not None and hasattr(first_fcs, 'StackID'):
+            if len({frame.FrameContentSequence[0].StackID for frame in self.frames}) > 1:
+                raise WrapperError('More than one StackID remains after filtering')
+        # Try to determine slice order and minimal image position patient
+        self._frame_slc_ord = self._ipp = self._slice_spacing = None
+        try:
+            frame_ipps = [f.PlanePositionSequence[0].ImagePositionPatient for f in self.frames]
+        except AttributeError:
+            try:
+                frame_ipps = [self.shared.PlanePositionSequence[0].ImagePositionPatient]
+            except AttributeError:
+                frame_ipps = None
+        if frame_ipps is not None and all(ipp is not None for ipp in frame_ipps):
+            frame_ipps = [np.array(list(map(float, ipp))) for ipp in frame_ipps]
+            frame_slc_pos = [np.inner(ipp, self.slice_normal) for ipp in frame_ipps]
+            rnd_slc_pos = np.round(frame_slc_pos, 4)
+            uniq_slc_pos = np.unique(rnd_slc_pos)
+            pos_ord_map = dict(zip(uniq_slc_pos, np.argsort(uniq_slc_pos)))
+            self._frame_slc_ord = [pos_ord_map[pos] for pos in rnd_slc_pos]
+            if len(self._frame_slc_ord) > 1:
+                self._slice_spacing = (
+                    frame_slc_pos[self._frame_slc_ord[1]] - frame_slc_pos[self._frame_slc_ord[0]]
+                )
+            self._ipp = frame_ipps[np.argmin(frame_slc_pos)]
+        self._frame_indices = None
+
+    @cached_property
+    def vendor(self):
+        """The vendor of the instrument that produced the DICOM"""
+        vendor = super().vendor
+        if vendor is not None:
+            return vendor
+        vendor = vendor_from_private(self.shared)
+        if vendor is not None:
+            return vendor
+        return vendor_from_private(self.frames[0])
+
+    @cached_property
+    def frame_order(self):
+        """The ordering of frames to make nD array"""
+        if self._frame_indices is None:
+            _ = self.image_shape
+        return np.lexsort(self._frame_indices.T)
+
+    @cached_property
     def image_shape(self):
         """The array shape as it will be returned by ``get_data()``
 
@@ -500,73 +749,102 @@ def image_shape(self):
         rows, cols = self.get('Rows'), self.get('Columns')
         if None in (rows, cols):
             raise WrapperError('Rows and/or Columns are empty.')
-
-        # Check number of frames
-        first_frame = self.frames[0]
-        n_frames = self.get('NumberOfFrames')
-        # some Philips may have derived images appended
-        has_derived = False
-        if hasattr(first_frame, 'get') and first_frame.get([0x18, 0x9117]):
-            # DWI image may include derived isotropic, ADC or trace volume
-            try:
-                self.frames = pydicom.Sequence(
-                    frame
-                    for frame in self.frames
-                    if frame.MRDiffusionSequence[0].DiffusionDirectionality != 'ISOTROPIC'
-                )
-            except IndexError:
-                # Sequence tag is found but missing items!
-                raise WrapperError('Diffusion file missing information')
-            except AttributeError:
-                # DiffusionDirectionality tag is not required
-                pass
-            else:
-                if n_frames != len(self.frames):
-                    warnings.warn('Derived images found and removed')
-                    n_frames = len(self.frames)
-                    has_derived = True
-
-        assert len(self.frames) == n_frames
-        frame_indices = np.array(
-            [frame.FrameContentSequence[0].DimensionIndexValues for frame in self.frames]
-        )
-        # Check that there is only one multiframe stack index
-        stack_ids = {frame.FrameContentSequence[0].StackID for frame in self.frames}
-        if len(stack_ids) > 1:
-            raise WrapperError(
-                'File contains more than one StackID. Cannot handle multi-stack files'
+        # Check number of frames and handle single frame files
+        n_frames = len(self.frames)
+        if n_frames == 1:
+            self._frame_indices = np.array([[0]], dtype=np.int64)
+            return (rows, cols)
+        # Initialize array of frame indices
+        try:
+            frame_indices = np.array(
+                [frame.FrameContentSequence[0].DimensionIndexValues for frame in self.frames]
             )
-        # Determine if one of the dimension indices refers to the stack id
+        except AttributeError:
+            raise WrapperError("Can't find frame 'DimensionIndexValues'")
+        if len(frame_indices.shape) == 1:
+            frame_indices = frame_indices.reshape(frame_indices.shape + (1,))
+        # Determine the shape and which indices to use
+        shape = [rows, cols]
+        curr_parts = n_frames
+        frames_per_part = 1
+        del_indices = {}
         dim_seq = [dim.DimensionIndexPointer for dim in self.get('DimensionIndexSequence')]
-        stackid_tag = pydicom.datadict.tag_for_keyword('StackID')
-        # remove the stack id axis if present
-        if stackid_tag in dim_seq:
-            stackid_dim_idx = dim_seq.index(stackid_tag)
-            frame_indices = np.delete(frame_indices, stackid_dim_idx, axis=1)
-            dim_seq.pop(stackid_dim_idx)
-        if has_derived:
-            # derived volume is included
-            derived_tag = pydicom.datadict.tag_for_keyword('DiffusionBValue')
-            if derived_tag not in dim_seq:
-                raise WrapperError('Missing information, cannot remove indices with confidence.')
-            derived_dim_idx = dim_seq.index(derived_tag)
-            frame_indices = np.delete(frame_indices, derived_dim_idx, axis=1)
-        # account for the 2 additional dimensions (row and column) not included
-        # in the indices
-        n_dim = frame_indices.shape[1] + 2
+        stackpos_tag = pydicom.datadict.tag_for_keyword('InStackPositionNumber')
+        slice_dim_idx = dim_seq.index(stackpos_tag)
+        for row_idx, row in enumerate(frame_indices.T):
+            unique = np.unique(row)
+            count = len(unique)
+            if curr_parts == 1 or (count == 1 and row_idx != slice_dim_idx):
+                del_indices[row_idx] = count
+                continue
+            # Replace slice indices with order determined from slice positions along normal
+            if row_idx == slice_dim_idx:
+                if len(shape) > 2:
+                    raise WrapperError('Non-singular index precedes the slice index')
+                row = self._frame_slc_ord
+                frame_indices.T[row_idx, :] = row
+                unique = np.unique(row)
+                if len(unique) != count:
+                    raise WrapperError("Number of slice indices and positions don't match")
+            elif count == n_frames:
+                if shape[-1] == 'remaining':
+                    raise WrapperError('At most one index have ambiguous size')
+                shape.append('remaining')
+                continue
+            new_parts, leftover = divmod(curr_parts, count)
+            expected = new_parts * frames_per_part
+            if leftover != 0 or any(np.count_nonzero(row == val) != expected for val in unique):
+                if row_idx == slice_dim_idx:
+                    raise WrapperError('Missing slices from multiframe')
+                del_indices[row_idx] = count
+                continue
+            if shape[-1] == 'remaining':
+                shape[-1] = new_parts
+                frames_per_part *= shape[-1]
+                new_parts = 1
+            frames_per_part *= count
+            shape.append(count)
+            curr_parts = new_parts
+        if shape[-1] == 'remaining':
+            if curr_parts > 1:
+                shape[-1] = curr_parts
+                curr_parts = 1
+            else:
+                del_indices[len(shape)] = 1
+                shape = shape[:-1]
+        if del_indices:
+            if curr_parts > 1:
+                ns_failed = [k for k, v in del_indices.items() if v != 1]
+                if len(ns_failed) > 1:
+                    # If some indices weren't used yet but we still have unaccounted for
+                    # partitions, try combining indices into single tuple and using that
+                    tup_dtype = np.dtype(','.join(['I'] * len(ns_failed)))
+                    row = [tuple(x for x in vals) for vals in frame_indices[:, ns_failed]]
+                    row = np.array(row, dtype=tup_dtype)
+            frame_indices = np.delete(frame_indices, np.array(list(del_indices.keys())), axis=1)
+            if curr_parts > 1 and len(ns_failed) > 1:
+                unique = np.unique(row, axis=0)
+                count = len(unique)
+                new_parts, rem = divmod(curr_parts, count)
+                allowed_val_counts = [new_parts * frames_per_part, n_frames]
+                if rem == 0 and all(
+                    np.count_nonzero(row == val) in allowed_val_counts for val in unique
+                ):
+                    shape.append(count)
+                    curr_parts = new_parts
+                    ord_vals = np.argsort(unique)
+                    order = {tuple(unique[i]): ord_vals[i] for i in range(count)}
+                    ord_row = np.array([order[tuple(v)] for v in row])
+                    frame_indices = np.hstack(
+                        [frame_indices, np.array(ord_row).reshape((n_frames, 1))]
+                    )
+        if curr_parts > 1:
+            raise WrapperError('Unable to determine sorting of final dimension(s)')
         # Store frame indices
         self._frame_indices = frame_indices
-        if n_dim < 4:  # 3D volume
-            return rows, cols, n_frames
-        # More than 3 dimensions
-        ns_unique = [len(np.unique(row)) for row in self._frame_indices.T]
-        shape = (rows, cols) + tuple(ns_unique)
-        n_vols = np.prod(shape[3:])
-        if n_frames != n_vols * shape[2]:
-            raise WrapperError('Calculated shape does not match number of frames.')
         return tuple(shape)
 
-    @one_time
+    @cached_property
     def image_orient_patient(self):
         """
         Note that this is _not_ LR flipped
@@ -583,7 +861,7 @@ def image_orient_patient(self):
         iop = np.array(list(map(float, iop)))
         return np.array(iop).reshape(2, 3).T
 
-    @one_time
+    @cached_property
     def voxel_sizes(self):
         """Get i, j, k voxel sizes"""
         try:
@@ -594,29 +872,25 @@ def voxel_sizes(self):
             except AttributeError:
                 raise WrapperError('Not enough data for pixel spacing')
         pix_space = pix_measures.PixelSpacing
-        try:
-            zs = pix_measures.SliceThickness
-        except AttributeError:
-            zs = self.get('SpacingBetweenSlices')
-            if zs is None:
-                raise WrapperError('Not enough data for slice thickness')
+        if self._slice_spacing is not None:
+            zs = self._slice_spacing
+        else:
+            try:
+                zs = pix_measures.SliceThickness
+            except AttributeError:
+                zs = self.get('SpacingBetweenSlices')
+                if zs is None:
+                    raise WrapperError('Not enough data for slice thickness')
         # Ensure values are float rather than Decimal
         return tuple(map(float, list(pix_space) + [zs]))
 
-    @one_time
+    @property
     def image_position(self):
-        try:
-            ipp = self.shared.PlanePositionSequence[0].ImagePositionPatient
-        except AttributeError:
-            try:
-                ipp = self.frames[0].PlanePositionSequence[0].ImagePositionPatient
-            except AttributeError:
-                raise WrapperError('Cannot get image position from dicom')
-        if ipp is None:
-            return None
-        return np.array(list(map(float, ipp)))
+        if self._ipp is None:
+            raise WrapperError('Not enough information for image_position_patient')
+        return self._ipp
 
-    @one_time
+    @cached_property
     def series_signature(self):
         signature = {}
         eq = operator.eq
@@ -627,26 +901,63 @@ def series_signature(self):
         signature['vox'] = (self.voxel_sizes, none_or_close)
         return signature
 
-    def get_data(self):
+    @cached_property
+    def scale_factors(self):
+        """Return `(2, N)` array of slope/intercept pairs
+
+        If there is a single global scale factor then `N` will be one, otherwise it will
+        be the number of frames
+        """
+        # Look for shared / global RWV scale factor first
+        shared_scale = self._get_rwv_scale_factor(self.shared)
+        if shared_scale is not None:
+            return np.array([shared_scale])
+        shared_scale = self._get_rwv_scale_factor(self.dcm_data)
+        if shared_scale is not None:
+            return np.array([shared_scale])
+        # Try pulling out best scale factors from each individual frame
+        frame_scales = [self._get_best_scale_factor(f) for f in self.frames]
+        if any(s is not None for s in frame_scales):
+            if any(s is None for s in frame_scales):
+                if self.vendor == Vendor.PHILIPS:
+                    warnings.warn(
+                        'Unable to find Philips private scale factor, cross-series comparisons may be invalid'
+                    )
+                frame_scales = [s if s is not None else (1, 0) for s in frame_scales]
+            if all(s == frame_scales[0] for s in frame_scales[1:]):
+                return np.array([frame_scales[0]])
+            return np.array(frame_scales)[self.frame_order]
+        # Finally look for shared non-RWV scale factors
+        shared_scale = self._get_best_scale_factor(self.shared)
+        if shared_scale is not None:
+            return np.array([shared_scale])
+        shared_scale = self._get_best_scale_factor(self.dcm_data)
+        if shared_scale is None:
+            if self.vendor == Vendor.PHILIPS:
+                warnings.warn(
+                    'Unable to find Philips private scale factor, cross-series comparisons may be invalid'
+                )
+            shared_scale = (1, 0)
+        return np.array([shared_scale])
+
+    def get_unscaled_data(self):
         shape = self.image_shape
         if shape is None:
             raise WrapperError('No valid information for image shape')
         data = self.get_pixel_array()
-        # Roll frames axis to last
-        data = data.transpose((1, 2, 0))
-        # Sort frames with first index changing fastest, last slowest
-        sorted_indices = np.lexsort(self._frame_indices.T)
-        data = data[..., sorted_indices]
-        data = data.reshape(shape, order='F')
-        return self._scale_data(data)
+        # Roll frames axis to last and reorder
+        if len(data.shape) > 2:
+            data = data.transpose((1, 2, 0))[..., self.frame_order]
+        return data.reshape(shape, order='F')
 
     def _scale_data(self, data):
-        pix_trans = getattr(self.frames[0], 'PixelValueTransformationSequence', None)
-        if pix_trans is None:
-            return super()._scale_data(data)
-        scale = float(pix_trans[0].RescaleSlope)
-        offset = float(pix_trans[0].RescaleIntercept)
-        return self._apply_scale_offset(data, scale, offset)
+        scale_factors = self.scale_factors
+        if scale_factors.shape[0] == 1:
+            scale, offset = scale_factors[0]
+            return self._apply_scale_offset(data, scale, offset)
+        orig_shape = data.shape
+        data = data.reshape(data.shape[:2] + (len(self.frames),))
+        return (data * scale_factors[:, 0] + scale_factors[:, 1]).reshape(orig_shape)
 
 
 class SiemensWrapper(Wrapper):
@@ -673,7 +984,7 @@ def __init__(self, dcm_data, csa_header=None):
            object should allow 'get' and '__getitem__' access.  If `csa_header`
            is None, it should also be possible to extract a CSA header from
            `dcm_data`. Usually this will be a ``dicom.dataset.Dataset`` object
-           resulting from reading a DICOM file.  A dict should also work.
+           resulting from reading a DICOM file.
         csa_header : None or mapping, optional
            mapping giving values for Siemens CSA image sub-header.  If
            None, we try and read the CSA information from `dcm_data`.
@@ -689,7 +1000,12 @@ def __init__(self, dcm_data, csa_header=None):
                 csa_header = {}
         self.csa_header = csa_header
 
-    @one_time
+    @cached_property
+    def vendor(self):
+        """The vendor of the instrument that produced the DICOM"""
+        return Vendor.SIEMENS
+
+    @cached_property
     def slice_normal(self):
         # The std_slice_normal comes from the cross product of the directions
         # in the ImageOrientationPatient
@@ -713,7 +1029,7 @@ def slice_normal(self):
             else:
                 return std_slice_normal
 
-    @one_time
+    @cached_property
     def series_signature(self):
         """Add ICE dims from CSA header to signature"""
         signature = super().series_signature
@@ -723,7 +1039,7 @@ def series_signature(self):
         signature['ICE_Dims'] = (ice, operator.eq)
         return signature
 
-    @one_time
+    @cached_property
     def b_matrix(self):
         """Get DWI B matrix referring to voxel space
 
@@ -760,7 +1076,7 @@ def b_matrix(self):
         # semi-definite.
         return nearest_pos_semi_def(B_vox)
 
-    @one_time
+    @cached_property
     def q_vector(self):
         """Get DWI q vector referring to voxel space
 
@@ -833,7 +1149,7 @@ def __init__(self, dcm_data, csa_header=None, n_mosaic=None):
         self.n_mosaic = n_mosaic
         self.mosaic_size = int(np.ceil(np.sqrt(n_mosaic)))
 
-    @one_time
+    @cached_property
     def image_shape(self):
         """Return image shape as returned by ``get_data()``"""
         # reshape pixel slice array back from mosaic
@@ -843,7 +1159,7 @@ def image_shape(self):
             return None
         return (rows // self.mosaic_size, cols // self.mosaic_size, self.n_mosaic)
 
-    @one_time
+    @cached_property
     def image_position(self):
         """Return position of first voxel in data block
 
@@ -880,7 +1196,7 @@ def image_position(self):
         Q = np.fliplr(iop) * pix_spacing
         return ipp + np.dot(Q, vox_trans_fixes[:, None]).ravel()
 
-    def get_data(self):
+    def get_unscaled_data(self):
         """Get scaled image data from DICOMs
 
         Resorts data block from mosaic to 3D
@@ -923,8 +1239,7 @@ def get_data(self):
         # pool mosaic-generated dims
         v3 = v4.reshape((n_slice_rows, n_slice_cols, n_blocks))
         # delete any padding slices
-        v3 = v3[..., :n_mosaic]
-        return self._scale_data(v3)
+        return v3[..., :n_mosaic]
 
 
 def none_or_close(val1, val2, rtol=1e-5, atol=1e-6):
diff --git a/nibabel/nicom/dwiparams.py b/nibabel/nicom/dwiparams.py
index cb0e501202..5930e96f91 100644
--- a/nibabel/nicom/dwiparams.py
+++ b/nibabel/nicom/dwiparams.py
@@ -18,6 +18,7 @@
 
    B ~ (q_est . q_est.T) / norm(q_est)
 """
+
 import numpy as np
 import numpy.linalg as npl
 
diff --git a/nibabel/nicom/tests/test_ascconv.py b/nibabel/nicom/tests/test_ascconv.py
index cd27bc3192..afe5f05e13 100644
--- a/nibabel/nicom/tests/test_ascconv.py
+++ b/nibabel/nicom/tests/test_ascconv.py
@@ -1,11 +1,9 @@
-"""Testing Siemens "ASCCONV" parser
-"""
+"""Testing Siemens "ASCCONV" parser"""
 
 from collections import OrderedDict
 from os.path import dirname
 from os.path import join as pjoin
 
-import numpy as np
 from numpy.testing import assert_array_almost_equal, assert_array_equal
 
 from .. import ascconv
diff --git a/nibabel/nicom/tests/test_csareader.py b/nibabel/nicom/tests/test_csareader.py
index 0fc559c7fc..f31f4a3935 100644
--- a/nibabel/nicom/tests/test_csareader.py
+++ b/nibabel/nicom/tests/test_csareader.py
@@ -1,7 +1,6 @@
-"""Testing Siemens CSA header reader
-"""
+"""Testing Siemens CSA header reader"""
+
 import gzip
-import sys
 from copy import deepcopy
 from os.path import join as pjoin
 
diff --git a/nibabel/nicom/tests/test_dicomreaders.py b/nibabel/nicom/tests/test_dicomreaders.py
index 1e749aced1..d508343be1 100644
--- a/nibabel/nicom/tests/test_dicomreaders.py
+++ b/nibabel/nicom/tests/test_dicomreaders.py
@@ -1,5 +1,4 @@
-"""Testing reading DICOM files
-"""
+"""Testing reading DICOM files"""
 
 from os.path import join as pjoin
 
@@ -41,7 +40,7 @@ def test_passing_kwds():
         # This should not raise an error
         data2, aff2, bs2, gs2 = func(IO_DATA_PATH, dwi_glob, dicom_kwargs=dict(force=True))
         assert_array_equal(data, data2)
-        # This should raise an error in pydicom.dicomio.read_file
+        # This should raise an error in pydicom.filereader.dcmread
         with pytest.raises(TypeError):
             func(IO_DATA_PATH, dwi_glob, dicom_kwargs=dict(not_a_parameter=True))
         # These are invalid dicoms, so will raise an error unless force=True
diff --git a/nibabel/nicom/tests/test_dicomwrappers.py b/nibabel/nicom/tests/test_dicomwrappers.py
index 62076c042a..9f707b25e7 100755
--- a/nibabel/nicom/tests/test_dicomwrappers.py
+++ b/nibabel/nicom/tests/test_dicomwrappers.py
@@ -1,8 +1,7 @@
-"""Testing DICOM wrappers
-"""
+"""Testing DICOM wrappers"""
 
 import gzip
-from copy import copy
+from copy import deepcopy
 from decimal import Decimal
 from hashlib import sha1
 from os.path import dirname
@@ -23,8 +22,8 @@
 DATA_FILE = pjoin(IO_DATA_PATH, 'siemens_dwi_1000.dcm.gz')
 DATA_FILE_PHILIPS = pjoin(IO_DATA_PATH, 'philips_mprage.dcm.gz')
 if have_dicom:
-    DATA = pydicom.read_file(gzip.open(DATA_FILE))
-    DATA_PHILIPS = pydicom.read_file(gzip.open(DATA_FILE_PHILIPS))
+    DATA = pydicom.dcmread(gzip.open(DATA_FILE))
+    DATA_PHILIPS = pydicom.dcmread(gzip.open(DATA_FILE_PHILIPS))
 else:
     DATA = None
     DATA_PHILIPS = None
@@ -35,6 +34,11 @@
 DATA_FILE_EMPTY_ST = pjoin(IO_DATA_PATH, 'slicethickness_empty_string.dcm')
 DATA_FILE_4D_DERIVED = pjoin(get_nibabel_data(), 'nitest-dicom', '4d_multiframe_with_derived.dcm')
 DATA_FILE_CT = pjoin(get_nibabel_data(), 'nitest-dicom', 'siemens_ct_header_csa.dcm')
+DATA_FILE_SIEMENS_TRACE = pjoin(
+    get_nibabel_data(),
+    'dcm_qa_xa30',
+    'In/20_DWI_dir80_AP/0001_1.3.12.2.1107.5.2.43.67093.2022071112140611403312307.dcm',
+)
 
 # This affine from our converted image was shown to match our image spatially
 # with an image from SPM DICOM conversion. We checked the matching with SPM
@@ -59,8 +63,8 @@ def test_wrappers():
     # test direct wrapper calls
     # first with empty or minimal data
     multi_minimal = {
-        'PerFrameFunctionalGroupsSequence': [None],
-        'SharedFunctionalGroupsSequence': [None],
+        'PerFrameFunctionalGroupsSequence': [pydicom.Dataset()],
+        'SharedFunctionalGroupsSequence': [pydicom.Dataset()],
     }
     for maker, args in (
         (didw.Wrapper, ({},)),
@@ -159,10 +163,10 @@ def test_wrapper_from_data():
     fake_data['SOPClassUID'] = '1.2.840.10008.5.1.4.1.1.4.1'
     with pytest.raises(didw.WrapperError):
         didw.wrapper_from_data(fake_data)
-    fake_data['PerFrameFunctionalGroupsSequence'] = [None]
+    fake_data['PerFrameFunctionalGroupsSequence'] = [pydicom.Dataset()]
     with pytest.raises(didw.WrapperError):
         didw.wrapper_from_data(fake_data)
-    fake_data['SharedFunctionalGroupsSequence'] = [None]
+    fake_data['SharedFunctionalGroupsSequence'] = [pydicom.Dataset()]
     # minimal set should now be met
     dw = didw.wrapper_from_data(fake_data)
     assert dw.is_multiframe
@@ -170,7 +174,7 @@ def test_wrapper_from_data():
 
 @dicom_test
 def test_wrapper_args_kwds():
-    # Test we can pass args, kwargs to read_file
+    # Test we can pass args, kwargs to dcmread
     dcm = didw.wrapper_from_file(DATA_FILE)
     data = dcm.get_data()
     # Passing in non-default arg for defer_size
@@ -360,7 +364,7 @@ def test_decimal_rescale():
     assert dw.get_data().dtype != np.dtype(object)
 
 
-def fake_frames(seq_name, field_name, value_seq):
+def fake_frames(seq_name, field_name, value_seq, frame_seq=None):
     """Make fake frames for multiframe testing
 
     Parameters
@@ -371,6 +375,8 @@ def fake_frames(seq_name, field_name, value_seq):
         name of field within sequence
     value_seq : length N sequence
         sequence of values
+    frame_seq : length N list
+        previous result from this function to update
 
     Returns
     -------
@@ -378,23 +384,33 @@ def fake_frames(seq_name, field_name, value_seq):
         each element in list is obj.<seq_name>[0].<field_name> =
         value_seq[n] for n in range(N)
     """
-
-    class Fake:
-        pass
-
-    frames = []
-    for value in value_seq:
-        fake_frame = Fake()
-        fake_element = Fake()
+    if frame_seq is None:
+        frame_seq = [pydicom.Dataset() for _ in range(len(value_seq))]
+    for value, fake_frame in zip(value_seq, frame_seq):
+        if value is None:
+            continue
+        if hasattr(fake_frame, seq_name):
+            fake_element = getattr(fake_frame, seq_name)[0]
+        else:
+            fake_element = pydicom.Dataset()
+            setattr(fake_frame, seq_name, [fake_element])
         setattr(fake_element, field_name, value)
-        setattr(fake_frame, seq_name, [fake_element])
-        frames.append(fake_frame)
-    return frames
+    return frame_seq
 
 
-def fake_shape_dependents(div_seq, sid_seq=None, sid_dim=None):
+def fake_shape_dependents(
+    div_seq,
+    sid_seq=None,
+    sid_dim=None,
+    ipp_seq=None,
+    slice_dim=None,
+    flip_ipp_idx_corr=False,
+):
     """Make a fake dictionary of data that ``image_shape`` is dependent on.
 
+    If you are providing the ``ipp_seq`` argument, they should be generated using
+    a slice normal aligned with the z-axis (i.e. iop == (0, 1, 0, 1, 0, 0)).
+
     Parameters
     ----------
     div_seq : list of tuples
@@ -403,39 +419,85 @@ def fake_shape_dependents(div_seq, sid_seq=None, sid_dim=None):
         list of values to use for the `StackID` of each frame.
     sid_dim : int
         the index of the column in 'div_seq' to use as 'sid_seq'
+    ipp_seq : list of tuples
+        list of values to use for `ImagePositionPatient` for each frame
+    slice_dim : int
+        the index of the column in 'div_seq' corresponding to slices
+    flip_ipp_idx_corr : bool
+        generate ipp values so slice location is negatively correlated with slice index
     """
 
-    class DimIdxSeqElem:
+    class DimIdxSeqElem(pydicom.Dataset):
         def __init__(self, dip=(0, 0), fgp=None):
+            super().__init__()
             self.DimensionIndexPointer = dip
             if fgp is not None:
                 self.FunctionalGroupPointer = fgp
 
-    class FrmContSeqElem:
-        def __init__(self, div, sid):
-            self.DimensionIndexValues = div
-            self.StackID = sid
-
-    class PerFrmFuncGrpSeqElem:
+    class FrmContSeqElem(pydicom.Dataset):
         def __init__(self, div, sid):
+            super().__init__()
+            self.DimensionIndexValues = list(div)
+            self.StackID = str(sid)
+
+    class PlnPosSeqElem(pydicom.Dataset):
+        def __init__(self, ipp):
+            super().__init__()
+            self.ImagePositionPatient = ipp
+
+    class PlnOrientSeqElem(pydicom.Dataset):
+        def __init__(self, iop):
+            super().__init__()
+            self.ImageOrientationPatient = iop
+
+    class PerFrmFuncGrpSeqElem(pydicom.Dataset):
+        def __init__(self, div, sid, ipp, iop):
+            super().__init__()
             self.FrameContentSequence = [FrmContSeqElem(div, sid)]
+            self.PlanePositionSequence = [PlnPosSeqElem(ipp)]
+            self.PlaneOrientationSequence = [PlnOrientSeqElem(iop)]
 
     # if no StackID values passed in then use the values at index 'sid_dim' in
     # the value for DimensionIndexValues for it
+    n_indices = len(div_seq[0])
     if sid_seq is None:
         if sid_dim is None:
             sid_dim = 0
         sid_seq = [div[sid_dim] for div in div_seq]
-    # create the DimensionIndexSequence
+    # Determine slice_dim and create per-slice ipp information
+    if slice_dim is None:
+        slice_dim = 1 if sid_dim == 0 else 0
     num_of_frames = len(div_seq)
-    dim_idx_seq = [DimIdxSeqElem()] * num_of_frames
+    frame_slc_indices = np.array(div_seq)[:, slice_dim]
+    uniq_slc_indices = np.unique(frame_slc_indices)
+    n_slices = len(uniq_slc_indices)
+    iop_seq = [[0.0, 1.0, 0.0, 1.0, 0.0, 0.0] for _ in range(num_of_frames)]
+    if ipp_seq is None:
+        slc_locs = np.linspace(-1.0, 1.0, n_slices)
+        if flip_ipp_idx_corr:
+            slc_locs = slc_locs[::-1]
+        slc_idx_loc = {
+            div_idx: slc_locs[arr_idx] for arr_idx, div_idx in enumerate(np.sort(uniq_slc_indices))
+        }
+        ipp_seq = [[-1.0, -1.0, slc_idx_loc[idx]] for idx in frame_slc_indices]
+    else:
+        assert flip_ipp_idx_corr is False  # caller can flip it themselves
+        assert len(ipp_seq) == num_of_frames
+    # create the DimensionIndexSequence
+    dim_idx_seq = [DimIdxSeqElem()] * n_indices
+    # Add entry for InStackPositionNumber to DimensionIndexSequence
+    fcs_tag = pydicom.datadict.tag_for_keyword('FrameContentSequence')
+    isp_tag = pydicom.datadict.tag_for_keyword('InStackPositionNumber')
+    dim_idx_seq[slice_dim] = DimIdxSeqElem(isp_tag, fcs_tag)
     # add an entry for StackID into the DimensionIndexSequence
     if sid_dim is not None:
         sid_tag = pydicom.datadict.tag_for_keyword('StackID')
-        fcs_tag = pydicom.datadict.tag_for_keyword('FrameContentSequence')
         dim_idx_seq[sid_dim] = DimIdxSeqElem(sid_tag, fcs_tag)
     # create the PerFrameFunctionalGroupsSequence
-    frames = [PerFrmFuncGrpSeqElem(div, sid) for div, sid in zip(div_seq, sid_seq)]
+    frames = [
+        PerFrmFuncGrpSeqElem(div, sid, ipp, iop)
+        for div, sid, ipp, iop in zip(div_seq, sid_seq, ipp_seq, iop_seq)
+    ]
     return {
         'NumberOfFrames': num_of_frames,
         'DimensionIndexSequence': dim_idx_seq,
@@ -443,48 +505,106 @@ def __init__(self, div, sid):
     }
 
 
+if have_dicom:
+
+    class FakeDataset(pydicom.Dataset):
+        pixel_array = None
+
+
 class TestMultiFrameWrapper(TestCase):
     # Test MultiframeWrapper
-    MINIMAL_MF = {
+
+    if have_dicom:
         # Minimal contents of dcm_data for this wrapper
-        'PerFrameFunctionalGroupsSequence': [None],
-        'SharedFunctionalGroupsSequence': [None],
-    }
-    WRAPCLASS = didw.MultiframeWrapper
+        MINIMAL_MF = FakeDataset()
+        MINIMAL_MF.PerFrameFunctionalGroupsSequence = [pydicom.Dataset()]
+        MINIMAL_MF.SharedFunctionalGroupsSequence = [pydicom.Dataset()]
+        WRAPCLASS = didw.MultiframeWrapper
 
     @dicom_test
     def test_shape(self):
         # Check the shape algorithm
-        fake_mf = copy(self.MINIMAL_MF)
+        fake_mf = deepcopy(self.MINIMAL_MF)
         MFW = self.WRAPCLASS
         dw = MFW(fake_mf)
         # No rows, cols, raise WrapperError
         with pytest.raises(didw.WrapperError):
             dw.image_shape
-        fake_mf['Rows'] = 64
+        fake_mf.Rows = 64
         with pytest.raises(didw.WrapperError):
             dw.image_shape
         fake_mf.pop('Rows')
-        fake_mf['Columns'] = 64
+        fake_mf.Columns = 64
         with pytest.raises(didw.WrapperError):
             dw.image_shape
-        fake_mf['Rows'] = 32
-        # Missing frame data, raise AssertionError
-        with pytest.raises(AssertionError):
-            dw.image_shape
-        fake_mf['NumberOfFrames'] = 4
-        # PerFrameFunctionalGroupsSequence does not match NumberOfFrames
-        with pytest.raises(AssertionError):
-            dw.image_shape
-        # check 3D shape when StackID index is 0
+        fake_mf.Rows = 32
+        # Single frame doesn't need dimension index values
+        assert dw.image_shape == (32, 64)
+        assert len(dw.frame_order) == 1
+        assert dw.frame_order[0] == 0
+        # Multiple frames do require dimension index values
+        fake_mf.PerFrameFunctionalGroupsSequence = [pydicom.Dataset(), pydicom.Dataset()]
+        with pytest.raises(didw.WrapperError):
+            MFW(fake_mf).image_shape
+        # check 2D shape with StackID index is 0
+        div_seq = ((1, 1),)
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        dw = MFW(fake_mf)
+        assert dw.image_shape == (32, 64)
+        assert len(dw.frame_order) == 1
+        assert dw.frame_order[0] == 0
+        # Check 2D shape with extraneous extra indices
+        div_seq = ((1, 1, 2),)
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        dw = MFW(fake_mf)
+        assert dw.image_shape == (32, 64)
+        assert len(dw.frame_order) == 1
+        assert dw.frame_order[0] == 0
+        # Check 2D plus time
+        div_seq = ((1, 1, 1), (1, 1, 2), (1, 1, 3))
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        assert MFW(fake_mf).image_shape == (32, 64, 1, 3)
+        # Check 3D shape when StackID index is 0
         div_seq = ((1, 1), (1, 2), (1, 3), (1, 4))
         fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
         assert MFW(fake_mf).image_shape == (32, 64, 4)
-        # Check stack number matching when StackID index is 0
+        # Check fow warning when implicitly dropping stacks
         div_seq = ((1, 1), (1, 2), (1, 3), (2, 4))
         fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        with pytest.warns(
+            UserWarning,
+            match='A multi-stack file was passed without an explicit filter,',
+        ):
+            assert MFW(fake_mf).image_shape == (32, 64, 3)
+        # No warning if we expclitly select that StackID to keep
+        assert MFW(fake_mf, frame_filters=(didw.FilterMultiStack(1),)).image_shape == (32, 64, 3)
+        assert MFW(fake_mf, frame_filters=(didw.FilterMultiStack(2),)).image_shape == (32, 64)
+        # Stack filtering is the same when StackID is not an index
+        div_seq = ((1,), (2,), (3,), (4,))
+        sid_seq = (1, 1, 1, 2)
+        fake_mf.update(fake_shape_dependents(div_seq, sid_seq=sid_seq))
+        with pytest.warns(
+            UserWarning,
+            match='A multi-stack file was passed without an explicit filter,',
+        ):
+            assert MFW(fake_mf).image_shape == (32, 64, 3)
+        # No warning if we expclitly select that StackID to keep
+        assert MFW(fake_mf, frame_filters=(didw.FilterMultiStack(1),)).image_shape == (32, 64, 3)
+        assert MFW(fake_mf, frame_filters=(didw.FilterMultiStack(2),)).image_shape == (32, 64)
+        # Check for error when explicitly requested StackID is missing
         with pytest.raises(didw.WrapperError):
-            MFW(fake_mf).image_shape
+            MFW(fake_mf, frame_filters=(didw.FilterMultiStack(3),))
+        # StackID can be a string
+        div_seq = ((1,), (2,), (3,), (4,))
+        sid_seq = ('a', 'a', 'a', 'b')
+        fake_mf.update(fake_shape_dependents(div_seq, sid_seq=sid_seq))
+        with pytest.warns(
+            UserWarning,
+            match='A multi-stack file was passed without an explicit filter,',
+        ):
+            assert MFW(fake_mf).image_shape == (32, 64, 3)
+        assert MFW(fake_mf, frame_filters=(didw.FilterMultiStack('a'),)).image_shape == (32, 64, 3)
+        assert MFW(fake_mf, frame_filters=(didw.FilterMultiStack('b'),)).image_shape == (32, 64)
         # Make some fake frame data for 4D when StackID index is 0
         div_seq = ((1, 1, 1), (1, 2, 1), (1, 1, 2), (1, 2, 2), (1, 1, 3), (1, 2, 3))
         fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
@@ -492,8 +612,12 @@ def test_shape(self):
         # Check stack number matching for 4D when StackID index is 0
         div_seq = ((1, 1, 1), (1, 2, 1), (1, 1, 2), (1, 2, 2), (1, 1, 3), (2, 2, 3))
         fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
-        with pytest.raises(didw.WrapperError):
-            MFW(fake_mf).image_shape
+        with pytest.warns(
+            UserWarning,
+            match='A multi-stack file was passed without an explicit filter,',
+        ):
+            with pytest.raises(didw.WrapperError):
+                MFW(fake_mf).image_shape
         # Check indices can be non-contiguous when StackID index is 0
         div_seq = ((1, 1, 1), (1, 2, 1), (1, 1, 3), (1, 2, 3))
         fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
@@ -502,17 +626,22 @@ def test_shape(self):
         div_seq = ((1, 1, 0), (1, 2, 0), (1, 1, 3), (1, 2, 3))
         fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
         assert MFW(fake_mf).image_shape == (32, 64, 2, 2)
+        # Check number of IPP vals match the number of slices or we raise
+        frames = fake_mf.PerFrameFunctionalGroupsSequence
+        for frame in frames[1:]:
+            frame.PlanePositionSequence = frames[0].PlanePositionSequence[:]
+        with pytest.raises(didw.WrapperError):
+            MFW(fake_mf).image_shape
+        # Check we raise on missing slices
+        div_seq = ((1, 1, 0), (1, 2, 0), (1, 1, 1))
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        with pytest.raises(didw.WrapperError):
+            MFW(fake_mf).image_shape
         # check 3D shape when there is no StackID index
         div_seq = ((1,), (2,), (3,), (4,))
         sid_seq = (1, 1, 1, 1)
         fake_mf.update(fake_shape_dependents(div_seq, sid_seq=sid_seq))
         assert MFW(fake_mf).image_shape == (32, 64, 4)
-        # check 3D stack number matching when there is no StackID index
-        div_seq = ((1,), (2,), (3,), (4,))
-        sid_seq = (1, 1, 1, 2)
-        fake_mf.update(fake_shape_dependents(div_seq, sid_seq=sid_seq))
-        with pytest.raises(didw.WrapperError):
-            MFW(fake_mf).image_shape
         # check 4D shape when there is no StackID index
         div_seq = ((1, 1), (2, 1), (1, 2), (2, 2), (1, 3), (2, 3))
         sid_seq = (1, 1, 1, 1, 1, 1)
@@ -522,8 +651,12 @@ def test_shape(self):
         div_seq = ((1, 1), (2, 1), (1, 2), (2, 2), (1, 3), (2, 3))
         sid_seq = (1, 1, 1, 1, 1, 2)
         fake_mf.update(fake_shape_dependents(div_seq, sid_seq=sid_seq))
-        with pytest.raises(didw.WrapperError):
-            MFW(fake_mf).image_shape
+        with pytest.warns(
+            UserWarning,
+            match='A multi-stack file was passed without an explicit filter,',
+        ):
+            with pytest.raises(didw.WrapperError):
+                MFW(fake_mf).image_shape
         # check 3D shape when StackID index is 1
         div_seq = ((1, 1), (2, 1), (3, 1), (4, 1))
         fake_mf.update(fake_shape_dependents(div_seq, sid_dim=1))
@@ -531,16 +664,82 @@ def test_shape(self):
         # Check stack number matching when StackID index is 1
         div_seq = ((1, 1), (2, 1), (3, 2), (4, 1))
         fake_mf.update(fake_shape_dependents(div_seq, sid_dim=1))
-        with pytest.raises(didw.WrapperError):
-            MFW(fake_mf).image_shape
+        with pytest.warns(
+            UserWarning,
+            match='A multi-stack file was passed without an explicit filter,',
+        ):
+            assert MFW(fake_mf).image_shape == (32, 64, 3)
         # Make some fake frame data for 4D when StackID index is 1
         div_seq = ((1, 1, 1), (2, 1, 1), (1, 1, 2), (2, 1, 2), (1, 1, 3), (2, 1, 3))
         fake_mf.update(fake_shape_dependents(div_seq, sid_dim=1))
         assert MFW(fake_mf).image_shape == (32, 64, 2, 3)
+        # Check non-singular dimension preceding slice dim raises
+        div_seq = ((1, 1, 1), (1, 2, 1), (1, 1, 2), (1, 2, 2), (1, 1, 3), (1, 2, 3))
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0, slice_dim=2))
+        with pytest.raises(didw.WrapperError):
+            MFW(fake_mf).image_shape
+        # Test with combo indices, here with the last two needing to be combined into
+        # a single index corresponding to [(1, 1), (1, 1), (2, 1), (2, 1), (2, 2), (2, 2)]
+        div_seq = (
+            (1, 1, 1, 1),
+            (1, 2, 1, 1),
+            (1, 1, 2, 1),
+            (1, 2, 2, 1),
+            (1, 1, 2, 2),
+            (1, 2, 2, 2),
+        )
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        assert MFW(fake_mf).image_shape == (32, 64, 2, 3)
+        # Test invalid 4D indices
+        div_seq = ((1, 1, 1), (1, 2, 1), (1, 1, 2), (1, 2, 2), (1, 1, 3), (1, 2, 4))
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        with pytest.raises(didw.WrapperError):
+            MFW(fake_mf).image_shape
+        div_seq = ((1, 1, 1), (1, 2, 1), (1, 1, 2), (1, 2, 2), (1, 1, 3), (1, 2, 2))
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        with pytest.raises(didw.WrapperError):
+            MFW(fake_mf).image_shape
+        # Time index that is unique to each frame
+        div_seq = ((1, 1, 1), (1, 2, 2), (1, 1, 3), (1, 2, 4), (1, 1, 5), (1, 2, 6))
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        assert MFW(fake_mf).image_shape == (32, 64, 2, 3)
+        div_seq = (
+            (1, 1, 1, 1),
+            (1, 2, 2, 1),
+            (1, 1, 3, 1),
+            (1, 2, 4, 1),
+            (1, 1, 5, 1),
+            (1, 2, 6, 1),
+            (1, 1, 7, 2),
+            (1, 2, 8, 2),
+            (1, 1, 9, 2),
+            (1, 2, 10, 2),
+            (1, 1, 11, 2),
+            (1, 2, 12, 2),
+        )
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        assert MFW(fake_mf).image_shape == (32, 64, 2, 3, 2)
+        # Check we only allow one extra spatial dimension with unique val per frame
+        div_seq = (
+            (1, 1, 1, 6),
+            (1, 2, 2, 5),
+            (1, 1, 3, 4),
+            (1, 2, 4, 3),
+            (1, 1, 5, 2),
+            (1, 2, 6, 1),
+        )
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        with pytest.raises(didw.WrapperError):
+            MFW(fake_mf).image_shape
+        # Check that having unique value per frame works with single volume
+        div_seq = ((1, 1, 1), (1, 2, 2), (1, 3, 3))
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        assert MFW(fake_mf).image_shape == (32, 64, 3)
 
+    @dicom_test
     def test_iop(self):
         # Test Image orient patient for multiframe
-        fake_mf = copy(self.MINIMAL_MF)
+        fake_mf = deepcopy(self.MINIMAL_MF)
         MFW = self.WRAPCLASS
         dw = MFW(fake_mf)
         with pytest.raises(didw.WrapperError):
@@ -549,84 +748,94 @@ def test_iop(self):
         fake_frame = fake_frames(
             'PlaneOrientationSequence', 'ImageOrientationPatient', [[0, 1, 0, 1, 0, 0]]
         )[0]
-        fake_mf['SharedFunctionalGroupsSequence'] = [fake_frame]
+        fake_mf.SharedFunctionalGroupsSequence = [fake_frame]
         assert_array_equal(MFW(fake_mf).image_orient_patient, [[0, 1], [1, 0], [0, 0]])
-        fake_mf['SharedFunctionalGroupsSequence'] = [None]
+        fake_mf.SharedFunctionalGroupsSequence = [pydicom.Dataset()]
         with pytest.raises(didw.WrapperError):
             MFW(fake_mf).image_orient_patient
-        fake_mf['PerFrameFunctionalGroupsSequence'] = [fake_frame]
+        fake_mf.PerFrameFunctionalGroupsSequence = [fake_frame]
         assert_array_equal(MFW(fake_mf).image_orient_patient, [[0, 1], [1, 0], [0, 0]])
 
+    @dicom_test
     def test_voxel_sizes(self):
         # Test voxel size calculation
-        fake_mf = copy(self.MINIMAL_MF)
+        fake_mf = deepcopy(self.MINIMAL_MF)
         MFW = self.WRAPCLASS
         dw = MFW(fake_mf)
         with pytest.raises(didw.WrapperError):
             dw.voxel_sizes
         # Make a fake frame
         fake_frame = fake_frames('PixelMeasuresSequence', 'PixelSpacing', [[2.1, 3.2]])[0]
-        fake_mf['SharedFunctionalGroupsSequence'] = [fake_frame]
+        fake_mf.SharedFunctionalGroupsSequence = [fake_frame]
         # Still not enough, we lack information for slice distances
         with pytest.raises(didw.WrapperError):
             MFW(fake_mf).voxel_sizes
         # This can come from SpacingBetweenSlices or frame SliceThickness
-        fake_mf['SpacingBetweenSlices'] = 4.3
+        fake_mf.SpacingBetweenSlices = 4.3
         assert_array_equal(MFW(fake_mf).voxel_sizes, [2.1, 3.2, 4.3])
         # If both, prefer SliceThickness
         fake_frame.PixelMeasuresSequence[0].SliceThickness = 5.4
         assert_array_equal(MFW(fake_mf).voxel_sizes, [2.1, 3.2, 5.4])
         # Just SliceThickness is OK
-        del fake_mf['SpacingBetweenSlices']
+        del fake_mf.SpacingBetweenSlices
         assert_array_equal(MFW(fake_mf).voxel_sizes, [2.1, 3.2, 5.4])
         # Removing shared leads to error again
-        fake_mf['SharedFunctionalGroupsSequence'] = [None]
+        fake_mf.SharedFunctionalGroupsSequence = [pydicom.Dataset()]
         with pytest.raises(didw.WrapperError):
             MFW(fake_mf).voxel_sizes
         # Restoring to frames makes it work again
-        fake_mf['PerFrameFunctionalGroupsSequence'] = [fake_frame]
+        fake_mf.PerFrameFunctionalGroupsSequence = [fake_frame]
         assert_array_equal(MFW(fake_mf).voxel_sizes, [2.1, 3.2, 5.4])
         # Decimals in any field are OK
         fake_frame = fake_frames(
             'PixelMeasuresSequence', 'PixelSpacing', [[Decimal('2.1'), Decimal('3.2')]]
         )[0]
-        fake_mf['SharedFunctionalGroupsSequence'] = [fake_frame]
-        fake_mf['SpacingBetweenSlices'] = Decimal('4.3')
+        fake_mf.SharedFunctionalGroupsSequence = [fake_frame]
+        fake_mf.SpacingBetweenSlices = Decimal('4.3')
         assert_array_equal(MFW(fake_mf).voxel_sizes, [2.1, 3.2, 4.3])
         fake_frame.PixelMeasuresSequence[0].SliceThickness = Decimal('5.4')
         assert_array_equal(MFW(fake_mf).voxel_sizes, [2.1, 3.2, 5.4])
 
+    @dicom_test
     def test_image_position(self):
         # Test image_position property for multiframe
-        fake_mf = copy(self.MINIMAL_MF)
+        fake_mf = deepcopy(self.MINIMAL_MF)
         MFW = self.WRAPCLASS
         dw = MFW(fake_mf)
         with pytest.raises(didw.WrapperError):
             dw.image_position
         # Make a fake frame
-        fake_frame = fake_frames(
-            'PlanePositionSequence', 'ImagePositionPatient', [[-2.0, 3.0, 7]]
-        )[0]
-        fake_mf['SharedFunctionalGroupsSequence'] = [fake_frame]
+        iop = [0, 1, 0, 1, 0, 0]
+        frames = fake_frames('PlaneOrientationSequence', 'ImageOrientationPatient', [iop])
+        frames = fake_frames(
+            'PlanePositionSequence', 'ImagePositionPatient', [[-2.0, 3.0, 7]], frames
+        )
+        fake_mf.SharedFunctionalGroupsSequence = frames
         assert_array_equal(MFW(fake_mf).image_position, [-2, 3, 7])
-        fake_mf['SharedFunctionalGroupsSequence'] = [None]
+        fake_mf.SharedFunctionalGroupsSequence = [pydicom.Dataset()]
         with pytest.raises(didw.WrapperError):
             MFW(fake_mf).image_position
-        fake_mf['PerFrameFunctionalGroupsSequence'] = [fake_frame]
+        fake_mf.PerFrameFunctionalGroupsSequence = frames
         assert_array_equal(MFW(fake_mf).image_position, [-2, 3, 7])
         # Check lists of Decimals work
-        fake_frame.PlanePositionSequence[0].ImagePositionPatient = [
+        frames[0].PlanePositionSequence[0].ImagePositionPatient = [
             Decimal(str(v)) for v in [-2, 3, 7]
         ]
         assert_array_equal(MFW(fake_mf).image_position, [-2, 3, 7])
         assert MFW(fake_mf).image_position.dtype == float
+        # We should get minimum along slice normal with multiple frames
+        frames = fake_frames('PlaneOrientationSequence', 'ImageOrientationPatient', [iop] * 2)
+        ipps = [[-2.0, 3.0, 7], [-2.0, 3.0, 6]]
+        frames = fake_frames('PlanePositionSequence', 'ImagePositionPatient', ipps, frames)
+        fake_mf.PerFrameFunctionalGroupsSequence = frames
+        assert_array_equal(MFW(fake_mf).image_position, [-2, 3, 6])
 
     @dicom_test
     @pytest.mark.xfail(reason='Not packaged in install', raises=FileNotFoundError)
     def test_affine(self):
         # Make sure we find orientation/position/spacing info
         dw = didw.wrapper_from_file(DATA_FILE_4D)
-        aff = dw.affine
+        dw.affine
 
     @dicom_test
     @pytest.mark.xfail(reason='Not packaged in install', raises=FileNotFoundError)
@@ -640,7 +849,7 @@ def test_data_real(self):
         if endian_codes[data.dtype.byteorder] == '>':
             data = data.byteswap()
         dat_str = data.tobytes()
-        assert sha1(dat_str).hexdigest() == '149323269b0af92baa7508e19ca315240f77fa8c'
+        assert sha1(dat_str).hexdigest() == 'dc011bb49682fb78f3cebacf965cb65cc9daba7d'
 
     @dicom_test
     def test_slicethickness_fallback(self):
@@ -652,9 +861,16 @@ def test_slicethickness_fallback(self):
     def test_data_derived_shape(self):
         # Test 4D diffusion data with an additional trace volume included
         # Excludes the trace volume and generates the correct shape
-        dw = didw.wrapper_from_file(DATA_FILE_4D_DERIVED)
         with pytest.warns(UserWarning, match='Derived images found and removed'):
-            assert dw.image_shape == (96, 96, 60, 33)
+            dw = didw.wrapper_from_file(DATA_FILE_4D_DERIVED)
+        assert dw.image_shape == (96, 96, 60, 33)
+
+    @dicom_test
+    @needs_nibabel_data('dcm_qa_xa30')
+    def test_data_trace(self):
+        # Test that a standalone trace volume is found and not dropped
+        dw = didw.wrapper_from_file(DATA_FILE_SIEMENS_TRACE)
+        assert dw.image_shape == (72, 72, 39)
 
     @dicom_test
     @needs_nibabel_data('nitest-dicom')
@@ -667,7 +883,7 @@ def test_data_unreadable_private_headers(self):
     @dicom_test
     def test_data_fake(self):
         # Test algorithm for get_data
-        fake_mf = copy(self.MINIMAL_MF)
+        fake_mf = deepcopy(self.MINIMAL_MF)
         MFW = self.WRAPCLASS
         dw = MFW(fake_mf)
         # Fails - no shape
@@ -679,8 +895,8 @@ def test_data_fake(self):
         with pytest.raises(didw.WrapperError):
             dw.get_data()
         # Make shape and indices
-        fake_mf['Rows'] = 2
-        fake_mf['Columns'] = 3
+        fake_mf.Rows = 2
+        fake_mf.Columns = 3
         dim_idxs = ((1, 1), (1, 2), (1, 3), (1, 4))
         fake_mf.update(fake_shape_dependents(dim_idxs, sid_dim=0))
         assert MFW(fake_mf).image_shape == (2, 3, 4)
@@ -690,19 +906,24 @@ def test_data_fake(self):
         # Add data - 3D
         data = np.arange(24).reshape((2, 3, 4))
         # Frames dim is first for some reason
-        fake_mf['pixel_array'] = np.rollaxis(data, 2)
+        object.__setattr__(fake_mf, 'pixel_array', np.rollaxis(data, 2))
         # Now it should work
         dw = MFW(fake_mf)
         assert_array_equal(dw.get_data(), data)
         # Test scaling works
-        fake_mf['RescaleSlope'] = 2.0
-        fake_mf['RescaleIntercept'] = -1
+        fake_mf.RescaleSlope = 2.0
+        fake_mf.RescaleIntercept = -1
         assert_array_equal(MFW(fake_mf).get_data(), data * 2.0 - 1)
         # Check slice sorting
         dim_idxs = ((1, 4), (1, 2), (1, 3), (1, 1))
         fake_mf.update(fake_shape_dependents(dim_idxs, sid_dim=0))
         sorted_data = data[..., [3, 1, 2, 0]]
-        fake_mf['pixel_array'] = np.rollaxis(sorted_data, 2)
+        fake_mf.pixel_array = np.rollaxis(sorted_data, 2)
+        assert_array_equal(MFW(fake_mf).get_data(), data * 2.0 - 1)
+        # Check slice sorting with negative index / IPP correlation
+        fake_mf.update(fake_shape_dependents(dim_idxs, sid_dim=0, flip_ipp_idx_corr=True))
+        sorted_data = data[..., [0, 2, 1, 3]]
+        fake_mf.pixel_array = np.rollaxis(sorted_data, 2)
         assert_array_equal(MFW(fake_mf).get_data(), data * 2.0 - 1)
         # 5D!
         dim_idxs = [
@@ -729,28 +950,173 @@ def test_data_fake(self):
         sorted_data = data.reshape(shape[:2] + (-1,), order='F')
         order = [11, 9, 10, 8, 3, 1, 2, 0, 15, 13, 14, 12, 7, 5, 6, 4]
         sorted_data = sorted_data[..., np.argsort(order)]
-        fake_mf['pixel_array'] = np.rollaxis(sorted_data, 2)
+        fake_mf.pixel_array = np.rollaxis(sorted_data, 2)
         assert_array_equal(MFW(fake_mf).get_data(), data * 2.0 - 1)
 
-    def test__scale_data(self):
+    @dicom_test
+    def test_scale_data(self):
         # Test data scaling
-        fake_mf = copy(self.MINIMAL_MF)
+        fake_mf = deepcopy(self.MINIMAL_MF)
+        fake_mf.Rows = 2
+        fake_mf.Columns = 3
+        fake_mf.PerFrameFunctionalGroupsSequence = [pydicom.Dataset() for _ in range(4)]
         MFW = self.WRAPCLASS
-        dw = MFW(fake_mf)
-        data = np.arange(24).reshape((2, 3, 4))
-        assert_array_equal(data, dw._scale_data(data))
-        fake_mf['RescaleSlope'] = 2.0
-        fake_mf['RescaleIntercept'] = -1.0
-        assert_array_equal(data * 2 - 1, dw._scale_data(data))
-        fake_frame = fake_frames('PixelValueTransformationSequence', 'RescaleSlope', [3.0])[0]
-        fake_mf['PerFrameFunctionalGroupsSequence'] = [fake_frame]
-        # Lacking RescaleIntercept -> Error
-        dw = MFW(fake_mf)
-        with pytest.raises(AttributeError):
-            dw._scale_data(data)
-        fake_frame.PixelValueTransformationSequence[0].RescaleIntercept = -2
-        assert_array_equal(data * 3 - 2, dw._scale_data(data))
+        data = np.arange(24).reshape((2, 3, 4), order='F')
+        assert_array_equal(data, MFW(fake_mf)._scale_data(data))
+        # Test legacy top-level slope/intercept
+        fake_mf.RescaleSlope = 2.0
+        fake_mf.RescaleIntercept = -1.0
+        assert_array_equal(data * 2 - 1, MFW(fake_mf)._scale_data(data))
+        # RealWorldValueMapping takes precedence, but only with defined units
+        fake_mf.RealWorldValueMappingSequence = [pydicom.Dataset()]
+        fake_mf.RealWorldValueMappingSequence[0].RealWorldValueSlope = 10.0
+        fake_mf.RealWorldValueMappingSequence[0].RealWorldValueIntercept = -5.0
+        assert_array_equal(data * 2 - 1, MFW(fake_mf)._scale_data(data))
+        fake_mf.RealWorldValueMappingSequence[0].MeasurementUnitsCodeSequence = [pydicom.Dataset()]
+        fake_mf.RealWorldValueMappingSequence[0].MeasurementUnitsCodeSequence[0].CodeMeaning = '%'
+        assert_array_equal(data * 10 - 5, MFW(fake_mf)._scale_data(data))
+        fake_mf.RealWorldValueMappingSequence[0].MeasurementUnitsCodeSequence[
+            0
+        ].CodeMeaning = 'no units'
+        assert_array_equal(data * 2 - 1, MFW(fake_mf)._scale_data(data))
+        # Possible to have more than one RealWorldValueMapping, use first one with defined units
+        fake_mf.RealWorldValueMappingSequence.append(pydicom.Dataset())
+        fake_mf.RealWorldValueMappingSequence[-1].RealWorldValueSlope = 15.0
+        fake_mf.RealWorldValueMappingSequence[-1].RealWorldValueIntercept = -3.0
+        fake_mf.RealWorldValueMappingSequence[-1].MeasurementUnitsCodeSequence = [
+            pydicom.Dataset()
+        ]
+        fake_mf.RealWorldValueMappingSequence[-1].MeasurementUnitsCodeSequence[0].CodeMeaning = '%'
+        assert_array_equal(data * 15 - 3, MFW(fake_mf)._scale_data(data))
+        # A global RWV scale takes precedence over per-frame PixelValueTransformation
+        div_seq = ((1, 1, 1), (1, 2, 1), (1, 1, 2), (1, 2, 2))
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        frames = fake_frames(
+            'PixelValueTransformationSequence',
+            'RescaleSlope',
+            [3.0, 3.0, 3.0, 3.0],
+            fake_mf.PerFrameFunctionalGroupsSequence,
+        )
+        assert_array_equal(data * 15 - 3, MFW(fake_mf)._scale_data(data))
+        # The per-frame PixelValueTransformation takes precedence over plain top-level slope / inter
+        delattr(fake_mf, 'RealWorldValueMappingSequence')
+        assert_array_equal(data * 3, MFW(fake_mf)._scale_data(data))
+        for frame in frames:
+            frame.PixelValueTransformationSequence[0].RescaleIntercept = -2
+        assert_array_equal(data * 3 - 2, MFW(fake_mf)._scale_data(data))
         # Decimals are OK
-        fake_frame.PixelValueTransformationSequence[0].RescaleSlope = Decimal('3')
-        fake_frame.PixelValueTransformationSequence[0].RescaleIntercept = Decimal('-2')
-        assert_array_equal(data * 3 - 2, dw._scale_data(data))
+        for frame in frames:
+            frame.PixelValueTransformationSequence[0].RescaleSlope = Decimal(3)
+            frame.PixelValueTransformationSequence[0].RescaleIntercept = Decimal(-2)
+        assert_array_equal(data * 3 - 2, MFW(fake_mf)._scale_data(data))
+        # A per-frame RWV scaling takes precedence over per-frame PixelValueTransformation
+        for frame in frames:
+            frame.RealWorldValueMappingSequence = [pydicom.Dataset()]
+            frame.RealWorldValueMappingSequence[0].RealWorldValueSlope = 10.0
+            frame.RealWorldValueMappingSequence[0].RealWorldValueIntercept = -5.0
+            frame.RealWorldValueMappingSequence[0].MeasurementUnitsCodeSequence = [
+                pydicom.Dataset()
+            ]
+            frame.RealWorldValueMappingSequence[0].MeasurementUnitsCodeSequence[
+                0
+            ].CodeMeaning = '%'
+        assert_array_equal(data * 10 - 5, MFW(fake_mf)._scale_data(data))
+        # Test varying per-frame scale factors
+        for frame_idx, frame in enumerate(frames):
+            frame.RealWorldValueMappingSequence[0].RealWorldValueSlope = 2 * (frame_idx + 1)
+            frame.RealWorldValueMappingSequence[0].RealWorldValueIntercept = -1 * (frame_idx + 1)
+        assert_array_equal(
+            data * np.array([2, 4, 6, 8]) + np.array([-1, -2, -3, -4]),
+            MFW(fake_mf)._scale_data(data),
+        )
+
+    @dicom_test
+    def test_philips_scale_data(self):
+        fake_mf = deepcopy(self.MINIMAL_MF)
+        fake_mf.Manufacturer = 'Philips'
+        fake_mf.Rows = 2
+        fake_mf.Columns = 3
+        fake_mf.PerFrameFunctionalGroupsSequence = [pydicom.Dataset() for _ in range(4)]
+        MFW = self.WRAPCLASS
+        data = np.arange(24).reshape((2, 3, 4), order='F')
+        # Unlike other manufacturers, public scale factors from Philips without defined
+        # units should not be used. In lieu of this the private scale factor should be
+        # used, which should always be available (modulo deidentification). If we can't
+        # find any of these scale factors a warning is issued.
+        with pytest.warns(
+            UserWarning,
+            match='Unable to find Philips private scale factor, cross-series comparisons may be invalid',
+        ):
+            assert_array_equal(data, MFW(fake_mf)._scale_data(data))
+        fake_mf.RescaleSlope = 2.0
+        fake_mf.RescaleIntercept = -1.0
+        for rescale_type in (None, '', 'US', 'normalized'):
+            if rescale_type is not None:
+                fake_mf.RescaleType = rescale_type
+            with pytest.warns(
+                UserWarning,
+                match='Unable to find Philips private scale factor, cross-series comparisons may be invalid',
+            ):
+                assert_array_equal(data, MFW(fake_mf)._scale_data(data))
+        # Falling back to private scaling doesn't generate error
+        priv_block = fake_mf.private_block(0x2005, 'Philips MR Imaging DD 001', create=True)
+        priv_block.add_new(0xE, 'FL', 3.0)
+        assert_array_equal(data * 3.0, MFW(fake_mf)._scale_data(data))
+        # If the units are defined they take precedence over private scaling
+        fake_mf.RescaleType = 'mrad'
+        assert_array_equal(data * 2 - 1, MFW(fake_mf)._scale_data(data))
+        # A RWV scale factor with defined units takes precdence
+        shared = pydicom.Dataset()
+        fake_mf.SharedFunctionalGroupsSequence = [shared]
+        rwv_map = pydicom.Dataset()
+        rwv_map.RealWorldValueSlope = 10.0
+        rwv_map.RealWorldValueIntercept = -5.0
+        rwv_map.MeasurementUnitsCodeSequence = [pydicom.Dataset()]
+        rwv_map.MeasurementUnitsCodeSequence[0].CodeMeaning = '%'
+        shared.RealWorldValueMappingSequence = [rwv_map]
+        assert_array_equal(data * 10 - 5, MFW(fake_mf)._scale_data(data))
+        # Get rid of valid top-level scale factors, test per-frame scale factors
+        delattr(shared, 'RealWorldValueMappingSequence')
+        delattr(fake_mf, 'RescaleType')
+        del fake_mf[priv_block.get_tag(0xE)]
+        div_seq = ((1, 1, 1), (1, 2, 1), (1, 1, 2), (1, 2, 2))
+        fake_mf.update(fake_shape_dependents(div_seq, sid_dim=0))
+        # Simplest case is all frames have same (valid) scale factor
+        for frame in fake_mf.PerFrameFunctionalGroupsSequence:
+            pix_trans = pydicom.Dataset()
+            pix_trans.RescaleSlope = 2.5
+            pix_trans.RescaleIntercept = -4
+            pix_trans.RescaleType = 'mrad'
+            frame.PixelValueTransformationSequence = [pix_trans]
+        assert_array_equal(data * 2.5 - 4, MFW(fake_mf)._scale_data(data))
+        # If some frames are missing valid scale factors we should get a warning
+        for frame in fake_mf.PerFrameFunctionalGroupsSequence[2:]:
+            delattr(frame.PixelValueTransformationSequence[0], 'RescaleType')
+        with pytest.warns(
+            UserWarning,
+            match='Unable to find Philips private scale factor, cross-series comparisons may be invalid',
+        ):
+            assert_array_equal(
+                data * np.array([2.5, 2.5, 1, 1]) + np.array([-4, -4, 0, 0]),
+                MFW(fake_mf)._scale_data(data),
+            )
+        # We can fall back to private scale factor on frame-by-frame basis
+        for frame in fake_mf.PerFrameFunctionalGroupsSequence:
+            priv_block = frame.private_block(0x2005, 'Philips MR Imaging DD 001', create=True)
+            priv_block.add_new(0xE, 'FL', 7.0)
+        assert_array_equal(
+            data * np.array([2.5, 2.5, 7, 7]) + np.array([-4, -4, 0, 0]),
+            MFW(fake_mf)._scale_data(data),
+        )
+        # Again RWV scale factors take precedence
+        for frame_idx, frame in enumerate(fake_mf.PerFrameFunctionalGroupsSequence):
+            rwv_map = pydicom.Dataset()
+            rwv_map.RealWorldValueSlope = 14.0 - frame_idx
+            rwv_map.RealWorldValueIntercept = 5.0
+            rwv_map.MeasurementUnitsCodeSequence = [pydicom.Dataset()]
+            rwv_map.MeasurementUnitsCodeSequence[0].CodeMeaning = '%'
+            frame.RealWorldValueMappingSequence = [rwv_map]
+        assert_array_equal(
+            data * np.array([14, 13, 12, 11]) + np.array([5, 5, 5, 5]),
+            MFW(fake_mf)._scale_data(data),
+        )
diff --git a/nibabel/nicom/tests/test_dwiparams.py b/nibabel/nicom/tests/test_dwiparams.py
index 6e98b4af61..559c0a2143 100644
--- a/nibabel/nicom/tests/test_dwiparams.py
+++ b/nibabel/nicom/tests/test_dwiparams.py
@@ -1,5 +1,4 @@
-"""Testing diffusion parameter processing
-"""
+"""Testing diffusion parameter processing"""
 
 import numpy as np
 import pytest
diff --git a/nibabel/nicom/tests/test_structreader.py b/nibabel/nicom/tests/test_structreader.py
index 2d37bbc3ed..ccd2dd4f85 100644
--- a/nibabel/nicom/tests/test_structreader.py
+++ b/nibabel/nicom/tests/test_structreader.py
@@ -1,5 +1,5 @@
-"""Testing Siemens CSA header reader
-"""
+"""Testing Siemens CSA header reader"""
+
 import struct
 import sys
 
diff --git a/nibabel/nicom/tests/test_utils.py b/nibabel/nicom/tests/test_utils.py
index 37dbcd7d19..bdf95bbbe2 100644
--- a/nibabel/nicom/tests/test_utils.py
+++ b/nibabel/nicom/tests/test_utils.py
@@ -1,10 +1,10 @@
-"""Testing nicom.utils module
-"""
+"""Testing nicom.utils module"""
+
 import re
 
 from nibabel.optpkg import optional_package
 
-from ..utils import find_private_section
+from ..utils import find_private_section as fps
 from .test_dicomwrappers import DATA, DATA_PHILIPS
 
 pydicom, _, setup_module = optional_package('pydicom')
@@ -13,37 +13,53 @@
 def test_find_private_section_real():
     # Find section containing named private creator information
     # On real data first
-    assert find_private_section(DATA, 0x29, 'SIEMENS CSA HEADER') == 0x1000
-    assert find_private_section(DATA, 0x29, 'SIEMENS MEDCOM HEADER2') == 0x1100
-    assert find_private_section(DATA_PHILIPS, 0x29, 'SIEMENS CSA HEADER') == None
-    # Make fake datasets
+    assert fps(DATA, 0x29, 'SIEMENS CSA HEADER') == 0x1000
+    assert fps(DATA, 0x29, b'SIEMENS CSA HEADER') == 0x1000
+    assert fps(DATA, 0x29, re.compile(r'SIEMENS CSA HEADER')) == 0x1000
+    assert fps(DATA, 0x29, 'NOT A HEADER') is None
+    assert fps(DATA, 0x29, 'SIEMENS MEDCOM HEADER2') == 0x1100
+    assert fps(DATA_PHILIPS, 0x29, 'SIEMENS CSA HEADER') == None
+
+
+def test_find_private_section_fake():
+    # Make and test fake datasets
     ds = pydicom.dataset.Dataset({})
+    assert fps(ds, 0x11, 'some section') is None
     ds.add_new((0x11, 0x10), 'LO', b'some section')
-    assert find_private_section(ds, 0x11, 'some section') == 0x1000
-    ds.add_new((0x11, 0x11), 'LO', b'anther section')
+    assert fps(ds, 0x11, 'some section') == 0x1000
+    ds.add_new((0x11, 0x11), 'LO', b'another section')
     ds.add_new((0x11, 0x12), 'LO', b'third section')
-    assert find_private_section(ds, 0x11, 'third section') == 0x1200
-    # Wrong 'OB' is acceptable for VM (should be 'LO')
+    assert fps(ds, 0x11, 'third section') == 0x1200
+    # Technically incorrect 'OB' is acceptable for VM (should be 'LO')
     ds.add_new((0x11, 0x12), 'OB', b'third section')
-    assert find_private_section(ds, 0x11, 'third section') == 0x1200
+    assert fps(ds, 0x11, 'third section') == 0x1200
     # Anything else not acceptable
     ds.add_new((0x11, 0x12), 'PN', b'third section')
-    assert find_private_section(ds, 0x11, 'third section') is None
+    assert fps(ds, 0x11, 'third section') is None
     # The input (DICOM value) can be a string insteal of bytes
     ds.add_new((0x11, 0x12), 'LO', 'third section')
-    assert find_private_section(ds, 0x11, 'third section') == 0x1200
+    assert fps(ds, 0x11, 'third section') == 0x1200
     # Search can be bytes as well as string
     ds.add_new((0x11, 0x12), 'LO', b'third section')
-    assert find_private_section(ds, 0x11, b'third section') == 0x1200
+    assert fps(ds, 0x11, b'third section') == 0x1200
     # Search with string or bytes must be exact
-    assert find_private_section(ds, 0x11, b'third sectio') is None
-    assert find_private_section(ds, 0x11, 'hird sectio') is None
+    assert fps(ds, 0x11, b'third sectio') is None
+    assert fps(ds, 0x11, 'hird sectio') is None
     # The search can be a regexp
-    assert find_private_section(ds, 0x11, re.compile(r'third\Wsectio[nN]')) == 0x1200
+    assert fps(ds, 0x11, re.compile(r'third\Wsectio[nN]')) == 0x1200
     # No match -> None
-    assert find_private_section(ds, 0x11, re.compile(r'not third\Wsectio[nN]')) is None
+    assert fps(ds, 0x11, re.compile(r'not third\Wsectio[nN]')) is None
     # If there are gaps in the sequence before the one we want, that is OK
     ds.add_new((0x11, 0x13), 'LO', b'near section')
-    assert find_private_section(ds, 0x11, 'near section') == 0x1300
+    assert fps(ds, 0x11, 'near section') == 0x1300
     ds.add_new((0x11, 0x15), 'LO', b'far section')
-    assert find_private_section(ds, 0x11, 'far section') == 0x1500
+    assert fps(ds, 0x11, 'far section') == 0x1500
+    # More than one match - find the first.
+    assert fps(ds, 0x11, re.compile(r'(another|third) section')) == 0x1100
+    # The signalling element number must be <= 0xFF
+    ds = pydicom.dataset.Dataset({})
+    ds.add_new((0x11, 0xFF), 'LO', b'some section')
+    assert fps(ds, 0x11, 'some section') == 0xFF00
+    ds = pydicom.dataset.Dataset({})
+    ds.add_new((0x11, 0x100), 'LO', b'some section')
+    assert fps(ds, 0x11, 'some section') is None
diff --git a/nibabel/nicom/utils.py b/nibabel/nicom/utils.py
index 48a010903a..2c01c9d161 100644
--- a/nibabel/nicom/utils.py
+++ b/nibabel/nicom/utils.py
@@ -1,7 +1,6 @@
-"""Utilities for working with DICOM datasets
-"""
+"""Utilities for working with DICOM datasets"""
 
-from numpy.compat.py3k import asstr
+from enum import Enum
 
 
 def find_private_section(dcm_data, group_no, creator):
@@ -27,26 +26,76 @@ def find_private_section(dcm_data, group_no, creator):
     Returns
     -------
     element_start : int
-        Element number at which named section starts
+        Element number at which named section starts.
     """
-    is_regex = hasattr(creator, 'search')
-    if not is_regex:  # assume string / bytes
-        creator = asstr(creator)
-    for element in dcm_data:  # Assumed ordered by tag (groupno, elno)
-        grpno, elno = element.tag.group, element.tag.elem
-        if grpno > group_no:
-            break
-        if grpno != group_no:
-            continue
+    if hasattr(creator, 'search'):
+        match_func = creator.search
+    else:
+        if isinstance(creator, bytes):
+            creator = creator.decode('latin-1')
+        match_func = creator.__eq__
+    # Group elements assumed ordered by tag (groupno, elno)
+    for element in dcm_data.group_dataset(group_no):
+        elno = element.tag.elem
         if elno > 0xFF:
             break
         if element.VR not in ('LO', 'OB'):
             continue
-        name = asstr(element.value)
-        if is_regex:
-            if creator.search(name) is not None:
-                return elno * 0x100
-        else:  # string - needs exact match
-            if creator == name:
-                return elno * 0x100
+        val = element.value
+        if isinstance(val, bytes):
+            val = val.decode('latin-1')
+        if match_func(val):
+            return elno * 0x100
     return None
+
+
+class Vendor(Enum):
+    SIEMENS = 1
+    GE = 2
+    PHILIPS = 3
+
+
+vendor_priv_sections = {
+    Vendor.SIEMENS: [
+        (0x9, 'SIEMENS SYNGO INDEX SERVICE'),
+        (0x19, 'SIEMENS MR HEADER'),
+        (0x21, 'SIEMENS MR SDR 01'),
+        (0x21, 'SIEMENS MR SDS 01'),
+        (0x21, 'SIEMENS MR SDI 02'),
+        (0x29, 'SIEMENS CSA HEADER'),
+        (0x29, 'SIEMENS MEDCOM HEADER2'),
+        (0x51, 'SIEMENS MR HEADER'),
+    ],
+    Vendor.PHILIPS: [
+        (0x2001, 'Philips Imaging DD 001'),
+        (0x2001, 'Philips Imaging DD 002'),
+        (0x2001, 'Philips Imaging DD 129'),
+        (0x2005, 'Philips MR Imaging DD 001'),
+        (0x2005, 'Philips MR Imaging DD 002'),
+        (0x2005, 'Philips MR Imaging DD 003'),
+        (0x2005, 'Philips MR Imaging DD 004'),
+        (0x2005, 'Philips MR Imaging DD 005'),
+        (0x2005, 'Philips MR Imaging DD 006'),
+        (0x2005, 'Philips MR Imaging DD 007'),
+        (0x2005, 'Philips MR Imaging DD 005'),
+        (0x2005, 'Philips MR Imaging DD 006'),
+    ],
+    Vendor.GE: [
+        (0x9, 'GEMS_IDEN_01'),
+        (0x19, 'GEMS_ACQU_01'),
+        (0x21, 'GEMS_RELA_01'),
+        (0x23, 'GEMS_STDY_01'),
+        (0x25, 'GEMS_SERS_01'),
+        (0x27, 'GEMS_IMAG_01'),
+        (0x29, 'GEMS_IMPS_01'),
+        (0x43, 'GEMS_PARM_01'),
+    ],
+}
+
+
+def vendor_from_private(dcm_data):
+    """Try to determine the vendor by looking for specific private tags"""
+    for vendor, priv_sections in vendor_priv_sections.items():
+        for priv_group, priv_creator in priv_sections:
+            if find_private_section(dcm_data, priv_group, priv_creator) != None:
+                return vendor
diff --git a/nibabel/nifti1.py b/nibabel/nifti1.py
index 9bb88e844c..e39f9f9042 100644
--- a/nibabel/nifti1.py
+++ b/nibabel/nifti1.py
@@ -10,29 +10,43 @@
 
 NIfTI1 format defined at http://nifti.nimh.nih.gov/nifti-1/
 """
+
 from __future__ import annotations
 
+import json
+import typing as ty
 import warnings
 from io import BytesIO
-from typing import Type
 
 import numpy as np
 import numpy.linalg as npl
-from numpy.compat.py3k import asstr
 
 from . import analyze  # module import
+from ._typing import Self, TypeVar
 from .arrayproxy import get_obj_dtype
 from .batteryrunners import Report
 from .casting import have_binary128
 from .deprecated import alert_future_error
-from .filebasedimages import SerializableImage
+from .filebasedimages import ImageFileError, SerializableImage
 from .optpkg import optional_package
 from .quaternions import fillpositive, mat2quat, quat2mat
-from .spatialimages import HeaderDataError, ImageFileError
+from .spatialimages import HeaderDataError
 from .spm99analyze import SpmAnalyzeHeader
 from .volumeutils import Recoder, endian_codes, make_dt_codes
 
-pdcm, have_dicom, _ = optional_package('pydicom')
+if ty.TYPE_CHECKING:
+    import pydicom as pdcm
+
+    have_dicom = True
+    DicomDataset = pdcm.Dataset
+else:
+    pdcm, have_dicom, _ = optional_package('pydicom')
+    if have_dicom:
+        DicomDataset = pdcm.Dataset
+    else:
+        DicomDataset = ty.Any
+
+T = TypeVar('T', default=bytes)
 
 # nifti1 flat header definition for Analyze-like first 348 bytes
 # first number in comments indicates offset in file header in bytes
@@ -90,8 +104,8 @@
 # datatypes not in analyze format, with codes
 if have_binary128():
     # Only enable 128 bit floats if we really have IEEE binary 128 longdoubles
-    _float128t: Type[np.generic] = np.longdouble
-    _complex256t: Type[np.generic] = np.longcomplex
+    _float128t: type[np.generic] = np.longdouble
+    _complex256t: type[np.generic] = np.clongdouble
 else:
     _float128t = np.void
     _complex256t = np.void
@@ -284,15 +298,38 @@
 )
 
 
-class Nifti1Extension:
-    """Baseclass for NIfTI1 header extensions.
+class NiftiExtension(ty.Generic[T]):
+    """Base class for NIfTI header extensions.
 
-    This class is sufficient to handle very simple text-based extensions, such
-    as `comment`. More sophisticated extensions should/will be supported by
-    dedicated subclasses.
+    This class provides access to the extension content in various forms.
+    For simple extensions that expose data as bytes, text or JSON, this class
+    is sufficient. More complex extensions should be implemented as subclasses
+    that provide custom serialization/deserialization methods.
+
+    Efficiency note:
+
+    This class assumes that the runtime representation of the extension content
+    is mutable. Once a runtime representation is set, it is cached and will be
+    serialized on any attempt to access the extension content as bytes, including
+    determining the size of the extension in the NIfTI file.
+
+    If the runtime representation is never accessed, the raw bytes will be used
+    without modification. While avoiding unnecessary deserialization, if there
+    are bytestrings that do not produce a valid runtime representation, they will
+    be written as-is, and may cause errors downstream.
     """
 
-    def __init__(self, code, content):
+    code: int
+    encoding: str | None = None
+    _raw: bytes
+    _object: T | None = None
+
+    def __init__(
+        self,
+        code: int | str,
+        content: bytes = b'',
+        object: T | None = None,
+    ) -> None:
         """
         Parameters
         ----------
@@ -300,94 +337,133 @@ def __init__(self, code, content):
           Canonical extension code as defined in the NIfTI standard, given
           either as integer or corresponding label
           (see :data:`~nibabel.nifti1.extension_codes`)
-        content : str
-          Extension content as read from the NIfTI file header. This content is
-          converted into a runtime representation.
+        content : bytes, optional
+          Extension content as read from the NIfTI file header.
+        object : optional
+          Extension content in runtime form.
         """
         try:
-            self._code = extension_codes.code[code]
+            self.code = extension_codes.code[code]  # type: ignore[assignment]
         except KeyError:
-            # XXX or fail or at least complain?
-            self._code = code
-        self._content = self._unmangle(content)
+            self.code = code  # type: ignore[assignment]
+        self._raw = content
+        if object is not None:
+            self._object = object
 
-    def _unmangle(self, value):
-        """Convert the extension content into its runtime representation.
+    @property
+    def _content(self):
+        return self.get_object()
 
-        The default implementation does nothing at all.
+    @classmethod
+    def from_bytes(cls, content: bytes) -> Self:
+        """Create an extension from raw bytes.
 
-        Parameters
-        ----------
-        value : str
-          Extension content as read from file.
+        This constructor may only be used in extension classes with a class
+        attribute `code` to indicate the extension type.
+        """
+        if not hasattr(cls, 'code'):
+            raise NotImplementedError('from_bytes() requires a class attribute `code`')
+        return cls(cls.code, content=content)
 
-        Returns
-        -------
-        The same object that was passed as `value`.
+    @classmethod
+    def from_object(cls, obj: T) -> Self:
+        """Create an extension from a runtime object.
 
-        Notes
-        -----
-        Subclasses should reimplement this method to provide the desired
-        unmangling procedure and may return any type of object.
+        This constructor may only be used in extension classes with a class
+        attribute `code` to indicate the extension type.
         """
-        return value
-
-    def _mangle(self, value):
-        """Convert the extension content into NIfTI file header representation.
+        if not hasattr(cls, 'code'):
+            raise NotImplementedError('from_object() requires a class attribute `code`')
+        return cls(cls.code, object=obj)
 
-        The default implementation does nothing at all.
+    # Handle (de)serialization of extension content
+    # Subclasses may implement these methods to provide an alternative
+    # view of the extension content. If left unimplemented, the content
+    # must be bytes and is not modified.
+    def _mangle(self, obj: T) -> bytes:
+        raise NotImplementedError
 
-        Parameters
-        ----------
-        value : str
-          Extension content in runtime form.
+    def _unmangle(self, content: bytes) -> T:
+        raise NotImplementedError
 
-        Returns
-        -------
-        str
+    def _sync(self) -> None:
+        """Synchronize content with object.
 
-        Notes
-        -----
-        Subclasses should reimplement this method to provide the desired
-        mangling procedure.
+        This permits the runtime representation to be modified in-place
+        and updates the bytes representation accordingly.
         """
-        return value
+        if self._object is not None:
+            self._raw = self._mangle(self._object)
+
+    def __repr__(self) -> str:
+        try:
+            code = extension_codes.label[self.code]
+        except KeyError:
+            # deal with unknown codes
+            code = self.code
+        return f'{self.__class__.__name__}({code}, {self._raw!r})'
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, self.__class__)
+            and self.code == other.code
+            and self.content == other.content
+        )
+
+    def __ne__(self, other):
+        return not self == other
 
     def get_code(self):
         """Return the canonical extension type code."""
-        return self._code
+        return self.code
+
+    # Canonical access to extension content
+    # Follows the lead of httpx.Response .content, .text and .json()
+    # properties/methods
+    @property
+    def content(self) -> bytes:
+        """Return the extension content as raw bytes."""
+        self._sync()
+        return self._raw
+
+    @property
+    def text(self) -> str:
+        """Attempt to decode the extension content as text.
+
+        The encoding is determined by the `encoding` attribute, which may be
+        set by the user or subclass. If not set, the default encoding is 'utf-8'.
+        """
+        return self.content.decode(self.encoding or 'utf-8')
 
-    def get_content(self):
-        """Return the extension content in its runtime representation."""
-        return self._content
+    def json(self) -> ty.Any:
+        """Attempt to decode the extension content as JSON.
 
-    def get_sizeondisk(self):
-        """Return the size of the extension in the NIfTI file."""
-        # need raw value size plus 8 bytes for esize and ecode
-        size = len(self._mangle(self._content))
-        size += 8
-        # extensions size has to be a multiple of 16 bytes
-        if size % 16 != 0:
-            size += 16 - (size % 16)
-        return size
+        If the content is not valid JSON, a JSONDecodeError or UnicodeDecodeError
+        will be raised.
+        """
+        return json.loads(self.content)
 
-    def __repr__(self):
-        try:
-            code = extension_codes.label[self._code]
-        except KeyError:
-            # deal with unknown codes
-            code = self._code
+    def get_object(self) -> T:
+        """Return the extension content in its runtime representation.
 
-        s = f"Nifti1Extension('{code}', '{self._content}')"
-        return s
+        This method may return a different type for each extension type.
+        For simple use cases, consider using ``.content``, ``.text`` or ``.json()``
+        instead.
+        """
+        if self._object is None:
+            self._object = self._unmangle(self._raw)
+        return self._object
 
-    def __eq__(self, other):
-        return (self._code, self._content) == (other._code, other._content)
+    # Backwards compatibility
+    get_content = get_object
 
-    def __ne__(self, other):
-        return not self == other
+    def get_sizeondisk(self) -> int:
+        """Return the size of the extension in the NIfTI file."""
+        # need raw value size plus 8 bytes for esize and ecode, rounded up to next 16 bytes
+        # Rounding C+8 up to M is done by (C+8 + (M-1)) // M * M
+        return (len(self.content) + 23) // 16 * 16
 
-    def write_to(self, fileobj, byteswap):
+    def write_to(self, fileobj: ty.BinaryIO, byteswap: bool = False) -> None:
         """Write header extensions to fileobj
 
         Write starts at fileobj current file position.
@@ -404,21 +480,75 @@ def write_to(self, fileobj, byteswap):
         None
         """
         extstart = fileobj.tell()
-        rawsize = self.get_sizeondisk()
+        rawsize = self.get_sizeondisk()  # Calls _sync()
         # write esize and ecode first
-        extinfo = np.array((rawsize, self._code), dtype=np.int32)
+        extinfo = np.array((rawsize, self.code), dtype=np.int32)
         if byteswap:
             extinfo = extinfo.byteswap()
         fileobj.write(extinfo.tobytes())
-        # followed by the actual extension content
-        # XXX if mangling upon load is implemented, it should be reverted here
-        fileobj.write(self._mangle(self._content))
+        # followed by the actual extension content, synced above
+        fileobj.write(self._raw)
         # be nice and zero out remaining part of the extension till the
         # next 16 byte border
-        fileobj.write(b'\x00' * (extstart + rawsize - fileobj.tell()))
+        pad = extstart + rawsize - fileobj.tell()
+        if pad:
+            fileobj.write(bytes(pad))
+
+
+class Nifti1Extension(NiftiExtension[T]):
+    """Baseclass for NIfTI1 header extensions.
+
+    This class is sufficient to handle very simple text-based extensions, such
+    as `comment`. More sophisticated extensions should/will be supported by
+    dedicated subclasses.
+    """
+
+    code = 0  # Default to unknown extension
+
+    def _unmangle(self, value: bytes) -> T:
+        """Convert the extension content into its runtime representation.
+
+        The default implementation does nothing at all.
+
+        Parameters
+        ----------
+        value : str
+          Extension content as read from file.
+
+        Returns
+        -------
+        The same object that was passed as `value`.
+
+        Notes
+        -----
+        Subclasses should reimplement this method to provide the desired
+        unmangling procedure and may return any type of object.
+        """
+        return value  # type: ignore[return-value]
+
+    def _mangle(self, value: T) -> bytes:
+        """Convert the extension content into NIfTI file header representation.
+
+        The default implementation does nothing at all.
+
+        Parameters
+        ----------
+        value : str
+          Extension content in runtime form.
 
+        Returns
+        -------
+        str
 
-class Nifti1DicomExtension(Nifti1Extension):
+        Notes
+        -----
+        Subclasses should reimplement this method to provide the desired
+        mangling procedure.
+        """
+        return value  # type: ignore[return-value]
+
+
+class Nifti1DicomExtension(Nifti1Extension[DicomDataset]):
     """NIfTI1 DICOM header extension
 
     This class is a thin wrapper around pydicom to read a binary DICOM
@@ -428,7 +558,16 @@ class Nifti1DicomExtension(Nifti1Extension):
     header.
     """
 
-    def __init__(self, code, content, parent_hdr=None):
+    code = 2
+    _is_implicit_VR: bool = False
+    _is_little_endian: bool = True
+
+    def __init__(
+        self,
+        code: int | str,
+        content: bytes | DicomDataset | None = None,
+        parent_hdr: Nifti1Header | None = None,
+    ) -> None:
         """
         Parameters
         ----------
@@ -453,30 +592,28 @@ def __init__(self, code, content, parent_hdr=None):
         code should always be 2 for DICOM.
         """
 
-        self._code = code
-        if parent_hdr:
+        if code != 2:
+            raise ValueError(f'code must be 2 for DICOM. Got {code}.')
+
+        if content is None:
+            content = pdcm.Dataset()
+
+        if parent_hdr is not None:
             self._is_little_endian = parent_hdr.endianness == '<'
-        else:
-            self._is_little_endian = True
+
         if isinstance(content, pdcm.dataset.Dataset):
-            self._is_implicit_VR = False
-            self._raw_content = self._mangle(content)
-            self._content = content
+            super().__init__(code, object=content)
         elif isinstance(content, bytes):  # Got a byte string - unmangle it
-            self._raw_content = content
-            self._is_implicit_VR = self._guess_implicit_VR()
-            ds = self._unmangle(content, self._is_implicit_VR, self._is_little_endian)
-            self._content = ds
-        elif content is None:  # initialize a new dicom dataset
-            self._is_implicit_VR = False
-            self._content = pdcm.dataset.Dataset()
+            self._is_implicit_VR = self._guess_implicit_VR(content)
+            super().__init__(code, content=content)
         else:
             raise TypeError(
                 f'content must be either a bytestring or a pydicom Dataset. '
                 f'Got {content.__class__}'
             )
 
-    def _guess_implicit_VR(self):
+    @staticmethod
+    def _guess_implicit_VR(content) -> bool:
         """Try to guess DICOM syntax by checking for valid VRs.
 
         Without a DICOM Transfer Syntax, it's difficult to tell if Value
@@ -484,19 +621,17 @@ def _guess_implicit_VR(self):
         This reads where the first VR would be and checks it against a list of
         valid VRs
         """
-        potential_vr = self._raw_content[4:6].decode()
-        if potential_vr in pdcm.values.converters.keys():
-            implicit_VR = False
-        else:
-            implicit_VR = True
-        return implicit_VR
-
-    def _unmangle(self, value, is_implicit_VR=False, is_little_endian=True):
-        bio = BytesIO(value)
-        ds = pdcm.filereader.read_dataset(bio, is_implicit_VR, is_little_endian)
-        return ds
+        potential_vr = content[4:6].decode()
+        return potential_vr not in pdcm.values.converters.keys()
+
+    def _unmangle(self, obj: bytes) -> DicomDataset:
+        return pdcm.filereader.read_dataset(
+            BytesIO(obj),
+            self._is_implicit_VR,
+            self._is_little_endian,
+        )
 
-    def _mangle(self, dataset):
+    def _mangle(self, dataset: DicomDataset) -> bytes:
         bio = BytesIO()
         dio = pdcm.filebase.DicomFileLike(bio)
         dio.is_implicit_VR = self._is_implicit_VR
@@ -521,6 +656,21 @@ def _mangle(self, dataset):
         (12, 'workflow_fwds', Nifti1Extension),
         (14, 'freesurfer', Nifti1Extension),
         (16, 'pypickle', Nifti1Extension),
+        (18, 'mind_ident', NiftiExtension),
+        (20, 'b_value', NiftiExtension),
+        (22, 'spherical_direction', NiftiExtension),
+        (24, 'dt_component', NiftiExtension),
+        (26, 'shc_degreeorder', NiftiExtension),
+        (28, 'voxbo', NiftiExtension),
+        (30, 'caret', NiftiExtension),
+        ## Defined in nibabel.cifti2.parse_cifti2
+        # (32, 'cifti', Cifti2Extension),
+        (34, 'variable_frame_timing', NiftiExtension),
+        (36, 'unassigned', NiftiExtension),
+        (38, 'eval', NiftiExtension),
+        (40, 'matlab', NiftiExtension),
+        (42, 'quantiphyse', NiftiExtension),
+        (44, 'mrs', Nifti1Extension),
     ),
     fields=('code', 'label', 'handler'),
 )
@@ -553,7 +703,7 @@ def get_sizeondisk(self):
         return np.sum([e.get_sizeondisk() for e in self])
 
     def __repr__(self):
-        return 'Nifti1Extensions(%s)' % ', '.join(str(e) for e in self)
+        return 'Nifti1Extensions({})'.format(', '.join(str(e) for e in self))
 
     def write_to(self, fileobj, byteswap):
         """Write header extensions to fileobj
@@ -688,7 +838,7 @@ class Nifti1Header(SpmAnalyzeHeader):
     single_magic = b'n+1'
 
     # Quaternion threshold near 0, based on float32 precision
-    quaternion_threshold = -np.finfo(np.float32).eps * 3
+    quaternion_threshold: np.floating = np.finfo(np.float32).eps * 3
 
     def __init__(self, binaryblock=None, endianness=None, check=True, extensions=()):
         """Initialize header from binary data block and extensions"""
@@ -1098,7 +1248,10 @@ def set_qform(self, affine, code=None, strip_shears=True):
         # (a subtle requirement of the NIFTI format qform transform)
         # Transform below is polar decomposition, returning the closest
         # orthogonal matrix PR, to input R
-        P, S, Qs = npl.svd(R)
+        try:
+            P, S, Qs = npl.svd(R)
+        except np.linalg.LinAlgError as e:
+            raise HeaderDataError(f'Could not decompose affine:\n{affine}') from e
         PR = np.dot(P, Qs)
         if not strip_shears and not np.allclose(PR, R):
             raise HeaderDataError('Shears in affine and `strip_shears` is False')
@@ -1405,8 +1558,8 @@ def get_intent(self, code_repr='label'):
         else:
             raise TypeError('repr can be "label" or "code"')
         n_params = len(recoder.parameters[code]) if known_intent else 0
-        params = (float(hdr['intent_p%d' % (i + 1)]) for i in range(n_params))
-        name = asstr(hdr['intent_name'].item())
+        params = (float(hdr[f'intent_p{i}']) for i in range(1, n_params + 1))
+        name = hdr['intent_name'].item().decode('latin-1')
         return label, tuple(params), name
 
     def set_intent(self, code, params=(), name='', allow_unknown=False):
@@ -1478,8 +1631,8 @@ def set_intent(self, code, params=(), name='', allow_unknown=False):
         hdr['intent_name'] = name
         all_params = [0] * 3
         all_params[: len(params)] = params[:]
-        for i, param in enumerate(all_params):
-            hdr['intent_p%d' % (i + 1)] = param
+        for i, param in enumerate(all_params, start=1):
+            hdr[f'intent_p{i}'] = param
 
     def get_slice_duration(self):
         """Get slice duration
@@ -1638,16 +1791,15 @@ def set_slice_times(self, slice_times):
         labels = so_recoder.value_set('label')
         labels.remove('unknown')
 
-        matching_labels = []
-        for label in labels:
-            if np.all(st_order == self._slice_time_order(label, n_timed)):
-                matching_labels.append(label)
+        matching_labels = [
+            label for label in labels if np.all(st_order == self._slice_time_order(label, n_timed))
+        ]
 
         if not matching_labels:
             raise HeaderDataError(f'slice ordering of {st_order} fits with no known scheme')
         if len(matching_labels) > 1:
             warnings.warn(
-                f"Multiple slice orders satisfy: {', '.join(matching_labels)}. "
+                f'Multiple slice orders satisfy: {", ".join(matching_labels)}. '
                 'Choosing the first one'
             )
         label = matching_labels[0]
@@ -1742,7 +1894,7 @@ def _chk_magic(hdr, fix=False):
         magic = hdr['magic'].item()
         if magic in (hdr.pair_magic, hdr.single_magic):
             return hdr, rep
-        rep.problem_msg = f'magic string "{asstr(magic)}" is not valid'
+        rep.problem_msg = f'magic string {magic.decode("latin1")!r} is not valid'
         rep.problem_level = 45
         if fix:
             rep.fix_msg = 'leaving as is, but future errors are likely'
@@ -1758,7 +1910,7 @@ def _chk_offset(hdr, fix=False):
             return hdr, rep
         if magic == hdr.single_magic and offset < hdr.single_vox_offset:
             rep.problem_level = 40
-            rep.problem_msg = 'vox offset %d too low for single file nifti1' % offset
+            rep.problem_msg = f'vox offset {int(offset)} too low for single file nifti1'
             if fix:
                 hdr['vox_offset'] = hdr.single_vox_offset
                 rep.fix_msg = f'setting to minimum value of {hdr.single_vox_offset}'
@@ -1790,7 +1942,7 @@ def _chk_xform_code(klass, code_type, hdr, fix):
         if code in recoder.value_set():
             return hdr, rep
         rep.problem_level = 30
-        rep.problem_msg = '%s %d not valid' % (code_type, code)
+        rep.problem_msg = f'{code_type} {code} not valid'
         if fix:
             hdr[code_type] = 0
             rep.fix_msg = 'setting to 0'
@@ -1817,7 +1969,8 @@ class Nifti1PairHeader(Nifti1Header):
 class Nifti1Pair(analyze.AnalyzeImage):
     """Class for NIfTI1 format image, header pair"""
 
-    header_class: Type[Nifti1Header] = Nifti1PairHeader
+    header_class: type[Nifti1Header] = Nifti1PairHeader
+    header: Nifti1Header
     _meta_sniff_len = header_class.sizeof_hdr
     rw = True
 
@@ -2444,10 +2597,14 @@ def _get_analyze_compat_dtype(arr):
         return np.dtype('int16' if arr.max() <= np.iinfo(np.int16).max else 'int32')
 
     mn, mx = arr.min(), arr.max()
-    if np.can_cast(mn, np.int32) and np.can_cast(mx, np.int32):
-        return np.dtype('int32')
-    if np.can_cast(mn, np.float32) and np.can_cast(mx, np.float32):
-        return np.dtype('float32')
+    if arr.dtype.kind in 'iu':
+        info = np.iinfo('int32')
+        if mn >= info.min and mx <= info.max:
+            return np.dtype('int32')
+    elif arr.dtype.kind == 'f':
+        info = np.finfo('float32')
+        if mn >= info.min and mx <= info.max:
+            return np.dtype('float32')
 
     raise ValueError(
         f'Cannot find analyze-compatible dtype for array with dtype={dtype} (min={mn}, max={mx})'
diff --git a/nibabel/nifti2.py b/nibabel/nifti2.py
index cb138962cc..9c898b47ba 100644
--- a/nibabel/nifti2.py
+++ b/nibabel/nifti2.py
@@ -17,8 +17,9 @@
 
 from .analyze import AnalyzeHeader
 from .batteryrunners import Report
+from .filebasedimages import ImageFileError
 from .nifti1 import Nifti1Header, Nifti1Image, Nifti1Pair
-from .spatialimages import HeaderDataError, ImageFileError
+from .spatialimages import HeaderDataError
 
 r"""
 Header struct from : https://www.nitrc.org/forum/message.php?msg_id=3738
diff --git a/nibabel/onetime.py b/nibabel/onetime.py
index 8156b1a403..f6d3633af3 100644
--- a/nibabel/onetime.py
+++ b/nibabel/onetime.py
@@ -1,10 +1,12 @@
-"""
-Descriptor support for NIPY.
+"""Descriptor support for NIPY
+
+Utilities to support special Python descriptors [1,2], in particular
+:func:`~functools.cached_property`, which has been available in the Python
+standard library since Python 3.8. We currently maintain aliases from
+earlier names for this descriptor, specifically `OneTimeProperty` and `auto_attr`.
 
-Utilities to support special Python descriptors [1,2], in particular the use of
-a useful pattern for properties we call 'one time properties'.  These are
-object attributes which are declared as properties, but become regular
-attributes once they've been read the first time.  They can thus be evaluated
+:func:`~functools.cached_property` creates properties that are computed once
+and then stored as regular attributes. They can thus be evaluated
 later in the object's life cycle, but once evaluated they become normal, static
 attributes with no function call overhead on access or any other constraints.
 
@@ -20,6 +22,10 @@
 [2] Python data model, https://docs.python.org/reference/datamodel.html
 """
 
+from __future__ import annotations
+
+from functools import cached_property
+
 from nibabel.deprecated import deprecate_with_version
 
 # -----------------------------------------------------------------------------
@@ -28,22 +34,22 @@
 
 
 class ResetMixin:
-    """A Mixin class to add a .reset() method to users of OneTimeProperty.
+    """A Mixin class to add a .reset() method to users of cached_property.
 
-    By default, auto attributes once computed, become static.  If they happen
+    By default, cached properties, once computed, become static.  If they happen
     to depend on other parts of an object and those parts change, their values
     may now be invalid.
 
     This class offers a .reset() method that users can call *explicitly* when
     they know the state of their objects may have changed and they want to
     ensure that *all* their special attributes should be invalidated.  Once
-    reset() is called, all their auto attributes are reset to their
-    OneTimeProperty descriptors, and their accessor functions will be triggered
-    again.
+    reset() is called, all their cached properties are reset to their
+    :func:`~functools.cached_property` descriptors,
+    and their accessor functions will be triggered again.
 
     .. warning::
 
-       If a class has a set of attributes that are OneTimeProperty, but that
+       If a class has a set of attributes that are cached_property, but that
        can be initialized from any one of them, do NOT use this mixin!  For
        instance, UniformTimeSeries can be initialized with only sampling_rate
        and t0, sampling_interval and time are auto-computed.  But if you were
@@ -62,15 +68,15 @@ class ResetMixin:
     ...     def __init__(self,x=1.0):
     ...         self.x = x
     ...
-    ...     @auto_attr
+    ...     @cached_property
     ...     def y(self):
     ...         print('*** y computation executed ***')
     ...         return self.x / 2.0
-    ...
 
     >>> a = A(10)
 
     About to access y twice, the second time no computation is done:
+
     >>> a.y
     *** y computation executed ***
     5.0
@@ -78,17 +84,21 @@ class ResetMixin:
     5.0
 
     Changing x
+
     >>> a.x = 20
 
     a.y doesn't change to 10, since it is a static attribute:
+
     >>> a.y
     5.0
 
     We now reset a, and this will then force all auto attributes to recompute
     the next time we access them:
+
     >>> a.reset()
 
     About to access y twice again after reset():
+
     >>> a.y
     *** y computation executed ***
     10.0
@@ -96,82 +106,19 @@ class ResetMixin:
     10.0
     """
 
-    def reset(self):
-        """Reset all OneTimeProperty attributes that may have fired already."""
-        instdict = self.__dict__
-        classdict = self.__class__.__dict__
+    def reset(self) -> None:
+        """Reset all cached_property attributes that may have fired already."""
         # To reset them, we simply remove them from the instance dict.  At that
         # point, it's as if they had never been computed.  On the next access,
         # the accessor function from the parent class will be called, simply
         # because that's how the python descriptor protocol works.
-        for mname, mval in classdict.items():
-            if mname in instdict and isinstance(mval, OneTimeProperty):
+        for mname, mval in self.__class__.__dict__.items():
+            if mname in self.__dict__ and isinstance(mval, cached_property):
                 delattr(self, mname)
 
 
-class OneTimeProperty:
-    """A descriptor to make special properties that become normal attributes.
-
-    This is meant to be used mostly by the auto_attr decorator in this module.
-    """
-
-    def __init__(self, func):
-        """Create a OneTimeProperty instance.
-
-        Parameters
-        ----------
-          func : method
-
-          The method that will be called the first time to compute a value.
-          Afterwards, the method's name will be a standard attribute holding
-          the value of this computation.
-        """
-        self.getter = func
-        self.name = func.__name__
-
-    def __get__(self, obj, type=None):
-        """This will be called on attribute access on the class or instance."""
-        if obj is None:
-            # Being called on the class, return the original function. This
-            # way, introspection works on the class.
-            # return func
-            return self.getter
-
-        # Errors in the following line are errors in setting a
-        # OneTimeProperty
-        val = self.getter(obj)
-
-        setattr(obj, self.name, val)
-        return val
-
-
-def auto_attr(func):
-    """Decorator to create OneTimeProperty attributes.
-
-    Parameters
-    ----------
-      func : method
-        The method that will be called the first time to compute a value.
-        Afterwards, the method's name will be a standard attribute holding the
-        value of this computation.
-
-    Examples
-    --------
-    >>> class MagicProp:
-    ...     @auto_attr
-    ...     def a(self):
-    ...         return 99
-    ...
-    >>> x = MagicProp()
-    >>> 'a' in x.__dict__
-    False
-    >>> x.a
-    99
-    >>> 'a' in x.__dict__
-    True
-    """
-    return OneTimeProperty(func)
-
+OneTimeProperty = cached_property
+auto_attr = cached_property
 
 # -----------------------------------------------------------------------------
 # Deprecated API
diff --git a/nibabel/openers.py b/nibabel/openers.py
index d75839fe1a..2d95d48130 100644
--- a/nibabel/openers.py
+++ b/nibabel/openers.py
@@ -6,42 +6,40 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Context manager openers for various fileobject types
-"""
+"""Context manager openers for various fileobject types"""
+
+from __future__ import annotations
 
 import gzip
-import warnings
+import io
+import typing as ty
 from bz2 import BZ2File
 from os.path import splitext
 
-from packaging.version import Version
+from ._compression import HAVE_INDEXED_GZIP, IndexedGzipFile, pyzstd
 
-from nibabel.optpkg import optional_package
+if ty.TYPE_CHECKING:
+    from types import TracebackType
 
-# is indexed_gzip present and modern?
-try:
-    import indexed_gzip as igzip  # type: ignore
+    from _typeshed import WriteableBuffer
 
-    version = igzip.__version__
+    from ._typing import Self
 
-    HAVE_INDEXED_GZIP = True
+    ModeRT = ty.Literal['r', 'rt']
+    ModeRB = ty.Literal['rb']
+    ModeWT = ty.Literal['w', 'wt']
+    ModeWB = ty.Literal['wb']
+    ModeR = ty.Union[ModeRT, ModeRB]
+    ModeW = ty.Union[ModeWT, ModeWB]
+    Mode = ty.Union[ModeR, ModeW]
 
-    # < 0.7 - no good
-    if Version(version) < Version('0.7.0'):
-        warnings.warn(f'indexed_gzip is present, but too old (>= 0.7.0 required): {version})')
-        HAVE_INDEXED_GZIP = False
-    # >= 0.8 SafeIndexedGzipFile renamed to IndexedGzipFile
-    elif Version(version) < Version('0.8.0'):
-        IndexedGzipFile = igzip.SafeIndexedGzipFile
-    else:
-        IndexedGzipFile = igzip.IndexedGzipFile
-    del igzip, version
+    OpenerDef = tuple[ty.Callable[..., io.IOBase], tuple[str, ...]]
 
-except ImportError:
-    # nibabel.openers.IndexedGzipFile is imported by nibabel.volumeutils
-    # to detect compressed file types, so we give a fallback value here.
-    IndexedGzipFile = gzip.GzipFile
-    HAVE_INDEXED_GZIP = False
+
+@ty.runtime_checkable
+class Fileish(ty.Protocol):
+    def read(self, size: int = -1, /) -> bytes: ...
+    def write(self, b: bytes, /) -> int | None: ...
 
 
 class DeterministicGzipFile(gzip.GzipFile):
@@ -51,35 +49,62 @@ class DeterministicGzipFile(gzip.GzipFile):
     to a modification time (``mtime``) of 0 seconds.
     """
 
-    def __init__(self, filename=None, mode=None, compresslevel=9, fileobj=None, mtime=0):
-        # These two guards are copied from
+    def __init__(
+        self,
+        filename: str | None = None,
+        mode: Mode | None = None,
+        compresslevel: int = 9,
+        fileobj: io.FileIO | None = None,
+        mtime: int = 0,
+    ):
+        if mode is None:
+            mode = 'rb'
+        modestr: str = mode
+
+        # These two guards are adapted from
         # https://github.com/python/cpython/blob/6ab65c6/Lib/gzip.py#L171-L174
-        if mode and 'b' not in mode:
-            mode += 'b'
+        if 'b' not in modestr:
+            modestr = f'{mode}b'
         if fileobj is None:
-            fileobj = self.myfileobj = open(filename, mode or 'rb')
-        return super().__init__(
-            filename='', mode=mode, compresslevel=compresslevel, fileobj=fileobj, mtime=mtime
+            if filename is None:
+                raise TypeError('Must define either fileobj or filename')
+            # Cast because GzipFile.myfileobj has type io.FileIO while open returns ty.IO
+            fileobj = self.myfileobj = ty.cast('io.FileIO', open(filename, modestr))
+        super().__init__(
+            filename='',
+            mode=modestr,
+            compresslevel=compresslevel,
+            fileobj=fileobj,
+            mtime=mtime,
         )
 
 
-def _gzip_open(filename, mode='rb', compresslevel=9, mtime=0, keep_open=False):
+def _gzip_open(
+    filename: str,
+    mode: Mode = 'rb',
+    compresslevel: int = 9,
+    mtime: int = 0,
+    keep_open: bool = False,
+) -> gzip.GzipFile:
+    if not HAVE_INDEXED_GZIP or mode != 'rb':
+        gzip_file = DeterministicGzipFile(filename, mode, compresslevel, mtime=mtime)
 
     # use indexed_gzip if possible for faster read access.  If keep_open ==
     # True, we tell IndexedGzipFile to keep the file handle open. Otherwise
     # the IndexedGzipFile will close/open the file on each read.
-    if HAVE_INDEXED_GZIP and mode == 'rb':
-        gzip_file = IndexedGzipFile(filename, drop_handles=not keep_open)
-
-    # Fall-back to built-in GzipFile
     else:
-        gzip_file = DeterministicGzipFile(filename, mode, compresslevel, mtime=mtime)
+        gzip_file = IndexedGzipFile(filename, drop_handles=not keep_open)
 
     return gzip_file
 
 
-def _zstd_open(filename, mode='r', *, level_or_option=None, zstd_dict=None):
-    pyzstd = optional_package('pyzstd')[0]
+def _zstd_open(
+    filename: str,
+    mode: Mode = 'r',
+    *,
+    level_or_option: int | dict | None = None,
+    zstd_dict: pyzstd.ZstdDict | None = None,
+) -> pyzstd.ZstdFile:
     return pyzstd.ZstdFile(filename, mode, level_or_option=level_or_option, zstd_dict=zstd_dict)
 
 
@@ -103,10 +128,11 @@ class Opener:
         passed to opening method when `fileish` is str.  Change of defaults as
         for \*args
     """
+
     gz_def = (_gzip_open, ('mode', 'compresslevel', 'mtime', 'keep_open'))
     bz2_def = (BZ2File, ('mode', 'buffering', 'compresslevel'))
     zstd_def = (_zstd_open, ('mode', 'level_or_option', 'zstd_dict'))
-    compress_ext_map = {
+    compress_ext_map: dict[str | None, OpenerDef] = {
         '.gz': gz_def,
         '.bz2': bz2_def,
         '.zst': zstd_def,
@@ -123,19 +149,19 @@ class Opener:
         'w': default_zst_compresslevel,
     }
     #: whether to ignore case looking for compression extensions
-    compress_ext_icase = True
+    compress_ext_icase: bool = True
+
+    fobj: io.IOBase
 
-    def __init__(self, fileish, *args, **kwargs):
-        if self._is_fileobj(fileish):
+    def __init__(self, fileish: str | io.IOBase, *args, **kwargs):
+        if isinstance(fileish, (io.IOBase, Fileish)):
             self.fobj = fileish
             self.me_opened = False
-            self._name = None
+            self._name = getattr(fileish, 'name', None)
             return
         opener, arg_names = self._get_opener_argnames(fileish)
         # Get full arguments to check for mode and compresslevel
-        full_kwargs = kwargs.copy()
-        n_args = len(args)
-        full_kwargs.update(dict(zip(arg_names[:n_args], args)))
+        full_kwargs = {**kwargs, **dict(zip(arg_names, args))}
         # Set default mode
         if 'mode' not in full_kwargs:
             mode = 'rb'
@@ -157,7 +183,7 @@ def __init__(self, fileish, *args, **kwargs):
         self._name = fileish
         self.me_opened = True
 
-    def _get_opener_argnames(self, fileish):
+    def _get_opener_argnames(self, fileish: str) -> OpenerDef:
         _, ext = splitext(fileish)
         if self.compress_ext_icase:
             ext = ext.lower()
@@ -170,16 +196,12 @@ def _get_opener_argnames(self, fileish):
             return self.compress_ext_map[ext]
         return self.compress_ext_map[None]
 
-    def _is_fileobj(self, obj):
-        """Is `obj` a file-like object?"""
-        return hasattr(obj, 'read') and hasattr(obj, 'write')
-
     @property
-    def closed(self):
+    def closed(self) -> bool:
         return self.fobj.closed
 
     @property
-    def name(self):
+    def name(self) -> str | None:
         """Return ``self.fobj.name`` or self._name if not present
 
         self._name will be None if object was created with a fileobj, otherwise
@@ -188,42 +210,53 @@ def name(self):
         return self._name
 
     @property
-    def mode(self):
-        return self.fobj.mode
+    def mode(self) -> str:
+        # Check and raise our own error for type narrowing purposes
+        if hasattr(self.fobj, 'mode'):
+            return self.fobj.mode
+        raise AttributeError(f'{self.fobj.__class__.__name__} has no attribute "mode"')
 
-    def fileno(self):
+    def fileno(self) -> int:
         return self.fobj.fileno()
 
-    def read(self, *args, **kwargs):
-        return self.fobj.read(*args, **kwargs)
+    def read(self, size: int = -1, /) -> bytes:
+        return self.fobj.read(size)
 
-    def readinto(self, *args, **kwargs):
-        return self.fobj.readinto(*args, **kwargs)
+    def readinto(self, buffer: WriteableBuffer, /) -> int | None:
+        # Check and raise our own error for type narrowing purposes
+        if hasattr(self.fobj, 'readinto'):
+            return self.fobj.readinto(buffer)
+        raise AttributeError(f'{self.fobj.__class__.__name__} has no attribute "readinto"')
 
-    def write(self, *args, **kwargs):
-        return self.fobj.write(*args, **kwargs)
+    def write(self, b: bytes, /) -> int | None:
+        return self.fobj.write(b)
 
-    def seek(self, *args, **kwargs):
-        return self.fobj.seek(*args, **kwargs)
+    def seek(self, pos: int, whence: int = 0, /) -> int:
+        return self.fobj.seek(pos, whence)
 
-    def tell(self, *args, **kwargs):
-        return self.fobj.tell(*args, **kwargs)
+    def tell(self, /) -> int:
+        return self.fobj.tell()
 
-    def close(self, *args, **kwargs):
-        return self.fobj.close(*args, **kwargs)
+    def close(self, /) -> None:
+        return self.fobj.close()
 
-    def __iter__(self):
+    def __iter__(self) -> ty.Iterator[bytes]:
         return iter(self.fobj)
 
-    def close_if_mine(self):
+    def close_if_mine(self) -> None:
         """Close ``self.fobj`` iff we opened it in the constructor"""
         if self.me_opened:
             self.close()
 
-    def __enter__(self):
+    def __enter__(self) -> Self:
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
         self.close_if_mine()
 
 
diff --git a/nibabel/optpkg.py b/nibabel/optpkg.py
index d1eb9d17d5..90b8ded518 100644
--- a/nibabel/optpkg.py
+++ b/nibabel/optpkg.py
@@ -1,20 +1,34 @@
 """Routines to support optional packages"""
+
+from __future__ import annotations
+
+import typing as ty
+
 from packaging.version import Version
 
 from .tripwire import TripWire
 
+if ty.TYPE_CHECKING:
+    from types import ModuleType
 
-def _check_pkg_version(pkg, min_version):
-    # Default version checking function
-    if isinstance(min_version, str):
-        min_version = Version(min_version)
-    try:
-        return min_version <= Version(pkg.__version__)
-    except AttributeError:
+
+def _check_pkg_version(min_version: str | Version) -> ty.Callable[[ModuleType], bool]:
+    min_ver = Version(min_version) if isinstance(min_version, str) else min_version
+
+    def check(pkg: ModuleType) -> bool:
+        pkg_ver = getattr(pkg, '__version__', None)
+        if isinstance(pkg_ver, str):
+            return min_ver <= Version(pkg_ver)
         return False
 
+    return check
+
 
-def optional_package(name, trip_msg=None, min_version=None):
+def optional_package(
+    name: str,
+    trip_msg: str | None = None,
+    min_version: str | Version | ty.Callable[[ModuleType], bool] | None = None,
+) -> tuple[ModuleType | TripWire, bool, ty.Callable[[], None]]:
     """Return package-like thing and module setup for package `name`
 
     Parameters
@@ -81,7 +95,7 @@ def optional_package(name, trip_msg=None, min_version=None):
     elif min_version is None:
         check_version = lambda pkg: True
     else:
-        check_version = lambda pkg: _check_pkg_version(pkg, min_version)
+        check_version = _check_pkg_version(min_version)
     # fromlist=[''] results in submodule being returned, rather than the top
     # level module.  See help(__import__)
     fromlist = [''] if '.' in name else []
@@ -107,11 +121,11 @@ def optional_package(name, trip_msg=None, min_version=None):
         trip_msg = (
             f'We need package {name} for these functions, but ``import {name}`` raised {exc}'
         )
-    pkg = TripWire(trip_msg)
+    trip = TripWire(trip_msg)
 
-    def setup_module():
+    def setup_module() -> None:
         import unittest
 
         raise unittest.SkipTest(f'No {name} for these tests')
 
-    return pkg, False, setup_module
+    return trip, False, setup_module
diff --git a/nibabel/orientations.py b/nibabel/orientations.py
index f9e1ea028c..f1cdd228be 100644
--- a/nibabel/orientations.py
+++ b/nibabel/orientations.py
@@ -8,7 +8,6 @@
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Utilities for calculating and applying affine orientations"""
 
-
 import numpy as np
 import numpy.linalg as npl
 
@@ -125,7 +124,7 @@ def ornt_transform(start_ornt, end_ornt):
                 result[start_in_idx, :] = [end_in_idx, flip]
                 break
         else:
-            raise ValueError('Unable to find out axis %d in start_ornt' % end_out_idx)
+            raise ValueError(f'Unable to find out axis {end_out_idx} in start_ornt')
     return result
 
 
@@ -323,7 +322,7 @@ def axcodes2ornt(axcodes, labels=None):
            [ 2.,  1.]])
     """
     labels = list(zip('LPI', 'RAS')) if labels is None else labels
-    allowed_labels = sum([list(L) for L in labels], []) + [None]
+    allowed_labels = sum(map(list, labels), [None])
     if len(allowed_labels) != len(set(allowed_labels)):
         raise ValueError(f'Duplicate labels in {allowed_labels}')
     if not set(axcodes).issubset(allowed_labels):
diff --git a/nibabel/parrec.py b/nibabel/parrec.py
index 7c594dcb45..22520a603e 100644
--- a/nibabel/parrec.py
+++ b/nibabel/parrec.py
@@ -6,9 +6,7 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-# Disable line length checking for PAR fragments in module docstring
-# flake8: noqa E501
-"""Read images in PAR/REC format.
+"""Read images in PAR/REC format
 
 This is yet another MRI image format generated by Philips scanners. It is an
 ASCII header (PAR) plus a binary blob (REC).
@@ -784,10 +782,10 @@ def as_analyze_map(self):
         # Here we set the parameters we can to simplify PAR/REC
         # to NIfTI conversion.
         descr = (
-            f"{self.general_info['exam_name']};"
-            f"{self.general_info['patient_name']};"
-            f"{self.general_info['exam_date'].replace(' ', '')};"
-            f"{self.general_info['protocol_name']}"
+            f'{self.general_info["exam_name"]};'
+            f'{self.general_info["patient_name"]};'
+            f'{self.general_info["exam_date"].replace(" ", "")};'
+            f'{self.general_info["protocol_name"]}'
         )[:80]
         is_fmri = self.general_info['max_dynamics'] > 1
         # PAR/REC uses msec, but in _calc_zooms we convert to sec
@@ -1254,6 +1252,7 @@ class PARRECImage(SpatialImage):
     """PAR/REC image"""
 
     header_class = PARRECHeader
+    header: PARRECHeader
     valid_exts = ('.rec', '.par')
     files_types = (('image', '.rec'), ('header', '.par'))
 
@@ -1338,7 +1337,7 @@ def from_filename(
             strict_sort=strict_sort,
         )
 
-    load = from_filename  # type: ignore
+    load = from_filename  # type: ignore[assignment]
 
 
 load = PARRECImage.from_filename
diff --git a/nibabel/pkg_info.py b/nibabel/pkg_info.py
index 73dfd92ed2..7232806a0a 100644
--- a/nibabel/pkg_info.py
+++ b/nibabel/pkg_info.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import sys
+from contextlib import suppress
 from subprocess import run
 
 from packaging.version import Version
@@ -14,7 +15,7 @@
 COMMIT_HASH = '$Format:%h$'
 
 
-def _cmp(a, b) -> int:
+def _cmp(a: Version, b: Version) -> int:
     """Implementation of ``cmp`` for Python 3"""
     return (a > b) - (a < b)
 
@@ -101,19 +102,21 @@ def pkg_commit_hash(pkg_path: str | None = None) -> tuple[str, str]:
         return 'archive substitution', COMMIT_HASH
     ver = Version(__version__)
     if ver.local is not None and ver.local.startswith('g'):
-        return ver.local[1:8], 'installation'
-    # maybe we are in a repository
-    proc = run(
-        ('git', 'rev-parse', '--short', 'HEAD'),
-        capture_output=True,
-        cwd=pkg_path,
-    )
-    if proc.stdout:
-        return 'repository', proc.stdout.decode().strip()
+        return 'installation', ver.local[1:8]
+    # maybe we are in a repository, but consider that we may not have git
+    with suppress(FileNotFoundError):
+        proc = run(
+            ('git', 'rev-parse', '--short', 'HEAD'),
+            capture_output=True,
+            cwd=pkg_path,
+        )
+        if proc.stdout:
+            return 'repository', proc.stdout.decode().strip()
+
     return '(none found)', '<not found>'
 
 
-def get_pkg_info(pkg_path: str) -> dict:
+def get_pkg_info(pkg_path: str) -> dict[str, str]:
     """Return dict describing the context of this package
 
     Parameters
diff --git a/nibabel/pointset.py b/nibabel/pointset.py
new file mode 100644
index 0000000000..1d20b82fe5
--- /dev/null
+++ b/nibabel/pointset.py
@@ -0,0 +1,197 @@
+"""Point-set structures
+
+Imaging data are sampled at points in space, and these points
+can be described by coordinates.
+These structures are designed to enable operations on sets of
+points, as opposed to the data sampled at those points.
+
+Abstractly, a point set is any collection of points, but there are
+two types that warrant special consideration in the neuroimaging
+context: grids and meshes.
+
+A *grid* is a collection of regularly-spaced points. The canonical
+examples of grids are the indices of voxels and their affine
+projection into a reference space.
+
+A *mesh* is a collection of points and some structure that enables
+adjacent points to be identified. A *triangular mesh* in particular
+uses triplets of adjacent vertices to describe faces.
+"""
+
+from __future__ import annotations
+
+import math
+import typing as ty
+from dataclasses import dataclass, replace
+
+import numpy as np
+
+from nibabel.casting import able_int_type
+from nibabel.fileslice import strided_scalar
+from nibabel.spatialimages import SpatialImage
+
+if ty.TYPE_CHECKING:
+    from ._typing import Self, TypeVar
+
+    _DType = TypeVar('_DType', bound=np.dtype[ty.Any])
+
+
+class CoordinateArray(ty.Protocol):
+    ndim: int
+    shape: tuple[int, int]
+
+    @ty.overload
+    def __array__(self, dtype: None = ..., /) -> np.ndarray[ty.Any, np.dtype[ty.Any]]: ...
+
+    @ty.overload
+    def __array__(self, dtype: _DType, /) -> np.ndarray[ty.Any, _DType]: ...
+
+
+@dataclass
+class Pointset:
+    """A collection of points described by coordinates.
+
+    Parameters
+    ----------
+    coords : array-like
+      (*N*, *n*) array with *N* being points and columns their *n*-dimensional coordinates
+    affine : :class:`numpy.ndarray`
+      Affine transform to be applied to coordinates array
+    homogeneous : :class:`bool`
+      Indicate whether the provided coordinates are homogeneous,
+      i.e., homogeneous 3D coordinates have the form ``(x, y, z, 1)``
+    """
+
+    coordinates: CoordinateArray
+    affine: np.ndarray
+    homogeneous: bool = False
+
+    # Force use of __rmatmul__ with numpy arrays
+    __array_priority__ = 99
+
+    def __init__(
+        self,
+        coordinates: CoordinateArray,
+        affine: np.ndarray | None = None,
+        homogeneous: bool = False,
+    ):
+        self.coordinates = coordinates
+        self.homogeneous = homogeneous
+
+        if affine is None:
+            self.affine = np.eye(self.dim + 1)
+        else:
+            self.affine = np.asanyarray(affine)
+
+        if self.affine.shape != (self.dim + 1,) * 2:
+            raise ValueError(f'Invalid affine for {self.dim}D coordinates:\n{self.affine}')
+        if np.any(self.affine[-1, :-1] != 0) or self.affine[-1, -1] != 1:
+            raise ValueError(f'Invalid affine matrix:\n{self.affine}')
+
+    @property
+    def n_coords(self) -> int:
+        """Number of coordinates
+
+        Subclasses should override with more efficient implementations.
+        """
+        return self.coordinates.shape[0]
+
+    @property
+    def dim(self) -> int:
+        """The dimensionality of the space the coordinates are in"""
+        return self.coordinates.shape[1] - self.homogeneous
+
+    # Use __rmatmul__ to prefer to compose affines. Mypy does not like that
+    # this conflicts with ndarray.__matmul__. We will need some more feedback
+    # on how this plays out for type-checking or code suggestions before we
+    # can do better than ignore.
+    def __rmatmul__(self, affine: np.ndarray) -> Self:  # type: ignore[misc]
+        """Apply an affine transformation to the pointset
+
+        This will return a new pointset with an updated affine matrix only.
+        """
+        return replace(self, affine=np.asanyarray(affine) @ self.affine)
+
+    def _homogeneous_coords(self):
+        if self.homogeneous:
+            return np.asanyarray(self.coordinates)
+
+        ones = strided_scalar(
+            shape=(self.coordinates.shape[0], 1),
+            scalar=np.array(1, dtype=self.coordinates.dtype),
+        )
+        return np.hstack((self.coordinates, ones))
+
+    def get_coords(self, *, as_homogeneous: bool = False):
+        """Retrieve the coordinates
+
+        Parameters
+        ----------
+        as_homogeneous : :class:`bool`
+            Return homogeneous coordinates if ``True``, or Cartesian
+            coordinates if ``False``.
+
+        name : :class:`str`
+            Select a particular coordinate system if more than one may exist.
+            By default, `None` is equivalent to `"world"` and corresponds to
+            an RAS+ coordinate system.
+        """
+        ident = np.allclose(self.affine, np.eye(self.affine.shape[0]))
+        if self.homogeneous == as_homogeneous and ident:
+            return np.asanyarray(self.coordinates)
+        coords = self._homogeneous_coords()
+        if not ident:
+            coords = (self.affine @ coords.T).T
+        if not as_homogeneous:
+            coords = coords[:, :-1]
+        return coords
+
+
+class Grid(Pointset):
+    r"""A regularly-spaced collection of coordinates
+
+    This class provides factory methods for generating Pointsets from
+    :class:`~nibabel.spatialimages.SpatialImage`\s and generating masks
+    from coordinate sets.
+    """
+
+    @classmethod
+    def from_image(cls, spatialimage: SpatialImage) -> Self:
+        return cls(coordinates=GridIndices(spatialimage.shape[:3]), affine=spatialimage.affine)
+
+    @classmethod
+    def from_mask(cls, mask: SpatialImage) -> Self:
+        mask_arr = np.bool_(mask.dataobj)
+        return cls(
+            coordinates=np.c_[np.nonzero(mask_arr)].astype(able_int_type(mask.shape)),
+            affine=mask.affine,
+        )
+
+    def to_mask(self, shape=None) -> SpatialImage:
+        if shape is None:
+            shape = tuple(np.max(self.coordinates, axis=0)[: self.dim] + 1)
+        mask_arr = np.zeros(shape, dtype='bool')
+        mask_arr[tuple(np.asanyarray(self.coordinates)[:, : self.dim].T)] = True
+        return SpatialImage(mask_arr, self.affine)
+
+
+class GridIndices:
+    """Class for generating indices just-in-time"""
+
+    __slots__ = ('dtype', 'gridshape', 'shape')
+    ndim = 2
+
+    def __init__(self, shape, dtype=None):
+        self.gridshape = shape
+        self.dtype = dtype or able_int_type(shape)
+        self.shape = (math.prod(self.gridshape), len(self.gridshape))
+
+    def __repr__(self):
+        return f'<{self.__class__.__name__}{self.gridshape}>'
+
+    def __array__(self, dtype=None):
+        if dtype is None:
+            dtype = self.dtype
+
+        axes = [np.arange(s, dtype=dtype) for s in self.gridshape]
+        return np.reshape(np.meshgrid(*axes, copy=False, indexing='ij'), (len(axes), -1)).T
diff --git a/nibabel/processing.py b/nibabel/processing.py
index d0a01b52b3..673ceada63 100644
--- a/nibabel/processing.py
+++ b/nibabel/processing.py
@@ -6,13 +6,15 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Image processing functions for:
+"""Image processing functions
 
-* smoothing
-* resampling
-* converting sd to and from FWHM
+Image processing functions for:
 
-Smoothing and resampling routines need scipy
+    * smoothing
+    * resampling
+    * converting SD to and from FWHM
+
+Smoothing and resampling routines need scipy.
 """
 
 import numpy as np
@@ -20,7 +22,7 @@
 
 from .optpkg import optional_package
 
-spnd, _, _ = optional_package('scipy.ndimage')
+spnd = optional_package('scipy.ndimage')[0]
 
 from .affines import AffineError, append_diag, from_matvec, rescale_affine, to_matvec
 from .imageclasses import spatial_axes_first
@@ -318,6 +320,7 @@ def conform(
     out_shape=(256, 256, 256),
     voxel_size=(1.0, 1.0, 1.0),
     order=3,
+    mode='constant',
     cval=0.0,
     orientation='RAS',
     out_class=None,
@@ -351,6 +354,10 @@ def conform(
     order : int, optional
         The order of the spline interpolation, default is 3.  The order has to
         be in the range 0-5 (see ``scipy.ndimage.affine_transform``)
+    mode : str, optional
+        Points outside the boundaries of the input are filled according to the
+        given mode ('constant', 'nearest', 'reflect' or 'wrap'). Default is
+        'constant' (see :func:`scipy.ndimage.affine_transform`)
     cval : scalar, optional
         Value used for points outside the boundaries of the input if
         ``mode='constant'``. Default is 0.0 (see
@@ -391,7 +398,7 @@ def conform(
         from_img=from_img,
         to_vox_map=(out_shape, out_aff),
         order=order,
-        mode='constant',
+        mode=mode,
         cval=cval,
         out_class=out_class,
     )
diff --git a/nibabel/pydicom_compat.py b/nibabel/pydicom_compat.py
index 4d9df7df7b..76423b40a8 100644
--- a/nibabel/pydicom_compat.py
+++ b/nibabel/pydicom_compat.py
@@ -19,13 +19,22 @@
 
 A deprecated copy is available here for backward compatibility.
 """
+
 from __future__ import annotations
 
+import warnings
 from typing import Callable
 
 from .deprecated import deprecate_with_version
 from .optpkg import optional_package
 
+warnings.warn(
+    "We will remove the 'pydicom_compat' module from nibabel 7.0. "
+    "Please consult pydicom's documentation for any future needs.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
 pydicom, have_dicom, _ = optional_package('pydicom')
 
 read_file: Callable | None = None
@@ -34,8 +43,8 @@
 
 if have_dicom:
     # Values not imported by default
-    import pydicom.values  # type: ignore
-    from pydicom.dicomio import read_file  # noqa:F401
+    import pydicom.values  # type: ignore[import-not-found]
+    from pydicom.dicomio import dcmread as read_file  # noqa:F401
     from pydicom.sequence import Sequence  # noqa:F401
 
     tag_for_keyword = pydicom.datadict.tag_for_keyword
diff --git a/nibabel/quaternions.py b/nibabel/quaternions.py
index c14e5a2731..77cf8d2d3f 100644
--- a/nibabel/quaternions.py
+++ b/nibabel/quaternions.py
@@ -7,7 +7,7 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """
-Functions to operate on, or return, quaternions.
+Functions to operate on, or return, quaternions
 
 The module also includes functions for the closely related angle, axis
 pair as a specification for rotation.
@@ -30,7 +30,9 @@
 
 import numpy as np
 
-MAX_FLOAT = np.maximum_sctype(float)
+from .casting import sctypes
+
+MAX_FLOAT = sctypes['float'][-1]
 FLOAT_EPS = np.finfo(float).eps
 
 
@@ -42,10 +44,10 @@ def fillpositive(xyz, w2_thresh=None):
     xyz : iterable
        iterable containing 3 values, corresponding to quaternion x, y, z
     w2_thresh : None or float, optional
-       threshold to determine if w squared is really negative.
+       threshold to determine if w squared is non-zero.
        If None (default) then w2_thresh set equal to
-       ``-np.finfo(xyz.dtype).eps``, if possible, otherwise
-       ``-np.finfo(np.float64).eps``
+       3 * ``np.finfo(xyz.dtype).eps``, if possible, otherwise
+       3 * ``np.finfo(np.float64).eps``
 
     Returns
     -------
@@ -89,17 +91,17 @@ def fillpositive(xyz, w2_thresh=None):
     # If necessary, guess precision of input
     if w2_thresh is None:
         try:  # trap errors for non-array, integer array
-            w2_thresh = -np.finfo(xyz.dtype).eps * 3
+            w2_thresh = np.finfo(xyz.dtype).eps * 3
         except (AttributeError, ValueError):
-            w2_thresh = -FLOAT_EPS * 3
+            w2_thresh = FLOAT_EPS * 3
     # Use maximum precision
     xyz = np.asarray(xyz, dtype=MAX_FLOAT)
     # Calculate w
-    w2 = 1.0 - np.dot(xyz, xyz)
-    if w2 < 0:
-        if w2 < w2_thresh:
-            raise ValueError(f'w2 should be positive, but is {w2:e}')
+    w2 = 1.0 - xyz @ xyz
+    if np.abs(w2) < np.abs(w2_thresh):
         w = 0
+    elif w2 < 0:
+        raise ValueError(f'w2 should be positive, but is {w2:e}')
     else:
         w = np.sqrt(w2)
     return np.r_[w, xyz]
diff --git a/nibabel/rstutils.py b/nibabel/rstutils.py
index cb40633e54..1ba63f4339 100644
--- a/nibabel/rstutils.py
+++ b/nibabel/rstutils.py
@@ -52,7 +52,7 @@ def rst_table(
     cross = format_chars.pop('cross', '+')
     title_heading = format_chars.pop('title_heading', '*')
     if len(format_chars) != 0:
-        raise ValueError(f"Unexpected ``format_char`` keys {', '.join(format_chars)}")
+        raise ValueError(f'Unexpected ``format_char`` keys {", ".join(format_chars)}')
     down_joiner = ' ' + down + ' '
     down_starter = down + ' '
     down_ender = ' ' + down
diff --git a/nibabel/spatialimages.py b/nibabel/spatialimages.py
index 4bd25e986f..bce17e7341 100644
--- a/nibabel/spatialimages.py
+++ b/nibabel/spatialimages.py
@@ -129,20 +129,48 @@
     >>> np.all(img3.get_fdata(dtype=np.float32) == data)
     True
 """
+
 from __future__ import annotations
 
-from typing import Type
+import typing as ty
+from functools import cache
+from typing import Literal
 
 import numpy as np
 
+from ._typing import TypeVar
+from .casting import sctypes_aliases
 from .dataobj_images import DataobjImage
-from .filebasedimages import ImageFileError  # noqa
-from .filebasedimages import FileBasedHeader
+from .filebasedimages import FileBasedHeader, FileBasedImage
 from .fileslice import canonical_slicers
 from .orientations import apply_orientation, inv_ornt_aff
 from .viewers import OrthoSlicer3D
 from .volumeutils import shape_zoom_affine
 
+if ty.TYPE_CHECKING:
+    import io
+    from collections.abc import Sequence
+
+    import numpy.typing as npt
+
+    from ._typing import Self
+    from .arrayproxy import ArrayLike
+    from .fileholders import FileMap
+
+SpatialImgT = TypeVar('SpatialImgT', bound='SpatialImage')
+
+
+class HasDtype(ty.Protocol):
+    def get_data_dtype(self) -> np.dtype: ...
+    def set_data_dtype(self, dtype: npt.DTypeLike) -> None: ...
+
+
+@ty.runtime_checkable
+class SpatialProtocol(ty.Protocol):
+    def get_data_dtype(self) -> np.dtype: ...
+    def get_data_shape(self) -> tuple[int, ...]: ...
+    def get_zooms(self) -> tuple[float, ...]: ...
+
 
 class HeaderDataError(Exception):
     """Class to indicate error in getting or setting header data"""
@@ -152,13 +180,22 @@ class HeaderTypeError(Exception):
     """Class to indicate error in parameters into header functions"""
 
 
-class SpatialHeader(FileBasedHeader):
+class SpatialHeader(FileBasedHeader, SpatialProtocol):
     """Template class to implement header protocol"""
 
-    default_x_flip = True
-    data_layout = 'F'
+    default_x_flip: bool = True
+    data_layout: Literal['F', 'C'] = 'F'
 
-    def __init__(self, data_dtype=np.float32, shape=(0,), zooms=None):
+    _dtype: np.dtype
+    _shape: tuple[int, ...]
+    _zooms: tuple[float, ...]
+
+    def __init__(
+        self,
+        data_dtype: npt.DTypeLike = np.float32,
+        shape: Sequence[int] = (0,),
+        zooms: Sequence[float] | None = None,
+    ):
         self.set_data_dtype(data_dtype)
         self._zooms = ()
         self.set_data_shape(shape)
@@ -166,7 +203,10 @@ def __init__(self, data_dtype=np.float32, shape=(0,), zooms=None):
             self.set_zooms(zooms)
 
     @classmethod
-    def from_header(klass, header=None):
+    def from_header(
+        klass,
+        header: SpatialProtocol | FileBasedHeader | ty.Mapping | None = None,
+    ) -> Self:
         if header is None:
             return klass()
         # I can't do isinstance here because it is not necessarily true
@@ -175,26 +215,20 @@ def from_header(klass, header=None):
         # different field names
         if type(header) == klass:
             return header.copy()
-        return klass(header.get_data_dtype(), header.get_data_shape(), header.get_zooms())
-
-    @classmethod
-    def from_fileobj(klass, fileobj):
-        raise NotImplementedError
-
-    def write_to(self, fileobj):
-        raise NotImplementedError
-
-    def __eq__(self, other):
-        return (self.get_data_dtype(), self.get_data_shape(), self.get_zooms()) == (
-            other.get_data_dtype(),
-            other.get_data_shape(),
-            other.get_zooms(),
-        )
-
-    def __ne__(self, other):
-        return not self == other
+        if isinstance(header, SpatialProtocol):
+            return klass(header.get_data_dtype(), header.get_data_shape(), header.get_zooms())
+        return super().from_header(header)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, SpatialHeader):
+            return (self.get_data_dtype(), self.get_data_shape(), self.get_zooms()) == (
+                other.get_data_dtype(),
+                other.get_data_shape(),
+                other.get_zooms(),
+            )
+        return NotImplemented
 
-    def copy(self):
+    def copy(self) -> Self:
         """Copy object to independent representation
 
         The copy should not be affected by any changes to the original
@@ -202,47 +236,47 @@ def copy(self):
         """
         return self.__class__(self._dtype, self._shape, self._zooms)
 
-    def get_data_dtype(self):
+    def get_data_dtype(self) -> np.dtype:
         return self._dtype
 
-    def set_data_dtype(self, dtype):
+    def set_data_dtype(self, dtype: npt.DTypeLike) -> None:
         self._dtype = np.dtype(dtype)
 
-    def get_data_shape(self):
+    def get_data_shape(self) -> tuple[int, ...]:
         return self._shape
 
-    def set_data_shape(self, shape):
+    def set_data_shape(self, shape: Sequence[int]) -> None:
         ndim = len(shape)
         if ndim == 0:
             self._shape = (0,)
             self._zooms = (1.0,)
             return
-        self._shape = tuple([int(s) for s in shape])
+        self._shape = tuple(int(s) for s in shape)
         # set any unset zooms to 1.0
         nzs = min(len(self._zooms), ndim)
         self._zooms = self._zooms[:nzs] + (1.0,) * (ndim - nzs)
 
-    def get_zooms(self):
+    def get_zooms(self) -> tuple[float, ...]:
         return self._zooms
 
-    def set_zooms(self, zooms):
-        zooms = tuple([float(z) for z in zooms])
+    def set_zooms(self, zooms: Sequence[float]) -> None:
+        zooms = tuple(float(z) for z in zooms)
         shape = self.get_data_shape()
         ndim = len(shape)
         if len(zooms) != ndim:
-            raise HeaderDataError('Expecting %d zoom values for ndim %d' % (ndim, ndim))
-        if len([z for z in zooms if z < 0]):
+            raise HeaderDataError(f'Expecting {ndim} zoom values for ndim {ndim}')
+        if any(z < 0 for z in zooms):
             raise HeaderDataError('zooms must be positive')
         self._zooms = zooms
 
-    def get_base_affine(self):
+    def get_base_affine(self) -> np.ndarray:
         shape = self.get_data_shape()
         zooms = self.get_zooms()
         return shape_zoom_affine(shape, zooms, self.default_x_flip)
 
     get_best_affine = get_base_affine
 
-    def data_to_fileobj(self, data, fileobj, rescale=True):
+    def data_to_fileobj(self, data: npt.ArrayLike, fileobj: io.IOBase, rescale: bool = True):
         """Write array data `data` as binary to `fileobj`
 
         Parameters
@@ -259,7 +293,7 @@ def data_to_fileobj(self, data, fileobj, rescale=True):
         dtype = self.get_data_dtype()
         fileobj.write(data.astype(dtype).tobytes(order=self.data_layout))
 
-    def data_from_fileobj(self, fileobj):
+    def data_from_fileobj(self, fileobj: io.IOBase) -> np.ndarray:
         """Read binary image data from `fileobj`"""
         dtype = self.get_data_dtype()
         shape = self.get_data_shape()
@@ -268,7 +302,42 @@ def data_from_fileobj(self, fileobj):
         return np.ndarray(shape, dtype, data_bytes, order=self.data_layout)
 
 
-def supported_np_types(obj):
+@cache
+def _supported_np_types(klass: type[HasDtype]) -> set[type[np.generic]]:
+    """Numpy data types that instances of ``klass`` support
+
+    Parameters
+    ----------
+    klass : class
+        Class implementing `get_data_dtype` and `set_data_dtype` methods.  The object
+        should raise ``HeaderDataError`` for setting unsupported dtypes. The
+        object will likely be a header or a :class:`SpatialImage`
+
+    Returns
+    -------
+    np_types : set
+        set of numpy types that ``klass`` instances support
+    """
+    try:
+        obj = klass()
+    except TypeError as e:
+        if hasattr(klass, 'header_class'):
+            obj = klass.header_class()
+        else:
+            raise e
+    supported = set()
+    for np_type in sctypes_aliases:
+        try:
+            obj.set_data_dtype(np_type)
+        except HeaderDataError:
+            continue
+        # Did set work?
+        if np.dtype(obj.get_data_dtype()) == np.dtype(np_type):
+            supported.add(np_type)
+    return supported
+
+
+def supported_np_types(obj: HasDtype) -> set[type[np.generic]]:
     """Numpy data types that instance `obj` supports
 
     Parameters
@@ -283,33 +352,22 @@ def supported_np_types(obj):
     np_types : set
         set of numpy types that `obj` supports
     """
-    dt = obj.get_data_dtype()
-    supported = []
-    for name, np_types in np.sctypes.items():
-        for np_type in np_types:
-            try:
-                obj.set_data_dtype(np_type)
-            except HeaderDataError:
-                continue
-            # Did set work?
-            if np.dtype(obj.get_data_dtype()) == np.dtype(np_type):
-                supported.append(np_type)
-    # Reset original header dtype
-    obj.set_data_dtype(dt)
-    return set(supported)
+    return _supported_np_types(obj.__class__)
 
 
 class ImageDataError(Exception):
     pass
 
 
-class SpatialFirstSlicer:
+class SpatialFirstSlicer(ty.Generic[SpatialImgT]):
     """Slicing interface that returns a new image with an updated affine
 
     Checks that an image's first three axes are spatial
     """
 
-    def __init__(self, img):
+    img: SpatialImgT
+
+    def __init__(self, img: SpatialImgT):
         # Local import to avoid circular import on module load
         from .imageclasses import spatial_axes_first
 
@@ -319,7 +377,7 @@ def __init__(self, img):
             )
         self.img = img
 
-    def __getitem__(self, slicer):
+    def __getitem__(self, slicer: object) -> SpatialImgT:
         try:
             slicer = self.check_slicing(slicer)
         except ValueError as err:
@@ -332,7 +390,11 @@ def __getitem__(self, slicer):
         affine = self.slice_affine(slicer)
         return self.img.__class__(dataobj.copy(), affine, self.img.header)
 
-    def check_slicing(self, slicer, return_spatial=False):
+    def check_slicing(
+        self,
+        slicer: object,
+        return_spatial: bool = False,
+    ) -> tuple[slice | int | None, ...]:
         """Canonicalize slicers and check for scalar indices in spatial dims
 
         Parameters
@@ -349,11 +411,11 @@ def check_slicing(self, slicer, return_spatial=False):
             Validated slicer object that will slice image's `dataobj`
             without collapsing spatial dimensions
         """
-        slicer = canonical_slicers(slicer, self.img.shape)
+        canonical = canonical_slicers(slicer, self.img.shape)
         # We can get away with this because we've checked the image's
         # first three axes are spatial.
         # More general slicers will need to be smarter, here.
-        spatial_slices = slicer[:3]
+        spatial_slices = canonical[:3]
         for subslicer in spatial_slices:
             if subslicer is None:
                 raise IndexError('New axis not permitted in spatial dimensions')
@@ -361,9 +423,9 @@ def check_slicing(self, slicer, return_spatial=False):
                 raise IndexError(
                     'Scalar indices disallowed in spatial dimensions; Use `[x]` or `x:x+1`.'
                 )
-        return spatial_slices if return_spatial else slicer
+        return spatial_slices if return_spatial else canonical
 
-    def slice_affine(self, slicer):
+    def slice_affine(self, slicer: object) -> np.ndarray:
         """Retrieve affine for current image, if sliced by a given index
 
         Applies scaling if down-sampling is applied, and adjusts the intercept
@@ -403,10 +465,20 @@ def slice_affine(self, slicer):
 class SpatialImage(DataobjImage):
     """Template class for volumetric (3D/4D) images"""
 
-    header_class: Type[SpatialHeader] = SpatialHeader
-    ImageSlicer = SpatialFirstSlicer
+    header_class: type[SpatialHeader] = SpatialHeader
+    ImageSlicer: type[SpatialFirstSlicer] = SpatialFirstSlicer
+
+    _header: SpatialHeader
+    header: SpatialHeader
 
-    def __init__(self, dataobj, affine, header=None, extra=None, file_map=None):
+    def __init__(
+        self,
+        dataobj: ArrayLike,
+        affine: np.ndarray | None,
+        header: FileBasedHeader | ty.Mapping | None = None,
+        extra: ty.Mapping | None = None,
+        file_map: FileMap | None = None,
+    ):
         """Initialize image
 
         The image is a combination of (array-like, affine matrix, header), with
@@ -456,7 +528,7 @@ def __init__(self, dataobj, affine, header=None, extra=None, file_map=None):
     def affine(self):
         return self._affine
 
-    def update_header(self):
+    def update_header(self) -> None:
         """Harmonize header with image data and affine
 
         >>> data = np.zeros((2,3,4))
@@ -485,8 +557,9 @@ def update_header(self):
             return
         self._affine2header()
 
-    def _affine2header(self):
+    def _affine2header(self) -> None:
         """Unconditionally set affine into the header"""
+        assert self._affine is not None
         RZS = self._affine[:3, :3]
         vox = np.sqrt(np.sum(RZS * RZS, axis=0))
         hdr = self._header
@@ -495,7 +568,7 @@ def _affine2header(self):
         zooms[:n_to_set] = vox[:n_to_set]
         hdr.set_zooms(zooms)
 
-    def __str__(self):
+    def __str__(self) -> str:
         shape = self.shape
         affine = self.affine
         return f"""
@@ -507,14 +580,14 @@ def __str__(self):
 {self._header}
 """
 
-    def get_data_dtype(self):
+    def get_data_dtype(self) -> np.dtype:
         return self._header.get_data_dtype()
 
-    def set_data_dtype(self, dtype):
+    def set_data_dtype(self, dtype: npt.DTypeLike) -> None:
         self._header.set_data_dtype(dtype)
 
     @classmethod
-    def from_image(klass, img):
+    def from_image(klass, img: SpatialImage | FileBasedImage) -> Self:
         """Class method to create new instance of own class from `img`
 
         Parameters
@@ -528,15 +601,17 @@ def from_image(klass, img):
         cimg : ``spatialimage`` instance
            Image, of our own class
         """
-        return klass(
-            img.dataobj,
-            img.affine,
-            klass.header_class.from_header(img.header),
-            extra=img.extra.copy(),
-        )
+        if isinstance(img, SpatialImage):
+            return klass(
+                img.dataobj,
+                img.affine,
+                klass.header_class.from_header(img.header),
+                extra=img.extra.copy(),
+            )
+        return super().from_image(img)
 
     @property
-    def slicer(self):
+    def slicer(self) -> SpatialFirstSlicer[Self]:
         """Slicer object that returns cropped and subsampled images
 
         The image is resliced in the current orientation; no rotation or
@@ -555,7 +630,7 @@ def slicer(self):
         """
         return self.ImageSlicer(self)
 
-    def __getitem__(self, idx):
+    def __getitem__(self, idx: object) -> None:
         """No slicing or dictionary interface for images
 
         Use the slicer attribute to perform cropping and subsampling at your
@@ -568,7 +643,7 @@ def __getitem__(self, idx):
             '`img.get_fdata()[slice]`'
         )
 
-    def orthoview(self):
+    def orthoview(self) -> OrthoSlicer3D:
         """Plot the image using OrthoSlicer3D
 
         Returns
@@ -584,7 +659,7 @@ def orthoview(self):
         """
         return OrthoSlicer3D(self.dataobj, self.affine, title=self.get_filename())
 
-    def as_reoriented(self, ornt):
+    def as_reoriented(self, ornt: Sequence[Sequence[int]]) -> Self:
         """Apply an orientation change and return a new image
 
         If ornt is identity transform, return the original image, unchanged
diff --git a/nibabel/spm2analyze.py b/nibabel/spm2analyze.py
index 67389403b9..9c4c544cf5 100644
--- a/nibabel/spm2analyze.py
+++ b/nibabel/spm2analyze.py
@@ -7,11 +7,12 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Read / write access to SPM2 version of analyze image format"""
+
 import numpy as np
 
 from . import spm99analyze as spm99  # module import
 
-image_dimension_dtd = spm99.image_dimension_dtd[:]
+image_dimension_dtd = spm99.image_dimension_dtd.copy()
 image_dimension_dtd[image_dimension_dtd.index(('funused2', 'f4'))] = ('scl_inter', 'f4')
 
 # Full header numpy dtype combined across sub-fields
@@ -128,7 +129,8 @@ class Spm2AnalyzeImage(spm99.Spm99AnalyzeImage):
     """Class for SPM2 variant of basic Analyze image"""
 
     header_class = Spm2AnalyzeHeader
+    header: Spm2AnalyzeHeader
 
 
-load = Spm2AnalyzeImage.load
+load = Spm2AnalyzeImage.from_filename
 save = Spm2AnalyzeImage.instance_to_filename
diff --git a/nibabel/spm99analyze.py b/nibabel/spm99analyze.py
index a089bedb02..cdedf223e0 100644
--- a/nibabel/spm99analyze.py
+++ b/nibabel/spm99analyze.py
@@ -7,6 +7,7 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Read / write access to SPM99 version of analyze image format"""
+
 import warnings
 from io import BytesIO
 
@@ -22,10 +23,10 @@
 """ Support subtle variations of SPM version of Analyze """
 header_key_dtd = analyze.header_key_dtd
 # funused1 in dime subfield is scalefactor
-image_dimension_dtd = analyze.image_dimension_dtd[:]
+image_dimension_dtd = analyze.image_dimension_dtd.copy()
 image_dimension_dtd[image_dimension_dtd.index(('funused1', 'f4'))] = ('scl_slope', 'f4')
 # originator text field used as image origin (translations)
-data_history_dtd = analyze.data_history_dtd[:]
+data_history_dtd = analyze.data_history_dtd.copy()
 data_history_dtd[data_history_dtd.index(('originator', 'S10'))] = ('origin', 'i2', (5,))
 
 # Full header numpy dtype combined across sub-fields
@@ -227,6 +228,7 @@ class Spm99AnalyzeImage(analyze.AnalyzeImage):
     """Class for SPM99 variant of basic Analyze image"""
 
     header_class = Spm99AnalyzeHeader
+    header: Spm99AnalyzeHeader
     files_types = (('image', '.img'), ('header', '.hdr'), ('mat', '.mat'))
     has_affine = True
     makeable = True
@@ -239,7 +241,7 @@ def from_file_map(klass, file_map, *, mmap=True, keep_file_open=None):
         Parameters
         ----------
         file_map : dict
-            Mapping with (kay, value) pairs of (``file_type``, FileHolder
+            Mapping with (key, value) pairs of (``file_type``, FileHolder
             instance giving file-likes for each file needed for this image
             type.
         mmap : {True, False, 'c', 'r'}, optional, keyword only
@@ -274,7 +276,7 @@ def from_file_map(klass, file_map, *, mmap=True, keep_file_open=None):
             contents = matf.read()
         if len(contents) == 0:
             return ret
-        import scipy.io as sio  # type: ignore
+        import scipy.io as sio  # type: ignore[import]
 
         mats = sio.loadmat(BytesIO(contents))
         if 'mat' in mats:  # this overrides a 'M', and includes any flip
@@ -331,5 +333,5 @@ def to_file_map(self, file_map=None, dtype=None):
             sio.savemat(mfobj, {'M': M, 'mat': mat}, format='4')
 
 
-load = Spm99AnalyzeImage.load
+load = Spm99AnalyzeImage.from_filename
 save = Spm99AnalyzeImage.instance_to_filename
diff --git a/nibabel/streamlines/__init__.py b/nibabel/streamlines/__init__.py
index f99f80e4e4..02e11e4f29 100644
--- a/nibabel/streamlines/__init__.py
+++ b/nibabel/streamlines/__init__.py
@@ -1,5 +1,5 @@
-"""Multiformat-capable streamline format read / write interface
-"""
+"""Multiformat-capable streamline format read / write interface"""
+
 import os
 import warnings
 
@@ -125,13 +125,12 @@ def save(tractogram, filename, **kwargs):
         tractogram_file = tractogram
         if tractogram_file_class is None or not isinstance(tractogram_file, tractogram_file_class):
             msg = (
-                'The extension you specified is unusual for the provided'
-                " 'TractogramFile' object."
+                "The extension you specified is unusual for the provided 'TractogramFile' object."
             )
             warnings.warn(msg, ExtensionWarning)
 
         if kwargs:
-            msg = "A 'TractogramFile' object was provided, no need for" ' keyword arguments.'
+            msg = "A 'TractogramFile' object was provided, no need for keyword arguments."
             raise ValueError(msg)
 
     tractogram_file.save(filename)
diff --git a/nibabel/streamlines/array_sequence.py b/nibabel/streamlines/array_sequence.py
index faa5d2390d..63336352bd 100644
--- a/nibabel/streamlines/array_sequence.py
+++ b/nibabel/streamlines/array_sequence.py
@@ -72,7 +72,7 @@ def fn_binary_op(self, value):
         fn.__name__ = op
         fn.__doc__ = getattr(np.ndarray, op).__doc__
 
-    for op in [
+    for op in (
         '__add__',
         '__sub__',
         '__mul__',
@@ -85,14 +85,14 @@ def fn_binary_op(self, value):
         '__or__',
         '__and__',
         '__xor__',
-    ]:
+    ):
         _wrap(cls, op=op, inplace=False)
-        _wrap(cls, op=f"__i{op.strip('_')}__", inplace=True)
+        _wrap(cls, op=f'__i{op.strip("_")}__', inplace=True)
 
-    for op in ['__eq__', '__ne__', '__lt__', '__le__', '__gt__', '__ge__']:
+    for op in ('__eq__', '__ne__', '__lt__', '__le__', '__gt__', '__ge__'):
         _wrap(cls, op)
 
-    for op in ['__neg__', '__abs__', '__invert__']:
+    for op in ('__neg__', '__abs__', '__invert__'):
         _wrap(cls, op, unary=True)
 
     return cls
diff --git a/nibabel/streamlines/header.py b/nibabel/streamlines/header.py
index 2aed10c62c..a3b52b0747 100644
--- a/nibabel/streamlines/header.py
+++ b/nibabel/streamlines/header.py
@@ -1,5 +1,4 @@
-"""Field class defining common header fields in tractogram files
-"""
+"""Field class defining common header fields in tractogram files"""
 
 
 class Field:
diff --git a/nibabel/streamlines/tck.py b/nibabel/streamlines/tck.py
index 43df2f87e0..358c579362 100644
--- a/nibabel/streamlines/tck.py
+++ b/nibabel/streamlines/tck.py
@@ -309,7 +309,6 @@ def _read_header(cls, fileobj):
         offset_data = 0
 
         with Opener(fileobj) as f:
-
             # Record start position
             start_position = f.tell()
 
diff --git a/nibabel/streamlines/tests/test_array_sequence.py b/nibabel/streamlines/tests/test_array_sequence.py
index 0c8557fe50..22327b9a31 100644
--- a/nibabel/streamlines/tests/test_array_sequence.py
+++ b/nibabel/streamlines/tests/test_array_sequence.py
@@ -1,6 +1,5 @@
 import itertools
 import os
-import sys
 import tempfile
 import unittest
 
@@ -80,7 +79,7 @@ def test_creating_arraysequence_from_list(self):
         # List of ndarrays.
         N = 5
         for ndim in range(1, N + 1):
-            common_shape = tuple([SEQ_DATA['rng'].randint(1, 10) for _ in range(ndim - 1)])
+            common_shape = tuple(SEQ_DATA['rng'].randint(1, 10) for _ in range(ndim - 1))
             data = generate_data(nb_arrays=5, common_shape=common_shape, rng=SEQ_DATA['rng'])
             check_arr_seq(ArraySequence(data), data)
 
@@ -220,7 +219,7 @@ def test_arraysequence_extend(self):
             seq.extend(data)
 
         # Extend after extracting some slice
-        working_slice = seq[:2]
+        _ = seq[:2]
         seq.extend(ArraySequence(new_data))
 
     def test_arraysequence_getitem(self):
@@ -398,7 +397,7 @@ def _test_binary(op, arrseq, scalars, seqs, inplace=False):
             if op in CMP_OPS:
                 continue
 
-            op = f"__i{op.strip('_')}__"
+            op = f'__i{op.strip("_")}__'
             _test_binary(op, seq, SCALARS, ARRSEQS, inplace=True)
 
             if op == '__itruediv__':
diff --git a/nibabel/streamlines/tests/test_streamlines.py b/nibabel/streamlines/tests/test_streamlines.py
index dfb74042a3..8811ddcfa0 100644
--- a/nibabel/streamlines/tests/test_streamlines.py
+++ b/nibabel/streamlines/tests/test_streamlines.py
@@ -1,5 +1,4 @@
 import os
-import tempfile
 import unittest
 import warnings
 from io import BytesIO
@@ -7,7 +6,6 @@
 
 import numpy as np
 import pytest
-from numpy.compat.py3k import asbytes
 
 import nibabel as nib
 from nibabel.testing import clear_and_catch_warnings, data_path, error_warnings
@@ -21,7 +19,7 @@
 DATA = {}
 
 
-def setup():
+def setup_module():
     global DATA
     DATA['empty_filenames'] = [pjoin(data_path, 'empty' + ext) for ext in FORMATS.keys()]
     DATA['simple_filenames'] = [pjoin(data_path, 'simple' + ext) for ext in FORMATS.keys()]
@@ -84,7 +82,7 @@ def setup():
     )
 
 
-def test_is_supported_detect_format():
+def test_is_supported_detect_format(tmp_path):
     # Test is_supported and detect_format functions
     # Empty file/string
     f = BytesIO()
@@ -96,22 +94,24 @@ def test_is_supported_detect_format():
     # Valid file without extension
     for tfile_cls in FORMATS.values():
         f = BytesIO()
-        f.write(asbytes(tfile_cls.MAGIC_NUMBER))
+        f.write(tfile_cls.MAGIC_NUMBER)
         f.seek(0, os.SEEK_SET)
         assert nib.streamlines.is_supported(f)
         assert nib.streamlines.detect_format(f) is tfile_cls
 
     # Wrong extension but right magic number
     for tfile_cls in FORMATS.values():
-        with tempfile.TemporaryFile(mode='w+b', suffix='.txt') as f:
-            f.write(asbytes(tfile_cls.MAGIC_NUMBER))
+        fpath = tmp_path / 'test.txt'
+        with open(fpath, 'w+b') as f:
+            f.write(tfile_cls.MAGIC_NUMBER)
             f.seek(0, os.SEEK_SET)
             assert nib.streamlines.is_supported(f)
             assert nib.streamlines.detect_format(f) is tfile_cls
 
     # Good extension but wrong magic number
     for ext, tfile_cls in FORMATS.items():
-        with tempfile.TemporaryFile(mode='w+b', suffix=ext) as f:
+        fpath = tmp_path / f'test{ext}'
+        with open(fpath, 'w+b') as f:
             f.write(b'pass')
             f.seek(0, os.SEEK_SET)
             assert not nib.streamlines.is_supported(f)
@@ -191,13 +191,13 @@ def test_save_tractogram_file(self):
         trk_file = trk.TrkFile(tractogram)
 
         # No need for keyword arguments.
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             nib.streamlines.save(trk_file, 'dummy.trk', header={})
 
         # Wrong extension.
         with pytest.warns(ExtensionWarning, match='extension'):
             trk_file = trk.TrkFile(tractogram)
-            with self.assertRaises(ValueError):
+            with pytest.raises(ValueError):
                 nib.streamlines.save(trk_file, 'dummy.tck', header={})
 
         with InTemporaryDirectory():
@@ -207,7 +207,7 @@ def test_save_tractogram_file(self):
 
     def test_save_empty_file(self):
         tractogram = Tractogram(affine_to_rasmm=np.eye(4))
-        for ext, cls in FORMATS.items():
+        for ext in FORMATS:
             with InTemporaryDirectory():
                 filename = 'streamlines' + ext
                 nib.streamlines.save(tractogram, filename)
@@ -216,7 +216,7 @@ def test_save_empty_file(self):
 
     def test_save_simple_file(self):
         tractogram = Tractogram(DATA['streamlines'], affine_to_rasmm=np.eye(4))
-        for ext, cls in FORMATS.items():
+        for ext in FORMATS:
             with InTemporaryDirectory():
                 filename = 'streamlines' + ext
                 nib.streamlines.save(tractogram, filename)
@@ -262,7 +262,7 @@ def test_save_complex_file(self):
     def test_save_sliced_tractogram(self):
         tractogram = Tractogram(DATA['streamlines'], affine_to_rasmm=np.eye(4))
         original_tractogram = tractogram.copy()
-        for ext, cls in FORMATS.items():
+        for ext in FORMATS:
             with InTemporaryDirectory():
                 filename = 'streamlines' + ext
                 nib.streamlines.save(tractogram[::2], filename)
@@ -272,18 +272,18 @@ def test_save_sliced_tractogram(self):
                 assert_tractogram_equal(tractogram, original_tractogram)
 
     def test_load_unknown_format(self):
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             nib.streamlines.load('')
 
     def test_save_unknown_format(self):
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             nib.streamlines.save(Tractogram(), '')
 
     def test_save_from_generator(self):
         tractogram = Tractogram(DATA['streamlines'], affine_to_rasmm=np.eye(4))
 
         # Just to create a generator
-        for ext, _ in FORMATS.items():
+        for ext in FORMATS:
             filtered = (s for s in tractogram.streamlines if True)
             lazy_tractogram = LazyTractogram(lambda: filtered, affine_to_rasmm=np.eye(4))
 
diff --git a/nibabel/streamlines/tests/test_tck.py b/nibabel/streamlines/tests/test_tck.py
index 3df7dd4f2d..083ab8e6e9 100644
--- a/nibabel/streamlines/tests/test_tck.py
+++ b/nibabel/streamlines/tests/test_tck.py
@@ -8,7 +8,6 @@
 from numpy.testing import assert_array_equal
 
 from ...testing import data_path, error_warnings
-from .. import tck as tck_module
 from ..array_sequence import ArraySequence
 from ..tck import TckFile
 from ..tractogram import Tractogram
@@ -138,7 +137,7 @@ def test_load_file_with_wrong_information(self):
 
         # Simulate a TCK file with no `file` field.
         new_tck_file = tck_file.replace(b'\nfile: . 67', b'')
-        with pytest.warns(HeaderWarning, match="Missing 'file'") as w:
+        with pytest.warns(HeaderWarning, match="Missing 'file'"):
             tck = TckFile.load(BytesIO(new_tck_file))
         assert_array_equal(tck.header['file'], '. 56')
 
diff --git a/nibabel/streamlines/tests/test_tractogram.py b/nibabel/streamlines/tests/test_tractogram.py
index 30294be438..72b84fac6e 100644
--- a/nibabel/streamlines/tests/test_tractogram.py
+++ b/nibabel/streamlines/tests/test_tractogram.py
@@ -1,6 +1,5 @@
 import copy
 import operator
-import sys
 import unittest
 import warnings
 from collections import defaultdict
@@ -50,8 +49,8 @@ def make_fake_tractogram(
 ):
     """Make multiple streamlines according to provided requirements."""
     all_streamlines = []
-    all_data_per_point = defaultdict(lambda: [])
-    all_data_per_streamline = defaultdict(lambda: [])
+    all_data_per_point = defaultdict(list)
+    all_data_per_streamline = defaultdict(list)
     for nb_points in list_nb_points:
         data = make_fake_streamline(
             nb_points, data_per_point_shapes, data_for_streamline_shapes, rng
@@ -80,6 +79,7 @@ def make_dummy_streamline(nb_points):
             'mean_curvature': np.array([1.11], dtype='f4'),
             'mean_torsion': np.array([1.22], dtype='f4'),
             'mean_colors': np.array([1, 0, 0], dtype='f4'),
+            'clusters_labels': np.array([0, 1], dtype='i4'),
         }
 
     elif nb_points == 2:
@@ -92,6 +92,7 @@ def make_dummy_streamline(nb_points):
             'mean_curvature': np.array([2.11], dtype='f4'),
             'mean_torsion': np.array([2.22], dtype='f4'),
             'mean_colors': np.array([0, 1, 0], dtype='f4'),
+            'clusters_labels': np.array([2, 3, 4], dtype='i4'),
         }
 
     elif nb_points == 5:
@@ -104,6 +105,7 @@ def make_dummy_streamline(nb_points):
             'mean_curvature': np.array([3.11], dtype='f4'),
             'mean_torsion': np.array([3.22], dtype='f4'),
             'mean_colors': np.array([0, 0, 1], dtype='f4'),
+            'clusters_labels': np.array([5, 6, 7, 8], dtype='i4'),
         }
 
     return streamline, data_per_point, data_for_streamline
@@ -119,6 +121,7 @@ def setup_module():
     DATA['mean_curvature'] = []
     DATA['mean_torsion'] = []
     DATA['mean_colors'] = []
+    DATA['clusters_labels'] = []
     for nb_points in [1, 2, 5]:
         data = make_dummy_streamline(nb_points)
         streamline, data_per_point, data_for_streamline = data
@@ -128,12 +131,14 @@ def setup_module():
         DATA['mean_curvature'].append(data_for_streamline['mean_curvature'])
         DATA['mean_torsion'].append(data_for_streamline['mean_torsion'])
         DATA['mean_colors'].append(data_for_streamline['mean_colors'])
+        DATA['clusters_labels'].append(data_for_streamline['clusters_labels'])
 
     DATA['data_per_point'] = {'colors': DATA['colors'], 'fa': DATA['fa']}
     DATA['data_per_streamline'] = {
         'mean_curvature': DATA['mean_curvature'],
         'mean_torsion': DATA['mean_torsion'],
         'mean_colors': DATA['mean_colors'],
+        'clusters_labels': DATA['clusters_labels'],
     }
 
     DATA['empty_tractogram'] = Tractogram(affine_to_rasmm=np.eye(4))
@@ -154,6 +159,7 @@ def setup_module():
         'mean_curvature': lambda: (e for e in DATA['mean_curvature']),
         'mean_torsion': lambda: (e for e in DATA['mean_torsion']),
         'mean_colors': lambda: (e for e in DATA['mean_colors']),
+        'clusters_labels': lambda: (e for e in DATA['clusters_labels']),
     }
 
     DATA['lazy_tractogram'] = LazyTractogram(
@@ -165,7 +171,6 @@ def setup_module():
 
 
 def check_tractogram_item(tractogram_item, streamline, data_for_streamline={}, data_for_points={}):
-
     assert_array_equal(tractogram_item.streamline, streamline)
 
     assert len(tractogram_item.data_for_streamline) == len(data_for_streamline)
@@ -214,7 +219,10 @@ def test_per_array_dict_creation(self):
         data_dict = PerArrayDict(nb_streamlines, data_per_streamline)
         assert data_dict.keys() == data_per_streamline.keys()
         for k in data_dict.keys():
-            assert_array_equal(data_dict[k], data_per_streamline[k])
+            if isinstance(data_dict[k], np.ndarray) and np.all(
+                data_dict[k].shape[0] == data_dict[k].shape
+            ):
+                assert_array_equal(data_dict[k], data_per_streamline[k])
 
         del data_dict['mean_curvature']
         assert len(data_dict) == len(data_per_streamline) - 1
@@ -224,7 +232,10 @@ def test_per_array_dict_creation(self):
         data_dict = PerArrayDict(nb_streamlines, data_per_streamline)
         assert data_dict.keys() == data_per_streamline.keys()
         for k in data_dict.keys():
-            assert_array_equal(data_dict[k], data_per_streamline[k])
+            if isinstance(data_dict[k], np.ndarray) and np.all(
+                data_dict[k].shape[0] == data_dict[k].shape
+            ):
+                assert_array_equal(data_dict[k], data_per_streamline[k])
 
         del data_dict['mean_curvature']
         assert len(data_dict) == len(data_per_streamline) - 1
@@ -234,7 +245,10 @@ def test_per_array_dict_creation(self):
         data_dict = PerArrayDict(nb_streamlines, **data_per_streamline)
         assert data_dict.keys() == data_per_streamline.keys()
         for k in data_dict.keys():
-            assert_array_equal(data_dict[k], data_per_streamline[k])
+            if isinstance(data_dict[k], np.ndarray) and np.all(
+                data_dict[k].shape[0] == data_dict[k].shape
+            ):
+                assert_array_equal(data_dict[k], data_per_streamline[k])
 
         del data_dict['mean_curvature']
         assert len(data_dict) == len(data_per_streamline) - 1
@@ -261,6 +275,7 @@ def test_extend(self):
             'mean_curvature': 2 * np.array(DATA['mean_curvature']),
             'mean_torsion': 3 * np.array(DATA['mean_torsion']),
             'mean_colors': 4 * np.array(DATA['mean_colors']),
+            'clusters_labels': 5 * np.array(DATA['clusters_labels'], dtype=object),
         }
         sdict2 = PerArrayDict(len(DATA['tractogram']), new_data)
 
@@ -284,7 +299,8 @@ def test_extend(self):
             'mean_curvature': 2 * np.array(DATA['mean_curvature']),
             'mean_torsion': 3 * np.array(DATA['mean_torsion']),
             'mean_colors': 4 * np.array(DATA['mean_colors']),
-            'other': 5 * np.array(DATA['mean_colors']),
+            'clusters_labels': 5 * np.array(DATA['clusters_labels'], dtype=object),
+            'other': 6 * np.array(DATA['mean_colors']),
         }
         sdict2 = PerArrayDict(len(DATA['tractogram']), new_data)
 
@@ -305,6 +321,7 @@ def test_extend(self):
             'mean_curvature': 2 * np.array(DATA['mean_curvature']),
             'mean_torsion': 3 * np.array(DATA['mean_torsion']),
             'mean_colors': 4 * np.array(DATA['mean_torsion']),
+            'clusters_labels': 5 * np.array(DATA['clusters_labels'], dtype=object),
         }
         sdict2 = PerArrayDict(len(DATA['tractogram']), new_data)
         with pytest.raises(ValueError):
@@ -441,7 +458,10 @@ def test_lazydict_creation(self):
             assert is_lazy_dict(data_dict)
             assert data_dict.keys() == expected_keys
             for k in data_dict.keys():
-                assert_array_equal(list(data_dict[k]), list(DATA['data_per_streamline'][k]))
+                if isinstance(data_dict[k], np.ndarray) and np.all(
+                    data_dict[k].shape[0] == data_dict[k].shape
+                ):
+                    assert_array_equal(list(data_dict[k]), list(DATA['data_per_streamline'][k]))
 
             assert len(data_dict) == len(DATA['data_per_streamline_func'])
 
@@ -578,6 +598,7 @@ def test_tractogram_add_new_data(self):
         t.data_per_streamline['mean_curvature'] = DATA['mean_curvature']
         t.data_per_streamline['mean_torsion'] = DATA['mean_torsion']
         t.data_per_streamline['mean_colors'] = DATA['mean_colors']
+        t.data_per_streamline['clusters_labels'] = DATA['clusters_labels']
         assert_tractogram_equal(t, DATA['tractogram'])
 
         # Retrieve tractogram by their index.
@@ -598,6 +619,7 @@ def test_tractogram_add_new_data(self):
         t.data_per_streamline['mean_curvature'] = DATA['mean_curvature']
         t.data_per_streamline['mean_torsion'] = DATA['mean_torsion']
         t.data_per_streamline['mean_colors'] = DATA['mean_colors']
+        t.data_per_streamline['clusters_labels'] = DATA['clusters_labels']
         assert_tractogram_equal(t, DATA['tractogram'])
 
     def test_tractogram_copy(self):
@@ -647,14 +669,6 @@ def test_creating_invalid_tractogram(self):
         with pytest.raises(ValueError):
             Tractogram(streamlines=DATA['streamlines'], data_per_point={'scalars': scalars})
 
-        # Inconsistent dimension for a data_per_streamline.
-        properties = [[1.11, 1.22], [2.11], [3.11, 3.22]]
-
-        with pytest.raises(ValueError):
-            Tractogram(
-                streamlines=DATA['streamlines'], data_per_streamline={'properties': properties}
-            )
-
         # Too many dimension for a data_per_streamline.
         properties = [
             np.array([[1.11], [1.22]], dtype='f4'),
@@ -870,6 +884,7 @@ def test_lazy_tractogram_from_data_func(self):
             DATA['mean_curvature'],
             DATA['mean_torsion'],
             DATA['mean_colors'],
+            DATA['clusters_labels'],
         ]
 
         def _data_gen():
@@ -879,6 +894,7 @@ def _data_gen():
                     'mean_curvature': d[3],
                     'mean_torsion': d[4],
                     'mean_colors': d[5],
+                    'clusters_labels': d[6],
                 }
                 yield TractogramItem(d[0], data_for_streamline, data_for_points)
 
diff --git a/nibabel/streamlines/tests/test_tractogram_file.py b/nibabel/streamlines/tests/test_tractogram_file.py
index 53a7fb662b..6f764009f1 100644
--- a/nibabel/streamlines/tests/test_tractogram_file.py
+++ b/nibabel/streamlines/tests/test_tractogram_file.py
@@ -1,5 +1,4 @@
-"""Test tractogramFile base class
-"""
+"""Test tractogramFile base class"""
 
 import pytest
 
@@ -8,7 +7,6 @@
 
 
 def test_subclassing_tractogram_file():
-
     # Missing 'save' method
     class DummyTractogramFile(TractogramFile):
         @classmethod
diff --git a/nibabel/streamlines/tests/test_trk.py b/nibabel/streamlines/tests/test_trk.py
index b8ff43620b..4cb6032c25 100644
--- a/nibabel/streamlines/tests/test_trk.py
+++ b/nibabel/streamlines/tests/test_trk.py
@@ -149,7 +149,7 @@ def test_load_file_with_wrong_information(self):
         # Simulate a TRK where `vox_to_ras` is invalid.
         trk_struct, trk_bytes = self.trk_with_bytes()
         trk_struct[Field.VOXEL_TO_RASMM] = np.diag([0, 0, 0, 1])
-        with clear_and_catch_warnings(record=True, modules=[trk_module]) as w:
+        with clear_and_catch_warnings(modules=[trk_module]):
             with pytest.raises(HeaderError):
                 TrkFile.load(BytesIO(trk_bytes))
 
diff --git a/nibabel/streamlines/tractogram.py b/nibabel/streamlines/tractogram.py
index 9e7c0f9af2..5a39b415a6 100644
--- a/nibabel/streamlines/tractogram.py
+++ b/nibabel/streamlines/tractogram.py
@@ -1,6 +1,7 @@
 import copy
 import numbers
-from collections.abc import MutableMapping
+import types
+from collections.abc import Iterable, MutableMapping
 from warnings import warn
 
 import numpy as np
@@ -101,15 +102,28 @@ def __init__(self, n_rows=0, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def __setitem__(self, key, value):
-        value = np.asarray(list(value))
+        dtype = np.float64
+
+        if isinstance(value, types.GeneratorType):
+            value = list(value)
+
+        if isinstance(value, np.ndarray):
+            dtype = value.dtype
+        elif not all(len(v) == len(value[0]) for v in value[1:]):
+            dtype = object
+
+        value = np.asarray(value, dtype=dtype)
 
         if value.ndim == 1 and value.dtype != object:
             # Reshape without copy
             value.shape = (len(value), 1)
 
-        if value.ndim != 2:
+        if value.ndim != 2 and value.dtype != object:
             raise ValueError('data_per_streamline must be a 2D array.')
 
+        if value.dtype == object and not all(isinstance(v, Iterable) for v in value):
+            raise ValueError('data_per_streamline must be a 2D array')
+
         # We make sure there is the right amount of values
         if 0 < self.n_rows != len(value):
             msg = f'The number of values ({len(value)}) should match n_elements ({self.n_rows}).'
diff --git a/nibabel/streamlines/tractogram_file.py b/nibabel/streamlines/tractogram_file.py
index 2cec1ea9cb..65add3e2f2 100644
--- a/nibabel/streamlines/tractogram_file.py
+++ b/nibabel/streamlines/tractogram_file.py
@@ -1,5 +1,5 @@
-"""Define abstract interface for Tractogram file classes
-"""
+"""Define abstract interface for Tractogram file classes"""
+
 from abc import ABC, abstractmethod
 
 from .header import Field
@@ -74,7 +74,7 @@ def is_correct_format(cls, fileobj):
             Returns True if `fileobj` is in the right streamlines file format,
             otherwise returns False.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @classmethod
     def create_empty_header(cls):
@@ -101,7 +101,7 @@ def load(cls, fileobj, lazy_load=True):
             Returns an object containing tractogram data and header
             information.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @abstractmethod
     def save(self, fileobj):
@@ -113,4 +113,4 @@ def save(self, fileobj):
             If string, a filename; otherwise an open file-like object
             opened and ready to write.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
diff --git a/nibabel/streamlines/trk.py b/nibabel/streamlines/trk.py
index 4f570a2803..c434619d63 100644
--- a/nibabel/streamlines/trk.py
+++ b/nibabel/streamlines/trk.py
@@ -7,7 +7,6 @@
 import warnings
 
 import numpy as np
-from numpy.compat.py3k import asstr
 
 import nibabel as nib
 from nibabel.openers import Opener
@@ -180,7 +179,7 @@ def decode_value_from_name(encoded_name):
     value : int
         Value decoded from the name.
     """
-    encoded_name = asstr(encoded_name)
+    encoded_name = encoded_name.decode('latin1')
     if len(encoded_name) == 0:
         return encoded_name, 0
 
@@ -367,7 +366,6 @@ def _read():
             tractogram = LazyTractogram.from_data_func(_read)
 
         else:
-
             # Speed up loading by guessing a suitable buffer size.
             with Opener(fileobj) as f:
                 old_file_position = f.tell()
@@ -578,10 +576,10 @@ def _read_header(fileobj):
                 endianness = swapped_code
 
                 # Swap byte order
-                header_rec = header_rec.newbyteorder()
+                header_rec = header_rec.view(header_rec.dtype.newbyteorder())
                 if header_rec['hdr_size'] != TrkFile.HEADER_SIZE:
                     msg = (
-                        f"Invalid hdr_size: {header_rec['hdr_size']} "
+                        f'Invalid hdr_size: {header_rec["hdr_size"]} '
                         f'instead of {TrkFile.HEADER_SIZE}'
                     )
                     raise HeaderError(msg)
@@ -740,14 +738,18 @@ def __str__(self):
                     vars[attr] = vars[hdr_field]
 
         nb_scalars = self.header[Field.NB_SCALARS_PER_POINT]
-        scalar_names = [asstr(s) for s in vars['scalar_name'][:nb_scalars] if len(s) > 0]
+        scalar_names = [
+            s.decode('latin-1') for s in vars['scalar_name'][:nb_scalars] if len(s) > 0
+        ]
         vars['scalar_names'] = '\n  '.join(scalar_names)
         nb_properties = self.header[Field.NB_PROPERTIES_PER_STREAMLINE]
-        property_names = [asstr(s) for s in vars['property_name'][:nb_properties] if len(s) > 0]
+        property_names = [
+            s.decode('latin-1') for s in vars['property_name'][:nb_properties] if len(s) > 0
+        ]
         vars['property_names'] = '\n  '.join(property_names)
         # Make all byte strings into strings
         # Fixes recursion error on Python 3.3
-        vars = {k: asstr(v) if hasattr(v, 'decode') else v for k, v in vars.items()}
+        vars = {k: v.decode('latin-1') if hasattr(v, 'decode') else v for k, v in vars.items()}
         return """\
 MAGIC NUMBER: {MAGIC_NUMBER}
 v.{version}
@@ -770,6 +772,4 @@ def __str__(self):
 swap_yz: {swap_yz}
 swap_zx: {swap_zx}
 n_count: {NB_STREAMLINES}
-hdr_size: {hdr_size}""".format(
-            **vars
-        )
+hdr_size: {hdr_size}""".format(**vars)
diff --git a/nibabel/testing/__init__.py b/nibabel/testing/__init__.py
index eb99eabca0..b42baf2955 100644
--- a/nibabel/testing/__init__.py
+++ b/nibabel/testing/__init__.py
@@ -8,39 +8,49 @@
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Utilities for testing"""
 
+from __future__ import annotations
+
 import os
 import re
 import sys
+import typing as ty
 import unittest
 import warnings
 from contextlib import nullcontext
+from importlib.resources import as_file, files
 from itertools import zip_longest
 
 import numpy as np
 import pytest
 from numpy.testing import assert_array_equal
-from pkg_resources import resource_filename
 
 from .helpers import assert_data_similar, bytesio_filemap, bytesio_round_trip
 from .np_features import memmap_after_ufunc
 
+if ty.TYPE_CHECKING:
+    from importlib.resources.abc import Traversable
+
 
-def test_data(subdir=None, fname=None):
+def get_test_data(
+    subdir: ty.Literal['gifti', 'nicom', 'externals'] | None = None,
+    fname: str | None = None,
+) -> Traversable:
+    parts: tuple[str, ...]
     if subdir is None:
-        resource = os.path.join('tests', 'data')
+        parts = ('tests', 'data')
     elif subdir in ('gifti', 'nicom', 'externals'):
-        resource = os.path.join(subdir, 'tests', 'data')
+        parts = (subdir, 'tests', 'data')
     else:
         raise ValueError(f'Unknown test data directory: {subdir}')
 
     if fname is not None:
-        resource = os.path.join(resource, fname)
+        parts += (fname,)
 
-    return resource_filename('nibabel', resource)
+    return files('nibabel').joinpath(*parts)
 
 
 # set path to example data
-data_path = test_data()
+data_path = get_test_data()
 
 
 def assert_dt_equal(a, b):
@@ -137,9 +147,10 @@ class clear_and_catch_warnings(warnings.catch_warnings):
     Examples
     --------
     >>> import warnings
-    >>> with clear_and_catch_warnings(modules=[np.core.fromnumeric]):
+    >>> with clear_and_catch_warnings(modules=[np.lib.scimath]):
     ...     warnings.simplefilter('always')
-    ...     # do something that raises a warning in np.core.fromnumeric
+    ...     # do something that raises a warning in np.lib.scimath
+    ...     _ = np.arccos(90)
     """
 
     class_modules = ()
@@ -210,19 +221,6 @@ def assert_arr_dict_equal(dict1, dict2):
         assert_array_equal(value1, value2)
 
 
-class BaseTestCase(unittest.TestCase):
-    """TestCase that does not attempt to run if prefixed with a ``_``
-
-    This restores the nose-like behavior of skipping so-named test cases
-    in test runners like pytest.
-    """
-
-    def setUp(self):
-        if self.__class__.__name__.startswith('_'):
-            raise unittest.SkipTest('Base test case - subclass to run')
-        super().setUp()
-
-
 def expires(version):
     """Decorator to mark a test as xfail with ExpiredDeprecationError after version"""
     from packaging.version import Version
@@ -234,3 +232,15 @@ def expires(version):
         return lambda x: x
 
     return pytest.mark.xfail(raises=ExpiredDeprecationError)
+
+
+def deprecated_to(version):
+    """Context manager to expect DeprecationWarnings until a given version"""
+    from packaging.version import Version
+
+    from nibabel import __version__ as nbver
+
+    if Version(nbver) < Version(version):
+        return pytest.deprecated_call()
+
+    return nullcontext()
diff --git a/nibabel/testing/helpers.py b/nibabel/testing/helpers.py
index 35b13049f1..ad4bf258cd 100644
--- a/nibabel/testing/helpers.py
+++ b/nibabel/testing/helpers.py
@@ -1,12 +1,12 @@
-"""Helper functions for tests
-"""
+"""Helper functions for tests"""
+
 from io import BytesIO
 
 import numpy as np
 
 from ..optpkg import optional_package
 
-_, have_scipy, _ = optional_package('scipy.io')
+have_scipy = optional_package('scipy.io')[1]
 
 from numpy.testing import assert_array_equal
 
@@ -14,7 +14,7 @@
 def bytesio_filemap(klass):
     """Return bytes io filemap for this image class `klass`"""
     file_map = klass.make_file_map()
-    for name, fileholder in file_map.items():
+    for fileholder in file_map.values():
         fileholder.fileobj = BytesIO()
         fileholder.pos = 0
     return file_map
diff --git a/nibabel/testing/np_features.py b/nibabel/testing/np_features.py
index eeb783900a..dd21aac2c0 100644
--- a/nibabel/testing/np_features.py
+++ b/nibabel/testing/np_features.py
@@ -1,11 +1,11 @@
-"""Look for changes in numpy behavior over versions
-"""
-from functools import lru_cache
+"""Look for changes in numpy behavior over versions"""
+
+from functools import cache
 
 import numpy as np
 
 
-@lru_cache(maxsize=None)
+@cache
 def memmap_after_ufunc() -> bool:
     """Return True if ufuncs on memmap arrays always return memmap arrays
 
diff --git a/nibabel/tests/conftest.py b/nibabel/tests/conftest.py
new file mode 100644
index 0000000000..fb13708450
--- /dev/null
+++ b/nibabel/tests/conftest.py
@@ -0,0 +1,18 @@
+import pytest
+
+from ..spatialimages import supported_np_types
+
+
+# Generate dynamic fixtures
+def pytest_generate_tests(metafunc):
+    if 'supported_dtype' in metafunc.fixturenames:
+        if metafunc.cls is None or not metafunc.cls.image_class:
+            raise pytest.UsageError(
+                'Attempting to use supported_dtype fixture outside an image test case'
+            )
+        # xdist needs a consistent ordering, so sort by class name
+        supported_dtypes = sorted(
+            supported_np_types(metafunc.cls.image_class.header_class()),
+            key=lambda x: x.__name__,
+        )
+        metafunc.parametrize('supported_dtype', supported_dtypes)
diff --git a/nibabel/tests/data/check_parrec_reslice.py b/nibabel/tests/data/check_parrec_reslice.py
index 8ade7f539c..b22a869090 100644
--- a/nibabel/tests/data/check_parrec_reslice.py
+++ b/nibabel/tests/data/check_parrec_reslice.py
@@ -21,6 +21,7 @@
 The *_cor_SENSE* image has a higher RMS because the back of the phantom is out
 of the field of view.
 """
+
 import glob
 
 import numpy as np
@@ -59,7 +60,7 @@ def gmean_norm(data):
     normal_data = normal_img.get_fdata()
     normal_normed = gmean_norm(normal_data)
 
-    print(f'RMS of standard image {normal_fname:<44}: {np.sqrt(np.sum(normal_normed ** 2))}')
+    print(f'RMS of standard image {normal_fname:<44}: {np.sqrt(np.sum(normal_normed**2))}')
 
     for parfile in glob.glob('*.PAR'):
         if parfile == normal_fname:
@@ -68,4 +69,4 @@ def gmean_norm(data):
         fixed_img = resample_img2img(normal_img, funny_img)
         fixed_data = fixed_img.get_fdata()
         difference_data = normal_normed - gmean_norm(fixed_data)
-        print(f'RMS resliced {parfile:<52} : {np.sqrt(np.sum(difference_data ** 2))}')
+        print(f'RMS resliced {parfile:<52} : {np.sqrt(np.sum(difference_data**2))}')
diff --git a/nibabel/tests/data/gen_standard.py b/nibabel/tests/data/gen_standard.py
index 598726fe74..7fd05d936e 100644
--- a/nibabel/tests/data/gen_standard.py
+++ b/nibabel/tests/data/gen_standard.py
@@ -5,6 +5,7 @@
 
     * standard.trk
 """
+
 import numpy as np
 
 import nibabel as nib
diff --git a/nibabel/tests/data/minc2_baddim.mnc b/nibabel/tests/data/minc2_baddim.mnc
new file mode 100644
index 0000000000..c7de97bd5e
Binary files /dev/null and b/nibabel/tests/data/minc2_baddim.mnc differ
diff --git a/nibabel/tests/nibabel_data.py b/nibabel/tests/nibabel_data.py
index 8d4652d79f..5919eba925 100644
--- a/nibabel/tests/nibabel_data.py
+++ b/nibabel/tests/nibabel_data.py
@@ -1,11 +1,9 @@
-"""Functions / decorators for finding / requiring nibabel-data directory
-"""
+"""Functions / decorators for finding / requiring nibabel-data directory"""
 
 import unittest
 from os import environ, listdir
-from os.path import dirname, exists, isdir
+from os.path import dirname, exists, isdir, realpath
 from os.path import join as pjoin
-from os.path import realpath
 
 
 def get_nibabel_data():
diff --git a/nibabel/tests/scriptrunner.py b/nibabel/tests/scriptrunner.py
index 1ec2fcb486..2f3de50791 100644
--- a/nibabel/tests/scriptrunner.py
+++ b/nibabel/tests/scriptrunner.py
@@ -12,11 +12,11 @@
     assert_equal(code, 0)
     assert_equal(stdout, b'This script ran OK')
 """
+
 import os
 import sys
-from os.path import dirname, isdir, isfile
+from os.path import dirname, isdir, isfile, pathsep, realpath
 from os.path import join as pjoin
-from os.path import pathsep, realpath
 from subprocess import PIPE, Popen
 
 MY_PACKAGE = __package__
diff --git a/nibabel/tests/test_affines.py b/nibabel/tests/test_affines.py
index 28f405e566..d4ea11821b 100644
--- a/nibabel/tests/test_affines.py
+++ b/nibabel/tests/test_affines.py
@@ -225,7 +225,6 @@ def test_rescale_affine():
     orig_shape = rng.randint(low=20, high=512, size=(3,))
     orig_aff = np.eye(4)
     orig_aff[:3, :] = rng.normal(size=(3, 4))
-    orig_zooms = voxel_sizes(orig_aff)
     orig_axcodes = aff2axcodes(orig_aff)
     orig_centroid = apply_affine(orig_aff, (orig_shape - 1) // 2)
 
diff --git a/nibabel/tests/test_analyze.py b/nibabel/tests/test_analyze.py
index 7584d550f6..85669b3661 100644
--- a/nibabel/tests/test_analyze.py
+++ b/nibabel/tests/test_analyze.py
@@ -26,8 +26,7 @@
 from .. import imageglobals
 from ..analyze import AnalyzeHeader, AnalyzeImage
 from ..arraywriters import WriterError
-from ..casting import as_int
-from ..loadsave import read_img_data
+from ..casting import sctypes_aliases
 from ..nifti1 import Nifti1Header
 from ..optpkg import optional_package
 from ..spatialimages import HeaderDataError, HeaderTypeError, supported_np_types
@@ -49,12 +48,10 @@
 PIXDIM0_MSG = 'pixdim[1,2,3] should be non-zero; setting 0 dims to 1'
 
 
-def add_intp(supported_np_types):
-    # Add intp, uintp to supported types as necessary
-    supported_dtypes = [np.dtype(t) for t in supported_np_types]
-    for np_type in (np.intp, np.uintp):
-        if np.dtype(np_type) in supported_dtypes:
-            supported_np_types.add(np_type)
+def add_duplicate_types(supported_np_types):
+    # Update supported numpy types with named scalar types that map to the same set of dtypes
+    dtypes = {np.dtype(t) for t in supported_np_types}
+    supported_np_types.update(scalar for scalar in sctypes_aliases if np.dtype(scalar) in dtypes)
 
 
 class TestAnalyzeHeader(tws._TestLabeledWrapStruct):
@@ -62,7 +59,7 @@ class TestAnalyzeHeader(tws._TestLabeledWrapStruct):
     example_file = header_file
     sizeof_hdr = AnalyzeHeader.sizeof_hdr
     supported_np_types = {np.uint8, np.int16, np.int32, np.float32, np.float64, np.complex64}
-    add_intp(supported_np_types)
+    add_duplicate_types(supported_np_types)
 
     def test_supported_types(self):
         hdr = self.header_class()
@@ -311,8 +308,7 @@ def test_shapes(self):
             assert hdr.get_data_shape() == shape
         # Check max works, but max+1 raises error
         dim_dtype = hdr.structarr['dim'].dtype
-        # as_int for safety to deal with numpy 1.4.1 int conversion errors
-        mx = as_int(np.iinfo(dim_dtype).max)
+        mx = int(np.iinfo(dim_dtype).max)
         shape = (mx,)
         hdr.set_data_shape(shape)
         assert hdr.get_data_shape() == shape
@@ -501,7 +497,7 @@ def test_str(self):
         hdr = self.header_class()
         s1 = str(hdr)
         # check the datacode recoding
-        rexp = re.compile('^datatype +: float32', re.MULTILINE)
+        rexp = re.compile(r'^datatype +: float32', re.MULTILINE)
         assert rexp.search(s1) is not None
 
     def test_from_header(self):
@@ -732,8 +728,8 @@ def test_data_hdr_cache(self):
         IC = self.image_class
         # save an image to a file map
         fm = IC.make_file_map()
-        for key, value in fm.items():
-            fm[key].fileobj = BytesIO()
+        for value in fm.values():
+            value.fileobj = BytesIO()
         shape = (2, 3, 4)
         data = np.arange(24, dtype=np.int8).reshape(shape)
         affine = np.eye(4)
@@ -835,7 +831,7 @@ def test_header_updating(self):
         hdr = img.header
         hdr.set_zooms((4, 5, 6))
         # Save / reload using bytes IO objects
-        for key, value in img.file_map.items():
+        for value in img.file_map.values():
             value.fileobj = BytesIO()
         img.to_file_map()
         hdr_back = img.from_file_map(img.file_map).header
@@ -846,7 +842,7 @@ def test_header_updating(self):
         assert_array_equal(hdr.get_zooms(), (2, 3, 4))
         # Modify affine in-place? Update on save.
         img.affine[0, 0] = 9
-        for key, value in img.file_map.items():
+        for value in img.file_map.values():
             value.fileobj = BytesIO()
         img.to_file_map()
         hdr_back = img.from_file_map(img.file_map).header
@@ -868,7 +864,7 @@ def test_pickle(self):
         assert_array_equal(img.get_fdata(), img2.get_fdata())
         assert img.header == img2.header
         # Save / reload using bytes IO objects
-        for key, value in img.file_map.items():
+        for value in img.file_map.values():
             value.fileobj = BytesIO()
         img.to_file_map()
         img_prox = img.from_file_map(img.file_map)
diff --git a/nibabel/tests/test_api_validators.py b/nibabel/tests/test_api_validators.py
index 1d21092eef..2388089f2c 100644
--- a/nibabel/tests/test_api_validators.py
+++ b/nibabel/tests/test_api_validators.py
@@ -1,5 +1,5 @@
-"""Metaclass and class for validating instance APIs
-"""
+"""Metaclass and class for validating instance APIs"""
+
 import os
 
 import pytest
@@ -99,18 +99,18 @@ class TestRunAllTests(ValidateAPI):
     We check this in the module teardown function
     """
 
-    run_tests = []
+    run_tests = {}
 
     def obj_params(self):
         yield 1, 2
 
     def validate_first(self, obj, param):
-        self.run_tests.append('first')
+        self.run_tests.add('first')
 
     def validate_second(self, obj, param):
-        self.run_tests.append('second')
+        self.run_tests.add('second')
 
     @classmethod
     def teardown_class(cls):
         # Check that both validate_xxx tests got run
-        assert cls.run_tests == ['first', 'second']
+        assert cls.run_tests == {'first', 'second'}
diff --git a/nibabel/tests/test_arrayproxy.py b/nibabel/tests/test_arrayproxy.py
index 7558c55ea5..65b9131905 100644
--- a/nibabel/tests/test_arrayproxy.py
+++ b/nibabel/tests/test_arrayproxy.py
@@ -6,13 +6,11 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Tests for arrayproxy module
-"""
+"""Tests for arrayproxy module"""
 
 import contextlib
 import gzip
 import pickle
-import warnings
 from io import BytesIO
 from unittest import mock
 
@@ -24,7 +22,7 @@
 from .. import __version__
 from ..arrayproxy import ArrayProxy, get_obj_dtype, is_proxy, reshape_dataobj
 from ..deprecator import ExpiredDeprecationError
-from ..nifti1 import Nifti1Header
+from ..nifti1 import Nifti1Header, Nifti1Image
 from ..openers import ImageOpener
 from ..testing import memmap_after_ufunc
 from ..tmpdirs import InTemporaryDirectory
@@ -484,9 +482,11 @@ def test_keep_file_open_true_false_invalid():
 
     for test in tests:
         filetype, kfo, have_igzip, exp_persist, exp_kfo = test
-        with InTemporaryDirectory(), mock.patch(
-            'nibabel.openers.ImageOpener', CountingImageOpener
-        ), patch_indexed_gzip(have_igzip):
+        with (
+            InTemporaryDirectory(),
+            mock.patch('nibabel.openers.ImageOpener', CountingImageOpener),
+            patch_indexed_gzip(have_igzip),
+        ):
             fname = f'testdata.{filetype}'
             # create the test data file
             if filetype == 'gz':
@@ -554,16 +554,53 @@ def test_keep_file_open_true_false_invalid():
                     ArrayProxy(fname, ((10, 10, 10), dtype))
 
 
+def islock(l):
+    # isinstance doesn't work on threading.Lock?
+    return hasattr(l, 'acquire') and hasattr(l, 'release')
+
+
 def test_pickle_lock():
     # Test that ArrayProxy can be pickled, and that thread lock is created
 
-    def islock(l):
-        # isinstance doesn't work on threading.Lock?
-        return hasattr(l, 'acquire') and hasattr(l, 'release')
-
     proxy = ArrayProxy('dummyfile', ((10, 10, 10), np.float32))
     assert islock(proxy._lock)
     pickled = pickle.dumps(proxy)
     unpickled = pickle.loads(pickled)
     assert islock(unpickled._lock)
     assert proxy._lock is not unpickled._lock
+
+
+def test_copy():
+    # Test copying array proxies
+
+    # If the file-like is a file name, get a new lock
+    proxy = ArrayProxy('dummyfile', ((10, 10, 10), np.float32))
+    assert islock(proxy._lock)
+    copied = proxy.copy()
+    assert islock(copied._lock)
+    assert proxy._lock is not copied._lock
+
+    # If an open filehandle, the lock should be shared to
+    # avoid changing filehandle state in critical sections
+    proxy = ArrayProxy(BytesIO(), ((10, 10, 10), np.float32))
+    assert islock(proxy._lock)
+    copied = proxy.copy()
+    assert islock(copied._lock)
+    assert proxy._lock is copied._lock
+
+
+def test_copy_with_indexed_gzip_handle(tmp_path):
+    indexed_gzip = pytest.importorskip('indexed_gzip')
+
+    spec = ((50, 50, 50, 50), np.float32, 352, 1, 0)
+    data = np.arange(np.prod(spec[0]), dtype=spec[1]).reshape(spec[0])
+    fname = str(tmp_path / 'test.nii.gz')
+    Nifti1Image(data, np.eye(4)).to_filename(fname)
+
+    with indexed_gzip.IndexedGzipFile(fname) as fobj:
+        proxy = ArrayProxy(fobj, spec)
+        copied = proxy.copy()
+
+        assert proxy.file_like is copied.file_like
+        assert np.array_equal(proxy[0, 0, 0], copied[0, 0, 0])
+        assert np.array_equal(proxy[-1, -1, -1], copied[-1, -1, -1])
diff --git a/nibabel/tests/test_arraywriters.py b/nibabel/tests/test_arraywriters.py
index e77c2fd11f..4a853ecf5e 100644
--- a/nibabel/tests/test_arraywriters.py
+++ b/nibabel/tests/test_arraywriters.py
@@ -20,14 +20,14 @@
     get_slope_inter,
     make_array_writer,
 )
-from ..casting import int_abs, on_powerpc, shared_range, type_info
+from ..casting import int_abs, sctypes, shared_range, type_info
 from ..testing import assert_allclose_safely, suppress_warnings
 from ..volumeutils import _dt_min_max, apply_read_scaling, array_from_file
 
-FLOAT_TYPES = np.sctypes['float']
-COMPLEX_TYPES = np.sctypes['complex']
-INT_TYPES = np.sctypes['int']
-UINT_TYPES = np.sctypes['uint']
+FLOAT_TYPES = sctypes['float']
+COMPLEX_TYPES = sctypes['complex']
+INT_TYPES = sctypes['int']
+UINT_TYPES = sctypes['uint']
 CFLOAT_TYPES = FLOAT_TYPES + COMPLEX_TYPES
 IUINT_TYPES = INT_TYPES + UINT_TYPES
 NUMERIC_TYPES = CFLOAT_TYPES + IUINT_TYPES
@@ -61,7 +61,8 @@ def test_arraywriters():
             assert aw.out_dtype == arr.dtype
             assert_array_equal(arr, round_trip(aw))
             # Byteswapped should be OK
-            bs_arr = arr.byteswap().newbyteorder('S')
+            bs_arr = arr.byteswap()
+            bs_arr = bs_arr.view(bs_arr.dtype.newbyteorder('S'))
             bs_aw = klass(bs_arr)
             bs_aw_rt = round_trip(bs_aw)
             # assert against original array because POWER7 was running into
@@ -275,7 +276,7 @@ def test_slope_inter_castable():
         for out_dtt in NUMERIC_TYPES:
             for klass in (ArrayWriter, SlopeArrayWriter, SlopeInterArrayWriter):
                 arr = np.zeros((5,), dtype=in_dtt)
-                aw = klass(arr, out_dtt)  # no error
+                klass(arr, out_dtt)  # no error
     # Test special case of none finite
     # This raises error for ArrayWriter, but not for the others
     arr = np.array([np.inf, np.nan, -np.inf])
@@ -284,8 +285,8 @@ def test_slope_inter_castable():
             in_arr = arr.astype(in_dtt)
             with pytest.raises(WriterError):
                 ArrayWriter(in_arr, out_dtt)
-            aw = SlopeArrayWriter(arr.astype(in_dtt), out_dtt)  # no error
-            aw = SlopeInterArrayWriter(arr.astype(in_dtt), out_dtt)  # no error
+            SlopeArrayWriter(arr.astype(in_dtt), out_dtt)  # no error
+            SlopeInterArrayWriter(arr.astype(in_dtt), out_dtt)  # no error
     for in_dtt, out_dtt, arr, slope_only, slope_inter, neither in (
         (np.float32, np.float32, 1, True, True, True),
         (np.float64, np.float32, 1, True, True, True),
diff --git a/nibabel/tests/test_batteryrunners.py b/nibabel/tests/test_batteryrunners.py
index 84590452ea..5cae764c8b 100644
--- a/nibabel/tests/test_batteryrunners.py
+++ b/nibabel/tests/test_batteryrunners.py
@@ -6,8 +6,7 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Tests for BatteryRunner and Report objects
-"""
+"""Tests for BatteryRunner and Report objects"""
 
 import logging
 from io import StringIO
diff --git a/nibabel/tests/test_brikhead.py b/nibabel/tests/test_brikhead.py
index 5bf6e79cb9..31e0d0d47c 100644
--- a/nibabel/tests/test_brikhead.py
+++ b/nibabel/tests/test_brikhead.py
@@ -13,7 +13,7 @@
 import pytest
 from numpy.testing import assert_array_equal
 
-from .. import Nifti1Image, brikhead, load
+from .. import Nifti1Image, brikhead
 from ..testing import assert_data_similar, data_path
 from .test_fileslice import slicer_samples
 
diff --git a/nibabel/tests/test_casting.py b/nibabel/tests/test_casting.py
index 62da526319..c6c1ddb661 100644
--- a/nibabel/tests/test_casting.py
+++ b/nibabel/tests/test_casting.py
@@ -1,22 +1,21 @@
-"""Test casting utilities
-"""
+"""Test casting utilities"""
+
 import os
 from platform import machine
 
 import numpy as np
 import pytest
-from numpy.testing import assert_array_almost_equal, assert_array_equal
+from numpy.testing import assert_array_equal
 
 from ..casting import (
     CastingError,
     able_int_type,
-    as_int,
     best_float,
     float_to_int,
     floor_log2,
     int_abs,
-    int_to_float,
     longdouble_precision_improved,
+    sctypes,
     shared_range,
     ulp,
 )
@@ -24,8 +23,8 @@
 
 
 def test_shared_range():
-    for ft in np.sctypes['float']:
-        for it in np.sctypes['int'] + np.sctypes['uint']:
+    for ft in sctypes['float']:
+        for it in sctypes['int'] + sctypes['uint']:
             # Test that going a bit above or below the calculated min and max
             # either generates the same number when cast, or the max int value
             # (if this system generates that) or something smaller (because of
@@ -41,7 +40,7 @@ def test_shared_range():
             if casted_mx != imax:
                 # The shared_range have told us that they believe the imax does
                 # not have an exact representation.
-                fimax = int_to_float(imax, ft)
+                fimax = ft(imax)
                 if np.isfinite(fimax):
                     assert int(fimax) != imax
                 # Therefore the imax, cast back to float, and to integer, will
@@ -54,7 +53,7 @@ def test_shared_range():
                 assert np.all((bit_bigger == casted_mx) | (bit_bigger == imax))
             else:
                 assert np.all(bit_bigger <= casted_mx)
-            if it in np.sctypes['uint']:
+            if it in sctypes['uint']:
                 assert mn == 0
                 continue
             # And something larger for the minimum
@@ -67,7 +66,7 @@ def test_shared_range():
             if casted_mn != imin:
                 # The shared_range have told us that they believe the imin does
                 # not have an exact representation.
-                fimin = int_to_float(imin, ft)
+                fimin = ft(imin)
                 if np.isfinite(fimin):
                     assert int(fimin) != imin
                 # Therefore the imin, cast back to float, and to integer, will
@@ -90,8 +89,8 @@ def test_shared_range_inputs():
 
 
 def test_casting():
-    for ft in np.sctypes['float']:
-        for it in np.sctypes['int'] + np.sctypes['uint']:
+    for ft in sctypes['float']:
+        for it in sctypes['int'] + sctypes['uint']:
             ii = np.iinfo(it)
             arr = [ii.min - 1, ii.max + 1, -np.inf, np.inf, np.nan, 0.2, 10.6]
             farr_orig = np.array(arr, dtype=ft)
@@ -100,11 +99,6 @@ def test_casting():
             mn, mx = shared_range(ft, it)
             with np.errstate(invalid='ignore'):
                 iarr = float_to_int(farr, it)
-            # Dammit - for long doubles we need to jump through some hoops not
-            # to round to numbers outside the range
-            if ft is np.longdouble:
-                mn = as_int(mn)
-                mx = as_int(mx)
             exp_arr = np.array([mn, mx, mn, mx, 0, 0, 11], dtype=it)
             assert_array_equal(iarr, exp_arr)
             # Now test infmax version
@@ -140,7 +134,7 @@ def test_casting():
 
 
 def test_int_abs():
-    for itype in np.sctypes['int']:
+    for itype in sctypes['int']:
         info = np.iinfo(itype)
         in_arr = np.array([info.min, info.max], dtype=itype)
         idtype = np.dtype(itype)
@@ -148,7 +142,7 @@ def test_int_abs():
         assert udtype.kind == 'u'
         assert idtype.itemsize == udtype.itemsize
         mn, mx = in_arr
-        e_mn = as_int(mx) + 1  # as_int needed for numpy 1.4.1 casting
+        e_mn = int(mx) + 1
         assert int_abs(mx) == mx
         assert int_abs(mn) == e_mn
         assert_array_equal(int_abs(in_arr), [e_mn, mx])
@@ -167,7 +161,7 @@ def test_floor_log2():
 
 
 def test_able_int_type():
-    # The integer type cabable of containing values
+    # The integer type capable of containing values
     for vals, exp_out in (
         ([0, 1], np.uint8),
         ([0, 255], np.uint8),
@@ -188,7 +182,7 @@ def test_able_int_type():
 
 def test_able_casting():
     # Check the able_int_type function guesses numpy out type
-    types = np.sctypes['int'] + np.sctypes['uint']
+    types = sctypes['int'] + sctypes['uint']
     for in_type in types:
         in_info = np.iinfo(in_type)
         in_mn, in_mx = in_info.min, in_info.max
@@ -233,10 +227,15 @@ def test_best_float():
 
 
 def test_longdouble_precision_improved():
-    # Just check that this can only be True on windows, msvc
-    from numpy.distutils.ccompiler import get_default_compiler
+    # Just check that this can only be True on Windows
 
-    if not (os.name == 'nt' and get_default_compiler() == 'msvc'):
+    # This previously used distutils.ccompiler.get_default_compiler to check for msvc
+    # In https://github.com/python/cpython/blob/3467991/Lib/distutils/ccompiler.py#L919-L956
+    # we see that this was implied by os.name == 'nt', so we can remove this deprecated
+    # call.
+    # However, there may be detectable conditions in Windows where we would expect this
+    # to be False as well.
+    if os.name != 'nt':
         assert not longdouble_precision_improved()
 
 
diff --git a/nibabel/tests/test_data.py b/nibabel/tests/test_data.py
index abcb3caaf2..511fa7f857 100644
--- a/nibabel/tests/test_data.py
+++ b/nibabel/tests/test_data.py
@@ -1,6 +1,7 @@
 # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
 """Tests for data module"""
+
 import os
 import sys
 import tempfile
@@ -22,11 +23,11 @@
     get_data_path,
     make_datasource,
 )
-from .test_environment import DATA_KEY, USER_KEY, with_environment
+from .test_environment import DATA_KEY, USER_KEY, with_environment  # noqa: F401
 
 
 @pytest.fixture
-def with_nimd_env(request, with_environment):
+def with_nimd_env(request, with_environment):  # noqa: F811
     DATA_FUNCS = {}
     DATA_FUNCS['home_dir_func'] = nibd.get_nipy_user_dir
     DATA_FUNCS['sys_dir_func'] = nibd.get_nipy_system_dir
@@ -159,7 +160,7 @@ def test_data_path(with_nimd_env):
         tmpfile = pjoin(tmpdir, 'another_example.ini')
         with open(tmpfile, 'w') as fobj:
             fobj.write('[DATA]\n')
-            fobj.write('path = %s\n' % '/path/two')
+            fobj.write('path = {}\n'.format('/path/two'))
         assert get_data_path() == tst_list + ['/path/two'] + old_pth
 
 
diff --git a/nibabel/tests/test_dataobj_images.py b/nibabel/tests/test_dataobj_images.py
index a1d2dbc9f1..877e407812 100644
--- a/nibabel/tests/test_dataobj_images.py
+++ b/nibabel/tests/test_dataobj_images.py
@@ -1,5 +1,4 @@
-"""Testing dataobj_images module
-"""
+"""Testing dataobj_images module"""
 
 import numpy as np
 
diff --git a/nibabel/tests/test_deprecated.py b/nibabel/tests/test_deprecated.py
index 2576eca3d9..01636632e4 100644
--- a/nibabel/tests/test_deprecated.py
+++ b/nibabel/tests/test_deprecated.py
@@ -1,5 +1,4 @@
-"""Testing `deprecated` module
-"""
+"""Testing `deprecated` module"""
 
 import warnings
 
@@ -15,12 +14,12 @@
 from nibabel.tests.test_deprecator import TestDeprecatorFunc as _TestDF
 
 
-def setup():
+def setup_module():
     # Hack nibabel version string
     pkg_info.cmp_pkg_version.__defaults__ = ('2.0',)
 
 
-def teardown():
+def teardown_module():
     # Hack nibabel version string back again
     pkg_info.cmp_pkg_version.__defaults__ = (pkg_info.__version__,)
 
diff --git a/nibabel/tests/test_deprecator.py b/nibabel/tests/test_deprecator.py
index 833908af94..0fdaf2014a 100644
--- a/nibabel/tests/test_deprecator.py
+++ b/nibabel/tests/test_deprecator.py
@@ -1,5 +1,4 @@
-"""Testing deprecator module / Deprecator class
-"""
+"""Testing deprecator module / Deprecator class"""
 
 import sys
 import warnings
@@ -14,6 +13,7 @@
     Deprecator,
     ExpiredDeprecationError,
     _add_dep_doc,
+    _dedent_docstring,
     _ensure_cr,
 )
 
@@ -21,6 +21,14 @@
 
 _OWN_MODULE = sys.modules[__name__]
 
+func_docstring = (
+    f'A docstring\n   \n   foo\n   \n{indent(TESTSETUP, "   ", lambda x: True)}'
+    f'   Some text\n{indent(TESTCLEANUP, "   ", lambda x: True)}'
+)
+
+if sys.version_info >= (3, 13):
+    func_docstring = _dedent_docstring(func_docstring)
+
 
 def test__ensure_cr():
     # Make sure text ends with carriage return
@@ -92,11 +100,7 @@ def test_dep_func(self):
         with pytest.deprecated_call() as w:
             assert func(1, 2) is None
             assert len(w) == 1
-        assert (
-            func.__doc__
-            == f'A docstring\n   \n   foo\n   \n{indent(TESTSETUP, "   ", lambda x: True)}'
-            f'   Some text\n{indent(TESTCLEANUP, "   ", lambda x: True)}'
-        )
+        assert func.__doc__ == func_docstring
 
         # Try some since and until versions
         func = dec('foo', '1.1')(func_no_doc)
@@ -157,7 +161,7 @@ def test_dep_func(self):
 class TestDeprecatorMaker:
     """Test deprecator class creation with custom warnings and errors"""
 
-    dep_maker = partial(Deprecator, cmp_func)
+    dep_maker = staticmethod(partial(Deprecator, cmp_func))
 
     def test_deprecator_maker(self):
         dec = self.dep_maker(warn_class=UserWarning)
diff --git a/nibabel/tests/test_dft.py b/nibabel/tests/test_dft.py
index f756600fd3..6155dda83c 100644
--- a/nibabel/tests/test_dft.py
+++ b/nibabel/tests/test_dft.py
@@ -1,5 +1,4 @@
-"""Testing dft
-"""
+"""Testing dft"""
 
 import os
 import sqlite3
@@ -27,7 +26,7 @@
 data_dir = pjoin(dirname(__file__), 'data')
 
 
-def setUpModule():
+def setup_module():
     if os.name == 'nt':
         raise unittest.SkipTest('FUSE not available for windows, skipping dft tests')
     if not have_dicom:
@@ -59,7 +58,7 @@ def db(monkeypatch):
     and not modify the host filesystem."""
     database = dft._DB(fname=':memory:')
     monkeypatch.setattr(dft, 'DB', database)
-    yield database
+    return database
 
 
 def test_init(db):
diff --git a/nibabel/tests/test_diff.py b/nibabel/tests/test_diff.py
index fee71d628b..798a7f7b30 100644
--- a/nibabel/tests/test_diff.py
+++ b/nibabel/tests/test_diff.py
@@ -1,7 +1,6 @@
 # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
-"""Test diff
-"""
+"""Test diff"""
 
 from os.path import abspath, dirname
 from os.path import join as pjoin
diff --git a/nibabel/tests/test_ecat.py b/nibabel/tests/test_ecat.py
index ff74b7b084..702913e14d 100644
--- a/nibabel/tests/test_ecat.py
+++ b/nibabel/tests/test_ecat.py
@@ -8,7 +8,7 @@
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 
 import os
-import warnings
+from pathlib import Path
 from unittest import TestCase
 
 import numpy as np
@@ -183,8 +183,8 @@ class TestEcatImage(TestCase):
     img = image_class.load(example_file)
 
     def test_file(self):
-        assert self.img.file_map['header'].filename == self.example_file
-        assert self.img.file_map['image'].filename == self.example_file
+        assert Path(self.img.file_map['header'].filename) == Path(self.example_file)
+        assert Path(self.img.file_map['image'].filename) == Path(self.example_file)
 
     def test_save(self):
         tmp_file = 'tinypet_tmp.v'
diff --git a/nibabel/tests/test_ecat_data.py b/nibabel/tests/test_ecat_data.py
index b7dbe4750a..427645b92a 100644
--- a/nibabel/tests/test_ecat_data.py
+++ b/nibabel/tests/test_ecat_data.py
@@ -6,14 +6,13 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Test we can correctly import example ECAT files
-"""
+"""Test we can correctly import example ECAT files"""
 
 import os
 from os.path import join as pjoin
 
 import numpy as np
-from numpy.testing import assert_almost_equal, assert_array_equal
+from numpy.testing import assert_almost_equal
 
 from ..ecat import load
 from .nibabel_data import get_nibabel_data, needs_nibabel_data
diff --git a/nibabel/tests/test_environment.py b/nibabel/tests/test_environment.py
index afb6d36f84..aa58d9b8e0 100644
--- a/nibabel/tests/test_environment.py
+++ b/nibabel/tests/test_environment.py
@@ -1,5 +1,4 @@
-"""Testing environment settings
-"""
+"""Testing environment settings"""
 
 import os
 from os import environ as env
diff --git a/nibabel/tests/test_euler.py b/nibabel/tests/test_euler.py
index b0c965c399..4d251a16e3 100644
--- a/nibabel/tests/test_euler.py
+++ b/nibabel/tests/test_euler.py
@@ -21,12 +21,8 @@
 FLOAT_EPS = np.finfo(np.float64).eps
 
 # Example rotations """
-eg_rots = []
 params = np.arange(-pi * 2, pi * 2.5, pi / 2)
-for x in params:
-    for y in params:
-        for z in params:
-            eg_rots.append((x, y, z))
+eg_rots = [(x, y, z) for x in params for y in params for z in params]
 
 
 def x_only(x):
@@ -123,7 +119,7 @@ def test_euler_mat_1():
     assert_array_equal(M, np.eye(3))
 
 
-@pytest.mark.parametrize('x, y, z', eg_rots)
+@pytest.mark.parametrize(('x', 'y', 'z'), eg_rots)
 def test_euler_mat_2(x, y, z):
     M1 = nea.euler2mat(z, y, x)
     M2 = sympy_euler(z, y, x)
@@ -176,7 +172,7 @@ def test_euler_instability():
     assert not np.allclose(M_e, M_e_back)
 
 
-@pytest.mark.parametrize('x, y, z', eg_rots)
+@pytest.mark.parametrize(('x', 'y', 'z'), eg_rots)
 def test_quats(x, y, z):
     M1 = nea.euler2mat(z, y, x)
     quatM = nq.mat2quat(M1)
diff --git a/nibabel/tests/test_filebasedimages.py b/nibabel/tests/test_filebasedimages.py
index 3aa1ae78c5..7d162c0917 100644
--- a/nibabel/tests/test_filebasedimages.py
+++ b/nibabel/tests/test_filebasedimages.py
@@ -1,5 +1,4 @@
-"""Testing filebasedimages module
-"""
+"""Testing filebasedimages module"""
 
 import warnings
 from itertools import product
diff --git a/nibabel/tests/test_filehandles.py b/nibabel/tests/test_filehandles.py
index 506a623758..c985d35440 100644
--- a/nibabel/tests/test_filehandles.py
+++ b/nibabel/tests/test_filehandles.py
@@ -33,8 +33,7 @@ def test_multiload():
         tmpdir = mkdtemp()
         fname = pjoin(tmpdir, 'test.img')
         save(img, fname)
-        for i in range(N):
-            imgs.append(load(fname))
+        imgs.extend(load(fname) for _ in range(N))
     finally:
         del img, imgs
         shutil.rmtree(tmpdir)
diff --git a/nibabel/tests/test_fileholders.py b/nibabel/tests/test_fileholders.py
index 33b3f76e6f..83fe75aecc 100644
--- a/nibabel/tests/test_fileholders.py
+++ b/nibabel/tests/test_fileholders.py
@@ -1,5 +1,4 @@
-"""Testing fileholders
-"""
+"""Testing fileholders"""
 
 from io import BytesIO
 
diff --git a/nibabel/tests/test_filename_parser.py b/nibabel/tests/test_filename_parser.py
index 29da7b6f61..4e53cb2e5d 100644
--- a/nibabel/tests/test_filename_parser.py
+++ b/nibabel/tests/test_filename_parser.py
@@ -8,9 +8,17 @@
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Tests for filename container"""
 
+import pathlib
+
 import pytest
 
-from ..filename_parser import TypesFilenamesError, parse_filename, splitext_addext, types_filenames
+from ..filename_parser import (
+    TypesFilenamesError,
+    _stringify_path,
+    parse_filename,
+    splitext_addext,
+    types_filenames,
+)
 
 
 def test_filenames():
@@ -123,3 +131,19 @@ def test_splitext_addext():
     assert res == ('..', '', '')
     res = splitext_addext('...')
     assert res == ('...', '', '')
+
+
+def test__stringify_path():
+    res = _stringify_path('fname.ext.gz')
+    assert res == 'fname.ext.gz'
+    res = _stringify_path(pathlib.Path('fname.ext.gz'))
+    assert res == 'fname.ext.gz'
+
+    home = pathlib.Path.home().as_posix()
+    res = _stringify_path(pathlib.Path('~/fname.ext.gz'))
+    assert res == f'{home}/fname.ext.gz'
+
+    res = _stringify_path(pathlib.Path('./fname.ext.gz'))
+    assert res == 'fname.ext.gz'
+    res = _stringify_path(pathlib.Path('../fname.ext.gz'))
+    assert res == '../fname.ext.gz'
diff --git a/nibabel/tests/test_files_interface.py b/nibabel/tests/test_files_interface.py
index 52557d353d..b3562b6083 100644
--- a/nibabel/tests/test_files_interface.py
+++ b/nibabel/tests/test_files_interface.py
@@ -6,8 +6,7 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Testing filesets - a draft
-"""
+"""Testing filesets - a draft"""
 
 from io import BytesIO
 
@@ -29,7 +28,7 @@ def test_files_spatialimages():
     ]
     for klass in klasses:
         file_map = klass.make_file_map()
-        for key, value in file_map.items():
+        for value in file_map.values():
             assert value.filename is None
             assert value.fileobj is None
             assert value.pos == 0
@@ -42,7 +41,7 @@ def test_files_spatialimages():
             img = klass(arr.astype(np.float32), aff)
         else:
             img = klass(arr, aff)
-        for key, value in img.file_map.items():
+        for value in img.file_map.values():
             assert value.filename is None
             assert value.fileobj is None
             assert value.pos == 0
diff --git a/nibabel/tests/test_fileslice.py b/nibabel/tests/test_fileslice.py
index e9f65e45a2..ae842217ff 100644
--- a/nibabel/tests/test_fileslice.py
+++ b/nibabel/tests/test_fileslice.py
@@ -1,6 +1,5 @@
 """Test slicing of file-like objects"""
 
-
 import time
 from functools import partial
 from io import BytesIO
@@ -490,16 +489,16 @@ def test_optimize_read_slicers():
         (slice(None),),
     )
     # Check gap threshold with 3D
-    _depends0 = partial(threshold_heuristic, skip_thresh=10 * 4 - 1)
-    _depends1 = partial(threshold_heuristic, skip_thresh=10 * 4)
+    depends0 = partial(threshold_heuristic, skip_thresh=10 * 4 - 1)
+    depends1 = partial(threshold_heuristic, skip_thresh=10 * 4)
     assert optimize_read_slicers(
-        (slice(9), slice(None), slice(None)), (10, 6, 2), 4, _depends0
+        (slice(9), slice(None), slice(None)), (10, 6, 2), 4, depends0
     ) == ((slice(None), slice(None), slice(None)), (slice(0, 9, 1), slice(None), slice(None)))
     assert optimize_read_slicers(
-        (slice(None), slice(5), slice(None)), (10, 6, 2), 4, _depends0
+        (slice(None), slice(5), slice(None)), (10, 6, 2), 4, depends0
     ) == ((slice(None), slice(0, 5, 1), slice(None)), (slice(None), slice(None), slice(None)))
     assert optimize_read_slicers(
-        (slice(None), slice(5), slice(None)), (10, 6, 2), 4, _depends1
+        (slice(None), slice(5), slice(None)), (10, 6, 2), 4, depends1
     ) == ((slice(None), slice(None), slice(None)), (slice(None), slice(0, 5, 1), slice(None)))
     # Check longs as integer slices
     sn = slice(None)
diff --git a/nibabel/tests/test_fileutils.py b/nibabel/tests/test_fileutils.py
index 21c7676fce..bc202c6682 100644
--- a/nibabel/tests/test_fileutils.py
+++ b/nibabel/tests/test_fileutils.py
@@ -6,9 +6,7 @@
 #   copyright and license terms.
 #
 # ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Testing fileutils module
-"""
-
+"""Testing fileutils module"""
 
 import pytest
 
diff --git a/nibabel/tests/test_floating.py b/nibabel/tests/test_floating.py
index a06c180b84..82c8e667a9 100644
--- a/nibabel/tests/test_floating.py
+++ b/nibabel/tests/test_floating.py
@@ -1,23 +1,21 @@
-"""Test floating point deconstructions and floor methods
-"""
+"""Test floating point deconstructions and floor methods"""
+
 import sys
 
 import numpy as np
-import pytest
+from packaging.version import Version
 
 from ..casting import (
     FloatingError,
     _check_maxexp,
     _check_nmant,
-    as_int,
     ceil_exact,
     floor_exact,
-    floor_log2,
     have_binary128,
-    int_to_float,
     longdouble_precision_improved,
     ok_floats,
     on_powerpc,
+    sctypes,
     type_info,
 )
 from ..testing import suppress_warnings
@@ -26,6 +24,8 @@
 
 LD_INFO = type_info(np.longdouble)
 
+FP_OVERFLOW_WARN = Version(np.__version__) < Version('2.0.0.dev0')
+
 
 def dtt2dict(dtt):
     """Create info dictionary from numpy type"""
@@ -43,7 +43,7 @@ def dtt2dict(dtt):
 
 def test_type_info():
     # Test routine to get min, max, nmant, nexp
-    for dtt in np.sctypes['int'] + np.sctypes['uint']:
+    for dtt in sctypes['int'] + sctypes['uint']:
         info = np.iinfo(dtt)
         infod = type_info(dtt)
         assert infod == dict(
@@ -123,99 +123,31 @@ def test_check_nmant_nexp():
             assert _check_maxexp(t, ti['maxexp'])
 
 
-def test_as_int():
-    # Integer representation of number
-    assert as_int(2.0) == 2
-    assert as_int(-2.0) == -2
-    with pytest.raises(FloatingError):
-        as_int(2.1)
-    with pytest.raises(FloatingError):
-        as_int(-2.1)
-    assert as_int(2.1, False) == 2
-    assert as_int(-2.1, False) == -2
-    v = np.longdouble(2**64)
-    assert as_int(v) == 2**64
-    # Have all long doubles got 63+1 binary bits of precision?  Windows 32-bit
-    # longdouble appears to have 52 bit precision, but we avoid that by checking
-    # for known precisions that are less than that required
-    try:
-        nmant = type_info(np.longdouble)['nmant']
-    except FloatingError:
-        nmant = 63  # Unknown precision, let's hope it's at least 63
-    v = np.longdouble(2) ** (nmant + 1) - 1
-    assert as_int(v) == 2 ** (nmant + 1) - 1
-    # Check for predictable overflow
-    nexp64 = floor_log2(type_info(np.float64)['max'])
-    with np.errstate(over='ignore'):
-        val = np.longdouble(2**nexp64) * 2  # outside float64 range
-    with pytest.raises(OverflowError):
-        as_int(val)
-    with pytest.raises(OverflowError):
-        as_int(-val)
-
-
-def test_int_to_float():
-    # Convert python integer to floating point
-    # Standard float types just return cast value
-    for ie3 in IEEE_floats:
-        nmant = type_info(ie3)['nmant']
-        for p in range(nmant + 3):
-            i = 2**p + 1
-            assert int_to_float(i, ie3) == ie3(i)
-            assert int_to_float(-i, ie3) == ie3(-i)
-        # IEEEs in this case are binary formats only
-        nexp = floor_log2(type_info(ie3)['max'])
-        # Values too large for the format
-        smn, smx = -(2 ** (nexp + 1)), 2 ** (nexp + 1)
-        if ie3 is np.float64:
-            with pytest.raises(OverflowError):
-                int_to_float(smn, ie3)
-            with pytest.raises(OverflowError):
-                int_to_float(smx, ie3)
-        else:
-            assert int_to_float(smn, ie3) == ie3(smn)
-            assert int_to_float(smx, ie3) == ie3(smx)
-    # Longdoubles do better than int, we hope
-    LD = np.longdouble
-    # up to integer precision of float64 nmant, we get the same result as for
-    # casting directly
+def test_int_longdouble_np_regression():
+    # Test longdouble conversion from int works as expected
+    # Previous versions of numpy would fail, and we used a custom int_to_float()
+    # function. This test remains to ensure we don't need to bring it back.
     nmant = type_info(np.float64)['nmant']
-    for p in range(nmant + 2):  # implicit
-        i = 2**p - 1
-        assert int_to_float(i, LD) == LD(i)
-        assert int_to_float(-i, LD) == LD(-i)
-    # Above max of float64, we're hosed
-    nexp64 = floor_log2(type_info(np.float64)['max'])
-    smn64, smx64 = -(2 ** (nexp64 + 1)), 2 ** (nexp64 + 1)
-    # The algorithm here implemented goes through float64, so supermax and
-    # supermin will cause overflow errors
-    with pytest.raises(OverflowError):
-        int_to_float(smn64, LD)
-    with pytest.raises(OverflowError):
-        int_to_float(smx64, LD)
-    try:
-        nmant = type_info(np.longdouble)['nmant']
-    except FloatingError:  # don't know where to test
-        return
     # test we recover precision just above nmant
     i = 2 ** (nmant + 1) - 1
-    assert as_int(int_to_float(i, LD)) == i
-    assert as_int(int_to_float(-i, LD)) == -i
+    assert int(np.longdouble(i)) == i
+    assert int(np.longdouble(-i)) == -i
     # If longdouble can cope with 2**64, test
     if nmant >= 63:
         # Check conversion to int; the line below causes an error subtracting
         # ints / uint64 values, at least for Python 3.3 and numpy dev 1.8
         big_int = np.uint64(2**64 - 1)
-        assert as_int(int_to_float(big_int, LD)) == big_int
+        assert int(np.longdouble(big_int)) == big_int
 
 
-def test_as_int_np_fix():
-    # Test as_int works for integers.  We need as_int for integers because of a
+def test_int_np_regression():
+    # Test int works as expected for integers.
+    # We previously used a custom as_int() for integers because of a
     # numpy 1.4.1 bug such that int(np.uint32(2**32-1) == -1
-    for t in np.sctypes['int'] + np.sctypes['uint']:
+    for t in sctypes['int'] + sctypes['uint']:
         info = np.iinfo(t)
         mn, mx = np.array([info.min, info.max], dtype=t)
-        assert (mn, mx) == (as_int(mn), as_int(mx))
+        assert (mn, mx) == (int(mn), int(mx))
 
 
 def test_floor_exact_16():
@@ -237,7 +169,9 @@ def test_floor_exact_64():
         assert floor_exact(test_val, np.float64) == 2 ** (e + 1) - int(gap)
 
 
-def test_floor_exact():
+def test_floor_exact(max_digits):
+    max_digits(4950)  # max longdouble is ~10**4932
+
     to_test = IEEE_floats + [float]
     try:
         type_info(np.longdouble)['nmant']
@@ -248,16 +182,16 @@ def test_floor_exact():
         to_test.append(np.longdouble)
     # When numbers go above int64 - I believe, numpy comparisons break down,
     # so we have to cast to int before comparison
-    int_flex = lambda x, t: as_int(floor_exact(x, t))
-    int_ceex = lambda x, t: as_int(ceil_exact(x, t))
+    int_flex = lambda x, t: int(floor_exact(x, t))
+    int_ceex = lambda x, t: int(ceil_exact(x, t))
     for t in to_test:
         # A number bigger than the range returns the max
         info = type_info(t)
-        assert floor_exact(2**5000, t) == np.inf
-        assert ceil_exact(2**5000, t) == np.inf
+        assert floor_exact(10**4933, t) == np.inf
+        assert ceil_exact(10**4933, t) == np.inf
         # A number more negative returns -inf
-        assert floor_exact(-(2**5000), t) == -np.inf
-        assert ceil_exact(-(2**5000), t) == -np.inf
+        assert floor_exact(-(10**4933), t) == -np.inf
+        assert ceil_exact(-(10**4933), t) == -np.inf
         # Check around end of integer precision
         nmant = info['nmant']
         for i in range(nmant + 1):
@@ -286,7 +220,7 @@ def test_floor_exact():
         for i in range(5):
             iv = 2 ** (nmant + 1 + i)
             gap = 2 ** (i + 1)
-            assert as_int(t(iv) + t(gap)) == iv + gap
+            assert int(t(iv) + t(gap)) == iv + gap
             for j in range(1, gap):
                 assert int_flex(iv + j, t) == iv
                 assert int_flex(iv + gap + j, t) == iv + gap
diff --git a/nibabel/tests/test_funcs.py b/nibabel/tests/test_funcs.py
index 10f6e90813..b4139f30ef 100644
--- a/nibabel/tests/test_funcs.py
+++ b/nibabel/tests/test_funcs.py
@@ -23,7 +23,7 @@
 
 def _as_fname(img):
     global _counter
-    fname = 'img%3d.nii' % _counter
+    fname = f'img{_counter:3d}.nii'
     _counter = _counter + 1
     save(img, fname)
     return fname
@@ -58,7 +58,6 @@ def test_concat():
 
                 # Loop over every possible axis, including None (explicit and implied)
                 for axis in list(range(-(dim - 2), (dim - 1))) + [None, '__default__']:
-
                     # Allow testing default vs. passing explicit param
                     if axis == '__default__':
                         np_concat_kwargs = dict(axis=-1)
@@ -102,9 +101,9 @@ def test_concat():
                             except ValueError as ve:
                                 assert expect_error, str(ve)
                             else:
-                                assert (
-                                    not expect_error
-                                ), 'Expected a concatenation error, but got none.'
+                                assert not expect_error, (
+                                    'Expected a concatenation error, but got none.'
+                                )
                                 assert_array_equal(all_imgs.get_fdata(), all_data)
                                 assert_array_equal(all_imgs.affine, affine)
 
@@ -118,9 +117,9 @@ def test_concat():
                             except ValueError as ve:
                                 assert expect_error, str(ve)
                             else:
-                                assert (
-                                    not expect_error
-                                ), 'Expected a concatenation error, but got none.'
+                                assert not expect_error, (
+                                    'Expected a concatenation error, but got none.'
+                                )
                                 assert_array_equal(all_imgs.get_fdata(), all_data)
                                 assert_array_equal(all_imgs.affine, affine)
 
diff --git a/nibabel/tests/test_image_api.py b/nibabel/tests/test_image_api.py
index 091bc57e8c..5898762322 100644
--- a/nibabel/tests/test_image_api.py
+++ b/nibabel/tests/test_image_api.py
@@ -25,6 +25,7 @@
 
 import io
 import pathlib
+import sys
 import warnings
 from functools import partial
 from itertools import product
@@ -39,7 +40,7 @@
 import unittest
 
 import pytest
-from numpy.testing import assert_allclose, assert_almost_equal, assert_array_equal, assert_warns
+from numpy.testing import assert_allclose, assert_almost_equal, assert_array_equal
 
 from nibabel.arraywriters import WriterError
 from nibabel.testing import (
@@ -47,8 +48,8 @@
     bytesio_filemap,
     bytesio_round_trip,
     clear_and_catch_warnings,
+    deprecated_to,
     expires,
-    nullcontext,
 )
 
 from .. import (
@@ -69,7 +70,7 @@
     minc2,
     parrec,
 )
-from ..deprecator import ExpiredDeprecationError
+from ..casting import sctypes
 from ..spatialimages import SpatialImage
 from ..tmpdirs import InTemporaryDirectory
 from .test_api_validators import ValidateAPI
@@ -79,10 +80,6 @@
 from .test_parrec import EXAMPLE_IMAGES as PARREC_EXAMPLE_IMAGES
 
 
-def maybe_deprecated(meth_name):
-    return pytest.deprecated_call() if meth_name == 'get_data' else nullcontext()
-
-
 class GenericImageAPI(ValidateAPI):
     """General image validation API"""
 
@@ -172,7 +169,7 @@ def validate_filenames(self, imaker, params):
         for path in (fname, pathlib.Path(fname)):
             with InTemporaryDirectory():
                 # Validate that saving or loading a file doesn't use deprecated methods internally
-                with clear_and_catch_warnings() as w:
+                with clear_and_catch_warnings():
                     warnings.filterwarnings(
                         'error', category=DeprecationWarning, module=r'nibabel.*'
                     )
@@ -193,7 +190,7 @@ def validate_no_slicing(self, imaker, params):
     @expires('5.0.0')
     def validate_get_data_deprecated(self, imaker, params):
         img = imaker()
-        with pytest.deprecated_call():
+        with deprecated_to('5.0.0'):
             data = img.get_data()
         assert_array_equal(np.asanyarray(img.dataobj), data)
 
@@ -245,14 +242,12 @@ def validate_data_interface(self, imaker, params):
                 self._check_array_interface(imaker, meth_name)
             method = getattr(img, meth_name)
             # Data shape is same as image shape
-            with maybe_deprecated(meth_name):
-                assert img.shape == method().shape
+            assert img.shape == method().shape
             # Data ndim is same as image ndim
-            with maybe_deprecated(meth_name):
-                assert img.ndim == method().ndim
+            assert img.ndim == method().ndim
             # Values to get_data caching parameter must be 'fill' or
             # 'unchanged'
-            with maybe_deprecated(meth_name), pytest.raises(ValueError):
+            with pytest.raises(ValueError):
                 method(caching='something')
         # dataobj is read only
         fake_data = np.zeros(img.shape, dtype=img.get_data_dtype())
@@ -276,13 +271,11 @@ def _check_proxy_interface(self, imaker, meth_name):
         assert not img.in_memory
         # Load with caching='unchanged'
         method = getattr(img, meth_name)
-        with maybe_deprecated(meth_name):
-            data = method(caching='unchanged')
+        data = method(caching='unchanged')
         # Still not cached
         assert not img.in_memory
         # Default load, does caching
-        with maybe_deprecated(meth_name):
-            data = method()
+        data = method()
         # Data now cached. in_memory is True if either of the get_data
         # or get_fdata caches are not-None
         assert img.in_memory
@@ -294,36 +287,30 @@ def _check_proxy_interface(self, imaker, meth_name):
         # integers, but lets assume that's not true here.
         assert_array_equal(proxy_data, data)
         # Now caching='unchanged' does nothing, returns cached version
-        with maybe_deprecated(meth_name):
-            data_again = method(caching='unchanged')
+        data_again = method(caching='unchanged')
         assert data is data_again
         # caching='fill' does nothing because the cache is already full
-        with maybe_deprecated(meth_name):
-            data_yet_again = method(caching='fill')
+        data_yet_again = method(caching='fill')
         assert data is data_yet_again
         # changing array data does not change proxy data, or reloaded
         # data
         data[:] = 42
         assert_array_equal(proxy_data, proxy_copy)
         assert_array_equal(np.asarray(img.dataobj), proxy_copy)
-        # It does change the result of get_data
-        with maybe_deprecated(meth_name):
-            assert_array_equal(method(), 42)
+        # It does change the result of get_fdata
+        assert_array_equal(method(), 42)
         # until we uncache
         img.uncache()
         # Which unsets in_memory
         assert not img.in_memory
-        with maybe_deprecated(meth_name):
-            assert_array_equal(method(), proxy_copy)
+        assert_array_equal(method(), proxy_copy)
         # Check caching='fill' does cache data
         img = imaker()
         method = getattr(img, meth_name)
         assert not img.in_memory
-        with maybe_deprecated(meth_name):
-            data = method(caching='fill')
+        data = method(caching='fill')
         assert img.in_memory
-        with maybe_deprecated(meth_name):
-            data_again = method()
+        data_again = method()
         assert data is data_again
         # Check that caching refreshes for new floating point type.
         img.uncache()
@@ -367,8 +354,7 @@ def _check_array_caching(self, imaker, meth_name, caching):
         get_data_func = method if caching is None else partial(method, caching=caching)
         assert isinstance(img.dataobj, np.ndarray)
         assert img.in_memory
-        with maybe_deprecated(meth_name):
-            data = get_data_func()
+        data = get_data_func()
         # Returned data same object as underlying dataobj if using
         # old ``get_data`` method, or using newer ``get_fdata``
         # method, where original array was float64.
@@ -376,8 +362,7 @@ def _check_array_caching(self, imaker, meth_name, caching):
         dataobj_is_data = arr_dtype == np.float64 or method == img.get_data
         # Set something to the output array.
         data[:] = 42
-        with maybe_deprecated(meth_name):
-            get_result_changed = np.all(get_data_func() == 42)
+        get_result_changed = np.all(get_data_func() == 42)
         assert get_result_changed == (dataobj_is_data or caching != 'unchanged')
         if dataobj_is_data:
             assert data is img.dataobj
@@ -386,15 +371,13 @@ def _check_array_caching(self, imaker, meth_name, caching):
             assert_array_equal(np.asarray(img.dataobj), 42)
             # Uncache has no effect
             img.uncache()
-            with maybe_deprecated(meth_name):
-                assert_array_equal(get_data_func(), 42)
+            assert_array_equal(get_data_func(), 42)
         else:
             assert not data is img.dataobj
             assert not np.all(np.asarray(img.dataobj) == 42)
             # Uncache does have an effect
             img.uncache()
-            with maybe_deprecated(meth_name):
-                assert not np.all(get_data_func() == 42)
+            assert not np.all(get_data_func() == 42)
         # in_memory is always true for array images, regardless of
         # cache state.
         img.uncache()
@@ -403,12 +386,11 @@ def _check_array_caching(self, imaker, meth_name, caching):
             return
         # Return original array from get_fdata only if the input array is the
         # requested dtype.
-        float_types = np.sctypes['float']
+        float_types = sctypes['float']
         if arr_dtype not in float_types:
             return
         for float_type in float_types:
-            with maybe_deprecated(meth_name):
-                data = get_data_func(dtype=float_type)
+            data = get_data_func(dtype=float_type)
             assert (data is img.dataobj) == (arr_dtype == float_type)
 
     def validate_shape(self, imaker, params):
@@ -579,6 +561,10 @@ def validate_from_url(self, imaker, params):
         del img
         del rt_img
 
+    @pytest.mark.xfail(
+        sys.version_info >= (3, 12),
+        reason='Response type for file: urls is not a stream in Python 3.12',
+    )
     def validate_from_file_url(self, imaker, params):
         tmp_path = self.tmp_path
 
diff --git a/nibabel/tests/test_image_load_save.py b/nibabel/tests/test_image_load_save.py
index 962a2433bf..0e5fd57d08 100644
--- a/nibabel/tests/test_image_load_save.py
+++ b/nibabel/tests/test_image_load_save.py
@@ -7,6 +7,7 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Tests for loader function"""
+
 import logging
 import pathlib
 import shutil
@@ -24,7 +25,6 @@
     MGHImage,
     Minc1Image,
     Minc2Image,
-    Nifti1Header,
     Nifti1Image,
     Nifti1Pair,
     Nifti2Image,
@@ -40,7 +40,7 @@
 from .. import spm99analyze as spm99
 from ..optpkg import optional_package
 from ..spatialimages import SpatialImage
-from ..testing import expires
+from ..testing import deprecated_to, expires
 from ..tmpdirs import InTemporaryDirectory
 from ..volumeutils import native_code, swapped_code
 
@@ -131,7 +131,7 @@ def test_save_load():
     affine[:3, 3] = [3, 2, 1]
     img = ni1.Nifti1Image(data, affine)
     img.set_data_dtype(npt)
-    with InTemporaryDirectory() as pth:
+    with InTemporaryDirectory():
         nifn = 'an_image.nii'
         sifn = 'another_image.img'
         ni1.save(img, nifn)
@@ -285,7 +285,7 @@ def test_filename_save():
 @expires('5.0.0')
 def test_guessed_image_type():
     # Test whether we can guess the image type from example files
-    with pytest.deprecated_call():
+    with deprecated_to('5.0.0'):
         assert nils.guessed_image_type(pjoin(DATA_PATH, 'example4d.nii.gz')) == Nifti1Image
         assert nils.guessed_image_type(pjoin(DATA_PATH, 'nifti1.hdr')) == Nifti1Pair
         assert nils.guessed_image_type(pjoin(DATA_PATH, 'example_nifti2.nii.gz')) == Nifti2Image
diff --git a/nibabel/tests/test_image_types.py b/nibabel/tests/test_image_types.py
index 9fd48ee697..a9c41763a7 100644
--- a/nibabel/tests/test_image_types.py
+++ b/nibabel/tests/test_image_types.py
@@ -15,19 +15,14 @@
 import numpy as np
 
 from .. import (
-    AnalyzeHeader,
-    AnalyzeImage,
     MGHImage,
     Minc1Image,
     Minc2Image,
-    Nifti1Header,
     Nifti1Image,
     Nifti1Pair,
-    Nifti2Header,
     Nifti2Image,
     Nifti2Pair,
     Spm2AnalyzeImage,
-    Spm99AnalyzeImage,
     all_image_classes,
 )
 
@@ -73,7 +68,7 @@ def check_img(img_path, img_klass, sniff_mode, sniff, expect_success, msg):
                 # Check that the image type was recognized.
                 new_msg = (
                     f'{basename(img_path)} ({msg}) image '
-                    f"is{'' if is_img else ' not'} "
+                    f'is{"" if is_img else " not"} '
                     f'a {img_klass.__name__} image.'
                 )
                 assert is_img, new_msg
@@ -93,7 +88,6 @@ def check_img(img_path, img_klass, sniff_mode, sniff, expect_success, msg):
             irrelevant=b'a' * (sizeof_hdr - 1),  # A too-small sniff, query
             bad_sniff=b'a' * sizeof_hdr,  # Bad sniff, should fail
         ).items():
-
             for klass in img_klasses:
                 if klass == expected_img_klass:
                     # Class will load unless you pass a bad sniff,
diff --git a/nibabel/tests/test_imageclasses.py b/nibabel/tests/test_imageclasses.py
index 74f05dc6e3..90ef966d2d 100644
--- a/nibabel/tests/test_imageclasses.py
+++ b/nibabel/tests/test_imageclasses.py
@@ -1,15 +1,11 @@
-"""Testing imageclasses module
-"""
+"""Testing imageclasses module"""
 
-import warnings
 from os.path import dirname
 from os.path import join as pjoin
 
 import numpy as np
-import pytest
 
 import nibabel as nib
-from nibabel import imageclasses
 from nibabel.analyze import AnalyzeImage
 from nibabel.imageclasses import spatial_axes_first
 from nibabel.nifti1 import Nifti1Image
diff --git a/nibabel/tests/test_imageglobals.py b/nibabel/tests/test_imageglobals.py
index ac043d192b..9de72e87c6 100644
--- a/nibabel/tests/test_imageglobals.py
+++ b/nibabel/tests/test_imageglobals.py
@@ -6,8 +6,8 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Tests for imageglobals module
-"""
+"""Tests for imageglobals module"""
+
 from .. import imageglobals as igs
 
 
diff --git a/nibabel/tests/test_init.py b/nibabel/tests/test_init.py
index ff4dc082f6..d339c4e26b 100644
--- a/nibabel/tests/test_init.py
+++ b/nibabel/tests/test_init.py
@@ -1,13 +1,15 @@
+import pathlib
+import unittest
+from importlib.resources import files
 from unittest import mock
 
 import pytest
-from pkg_resources import resource_filename
 
 import nibabel as nib
 
 
 @pytest.mark.parametrize(
-    'verbose, v_args', [(-2, ['-qq']), (-1, ['-q']), (0, []), (1, ['-v']), (2, ['-vv'])]
+    ('verbose', 'v_args'), [(-2, ['-qq']), (-1, ['-q']), (0, []), (1, ['-v']), (2, ['-vv'])]
 )
 @pytest.mark.parametrize('doctests', (True, False))
 @pytest.mark.parametrize('coverage', (True, False))
@@ -38,12 +40,11 @@ def test_nibabel_test_errors():
 
 
 def test_nibabel_bench():
-    expected_args = ['-c', '--pyargs', 'nibabel']
+    config_path = files('nibabel') / 'benchmarks/pytest.benchmark.ini'
+    if not isinstance(config_path, pathlib.Path):
+        raise unittest.SkipTest('Package is not unpacked; could get temp path')
 
-    try:
-        expected_args.insert(1, resource_filename('nibabel', 'benchmarks/pytest.benchmark.ini'))
-    except:
-        raise unittest.SkipTest('Not installed')
+    expected_args = ['-c', str(config_path), '--pyargs', 'nibabel']
 
     with mock.patch('pytest.main') as pytest_main:
         nib.bench(verbose=0)
diff --git a/nibabel/tests/test_loadsave.py b/nibabel/tests/test_loadsave.py
index de1d818039..035cbb56c7 100644
--- a/nibabel/tests/test_loadsave.py
+++ b/nibabel/tests/test_loadsave.py
@@ -1,5 +1,4 @@
-"""Testing loadsave module
-"""
+"""Testing loadsave module"""
 
 import pathlib
 import shutil
@@ -21,7 +20,7 @@
 from ..loadsave import _signature_matches_extension, load, read_img_data
 from ..openers import Opener
 from ..optpkg import optional_package
-from ..testing import expires
+from ..testing import deprecated_to, expires
 from ..tmpdirs import InTemporaryDirectory
 
 _, have_scipy, _ = optional_package('scipy')
@@ -50,14 +49,14 @@ def test_read_img_data():
             fpath = pathlib.Path(fpath)
         img = load(fpath)
         data = img.get_fdata()
-        with pytest.deprecated_call():
+        with deprecated_to('5.0.0'):
             data2 = read_img_data(img)
         assert_array_equal(data, data2)
         # These examples have null scaling - assert prefer=unscaled is the same
         dao = img.dataobj
         if hasattr(dao, 'slope') and hasattr(img.header, 'raw_data_from_fileobj'):
             assert (dao.slope, dao.inter) == (1, 0)
-            with pytest.deprecated_call():
+            with deprecated_to('5.0.0'):
                 assert_array_equal(read_img_data(img, prefer='unscaled'), data)
         # Assert all caps filename works as well
         with TemporaryDirectory() as tmpdir:
@@ -89,7 +88,7 @@ def test_load_bad_compressed_extension(tmp_path, extension):
         pytest.skip()
     file_path = tmp_path / f'img.nii{extension}'
     file_path.write_bytes(b'bad')
-    with pytest.raises(ImageFileError, match='.*is not a .* file'):
+    with pytest.raises(ImageFileError, match=r'.*is not a .* file'):
         load(file_path)
 
 
@@ -100,7 +99,7 @@ def test_load_good_extension_with_bad_data(tmp_path, extension):
     file_path = tmp_path / f'img.nii{extension}'
     with Opener(file_path, 'wb') as fobj:
         fobj.write(b'bad')
-    with pytest.raises(ImageFileError, match='Cannot work out file type of .*'):
+    with pytest.raises(ImageFileError, match=r'Cannot work out file type of .*'):
         load(file_path)
 
 
@@ -140,21 +139,21 @@ def test_read_img_data_nifti():
             img = img_class(data, np.eye(4))
             img.set_data_dtype(out_dtype)
             # No filemap => error
-            with pytest.deprecated_call(), pytest.raises(ImageFileError):
+            with deprecated_to('5.0.0'), pytest.raises(ImageFileError):
                 read_img_data(img)
             # Make a filemap
             froot = f'an_image_{i}'
             img.file_map = img.filespec_to_file_map(froot)
             # Trying to read from this filemap will generate an error because
             # we are going to read from files that do not exist
-            with pytest.deprecated_call(), pytest.raises(OSError):
+            with deprecated_to('5.0.0'), pytest.raises(OSError):
                 read_img_data(img)
             img.to_file_map()
             # Load - now the scaling and offset correctly applied
             img_fname = img.file_map['image'].filename
             img_back = load(img_fname)
             data_back = img_back.get_fdata()
-            with pytest.deprecated_call():
+            with deprecated_to('5.0.0'):
                 assert_array_equal(data_back, read_img_data(img_back))
             # This is the same as if we loaded the image and header separately
             hdr_fname = img.file_map['header'].filename if 'header' in img.file_map else img_fname
@@ -166,16 +165,16 @@ def test_read_img_data_nifti():
             # Unscaled is the same as returned from raw_data_from_fileobj
             with open(img_fname, 'rb') as fobj:
                 unscaled_back = hdr_back.raw_data_from_fileobj(fobj)
-            with pytest.deprecated_call():
+            with deprecated_to('5.0.0'):
                 assert_array_equal(unscaled_back, read_img_data(img_back, prefer='unscaled'))
             # If we futz with the scaling in the header, the result changes
-            with pytest.deprecated_call():
+            with deprecated_to('5.0.0'):
                 assert_array_equal(data_back, read_img_data(img_back))
             has_inter = hdr_back.has_data_intercept
             old_slope = hdr_back['scl_slope']
             old_inter = hdr_back['scl_inter'] if has_inter else 0
             est_unscaled = (data_back - old_inter) / old_slope
-            with pytest.deprecated_call():
+            with deprecated_to('5.0.0'):
                 actual_unscaled = read_img_data(img_back, prefer='unscaled')
             assert_almost_equal(est_unscaled, actual_unscaled)
             img_back.header['scl_slope'] = 2.1
@@ -185,14 +184,14 @@ def test_read_img_data_nifti():
             else:
                 new_inter = 0
             # scaled scaling comes from new parameters in header
-            with pytest.deprecated_call():
+            with deprecated_to('5.0.0'):
                 assert np.allclose(actual_unscaled * 2.1 + new_inter, read_img_data(img_back))
             # Unscaled array didn't change
-            with pytest.deprecated_call():
+            with deprecated_to('5.0.0'):
                 assert_array_equal(actual_unscaled, read_img_data(img_back, prefer='unscaled'))
             # Check the offset too
             img.header.set_data_offset(1024)
-            # Delete arrays still pointing to file, so Windows can re-use
+            # Delete arrays still pointing to file, so Windows can reuse
             del actual_unscaled, unscaled_back
             img.to_file_map()
             # Write an integer of zeros after
@@ -200,14 +199,14 @@ def test_read_img_data_nifti():
                 fobj.write(b'\x00\x00')
             img_back = load(img_fname)
             data_back = img_back.get_fdata()
-            with pytest.deprecated_call():
+            with deprecated_to('5.0.0'):
                 assert_array_equal(data_back, read_img_data(img_back))
             img_back.header.set_data_offset(1026)
             # Check we pick up new offset
             exp_offset = np.zeros((data.size,), data.dtype) + old_inter
             exp_offset[:-1] = np.ravel(data_back, order='F')[1:]
             exp_offset = np.reshape(exp_offset, shape, order='F')
-            with pytest.deprecated_call():
+            with deprecated_to('5.0.0'):
                 assert_array_equal(exp_offset, read_img_data(img_back))
             # Delete stuff that might hold onto file references
             del img, img_back, data_back
diff --git a/nibabel/tests/test_minc1.py b/nibabel/tests/test_minc1.py
index be4f0deb07..8f88bf802d 100644
--- a/nibabel/tests/test_minc1.py
+++ b/nibabel/tests/test_minc1.py
@@ -9,8 +9,6 @@
 
 import bz2
 import gzip
-import types
-import warnings
 from io import BytesIO
 from os.path import join as pjoin
 
@@ -19,12 +17,10 @@
 from numpy.testing import assert_array_equal
 
 from .. import Nifti1Image, load, minc1
-from ..deprecated import ModuleProxy
-from ..deprecator import ExpiredDeprecationError
 from ..externals.netcdf import netcdf_file
 from ..minc1 import Minc1File, Minc1Image, MincHeader
 from ..optpkg import optional_package
-from ..testing import assert_data_similar, clear_and_catch_warnings, data_path
+from ..testing import assert_data_similar, data_path
 from ..tmpdirs import InTemporaryDirectory
 from . import test_spatialimages as tsi
 from .test_fileslice import slicer_samples
diff --git a/nibabel/tests/test_minc2.py b/nibabel/tests/test_minc2.py
index 251393818a..4c2973a728 100644
--- a/nibabel/tests/test_minc2.py
+++ b/nibabel/tests/test_minc2.py
@@ -10,6 +10,7 @@
 from os.path import join as pjoin
 
 import numpy as np
+import pytest
 
 from .. import minc2
 from ..minc2 import Minc2File, Minc2Image
@@ -121,3 +122,12 @@ class TestMinc2Image(tm2.TestMinc1Image):
         image_class = Minc2Image
         eg_images = (pjoin(data_path, 'small.mnc'),)
         module = minc2
+
+
+def test_bad_diminfo():
+    fname = pjoin(data_path, 'minc2_baddim.mnc')
+    # File has a bad spacing field 'xspace' when it should be
+    # `irregular`, `regular__` or absent (default to regular__).
+    # We interpret an invalid spacing as absent, but warn.
+    with pytest.warns(UserWarning):
+        Minc2Image.from_filename(fname)
diff --git a/nibabel/tests/test_minc2_data.py b/nibabel/tests/test_minc2_data.py
index e96e716699..a5ea38a8a9 100644
--- a/nibabel/tests/test_minc2_data.py
+++ b/nibabel/tests/test_minc2_data.py
@@ -6,8 +6,7 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Test we can correctly import example MINC2_PATH files
-"""
+"""Test we can correctly import example MINC2_PATH files"""
 
 import os
 from os.path import join as pjoin
diff --git a/nibabel/tests/test_mriutils.py b/nibabel/tests/test_mriutils.py
index 848579cee6..02b9da5482 100644
--- a/nibabel/tests/test_mriutils.py
+++ b/nibabel/tests/test_mriutils.py
@@ -6,9 +6,7 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Testing mriutils module
-"""
-
+"""Testing mriutils module"""
 
 import pytest
 from numpy.testing import assert_almost_equal
diff --git a/nibabel/tests/test_nibabel_data.py b/nibabel/tests/test_nibabel_data.py
index 1687589549..7e319ac3f5 100644
--- a/nibabel/tests/test_nibabel_data.py
+++ b/nibabel/tests/test_nibabel_data.py
@@ -1,10 +1,8 @@
-"""Tests for ``get_nibabel_data``
-"""
+"""Tests for ``get_nibabel_data``"""
 
 import os
-from os.path import dirname, isdir
+from os.path import dirname, isdir, realpath
 from os.path import join as pjoin
-from os.path import realpath
 
 from . import nibabel_data as nibd
 
diff --git a/nibabel/tests/test_nifti1.py b/nibabel/tests/test_nifti1.py
index 15971c21f5..acdcb337b6 100644
--- a/nibabel/tests/test_nifti1.py
+++ b/nibabel/tests/test_nifti1.py
@@ -7,6 +7,7 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Tests for nifti reading package"""
+
 import os
 import struct
 import unittest
@@ -79,8 +80,8 @@ class TestNifti1PairHeader(tana.TestAnalyzeHeader, tspm.HeaderScalingMixin):
         (np.int8, np.uint16, np.uint32, np.int64, np.uint64, np.complex128)
     )
     if have_binary128():
-        supported_np_types = supported_np_types.union((np.longdouble, np.longcomplex))
-    tana.add_intp(supported_np_types)
+        supported_np_types = supported_np_types.union((np.longdouble, np.clongdouble))
+    tana.add_duplicate_types(supported_np_types)
 
     def test_empty(self):
         tana.TestAnalyzeHeader.test_empty(self)
@@ -251,7 +252,7 @@ def test_magic_offset_checks(self):
         fhdr, message, raiser = self.log_chk(hdr, 45)
         assert fhdr['magic'] == b'ooh'
         assert (
-            message == 'magic string "ooh" is not valid; '
+            message == "magic string 'ooh' is not valid; "
             'leaving as is, but future errors are likely'
         )
         # For pairs, any offset is OK, but should be divisible by 16
@@ -537,11 +538,11 @@ def test_slice_times(self):
         hdr.set_slice_duration(0.1)
         # We need a function to print out the Nones and floating point
         # values in a predictable way, for the tests below.
-        _stringer = lambda val: val is not None and '%2.1f' % val or None
-        _print_me = lambda s: list(map(_stringer, s))
+        stringer = lambda val: f'{val:2.1f}' if val is not None else None
+        print_me = lambda s: list(map(stringer, s))
         # The following examples are from the nifti1.h documentation.
         hdr['slice_code'] = slice_order_codes['sequential increasing']
-        assert _print_me(hdr.get_slice_times()) == [
+        assert print_me(hdr.get_slice_times()) == [
             '0.0',
             '0.1',
             '0.2',
@@ -552,17 +553,17 @@ def test_slice_times(self):
         ]
         hdr['slice_start'] = 1
         hdr['slice_end'] = 5
-        assert _print_me(hdr.get_slice_times()) == [None, '0.0', '0.1', '0.2', '0.3', '0.4', None]
+        assert print_me(hdr.get_slice_times()) == [None, '0.0', '0.1', '0.2', '0.3', '0.4', None]
         hdr['slice_code'] = slice_order_codes['sequential decreasing']
-        assert _print_me(hdr.get_slice_times()) == [None, '0.4', '0.3', '0.2', '0.1', '0.0', None]
+        assert print_me(hdr.get_slice_times()) == [None, '0.4', '0.3', '0.2', '0.1', '0.0', None]
         hdr['slice_code'] = slice_order_codes['alternating increasing']
-        assert _print_me(hdr.get_slice_times()) == [None, '0.0', '0.3', '0.1', '0.4', '0.2', None]
+        assert print_me(hdr.get_slice_times()) == [None, '0.0', '0.3', '0.1', '0.4', '0.2', None]
         hdr['slice_code'] = slice_order_codes['alternating decreasing']
-        assert _print_me(hdr.get_slice_times()) == [None, '0.2', '0.4', '0.1', '0.3', '0.0', None]
+        assert print_me(hdr.get_slice_times()) == [None, '0.2', '0.4', '0.1', '0.3', '0.0', None]
         hdr['slice_code'] = slice_order_codes['alternating increasing 2']
-        assert _print_me(hdr.get_slice_times()) == [None, '0.2', '0.0', '0.3', '0.1', '0.4', None]
+        assert print_me(hdr.get_slice_times()) == [None, '0.2', '0.0', '0.3', '0.1', '0.4', None]
         hdr['slice_code'] = slice_order_codes['alternating decreasing 2']
-        assert _print_me(hdr.get_slice_times()) == [None, '0.4', '0.1', '0.3', '0.0', '0.2', None]
+        assert print_me(hdr.get_slice_times()) == [None, '0.4', '0.1', '0.3', '0.0', '0.2', None]
         # test set
         hdr = self.header_class()
         hdr.set_dim_info(slice=2)
@@ -577,12 +578,12 @@ def test_slice_times(self):
         with pytest.raises(HeaderDataError):
             # all None
             hdr.set_slice_times((None,) * len(times))
-        n_mid_times = times[:]
+        n_mid_times = times.copy()
         n_mid_times[3] = None
         with pytest.raises(HeaderDataError):
             # None in middle
             hdr.set_slice_times(n_mid_times)
-        funny_times = times[:]
+        funny_times = times.copy()
         funny_times[3] = 0.05
         with pytest.raises(HeaderDataError):
             # can't get single slice duration
@@ -731,7 +732,6 @@ def unshear_44(affine):
 
 
 class TestNifti1SingleHeader(TestNifti1PairHeader):
-
     header_class = Nifti1Header
 
     def test_empty(self):
@@ -820,7 +820,7 @@ def _qform_rt(self, img):
         hdr['qform_code'] = 3
         hdr['sform_code'] = 4
         # Save / reload using bytes IO objects
-        for key, value in img.file_map.items():
+        for value in img.file_map.values():
             value.fileobj = BytesIO()
         img.to_file_map()
         return img.from_file_map(img.file_map)
@@ -1169,7 +1169,7 @@ def test_dynamic_dtype_aliases(self):
             assert img.get_data_dtype() == alias
             img_rt = bytesio_round_trip(img)
             assert img_rt.get_data_dtype() == effective_dt
-            # Seralizing does not finalize the source image
+            # Serializing does not finalize the source image
             assert img.get_data_dtype() == alias
 
     def test_static_dtype_aliases(self):
@@ -1224,6 +1224,59 @@ def test_ext_eq():
     assert not ext == ext2
 
 
+def test_extension_content_access():
+    ext = Nifti1Extension('comment', b'123')
+    # Unmangled content access
+    assert ext.get_content() == b'123'
+
+    # Raw, text and JSON access
+    assert ext.content == b'123'
+    assert ext.text == '123'
+    assert ext.json() == 123
+
+    # Encoding can be set
+    ext.encoding = 'ascii'
+    assert ext.text == '123'
+
+    # Test that encoding errors are caught
+    ascii_ext = Nifti1Extension('comment', 'hôpital'.encode())
+    ascii_ext.encoding = 'ascii'
+    with pytest.raises(UnicodeDecodeError):
+        ascii_ext.text
+
+    json_ext = Nifti1Extension('unknown', b'{"a": 1}')
+    assert json_ext.content == b'{"a": 1}'
+    assert json_ext.text == '{"a": 1}'
+    assert json_ext.json() == {'a': 1}
+
+
+def test_legacy_underscore_content():
+    """Verify that subclasses that depended on access to ._content continue to work."""
+    import io
+    import json
+
+    class MyLegacyExtension(Nifti1Extension):
+        def _mangle(self, value):
+            return json.dumps(value).encode()
+
+        def _unmangle(self, value):
+            if isinstance(value, bytes):
+                value = value.decode()
+            return json.loads(value)
+
+    ext = MyLegacyExtension(0, '{}')
+
+    assert isinstance(ext._content, dict)
+    # Object identity is not broken by multiple accesses
+    assert ext._content is ext._content
+
+    ext._content['val'] = 1
+
+    fobj = io.BytesIO()
+    ext.write_to(fobj)
+    assert fobj.getvalue() == b'\x20\x00\x00\x00\x00\x00\x00\x00{"val": 1}' + bytes(14)
+
+
 def test_extension_codes():
     for k in extension_codes.keys():
         Nifti1Extension(k, 'somevalue')
@@ -1339,7 +1392,7 @@ def test_nifti_dicom_extension():
     dcmbytes_explicit = struct.pack('<HH2sH4s', 0x10, 0x20, b'LO', 4, b'NiPy')
     dcmext = Nifti1DicomExtension(2, dcmbytes_explicit)
     assert dcmext.__class__ == Nifti1DicomExtension
-    assert dcmext._guess_implicit_VR() is False
+    assert dcmext._is_implicit_VR is False
     assert dcmext._is_little_endian is True
     assert dcmext.get_code() == 2
     assert dcmext.get_content().PatientID == 'NiPy'
@@ -1350,7 +1403,7 @@ def test_nifti_dicom_extension():
     # create a single dicom tag (Patient ID, [0010,0020]) with Implicit VR
     dcmbytes_implicit = struct.pack('<HHL4s', 0x10, 0x20, 4, b'NiPy')
     dcmext = Nifti1DicomExtension(2, dcmbytes_implicit)
-    assert dcmext._guess_implicit_VR() is True
+    assert dcmext._is_implicit_VR is True
     assert dcmext.get_code() == 2
     assert dcmext.get_content().PatientID == 'NiPy'
     assert len(dcmext.get_content().values()) == 1
@@ -1362,7 +1415,7 @@ def test_nifti_dicom_extension():
     hdr_be = Nifti1Header(endianness='>')  # Big Endian Nifti1Header
     dcmext = Nifti1DicomExtension(2, dcmbytes_explicit_be, parent_hdr=hdr_be)
     assert dcmext.__class__ == Nifti1DicomExtension
-    assert dcmext._guess_implicit_VR() is False
+    assert dcmext._is_implicit_VR is False
     assert dcmext.get_code() == 2
     assert dcmext.get_content().PatientID == 'NiPy'
     assert dcmext.get_content()[0x10, 0x20].value == 'NiPy'
diff --git a/nibabel/tests/test_nifti2.py b/nibabel/tests/test_nifti2.py
index 742ef148bf..01d44c1595 100644
--- a/nibabel/tests/test_nifti2.py
+++ b/nibabel/tests/test_nifti2.py
@@ -7,13 +7,14 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Tests for nifti2 reading package"""
+
 import os
 
 import numpy as np
 from numpy.testing import assert_array_equal
 
 from .. import nifti2
-from ..nifti1 import Nifti1Extension, Nifti1Extensions, Nifti1Header, Nifti1PairHeader
+from ..nifti1 import Nifti1Extension, Nifti1Header, Nifti1PairHeader
 from ..nifti2 import Nifti2Header, Nifti2Image, Nifti2Pair, Nifti2PairHeader
 from ..testing import data_path
 from . import test_nifti1 as tn1
diff --git a/nibabel/tests/test_onetime.py b/nibabel/tests/test_onetime.py
index 426702fa43..d6b4579534 100644
--- a/nibabel/tests/test_onetime.py
+++ b/nibabel/tests/test_onetime.py
@@ -1,12 +1,25 @@
-import pytest
+from functools import cached_property
 
-from nibabel.onetime import auto_attr, setattr_on_read
-from nibabel.testing import expires
+from nibabel.onetime import ResetMixin, setattr_on_read
+from nibabel.testing import deprecated_to, expires
+
+
+class A(ResetMixin):
+    @cached_property
+    def y(self):
+        return self.x / 2.0
+
+    @cached_property
+    def z(self):
+        return self.x / 3.0
+
+    def __init__(self, x=1.0):
+        self.x = x
 
 
 @expires('5.0.0')
 def test_setattr_on_read():
-    with pytest.deprecated_call():
+    with deprecated_to('5.0.0'):
 
         class MagicProp:
             @setattr_on_read
@@ -21,15 +34,14 @@ def a(self):
     assert x.a is obj
 
 
-def test_auto_attr():
-    class MagicProp:
-        @auto_attr
-        def a(self):
-            return object()
-
-    x = MagicProp()
-    assert 'a' not in x.__dict__
-    obj = x.a
-    assert 'a' in x.__dict__
-    # Each call to object() produces a unique object. Verify we get the same one every time.
-    assert x.a is obj
+def test_ResetMixin():
+    a = A(10)
+    assert 'y' not in a.__dict__
+    assert a.y == 5
+    assert 'y' in a.__dict__
+    a.x = 20
+    assert a.y == 5
+    # Call reset and no error should be raised even though z was never accessed
+    a.reset()
+    assert 'y' not in a.__dict__
+    assert a.y == 10
diff --git a/nibabel/tests/test_openers.py b/nibabel/tests/test_openers.py
index b4f71f2501..05d0e04cd0 100644
--- a/nibabel/tests/test_openers.py
+++ b/nibabel/tests/test_openers.py
@@ -7,6 +7,7 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Test for openers module"""
+
 import contextlib
 import hashlib
 import os
@@ -17,10 +18,8 @@
 from unittest import mock
 
 import pytest
-from numpy.compat.py3k import asbytes, asstr
 from packaging.version import Version
 
-from ..deprecator import ExpiredDeprecationError
 from ..openers import HAVE_INDEXED_GZIP, BZ2File, DeterministicGzipFile, ImageOpener, Opener
 from ..optpkg import optional_package
 from ..tmpdirs import InTemporaryDirectory
@@ -38,7 +37,7 @@ def __init__(self, message):
     def write(self):
         pass
 
-    def read(self):
+    def read(self, size=-1, /):
         return self.message
 
 
@@ -122,41 +121,43 @@ def patch_indexed_gzip(state):
         values = (True, MockIndexedGzipFile)
     else:
         values = (False, GzipFile)
-    with mock.patch('nibabel.openers.HAVE_INDEXED_GZIP', values[0]), mock.patch(
-        'nibabel.openers.IndexedGzipFile', values[1], create=True
+    with (
+        mock.patch('nibabel.openers.HAVE_INDEXED_GZIP', values[0]),
+        mock.patch('nibabel.openers.IndexedGzipFile', values[1], create=True),
     ):
         yield
 
 
-def test_Opener_gzip_type():
-    # Test that BufferedGzipFile or IndexedGzipFile are used as appropriate
+def test_Opener_gzip_type(tmp_path):
+    # Test that GzipFile or IndexedGzipFile are used as appropriate
 
-    data = 'this is some test data'
-    fname = 'test.gz'
+    data = b'this is some test data'
+    fname = tmp_path / 'test.gz'
 
-    with InTemporaryDirectory():
+    # make some test data
+    with GzipFile(fname, mode='wb') as f:
+        f.write(data)
 
-        # make some test data
-        with GzipFile(fname, mode='wb') as f:
-            f.write(data.encode())
-
-        # Each test is specified by a tuple containing:
-        #   (indexed_gzip present, Opener kwargs, expected file type)
-        tests = [
-            (False, {'mode': 'rb', 'keep_open': True}, GzipFile),
-            (False, {'mode': 'rb', 'keep_open': False}, GzipFile),
-            (False, {'mode': 'wb', 'keep_open': True}, GzipFile),
-            (False, {'mode': 'wb', 'keep_open': False}, GzipFile),
-            (True, {'mode': 'rb', 'keep_open': True}, MockIndexedGzipFile),
-            (True, {'mode': 'rb', 'keep_open': False}, MockIndexedGzipFile),
-            (True, {'mode': 'wb', 'keep_open': True}, GzipFile),
-            (True, {'mode': 'wb', 'keep_open': False}, GzipFile),
-        ]
+    # Each test is specified by a tuple containing:
+    #   (indexed_gzip present, Opener kwargs, expected file type)
+    tests = [
+        (False, {'mode': 'rb', 'keep_open': True}, GzipFile),
+        (False, {'mode': 'rb', 'keep_open': False}, GzipFile),
+        (False, {'mode': 'wb', 'keep_open': True}, GzipFile),
+        (False, {'mode': 'wb', 'keep_open': False}, GzipFile),
+        (True, {'mode': 'rb', 'keep_open': True}, MockIndexedGzipFile),
+        (True, {'mode': 'rb', 'keep_open': False}, MockIndexedGzipFile),
+        (True, {'mode': 'wb', 'keep_open': True}, GzipFile),
+        (True, {'mode': 'wb', 'keep_open': False}, GzipFile),
+    ]
 
-        for test in tests:
-            igzip_present, kwargs, expected = test
-            with patch_indexed_gzip(igzip_present):
-                assert isinstance(Opener(fname, **kwargs).fobj, expected)
+    for test in tests:
+        igzip_present, kwargs, expected = test
+        with patch_indexed_gzip(igzip_present):
+            opener = Opener(fname, **kwargs)
+            assert isinstance(opener.fobj, expected)
+            # Explicit close to appease Windows
+            del opener
 
 
 class TestImageOpener(unittest.TestCase):
@@ -342,10 +343,10 @@ def test_iter():
         for input, does_t in files_to_test:
             with Opener(input, 'wb') as fobj:
                 for line in lines:
-                    fobj.write(asbytes(line + os.linesep))
+                    fobj.write(str.encode(line + os.linesep))
             with Opener(input, 'rb') as fobj:
                 for back_line, line in zip(fobj, lines):
-                    assert asstr(back_line).rstrip() == line
+                    assert back_line.decode().rstrip() == line
             if not does_t:
                 continue
             with Opener(input, 'rt') as fobj:
@@ -431,17 +432,17 @@ def test_DeterministicGzipFile_fileobj():
         with open('test.gz', 'wb') as fobj:
             with DeterministicGzipFile(filename='', mode='wb', fileobj=fobj) as gzobj:
                 gzobj.write(msg)
-        md5sum('test.gz') == ref_chksum
+        assert md5sum('test.gz') == ref_chksum
 
         with open('test.gz', 'wb') as fobj:
             with DeterministicGzipFile(fileobj=fobj, mode='wb') as gzobj:
                 gzobj.write(msg)
-        md5sum('test.gz') == ref_chksum
+        assert md5sum('test.gz') == ref_chksum
 
         with open('test.gz', 'wb') as fobj:
             with DeterministicGzipFile(filename='test.gz', mode='wb', fileobj=fobj) as gzobj:
                 gzobj.write(msg)
-        md5sum('test.gz') == ref_chksum
+        assert md5sum('test.gz') == ref_chksum
 
 
 def test_bitwise_determinism():
diff --git a/nibabel/tests/test_optpkg.py b/nibabel/tests/test_optpkg.py
index 7ffaa2f851..c243633a07 100644
--- a/nibabel/tests/test_optpkg.py
+++ b/nibabel/tests/test_optpkg.py
@@ -1,5 +1,4 @@
-"""Testing optpkg module
-"""
+"""Testing optpkg module"""
 
 import builtins
 import sys
diff --git a/nibabel/tests/test_orientations.py b/nibabel/tests/test_orientations.py
index 8821fac0e0..e7c32d7867 100644
--- a/nibabel/tests/test_orientations.py
+++ b/nibabel/tests/test_orientations.py
@@ -8,8 +8,6 @@
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Testing for orientations module"""
 
-import warnings
-
 import numpy as np
 import pytest
 from numpy.testing import assert_array_equal
@@ -26,7 +24,7 @@
     ornt2axcodes,
     ornt_transform,
 )
-from ..testing import expires
+from ..testing import deprecated_to, expires
 
 IN_ARRS = [
     np.eye(4),
@@ -185,7 +183,6 @@ def test_apply():
         apply_orientation(a[:, :, 1], ornt)
     with pytest.raises(OrientationError):
         apply_orientation(a, [[0, 1], [np.nan, np.nan], [2, 1]])
-    shape = np.array(a.shape)
     for ornt in ALL_ORNTS:
         t_arr = apply_orientation(a, ornt)
         assert_array_equal(a.shape, np.array(t_arr.shape)[np.array(ornt)[:, 0]])
@@ -407,6 +404,6 @@ def test_inv_ornt_aff():
 def test_flip_axis_deprecation():
     a = np.arange(24).reshape((2, 3, 4))
     axis = 1
-    with pytest.deprecated_call():
+    with deprecated_to('5.0.0'):
         a_flipped = flip_axis(a, axis)
     assert_array_equal(a_flipped, np.flip(a, axis))
diff --git a/nibabel/tests/test_parrec.py b/nibabel/tests/test_parrec.py
index 0a9d7c7dc2..a312c558a8 100644
--- a/nibabel/tests/test_parrec.py
+++ b/nibabel/tests/test_parrec.py
@@ -1,5 +1,4 @@
-"""Testing parrec module
-"""
+"""Testing parrec module"""
 
 from glob import glob
 from os.path import basename, dirname
@@ -192,15 +191,6 @@
 ]
 
 
-def _shuffle(arr):
-    """Return a copy of the array with entries shuffled.
-
-    Needed to avoid a bug in np.random.shuffle for numpy 1.7.
-    see:  numpy/numpy#4286
-    """
-    return arr[np.argsort(np.random.randn(len(arr)))]
-
-
 def test_top_level_load():
     # Test PARREC images can be loaded from nib.load
     img = top_load(EG_PAR)
@@ -294,8 +284,8 @@ def test_affine_regression():
     # Test against checked affines from previous runs
     # Checked against Michael's data using some GUI tools
     # Data at http://psydata.ovgu.de/philips_achieva_testfiles/conversion2
-    for basename, exp_affine in PREVIOUS_AFFINES.items():
-        fname = pjoin(DATA_PATH, basename + '.PAR')
+    for basename_affine, exp_affine in PREVIOUS_AFFINES.items():
+        fname = pjoin(DATA_PATH, basename_affine + '.PAR')
         with open(fname) as fobj:
             hdr = PARRECHeader.from_fileobj(fobj)
         assert_almost_equal(hdr.get_affine(), exp_affine)
@@ -332,7 +322,7 @@ def test_sorting_dual_echo_T1():
         t1_hdr = PARRECHeader.from_fileobj(fobj, strict_sort=True)
 
     # should get the correct order even if we randomly shuffle the order
-    t1_hdr.image_defs = _shuffle(t1_hdr.image_defs)
+    np.random.shuffle(t1_hdr.image_defs)
 
     sorted_indices = t1_hdr.get_sorted_slice_indices()
     sorted_echos = t1_hdr.image_defs['echo number'][sorted_indices]
@@ -363,7 +353,7 @@ def test_sorting_multiple_echos_and_contrasts():
         t1_hdr = PARRECHeader.from_fileobj(fobj, strict_sort=True)
 
     # should get the correct order even if we randomly shuffle the order
-    t1_hdr.image_defs = _shuffle(t1_hdr.image_defs)
+    np.random.shuffle(t1_hdr.image_defs)
 
     sorted_indices = t1_hdr.get_sorted_slice_indices()
     sorted_slices = t1_hdr.image_defs['slice number'][sorted_indices]
@@ -402,7 +392,7 @@ def test_sorting_multiecho_ASL():
         asl_hdr = PARRECHeader.from_fileobj(fobj, strict_sort=True)
 
     # should get the correct order even if we randomly shuffle the order
-    asl_hdr.image_defs = _shuffle(asl_hdr.image_defs)
+    np.random.shuffle(asl_hdr.image_defs)
 
     sorted_indices = asl_hdr.get_sorted_slice_indices()
     sorted_slices = asl_hdr.image_defs['slice number'][sorted_indices]
@@ -524,7 +514,7 @@ def test_diffusion_parameters_strict_sort():
         dti_hdr = PARRECHeader.from_fileobj(fobj, strict_sort=True)
 
     # should get the correct order even if we randomly shuffle the order
-    dti_hdr.image_defs = _shuffle(dti_hdr.image_defs)
+    np.random.shuffle(dti_hdr.image_defs)
 
     assert dti_hdr.get_data_shape() == (80, 80, 10, 8)
     assert dti_hdr.general_info['diffusion'] == 1
@@ -533,7 +523,10 @@ def test_diffusion_parameters_strict_sort():
     # DTI_PAR_BVECS gives bvecs copied from first slice each vol in DTI.PAR
     # Permute to match bvec directions to acquisition directions
     # note that bval sorting occurs prior to bvec sorting
-    assert_almost_equal(bvecs, DTI_PAR_BVECS[np.ix_(np.argsort(DTI_PAR_BVALS), [2, 0, 1])])
+    assert_almost_equal(
+        bvecs,
+        DTI_PAR_BVECS[np.ix_(np.argsort(DTI_PAR_BVALS, kind='stable'), [2, 0, 1])],
+    )
     # Check q vectors
     assert_almost_equal(dti_hdr.get_q_vectors(), bvals[:, None] * bvecs)
 
@@ -613,7 +606,7 @@ def test_truncations():
         PARRECHeader(gen_info, slice_info)
     gen_info['max_echoes'] = 1
     hdr = PARRECHeader(gen_info, slice_info)
-    # dyamics
+    # dynamics
     gen_info['max_dynamics'] = 3
     with pytest.raises(PARRECError):
         PARRECHeader(gen_info, slice_info)
@@ -890,7 +883,6 @@ def test_dualTR():
 def test_ADC_map():
     # test reading an apparent diffusion coefficient map
     with open(ADC_PAR) as fobj:
-
         # two truncation warnings expected because general_info indicates:
         # 1.) multiple directions
         # 2.) multiple b-values
diff --git a/nibabel/tests/test_parrec_data.py b/nibabel/tests/test_parrec_data.py
index a437fafeda..02a1d5733a 100644
--- a/nibabel/tests/test_parrec_data.py
+++ b/nibabel/tests/test_parrec_data.py
@@ -1,14 +1,11 @@
-"""Test we can correctly import example PARREC files
-"""
+"""Test we can correctly import example PARREC files"""
 
 import unittest
 from glob import glob
-from os.path import basename, exists
+from os.path import basename, exists, splitext
 from os.path import join as pjoin
-from os.path import splitext
 
 import numpy as np
-import pytest
 from numpy.testing import assert_almost_equal
 
 from .. import load as top_load
diff --git a/nibabel/tests/test_pkg_info.py b/nibabel/tests/test_pkg_info.py
index 0d8146fdb0..1a9a06dc93 100644
--- a/nibabel/tests/test_pkg_info.py
+++ b/nibabel/tests/test_pkg_info.py
@@ -1,8 +1,6 @@
-"""Testing package info
-"""
+"""Testing package info"""
 
 import pytest
-from packaging.version import Version
 
 import nibabel as nib
 from nibabel.pkg_info import cmp_pkg_version
@@ -16,7 +14,7 @@ def test_pkg_info():
         - nibabel.pkg_info.get_pkg_info
         - nibabel.pkg_info.pkg_commit_hash
     """
-    info = nib.get_info()
+    nib.get_info()
 
 
 def test_version():
@@ -39,7 +37,7 @@ def test_cmp_pkg_version_0():
 
 
 @pytest.mark.parametrize(
-    'test_ver, pkg_ver, exp_out',
+    ('test_ver', 'pkg_ver', 'exp_out'),
     [
         ('1.0', '1.0', 0),
         ('1.0.0', '1.0', 0),
@@ -56,8 +54,6 @@ def test_cmp_pkg_version_0():
         ('1.2.1rc1', '1.2.1', -1),
         ('1.2.1rc1', '1.2.1rc', 1),
         ('1.2.1rc', '1.2.1rc1', -1),
-        ('1.2.1rc1', '1.2.1rc', 1),
-        ('1.2.1rc', '1.2.1rc1', -1),
         ('1.2.1b', '1.2.1a', 1),
         ('1.2.1a', '1.2.1b', -1),
         ('1.2.0+1', '1.2', 1),
diff --git a/nibabel/tests/test_pointset.py b/nibabel/tests/test_pointset.py
new file mode 100644
index 0000000000..f4f0e4361b
--- /dev/null
+++ b/nibabel/tests/test_pointset.py
@@ -0,0 +1,181 @@
+from math import prod
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from nibabel import pointset as ps
+from nibabel.affines import apply_affine
+from nibabel.fileslice import strided_scalar
+from nibabel.optpkg import optional_package
+from nibabel.spatialimages import SpatialImage
+from nibabel.tests.nibabel_data import get_nibabel_data
+
+h5, has_h5py, _ = optional_package('h5py')
+
+FS_DATA = Path(get_nibabel_data()) / 'nitest-freesurfer'
+
+
+class TestPointsets:
+    rng = np.random.default_rng()
+
+    @pytest.mark.parametrize('shape', [(5, 2), (5, 3), (5, 4)])
+    @pytest.mark.parametrize('homogeneous', [True, False])
+    def test_init(self, shape, homogeneous):
+        coords = self.rng.random(shape)
+
+        if homogeneous:
+            coords = np.column_stack([coords, np.ones(shape[0])])
+
+        points = ps.Pointset(coords, homogeneous=homogeneous)
+        assert np.allclose(points.affine, np.eye(shape[1] + 1))
+        assert points.homogeneous is homogeneous
+        assert (points.n_coords, points.dim) == shape
+
+        points = ps.Pointset(coords, affine=np.diag([2] * shape[1] + [1]), homogeneous=homogeneous)
+        assert np.allclose(points.affine, np.diag([2] * shape[1] + [1]))
+        assert points.homogeneous is homogeneous
+        assert (points.n_coords, points.dim) == shape
+
+        # Badly shaped affine
+        with pytest.raises(ValueError):
+            ps.Pointset(coords, affine=[0, 1])
+
+        # Badly valued affine
+        with pytest.raises(ValueError):
+            ps.Pointset(coords, affine=np.ones((shape[1] + 1, shape[1] + 1)))
+
+    @pytest.mark.parametrize('shape', [(5, 2), (5, 3), (5, 4)])
+    @pytest.mark.parametrize('homogeneous', [True, False])
+    def test_affines(self, shape, homogeneous):
+        orig_coords = coords = self.rng.random(shape)
+
+        if homogeneous:
+            coords = np.column_stack([coords, np.ones(shape[0])])
+
+        points = ps.Pointset(coords, homogeneous=homogeneous)
+        assert np.allclose(points.get_coords(), orig_coords)
+
+        # Apply affines
+        scaler = np.diag([2] * shape[1] + [1])
+        scaled = scaler @ points
+        assert np.array_equal(scaled.coordinates, points.coordinates)
+        assert np.array_equal(scaled.affine, scaler)
+        assert np.allclose(scaled.get_coords(), 2 * orig_coords)
+
+        flipper = np.eye(shape[1] + 1)
+        # [[1, 0, 0], [0, 1, 0], [0, 0, 1]] becomes [[0, 1, 0], [1, 0, 0], [0, 0, 1]]
+        flipper[:-1] = flipper[-2::-1]
+        flipped = flipper @ points
+        assert np.array_equal(flipped.coordinates, points.coordinates)
+        assert np.array_equal(flipped.affine, flipper)
+        assert np.allclose(flipped.get_coords(), orig_coords[:, ::-1])
+
+        # Concatenate affines, with any associativity
+        for doubledup in [(scaler @ flipper) @ points, scaler @ (flipper @ points)]:
+            assert np.array_equal(doubledup.coordinates, points.coordinates)
+            assert np.allclose(doubledup.affine, scaler @ flipper)
+            assert np.allclose(doubledup.get_coords(), 2 * orig_coords[:, ::-1])
+
+    def test_homogeneous_coordinates(self):
+        ccoords = self.rng.random((5, 3))
+        hcoords = np.column_stack([ccoords, np.ones(5)])
+
+        cartesian = ps.Pointset(ccoords)
+        homogeneous = ps.Pointset(hcoords, homogeneous=True)
+
+        for points in (cartesian, homogeneous):
+            assert np.array_equal(points.get_coords(), ccoords)
+            assert np.array_equal(points.get_coords(as_homogeneous=True), hcoords)
+
+        affine = np.diag([2, 3, 4, 1])
+        cart2 = affine @ cartesian
+        homo2 = affine @ homogeneous
+
+        exp_c = apply_affine(affine, ccoords)
+        exp_h = (affine @ hcoords.T).T
+        for points in (cart2, homo2):
+            assert np.array_equal(points.get_coords(), exp_c)
+            assert np.array_equal(points.get_coords(as_homogeneous=True), exp_h)
+
+
+def test_GridIndices():
+    # 2D case
+    shape = (2, 3)
+    gi = ps.GridIndices(shape)
+
+    assert gi.dtype == np.dtype('u1')
+    assert gi.shape == (6, 2)
+    assert repr(gi) == '<GridIndices(2, 3)>'
+
+    gi_arr = np.asanyarray(gi)
+    assert gi_arr.dtype == np.dtype('u1')
+    assert gi_arr.shape == (6, 2)
+    # Tractable to write out
+    assert np.array_equal(gi_arr, [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2]])
+
+    shape = (2, 3, 4)
+    gi = ps.GridIndices(shape)
+
+    assert gi.dtype == np.dtype('u1')
+    assert gi.shape == (24, 3)
+    assert repr(gi) == '<GridIndices(2, 3, 4)>'
+
+    gi_arr = np.asanyarray(gi)
+    assert gi_arr.dtype == np.dtype('u1')
+    assert gi_arr.shape == (24, 3)
+    # Separate implementation
+    assert np.array_equal(gi_arr, np.mgrid[:2, :3, :4].reshape(3, -1).T)
+
+
+class TestGrids(TestPointsets):
+    @pytest.mark.parametrize('shape', [(5, 5, 5), (5, 5, 5, 5), (5, 5, 5, 5, 5)])
+    def test_from_image(self, shape):
+        # Check image is generates voxel coordinates
+        affine = np.diag([2, 3, 4, 1])
+        img = SpatialImage(strided_scalar(shape), affine)
+        grid = ps.Grid.from_image(img)
+        grid_coords = grid.get_coords()
+
+        assert grid.n_coords == prod(shape[:3])
+        assert grid.dim == 3
+        assert np.allclose(grid.affine, affine)
+
+        assert np.allclose(grid_coords[0], [0, 0, 0])
+        # Final index is [4, 4, 4], scaled by affine
+        assert np.allclose(grid_coords[-1], [8, 12, 16])
+
+    def test_from_mask(self):
+        affine = np.diag([2, 3, 4, 1])
+        mask = np.zeros((3, 3, 3))
+        mask[1, 1, 1] = 1
+        img = SpatialImage(mask, affine)
+
+        grid = ps.Grid.from_mask(img)
+        grid_coords = grid.get_coords()
+
+        assert grid.n_coords == 1
+        assert grid.dim == 3
+        assert np.array_equal(grid_coords, [[2, 3, 4]])
+
+    def test_to_mask(self):
+        coords = np.array([[1, 1, 1]])
+
+        grid = ps.Grid(coords)
+
+        mask_img = grid.to_mask()
+        assert mask_img.shape == (2, 2, 2)
+        assert np.array_equal(mask_img.get_fdata(), [[[0, 0], [0, 0]], [[0, 0], [0, 1]]])
+        assert np.array_equal(mask_img.affine, np.eye(4))
+
+        mask_img = grid.to_mask(shape=(3, 3, 3))
+        assert mask_img.shape == (3, 3, 3)
+        assert np.array_equal(
+            mask_img.get_fdata(),
+            [
+                [[0, 0, 0], [0, 0, 0], [0, 0, 0]],
+                [[0, 0, 0], [0, 1, 0], [0, 0, 0]],
+                [[0, 0, 0], [0, 0, 0], [0, 0, 0]],
+            ],
+        )
+        assert np.array_equal(mask_img.affine, np.eye(4))
diff --git a/nibabel/tests/test_processing.py b/nibabel/tests/test_processing.py
index ffd1fbff2b..7e2cc4b16d 100644
--- a/nibabel/tests/test_processing.py
+++ b/nibabel/tests/test_processing.py
@@ -6,10 +6,10 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Testing processing module
-"""
+"""Testing processing module"""
 
 import logging
+import warnings
 from os.path import dirname
 from os.path import join as pjoin
 
@@ -170,7 +170,8 @@ def test_resample_from_to(caplog):
     exp_out[1:, :, :] = data[1, :, :]
     assert_almost_equal(out.dataobj, exp_out)
     out = resample_from_to(img, trans_p_25_img)
-    with pytest.warns(UserWarning):  # Suppress scipy warning
+    with warnings.catch_warnings():
+        warnings.simplefilter('ignore', UserWarning)
         exp_out = spnd.affine_transform(data, [1, 1, 1], [-0.25, 0, 0], order=3)
     assert_almost_equal(out.dataobj, exp_out)
     # Test cval
@@ -222,7 +223,7 @@ def test_resample_from_to(caplog):
 
 @needs_scipy
 def test_resample_to_output(caplog):
-    # Test routine to sample iamges to output space
+    # Test routine to sample images to output space
     # Image aligned to output axes - no-op
     data = np.arange(24, dtype='int32').reshape((2, 3, 4))
     img = Nifti1Image(data, np.eye(4))
@@ -276,7 +277,8 @@ def test_resample_to_output(caplog):
     assert_array_equal(out_img.dataobj, np.flipud(data))
     # Subsample voxels
     out_img = resample_to_output(Nifti1Image(data, np.diag([4, 5, 6, 1])))
-    with pytest.warns(UserWarning):  # Suppress scipy warning
+    with warnings.catch_warnings():
+        warnings.simplefilter('ignore', UserWarning)
         exp_out = spnd.affine_transform(data, [1 / 4, 1 / 5, 1 / 6], output_shape=(5, 11, 19))
     assert_array_equal(out_img.dataobj, exp_out)
     # Unsubsample with voxel sizes
diff --git a/nibabel/tests/test_proxy_api.py b/nibabel/tests/test_proxy_api.py
index 1c9e02186c..c5f7ab42ae 100644
--- a/nibabel/tests/test_proxy_api.py
+++ b/nibabel/tests/test_proxy_api.py
@@ -25,7 +25,7 @@
   * if you pass a header into the __init__, then modifying the original
     header will not affect the result of the array return.
 
-These last are to allow the proxy to be re-used with different images.
+These last are to allow the proxy to be reused with different images.
 """
 
 import unittest
@@ -36,13 +36,12 @@
 
 import numpy as np
 import pytest
-from numpy.testing import assert_allclose, assert_almost_equal, assert_array_equal
+from numpy.testing import assert_allclose, assert_array_equal
 
 from .. import ecat, minc1, minc2, parrec
 from ..analyze import AnalyzeHeader
 from ..arrayproxy import ArrayProxy, is_proxy
-from ..casting import have_binary128
-from ..deprecator import ExpiredDeprecationError
+from ..casting import have_binary128, sctypes
 from ..externals.netcdf import netcdf_file
 from ..freesurfer.mghformat import MGHHeader
 from ..nifti1 import Nifti1Header
@@ -58,6 +57,11 @@
 
 h5py, have_h5py, _ = optional_package('h5py')
 
+try:
+    from numpy.exceptions import ComplexWarning
+except ModuleNotFoundError:  # NumPy < 1.25
+    from numpy import ComplexWarning
+
 
 def _some_slicers(shape):
     ndim = len(shape)
@@ -144,9 +148,9 @@ def validate_array_interface_with_dtype(self, pmaker, params):
         if np.issubdtype(orig.dtype, np.complexfloating):
             context = clear_and_catch_warnings()
             context.__enter__()
-            warnings.simplefilter('ignore', np.ComplexWarning)
+            warnings.simplefilter('ignore', ComplexWarning)
 
-        for dtype in np.sctypes['float'] + np.sctypes['int'] + np.sctypes['uint']:
+        for dtype in sctypes['float'] + sctypes['int'] + sctypes['uint']:
             # Directly coerce with a dtype
             direct = dtype(prox)
             # Half-precision is imprecise. Obviously. It's a bad idea, but don't break
@@ -162,6 +166,10 @@ def validate_array_interface_with_dtype(self, pmaker, params):
                 assert_dt_equal(out.dtype, np.dtype(dtype))
                 # Shape matches expected shape
                 assert out.shape == params['shape']
+                del out
+            del direct
+
+        del orig
 
         if context is not None:
             context.__exit__()
diff --git a/nibabel/tests/test_quaternions.py b/nibabel/tests/test_quaternions.py
index a3e63dd851..a5ec89d948 100644
--- a/nibabel/tests/test_quaternions.py
+++ b/nibabel/tests/test_quaternions.py
@@ -16,35 +16,40 @@
 from .. import eulerangles as nea
 from .. import quaternions as nq
 
+
+def norm(vec):
+    # Return unit vector with same orientation as input vector
+    return vec / np.sqrt(vec @ vec)
+
+
+def gen_vec(dtype):
+    # Generate random 3-vector in [-1, 1]^3
+    rand = np.random.default_rng()
+    return rand.uniform(low=-1.0, high=1.0, size=(3,)).astype(dtype)
+
+
 # Example rotations
-eg_rots = []
-params = (-pi, pi, pi / 2)
-zs = np.arange(*params)
-ys = np.arange(*params)
-xs = np.arange(*params)
-for z in zs:
-    for y in ys:
-        for x in xs:
-            eg_rots.append(nea.euler2mat(z, y, x))
+eg_rots = [
+    nea.euler2mat(z, y, x)
+    for z in np.arange(-pi, pi, pi / 2)
+    for y in np.arange(-pi, pi, pi / 2)
+    for x in np.arange(-pi, pi, pi / 2)
+]
+
 # Example quaternions (from rotations)
-eg_quats = []
-for M in eg_rots:
-    eg_quats.append(nq.mat2quat(M))
+eg_quats = [nq.mat2quat(M) for M in eg_rots]
 # M, quaternion pairs
 eg_pairs = list(zip(eg_rots, eg_quats))
 
 # Set of arbitrary unit quaternions
-unit_quats = set()
-params = range(-2, 3)
-for w in params:
-    for x in params:
-        for y in params:
-            for z in params:
-                q = (w, x, y, z)
-                Nq = np.sqrt(np.dot(q, q))
-                if not Nq == 0:
-                    q = tuple([e / Nq for e in q])
-                    unit_quats.add(q)
+unit_quats = set(
+    tuple(norm(np.r_[w, x, y, z]))
+    for w in range(-2, 3)
+    for x in range(-2, 3)
+    for y in range(-2, 3)
+    for z in range(-2, 3)
+    if (w, x, y, z) != (0, 0, 0, 0)
+)
 
 
 def test_fillpos():
@@ -69,6 +74,50 @@ def test_fillpos():
     assert wxyz[0] == 0.0
 
 
+@pytest.mark.parametrize('dtype', ('f4', 'f8'))
+def test_fillpositive_plus_minus_epsilon(dtype):
+    # Deterministic test for fillpositive threshold
+    # We are trying to fill (x, y, z) with a w such that |(w, x, y, z)| == 1
+    # If |(x, y, z)| is slightly off one, w should still be 0
+    nptype = np.dtype(dtype).type
+
+    # Obviously, |(x, y, z)| == 1
+    baseline = np.array([0, 0, 1], dtype=dtype)
+
+    # Obviously, |(x, y, z)| ~ 1
+    plus = baseline * nptype(1 + np.finfo(dtype).eps)
+    minus = baseline * nptype(1 - np.finfo(dtype).eps)
+
+    assert nq.fillpositive(plus)[0] == 0.0
+    assert nq.fillpositive(minus)[0] == 0.0
+
+    # |(x, y, z)| > 1, no real solutions
+    plus = baseline * nptype(1 + 2 * np.finfo(dtype).eps)
+    with pytest.raises(ValueError):
+        nq.fillpositive(plus)
+
+    # |(x, y, z)| < 1, two real solutions, we choose positive
+    minus = baseline * nptype(1 - 2 * np.finfo(dtype).eps)
+    assert nq.fillpositive(minus)[0] > 0.0
+
+
+@pytest.mark.parametrize('dtype', ('f4', 'f8'))
+def test_fillpositive_simulated_error(dtype):
+    # Nondeterministic test for fillpositive threshold
+    # Create random vectors, normalize to unit length, and count on floating point
+    # error to result in magnitudes larger/smaller than one
+    # This is to simulate cases where a unit quaternion with w == 0 would be encoded
+    # as xyz with small error, and we want to recover the w of 0
+
+    # Permit 1 epsilon per value (default, but make explicit here)
+    w2_thresh = 3 * np.finfo(dtype).eps
+
+    for _ in range(50):
+        xyz = norm(gen_vec(dtype))
+
+        assert nq.fillpositive(xyz, w2_thresh)[0] == 0.0
+
+
 def test_conjugate():
     # Takes sequence
     cq = nq.conjugate((1, 0, 0, 0))
@@ -97,7 +146,7 @@ def test_inverse_0():
     assert iq.dtype.kind == 'f'
 
 
-@pytest.mark.parametrize('M, q', eg_pairs)
+@pytest.mark.parametrize(('M', 'q'), eg_pairs)
 def test_inverse_1(M, q):
     iq = nq.inverse(q)
     iqM = nq.quat2mat(iq)
@@ -120,15 +169,15 @@ def test_norm():
     assert not nq.isunit(qi)
 
 
-@pytest.mark.parametrize('M1, q1', eg_pairs[0::4])
-@pytest.mark.parametrize('M2, q2', eg_pairs[1::4])
+@pytest.mark.parametrize(('M1', 'q1'), eg_pairs[0::4])
+@pytest.mark.parametrize(('M2', 'q2'), eg_pairs[1::4])
 def test_mult(M1, q1, M2, q2):
     # Test that quaternion * same as matrix *
     q21 = nq.mult(q2, q1)
-    assert_array_almost_equal, np.dot(M2, M1), nq.quat2mat(q21)
+    assert_array_almost_equal, M2 @ M1, nq.quat2mat(q21)
 
 
-@pytest.mark.parametrize('M, q', eg_pairs)
+@pytest.mark.parametrize(('M', 'q'), eg_pairs)
 def test_inverse(M, q):
     iq = nq.inverse(q)
     iqM = nq.quat2mat(iq)
@@ -136,17 +185,11 @@ def test_inverse(M, q):
     assert np.allclose(iM, iqM)
 
 
-def test_eye():
-    qi = nq.eye()
-    assert np.all([1, 0, 0, 0] == qi)
-    assert np.allclose(nq.quat2mat(qi), np.eye(3))
-
-
 @pytest.mark.parametrize('vec', np.eye(3))
-@pytest.mark.parametrize('M, q', eg_pairs)
+@pytest.mark.parametrize(('M', 'q'), eg_pairs)
 def test_qrotate(vec, M, q):
     vdash = nq.rotate_vector(vec, q)
-    vM = np.dot(M, vec)
+    vM = M @ vec
     assert_array_almost_equal(vdash, vM)
 
 
@@ -179,6 +222,6 @@ def test_angle_axis():
         nq.nearly_equivalent(q, q2)
         aa_mat = nq.angle_axis2mat(theta, vec)
         assert_array_almost_equal(aa_mat, M)
-        unit_vec = vec / np.sqrt(vec.dot(vec))
+        unit_vec = norm(vec)
         aa_mat2 = nq.angle_axis2mat(theta, unit_vec, is_normalized=True)
         assert_array_almost_equal(aa_mat2, M)
diff --git a/nibabel/tests/test_removalschedule.py b/nibabel/tests/test_removalschedule.py
index db99ae3a46..d2bc7da2fc 100644
--- a/nibabel/tests/test_removalschedule.py
+++ b/nibabel/tests/test_removalschedule.py
@@ -1,4 +1,3 @@
-import unittest
 from unittest import mock
 
 import pytest
@@ -6,6 +5,7 @@
 from ..pkg_info import cmp_pkg_version
 
 MODULE_SCHEDULE = [
+    ('7.0.0', ['nibabel.pydicom_compat']),
     ('5.0.0', ['nibabel.keywordonly', 'nibabel.py3k']),
     ('4.0.0', ['nibabel.trackvis']),
     ('3.0.0', ['nibabel.minc', 'nibabel.checkwarns']),
@@ -17,6 +17,8 @@
     (
         '8.0.0',
         [
+            ('nibabel.casting', 'as_int'),
+            ('nibabel.casting', 'int_to_float'),
             ('nibabel.tmpdirs', 'TemporaryDirectory'),
         ],
     ),
@@ -123,7 +125,7 @@ def test_module_removal():
     for module in _filter(MODULE_SCHEDULE):
         with pytest.raises(ImportError):
             __import__(module)
-            assert False, f'Time to remove {module}'
+            raise AssertionError(f'Time to remove {module}')
 
 
 def test_object_removal():
diff --git a/nibabel/tests/test_round_trip.py b/nibabel/tests/test_round_trip.py
index cb754d0b54..6daf960aa4 100644
--- a/nibabel/tests/test_round_trip.py
+++ b/nibabel/tests/test_round_trip.py
@@ -10,7 +10,7 @@
 
 from .. import Nifti1Header, Nifti1Image
 from ..arraywriters import ScalingError
-from ..casting import best_float, type_info, ulp
+from ..casting import best_float, sctypes, type_info, ulp
 from ..spatialimages import HeaderDataError, supported_np_types
 
 DEBUG = False
@@ -102,21 +102,21 @@ def test_round_trip():
     rng = np.random.RandomState(20111121)
     N = 10000
     sd_10s = range(-20, 51, 5)
-    iuint_types = np.sctypes['int'] + np.sctypes['uint']
+    iuint_types = sctypes['int'] + sctypes['uint']
     # Remove types which cannot be set into nifti header datatype
     nifti_supported = supported_np_types(Nifti1Header())
     iuint_types = [t for t in iuint_types if t in nifti_supported]
     f_types = [np.float32, np.float64]
     # Expanding standard deviations
-    for i, sd_10 in enumerate(sd_10s):
+    for sd_10 in sd_10s:
         sd = 10.0**sd_10
         V_in = rng.normal(0, sd, size=(N, 1))
-        for j, in_type in enumerate(f_types):
-            for k, out_type in enumerate(iuint_types):
+        for in_type in f_types:
+            for out_type in iuint_types:
                 check_arr(sd_10, V_in, in_type, out_type, scaling_type)
     # Spread integers across range
-    for i, sd in enumerate(np.linspace(0.05, 0.5, 5)):
-        for j, in_type in enumerate(iuint_types):
+    for sd in np.linspace(0.05, 0.5, 5):
+        for in_type in iuint_types:
             info = np.iinfo(in_type)
             mn, mx = info.min, info.max
             type_range = mx - mn
@@ -124,7 +124,7 @@ def test_round_trip():
             # float(sd) because type_range can be type 'long'
             width = type_range * float(sd)
             V_in = rng.normal(center, width, size=(N, 1))
-            for k, out_type in enumerate(iuint_types):
+            for out_type in iuint_types:
                 check_arr(sd, V_in, in_type, out_type, scaling_type)
 
 
diff --git a/nibabel/tests/test_rstutils.py b/nibabel/tests/test_rstutils.py
index 847b7a4eee..eab1969857 100644
--- a/nibabel/tests/test_rstutils.py
+++ b/nibabel/tests/test_rstutils.py
@@ -1,5 +1,4 @@
-"""Test printable table
-"""
+"""Test printable table"""
 
 import numpy as np
 import pytest
diff --git a/nibabel/tests/test_scaling.py b/nibabel/tests/test_scaling.py
index 2fbe88a1a7..ccc379c256 100644
--- a/nibabel/tests/test_scaling.py
+++ b/nibabel/tests/test_scaling.py
@@ -13,9 +13,9 @@
 
 import numpy as np
 import pytest
-from numpy.testing import assert_array_almost_equal, assert_array_equal
+from numpy.testing import assert_array_equal
 
-from ..casting import type_info
+from ..casting import sctypes, type_info
 from ..testing import suppress_warnings
 from ..volumeutils import apply_read_scaling, array_from_file, array_to_file, finite_range
 from .test_volumeutils import _calculate_scale
@@ -25,7 +25,7 @@
 
 
 @pytest.mark.parametrize(
-    'in_arr, res',
+    ('in_arr', 'res'),
     [
         ([[-1, 0, 1], [np.inf, np.nan, -np.inf]], (-1, 1)),
         (np.array([[-1, 0, 1], [np.inf, np.nan, -np.inf]]), (-1, 1)),
@@ -36,7 +36,6 @@
         ([[np.nan, -1, 2], [-2, np.nan, 1]], (-2, 2)),
         ([[np.nan, -np.inf, 2], [-2, np.nan, np.inf]], (-2, 2)),
         ([[-np.inf, 2], [np.nan, 1]], (1, 2)),  # good max case
-        ([[np.nan, -np.inf, 2], [-2, np.nan, np.inf]], (-2, 2)),
         ([np.nan], (np.inf, -np.inf)),
         ([np.inf], (np.inf, -np.inf)),
         ([-np.inf], (np.inf, -np.inf)),
@@ -134,7 +133,7 @@ def test_a2f_nan2zero():
 
 
 @pytest.mark.parametrize(
-    'in_type, out_type',
+    ('in_type', 'out_type'),
     [
         (np.int16, np.int16),
         (np.int16, np.int8),
@@ -163,7 +162,7 @@ def test_array_file_scales(in_type, out_type):
 
 
 @pytest.mark.parametrize(
-    'category0, category1, overflow',
+    ('category0', 'category1', 'overflow'),
     [
         # Confirm that, for all ints and uints as input, and all possible outputs,
         # for any simple way of doing the calculation, the result is near enough
@@ -177,8 +176,8 @@ def test_array_file_scales(in_type, out_type):
     ],
 )
 def test_scaling_in_abstract(category0, category1, overflow):
-    for in_type in np.sctypes[category0]:
-        for out_type in np.sctypes[category1]:
+    for in_type in sctypes[category0]:
+        for out_type in sctypes[category1]:
             if overflow:
                 with suppress_warnings():
                     check_int_a2f(in_type, out_type)
@@ -188,10 +187,10 @@ def test_scaling_in_abstract(category0, category1, overflow):
 
 def check_int_a2f(in_type, out_type):
     # Check that array to / from file returns roughly the same as input
-    big_floater = np.maximum_sctype(np.float64)
+    big_floater = sctypes['float'][-1]
     info = type_info(in_type)
     this_min, this_max = info['min'], info['max']
-    if not in_type in np.sctypes['complex']:
+    if not in_type in sctypes['complex']:
         data = np.array([this_min, this_max], in_type)
         # Bug in numpy 1.6.2 on PPC leading to infs - abort
         if not np.all(np.isfinite(data)):
diff --git a/nibabel/tests/test_scripts.py b/nibabel/tests/test_scripts.py
index 9f07b3933b..0ff4ce1984 100644
--- a/nibabel/tests/test_scripts.py
+++ b/nibabel/tests/test_scripts.py
@@ -11,9 +11,8 @@
 import sys
 import unittest
 from glob import glob
-from os.path import abspath, basename, dirname, exists
+from os.path import abspath, basename, dirname, exists, splitext
 from os.path import join as pjoin
-from os.path import splitext
 
 import numpy as np
 import pytest
@@ -167,9 +166,9 @@ def test_nib_ls_multiple():
     # they should be indented correctly.  Since all files are int type -
     ln = max(len(f) for f in fnames)
     i_str = ' i' if sys.byteorder == 'little' else ' <i'
-    assert [l[ln : ln + len(i_str)] for l in stdout_lines] == [
-        i_str
-    ] * 4, f"Type sub-string didn't start with '{i_str}'. Full output was: {stdout_lines}"
+    assert [l[ln : ln + len(i_str)] for l in stdout_lines] == [i_str] * 4, (
+        f"Type sub-string didn't start with '{i_str}'. Full output was: {stdout_lines}"
+    )
     # and if disregard type indicator which might vary
     assert [l[l.index('[') :] for l in stdout_lines] == [
         '[128,  96,  24,   2] 2.00x2.00x2.20x2000.00  #exts: 2 sform',
@@ -197,13 +196,13 @@ def test_help():
             # needs special treatment since depends on fuse module which
             # might not be available.
             try:
-                import fuse
+                import fuse  # noqa: F401
             except Exception:
                 continue  # do not test this one
         code, stdout, stderr = run_command([cmd, '--help'])
         assert code == 0
         assert_re_in(f'.*{cmd}', stdout)
-        assert_re_in('.*Usage', stdout)
+        assert_re_in('.*[uU]sage', stdout)
         # Some third party modules might like to announce some Deprecation
         # etc warnings, see e.g. https://travis-ci.org/nipy/nibabel/jobs/370353602
         if 'warning' not in stderr.lower():
@@ -228,7 +227,7 @@ def test_nib_nifti_dx():
     expected = f"""Picky header check output for "{dirty_hdr}"
 
 pixdim[0] (qfac) should be 1 (default) or -1
-magic string "" is not valid
+magic string '' is not valid
 sform_code 11776 not valid"""
     # Split strings to remove line endings
     assert stdout == expected
@@ -418,7 +417,7 @@ def test_parrec2nii_with_data():
         assert_almost_equal(np.loadtxt('DTI.bvals'), np.sort(DTI_PAR_BVALS))
         img = load('DTI.nii')
         data_sorted = img.get_fdata()
-        assert_almost_equal(data[..., np.argsort(DTI_PAR_BVALS)], data_sorted)
+        assert_almost_equal(data[..., np.argsort(DTI_PAR_BVALS, kind='stable')], data_sorted)
         del img
 
         # Writes .ordering.csv if requested
diff --git a/nibabel/tests/test_spaces.py b/nibabel/tests/test_spaces.py
index dbfe533890..4722228a5b 100644
--- a/nibabel/tests/test_spaces.py
+++ b/nibabel/tests/test_spaces.py
@@ -1,5 +1,4 @@
-"""Tests for spaces module
-"""
+"""Tests for spaces module"""
 
 import numpy as np
 import numpy.linalg as npl
@@ -126,7 +125,7 @@ def test_slice2volume():
 
 
 @pytest.mark.parametrize(
-    'index, axis',
+    ('index', 'axis'),
     [
         [-1, 0],
         [0, -1],
diff --git a/nibabel/tests/test_spatialimages.py b/nibabel/tests/test_spatialimages.py
index 27305739aa..7890ba48e4 100644
--- a/nibabel/tests/test_spatialimages.py
+++ b/nibabel/tests/test_spatialimages.py
@@ -6,12 +6,9 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Testing spatialimages
-"""
+"""Testing spatialimages"""
 
-import warnings
 from io import BytesIO
-from unittest import TestCase
 
 import numpy as np
 import pytest
@@ -20,13 +17,7 @@
 from .. import load as top_load
 from ..imageclasses import spatial_axes_first
 from ..spatialimages import HeaderDataError, SpatialHeader, SpatialImage
-from ..testing import (
-    bytesio_round_trip,
-    clear_and_catch_warnings,
-    expires,
-    memmap_after_ufunc,
-    suppress_warnings,
-)
+from ..testing import bytesio_round_trip, deprecated_to, expires, memmap_after_ufunc
 from ..tmpdirs import InTemporaryDirectory
 
 
@@ -205,7 +196,7 @@ def __array__(self, dtype='int16'):
         return np.arange(3, dtype=dtype)
 
 
-class TestSpatialImage(TestCase):
+class TestSpatialImage:
     # class for testing images
     image_class = SpatialImage
     can_save = False
@@ -376,7 +367,7 @@ def test_get_data(self):
         in_data = in_data_template.copy()
         img = img_klass(in_data, None)
         assert in_data is img.dataobj
-        with pytest.deprecated_call():
+        with deprecated_to('5.0.0'):
             out_data = img.get_data()
         assert in_data is out_data
         # and that uncache has no effect
@@ -389,26 +380,28 @@ def test_get_data(self):
         rt_img = bytesio_round_trip(img)
         assert in_data is not rt_img.dataobj
         assert (rt_img.dataobj == in_data).all()
-        with pytest.deprecated_call():
+        with deprecated_to('5.0.0'):
             out_data = rt_img.get_data()
         assert (out_data == in_data).all()
         assert rt_img.dataobj is not out_data
         # cache
-        with pytest.deprecated_call():
+        with deprecated_to('5.0.0'):
             assert rt_img.get_data() is out_data
         out_data[:] = 42
         rt_img.uncache()
-        with pytest.deprecated_call():
+        with deprecated_to('5.0.0'):
             assert rt_img.get_data() is not out_data
-        with pytest.deprecated_call():
+        with deprecated_to('5.0.0'):
             assert (rt_img.get_data() == in_data).all()
 
     def test_slicer(self):
         img_klass = self.image_class
         in_data_template = np.arange(240, dtype=np.int16)
         base_affine = np.eye(4)
-        t_axis = None
-        for dshape in ((4, 5, 6, 2), (8, 5, 6)):    # Time series      # Volume
+        for dshape in (
+            (4, 5, 6, 2),  # Time series
+            (8, 5, 6),  # Volume
+        ):
             in_data = in_data_template.copy().reshape(dshape)
             img = img_klass(in_data, base_affine.copy())
 
@@ -541,15 +534,15 @@ def test_slicer(self):
                     sliceobj = tuple(np.random.choice(slice_elems, n_elems))
                     try:
                         sliced_img = img.slicer[sliceobj]
-                    except (IndexError, ValueError):
-                        # Only checking valid slices
-                        pass
-                    else:
-                        sliced_data = in_data[sliceobj]
-                        assert (sliced_data == sliced_img.get_fdata()).all()
-                        assert (sliced_data == sliced_img.dataobj).all()
-                        assert (sliced_data == img.dataobj[sliceobj]).all()
-                        assert (sliced_data == img.get_fdata()[sliceobj]).all()
+                    except (IndexError, ValueError, HeaderDataError):
+                        # Skip invalid slices or images that can't be created
+                        continue
+
+                    sliced_data = in_data[sliceobj]
+                    assert np.array_equal(sliced_data, sliced_img.get_fdata())
+                    assert np.array_equal(sliced_data, sliced_img.dataobj)
+                    assert np.array_equal(sliced_data, img.dataobj[sliceobj])
+                    assert np.array_equal(sliced_data, img.get_fdata()[sliceobj])
 
 
 class MmapImageMixin:
@@ -617,9 +610,9 @@ def test_load_mmap(self):
                     back_img = func(param1, **kwargs)
                     back_data = np.asanyarray(back_img.dataobj)
                     if expected_mode is None:
-                        assert not isinstance(
-                            back_data, np.memmap
-                        ), f'Should not be a {img_klass.__name__}'
+                        assert not isinstance(back_data, np.memmap), (
+                            f'Should not be a {img_klass.__name__}'
+                        )
                     else:
                         assert isinstance(back_data, np.memmap), f'Not a {img_klass.__name__}'
                         if self.check_mmap_mode:
diff --git a/nibabel/tests/test_spm99analyze.py b/nibabel/tests/test_spm99analyze.py
index 9bc4c928a6..26098d8ede 100644
--- a/nibabel/tests/test_spm99analyze.py
+++ b/nibabel/tests/test_spm99analyze.py
@@ -23,8 +23,8 @@
 # files
 needs_scipy = unittest.skipUnless(have_scipy, 'scipy not available')
 
-from ..casting import shared_range, type_info
-from ..spatialimages import HeaderDataError, supported_np_types
+from ..casting import sctypes_aliases, shared_range, type_info
+from ..spatialimages import HeaderDataError
 from ..spm99analyze import HeaderTypeError, Spm99AnalyzeHeader, Spm99AnalyzeImage
 from ..testing import (
     assert_allclose_safely,
@@ -35,10 +35,20 @@
 from ..volumeutils import _dt_min_max, apply_read_scaling
 from . import test_analyze
 
-FLOAT_TYPES = np.sctypes['float']
-COMPLEX_TYPES = np.sctypes['complex']
-INT_TYPES = np.sctypes['int']
-UINT_TYPES = np.sctypes['uint']
+# np.core.sctypes values are lists of types with unique sizes
+# For testing, we want all concrete classes of a type
+# Key on kind, rather than abstract base classes, since timedelta64 is a signedinteger
+sctypes = {}
+for sctype in sctypes_aliases:
+    sctypes.setdefault(np.dtype(sctype).kind, []).append(sctype)
+
+# Sort types to ensure that xdist doesn't complain about test order when we parametrize
+FLOAT_TYPES = sorted(sctypes['f'], key=lambda x: x.__name__)
+COMPLEX_TYPES = sorted(sctypes['c'], key=lambda x: x.__name__)
+INT_TYPES = sorted(sctypes['i'], key=lambda x: x.__name__)
+UINT_TYPES = sorted(sctypes['u'], key=lambda x: x.__name__)
+
+# Create combined type lists
 CFLOAT_TYPES = FLOAT_TYPES + COMPLEX_TYPES
 IUINT_TYPES = INT_TYPES + UINT_TYPES
 NUMERIC_TYPES = CFLOAT_TYPES + IUINT_TYPES
@@ -306,57 +316,58 @@ def test_int_int_scaling(self):
         img_rt = bytesio_round_trip(img)
         assert_array_equal(img_rt.get_fdata(), np.clip(arr, 0, 255))
 
-    def test_no_scaling(self):
+    # NOTE: Need to check complex scaling
+    @pytest.mark.parametrize('in_dtype', FLOAT_TYPES + IUINT_TYPES)
+    def test_no_scaling(self, in_dtype, supported_dtype):
         # Test writing image converting types when not calculating scaling
         img_class = self.image_class
         hdr_class = img_class.header_class
         hdr = hdr_class()
-        supported_types = supported_np_types(hdr)
         # Any old non-default slope and intercept
         slope = 2
         inter = 10 if hdr.has_data_intercept else 0
-        for in_dtype, out_dtype in itertools.product(FLOAT_TYPES + IUINT_TYPES, supported_types):
-            # Need to check complex scaling
-            mn_in, mx_in = _dt_min_max(in_dtype)
-            arr = np.array([mn_in, -1, 0, 1, 10, mx_in], dtype=in_dtype)
-            img = img_class(arr, np.eye(4), hdr)
-            img.set_data_dtype(out_dtype)
-            # Setting the scaling means we don't calculate it later
-            img.header.set_slope_inter(slope, inter)
-            with np.errstate(invalid='ignore'):
-                rt_img = bytesio_round_trip(img)
-            with suppress_warnings():  # invalid mult
-                back_arr = np.asanyarray(rt_img.dataobj)
-            exp_back = arr.copy()
-            # If converting to floating point type, casting is direct.
-            # Otherwise we will need to do float-(u)int casting at some point
-            if out_dtype in IUINT_TYPES:
-                if in_dtype in FLOAT_TYPES:
-                    # Working precision is (at least) float
-                    exp_back = exp_back.astype(float)
-                    # Float to iu conversion will always round, clip
-                    with np.errstate(invalid='ignore'):
-                        exp_back = np.round(exp_back)
-                    if in_dtype in FLOAT_TYPES:
-                        # Clip to shared range of working precision
-                        exp_back = np.clip(exp_back, *shared_range(float, out_dtype))
-                else:  # iu input and output type
-                    # No scaling, never gets converted to float.
-                    # Does get clipped to range of output type
-                    mn_out, mx_out = _dt_min_max(out_dtype)
-                    if (mn_in, mx_in) != (mn_out, mx_out):
-                        # Use smaller of input, output range to avoid np.clip
-                        # upcasting the array because of large clip limits.
-                        exp_back = np.clip(exp_back, max(mn_in, mn_out), min(mx_in, mx_out))
-            if out_dtype in COMPLEX_TYPES:
-                # always cast to real from complex
-                exp_back = exp_back.astype(out_dtype)
-            else:
-                # Cast to working precision
+
+        mn_in, mx_in = _dt_min_max(in_dtype)
+        mn = -1 if np.dtype(in_dtype).kind != 'u' else 0
+        arr = np.array([mn_in, mn, 0, 1, 10, mx_in], dtype=in_dtype)
+        img = img_class(arr, np.eye(4), hdr)
+        img.set_data_dtype(supported_dtype)
+        # Setting the scaling means we don't calculate it later
+        img.header.set_slope_inter(slope, inter)
+        with np.errstate(invalid='ignore'):
+            rt_img = bytesio_round_trip(img)
+        with suppress_warnings():  # invalid mult
+            back_arr = np.asanyarray(rt_img.dataobj)
+        exp_back = arr.copy()
+        # If converting to floating point type, casting is direct.
+        # Otherwise we will need to do float-(u)int casting at some point
+        if supported_dtype in IUINT_TYPES:
+            if in_dtype in FLOAT_TYPES:
+                # Working precision is (at least) float
                 exp_back = exp_back.astype(float)
-            # Allow for small differences in large numbers
-            with suppress_warnings():  # invalid value
-                assert_allclose_safely(back_arr, exp_back * slope + inter)
+                # Float to iu conversion will always round, clip
+                with np.errstate(invalid='ignore'):
+                    exp_back = np.round(exp_back)
+                if in_dtype in FLOAT_TYPES:
+                    # Clip to shared range of working precision
+                    exp_back = np.clip(exp_back, *shared_range(float, supported_dtype))
+            else:  # iu input and output type
+                # No scaling, never gets converted to float.
+                # Does get clipped to range of output type
+                mn_out, mx_out = _dt_min_max(supported_dtype)
+                if (mn_in, mx_in) != (mn_out, mx_out):
+                    # Use smaller of input, output range to avoid np.clip
+                    # upcasting the array because of large clip limits.
+                    exp_back = np.clip(exp_back, max(mn_in, mn_out), min(mx_in, mx_out))
+        if supported_dtype in COMPLEX_TYPES:
+            # always cast to real from complex
+            exp_back = exp_back.astype(supported_dtype)
+        else:
+            # Cast to working precision
+            exp_back = exp_back.astype(float)
+        # Allow for small differences in large numbers
+        with suppress_warnings():  # invalid value
+            assert_allclose_safely(back_arr, exp_back * slope + inter)
 
     def test_write_scaling(self):
         # Check writes with scaling set
@@ -412,7 +423,7 @@ def test_mat_read(self):
         aff = np.diag([2, 3, 4, 1])  # no LR flip in affine
         img = img_klass(arr, aff)
         fm = img.file_map
-        for key, value in fm.items():
+        for value in fm.values():
             value.fileobj = BytesIO()
         # Test round trip
         img.to_file_map()
@@ -464,7 +475,7 @@ def test_none_affine(self):
         img = img_klass(np.zeros((2, 3, 4)), None)
         aff = img.header.get_best_affine()
         # Save / reload using bytes IO objects
-        for key, value in img.file_map.items():
+        for value in img.file_map.values():
             value.fileobj = BytesIO()
         img.to_file_map()
         img_back = img.from_file_map(img.file_map)
diff --git a/nibabel/tests/test_testing.py b/nibabel/tests/test_testing.py
index 38c815d4c8..ec147baa95 100644
--- a/nibabel/tests/test_testing.py
+++ b/nibabel/tests/test_testing.py
@@ -1,5 +1,4 @@
-"""Tests for warnings context managers
-"""
+"""Tests for warnings context managers"""
 
 import os
 import sys
@@ -8,6 +7,7 @@
 import numpy as np
 import pytest
 
+from ..casting import sctypes
 from ..testing import (
     assert_allclose_safely,
     assert_re_in,
@@ -15,8 +15,8 @@
     data_path,
     error_warnings,
     get_fresh_mod,
+    get_test_data,
     suppress_warnings,
-    test_data,
 )
 
 
@@ -48,7 +48,7 @@ def test_assert_allclose_safely():
     with pytest.raises(AssertionError):
         assert_allclose_safely(a, b)
     # Test allcloseness of inf, especially np.float128 infs
-    for dtt in np.sctypes['float']:
+    for dtt in sctypes['float']:
         a = np.array([-np.inf, 1, np.inf], dtype=dtt)
         b = np.array([-np.inf, 1, np.inf], dtype=dtt)
         assert_allclose_safely(a, b)
@@ -113,7 +113,7 @@ def test_warn_error():
     with error_warnings():
         with pytest.raises(UserWarning):
             warnings.warn('A test')
-    with error_warnings() as w:  # w not used for anything
+    with error_warnings():
         with pytest.raises(UserWarning):
             warnings.warn('A test')
     assert n_warns == len(warnings.filters)
@@ -133,7 +133,7 @@ def test_warn_ignore():
     with suppress_warnings():
         warnings.warn('Here is a warning, you will not see it')
         warnings.warn('Nor this one', DeprecationWarning)
-    with suppress_warnings() as w:  # w not used
+    with suppress_warnings():
         warnings.warn('Here is a warning, you will not see it')
         warnings.warn('Nor this one', DeprecationWarning)
     assert n_warns == len(warnings.filters)
@@ -148,7 +148,7 @@ def f():
 
 
 @pytest.mark.parametrize(
-    'regex, entries',
+    ('regex', 'entries'),
     [
         ['.*', ''],
         ['.*', ['any']],
@@ -171,20 +171,22 @@ def test_assert_re_in(regex, entries):
 
 
 def test_test_data():
-    assert test_data() == data_path
-    assert test_data() == os.path.abspath(
+    assert str(get_test_data()) == str(data_path)  # Always get the same result
+    # Works the same as using __file__ and os.path utilities
+    assert str(get_test_data()) == os.path.abspath(
         os.path.join(os.path.dirname(__file__), '..', 'tests', 'data')
     )
+    # Check action of subdir and that existence checks work
     for subdir in ('nicom', 'gifti', 'externals'):
-        assert test_data(subdir) == os.path.join(data_path[:-10], subdir, 'tests', 'data')
-        assert os.path.exists(test_data(subdir))
-        assert not os.path.exists(test_data(subdir, 'doesnotexist'))
+        assert get_test_data(subdir) == data_path.parent.parent / subdir / 'tests' / 'data'
+        assert os.path.exists(get_test_data(subdir))
+        assert not os.path.exists(get_test_data(subdir, 'doesnotexist'))
 
     for subdir in ('freesurfer', 'doesnotexist'):
         with pytest.raises(ValueError):
-            test_data(subdir)
+            get_test_data(subdir)
 
-    assert not os.path.exists(test_data(None, 'doesnotexist'))
+    assert not os.path.exists(get_test_data(None, 'doesnotexist'))
 
     for subdir, fname in [
         ('gifti', 'ascii.gii'),
@@ -192,4 +194,4 @@ def test_test_data():
         ('externals', 'example_1.nc'),
         (None, 'empty.tck'),
     ]:
-        assert os.path.exists(test_data(subdir, fname))
+        assert os.path.exists(get_test_data(subdir, fname))
diff --git a/nibabel/tests/test_tripwire.py b/nibabel/tests/test_tripwire.py
index f172d5c579..4bf91923f2 100644
--- a/nibabel/tests/test_tripwire.py
+++ b/nibabel/tests/test_tripwire.py
@@ -1,5 +1,4 @@
-"""Testing tripwire module
-"""
+"""Testing tripwire module"""
 
 import pytest
 
@@ -17,9 +16,5 @@ def test_tripwire():
     with pytest.raises(TripWireError):
         silly_module_name.do_silly_thing
     # Check AttributeError can be checked too
-    try:
+    with pytest.raises(AttributeError):
         silly_module_name.__wrapped__
-    except TripWireError as err:
-        assert isinstance(err, AttributeError)
-    else:
-        raise RuntimeError('No error raised, but expected')
diff --git a/nibabel/tests/test_viewers.py b/nibabel/tests/test_viewers.py
index 53f4a32bdc..fa22d9021a 100644
--- a/nibabel/tests/test_viewers.py
+++ b/nibabel/tests/test_viewers.py
@@ -102,3 +102,230 @@ def test_viewer():
     v2.link_to(v1)  # shouldn't do anything
     v1.close()
     v2.close()
+
+
+@needs_mpl
+def test_viewer_nonRAS():
+    data1 = np.random.rand(10, 20, 40)
+    data1[5, 10, :] = 0
+    data1[5, :, 30] = 0
+    data1[:, 10, 30] = 0
+    # RSA affine
+    aff1 = np.array([[1, 0, 0, -5], [0, 0, 1, -30], [0, 1, 0, -10], [0, 0, 0, 1]])
+    o1 = OrthoSlicer3D(data1, aff1)
+    sag = o1._ims[0].get_array()
+    cor = o1._ims[1].get_array()
+    axi = o1._ims[2].get_array()
+
+    # Sagittal view: [0, I->S, P->A], so data is transposed, matching plot array
+    assert_array_equal(sag, data1[5, :, :])
+    # Coronal view: [L->R, I->S, 0]. Data is not transposed, transpose to match plot array
+    assert_array_equal(cor, data1[:, :, 30].T)
+    # Axial view: [L->R, 0, P->A]. Data is not transposed, transpose to match plot array
+    assert_array_equal(axi, data1[:, 10, :].T)
+
+    o1.set_position(1, 2, 3)  # R, A, S coordinates
+
+    sag = o1._ims[0].get_array()
+    cor = o1._ims[1].get_array()
+    axi = o1._ims[2].get_array()
+
+    # Shift 1 right, 2 anterior, 3 superior
+    assert_array_equal(sag, data1[6, :, :])
+    assert_array_equal(cor, data1[:, :, 32].T)
+    assert_array_equal(axi, data1[:, 13, :].T)
+
+
+@needs_mpl
+def test_viewer_nonRAS_on_mouse():
+    """
+    test on_mouse selection on non RAS matrices
+
+    """
+    # This affine simulates an acquisition on a quadruped subject that is in a prone position.
+    # This corresponds to an acquisition with:
+    # - LR inverted on scanner x (i)
+    # - IS on scanner y (j)
+    # - PA on scanner z (k)
+    # This example enables to test also OrthoSlicer3D properties `_flips` and `_order`.
+
+    (I, J, K) = (10, 20, 40)
+    data1 = np.random.rand(I, J, K)
+    (i_target, j_target, k_target) = (2, 14, 12)
+    i1 = i_target - 2
+    i2 = i_target + 2
+    j1 = j_target - 3
+    j2 = j_target + 3
+    k1 = k_target - 4
+    k2 = k_target + 4
+    data1[i1 : i2 + 1, j1 : j2 + 1, k1 : k2 + 1] = 0
+    data1[i_target, j_target, k_target] = 1
+    valp1 = 1.5
+    valm1 = 0.5
+    data1[i_target - 1, j_target, k_target] = valp1  # x flipped
+    data1[i_target + 1, j_target, k_target] = valm1  # x flipped
+    data1[i_target, j_target - 1, k_target] = valm1
+    data1[i_target, j_target + 1, k_target] = valp1
+    data1[i_target, j_target, k_target - 1] = valm1
+    data1[i_target, j_target, k_target + 1] = valp1
+
+    aff1 = np.array([[-1, 0, 0, 5], [0, 0, 1, -10], [0, 1, 0, -30], [0, 0, 0, 1]])
+
+    o1 = OrthoSlicer3D(data1, aff1)
+
+    class Event:
+        def __init__(self):
+            self.name = 'simulated mouse event'
+            self.button = 1
+
+    event = Event()
+    event.xdata = k_target
+    event.ydata = j_target
+    event.inaxes = o1._ims[0].axes
+    o1._on_mouse(event)
+
+    event.inaxes = o1._ims[1].axes
+    event.xdata = (I - 1) - i_target  # x flipped
+    event.ydata = j_target
+    o1._on_mouse(event)
+
+    event.inaxes = o1._ims[2].axes
+    event.xdata = (I - 1) - i_target  # x flipped
+    event.ydata = k_target
+    o1._on_mouse(event)
+
+    sag = o1._ims[0].get_array()
+    cor = o1._ims[1].get_array()
+    axi = o1._ims[2].get_array()
+
+    assert_array_equal(sag, data1[i_target, :, :])  #
+    assert_array_equal(cor, data1[::-1, :, k_target].T)  # x flipped
+    assert_array_equal(axi, data1[::-1, j_target, :].T)  # x flipped
+    return None
+
+
+@needs_mpl
+def test_viewer_nonRAS_on_scroll():
+    """
+    test scrolling on non RAS matrices
+
+    """
+    # This affine simulates an acquisition on a quadruped subject that is in a prone position.
+    # This corresponds to an acquisition with:
+    # - LR inverted on scanner x (i)
+    # - IS on scanner y (j)
+    # - PA on scanner z (k)
+    # This example enables to test also OrthoSlicer3D properties `_flips` and `_order`.
+
+    (I, J, K) = (10, 20, 40)
+    data1 = np.random.rand(I, J, K)
+    (i_target, j_target, k_target) = (2, 14, 12)
+    i1 = i_target - 2
+    i2 = i_target + 2
+    j1 = j_target - 3
+    j2 = j_target + 3
+    k1 = k_target - 4
+    k2 = k_target + 4
+    data1[i1 : i2 + 1, j1 : j2 + 1, k1 : k2 + 1] = 0
+    data1[i_target, j_target, k_target] = 1
+    valp1 = 1.5
+    valm1 = 0.5
+    data1[i_target - 1, j_target, k_target] = valp1  # x flipped
+    data1[i_target + 1, j_target, k_target] = valm1  # x flipped
+    data1[i_target, j_target - 1, k_target] = valm1
+    data1[i_target, j_target + 1, k_target] = valp1
+    data1[i_target, j_target, k_target - 1] = valm1
+    data1[i_target, j_target, k_target + 1] = valp1
+
+    aff1 = np.array([[-1, 0, 0, 5], [0, 0, 1, -10], [0, 1, 0, -30], [0, 0, 0, 1]])
+
+    o1 = OrthoSlicer3D(data1, aff1)
+
+    class Event:
+        def __init__(self):
+            self.name = 'simulated mouse event'
+            self.button = None
+            self.key = None
+
+    [x_t, y_t, z_t] = list(aff1.dot(np.array([i_target, j_target, k_target, 1]))[:3])
+    # print(x_t, y_t, z_t)
+    # scanner positions are x_t=3, y_t=2, z_t=16
+
+    event = Event()
+
+    # Sagittal plane - one scroll up
+    # x coordinate is flipped so index decrease by 1
+    o1.set_position(x_t, y_t, z_t)
+    event.inaxes = o1._ims[0].axes
+    event.button = 'up'
+    o1._on_scroll(event)
+    sag = o1._ims[0].get_array()
+    cor = o1._ims[1].get_array()
+    axi = o1._ims[2].get_array()
+    assert_array_equal(sag, data1[i_target - 1, :, :])
+    assert_array_equal(cor, data1[::-1, :, k_target].T)  # ::-1 because the array is flipped in x
+    assert_array_equal(axi, data1[::-1, j_target, :].T)  # ::-1 because the array is flipped in x
+
+    # Sagittal plane - one scrolled down
+    o1.set_position(x_t, y_t, z_t)
+    event.button = 'down'
+    o1._on_scroll(event)
+    sag = o1._ims[0].get_array()
+    cor = o1._ims[1].get_array()
+    axi = o1._ims[2].get_array()
+    assert_array_equal(sag, data1[i_target + 1, :, :])
+    assert_array_equal(cor, data1[::-1, :, k_target].T)
+    assert_array_equal(axi, data1[::-1, j_target, :].T)
+
+    # Coronal plane - one scroll up
+    # y coordinate is increase by 1
+    o1.set_position(x_t, y_t, z_t)
+    event.inaxes = o1._ims[1].axes
+    event.button = 'up'
+    o1._on_scroll(event)
+    sag = o1._ims[0].get_array()
+    cor = o1._ims[1].get_array()
+    axi = o1._ims[2].get_array()
+    assert_array_equal(sag, data1[i_target, :, :])
+    assert_array_equal(
+        cor, data1[::-1, :, k_target + 1].T
+    )  # ::-1 because the array is flipped in x
+    assert_array_equal(axi, data1[::-1, j_target, :].T)  # ::-1 because the array is flipped in x
+
+    # Coronal plane - one scrolled down
+    o1.set_position(x_t, y_t, z_t)
+    event.button = 'down'
+    o1._on_scroll(event)
+    sag = o1._ims[0].get_array()
+    cor = o1._ims[1].get_array()
+    axi = o1._ims[2].get_array()
+    assert_array_equal(sag, data1[i_target, :, :])
+    assert_array_equal(cor, data1[::-1, :, k_target - 1].T)
+    assert_array_equal(axi, data1[::-1, j_target, :].T)
+
+    # Axial plane - one scroll up
+    # y is increase by 1
+    o1.set_position(x_t, y_t, z_t)
+    event.inaxes = o1._ims[2].axes
+    event.button = 'up'
+    o1._on_scroll(event)
+    sag = o1._ims[0].get_array()
+    cor = o1._ims[1].get_array()
+    axi = o1._ims[2].get_array()
+    assert_array_equal(sag, data1[i_target, :, :])
+    assert_array_equal(cor, data1[::-1, :, k_target].T)  # ::-1 because the array is flipped in x
+    assert_array_equal(
+        axi, data1[::-1, j_target + 1, :].T
+    )  # ::-1 because the array is flipped in x
+
+    # Axial plane - one scrolled down
+    o1.set_position(x_t, y_t, z_t)
+    event.button = 'down'
+    o1._on_scroll(event)
+    sag = o1._ims[0].get_array()
+    cor = o1._ims[1].get_array()
+    axi = o1._ims[2].get_array()
+    assert_array_equal(sag, data1[i_target, :, :])
+    assert_array_equal(cor, data1[::-1, :, k_target].T)
+    assert_array_equal(axi, data1[::-1, j_target - 1, :].T)
+    return None
diff --git a/nibabel/tests/test_volumeutils.py b/nibabel/tests/test_volumeutils.py
index ab5bd38ee6..1bd44cbd0a 100644
--- a/nibabel/tests/test_volumeutils.py
+++ b/nibabel/tests/test_volumeutils.py
@@ -32,7 +32,7 @@
     suppress_warnings,
 )
 
-from ..casting import OK_FLOATS, floor_log2, shared_range, type_info
+from ..casting import OK_FLOATS, floor_log2, sctypes, shared_range, type_info
 from ..openers import BZ2File, ImageOpener, Opener
 from ..optpkg import optional_package
 from ..tmpdirs import InTemporaryDirectory
@@ -59,15 +59,21 @@
 
 pyzstd, HAVE_ZSTD, _ = optional_package('pyzstd')
 
-#: convenience variables for numpy types
-FLOAT_TYPES = np.sctypes['float']
-COMPLEX_TYPES = np.sctypes['complex']
+# convenience variables for numpy types
+FLOAT_TYPES = sctypes['float']
+COMPLEX_TYPES = sctypes['complex']
 CFLOAT_TYPES = FLOAT_TYPES + COMPLEX_TYPES
-INT_TYPES = np.sctypes['int']
-IUINT_TYPES = INT_TYPES + np.sctypes['uint']
+INT_TYPES = sctypes['int']
+IUINT_TYPES = INT_TYPES + sctypes['uint']
 NUMERIC_TYPES = CFLOAT_TYPES + IUINT_TYPES
 
 FP_RUNTIME_WARN = Version(np.__version__) >= Version('1.24.0.dev0+239')
+NP_2 = Version(np.__version__) >= Version('2.0.0.dev0')
+
+try:
+    from numpy.exceptions import ComplexWarning
+except ModuleNotFoundError:  # NumPy < 1.25
+    from numpy import ComplexWarning
 
 
 def test__is_compressed_fobj():
@@ -538,8 +544,12 @@ def test_a2f_scaled_unscaled():
         NUMERIC_TYPES, NUMERIC_TYPES, (0, 0.5, -1, 1), (1, 0.5, 2)
     ):
         mn_in, mx_in = _dt_min_max(in_dtype)
-        nan_val = np.nan if in_dtype in CFLOAT_TYPES else 10
-        arr = np.array([mn_in, -1, 0, 1, mx_in, nan_val], dtype=in_dtype)
+        vals = [mn_in, 0, 1, mx_in]
+        if np.dtype(in_dtype).kind != 'u':
+            vals.append(-1)
+        if in_dtype in CFLOAT_TYPES:
+            vals.append(np.nan)
+        arr = np.array(vals, dtype=in_dtype)
         mn_out, mx_out = _dt_min_max(out_dtype)
         # 0 when scaled to output will also be the output value for NaN
         nan_fill = -intercept / divslope
@@ -597,7 +607,7 @@ def test_a2f_nanpos():
 
 def test_a2f_bad_scaling():
     # Test that pathological scalers raise an error
-    NUMERICAL_TYPES = sum([np.sctypes[key] for key in ['int', 'uint', 'float', 'complex']], [])
+    NUMERICAL_TYPES = sum((sctypes[key] for key in ['int', 'uint', 'float', 'complex']), [])
     for in_type, out_type, slope, inter in itertools.product(
         NUMERICAL_TYPES,
         NUMERICAL_TYPES,
@@ -610,7 +620,7 @@ def test_a2f_bad_scaling():
         if np.issubdtype(in_type, np.complexfloating) and not np.issubdtype(
             out_type, np.complexfloating
         ):
-            cm = pytest.warns(np.ComplexWarning)
+            cm = pytest.warns(ComplexWarning)
         if (slope, inter) == (1, 0):
             with cm:
                 assert_array_equal(
@@ -650,7 +660,7 @@ def test_a2f_nan2zero_range():
         arr = np.array([-1, 0, 1, np.nan], dtype=dt)
         # Error occurs for arrays without nans too
         arr_no_nan = np.array([-1, 0, 1, 2], dtype=dt)
-        complex_warn = (np.ComplexWarning,) if np.issubdtype(dt, np.complexfloating) else ()
+        complex_warn = (ComplexWarning,) if np.issubdtype(dt, np.complexfloating) else ()
         # Casting nan to int will produce a RuntimeWarning in numpy 1.24
         nan_warn = (RuntimeWarning,) if FP_RUNTIME_WARN else ()
         c_and_n_warn = complex_warn + nan_warn
@@ -733,9 +743,14 @@ def test_apply_scaling():
     f32_arr = np.zeros((1,), dtype=f32)
     i16_arr = np.zeros((1,), dtype=np.int16)
     # Check float upcast (not the normal numpy scalar rule)
+    # This is the normal rule - no upcast from Python scalar
+    assert (f32_arr * 1.0).dtype == np.float32
+    assert (f32_arr + 1.0).dtype == np.float32
     # This is the normal rule - no upcast from scalar
-    assert (f32_arr * f64(1)).dtype == np.float32
-    assert (f32_arr + f64(1)).dtype == np.float32
+    # before NumPy 2.0, after 2.0, it upcasts
+    want_dtype = np.float64 if NP_2 else np.float32
+    assert (f32_arr * f64(1)).dtype == want_dtype
+    assert (f32_arr + f64(1)).dtype == want_dtype
     # The function does upcast though
     ret = apply_read_scaling(np.float32(0), np.float64(2))
     assert ret.dtype == np.float64
@@ -830,10 +845,10 @@ def check_against(f1, f2):
         return f1 if FLOAT_TYPES.index(f1) >= FLOAT_TYPES.index(f2) else f2
 
     for first in FLOAT_TYPES:
-        for other in IUINT_TYPES + np.sctypes['complex']:
+        for other in IUINT_TYPES + sctypes['complex']:
             assert better_float_of(first, other) == first
             assert better_float_of(other, first) == first
-            for other2 in IUINT_TYPES + np.sctypes['complex']:
+            for other2 in IUINT_TYPES + sctypes['complex']:
                 assert better_float_of(other, other2) == np.float32
                 assert better_float_of(other, other2, np.float64) == np.float64
         for second in FLOAT_TYPES:
@@ -974,7 +989,7 @@ def test_seek_tell_logic():
 
     class BabyBio(BytesIO):
         def seek(self, *args):
-            raise OSError()
+            raise OSError
 
     bio = BabyBio()
     # Fresh fileobj, position 0, can't seek - error
diff --git a/nibabel/tests/test_wrapstruct.py b/nibabel/tests/test_wrapstruct.py
index 66dda18237..0eb906fee7 100644
--- a/nibabel/tests/test_wrapstruct.py
+++ b/nibabel/tests/test_wrapstruct.py
@@ -23,6 +23,7 @@
 
 _field_recoders -> field_recoders
 """
+
 import logging
 from io import BytesIO, StringIO
 
@@ -32,12 +33,12 @@
 
 from .. import imageglobals
 from ..batteryrunners import Report
+from ..casting import sctypes
 from ..spatialimages import HeaderDataError
-from ..testing import BaseTestCase
 from ..volumeutils import Recoder, native_code, swapped_code
 from ..wrapstruct import LabeledWrapStruct, WrapStruct, WrapStructError
 
-INTEGER_TYPES = np.sctypes['int'] + np.sctypes['uint']
+INTEGER_TYPES = sctypes['int'] + sctypes['uint']
 
 
 def log_chk(hdr, level):
@@ -101,7 +102,7 @@ def log_chk(hdr, level):
     return hdrc, message, raiser
 
 
-class _TestWrapStructBase(BaseTestCase):
+class _TestWrapStructBase:
     """Class implements base tests for binary headers
 
     It serves as a base class for other binary header tests
@@ -435,15 +436,6 @@ def test_copy(self):
         self._set_something_into_hdr(hdr2)
         assert hdr == hdr2
 
-    def test_copy(self):
-        hdr = self.header_class()
-        hdr2 = hdr.copy()
-        assert hdr == hdr2
-        self._set_something_into_hdr(hdr)
-        assert hdr != hdr2
-        self._set_something_into_hdr(hdr2)
-        assert hdr == hdr2
-
     def test_checks(self):
         # Test header checks
         hdr_t = self.header_class()
diff --git a/nibabel/tmpdirs.py b/nibabel/tmpdirs.py
index 3074fca6f2..2bcf9fdeba 100644
--- a/nibabel/tmpdirs.py
+++ b/nibabel/tmpdirs.py
@@ -6,8 +6,8 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""Contexts for *with* statement providing temporary directories
-"""
+"""Contexts for *with* statement providing temporary directories"""
+
 import os
 import tempfile
 from contextlib import contextmanager
@@ -16,7 +16,7 @@
     from contextlib import chdir as _chdir
 except ImportError:  # PY310
 
-    @contextmanager  # type: ignore
+    @contextmanager  # type: ignore[no-redef]
     def _chdir(path):
         cwd = os.getcwd()
         os.chdir(path)
@@ -54,7 +54,7 @@ def __init__(self, suffix='', prefix=tempfile.template, dir=None):
         >>> os.path.exists(tmpdir)
         False
         """
-        return super().__init__(suffix, prefix, dir)
+        super().__init__(suffix, prefix, dir)
 
 
 @contextmanager
diff --git a/nibabel/tripwire.py b/nibabel/tripwire.py
index 3b6ecfbb40..efe651fd93 100644
--- a/nibabel/tripwire.py
+++ b/nibabel/tripwire.py
@@ -1,5 +1,6 @@
-"""Class to raise error for missing modules or other misfortunes
-"""
+"""Class to raise error for missing modules or other misfortunes"""
+
+from typing import Any
 
 
 class TripWireError(AttributeError):
@@ -11,7 +12,7 @@ class TripWireError(AttributeError):
     # is not present.
 
 
-def is_tripwire(obj):
+def is_tripwire(obj: Any) -> bool:
     """Returns True if `obj` appears to be a TripWire object
 
     Examples
@@ -44,9 +45,9 @@ class TripWire:
     TripWireError: We do not have a_module
     """
 
-    def __init__(self, msg):
+    def __init__(self, msg: str) -> None:
         self._msg = msg
 
-    def __getattr__(self, attr_name):
+    def __getattr__(self, attr_name: str) -> Any:
         """Raise informative error accessing attributes"""
         raise TripWireError(self._msg)
diff --git a/nibabel/viewers.py b/nibabel/viewers.py
index 9dad3dd17f..7f7f1d5a41 100644
--- a/nibabel/viewers.py
+++ b/nibabel/viewers.py
@@ -14,7 +14,7 @@
 
 
 class OrthoSlicer3D:
-    """Orthogonal-plane slice viewer.
+    """Orthogonal-plane slice viewer
 
     OrthoSlicer3d expects 3- or 4-dimensional array data.  It treats
     4D data as a sequence of 3D spatial volumes, where a slice over the final
@@ -103,7 +103,7 @@ def __init__(self, data, affine=None, axes=None, title=None):
             #   |         |     |         |
             #   |         |     |         |
             #   +---------+     +---------+
-            #        A  -->     <--  R
+            #        A  -->          R  -->
             # ^ +---------+     +---------+
             # | |         |     |         |
             #   |  Axial  |     |   Vol   |
@@ -111,7 +111,7 @@ def __init__(self, data, affine=None, axes=None, title=None):
             #   |         |     |         |
             #   |         |     |         |
             #   +---------+     +---------+
-            #   <--  R          <--  t  -->
+            #        R  -->     <--  t  -->
 
             fig, axes = plt.subplots(2, 2)
             fig.set_size_inches((8, 8), forward=True)
@@ -373,11 +373,11 @@ def set_volume_idx(self, v):
 
     def _set_volume_index(self, v, update_slices=True):
         """Set the plot data using a volume index"""
-        v = self._data_idx[3] if v is None else int(round(v))
+        v = self._data_idx[3] if v is None else round(v)
         if v == self._data_idx[3]:
             return
         max_ = np.prod(self._volume_dims)
-        self._data_idx[3] = max(min(int(round(v)), max_ - 1), 0)
+        self._data_idx[3] = max(min(round(v), max_ - 1), 0)
         idx = (slice(None), slice(None), slice(None))
         if self._data.ndim > 3:
             idx = idx + tuple(np.unravel_index(self._data_idx[3], self._volume_dims))
@@ -399,8 +399,9 @@ def _set_position(self, x, y, z, notify=True):
         # deal with slicing appropriately
         self._position[:3] = [x, y, z]
         idxs = np.dot(self._inv_affine, self._position)[:3]
-        for ii, (size, idx) in enumerate(zip(self._sizes, idxs)):
-            self._data_idx[ii] = max(min(int(round(idx)), size - 1), 0)
+        idxs_new_order = idxs[self._order]
+        for ii, (size, idx) in enumerate(zip(self._sizes, idxs_new_order)):
+            self._data_idx[ii] = max(min(round(idx), size - 1), 0)
         for ii in range(3):
             # sagittal: get to S/A
             # coronal: get to S/L
@@ -418,7 +419,7 @@ def _set_position(self, x, y, z, notify=True):
             # deal with crosshairs
             loc = self._data_idx[ii]
             if self._flips[ii]:
-                loc = self._sizes[ii] - loc
+                loc = self._sizes[ii] - 1 - loc
             loc = [loc] * 2
             if ii == 0:
                 self._crosshairs[2]['vert'].set_xdata(loc)
@@ -446,7 +447,7 @@ def _set_position(self, x, y, z, notify=True):
     # Matplotlib handlers ####################################################
     def _in_axis(self, event):
         """Return axis index if within one of our axes, else None"""
-        if getattr(event, 'inaxes') is None:
+        if event.inaxes is None:
             return None
         for ii, ax in enumerate(self._axes):
             if event.inaxes is ax:
@@ -467,12 +468,17 @@ def _on_scroll(self, event):
         dv *= 1.0 if event.button == 'up' else -1.0
         dv *= -1 if self._flips[ii] else 1
         val = self._data_idx[ii] + dv
+
         if ii == 3:
             self._set_volume_index(val)
         else:
-            coords = [self._data_idx[k] for k in range(3)] + [1.0]
+            coords = [self._data_idx[k] for k in range(3)]
             coords[ii] = val
-            self._set_position(*np.dot(self._affine, coords)[:3])
+            coords_ordered = [0, 0, 0, 1]
+            for k in range(3):
+                coords_ordered[self._order[k]] = coords[k]
+            position = np.dot(self._affine, coords_ordered)[:3]
+            self._set_position(*position)
         self._draw()
 
     def _on_mouse(self, event):
@@ -487,14 +493,18 @@ def _on_mouse(self, event):
             self._set_volume_index(event.xdata)
         else:
             # translate click xdata/ydata to physical position
-            xax, yax = [[1, 2], [0, 2], [0, 1]][ii]
+            xax, yax = [
+                [self._order[1], self._order[2]],
+                [self._order[0], self._order[2]],
+                [self._order[0], self._order[1]],
+            ][ii]
             x, y = event.xdata, event.ydata
-            x = self._sizes[xax] - x if self._flips[xax] else x
-            y = self._sizes[yax] - y if self._flips[yax] else y
-            idxs = [None, None, None, 1.0]
+            x = self._sizes[xax] - x - 1 if self._flips[xax] else x
+            y = self._sizes[yax] - y - 1 if self._flips[yax] else y
+            idxs = np.ones(4)
             idxs[xax] = x
             idxs[yax] = y
-            idxs[ii] = self._data_idx[ii]
+            idxs[self._order[ii]] = self._data_idx[ii]
             self._set_position(*np.dot(self._affine, idxs)[:3])
         self._draw()
 
@@ -502,7 +512,7 @@ def _on_keypress(self, event):
         """Handle mpl keypress events"""
         if event.key is not None and 'escape' in event.key:
             self.close()
-        elif event.key in ['=', '+']:
+        elif event.key in ('=', '+'):
             # increment volume index
             new_idx = min(self._data_idx[3] + 1, self.n_volumes)
             self._set_volume_index(new_idx, update_slices=True)
diff --git a/nibabel/volumeutils.py b/nibabel/volumeutils.py
index 225062b2cb..41bff7275c 100644
--- a/nibabel/volumeutils.py
+++ b/nibabel/volumeutils.py
@@ -7,28 +7,38 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Utility functions for analyze-like formats"""
+
 from __future__ import annotations
 
-import gzip
 import sys
+import typing as ty
 import warnings
-from collections import OrderedDict
 from functools import reduce
-from operator import mul
+from operator import getitem, mul
 from os.path import exists, splitext
 
 import numpy as np
 
+from ._compression import COMPRESSED_FILE_LIKES
 from .casting import OK_FLOATS, shared_range
 from .externals.oset import OrderedSet
-from .openers import BZ2File, IndexedGzipFile
-from .optpkg import optional_package
 
-pyzstd, HAVE_ZSTD, _ = optional_package('pyzstd')
+if ty.TYPE_CHECKING:
+    import io
+
+    import numpy.typing as npt
+
+    from ._typing import TypeVar
+
+    Scalar = np.number | float
+
+    K = TypeVar('K')
+    V = TypeVar('V')
+    DT = TypeVar('DT', bound=np.generic)
 
 sys_is_le = sys.byteorder == 'little'
-native_code = sys_is_le and '<' or '>'
-swapped_code = sys_is_le and '>' or '<'
+native_code: ty.Literal['<', '>'] = '<' if sys_is_le else '>'
+swapped_code: ty.Literal['<', '>'] = '>' if sys_is_le else '<'
 
 _endian_codes = (  # numpy code, aliases
     ('<', 'little', 'l', 'le', 'L', 'LE'),
@@ -41,13 +51,6 @@
 #: default compression level when writing gz and bz2 files
 default_compresslevel = 1
 
-#: file-like classes known to hold compressed data
-COMPRESSED_FILE_LIKES: tuple[type, ...] = (gzip.GzipFile, BZ2File, IndexedGzipFile)
-
-# Enable .zst support if pyzstd installed.
-if HAVE_ZSTD:
-    COMPRESSED_FILE_LIKES = (*COMPRESSED_FILE_LIKES, pyzstd.ZstdFile)
-
 
 class Recoder:
     """class to return canonical code(s) from code or aliases
@@ -83,7 +86,14 @@ class Recoder:
     2
     """
 
-    def __init__(self, codes, fields=('code',), map_maker=OrderedDict):
+    fields: tuple[str, ...]
+
+    def __init__(
+        self,
+        codes: ty.Sequence[ty.Sequence[ty.Hashable]],
+        fields: ty.Sequence[str] = ('code',),
+        map_maker: type[ty.Mapping[ty.Hashable, ty.Hashable]] = dict,
+    ):
         """Create recoder object
 
         ``codes`` give a sequence of code, alias sequences
@@ -121,7 +131,14 @@ def __init__(self, codes, fields=('code',), map_maker=OrderedDict):
         self.field1 = self.__dict__[fields[0]]
         self.add_codes(codes)
 
-    def add_codes(self, code_syn_seqs):
+    def __getattr__(self, key: str) -> ty.Mapping[ty.Hashable, ty.Hashable]:
+        # By setting this, we let static analyzers know that dynamic attributes will
+        # be dict-like (Mapping).
+        # However, __getattr__ is called if looking up the field in __dict__ fails,
+        # so we only get here if the attribute is really missing.
+        raise AttributeError(f'{self.__class__.__name__!r} object has no attribute {key!r}')
+
+    def add_codes(self, code_syn_seqs: ty.Sequence[ty.Sequence[ty.Hashable]]) -> None:
         """Add codes to object
 
         Parameters
@@ -155,7 +172,7 @@ def add_codes(self, code_syn_seqs):
                 for field_ind, field_name in enumerate(self.fields):
                     self.__dict__[field_name][alias] = code_syns[field_ind]
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: ty.Hashable) -> ty.Hashable:
         """Return value from field1 dictionary (first column of values)
 
         Returns same value as ``obj.field1[key]`` and, with the
@@ -168,13 +185,9 @@ def __getitem__(self, key):
         """
         return self.field1[key]
 
-    def __contains__(self, key):
+    def __contains__(self, key: ty.Hashable) -> bool:
         """True if field1 in recoder contains `key`"""
-        try:
-            self.field1[key]
-        except KeyError:
-            return False
-        return True
+        return key in self.field1
 
     def keys(self):
         """Return all available code and alias values
@@ -190,7 +203,7 @@ def keys(self):
         """
         return self.field1.keys()
 
-    def value_set(self, name=None):
+    def value_set(self, name: str | None = None) -> OrderedSet:
         """Return OrderedSet of possible returned values for column
 
         By default, the column is the first column.
@@ -224,7 +237,7 @@ def value_set(self, name=None):
 endian_codes = Recoder(_endian_codes)
 
 
-class DtypeMapper:
+class DtypeMapper(dict[ty.Hashable, ty.Hashable]):
     """Specialized mapper for numpy dtypes
 
     We pass this mapper into the Recoder class to deal with numpy dtype
@@ -242,26 +255,20 @@ class DtypeMapper:
     and return any matching values for the matching key.
     """
 
-    def __init__(self):
-        self._dict = {}
-        self._dtype_keys = []
-
-    def keys(self):
-        return self._dict.keys()
-
-    def values(self):
-        return self._dict.values()
+    def __init__(self) -> None:
+        super().__init__()
+        self._dtype_keys: list[np.dtype] = []
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: ty.Hashable, value: ty.Hashable) -> None:
         """Set item into mapping, checking for dtype keys
 
         Cache dtype keys for comparison test in __getitem__
         """
-        self._dict[key] = value
-        if hasattr(key, 'subdtype'):
+        super().__setitem__(key, value)
+        if isinstance(key, np.dtype):
             self._dtype_keys.append(key)
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: ty.Hashable) -> ty.Hashable:
         """Get item from mapping, checking for dtype keys
 
         First do simple hash lookup, then check for a dtype key that has failed
@@ -269,17 +276,20 @@ def __getitem__(self, key):
         to `key`.
         """
         try:
-            return self._dict[key]
+            return super().__getitem__(key)
         except KeyError:
             pass
-        if hasattr(key, 'subdtype'):
+        if isinstance(key, np.dtype):
             for dt in self._dtype_keys:
                 if key == dt:
-                    return self._dict[dt]
+                    return super().__getitem__(dt)
         raise KeyError(key)
 
 
-def pretty_mapping(mapping, getterfunc=None):
+def pretty_mapping(
+    mapping: ty.Mapping[K, V],
+    getterfunc: ty.Callable[[ty.Mapping[K, V], K], V] | None = None,
+) -> str:
     """Make pretty string from mapping
 
     Adjusts text column to print values on basis of longest key.
@@ -328,18 +338,12 @@ def pretty_mapping(mapping, getterfunc=None):
     longer_field  : method string
     """
     if getterfunc is None:
-        getterfunc = lambda obj, key: obj[key]
-    lens = [len(str(name)) for name in mapping]
-    mxlen = np.max(lens)
-    fmt = '%%-%ds  : %%s' % mxlen
-    out = []
-    for name in mapping:
-        value = getterfunc(mapping, name)
-        out.append(fmt % (name, value))
-    return '\n'.join(out)
-
-
-def make_dt_codes(codes_seqs):
+        getterfunc = getitem
+    mxlen = max(len(str(name)) for name in mapping)
+    return '\n'.join(f'{name:{mxlen}s}  : {getterfunc(mapping, name)}' for name in mapping)
+
+
+def make_dt_codes(codes_seqs: ty.Sequence[ty.Sequence]) -> Recoder:
     """Create full dt codes Recoder instance from datatype codes
 
     Include created numpy dtype (from numpy type) and opposite endian
@@ -379,12 +383,19 @@ def make_dt_codes(codes_seqs):
     return Recoder(dt_codes, fields + ['dtype', 'sw_dtype'], DtypeMapper)
 
 
-def _is_compressed_fobj(fobj):
+def _is_compressed_fobj(fobj: io.IOBase) -> bool:
     """Return True if fobj represents a compressed data file-like object"""
     return isinstance(fobj, COMPRESSED_FILE_LIKES)
 
 
-def array_from_file(shape, in_dtype, infile, offset=0, order='F', mmap=True):
+def array_from_file(
+    shape: tuple[int, ...],
+    in_dtype: np.dtype[DT],
+    infile: io.IOBase,
+    offset: int = 0,
+    order: ty.Literal['C', 'F'] = 'F',
+    mmap: bool | ty.Literal['c', 'r', 'r+'] = True,
+) -> npt.NDArray[DT]:
     """Get array from file with specified shape, dtype and file offset
 
     Parameters
@@ -428,25 +439,24 @@ def array_from_file(shape, in_dtype, infile, offset=0, order='F', mmap=True):
     True
     """
     if mmap not in (True, False, 'c', 'r', 'r+'):
-        raise ValueError("mmap value should be one of True, False, 'c', " "'r', 'r+'")
-    if mmap is True:
-        mmap = 'c'
+        raise ValueError("mmap value should be one of True, False, 'c', 'r', 'r+'")
     in_dtype = np.dtype(in_dtype)
     # Get file-like object from Opener instance
     infile = getattr(infile, 'fobj', infile)
     if mmap and not _is_compressed_fobj(infile):
+        mode = 'c' if mmap is True else mmap
         try:  # Try memmapping file on disk
-            return np.memmap(infile, in_dtype, mode=mmap, shape=shape, order=order, offset=offset)
+            return np.memmap(infile, in_dtype, mode=mode, shape=shape, order=order, offset=offset)
             # The error raised by memmap, for different file types, has
             # changed in different incarnations of the numpy routine
         except (AttributeError, TypeError, ValueError):
             pass
     if len(shape) == 0:
-        return np.array([])
+        return np.array([], in_dtype)
     # Use reduce and mul to work around numpy integer overflow
     n_bytes = reduce(mul, shape) * in_dtype.itemsize
     if n_bytes == 0:
-        return np.array([])
+        return np.array([], in_dtype)
     # Read data from file
     infile.seek(offset)
     if hasattr(infile, 'readinto'):
@@ -460,9 +470,9 @@ def array_from_file(shape, in_dtype, infile, offset=0, order='F', mmap=True):
     if n_bytes != n_read:
         raise OSError(
             f'Expected {n_bytes} bytes, got {n_read} bytes from '
-            f"{getattr(infile, 'name', 'object')}\n - could the file be damaged?"
+            f'{getattr(infile, "name", "object")}\n - could the file be damaged?'
         )
-    arr = np.ndarray(shape, in_dtype, buffer=data_bytes, order=order)
+    arr: np.ndarray = np.ndarray(shape, in_dtype, buffer=data_bytes, order=order)
     if needs_copy:
         return arr.copy()
     arr.flags.writeable = True
@@ -470,17 +480,17 @@ def array_from_file(shape, in_dtype, infile, offset=0, order='F', mmap=True):
 
 
 def array_to_file(
-    data,
-    fileobj,
-    out_dtype=None,
-    offset=0,
-    intercept=0.0,
-    divslope=1.0,
-    mn=None,
-    mx=None,
-    order='F',
-    nan2zero=True,
-):
+    data: npt.ArrayLike,
+    fileobj: io.IOBase,
+    out_dtype: np.dtype | None = None,
+    offset: int = 0,
+    intercept: Scalar = 0.0,
+    divslope: Scalar | None = 1.0,
+    mn: Scalar | None = None,
+    mx: Scalar | None = None,
+    order: ty.Literal['C', 'F'] = 'F',
+    nan2zero: bool = True,
+) -> None:
     """Helper function for writing arrays to file objects
 
     Writes arrays as scaled by `intercept` and `divslope`, and clipped
@@ -562,8 +572,7 @@ def array_to_file(
     True
     """
     # Shield special case
-    div_none = divslope is None
-    if not np.all(np.isfinite((intercept, 1.0 if div_none else divslope))):
+    if not np.isfinite(np.array((intercept, 1.0 if divslope is None else divslope))).all():
         raise ValueError('divslope and intercept must be finite')
     if divslope == 0:
         raise ValueError('divslope cannot be zero')
@@ -575,7 +584,7 @@ def array_to_file(
         out_dtype = np.dtype(out_dtype)
     if offset is not None:
         seek_tell(fileobj, offset)
-    if div_none or (mn, mx) == (0, 0) or ((mn is not None and mx is not None) and mx < mn):
+    if divslope is None or (mn, mx) == (0, 0) or ((mn is not None and mx is not None) and mx < mn):
         write_zeros(fileobj, data.size * out_dtype.itemsize)
         return
     if order not in 'FC':
@@ -613,7 +622,7 @@ def array_to_file(
             # pre scale thresholds
             mn, mx = _dt_min_max(in_dtype, mn, mx)
             mn_out, mx_out = _dt_min_max(out_dtype)
-            pre_clips = max(mn, mn_out), min(mx, mx_out)
+            pre_clips = max(mn, mn_out), min(mx, mx_out)  # type: ignore[type-var]
             return _write_data(data, fileobj, out_dtype, order, pre_clips=pre_clips)
         # In any case, we do not want to check for nans because we've already
         # disallowed scaling that generates nans
@@ -707,17 +716,17 @@ def array_to_file(
 
 
 def _write_data(
-    data,
-    fileobj,
-    out_dtype,
-    order,
-    in_cast=None,
-    pre_clips=None,
-    inter=0.0,
-    slope=1.0,
-    post_clips=None,
-    nan_fill=None,
-):
+    data: np.ndarray,
+    fileobj: io.IOBase,
+    out_dtype: np.dtype,
+    order: ty.Literal['C', 'F'],
+    in_cast: np.dtype | None = None,
+    pre_clips: tuple[Scalar | None, Scalar | None] | None = None,
+    inter: Scalar | np.ndarray = 0.0,
+    slope: Scalar | np.ndarray = 1.0,
+    post_clips: tuple[Scalar | None, Scalar | None] | None = None,
+    nan_fill: Scalar | None = None,
+) -> None:
     """Write array `data` to `fileobj` as `out_dtype` type, layout `order`
 
     Does not modify `data` in-place.
@@ -774,7 +783,9 @@ def _write_data(
         fileobj.write(dslice.tobytes())
 
 
-def _dt_min_max(dtype_like, mn=None, mx=None):
+def _dt_min_max(
+    dtype_like: npt.DTypeLike, mn: Scalar | None = None, mx: Scalar | None = None
+) -> tuple[Scalar, Scalar]:
     dt = np.dtype(dtype_like)
     if dt.kind in 'fc':
         dt_mn, dt_mx = (-np.inf, np.inf)
@@ -786,20 +797,25 @@ def _dt_min_max(dtype_like, mn=None, mx=None):
     return dt_mn if mn is None else mn, dt_mx if mx is None else mx
 
 
-_CSIZE2FLOAT = {8: np.float32, 16: np.float64, 24: np.longdouble, 32: np.longdouble}
+_CSIZE2FLOAT: dict[int, type[np.floating]] = {
+    8: np.float32,
+    16: np.float64,
+    24: np.longdouble,
+    32: np.longdouble,
+}
 
 
-def _matching_float(np_type):
+def _matching_float(np_type: npt.DTypeLike) -> type[np.floating]:
     """Return floating point type matching `np_type`"""
     dtype = np.dtype(np_type)
     if dtype.kind not in 'cf':
         raise ValueError('Expecting float or complex type as input')
-    if dtype.kind in 'f':
+    if issubclass(dtype.type, np.floating):
         return dtype.type
     return _CSIZE2FLOAT[dtype.itemsize]
 
 
-def write_zeros(fileobj, count, block_size=8194):
+def write_zeros(fileobj: io.IOBase, count: int, block_size: int = 8194) -> None:
     """Write `count` zero bytes to `fileobj`
 
     Parameters
@@ -819,7 +835,7 @@ def write_zeros(fileobj, count, block_size=8194):
     fileobj.write(b'\x00' * rem)
 
 
-def seek_tell(fileobj, offset, write0=False):
+def seek_tell(fileobj: io.IOBase, offset: int, write0: bool = False) -> None:
     """Seek in `fileobj` or check we're in the right place already
 
     Parameters
@@ -849,7 +865,11 @@ def seek_tell(fileobj, offset, write0=False):
         assert fileobj.tell() == offset
 
 
-def apply_read_scaling(arr, slope=None, inter=None):
+def apply_read_scaling(
+    arr: np.ndarray,
+    slope: Scalar | None = None,
+    inter: Scalar | None = None,
+) -> np.ndarray:
     """Apply scaling in `slope` and `inter` to array `arr`
 
     This is for loading the array from a file (as opposed to the reverse
@@ -888,23 +908,28 @@ def apply_read_scaling(arr, slope=None, inter=None):
         return arr
     shape = arr.shape
     # Force float / float upcasting by promoting to arrays
-    arr, slope, inter = (np.atleast_1d(v) for v in (arr, slope, inter))
+    slope1d, inter1d = (np.atleast_1d(v) for v in (slope, inter))
+    arr = np.atleast_1d(arr)
     if arr.dtype.kind in 'iu':
         # int to float; get enough precision to avoid infs
         # Find floating point type for which scaling does not overflow,
         # starting at given type
-        default = slope.dtype.type if slope.dtype.kind == 'f' else np.float64
-        ftype = int_scinter_ftype(arr.dtype, slope, inter, default)
-        slope = slope.astype(ftype)
-        inter = inter.astype(ftype)
-    if slope != 1.0:
-        arr = arr * slope
-    if inter != 0.0:
-        arr = arr + inter
+        default = slope1d.dtype.type if slope1d.dtype.kind == 'f' else np.float64
+        ftype = int_scinter_ftype(arr.dtype, slope1d, inter1d, default)
+        slope1d = slope1d.astype(ftype)
+        inter1d = inter1d.astype(ftype)
+    if slope1d != 1.0:
+        arr = arr * slope1d
+    if inter1d != 0.0:
+        arr = arr + inter1d
     return arr.reshape(shape)
 
 
-def working_type(in_type, slope=1.0, inter=0.0):
+def working_type(
+    in_type: npt.DTypeLike,
+    slope: npt.ArrayLike = 1.0,
+    inter: npt.ArrayLike = 0.0,
+) -> type[np.number]:
     """Return array type from applying `slope`, `inter` to array of `in_type`
 
     Numpy type that results from an array of type `in_type` being combined with
@@ -935,19 +960,22 @@ def working_type(in_type, slope=1.0, inter=0.0):
         `in_type`.
     """
     val = np.array([1], dtype=in_type)
-    slope = np.array(slope)
-    inter = np.array(inter)
     # Don't use real values to avoid overflows.  Promote to 1D to avoid scalar
     # casting rules.  Don't use ones_like, zeros_like because of a bug in numpy
     # <= 1.5.1 in converting complex192 / complex256 scalars.
     if inter != 0:
-        val = val + np.array([0], dtype=inter.dtype)
+        val = val + np.array([0], dtype=np.array(inter).dtype)
     if slope != 1:
-        val = val / np.array([1], dtype=slope.dtype)
+        val = val / np.array([1], dtype=np.array(slope).dtype)
     return val.dtype.type
 
 
-def int_scinter_ftype(ifmt, slope=1.0, inter=0.0, default=np.float32):
+def int_scinter_ftype(
+    ifmt: np.dtype[np.integer] | type[np.integer],
+    slope: npt.ArrayLike = 1.0,
+    inter: npt.ArrayLike = 0.0,
+    default: type[np.floating] = np.float32,
+) -> type[np.floating]:
     """float type containing int type `ifmt` * `slope` + `inter`
 
     Return float type that can represent the max and the min of the `ifmt` type
@@ -999,7 +1027,12 @@ def int_scinter_ftype(ifmt, slope=1.0, inter=0.0, default=np.float32):
         raise ValueError('Overflow using highest floating point type')
 
 
-def best_write_scale_ftype(arr, slope=1.0, inter=0.0, default=np.float32):
+def best_write_scale_ftype(
+    arr: np.ndarray,
+    slope: npt.ArrayLike = 1.0,
+    inter: npt.ArrayLike = 0.0,
+    default: type[np.number] = np.float32,
+) -> type[np.floating]:
     """Smallest float type to contain range of ``arr`` after scaling
 
     Scaling that will be applied to ``arr`` is ``(arr - inter) / slope``.
@@ -1063,7 +1096,11 @@ def best_write_scale_ftype(arr, slope=1.0, inter=0.0, default=np.float32):
         return OK_FLOATS[-1]
 
 
-def better_float_of(first, second, default=np.float32):
+def better_float_of(
+    first: npt.DTypeLike,
+    second: npt.DTypeLike,
+    default: type[np.floating] = np.float32,
+) -> type[np.floating]:
     """Return more capable float type of `first` and `second`
 
     Return `default` if neither of `first` or `second` is a float
@@ -1097,19 +1134,22 @@ def better_float_of(first, second, default=np.float32):
     first = np.dtype(first)
     second = np.dtype(second)
     default = np.dtype(default).type
-    kinds = (first.kind, second.kind)
-    if 'f' not in kinds:
-        return default
-    if kinds == ('f', 'f'):
-        if first.itemsize >= second.itemsize:
-            return first.type
-        return second.type
-    if first.kind == 'f':
+    if issubclass(first.type, np.floating):
+        if issubclass(second.type, np.floating) and first.itemsize < second.itemsize:
+            return second.type
         return first.type
-    return second.type
+    if issubclass(second.type, np.floating):
+        return second.type
+    return default
 
 
-def _ftype4scaled_finite(tst_arr, slope, inter, direction='read', default=np.float32):
+def _ftype4scaled_finite(
+    tst_arr: np.ndarray,
+    slope: npt.ArrayLike,
+    inter: npt.ArrayLike,
+    direction: ty.Literal['read', 'write'] = 'read',
+    default: type[np.floating] = np.float32,
+) -> type[np.floating]:
     """Smallest float type for scaling of `tst_arr` that does not overflow"""
     assert direction in ('read', 'write')
     if default not in OK_FLOATS and default is np.longdouble:
@@ -1120,7 +1160,6 @@ def _ftype4scaled_finite(tst_arr, slope, inter, direction='read', default=np.flo
     tst_arr = np.atleast_1d(tst_arr)
     slope = np.atleast_1d(slope)
     inter = np.atleast_1d(inter)
-    overflow_filter = ('error', '.*overflow.*', RuntimeWarning)
     for ftype in OK_FLOATS[def_ind:]:
         tst_trans = tst_arr.copy()
         slope = slope.astype(ftype)
@@ -1128,7 +1167,7 @@ def _ftype4scaled_finite(tst_arr, slope, inter, direction='read', default=np.flo
         try:
             with warnings.catch_warnings():
                 # Error on overflows to short circuit the logic
-                warnings.filterwarnings(*overflow_filter)
+                warnings.filterwarnings('error', '.*overflow.*', RuntimeWarning)
                 if direction == 'read':  # as in reading of image from disk
                     if slope != 1.0:
                         tst_trans = tst_trans * slope
@@ -1147,7 +1186,22 @@ def _ftype4scaled_finite(tst_arr, slope, inter, direction='read', default=np.flo
     raise ValueError('Overflow using highest floating point type')
 
 
-def finite_range(arr, check_nan=False):
+@ty.overload
+def finite_range(
+    arr: npt.ArrayLike, check_nan: ty.Literal[False] = False
+) -> tuple[Scalar, Scalar]: ...
+
+
+@ty.overload
+def finite_range(
+    arr: npt.ArrayLike, check_nan: ty.Literal[True]
+) -> tuple[Scalar, Scalar, bool]: ...
+
+
+def finite_range(
+    arr: npt.ArrayLike,
+    check_nan: bool = False,
+) -> tuple[Scalar, Scalar, bool] | tuple[Scalar, Scalar]:
     """Get range (min, max) or range and flag (min, max, has_nan) from `arr`
 
     Parameters
@@ -1195,7 +1249,9 @@ def finite_range(arr, check_nan=False):
     """
     arr = np.asarray(arr)
     if arr.size == 0:
-        return (np.inf, -np.inf) + (False,) * check_nan
+        if check_nan:
+            return (np.inf, -np.inf, False)
+        return (np.inf, -np.inf)
     # Resort array to slowest->fastest memory change indices
     stride_order = np.argsort(arr.strides)[::-1]
     sarr = arr.transpose(stride_order)
@@ -1243,7 +1299,11 @@ def finite_range(arr, check_nan=False):
     return np.nanmin(mins), np.nanmax(maxes)
 
 
-def shape_zoom_affine(shape, zooms, x_flip=True):
+def shape_zoom_affine(
+    shape: ty.Sequence[int] | np.ndarray,
+    zooms: ty.Sequence[float] | np.ndarray,
+    x_flip: bool = True,
+) -> np.ndarray:
     """Get affine implied by given shape and zooms
 
     We get the translations from the center of the image (implied by
@@ -1305,7 +1365,7 @@ def shape_zoom_affine(shape, zooms, x_flip=True):
     return aff
 
 
-def rec2dict(rec):
+def rec2dict(rec: np.ndarray) -> dict[str, np.generic | np.ndarray]:
     """Convert recarray to dictionary
 
     Also converts scalar values to scalars
@@ -1338,7 +1398,7 @@ def rec2dict(rec):
     return dct
 
 
-def fname_ext_ul_case(fname):
+def fname_ext_ul_case(fname: str) -> str:
     """`fname` with ext changed to upper / lower case if file exists
 
     Check for existence of `fname`.  If it does exist, return unmodified.  If
diff --git a/nibabel/wrapstruct.py b/nibabel/wrapstruct.py
index 6e236d7356..5ffe04bc78 100644
--- a/nibabel/wrapstruct.py
+++ b/nibabel/wrapstruct.py
@@ -109,6 +109,7 @@
 
    nib.imageglobals.logger = logger
 """
+
 from __future__ import annotations
 
 import numpy as np
diff --git a/nibabel/xmlutils.py b/nibabel/xmlutils.py
index 8e0b18fb6e..12fd30f225 100644
--- a/nibabel/xmlutils.py
+++ b/nibabel/xmlutils.py
@@ -6,29 +6,34 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""
-Thin layer around xml.etree.ElementTree, to abstract nibabel xml support.
-"""
+"""Thin layer around xml.etree.ElementTree, to abstract nibabel xml support"""
 
 from io import BytesIO
-from xml.etree.ElementTree import Element, SubElement, tostring  # noqa
+from xml.etree.ElementTree import Element, SubElement, tostring  # noqa: F401
 from xml.parsers.expat import ParserCreate
 
 from .filebasedimages import FileBasedHeader
 
 
 class XmlSerializable:
-    """Basic interface for serializing an object to xml"""
+    """Basic interface for serializing an object to XML"""
 
-    def _to_xml_element(self):
+    def _to_xml_element(self) -> Element:
         """Output should be a xml.etree.ElementTree.Element"""
-        raise NotImplementedError()
+        raise NotImplementedError
+
+    def to_xml(self, enc='utf-8', **kwargs) -> bytes:
+        r"""Generate an XML bytestring with a given encoding.
 
-    def to_xml(self, enc='utf-8'):
-        """Output should be an xml string with the given encoding.
-        (default: utf-8)"""
+        Parameters
+        ----------
+        enc : :class:`string`
+            Encoding to use for the generated bytestring. Default: 'utf-8'
+        \*\*kwargs : :class:`dict`
+            Additional keyword arguments to :func:`xml.etree.ElementTree.tostring`.
+        """
         ele = self._to_xml_element()
-        return '' if ele is None else tostring(ele, enc)
+        return tostring(ele, enc, **kwargs)
 
 
 class XmlBasedHeader(FileBasedHeader, XmlSerializable):
diff --git a/nisext/__init__.py b/nisext/__init__.py
deleted file mode 100644
index 6b19d7eb8e..0000000000
--- a/nisext/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# init for sext package
-"""Setuptools extensions
-
-nibabel uses these routines, and houses them, and installs them.  nipy-proper
-and dipy use them.
-"""
-
-import warnings
-
-warnings.warn(
-    """The nisext package is deprecated as of NiBabel 5.0 and will be fully
-removed in NiBabel 6.0"""
-)
diff --git a/nisext/py3builder.py b/nisext/py3builder.py
deleted file mode 100644
index 24bd298364..0000000000
--- a/nisext/py3builder.py
+++ /dev/null
@@ -1,38 +0,0 @@
-"""distutils utilities for porting to python 3 within 2-compatible tree"""
-
-
-try:
-    from distutils.command.build_py import build_py_2to3
-except ImportError:
-    # 2.x - no parsing of code
-    from distutils.command.build_py import build_py
-else:   # Python 3
-    # Command to also apply 2to3 to doctests
-    from distutils import log
-
-    class build_py(build_py_2to3):
-        def run_2to3(self, files):
-            # Add doctest parsing; this stuff copied from distutils.utils in
-            # python 3.2 source
-            if not files:
-                return
-            fixer_names, options, explicit = (self.fixer_names, self.options, self.explicit)
-            # Make this class local, to delay import of 2to3
-            from lib2to3.refactor import RefactoringTool, get_fixers_from_package
-
-            class DistutilsRefactoringTool(RefactoringTool):
-                def log_error(self, msg, *args, **kw):
-                    log.error(msg, *args)
-
-                def log_message(self, msg, *args):
-                    log.info(msg, *args)
-
-                def log_debug(self, msg, *args):
-                    log.debug(msg, *args)
-
-            if fixer_names is None:
-                fixer_names = get_fixers_from_package('lib2to3.fixes')
-            r = DistutilsRefactoringTool(fixer_names, options=options)
-            r.refactor(files, write=True)
-            # Then doctests
-            r.refactor(files, write=True, doctests_only=True)
diff --git a/nisext/sexts.py b/nisext/sexts.py
deleted file mode 100644
index b206588dec..0000000000
--- a/nisext/sexts.py
+++ /dev/null
@@ -1,285 +0,0 @@
-"""Distutils / setuptools helpers"""
-
-import os
-from configparser import ConfigParser
-from distutils import log
-from distutils.command.build_py import build_py
-from distutils.command.install_scripts import install_scripts
-from distutils.version import LooseVersion
-from os.path import join as pjoin
-from os.path import split as psplit
-from os.path import splitext
-
-
-def get_comrec_build(pkg_dir, build_cmd=build_py):
-    """Return extended build command class for recording commit
-
-    The extended command tries to run git to find the current commit, getting
-    the empty string if it fails.  It then writes the commit hash into a file
-    in the `pkg_dir` path, named ``COMMIT_INFO.txt``.
-
-    In due course this information can be used by the package after it is
-    installed, to tell you what commit it was installed from if known.
-
-    To make use of this system, you need a package with a COMMIT_INFO.txt file -
-    e.g. ``myproject/COMMIT_INFO.txt`` - that might well look like this::
-
-        # This is an ini file that may contain information about the code state
-        [commit hash]
-        # The line below may contain a valid hash if it has been substituted during 'git archive'
-        archive_subst_hash=$Format:%h$
-        # This line may be modified by the install process
-        install_hash=
-
-    The COMMIT_INFO file above is also designed to be used with git substitution
-    - so you probably also want a ``.gitattributes`` file in the root directory
-    of your working tree that contains something like this::
-
-       myproject/COMMIT_INFO.txt export-subst
-
-    That will cause the ``COMMIT_INFO.txt`` file to get filled in by ``git
-    archive`` - useful in case someone makes such an archive - for example with
-    via the github 'download source' button.
-
-    Although all the above will work as is, you might consider having something
-    like a ``get_info()`` function in your package to display the commit
-    information at the terminal.  See the ``pkg_info.py`` module in the nipy
-    package for an example.
-    """
-
-    class MyBuildPy(build_cmd):
-        """Subclass to write commit data into installation tree"""
-
-        def run(self):
-            build_cmd.run(self)
-            import subprocess
-
-            proc = subprocess.Popen(
-                'git rev-parse --short HEAD',
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                shell=True,
-            )
-            repo_commit, _ = proc.communicate()
-            # Fix for python 3
-            repo_commit = str(repo_commit)
-            # We write the installation commit even if it's empty
-            cfg_parser = ConfigParser()
-            cfg_parser.read(pjoin(pkg_dir, 'COMMIT_INFO.txt'))
-            cfg_parser.set('commit hash', 'install_hash', repo_commit)
-            out_pth = pjoin(self.build_lib, pkg_dir, 'COMMIT_INFO.txt')
-            cfg_parser.write(open(out_pth, 'wt'))
-
-    return MyBuildPy
-
-
-def _add_append_key(in_dict, key, value):
-    """Helper for appending dependencies to setuptools args"""
-    # If in_dict[key] does not exist, create it
-    # If in_dict[key] is a string, make it len 1 list of strings
-    # Append value to in_dict[key] list
-    if key not in in_dict:
-        in_dict[key] = []
-    elif isinstance(in_dict[key], str):
-        in_dict[key] = [in_dict[key]]
-    in_dict[key].append(value)
-
-
-# Dependency checks
-def package_check(
-    pkg_name,
-    version=None,
-    optional=False,
-    checker=LooseVersion,
-    version_getter=None,
-    messages=None,
-    setuptools_args=None,
-):
-    """Check if package `pkg_name` is present and has good enough version
-
-    Has two modes of operation.  If `setuptools_args` is None (the default),
-    raise an error for missing non-optional dependencies and log warnings for
-    missing optional dependencies.  If `setuptools_args` is a dict, then fill
-    ``install_requires`` key value with any missing non-optional dependencies,
-    and the ``extras_requires`` key value with optional dependencies.
-
-    This allows us to work with and without setuptools.  It also means we can
-    check for packages that have not been installed with setuptools to avoid
-    installing them again.
-
-    Parameters
-    ----------
-    pkg_name : str
-       name of package as imported into python
-    version : {None, str}, optional
-       minimum version of the package that we require. If None, we don't
-       check the version.  Default is None
-    optional : bool or str, optional
-       If ``bool(optional)`` is False, raise error for absent package or wrong
-       version; otherwise warn.  If ``setuptools_args`` is not None, and
-       ``bool(optional)`` is not False, then `optional` should be a string
-       giving the feature name for the ``extras_require`` argument to setup.
-    checker : callable, optional
-       callable with which to return comparable thing from version
-       string.  Default is ``distutils.version.LooseVersion``
-    version_getter : {None, callable}:
-       Callable that takes `pkg_name` as argument, and returns the
-       package version string - as in::
-
-          ``version = version_getter(pkg_name)``
-
-       If None, equivalent to::
-
-          mod = __import__(pkg_name); version = mod.__version__``
-    messages : None or dict, optional
-       dictionary giving output messages
-    setuptools_args : None or dict
-       If None, raise errors / warnings for missing non-optional / optional
-       dependencies.  If dict fill key values ``install_requires`` and
-       ``extras_require`` for non-optional and optional dependencies.
-    """
-    setuptools_mode = not setuptools_args is None
-    optional_tf = bool(optional)
-    if version_getter is None:
-
-        def version_getter(pkg_name):
-            mod = __import__(pkg_name)
-            return mod.__version__
-
-    if messages is None:
-        messages = {}
-    msgs = {
-        'missing': 'Cannot import package "%s" - is it installed?',
-        'missing opt': 'Missing optional package "%s"',
-        'opt suffix': '; you may get run-time errors',
-        'version too old': 'You have version %s of package "%s" but we need version >= %s',
-    }
-    msgs.update(messages)
-    status, have_version = _package_status(pkg_name, version, version_getter, checker)
-    if status == 'satisfied':
-        return
-    if not setuptools_mode:
-        if status == 'missing':
-            if not optional_tf:
-                raise RuntimeError(msgs['missing'] % pkg_name)
-            log.warn(msgs['missing opt'] % pkg_name + msgs['opt suffix'])
-            return
-        elif status == 'no-version':
-            raise RuntimeError(f'Cannot find version for {pkg_name}')
-        assert status == 'low-version'
-        if not optional_tf:
-            raise RuntimeError(msgs['version too old'] % (have_version, pkg_name, version))
-        log.warn(msgs['version too old'] % (have_version, pkg_name, version) + msgs['opt suffix'])
-        return
-    # setuptools mode
-    if optional_tf and not isinstance(optional, str):
-        raise RuntimeError('Not-False optional arg should be string')
-    dependency = pkg_name
-    if version:
-        dependency += '>=' + version
-    if optional_tf:
-        if not 'extras_require' in setuptools_args:
-            setuptools_args['extras_require'] = {}
-        _add_append_key(setuptools_args['extras_require'], optional, dependency)
-    else:
-        _add_append_key(setuptools_args, 'install_requires', dependency)
-
-
-def _package_status(pkg_name, version, version_getter, checker):
-    try:
-        __import__(pkg_name)
-    except ImportError:
-        return 'missing', None
-    if not version:
-        return 'satisfied', None
-    try:
-        have_version = version_getter(pkg_name)
-    except AttributeError:
-        return 'no-version', None
-    if checker(have_version) < checker(version):
-        return 'low-version', have_version
-    return 'satisfied', have_version
-
-
-BAT_TEMPLATE = r"""@echo off
-REM wrapper to use shebang first line of {FNAME}
-set mypath=%~dp0
-set pyscript="%mypath%{FNAME}"
-set /p line1=<%pyscript%
-if "%line1:~0,2%" == "#!" (goto :goodstart)
-echo First line of %pyscript% does not start with "#!"
-exit /b 1
-:goodstart
-set py_exe=%line1:~2%
-call "%py_exe%" %pyscript% %*
-"""
-
-
-class install_scripts_bat(install_scripts):
-    """Make scripts executable on Windows
-
-    Scripts are bare file names without extension on Unix, fitting (for example)
-    Debian rules. They identify as python scripts with the usual ``#!`` first
-    line. Unix recognizes and uses this first "shebang" line, but Windows does
-    not. So, on Windows only we add a ``.bat`` wrapper of name
-    ``bare_script_name.bat`` to call ``bare_script_name`` using the python
-    interpreter from the #! first line of the script.
-
-    Notes
-    -----
-    See discussion at
-    https://matthew-brett.github.io/pydagogue/installing_scripts.html and
-    example at git://github.com/matthew-brett/myscripter.git for more
-    background.
-    """
-
-    def run(self):
-        install_scripts.run(self)
-        if not os.name == 'nt':
-            return
-        for filepath in self.get_outputs():
-            # If we can find an executable name in the #! top line of the script
-            # file, make .bat wrapper for script.
-            with open(filepath, 'rt') as fobj:
-                first_line = fobj.readline()
-            if not (first_line.startswith('#!') and 'python' in first_line.lower()):
-                log.info('No #!python executable found, skipping .bat wrapper')
-                continue
-            pth, fname = psplit(filepath)
-            froot, ext = splitext(fname)
-            bat_file = pjoin(pth, froot + '.bat')
-            bat_contents = BAT_TEMPLATE.replace('{FNAME}', fname)
-            log.info(f'Making {bat_file} wrapper for {filepath}')
-            if self.dry_run:
-                continue
-            with open(bat_file, 'wt') as fobj:
-                fobj.write(bat_contents)
-
-
-class Bunch:
-    def __init__(self, vars):
-        for key, name in vars.items():
-            if key.startswith('__'):
-                continue
-            self.__dict__[key] = name
-
-
-def read_vars_from(ver_file):
-    """Read variables from Python text file
-
-    Parameters
-    ----------
-    ver_file : str
-        Filename of file to read
-
-    Returns
-    -------
-    info_vars : Bunch instance
-        Bunch object where variables read from `ver_file` appear as
-        attributes
-    """
-    # Use exec for compabibility with Python 3
-    ns = {}
-    with open(ver_file, 'rt') as fobj:
-        exec(fobj.read(), ns)
-    return Bunch(ns)
diff --git a/nisext/testers.py b/nisext/testers.py
deleted file mode 100644
index 07f71af696..0000000000
--- a/nisext/testers.py
+++ /dev/null
@@ -1,523 +0,0 @@
-"""Test package information in various install settings
-
-The routines here install the package from source directories, zips or eggs, and
-check these installations by running tests, checking version information,
-looking for files that were not copied over.
-
-The typical use for this module is as a Makefile target.  For example, here are
-the Makefile targets from nibabel::
-
-    # Check for files not installed
-    check-files:
-        $(PYTHON) -c 'from nisext.testers import check_files; check_files("nibabel")'
-
-    # Print out info for possible install methods
-    check-version-info:
-        $(PYTHON) -c 'from nisext.testers import info_from_here; info_from_here("nibabel")'
-
-    # Run tests from installed code
-    installed-tests:
-        $(PYTHON) -c 'from nisext.testers import tests_installed; tests_installed("nibabel")'
-
-    # Run tests from installed code
-    sdist-tests:
-        $(PYTHON) -c 'from nisext.testers import sdist_tests; sdist_tests("nibabel")'
-
-    # Run tests from binary egg
-    bdist-egg-tests:
-        $(PYTHON) -c 'from nisext.testers import bdist_egg_tests; bdist_egg_tests("nibabel")'
-"""
-
-
-import os
-import re
-import shutil
-import sys
-import tempfile
-import zipfile
-from glob import glob
-from os.path import abspath
-from os.path import join as pjoin
-from subprocess import PIPE, Popen
-
-NEEDS_SHELL = os.name != 'nt'
-PYTHON = sys.executable
-HAVE_PUTENV = hasattr(os, 'putenv')
-
-PY_LIB_SDIR = 'pylib'
-
-
-def back_tick(cmd, ret_err=False, as_str=True):
-    """Run command `cmd`, return stdout, or stdout, stderr if `ret_err`
-
-    Roughly equivalent to ``check_output`` in Python 2.7
-
-    Parameters
-    ----------
-    cmd : str
-        command to execute
-    ret_err : bool, optional
-        If True, return stderr in addition to stdout.  If False, just return
-        stdout
-    as_str : bool, optional
-        Whether to decode outputs to unicode string on exit.
-
-    Returns
-    -------
-    out : str or tuple
-        If `ret_err` is False, return stripped string containing stdout from
-        `cmd`.  If `ret_err` is True, return tuple of (stdout, stderr) where
-        ``stdout`` is the stripped stdout, and ``stderr`` is the stripped
-        stderr.
-
-    Raises
-    ------
-    RuntimeError
-        if command returns non-zero exit code.
-    """
-    proc = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=NEEDS_SHELL)
-    out, err = proc.communicate()
-    retcode = proc.returncode
-    if retcode is None:
-        proc.terminate()
-        raise RuntimeError(cmd + ' process did not terminate')
-    if retcode != 0:
-        raise RuntimeError(cmd + ' process returned code %d' % retcode)
-    out = out.strip()
-    if as_str:
-        out = out.decode('latin-1')
-    if not ret_err:
-        return out
-    err = err.strip()
-    if as_str:
-        err = err.decode('latin-1')
-    return out, err
-
-
-def run_mod_cmd(mod_name, pkg_path, cmd, script_dir=None, print_location=True):
-    """Run command in own process in anonymous path
-
-    Parameters
-    ----------
-    mod_name : str
-        Name of module to import - e.g. 'nibabel'
-    pkg_path : str
-        directory containing `mod_name` package.  Typically that will be the
-        directory containing the e.g. 'nibabel' directory.
-    cmd : str
-        Python command to execute
-    script_dir : None or str, optional
-        script directory to prepend to PATH
-    print_location : bool, optional
-        Whether to print the location of the imported `mod_name`
-
-    Returns
-    -------
-    stdout : str
-        stdout as str
-    stderr : str
-        stderr as str
-    """
-    if script_dir is None:
-        paths_add = ''
-    else:
-        if not HAVE_PUTENV:
-            raise RuntimeError('We cannot set environment variables')
-        # Need to add the python path for the scripts to pick up our package in
-        # their environment, because the scripts will get called via the shell
-        # (via `cmd`). Consider that PYTHONPATH may not be set. Because the
-        # command might run scripts via the shell, prepend script_dir to the
-        # system path also.
-        paths_add = r"""
-os.environ['PATH'] = r'"{script_dir}"' + os.path.pathsep + os.environ['PATH']
-PYTHONPATH = os.environ.get('PYTHONPATH')
-if PYTHONPATH is None:
-    os.environ['PYTHONPATH'] = r'"{pkg_path}"'
-else:
-    os.environ['PYTHONPATH'] = r'"{pkg_path}"' + os.path.pathsep + PYTHONPATH
-""".format(
-            **locals()
-        )
-    if print_location:
-        p_loc = f'print({mod_name}.__file__);'
-    else:
-        p_loc = ''
-    cwd = os.getcwd()
-    tmpdir = tempfile.mkdtemp()
-    try:
-        os.chdir(tmpdir)
-        with open('script.py', 'wt') as fobj:
-            fobj.write(
-                r"""
-import os
-import sys
-sys.path.insert(0, r"{pkg_path}")
-{paths_add}
-import {mod_name}
-{p_loc}
-{cmd}""".format(
-                    **locals()
-                )
-            )
-        res = back_tick(f'{PYTHON} script.py', ret_err=True)
-    finally:
-        os.chdir(cwd)
-        shutil.rmtree(tmpdir)
-    return res
-
-
-def zip_extract_all(fname, path=None):
-    """Extract all members from zipfile
-
-    Deals with situation where the directory is stored in the zipfile as a name,
-    as well as files that have to go into this directory.
-    """
-    zf = zipfile.ZipFile(fname)
-    members = zf.namelist()
-    # Remove members that are just bare directories
-    members = [m for m in members if not m.endswith('/')]
-    for zipinfo in members:
-        zf.extract(zipinfo, path, None)
-
-
-def install_from_to(from_dir, to_dir, py_lib_sdir=PY_LIB_SDIR, bin_sdir='bin'):
-    """Install package in `from_dir` to standard location in `to_dir`
-
-    Parameters
-    ----------
-    from_dir : str
-        path containing files to install with ``python setup.py ...``
-    to_dir : str
-        prefix path to which files will be installed, as in ``python setup.py
-        install --prefix=to_dir``
-    py_lib_sdir : str, optional
-        subdirectory within `to_dir` to which library code will be installed
-    bin_sdir : str, optional
-        subdirectory within `to_dir` to which scripts will be installed
-    """
-    site_pkgs_path = os.path.join(to_dir, py_lib_sdir)
-    py_lib_locs = f' --install-purelib={site_pkgs_path} ' f'--install-platlib={site_pkgs_path}'
-    pwd = os.path.abspath(os.getcwd())
-    cmd = f'{PYTHON} setup.py --quiet install --prefix={to_dir} {py_lib_locs}'
-    try:
-        os.chdir(from_dir)
-        back_tick(cmd)
-    finally:
-        os.chdir(pwd)
-
-
-def install_from_zip(
-    zip_fname, install_path, pkg_finder=None, py_lib_sdir=PY_LIB_SDIR, script_sdir='bin'
-):
-    """Install package from zip file `zip_fname`
-
-    Parameters
-    ----------
-    zip_fname : str
-        filename of zip file containing package code
-    install_path : str
-        output prefix at which to install package
-    pkg_finder : None or callable, optional
-        If None, assume zip contains ``setup.py`` at the top level.  Otherwise,
-        find directory containing ``setup.py`` with ``pth =
-        pkg_finder(unzip_path)`` where ``unzip_path`` is the path to which we
-        have unzipped the zip file contents.
-    py_lib_sdir : str, optional
-        subdirectory to which to write the library code from the package.  Thus
-        if package called ``nibabel``, the written code will be in
-        ``<install_path>/<py_lib_sdir>/nibabel
-    script_sdir : str, optional
-        subdirectory to which we write the installed scripts.  Thus scripts will
-        be written to ``<install_path>/<script_sdir>
-    """
-    unzip_path = tempfile.mkdtemp()
-    try:
-        # Zip may unpack module into current directory
-        zip_extract_all(zip_fname, unzip_path)
-        if pkg_finder is None:
-            from_path = unzip_path
-        else:
-            from_path = pkg_finder(unzip_path)
-        install_from_to(from_path, install_path, py_lib_sdir, script_sdir)
-    finally:
-        shutil.rmtree(unzip_path)
-
-
-def contexts_print_info(mod_name, repo_path, install_path):
-    """Print result of get_info from different installation routes
-
-    Runs installation from:
-
-    * git archive zip file
-    * with setup.py install from repository directory
-    * just running code from repository directory
-
-    and prints out result of get_info in each case.  There will be many files
-    written into `install_path` that you may want to clean up somehow.
-
-    Parameters
-    ----------
-    mod_name : str
-       package name that will be installed, and tested
-    repo_path : str
-       path to location of git repository
-    install_path : str
-       path into which to install temporary installations
-    """
-    site_pkgs_path = os.path.join(install_path, PY_LIB_SDIR)
-    # first test archive
-    pwd = os.path.abspath(os.getcwd())
-    out_fname = pjoin(install_path, 'test.zip')
-    try:
-        os.chdir(repo_path)
-        back_tick(f'git archive --format zip -o {out_fname} HEAD')
-    finally:
-        os.chdir(pwd)
-    install_from_zip(out_fname, install_path, None)
-    cmd_str = f'print({mod_name}.get_info())'
-    print(run_mod_cmd(mod_name, site_pkgs_path, cmd_str)[0])
-    # now test install into a directory from the repository
-    install_from_to(repo_path, install_path, PY_LIB_SDIR)
-    print(run_mod_cmd(mod_name, site_pkgs_path, cmd_str)[0])
-    # test from development tree
-    print(run_mod_cmd(mod_name, repo_path, cmd_str)[0])
-
-
-def info_from_here(mod_name):
-    """Run info context checks starting in working directory
-
-    Runs checks from current working directory, installing temporary
-    installations into a new temporary directory
-
-    Parameters
-    ----------
-    mod_name : str
-       package name that will be installed, and tested
-    """
-    repo_path = os.path.abspath(os.getcwd())
-    install_path = tempfile.mkdtemp()
-    try:
-        contexts_print_info(mod_name, repo_path, install_path)
-    finally:
-        shutil.rmtree(install_path)
-
-
-def tests_installed(mod_name, source_path=None):
-    """Install from `source_path` into temporary directory; run tests
-
-    Parameters
-    ----------
-    mod_name : str
-        name of module - e.g. 'nibabel'
-    source_path : None or str
-        Path from which to install.  If None, defaults to working directory
-    """
-    if source_path is None:
-        source_path = os.path.abspath(os.getcwd())
-    install_path = tempfile.mkdtemp()
-    site_pkgs_path = pjoin(install_path, PY_LIB_SDIR)
-    scripts_path = pjoin(install_path, 'bin')
-    try:
-        install_from_to(source_path, install_path, PY_LIB_SDIR, 'bin')
-        stdout, stderr = run_mod_cmd(mod_name, site_pkgs_path, mod_name + '.test()', scripts_path)
-    finally:
-        shutil.rmtree(install_path)
-    print(stdout)
-    print(stderr)
-
-
-# Tell nose this is not a test
-tests_installed.__test__ = False
-
-
-def check_installed_files(repo_mod_path, install_mod_path):
-    """Check files in `repo_mod_path` are installed at `install_mod_path`
-
-    At the moment, all this does is check that all the ``*.py`` files in
-    `repo_mod_path` are installed at `install_mod_path`.
-
-    Parameters
-    ----------
-    repo_mod_path : str
-        repository path containing package files, e.g. <nibabel-repo>/nibabel>
-    install_mod_path : str
-        path at which package has been installed.  This is the path where the
-        root package ``__init__.py`` lives.
-
-    Return
-    ------
-    uninstalled : list
-        list of files that should have been installed, but have not been
-        installed
-    """
-    return missing_from(repo_mod_path, install_mod_path, filter=r'\.py$')
-
-
-def missing_from(path0, path1, filter=None):
-    """Return filenames present in `path0` but not in `path1`
-
-    Parameters
-    ----------
-    path0 : str
-        path which contains all files of interest
-    path1 : str
-        path which should contain all files of interest
-    filter : None or str or regexp, optional
-        A successful result from ``filter.search(fname)`` means the file is of
-        interest.  None means all files are of interest
-
-    Returns
-    -------
-    path1_missing : list
-        list of all files missing from `path1` that are in `path0` at the same
-        relative path.
-    """
-    if not filter is None:
-        filter = re.compile(filter)
-    uninstalled = []
-    # Walk directory tree to get py files
-    for dirpath, dirnames, filenames in os.walk(path0):
-        out_dirpath = dirpath.replace(path0, path1)
-        for fname in filenames:
-            if not filter is None and filter.search(fname) is None:
-                continue
-            equiv_fname = os.path.join(out_dirpath, fname)
-            if not os.path.isfile(equiv_fname):
-                uninstalled.append(pjoin(dirpath, fname))
-    return uninstalled
-
-
-def check_files(mod_name, repo_path=None, scripts_sdir='bin'):
-    """Print library and script files not picked up during install"""
-    if repo_path is None:
-        repo_path = abspath(os.getcwd())
-    install_path = tempfile.mkdtemp()
-    repo_mod_path = pjoin(repo_path, mod_name)
-    installed_mod_path = pjoin(install_path, PY_LIB_SDIR, mod_name)
-    repo_bin = pjoin(repo_path, 'bin')
-    installed_bin = pjoin(install_path, 'bin')
-    try:
-        zip_fname = make_dist(repo_path, install_path, 'sdist --formats=zip', '*.zip')
-        pf = get_sdist_finder(mod_name)
-        install_from_zip(zip_fname, install_path, pf, PY_LIB_SDIR, scripts_sdir)
-        lib_misses = missing_from(repo_mod_path, installed_mod_path, r'\.py$')
-        script_misses = missing_from(repo_bin, installed_bin)
-    finally:
-        shutil.rmtree(install_path)
-    if lib_misses:
-        print('Missed library files: ', ', '.join(lib_misses))
-    else:
-        print('You got all the library files')
-    if script_misses:
-        print('Missed script files: ', ', '.join(script_misses))
-    else:
-        print('You got all the script files')
-    return len(lib_misses) > 0 or len(script_misses) > 0
-
-
-def get_sdist_finder(mod_name):
-    """Return function finding sdist source directory for `mod_name`"""
-
-    def pf(pth):
-        pkg_dirs = glob(pjoin(pth, mod_name + '-*'))
-        if len(pkg_dirs) != 1:
-            raise OSError('There must be one and only one package dir')
-        return pkg_dirs[0]
-
-    return pf
-
-
-def sdist_tests(mod_name, repo_path=None, label='fast', doctests=True):
-    """Make sdist zip, install from it, and run tests"""
-    if repo_path is None:
-        repo_path = abspath(os.getcwd())
-    install_path = tempfile.mkdtemp()
-    try:
-        zip_fname = make_dist(repo_path, install_path, 'sdist --formats=zip', '*.zip')
-        pf = get_sdist_finder(mod_name)
-        install_from_zip(zip_fname, install_path, pf, PY_LIB_SDIR, 'bin')
-        site_pkgs_path = pjoin(install_path, PY_LIB_SDIR)
-        script_path = pjoin(install_path, 'bin')
-        cmd = f"{mod_name}.test(label='{label}', doctests={doctests})"
-        stdout, stderr = run_mod_cmd(mod_name, site_pkgs_path, cmd, script_path)
-    finally:
-        shutil.rmtree(install_path)
-    print(stdout)
-    print(stderr)
-
-
-sdist_tests.__test__ = False
-
-
-def bdist_egg_tests(mod_name, repo_path=None, label='fast', doctests=True):
-    """Make bdist_egg, unzip it, and run tests from result
-
-    We've got a problem here, because the egg does not contain the scripts, and
-    so, if we are testing the scripts with ``mod.test()``, we won't pick up the
-    scripts from the repository we are testing.
-
-    So, you might need to add a label to the script tests, and use the `label`
-    parameter to indicate these should be skipped. As in:
-
-        bdist_egg_tests('nibabel', None, label='not script_test')
-    """
-    if repo_path is None:
-        repo_path = abspath(os.getcwd())
-    install_path = tempfile.mkdtemp()
-    scripts_path = pjoin(install_path, 'bin')
-    try:
-        zip_fname = make_dist(repo_path, install_path, 'bdist_egg', '*.egg')
-        zip_extract_all(zip_fname, install_path)
-        cmd = f"{mod_name}.test(label='{label}', doctests={doctests})"
-        stdout, stderr = run_mod_cmd(mod_name, install_path, cmd, scripts_path)
-    finally:
-        shutil.rmtree(install_path)
-    print(stdout)
-    print(stderr)
-
-
-bdist_egg_tests.__test__ = False
-
-
-def make_dist(repo_path, out_dir, setup_params, zipglob):
-    """Create distutils distribution file
-
-    Parameters
-    ----------
-    repo_path : str
-        path to repository containing code and ``setup.py``
-    out_dir : str
-        path to which to write new distribution file
-    setup_params: str
-        parameters to pass to ``setup.py`` to create distribution.
-    zipglob : str
-        glob identifying expected output file.
-
-    Returns
-    -------
-    out_fname : str
-        filename of generated distribution file
-
-    Examples
-    --------
-    Make, return a zipped sdist::
-
-      make_dist('/path/to/repo', '/tmp/path', 'sdist --formats=zip', '*.zip')
-
-    Make, return a binary egg::
-
-      make_dist('/path/to/repo', '/tmp/path', 'bdist_egg', '*.egg')
-    """
-    pwd = os.path.abspath(os.getcwd())
-    try:
-        os.chdir(repo_path)
-        back_tick(f'{PYTHON} setup.py {setup_params} --dist-dir={out_dir}')
-        zips = glob(pjoin(out_dir, zipglob))
-        if len(zips) != 1:
-            raise OSError(
-                f'There must be one and only one {zipglob} '
-                f"file, but I found \"{': '.join(zips)}\""
-            )
-    finally:
-        os.chdir(pwd)
-    return zips[0]
diff --git a/nisext/tests/__init__.py b/nisext/tests/__init__.py
deleted file mode 100644
index af7d1d1dd2..0000000000
--- a/nisext/tests/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Tests for nisext package
diff --git a/nisext/tests/test_sexts.py b/nisext/tests/test_sexts.py
deleted file mode 100644
index f262ec5685..0000000000
--- a/nisext/tests/test_sexts.py
+++ /dev/null
@@ -1,106 +0,0 @@
-"""Tests for nisexts.sexts module
-"""
-
-import sys
-import types
-
-import pytest
-
-from ..sexts import package_check
-
-FAKE_NAME = 'nisext_improbable'
-assert FAKE_NAME not in sys.modules
-FAKE_MODULE = types.ModuleType('nisext_fake')
-
-
-def test_package_check():
-    # Try to use a required package - raise error
-    with pytest.raises(RuntimeError):
-        package_check(FAKE_NAME)
-    # Optional, log.warn
-    package_check(FAKE_NAME, optional=True)
-    # Can also pass a string
-    package_check(FAKE_NAME, optional='some-package')
-    try:
-        # Make a package
-        sys.modules[FAKE_NAME] = FAKE_MODULE
-        # Now it passes if we don't check the version
-        package_check(FAKE_NAME)
-        # A fake version
-        FAKE_MODULE.__version__ = '0.2'
-        package_check(FAKE_NAME, version='0.2')
-        # fails when version not good enough
-        with pytest.raises(RuntimeError):
-            package_check(FAKE_NAME, '0.3')
-        # Unless optional in which case log.warns
-        package_check(FAKE_NAME, version='0.3', optional=True)
-        # Might do custom version check
-        package_check(FAKE_NAME, version='0.2', version_getter=lambda x: '0.2')
-    finally:
-        del sys.modules[FAKE_NAME]
-
-
-def test_package_check_setuptools():
-    # If setuptools arg not None, missing package just adds it to arg
-    with pytest.raises(RuntimeError):
-        package_check(FAKE_NAME, setuptools_args=None)
-
-    def pkg_chk_sta(*args, **kwargs):
-        st_args = {}
-        package_check(*args, setuptools_args=st_args, **kwargs)
-        return st_args
-
-    assert pkg_chk_sta(FAKE_NAME) == {'install_requires': ['nisext_improbable']}
-    # Check that this gets appended to existing value
-    old_sta = {'install_requires': ['something']}
-    package_check(FAKE_NAME, setuptools_args=old_sta)
-    assert old_sta == {'install_requires': ['something', 'nisext_improbable']}
-    # That existing value as string gets converted to a list
-    old_sta = {'install_requires': 'something'}
-    package_check(FAKE_NAME, setuptools_args=old_sta)
-    assert old_sta == {'install_requires': ['something', 'nisext_improbable']}
-    # Optional, add to extras_require
-    assert pkg_chk_sta(FAKE_NAME, optional='something') == {
-        'extras_require': {'something': ['nisext_improbable']}
-    }
-    # Check that this gets appended to existing value
-    old_sta = {'extras_require': {'something': ['amodule']}}
-    package_check(FAKE_NAME, optional='something', setuptools_args=old_sta)
-    assert old_sta == {'extras_require': {'something': ['amodule', 'nisext_improbable']}}
-    # That string gets converted to a list here too
-    old_sta = {'extras_require': {'something': 'amodule'}}
-    package_check(FAKE_NAME, optional='something', setuptools_args=old_sta)
-    assert old_sta == {'extras_require': {'something': ['amodule', 'nisext_improbable']}}
-    # But optional has to be a string if not empty and setuptools_args defined
-    with pytest.raises(RuntimeError):
-        package_check(FAKE_NAME, optional=True, setuptools_args={})
-    try:
-        # Make a package
-        sys.modules[FAKE_NAME] = FAKE_MODULE
-        # No install_requires because we already have it
-        assert pkg_chk_sta(FAKE_NAME) == {}
-        # A fake version still works
-        FAKE_MODULE.__version__ = '0.2'
-        assert pkg_chk_sta(FAKE_NAME, version='0.2') == {}
-        # goes into install requires when version not good enough
-        exp_spec = [FAKE_NAME + '>=0.3']
-        assert pkg_chk_sta(FAKE_NAME, version='0.3') == {'install_requires': exp_spec}
-        # Unless optional in which case goes into extras_require
-        package_check(FAKE_NAME, version='0.2', version_getter=lambda x: '0.2')
-        assert pkg_chk_sta(FAKE_NAME, version='0.3', optional='afeature') == {
-            'extras_require': {'afeature': exp_spec}
-        }
-        # Might do custom version check
-        assert pkg_chk_sta(FAKE_NAME, version='0.2', version_getter=lambda x: '0.2') == {}
-        # If the version check fails, put into requires
-        bad_getter = lambda x: x.not_an_attribute
-        exp_spec = [FAKE_NAME + '>=0.2']
-        assert pkg_chk_sta(FAKE_NAME, version='0.2', version_getter=bad_getter) == {
-            'install_requires': exp_spec
-        }
-        # Likewise for optional dependency
-        assert pkg_chk_sta(
-            FAKE_NAME, version='0.2', optional='afeature', version_getter=bad_getter
-        ) == {'extras_require': {'afeature': [FAKE_NAME + '>=0.2']}}
-    finally:
-        del sys.modules[FAKE_NAME]
diff --git a/nisext/tests/test_testers.py b/nisext/tests/test_testers.py
deleted file mode 100644
index f81a40f1df..0000000000
--- a/nisext/tests/test_testers.py
+++ /dev/null
@@ -1,35 +0,0 @@
-"""Tests for testers
-"""
-
-import os
-from os.path import dirname, pathsep
-
-import pytest
-
-from ..testers import PYTHON, back_tick, run_mod_cmd
-
-
-def test_back_tick():
-    cmd = f'{PYTHON} -c "print(\'Hello\')"'
-    assert back_tick(cmd) == 'Hello'
-    assert back_tick(cmd, ret_err=True) == ('Hello', '')
-    assert back_tick(cmd, True, False) == (b'Hello', b'')
-    cmd = f'{PYTHON} -c "raise ValueError()"'
-    with pytest.raises(RuntimeError):
-        back_tick(cmd)
-
-
-def test_run_mod_cmd():
-    mod = 'os'
-    mod_dir = dirname(os.__file__)
-    assert run_mod_cmd(mod, mod_dir, "print('Hello')", None, False) == ('Hello', '')
-    sout, serr = run_mod_cmd(mod, mod_dir, "print('Hello again')")
-    assert serr == ''
-    mod_file, out_str = [s.strip() for s in sout.split('\n')]
-    assert mod_file.startswith(mod_dir)
-    assert out_str == 'Hello again'
-    sout, serr = run_mod_cmd(mod, mod_dir, "print(os.environ['PATH'])", None, False)
-    assert serr == ''
-    sout2, serr = run_mod_cmd(mod, mod_dir, "print(os.environ['PATH'])", 'pth2', False)
-    assert serr == ''
-    assert sout2 == '"pth2"' + pathsep + sout
diff --git a/pyproject.toml b/pyproject.toml
index 65104ff137..b6b420c79c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -9,8 +9,13 @@ authors = [{ name = "NiBabel developers", email = "neuroimaging@python.org" }]
 maintainers = [{ name = "Christopher Markiewicz" }]
 readme = "README.rst"
 license = { text = "MIT License" }
-requires-python = ">=3.8"
-dependencies = ["numpy >=1.19", "packaging >=17", "setuptools"]
+requires-python = ">=3.9"
+dependencies = [
+  "numpy >=1.23",
+  "packaging >=20",
+  "importlib_resources >=5.12; python_version < '3.12'",
+  "typing_extensions >=4.6; python_version < '3.13'",
+]
 classifiers = [
   "Development Status :: 5 - Production/Stable",
   "Environment :: Console",
@@ -18,10 +23,11 @@ classifiers = [
   "License :: OSI Approved :: MIT License",
   "Operating System :: OS Independent",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
   "Topic :: Scientific/Engineering",
 ]
 # Version from setuptools_scm
@@ -45,31 +51,37 @@ nib-roi = "nibabel.cmdline.roi:main"
 parrec2nii = "nibabel.cmdline.parrec2nii:main"
 
 [project.optional-dependencies]
-all = ["nibabel[dicomfs,dev,doc,minc2,spm,style,test,zstd]"]
-dev = ["gitpython", "twine", "nibabel[style]"]
-dicom = ["pydicom >=1.0.0"]
-dicomfs = ["nibabel[dicom]", "pillow"]
+all = ["nibabel[dicomfs,indexed_gzip,minc2,spm,zstd]"]
+# Features
+indexed_gzip = ["indexed_gzip >=1.6"]
+dicom = ["pydicom >=2.3"]
+dicomfs = ["nibabel[dicom]", "pillow >=8.4"]
+minc2 = ["h5py >=3.5"]
+spm = ["scipy >=1.8"]
+viewers = ["matplotlib >=3.5"]
+zstd = ["pyzstd >=0.15.2"]
+# For doc and test, make easy to use outside of tox
+# tox should use these with extras instead of duplicating
 doc = [
-  "matplotlib >= 1.5.3",
+  "sphinx",
+  "matplotlib>=3.5",
   "numpydoc",
-  "sphinx ~= 5.3",
   "texext",
-  "tomli; python_version < \"3.11\"",
+  "tomli; python_version < '3.11'",
 ]
-doctest = ["nibabel[doc,test]"]
-minc2 = ["h5py"]
-spm = ["scipy"]
-style = ["flake8", "blue", "isort"]
 test = [
-  "coverage",
-  "pytest !=5.3.4",
-  "pytest-cov",
-  "pytest-doctestplus",
-  "pytest-httpserver",
-  "pytest-xdist",
+  "pytest >=6",
+  "pytest-doctestplus >=1",
+  "pytest-cov >=2.11",
+  "pytest-httpserver >=1.0.7",
+  "pytest-xdist >=3.5",
+  "coverage[toml]>=7.2",
 ]
-typing = ["mypy", "pytest", "types-setuptools", "types-Pillow", "pydicom"]
-zstd = ["pyzstd >= 0.14.3"]
+# Remaining: Simpler to centralize in tox
+dev = ["tox"]
+doctest = ["tox"]
+style = ["tox"]
+typing = ["tox"]
 
 [tool.hatch.build.targets.sdist]
 exclude = [
@@ -79,7 +91,7 @@ exclude = [
 ]
 
 [tool.hatch.build.targets.wheel]
-packages = ["nibabel", "nisext"]
+packages = ["nibabel"]
 exclude = [
   # 56MB test file does not need to be installed everywhere
   "nibabel/nicom/tests/data/4d_multiframe_test.dcm",
@@ -87,29 +99,105 @@ exclude = [
 
 [tool.hatch.version]
 source = "vcs"
+tag-pattern = '(?P<version>\d+(?:\.\d+){0,2}[^+]*)(?:\+.*)?$'
 raw-options = { version_scheme = "release-branch-semver" }
 
 [tool.hatch.build.hooks.vcs]
 version-file = "nibabel/_version.py"
+# Old default setuptools_scm template; hatch-vcs currently causes
+# a noisy warning if template is missing.
+template = '''
+# file generated by setuptools_scm
+# don't change, don't track in version control
+__version__ = version = {version!r}
+__version_tuple__ = version_tuple = {version_tuple!r}
+'''
+
+[tool.ruff]
+line-length = 99
+exclude = ["doc", "nibabel/externals", "tools", "version.py", "versioneer.py"]
 
-[tool.blue]
-line_length = 99
-target-version = ["py37"]
-force-exclude = """
-(
-  _version.py
-  | nibabel/externals/
-  | versioneer.py
-)
-"""
+[tool.ruff.lint]
+select = [
+    "B",
+    "C4",
+    "F",
+    "FLY",
+    "FURB",
+    "I",
+    "ISC",
+    "PERF",
+    "PGH",
+    "PIE",
+    "PLE",
+    "PT",
+    "PYI",
+    "Q",
+    "RSE",
+    "RUF",
+    "TCH",
+    "UP",
+]
+ignore = [
+    "B006",   # TODO: enable
+    "B008",   # TODO: enable
+    "B007",
+    "B011",
+    "B017",   # TODO: enable
+    "B018",
+    "B020",
+    "B023",   # TODO: enable
+    "B028",
+    "B904",
+    "C401",
+    "C408",
+    "C416",
+    "PERF203",
+    "PIE790",
+    "PT007",
+    "PT011",
+    "PT012",
+    "PT017",
+    "PT018",
+    "PYI024",
+    "RUF005",
+    "RUF012", # TODO: enable
+    "RUF015",
+    "RUF017", # TODO: enable
+    "UP038",  # https://github.com/astral-sh/ruff/issues/7871
+    # https://docs.astral.sh/ruff/formatter/#conflicting-lint-rules
+    "W191",
+    "E111",
+    "E114",
+    "E117",
+    "D206",
+    "D300",
+    "Q000",
+    "Q001",
+    "Q002",
+    "Q003",
+    "COM812",
+    "COM819",
+]
 
-[tool.isort]
-profile = "black"
-line_length = 99
-extend_skip = ["_version.py", "externals"]
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]
+"doc/source/conf.py" = ["F401"]
+
+[tool.ruff.format]
+quote-style = "single"
 
 [tool.mypy]
 python_version = "3.11"
 exclude = [
   "/tests",
 ]
+warn_unreachable = true
+enable_error_code = ["ignore-without-code", "redundant-expr", "truthy-bool"]
+
+[tool.codespell]
+skip = "*/data/*,./nibabel-data"
+ignore-words-list = "ans,te,ue,ist,nin,nd,ccompiler,ser"
+
+[tool.uv.pip]
+only-binary = ["numpy", "scipy", "h5py"]
diff --git a/requirements.txt b/requirements.txt
index 1d1e434609..c65baf5cb8 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,5 @@
 # Auto-generated by tools/update_requirements.py
-numpy >=1.19
-packaging >=17
-setuptools
+numpy >=1.22
+packaging >=20
+importlib_resources >=5.12; python_version < '3.12'
+typing_extensions >=4.6; python_version < '3.13'
diff --git a/tools/ci/activate.sh b/tools/ci/activate.sh
deleted file mode 100644
index 567e13a67b..0000000000
--- a/tools/ci/activate.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-if [ -e virtenv/bin/activate ]; then
-    source virtenv/bin/activate
-elif [ -e virtenv/Scripts/activate ]; then
-    source virtenv/Scripts/activate
-else
-    echo Cannot activate virtual environment
-    ls -R virtenv
-    false
-fi
diff --git a/tools/ci/build_archive.sh b/tools/ci/build_archive.sh
deleted file mode 100755
index 3c25012e1b..0000000000
--- a/tools/ci/build_archive.sh
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-
-echo "Building archive"
-
-source tools/ci/activate.sh
-
-set -eu
-
-# Required dependencies
-echo "INSTALL_TYPE = $INSTALL_TYPE"
-
-set -x
-
-if [ "$INSTALL_TYPE" = "sdist" -o "$INSTALL_TYPE" = "wheel" ]; then
-    python -m build
-elif [ "$INSTALL_TYPE" = "archive" ]; then
-    ARCHIVE="/tmp/package.tar.gz"
-    git archive -o $ARCHIVE HEAD
-fi
-
-if [ "$INSTALL_TYPE" = "sdist" ]; then
-    ARCHIVE=$( ls $PWD/dist/*.tar.gz )
-elif [ "$INSTALL_TYPE" = "wheel" ]; then
-    ARCHIVE=$( ls $PWD/dist/*.whl )
-elif [ "$INSTALL_TYPE" = "pip" ]; then
-    ARCHIVE="$PWD"
-fi
-
-export ARCHIVE
-
-set +eux
diff --git a/tools/ci/check.sh b/tools/ci/check.sh
deleted file mode 100755
index bcb1a934e2..0000000000
--- a/tools/ci/check.sh
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/bin/bash
-
-echo Running tests
-
-source tools/ci/activate.sh
-
-set -eu
-
-# Required variables
-echo CHECK_TYPE = $CHECK_TYPE
-
-set -x
-
-export NIBABEL_DATA_DIR="$PWD/nibabel-data"
-
-if [ "${CHECK_TYPE}" == "style" ]; then
-    # Run styles only on core nibabel code.
-    flake8 nibabel
-elif [ "${CHECK_TYPE}" == "doctest" ]; then
-    make -C doc html && make -C doc doctest
-elif [ "${CHECK_TYPE}" == "test" ]; then
-    # Change into an innocuous directory and find tests from installation
-    mkdir for_testing
-    cd for_testing
-    cp ../.coveragerc .
-    pytest --doctest-modules --doctest-plus --cov nibabel --cov-report xml \
-        --junitxml=test-results.xml -v --pyargs nibabel -n auto
-elif [ "${CHECK_TYPE}" == "typing" ]; then
-    mypy nibabel
-else
-    false
-fi
-
-set +eux
-
-echo Done running tests
diff --git a/tools/ci/create_venv.sh b/tools/ci/create_venv.sh
deleted file mode 100755
index 7a28767396..0000000000
--- a/tools/ci/create_venv.sh
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/bin/bash
-
-echo Creating isolated virtual environment
-
-source tools/ci/env.sh
-
-set -eu
-
-# Required variables
-echo SETUP_REQUIRES = $SETUP_REQUIRES
-
-set -x
-
-python -m pip install --upgrade pip virtualenv
-virtualenv --python=python virtenv
-source tools/ci/activate.sh
-python --version
-python -m pip install -U $SETUP_REQUIRES
-which python
-which pip
-
-set +eux
-
-echo Done creating isolated virtual environment
diff --git a/tools/ci/env.sh b/tools/ci/env.sh
deleted file mode 100644
index dd29443126..0000000000
--- a/tools/ci/env.sh
+++ /dev/null
@@ -1,17 +0,0 @@
-SETUP_REQUIRES="pip build"
-
-# Minimum requirements
-REQUIREMENTS="-r requirements.txt"
-# Minimum versions of minimum requirements
-MIN_REQUIREMENTS="-r min-requirements.txt"
-
-DEFAULT_OPT_DEPENDS="scipy matplotlib pillow pydicom h5py indexed_gzip pyzstd"
-# pydicom has skipped some important pre-releases, so enable a check against master
-PYDICOM_MASTER="git+https://github.com/pydicom/pydicom.git@master"
-# Minimum versions of optional requirements
-MIN_OPT_DEPENDS="matplotlib==1.5.3 pydicom==1.0.1 pillow==2.6"
-
-# Numpy and scipy upload nightly/weekly/intermittent wheels
-NIGHTLY_WHEELS="https://pypi.anaconda.org/scipy-wheels-nightly/simple"
-STAGING_WHEELS="https://pypi.anaconda.org/multibuild-wheels-staging/simple"
-PRE_PIP_FLAGS="--pre --extra-index-url $NIGHTLY_WHEELS --extra-index-url $STAGING_WHEELS"
diff --git a/tools/ci/install.sh b/tools/ci/install.sh
deleted file mode 100755
index c0c3b23e67..0000000000
--- a/tools/ci/install.sh
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/bin/bash
-
-echo Installing nibabel
-
-source tools/ci/activate.sh
-source tools/ci/env.sh
-
-set -eu
-
-# Required variables
-echo INSTALL_TYPE = $INSTALL_TYPE
-echo CHECK_TYPE = $CHECK_TYPE
-echo EXTRA_PIP_FLAGS = $EXTRA_PIP_FLAGS
-
-set -x
-
-if [ -n "$EXTRA_PIP_FLAGS" ]; then
-    EXTRA_PIP_FLAGS=${!EXTRA_PIP_FLAGS}
-fi
-
-(
-  # Ensure installation does not depend on being in source tree
-  mkdir ../unversioned_install_dir
-  cd ../unversioned_install_dir
-  pip install $EXTRA_PIP_FLAGS $ARCHIVE
-
-  # Basic import check
-  python -c 'import nibabel; print(nibabel.__version__)'
-)
-
-if [ "$CHECK_TYPE" == "skiptests" ]; then
-    exit 0
-fi
-
-pip install $EXTRA_PIP_FLAGS "nibabel[$CHECK_TYPE]"
-
-set +eux
-
-echo Done installing nibabel
diff --git a/tools/ci/install_dependencies.sh b/tools/ci/install_dependencies.sh
deleted file mode 100755
index f26c5204c0..0000000000
--- a/tools/ci/install_dependencies.sh
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/bin/bash
-
-echo Installing dependencies
-
-source tools/ci/activate.sh
-source tools/ci/env.sh
-
-set -eu
-
-# Required variables
-echo EXTRA_PIP_FLAGS = $EXTRA_PIP_FLAGS
-echo DEPENDS = $DEPENDS
-echo OPTIONAL_DEPENDS = $OPTIONAL_DEPENDS
-
-set -x
-
-if [ -n "$EXTRA_PIP_FLAGS" ]; then
-    EXTRA_PIP_FLAGS=${!EXTRA_PIP_FLAGS}
-fi
-
-if [ -n "$DEPENDS" ]; then
-    pip install ${EXTRA_PIP_FLAGS} --prefer-binary ${!DEPENDS}
-    if [ -n "$OPTIONAL_DEPENDS" ]; then
-        for DEP in ${!OPTIONAL_DEPENDS}; do
-            pip install ${EXTRA_PIP_FLAGS} --prefer-binary $DEP || true
-	done
-    fi
-fi
-
-set +eux
-
-echo Done installing dependencies
diff --git a/tools/ci/submit_coverage.sh b/tools/ci/submit_coverage.sh
deleted file mode 100755
index 17bfe3933b..0000000000
--- a/tools/ci/submit_coverage.sh
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/bin/bash
-
-echo Submitting coverage
-
-source tools/ci/activate.sh
-
-set -eu
-
-set -x
-
-COVERAGE_FILE="for_testing/coverage.xml"
-
-if [ -e "$COVERAGE_FILE" ]; then
-    # Pin codecov version to reduce scope for malicious updates
-    python -m pip install "codecov==2.1.11"
-    python -m codecov --file for_testing/coverage.xml
-fi
-
-set +eux
-
-echo Done submitting coverage
diff --git a/tools/gitwash_dumper.py b/tools/gitwash_dumper.py
index cabff5c0af..7472658ecd 100755
--- a/tools/gitwash_dumper.py
+++ b/tools/gitwash_dumper.py
@@ -223,7 +223,7 @@ def main():
             out_path,
             cp_globs=(pjoin('gitwash', '*'),),
             rep_globs=('*.rst',),
-            renames=(('\.rst$', options.source_suffix),),
+            renames=((r'\.rst$', options.source_suffix),),
         )
         make_link_targets(
             project_name,
diff --git a/tools/make_tarball.py b/tools/make_tarball.py
index 3cdad40d0b..b49a1f276a 100755
--- a/tools/make_tarball.py
+++ b/tools/make_tarball.py
@@ -5,7 +5,7 @@
 import os
 
 import commands
-from toollib import *
+from toollib import c, cd
 
 tag = commands.getoutput('git describe')
 base_name = f'nibabel-{tag}'
diff --git a/tools/markdown_release_notes.py b/tools/markdown_release_notes.py
new file mode 100644
index 0000000000..cdae474f51
--- /dev/null
+++ b/tools/markdown_release_notes.py
@@ -0,0 +1,140 @@
+#!/usr/bin/env python
+import re
+import sys
+from collections import defaultdict
+from functools import cache
+from operator import call
+from pathlib import Path
+
+from sphinx.ext.intersphinx import fetch_inventory
+
+CHANGELOG = Path(__file__).parent.parent / 'Changelog'
+
+# Match release lines like "5.2.0 (Monday 11 December 2023)"
+RELEASE_REGEX = re.compile(r"""((?:\d+)\.(?:\d+)\.(?:\d+)) \(\w+ \d{1,2} \w+ \d{4}\)$""")
+
+
+class MockConfig:
+    intersphinx_timeout: int | None = None
+    tls_verify = False
+    tls_cacerts: str | dict[str, str] | None = None
+    user_agent: str = ''
+
+
+@call
+class MockApp:
+    srcdir = ''
+    config = MockConfig()
+
+
+fetch_inv = cache(fetch_inventory)
+
+
+def get_intersphinx(obj):
+    module = obj.split('.', 1)[0]
+
+    registry = defaultdict(lambda: 'https://docs.python.org/3')
+    registry.update(
+        numpy='https://numpy.org/doc/stable',
+    )
+
+    base_url = registry[module]
+
+    inventory = fetch_inv(MockApp, '', f'{base_url}/objects.inv')
+    # Check py: first, then whatever
+    for objclass in sorted(inventory, key=lambda x: not x.startswith('py:')):
+        if obj in inventory[objclass]:
+            return f'{base_url}/{inventory[objclass][obj][2]}'
+    raise ValueError("Couldn't lookup {obj}")
+
+
+def main():
+    version = sys.argv[1]
+    output = sys.argv[2]
+    if output == '-':
+        output = sys.stdout
+    else:
+        output = open(output, 'w')
+
+    release_notes = []
+    in_release_notes = False
+
+    with open(CHANGELOG) as f:
+        for line in f:
+            match = RELEASE_REGEX.match(line)
+            if match:
+                if in_release_notes:
+                    break
+                in_release_notes = match.group(1) == version
+                next(f)  # Skip the underline
+                continue
+
+            if in_release_notes:
+                release_notes.append(line)
+
+    # Drop empty lines at start and end
+    while release_notes and not release_notes[0].strip():
+        release_notes.pop(0)
+    while release_notes and not release_notes[-1].strip():
+        release_notes.pop()
+
+    # Join lines
+    release_notes = ''.join(release_notes)
+
+    # Remove line breaks when they are followed by a space
+    release_notes = re.sub(r'\n +', ' ', release_notes)
+
+    # Replace pr/<number> with #<number> for GitHub
+    release_notes = re.sub(r'pr/(\d+)', r'#\1', release_notes)
+
+    # Replace :mod:`package.X` with [package.X](...)
+    release_notes = re.sub(
+        r':mod:`nibabel\.(.*)`',
+        r'[nibabel.\1](https://nipy.org/nibabel/reference/nibabel.\1.html)',
+        release_notes,
+    )
+    # Replace :class/func/attr:`package.module.X` with [package.module.X](...)
+    release_notes = re.sub(
+        r':(?:class|func|attr):`(nibabel\.\w*)(\.[\w.]*)?\.(\w+)`',
+        r'[\1\2.\3](https://nipy.org/nibabel/reference/\1.html#\1\2.\3)',
+        release_notes,
+    )
+    release_notes = re.sub(
+        r':(?:class|func|attr):`~(nibabel\.\w*)(\.[\w.]*)?\.(\w+)`',
+        r'[\3](https://nipy.org/nibabel/reference/\1.html#\1\2.\3)',
+        release_notes,
+    )
+    # Replace :meth:`package.module.class.X` with [package.module.class.X](...)
+    release_notes = re.sub(
+        r':meth:`(nibabel\.[\w.]*)\.(\w+)\.(\w+)`',
+        r'[\1.\2.\3](https://nipy.org/nibabel/reference/\1.html#\1.\2.\3)',
+        release_notes,
+    )
+    release_notes = re.sub(
+        r':meth:`~(nibabel\.[\w.]*)\.(\w+)\.(\w+)`',
+        r'[\3](https://nipy.org/nibabel/reference/\1.html#\1.\2.\3)',
+        release_notes,
+    )
+    # Replace :<any>:`<ref>` with intersphinx lookup
+    for ref in re.findall(r'(:[^:]*:`~?\w[\w.]+\w`)', release_notes):
+        objclass, tilde, module, obj = re.match(r':([^:]*):`(~?)([\w.]+)\.(\w+)`', ref).groups()
+        url = get_intersphinx(f'{module}.{obj}')
+        mdlink = f'[{"" if tilde else module}{obj}]({url})'
+        release_notes = release_notes.replace(ref, mdlink)
+    # Replace RST links with Markdown links
+    release_notes = re.sub(r'`([^<`]*) <([^>]*)>`_+', r'[\1](\2)', release_notes)
+
+    def python_doc(match):
+        module = match.group(1)
+        name = match.group(2)
+        return f'[{name}](https://docs.python.org/3/library/{module.lower()}.html#{module}.{name})'
+
+    release_notes = re.sub(r':meth:`~([\w.]+)\.(\w+)`', python_doc, release_notes)
+
+    with output:
+        output.write('## Release notes\n\n')
+        output.write(release_notes)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/mpkg_wrapper.py b/tools/mpkg_wrapper.py
index 0a96156e4d..f5f059b28d 100644
--- a/tools/mpkg_wrapper.py
+++ b/tools/mpkg_wrapper.py
@@ -24,7 +24,7 @@ def main():
     g = dict(globals())
     g['__file__'] = sys.argv[0]
     g['__name__'] = '__main__'
-    execfile(sys.argv[0], g, g)
+    exec(open(sys.argv[0]).read(), g, g)
 
 
 if __name__ == '__main__':
diff --git a/tools/update_requirements.py b/tools/update_requirements.py
index eb0343bd78..13709b22e8 100755
--- a/tools/update_requirements.py
+++ b/tools/update_requirements.py
@@ -2,7 +2,10 @@
 import sys
 from pathlib import Path
 
-import tomli
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
 
 if sys.version_info < (3, 6):
     print('This script requires Python 3.6 to work correctly')
@@ -15,7 +18,7 @@
 doc_reqs = repo_root / 'doc-requirements.txt'
 
 with open(pyproject_toml, 'rb') as fobj:
-    config = tomli.load(fobj)
+    config = tomllib.load(fobj)
 requirements = config['project']['dependencies']
 doc_requirements = config['project']['optional-dependencies']['doc']
 
@@ -27,9 +30,10 @@
 lines[1:-1] = requirements
 reqs.write_text('\n'.join(lines))
 
-# Write minimum requirements
-lines[1:-1] = [req.replace('>=', '==').replace('~=', '==') for req in requirements]
-min_reqs.write_text('\n'.join(lines))
+# # Write minimum requirements
+# lines[1:-1] = [req.replace('>=', '==').replace('~=', '==') for req in requirements]
+# min_reqs.write_text('\n'.join(lines))
+print(f"To update {min_reqs.name}, use `uv pip compile` (see comment at top of file).")
 
 # Write documentation requirements
 lines[1:-1] = ['-r requirements.txt'] + doc_requirements
diff --git a/tox.ini b/tox.ini
index a0002e12b6..42ec48a6b6 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,20 +1,211 @@
+# This file encodes a lot of our intended support range, as well as some
+# details about dependency availability.
+#
+# The majority of the information is contained in tox.envlist and testenv.deps.
 [tox]
-# From-scratch tox-default-name virtualenvs
-envlist = py25,py26,py27,py32
+requires =
+  tox>=4
+  tox-uv
+envlist =
+  # No preinstallations
+  py3{9,10,11,12,13,13t}-none
+  # Minimum Python with minimum deps
+  py39-min
+  # Run full and pre dependencies against all archs
+  py3{9,10,11,12,13,13t}-{full,pre}-{x86,x64,arm64}
+  install
+  doctest
+  style
+  typecheck
+skip_missing_interpreters = true
+
+# Configuration that allows us to split tests across GitHub runners effectively
+[gh-actions]
+python =
+  3.9: py39
+  3.10: py310
+  3.11: py311
+  3.12: py312
+  3.13: py313
+  3.13t: py313t
+
+[gh-actions:env]
+DEPENDS =
+  none: none
+  pre: pre
+  full: full, install
+  min: min
+
+ARCH =
+  x64: x64
+  x86: x86
+  arm64: arm64
+
 [testenv]
+description = Pytest with coverage
+labels = test
+pip_pre =
+  pre: true
+pass_env =
+  # getpass.getuser() sources for Windows:
+  LOGNAME
+  USER
+  LNAME
+  USERNAME
+  # Environment variables we check for
+  NIPY_EXTRA_TESTS
+  # Pass user color preferences through
+  PY_COLORS
+  FORCE_COLOR
+  NO_COLOR
+  CLICOLOR
+  CLICOLOR_FORCE
+  # uv needs help in this case
+  py313t-x86: UV_PYTHON
+set_env =
+  pre: PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple
+  pre: UV_INDEX=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple
+  pre: UV_INDEX_STRATEGY=unsafe-best-match
+  py313t: PYTHONGIL={env:PYTHONGIL:0}
+extras =
+  test
+
+  # Simple, thanks Hugo and Paul
+  !none: dicomfs
+  !none: indexed_gzip
+
+  # Minimum dependencies
+  min: minc2
+  min: spm
+  min: viewers
+  min: zstd
+
+  # Matplotlib has wheels for everything except win32 (x86)
+  {full,pre}-{x,arm}64: viewers
+
+  # Nightly, but not released cp313t wheels for: scipy
+  # When released, remove the py3* line and add full to the pre line
+  py3{9,10,11,12,13}-full-{x,arm}64: spm
+  pre-{x,arm}64: spm
+
+  # No cp313t wheels for: h5py, pyzstd
+  py3{9,10,11,12,13}-{full,pre}-{x,arm}64: minc2
+  py3{9,10,11,12,13}-{full,pre}-{x,arm}64: zstd
+
+  # win32 (x86) wheels still exist for scipy+py39
+  py39-full-x86: spm
+
 deps =
-    nose
-    numpy
-commands=nosetests --with-doctest
-# MBs virtualenvs; numpy, nose already installed.  Run these with:
-# tox -e python25,python26,python27,python32,np-1.2.1
-[testenv:python25]
+  pre: pydicom @ git+https://github.com/pydicom/pydicom.git@main
+
+uv_resolution =
+  min: lowest-direct
+
+commands =
+  pytest --doctest-modules --doctest-plus \
+    --cov nibabel --cov-report xml:cov.xml \
+    --junitxml test-results.xml \
+    --durations=20 --durations-min=1.0 \
+    --pyargs nibabel {posargs:-n auto}
+
+[testenv:install]
+description = Install and verify import succeeds
+labels = test
 deps =
-[testenv:python26]
+extras =
+commands =
+  python -c "import nibabel; print(nibabel.__version__)"
+
+[testenv:docs]
+description = Build documentation site
+labels = docs
+allowlist_externals = make
+extras = doc
+commands =
+  make -C doc html
+
+[testenv:doctest]
+description = Run doctests in documentation site
+labels = docs
+allowlist_externals = make
+extras =
+  doc
+  test
+commands =
+  make -C doc doctest
+
+[testenv:style]
+description = Check our style guide
+labels = check
 deps =
-[testenv:python27]
+  ruff>=0.3.0
+skip_install = true
+commands =
+  ruff check --diff nibabel
+  ruff format --diff nibabel
+
+[testenv:style-fix]
+description = Auto-apply style guide to the extent possible
+labels = pre-release
 deps =
-[testenv:python32]
+  ruff
+skip_install = true
+commands =
+  ruff check --fix nibabel
+  ruff format nibabel
+
+[testenv:spellcheck]
+description = Check spelling
+labels = check
 deps =
-[testenv:np-1.2.1]
+  codespell[toml]
+skip_install = true
+commands =
+  codespell . {posargs}
+
+[testenv:typecheck]
+description = Check type consistency
+labels = check
 deps =
+  mypy
+  pytest
+  types-setuptools
+  types-Pillow
+  pydicom
+  numpy
+  pyzstd
+  importlib_resources
+  typing_extensions
+skip_install = true
+commands =
+  mypy nibabel
+
+[testenv:build{,-strict}]
+labels =
+  check
+  pre-release
+deps =
+  build
+  twine
+skip_install = true
+set_env =
+  build-strict: PYTHONWARNINGS=error
+commands =
+  python -m build
+  python -m twine check dist/*
+
+[testenv:publish]
+depends = build
+labels = release
+deps =
+  twine
+skip_install = true
+commands =
+  python -m twine upload dist/*
+
+[testenv:zenodo]
+deps = gitpython
+labels = pre-release
+skip_install = true
+commands =
+  python tools/prep_zenodo.py
