diff --git a/.circleci/version.py b/.circleci/version.py
index 8bbac435c3..cbaaacb31b 100644
--- a/.circleci/version.py
+++ b/.circleci/version.py
@@ -1,4 +1,5 @@
 """Get sdcflows version."""
+
 import sdcflows
 
-print(sdcflows.__version__, end="", file=open("/tmp/.docker-version.txt", "w"))
+print(sdcflows.__version__, end='', file=open('/tmp/.docker-version.txt', 'w'))
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 0000000000..fe21fefa26
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,6 @@
+# Thu May 15 09:29:29 2025 -0400 - markiewicz@stanford.edu - run: ruff format [ignore-rev]
+d97ae316c0bdf71084a0732760ceed5221033fc2
+# Thu May 15 09:26:57 2025 -0400 - markiewicz@stanford.edu - run: ruff check --fix [ignore-rev]
+cacd409cce71f2e530ad1bd1e8b79f397cab81d4
+# Thu May 15 09:22:00 2025 -0400 - markiewicz@stanford.edu - run: pre-commit run --all [ignore-rev]
+2b40bee0d6b2c88628760a8b1513851a439411e8
diff --git a/.git_archival.txt b/.git_archival.txt
index b1a286bbb6..8fb235d704 100644
--- a/.git_archival.txt
+++ b/.git_archival.txt
@@ -1,4 +1,4 @@
 node: $Format:%H$
 node-date: $Format:%cI$
 describe-name: $Format:%(describe:tags=true,match=*[0-9]*)$
-ref-names: $Format:%D$
\ No newline at end of file
+ref-names: $Format:%D$
diff --git a/.github/workflows/validate.yml b/.github/workflows/validate.yml
index bd8b7c2b0c..a3e3eae35a 100644
--- a/.github/workflows/validate.yml
+++ b/.github/workflows/validate.yml
@@ -17,11 +17,12 @@ permissions:
   contents: read
 
 jobs:
-  flake8:
+  style:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
-    - run: pipx run flake8-pyproject sdcflows/
+    - run: pipx run ruff check sdcflows/
+    - run: pipx run ruff format --diff sdcflows/
 
   # codespell:
   #   runs-on: ubuntu-latest
diff --git a/.maint/update_authors.py b/.maint/update_authors.py
index 0ca78d4993..48fe34eed0 100644
--- a/.maint/update_authors.py
+++ b/.maint/update_authors.py
@@ -8,9 +8,11 @@
 # ]
 # ///
 """Update and sort the creators list of the zenodo record."""
+
+import json
 import sys
 from pathlib import Path
-import json
+
 import click
 from fuzzywuzzy import fuzz, process
 
@@ -43,21 +45,18 @@ def read_md_table(md_text):
     keys = None
     retval = []
     for line in md_text.splitlines():
-        if line.strip().startswith("| --- |"):
-            keys = (
-                k.replace("*", "").strip()
-                for k in prev.split("|")
-            )
+        if line.strip().startswith('| --- |'):
+            keys = (k.replace('*', '').strip() for k in prev.split('|'))
             keys = [k.lower() for k in keys if k]
             continue
         elif not keys:
             prev = line
             continue
 
-        if not line or not line.strip().startswith("|"):
+        if not line or not line.strip().startswith('|'):
             break
 
-        values = [v.strip() or None for v in line.split("|")][1:-1]
+        values = [v.strip() or None for v in line.split('|')][1:-1]
         retval.append({k: v for k, v in zip(keys, values) if v})
 
     return retval
@@ -66,21 +65,15 @@ def read_md_table(md_text):
 def sort_contributors(entries, git_lines, exclude=None, last=None):
     """Return a list of author dictionaries, ordered by contribution."""
     last = last or []
-    sorted_authors = sorted(entries, key=lambda i: i["name"])
+    sorted_authors = sorted(entries, key=lambda i: i['name'])
 
-    first_last = [
-        " ".join(val["name"].split(",")[::-1]).strip() for val in sorted_authors
-    ]
-    first_last_excl = [
-        " ".join(val["name"].split(",")[::-1]).strip() for val in exclude or []
-    ]
+    first_last = [' '.join(val['name'].split(',')[::-1]).strip() for val in sorted_authors]
+    first_last_excl = [' '.join(val['name'].split(',')[::-1]).strip() for val in exclude or []]
 
     unmatched = []
     author_matches = []
     for ele in git_lines:
-        matches = process.extract(
-            ele, first_last, scorer=fuzz.token_sort_ratio, limit=2
-        )
+        matches = process.extract(ele, first_last, scorer=fuzz.token_sort_ratio, limit=2)
         # matches is a list [('First match', % Match), ('Second match', % Match)]
         if matches[0][1] > 80:
             val = sorted_authors[first_last.index(matches[0][0])]
@@ -93,7 +86,7 @@ def sort_contributors(entries, git_lines, exclude=None, last=None):
         if val not in author_matches:
             author_matches.append(val)
 
-    names = {" ".join(val["name"].split(",")[::-1]).strip() for val in author_matches}
+    names = {' '.join(val['name'].split(',')[::-1]).strip() for val in author_matches}
     for missing_name in first_last:
         if missing_name not in names:
             missing = sorted_authors[first_last.index(missing_name)]
@@ -101,7 +94,7 @@ def sort_contributors(entries, git_lines, exclude=None, last=None):
 
     position_matches = []
     for i, item in enumerate(author_matches):
-        pos = item.pop("position", None)
+        pos = item.pop('position', None)
         if pos is not None:
             position_matches.append((i, int(pos)))
 
@@ -113,7 +106,7 @@ def sort_contributors(entries, git_lines, exclude=None, last=None):
     return author_matches, unmatched
 
 
-def get_git_lines(fname="line-contributors.txt"):
+def get_git_lines(fname='line-contributors.txt'):
     """Run git-line-summary."""
     import shutil
     import subprocess as sp
@@ -122,17 +115,17 @@ def get_git_lines(fname="line-contributors.txt"):
 
     lines = []
     if contrib_file.exists():
-        print("WARNING: Reusing existing line-contributors.txt file.", file=sys.stderr)
+        print('WARNING: Reusing existing line-contributors.txt file.', file=sys.stderr)
         lines = contrib_file.read_text().splitlines()
 
-    cmd = [shutil.which("git-line-summary")]
+    cmd = [shutil.which('git-line-summary')]
     if cmd == [None]:
-        cmd = [shutil.which("git-summary"), "--line"]
+        cmd = [shutil.which('git-summary'), '--line']
     if not lines and cmd[0]:
-        print(f"Running {' '.join(cmd)!r} on repo")
+        print(f'Running {" ".join(cmd)!r} on repo')
         lines = sp.check_output(cmd).decode().splitlines()
-        lines = [l for l in lines if "Not Committed Yet" not in l]
-        contrib_file.write_text("\n".join(lines))
+        lines = [line for line in lines if 'Not Committed Yet' not in line]
+        contrib_file.write_text('\n'.join(lines))
 
     if not lines:
         raise RuntimeError(
@@ -142,15 +135,15 @@ def get_git_lines(fname="line-contributors.txt"):
 git-line-summary not found, please install git-extras. """
             * (cmd[0] is None)
         )
-    return [" ".join(line.strip().split()[1:-1]) for line in lines if "%" in line]
+    return [' '.join(line.strip().split()[1:-1]) for line in lines if '%' in line]
 
 
 def _namelast(inlist):
     retval = []
     for i in inlist:
-        i["name"] = (f"{i.pop('name', '')} {i.pop('lastname', '')}").strip()
-        if not i["name"]:
-            i["name"] = i.get("handle", "<Unknown Name>")
+        i['name'] = (f'{i.pop("name", "")} {i.pop("lastname", "")}').strip()
+        if not i['name']:
+            i['name'] = i.get('handle', '<Unknown Name>')
         retval.append(i)
     return retval
 
@@ -162,12 +155,13 @@ def cli():
 
 
 @cli.command()
-@click.option("-z", "--zenodo-file", type=click.Path(exists=True), default=".zenodo.json")
-@click.option("-m", "--maintainers", type=click.Path(exists=True), default=".maint/MAINTAINERS.md")
-@click.option("-c", "--contributors", type=click.Path(exists=True),
-              default=".maint/CONTRIBUTORS.md")
-@click.option("--pi", type=click.Path(exists=True), default=".maint/PIs.md")
-@click.option("-f", "--former-file", type=click.Path(exists=True), default=".maint/FORMER.md")
+@click.option('-z', '--zenodo-file', type=click.Path(exists=True), default='.zenodo.json')
+@click.option('-m', '--maintainers', type=click.Path(exists=True), default='.maint/MAINTAINERS.md')
+@click.option(
+    '-c', '--contributors', type=click.Path(exists=True), default='.maint/CONTRIBUTORS.md'
+)
+@click.option('--pi', type=click.Path(exists=True), default='.maint/PIs.md')
+@click.option('-f', '--former-file', type=click.Path(exists=True), default='.maint/FORMER.md')
 def zenodo(
     zenodo_file,
     maintainers,
@@ -188,65 +182,53 @@ def zenodo(
     )
 
     zen_contributors, miss_contributors = sort_contributors(
-        _namelast(read_md_table(Path(contributors).read_text())),
-        data,
-        exclude=former
+        _namelast(read_md_table(Path(contributors).read_text())), data, exclude=former
     )
 
     zen_pi = _namelast(reversed(read_md_table(Path(pi).read_text())))
 
-    zenodo["creators"] = zen_creators
-    zenodo["contributors"] = zen_contributors + [
-        pi for pi in zen_pi if pi not in zen_contributors
-    ]
-    creator_names = {
-        c["name"] for c in zenodo["creators"]
-        if c["name"] != "<Unknown Name>"
-    }
-
-    zenodo["contributors"] = [
-        c for c in zenodo["contributors"]
-        if c["name"] not in creator_names
-    ]
+    zenodo['creators'] = zen_creators
+    zenodo['contributors'] = zen_contributors + [pi for pi in zen_pi if pi not in zen_contributors]
+    creator_names = {c['name'] for c in zenodo['creators'] if c['name'] != '<Unknown Name>'}
+
+    zenodo['contributors'] = [c for c in zenodo['contributors'] if c['name'] not in creator_names]
 
     misses = set(miss_creators).intersection(miss_contributors)
     if misses:
         print(
-            "Some people made commits, but are missing in .maint/ "
-            f"files: {', '.join(misses)}",
+            f'Some people made commits, but are missing in .maint/ files: {", ".join(misses)}',
             file=sys.stderr,
         )
 
     # Remove position
-    for creator in zenodo["creators"]:
-        creator.pop("position", None)
-        creator.pop("handle", None)
-        if "affiliation" not in creator:
-            creator["affiliation"] = "Unknown affiliation"
-        elif isinstance(creator["affiliation"], list):
-            creator["affiliation"] = creator["affiliation"][0]
-
-    for creator in zenodo["contributors"]:
-        creator.pop("handle", None)
-        creator["type"] = "Researcher"
-        creator.pop("position", None)
-
-        if "affiliation" not in creator:
-            creator["affiliation"] = "Unknown affiliation"
-        elif isinstance(creator["affiliation"], list):
-            creator["affiliation"] = creator["affiliation"][0]
-
-    Path(zenodo_file).write_text(
-        "%s\n" % json.dumps(zenodo, indent=2, ensure_ascii=False)
-    )
+    for creator in zenodo['creators']:
+        creator.pop('position', None)
+        creator.pop('handle', None)
+        if 'affiliation' not in creator:
+            creator['affiliation'] = 'Unknown affiliation'
+        elif isinstance(creator['affiliation'], list):
+            creator['affiliation'] = creator['affiliation'][0]
+
+    for creator in zenodo['contributors']:
+        creator.pop('handle', None)
+        creator['type'] = 'Researcher'
+        creator.pop('position', None)
+
+        if 'affiliation' not in creator:
+            creator['affiliation'] = 'Unknown affiliation'
+        elif isinstance(creator['affiliation'], list):
+            creator['affiliation'] = creator['affiliation'][0]
+
+    Path(zenodo_file).write_text('%s\n' % json.dumps(zenodo, indent=2, ensure_ascii=False))
 
 
 @cli.command()
-@click.option("-m", "--maintainers", type=click.Path(exists=True), default=".maint/MAINTAINERS.md")
-@click.option("-c", "--contributors", type=click.Path(exists=True),
-              default=".maint/CONTRIBUTORS.md")
-@click.option("--pi", type=click.Path(exists=True), default=".maint/PIs.md")
-@click.option("-f", "--former-file", type=click.Path(exists=True), default=".maint/FORMER.md")
+@click.option('-m', '--maintainers', type=click.Path(exists=True), default='.maint/MAINTAINERS.md')
+@click.option(
+    '-c', '--contributors', type=click.Path(exists=True), default='.maint/CONTRIBUTORS.md'
+)
+@click.option('--pi', type=click.Path(exists=True), default='.maint/PIs.md')
+@click.option('-f', '--former-file', type=click.Path(exists=True), default='.maint/FORMER.md')
 def publication(
     maintainers,
     contributors,
@@ -254,9 +236,8 @@ def publication(
     former_file,
 ):
     """Generate the list of authors and affiliations for papers."""
-    members = (
-        _namelast(read_md_table(Path(maintainers).read_text()))
-        + _namelast(read_md_table(Path(contributors).read_text()))
+    members = _namelast(read_md_table(Path(maintainers).read_text())) + _namelast(
+        read_md_table(Path(contributors).read_text())
     )
     former_names = _namelast(read_md_table(Path(former_file).read_text()))
 
@@ -267,11 +248,8 @@ def publication(
     )
 
     pi_hits = _namelast(reversed(read_md_table(Path(pi).read_text())))
-    pi_names = [pi["name"] for pi in pi_hits]
-    hits = [
-        hit for hit in hits
-        if hit["name"] not in pi_names
-    ] + pi_hits
+    pi_names = [pi['name'] for pi in pi_hits]
+    hits = [hit for hit in hits if hit['name'] not in pi_names] + pi_hits
 
     def _aslist(value):
         if isinstance(value, (list, tuple)):
@@ -281,16 +259,16 @@ def _aslist(value):
     # Remove position
     affiliations = []
     for item in hits:
-        item.pop("position", None)
-        for a in _aslist(item.get("affiliation", "Unaffiliated")):
+        item.pop('position', None)
+        for a in _aslist(item.get('affiliation', 'Unaffiliated')):
             if a not in affiliations:
                 affiliations.append(a)
 
     aff_indexes = [
-        ", ".join(
+        ', '.join(
             [
-                "%d" % (affiliations.index(a) + 1)
-                for a in _aslist(author.get("affiliation", "Unaffiliated"))
+                '%d' % (affiliations.index(a) + 1)
+                for a in _aslist(author.get('affiliation', 'Unaffiliated'))
             ]
         )
         for author in hits
@@ -298,30 +276,22 @@ def _aslist(value):
 
     if misses:
         print(
-            "Some people made commits, but are missing in .maint/ "
-            f"files: {', '.join(misses)}",
+            f'Some people made commits, but are missing in .maint/ files: {", ".join(misses)}',
             file=sys.stderr,
         )
 
-    print("Authors (%d):" % len(hits))
+    print('Authors (%d):' % len(hits))
     print(
-        "%s."
-        % "; ".join(
-            [
-                "%s \\ :sup:`%s`\\ " % (i["name"], idx)
-                for i, idx in zip(hits, aff_indexes)
-            ]
-        )
+        '%s.'
+        % '; '.join(['%s \\ :sup:`%s`\\ ' % (i['name'], idx) for i, idx in zip(hits, aff_indexes)])
     )
 
     print(
-        "\n\nAffiliations:\n%s"
-        % "\n".join(
-            ["{0: >2}. {1}".format(i + 1, a) for i, a in enumerate(affiliations)]
-        )
+        '\n\nAffiliations:\n%s'
+        % '\n'.join(['{0: >2}. {1}'.format(i + 1, a) for i, a in enumerate(affiliations)])
     )
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     """ Install entry-point """
     cli()
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 17c213359a..ce9679c707 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,10 +1,9 @@
 exclude: ".*/data/.*"
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
+    rev: v5.0.0
     hooks:
       - id: check-added-large-files
-      - id: check-docstring-first
       - id: check-merge-conflict
       - id: check-json
       - id: check-toml
diff --git a/docs/conf.py b/docs/conf.py
index 517302b16a..49053b911e 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -6,8 +6,10 @@
 http://www.sphinx-doc.org/en/master/config
 
 """
+
 from packaging.version import Version
-from sdcflows import __version__, __copyright__, __packagename__
+
+from sdcflows import __copyright__, __packagename__, __version__
 
 # -- Path setup --------------------------------------------------------------
 # If extensions (or modules to document with autodoc) are in another directory,
@@ -18,7 +20,7 @@
 # -- Project information -----------------------------------------------------
 project = __packagename__
 copyright = __copyright__
-author = "The SDCflows Developers"
+author = 'The SDCflows Developers'
 
 # The short X.Y version
 version = Version(__version__).public
@@ -27,57 +29,57 @@
 
 # -- General configuration ---------------------------------------------------
 extensions = [
-    "sphinx.ext.autodoc",
-    "sphinx.ext.coverage",
-    "sphinx.ext.doctest",
-    "sphinx.ext.githubpages",
-    "sphinx.ext.ifconfig",
-    "sphinx.ext.intersphinx",
-    "sphinx.ext.mathjax",
-    "sphinx.ext.viewcode",
-    "sphinxarg.ext",
-    "sphinxcontrib.apidoc",
-    "nbsphinx",
-    "nipype.sphinxext.apidoc",
-    "nipype.sphinxext.plot_workflow",
+    'sphinx.ext.autodoc',
+    'sphinx.ext.coverage',
+    'sphinx.ext.doctest',
+    'sphinx.ext.githubpages',
+    'sphinx.ext.ifconfig',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.mathjax',
+    'sphinx.ext.viewcode',
+    'sphinxarg.ext',
+    'sphinxcontrib.apidoc',
+    'nbsphinx',
+    'nipype.sphinxext.apidoc',
+    'nipype.sphinxext.plot_workflow',
 ]
 
 autodoc_mock_imports = [
-    "matplotlib",
-    "migas",
-    "nilearn",
-    "nipy",
-    "nitime",
-    "nireports",
-    "pandas",
-    "seaborn",
-    "skimage",
-    "svgutils",
-    "transforms3d",
+    'matplotlib',
+    'migas',
+    'nilearn',
+    'nipy',
+    'nitime',
+    'nireports',
+    'pandas',
+    'seaborn',
+    'skimage',
+    'svgutils',
+    'transforms3d',
 ]
 
 # Accept custom section names to be parsed for numpy-style docstrings
 # of parameters.
 napoleon_use_param = False
 napoleon_custom_sections = [
-    ("Inputs", "Parameters"),
-    ("Outputs", "Parameters"),
-    ("Attributes", "Parameters"),
-    ("Mandatory Inputs", "Parameters"),
-    ("Optional Inputs", "Parameters"),
+    ('Inputs', 'Parameters'),
+    ('Outputs', 'Parameters'),
+    ('Attributes', 'Parameters'),
+    ('Mandatory Inputs', 'Parameters'),
+    ('Optional Inputs', 'Parameters'),
 ]
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ["_templates"]
+templates_path = ['_templates']
 
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
 #
 # source_suffix = ['.rst', '.md']
-source_suffix = ".rst"
+source_suffix = '.rst'
 
 # The master toctree document.
-master_doc = "index"
+master_doc = 'index'
 
 numfig = True
 
@@ -86,16 +88,16 @@
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = "en"
+language = 'en'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This pattern also affects html_static_path and html_extra_path.
 exclude_patterns = [
-    "_build",
-    "Thumbs.db",
-    ".DS_Store",
-    "api/sdcflows.rst",
+    '_build',
+    'Thumbs.db',
+    '.DS_Store',
+    'api/sdcflows.rst',
 ]
 
 # The name of the Pygments (syntax highlighting) style to use.
@@ -107,7 +109,7 @@
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = "furo"
+html_theme = 'furo'
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
@@ -118,12 +120,12 @@
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ["_static"]
+html_static_path = ['_static']
 html_js_files = [
-    "js/version-switch.js",
+    'js/version-switch.js',
 ]
 html_css_files = [
-    "css/version-switch.css",
+    'css/version-switch.css',
 ]
 
 # Custom sidebar templates, must be a dictionary that maps document names
@@ -140,7 +142,7 @@
 # -- Options for HTMLHelp output ---------------------------------------------
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = "sdcflowsdoc"
+htmlhelp_basename = 'sdcflowsdoc'
 
 
 # -- Options for LaTeX output ------------------------------------------------
@@ -166,10 +168,10 @@
 latex_documents = [
     (
         master_doc,
-        "sdcflows.tex",
-        "SDCFlows Documentation",
-        "The SDCFlows Developers",
-        "manual",
+        'sdcflows.tex',
+        'SDCFlows Documentation',
+        'The SDCFlows Developers',
+        'manual',
     ),
 ]
 
@@ -178,7 +180,7 @@
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [(master_doc, "sdcflows", "SDCFlows Documentation", [author], 1)]
+man_pages = [(master_doc, 'sdcflows', 'SDCFlows Documentation', [author], 1)]
 
 
 # -- Options for Texinfo output ----------------------------------------------
@@ -189,12 +191,12 @@
 texinfo_documents = [
     (
         master_doc,
-        "sdcflows",
-        "SDCFlows Documentation",
+        'sdcflows',
+        'SDCFlows Documentation',
         author,
-        "SDCFlows",
-        "One line description of project.",
-        "Miscellaneous",
+        'SDCFlows',
+        'One line description of project.',
+        'Miscellaneous',
     ),
 ]
 
@@ -214,31 +216,31 @@
 # epub_uid = ''
 
 # A list of files that should not be packed into the epub file.
-epub_exclude_files = ["search.html"]
+epub_exclude_files = ['search.html']
 
 
 # -- Extension configuration -------------------------------------------------
 
-apidoc_module_dir = "../sdcflows"
-apidoc_output_dir = "api"
-apidoc_excluded_paths = ["conftest.py", "*/tests/*", "tests/*"]
+apidoc_module_dir = '../sdcflows'
+apidoc_output_dir = 'api'
+apidoc_excluded_paths = ['conftest.py', '*/tests/*', 'tests/*']
 apidoc_separate_modules = True
-apidoc_extra_args = ["--module-first", "-d 1", "-T"]
+apidoc_extra_args = ['--module-first', '-d 1', '-T']
 
 # -- Options for intersphinx extension ---------------------------------------
 
 # Example configuration for intersphinx: refer to the Python standard library.
 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),
-    "bids": ("https://bids-standard.github.io/pybids/", None),
-    "nibabel": ("https://nipy.org/nibabel/", None),
-    "nipype": ("https://nipype.readthedocs.io/en/latest/", None),
-    "niworkflows": ("https://www.nipreps.org/niworkflows/", None),
-    "smriprep": ("https://www.nipreps.org/smriprep/", None),
-    "templateflow": ("https://www.templateflow.org/python-client", None),
+    '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),
+    'bids': ('https://bids-standard.github.io/pybids/', None),
+    'nibabel': ('https://nipy.org/nibabel/', None),
+    'nipype': ('https://nipype.readthedocs.io/en/latest/', None),
+    'niworkflows': ('https://www.nipreps.org/niworkflows/', None),
+    'smriprep': ('https://www.nipreps.org/smriprep/', None),
+    'templateflow': ('https://www.templateflow.org/python-client', None),
 }
 
 # -- Options for versioning extension ----------------------------------------
diff --git a/docs/examples.rst b/docs/examples.rst
index 4efb78ab02..af6f58b215 100644
--- a/docs/examples.rst
+++ b/docs/examples.rst
@@ -5,4 +5,4 @@ Examples
    :maxdepth: 2
    :caption: Contents:
 
-   notebooks/SDC - Theory and physics
\ No newline at end of file
+   notebooks/SDC - Theory and physics
diff --git a/docs/notebooks/SDC - Theory and physics.ipynb b/docs/notebooks/SDC - Theory and physics.ipynb
index 1a4b17e697..d8fa57fdac 100644
--- a/docs/notebooks/SDC - Theory and physics.ipynb	
+++ b/docs/notebooks/SDC - Theory and physics.ipynb	
@@ -31,11 +31,11 @@
     "from matplotlib import pyplot as plt\n",
     "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n",
     "\n",
-    "plt.rcParams[\"figure.figsize\"] = (12, 9)\n",
-    "plt.rcParams[\"xtick.bottom\"] = False\n",
-    "plt.rcParams[\"xtick.labelbottom\"] = False\n",
-    "plt.rcParams[\"ytick.left\"] = False\n",
-    "plt.rcParams[\"ytick.labelleft\"] = False"
+    "plt.rcParams['figure.figsize'] = (12, 9)\n",
+    "plt.rcParams['xtick.bottom'] = False\n",
+    "plt.rcParams['xtick.labelbottom'] = False\n",
+    "plt.rcParams['ytick.left'] = False\n",
+    "plt.rcParams['ytick.labelleft'] = False"
    ]
   },
   {
@@ -54,9 +54,10 @@
    "outputs": [],
    "source": [
     "from itertools import product\n",
+    "\n",
+    "import nibabel as nb\n",
     "import numpy as np\n",
     "from scipy import ndimage as ndi\n",
-    "import nibabel as nb\n",
     "from templateflow.api import get"
    ]
   },
@@ -71,44 +72,45 @@
     "    samples_x = np.arange(6, brain_slice.shape[1] - 3, step=12).astype(int)\n",
     "    samples_y = np.arange(6, brain_slice.shape[0] - 3, step=12).astype(int)\n",
     "    return zip(*product(samples_x, samples_y))\n",
-    "    \n",
     "\n",
-    "def plot_brain(brain_slice, brain_cmap=\"RdPu_r\", grid=False, voxel_centers_c=None):\n",
+    "\n",
+    "def plot_brain(brain_slice, brain_cmap='RdPu_r', grid=False, voxel_centers_c=None):\n",
     "    fig, ax = plt.subplots()\n",
     "\n",
     "    # Plot image\n",
-    "    ax.imshow(brain_slice, cmap=brain_cmap, origin=\"lower\");\n",
+    "    ax.imshow(brain_slice, cmap=brain_cmap, origin='lower')\n",
     "\n",
     "    # Generate focus axes\n",
     "    axins = inset_axes(\n",
     "        ax,\n",
-    "        width=\"200%\",\n",
-    "        height=\"100%\",\n",
-    "        bbox_to_anchor=(1, .6, .5, .4),\n",
+    "        width='200%',\n",
+    "        height='100%',\n",
+    "        bbox_to_anchor=(1, 0.6, 0.5, 0.4),\n",
     "        bbox_transform=ax.transAxes,\n",
     "        loc=2,\n",
     "    )\n",
-    "    axins.set_aspect(\"auto\")\n",
+    "    axins.set_aspect('auto')\n",
     "\n",
     "    # sub region of the original image\n",
     "    x1, x2 = (np.array((0, 48)) + (z_s.shape[1] - 1) * 0.5).astype(int)\n",
     "    y1, y2 = np.round(np.array((-15, 15)) + (z_s.shape[0] - 1) * 0.70).astype(int)\n",
     "\n",
-    "    axins.imshow(brain_slice[y1:y2, x1:x2], extent=(x1, x2, y1, y2), cmap=brain_cmap, origin=\"lower\");\n",
+    "    axins.imshow(\n",
+    "        brain_slice[y1:y2, x1:x2], extent=(x1, x2, y1, y2), cmap=brain_cmap, origin='lower'\n",
+    "    )\n",
     "    axins.set_xlim(x1, x2)\n",
     "    axins.set_ylim(y1, y2)\n",
     "    axins.set_xticklabels([])\n",
     "    axins.set_yticklabels([])\n",
     "\n",
-    "    ax.indicate_inset_zoom(axins, edgecolor=\"black\", alpha=1, linewidth=1.5);\n",
+    "    ax.indicate_inset_zoom(axins, edgecolor='black', alpha=1, linewidth=1.5)\n",
     "\n",
-    "        \n",
     "    if grid:\n",
     "        params = {}\n",
     "        if voxel_centers_c is not None:\n",
-    "            params[\"norm\"] = mpl.colors.CenteredNorm()\n",
-    "            params[\"c\"] = voxel_centers_c\n",
-    "            params[\"cmap\"] = \"seismic\"\n",
+    "            params['norm'] = mpl.colors.CenteredNorm()\n",
+    "            params['c'] = voxel_centers_c\n",
+    "            params['cmap'] = 'seismic'\n",
     "        elif voxel_centers_c is None:\n",
     "            params['c'] = 'black'\n",
     "\n",
@@ -121,23 +123,24 @@
     "        e_j = np.arange(0, z_slice.shape[0], step=12).astype(int)\n",
     "\n",
     "        # Plot grid\n",
-    "        ax.plot([e_i[1:-1]] * len(e_j), e_j, c='k', lw=1, alpha=0.3);\n",
-    "        ax.plot(e_i, [e_j[1:-1]] * len(e_i), c='k', lw=1, alpha=0.3);\n",
-    "        axins.plot([e_i[1:-1]] * len(e_j), e_j, c='k', lw=1, alpha=0.3);\n",
-    "        axins.plot(e_i, [e_j[1:-1]] * len(e_i), c='k', lw=1, alpha=0.3);\n",
-    "        \n",
+    "        ax.plot([e_i[1:-1]] * len(e_j), e_j, c='k', lw=1, alpha=0.3)\n",
+    "        ax.plot(e_i, [e_j[1:-1]] * len(e_i), c='k', lw=1, alpha=0.3)\n",
+    "        axins.plot([e_i[1:-1]] * len(e_j), e_j, c='k', lw=1, alpha=0.3)\n",
+    "        axins.plot(e_i, [e_j[1:-1]] * len(e_i), c='k', lw=1, alpha=0.3)\n",
+    "\n",
     "    return fig, ax, axins\n",
     "\n",
+    "\n",
     "def axis_cbar(ax):\n",
     "    cbar = inset_axes(\n",
     "        ax,\n",
-    "        width=\"100%\",\n",
-    "        height=\"10%\",\n",
+    "        width='100%',\n",
+    "        height='10%',\n",
     "        bbox_to_anchor=(0, -0.15, 1, 0.5),\n",
     "        bbox_transform=ax.transAxes,\n",
     "        loc='lower center',\n",
     "    )\n",
-    "    cbar.set_aspect(\"auto\")\n",
+    "    cbar.set_aspect('auto')\n",
     "    return cbar"
    ]
   },
@@ -158,7 +161,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "data = np.asanyarray(nb.load(get(\"MNI152NLin2009cAsym\", desc=\"brain\", resolution=1, suffix=\"T1w\")).dataobj);"
+    "data = np.asanyarray(\n",
+    "    nb.load(get('MNI152NLin2009cAsym', desc='brain', resolution=1, suffix='T1w')).dataobj\n",
+    ");"
    ]
   },
   {
@@ -168,7 +173,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "z_slice = np.swapaxes(data[..., 90], 0, 1).astype(\"float32\")\n",
+    "z_slice = np.swapaxes(data[..., 90], 0, 1).astype('float32')\n",
     "z_s = z_slice.copy()\n",
     "z_slice[z_slice == 0] = np.nan"
    ]
@@ -273,7 +278,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "field = nb.load(\"fieldmap.nii.gz\").get_fdata(dtype=\"float32\")"
+    "field = nb.load('fieldmap.nii.gz').get_fdata(dtype='float32')"
    ]
   },
   {
@@ -295,8 +300,8 @@
    ],
    "source": [
     "fig, ax, axins = plot_brain(z_slice, grid=True)\n",
-    "ax.imshow(field, cmap=\"seismic\", norm=mpl.colors.CenteredNorm(), origin=\"lower\", alpha=0.4);\n",
-    "axins.imshow(field, cmap=\"seismic\", norm=mpl.colors.CenteredNorm(), origin=\"lower\", alpha=0.4);"
+    "ax.imshow(field, cmap='seismic', norm=mpl.colors.CenteredNorm(), origin='lower', alpha=0.4)\n",
+    "axins.imshow(field, cmap='seismic', norm=mpl.colors.CenteredNorm(), origin='lower', alpha=0.4);"
    ]
   },
   {
@@ -336,15 +341,14 @@
     }
    ],
    "source": [
-    "fig, ax, axins = plot_brain(np.ones_like(z_slice) * np.nan, grid=True, voxel_centers_c=sampled_field)\n",
-    "im = ax.imshow(field, cmap=\"seismic\", norm=mpl.colors.CenteredNorm(), origin=\"lower\", alpha=0.3);\n",
-    "axins.imshow(field, cmap=\"seismic\", norm=mpl.colors.CenteredNorm(), origin=\"lower\", alpha=0.3);\n",
+    "fig, ax, axins = plot_brain(\n",
+    "    np.ones_like(z_slice) * np.nan, grid=True, voxel_centers_c=sampled_field\n",
+    ")\n",
+    "im = ax.imshow(field, cmap='seismic', norm=mpl.colors.CenteredNorm(), origin='lower', alpha=0.3)\n",
+    "axins.imshow(field, cmap='seismic', norm=mpl.colors.CenteredNorm(), origin='lower', alpha=0.3)\n",
     "\n",
     "fig.colorbar(\n",
-    "    im,\n",
-    "    cax=axis_cbar(axins),\n",
-    "    orientation='horizontal',\n",
-    "    ticks=[-field.max(), 0, field.max()]\n",
+    "    im, cax=axis_cbar(axins), orientation='horizontal', ticks=[-field.max(), 0, field.max()]\n",
     ").set_ticklabels(\n",
     "    [r'$\\Delta B_0 < 0$', r'$\\Delta B_0 = 0$', r'$\\Delta B_0 > 0$'],\n",
     "    fontsize=16,\n",
@@ -378,14 +382,11 @@
    ],
    "source": [
     "fig, ax, axins = plot_brain(z_slice, grid=True, voxel_centers_c=sampled_field)\n",
-    "im = ax.imshow(field, cmap=\"seismic\", norm=mpl.colors.CenteredNorm(), origin=\"lower\", alpha=0.3);\n",
-    "axins.imshow(field, cmap=\"seismic\", norm=mpl.colors.CenteredNorm(), origin=\"lower\", alpha=0.3);\n",
+    "im = ax.imshow(field, cmap='seismic', norm=mpl.colors.CenteredNorm(), origin='lower', alpha=0.3)\n",
+    "axins.imshow(field, cmap='seismic', norm=mpl.colors.CenteredNorm(), origin='lower', alpha=0.3)\n",
     "\n",
     "fig.colorbar(\n",
-    "    im,\n",
-    "    cax=axis_cbar(axins),\n",
-    "    orientation='horizontal',\n",
-    "    ticks=[-field.max(), 0, field.max()]\n",
+    "    im, cax=axis_cbar(axins), orientation='horizontal', ticks=[-field.max(), 0, field.max()]\n",
     ").set_ticklabels(\n",
     "    [r'$\\Delta B_0 < 0$', r'$\\Delta B_0 = 0$', r'$\\Delta B_0 > 0$'],\n",
     "    fontsize=16,\n",
@@ -415,7 +416,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "trt = - 0.15  # in seconds"
+    "trt = -0.15  # in seconds"
    ]
   },
   {
@@ -465,7 +466,7 @@
     "    scale_units='xy',\n",
     "    scale=1,\n",
     ")\n",
-    "im = ax.imshow(field, cmap=\"seismic\", norm=mpl.colors.CenteredNorm(), origin=\"lower\", alpha=0.3);\n",
+    "im = ax.imshow(field, cmap='seismic', norm=mpl.colors.CenteredNorm(), origin='lower', alpha=0.3)\n",
     "\n",
     "# Inset plotting\n",
     "q = axins.quiver(\n",
@@ -480,14 +481,14 @@
     "    width=0.008,\n",
     "    scale=1,\n",
     ")\n",
-    "axins.imshow(field, cmap=\"seismic\", norm=mpl.colors.CenteredNorm(), origin=\"lower\", alpha=0.3);\n",
+    "axins.imshow(field, cmap='seismic', norm=mpl.colors.CenteredNorm(), origin='lower', alpha=0.3)\n",
     "\n",
     "fig.colorbar(\n",
     "    im,\n",
     "    cax=axis_cbar(axins),\n",
     "    orientation='horizontal',\n",
     "    ticks=[-field.max(), 0, field.max()],\n",
-    ").set_ticklabels([r'$s_{min}$', '0.0' , r'$s_{max}$'], fontsize=16)"
+    ").set_ticklabels([r'$s_{min}$', '0.0', r'$s_{max}$'], fontsize=16)"
    ]
   },
   {
@@ -517,26 +518,44 @@
     "\n",
     "# Plot main view\n",
     "ax.scatter(np.array(x_coord)[is_in_fov], np.array(y_coord)[is_in_fov], s=10, c='k')\n",
-    "ax.scatter(np.array(x_coord)[is_in_fov], y_coord_moved[is_in_fov], c=c, s=10, cmap=\"seismic\", vmin=-1, vmax=1)\n",
-    "ax.plot([e_i[1:-1]] * len(e_j), e_j, c='k', lw=1, alpha=0.3);\n",
-    "im = ax.imshow(field, cmap=\"seismic\", norm=mpl.colors.CenteredNorm(), origin=\"lower\", alpha=0.3);\n",
+    "ax.scatter(\n",
+    "    np.array(x_coord)[is_in_fov],\n",
+    "    y_coord_moved[is_in_fov],\n",
+    "    c=c,\n",
+    "    s=10,\n",
+    "    cmap='seismic',\n",
+    "    vmin=-1,\n",
+    "    vmax=1,\n",
+    ")\n",
+    "ax.plot([e_i[1:-1]] * len(e_j), e_j, c='k', lw=1, alpha=0.3)\n",
+    "im = ax.imshow(field, cmap='seismic', norm=mpl.colors.CenteredNorm(), origin='lower', alpha=0.3)\n",
     "\n",
     "# Plot inset\n",
-    "axins.scatter(np.array(x_coord)[is_in_fov], np.array(y_coord)[is_in_fov], s=80, c=None, fc='none', ec='k')\n",
-    "axins.scatter(np.array(x_coord)[is_in_fov], y_coord_moved[is_in_fov], s=80, c=c, cmap='seismic', vmin=-1, vmax=1)\n",
+    "axins.scatter(\n",
+    "    np.array(x_coord)[is_in_fov], np.array(y_coord)[is_in_fov], s=80, c=None, fc='none', ec='k'\n",
+    ")\n",
+    "axins.scatter(\n",
+    "    np.array(x_coord)[is_in_fov],\n",
+    "    y_coord_moved[is_in_fov],\n",
+    "    s=80,\n",
+    "    c=c,\n",
+    "    cmap='seismic',\n",
+    "    vmin=-1,\n",
+    "    vmax=1,\n",
+    ")\n",
     "axins.quiver(\n",
     "    np.array(x_coord)[is_in_fov],\n",
     "    y_coord_moved[is_in_fov],\n",
     "    u,\n",
     "    -v,\n",
-    "    color=\"black\",\n",
+    "    color='black',\n",
     "    angles='xy',\n",
     "    scale_units='xy',\n",
     "    width=0.008,\n",
     "    scale=1,\n",
     ")\n",
-    "axins.plot([e_i[1:-1]] * len(e_j), e_j, c='k', lw=1, alpha=0.3);\n",
-    "axins.imshow(field, cmap=\"seismic\", norm=mpl.colors.CenteredNorm(), origin=\"lower\", alpha=0.3);\n",
+    "axins.plot([e_i[1:-1]] * len(e_j), e_j, c='k', lw=1, alpha=0.3)\n",
+    "axins.imshow(field, cmap='seismic', norm=mpl.colors.CenteredNorm(), origin='lower', alpha=0.3)\n",
     "\n",
     "# Calculate warping\n",
     "j_axis = np.arange(z_slice.shape[1], dtype=int)\n",
@@ -544,8 +563,8 @@
     "    warped_edges = i + trt * field[i, :]\n",
     "    warped_edges[warped_edges <= 0] = np.nan\n",
     "    warped_edges[warped_edges >= field.shape[0] - 1] = np.nan\n",
-    "    ax.plot(j_axis, warped_edges, c='k', lw=1, alpha=0.5);\n",
-    "    axins.plot(j_axis, warped_edges, c='k', lw=1, alpha=0.5);\n",
+    "    ax.plot(j_axis, warped_edges, c='k', lw=1, alpha=0.5)\n",
+    "    axins.plot(j_axis, warped_edges, c='k', lw=1, alpha=0.5)\n",
     "\n",
     "fig.colorbar(\n",
     "    im,\n",
@@ -573,7 +592,7 @@
    "outputs": [],
    "source": [
     "all_indexes = tuple([np.arange(s) for s in z_slice.shape])\n",
-    "all_ndindex = np.array(np.meshgrid(*all_indexes, indexing=\"ij\")).reshape(2, -1)"
+    "all_ndindex = np.array(np.meshgrid(*all_indexes, indexing='ij')).reshape(2, -1)"
    ]
   },
   {
@@ -583,7 +602,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "all_ndindex_warped = all_ndindex.astype(\"float32\")\n",
+    "all_ndindex_warped = all_ndindex.astype('float32')\n",
     "all_ndindex_warped[0, :] += trt * field.reshape(-1)"
    ]
   },
@@ -658,9 +677,9 @@
     }
    ],
    "source": [
-    "fig, ax, axins = plot_brain(warped_brain, grid=False, brain_cmap='gray');\n",
-    "im = ax.imshow(z_slice, cmap=\"RdPu_r\", origin=\"lower\", alpha=0.5);\n",
-    "axins.imshow(z_slice, cmap=\"RdPu_r\", origin=\"lower\", alpha=0.5);"
+    "fig, ax, axins = plot_brain(warped_brain, grid=False, brain_cmap='gray')\n",
+    "im = ax.imshow(z_slice, cmap='RdPu_r', origin='lower', alpha=0.5)\n",
+    "axins.imshow(z_slice, cmap='RdPu_r', origin='lower', alpha=0.5);"
    ]
   },
   {
@@ -691,7 +710,7 @@
     }
    ],
    "source": [
-    "all_ndindex_warped = all_ndindex.astype(\"float32\")\n",
+    "all_ndindex_warped = all_ndindex.astype('float32')\n",
     "all_ndindex_warped[0, :] -= trt * field.reshape(-1)\n",
     "\n",
     "warped_brain = ndi.map_coordinates(\n",
@@ -699,9 +718,9 @@
     "    all_ndindex_warped,\n",
     ").reshape(z_slice.shape)\n",
     "\n",
-    "fig, ax, axins = plot_brain(warped_brain, grid=False, brain_cmap='gray');\n",
-    "im = ax.imshow(z_slice, cmap=\"RdPu_r\", origin=\"lower\", alpha=0.5);\n",
-    "axins.imshow(z_slice, cmap=\"RdPu_r\", origin=\"lower\", alpha=0.5);"
+    "fig, ax, axins = plot_brain(warped_brain, grid=False, brain_cmap='gray')\n",
+    "im = ax.imshow(z_slice, cmap='RdPu_r', origin='lower', alpha=0.5)\n",
+    "axins.imshow(z_slice, cmap='RdPu_r', origin='lower', alpha=0.5);"
    ]
   }
  ],
diff --git a/docs/tools/apigen.py b/docs/tools/apigen.py
index 716fd488f0..f602f45fa8 100644
--- a/docs/tools/apigen.py
+++ b/docs/tools/apigen.py
@@ -21,7 +21,6 @@
 import os
 import re
 from inspect import getmodule
-
 from types import BuiltinFunctionType, FunctionType
 
 # suppress print statements (warnings for empty files)
@@ -29,21 +28,21 @@
 
 
 class ApiDocWriter(object):
-    """ Class for automatic detection and parsing of API docs
+    """Class for automatic detection and parsing of API docs
     to Sphinx-parsable reST format"""
 
     # only separating first two levels
-    rst_section_levels = ["*", "=", "-", "~", "^"]
+    rst_section_levels = ['*', '=', '-', '~', '^']
 
     def __init__(
         self,
         package_name,
-        rst_extension=".txt",
+        rst_extension='.txt',
         package_skip_patterns=None,
         module_skip_patterns=None,
         other_defines=True,
     ):
-        """ Initialize package for parsing
+        r"""Initialize package for parsing
 
         Parameters
         ----------
@@ -73,9 +72,9 @@ def __init__(
             particular module but not defined there.
         """
         if package_skip_patterns is None:
-            package_skip_patterns = ["\\.tests$"]
+            package_skip_patterns = ['\\.tests$']
         if module_skip_patterns is None:
-            module_skip_patterns = ["\\.setup$", "\\._"]
+            module_skip_patterns = ['\\.setup$', '\\._']
         self.package_name = package_name
         self.rst_extension = rst_extension
         self.package_skip_patterns = package_skip_patterns
@@ -86,7 +85,7 @@ def get_package_name(self):
         return self._package_name
 
     def set_package_name(self, package_name):
-        """ Set package_name
+        """Set package_name
 
         >>> docwriter = ApiDocWriter('sphinx')
         >>> import sphinx
@@ -103,20 +102,18 @@ def set_package_name(self, package_name):
         self.root_path = root_module.__path__[-1]
         self.written_modules = None
 
-    package_name = property(
-        get_package_name, set_package_name, None, "get/set package_name"
-    )
+    package_name = property(get_package_name, set_package_name, None, 'get/set package_name')
 
     def _import(self, name):
-        """ Import namespace package """
+        """Import namespace package"""
         mod = __import__(name)
-        components = name.split(".")
+        components = name.split('.')
         for comp in components[1:]:
             mod = getattr(mod, comp)
         return mod
 
     def _get_object_name(self, line):
-        """ Get second token in line
+        """Get second token in line
         >>> docwriter = ApiDocWriter('sphinx')
         >>> docwriter._get_object_name("  def func():  ")
         'func'
@@ -125,13 +122,13 @@ def _get_object_name(self, line):
         >>> docwriter._get_object_name("  class Klass:  ")
         'Klass'
         """
-        name = line.split()[1].split("(")[0].strip()
+        name = line.split()[1].split('(')[0].strip()
         # in case we have classes which are not derived from object
         # ie. old style classes
-        return name.rstrip(":")
+        return name.rstrip(':')
 
     def _uri2path(self, uri):
-        """ Convert uri to absolute filepath
+        """Convert uri to absolute filepath
 
         Parameters
         ----------
@@ -159,36 +156,36 @@ def _uri2path(self, uri):
 
         """
         if uri == self.package_name:
-            return os.path.join(self.root_path, "__init__.py")
-        path = uri.replace(self.package_name + ".", "")
-        path = path.replace(".", os.path.sep)
+            return os.path.join(self.root_path, '__init__.py')
+        path = uri.replace(self.package_name + '.', '')
+        path = path.replace('.', os.path.sep)
         path = os.path.join(self.root_path, path)
         # XXX maybe check for extensions as well?
-        if os.path.exists(path + ".py"):  # file
-            path += ".py"
-        elif os.path.exists(os.path.join(path, "__init__.py")):
-            path = os.path.join(path, "__init__.py")
+        if os.path.exists(path + '.py'):  # file
+            path += '.py'
+        elif os.path.exists(os.path.join(path, '__init__.py')):
+            path = os.path.join(path, '__init__.py')
         else:
             return None
         return path
 
     def _path2uri(self, dirpath):
-        """ Convert directory path to uri """
-        package_dir = self.package_name.replace(".", os.path.sep)
+        """Convert directory path to uri"""
+        package_dir = self.package_name.replace('.', os.path.sep)
         relpath = dirpath.replace(self.root_path, package_dir)
         if relpath.startswith(os.path.sep):
             relpath = relpath[1:]
-        return relpath.replace(os.path.sep, ".")
+        return relpath.replace(os.path.sep, '.')
 
     def _parse_module(self, uri):
-        """ Parse module defined in *uri* """
+        """Parse module defined in *uri*"""
         filename = self._uri2path(uri)
         if filename is None:
-            print(filename, "erk")
+            print(filename, 'erk')
             # nothing that we could handle here.
             return ([], [])
 
-        f = open(filename, "rt")
+        f = open(filename, 'rt')
         functions, classes = self._parse_lines(f)
         f.close()
         return functions, classes
@@ -211,7 +208,7 @@ def _parse_module_with_import(self, uri):
         """
         mod = __import__(uri, fromlist=[uri])
         # find all public objects in the module.
-        obj_strs = [obj for obj in dir(mod) if not obj.startswith("_")]
+        obj_strs = [obj for obj in dir(mod) if not obj.startswith('_')]
         functions = []
         classes = []
         for obj_str in obj_strs:
@@ -224,7 +221,7 @@ def _parse_module_with_import(self, uri):
                 continue
             # figure out if obj is a function or class
             if (
-                hasattr(obj, "func_name")
+                hasattr(obj, 'func_name')
                 or isinstance(obj, BuiltinFunctionType)
                 or isinstance(obj, FunctionType)
             ):
@@ -239,19 +236,19 @@ def _parse_module_with_import(self, uri):
         return functions, classes
 
     def _parse_lines(self, linesource):
-        """ Parse lines of text for functions and classes """
+        """Parse lines of text for functions and classes"""
         functions = []
         classes = []
         for line in linesource:
-            if line.startswith("def ") and line.count("("):
+            if line.startswith('def ') and line.count('('):
                 # exclude private stuff
                 name = self._get_object_name(line)
-                if not name.startswith("_"):
+                if not name.startswith('_'):
                     functions.append(name)
-            elif line.startswith("class "):
+            elif line.startswith('class '):
                 # exclude private stuff
                 name = self._get_object_name(line)
-                if not name.startswith("_"):
+                if not name.startswith('_'):
                     classes.append(name)
             else:
                 pass
@@ -277,59 +274,53 @@ def generate_api_doc(self, uri):
         # get the names of all classes and functions
         functions, classes = self._parse_module_with_import(uri)
         if not len(functions) and not len(classes) and DEBUG:
-            print("WARNING: Empty -", uri)  # dbg
+            print('WARNING: Empty -', uri)  # dbg
 
         # Make a shorter version of the uri that omits the package name for
         # titles
-        uri_short = re.sub(r"^%s\." % self.package_name, "", uri)
+        uri_short = re.sub(r'^%s\.' % self.package_name, '', uri)
 
-        head = ".. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n"
-        body = ""
+        head = '.. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n'
+        body = ''
 
         # Set the chapter title to read 'module' for all modules except for the
         # main packages
-        if "." in uri_short:
-            title = "Module: :mod:`" + uri_short + "`"
-            head += title + "\n" + self.rst_section_levels[2] * len(title)
+        if '.' in uri_short:
+            title = 'Module: :mod:`' + uri_short + '`'
+            head += title + '\n' + self.rst_section_levels[2] * len(title)
         else:
-            title = ":mod:`" + uri_short + "`"
-            head += title + "\n" + self.rst_section_levels[1] * len(title)
+            title = ':mod:`' + uri_short + '`'
+            head += title + '\n' + self.rst_section_levels[1] * len(title)
 
-        head += "\n.. automodule:: " + uri + "\n"
-        head += "\n.. currentmodule:: " + uri + "\n"
-        body += "\n.. currentmodule:: " + uri + "\n\n"
+        head += '\n.. automodule:: ' + uri + '\n'
+        head += '\n.. currentmodule:: ' + uri + '\n'
+        body += '\n.. currentmodule:: ' + uri + '\n\n'
         for c in classes:
-            body += (
-                "\n:class:`"
-                + c
-                + "`\n"
-                + self.rst_section_levels[3] * (len(c) + 9)
-                + "\n\n"
-            )
-            body += "\n.. autoclass:: " + c + "\n"
+            body += '\n:class:`' + c + '`\n' + self.rst_section_levels[3] * (len(c) + 9) + '\n\n'
+            body += '\n.. autoclass:: ' + c + '\n'
             # must NOT exclude from index to keep cross-refs working
             body += (
-                "  :members:\n"
-                "  :undoc-members:\n"
-                "  :show-inheritance:\n"
-                "\n"
-                "  .. automethod:: __init__\n\n"
+                '  :members:\n'
+                '  :undoc-members:\n'
+                '  :show-inheritance:\n'
+                '\n'
+                '  .. automethod:: __init__\n\n'
             )
-        head += ".. autosummary::\n\n"
+        head += '.. autosummary::\n\n'
         for f in classes + functions:
-            head += "   " + f + "\n"
-        head += "\n"
+            head += '   ' + f + '\n'
+        head += '\n'
 
         for f in functions:
             # must NOT exclude from index to keep cross-refs working
-            body += f + "\n"
-            body += self.rst_section_levels[3] * len(f) + "\n"
-            body += "\n.. autofunction:: " + f + "\n\n"
+            body += f + '\n'
+            body += self.rst_section_levels[3] * len(f) + '\n'
+            body += '\n.. autofunction:: ' + f + '\n\n'
 
         return head, body
 
     def _survives_exclude(self, matchstr, match_type):
-        """ Returns True if *matchstr* does not match patterns
+        """Returns True if *matchstr* does not match patterns
 
         ``self.package_name`` removed from front of string if present
 
@@ -349,9 +340,9 @@ def _survives_exclude(self, matchstr, match_type):
         >>> dw._survives_exclude('sphinx.badmod', 'module')
         False
         """
-        if match_type == "module":
+        if match_type == 'module':
             patterns = self.module_skip_patterns
-        elif match_type == "package":
+        elif match_type == 'package':
             patterns = self.package_skip_patterns
         else:
             raise ValueError('Cannot interpret match type "%s"' % match_type)
@@ -370,7 +361,7 @@ def _survives_exclude(self, matchstr, match_type):
         return True
 
     def discover_modules(self):
-        """ Return module sequence discovered from ``self.package_name``
+        r"""Return module sequence discovered from ``self.package_name``
 
 
         Parameters
@@ -403,27 +394,23 @@ def discover_modules(self):
             # dipy does not import a whole bunch of modules we'll
             # include those here as well (the *.py filenames).
             filenames = [
-                f[:-3]
-                for f in filenames
-                if f.endswith(".py") and not f.startswith("__init__")
+                f[:-3] for f in filenames if f.endswith('.py') and not f.startswith('__init__')
             ]
             for filename in filenames:
-                package_uri = "/".join((dirpath, filename))
+                package_uri = '/'.join((dirpath, filename))
 
             for subpkg_name in dirnames + filenames:
-                package_uri = ".".join((root_uri, subpkg_name))
+                package_uri = '.'.join((root_uri, subpkg_name))
                 package_path = self._uri2path(package_uri)
-                if package_path and self._survives_exclude(package_uri, "package"):
+                if package_path and self._survives_exclude(package_uri, 'package'):
                     modules.append(package_uri)
 
         return sorted(modules)
 
     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
+            '.'.join(m.split('.')[:2]) if m.count('.') >= 1 else m.split('.')[0] for m in modules
         ]
 
         from collections import OrderedDict
@@ -439,12 +426,12 @@ def write_modules_api(self, modules, outdir):
         written_modules = []
 
         for ulm, mods in module_by_ulm.items():
-            print("Generating docs for %s:" % ulm)
+            print('Generating docs for %s:' % ulm)
             document_head = []
             document_body = []
 
             for m in mods:
-                print("  -> " + m)
+                print('  -> ' + m)
                 head, body = self.generate_api_doc(m)
 
                 document_head.append(head)
@@ -452,7 +439,7 @@ def write_modules_api(self, modules, outdir):
 
             out_module = ulm + self.rst_extension
             outfile = os.path.join(outdir, out_module)
-            fileobj = open(outfile, "wt")
+            fileobj = open(outfile, 'wt')
 
             fileobj.writelines(document_head + document_body)
             fileobj.close()
@@ -483,7 +470,7 @@ def write_api_docs(self, outdir):
         modules = self.discover_modules()
         self.write_modules_api(modules, outdir)
 
-    def write_index(self, outdir, froot="gen", relative_to=None):
+    def write_index(self, outdir, froot='gen', relative_to=None):
         """Make a reST API index file from written files
 
         Parameters
@@ -502,22 +489,22 @@ def write_index(self, outdir, froot="gen", relative_to=None):
             leave path as it is.
         """
         if self.written_modules is None:
-            raise ValueError("No modules written")
+            raise ValueError('No modules written')
         # Get full filename path
         path = os.path.join(outdir, froot + self.rst_extension)
         # Path written into index is relative to rootpath
         if relative_to is not None:
-            relpath = (outdir + os.path.sep).replace(relative_to + os.path.sep, "")
+            relpath = (outdir + os.path.sep).replace(relative_to + os.path.sep, '')
         else:
             relpath = outdir
-        idx = open(path, "wt")
+        idx = open(path, 'wt')
         w = idx.write
-        w(".. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n")
+        w('.. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n')
 
-        title = "API Reference"
-        w(title + "\n")
-        w("=" * len(title) + "\n\n")
-        w(".. toctree::\n\n")
+        title = 'API Reference'
+        w(title + '\n')
+        w('=' * len(title) + '\n\n')
+        w('.. toctree::\n\n')
         for f in self.written_modules:
-            w("   %s\n" % os.path.join(relpath, f))
+            w('   %s\n' % os.path.join(relpath, f))
         idx.close()
diff --git a/docs/tools/buildmodref.py b/docs/tools/buildmodref.py
index 769c696bf1..e0a7c41059 100755
--- a/docs/tools/buildmodref.py
+++ b/docs/tools/buildmodref.py
@@ -1,23 +1,22 @@
 #!/usr/bin/env python
-"""Script to auto-generate API docs.
-"""
-from __future__ import print_function, division
+"""Script to auto-generate API docs."""
+
+from __future__ import division, print_function
 
 # stdlib imports
 import sys
-import re
-
-# local imports
-from apigen import ApiDocWriter
 
 # version comparison
 from distutils.version import LooseVersion as V
 
+# local imports
+from apigen import ApiDocWriter
+
 # *****************************************************************************
 
 
 def abort(error):
-    print("*WARNING* API documentation not generated: %s" % error)
+    print('*WARNING* API documentation not generated: %s' % error)
     exit()
 
 
@@ -28,7 +27,7 @@ def writeapi(package, outdir, source_version, other_defines=True):
     try:
         __import__(package)
     except ImportError:
-        abort("Can not import " + package)
+        abort('Can not import ' + package)
 
     module = sys.modules[package]
 
@@ -39,21 +38,21 @@ def writeapi(package, outdir, source_version, other_defines=True):
 
     installed_version = V(module.__version__)
     if source_version != installed_version:
-        abort("Installed version does not match source version")
+        abort('Installed version does not match source version')
 
-    docwriter = ApiDocWriter(package, rst_extension=".rst", other_defines=other_defines)
+    docwriter = ApiDocWriter(package, rst_extension='.rst', other_defines=other_defines)
 
     docwriter.package_skip_patterns += [
-        r"\.%s$" % package,
-        r".*test.*$",
-        r"\.version.*$",
+        r'\.%s$' % package,
+        r'.*test.*$',
+        r'\.version.*$',
     ]
     docwriter.write_api_docs(outdir)
-    docwriter.write_index(outdir, "index", relative_to=outdir)
-    print("%d files written" % len(docwriter.written_modules))
+    docwriter.write_index(outdir, 'index', relative_to=outdir)
+    print('%d files written' % len(docwriter.written_modules))
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     package = sys.argv[1]
     outdir = sys.argv[2]
     try:
@@ -61,6 +60,6 @@ def writeapi(package, outdir, source_version, other_defines=True):
     except IndexError:
         other_defines = True
     else:
-        other_defines = other_defines in ("True", "true", "1")
+        other_defines = other_defines in ('True', 'true', '1')
 
     writeapi(package, outdir, other_defines=other_defines)
diff --git a/pyproject.toml b/pyproject.toml
index 3fab6b2b79..040fab4974 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -65,10 +65,8 @@ mem = [
 ]
 
 dev = [
-    "black",
     "pre-commit",
-    "isort",
-    "flake8-pyproject",
+    "ruff",
 ]
 
 test = [
@@ -117,39 +115,9 @@ version-file = "sdcflows/_version.py"
 # Developer tool configurations
 #
 
+# Disable black, use ruff below
 [tool.black]
-line-length = 99
-target-version = ['py39']
-skip-string-normalization = true
-exclude = '''
-# Directories
-/(
-    \.eggs
-  | \.git
-  | \.hg
-  | \.mypy_cache
-  | \.tox
-  | \.venv
-  | venv
-  | _build
-  | build
-  | dist
-)/
-'''
-
-[tool.isort]
-profile = 'black'
-skip_gitignore = true
-
-[tool.flake8]
-max-line-length = "99"
-doctests = "False"
-exclude = "*build/"
-ignore = ["W503", "E203"]
-per-file-ignores = [
-    "**/__init__.py : F401",
-    "docs/conf.py : E265",
-]
+exclude = "*"
 
 [tool.pytest.ini_options]
 minversion = "6"
@@ -206,3 +174,30 @@ skip = """
 ignore = [
   "W002",  # Test data contains duplicates
 ]
+
+[tool.ruff]
+line-length = 99
+
+[tool.ruff.lint]
+select = [
+  "F",
+  "E",
+  "W",
+  "I",
+]
+ignore = [
+  "E203",
+  "B019",
+  "SIM108",
+  "C901",
+]
+
+[tool.ruff.lint.flake8-quotes]
+inline-quotes = "single"
+
+[tool.ruff.lint.extend-per-file-ignores]
+"*/__init__.py" = ["F401"]
+"docs/conf.py" = ["E265"]
+
+[tool.ruff.format]
+quote-style = "single"
diff --git a/sdcflows/__init__.py b/sdcflows/__init__.py
index e0cb64387f..07c3833a49 100644
--- a/sdcflows/__init__.py
+++ b/sdcflows/__init__.py
@@ -1,13 +1,15 @@
 """SDCflows - :abbr:`SDC (susceptibility distortion correction)` by DUMMIES, for dummies."""
-__packagename__ = "sdcflows"
-__copyright__ = "2022, The NiPreps developers"
+
+__packagename__ = 'sdcflows'
+__copyright__ = '2022, The NiPreps developers'
 try:
     from ._version import __version__
 except ModuleNotFoundError:
-    from importlib.metadata import version, PackageNotFoundError
+    from importlib.metadata import PackageNotFoundError, version
+
     try:
         __version__ = version(__packagename__)
     except PackageNotFoundError:
-        __version__ = "0+unknown"
+        __version__ = '0+unknown'
     del version
     del PackageNotFoundError
diff --git a/sdcflows/_warnings.py b/sdcflows/_warnings.py
index e9708230ac..15d0d1fe4f 100644
--- a/sdcflows/_warnings.py
+++ b/sdcflows/_warnings.py
@@ -25,10 +25,11 @@
 # The original file this work derives from is found at:
 # https://github.com/nipreps/mriqc/blob/8ceadba8669cc2a86119a97b9311ab968f11c6eb/mriqc/_warnings.py
 """Manipulate Python warnings."""
+
 import logging
 import warnings
 
-_wlog = logging.getLogger("py.warnings")
+_wlog = logging.getLogger('py.warnings')
 _wlog.addHandler(logging.NullHandler())
 
 
@@ -36,9 +37,9 @@ def _warn(message, category=None, stacklevel=1, source=None):
     """Redefine the warning function."""
     if category is not None:
         category = type(category).__name__
-        category = category.replace("type", "WARNING")
+        category = category.replace('type', 'WARNING')
 
-    logging.getLogger("py.warnings").warning(f"{category or 'WARNING'}: {message}")
+    logging.getLogger('py.warnings').warning(f'{category or "WARNING"}: {message}')
 
 
 def _showwarning(message, category, filename, lineno, file=None, line=None):
diff --git a/sdcflows/cli/main.py b/sdcflows/cli/main.py
index 0ba9b4e076..d96751dd2c 100644
--- a/sdcflows/cli/main.py
+++ b/sdcflows/cli/main.py
@@ -25,11 +25,12 @@
 
 def main(argv=None):
     """Entry point for SDCFlows' CLI."""
+    import atexit
     import gc
     import os
     import sys
     from tempfile import mktemp
-    import atexit
+
     from sdcflows import config
     from sdcflows.cli.parser import parse_args
 
@@ -42,25 +43,24 @@ def main(argv=None):
         from niworkflows.utils.debug import setup_exceptionhook
 
         setup_exceptionhook()
-        config.nipype.plugin = "Linear"
+        config.nipype.plugin = 'Linear'
 
     # CRITICAL Save the config to a file. This is necessary because the execution graph
     # is built as a separate process to keep the memory footprint low. The most
     # straightforward way to communicate with the child process is via the filesystem.
     # The config file name needs to be unique, otherwise multiple sdcflows instances
     # will create write conflicts.
-    config_file = mktemp(
-        dir=config.execution.work_dir, prefix=".sdcflows.", suffix=".toml"
-    )
+    config_file = mktemp(dir=config.execution.work_dir, prefix='.sdcflows.', suffix='.toml')
     config.to_filename(config_file)
     config.file_path = config_file
     exitcode = 0
 
-    if config.workflow.analysis_level != ["participant"]:
+    if config.workflow.analysis_level != ['participant']:
         raise ValueError("Analysis level can only be 'participant'")
 
     if config.execution.dry_run:  # --dry-run: pretty print results
         from niworkflows.utils.bids import collect_participants
+
         from sdcflows.utils.wrangler import find_estimators
 
         subjects = collect_participants(
@@ -76,31 +76,31 @@ def main(argv=None):
                 logger=config.loggers.cli,
             )
 
-        print(f"Estimation for <{config.execution.bids_dir}> complete. Found:")
+        print(f'Estimation for <{config.execution.bids_dir}> complete. Found:')
         for subject, estimators in estimators_record.items():
-            print(f"\tsub-{subject}")
+            print(f'\tsub-{subject}')
             if not estimators:
-                print("\t\tNo estimators found")
+                print('\t\tNo estimators found')
                 continue
             for estimator in estimators:
-                print(f"\t\t{estimator}")
+                print(f'\t\t{estimator}')
                 for fl in estimator.sources:
-                    fl_relpath = fl.path.relative_to(config.execution.bids_dir / f"sub-{subject}")
-                    pe_dir = fl.metadata.get("PhaseEncodingDirection")
-                    print(f"\t\t\t{pe_dir}\t{fl_relpath}")
+                    fl_relpath = fl.path.relative_to(config.execution.bids_dir / f'sub-{subject}')
+                    pe_dir = fl.metadata.get('PhaseEncodingDirection')
+                    print(f'\t\t\t{pe_dir}\t{fl_relpath}')
         sys.exit(exitcode)
 
     # Initialize process pool if multiprocessing
     _pool = None
-    if config.nipype.plugin in ("MultiProc", "LegacyMultiProc"):
-        from contextlib import suppress
+    if config.nipype.plugin in ('MultiProc', 'LegacyMultiProc'):
         import multiprocessing as mp
         from concurrent.futures import ProcessPoolExecutor
+        from contextlib import suppress
 
-        os.environ["OMP_NUM_THREADS"] = "1"
+        os.environ['OMP_NUM_THREADS'] = '1'
 
         with suppress(RuntimeError):
-            mp.set_start_method("fork")
+            mp.set_start_method('fork')
         gc.collect()
 
         _pool = ProcessPoolExecutor(
@@ -127,8 +127,8 @@ def main(argv=None):
         p.start()
         p.join()
 
-        sdcflows_wf = retval.get("workflow", None)
-        exitcode = p.exitcode or retval.get("return_code", 0)
+        sdcflows_wf = retval.get('workflow', None)
+        exitcode = p.exitcode or retval.get('return_code', 0)
 
     # CRITICAL Load the config from the file. This is necessary because the ``build_workflow``
     # function executed constrained in a process may change the config (and thus the global
@@ -151,12 +151,12 @@ def main(argv=None):
     config.loggers.init()
 
     # Resource management options
-    if config.nipype.plugin in ("MultiProc", "LegacyMultiProc") and (
+    if config.nipype.plugin in ('MultiProc', 'LegacyMultiProc') and (
         1 < config.nipype.nprocs < config.nipype.omp_nthreads
     ):
         config.loggers.cli.warning(
-            "Per-process threads (--omp-nthreads=%d) exceed total "
-            "threads (--nthreads/--n_cpus=%d)",
+            'Per-process threads (--omp-nthreads=%d) exceed total '
+            'threads (--nthreads/--n_cpus=%d)',
             config.nipype.omp_nthreads,
             config.nipype.nprocs,
         )
@@ -165,7 +165,7 @@ def main(argv=None):
         sys.exit(os.EX_SOFTWARE)
 
     if sdcflows_wf and config.execution.write_graph:
-        sdcflows_wf.write_graph(graph2use="colored", format="svg", simple_form=True)
+        sdcflows_wf.write_graph(graph2use='colored', format='svg', simple_form=True)
 
     # Clean up master process before running workflow, which may create forks
     gc.collect()
@@ -175,13 +175,11 @@ def main(argv=None):
         from niworkflows.engine.plugin import MultiProcPlugin
 
         _plugin = {
-            "plugin": MultiProcPlugin(
-                pool=_pool, plugin_args=config.nipype.plugin_args
-            ),
+            'plugin': MultiProcPlugin(pool=_pool, plugin_args=config.nipype.plugin_args),
         }
     sdcflows_wf.run(**_plugin)
-    config.loggers.cli.log(25, "Finished all workload")
+    config.loggers.cli.log(25, 'Finished all workload')
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
diff --git a/sdcflows/cli/parser.py b/sdcflows/cli/parser.py
index 63570fd717..184f375717 100644
--- a/sdcflows/cli/parser.py
+++ b/sdcflows/cli/parser.py
@@ -21,6 +21,7 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Standalone command line executable for estimation of fieldmaps."""
+
 import re
 from argparse import Action, ArgumentDefaultsHelpFormatter, ArgumentParser
 from functools import partial
@@ -46,22 +47,19 @@ def _parse_participant_labels(value):
 
     """
     return sorted(
-        set(
-            re.sub(r"^sub-", "", item.strip())
-            for item in re.split(r"\s+", f"{value}".strip())
-        )
+        set(re.sub(r'^sub-', '', item.strip()) for item in re.split(r'\s+', f'{value}'.strip()))
     )
 
 
 def _parser():
     class ParticipantLabelAction(Action):
         def __call__(self, parser, namespace, values, option_string=None):
-            setattr(namespace, self.dest, _parse_participant_labels(" ".join(values)))
+            setattr(namespace, self.dest, _parse_participant_labels(' '.join(values)))
 
     def _path_exists(path, parser):
         """Ensure a given path exists."""
         if path is None or not Path(path).exists():
-            raise parser.error(f"Path does not exist: <{path}>.")
+            raise parser.error(f'Path does not exist: <{path}>.')
         return Path(path).expanduser().absolute()
 
     def _min_one(value, parser):
@@ -72,10 +70,10 @@ def _min_one(value, parser):
         return value
 
     def _to_gb(value):
-        scale = {"G": 1, "T": 10**3, "M": 1e-3, "K": 1e-6, "B": 1e-9}
-        digits = "".join([c for c in value if c.isdigit()])
+        scale = {'G': 1, 'T': 10**3, 'M': 1e-3, 'K': 1e-6, 'B': 1e-9}
+        digits = ''.join([c for c in value if c.isdigit()])
         n_digits = len(digits)
-        units = value[n_digits:] or "G"
+        units = value[n_digits:] or 'G'
         return int(digits) * scale[units[0]]
 
     def _bids_filter(value):
@@ -95,88 +93,88 @@ def _bids_filter(value):
     PositiveInt = partial(_min_one, parser=parser)
 
     parser.add_argument(
-        "bids_dir",
-        action="store",
+        'bids_dir',
+        action='store',
         type=PathExists,
-        help="The root folder of a BIDS valid dataset (sub-XXXXX folders should "
-        "be found at the top level in this folder).",
+        help='The root folder of a BIDS valid dataset (sub-XXXXX folders should '
+        'be found at the top level in this folder).',
     )
     parser.add_argument(
-        "output_dir",
-        action="store",
+        'output_dir',
+        action='store',
         type=Path,
-        help="The directory where the output files "
-        "should be stored. If you are running group level analysis "
-        "this folder should be prepopulated with the results of the "
-        "participant level analysis.",
+        help='The directory where the output files '
+        'should be stored. If you are running group level analysis '
+        'this folder should be prepopulated with the results of the '
+        'participant level analysis.',
     )
     parser.add_argument(
-        "analysis_level",
-        action="store",
-        nargs="+",
-        help="Level of the analysis that will be performed. "
-        "Multiple participant level analyses can be run independently "
-        "(in parallel) using the same output_dir.",
-        choices=["participant", "group"],
+        'analysis_level',
+        action='store',
+        nargs='+',
+        help='Level of the analysis that will be performed. '
+        'Multiple participant level analyses can be run independently '
+        '(in parallel) using the same output_dir.',
+        choices=['participant', 'group'],
     )
 
     # optional arguments
     parser.add_argument(
-        "--version", action="version", version=f"SDCFlows {config.environment.version}"
+        '--version', action='version', version=f'SDCFlows {config.environment.version}'
     )
     parser.add_argument(
-        "-v",
-        "--verbose",
-        dest="verbose_count",
-        action="count",
+        '-v',
+        '--verbose',
+        dest='verbose_count',
+        action='count',
         default=0,
-        help="Increases log verbosity for each occurrence, debug level is -vvv.",
+        help='Increases log verbosity for each occurrence, debug level is -vvv.',
     )
 
     # main options
-    g_bids = parser.add_argument_group("Options related to BIDS")
+    g_bids = parser.add_argument_group('Options related to BIDS')
     g_bids.add_argument(
-        "--participant-label",
+        '--participant-label',
         action=ParticipantLabelAction,
-        nargs="+",
-        help="A space delimited list of participant identifiers or a single "
-        "identifier (the sub- prefix can be removed).",
+        nargs='+',
+        help='A space delimited list of participant identifiers or a single '
+        'identifier (the sub- prefix can be removed).',
     )
     g_bids.add_argument(
-        "--session-label",
-        action="store",
-        nargs="*",
+        '--session-label',
+        action='store',
+        nargs='*',
         type=str,
-        help="Filter input dataset by session label.",
+        help='Filter input dataset by session label.',
     )
     g_bids.add_argument(
-        "--bids-filter-file",
-        action="store",
+        '--bids-filter-file',
+        action='store',
         type=Path,
-        metavar="PATH",
-        help="a JSON file describing custom BIDS input filter using pybids "
-        "{<suffix>:{<entity>:<filter>,...},...} "
-        "(https://github.com/bids-standard/pybids/blob/master/bids/layout/config/bids.json)",
+        metavar='PATH',
+        help='a JSON file describing custom BIDS input filter using pybids '
+        '{<suffix>:{<entity>:<filter>,...},...} '
+        '(https://github.com/bids-standard/pybids/blob/master/bids/layout/config/bids.json)',
     )
     g_bids.add_argument(
-        "--bids-database-dir",
-        metavar="PATH",
+        '--bids-database-dir',
+        metavar='PATH',
         type=PathExists,
-        help="Path to an existing PyBIDS database folder, for faster indexing "
-        "(especially useful for large datasets).",
+        help='Path to an existing PyBIDS database folder, for faster indexing '
+        '(especially useful for large datasets).',
     )
     g_bids.add_argument(
-        "--bids-database-wipe",
-        action="store_true",
+        '--bids-database-wipe',
+        action='store_true',
         default=False,
-        help="Wipe out previously existing BIDS indexing caches, forcing re-indexing.",
+        help='Wipe out previously existing BIDS indexing caches, forcing re-indexing.',
     )
 
     # General performance
-    g_perfm = parser.add_argument_group("Options to handle performance")
+    g_perfm = parser.add_argument_group('Options to handle performance')
     g_perfm.add_argument(
-        "--nprocs",
-        action="store",
+        '--nprocs',
+        action='store',
         type=PositiveInt,
         help="""\
 Maximum number of simultaneously running parallel processes executed by *SDCFlows* \
@@ -192,8 +190,8 @@ def _bids_filter(value):
 not be what you want in, e.g., shared systems like a HPC cluster.""",
     )
     g_perfm.add_argument(
-        "--omp-nthreads",
-        action="store",
+        '--omp-nthreads',
+        action='store',
         type=PositiveInt,
         help="""\
 Maximum number of threads that multi-threaded processes executed by *SDCFlows* \
@@ -202,69 +200,69 @@ def _bids_filter(value):
 not be what you want in, e.g., shared systems like a HPC cluster.""",
     )
     g_perfm.add_argument(
-        "--mem-gb",
-        dest="memory_gb",
-        action="store",
+        '--mem-gb',
+        dest='memory_gb',
+        action='store',
         type=_to_gb,
-        help="Upper bound memory limit for SDCFlows processes.",
+        help='Upper bound memory limit for SDCFlows processes.',
     )
     g_perfm.add_argument(
-        "--debug",
-        action="store_true",
+        '--debug',
+        action='store_true',
         default=False,
-        help="Enable changes to processing to aid in debugging",
+        help='Enable changes to processing to aid in debugging',
     )
     g_perfm.add_argument(
-        "--pdb",
-        dest="pdb",
-        action="store_true",
+        '--pdb',
+        dest='pdb',
+        action='store_true',
         default=False,
-        help="Open Python debugger (pdb) on exceptions.",
+        help='Open Python debugger (pdb) on exceptions.',
     )
     g_perfm.add_argument(
-        "--sloppy",
-        action="store_true",
+        '--sloppy',
+        action='store_true',
         default=False,
-        help="Use sloppy mode for minimal footprint.",
+        help='Use sloppy mode for minimal footprint.',
     )
 
     # Control instruments
-    g_outputs = parser.add_argument_group("Instrumental options")
+    g_outputs = parser.add_argument_group('Instrumental options')
     g_outputs.add_argument(
-        "-w",
-        "--work-dir",
-        action="store",
+        '-w',
+        '--work-dir',
+        action='store',
         type=Path,
-        default=Path("work").absolute(),
-        help="Path where intermediate results should be stored.",
+        default=Path('work').absolute(),
+        help='Path where intermediate results should be stored.',
     )
     g_outputs.add_argument(
-        "-n",
-        "--dry-run",
-        action="store_true",
+        '-n',
+        '--dry-run',
+        action='store_true',
         default=False,
-        help="only find estimable fieldmaps (that is, estimation is not triggered)",
+        help='only find estimable fieldmaps (that is, estimation is not triggered)',
     )
     g_outputs.add_argument(
-        "--no-fmapless",
-        action="store_false",
-        dest="fmapless",
+        '--no-fmapless',
+        action='store_false',
+        dest='fmapless',
         default=True,
-        help="Allow fieldmap-less estimation",
+        help='Allow fieldmap-less estimation',
     )
     g_outputs.add_argument(
-        "--use-plugin",
-        action="store",
+        '--use-plugin',
+        action='store',
         default=None,
         type=Path,
-        help="Nipype plugin configuration file.",
+        help='Nipype plugin configuration file.',
     )
     g_outputs.add_argument(
-        "--notrack",
-        action="store_true",
-        help="Opt-out of sending tracking information of this run to the NiPreps developers. "
-        "This information helps to improve SDCFlows and provides an indicator of "
-        "real world usage for obtaining funding.",
+        '--notrack',
+        action='store_true',
+        help='Opt-out of sending tracking information of this run to the NiPreps developers. '
+        'This information helps to improve SDCFlows and provides an indicator of '
+        'real world usage for obtaining funding.',
     )
 
     return parser
@@ -272,8 +270,8 @@ def _bids_filter(value):
 
 def parse_args(args=None, namespace=None):
     """Parse args and run further checks on the command line."""
-    from logging import DEBUG
     from json import loads
+    from logging import DEBUG
 
     parser = _parser()
     opts = parser.parse_args(args, namespace)
@@ -286,13 +284,11 @@ def parse_args(args=None, namespace=None):
 
         with open(opts.use_plugin) as f:
             plugin_settings = loadyml(f)
-        _plugin = plugin_settings.get("plugin")
+        _plugin = plugin_settings.get('plugin')
         if _plugin:
             config.nipype.plugin = _plugin
-            config.nipype.plugin_args = plugin_settings.get("plugin_args", {})
-            config.nipype.nprocs = config.nipype.plugin_args.get(
-                "nprocs", config.nipype.nprocs
-            )
+            config.nipype.plugin_args = plugin_settings.get('plugin_args', {})
+            config.nipype.nprocs = config.nipype.plugin_args.get('nprocs', config.nipype.nprocs)
 
     # Load BIDS filters
     if opts.bids_filter_file:
@@ -306,21 +302,21 @@ def parse_args(args=None, namespace=None):
     # Ensure input and output folders are not the same
     if output_dir == bids_dir:
         parser.error(
-            "The selected output folder is the same as the input BIDS folder. "
-            "Please modify the output path (suggestion: %s)."
+            'The selected output folder is the same as the input BIDS folder. '
+            'Please modify the output path (suggestion: %s).'
             % bids_dir
-            / "derivatives"
-            / ("sdcflows_%s" % version.split("+")[0])
+            / 'derivatives'
+            / ('sdcflows_%s' % version.split('+')[0])
         )
 
     if bids_dir in work_dir.parents:
         parser.error(
-            "The selected working directory is a subdirectory of the input BIDS folder. "
-            "Please modify the output path."
+            'The selected working directory is a subdirectory of the input BIDS folder. '
+            'Please modify the output path.'
         )
 
     # Setup directories
-    config.execution.log_dir = output_dir / "logs"
+    config.execution.log_dir = output_dir / 'logs'
     # Check and create output and working directories
     config.execution.log_dir.mkdir(exist_ok=True, parents=True)
     output_dir.mkdir(exist_ok=True, parents=True)
@@ -335,8 +331,8 @@ def parse_args(args=None, namespace=None):
         missing_subjects = selected_label - set(participant_label)
         if missing_subjects:
             parser.error(
-                "One or more participant labels were not found in the BIDS directory: "
-                f"{', '.join(missing_subjects)}."
+                'One or more participant labels were not found in the BIDS directory: '
+                f'{", ".join(missing_subjects)}.'
             )
         participant_label = selected_label
 
diff --git a/sdcflows/cli/tests/test_find_estimators.py b/sdcflows/cli/tests/test_find_estimators.py
index e5cd1432cc..a1cc4da98c 100644
--- a/sdcflows/cli/tests/test_find_estimators.py
+++ b/sdcflows/cli/tests/test_find_estimators.py
@@ -21,7 +21,9 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Check the CLI."""
+
 from importlib import reload
+
 import pytest
 from niworkflows.utils.testing import generate_bids_skeleton
 
@@ -40,95 +42,95 @@
 """
 
 intendedfor_config = {
-    "01": [
-        {"anat": [{"suffix": "T1w", "metadata": {"EchoTime": 1}}]},
+    '01': [
+        {'anat': [{'suffix': 'T1w', 'metadata': {'EchoTime': 1}}]},
         {
-            "fmap": [
+            'fmap': [
                 {
-                    "dir": "AP",
-                    "suffix": "epi",
-                    "metadata": {
-                        "TotalReadoutTime": 0.1,
-                        "PhaseEncodingDirection": "j-",
-                        "IntendedFor": "func/sub-01_task-rest_bold.nii.gz",
+                    'dir': 'AP',
+                    'suffix': 'epi',
+                    'metadata': {
+                        'TotalReadoutTime': 0.1,
+                        'PhaseEncodingDirection': 'j-',
+                        'IntendedFor': 'func/sub-01_task-rest_bold.nii.gz',
                     },
                 },
                 {
-                    "dir": "PA",
-                    "suffix": "epi",
-                    "metadata": {
-                        "TotalReadoutTime": 0.1,
-                        "PhaseEncodingDirection": "j",
-                        "IntendedFor": "func/sub-01_task-rest_bold.nii.gz",
+                    'dir': 'PA',
+                    'suffix': 'epi',
+                    'metadata': {
+                        'TotalReadoutTime': 0.1,
+                        'PhaseEncodingDirection': 'j',
+                        'IntendedFor': 'func/sub-01_task-rest_bold.nii.gz',
                     },
                 },
             ]
         },
         {
-            "func": [
+            'func': [
                 {
-                    "task": "rest",
-                    "suffix": "bold",
-                    "metadata": {
-                        "RepetitionTime": 0.8,
-                        "PhaseEncodingDirection": "j",
+                    'task': 'rest',
+                    'suffix': 'bold',
+                    'metadata': {
+                        'RepetitionTime': 0.8,
+                        'PhaseEncodingDirection': 'j',
                     },
                 }
             ]
         },
     ],
-    "02": [{"anat": [{"suffix": "T1w", "metadata": {"EchoTime": 1}}]}],
+    '02': [{'anat': [{'suffix': 'T1w', 'metadata': {'EchoTime': 1}}]}],
 }
 
 
 b0field_config = {
-    "01": [
-        {"anat": [{"suffix": "T1w", "metadata": {"EchoTime": 1}}]},
+    '01': [
+        {'anat': [{'suffix': 'T1w', 'metadata': {'EchoTime': 1}}]},
         {
-            "fmap": [
+            'fmap': [
                 {
-                    "dir": "AP",
-                    "suffix": "epi",
-                    "metadata": {
-                        "B0FieldIdentifier": "pepolar",
-                        "TotalReadoutTime": 0.1,
-                        "PhaseEncodingDirection": "j-",
+                    'dir': 'AP',
+                    'suffix': 'epi',
+                    'metadata': {
+                        'B0FieldIdentifier': 'pepolar',
+                        'TotalReadoutTime': 0.1,
+                        'PhaseEncodingDirection': 'j-',
                     },
                 },
                 {
-                    "dir": "PA",
-                    "suffix": "epi",
-                    "metadata": {
-                        "B0FieldIdentifier": "pepolar",
-                        "TotalReadoutTime": 0.1,
-                        "PhaseEncodingDirection": "j",
+                    'dir': 'PA',
+                    'suffix': 'epi',
+                    'metadata': {
+                        'B0FieldIdentifier': 'pepolar',
+                        'TotalReadoutTime': 0.1,
+                        'PhaseEncodingDirection': 'j',
                     },
                 },
             ]
         },
         {
-            "func": [
+            'func': [
                 {
-                    "task": "rest",
-                    "suffix": "bold",
-                    "metadata": {
-                        "B0FieldSource": "pepolar",
-                        "RepetitionTime": 0.8,
-                        "PhaseEncodingDirection": "j",
+                    'task': 'rest',
+                    'suffix': 'bold',
+                    'metadata': {
+                        'B0FieldSource': 'pepolar',
+                        'RepetitionTime': 0.8,
+                        'PhaseEncodingDirection': 'j',
                     },
                 }
             ]
         },
     ],
-    "02": [{"anat": [{"suffix": "T1w", "metadata": {"EchoTime": 1}}]}],
+    '02': [{'anat': [{'suffix': 'T1w', 'metadata': {'EchoTime': 1}}]}],
 }
 
 
 @pytest.mark.parametrize(
-    "test_id,config,estimator_id",
+    'test_id,config,estimator_id',
     [
-        ("intendedfor", intendedfor_config, "auto_00000"),
-        ("b0field", b0field_config, "pepolar"),
+        ('intendedfor', intendedfor_config, 'auto_00000'),
+        ('b0field', b0field_config, 'pepolar'),
     ],
 )
 def test_cli_finder_wrapper(tmp_path, capsys, test_id, config, estimator_id):
@@ -141,7 +143,7 @@ def test_cli_finder_wrapper(tmp_path, capsys, test_id, config, estimator_id):
     path = (tmp_path / test_id).absolute()
     generate_bids_skeleton(path, config)
     with pytest.raises(SystemExit) as wrapped_exit:
-        cli_finder_wrapper([str(path), str(tmp_path / "out"), "participant", "--dry-run"])
+        cli_finder_wrapper([str(path), str(tmp_path / 'out'), 'participant', '--dry-run'])
 
     assert wrapped_exit.value.code == 0
     output = OUTPUT.format(path=path, estimator_id=estimator_id)
diff --git a/sdcflows/cli/workflow.py b/sdcflows/cli/workflow.py
index c97b4ef696..ab0ac72342 100644
--- a/sdcflows/cli/workflow.py
+++ b/sdcflows/cli/workflow.py
@@ -26,8 +26,9 @@
 def build_workflow(config_file, retval):
     """Create the Nipype Workflow that supports the whole execution graph."""
     import os
+
     # We do not need OMP > 1 for workflow creation
-    os.environ["OMP_NUM_THREADS"] = "1"
+    os.environ['OMP_NUM_THREADS'] = '1'
 
     from sdcflows import config
     from sdcflows.workflows.fit.base import init_sdcflows_wf
@@ -38,15 +39,18 @@ def build_workflow(config_file, retval):
     # Make sure loggers are started
     config.loggers.init()
 
-    config.loggers.cli.log(25, f"""\
+    config.loggers.cli.log(
+        25,
+        f"""\
 Running SDCFlows {config.environment.version}:
              * BIDS dataset path: {config.execution.bids_dir}.
              * Output folder: {config.execution.output_dir}.
              * Analysis levels: {config.workflow.analysis_level}.
-""")
+""",
+    )
 
-    retval["return_code"] = 1
-    retval["workflow"] = None
-    retval["workflow"] = init_sdcflows_wf()
-    retval["return_code"] = int(retval["workflow"] is None)
+    retval['return_code'] = 1
+    retval['workflow'] = None
+    retval['workflow'] = init_sdcflows_wf()
+    retval['return_code'] = int(retval['workflow'] is None)
     return retval
diff --git a/sdcflows/config.py b/sdcflows/config.py
index 2bcaedd757..e2e851184d 100644
--- a/sdcflows/config.py
+++ b/sdcflows/config.py
@@ -110,6 +110,7 @@
     :py:class:`~bids.layout.BIDSLayout`, etc.)
 
 """
+
 import os
 import sys
 from pathlib import Path
@@ -123,53 +124,51 @@
     from importlib_metadata import version as get_version
 
 # Ignore annoying warnings
-from sdcflows._warnings import logging
 from sdcflows import __version__
+from sdcflows._warnings import logging
 
 _pre_exec_env = dict(os.environ)
 
 # Reduce numpy's vms by limiting OMP_NUM_THREADS
-_default_omp_threads = int(os.getenv("OMP_NUM_THREADS", os.cpu_count()))
+_default_omp_threads = int(os.getenv('OMP_NUM_THREADS', os.cpu_count()))
 
 # Disable NiPype etelemetry always
-_disable_et = bool(
-    os.getenv("NO_ET") is not None or os.getenv("NIPYPE_NO_ET") is not None
-)
-os.environ["NIPYPE_NO_ET"] = "1"
-os.environ["NO_ET"] = "1"
+_disable_et = bool(os.getenv('NO_ET') is not None or os.getenv('NIPYPE_NO_ET') is not None)
+os.environ['NIPYPE_NO_ET'] = '1'
+os.environ['NO_ET'] = '1'
 
-if not hasattr(sys, "_is_pytest_session"):
+if not hasattr(sys, '_is_pytest_session'):
     sys._is_pytest_session = False  # Trick to avoid sklearn's FutureWarnings
 # Disable all warnings in main and children processes only on production versions
 if not any(
     (
-        "+" in __version__,
-        __version__.endswith(".dirty"),
-        os.getenv("SDCFLOWS_DEV", "0").lower() in ("1", "on", "true", "y", "yes"),
+        '+' in __version__,
+        __version__.endswith('.dirty'),
+        os.getenv('SDCFLOWS_DEV', '0').lower() in ('1', 'on', 'true', 'y', 'yes'),
     )
 ):
-    os.environ["PYTHONWARNINGS"] = "ignore"
+    os.environ['PYTHONWARNINGS'] = 'ignore'
 
-logging.addLevelName(25, "IMPORTANT")  # Add a new level between INFO and WARNING
-logging.addLevelName(15, "VERBOSE")  # Add a new level between INFO and DEBUG
+logging.addLevelName(25, 'IMPORTANT')  # Add a new level between INFO and WARNING
+logging.addLevelName(15, 'VERBOSE')  # Add a new level between INFO and DEBUG
 
 DEFAULT_MEMORY_MIN_GB = 0.01
 
 _exec_env = os.name
 _docker_ver = None
 # special variable set in the container
-if os.getenv("IS_DOCKER_8395080871"):
-    _exec_env = "singularity"
-    _cgroup = Path("/proc/1/cgroup")
-    if _cgroup.exists() and "docker" in _cgroup.read_text():
-        _docker_ver = os.getenv("DOCKER_VERSION_8395080871")
-        _exec_env = "docker"
+if os.getenv('IS_DOCKER_8395080871'):
+    _exec_env = 'singularity'
+    _cgroup = Path('/proc/1/cgroup')
+    if _cgroup.exists() and 'docker' in _cgroup.read_text():
+        _docker_ver = os.getenv('DOCKER_VERSION_8395080871')
+        _exec_env = 'docker'
     del _cgroup
 
 _templateflow_home = Path(
     os.getenv(
-        "TEMPLATEFLOW_HOME",
-        os.path.join(os.getenv("HOME"), ".cache", "templateflow"),
+        'TEMPLATEFLOW_HOME',
+        os.path.join(os.getenv('HOME'), '.cache', 'templateflow'),
     )
 )
 
@@ -180,39 +179,34 @@
 except Exception:
     _free_mem_at_start = None
 
-_oc_limit = "n/a"
-_oc_policy = "n/a"
+_oc_limit = 'n/a'
+_oc_policy = 'n/a'
 try:
     # Memory policy may have a large effect on types of errors experienced
-    _proc_oc_path = Path("/proc/sys/vm/overcommit_memory")
+    _proc_oc_path = Path('/proc/sys/vm/overcommit_memory')
     if _proc_oc_path.exists():
-        _oc_policy = {"0": "heuristic", "1": "always", "2": "never"}.get(
-            _proc_oc_path.read_text().strip(), "unknown"
+        _oc_policy = {'0': 'heuristic', '1': 'always', '2': 'never'}.get(
+            _proc_oc_path.read_text().strip(), 'unknown'
         )
-        if _oc_policy != "never":
-            _proc_oc_kbytes = Path("/proc/sys/vm/overcommit_kbytes")
+        if _oc_policy != 'never':
+            _proc_oc_kbytes = Path('/proc/sys/vm/overcommit_kbytes')
             if _proc_oc_kbytes.exists():
                 _oc_limit = _proc_oc_kbytes.read_text().strip()
-            if (
-                _oc_limit in ("0", "n/a")
-                and Path("/proc/sys/vm/overcommit_ratio").exists()
-            ):
-                _oc_limit = "{}%".format(
-                    Path("/proc/sys/vm/overcommit_ratio").read_text().strip()
-                )
+            if _oc_limit in ('0', 'n/a') and Path('/proc/sys/vm/overcommit_ratio').exists():
+                _oc_limit = '{}%'.format(Path('/proc/sys/vm/overcommit_ratio').read_text().strip())
 except Exception:
     pass
 
 _memory_gb = None
 try:
-    if "linux" in sys.platform:
-        with open("/proc/meminfo", "r") as f_in:
+    if 'linux' in sys.platform:
+        with open('/proc/meminfo', 'r') as f_in:
             _meminfo_lines = f_in.readlines()
-            _mem_total_line = [line for line in _meminfo_lines if "MemTotal" in line][0]
+            _mem_total_line = [line for line in _meminfo_lines if 'MemTotal' in line][0]
             _mem_total = float(_mem_total_line.split()[1])
             _memory_gb = _mem_total / (1024.0**2)
-    elif "darwin" in sys.platform:
-        _mem_str = os.popen("sysctl hw.memsize").read().strip().split(" ")[-1]
+    elif 'darwin' in sys.platform:
+        _mem_str = os.popen('sysctl hw.memsize').read().strip().split(' ')[-1]
         _memory_gb = float(_mem_str) / (1024.0**3)
 except Exception:
     pass
@@ -230,7 +224,7 @@ class _Config:
 
     def __init__(self):
         """Avert instantiation."""
-        raise RuntimeError("Configuration type is not instantiable.")
+        raise RuntimeError('Configuration type is not instantiable.')
 
     @classmethod
     def load(cls, settings, init=True):
@@ -255,7 +249,7 @@ def get(cls):
         """Return defined settings."""
         out = {}
         for k, v in cls.__dict__.items():
-            if k.startswith("_") or v is None:
+            if k.startswith('_') or v is None:
                 continue
             if callable(getattr(cls, k)):
                 continue
@@ -291,9 +285,9 @@ class environment(_Config):
     """Linux's kernel virtual memory overcommit policy."""
     overcommit_limit = _oc_limit
     """Linux's kernel virtual memory overcommit limits."""
-    nipype_version = get_version("nipype")
+    nipype_version = get_version('nipype')
     """Nipype's current version."""
-    templateflow_version = get_version("templateflow")
+    templateflow_version = get_version('templateflow')
     """The TemplateFlow client version installed."""
     total_memory = _memory_gb
     """Total memory available, in GB."""
@@ -306,7 +300,7 @@ class environment(_Config):
 class nipype(_Config):
     """Nipype settings."""
 
-    crashfile_format = "txt"
+    crashfile_format = 'txt'
     """The file format for crashfiles, either text or pickle."""
     get_linked_libs = False
     """Run NiPype's tool to enlist linked libraries for every interface."""
@@ -318,11 +312,11 @@ class nipype(_Config):
     """Number of processes (compute tasks) that can be run in parallel (multiprocessing only)."""
     omp_nthreads = _default_omp_threads
     """Number of CPUs a single process can access for multithreaded execution."""
-    plugin = "MultiProc"
+    plugin = 'MultiProc'
     """NiPype's execution plugin."""
     plugin_args = {
-        "maxtasksperchild": 1,
-        "raise_insufficient": False,
+        'maxtasksperchild': 1,
+        'raise_insufficient': False,
     }
     """Settings for NiPype's execution plugin."""
     remove_node_directories = False
@@ -336,13 +330,13 @@ class nipype(_Config):
     def get_plugin(cls):
         """Format a dictionary for Nipype consumption."""
         out = {
-            "plugin": cls.plugin,
-            "plugin_args": cls.plugin_args,
+            'plugin': cls.plugin,
+            'plugin_args': cls.plugin_args,
         }
-        if cls.plugin in ("MultiProc", "LegacyMultiProc"):
-            out["plugin_args"]["n_procs"] = int(cls.nprocs)
+        if cls.plugin in ('MultiProc', 'LegacyMultiProc'):
+            out['plugin_args']['n_procs'] = int(cls.nprocs)
             if cls.memory_gb:
-                out["plugin_args"]["memory_gb"] = float(cls.memory_gb)
+                out['plugin_args']['memory_gb'] = float(cls.memory_gb)
         return out
 
     @classmethod
@@ -353,11 +347,11 @@ def init(cls):
         # Nipype config (logs and execution)
         ncfg.update_config(
             {
-                "execution": {
-                    "crashdump_dir": str(execution.log_dir),
-                    "crashfile_format": cls.crashfile_format,
-                    "get_linked_libs": cls.get_linked_libs,
-                    "stop_on_first_crash": cls.stop_on_first_crash,
+                'execution': {
+                    'crashdump_dir': str(execution.log_dir),
+                    'crashfile_format': cls.crashfile_format,
+                    'get_linked_libs': cls.get_linked_libs,
+                    'stop_on_first_crash': cls.stop_on_first_crash,
                 }
             }
         )
@@ -398,7 +392,7 @@ class execution(_Config):
     """List of participant identifiers that are to be preprocessed."""
     pdb = False
     """Drop into PDB when exceptions are encountered."""
-    run_uuid = "{}_{}".format(strftime("%Y%m%d-%H%M%S"), uuid4())
+    run_uuid = '{}_{}'.format(strftime('%Y%m%d-%H%M%S'), uuid4())
     """Unique identifier of this particular run."""
     session_label = None
     """Filter input dataset by session identifier."""
@@ -406,7 +400,7 @@ class execution(_Config):
     """Run in sloppy mode (meaning, suboptimal parameters that minimize run-time)."""
     templateflow_home = _templateflow_home
     """The root folder of the TemplateFlow client."""
-    work_dir = Path("work").absolute()
+    work_dir = Path('work').absolute()
     """Path to a working directory where intermediate results will be available."""
     write_graph = False
     """Write out the computational graph corresponding to the planned preprocessing."""
@@ -414,13 +408,13 @@ class execution(_Config):
     _layout = None
 
     _paths = (
-        "bids_dir",
-        "bids_database_dir",
-        "layout",
-        "log_dir",
-        "output_dir",
-        "templateflow_home",
-        "work_dir",
+        'bids_dir',
+        'bids_database_dir',
+        'layout',
+        'log_dir',
+        'output_dir',
+        'templateflow_home',
+        'work_dir',
     )
 
     @classmethod
@@ -432,25 +426,24 @@ def init(cls):
 
         if cls._layout is None:
             import re
-            from bids.layout.index import BIDSLayoutIndexer
+
             from bids.layout import BIDSLayout
+            from bids.layout.index import BIDSLayoutIndexer
 
             ignore_paths = [
                 # Ignore folders at the top if they don't start with /sub-<label>/
-                re.compile(r"^(?!/sub-[a-zA-Z0-9]+)"),
+                re.compile(r'^(?!/sub-[a-zA-Z0-9]+)'),
                 # Ignore all modality subfolders, except for func/ or anat/
                 re.compile(
-                    r"^/sub-[a-zA-Z0-9]+(/ses-[a-zA-Z0-9]+)?/"
-                    r"(beh|pet|perf|meg|eeg|ieeg|micr|nirs)"
+                    r'^/sub-[a-zA-Z0-9]+(/ses-[a-zA-Z0-9]+)?/'
+                    r'(beh|pet|perf|meg|eeg|ieeg|micr|nirs)'
                 ),
             ]
 
             if cls.participant_label:
                 # If we know participant labels, ignore all other
                 ignore_paths[0] = re.compile(
-                    r"^(?!/sub-("
-                    + "|".join(cls.participant_label)
-                    + "))"
+                    r'^(?!/sub-(' + '|'.join(cls.participant_label) + '))'
                 )
 
             # Recommended after PyBIDS 12.1
@@ -462,12 +455,11 @@ def init(cls):
             # Initialize database in a multiprocessing-safe manner
             _db_path = (
                 cls.work_dir if cls.participant_label else cls.output_dir
-            ) / f".bids_db-{cls.run_uuid}"
+            ) / f'.bids_db-{cls.run_uuid}'
 
             if cls.bids_database_dir is None:
                 cls.bids_database_dir = (
-                    cls.output_dir / ".bids_db"
-                    if not cls.participant_label else _db_path
+                    cls.output_dir / '.bids_db' if not cls.participant_label else _db_path
                 )
 
             if cls.bids_database_wipe or not cls.bids_database_dir.exists():
@@ -502,26 +494,26 @@ def init(cls):
 class workflow(_Config):
     """Configure the particular execution graph of this workflow."""
 
-    analysis_level = ["participant"]
+    analysis_level = ['participant']
     """Level of analysis."""
     fmapless = False
     """Allow fieldmap-less estimation"""
-    species = "human"
+    species = 'human'
     """Subject species to choose most appropriate template"""
-    template_id = "MNI152NLin2009cAsym"
+    template_id = 'MNI152NLin2009cAsym'
     """TemplateFlow ID of template used for the anatomical processing."""
 
 
 class loggers:
     """Keep loggers easily accessible (see :py:func:`init`)."""
 
-    _fmt = "%(asctime)s,%(msecs)d %(name)-2s " "%(levelname)-2s:\n\t %(message)s"
-    _datefmt = "%y%m%d-%H:%M:%S"
+    _fmt = '%(asctime)s,%(msecs)d %(name)-2s %(levelname)-2s:\n\t %(message)s'
+    _datefmt = '%y%m%d-%H:%M:%S'
     _init = False
 
     default = logging.getLogger()
     """The root logger."""
-    cli = logging.getLogger("cli")
+    cli = logging.getLogger('cli')
     """Command-line interface logging."""
     workflow = None
     """NiPype's workflow logger."""
@@ -541,25 +533,23 @@ def init(cls):
 
         """
         if not cls._init:
-            from nipype import logging as nlogging
             from nipype import config as ncfg
+            from nipype import logging as nlogging
 
-            cls.workflow = nlogging.getLogger("nipype.workflow")
-            cls.interface = nlogging.getLogger("nipype.interface")
-            cls.utils = nlogging.getLogger("nipype.utils")
+            cls.workflow = nlogging.getLogger('nipype.workflow')
+            cls.interface = nlogging.getLogger('nipype.interface')
+            cls.utils = nlogging.getLogger('nipype.utils')
 
             if not len(cls.cli.handlers):
                 _handler = logging.StreamHandler(stream=sys.stdout)
-                _handler.setFormatter(
-                    logging.Formatter(fmt=cls._fmt, datefmt=cls._datefmt)
-                )
+                _handler.setFormatter(logging.Formatter(fmt=cls._fmt, datefmt=cls._datefmt))
                 cls.cli.addHandler(_handler)
 
             ncfg.update_config(
                 {
-                    "logging": {
-                        "log_directory": str(execution.log_dir),
-                        "log_to_file": True,
+                    'logging': {
+                        'log_directory': str(execution.log_dir),
+                        'log_to_file': True,
                     },
                 }
             )
@@ -598,7 +588,7 @@ def load(filename):
     filename = Path(filename)
     settings = loads(filename.read_text())
     for sectionname, configs in settings.items():
-        if sectionname != "environment":
+        if sectionname != 'environment':
             section = getattr(sys.modules[__name__], sectionname)
             section.load(configs)
 
@@ -606,16 +596,16 @@ def load(filename):
 def get(flat=False):
     """Get config as a dict."""
     settings = {
-        "environment": environment.get(),
-        "execution": execution.get(),
-        "workflow": workflow.get(),
-        "nipype": nipype.get(),
+        'environment': environment.get(),
+        'execution': execution.get(),
+        'workflow': workflow.get(),
+        'nipype': nipype.get(),
     }
     if not flat:
         return settings
 
     return {
-        ".".join((section, k)): v
+        '.'.join((section, k)): v
         for section, configs in settings.items()
         for k, v in configs.items()
     }
@@ -640,8 +630,8 @@ def _process_initializer(config_file: Path):
     from sdcflows import config
 
     # Disable eTelemetry
-    os.environ["NIPYPE_NO_ET"] = "1"
-    os.environ["NO_ET"] = "1"
+    os.environ['NIPYPE_NO_ET'] = '1'
+    os.environ['NO_ET'] = '1'
 
     # Load config
     config.load(config_file)
@@ -656,7 +646,7 @@ def _process_initializer(config_file: Path):
     os.chdir(config.execution.cwd)
 
     # Set the maximal number of threads per process
-    os.environ["OMP_NUM_THREADS"] = f"{config.nipype.omp_nthreads}"
+    os.environ['OMP_NUM_THREADS'] = f'{config.nipype.omp_nthreads}'
 
 
 def restore_env():
diff --git a/sdcflows/conftest.py b/sdcflows/conftest.py
index 2825b6b587..cdacab6292 100644
--- a/sdcflows/conftest.py
+++ b/sdcflows/conftest.py
@@ -22,34 +22,39 @@
 #
 """py.test configuration."""
 
-import os
 import logging
+import os
 from pathlib import Path
-import numpy
+
 import nibabel
+import numpy
 import pytest
 from bids.layout import BIDSLayout
+
 from .fieldmaps import clear_registry
 
 # disable ET
 os.environ['NO_ET'] = '1'
 
-test_data_env = os.getenv("TEST_DATA_HOME", str(Path.home() / "sdcflows-tests"))
-test_output_dir = os.getenv("TEST_OUTPUT_DIR")
-test_workdir = os.getenv("TEST_WORK_DIR")
-_sloppy_mode = os.getenv("TEST_PRODUCTION", "off").lower() not in ("on", "1", "true", "yes", "y")
+test_data_env = os.getenv('TEST_DATA_HOME', str(Path.home() / 'sdcflows-tests'))
+test_output_dir = os.getenv('TEST_OUTPUT_DIR')
+test_workdir = os.getenv('TEST_WORK_DIR')
+_sloppy_mode = os.getenv('TEST_PRODUCTION', 'off').lower() not in ('on', '1', 'true', 'yes', 'y')
 
 layouts = {
     p.name: BIDSLayout(str(p), validate=False, derivatives=True)
-    for p in Path(test_data_env).glob("*")
+    for p in Path(test_data_env).glob('*')
     if p.is_dir()
 }
 
-data_dir = Path(__file__).parent / "tests" / "data"
-layouts.update({
-    folder.name: BIDSLayout(folder, validate=False, derivatives=False)
-    for folder in data_dir.glob("ds*") if folder.is_dir()
-})
+data_dir = Path(__file__).parent / 'tests' / 'data'
+layouts.update(
+    {
+        folder.name: BIDSLayout(folder, validate=False, derivatives=False)
+        for folder in data_dir.glob('ds*')
+        if folder.is_dir()
+    }
+)
 
 
 def pytest_report_header(config):
@@ -63,7 +68,7 @@ def pytest_report_header(config):
 
 @pytest.fixture(autouse=True)
 def doctest_fixture(doctest_namespace, request, caplog):
-    doctest_plugin = request.config.pluginmanager.getplugin("doctest")
+    doctest_plugin = request.config.pluginmanager.getplugin('doctest')
     if isinstance(request.node, doctest_plugin.DoctestItem):
         doctest_namespace.update(
             np=numpy,
@@ -71,9 +76,9 @@ def doctest_fixture(doctest_namespace, request, caplog):
             os=os,
             Path=Path,
             layouts=layouts,
-            dsA_dir=data_dir / "dsA",
-            dsB_dir=data_dir / "dsB",
-            dsC_dir=data_dir / "dsC",
+            dsA_dir=data_dir / 'dsA',
+            dsB_dir=data_dir / 'dsB',
+            dsC_dir=data_dir / 'dsC',
             data_dir=data_dir,
             caplog=caplog,
             logging=logging,
@@ -117,7 +122,7 @@ def testdata_dir():
 
 @pytest.fixture
 def dsA_dir():
-    return data_dir / "dsA"
+    return data_dir / 'dsA'
 
 
 @pytest.fixture
diff --git a/sdcflows/data/__init__.py b/sdcflows/data/__init__.py
index 041c9366ab..3b00e782a9 100644
--- a/sdcflows/data/__init__.py
+++ b/sdcflows/data/__init__.py
@@ -10,6 +10,7 @@
 
 .. autoclass:: Loader
 """
+
 from acres import Loader
 
 load = Loader(__spec__.name)
diff --git a/sdcflows/fieldmaps.py b/sdcflows/fieldmaps.py
index e6f35d206b..5f9262f44b 100644
--- a/sdcflows/fieldmaps.py
+++ b/sdcflows/fieldmaps.py
@@ -21,20 +21,22 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Utilities for fieldmap estimation."""
-from pathlib import Path
-from enum import Enum, auto
+
+import re
 from collections import defaultdict
 from contextlib import suppress
-import re
-import attr
+from enum import Enum, auto
 from json import loads
+from pathlib import Path
+
+import attr
 from bids.layout import parse_file_entities
 from bids.utils import listify
 from niworkflows.utils.bids import relative_to_root
+
 from .utils.bimap import EstimatorRegistry
 from .utils.misc import create_logger
 
-
 logger = create_logger('sdcflows.fieldmaps')
 
 _estimators = EstimatorRegistry()
@@ -56,21 +58,21 @@ class EstimatorType(Enum):
 
 
 MODALITIES = {
-    "bold": EstimatorType.PEPOLAR,
-    "dwi": EstimatorType.PEPOLAR,
-    "epi": EstimatorType.PEPOLAR,
-    "asl": EstimatorType.PEPOLAR,
-    "m0scan": EstimatorType.PEPOLAR,
-    "fieldmap": EstimatorType.MAPPED,
-    "magnitude": None,
-    "magnitude1": None,
-    "magnitude2": None,
-    "phase1": EstimatorType.PHASEDIFF,
-    "phase2": EstimatorType.PHASEDIFF,
-    "phasediff": EstimatorType.PHASEDIFF,
-    "sbref": EstimatorType.PEPOLAR,
-    "T1w": EstimatorType.ANAT,
-    "T2w": EstimatorType.ANAT,
+    'bold': EstimatorType.PEPOLAR,
+    'dwi': EstimatorType.PEPOLAR,
+    'epi': EstimatorType.PEPOLAR,
+    'asl': EstimatorType.PEPOLAR,
+    'm0scan': EstimatorType.PEPOLAR,
+    'fieldmap': EstimatorType.MAPPED,
+    'magnitude': None,
+    'magnitude1': None,
+    'magnitude2': None,
+    'phase1': EstimatorType.PHASEDIFF,
+    'phase2': EstimatorType.PHASEDIFF,
+    'phasediff': EstimatorType.PHASEDIFF,
+    'sbref': EstimatorType.PEPOLAR,
+    'T1w': EstimatorType.ANAT,
+    'T2w': EstimatorType.ANAT,
 }
 
 
@@ -79,7 +81,7 @@ def _type_setter(obj, attribute, value):
     if obj.method == value:
         return value
     elif obj.method != EstimatorType.UNKNOWN:
-        raise TypeError(f"Cannot change determined method {obj.method} to {value}.")
+        raise TypeError(f'Cannot change determined method {obj.method} to {value}.')
 
     if value not in (
         EstimatorType.PEPOLAR,
@@ -87,7 +89,7 @@ def _type_setter(obj, attribute, value):
         EstimatorType.MAPPED,
         EstimatorType.ANAT,
     ):
-        raise ValueError(f"Invalid estimation method type {value}.")
+        raise ValueError(f'Invalid estimation method type {value}.')
 
     return value
 
@@ -95,7 +97,7 @@ def _type_setter(obj, attribute, value):
 def _id_setter(obj, attribute, value):
     if obj.bids_id and obj.bids_id == value:
         return value
-    raise ValueError("Cannot edit the bids_id")
+    raise ValueError('Cannot edit the bids_id')
 
 
 @attr.s(slots=True)
@@ -229,29 +231,28 @@ def check_path(self, attribute, value):
         """Validate a fieldmap path."""
         if not value.is_file():
             raise FileNotFoundError(
-                f"File path <{value}> does not exist, is a broken link, or it is not a file"
+                f'File path <{value}> does not exist, is a broken link, or it is not a file'
             )
 
-        if not value.name.endswith((".nii", ".nii.gz")):
-            raise ValueError(f"File path <{value}> does not look like a NIfTI file.")
+        if not value.name.endswith(('.nii', '.nii.gz')):
+            raise ValueError(f'File path <{value}> does not look like a NIfTI file.')
 
-        suffix = re.search(r"(?<=_)\w+(?=\.nii)", value.name).group()
+        suffix = re.search(r'(?<=_)\w+(?=\.nii)', value.name).group()
         if suffix not in tuple(MODALITIES.keys()):
             raise ValueError(
-                f"File path <{value}> with suffix <{suffix}> is not a valid "
-                "fieldmap sourcefile."
+                f'File path <{value}> with suffix <{suffix}> is not a valid fieldmap sourcefile.'
             )
 
     def __attrs_post_init__(self):
         """Validate metadata and additional checks."""
         self.entities = parse_file_entities(str(self.path))
-        self.suffix = self.entities.pop("suffix")
-        extension = self.entities.pop("extension").lstrip(".")
+        self.suffix = self.entities.pop('suffix')
+        extension = self.entities.pop('extension').lstrip('.')
 
         # Automatically fill metadata in when possible
         # TODO: implement BIDS hierarchy of metadata
         if self.find_meta:
-            sidecar = Path(str(self.path).replace(extension, "json"))
+            sidecar = Path(str(self.path).replace(extension, 'json'))
             if sidecar.is_file():
                 _meta = self.metadata or {}
                 self.metadata = loads(sidecar.read_text())
@@ -265,20 +266,18 @@ def __attrs_post_init__(self):
             else None
         )
 
-        if self.suffix in ("T1w", "T2w"):
-            self.metadata["TotalReadoutTime"] = 0.0
+        if self.suffix in ('T1w', 'T2w'):
+            self.metadata['TotalReadoutTime'] = 0.0
 
         # Check for REQUIRED metadata (depends on suffix.)
-        if self.suffix in ("bold", "dwi", "epi", "sbref", "asl", "m0scan"):
-            if "PhaseEncodingDirection" not in self.metadata:
-                raise MetadataError(
-                    f"Missing 'PhaseEncodingDirection' for <{self.path}>."
-                )
+        if self.suffix in ('bold', 'dwi', 'epi', 'sbref', 'asl', 'm0scan'):
+            if 'PhaseEncodingDirection' not in self.metadata:
+                raise MetadataError(f"Missing 'PhaseEncodingDirection' for <{self.path}>.")
 
             from .utils.epimanip import get_trt
 
-            msg = "Missing readout timing information for <%s>. %s"
-            extra = "Explicit fallback must be provided."
+            msg = 'Missing readout timing information for <%s>. %s'
+            extra = 'Explicit fallback must be provided.'
             have_trt = False
             try:
                 get_trt(self.metadata, in_file=self.path)
@@ -286,22 +285,20 @@ def __attrs_post_init__(self):
             except ValueError:
                 with suppress(ValueError):
                     get_trt(self.metadata, in_file=self.path, use_estimate=True)
-                    extra = "Estimated timing is available."
+                    extra = 'Estimated timing is available.'
 
             if not have_trt:
                 logger.warning(msg, self.path, extra)
 
-        elif self.suffix == "fieldmap" and "Units" not in self.metadata:
+        elif self.suffix == 'fieldmap' and 'Units' not in self.metadata:
             raise MetadataError(f"Missing 'Units' for <{self.path}>.")
 
-        elif self.suffix == "phasediff" and (
-            "EchoTime1" not in self.metadata or "EchoTime2" not in self.metadata
+        elif self.suffix == 'phasediff' and (
+            'EchoTime1' not in self.metadata or 'EchoTime2' not in self.metadata
         ):
-            raise MetadataError(
-                f"Missing 'EchoTime1' and/or 'EchoTime2' for <{self.path}>."
-            )
+            raise MetadataError(f"Missing 'EchoTime1' and/or 'EchoTime2' for <{self.path}>.")
 
-        elif self.suffix in ("phase1", "phase2") and ("EchoTime" not in self.metadata):
+        elif self.suffix in ('phase1', 'phase2') and ('EchoTime' not in self.metadata):
             raise MetadataError(f"Missing 'EchoTime' for <{self.path}>.")
 
 
@@ -320,10 +317,9 @@ class FieldmapEstimation:
     sources = attr.ib(
         default=None,
         converter=lambda v: [
-            FieldmapFile(f) if not isinstance(f, FieldmapFile) else f
-            for f in listify(v)
+            FieldmapFile(f) if not isinstance(f, FieldmapFile) else f for f in listify(v)
         ],
-        repr=lambda v: f"<{len(v)} files>",
+        repr=lambda v: f'<{len(v)} files>',
     )
     """File path or list of paths indicating the source data to estimate a fieldmap."""
 
@@ -345,24 +341,22 @@ def __attrs_post_init__(self):
         suffix_set = set(suffix_list)
 
         # Fieldmap option 1: actual field-mapping sequences
-        fmap_types = suffix_set.intersection(
-            ("fieldmap", "phasediff", "phase1", "phase2")
-        )
-        if len(fmap_types) > 1 and fmap_types - set(("phase1", "phase2")):
-            raise TypeError(f"Incompatible suffices found: <{','.join(fmap_types)}>.")
+        fmap_types = suffix_set.intersection(('fieldmap', 'phasediff', 'phase1', 'phase2'))
+        if len(fmap_types) > 1 and fmap_types - set(('phase1', 'phase2')):
+            raise TypeError(f'Incompatible suffices found: <{",".join(fmap_types)}>.')
 
         if fmap_types:
             sources = sorted(
                 f.path
                 for f in self.sources
-                if f.suffix in ("fieldmap", "phasediff", "phase1", "phase2")
+                if f.suffix in ('fieldmap', 'phasediff', 'phase1', 'phase2')
             )
 
             # Automagically add the corresponding phase2 file if missing as argument
-            missing_phases = ("phase1" not in fmap_types, "phase2" not in fmap_types)
+            missing_phases = ('phase1' not in fmap_types, 'phase2' not in fmap_types)
             if sum(missing_phases) == 1:
-                mis_ph = "phase1" if missing_phases[0] else "phase2"
-                hit_ph = "phase2" if missing_phases[0] else "phase1"
+                mis_ph = 'phase1' if missing_phases[0] else 'phase2'
+                hit_ph = 'phase2' if missing_phases[0] else 'phase1'
                 new_source = sources[0].parent / sources[0].name.replace(hit_ph, mis_ph)
                 self.sources.append(FieldmapFile(new_source))
                 sources.insert(int(missing_phases[1]), new_source)
@@ -371,83 +365,70 @@ def __attrs_post_init__(self):
             self.method = MODALITIES[fmap_types.pop()]
 
             # Determine the name of the corresponding (first) magnitude file(s)
-            magnitude = f"magnitude{'' if self.method == EstimatorType.MAPPED else '1'}"
+            magnitude = f'magnitude{"" if self.method == EstimatorType.MAPPED else "1"}'
             if magnitude not in suffix_set:
                 try:
-                    new_path = (
-                        sources[0].parent / sources[0].name
-                        .replace("_fieldmap", "_magnitude")
-                        .replace("_phasediff", "_phase1")
-                        .replace("_phase", "_magnitude")
-                    )
+                    new_path = sources[0].parent / sources[0].name.replace(
+                        '_fieldmap', '_magnitude'
+                    ).replace('_phasediff', '_phase1').replace('_phase', '_magnitude')
                     self.sources.append(FieldmapFile(new_path))
                 except Exception:
                     raise ValueError(
-                        "A fieldmap or phase-difference estimation type was found, "
-                        f"but an anatomical reference ({magnitude} file) is missing."
+                        'A fieldmap or phase-difference estimation type was found, '
+                        f'but an anatomical reference ({magnitude} file) is missing.'
                     )
 
             # Check presence and try to find (if necessary) the second magnitude file
-            if (
-                self.method == EstimatorType.PHASEDIFF
-                and "magnitude2" not in suffix_set
-            ):
+            if self.method == EstimatorType.PHASEDIFF and 'magnitude2' not in suffix_set:
                 try:
-                    new_path = (
-                        sources[-1].parent / sources[-1].name
-                        .replace("diff", "2")
-                        .replace("phase", "magnitude")
+                    new_path = sources[-1].parent / sources[-1].name.replace('diff', '2').replace(
+                        'phase', 'magnitude'
                     )
                     self.sources.append(FieldmapFile(new_path))
                 except Exception:
-                    if "phase2" in suffix_set:
+                    if 'phase2' in suffix_set:
                         raise ValueError(
-                            "A phase-difference estimation (phase1/2) type was found, "
-                            "but an anatomical reference (magnitude2 file) is missing."
+                            'A phase-difference estimation (phase1/2) type was found, '
+                            'but an anatomical reference (magnitude2 file) is missing.'
                         )
 
         # Fieldmap option 2: PEPOLAR (and fieldmap-less or ANAT)
         # IMPORTANT NOTE: fieldmap-less approaches can be considered PEPOLAR with RO = 0.0s
-        pepolar_types = suffix_set.intersection(("bold", "dwi", "epi", "sbref", "asl", "m0scan"))
-        anat_types = suffix_set.intersection(("T1w", "T2w"))
+        pepolar_types = suffix_set.intersection(('bold', 'dwi', 'epi', 'sbref', 'asl', 'm0scan'))
+        anat_types = suffix_set.intersection(('T1w', 'T2w'))
         _pepolar_estimation = (
-            len(
-                [f for f in suffix_list if f in ("bold", "dwi", "epi", "sbref", "asl", "m0scan")]
-            ) > 1
+            len([f for f in suffix_list if f in ('bold', 'dwi', 'epi', 'sbref', 'asl', 'm0scan')])
+            > 1
         )
 
         if _pepolar_estimation and not anat_types:
             self.method = MODALITIES[pepolar_types.pop()]
-            _pe = set(f.metadata["PhaseEncodingDirection"] for f in self.sources)
+            _pe = set(f.metadata['PhaseEncodingDirection'] for f in self.sources)
             if len(_pe) == 1:
                 raise ValueError(
-                    f"Only one phase-encoding direction <{_pe.pop()}> found across sources."
+                    f'Only one phase-encoding direction <{_pe.pop()}> found across sources.'
                 )
         elif anat_types:
             self.method = MODALITIES[anat_types.pop()]
 
             if not pepolar_types:
-                raise ValueError(
-                    "Only anatomical sources were found, cannot estimate fieldmap."
-                )
+                raise ValueError('Only anatomical sources were found, cannot estimate fieldmap.')
 
         if self.method == EstimatorType.UNKNOWN:
             # No method has been identified -> fail.
-            raise ValueError("Insufficient sources to estimate a fieldmap.")
+            raise ValueError('Insufficient sources to estimate a fieldmap.')
 
         intents_meta = set(
-            el
-            for f in self.sources
-            for el in listify(f.metadata.get("IntendedFor") or [])
+            el for f in self.sources for el in listify(f.metadata.get('IntendedFor') or [])
         )
 
         # Register this estimation method
         if not self.bids_id:
             # If not manually set, try to get it from BIDS metadata
             b0_ids = [
-                listify(f.metadata.get("B0FieldIdentifier"))
+                listify(f.metadata.get('B0FieldIdentifier'))
                 for f in self.sources
-                if f.metadata.get("B0FieldIdentifier")
+                if f.metadata.get('B0FieldIdentifier')
             ]
 
             if b0_ids:
@@ -455,19 +436,19 @@ def __attrs_post_init__(self):
                 bids_ids = set(b0_ids[0]).intersection(*b0_ids[1:])
                 if not bids_ids:
                     raise ValueError(
-                        f"No common ``B0FieldIdentifier`` found: <{', '.join(map(str, b0_ids))}>"
+                        f'No common ``B0FieldIdentifier`` found: <{", ".join(map(str, b0_ids))}>'
                     )
                 elif len(bids_ids) > 1:
                     raise ValueError(
-                        f"Multiple common ``B0FieldIdentifier``s found: <{', '.join(bids_ids)}>"
+                        f'Multiple common ``B0FieldIdentifier``s found: <{", ".join(bids_ids)}>'
                     )
-                object.__setattr__(self, "bids_id", bids_ids.pop())
+                object.__setattr__(self, 'bids_id', bids_ids.pop())
 
         if self.bids_id:
             _estimators[self.bids_id] = self.paths()
         else:
             bids_id = _estimators.add(self.paths())
-            object.__setattr__(self, "bids_id", bids_id)
+            object.__setattr__(self, 'bids_id', bids_id)
 
         for intent_file in intents_meta:
             _intents[intent_file].add(self.bids_id)
@@ -486,22 +467,23 @@ def get_workflow(self, set_inputs=True, **kwargs):
             return self._wf
 
         # Override workflow name
-        kwargs["name"] = f"wf_{self.sanitized_id}"
+        kwargs['name'] = f'wf_{self.sanitized_id}'
 
         if self.method in (EstimatorType.MAPPED, EstimatorType.PHASEDIFF):
             from .workflows.fit.fieldmap import init_fmap_wf
 
-            kwargs["mode"] = str(self.method).rpartition(".")[-1].lower()
+            kwargs['mode'] = str(self.method).rpartition('.')[-1].lower()
             self._wf = init_fmap_wf(**kwargs)
             if set_inputs:
                 self._wf.inputs.inputnode.magnitude = [
                     str(f.path.absolute())
-                    for f in self.sources if f.suffix.startswith("magnitude")
+                    for f in self.sources
+                    if f.suffix.startswith('magnitude')
                 ]
                 self._wf.inputs.inputnode.fieldmap = [
                     (str(f.path.absolute()), f.metadata)
                     for f in self.sources
-                    if f.suffix in ("fieldmap", "phasediff", "phase2", "phase1")
+                    if f.suffix in ('fieldmap', 'phasediff', 'phase2', 'phase1')
                 ]
         elif self.method == EstimatorType.PEPOLAR:
             from .workflows.fit.pepolar import init_topup_wf
@@ -509,12 +491,8 @@ def get_workflow(self, set_inputs=True, **kwargs):
             self._wf = init_topup_wf(**kwargs)
 
             if set_inputs:
-                self._wf.inputs.inputnode.in_data = [
-                    str(f.path.absolute()) for f in self.sources
-                ]
-                self._wf.inputs.inputnode.metadata = [
-                    f.metadata for f in self.sources
-                ]
+                self._wf.inputs.inputnode.in_data = [str(f.path.absolute()) for f in self.sources]
+                self._wf.inputs.inputnode.metadata = [f.metadata for f in self.sources]
         elif self.method == EstimatorType.ANAT:
             from .workflows.fit.syn import init_syn_sdc_wf
 
@@ -523,7 +501,7 @@ def get_workflow(self, set_inputs=True, **kwargs):
         return self._wf
 
 
-def get_identifier(filename, by="IntendedFor"):
+def get_identifier(filename, by='IntendedFor'):
     """
     Return the fieldmap identifier for a given filename.
 
@@ -535,10 +513,10 @@ def get_identifier(filename, by="IntendedFor"):
         Index table in which the search should be performed.
 
     """
-    if by == "IntendedFor":
+    if by == 'IntendedFor':
         return tuple(sorted(_intents.get(filename, ())))
 
-    if by == "sources":
+    if by == 'sources':
         return _estimators.get_key(filename)
 
     raise KeyError(r"'{by}'")
diff --git a/sdcflows/interfaces/brainmask.py b/sdcflows/interfaces/brainmask.py
index 7c917f2813..2a47413637 100644
--- a/sdcflows/interfaces/brainmask.py
+++ b/sdcflows/interfaces/brainmask.py
@@ -21,24 +21,26 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Brain extraction interfaces."""
+
 from nipype.interfaces.base import (
-    traits,
     BaseInterfaceInputSpec,
-    TraitedSpec,
     File,
     SimpleInterface,
+    TraitedSpec,
+    traits,
 )
+
 from ..utils.tools import brain_masker
 
 
 class _BrainExtractionInputSpec(BaseInterfaceInputSpec):
-    in_file = File(exists=True, mandatory=True, desc="file to mask")
+    in_file = File(exists=True, mandatory=True, desc='file to mask')
 
 
 class _BrainExtractionOutputSpec(TraitedSpec):
-    out_file = File(exists=True, desc="the input file, after masking")
-    out_mask = File(exists=True, desc="the binary brain mask")
-    out_probseg = File(exists=True, desc="the probabilistic brain mask")
+    out_file = File(exists=True, desc='the input file, after masking')
+    out_mask = File(exists=True, desc='the binary brain mask')
+    out_probseg = File(exists=True, desc='the probabilistic brain mask')
 
 
 class BrainExtraction(SimpleInterface):
@@ -51,23 +53,23 @@ def _run_interface(self, runtime):
         from nipype.utils.filemanip import fname_presuffix
 
         (
-            self._results["out_file"],
-            self._results["out_probseg"],
-            self._results["out_mask"],
+            self._results['out_file'],
+            self._results['out_probseg'],
+            self._results['out_mask'],
         ) = brain_masker(
             self.inputs.in_file,
-            fname_presuffix(self.inputs.in_file, suffix="_mask", newpath=runtime.cwd),
+            fname_presuffix(self.inputs.in_file, suffix='_mask', newpath=runtime.cwd),
         )
         return runtime
 
 
 class _BinaryDilationInputSpec(BaseInterfaceInputSpec):
-    in_file = File(exists=True, mandatory=True, desc="binary file to dilate")
-    radius = traits.Float(3, usedefault=True, desc="structure element (ball) radius")
+    in_file = File(exists=True, mandatory=True, desc='binary file to dilate')
+    radius = traits.Float(3, usedefault=True, desc='structure element (ball) radius')
 
 
 class _BinaryDilationOutputSpec(TraitedSpec):
-    out_file = File(exists=True, desc="the input file, after binary dilation")
+    out_file = File(exists=True, desc='the input file, after binary dilation')
 
 
 class BinaryDilation(SimpleInterface):
@@ -77,7 +79,7 @@ class BinaryDilation(SimpleInterface):
     output_spec = _BinaryDilationOutputSpec
 
     def _run_interface(self, runtime):
-        self._results["out_file"] = _dilate(
+        self._results['out_file'] = _dilate(
             self.inputs.in_file,
             self.inputs.radius,
             newpath=runtime.cwd,
@@ -86,12 +88,12 @@ def _run_interface(self, runtime):
 
 
 class _UnionInputSpec(BaseInterfaceInputSpec):
-    in1 = File(exists=True, mandatory=True, desc="binary file")
-    in2 = File(exists=True, mandatory=True, desc="binary file")
+    in1 = File(exists=True, mandatory=True, desc='binary file')
+    in2 = File(exists=True, mandatory=True, desc='binary file')
 
 
 class _UnionOutputSpec(TraitedSpec):
-    out_file = File(exists=True, desc="the input file, after binary dilation")
+    out_file = File(exists=True, desc='the input file, after binary dilation')
 
 
 class Union(SimpleInterface):
@@ -101,7 +103,7 @@ class Union(SimpleInterface):
     output_spec = _UnionOutputSpec
 
     def _run_interface(self, runtime):
-        self._results["out_file"] = _union(
+        self._results['out_file'] = _union(
             self.inputs.in1,
             self.inputs.in2,
             newpath=runtime.cwd,
@@ -112,43 +114,36 @@ def _run_interface(self, runtime):
 def _dilate(in_file, radius=3, newpath=None):
     """Dilate (binary) input mask."""
     from pathlib import Path
-    import numpy as np
+
     import nibabel as nb
+    import numpy as np
+    from nipype.utils.filemanip import fname_presuffix
     from scipy import ndimage
     from skimage.morphology import ball
-    from nipype.utils.filemanip import fname_presuffix
 
     mask = nb.load(in_file)
-    newdata = ndimage.binary_dilation(
-        np.asanyarray(mask.dataobj) > 0, ball(radius)
-    )
+    newdata = ndimage.binary_dilation(np.asanyarray(mask.dataobj) > 0, ball(radius))
 
     hdr = mask.header.copy()
-    hdr.set_data_dtype("uint8")
-    out_file = fname_presuffix(in_file, suffix="_dil", newpath=newpath or Path.cwd())
-    mask.__class__(newdata.astype("uint8"), mask.affine, hdr).to_filename(
-        out_file
-    )
+    hdr.set_data_dtype('uint8')
+    out_file = fname_presuffix(in_file, suffix='_dil', newpath=newpath or Path.cwd())
+    mask.__class__(newdata.astype('uint8'), mask.affine, hdr).to_filename(out_file)
     return out_file
 
 
 def _union(in1, in2, newpath=None):
     """Dilate (binary) input mask."""
     from pathlib import Path
-    import numpy as np
+
     import nibabel as nb
+    import numpy as np
     from nipype.utils.filemanip import fname_presuffix
 
     mask = nb.load(in1)
-    data = (
-        np.asanyarray(mask.dataobj)
-        + np.asanyarray(nb.load(in2).dataobj)
-    ) > 0
+    data = (np.asanyarray(mask.dataobj) + np.asanyarray(nb.load(in2).dataobj)) > 0
 
     hdr = mask.header.copy()
-    hdr.set_data_dtype("uint8")
-    out_file = fname_presuffix(in1, suffix="_union", newpath=newpath or Path.cwd())
-    mask.__class__(data.astype("uint8"), mask.affine, hdr).to_filename(
-        out_file
-    )
+    hdr.set_data_dtype('uint8')
+    out_file = fname_presuffix(in1, suffix='_union', newpath=newpath or Path.cwd())
+    mask.__class__(data.astype('uint8'), mask.affine, hdr).to_filename(out_file)
     return out_file
diff --git a/sdcflows/interfaces/bspline.py b/sdcflows/interfaces/bspline.py
index 4268a18ed5..ecf394823e 100644
--- a/sdcflows/interfaces/bspline.py
+++ b/sdcflows/interfaces/bspline.py
@@ -21,72 +21,68 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Filtering of :math:`B_0` field mappings with B-Splines."""
+
 from itertools import product
 from pathlib import Path
-import numpy as np
+
 import nibabel as nb
+import numpy as np
 from nibabel.affines import apply_affine
-from nitransforms.linear import Affine
-
 from nipype import logging
-from nipype.utils.filemanip import fname_presuffix
 from nipype.interfaces.base import (
     BaseInterfaceInputSpec,
-    TraitedSpec,
     File,
-    traits,
-    isdefined,
-    SimpleInterface,
     InputMultiObject,
     OutputMultiObject,
+    SimpleInterface,
+    TraitedSpec,
+    isdefined,
+    traits,
 )
+from nipype.utils.filemanip import fname_presuffix
+from nitransforms.linear import Affine
 
 from sdcflows.transform import grid_bspline_weights
 from sdcflows.utils.tools import reorient_pedir
 
-
 LOW_MEM_BLOCK_SIZE = 1000
 DEFAULT_ZOOMS_MM = (40.0, 40.0, 20.0)  # For human adults (mid-frequency), in mm
 DEFAULT_LF_ZOOMS_MM = (100.0, 100.0, 40.0)  # For human adults (low-frequency), in mm
 DEFAULT_HF_ZOOMS_MM = (16.0, 16.0, 10.0)  # For human adults (high-frequency), in mm
-LOGGER = logging.getLogger("nipype.interface")
+LOGGER = logging.getLogger('nipype.interface')
 
 
 class _BSplineApproxInputSpec(BaseInterfaceInputSpec):
-    in_data = File(exists=True, mandatory=True, desc="path to a fieldmap")
-    in_mask = File(exists=True, desc="path to a brain mask")
+    in_data = File(exists=True, mandatory=True, desc='path to a fieldmap')
+    in_mask = File(exists=True, desc='path to a brain mask')
     bs_spacing = InputMultiObject(
         [DEFAULT_HF_ZOOMS_MM],
         traits.Tuple(traits.Float, traits.Float, traits.Float),
         usedefault=True,
-        desc="spacing between B-Spline control points",
-    )
-    ridge_alpha = traits.Float(
-        1e-4, usedefault=True, desc="controls the regularization"
+        desc='spacing between B-Spline control points',
     )
+    ridge_alpha = traits.Float(1e-4, usedefault=True, desc='controls the regularization')
     recenter = traits.Enum(
-        "median",
-        "mode",
-        "mean",
+        'median',
+        'mode',
+        'mean',
         False,
         usedefault=True,
-        desc="strategy to recenter the distribution of the input fieldmap",
+        desc='strategy to recenter the distribution of the input fieldmap',
     )
     extrapolate = traits.Bool(
         True,
         usedefault=True,
-        desc="generate a field, extrapolated outside the brain mask",
+        desc='generate a field, extrapolated outside the brain mask',
     )
     zooms_min = traits.Union(
         traits.Float,
         traits.Tuple(traits.Float, traits.Float, traits.Float),
         default_value=1.0,
         usedefault=True,
-        desc="limit minimum image zooms, set 0.0 to use the original image",
-    )
-    debug = traits.Bool(
-        False, usedefault=True, desc="generate extra assets for debugging"
+        desc='limit minimum image zooms, set 0.0 to use the original image',
     )
+    debug = traits.Bool(False, usedefault=True, desc='generate extra assets for debugging')
 
 
 class _BSplineApproxOutputSpec(TraitedSpec):
@@ -130,13 +126,11 @@ class BSplineApprox(SimpleInterface):
     output_spec = _BSplineApproxOutputSpec
 
     def _run_interface(self, runtime):
-        from sklearn import linear_model as lm
         from scipy.sparse import hstack as sparse_hstack
+        from sklearn import linear_model as lm
 
         # Output name baseline
-        out_name = fname_presuffix(
-            self.inputs.in_data, suffix="_field", newpath=runtime.cwd
-        )
+        out_name = fname_presuffix(self.inputs.in_data, suffix='_field', newpath=runtime.cwd)
 
         # Load in the fieldmap
         fmapnii = nb.load(self.inputs.in_data)
@@ -144,17 +138,13 @@ def _run_interface(self, runtime):
         zooms = fmapnii.header.get_zooms()
 
         # Get a mask (or define on the spot to cover the full extent)
-        masknii = (
-            nb.load(self.inputs.in_mask) if isdefined(self.inputs.in_mask) else None
-        )
+        masknii = nb.load(self.inputs.in_mask) if isdefined(self.inputs.in_mask) else None
         # if masknii is not None:
         #     masknii = nb.as_closest_canonical(masknii)
 
         # Determine the shape of bspline coefficients
         # This should not change with resizing, so do it first
-        bs_grids = [
-            bspline_grid(fmapnii, control_zooms_mm=sp) for sp in self.inputs.bs_spacing
-        ]
+        bs_grids = [bspline_grid(fmapnii, control_zooms_mm=sp) for sp in self.inputs.bs_spacing]
 
         need_resize = np.any(np.array(zooms) < self.inputs.zooms_min)
         if need_resize:
@@ -164,15 +154,15 @@ def _run_interface(self, runtime):
 
             LOGGER.info(
                 "Resampling image with resolution exceeding 'zooms_min' "
-                f"({'x'.join(str(s) for s in zooms)} → "
-                f"{'x'.join(str(s) for s in target_zooms)})."
+                f'({"x".join(str(s) for s in zooms)} → '
+                f'{"x".join(str(s) for s in target_zooms)}).'
             )
             fmapnii = resample_to_zooms(fmapnii, target_zooms)
 
             if masknii is not None:
                 masknii = resample_to_zooms(masknii, target_zooms)
 
-        data = fmapnii.get_fdata(dtype="float32")
+        data = fmapnii.get_fdata(dtype='float32')
 
         # Generate a numpy array with the mask
         mask = (
@@ -183,32 +173,30 @@ def _run_interface(self, runtime):
 
         # Recenter the fieldmap
         center = 0
-        if self.inputs.recenter == "mode":
+        if self.inputs.recenter == 'mode':
             from scipy.stats import mode
 
             # Handle pre- and post-1.9 mode behavior.
             # squeeze can be dropped when the minimum version reaches 1.9
             # Will become: data -= mode(data[mask], keepdims=False).mode
             center = np.squeeze(mode(data[mask]).mode)
-        elif self.inputs.recenter == "median":
+        elif self.inputs.recenter == 'median':
             center = np.median(data[mask])
-        elif self.inputs.recenter == "mean":
+        elif self.inputs.recenter == 'mean':
             center = np.mean(data[mask])
 
         data -= center
         data[~mask] = 0
 
         # Calculate collocation matrix from (possibly resized) image and knot grids
-        colmat = sparse_hstack(
-            [grid_bspline_weights(fmapnii, grid) for grid in bs_grids]
-        ).tocsr()
+        colmat = sparse_hstack([grid_bspline_weights(fmapnii, grid) for grid in bs_grids]).tocsr()
 
-        bs_grids_str = ["x".join(str(s) for s in grid.shape) for grid in bs_grids]
-        bs_grids_str[-1] = f"and {bs_grids_str[-1]}"
+        bs_grids_str = ['x'.join(str(s) for s in grid.shape) for grid in bs_grids]
+        bs_grids_str[-1] = f'and {bs_grids_str[-1]}'
         LOGGER.info(
-            f"Approximating B-Splines grids ({', '.join(bs_grids_str)} [knots]) on a grid of "
-            f"{'x'.join(str(s) for s in fmapnii.shape)} ({np.prod(fmapnii.shape)}) voxels,"
-            f" of which {mask.sum()} fall within the mask."
+            f'Approximating B-Splines grids ({", ".join(bs_grids_str)} [knots]) on a grid of '
+            f'{"x".join(str(s) for s in fmapnii.shape)} ({np.prod(fmapnii.shape)}) voxels,'
+            f' of which {mask.sum()} fall within the mask.'
         )
 
         # Fit the model
@@ -216,40 +204,38 @@ def _run_interface(self, runtime):
         for attempt in range(3):
             model.fit(colmat, data.reshape(-1))
             extreme = np.abs(model.coef_).max()
-            LOGGER.debug(f"Model fit attempt {attempt}: max(|coeffs|) = {extreme}")
+            LOGGER.debug(f'Model fit attempt {attempt}: max(|coeffs|) = {extreme}')
             # Normal values seem to be ~1e2, bad ~1e8. May want to tweak this if
             # these distributions are wider than I think.
             if extreme < 1e4:
                 break
         else:
             raise RuntimeError(
-                f"Spline fit of input file {self.inputs.in_data} failed. "
-                f"Extreme value {extreme:.2e} detected in spline coefficients."
+                f'Spline fit of input file {self.inputs.in_data} failed. '
+                f'Extreme value {extreme:.2e} detected in spline coefficients.'
             )
 
-        self._results["out_intercept"] = model.intercept_
+        self._results['out_intercept'] = model.intercept_
 
         # Store coefficients
         index = 0
-        self._results["out_coeff"] = []
+        self._results['out_coeff'] = []
         for i, bsl in enumerate(bs_grids):
             n = bsl.dataobj.size
-            out_level = out_name.replace("_field.", f"_coeff{i:03}.")
+            out_level = out_name.replace('_field.', f'_coeff{i:03}.')
             bsl.__class__(
-                np.array(model.coef_, dtype="float32")[index : index + n].reshape(
-                    bsl.shape
-                ),
+                np.array(model.coef_, dtype='float32')[index : index + n].reshape(bsl.shape),
                 bsl.affine,
                 bsl.header,
             ).to_filename(out_level)
             index += n
-            self._results["out_coeff"].append(out_level)
+            self._results['out_coeff'].append(out_level)
 
         # Interpolating in the original grid will require a new collocation matrix
         if need_resize:
             fmapnii = nb.load(self.inputs.in_data)
             # fmapnii = nb.as_closest_canonical(fmapnii)
-            data = fmapnii.get_fdata(dtype="float32") - center
+            data = fmapnii.get_fdata(dtype='float32') - center
             if masknii is not None:
                 masknii = nb.load(self.inputs.in_mask)
                 # masknii = nb.as_closest_canonical(masknii)
@@ -267,79 +253,75 @@ def _run_interface(self, runtime):
 
         # Store interpolated field
         hdr = fmapnii.header.copy()
-        hdr.set_data_dtype("float32")
+        hdr.set_data_dtype('float32')
         outnii = fmapnii.__class__(interp_data, fmapnii.affine, hdr)
-        outnii.header["cal_max"] = np.abs(outnii.dataobj).max()
-        outnii.header["cal_min"] = -outnii.header["cal_max"]
+        outnii.header['cal_max'] = np.abs(outnii.dataobj).max()
+        outnii.header['cal_min'] = -outnii.header['cal_max']
         outnii.to_filename(out_name)
-        self._results["out_field"] = out_name
+        self._results['out_field'] = out_name
 
         # Write out fitting-error map
-        self._results["out_error"] = out_name.replace("_field.", "_error.")
-        errornii = fmapnii.__class__(
-            (data - interp_data) * mask, fmapnii.affine, fmapnii.header
-        )
-        errornii.header["cal_min"] = 0
-        errornii.header["cal_max"] = np.max(errornii.dataobj)
-        errornii.to_filename(self._results["out_error"])
+        self._results['out_error'] = out_name.replace('_field.', '_error.')
+        errornii = fmapnii.__class__((data - interp_data) * mask, fmapnii.affine, fmapnii.header)
+        errornii.header['cal_min'] = 0
+        errornii.header['cal_max'] = np.max(errornii.dataobj)
+        errornii.to_filename(self._results['out_error'])
 
         if not self.inputs.extrapolate:
             return runtime
 
         if np.all(mask):
-            self._results["out_extrapolated"] = self._results["out_field"]
+            self._results['out_extrapolated'] = self._results['out_field']
             return runtime
 
         extrapolators = colmat[~mask.reshape(-1), :]
         interp_data[~mask] = extrapolators @ model.coef_  # Extrapolation
-        self._results["out_extrapolated"] = out_name.replace("_field.", "_extra.")
+        self._results['out_extrapolated'] = out_name.replace('_field.', '_extra.')
         fmapnii.__class__(interp_data, fmapnii.affine, hdr).to_filename(
-            self._results["out_extrapolated"]
+            self._results['out_extrapolated']
         )
         return runtime
 
 
 class _ApplyCoeffsFieldInputSpec(BaseInterfaceInputSpec):
-    in_data = File(exist=True, mandatory=True, desc="input EPI data to be corrected")
+    in_data = File(exist=True, mandatory=True, desc='input EPI data to be corrected')
     in_coeff = InputMultiObject(
         File(exists=True),
         mandatory=True,
-        desc="input coefficients as calculated in the estimation stage",
+        desc='input coefficients as calculated in the estimation stage',
     )
     fmap2data_xfm = InputMultiObject(
         File(exists=True),
         desc="the transform by which the target EPI can be resampled on the fieldmap's grid.",
-        xor=["data2fmap_xfm"],
+        xor=['data2fmap_xfm'],
     )
     data2fmap_xfm = InputMultiObject(
         File(exists=True),
         desc="the transform by which the fieldmap can be resampled on the target EPI's grid.",
-        xor=["fmap2data_xfm"],
+        xor=['fmap2data_xfm'],
     )
     in_xfms = traits.List(
         traits.List(traits.List(traits.Float)),
-        desc="list of head-motion correction matrices",
-    )
-    ro_time = InputMultiObject(
-        traits.Float(), mandatory=True, desc="EPI readout time (s)."
+        desc='list of head-motion correction matrices',
     )
+    ro_time = InputMultiObject(traits.Float(), mandatory=True, desc='EPI readout time (s).')
     pe_dir = InputMultiObject(
-        traits.Enum("i", "i-", "j", "j-", "k", "k-"),
+        traits.Enum('i', 'i-', 'j', 'j-', 'k', 'k-'),
         mandatory=True,
-        desc="the phase-encoding direction corresponding to in_data",
+        desc='the phase-encoding direction corresponding to in_data',
     )
     jacobian = traits.Bool(
         False,
         usedefault=True,
-        desc="apply Jacobian determinant correction after unwarping",
+        desc='apply Jacobian determinant correction after unwarping',
     )
-    num_threads = traits.Int(nohash=True, desc="number of threads")
+    num_threads = traits.Int(nohash=True, desc='number of threads')
     approx = traits.Bool(
         True,
         usedefault=True,
         desc=(
-            "reconstruct the fieldmap on its original grid and then interpolate on the "
-            "rotated grid, rather than reconstructing directly on the rotated grid."
+            'reconstruct the fieldmap on its original grid and then interpolate on the '
+            'rotated grid, rather than reconstructing directly on the rotated grid.'
         ),
     )
 
@@ -410,33 +392,35 @@ def _run_interface(self, runtime):
 
         if isdefined(self.inputs.data2fmap_xfm):
             data2fmap_xfm = Affine.from_filename(
-                self.inputs.data2fmap_xfm if not isinstance(self.inputs.data2fmap_xfm, list)
+                self.inputs.data2fmap_xfm
+                if not isinstance(self.inputs.data2fmap_xfm, list)
                 else self.inputs.data2fmap_xfm[0],
-                fmt="itk"
+                fmt='itk',
             ).matrix
         elif isdefined(self.inputs.fmap2data_xfm):
             # Same, but inverting direction
-            data2fmap_xfm = (~Affine.from_filename(
-                self.inputs.fmap2data_xfm if not isinstance(self.inputs.fmap2data_xfm, list)
-                else self.inputs.fmap2data_xfm[0],
-                fmt="itk"
-            )).matrix
+            data2fmap_xfm = (
+                ~Affine.from_filename(
+                    self.inputs.fmap2data_xfm
+                    if not isinstance(self.inputs.fmap2data_xfm, list)
+                    else self.inputs.fmap2data_xfm[0],
+                    fmt='itk',
+                )
+            ).matrix
 
         # Pre-cached interpolator object
-        unwarp = B0FieldTransform(
-            coeffs=[nb.load(cname) for cname in self.inputs.in_coeff]
-        )
+        unwarp = B0FieldTransform(coeffs=[nb.load(cname) for cname in self.inputs.in_coeff])
 
         # We can now write out the fieldmap
-        self._results["out_field"] = fname_presuffix(
+        self._results['out_field'] = fname_presuffix(
             self.inputs.in_data,
-            suffix="_field",
+            suffix='_field',
             newpath=runtime.cwd,
         )
 
-        self._results["out_corrected"] = fname_presuffix(
+        self._results['out_corrected'] = fname_presuffix(
             self.inputs.in_data,
-            suffix="_sdc",
+            suffix='_sdc',
             newpath=runtime.cwd,
         )
 
@@ -449,24 +433,22 @@ def _run_interface(self, runtime):
             xfm_data2fmap=data2fmap_xfm,
             approx=self.inputs.approx,
             num_threads=self.inputs.num_threads or None,
-        ).to_filename(self._results["out_corrected"])
-        unwarp.mapped.to_filename(self._results["out_field"])
+        ).to_filename(self._results['out_corrected'])
+        unwarp.mapped.to_filename(self._results['out_field'])
         return runtime
 
 
 class _TransformCoefficientsInputSpec(BaseInterfaceInputSpec):
     in_coeff = InputMultiObject(
-        File(exist=True), mandatory=True, desc="input coefficients file(s)"
-    )
-    fmap_ref = File(exists=True, mandatory=True, desc="the fieldmap reference")
-    transform = File(exists=True, mandatory=True, desc="rigid-body transform file")
-    fmap_target = File(
-        exists=True, desc="the distorted EPI target (feed to set debug mode on)"
+        File(exist=True), mandatory=True, desc='input coefficients file(s)'
     )
+    fmap_ref = File(exists=True, mandatory=True, desc='the fieldmap reference')
+    transform = File(exists=True, mandatory=True, desc='rigid-body transform file')
+    fmap_target = File(exists=True, desc='the distorted EPI target (feed to set debug mode on)')
 
 
 class _TransformCoefficientsOutputSpec(TraitedSpec):
-    out_coeff = OutputMultiObject(File(exists=True), desc="moved coefficients")
+    out_coeff = OutputMultiObject(File(exists=True), desc='moved coefficients')
 
 
 class TransformCoefficients(SimpleInterface):
@@ -478,39 +460,35 @@ class TransformCoefficients(SimpleInterface):
     def _run_interface(self, runtime):
         from sdcflows.transform import _move_coeff
 
-        self._results["out_coeff"] = []
+        self._results['out_coeff'] = []
 
         for level in self.inputs.in_coeff:
             movednii = _move_coeff(
                 level,
                 self.inputs.fmap_ref,
                 self.inputs.transform,
-                fmap_target=(
-                    self.inputs.fmap_target or None
-                ),
-            )
-            out_file = fname_presuffix(
-                level, suffix="_space-target", newpath=runtime.cwd
+                fmap_target=(self.inputs.fmap_target or None),
             )
+            out_file = fname_presuffix(level, suffix='_space-target', newpath=runtime.cwd)
             movednii.to_filename(out_file)
-            self._results["out_coeff"].append(out_file)
+            self._results['out_coeff'].append(out_file)
         return runtime
 
 
 class _TOPUPCoeffReorientInputSpec(BaseInterfaceInputSpec):
     in_coeff = InputMultiObject(
-        File(exist=True), mandatory=True, desc="input coefficients file(s) from TOPUP"
+        File(exist=True), mandatory=True, desc='input coefficients file(s) from TOPUP'
     )
-    fmap_ref = File(exists=True, mandatory=True, desc="the fieldmap reference")
+    fmap_ref = File(exists=True, mandatory=True, desc='the fieldmap reference')
     pe_dir = traits.Enum(
-        *["".join(p) for p in product("ijkxyz", ("", "-"))],
+        *[''.join(p) for p in product('ijkxyz', ('', '-'))],
         mandatory=True,
-        desc="phase encoding direction",
+        desc='phase encoding direction',
     )
 
 
 class _TOPUPCoeffReorientOutputSpec(TraitedSpec):
-    out_coeff = OutputMultiObject(File(exists=True), desc="patched coefficients")
+    out_coeff = OutputMultiObject(File(exists=True), desc='patched coefficients')
 
 
 class TOPUPCoeffReorient(SimpleInterface):
@@ -545,15 +523,13 @@ class TOPUPCoeffReorient(SimpleInterface):
     output_spec = _TOPUPCoeffReorientOutputSpec
 
     def _run_interface(self, runtime):
-        self._results["out_coeff"] = [
+        self._results['out_coeff'] = [
             str(
                 _fix_topup_fieldcoeff(
                     in_coeff,
                     self.inputs.fmap_ref,
                     self.inputs.pe_dir,
-                    out_file=fname_presuffix(
-                        in_coeff, suffix="_fixed", newpath=runtime.cwd
-                    ),
+                    out_file=fname_presuffix(in_coeff, suffix='_fixed', newpath=runtime.cwd),
                 )
             )
             for in_coeff in self.inputs.in_coeff
@@ -586,17 +562,18 @@ def bspline_grid(img, control_zooms_mm=DEFAULT_ZOOMS_MM):
         bs_affine, 0.5 * (bs_shape - 1)
     )
 
-    return img.__class__(np.zeros(bs_shape, dtype="float32"), bs_affine)
+    return img.__class__(np.zeros(bs_shape, dtype='float32'), bs_affine)
 
 
 def _fix_topup_fieldcoeff(in_coeff, fmap_ref, pe_dir, out_file=None):
     """Read in a coefficients file generated by TOPUP and fix x-form headers."""
     from pathlib import Path
-    import numpy as np
+
     import nibabel as nb
+    import numpy as np
 
     if out_file is None:
-        out_file = Path("coefficients.nii.gz").absolute()
+        out_file = Path('coefficients.nii.gz').absolute()
 
     refnii = nb.load(fmap_ref)
     coeffnii = nb.load(in_coeff)
@@ -613,7 +590,7 @@ def _fix_topup_fieldcoeff(in_coeff, fmap_ref, pe_dir, out_file=None):
     # always is implicit.
     # If the PE direction is x/i, the flip in the axis direction causes that the
     # fieldmap estimation must also be inverted in direction (multiply by -1.0)
-    reverse_pe = -1.0 if coeff_pe_dir[0] == "i" else 1.0
+    reverse_pe = -1.0 if coeff_pe_dir[0] == 'i' else 1.0
     coeffnii = coeffnii.__class__(
         reverse_pe * np.flip(np.asanyarray(coeffnii.dataobj), axis=0),
         coeffnii.affine,
@@ -629,8 +606,8 @@ def _fix_topup_fieldcoeff(in_coeff, fmap_ref, pe_dir, out_file=None):
     exp_shape = ref_shape // factors + 3 * (factors > 1)
     if not np.all(coeff_shape == exp_shape):
         raise ValueError(
-            f"Shape of coefficients file {coeff_shape} does not meet the "
-            f"expected shape {exp_shape} (toupup factors are {factors})."
+            f'Shape of coefficients file {coeff_shape} does not meet the '
+            f'expected shape {exp_shape} (toupup factors are {factors}).'
         )
 
     # Contextualize the control points in space with a proper NIfTI affine
@@ -644,14 +621,14 @@ def _fix_topup_fieldcoeff(in_coeff, fmap_ref, pe_dir, out_file=None):
     header = coeffnii.header.copy()
     header.set_qform(newaff, code=1)
     header.set_sform(newaff, code=1)
-    header["cal_max"] = max(
+    header['cal_max'] = max(
         (
             abs(np.asanyarray(coeffnii.dataobj).min()),
             np.asanyarray(coeffnii.dataobj).max(),
         )
     )
-    header["cal_min"] = -header["cal_max"]
-    header.set_intent("estimate", tuple(), name="B-Spline coefficients")
+    header['cal_min'] = -header['cal_max']
+    header.set_intent('estimate', tuple(), name='B-Spline coefficients')
 
     # Write out fixed (generalized) coefficients
     coeffnii.__class__(coeffnii.dataobj, newaff, header).to_filename(out_file)
@@ -666,10 +643,10 @@ def _split_itk_file(in_file):
 
     def _chunks(inlist, chunksize):
         for i in range(0, len(inlist), chunksize):
-            yield "\n".join([header] + inlist[i : i + chunksize])
+            yield '\n'.join([header] + inlist[i : i + chunksize])
 
     for i, xfm in enumerate(_chunks(lines, 4)):
-        p = Path(f"{i:05}")
+        p = Path(f'{i:05}')
         p.write_text(xfm)
         yield str(p)
 
@@ -680,7 +657,7 @@ def _b0_resampler(in_file, coeffs, pe, ro, hmc_xfm=None, unwarp=None, newpath=No
 
     # Prepare output names
     filename = partial(fname_presuffix, newpath=newpath)
-    retval = [filename(in_file, suffix=s) for s in ("_unwarped", "_xfm", "_field")]
+    retval = [filename(in_file, suffix=s) for s in ('_unwarped', '_xfm', '_field')]
 
     if unwarp is None:
         from sdcflows.transform import B0FieldTransform
@@ -691,8 +668,8 @@ def _b0_resampler(in_file, coeffs, pe, ro, hmc_xfm=None, unwarp=None, newpath=No
         )
 
     if hmc_xfm is not None:
-        from nitransforms.linear import Affine
         from nitransforms.io.itk import ITKLinearTransform as XFMLoader
+        from nitransforms.linear import Affine
 
         unwarp.xfm = Affine(XFMLoader.from_filename(hmc_xfm).to_ras())
 
diff --git a/sdcflows/interfaces/epi.py b/sdcflows/interfaces/epi.py
index b1931a9327..a7e439abe8 100644
--- a/sdcflows/interfaces/epi.py
+++ b/sdcflows/interfaces/epi.py
@@ -35,18 +35,18 @@
 
 
 class _GetReadoutTimeInputSpec(BaseInterfaceInputSpec):
-    in_file = File(exists=True, desc="EPI image corresponding to the metadata")
-    metadata = traits.Dict(mandatory=True, desc="metadata corresponding to the inputs")
+    in_file = File(exists=True, desc='EPI image corresponding to the metadata')
+    metadata = traits.Dict(mandatory=True, desc='metadata corresponding to the inputs')
     use_estimate = traits.Bool(
         False, usedefault=True, desc='Use "Estimated*" fields to calculate TotalReadoutTime'
     )
-    fallback = traits.Float(desc="A fallback value, in seconds.")
+    fallback = traits.Float(desc='A fallback value, in seconds.')
 
 
 class _GetReadoutTimeOutputSpec(TraitedSpec):
     readout_time = traits.Float
-    pe_direction = traits.Enum("i", "i-", "j", "j-", "k", "k-")
-    pe_dir_fsl = traits.Enum("x", "x-", "y", "y-", "z", "z-")
+    pe_direction = traits.Enum('i', 'i-', 'j', 'j-', 'k', 'k-')
+    pe_dir_fsl = traits.Enum('x', 'x-', 'y', 'y-', 'z', 'z-')
 
 
 class GetReadoutTime(SimpleInterface):
@@ -58,18 +58,18 @@ class GetReadoutTime(SimpleInterface):
     def _run_interface(self, runtime):
         from ..utils.epimanip import get_trt
 
-        self._results["readout_time"] = get_trt(
+        self._results['readout_time'] = get_trt(
             self.inputs.metadata,
             self.inputs.in_file if isdefined(self.inputs.in_file) else None,
             use_estimate=self.inputs.use_estimate,
             fallback=self.inputs.fallback or None,
         )
-        self._results["pe_direction"] = self.inputs.metadata["PhaseEncodingDirection"]
-        self._results["pe_dir_fsl"] = (
-            self.inputs.metadata["PhaseEncodingDirection"]
-            .replace("i", "x")
-            .replace("j", "y")
-            .replace("k", "z")
+        self._results['pe_direction'] = self.inputs.metadata['PhaseEncodingDirection']
+        self._results['pe_dir_fsl'] = (
+            self.inputs.metadata['PhaseEncodingDirection']
+            .replace('i', 'x')
+            .replace('j', 'y')
+            .replace('k', 'z')
         )
         return runtime
 
@@ -78,37 +78,32 @@ class _SortPEBlipsInputSpec(BaseInterfaceInputSpec):
     in_data = InputMultiObject(
         File(exists=True),
         mandatory=True,
-        desc="list of input data",
+        desc='list of input data',
     )
     pe_dirs_fsl = InputMultiObject(
-        traits.Enum("x", "x-", "y", "y-", "z", "z-"),
+        traits.Enum('x', 'x-', 'y', 'y-', 'z', 'z-'),
         mandatory=True,
         desc="list of PE directions, in FSL's conventions",
     )
     readout_times = InputMultiObject(
-        traits.Float,
-        mandatory=True,
-        desc="list of total readout times"
+        traits.Float, mandatory=True, desc='list of total readout times'
     )
 
 
 class _SortPEBlipsOutputSpec(TraitedSpec):
     out_data = OutputMultiObject(
         File(),
-        desc="list of input data",
+        desc='list of input data',
     )
     pe_dirs = OutputMultiObject(
-        traits.Enum("i", "i-", "j", "j-", "k", "k-"),
+        traits.Enum('i', 'i-', 'j', 'j-', 'k', 'k-'),
         desc="list of PE directions, in BIDS's conventions",
     )
     pe_dirs_fsl = OutputMultiObject(
-        traits.Enum("x", "x-", "y", "y-", "z", "z-"),
+        traits.Enum('x', 'x-', 'y', 'y-', 'z', 'z-'),
         desc="list of PE directions, in FSL's conventions",
     )
-    readout_times = OutputMultiObject(
-        traits.Float,
-        desc="list of total readout times"
-    )
+    readout_times = OutputMultiObject(traits.Float, desc='list of total readout times')
 
 
 class SortPEBlips(SimpleInterface):
@@ -119,29 +114,27 @@ class SortPEBlips(SimpleInterface):
 
     def _run_interface(self, runtime):
         # Put sign first
-        blips = [
-            f"+{pe[0]}" if len(pe) == 1 else f"-{pe[0]}"
-            for pe in self.inputs.pe_dirs_fsl
-        ]
-        sorted_inputs = sorted(zip(
-            blips,
-            self.inputs.readout_times,
-            self.inputs.in_data,
-        ))
+        blips = [f'+{pe[0]}' if len(pe) == 1 else f'-{pe[0]}' for pe in self.inputs.pe_dirs_fsl]
+        sorted_inputs = sorted(
+            zip(
+                blips,
+                self.inputs.readout_times,
+                self.inputs.in_data,
+            )
+        )
 
         (
-            self._results["pe_dirs_fsl"],
-            self._results["readout_times"],
-            self._results["out_data"],
+            self._results['pe_dirs_fsl'],
+            self._results['readout_times'],
+            self._results['out_data'],
         ) = zip(*sorted_inputs)
 
         # Put sign back last
-        self._results["pe_dirs_fsl"] = [
-            pe[1] if pe.startswith("+") else f"{pe[1]}-"
-            for pe in self._results["pe_dirs_fsl"]
+        self._results['pe_dirs_fsl'] = [
+            pe[1] if pe.startswith('+') else f'{pe[1]}-' for pe in self._results['pe_dirs_fsl']
         ]
-        self._results["pe_dirs"] = [
-            pe.replace("x", "i").replace("y", "j").replace("z", "k")
-            for pe in self._results["pe_dirs_fsl"]
+        self._results['pe_dirs'] = [
+            pe.replace('x', 'i').replace('y', 'j').replace('z', 'k')
+            for pe in self._results['pe_dirs_fsl']
         ]
         return runtime
diff --git a/sdcflows/interfaces/fmap.py b/sdcflows/interfaces/fmap.py
index 6327460faf..28a4d12141 100644
--- a/sdcflows/interfaces/fmap.py
+++ b/sdcflows/interfaces/fmap.py
@@ -21,32 +21,34 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Interfaces to deal with the various types of fieldmap sources."""
+
 import os
-import numpy as np
+
 import nibabel as nb
 import nitransforms as nt
-from nipype.utils.filemanip import fname_presuffix
+import numpy as np
 from nipype import logging
+from nipype.interfaces import freesurfer as fs
 from nipype.interfaces.base import (
     BaseInterfaceInputSpec,
-    TraitedSpec,
     File,
-    traits,
-    SimpleInterface,
     InputMultiObject,
     OutputMultiObject,
+    SimpleInterface,
+    TraitedSpec,
+    traits,
 )
-from nipype.interfaces import freesurfer as fs
+from nipype.utils.filemanip import fname_presuffix
 
-LOGGER = logging.getLogger("nipype.interface")
+LOGGER = logging.getLogger('nipype.interface')
 
 
 class _PhaseMap2radsInputSpec(BaseInterfaceInputSpec):
-    in_file = File(exists=True, mandatory=True, desc="input (wrapped) phase map")
+    in_file = File(exists=True, mandatory=True, desc='input (wrapped) phase map')
 
 
 class _PhaseMap2radsOutputSpec(TraitedSpec):
-    out_file = File(desc="the phase map in the range 0 - 6.28")
+    out_file = File(desc='the phase map in the range 0 - 6.28')
 
 
 class PhaseMap2rads(SimpleInterface):
@@ -58,20 +60,18 @@ class PhaseMap2rads(SimpleInterface):
     def _run_interface(self, runtime):
         from ..utils.phasemanip import au2rads
 
-        self._results["out_file"] = au2rads(self.inputs.in_file, newpath=runtime.cwd)
+        self._results['out_file'] = au2rads(self.inputs.in_file, newpath=runtime.cwd)
         return runtime
 
 
 class _SubtractPhasesInputSpec(BaseInterfaceInputSpec):
-    in_phases = traits.List(File(exists=True), min=1, max=2, desc="input phase maps")
-    in_meta = traits.List(
-        traits.Dict(), min=1, max=2, desc="metadata corresponding to the inputs"
-    )
+    in_phases = traits.List(File(exists=True), min=1, max=2, desc='input phase maps')
+    in_meta = traits.List(traits.Dict(), min=1, max=2, desc='metadata corresponding to the inputs')
 
 
 class _SubtractPhasesOutputSpec(TraitedSpec):
-    phase_diff = File(exists=True, desc="phase difference map")
-    metadata = traits.Dict(desc="output metadata")
+    phase_diff = File(exists=True, desc='phase difference map')
+    metadata = traits.Dict(desc='output metadata')
 
 
 class SubtractPhases(SimpleInterface):
@@ -83,19 +83,18 @@ class SubtractPhases(SimpleInterface):
     def _run_interface(self, runtime):
         if len(self.inputs.in_phases) != len(self.inputs.in_meta):
             raise ValueError(
-                "Length of input phase-difference maps and metadata files "
-                "should match."
+                'Length of input phase-difference maps and metadata files should match.'
             )
 
         if len(self.inputs.in_phases) == 1:
-            self._results["phase_diff"] = self.inputs.in_phases[0]
-            self._results["metadata"] = self.inputs.in_meta[0]
+            self._results['phase_diff'] = self.inputs.in_phases[0]
+            self._results['metadata'] = self.inputs.in_meta[0]
             return runtime
 
         from ..utils.phasemanip import subtract_phases as _subtract_phases
 
         # Discard in_meta traits with copy(), so that pop() works.
-        self._results["phase_diff"], self._results["metadata"] = _subtract_phases(
+        self._results['phase_diff'], self._results['metadata'] = _subtract_phases(
             self.inputs.in_phases,
             (self.inputs.in_meta[0].copy(), self.inputs.in_meta[1].copy()),
             newpath=runtime.cwd,
@@ -105,12 +104,12 @@ def _run_interface(self, runtime):
 
 
 class _Phasediff2FieldmapInputSpec(BaseInterfaceInputSpec):
-    in_file = File(exists=True, mandatory=True, desc="input fieldmap")
-    metadata = traits.Dict(mandatory=True, desc="BIDS metadata dictionary")
+    in_file = File(exists=True, mandatory=True, desc='input fieldmap')
+    metadata = traits.Dict(mandatory=True, desc='BIDS metadata dictionary')
 
 
 class _Phasediff2FieldmapOutputSpec(TraitedSpec):
-    out_file = File(desc="the output fieldmap")
+    out_file = File(desc='the output fieldmap')
 
 
 class Phasediff2Fieldmap(SimpleInterface):
@@ -120,21 +119,22 @@ class Phasediff2Fieldmap(SimpleInterface):
     output_spec = _Phasediff2FieldmapOutputSpec
 
     def _run_interface(self, runtime):
-        from ..utils.phasemanip import phdiff2fmap, delta_te as _delta_te
+        from ..utils.phasemanip import delta_te as _delta_te
+        from ..utils.phasemanip import phdiff2fmap
 
-        self._results["out_file"] = phdiff2fmap(
+        self._results['out_file'] = phdiff2fmap(
             self.inputs.in_file, _delta_te(self.inputs.metadata), newpath=runtime.cwd
         )
         return runtime
 
 
 class _CheckB0UnitsInputSpec(BaseInterfaceInputSpec):
-    in_file = File(exists=True, mandatory=True, desc="input fieldmap")
-    units = traits.Enum("Hz", "rad/s", mandatory=True, desc="fieldmap units")
+    in_file = File(exists=True, mandatory=True, desc='input fieldmap')
+    units = traits.Enum('Hz', 'rad/s', mandatory=True, desc='fieldmap units')
 
 
 class _CheckB0UnitsOutputSpec(TraitedSpec):
-    out_file = File(exists=True, desc="output fieldmap in Hz")
+    out_file = File(exists=True, desc='output fieldmap in Hz')
 
 
 class CheckB0Units(SimpleInterface):
@@ -144,36 +144,34 @@ class CheckB0Units(SimpleInterface):
     output_spec = _CheckB0UnitsOutputSpec
 
     def _run_interface(self, runtime):
-        if self.inputs.units == "Hz":
-            self._results["out_file"] = self.inputs.in_file
+        if self.inputs.units == 'Hz':
+            self._results['out_file'] = self.inputs.in_file
             return runtime
 
-        self._results["out_file"] = fname_presuffix(
-            self.inputs.in_file, suffix="_Hz", newpath=runtime.cwd
+        self._results['out_file'] = fname_presuffix(
+            self.inputs.in_file, suffix='_Hz', newpath=runtime.cwd
         )
         img = nb.load(self.inputs.in_file)
         data = np.asanyarray(img.dataobj) / (2.0 * np.pi)
-        img.__class__(data, img.affine, img.header).to_filename(
-            self._results["out_file"]
-        )
+        img.__class__(data, img.affine, img.header).to_filename(self._results['out_file'])
         return runtime
 
 
 class _DisplacementsField2FieldmapInputSpec(BaseInterfaceInputSpec):
-    transform = File(exists=True, mandatory=True, desc="input displacements field")
-    epi = File(exists=True, mandatory=True, desc="source EPI image")
-    ro_time = traits.Float(mandatory=True, desc="total readout time")
+    transform = File(exists=True, mandatory=True, desc='input displacements field')
+    epi = File(exists=True, mandatory=True, desc='source EPI image')
+    ro_time = traits.Float(mandatory=True, desc='total readout time')
     pe_dir = traits.Enum(
-        "j-", "j", "i", "i-", "k", "k-", mandatory=True, desc="phase encoding direction"
+        'j-', 'j', 'i', 'i-', 'k', 'k-', mandatory=True, desc='phase encoding direction'
     )
-    demean = traits.Bool(False, usedefault=True, desc="regress field to the mean")
+    demean = traits.Bool(False, usedefault=True, desc='regress field to the mean')
     itk_transform = traits.Bool(
-        True, usedefault=True, desc="whether this is an ITK/ANTs transform"
+        True, usedefault=True, desc='whether this is an ITK/ANTs transform'
     )
 
 
 class _DisplacementsField2FieldmapOutputSpec(TraitedSpec):
-    out_file = File(exists=True, desc="output fieldmap in Hz")
+    out_file = File(exists=True, desc='output fieldmap in Hz')
 
 
 class DisplacementsField2Fieldmap(SimpleInterface):
@@ -185,8 +183,8 @@ class DisplacementsField2Fieldmap(SimpleInterface):
     def _run_interface(self, runtime):
         from sdcflows.transform import disp_to_fmap
 
-        self._results["out_file"] = fname_presuffix(
-            self.inputs.transform, suffix="_Hz", newpath=runtime.cwd
+        self._results['out_file'] = fname_presuffix(
+            self.inputs.transform, suffix='_Hz', newpath=runtime.cwd
         )
         fmapnii = disp_to_fmap(
             nb.load(self.inputs.transform),
@@ -201,12 +199,12 @@ def _run_interface(self, runtime):
             data -= np.median(data)
 
             fmapnii = fmapnii.__class__(
-                data.astype("float32"),
+                data.astype('float32'),
                 fmapnii.affine,
                 fmapnii.header,
             )
 
-        fmapnii.to_filename(self._results["out_file"])
+        fmapnii.to_filename(self._results['out_file'])
         return runtime
 
 
@@ -216,31 +214,31 @@ class _CheckRegisterInputSpec(TraitedSpec):
         mandatory=True,
         minlen=1,
         maxlen=2,
-        desc="Magnitude image(s) to verify registration",
+        desc='Magnitude image(s) to verify registration',
     )
     fmap_files = InputMultiObject(
         File(exists=True),
         mandatory=True,
         minlen=1,
         maxlen=2,
-        desc="Phase(diff) or fieldmap image(s) to update affines",
+        desc='Phase(diff) or fieldmap image(s) to update affines',
     )
     rot_thresh = traits.Float(
-        0.02, usedefault=True, mandatory=True, desc="rotation threshold in radians"
+        0.02, usedefault=True, mandatory=True, desc='rotation threshold in radians'
     )
     trans_thresh = traits.Float(
-        1., usedefault=True, mandatory=True, desc="translation threshold in mm"
+        1.0, usedefault=True, mandatory=True, desc='translation threshold in mm'
     )
 
 
 class _CheckRegisterOutputSpec(TraitedSpec):
     mag_files = OutputMultiObject(
         File,
-        desc="Magnitude image(s) verified to be in register, with consistent affines",
+        desc='Magnitude image(s) verified to be in register, with consistent affines',
     )
     fmap_files = OutputMultiObject(
         File,
-        desc="Fieldmap files with consistent affines",
+        desc='Fieldmap files with consistent affines',
     )
 
 
@@ -323,14 +321,12 @@ def _run_interface(self, runtime):
 
                 if np.any(angles > rot_thresh) or np.any(vec > trans_thresh):
                     LOGGER.critical(
-                        "Magnitude files {mag_files} are not in register with rotation "
-                        f"threshold {self.inputs.rot_thresh} and translation threshold "
-                        f"{self.inputs.trans_thresh}. Please manually verify images "
-                        "are in register and update the image headers before running SDC."
-                    )
-                    raise ValueError(
-                        "Magnitude 1/2 orientation mismatch too big to ignore."
+                        'Magnitude files {mag_files} are not in register with rotation '
+                        f'threshold {self.inputs.rot_thresh} and translation threshold '
+                        f'{self.inputs.trans_thresh}. Please manually verify images '
+                        'are in register and update the image headers before running SDC.'
                     )
+                    raise ValueError('Magnitude 1/2 orientation mismatch too big to ignore.')
 
         # Probably redundant, but we could hit this error
         # with phase1/magnitude1 + wonky phase2 + no magnitude2
@@ -345,8 +341,8 @@ def _run_interface(self, runtime):
         out_fmaps = [_conform_img(fmap, mag_imgs[0], runtime.cwd) for fmap in fmap_imgs]
 
         self._results = {
-            "mag_files": out_mags,
-            "fmap_files": out_fmaps,
+            'mag_files': out_mags,
+            'fmap_files': out_fmaps,
         }
 
         return runtime
@@ -367,7 +363,7 @@ def _conform_img(
     basename = os.path.basename(img.get_filename())
     out_file = os.path.join(cwd, basename)
 
-    LOGGER.info(f"Copying affine to {basename}")
+    LOGGER.info(f'Copying affine to {basename}')
     new_img = img.__class__(img.dataobj, target_img.affine, img.header)
     new_img.to_filename(out_file)
 
@@ -380,13 +376,13 @@ def _check_gross_geometry(
 ):
     if img1.shape[:3] != img2.shape[:3]:
         return (
-            "Images have shape mismatch: "
-            f"{img1.get_filename()} {img1.shape}, "
-            f"{img2.get_filename()} {img2.shape}"
+            'Images have shape mismatch: '
+            f'{img1.get_filename()} {img1.shape}, '
+            f'{img2.get_filename()} {img2.shape}'
         )
     if nb.aff2axcodes(img1.affine) != nb.aff2axcodes(img2.affine):
         return (
-            "Images have orientation mismatch: "
-            f"{img1.get_filename()} {''.join(nb.aff2axcodes(img1.affine))}, "
-            f"{img2.get_filename()} {''.join(nb.aff2axcodes(img2.affine))}"
+            'Images have orientation mismatch: '
+            f'{img1.get_filename()} {"".join(nb.aff2axcodes(img1.affine))}, '
+            f'{img2.get_filename()} {"".join(nb.aff2axcodes(img2.affine))}'
         )
diff --git a/sdcflows/interfaces/reportlets.py b/sdcflows/interfaces/reportlets.py
index 31856ea3db..3f7b05f39e 100644
--- a/sdcflows/interfaces/reportlets.py
+++ b/sdcflows/interfaces/reportlets.py
@@ -21,37 +21,34 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Interfaces to generate speciality reportlets."""
-import numpy as np
+
 import nibabel as nb
-from nilearn.image import threshold_img, load_img
-from niworkflows import NIWORKFLOWS_LOG
-from niworkflows.utils.images import rotation2canonical, rotate_affine
-from nireports.reportlets.utils import cuts_from_bbox, compose_view
+import numpy as np
+from nilearn.image import load_img, threshold_img
 from nipype.interfaces.base import File, isdefined, traits
 from nipype.interfaces.mixins import reporting
+from nireports.reportlets.utils import compose_view, cuts_from_bbox
+from niworkflows import NIWORKFLOWS_LOG
+from niworkflows.utils.images import rotate_affine, rotation2canonical
 
-from ..viz.utils import plot_registration, coolwarm_transparent
+from ..viz.utils import coolwarm_transparent, plot_registration
 
 
 class _FieldmapReportletInputSpec(reporting.ReportCapableInputSpec):
-    reference = File(exists=True, mandatory=True, desc="input reference")
-    moving = File(exists=True, desc="input moving")
-    fieldmap = File(exists=True, mandatory=True, desc="input fieldmap")
-    max_alpha = traits.Float(0.7, usedefault=True, desc="maximum alpha channel")
-    mask = File(exists=True, desc="brain mask")
-    out_report = File(
-        "report.svg", usedefault=True, desc="filename for the visual report"
-    )
-    show = traits.Enum(
-        1, 0, "both", usedefault=True, desc="where the fieldmap should be shown"
-    )
+    reference = File(exists=True, mandatory=True, desc='input reference')
+    moving = File(exists=True, desc='input moving')
+    fieldmap = File(exists=True, mandatory=True, desc='input fieldmap')
+    max_alpha = traits.Float(0.7, usedefault=True, desc='maximum alpha channel')
+    mask = File(exists=True, desc='brain mask')
+    out_report = File('report.svg', usedefault=True, desc='filename for the visual report')
+    show = traits.Enum(1, 0, 'both', usedefault=True, desc='where the fieldmap should be shown')
     reference_label = traits.Str(
-        "Reference", usedefault=True, desc="a label name for the reference mosaic"
+        'Reference', usedefault=True, desc='a label name for the reference mosaic'
     )
     moving_label = traits.Str(
-        "Fieldmap (Hz)", usedefault=True, desc="a label name for the reference mosaic"
+        'Fieldmap (Hz)', usedefault=True, desc='a label name for the reference mosaic'
     )
-    apply_mask = traits.Bool(False, usedefault=True, desc="zero values outside mask")
+    apply_mask = traits.Bool(False, usedefault=True, desc='zero values outside mask')
 
 
 class FieldmapReportlet(reporting.ReportCapableInterface):
@@ -63,7 +60,7 @@ class FieldmapReportlet(reporting.ReportCapableInterface):
 
     def __init__(self, **kwargs):
         """Instantiate FieldmapReportlet."""
-        self._n_cuts = kwargs.pop("n_cuts", self._n_cuts)
+        self._n_cuts = kwargs.pop('n_cuts', self._n_cuts)
         super(FieldmapReportlet, self).__init__(generate_report=True, **kwargs)
 
     def _run_interface(self, runtime):
@@ -71,15 +68,13 @@ def _run_interface(self, runtime):
 
     def _generate_report(self):
         """Generate a reportlet."""
-        NIWORKFLOWS_LOG.info("Generating visual report")
+        NIWORKFLOWS_LOG.info('Generating visual report')
 
         movnii = load_img(self.inputs.reference)
         canonical_r = rotation2canonical(movnii)
         movnii = refnii = rotate_affine(movnii, rot=canonical_r)
 
-        fmapnii = nb.squeeze_image(
-            rotate_affine(load_img(self.inputs.fieldmap), rot=canonical_r)
-        )
+        fmapnii = nb.squeeze_image(rotate_affine(load_img(self.inputs.fieldmap), rot=canonical_r))
 
         if fmapnii.dataobj.ndim == 4:
             for i, tstep in enumerate(nb.four_to_three(fmapnii)):
@@ -109,39 +104,39 @@ def _generate_report(self):
 
         fmap_overlay = [
             {
-                "overlay": fmapnii,
-                "overlay_params": {
-                    "cmap": coolwarm_transparent(max_alpha=self.inputs.max_alpha),
-                    "vmax": vmax,
-                    "vmin": -vmax,
+                'overlay': fmapnii,
+                'overlay_params': {
+                    'cmap': coolwarm_transparent(max_alpha=self.inputs.max_alpha),
+                    'vmax': vmax,
+                    'vmin': -vmax,
                 },
             }
         ] * 2
 
-        if self.inputs.show != "both":
+        if self.inputs.show != 'both':
             fmap_overlay[not self.inputs.show] = {}
 
         # Call composer
         compose_view(
             plot_registration(
                 movnii,
-                "moving-image",
+                'moving-image',
                 estimate_brightness=True,
                 cuts=cuts,
                 label=self.inputs.moving_label,
                 contour=contour_nii,
                 compress=False,
-                **fmap_overlay[1]
+                **fmap_overlay[1],
             ),
             plot_registration(
                 refnii,
-                "fixed-image",
+                'fixed-image',
                 estimate_brightness=True,
                 cuts=cuts,
                 label=self.inputs.reference_label,
                 contour=contour_nii,
                 compress=False,
-                **fmap_overlay[0]
+                **fmap_overlay[0],
             ),
             out_file=self._out_report,
         )
diff --git a/sdcflows/interfaces/tests/test_bspline.py b/sdcflows/interfaces/tests/test_bspline.py
index d10b49684b..dccb237eb0 100644
--- a/sdcflows/interfaces/tests/test_bspline.py
+++ b/sdcflows/interfaces/tests/test_bspline.py
@@ -21,23 +21,25 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test B-Spline interfaces."""
+
 import os
-import numpy as np
+
 import nibabel as nb
+import numpy as np
 import pytest
 
 from ..bspline import (
-    bspline_grid,
     ApplyCoeffsField,
     BSplineApprox,
     TOPUPCoeffReorient,
     _fix_topup_fieldcoeff,
+    bspline_grid,
 )
 
 rng = np.random.default_rng(seed=20160305)  # First commit in nipreps/sdcflows
 
 
-@pytest.mark.parametrize("testnum", range(100))
+@pytest.mark.parametrize('testnum', range(100))
 def test_bsplines(tmp_path, testnum):
     """Test idempotency of B-Splines interpolation + approximation."""
     targetshape = (50, 50, 30)
@@ -48,9 +50,7 @@ def test_bsplines(tmp_path, testnum):
     )
 
     # Intendedly mis-centered (exercise we may not have volume-centered NIfTIs)
-    targetaff[:3, 3] = nb.affines.apply_affine(
-        targetaff, 0.5 * (np.array(targetshape) - 3)
-    )
+    targetaff[:3, 3] = nb.affines.apply_affine(targetaff, 0.5 * (np.array(targetshape) - 3))
 
     mask = np.zeros(targetshape)
     mask[10:-10, 10:-10, 6:-6] = 1
@@ -58,24 +58,24 @@ def test_bsplines(tmp_path, testnum):
     targetnii = nb.Nifti1Image(mask, targetaff, None)
     targetnii.header.set_qform(targetaff, code=1)
     targetnii.header.set_sform(targetaff, code=1)
-    targetnii.to_filename(tmp_path / "mask.nii.gz")
+    targetnii.to_filename(tmp_path / 'mask.nii.gz')
 
     # Generate random coefficients
     gridnii = bspline_grid(targetnii, control_zooms_mm=(40, 40, 16))
     coeff = (rng.standard_normal(size=gridnii.shape)) * 100
-    coeffnii = nb.Nifti1Image(coeff.astype("float32"), gridnii.affine, gridnii.header)
-    coeffnii.header["cal_max"] = np.abs(coeff).max()
-    coeffnii.header["cal_min"] = -coeffnii.header["cal_max"]
+    coeffnii = nb.Nifti1Image(coeff.astype('float32'), gridnii.affine, gridnii.header)
+    coeffnii.header['cal_max'] = np.abs(coeff).max()
+    coeffnii.header['cal_min'] = -coeffnii.header['cal_max']
     coeffnii.header.set_qform(gridnii.affine, code=1)
     coeffnii.header.set_sform(gridnii.affine, code=1)
-    coeffnii.to_filename(tmp_path / "coeffs.nii.gz")
+    coeffnii.to_filename(tmp_path / 'coeffs.nii.gz')
 
     os.chdir(tmp_path)
     # Check that we can interpolate the coefficients on a target
     test1 = ApplyCoeffsField(
-        in_data=str(tmp_path / "mask.nii.gz"),
-        in_coeff=str(tmp_path / "coeffs.nii.gz"),
-        pe_dir="j-",
+        in_data=str(tmp_path / 'mask.nii.gz'),
+        in_coeff=str(tmp_path / 'coeffs.nii.gz'),
+        pe_dir='j-',
         ro_time=1.0,
     ).run()
 
@@ -84,18 +84,18 @@ def test_bsplines(tmp_path, testnum):
     fielddata -= np.median(fielddata)
     fielddata = 200 * fielddata / np.abs(fielddata).max()
 
-    fieldnii.header["cal_max"] = np.abs(fielddata).max()
-    fieldnii.header["cal_min"] = -fieldnii.header["cal_max"]
+    fieldnii.header['cal_max'] = np.abs(fielddata).max()
+    fieldnii.header['cal_min'] = -fieldnii.header['cal_max']
     fieldnii.header.set_qform(targetaff, code=1)
     fieldnii.header.set_sform(targetaff, code=1)
 
     nb.Nifti1Image(fielddata, targetaff, fieldnii.header).to_filename(
-        tmp_path / "testfield.nii.gz",
+        tmp_path / 'testfield.nii.gz',
     )
 
     # Approximate the interpolated target
     test2 = BSplineApprox(
-        in_data=str(tmp_path / "testfield.nii.gz"),
+        in_data=str(tmp_path / 'testfield.nii.gz'),
         # in_mask=str(tmp_path / "mask.nii.gz"),
         bs_spacing=[(40, 40, 16)],
         zooms_min=0,
@@ -113,44 +113,40 @@ def test_topup_coeffs(tmpdir, testdata_dir):
     """Check the revision of TOPUP headers."""
     tmpdir.chdir()
     result = TOPUPCoeffReorient(
-        in_coeff=str(testdata_dir / "topup-coeff.nii.gz"),
-        fmap_ref=str(testdata_dir / "epi.nii.gz"),
-        pe_dir="j",
+        in_coeff=str(testdata_dir / 'topup-coeff.nii.gz'),
+        fmap_ref=str(testdata_dir / 'epi.nii.gz'),
+        pe_dir='j',
     ).run()
 
     nii = nb.load(result.outputs.out_coeff)
-    ctrl = nb.load(testdata_dir / "topup-coeff-fixed.nii.gz")
+    ctrl = nb.load(testdata_dir / 'topup-coeff-fixed.nii.gz')
     assert np.allclose(nii.affine, ctrl.affine)
 
     nb.Nifti1Image(nii.get_fdata()[:-1, :-1, :-1], nii.affine, nii.header).to_filename(
-        "failing.nii.gz"
+        'failing.nii.gz'
     )
 
     with pytest.raises(ValueError):
         TOPUPCoeffReorient(
-            in_coeff="failing.nii.gz",
-            fmap_ref=str(testdata_dir / "epi.nii.gz"),
-            pe_dir="j",
+            in_coeff='failing.nii.gz',
+            fmap_ref=str(testdata_dir / 'epi.nii.gz'),
+            pe_dir='j',
         ).run()
 
     # Test automatic output file name generation, just for coverage
     with pytest.raises(ValueError):
-        _fix_topup_fieldcoeff("failing.nii.gz", str(testdata_dir / "epi.nii.gz"), "i")
+        _fix_topup_fieldcoeff('failing.nii.gz', str(testdata_dir / 'epi.nii.gz'), 'i')
 
 
 def test_topup_coeffs_interpolation(tmpdir, testdata_dir):
     """Check that our interpolation is not far away from TOPUP's."""
     tmpdir.chdir()
     result = ApplyCoeffsField(
-        in_data=str(testdata_dir / "epi.nii.gz"),
-        in_coeff=str(testdata_dir / "topup-coeff-fixed.nii.gz"),
-        pe_dir="j-",
+        in_data=str(testdata_dir / 'epi.nii.gz'),
+        in_coeff=str(testdata_dir / 'topup-coeff-fixed.nii.gz'),
+        pe_dir='j-',
         ro_time=1.0,
     ).run()
-    interpolated = nb.as_closest_canonical(
-        nb.load(result.outputs.out_field)
-    ).get_fdata()
-    reference = nb.as_closest_canonical(
-        nb.load(testdata_dir / "topup-field.nii.gz")
-    ).get_fdata()
+    interpolated = nb.as_closest_canonical(nb.load(result.outputs.out_field)).get_fdata()
+    reference = nb.as_closest_canonical(nb.load(testdata_dir / 'topup-field.nii.gz')).get_fdata()
     assert np.sqrt(np.mean((interpolated - reference) ** 2)) < 3
diff --git a/sdcflows/interfaces/tests/test_epi.py b/sdcflows/interfaces/tests/test_epi.py
index c6fa877fa3..53ed424780 100644
--- a/sdcflows/interfaces/tests/test_epi.py
+++ b/sdcflows/interfaces/tests/test_epi.py
@@ -21,20 +21,21 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test EPI interfaces."""
+
 from pathlib import Path
+
 from ..epi import SortPEBlips
 
 
 def test_sort_pe_blips(tmpdir):
-
     tmpdir.chdir()
 
-    input_comb = [("x-", 0.08), ("x-", 0.04), ("y-", 0.05), ("y", 0.05), ("x", 0.05)]
+    input_comb = [('x-', 0.08), ('x-', 0.04), ('y-', 0.05), ('y', 0.05), ('x', 0.05)]
 
     fnames = []
     for i in range(len(input_comb)):
-        fnames.append(f"file{i}.nii")
-        Path(fnames[-1]).write_text("")
+        fnames.append(f'file{i}.nii')
+        Path(fnames[-1]).write_text('')
 
     result = SortPEBlips(
         in_data=fnames,
@@ -42,4 +43,4 @@ def test_sort_pe_blips(tmpdir):
         readout_times=[trt for _, trt in input_comb],
     ).run()
 
-    assert result.outputs.out_data == [f"file{i}.nii" for i in (4, 3, 1, 0, 2)]
+    assert result.outputs.out_data == [f'file{i}.nii' for i in (4, 3, 1, 0, 2)]
diff --git a/sdcflows/interfaces/tests/test_fmap.py b/sdcflows/interfaces/tests/test_fmap.py
index 24a227b8dc..c07dba54f8 100644
--- a/sdcflows/interfaces/tests/test_fmap.py
+++ b/sdcflows/interfaces/tests/test_fmap.py
@@ -21,26 +21,27 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test fieldmap interfaces."""
-import numpy as np
+
 import nibabel as nb
+import numpy as np
 import pytest
 
 from ..fmap import CheckB0Units
 
 
-@pytest.mark.parametrize("units", ("rad/s", "Hz"))
+@pytest.mark.parametrize('units', ('rad/s', 'Hz'))
 def test_units(tmpdir, units):
     """Check the conversion of units."""
     tmpdir.chdir()
-    hz = np.ones((5, 5, 5), dtype="float32") * 100
+    hz = np.ones((5, 5, 5), dtype='float32') * 100
     data = hz.copy()
 
-    if units == "rad/s":
+    if units == 'rad/s':
         data *= 2.0 * np.pi
 
-    nb.Nifti1Image(data, np.eye(4), None).to_filename("data.nii.gz")
+    nb.Nifti1Image(data, np.eye(4), None).to_filename('data.nii.gz')
     out_data = nb.load(
-        CheckB0Units(units=units, in_file="data.nii.gz").run().outputs.out_file
-    ).get_fdata(dtype="float32")
+        CheckB0Units(units=units, in_file='data.nii.gz').run().outputs.out_file
+    ).get_fdata(dtype='float32')
 
     assert np.allclose(hz, out_data)
diff --git a/sdcflows/interfaces/tests/test_reportlets.py b/sdcflows/interfaces/tests/test_reportlets.py
index 433a4cb06b..d862ca5341 100644
--- a/sdcflows/interfaces/tests/test_reportlets.py
+++ b/sdcflows/interfaces/tests/test_reportlets.py
@@ -21,14 +21,17 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test the fieldmap reportlets."""
+
 from pathlib import Path
+
 import pytest
-from ..reportlets import FieldmapReportlet
+
 from ...utils.epimanip import epi_mask
+from ..reportlets import FieldmapReportlet
 
 
-@pytest.mark.parametrize("mask", [True, False])
-@pytest.mark.parametrize("apply_mask", [True, False])
+@pytest.mark.parametrize('mask', [True, False])
+@pytest.mark.parametrize('apply_mask', [True, False])
 def test_FieldmapReportlet(tmpdir, outdir, testdata_dir, mask, apply_mask):
     """Generate one reportlet."""
     tmpdir.chdir()
@@ -37,16 +40,14 @@ def test_FieldmapReportlet(tmpdir, outdir, testdata_dir, mask, apply_mask):
         outdir = Path.cwd()
 
     report = FieldmapReportlet(
-        reference=str(testdata_dir / "epi.nii.gz"),
-        moving=str(testdata_dir / "epi.nii.gz"),
-        fieldmap=str(testdata_dir / "topup-field.nii.gz"),
-        out_report=str(
-            outdir / f"test-fieldmap{'-masked' * mask}{'-zeroed' * apply_mask}.svg"
-        ),
+        reference=str(testdata_dir / 'epi.nii.gz'),
+        moving=str(testdata_dir / 'epi.nii.gz'),
+        fieldmap=str(testdata_dir / 'topup-field.nii.gz'),
+        out_report=str(outdir / f'test-fieldmap{"-masked" * mask}{"-zeroed" * apply_mask}.svg'),
         apply_mask=apply_mask,
     )
 
     if mask:
-        report.inputs.mask = epi_mask(str(testdata_dir / "epi.nii.gz"))
+        report.inputs.mask = epi_mask(str(testdata_dir / 'epi.nii.gz'))
 
     report.run()
diff --git a/sdcflows/interfaces/tests/test_utils.py b/sdcflows/interfaces/tests/test_utils.py
index d12d04cbc9..7d0998a4c1 100644
--- a/sdcflows/interfaces/tests/test_utils.py
+++ b/sdcflows/interfaces/tests/test_utils.py
@@ -21,52 +21,53 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test utilities."""
-import pytest
-import numpy as np
+
 import nibabel as nb
+import numpy as np
+import pytest
 
-from ..utils import Flatten, ConvertWarp, Deoblique, Reoblique, PadSlices
+from ..utils import ConvertWarp, Deoblique, Flatten, PadSlices, Reoblique
 
 
 def test_Flatten(tmpdir):
     """Test the flattening interface."""
     tmpdir.chdir()
     shape = (5, 5, 5)
-    nb.Nifti1Image(np.zeros(shape), np.eye(4), None).to_filename("file1.nii.gz")
-    nb.Nifti1Image(np.zeros((*shape, 6)), np.eye(4), None).to_filename("file2.nii.gz")
-    nb.Nifti1Image(np.zeros((*shape, 2)), np.eye(4), None).to_filename("file3.nii.gz")
+    nb.Nifti1Image(np.zeros(shape), np.eye(4), None).to_filename('file1.nii.gz')
+    nb.Nifti1Image(np.zeros((*shape, 6)), np.eye(4), None).to_filename('file2.nii.gz')
+    nb.Nifti1Image(np.zeros((*shape, 2)), np.eye(4), None).to_filename('file3.nii.gz')
 
     out = Flatten(
-        in_data=["file1.nii.gz", "file2.nii.gz", "file3.nii.gz"],
-        in_meta=[{"a": 1}, {"b": 2}, {"c": 3}],
+        in_data=['file1.nii.gz', 'file2.nii.gz', 'file3.nii.gz'],
+        in_meta=[{'a': 1}, {'b': 2}, {'c': 3}],
         max_trs=3,
     ).run()
 
     assert len(out.outputs.out_list) == 6
 
     out_meta = out.outputs.out_meta
-    assert out_meta[0] == {"a": 1}
-    assert out_meta[1] == out_meta[2] == out_meta[3] == {"b": 2}
-    assert out_meta[4] == out_meta[5] == {"c": 3}
+    assert out_meta[0] == {'a': 1}
+    assert out_meta[1] == out_meta[2] == out_meta[3] == {'b': 2}
+    assert out_meta[4] == out_meta[5] == {'c': 3}
 
 
-@pytest.mark.parametrize("shape", [(10, 10, 10, 1, 3), (10, 10, 10, 3)])
+@pytest.mark.parametrize('shape', [(10, 10, 10, 1, 3), (10, 10, 10, 3)])
 def test_ConvertWarp(tmpdir, shape):
     """Exercise the interface."""
     tmpdir.chdir()
 
-    nb.Nifti1Image(np.zeros(shape, dtype="uint8"), np.eye(4), None).to_filename("3dQwarp.nii.gz")
+    nb.Nifti1Image(np.zeros(shape, dtype='uint8'), np.eye(4), None).to_filename('3dQwarp.nii.gz')
 
-    out = ConvertWarp(in_file="3dQwarp.nii.gz").run()
+    out = ConvertWarp(in_file='3dQwarp.nii.gz').run()
 
     nii = nb.load(out.outputs.out_file)
     assert nii.header.get_data_dtype() == np.float32
-    assert nii.header.get_intent() == ("vector", (), "")
+    assert nii.header.get_intent() == ('vector', (), '')
     assert nii.shape == (10, 10, 10, 1, 3)
 
 
 @pytest.mark.parametrize(
-    "angles,oblique",
+    'angles,oblique',
     [
         ((0, 0, 0), False),
         ((0.9, 0.001, 0.001), True),
@@ -78,12 +79,12 @@ def test_Xeoblique(tmpdir, angles, oblique):
     tmpdir.chdir()
 
     affine = nb.affines.from_matvec(nb.eulerangles.euler2mat(*angles))
-    nb.Nifti1Image(np.zeros((10, 10, 10), dtype="uint8"), affine, None).to_filename("epi.nii.gz")
+    nb.Nifti1Image(np.zeros((10, 10, 10), dtype='uint8'), affine, None).to_filename('epi.nii.gz')
 
     result = (
         Deoblique(
-            in_file="epi.nii.gz",
-            in_mask="epi.nii.gz",
+            in_file='epi.nii.gz',
+            in_mask='epi.nii.gz',
         )
         .run()
         .outputs
@@ -95,7 +96,7 @@ def test_Xeoblique(tmpdir, angles, oblique):
         Reoblique(
             in_plumb=result.out_file,
             in_field=result.out_file,
-            in_epi="epi.nii.gz",
+            in_epi='epi.nii.gz',
         )
         .run()
         .outputs
@@ -105,7 +106,7 @@ def test_Xeoblique(tmpdir, angles, oblique):
 
 
 @pytest.mark.parametrize(
-    "in_shape,expected_shape,padded",
+    'in_shape,expected_shape,padded',
     [
         ((2, 2, 2), (2, 2, 2), False),
         ((2, 2, 3), (2, 2, 4), True),
@@ -121,8 +122,8 @@ def test_pad_slices(tmpdir, in_shape, expected_shape, padded):
 
     # RAS
     img = nb.Nifti1Image(data, aff)
-    img.to_filename("epi-ras.nii.gz")
-    res = PadSlices(in_file="epi-ras.nii.gz").run().outputs
+    img.to_filename('epi-ras.nii.gz')
+    res = PadSlices(in_file='epi-ras.nii.gz').run().outputs
 
     # LPS
     newaff = aff.copy()
@@ -130,8 +131,8 @@ def test_pad_slices(tmpdir, in_shape, expected_shape, padded):
     newaff[1, 1] *= -1.0
     newaff[:2, 3] = aff.dot(np.hstack((np.array(img.shape[:3]) - 1, 1.0)))[:2]
     img2 = nb.Nifti1Image(np.flip(np.flip(data, 0), 1), newaff)
-    img2.to_filename("epi-lps.nii.gz")
-    res2 = PadSlices(in_file="epi-lps.nii.gz").run().outputs
+    img2.to_filename('epi-lps.nii.gz')
+    res2 = PadSlices(in_file='epi-lps.nii.gz').run().outputs
 
     out_ras = nb.load(res.out_file)
     out_lps = nb.load(res2.out_file)
diff --git a/sdcflows/interfaces/utils.py b/sdcflows/interfaces/utils.py
index a50873737e..f315623de0 100644
--- a/sdcflows/interfaces/utils.py
+++ b/sdcflows/interfaces/utils.py
@@ -21,20 +21,24 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Utilities."""
+
 from itertools import product
+
+from nipype.interfaces.ants.segmentation import (
+    DenoiseImage as _DenoiseImageBase,
+)
+from nipype.interfaces.ants.segmentation import (
+    DenoiseImageInputSpec as _DenoiseImageInputSpecBase,
+)
 from nipype.interfaces.base import (
     BaseInterfaceInputSpec,
-    TraitedSpec,
     File,
-    traits,
-    SimpleInterface,
     InputMultiObject,
     OutputMultiObject,
+    SimpleInterface,
+    TraitedSpec,
     isdefined,
-)
-from nipype.interfaces.ants.segmentation import (
-    DenoiseImage as _DenoiseImageBase,
-    DenoiseImageInputSpec as _DenoiseImageInputSpecBase,
+    traits,
 )
 from nipype.interfaces.mixins import CopyHeaderInterface as _CopyHeaderInterface
 
@@ -47,14 +51,14 @@ class _FlattenInputSpec(BaseInterfaceInputSpec):
     in_data = InputMultiObject(
         File(exists=True),
         mandatory=True,
-        desc="list of input data",
+        desc='list of input data',
     )
     in_meta = InputMultiObject(
         traits.Dict(traits.Str),
         mandatory=True,
-        desc="list of metadata",
+        desc='list of metadata',
     )
-    max_trs = traits.Int(50, usedefault=True, desc="only pick first TRs")
+    max_trs = traits.Int(50, usedefault=True, desc='only pick first TRs')
 
 
 class _FlattenOutputSpec(TraitedSpec):
@@ -63,7 +67,7 @@ class _FlattenOutputSpec(TraitedSpec):
             File(exists=True),
             traits.Dict(traits.Str),
         ),
-        desc="list of output files",
+        desc='list of output files',
     )
     out_data = OutputMultiObject(File(exists=True))
     out_meta = OutputMultiObject(traits.Dict(traits.Str))
@@ -76,14 +80,14 @@ class Flatten(SimpleInterface):
     output_spec = _FlattenOutputSpec
 
     def _run_interface(self, runtime):
-        self._results["out_list"] = _flatten(
+        self._results['out_list'] = _flatten(
             zip(self.inputs.in_data, self.inputs.in_meta),
             max_trs=self.inputs.max_trs,
             out_dir=runtime.cwd,
         )
 
         # Unzip out_data, out_meta outputs.
-        self._results["out_data"], self._results["out_meta"] = zip(*self._results["out_list"])
+        self._results['out_data'], self._results['out_meta'] = zip(*self._results['out_list'])
         return runtime
 
 
@@ -91,9 +95,9 @@ class _UniformGridInputSpec(BaseInterfaceInputSpec):
     in_data = InputMultiObject(
         File(exists=True),
         mandatory=True,
-        desc="list of input data",
+        desc='list of input data',
     )
-    reference = traits.Int(0, usedefault=True, desc="reference index")
+    reference = traits.Int(0, usedefault=True, desc='reference index')
 
 
 class _UniformGridOutputSpec(TraitedSpec):
@@ -110,14 +114,14 @@ class UniformGrid(SimpleInterface):
     def _run_interface(self, runtime):
         import nibabel as nb
         import numpy as np
-        from nitransforms.linear import Affine
         from nipype.utils.filemanip import fname_presuffix
+        from nitransforms.linear import Affine
 
         retval = [None] * len(self.inputs.in_data)
-        self._results["reference"] = self.inputs.in_data[self.inputs.reference]
-        retval[self.inputs.reference] = self._results["reference"]
+        self._results['reference'] = self.inputs.in_data[self.inputs.reference]
+        retval[self.inputs.reference] = self._results['reference']
 
-        refnii = nb.load(self._results["reference"])
+        refnii = nb.load(self._results['reference'])
         refshape = refnii.shape[:3]
         refaff = refnii.affine
 
@@ -127,7 +131,7 @@ def _run_interface(self, runtime):
                 continue
 
             nii = nb.load(fname)
-            retval[i] = fname_presuffix(fname, suffix=f"_regrid{i:03d}", newpath=runtime.cwd)
+            retval[i] = fname_presuffix(fname, suffix=f'_regrid{i:03d}', newpath=runtime.cwd)
 
             if np.allclose(nii.shape[:3], refshape) and np.allclose(nii.affine, refaff):
                 if np.all(nii.affine == refaff):
@@ -144,29 +148,29 @@ def _run_interface(self, runtime):
             # Restore the original on-disk data type
             nii.__class__(regridded_img.dataobj, refaff, nii.header).to_filename(retval[i])
 
-        self._results["out_data"] = retval
+        self._results['out_data'] = retval
 
         return runtime
 
 
 class _ReorientImageAndMetadataInputSpec(TraitedSpec):
-    in_file = File(exists=True, mandatory=True, desc="Input 3- or 4D image")
-    target_orientation = traits.Str(desc="Axis codes of coordinate system to reorient to")
+    in_file = File(exists=True, mandatory=True, desc='Input 3- or 4D image')
+    target_orientation = traits.Str(desc='Axis codes of coordinate system to reorient to')
     pe_dir = InputMultiObject(
         traits.Enum(
-            *["".join(p) for p in product("ijkxyz", ("", "-"))],
+            *[''.join(p) for p in product('ijkxyz', ('', '-'))],
             mandatory=True,
-            desc="Phase encoding direction",
+            desc='Phase encoding direction',
         )
     )
 
 
 class _ReorientImageAndMetadataOutputSpec(TraitedSpec):
-    out_file = File(desc="Reoriented image")
+    out_file = File(desc='Reoriented image')
     pe_dir = OutputMultiObject(
         traits.Enum(
-            *["".join(p) for p in product("ijkxyz", ("", "-"))],
-            desc="Phase encoding direction in reoriented image",
+            *[''.join(p) for p in product('ijkxyz', ('', '-'))],
+            desc='Phase encoding direction in reoriented image',
         )
     )
 
@@ -176,13 +180,13 @@ class ReorientImageAndMetadata(SimpleInterface):
     output_spec = _ReorientImageAndMetadataOutputSpec
 
     def _run_interface(self, runtime):
-        import numpy as np
         import nibabel as nb
+        import numpy as np
         from nipype.utils.filemanip import fname_presuffix
 
         target = self.inputs.target_orientation.upper()
-        if not all(code in "RASLPI" for code in target):
-            raise ValueError(f"Invalid orientation code {self.inputs.target_orientation}")
+        if not all(code in 'RASLPI' for code in target):
+            raise ValueError(f'Invalid orientation code {self.inputs.target_orientation}')
 
         img = nb.load(self.inputs.in_file)
         img2target = nb.orientations.ornt_transform(
@@ -207,17 +211,17 @@ def _run_interface(self, runtime):
             pe_dir=pe_dirs,
         )
 
-        reoriented.to_filename(self._results["out_file"])
+        reoriented.to_filename(self._results['out_file'])
 
         return runtime
 
 
 class _ConvertWarpInputSpec(BaseInterfaceInputSpec):
-    in_file = File(exists=True, mandatory=True, desc="output of 3dQwarp")
+    in_file = File(exists=True, mandatory=True, desc='output of 3dQwarp')
 
 
 class _ConvertWarpOutputSpec(TraitedSpec):
-    out_file = File(exists=True, desc="the warp converted into ANTs")
+    out_file = File(exists=True, desc='the warp converted into ANTs')
 
 
 class ConvertWarp(SimpleInterface):
@@ -227,21 +231,21 @@ class ConvertWarp(SimpleInterface):
     output_spec = _ConvertWarpOutputSpec
 
     def _run_interface(self, runtime):
-        self._results["out_file"] = _qwarp2ants(self.inputs.in_file, newpath=runtime.cwd)
+        self._results['out_file'] = _qwarp2ants(self.inputs.in_file, newpath=runtime.cwd)
         return runtime
 
 
 class _DeobliqueInputSpec(BaseInterfaceInputSpec):
-    in_file = File(exists=True, mandatory=True, desc="the input dataset potentially oblique")
+    in_file = File(exists=True, mandatory=True, desc='the input dataset potentially oblique')
     in_mask = File(
         exists=True,
-        desc="a binary mask corresponding to the input dataset",
+        desc='a binary mask corresponding to the input dataset',
     )
 
 
 class _DeobliqueOutputSpec(TraitedSpec):
-    out_file = File(exists=True, desc="the input dataset, after correcting obliquity")
-    out_mask = File(exists=True, desc="the input mask, after correcting obliquity")
+    out_file = File(exists=True, desc='the input dataset, after correcting obliquity')
+    out_mask = File(exists=True, desc='the input mask, after correcting obliquity')
 
 
 class Deoblique(SimpleInterface):
@@ -251,15 +255,15 @@ class Deoblique(SimpleInterface):
     output_spec = _DeobliqueOutputSpec
 
     def _run_interface(self, runtime):
-        self._results["out_file"] = _deoblique(
+        self._results['out_file'] = _deoblique(
             self.inputs.in_file,
             newpath=runtime.cwd,
         )
 
         if isdefined(self.inputs.in_mask):
-            self._results["out_mask"] = _deoblique(
+            self._results['out_mask'] = _deoblique(
                 self.inputs.in_mask,
-                in_affine=self._results["out_file"],
+                in_affine=self._results['out_file'],
                 newpath=runtime.cwd,
             )
 
@@ -267,23 +271,23 @@ def _run_interface(self, runtime):
 
 
 class _ReobliqueInputSpec(BaseInterfaceInputSpec):
-    in_plumb = File(exists=True, mandatory=True, desc="the plumb EPI image")
+    in_plumb = File(exists=True, mandatory=True, desc='the plumb EPI image')
     in_field = File(
         exists=True,
         mandatory=True,
-        desc="the plumb field map, extracted from the displacements field estimated by SyN",
+        desc='the plumb field map, extracted from the displacements field estimated by SyN',
     )
-    in_epi = File(exists=True, mandatory=True, desc="the original, potentially oblique EPI image")
+    in_epi = File(exists=True, mandatory=True, desc='the original, potentially oblique EPI image')
     in_mask = File(
         exists=True,
-        desc="a binary mask corresponding to the input dataset",
+        desc='a binary mask corresponding to the input dataset',
     )
 
 
 class _ReobliqueOutputSpec(TraitedSpec):
     out_epi = File(exists=True, desc="the reoblique'd EPI image")
     out_field = File(exists=True, desc="the reoblique'd EPI image")
-    out_mask = File(exists=True, desc="the input mask, after correcting obliquity")
+    out_mask = File(exists=True, desc='the input mask, after correcting obliquity')
 
 
 class Reoblique(SimpleInterface):
@@ -295,9 +299,9 @@ class Reoblique(SimpleInterface):
     def _run_interface(self, runtime):
         in_mask = self.inputs.in_mask if isdefined(self.inputs.in_mask) else None
         (
-            self._results["out_epi"],
-            self._results["out_field"],
-            self._results["out_mask"],
+            self._results['out_epi'],
+            self._results['out_field'],
+            self._results['out_mask'],
         ) = _reoblique(
             self.inputs.in_epi,
             self.inputs.in_plumb,
@@ -306,7 +310,7 @@ def _run_interface(self, runtime):
             newpath=runtime.cwd,
         )
         if not in_mask:
-            self._results.pop("out_mask")
+            self._results.pop('out_mask')
 
         return runtime
 
@@ -315,7 +319,7 @@ class _DenoiseImageInputSpec(_DenoiseImageInputSpecBase):
     copy_header = traits.Bool(
         True,
         usedefault=True,
-        desc="copy headers of the original image into the output (corrected) file",
+        desc='copy headers of the original image into the output (corrected) file',
     )
 
 
@@ -323,19 +327,19 @@ class DenoiseImage(_DenoiseImageBase, _CopyHeaderInterface):
     """Add copy_header capability to DenoiseImage from nipype."""
 
     input_spec = _DenoiseImageInputSpec
-    _copy_header_map = {"output_image": "input_image"}
+    _copy_header_map = {'output_image': 'input_image'}
 
 
 class _PadSlicesInputSpec(BaseInterfaceInputSpec):
-    in_file = File(exists=True, mandatory=True, desc="3D or 4D NIfTI image")
+    in_file = File(exists=True, mandatory=True, desc='3D or 4D NIfTI image')
     axis = traits.Int(
-        2, usedefault=True, desc="The axis through which slices are stacked in the input data"
+        2, usedefault=True, desc='The axis through which slices are stacked in the input data'
     )
 
 
 class _PadSlicesOutputSpec(TraitedSpec):
-    out_file = File(exists=True, desc="The output file with even number of slices")
-    padded = traits.Bool(desc="Indicator if the input image was padded")
+    out_file = File(exists=True, desc='The output file with even number of slices')
+    padded = traits.Bool(desc='Indicator if the input image was padded')
 
 
 class PadSlices(SimpleInterface):
@@ -349,7 +353,7 @@ class PadSlices(SimpleInterface):
     output_spec = _PadSlicesOutputSpec
 
     def _run_interface(self, runtime):
-        self._results["out_file"], self._results["padded"] = _pad_num_slices(
+        self._results['out_file'], self._results['padded'] = _pad_num_slices(
             self.inputs.in_file,
             self.inputs.axis,
             runtime.cwd,
@@ -358,7 +362,7 @@ def _run_interface(self, runtime):
 
 
 class _PositiveDirectionCosinesInputSpec(BaseInterfaceInputSpec):
-    in_file = File(exists=True, mandatory=True, desc="input image")
+    in_file = File(exists=True, mandatory=True, desc='input image')
 
 
 class _PositiveDirectionCosinesOutputSpec(TraitedSpec):
@@ -373,7 +377,7 @@ class PositiveDirectionCosines(SimpleInterface):
     output_spec = _PositiveDirectionCosinesOutputSpec
 
     def _run_interface(self, runtime):
-        (self._results["out_file"], self._results["in_orientation"]) = _ensure_positive_cosines(
+        (self._results['out_file'], self._results['in_orientation']) = _ensure_positive_cosines(
             self.inputs.in_file,
             newpath=runtime.cwd,
         )
@@ -395,6 +399,7 @@ def _flatten(inlist, max_trs=50, out_dir=None):
 
     """
     from pathlib import Path
+
     import nibabel as nb
 
     out_dir = Path(out_dir) if out_dir is not None else Path()
@@ -406,10 +411,10 @@ def _flatten(inlist, max_trs=50, out_dir=None):
             output.append((path, meta))
         else:
             splitnii = nb.four_to_three(img.slicer[:, :, :, :max_trs])
-            stem = Path(path).name.rpartition(".nii")[0]
+            stem = Path(path).name.rpartition('.nii')[0]
 
             for j, nii in enumerate(splitnii):
-                out_name = (out_dir / f"{stem}_idx-{j:03}.nii.gz").absolute()
+                out_name = (out_dir / f'{stem}_idx-{j:03}.nii.gz').absolute()
                 nii.to_filename(out_name)
                 output.append((str(out_name), meta))
 
@@ -418,23 +423,23 @@ def _flatten(inlist, max_trs=50, out_dir=None):
 
 def _qwarp2ants(in_file, newpath=None):
     """Ensure the data type and intent of a warp is acceptable by ITK-based tools."""
-    import numpy as np
     import nibabel as nb
+    import numpy as np
     from nipype.utils.filemanip import fname_presuffix
 
     nii = nb.load(in_file)
     hdr = nii.header.copy()
-    hdr.set_data_dtype("<f4")
-    hdr.set_intent("vector", (), "")
-    out_file = fname_presuffix(in_file, "_warpfield", newpath=newpath)
-    data = np.squeeze(nii.get_fdata(dtype="float32"))[..., np.newaxis, :]
+    hdr.set_data_dtype('<f4')
+    hdr.set_intent('vector', (), '')
+    out_file = fname_presuffix(in_file, '_warpfield', newpath=newpath)
+    data = np.squeeze(nii.get_fdata(dtype='float32'))[..., np.newaxis, :]
     nb.Nifti1Image(data, nii.affine, hdr).to_filename(out_file)
     return out_file
 
 
 def _deoblique(in_file, in_affine=None, newpath=None):
-    import numpy as np
     import nibabel as nb
+    import numpy as np
     from nipype.utils.filemanip import fname_presuffix
 
     nii = nb.load(in_file)
@@ -444,7 +449,7 @@ def _deoblique(in_file, in_affine=None, newpath=None):
     if in_affine is None:
         orientation = nb.aff2axcodes(nii.affine)
         directions = (
-            np.array([int(l1 == l2) for l1, l2 in zip(orientation, "RAS")], dtype="float32") * 2
+            np.array([int(l1 == l2) for l1, l2 in zip(orientation, 'RAS')], dtype='float32') * 2
             - 1
         )
         newaff = np.eye(4)
@@ -457,14 +462,14 @@ def _deoblique(in_file, in_affine=None, newpath=None):
     hdr.set_qform(newaff, code=1)
     hdr.set_sform(newaff, code=1)
     newnii = nii.__class__(nii.dataobj, newaff, hdr)
-    out_file = fname_presuffix(in_file, suffix="_plumb", newpath=newpath)
+    out_file = fname_presuffix(in_file, suffix='_plumb', newpath=newpath)
     newnii.to_filename(out_file)
     return out_file
 
 
 def _reoblique(in_epi, in_plumb, in_field, in_mask=None, newpath=None):
-    import numpy as np
     import nibabel as nb
+    import numpy as np
     from nipype.utils.filemanip import fname_presuffix
 
     epinii = nb.load(in_epi)
@@ -472,7 +477,7 @@ def _reoblique(in_epi, in_plumb, in_field, in_mask=None, newpath=None):
         return in_plumb, in_field, in_mask
 
     out_files = [
-        fname_presuffix(f, suffix="_oriented", newpath=newpath) for f in (in_plumb, in_field)
+        fname_presuffix(f, suffix='_oriented', newpath=newpath) for f in (in_plumb, in_field)
     ] + [None]
     plumbnii = nb.load(in_plumb)
     plumbnii.__class__(plumbnii.dataobj, epinii.affine, epinii.header).to_filename(out_files[0])
@@ -484,7 +489,7 @@ def _reoblique(in_epi, in_plumb, in_field, in_mask=None, newpath=None):
     fmapnii.__class__(fmapnii.dataobj, epinii.affine, hdr).to_filename(out_files[1])
 
     if in_mask:
-        out_files[2] = fname_presuffix(in_mask, suffix="_oriented", newpath=newpath)
+        out_files[2] = fname_presuffix(in_mask, suffix='_oriented', newpath=newpath)
         masknii = nb.load(in_mask)
         hdr = masknii.header.copy()
         hdr.set_qform(*epinii.header.get_qform(coded=True))
@@ -518,8 +523,8 @@ def _pad_num_slices(in_file, ax=2, newpath=None):
 
     """
     import nibabel as nb
-    from nipype.utils.filemanip import fname_presuffix
     import numpy as np
+    from nipype.utils.filemanip import fname_presuffix
 
     img = nb.load(in_file)
     if img.shape[ax] % 2 == 0:
@@ -530,7 +535,7 @@ def _pad_num_slices(in_file, ax=2, newpath=None):
     padded = np.pad(img.dataobj, pwidth)
     hdr = img.header
     hdr.set_data_shape(padded.shape)
-    out_file = fname_presuffix(in_file, suffix="_padded", newpath=newpath)
+    out_file = fname_presuffix(in_file, suffix='_padded', newpath=newpath)
     img.__class__(padded, img.affine, header=hdr).to_filename(out_file)
     return out_file, True
 
@@ -546,9 +551,10 @@ def _ensure_positive_cosines(in_file: str, newpath: str = None):
     """
     import nibabel as nb
     from nipype.utils.filemanip import fname_presuffix
+
     from sdcflows.utils.tools import ensure_positive_cosines
 
-    out_file = fname_presuffix(in_file, suffix="_flipfree", newpath=newpath)
+    out_file = fname_presuffix(in_file, suffix='_flipfree', newpath=newpath)
     reoriented, axcodes = ensure_positive_cosines(nb.load(in_file))
     reoriented.to_filename(out_file)
-    return out_file, "".join(axcodes)
+    return out_file, ''.join(axcodes)
diff --git a/sdcflows/tests/test_fieldmaps.py b/sdcflows/tests/test_fieldmaps.py
index 1cd1073219..5032c68dcf 100644
--- a/sdcflows/tests/test_fieldmaps.py
+++ b/sdcflows/tests/test_fieldmaps.py
@@ -21,10 +21,13 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """test_fieldmaps."""
-from collections import namedtuple
+
 import shutil
-import pytest
+from collections import namedtuple
+
 import bids
+import pytest
+
 from .. import fieldmaps as fm
 
 
@@ -37,57 +40,57 @@ def clear_registry():
 
 def test_FieldmapFile(dsA_dir):
     """Test one existing file."""
-    f1 = fm.FieldmapFile(dsA_dir / "sub-01" / "anat" / "sub-01_T1w.nii.gz")
-    f2 = fm.FieldmapFile(str(dsA_dir / "sub-01" / "anat" / "sub-01_T1w.nii.gz"))
+    f1 = fm.FieldmapFile(dsA_dir / 'sub-01' / 'anat' / 'sub-01_T1w.nii.gz')
+    f2 = fm.FieldmapFile(str(dsA_dir / 'sub-01' / 'anat' / 'sub-01_T1w.nii.gz'))
     f3 = fm.FieldmapFile(
-        bids.layout.BIDSFile(str(dsA_dir / "sub-01" / "anat" / "sub-01_T1w.nii.gz"))
+        bids.layout.BIDSFile(str(dsA_dir / 'sub-01' / 'anat' / 'sub-01_T1w.nii.gz'))
     )
     assert f1 == f2 == f3
 
     with pytest.raises(ValueError):
-        fm.FieldmapFile(dsA_dir / "sub-01" / "fmap" / "sub-01_dir-AP_epi.json")
+        fm.FieldmapFile(dsA_dir / 'sub-01' / 'fmap' / 'sub-01_dir-AP_epi.json')
 
     with pytest.raises(ValueError):
-        fm.FieldmapFile(dsA_dir / "sub-01" / "anat" / "sub-01_FLAIR.nii.gz")
+        fm.FieldmapFile(dsA_dir / 'sub-01' / 'anat' / 'sub-01_FLAIR.nii.gz')
 
 
 @pytest.mark.parametrize(
-    "inputfiles,method,nsources",
+    'inputfiles,method,nsources',
     [
         (
-            ("fmap/sub-01_fieldmap.nii.gz", "fmap/sub-01_magnitude.nii.gz"),
+            ('fmap/sub-01_fieldmap.nii.gz', 'fmap/sub-01_magnitude.nii.gz'),
             fm.EstimatorType.MAPPED,
             2,
         ),
         (
             (
-                "fmap/sub-01_phase1.nii.gz",
-                "fmap/sub-01_phase2.nii.gz",
-                "fmap/sub-01_magnitude1.nii.gz",
-                "fmap/sub-01_magnitude2.nii.gz",
+                'fmap/sub-01_phase1.nii.gz',
+                'fmap/sub-01_phase2.nii.gz',
+                'fmap/sub-01_magnitude1.nii.gz',
+                'fmap/sub-01_magnitude2.nii.gz',
             ),
             fm.EstimatorType.PHASEDIFF,
             4,
         ),
         (
-            ("fmap/sub-01_phase1.nii.gz", "fmap/sub-01_phase2.nii.gz"),
+            ('fmap/sub-01_phase1.nii.gz', 'fmap/sub-01_phase2.nii.gz'),
             fm.EstimatorType.PHASEDIFF,
             4,
         ),
-        (("fmap/sub-01_phase2.nii.gz",), fm.EstimatorType.PHASEDIFF, 4),
-        (("fmap/sub-01_phase1.nii.gz",), fm.EstimatorType.PHASEDIFF, 4),
+        (('fmap/sub-01_phase2.nii.gz',), fm.EstimatorType.PHASEDIFF, 4),
+        (('fmap/sub-01_phase1.nii.gz',), fm.EstimatorType.PHASEDIFF, 4),
         (
-            ("fmap/sub-01_dir-LR_epi.nii.gz", "fmap/sub-01_dir-RL_epi.nii.gz"),
+            ('fmap/sub-01_dir-LR_epi.nii.gz', 'fmap/sub-01_dir-RL_epi.nii.gz'),
             fm.EstimatorType.PEPOLAR,
             2,
         ),
         (
-            ("fmap/sub-01_dir-LR_epi.nii.gz", "dwi/sub-01_dir-RL_sbref.nii.gz"),
+            ('fmap/sub-01_dir-LR_epi.nii.gz', 'dwi/sub-01_dir-RL_sbref.nii.gz'),
             fm.EstimatorType.PEPOLAR,
             2,
         ),
         (
-            ("anat/sub-01_T1w.nii.gz", "dwi/sub-01_dir-RL_sbref.nii.gz"),
+            ('anat/sub-01_T1w.nii.gz', 'dwi/sub-01_dir-RL_sbref.nii.gz'),
             fm.EstimatorType.ANAT,
             2,
         ),
@@ -95,19 +98,19 @@ def test_FieldmapFile(dsA_dir):
 )
 def test_FieldmapEstimation(dsA_dir, inputfiles, method, nsources):
     """Test errors."""
-    sub_dir = dsA_dir / "sub-01"
+    sub_dir = dsA_dir / 'sub-01'
 
     sources = [sub_dir / f for f in inputfiles]
 
     fe = fm.FieldmapEstimation(sources)
     assert fe.method == method
     assert len(fe.sources) == nsources
-    assert fe.bids_id is not None and fe.bids_id.startswith("auto_")
+    assert fe.bids_id is not None and fe.bids_id.startswith('auto_')
     assert fe.bids_id == fe.sanitized_id  # Auto-generated IDs are sanitized
 
     # Attempt to change bids_id
     with pytest.raises(ValueError):
-        fe.bids_id = "other"
+        fe.bids_id = 'other'
 
     # Setting the same value should not raise
     fe.bids_id = fe.bids_id
@@ -118,7 +121,7 @@ def test_FieldmapEstimation(dsA_dir, inputfiles, method, nsources):
 
     # Ensure we can't instantiate one more estimation with same sources
     with pytest.raises(ValueError):
-        fm.FieldmapEstimation(sources, bids_id=f"my{fe.bids_id}")
+        fm.FieldmapEstimation(sources, bids_id=f'my{fe.bids_id}')
 
     # Exercise workflow creation
     wf = fe.get_workflow()
@@ -126,17 +129,17 @@ def test_FieldmapEstimation(dsA_dir, inputfiles, method, nsources):
 
 
 @pytest.mark.parametrize(
-    "inputfiles,errortype",
+    'inputfiles,errortype',
     [
-        (("fmap/sub-01_fieldmap.nii.gz", "fmap/sub-01_phasediff.nii.gz"), TypeError),
-        (("fmap/sub-01_dir-RL_epi.nii.gz",), ValueError),
-        (("anat/sub-01_T1w.nii.gz",), ValueError),
-        (("anat/sub-01_T1w.nii.gz", "fmap/sub-01_phase2.nii.gz"), TypeError),
+        (('fmap/sub-01_fieldmap.nii.gz', 'fmap/sub-01_phasediff.nii.gz'), TypeError),
+        (('fmap/sub-01_dir-RL_epi.nii.gz',), ValueError),
+        (('anat/sub-01_T1w.nii.gz',), ValueError),
+        (('anat/sub-01_T1w.nii.gz', 'fmap/sub-01_phase2.nii.gz'), TypeError),
     ],
 )
 def test_FieldmapEstimationError(dsA_dir, inputfiles, errortype):
     """Test errors."""
-    sub_dir = dsA_dir / "sub-01"
+    sub_dir = dsA_dir / 'sub-01'
 
     fm.clear_registry()
 
@@ -154,12 +157,12 @@ def test_FieldmapEstimationIdentifier(monkeypatch, dsA_dir):
         fm.FieldmapEstimation(
             [
                 fm.FieldmapFile(
-                    dsA_dir / "sub-01" / "fmap/sub-01_fieldmap.nii.gz",
-                    metadata={"Units": "Hz", "B0FieldIdentifier": "fmap_0"},
+                    dsA_dir / 'sub-01' / 'fmap/sub-01_fieldmap.nii.gz',
+                    metadata={'Units': 'Hz', 'B0FieldIdentifier': 'fmap_0'},
                 ),
                 fm.FieldmapFile(
-                    dsA_dir / "sub-01" / "fmap/sub-01_magnitude.nii.gz",
-                    metadata={"Units": "Hz", "B0FieldIdentifier": "fmap_1"},
+                    dsA_dir / 'sub-01' / 'fmap/sub-01_magnitude.nii.gz',
+                    metadata={'Units': 'Hz', 'B0FieldIdentifier': 'fmap_1'},
                 ),
             ]
         )  # Inconsistent identifiers
@@ -167,33 +170,33 @@ def test_FieldmapEstimationIdentifier(monkeypatch, dsA_dir):
     fe = fm.FieldmapEstimation(
         [
             fm.FieldmapFile(
-                dsA_dir / "sub-01" / "fmap/sub-01_fieldmap.nii.gz",
+                dsA_dir / 'sub-01' / 'fmap/sub-01_fieldmap.nii.gz',
                 metadata={
-                    "Units": "Hz",
-                    "B0FieldIdentifier": "fmap_0",
-                    "IntendedFor": "file1.nii.gz",
+                    'Units': 'Hz',
+                    'B0FieldIdentifier': 'fmap_0',
+                    'IntendedFor': 'file1.nii.gz',
                 },
             ),
             fm.FieldmapFile(
-                dsA_dir / "sub-01" / "fmap/sub-01_magnitude.nii.gz",
-                metadata={"Units": "Hz", "B0FieldIdentifier": "fmap_0"},
+                dsA_dir / 'sub-01' / 'fmap/sub-01_magnitude.nii.gz',
+                metadata={'Units': 'Hz', 'B0FieldIdentifier': 'fmap_0'},
             ),
         ]
     )
-    assert fe.bids_id == "fmap_0"
-    assert fm.get_identifier("file1.nii.gz") == ("fmap_0",)
-    assert not fm.get_identifier("file2.nii.gz")
+    assert fe.bids_id == 'fmap_0'
+    assert fm.get_identifier('file1.nii.gz') == ('fmap_0',)
+    assert not fm.get_identifier('file2.nii.gz')
 
     with pytest.raises(KeyError):
         fm.FieldmapEstimation(
             [
                 fm.FieldmapFile(
-                    dsA_dir / "sub-01" / "fmap/sub-01_fieldmap.nii.gz",
-                    metadata={"Units": "Hz", "B0FieldIdentifier": "fmap_0"},
+                    dsA_dir / 'sub-01' / 'fmap/sub-01_fieldmap.nii.gz',
+                    metadata={'Units': 'Hz', 'B0FieldIdentifier': 'fmap_0'},
                 ),
                 fm.FieldmapFile(
-                    dsA_dir / "sub-01" / "fmap/sub-01_magnitude.nii.gz",
-                    metadata={"Units": "Hz", "B0FieldIdentifier": "fmap_0"},
+                    dsA_dir / 'sub-01' / 'fmap/sub-01_magnitude.nii.gz',
+                    metadata={'Units': 'Hz', 'B0FieldIdentifier': 'fmap_0'},
                 ),
             ]
         )  # Consistent, but already exists
@@ -203,148 +206,139 @@ def test_FieldmapEstimationIdentifier(monkeypatch, dsA_dir):
     fe = fm.FieldmapEstimation(
         [
             fm.FieldmapFile(
-                dsA_dir / "sub-01" / "fmap/sub-01_fieldmap.nii.gz",
+                dsA_dir / 'sub-01' / 'fmap/sub-01_fieldmap.nii.gz',
                 metadata={
-                    "Units": "Hz",
-                    "B0FieldIdentifier": "fmap_1",
-                    "IntendedFor": ["file1.nii.gz", "file2.nii.gz"],
+                    'Units': 'Hz',
+                    'B0FieldIdentifier': 'fmap_1',
+                    'IntendedFor': ['file1.nii.gz', 'file2.nii.gz'],
                 },
             ),
             fm.FieldmapFile(
-                dsA_dir / "sub-01" / "fmap/sub-01_magnitude.nii.gz",
-                metadata={"Units": "Hz", "B0FieldIdentifier": "fmap_1"},
+                dsA_dir / 'sub-01' / 'fmap/sub-01_magnitude.nii.gz',
+                metadata={'Units': 'Hz', 'B0FieldIdentifier': 'fmap_1'},
             ),
         ]
     )
-    assert fe.bids_id == "fmap_1"
-    assert fm.get_identifier("file1.nii.gz") == ("fmap_1",)
-    assert fm.get_identifier("file2.nii.gz") == ("fmap_1",)
-    assert not fm.get_identifier("file3.nii.gz")
+    assert fe.bids_id == 'fmap_1'
+    assert fm.get_identifier('file1.nii.gz') == ('fmap_1',)
+    assert fm.get_identifier('file2.nii.gz') == ('fmap_1',)
+    assert not fm.get_identifier('file3.nii.gz')
     assert fm.get_identifier(
-        str(dsA_dir / "sub-01" / "fmap/sub-01_magnitude.nii.gz"), by="sources"
-    ) == ("fmap_1",)
+        str(dsA_dir / 'sub-01' / 'fmap/sub-01_magnitude.nii.gz'), by='sources'
+    ) == ('fmap_1',)
 
     with monkeypatch.context() as m:
-        m.setattr(fm, "_intents", {"file1.nii.gz": {"fmap_0", "fmap_1"}})
-        assert fm.get_identifier("file1.nii.gz") == (
-            "fmap_0",
-            "fmap_1",
+        m.setattr(fm, '_intents', {'file1.nii.gz': {'fmap_0', 'fmap_1'}})
+        assert fm.get_identifier('file1.nii.gz') == (
+            'fmap_0',
+            'fmap_1',
         )
 
     with pytest.raises(KeyError):
-        fm.get_identifier("file", by="invalid")
+        fm.get_identifier('file', by='invalid')
 
     fm.clear_registry()
 
     fe = fm.FieldmapEstimation(
         [
             fm.FieldmapFile(
-                dsA_dir / "sub-01" / "fmap/sub-01_fieldmap.nii.gz",
+                dsA_dir / 'sub-01' / 'fmap/sub-01_fieldmap.nii.gz',
                 metadata={
-                    "Units": "Hz",
-                    "B0FieldIdentifier": "fmap-with^special#chars",
-                    "IntendedFor": ["file1.nii.gz", "file2.nii.gz"],
+                    'Units': 'Hz',
+                    'B0FieldIdentifier': 'fmap-with^special#chars',
+                    'IntendedFor': ['file1.nii.gz', 'file2.nii.gz'],
                 },
             ),
             fm.FieldmapFile(
-                dsA_dir / "sub-01" / "fmap/sub-01_magnitude.nii.gz",
-                metadata={"Units": "Hz", "B0FieldIdentifier": "fmap-with^special#chars"},
+                dsA_dir / 'sub-01' / 'fmap/sub-01_magnitude.nii.gz',
+                metadata={'Units': 'Hz', 'B0FieldIdentifier': 'fmap-with^special#chars'},
             ),
         ]
     )
-    assert fe.bids_id == "fmap-with^special#chars"
-    assert fe.sanitized_id == "fmap_with_special_chars"
+    assert fe.bids_id == 'fmap-with^special#chars'
+    assert fe.sanitized_id == 'fmap_with_special_chars'
     # The unsanitized ID is used for lookups
-    assert fm.get_identifier("file1.nii.gz") == ("fmap-with^special#chars",)
-    assert fm.get_identifier("file2.nii.gz") == ("fmap-with^special#chars",)
+    assert fm.get_identifier('file1.nii.gz') == ('fmap-with^special#chars',)
+    assert fm.get_identifier('file2.nii.gz') == ('fmap-with^special#chars',)
 
     wf = fe.get_workflow()
-    assert wf.name == "wf_fmap_with_special_chars"
+    assert wf.name == 'wf_fmap_with_special_chars'
 
     fm.clear_registry()
 
 
 def test_type_setter():
     """Cover the _type_setter routine."""
-    obj = namedtuple("FieldmapEstimation", ("method",))(method=fm.EstimatorType.UNKNOWN)
+    obj = namedtuple('FieldmapEstimation', ('method',))(method=fm.EstimatorType.UNKNOWN)
     with pytest.raises(ValueError):
-        fm._type_setter(obj, "method", 10)
+        fm._type_setter(obj, 'method', 10)
 
-    obj = namedtuple("FieldmapEstimation", ("method",))(method=fm.EstimatorType.PEPOLAR)
-    assert (
-        fm._type_setter(obj, "method", fm.EstimatorType.PEPOLAR)
-        == fm.EstimatorType.PEPOLAR
-    )
+    obj = namedtuple('FieldmapEstimation', ('method',))(method=fm.EstimatorType.PEPOLAR)
+    assert fm._type_setter(obj, 'method', fm.EstimatorType.PEPOLAR) == fm.EstimatorType.PEPOLAR
 
 
 def test_FieldmapEstimation_missing_files(tmpdir, dsA_dir):
     """Exercise some FieldmapEstimation checks."""
     tmpdir.chdir()
-    tmpdir.mkdir("data")
+    tmpdir.mkdir('data')
 
     # fieldmap - no magnitude
-    path = dsA_dir / "sub-01" / "fmap" / "sub-01_fieldmap.nii.gz"
-    shutil.copy(path, f"data/{path.name}")
+    path = dsA_dir / 'sub-01' / 'fmap' / 'sub-01_fieldmap.nii.gz'
+    shutil.copy(path, f'data/{path.name}')
 
     with pytest.raises(
         ValueError,
-        match=r"A fieldmap or phase-difference .* \(magnitude file\) is missing.*",
+        match=r'A fieldmap or phase-difference .* \(magnitude file\) is missing.*',
     ):
         fm.FieldmapEstimation(
-            [fm.FieldmapFile("data/sub-01_fieldmap.nii.gz", metadata={"Units": "Hz"})]
+            [fm.FieldmapFile('data/sub-01_fieldmap.nii.gz', metadata={'Units': 'Hz'})]
         )
 
     # phase1/2 - no magnitude2
-    path = dsA_dir / "sub-01" / "fmap" / "sub-01_phase1.nii.gz"
-    shutil.copy(path, f"data/{path.name}")
+    path = dsA_dir / 'sub-01' / 'fmap' / 'sub-01_phase1.nii.gz'
+    shutil.copy(path, f'data/{path.name}')
 
-    path = dsA_dir / "sub-01" / "fmap" / "sub-01_magnitude1.nii.gz"
-    shutil.copy(path, f"data/{path.name}")
+    path = dsA_dir / 'sub-01' / 'fmap' / 'sub-01_magnitude1.nii.gz'
+    shutil.copy(path, f'data/{path.name}')
 
-    path = dsA_dir / "sub-01" / "fmap" / "sub-01_phase2.nii.gz"
-    shutil.copy(path, f"data/{path.name}")
+    path = dsA_dir / 'sub-01' / 'fmap' / 'sub-01_phase2.nii.gz'
+    shutil.copy(path, f'data/{path.name}')
 
-    with pytest.raises(
-        ValueError, match=r".* \(phase1/2\) .* \(magnitude2 file\) is missing.*"
-    ):
+    with pytest.raises(ValueError, match=r'.* \(phase1/2\) .* \(magnitude2 file\) is missing.*'):
         fm.FieldmapEstimation(
             [
-                fm.FieldmapFile(
-                    "data/sub-01_phase1.nii.gz", metadata={"EchoTime": 0.004}
-                ),
-                fm.FieldmapFile(
-                    "data/sub-01_phase2.nii.gz", metadata={"EchoTime": 0.007}
-                ),
+                fm.FieldmapFile('data/sub-01_phase1.nii.gz', metadata={'EchoTime': 0.004}),
+                fm.FieldmapFile('data/sub-01_phase2.nii.gz', metadata={'EchoTime': 0.007}),
             ]
         )
 
     # pepolar - only one PE
-    path = dsA_dir / "sub-01" / "fmap" / "sub-01_dir-AP_epi.nii.gz"
-    shutil.copy(path, f"data/{path.name}")
+    path = dsA_dir / 'sub-01' / 'fmap' / 'sub-01_dir-AP_epi.nii.gz'
+    shutil.copy(path, f'data/{path.name}')
 
-    path = dsA_dir / "sub-01" / "dwi" / "sub-01_dir-AP_dwi.nii.gz"
-    shutil.copy(path, f"data/{path.name}")
-    with pytest.raises(ValueError, match="Only one phase-encoding direction <j>.*"):
+    path = dsA_dir / 'sub-01' / 'dwi' / 'sub-01_dir-AP_dwi.nii.gz'
+    shutil.copy(path, f'data/{path.name}')
+    with pytest.raises(ValueError, match='Only one phase-encoding direction <j>.*'):
         fm.FieldmapEstimation(
             [
                 fm.FieldmapFile(
-                    "data/sub-01_dir-AP_epi.nii.gz",
-                    metadata={"PhaseEncodingDirection": "j", "TotalReadoutTime": 0.004},
+                    'data/sub-01_dir-AP_epi.nii.gz',
+                    metadata={'PhaseEncodingDirection': 'j', 'TotalReadoutTime': 0.004},
                 ),
                 fm.FieldmapFile(
-                    "data/sub-01_dir-AP_dwi.nii.gz",
-                    metadata={"PhaseEncodingDirection": "j", "TotalReadoutTime": 0.004},
+                    'data/sub-01_dir-AP_dwi.nii.gz',
+                    metadata={'PhaseEncodingDirection': 'j', 'TotalReadoutTime': 0.004},
                 ),
             ]
         )
 
 
 def test_FieldmapFile_filename(tmp_path, dsA_dir):
-    datadir = tmp_path / "phasediff"
+    datadir = tmp_path / 'phasediff'
     datadir.mkdir(exist_ok=True)
 
-    fmap_path = dsA_dir / "sub-01" / "fmap"
-    for fl in fmap_path.glob("*"):
+    fmap_path = dsA_dir / 'sub-01' / 'fmap'
+    for fl in fmap_path.glob('*'):
         base = fl.name
         if 'magnitude1' in base or 'magnitude2' in base or 'phasediff' in base:
             print(fl.absolute(), str(datadir / base))
@@ -352,7 +346,5 @@ def test_FieldmapFile_filename(tmp_path, dsA_dir):
             shutil.copy(fl.absolute(), str(datadir / base))
 
     # Ensure the correct linked files (magnitude 1/2) are found
-    fm.FieldmapEstimation(
-        fm.FieldmapFile(datadir / "sub-01_phasediff.nii.gz")
-    )
+    fm.FieldmapEstimation(fm.FieldmapFile(datadir / 'sub-01_phasediff.nii.gz'))
     fm.clear_registry()
diff --git a/sdcflows/tests/test_transform.py b/sdcflows/tests/test_transform.py
index 60befe362e..05b54f4712 100644
--- a/sdcflows/tests/test_transform.py
+++ b/sdcflows/tests/test_transform.py
@@ -21,15 +21,17 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Unit tests of the transform object."""
-from subprocess import check_call
+
 from itertools import product
-import pytest
-import numpy as np
+from subprocess import check_call
+
 import nibabel as nb
-from nitransforms.linear import LinearTransformsMapping
-from skimage.morphology import ball
+import numpy as np
+import pytest
 import scipy.ndimage as nd
 from nireports.interfaces.reporting.base import SimpleBeforeAfterRPT as SimpleBeforeAfter
+from nitransforms.linear import LinearTransformsMapping
+from skimage.morphology import ball
 
 from sdcflows import transform as tf
 from sdcflows.interfaces.bspline import bspline_grid
@@ -67,7 +69,7 @@ def generate_oracle(
     )
 
     # Generate the grid with our tools, but fill data with cached file
-    coeff_data = nb.load(coeff_file).get_fdata(dtype="float32")
+    coeff_data = nb.load(coeff_file).get_fdata(dtype='float32')
     coeff_nii = bspline_grid(
         phantom_nii,
         np.array(nb.load(coeff_file).header.get_zooms()),
@@ -80,16 +82,16 @@ def generate_oracle(
     return phantom_nii, coeff_nii
 
 
-@pytest.mark.parametrize("pe_dir", ["j", "j-", "i", "i-", "k", "k-"])
-@pytest.mark.parametrize("rotation", [(None, None, None), (0.2, None, None)])
-@pytest.mark.parametrize("flip", list(product(*[(False, True)] * 3)))
+@pytest.mark.parametrize('pe_dir', ['j', 'j-', 'i', 'i-', 'k', 'k-'])
+@pytest.mark.parametrize('rotation', [(None, None, None), (0.2, None, None)])
+@pytest.mark.parametrize('flip', list(product(*[(False, True)] * 3)))
 def test_displacements_field(tmpdir, testdata_dir, outdir, pe_dir, rotation, flip):
     """Check the generated displacements fields."""
     tmpdir.chdir()
 
     # Generate test oracle
     phantom_nii, coeff_nii = generate_oracle(
-        testdata_dir / "field-coeff-tests.nii.gz",
+        testdata_dir / 'field-coeff-tests.nii.gz',
         rotation=rotation,
     )
 
@@ -98,55 +100,55 @@ def test_displacements_field(tmpdir, testdata_dir, outdir, pe_dir, rotation, fli
         phantom_nii,
         pe_dir=pe_dir,
         ro_time=0.2,
-        output_dtype="float32",
-    ).to_filename("warped-sdcflows.nii.gz")
+        output_dtype='float32',
+    ).to_filename('warped-sdcflows.nii.gz')
     b0.to_displacements(
         ro_time=0.2,
         pe_dir=pe_dir,
-    ).to_filename("itk-displacements.nii.gz")
+    ).to_filename('itk-displacements.nii.gz')
 
-    phantom_nii.to_filename("phantom.nii.gz")
+    phantom_nii.to_filename('phantom.nii.gz')
     # Run antsApplyTransform
     exit_code = check_call(
         [
-            "antsApplyTransforms -d 3 -r phantom.nii.gz -i phantom.nii.gz "
-            "-o warped-ants.nii.gz -n BSpline -t itk-displacements.nii.gz"
+            'antsApplyTransforms -d 3 -r phantom.nii.gz -i phantom.nii.gz '
+            '-o warped-ants.nii.gz -n BSpline -t itk-displacements.nii.gz'
         ],
         shell=True,
     )
     assert exit_code == 0
 
-    ours = np.asanyarray(nb.load("warped-sdcflows.nii.gz").dataobj)
-    theirs = np.asanyarray(nb.load("warped-ants.nii.gz").dataobj)
+    ours = np.asanyarray(nb.load('warped-sdcflows.nii.gz').dataobj)
+    theirs = np.asanyarray(nb.load('warped-ants.nii.gz').dataobj)
     assert np.all((np.sqrt(((ours - theirs) ** 2).sum()) / ours.size) < 1e-1)
 
     if outdir:
-        orientation = "".join([ax[bool(f)] for ax, f in zip(("RL", "AP", "SI"), flip)])
+        orientation = ''.join([ax[bool(f)] for ax, f in zip(('RL', 'AP', 'SI'), flip)])
 
         SimpleBeforeAfter(
-            after_label="Theirs (ANTs)",
-            before_label="Ours (SDCFlows)",
-            after="warped-ants.nii.gz",
-            before="warped-sdcflows.nii.gz",
+            after_label='Theirs (ANTs)',
+            before_label='Ours (SDCFlows)',
+            after='warped-ants.nii.gz',
+            before='warped-sdcflows.nii.gz',
             out_report=str(
-                outdir / f"xfm_pe-{pe_dir}_flip-{orientation}_x-{rotation[0] or 0}"
-                f"_y-{rotation[1] or 0}_z-{rotation[2] or 0}.svg"
+                outdir / f'xfm_pe-{pe_dir}_flip-{orientation}_x-{rotation[0] or 0}'
+                f'_y-{rotation[1] or 0}_z-{rotation[2] or 0}.svg'
             ),
         ).run()
 
 
 @pytest.mark.parametrize(
-    "pe0",
+    'pe0',
     [
-        "LR",
+        'LR',
     ],
 )
 # @pytest.mark.parametrize("hmc", (True, False))
-@pytest.mark.parametrize("hmc", (False, ))
-@pytest.mark.parametrize("fmap", (True, False))
+@pytest.mark.parametrize('hmc', (False,))
+@pytest.mark.parametrize('fmap', (True, False))
 def test_apply_transform(tmpdir, outdir, datadir, pe0, hmc, fmap):
     """Test the .apply() member of the B0Transform object."""
-    datadir = datadir / "hcph-pilot_fieldmaps"
+    datadir = datadir / 'hcph-pilot_fieldmaps'
     tmpdir.chdir()
 
     if not hmc and not fmap:
@@ -154,10 +156,7 @@ def test_apply_transform(tmpdir, outdir, datadir, pe0, hmc, fmap):
 
     # Get coefficients file (at least for a quick reference if fmap is False)
     coeffs = [
-        nb.load(
-            datadir
-            / f"sub-pilot_ses-15_desc-topup+coeff+{pe0}+{pe0[::-1]}_fieldmap.nii.gz"
-        )
+        nb.load(datadir / f'sub-pilot_ses-15_desc-topup+coeff+{pe0}+{pe0[::-1]}_fieldmap.nii.gz')
     ]
 
     if fmap is False:
@@ -169,31 +168,31 @@ def test_apply_transform(tmpdir, outdir, datadir, pe0, hmc, fmap):
     warp = tf.B0FieldTransform(coeffs=coeffs)
 
     hmc_xfms = (
-        np.load(datadir / f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-mockmotion_dwi.npy")
+        np.load(datadir / f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-mockmotion_dwi.npy')
         if hmc
         else None
     )
 
     in_file = (
-        datadir / f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-mockmotion_dwi.nii.gz"
+        datadir / f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-mockmotion_dwi.nii.gz'
         if hmc
-        else datadir / f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-3dvolreg_dwi.nii.gz"
+        else datadir / f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-3dvolreg_dwi.nii.gz'
     )
 
     corrected = warp.apply(
         in_file,
         ro_time=0.0502149,
-        pe_dir="i-",
+        pe_dir='i-',
         xfms=hmc_xfms,
         num_threads=6,
     )
-    corrected.to_filename(f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows_dwi.nii.gz")
+    corrected.to_filename(f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows_dwi.nii.gz')
 
     corrected.__class__(
         np.asanyarray(corrected.dataobj).mean(-1),
         corrected.affine,
         corrected.header,
-    ).to_filename(f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows_dwiref.nii.gz")
+    ).to_filename(f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows_dwiref.nii.gz')
 
     error_margin = 0.5
     if fmap is False:  # If no fieldmap, this is equivalent to only HMC
@@ -208,29 +207,26 @@ def test_apply_transform(tmpdir, outdir, datadir, pe0, hmc, fmap):
                 realigned_data,
                 realigned.affine,
                 realigned.header,
-            ).to_filename(
-                f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-nitransforms_dwiref.nii.gz"
-            )
+            ).to_filename(f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-nitransforms_dwiref.nii.gz')
 
             SimpleBeforeAfter(
-                after_label="Theirs (3dvolreg)",
-                before_label="Ours (SDCFlows)",
-                after=f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-nitransforms_dwiref.nii.gz",
-                before=f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows_dwiref.nii.gz",
-                out_report=str(
-                    outdir / f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-justhmc_dwi.svg"
-                ),
+                after_label='Theirs (3dvolreg)',
+                before_label='Ours (SDCFlows)',
+                after=f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-nitransforms_dwiref.nii.gz',
+                before=f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows_dwiref.nii.gz',
+                out_report=str(outdir / f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-justhmc_dwi.svg'),
             ).run()
 
-            realigned.__class__(error, realigned.affine, realigned.header,).to_filename(
-                outdir
-                / f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-justhmc+error_dwi.nii.gz"
+            realigned.__class__(
+                error,
+                realigned.affine,
+                realigned.header,
+            ).to_filename(
+                outdir / f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-justhmc+error_dwi.nii.gz'
             )
     else:
         realigned = nb.load(in_file)
-        error = np.nan_to_num(
-            np.sqrt(((corrected.dataobj - realigned.dataobj) ** 2)), nan=0
-        )
+        error = np.nan_to_num(np.sqrt(((corrected.dataobj - realigned.dataobj) ** 2)), nan=0)
         error_margin = 200  # test oracle is pretty bad here - needs revision.
 
         if outdir:
@@ -241,24 +237,26 @@ def test_apply_transform(tmpdir, outdir, datadir, pe0, hmc, fmap):
                 realigned_data,
                 realigned.affine,
                 realigned.header,
-            ).to_filename(
-                f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-3dvolreg_dwiref.nii.gz"
-            )
+            ).to_filename(f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-3dvolreg_dwiref.nii.gz')
 
             SimpleBeforeAfter(
-                after_label="Theirs (NiTransforms)",
-                before_label="Ours (SDCFlows)",
-                after=f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-3dvolreg_dwiref.nii.gz",
-                before=f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows_dwiref.nii.gz",
+                after_label='Theirs (NiTransforms)',
+                before_label='Ours (SDCFlows)',
+                after=f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-3dvolreg_dwiref.nii.gz',
+                before=f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows_dwiref.nii.gz',
                 out_report=str(
-                    outdir / f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-"
-                    f"{'just' if not hmc else 'hmc+'}fmap_dwi.svg"
+                    outdir / f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-'
+                    f'{"just" if not hmc else "hmc+"}fmap_dwi.svg'
                 ),
             ).run()
 
-            realigned.__class__(error, realigned.affine, realigned.header,).to_filename(
-                outdir / f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-"
-                f"{'' if not hmc else 'hmc+'}fmap+error_dwi.nii.gz"
+            realigned.__class__(
+                error,
+                realigned.affine,
+                realigned.header,
+            ).to_filename(
+                outdir / f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-'
+                f'{"" if not hmc else "hmc+"}fmap+error_dwi.nii.gz'
             )
 
     # error is below 0.5 in 95% of the voxels clipping margins
@@ -269,12 +267,12 @@ def test_apply_transform(tmpdir, outdir, datadir, pe0, hmc, fmap):
         corrected_nohmc = warp.apply(
             in_file,
             ro_time=0.0502149,
-            pe_dir="i-",
+            pe_dir='i-',
             xfms=None,
             num_threads=6,
         )
         corrected_nohmc.to_filename(
-            f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows+nohmc_dwi.nii.gz"
+            f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows+nohmc_dwi.nii.gz'
         )
 
         # Do not include the first volume in the average to enhance differences
@@ -282,32 +280,30 @@ def test_apply_transform(tmpdir, outdir, datadir, pe0, hmc, fmap):
             np.asanyarray(corrected.dataobj)[..., 1:].mean(-1),
             corrected.affine,
             corrected.header,
-        ).to_filename(
-            f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows+nohmc_dwiref.nii.gz"
-        )
+        ).to_filename(f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows+nohmc_dwiref.nii.gz')
 
         SimpleBeforeAfter(
-            after_label="W/o HMC",
-            before_label="With HMC",
-            after=f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows+nohmc_dwiref.nii.gz",
-            before=f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows_dwiref.nii.gz",
-            out_report=str(
-                outdir / f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-hmcdiff_dwi.svg"
-            ),
+            after_label='W/o HMC',
+            before_label='With HMC',
+            after=f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows+nohmc_dwiref.nii.gz',
+            before=f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-sdcflows_dwiref.nii.gz',
+            out_report=str(outdir / f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-hmcdiff_dwi.svg'),
         ).run()
 
         error = np.sqrt(((corrected.dataobj - corrected_nohmc.dataobj) ** 2))
-        realigned.__class__(error, realigned.affine, realigned.header,).to_filename(
-            outdir / f"sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-hmdiff+error_dwi.nii.gz"
-        )
+        realigned.__class__(
+            error,
+            realigned.affine,
+            realigned.header,
+        ).to_filename(outdir / f'sub-pilot_ses-15_acq-b0_dir-{pe0}_desc-hmdiff+error_dwi.nii.gz')
 
 
-@pytest.mark.parametrize("pe_dir", ["j", "j-", "i", "i-", "k", "k-"])
+@pytest.mark.parametrize('pe_dir', ['j', 'j-', 'i', 'i-', 'k', 'k-'])
 def test_conversions(tmpdir, testdata_dir, pe_dir):
     """Check inverse functions."""
     tmpdir.chdir()
 
-    fmap_nii = nb.load(testdata_dir / "topup-field.nii.gz")
+    fmap_nii = nb.load(testdata_dir / 'topup-field.nii.gz')
     new_nii = tf.disp_to_fmap(
         tf.fmap_to_disp(
             fmap_nii,
@@ -320,8 +316,8 @@ def test_conversions(tmpdir, testdata_dir, pe_dir):
     )
 
     assert np.allclose(
-        fmap_nii.get_fdata(dtype="float32"),
-        new_nii.get_fdata(dtype="float32"),
+        fmap_nii.get_fdata(dtype='float32'),
+        new_nii.get_fdata(dtype='float32'),
     )
 
 
diff --git a/sdcflows/tests/test_version.py b/sdcflows/tests/test_version.py
index 02123c9285..f48858dd95 100644
--- a/sdcflows/tests/test_version.py
+++ b/sdcflows/tests/test_version.py
@@ -21,9 +21,11 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test _version.py."""
+
 import sys
-from importlib.metadata import PackageNotFoundError
 from importlib import reload
+from importlib.metadata import PackageNotFoundError
+
 import sdcflows
 
 
@@ -31,32 +33,32 @@ def test_version_scm0(monkeypatch):
     """Retrieve the version via setuptools_scm."""
 
     class _version:
-        __version__ = "10.0.0"
+        __version__ = '10.0.0'
 
-    monkeypatch.setitem(sys.modules, "sdcflows._version", _version)
+    monkeypatch.setitem(sys.modules, 'sdcflows._version', _version)
     reload(sdcflows)
-    assert sdcflows.__version__ == "10.0.0"
+    assert sdcflows.__version__ == '10.0.0'
 
 
 def test_version_scm1(monkeypatch):
     """Retrieve the version via importlib.metadata."""
-    monkeypatch.setitem(sys.modules, "sdcflows._version", None)
+    monkeypatch.setitem(sys.modules, 'sdcflows._version', None)
 
     def _version(name):
-        return "9.0.0"
+        return '9.0.0'
 
-    monkeypatch.setattr("importlib.metadata.version", _version)
+    monkeypatch.setattr('importlib.metadata.version', _version)
     reload(sdcflows)
-    assert sdcflows.__version__ == "9.0.0"
+    assert sdcflows.__version__ == '9.0.0'
 
 
 def test_version_scm2(monkeypatch):
     """Check version could not be interpolated."""
-    monkeypatch.setitem(sys.modules, "sdcflows._version", None)
+    monkeypatch.setitem(sys.modules, 'sdcflows._version', None)
 
     def _raise(name):
-        raise PackageNotFoundError("No get_distribution mock")
+        raise PackageNotFoundError('No get_distribution mock')
 
-    monkeypatch.setattr("importlib.metadata.version", _raise)
+    monkeypatch.setattr('importlib.metadata.version', _raise)
     reload(sdcflows)
-    assert sdcflows.__version__ == "0+unknown"
+    assert sdcflows.__version__ == '0+unknown'
diff --git a/sdcflows/transform.py b/sdcflows/transform.py
index 87df8109c4..3388789ac3 100644
--- a/sdcflows/transform.py
+++ b/sdcflows/transform.py
@@ -44,26 +44,26 @@
 
 
 """
+
 from __future__ import annotations
 
+import asyncio
 import os
 from functools import partial
-import asyncio
 from pathlib import Path
 from typing import Callable, Sequence, Tuple
-
-import attr
-import numpy as np
 from warnings import warn
-from scipy import ndimage as ndi
-from scipy.interpolate import BSpline
-from scipy.sparse import hstack as sparse_hstack, kron, lil_array
 
+import attr
 import nibabel as nb
 import nitransforms as nt
+import numpy as np
 from bids.utils import listify
-
 from niworkflows.interfaces.nibabel import reorient_image
+from scipy import ndimage as ndi
+from scipy.interpolate import BSpline
+from scipy.sparse import hstack as sparse_hstack
+from scipy.sparse import kron, lil_array
 
 from sdcflows.utils.tools import ensure_positive_cosines
 
@@ -77,7 +77,7 @@ def _sdc_unwarp(
     fmap_hz: np.ndarray,
     output_dtype: str | np.dtype | None = None,
     order: int = 3,
-    mode: str = "constant",
+    mode: str = 'constant',
     cval: float = 0.0,
     prefilter: bool = True,
 ) -> np.ndarray:
@@ -128,9 +128,7 @@ async def worker(
     """Create one worker and attach it to the execution loop."""
     async with semaphore:
         loop = asyncio.get_running_loop()
-        result = await loop.run_in_executor(
-            None, func, data, coordinates, pe_info, hmc_xfm
-        )
+        result = await loop.run_in_executor(None, func, data, coordinates, pe_info, hmc_xfm)
         return result
 
 
@@ -142,7 +140,7 @@ async def unwarp_parallel(
     xfms: Sequence[np.ndarray],
     jacobian: bool,
     order: int = 3,
-    mode: str = "constant",
+    mode: str = 'constant',
     cval: float = 0.0,
     prefilter: bool = True,
     output_dtype: str | np.dtype | None = None,
@@ -338,7 +336,7 @@ def fit(
             [grid_bspline_weights(projected_reference, level) for level in coeffs]
         ).tocsr()
         coefficients = np.hstack(
-            [level.get_fdata(dtype="float32").reshape(-1) for level in coeffs]
+            [level.get_fdata(dtype='float32').reshape(-1) for level in coeffs]
         )
 
         # Reconstruct the fieldmap (in Hz) from coefficients
@@ -346,10 +344,10 @@ def fit(
 
         # Generate a NIfTI object
         hdr = target_reference.header.copy()
-        hdr.set_intent("estimate", name="fieldmap Hz")
-        hdr.set_data_dtype("float32")
-        hdr["cal_max"] = max((abs(fmap.min()), fmap.max()))
-        hdr["cal_min"] = -hdr["cal_max"]
+        hdr.set_intent('estimate', name='fieldmap Hz')
+        hdr.set_data_dtype('float32')
+        hdr['cal_max'] = max((abs(fmap.min()), fmap.max()))
+        hdr['cal_min'] = -hdr['cal_max']
 
         # Cache
         self.mapped = nb.Nifti1Image(fmap, projected_reference.affine, hdr)
@@ -358,9 +356,7 @@ def fit(
             from nitransforms.linear import Affine
 
             _tmp_reference = nb.Nifti1Image(
-                np.zeros(
-                    target_reference.shape[:3], dtype=target_reference.get_data_dtype()
-                ),
+                np.zeros(target_reference.shape[:3], dtype=target_reference.get_data_dtype()),
                 target_reference.affine,
                 target_reference.header,
             )
@@ -380,7 +376,7 @@ def apply(
         xfm_data2fmap: np.ndarray | None = None,
         approx: bool = True,
         order: int = 3,
-        mode: str = "constant",
+        mode: str = 'constant',
         cval: float = 0.0,
         prefilter: bool = True,
         output_dtype: str | np.dtype | None = None,
@@ -466,8 +462,8 @@ def apply(
 
         if self.mapped is not None:
             warn(
-                "The fieldmap has been already fit, the user is responsible for "
-                "ensuring the parameters of the EPI target are consistent."
+                'The fieldmap has been already fit, the user is responsible for '
+                'ensuring the parameters of the EPI target are consistent.'
             )
         else:
             # Generate warp field (before ensuring positive cosines)
@@ -495,21 +491,23 @@ def apply(
 
         pe_info = []
         for volid in range(n_volumes):
-            pe_axis = "ijk".index(pe_dir[volid][0])
-            axis_flip = axcodes[pe_axis] in ("LPI")
-            pe_flip = pe_dir[volid].endswith("-")
-
-            pe_info.append((
-                pe_axis,
-                # Displacements are reversed if either is true (after ensuring positive cosines)
-                -ro_time[volid] if (axis_flip ^ pe_flip) else ro_time[volid],
-            ))
+            pe_axis = 'ijk'.index(pe_dir[volid][0])
+            axis_flip = axcodes[pe_axis] in ('LPI')
+            pe_flip = pe_dir[volid].endswith('-')
+
+            pe_info.append(
+                (
+                    pe_axis,
+                    # Displacements are reversed if either is true (after ensuring positive cosines)
+                    -ro_time[volid] if (axis_flip ^ pe_flip) else ro_time[volid],
+                )
+            )
 
         # Reference image's voxel coordinates (in voxel units)
         voxcoords = (
             nt.linear.Affine(reference=moving)
             .reference.ndindex.reshape((ndim, *data.shape[:ndim]))
-            .astype("float32")
+            .astype('float32')
         )
 
         # Convert head-motion transforms to voxel-to-voxel:
@@ -524,9 +522,9 @@ def apply(
             # xfms = [ras2vox @ xfm @ vox2ras for xfm in xfms]
             xfms = None
             warn(
-                "Head-motion compensating (realignment) transforms are ignored when applying "
-                "the unwarp with SDCFlows. This feature will be enabled as soon as unit tests "
-                "are implemented for its quality assurance."
+                'Head-motion compensating (realignment) transforms are ignored when applying '
+                'the unwarp with SDCFlows. This feature will be enabled as soon as unit tests '
+                'are implemented for its quality assurance.'
             )
 
         # Resample
@@ -534,7 +532,7 @@ def apply(
             unwarp_parallel(
                 data,
                 voxcoords,
-                self.mapped.get_fdata(dtype="float32"),  # fieldmap in Hz
+                self.mapped.get_fdata(dtype='float32'),  # fieldmap in Hz
                 pe_info,
                 xfms,
                 jacobian,
@@ -602,15 +600,15 @@ def fmap_to_disp(fmap_nii, ro_time, pe_dir, itk_format=True):
 
     """
     # Set polarity & scale VSM (voxel-shift-map) by readout time
-    vsm = fmap_nii.get_fdata().copy() * (-ro_time if pe_dir.endswith("-") else ro_time)
+    vsm = fmap_nii.get_fdata().copy() * (-ro_time if pe_dir.endswith('-') else ro_time)
 
     # Shape of displacements field
     # Note that ITK NIfTI fields are 5D (have an empty 4th dimension)
     fieldshape = vsm.shape[:3] + (1, 3)
 
     # Convert VSM to voxel displacements
-    pe_axis = "ijk".index(pe_dir[0])
-    ijk_deltas = np.zeros((vsm.size, 3), dtype="float32")
+    pe_axis = 'ijk'.index(pe_dir[0])
+    ijk_deltas = np.zeros((vsm.size, 3), dtype='float32')
     ijk_deltas[:, pe_axis] = vsm.reshape(-1)
 
     # To convert from VSM to RAS field we just apply the affine
@@ -622,8 +620,8 @@ def fmap_to_disp(fmap_nii, ro_time, pe_dir, itk_format=True):
         xyz_deltas[..., (0, 1)] *= -1.0
 
     xyz_nii = nb.Nifti1Image(xyz_deltas.reshape(fieldshape), fmap_nii.affine)
-    xyz_nii.header.set_intent("vector", name="SDC")
-    xyz_nii.header.set_xyzt_units("mm")
+    xyz_nii.header.set_intent('vector', name='SDC')
+    xyz_nii.header.set_xyzt_units('mm')
     return xyz_nii
 
 
@@ -650,7 +648,7 @@ def disp_to_fmap(xyz_nii, epi_nii, ro_time, pe_dir, itk_format=True):
         A NIfTI 1.0 object containing the field in Hz.
 
     """
-    xyz_deltas = np.squeeze(xyz_nii.get_fdata(dtype="float32")).reshape((-1, 3))
+    xyz_deltas = np.squeeze(xyz_nii.get_fdata(dtype='float32')).reshape((-1, 3))
 
     if itk_format:
         # ITK displacement vectors are in LPS orientation
@@ -662,25 +660,25 @@ def disp_to_fmap(xyz_nii, epi_nii, ro_time, pe_dir, itk_format=True):
 
     # Convert displacements from mm to voxel units
     # Using the inverse affine accounts for reordering of axes, etc.
-    ijk_deltas = (xyz_deltas @ inv_mat.T).astype("float32")
-    pe_axis = "ijk".index(pe_dir[0])
+    ijk_deltas = (xyz_deltas @ inv_mat.T).astype('float32')
+    pe_axis = 'ijk'.index(pe_dir[0])
     vsm = ijk_deltas[:, pe_axis].reshape(xyz_nii.shape[:3])
-    scale_factor = -ro_time if pe_dir.endswith("-") else ro_time
+    scale_factor = -ro_time if pe_dir.endswith('-') else ro_time
 
     fmap_nii = nb.Nifti1Image(vsm / scale_factor, xyz_nii.affine)
-    fmap_nii.header.set_intent("estimate", name="Delta_B0 [Hz]")
-    fmap_nii.header.set_xyzt_units("mm")
-    fmap_nii.header["cal_max"] = max(
+    fmap_nii.header.set_intent('estimate', name='Delta_B0 [Hz]')
+    fmap_nii.header.set_xyzt_units('mm')
+    fmap_nii.header['cal_max'] = max(
         (
             abs(np.asanyarray(fmap_nii.dataobj).min()),
             np.asanyarray(fmap_nii.dataobj).max(),
         )
     )
-    fmap_nii.header["cal_min"] = -fmap_nii.header["cal_max"]
+    fmap_nii.header['cal_min'] = -fmap_nii.header['cal_max']
     return fmap_nii
 
 
-def grid_bspline_weights(target_nii, ctrl_nii, dtype="float32"):
+def grid_bspline_weights(target_nii, ctrl_nii, dtype='float32'):
     r"""
     Evaluate tensor-product B-Spline weights on a grid.
 
@@ -786,7 +784,7 @@ def _move_coeff(in_coeff, fmap_ref, transform, fmap_target=None):
         debug_ref = (~xfm).apply(fmap_ref, reference=nii_target)
         debug_ref.header.set_qform(nii_target.affine, code=1)
         debug_ref.header.set_sform(nii_target.affine, code=1)
-        debug_ref.to_filename(Path() / "debug_fmapref.nii.gz")
+        debug_ref.to_filename(Path() / 'debug_fmapref.nii.gz')
 
     # Generate a new transform
     newaff = np.linalg.inv(np.linalg.inv(coeff.affine) @ (~xfm).matrix)
@@ -796,11 +794,11 @@ def _move_coeff(in_coeff, fmap_ref, transform, fmap_target=None):
     hdr.set_sform(newaff, code=1)
 
     # Make it easy on viz software to render proper range
-    hdr["cal_max"] = max(
+    hdr['cal_max'] = max(
         (
             abs(np.asanyarray(coeff.dataobj).min()),
             np.asanyarray(coeff.dataobj).max(),
         )
     )
-    hdr["cal_min"] = -hdr["cal_max"]
+    hdr['cal_min'] = -hdr['cal_max']
     return coeff.__class__(coeff.dataobj, newaff, hdr)
diff --git a/sdcflows/utils/bimap.py b/sdcflows/utils/bimap.py
index 50ee59f8e3..5a8ed03759 100644
--- a/sdcflows/utils/bimap.py
+++ b/sdcflows/utils/bimap.py
@@ -21,9 +21,10 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """A bidirectional hashmap."""
+
 import re
 
-_autokey_pat = re.compile(r"^auto_(\d+)$")
+_autokey_pat = re.compile(r'^auto_(\d+)$')
 
 
 class bidict(dict):
@@ -125,7 +126,7 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._inverse = {v: k for k, v in self.items()}
         if len(self) != len(self._inverse):
-            raise TypeError("Bidirectional dictionary cannot contain repeated values")
+            raise TypeError('Bidirectional dictionary cannot contain repeated values')
 
     def __setitem__(self, key, value):
         if key == value:
@@ -141,9 +142,7 @@ def __setitem__(self, key, value):
             raise TypeError(f"key '{key}' of {exc}")
 
         if self.__contains__(key):
-            raise KeyError(
-                f"'{key}' is already {'a value' * (key in self._inverse)} in mapping"
-            )
+            raise KeyError(f"'{key}' is already {'a value' * (key in self._inverse)} in mapping")
         if self.__contains__(value):
             raise ValueError(
                 f"'{value}' is already {'a key' * (value not in self._inverse)} in mapping"
@@ -177,14 +176,12 @@ def add(self, value):
         """Insert a new value in the bidict, generating an automatic key."""
         _used = set(
             int(i.groups()[0])
-            for i in [
-                _autokey_pat.match(k) for k in self.keys() if k.startswith("auto_")
-            ]
+            for i in [_autokey_pat.match(k) for k in self.keys() if k.startswith('auto_')]
             if i is not None
         )
         for i in range(len(_used) + 1):
             if i not in _used:
-                newkey = f"auto_{i:05d}"
+                newkey = f'auto_{i:05d}'
 
         self.__setitem__(newkey, value)
         return newkey
diff --git a/sdcflows/utils/epimanip.py b/sdcflows/utils/epimanip.py
index 2980693cbc..353eb93e35 100644
--- a/sdcflows/utils/epimanip.py
+++ b/sdcflows/utils/epimanip.py
@@ -231,41 +231,41 @@ def get_trt(
     import nibabel as nb
 
     # Use case 1: TRT is defined
-    if "TotalReadoutTime" in in_meta:
-        trt = in_meta.get("TotalReadoutTime")
+    if 'TotalReadoutTime' in in_meta:
+        trt = in_meta.get('TotalReadoutTime')
         if not trt:
             raise ValueError(f"'{trt}'")
 
         return trt
-    elif use_estimate and "EstimatedTotalReadoutTime" in in_meta:
-        trt = in_meta.get("EstimatedTotalReadoutTime")
+    elif use_estimate and 'EstimatedTotalReadoutTime' in in_meta:
+        trt = in_meta.get('EstimatedTotalReadoutTime')
         if not trt:
             raise ValueError(f"'{trt}'")
 
         return trt
 
     if in_meta.keys() & {
-        "PhaseEncodingDirection",
-        "EffectiveEchoSpacing",
-        "EstimatedEffectiveEchoSpacing",
-        "EchoSpacing",
-        "WaterFatShift",
-    } > {"PhaseEncodingDirection"}:
+        'PhaseEncodingDirection',
+        'EffectiveEchoSpacing',
+        'EstimatedEffectiveEchoSpacing',
+        'EchoSpacing',
+        'WaterFatShift',
+    } > {'PhaseEncodingDirection'}:
         # npe = N voxels PE direction
-        pe_index = "ijk".index(in_meta["PhaseEncodingDirection"][0])
+        pe_index = 'ijk'.index(in_meta['PhaseEncodingDirection'][0])
         npe = nb.load(in_file).shape[pe_index]
 
         # Use case 2: EES is defined
-        ees = in_meta.get("EffectiveEchoSpacing")
+        ees = in_meta.get('EffectiveEchoSpacing')
         if ees:
             # Effective echo spacing means that acceleration factors have been accounted for.
             return ees * (npe - 1)
-        elif use_estimate and "EstimatedEffectiveEchoSpacing" in in_meta:
-            return in_meta.get("EstimatedEffectiveEchoSpacing") * (npe - 1)
+        elif use_estimate and 'EstimatedEffectiveEchoSpacing' in in_meta:
+            return in_meta.get('EstimatedEffectiveEchoSpacing') * (npe - 1)
 
         try:
-            echospacing = in_meta["EchoSpacing"]
-            acc_factor = in_meta["ParallelReductionFactorInPlane"]
+            echospacing = in_meta['EchoSpacing']
+            acc_factor = in_meta['ParallelReductionFactorInPlane']
         except KeyError:
             pass
         else:
@@ -275,14 +275,14 @@ def get_trt(
 
         # Use case 3 (Philips scans)
         try:
-            wfs = in_meta["WaterFatShift"]
-            epifactor = in_meta["EPIFactor"]
+            wfs = in_meta['WaterFatShift']
+            epifactor = in_meta['EPIFactor']
         except KeyError:
             pass
         else:
             wfs_hz = (
-                (in_meta.get("ImagingFrequency", 0) * 3.39941)
-                or (in_meta.get("MagneticFieldStrength", 0) * 144.7383333)
+                (in_meta.get('ImagingFrequency', 0) * 3.39941)
+                or (in_meta.get('MagneticFieldStrength', 0) * 144.7383333)
                 or None
             )
             if wfs_hz:
@@ -292,22 +292,23 @@ def get_trt(
     if fallback:
         return fallback
 
-    raise ValueError("Unknown total-readout time specification")
+    raise ValueError('Unknown total-readout time specification')
 
 
 def epi_mask(in_file, out_file=None):
     """Use grayscale morphological operations to obtain a quick mask of EPI data."""
     from pathlib import Path
+
     import nibabel as nb
     import numpy as np
     from scipy import ndimage
     from skimage.morphology import ball
 
     if out_file is None:
-        out_file = Path("mask.nii.gz").absolute()
+        out_file = Path('mask.nii.gz').absolute()
 
     img = nb.load(in_file)
-    data = img.get_fdata(dtype="float32")
+    data = img.get_fdata(dtype='float32')
     # First open to blur out the skull around the brain
     opened = ndimage.grey_opening(data, structure=ball(3))
     # Second, close large vessels and the ventricles
@@ -333,8 +334,8 @@ def epi_mask(in_file, out_file=None):
     labels = ndimage.watershed_ift(wshed, markers)
 
     hdr = img.header.copy()
-    hdr.set_data_dtype("uint8")
+    hdr.set_data_dtype('uint8')
     nb.Nifti1Image(
-        ndimage.binary_dilation(labels == 2, ball(2)).astype("uint8"), img.affine, hdr
+        ndimage.binary_dilation(labels == 2, ball(2)).astype('uint8'), img.affine, hdr
     ).to_filename(out_file)
     return out_file
diff --git a/sdcflows/utils/misc.py b/sdcflows/utils/misc.py
index b87f37bac4..04498f321c 100644
--- a/sdcflows/utils/misc.py
+++ b/sdcflows/utils/misc.py
@@ -21,6 +21,7 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Basic miscellaneous utilities."""
+
 import logging
 
 
diff --git a/sdcflows/utils/phasemanip.py b/sdcflows/utils/phasemanip.py
index 0cc77d75cd..2ee029ab92 100644
--- a/sdcflows/utils/phasemanip.py
+++ b/sdcflows/utils/phasemanip.py
@@ -25,12 +25,12 @@
 
 def au2rads(in_file, newpath=None):
     """Convert the input phase map in arbitrary units (a.u.) to rads."""
-    import numpy as np
     import nibabel as nb
+    import numpy as np
     from nipype.utils.filemanip import fname_presuffix
 
     im = nb.load(in_file)
-    data = im.get_fdata(caching="unchanged")  # Read as float64 for safety
+    data = im.get_fdata(caching='unchanged')  # Read as float64 for safety
     hdr = im.header.copy()
 
     # Rescale to [0, 2*pi]
@@ -40,27 +40,27 @@ def au2rads(in_file, newpath=None):
     data = np.clip(np.float32(data), 0.0, 2 * np.pi)
 
     hdr.set_data_dtype(np.float32)
-    hdr.set_xyzt_units("mm")
-    out_file = fname_presuffix(str(in_file), suffix="_rads", newpath=newpath)
+    hdr.set_xyzt_units('mm')
+    out_file = fname_presuffix(str(in_file), suffix='_rads', newpath=newpath)
     nb.Nifti1Image(data, None, hdr).to_filename(out_file)
     return out_file
 
 
 def subtract_phases(in_phases, in_meta, newpath=None):
     """Calculate the phase-difference map, given two input phase maps."""
-    import numpy as np
     import nibabel as nb
+    import numpy as np
     from nipype.utils.filemanip import fname_presuffix
 
-    echo_times = tuple([m.pop("EchoTime", None) for m in in_meta])
+    echo_times = tuple([m.pop('EchoTime', None) for m in in_meta])
     if echo_times[0] > echo_times[1]:
         in_phases = (in_phases[1], in_phases[0])
         in_meta = (in_meta[1], in_meta[0])
         echo_times = (echo_times[1], echo_times[0])
 
     in_phases_nii = [nb.load(ph) for ph in in_phases]
-    sub_data = in_phases_nii[1].get_fdata(dtype="float32") - in_phases_nii[0].get_fdata(
-        dtype="float32"
+    sub_data = in_phases_nii[1].get_fdata(dtype='float32') - in_phases_nii[0].get_fdata(
+        dtype='float32'
     )
 
     # wrap negative radians back to [0, 2pi]
@@ -69,27 +69,27 @@ def subtract_phases(in_phases, in_meta, newpath=None):
 
     new_meta = in_meta[1].copy()
     new_meta.update(in_meta[0])
-    new_meta["EchoTime1"] = echo_times[0]
-    new_meta["EchoTime2"] = echo_times[1]
+    new_meta['EchoTime1'] = echo_times[0]
+    new_meta['EchoTime2'] = echo_times[1]
 
     hdr = in_phases_nii[0].header.copy()
     hdr.set_data_dtype(np.float32)
-    hdr.set_xyzt_units("mm")
+    hdr.set_xyzt_units('mm')
     nii = nb.Nifti1Image(sub_data, in_phases_nii[0].affine, hdr)
-    out_phdiff = fname_presuffix(in_phases[0], suffix="_phdiff", newpath=newpath)
+    out_phdiff = fname_presuffix(in_phases[0], suffix='_phdiff', newpath=newpath)
     nii.to_filename(out_phdiff)
     return out_phdiff, new_meta
 
 
 def phdiff2fmap(in_file, delta_te, newpath=None):
     """Convert the input phase-difference map into a *fieldmap* in Hz."""
-    import numpy as np
     import nibabel as nb
+    import numpy as np
     from nipype.utils.filemanip import fname_presuffix
 
-    out_file = fname_presuffix(str(in_file), suffix="_fmap", newpath=newpath)
+    out_file = fname_presuffix(str(in_file), suffix='_fmap', newpath=newpath)
     image = nb.load(in_file)
-    data = image.get_fdata(dtype="float32") / (2.0 * np.pi * delta_te)
+    data = image.get_fdata(dtype='float32') / (2.0 * np.pi * delta_te)
     nii = nb.Nifti1Image(data, image.affine, image.header)
     nii.set_data_dtype(np.float32)
     nii.to_filename(out_file)
@@ -127,25 +127,21 @@ def delta_te(in_values):
     ValueError:
 
     """
-    te2 = in_values.get("EchoTime2")
-    te1 = in_values.get("EchoTime1")
+    te2 = in_values.get('EchoTime2')
+    te1 = in_values.get('EchoTime1')
 
     if te2 is None and te1 is None:
         try:
-            te2 = float(in_values.get("EchoTimeDifference"))
+            te2 = float(in_values.get('EchoTimeDifference'))
             return abs(te2)
         except TypeError:
-            raise ValueError(
-                "Phase/phase-difference fieldmaps: no echo-times information."
-            )
+            raise ValueError('Phase/phase-difference fieldmaps: no echo-times information.')
         except ValueError:
-            raise ValueError(
-                f"Could not interpret metadata <EchoTimeDifference={te2}>."
-            )
+            raise ValueError(f'Could not interpret metadata <EchoTimeDifference={te2}>.')
     try:
-        te2 = float(te2 or "unknown")
-        te1 = float(te1 or "unknown")
+        te2 = float(te2 or 'unknown')
+        te1 = float(te1 or 'unknown')
     except ValueError:
-        raise ValueError(f"Could not interpret metadata <EchoTime(1,2)={(te1, te2)}>.")
+        raise ValueError(f'Could not interpret metadata <EchoTime(1,2)={(te1, te2)}>.')
 
     return abs(te2 - te1)
diff --git a/sdcflows/utils/telemetry.py b/sdcflows/utils/telemetry.py
index 77c4dc0378..ce9c35c5eb 100644
--- a/sdcflows/utils/telemetry.py
+++ b/sdcflows/utils/telemetry.py
@@ -25,11 +25,12 @@
 # The original file this work derives from is found at:
 # https://github.com/nipreps/mriqc/blob/8ceadba8669cc2a86119a97b9311ab968f11c6eb/mriqc/utils/telemetry.py
 """Ping MIGAS for telemetry."""
+
 import migas
 
 from sdcflows import config
 
-MIGAS_PACKAGE = "nipreps/sdcflows"
+MIGAS_PACKAGE = 'nipreps/sdcflows'
 
 
 def setup_migas(init_ping: bool = True, exit_ping: bool = True) -> None:
diff --git a/sdcflows/utils/tests/test_misc.py b/sdcflows/utils/tests/test_misc.py
index 3b8fa754de..a9a4be7d93 100644
--- a/sdcflows/utils/tests/test_misc.py
+++ b/sdcflows/utils/tests/test_misc.py
@@ -21,23 +21,26 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test miscellaneous utilities."""
+
 import sys
-from collections import namedtuple
 import types
+from collections import namedtuple
+
 import pytest
+
 from ..misc import get_free_mem
 
 
-@pytest.mark.parametrize("retval", [None, 10])
+@pytest.mark.parametrize('retval', [None, 10])
 def test_get_free_mem(monkeypatch, retval):
     """Test the get_free_mem utility."""
 
     def mock_func():
         if retval is None:
             raise ImportError
-        return namedtuple("Mem", ("free",))(free=retval)
+        return namedtuple('Mem', ('free',))(free=retval)
 
-    psutil = types.ModuleType("psutil")
+    psutil = types.ModuleType('psutil')
     psutil.virtual_memory = mock_func
-    monkeypatch.setitem(sys.modules, "psutil", psutil)
+    monkeypatch.setitem(sys.modules, 'psutil', psutil)
     assert get_free_mem() == retval
diff --git a/sdcflows/utils/tests/test_phasemanip.py b/sdcflows/utils/tests/test_phasemanip.py
index 9b876c3504..ea33412dfd 100644
--- a/sdcflows/utils/tests/test_phasemanip.py
+++ b/sdcflows/utils/tests/test_phasemanip.py
@@ -21,8 +21,9 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test phase manipulation routines."""
-import numpy as np
+
 import nibabel as nb
+import numpy as np
 
 from ..phasemanip import au2rads, phdiff2fmap
 
@@ -33,24 +34,22 @@ def test_au2rads(tmp_path):
     data[0, 0, 0] = 0
     data[-1, -1, -1] = 4096
 
-    nb.Nifti1Image(data.astype("int16"), np.eye(4)).to_filename(
-        tmp_path / "testdata.nii.gz"
-    )
+    nb.Nifti1Image(data.astype('int16'), np.eye(4)).to_filename(tmp_path / 'testdata.nii.gz')
 
-    out_file = au2rads(tmp_path / "testdata.nii.gz")
+    out_file = au2rads(tmp_path / 'testdata.nii.gz')
 
     assert np.allclose(
-        (data / 4096).astype("float32") * 2.0 * np.pi,
-        nb.load(out_file).get_fdata(dtype="float32"),
+        (data / 4096).astype('float32') * 2.0 * np.pi,
+        nb.load(out_file).get_fdata(dtype='float32'),
     )
 
 
 def test_phdiff2fmap(tmp_path):
     """Check the conversion."""
     nb.Nifti1Image(
-        np.ones((5, 5, 5), dtype="float32") * 2.0 * np.pi * 2.46e-3, np.eye(4)
-    ).to_filename(tmp_path / "testdata.nii.gz")
+        np.ones((5, 5, 5), dtype='float32') * 2.0 * np.pi * 2.46e-3, np.eye(4)
+    ).to_filename(tmp_path / 'testdata.nii.gz')
 
-    out_file = phdiff2fmap(tmp_path / "testdata.nii.gz", 2.46e-3)
+    out_file = phdiff2fmap(tmp_path / 'testdata.nii.gz', 2.46e-3)
 
-    assert np.allclose(np.ones((5, 5, 5)), nb.load(out_file).get_fdata(dtype="float32"))
+    assert np.allclose(np.ones((5, 5, 5)), nb.load(out_file).get_fdata(dtype='float32'))
diff --git a/sdcflows/utils/tests/test_tools.py b/sdcflows/utils/tests/test_tools.py
index 438f702e2f..641ee5df8b 100644
--- a/sdcflows/utils/tests/test_tools.py
+++ b/sdcflows/utils/tests/test_tools.py
@@ -21,25 +21,27 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test EPI manipulation routines."""
+
+import nibabel as nb
 import numpy as np
 import pytest
-import nibabel as nb
 from nitransforms.linear import Affine
+
 from sdcflows.utils.tools import brain_masker, deoblique_and_zooms
 
 
 def test_epi_mask(tmpdir, testdata_dir):
     """Check mask algorithm."""
     tmpdir.chdir()
-    mask = brain_masker(testdata_dir / "epi.nii.gz")[-1]
+    mask = brain_masker(testdata_dir / 'epi.nii.gz')[-1]
     assert abs(np.asanyarray(nb.load(mask).dataobj).sum() - 166476) < 10
 
 
-@pytest.mark.parametrize("padding", [0, 1, 4])
-@pytest.mark.parametrize("factor", [1, 4, 0.8])
-@pytest.mark.parametrize("centered", [True, False])
+@pytest.mark.parametrize('padding', [0, 1, 4])
+@pytest.mark.parametrize('factor', [1, 4, 0.8])
+@pytest.mark.parametrize('centered', [True, False])
 @pytest.mark.parametrize(
-    "rotate",
+    'rotate',
     [
         np.eye(4),
         # Rotate 90 degrees around x-axis
@@ -92,17 +94,14 @@ def test_deoblique_and_zooms(tmpdir, padding, factor, centered, rotate, debug=Fa
     ref_back = Affine(reference=ref_img).apply(ref_resampled, order=0)
     resampled = Affine(reference=out_img).apply(mov_img, order=2)
     if debug:
-        ref_img.to_filename("reference.nii.gz")
-        ref_back.to_filename("reference_back.nii.gz")
-        ref_resampled.to_filename("reference_resampled.nii.gz")
-        mov_img.to_filename("moving.nii.gz")
-        resampled.to_filename("resampled.nii.gz")
+        ref_img.to_filename('reference.nii.gz')
+        ref_back.to_filename('reference_back.nii.gz')
+        ref_resampled.to_filename('reference_resampled.nii.gz')
+        mov_img.to_filename('moving.nii.gz')
+        resampled.to_filename('resampled.nii.gz')
 
     # Allow up to 3% pixels wrong after up(down)sampling and walk back.
-    assert (
-        np.abs(np.clip(ref_back.get_fdata(), 0, 1) - ref_data).sum()
-        < ref_data.size * 0.03
-    )
+    assert np.abs(np.clip(ref_back.get_fdata(), 0, 1) - ref_data).sum() < ref_data.size * 0.03
 
     vox_vol_out = np.prod(out_img.header.get_zooms())
     vox_vol_mov = np.prod(mov_img.header.get_zooms())
diff --git a/sdcflows/utils/tests/test_wrangler.py b/sdcflows/utils/tests/test_wrangler.py
index f5e7c6cdd5..75e93d019b 100644
--- a/sdcflows/utils/tests/test_wrangler.py
+++ b/sdcflows/utils/tests/test_wrangler.py
@@ -3,197 +3,197 @@
 from shutil import rmtree
 
 import pytest
-
 from niworkflows.utils.testing import generate_bids_skeleton
 
-from sdcflows.utils.wrangler import find_estimators
 from sdcflows.fieldmaps import clear_registry, get_identifier
+from sdcflows.utils.wrangler import find_estimators
 
 
 def gen_layout(bids_dir, database_dir=None):
     import re
+
     from bids.layout import BIDSLayout, BIDSLayoutIndexer
 
     _indexer = BIDSLayoutIndexer(
         validate=False,
         ignore=(
-            "code",
-            "stimuli",
-            "sourcedata",
-            "models",
-            "derivatives",
-            re.compile(r"^\."),
-            re.compile(r"sub-[a-zA-Z0-9]+(/ses-[a-zA-Z0-9]+)?/(beh|eeg|ieeg|meg|micr|perf)"),
+            'code',
+            'stimuli',
+            'sourcedata',
+            'models',
+            'derivatives',
+            re.compile(r'^\.'),
+            re.compile(r'sub-[a-zA-Z0-9]+(/ses-[a-zA-Z0-9]+)?/(beh|eeg|ieeg|meg|micr|perf)'),
         ),
     )
 
-    layout_kwargs = {"indexer": _indexer}
+    layout_kwargs = {'indexer': _indexer}
 
     if database_dir:
-        layout_kwargs["database_path"] = database_dir
+        layout_kwargs['database_path'] = database_dir
 
     layout = BIDSLayout(bids_dir, **layout_kwargs)
     return layout
 
 
 pepolar = {
-    "01": [
+    '01': [
         {
-            "session": "01",
-            "anat": [{"suffix": "T1w", "metadata": {"EchoTime": 1}}],
-            "fmap": [
+            'session': '01',
+            'anat': [{'suffix': 'T1w', 'metadata': {'EchoTime': 1}}],
+            'fmap': [
                 {
-                    "suffix": "epi",
-                    "dir": "AP",
-                    "metadata": {
-                        "EchoTime": 1.2,
-                        "PhaseEncodingDirection": "j-",
-                        "TotalReadoutTime": 0.8,
-                        "IntendedFor": "ses-01/func/sub-01_ses-01_task-rest_bold.nii.gz",
+                    'suffix': 'epi',
+                    'dir': 'AP',
+                    'metadata': {
+                        'EchoTime': 1.2,
+                        'PhaseEncodingDirection': 'j-',
+                        'TotalReadoutTime': 0.8,
+                        'IntendedFor': 'ses-01/func/sub-01_ses-01_task-rest_bold.nii.gz',
                     },
                 },
                 {
-                    "suffix": "epi",
-                    "dir": "PA",
-                    "metadata": {
-                        "EchoTime": 1.2,
-                        "PhaseEncodingDirection": "j",
-                        "TotalReadoutTime": 0.8,
-                        "IntendedFor": "ses-01/func/sub-01_ses-01_task-rest_bold.nii.gz",
+                    'suffix': 'epi',
+                    'dir': 'PA',
+                    'metadata': {
+                        'EchoTime': 1.2,
+                        'PhaseEncodingDirection': 'j',
+                        'TotalReadoutTime': 0.8,
+                        'IntendedFor': 'ses-01/func/sub-01_ses-01_task-rest_bold.nii.gz',
                     },
                 },
             ],
-            "func": [
+            'func': [
                 {
-                    "task": "rest",
-                    "suffix": "bold",
-                    "metadata": {
-                        "RepetitionTime": 0.8,
-                        "TotalReadoutTime": 0.5,
-                        "PhaseEncodingDirection": "j",
+                    'task': 'rest',
+                    'suffix': 'bold',
+                    'metadata': {
+                        'RepetitionTime': 0.8,
+                        'TotalReadoutTime': 0.5,
+                        'PhaseEncodingDirection': 'j',
                     },
                 }
             ],
         },
         {
-            "session": "02",
-            "anat": [{"suffix": "T1w", "metadata": {"EchoTime": 1}}],
-            "fmap": [
+            'session': '02',
+            'anat': [{'suffix': 'T1w', 'metadata': {'EchoTime': 1}}],
+            'fmap': [
                 {
-                    "suffix": "epi",
-                    "dir": "AP",
-                    "metadata": {
-                        "EchoTime": 1.2,
-                        "PhaseEncodingDirection": "j-",
-                        "TotalReadoutTime": 0.8,
-                        "IntendedFor": (
-                            "bids::sub-01/ses-02/func/sub-01_ses-02_task-rest_bold.nii.gz"
+                    'suffix': 'epi',
+                    'dir': 'AP',
+                    'metadata': {
+                        'EchoTime': 1.2,
+                        'PhaseEncodingDirection': 'j-',
+                        'TotalReadoutTime': 0.8,
+                        'IntendedFor': (
+                            'bids::sub-01/ses-02/func/sub-01_ses-02_task-rest_bold.nii.gz'
                         ),
                     },
                 },
                 {
-                    "suffix": "epi",
-                    "dir": "PA",
-                    "metadata": {
-                        "EchoTime": 1.2,
-                        "PhaseEncodingDirection": "j",
-                        "TotalReadoutTime": 0.8,
-                        "IntendedFor": (
-                            "bids::sub-01/ses-02/func/sub-01_ses-02_task-rest_bold.nii.gz"
+                    'suffix': 'epi',
+                    'dir': 'PA',
+                    'metadata': {
+                        'EchoTime': 1.2,
+                        'PhaseEncodingDirection': 'j',
+                        'TotalReadoutTime': 0.8,
+                        'IntendedFor': (
+                            'bids::sub-01/ses-02/func/sub-01_ses-02_task-rest_bold.nii.gz'
                         ),
                     },
                 },
             ],
-            "func": [
+            'func': [
                 {
-                    "task": "rest",
-                    "suffix": "bold",
-                    "metadata": {
-                        "RepetitionTime": 0.8,
-                        "TotalReadoutTime": 0.5,
-                        "PhaseEncodingDirection": "j",
+                    'task': 'rest',
+                    'suffix': 'bold',
+                    'metadata': {
+                        'RepetitionTime': 0.8,
+                        'TotalReadoutTime': 0.5,
+                        'PhaseEncodingDirection': 'j',
                     },
                 }
             ],
         },
         {
-            "session": "03",
-            "anat": [{"suffix": "T1w", "metadata": {"EchoTime": 1}}],
-            "fmap": [
+            'session': '03',
+            'anat': [{'suffix': 'T1w', 'metadata': {'EchoTime': 1}}],
+            'fmap': [
                 {
-                    "suffix": "epi",
-                    "dir": "AP",
-                    "metadata": {
-                        "EchoTime": 1.2,
-                        "PhaseEncodingDirection": "j-",
-                        "TotalReadoutTime": 0.8,
-                        "IntendedFor": (
-                            "bids::sub-01/ses-03/func/sub-01_ses-03_task-rest_bold.nii.gz"
+                    'suffix': 'epi',
+                    'dir': 'AP',
+                    'metadata': {
+                        'EchoTime': 1.2,
+                        'PhaseEncodingDirection': 'j-',
+                        'TotalReadoutTime': 0.8,
+                        'IntendedFor': (
+                            'bids::sub-01/ses-03/func/sub-01_ses-03_task-rest_bold.nii.gz'
                         ),
                     },
                 },
                 {
-                    "suffix": "epi",
-                    "dir": "PA",
-                    "metadata": {
-                        "EchoTime": 1.2,
-                        "PhaseEncodingDirection": "j",
-                        "TotalReadoutTime": 0.8,
-                        "IntendedFor": (
-                            "bids::sub-01/ses-03/func/sub-01_ses-03_task-rest_bold.nii.gz"
+                    'suffix': 'epi',
+                    'dir': 'PA',
+                    'metadata': {
+                        'EchoTime': 1.2,
+                        'PhaseEncodingDirection': 'j',
+                        'TotalReadoutTime': 0.8,
+                        'IntendedFor': (
+                            'bids::sub-01/ses-03/func/sub-01_ses-03_task-rest_bold.nii.gz'
                         ),
                     },
                 },
             ],
-            "func": [
+            'func': [
                 {
-                    "task": "rest",
-                    "suffix": "bold",
-                    "metadata": {
-                        "RepetitionTime": 0.8,
-                        "TotalReadoutTime": 0.5,
-                        "PhaseEncodingDirection": "j",
+                    'task': 'rest',
+                    'suffix': 'bold',
+                    'metadata': {
+                        'RepetitionTime': 0.8,
+                        'TotalReadoutTime': 0.5,
+                        'PhaseEncodingDirection': 'j',
                     },
                 }
             ],
         },
         {
-            "session": "04",
-            "anat": [{"suffix": "T1w", "metadata": {"EchoTime": 1}}],
-            "fmap": [
+            'session': '04',
+            'anat': [{'suffix': 'T1w', 'metadata': {'EchoTime': 1}}],
+            'fmap': [
                 {
-                    "suffix": "epi",
-                    "dir": "AP",
-                    "metadata": {
-                        "EchoTime": 1.2,
-                        "PhaseEncodingDirection": "j-",
-                        "TotalReadoutTime": 0.8,
-                        "IntendedFor": [
-                            "ses-04/func/sub-01_ses-04_task-rest_run-1_bold.nii.gz",
-                            "ses-04/func/sub-01_ses-04_task-rest_run-2_bold.nii.gz",
+                    'suffix': 'epi',
+                    'dir': 'AP',
+                    'metadata': {
+                        'EchoTime': 1.2,
+                        'PhaseEncodingDirection': 'j-',
+                        'TotalReadoutTime': 0.8,
+                        'IntendedFor': [
+                            'ses-04/func/sub-01_ses-04_task-rest_run-1_bold.nii.gz',
+                            'ses-04/func/sub-01_ses-04_task-rest_run-2_bold.nii.gz',
                         ],
                     },
                 },
             ],
-            "func": [
+            'func': [
                 {
-                    "task": "rest",
-                    "run": 1,
-                    "suffix": "bold",
-                    "metadata": {
-                        "RepetitionTime": 0.8,
-                        "TotalReadoutTime": 0.5,
-                        "PhaseEncodingDirection": "j",
+                    'task': 'rest',
+                    'run': 1,
+                    'suffix': 'bold',
+                    'metadata': {
+                        'RepetitionTime': 0.8,
+                        'TotalReadoutTime': 0.5,
+                        'PhaseEncodingDirection': 'j',
                     },
                 },
                 {
-                    "task": "rest",
-                    "run": 2,
-                    "suffix": "bold",
-                    "metadata": {
-                        "RepetitionTime": 0.8,
-                        "TotalReadoutTime": 0.5,
-                        "PhaseEncodingDirection": "j",
+                    'task': 'rest',
+                    'run': 2,
+                    'suffix': 'bold',
+                    'metadata': {
+                        'RepetitionTime': 0.8,
+                        'TotalReadoutTime': 0.5,
+                        'PhaseEncodingDirection': 'j',
                     },
                 },
             ],
@@ -203,88 +203,88 @@ def gen_layout(bids_dir, database_dir=None):
 
 
 phasediff = {
-    "01": [
+    '01': [
         {
-            "session": "01",
-            "anat": [{"suffix": "T1w", "metadata": {"EchoTime": 1}}],
-            "fmap": [
+            'session': '01',
+            'anat': [{'suffix': 'T1w', 'metadata': {'EchoTime': 1}}],
+            'fmap': [
                 {
-                    "suffix": "phasediff",
-                    "metadata": {
-                        "EchoTime1": 1.2,
-                        "EchoTime2": 1.4,
-                        "IntendedFor": "ses-01/func/sub-01_ses-01_task-rest_bold.nii.gz",
+                    'suffix': 'phasediff',
+                    'metadata': {
+                        'EchoTime1': 1.2,
+                        'EchoTime2': 1.4,
+                        'IntendedFor': 'ses-01/func/sub-01_ses-01_task-rest_bold.nii.gz',
                     },
                 },
-                {"suffix": "magnitude1", "metadata": {"EchoTime": 1.2}},
-                {"suffix": "magnitude2", "metadata": {"EchoTime": 1.4}},
+                {'suffix': 'magnitude1', 'metadata': {'EchoTime': 1.2}},
+                {'suffix': 'magnitude2', 'metadata': {'EchoTime': 1.4}},
             ],
-            "func": [
+            'func': [
                 {
-                    "task": "rest",
-                    "suffix": "bold",
-                    "metadata": {
-                        "RepetitionTime": 0.8,
-                        "TotalReadoutTime": 0.5,
-                        "PhaseEncodingDirection": "j",
+                    'task': 'rest',
+                    'suffix': 'bold',
+                    'metadata': {
+                        'RepetitionTime': 0.8,
+                        'TotalReadoutTime': 0.5,
+                        'PhaseEncodingDirection': 'j',
                     },
                 }
             ],
         },
         {
-            "session": "02",
-            "anat": [{"suffix": "T1w", "metadata": {"EchoTime": 1}}],
-            "fmap": [
+            'session': '02',
+            'anat': [{'suffix': 'T1w', 'metadata': {'EchoTime': 1}}],
+            'fmap': [
                 {
-                    "suffix": "phasediff",
-                    "metadata": {
-                        "EchoTime1": 1.2,
-                        "EchoTime2": 1.4,
-                        "IntendedFor": (
-                            "bids::sub-01/ses-02/func/sub-01_ses-02_task-rest_bold.nii.gz"
+                    'suffix': 'phasediff',
+                    'metadata': {
+                        'EchoTime1': 1.2,
+                        'EchoTime2': 1.4,
+                        'IntendedFor': (
+                            'bids::sub-01/ses-02/func/sub-01_ses-02_task-rest_bold.nii.gz'
                         ),
                     },
                 },
-                {"suffix": "magnitude1", "metadata": {"EchoTime": 1.2}},
-                {"suffix": "magnitude2", "metadata": {"EchoTime": 1.4}},
+                {'suffix': 'magnitude1', 'metadata': {'EchoTime': 1.2}},
+                {'suffix': 'magnitude2', 'metadata': {'EchoTime': 1.4}},
             ],
-            "func": [
+            'func': [
                 {
-                    "task": "rest",
-                    "suffix": "bold",
-                    "metadata": {
-                        "RepetitionTime": 0.8,
-                        "TotalReadoutTime": 0.5,
-                        "PhaseEncodingDirection": "j",
+                    'task': 'rest',
+                    'suffix': 'bold',
+                    'metadata': {
+                        'RepetitionTime': 0.8,
+                        'TotalReadoutTime': 0.5,
+                        'PhaseEncodingDirection': 'j',
                     },
                 }
             ],
         },
         {
-            "session": "03",
-            "anat": [{"suffix": "T1w", "metadata": {"EchoTime": 1}}],
-            "fmap": [
+            'session': '03',
+            'anat': [{'suffix': 'T1w', 'metadata': {'EchoTime': 1}}],
+            'fmap': [
                 {
-                    "suffix": "phasediff",
-                    "metadata": {
-                        "EchoTime1": 1.2,
-                        "EchoTime2": 1.4,
-                        "IntendedFor": (
-                            "bids::sub-01/ses-03/func/sub-01_ses-03_task-rest_bold.nii.gz"
+                    'suffix': 'phasediff',
+                    'metadata': {
+                        'EchoTime1': 1.2,
+                        'EchoTime2': 1.4,
+                        'IntendedFor': (
+                            'bids::sub-01/ses-03/func/sub-01_ses-03_task-rest_bold.nii.gz'
                         ),
                     },
                 },
-                {"suffix": "magnitude1", "metadata": {"EchoTime": 1.2}},
-                {"suffix": "magnitude2", "metadata": {"EchoTime": 1.4}},
+                {'suffix': 'magnitude1', 'metadata': {'EchoTime': 1.2}},
+                {'suffix': 'magnitude2', 'metadata': {'EchoTime': 1.4}},
             ],
-            "func": [
+            'func': [
                 {
-                    "task": "rest",
-                    "suffix": "bold",
-                    "metadata": {
-                        "RepetitionTime": 0.8,
-                        "TotalReadoutTime": 0.5,
-                        "PhaseEncodingDirection": "j",
+                    'task': 'rest',
+                    'suffix': 'bold',
+                    'metadata': {
+                        'RepetitionTime': 0.8,
+                        'TotalReadoutTime': 0.5,
+                        'PhaseEncodingDirection': 'j',
                     },
                 }
             ],
@@ -294,12 +294,12 @@ def gen_layout(bids_dir, database_dir=None):
 
 
 filters = {
-    "fmap": {
-        "datatype": "fmap",
-        "session": "01",
+    'fmap': {
+        'datatype': 'fmap',
+        'session': '01',
     },
-    "t1w": {"datatype": "anat", "session": "01", "suffix": "T1w"},
-    "bold": {"datatype": "func", "session": "01", "suffix": "bold"},
+    't1w': {'datatype': 'anat', 'session': '01', 'suffix': 'T1w'},
+    'bold': {'datatype': 'func', 'session': '01', 'suffix': 'bold'},
 }
 
 
@@ -326,12 +326,15 @@ def test_wrangler_filter(tmpdir, name, skeleton, estimations):
         ('phasediff', phasediff, 3),
     ],
 )
-@pytest.mark.parametrize("session, estimations", [
-    ("01", 1),
-    ("02", 1),
-    ("03", 1),
-    (None, None),
-])
+@pytest.mark.parametrize(
+    'session, estimations',
+    [
+        ('01', 1),
+        ('02', 1),
+        ('03', 1),
+        (None, None),
+    ],
+)
 def test_wrangler_URIs(tmpdir, name, skeleton, session, estimations, total_estimations):
     bids_dir = str(tmpdir / name)
     generate_bids_skeleton(bids_dir, skeleton)
@@ -343,7 +346,7 @@ def test_wrangler_URIs(tmpdir, name, skeleton, session, estimations, total_estim
     )
     assert len(est) == estimations or total_estimations
     if session:
-        bold = layout.get(session=session, suffix="bold", extension=".nii.gz")[0]
+        bold = layout.get(session=session, suffix='bold', extension='.nii.gz')[0]
         intended_rel = re.sub(r'^sub-[a-zA-Z0-9]*/', '', str(Path(bold).relative_to(layout.root)))
         b0_id = get_identifier(intended_rel)
         assert b0_id == ('auto_00000',)
@@ -352,7 +355,7 @@ def test_wrangler_URIs(tmpdir, name, skeleton, session, estimations, total_estim
 
 
 def test_single_reverse_pedir(tmp_path):
-    bids_dir = tmp_path / "bids"
+    bids_dir = tmp_path / 'bids'
     generate_bids_skeleton(bids_dir, pepolar)
     layout = gen_layout(bids_dir)
     est = find_estimators(layout=layout, subject='01', bids_filters={'session': '04'})
@@ -369,29 +372,29 @@ def test_single_reverse_pedir(tmp_path):
 
 
 def test_fieldmapless(tmp_path):
-    bids_dir = tmp_path / "bids"
+    bids_dir = tmp_path / 'bids'
 
-    T1w = {"suffix": "T1w"}
+    T1w = {'suffix': 'T1w'}
     bold = {
-        "task": "rest",
-        "suffix": "bold",
-        "metadata": {
-            "RepetitionTime": 0.8,
-            "TotalReadoutTime": 0.5,
-            "PhaseEncodingDirection": "j",
+        'task': 'rest',
+        'suffix': 'bold',
+        'metadata': {
+            'RepetitionTime': 0.8,
+            'TotalReadoutTime': 0.5,
+            'PhaseEncodingDirection': 'j',
         },
     }
-    me_metadata = [{"EchoTime": 0.01 * i, **bold["metadata"]} for i in range(1, 4)]
-    sbref = {**bold, **{"suffix": "sbref"}}
+    me_metadata = [{'EchoTime': 0.01 * i, **bold['metadata']} for i in range(1, 4)]
+    sbref = {**bold, **{'suffix': 'sbref'}}
     spec = {
-        "01": {
-            "anat": [T1w],
-            "func": [bold],
+        '01': {
+            'anat': [T1w],
+            'func': [bold],
         },
     }
     generate_bids_skeleton(bids_dir, spec)
     layout = gen_layout(bids_dir)
-    est = find_estimators(layout=layout, subject="01", fmapless=True)
+    est = find_estimators(layout=layout, subject='01', fmapless=True)
     assert len(est) == 1
     assert len(est[0].sources) == 2
     clear_registry()
@@ -399,14 +402,14 @@ def test_fieldmapless(tmp_path):
 
     # Multi-run generates one estimator per-run
     spec = {
-        "01": {
-            "anat": [T1w],
-            "func": [{"run": i, **bold} for i in range(1, 3)],
+        '01': {
+            'anat': [T1w],
+            'func': [{'run': i, **bold} for i in range(1, 3)],
         },
     }
     generate_bids_skeleton(bids_dir, spec)
     layout = gen_layout(bids_dir)
-    est = find_estimators(layout=layout, subject="01", fmapless=True)
+    est = find_estimators(layout=layout, subject='01', fmapless=True)
     assert len(est) == 2
     assert len(est[0].sources) == 2
     clear_registry()
@@ -414,14 +417,14 @@ def test_fieldmapless(tmp_path):
 
     # Multi-echo should only generate one estimator
     spec = {
-        "01": {
-            "anat": [T1w],
-            "func": [{"echo": i + 1, **bold, **{"metadata": me_metadata[i]}} for i in range(3)],
+        '01': {
+            'anat': [T1w],
+            'func': [{'echo': i + 1, **bold, **{'metadata': me_metadata[i]}} for i in range(3)],
         },
     }
     generate_bids_skeleton(bids_dir, spec)
     layout = gen_layout(bids_dir)
-    est = find_estimators(layout=layout, subject="01", fmapless=True)
+    est = find_estimators(layout=layout, subject='01', fmapless=True)
     assert len(est) == 1
     assert len(est[0].sources) == 2
     clear_registry()
@@ -429,14 +432,14 @@ def test_fieldmapless(tmp_path):
 
     # Matching bold+sbref should generate only one estimator
     spec = {
-        "01": {
-            "anat": [T1w],
-            "func": [bold, sbref],
+        '01': {
+            'anat': [T1w],
+            'func': [bold, sbref],
         },
     }
     generate_bids_skeleton(bids_dir, spec)
     layout = gen_layout(bids_dir)
-    est = find_estimators(layout=layout, subject="01", fmapless=True)
+    est = find_estimators(layout=layout, subject='01', fmapless=True)
     assert len(est) == 1
     assert len(est[0].sources) == 2
     clear_registry()
@@ -444,14 +447,14 @@ def test_fieldmapless(tmp_path):
 
     # Mismatching bold+sbref should generate two sbrefs
     spec = {
-        "01": {
-            "anat": [T1w],
-            "func": [{"acq": "A", **bold}, {"acq": "B", **sbref}],
+        '01': {
+            'anat': [T1w],
+            'func': [{'acq': 'A', **bold}, {'acq': 'B', **sbref}],
         },
     }
     generate_bids_skeleton(bids_dir, spec)
     layout = gen_layout(bids_dir)
-    est = find_estimators(layout=layout, subject="01", fmapless=True)
+    est = find_estimators(layout=layout, subject='01', fmapless=True)
     assert len(est) == 2
     assert len(est[0].sources) == 2
     clear_registry()
@@ -459,15 +462,15 @@ def test_fieldmapless(tmp_path):
 
     # Multiecho bold+sbref should generate only one estimator
     spec = {
-        "01": {
-            "anat": [T1w],
-            "func": [{"echo": i + 1, **bold, **{"metadata": me_metadata[i]}} for i in range(3)]
-            + [{"echo": i + 1, **sbref, **{"metadata": me_metadata[i]}} for i in range(3)],
+        '01': {
+            'anat': [T1w],
+            'func': [{'echo': i + 1, **bold, **{'metadata': me_metadata[i]}} for i in range(3)]
+            + [{'echo': i + 1, **sbref, **{'metadata': me_metadata[i]}} for i in range(3)],
         },
     }
     generate_bids_skeleton(bids_dir, spec)
     layout = gen_layout(bids_dir)
-    est = find_estimators(layout=layout, subject="01", fmapless=True)
+    est = find_estimators(layout=layout, subject='01', fmapless=True)
     assert len(est) == 1
     assert len(est[0].sources) == 2
     clear_registry()
diff --git a/sdcflows/utils/tools.py b/sdcflows/utils/tools.py
index 99200504e0..32318b4f02 100644
--- a/sdcflows/utils/tools.py
+++ b/sdcflows/utils/tools.py
@@ -21,6 +21,7 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Image processing tools."""
+
 import nibabel as nb
 
 
@@ -51,6 +52,7 @@ def deoblique_and_zooms(
 
     """
     from itertools import product
+
     import numpy as np
     from nibabel.affines import apply_affine, rescale_affine
 
@@ -63,15 +65,11 @@ def deoblique_and_zooms(
     _, qcode = in_reference.get_qform(coded=True)
 
     # Calculate the 8 most extreme coordinates of oblique in in_reference space
-    corners = np.array(list(product((0, 1), repeat=3))) * (
-        np.array(oblique.shape[:3]) - 1
-    )
+    corners = np.array(list(product((0, 1), repeat=3))) * (np.array(oblique.shape[:3]) - 1)
     extent_ijk = apply_affine(np.linalg.inv(affine) @ oblique.affine, corners)
 
     underflow = np.clip(extent_ijk.min(0) - padding, None, 0).astype(int)
-    overflow = np.ceil(
-        np.clip(extent_ijk.max(0) + padding + 1 - ref_shape, 0, None)
-    ).astype(int)
+    overflow = np.ceil(np.clip(extent_ijk.max(0) + padding + 1 - ref_shape, 0, None)).astype(int)
     if np.any(underflow < 0) or np.any(overflow > 0):
         # Add under/overflow voxels
         ref_shape += overflow - underflow
@@ -98,8 +96,9 @@ def deoblique_and_zooms(
 def resample_to_zooms(in_file, zooms, order=3, prefilter=True):
     """Resample the input data to a new grid with the requested zooms."""
     from pathlib import Path
-    import numpy as np
+
     import nibabel as nb
+    import numpy as np
     from nibabel.affines import rescale_affine
     from nitransforms.linear import Affine
 
@@ -153,18 +152,19 @@ def ensure_positive_cosines(img):
 
 def brain_masker(in_file, out_file=None, padding=5):
     """Use grayscale morphological operations to obtain a quick mask of EPI data."""
-    from pathlib import Path
     import re
+    from pathlib import Path
+
     import nibabel as nb
     import numpy as np
     from scipy import ndimage
-    from skimage.morphology import ball
     from skimage.filters import threshold_otsu
+    from skimage.morphology import ball
     from skimage.segmentation import random_walker
 
     # Load data
     img = nb.load(in_file)
-    data = np.pad(img.get_fdata(dtype="float32"), padding)
+    data = np.pad(img.get_fdata(dtype='float32'), padding)
     hdr = img.header.copy()
 
     # Cleanup background and invert intensity
@@ -182,16 +182,16 @@ def brain_masker(in_file, out_file=None, padding=5):
     # Rough binary mask
     closedbin = np.zeros_like(closed)
     closedbin[closed < th] = 1
-    closedbin = ndimage.binary_opening(closedbin, ball(3)).astype("uint8")
+    closedbin = ndimage.binary_opening(closedbin, ball(3)).astype('uint8')
 
     label_im, nb_labels = ndimage.label(closedbin)
     sizes = ndimage.sum(closedbin, label_im, range(nb_labels + 1))
     mask = sizes == sizes.max()
     closedbin = mask[label_im]
-    closedbin = ndimage.binary_closing(closedbin, ball(5)).astype("uint8")
+    closedbin = ndimage.binary_closing(closedbin, ball(5)).astype('uint8')
 
     # Prepare markers
-    markers = np.ones_like(closed, dtype="int8") * 2
+    markers = np.ones_like(closed, dtype='int8') * 2
     markers[1:-1, 1:-1, 1:-1] = 0
     closedbin_dil = ndimage.binary_dilation(closedbin, ball(5))
     markers[closedbin_dil] = 0
@@ -205,21 +205,17 @@ def brain_masker(in_file, out_file=None, padding=5):
         segtarget, markers, spacing=img.header.get_zooms()[:3], return_full_prob=True
     )[..., padding:-padding, padding:-padding, padding:-padding]
 
-    out_mask = Path(out_file or "brain_mask.nii.gz").absolute()
+    out_mask = Path(out_file or 'brain_mask.nii.gz').absolute()
 
-    hdr.set_data_dtype("uint8")
-    img.__class__((labels[0, ...] >= 0.5).astype("uint8"), img.affine, hdr).to_filename(
-        out_mask
-    )
+    hdr.set_data_dtype('uint8')
+    img.__class__((labels[0, ...] >= 0.5).astype('uint8'), img.affine, hdr).to_filename(out_mask)
 
-    out_probseg = re.sub(
-        r"\.nii(\.gz)$", r"_probseg.nii\1", str(out_mask).replace("_mask.", ".")
-    )
-    hdr.set_data_dtype("float32")
+    out_probseg = re.sub(r'\.nii(\.gz)$', r'_probseg.nii\1', str(out_mask).replace('_mask.', '.'))
+    hdr.set_data_dtype('float32')
     img.__class__((labels[0, ...]), img.affine, hdr).to_filename(out_probseg)
 
     out_brain = re.sub(
-        r"\.nii(\.gz)$", r"_brainmasked.nii\1", str(out_mask).replace("_mask.", ".")
+        r'\.nii(\.gz)$', r'_brainmasked.nii\1', str(out_mask).replace('_mask.', '.')
     )
     data = np.asanyarray(img.dataobj)
     data[labels[0, ...] < 0.5] = 0
@@ -282,14 +278,14 @@ def reorient_pedir(pe_dir, source_ornt, target_ornt=None):
 
     xfm = ornt_transform(source_ornt, target_ornt).astype(int)  # shape: (3, 2)
 
-    directions = "ijk" if pe_dir[0] in "ijk" else "xyz"
+    directions = 'ijk' if pe_dir[0] in 'ijk' else 'xyz'
 
     source_axis = directions.index(pe_dir[0])
-    source_flip = pe_dir[1:] == "-"
+    source_flip = pe_dir[1:] == '-'
 
     axis_xfm = xfm[source_axis, :]  # shape: (2,)
 
     target_axis = directions[axis_xfm[0]]
     target_flip = source_flip ^ (axis_xfm[1] == -1)
 
-    return f"{target_axis}-" if target_flip else target_axis
+    return f'{target_axis}-' if target_flip else target_axis
diff --git a/sdcflows/utils/wrangler.py b/sdcflows/utils/wrangler.py
index 977222dc58..acbcbe6ff9 100644
--- a/sdcflows/utils/wrangler.py
+++ b/sdcflows/utils/wrangler.py
@@ -21,56 +21,49 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Find fieldmaps on the BIDS inputs for :abbr:`SDC (susceptibility distortion correction)`."""
+
 from __future__ import annotations
+
 import logging
+from contextlib import suppress
 from functools import reduce
 from itertools import product
-from contextlib import suppress
 from pathlib import Path
-from typing import Optional, Union, List, Dict, Any
-from bids.layout import BIDSLayout, BIDSFile
+from typing import Any, Dict, List, Optional, Union
+
+from bids.layout import BIDSFile, BIDSLayout
 from bids.utils import listify
 
 from .. import fieldmaps as fm
 
 
-def _normalize_intent(
-    intent: str,
-    subject: str
-) -> str | None:
+def _normalize_intent(intent: str, subject: str) -> str | None:
     """Convert BIDS-URI intent to subject-relative intent
 
     SDCFlows currently makes strong assumptions about old-style intents,
     and a change to that needs to be carefully considered and tested.
     """
-    if intent.startswith("bids::"):
+    if intent.startswith('bids::'):
         # bids::sub-<subject>/
         #          ^- 10     ^- 11
-        return intent[11 + len(subject):]
+        return intent[11 + len(subject) :]
     return intent
 
 
-def _resolve_intent(
-    intent: str,
-    layout: BIDSLayout,
-    subject: str
-) -> str | None:
+def _resolve_intent(intent: str, layout: BIDSLayout, subject: str) -> str | None:
     root = Path(layout.root)
-    if intent.startswith("bids::"):
+    if intent.startswith('bids::'):
         return str(root / intent[6:])
-    if not intent.startswith("bids:"):
-        return str(root / f"sub-{subject}" / intent)
+    if not intent.startswith('bids:'):
+        return str(root / f'sub-{subject}' / intent)
     return intent
 
 
-def _filter_metadata(
-    metadata: Dict[str, Any],
-    subject: str
-) -> Dict[str, Any]:
-    intents = metadata.get("IntendedFor")
+def _filter_metadata(metadata: Dict[str, Any], subject: str) -> Dict[str, Any]:
+    intents = metadata.get('IntendedFor')
     if intents:
         updated = [_normalize_intent(intent, subject) for intent in listify(intents)]
-        return {**metadata, "IntendedFor": updated}
+        return {**metadata, 'IntendedFor': updated}
     return metadata
 
 
@@ -322,32 +315,33 @@ def find_estimators(
                        bids_id='auto_...')]
 
     """
-    from .misc import create_logger
-    from bids.layout import Query
     from bids.exceptions import BIDSEntityError
+    from bids.layout import Query
+
+    from .misc import create_logger
 
     # The created logger is set to ERROR log level
     logger = logger or create_logger('sdcflows.wrangler')
 
     base_entities = {
-        "subject": subject,
-        "extension": [".nii", ".nii.gz"],
-        "part": ["mag", None],
-        "scope": "raw",  # Ensure derivatives are not captured
+        'subject': subject,
+        'extension': ['.nii', '.nii.gz'],
+        'part': ['mag', None],
+        'scope': 'raw',  # Ensure derivatives are not captured
     }
 
     if bids_filters:
         filters = bids_filters.copy()  # copy to avoid altering in place
         if 'session' in bids_filters and sessions is not None:
-            raise ValueError("Filters include session, but session is already defined.")
+            raise ValueError('Filters include session, but session is already defined.')
         sessions = listify(filters.pop('session', None))
         base_entities.update(filters)
 
-    subject_root = Path(layout.root) / f"sub-{subject}"
+    subject_root = Path(layout.root) / f'sub-{subject}'
     sessions = sessions or layout.get_sessions(subject=subject) or [None]
     fmapless = fmapless or {}
     if fmapless is True:
-        fmapless = {"bold", "dwi", "asl"}
+        fmapless = {'bold', 'dwi', 'asl'}
 
     estimators = []
 
@@ -358,19 +352,19 @@ def find_estimators(
         b0_ids = reduce(
             set.union,
             (listify(ids) for ids in layout.get_B0FieldIdentifiers(**base_entities)),
-            set()
+            set(),
         )
 
     if b0_ids:
         logger.debug(
-            "Dataset includes `B0FieldIdentifier` metadata."
-            "Any data missing this metadata will be ignored."
+            'Dataset includes `B0FieldIdentifier` metadata.'
+            'Any data missing this metadata will be ignored.'
         )
 
         for b0_id in b0_ids:
             # Found B0FieldIdentifier metadata entries
             b0_entities = base_entities.copy()
-            b0_entities["B0FieldIdentifier"] = b0_id
+            b0_entities['B0FieldIdentifier'] = b0_id
 
             bare_ids = layout.get(**base_entities, B0FieldIdentifier=b0_id)
             listed_ids = layout.get(
@@ -399,7 +393,7 @@ def find_estimators(
         for fmap in layout.get(
             **{
                 **base_entities,
-                **{'suffix': ["fieldmap", "phasediff", "phase1"], 'session': sessions}
+                **{'suffix': ['fieldmap', 'phasediff', 'phase1'], 'session': sessions},
             }
         ):
             try:
@@ -411,26 +405,22 @@ def find_estimators(
                 )
             except (ValueError, TypeError) as err:
                 _log_debug_estimator_fail(
-                    logger, "unnamed fieldmap", [fmap], layout.root, str(err)
+                    logger, 'unnamed fieldmap', [fmap], layout.root, str(err)
                 )
             else:
                 _log_debug_estimation(logger, e, layout.root)
                 estimators.append(e)
 
         # A bunch of heuristics to select EPI fieldmaps
-        acqs = (
-            base_entities.get('acquisitions')
-            or layout.get_acquisitions(subject=subject, suffix="epi") + [None]
-        )
-        contrasts = (
-            base_entities.get('ceagent')
-            or layout.get_ceagents(subject=subject, suffix="epi") + [None]
-        )
+        acqs = base_entities.get('acquisitions') or layout.get_acquisitions(
+            subject=subject, suffix='epi'
+        ) + [None]
+        contrasts = base_entities.get('ceagent') or layout.get_ceagents(
+            subject=subject, suffix='epi'
+        ) + [None]
         for ses, acq, ce in product(sessions, acqs, contrasts):
             entities = base_entities.copy()
-            entities.update(
-                {"suffix": "epi", "session": ses, "acquisition": acq, "ceagent": ce}
-            )
+            entities.update({'suffix': 'epi', 'session': ses, 'acquisition': acq, 'ceagent': ce})
             dirs = layout.get_directions(**entities)
             if len(dirs) > 1:
                 by_intent = {}
@@ -447,7 +437,7 @@ def find_estimators(
                         e = fm.FieldmapEstimation(collection)
                     except (ValueError, TypeError) as err:
                         _log_debug_estimator_fail(
-                            logger, "unnamed PEPOLAR", collection, layout.root, str(err)
+                            logger, 'unnamed PEPOLAR', collection, layout.root, str(err)
                         )
                     else:
                         _log_debug_estimation(logger, e, layout.root)
@@ -460,72 +450,61 @@ def find_estimators(
             has_intended = layout.get(
                 **{
                     **base_entities,
-                    **{'suffix': 'epi', 'IntendedFor': Query.REQUIRED, 'session': sessions}
+                    **{'suffix': 'epi', 'IntendedFor': Query.REQUIRED, 'session': sessions},
                 }
             )
 
         for epi_fmap in has_intended:
             if epi_fmap.path in fm._estimators.sources:
-                logger.debug("Skipping fieldmap %s (already in use)", epi_fmap.relpath)
+                logger.debug('Skipping fieldmap %s (already in use)', epi_fmap.relpath)
                 continue  # skip EPI images already considered above
 
-            logger.debug("Found single PE fieldmap %s", epi_fmap.relpath)
+            logger.debug('Found single PE fieldmap %s', epi_fmap.relpath)
             epi_base_md = epi_fmap.get_metadata()
 
             # Find existing IntendedFor targets and warn if missing
             all_targets = []
-            for intent in listify(epi_base_md["IntendedFor"]):
+            for intent in listify(epi_base_md['IntendedFor']):
                 target = layout.get_file(_resolve_intent(intent, layout, subject))
                 if target is None:
-                    logger.debug("Single PE target %s not found", intent)
+                    logger.debug('Single PE target %s not found', intent)
                     continue
                 all_targets.append(target)
 
             # If sbrefs are targets, then the goal is generally to estimate with epi+sbref
             # and correct bold/dwi/asl
-            sbrefs = [
-                target for target in all_targets if target.entities["suffix"] == "sbref"
-            ]
+            sbrefs = [target for target in all_targets if target.entities['suffix'] == 'sbref']
             if sbrefs:
                 targets = sbrefs
                 intent_map = []
                 for sbref in sbrefs:
                     ents = sbref.get_entities(metadata=False)
-                    ents["suffix"] = ["bold", "dwi", "asl"]
+                    ents['suffix'] = ['bold', 'dwi', 'asl']
                     intent_map.append(
-                        [
-                            target
-                            for target in layout.get(**ents)
-                            if target in all_targets
-                        ]
+                        [target for target in layout.get(**ents) if target in all_targets]
                     )
             else:
                 targets = all_targets
                 intent_map = [[target] for target in all_targets]
 
             for target, intent in zip(targets, intent_map):
-                logger.debug("Found single PE target %s", target.relpath)
+                logger.debug('Found single PE target %s', target.relpath)
                 # The new estimator is IntendedFor the individual targets,
                 # even if the EPI file is IntendedFor multiple
                 estimator_md = epi_base_md.copy()
-                estimator_md["IntendedFor"] = [
-                    str(Path(pathlike).relative_to(subject_root))
-                    for pathlike in intent
+                estimator_md['IntendedFor'] = [
+                    str(Path(pathlike).relative_to(subject_root)) for pathlike in intent
                 ]
                 try:
                     e = fm.FieldmapEstimation(
                         [
                             fm.FieldmapFile(epi_fmap.path, metadata=estimator_md),
-                            fm.FieldmapFile(target.path, metadata=target.get_metadata())
+                            fm.FieldmapFile(target.path, metadata=target.get_metadata()),
                         ]
                     )
                 except (ValueError, TypeError) as err:
                     _log_debug_estimator_fail(
-                        logger,
-                        "unnamed PEPOLAR",
-                        [epi_fmap, target],
-                        layout.root,
-                        str(err)
+                        logger, 'unnamed PEPOLAR', [epi_fmap, target], layout.root, str(err)
                     )
                 else:
                     _log_debug_estimation(logger, e, layout.root)
@@ -538,10 +517,10 @@ def find_estimators(
     anat_file = layout.get(**{**base_entities, **{'suffix': anat_suffix, 'session': sessions}})
 
     if not fmapless or not anat_file:
-        logger.debug("Skipping fmap-less estimation")
+        logger.debug('Skipping fmap-less estimation')
         return estimators
 
-    logger.debug("Attempting fmap-less estimation")
+    logger.debug('Attempting fmap-less estimation')
     estimator_specs = find_anatomical_estimators(
         anat_file=anat_file[0],
         layout=layout,
@@ -554,7 +533,7 @@ def find_estimators(
         try:
             estimator = fm.FieldmapEstimation(spec)
         except (ValueError, TypeError) as err:
-            _log_debug_estimator_fail(logger, "ANAT", spec, layout.root, str(err))
+            _log_debug_estimator_fail(logger, 'ANAT', spec, layout.root, str(err))
         else:
             _log_debug_estimation(logger, estimator, layout.root)
             estimators.append(estimator)
@@ -596,21 +575,21 @@ def find_anatomical_estimators(
 
     from .epimanip import get_trt
 
-    subject_root = Path(layout.root) / f"sub-{subject}"
+    subject_root = Path(layout.root) / f'sub-{subject}'
 
     hits = set()  # Avoid duplicates
     estimators = []
     for ses, suffix in sorted(product(sessions, suffixes)):
-        suffixes = ["sbref", suffix]  # Order indicates preference; prefer sbref
+        suffixes = ['sbref', suffix]  # Order indicates preference; prefer sbref
         datatype = {
-            "bold": "func",
-            "dwi": "dwi",
-            "asl": "perf",
+            'bold': 'func',
+            'dwi': 'dwi',
+            'asl': 'perf',
         }[suffix]
         candidates = layout.get(
             **{
                 **base_entities,
-                **{"suffix": suffixes, "session": ses, "datatype": datatype},
+                **{'suffix': suffixes, 'session': ses, 'datatype': datatype},
             }
         )
 
@@ -620,16 +599,16 @@ def find_anatomical_estimators(
         for candidate in candidates:
             meta = candidate.get_metadata()
 
-            if not meta.get("PhaseEncodingDirection"):
+            if not meta.get('PhaseEncodingDirection'):
                 continue
 
             with suppress(ValueError):
-                meta.update({"TotalReadoutTime": get_trt(meta, candidate.path)})
+                meta.update({'TotalReadoutTime': get_trt(meta, candidate.path)})
             epi_targets.append(fm.FieldmapFile(candidate, metadata=meta))
 
         def sort_key(fmap):
             # Return sbref before DWI/BOLD and shortest echo first
-            return suffixes.index(fmap.suffix), fmap.metadata.get("EchoTime", 1)
+            return suffixes.index(fmap.suffix), fmap.metadata.get('EchoTime', 1)
 
         for target in sorted(epi_targets, key=sort_key):
             if target.path in hits:
@@ -637,15 +616,13 @@ def sort_key(fmap):
             query = {**base_entities, **target.entities}
 
             # Find all echos, so strip from query, if present
-            query.pop("echo", None)
+            query.pop('echo', None)
 
             # Include sbref and EPI images in IntendedFor
             # No harm in including sbrefs that won't be corrected,
             # and ensures the hits set prevents doubling up
             intent = [Path(epi) for epi in layout.get(suffix=suffixes, **query)]
-            metadata = {
-                "IntendedFor": [str(epi.relative_to(subject_root)) for epi in intent]
-            }
+            metadata = {'IntendedFor': [str(epi.relative_to(subject_root)) for epi in intent]}
             estimators.append([fm.FieldmapFile(anat_file, metadata=metadata), target])
             hits.update(intent)
 
@@ -659,27 +636,21 @@ def _log_debug_estimation(
 ) -> None:
     """A helper function to log estimation information when running with verbosity."""
     logger.debug(
-        "Found %s estimation from %d sources:\n- %s",
+        'Found %s estimation from %d sources:\n- %s',
         estimation.method.name,
         len(estimation.sources),
-        "\n- ".join(
-            [str(Path(s.path).relative_to(bids_root)) for s in estimation.sources]
-        ),
+        '\n- '.join([str(Path(s.path).relative_to(bids_root)) for s in estimation.sources]),
     )
 
 
 def _log_debug_estimator_fail(
-    logger: logging.Logger,
-    b0_id: str,
-    files: List[BIDSFile],
-    bids_root: str,
-    message: str
+    logger: logging.Logger, b0_id: str, files: List[BIDSFile], bids_root: str, message: str
 ) -> None:
     """A helper function to log failures to build an estimator when running with verbosity."""
     logger.debug(
-        "Failed to construct %s estimation from %d sources:\n- %s\nError: %s",
+        'Failed to construct %s estimation from %d sources:\n- %s\nError: %s',
         b0_id,
         len(files),
-        "\n- ".join([str(Path(s.path).relative_to(bids_root)) for s in files]),
+        '\n- '.join([str(Path(s.path).relative_to(bids_root)) for s in files]),
         message,
     )
diff --git a/sdcflows/viz/utils.py b/sdcflows/viz/utils.py
index 0790d04d50..2da06282bc 100644
--- a/sdcflows/viz/utils.py
+++ b/sdcflows/viz/utils.py
@@ -27,12 +27,12 @@ def plot_registration(
     anat_nii,
     div_id,
     plot_params=None,
-    order=("z", "x", "y"),
+    order=('z', 'x', 'y'),
     cuts=None,
     estimate_brightness=False,
     label=None,
     contour=None,
-    compress="auto",
+    compress='auto',
     overlay=None,
     overlay_params=None,
 ):
@@ -43,11 +43,11 @@ def plot_registration(
     """
     from uuid import uuid4
 
-    from lxml import etree
     import matplotlib.pyplot as plt
+    from lxml import etree
     from nilearn.plotting import plot_anat
     from nireports._vendored.svgutils.transform import SVGFigure
-    from nireports.reportlets.utils import robust_set_limits, extract_svg, SVGNS
+    from nireports.reportlets.utils import SVGNS, extract_svg, robust_set_limits
 
     plot_params = plot_params or {}
 
@@ -58,31 +58,31 @@ def plot_registration(
     out_files = []
     if estimate_brightness:
         plot_params = robust_set_limits(
-            anat_nii.get_fdata(dtype="float32").reshape(-1), plot_params
+            anat_nii.get_fdata(dtype='float32').reshape(-1), plot_params
         )
 
     # Plot each cut axis
     for i, mode in enumerate(list(order)):
-        plot_params["display_mode"] = mode
-        plot_params["cut_coords"] = cuts[mode]
+        plot_params['display_mode'] = mode
+        plot_params['cut_coords'] = cuts[mode]
         if i == 0:
-            plot_params["title"] = label
+            plot_params['title'] = label
         else:
-            plot_params["title"] = None
+            plot_params['title'] = None
 
         # Generate nilearn figure
         display = plot_anat(anat_nii, **plot_params)
         if overlay is not None:
             _overlay_params = {
-                "vmin": overlay.get_fdata(dtype="float32").min(),
-                "vmax": overlay.get_fdata(dtype="float32").max(),
-                "cmap": plt.cm.gray,
-                "interpolation": "nearest",
+                'vmin': overlay.get_fdata(dtype='float32').min(),
+                'vmax': overlay.get_fdata(dtype='float32').max(),
+                'cmap': plt.cm.gray,
+                'interpolation': 'nearest',
             }
             _overlay_params.update(overlay_params)
             display.add_overlay(overlay, **_overlay_params)
         if contour is not None:
-            display.add_contours(contour, colors="g", levels=[0.5], linewidths=0.5)
+            display.add_contours(contour, colors='g', levels=[0.5], linewidths=0.5)
 
         svg = extract_svg(display, compress=compress)
         display.close()
@@ -90,7 +90,7 @@ def plot_registration(
         # Find and replace the figure_1 id.
         xml_data = etree.fromstring(svg)
         find_text = etree.ETXPath("//{%s}g[@id='figure_1']" % SVGNS)
-        find_text(xml_data)[0].set("id", "%s-%s-%s" % (div_id, mode, uuid4()))
+        find_text(xml_data)[0].set('id', '%s-%s-%s' % (div_id, mode, uuid4()))
 
         svg_fig = SVGFigure()
         svg_fig.root = xml_data
@@ -101,8 +101,8 @@ def plot_registration(
 
 def coolwarm_transparent(max_alpha=0.7, opaque_perc=30, transparent_perc=8):
     """Modify the coolwarm color scale to have full transparency around the middle."""
-    import numpy as np
     import matplotlib.pylab as pl
+    import numpy as np
     from matplotlib.colors import ListedColormap
 
     # Choose colormap
diff --git a/sdcflows/workflows/ancillary.py b/sdcflows/workflows/ancillary.py
index ee2dc330c6..bcc3fea19e 100644
--- a/sdcflows/workflows/ancillary.py
+++ b/sdcflows/workflows/ancillary.py
@@ -21,15 +21,16 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Estimate fieldmaps for :abbr:`SDC (susceptibility distortion correction)`."""
+
 from nipype import logging
-from nipype.pipeline import engine as pe
 from nipype.interfaces import utility as niu
+from nipype.pipeline import engine as pe
 from niworkflows.engine.workflows import LiterateWorkflow as Workflow
 
-LOGGER = logging.getLogger("nipype.workflow")
+LOGGER = logging.getLogger('nipype.workflow')
 
 
-def init_brainextraction_wf(name="brainextraction_wf"):
+def init_brainextraction_wf(name='brainextraction_wf'):
     """
     Remove nonbrain tissue from images.
 
@@ -60,25 +61,26 @@ def init_brainextraction_wf(name="brainextraction_wf"):
     """
     from nipype.interfaces.ants import N4BiasFieldCorrection
     from niworkflows.interfaces.nibabel import IntensityClip
+
     from ..interfaces.brainmask import BrainExtraction
 
     wf = Workflow(name=name)
 
     inputnode = pe.Node(
-        niu.IdentityInterface(fields=("in_file", "bspline_dist")), name="inputnode"
+        niu.IdentityInterface(fields=('in_file', 'bspline_dist')), name='inputnode'
     )
     outputnode = pe.Node(
         niu.IdentityInterface(
             fields=(
-                "out_file",
-                "out_brain",
-                "out_mask",
-                "out_probseg",
+                'out_file',
+                'out_brain',
+                'out_mask',
+                'out_probseg',
             )
         ),
-        name="outputnode",
+        name='outputnode',
     )
-    clipper_pre = pe.Node(IntensityClip(), name="clipper_pre")
+    clipper_pre = pe.Node(IntensityClip(), name='clipper_pre')
 
     # de-gradient the fields ("bias/illumination artifact")
     n4 = pe.Node(
@@ -90,10 +92,10 @@ def init_brainextraction_wf(name="brainextraction_wf"):
             shrink_factor=4,
         ),
         n_procs=8,
-        name="n4",
+        name='n4',
     )
-    clipper_post = pe.Node(IntensityClip(p_min=0.01, p_max=99.9), name="clipper_post")
-    masker = pe.Node(BrainExtraction(), name="masker")
+    clipper_post = pe.Node(IntensityClip(p_min=0.01, p_max=99.9), name='clipper_post')
+    masker = pe.Node(BrainExtraction(), name='masker')
 
     # fmt:off
     wf.connect([
diff --git a/sdcflows/workflows/apply/correction.py b/sdcflows/workflows/apply/correction.py
index 6c99727a01..58cfbac514 100644
--- a/sdcflows/workflows/apply/correction.py
+++ b/sdcflows/workflows/apply/correction.py
@@ -21,8 +21,9 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Applying a fieldmap given its B-Spline coefficients in Hz."""
-from nipype.pipeline import engine as pe
+
 from nipype.interfaces import utility as niu
+from nipype.pipeline import engine as pe
 from niworkflows.engine.workflows import LiterateWorkflow as Workflow
 
 
@@ -34,7 +35,7 @@ def init_unwarp_wf(
     free_mem=None,
     omp_nthreads=1,
     debug=False,
-    name="unwarp_wf",
+    name='unwarp_wf',
 ):
     r"""
     Set up a workflow that unwarps the input :abbr:`EPI (echo-planar imaging)` dataset.
@@ -87,43 +88,44 @@ def init_unwarp_wf(
     """
     from niworkflows.interfaces.images import RobustAverage
     from niworkflows.interfaces.nibabel import MergeSeries
-    from sdcflows.interfaces.epi import GetReadoutTime
+
     from sdcflows.interfaces.bspline import ApplyCoeffsField
-    from sdcflows.workflows.ancillary import init_brainextraction_wf
+    from sdcflows.interfaces.epi import GetReadoutTime
     from sdcflows.utils.misc import front as _pop
+    from sdcflows.workflows.ancillary import init_brainextraction_wf
 
     workflow = Workflow(name=name)
     inputnode = pe.Node(
         niu.IdentityInterface(
             fields=[
-                "distorted",
-                "metadata",
-                "fmap_coeff",
-                "fmap2data_xfm",
-                "data2fmap_xfm",
-                "hmc_xforms",
+                'distorted',
+                'metadata',
+                'fmap_coeff',
+                'fmap2data_xfm',
+                'data2fmap_xfm',
+                'hmc_xforms',
             ]
         ),
-        name="inputnode",
+        name='inputnode',
     )
     outputnode = pe.Node(
         niu.IdentityInterface(
             fields=[
-                "fieldmap",
-                "fieldwarp",
-                "corrected",
-                "corrected_ref",
-                "corrected_mask",
+                'fieldmap',
+                'fieldwarp',
+                'corrected',
+                'corrected_ref',
+                'corrected_mask',
             ]
         ),
-        name="outputnode",
+        name='outputnode',
     )
 
     rotime = pe.Node(
         GetReadoutTime(
             use_estimate=use_metadata_estimates,
         ),
-        name="rotime",
+        name='rotime',
         run_without_submitting=True,
     )
     rotime.interface._always_run = debug
@@ -144,11 +146,11 @@ def init_unwarp_wf(
     resample = pe.Node(
         ApplyCoeffsField(jacobian=jacobian, num_threads=num_threads),
         mem_gb=mem_per_thread * num_threads,
-        name="resample",
+        name='resample',
     )
 
-    merge = pe.Node(MergeSeries(), name="merge")
-    average = pe.Node(RobustAverage(mc_method=None), name="average")
+    merge = pe.Node(MergeSeries(), name='merge')
+    average = pe.Node(RobustAverage(mc_method=None), name='average')
 
     brainextraction_wf = init_brainextraction_wf()
 
diff --git a/sdcflows/workflows/apply/registration.py b/sdcflows/workflows/apply/registration.py
index 3e05811dda..b9fb1b2775 100644
--- a/sdcflows/workflows/apply/registration.py
+++ b/sdcflows/workflows/apply/registration.py
@@ -29,9 +29,11 @@
 The target EPI is the distorted dataset (or a reference thereof).
 
 """
+
 from warnings import warn
-from nipype.pipeline import engine as pe
+
 from nipype.interfaces import utility as niu
+from nipype.pipeline import engine as pe
 from niworkflows.engine.workflows import LiterateWorkflow as Workflow
 
 from ... import data
@@ -42,7 +44,7 @@ def init_coeff2epi_wf(
     sloppy=False,
     debug=False,
     write_coeff=False,
-    name="coeff2epi_wf",
+    name='coeff2epi_wf',
 ):
     """
     Move the field coefficients on to the target (distorted) EPI space.
@@ -94,8 +96,9 @@ def init_coeff2epi_wf(
         as moving, resampling the latter into the fieldmap space.
 
     """
-    from packaging.version import parse as parseversion, Version
     from niworkflows.interfaces.fixes import FixHeaderRegistration as Registration
+    from packaging.version import Version
+    from packaging.version import parse as parseversion
 
     from sdcflows.interfaces import brainmask
 
@@ -107,34 +110,34 @@ def init_coeff2epi_wf(
 """
     inputnode = pe.Node(
         niu.IdentityInterface(
-            fields=["target_ref", "target_mask", "fmap_ref", "fmap_mask", "fmap_coeff"]
+            fields=['target_ref', 'target_mask', 'fmap_ref', 'fmap_mask', 'fmap_coeff']
         ),
-        name="inputnode",
+        name='inputnode',
     )
     outputnode = pe.Node(
-        niu.IdentityInterface(fields=["target_ref", "fmap_coeff", "target2fmap_xfm"]),
-        name="outputnode",
+        niu.IdentityInterface(fields=['target_ref', 'fmap_coeff', 'target2fmap_xfm']),
+        name='outputnode',
     )
 
     # Dilate only for coregistration purposes
     # https://github.com/nipreps/sdcflows/issues/461
-    dilate_target_mask = pe.Node(brainmask.BinaryDilation(radius=5), name="dilate_target_mask")
-    dilate_fmap_mask = pe.Node(brainmask.BinaryDilation(radius=5), name="dilate_fmap_mask")
+    dilate_target_mask = pe.Node(brainmask.BinaryDilation(radius=5), name='dilate_target_mask')
+    dilate_fmap_mask = pe.Node(brainmask.BinaryDilation(radius=5), name='dilate_fmap_mask')
 
     # Register the reference of the fieldmap to the reference
     # of the target image (the one that shall be corrected)
     coregister = pe.Node(
         Registration(
-            from_file=data.load(f"fmap-any_registration{'_testing' * sloppy}.json"),
+            from_file=data.load(f'fmap-any_registration{"_testing" * sloppy}.json'),
             output_warped_image=debug,
             output_inverse_warped_image=debug,
         ),
-        name="coregister",
+        name='coregister',
         n_procs=omp_nthreads,
     )
 
-    ver = coregister.interface.version or "2.2.0"
-    mask_trait_s = "s" if parseversion(ver) >= Version("2.2.0") else ""
+    ver = coregister.interface.version or '2.2.0'
+    mask_trait_s = 's' if parseversion(ver) >= Version('2.2.0') else ''
 
     # fmt: off
     workflow.connect([
@@ -160,8 +163,8 @@ def init_coeff2epi_wf(
 
     if write_coeff:
         warn(
-            "SDCFlows does not tinker with the coefficients file anymore, "
-            "the `write_coeff` parameter will be removed in a future release."
+            'SDCFlows does not tinker with the coefficients file anymore, '
+            'the `write_coeff` parameter will be removed in a future release.'
         )
 
     return workflow
diff --git a/sdcflows/workflows/apply/tests/test_correction.py b/sdcflows/workflows/apply/tests/test_correction.py
index fcb0446444..32774e8bfb 100644
--- a/sdcflows/workflows/apply/tests/test_correction.py
+++ b/sdcflows/workflows/apply/tests/test_correction.py
@@ -21,88 +21,85 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test unwarp."""
+
 import json
+
 import pytest
-from nipype.pipeline import engine as pe
 from nipype.interfaces import utility as niu
+from nipype.pipeline import engine as pe
 from nireports.interfaces.reporting.base import SimpleBeforeAfterRPT as SimpleBeforeAfter
+
 from sdcflows.workflows.apply.correction import init_unwarp_wf
 
 
-@pytest.mark.parametrize("with_affine", [False, True])
+@pytest.mark.parametrize('with_affine', [False, True])
 def test_unwarp_wf(tmpdir, datadir, workdir, outdir, with_affine):
     """Test the unwarping workflow."""
     tmpdir.chdir()
 
-    derivs_path = datadir / "HCP101006" / "derivatives" / "sdcflows-2.x"
+    derivs_path = datadir / 'HCP101006' / 'derivatives' / 'sdcflows-2.x'
 
     distorted = (
-        datadir
-        / "HCP101006"
-        / "sub-101006"
-        / "func"
-        / "sub-101006_task-rest_dir-LR_sbref.nii.gz"
+        datadir / 'HCP101006' / 'sub-101006' / 'func' / 'sub-101006_task-rest_dir-LR_sbref.nii.gz'
     )
 
     workflow = init_unwarp_wf(omp_nthreads=2, debug=True)
     workflow.inputs.inputnode.distorted = str(distorted)
     workflow.inputs.inputnode.metadata = json.loads(
-        (distorted.parent / distorted.name.replace(".nii.gz", ".json")).read_text()
+        (distorted.parent / distorted.name.replace('.nii.gz', '.json')).read_text()
     )
     workflow.inputs.inputnode.fmap_coeff = [
-        str(derivs_path / "sub-101006_coeff-1_desc-topup_fieldmap.nii.gz")
+        str(derivs_path / 'sub-101006_coeff-1_desc-topup_fieldmap.nii.gz')
     ]
 
     if with_affine:
         workflow.inputs.inputnode.fmap2data_xfm = str(
-            str(derivs_path / "sub-101006_from-sbrefLR_to-fieldmapref_mode-image_xfm.mat")
+            str(derivs_path / 'sub-101006_from-sbrefLR_to-fieldmapref_mode-image_xfm.mat')
         )
 
     if outdir:
-        from ...outputs import DerivativesDataSink
         from ....interfaces.reportlets import FieldmapReportlet
+        from ...outputs import DerivativesDataSink
 
-        outdir = outdir / f"with{'' if with_affine else 'out'}-affine"
+        outdir = outdir / f'with{"" if with_affine else "out"}-affine'
         outdir.mkdir(exist_ok=True, parents=True)
         unwarp_wf = workflow  # Change variable name
-        workflow = pe.Workflow(name="outputs_unwarp_wf")
-        squeeze = pe.Node(niu.Function(function=_squeeze), name="squeeze")
+        workflow = pe.Workflow(name='outputs_unwarp_wf')
+        squeeze = pe.Node(niu.Function(function=_squeeze), name='squeeze')
 
         report = pe.Node(
             SimpleBeforeAfter(
-                before_label="Distorted",
-                after_label="Corrected",
-                before=str(distorted)
+                before_label='Distorted', after_label='Corrected', before=str(distorted)
             ),
-            name="report",
+            name='report',
             mem_gb=0.1,
         )
         ds_report = pe.Node(
             DerivativesDataSink(
                 base_directory=str(outdir),
-                suffix="bold",
-                desc="corrected",
-                datatype="figures",
-                dismiss_entities=("fmap",),
+                suffix='bold',
+                desc='corrected',
+                datatype='figures',
+                dismiss_entities=('fmap',),
                 source_file=distorted,
             ),
-            name="ds_report",
+            name='ds_report',
             run_without_submitting=True,
         )
 
-        rep = pe.Node(FieldmapReportlet(), "simple_report")
+        rep = pe.Node(FieldmapReportlet(), 'simple_report')
         rep.interface._always_run = True
 
         ds_fmap_report = pe.Node(
             DerivativesDataSink(
                 base_directory=str(outdir),
-                datatype="figures",
-                suffix="bold",
-                desc="fieldmap",
-                dismiss_entities=("fmap",),
+                datatype='figures',
+                suffix='bold',
+                desc='fieldmap',
+                dismiss_entities=('fmap',),
                 source_file=distorted,
             ),
-            name="ds_fmap_report",
+            name='ds_fmap_report',
         )
 
         # fmt: off
@@ -122,11 +119,12 @@ def test_unwarp_wf(tmpdir, datadir, workdir, outdir, with_affine):
 
     if workdir:
         workflow.base_dir = str(workdir)
-    workflow.run(plugin="Linear")
+    workflow.run(plugin='Linear')
 
 
 def _squeeze(in_file):
     from pathlib import Path
+
     import nibabel as nb
 
     img = nb.load(in_file)
diff --git a/sdcflows/workflows/apply/tests/test_registration.py b/sdcflows/workflows/apply/tests/test_registration.py
index 8824eef7ff..03f9976326 100644
--- a/sdcflows/workflows/apply/tests/test_registration.py
+++ b/sdcflows/workflows/apply/tests/test_registration.py
@@ -21,40 +21,35 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test pepolar type of fieldmaps."""
+
 import os
-import pytest
 
-from nipype.pipeline import engine as pe
+import pytest
 from nipype.interfaces import utility as niu
+from nipype.pipeline import engine as pe
 from nireports.interfaces.reporting.base import SimpleBeforeAfterRPT as SimpleBeforeAfter
 
 from ...fit.fieldmap import init_magnitude_wf
 from ..registration import init_coeff2epi_wf
 
 
-@pytest.mark.skipif(os.getenv("TRAVIS") == "true", reason="this is TravisCI")
+@pytest.mark.skipif(os.getenv('TRAVIS') == 'true', reason='this is TravisCI')
 def test_registration_wf(tmpdir, datadir, workdir, outdir):
     """Test fieldmap-to-target alignment workflow."""
-    epi_ref_wf = init_magnitude_wf(2, name="epi_ref_wf")
+    epi_ref_wf = init_magnitude_wf(2, name='epi_ref_wf')
     epi_ref_wf.inputs.inputnode.magnitude = (
-        datadir
-        / "HCP101006"
-        / "sub-101006"
-        / "func"
-        / "sub-101006_task-rest_dir-LR_sbref.nii.gz"
+        datadir / 'HCP101006' / 'sub-101006' / 'func' / 'sub-101006_task-rest_dir-LR_sbref.nii.gz'
     )
 
-    magnitude = (
-        datadir / "HCP101006" / "sub-101006" / "fmap" / "sub-101006_magnitude1.nii.gz"
-    )
-    fmap_ref_wf = init_magnitude_wf(2, name="fmap_ref_wf")
+    magnitude = datadir / 'HCP101006' / 'sub-101006' / 'fmap' / 'sub-101006_magnitude1.nii.gz'
+    fmap_ref_wf = init_magnitude_wf(2, name='fmap_ref_wf')
     fmap_ref_wf.inputs.inputnode.magnitude = magnitude
 
-    gen_coeff = pe.Node(niu.Function(function=_gen_coeff), name="gen_coeff")
+    gen_coeff = pe.Node(niu.Function(function=_gen_coeff), name='gen_coeff')
 
     reg_wf = init_coeff2epi_wf(2, debug=True, sloppy=True, write_coeff=True)
 
-    workflow = pe.Workflow(name="test_registration_wf")
+    workflow = pe.Workflow(name='test_registration_wf')
     # fmt: off
     workflow.connect([
         (epi_ref_wf, reg_wf, [
@@ -75,22 +70,22 @@ def test_registration_wf(tmpdir, datadir, workdir, outdir):
 
         report = pe.Node(
             SimpleBeforeAfter(
-                after_label="Target EPI",
-                before_label="B0 Reference",
+                after_label='Target EPI',
+                before_label='B0 Reference',
             ),
-            name="report",
+            name='report',
             mem_gb=0.1,
         )
         ds_report = pe.Node(
             DerivativesDataSink(
                 base_directory=str(outdir),
-                suffix="fieldmap",
-                space="sbref",
-                datatype="figures",
-                dismiss_entities=("fmap",),
+                suffix='fieldmap',
+                space='sbref',
+                datatype='figures',
+                dismiss_entities=('fmap',),
                 source_file=magnitude,
             ),
-            name="ds_report",
+            name='ds_report',
             run_without_submitting=True,
         )
 
@@ -105,7 +100,7 @@ def test_registration_wf(tmpdir, datadir, workdir, outdir):
     if workdir:
         workflow.base_dir = str(workdir)
 
-    workflow.run(plugin="Linear")
+    workflow.run(plugin='Linear')
 
 
 # def test_map_coeffs(tmpdir):
@@ -124,9 +119,10 @@ def test_registration_wf(tmpdir, datadir, workdir, outdir):
 
 def _gen_coeff(img):
     from pathlib import Path
+
     from sdcflows.interfaces.bspline import bspline_grid
 
-    out_file = Path("coeff.nii.gz").absolute()
+    out_file = Path('coeff.nii.gz').absolute()
     bspline_grid(img).to_filename(out_file)
     return str(out_file)
 
diff --git a/sdcflows/workflows/base.py b/sdcflows/workflows/base.py
index 95d3b6273e..788fd8b77f 100644
--- a/sdcflows/workflows/base.py
+++ b/sdcflows/workflows/base.py
@@ -23,13 +23,13 @@
 """Estimate fieldmaps for :abbr:`SDC (susceptibility distortion correction)`."""
 
 from nipype import logging
-from nipype.pipeline import engine as pe
 from nipype.interfaces import utility as niu
+from nipype.pipeline import engine as pe
 from niworkflows.engine.workflows import LiterateWorkflow as Workflow
 
 from ..utils.epimanip import get_trt
 
-LOGGER = logging.getLogger("nipype.workflow")
+LOGGER = logging.getLogger('nipype.workflow')
 DEFAULT_MEMORY_MIN_GB = 0.01
 
 
@@ -43,7 +43,7 @@ def init_fmap_preproc_wf(
     fallback_total_readout_time=None,
     sloppy=False,
     debug=False,
-    name="fmap_preproc_wf",
+    name='fmap_preproc_wf',
     **kwargs,
 ):
     """
@@ -81,10 +81,10 @@ def init_fmap_preproc_wf(
         The preprocessed fieldmap coefficients.
 
     """
+    from sdcflows.fieldmaps import EstimatorType
     from sdcflows.workflows.fit.pepolar import INPUT_FIELDS as _pepolar_fields
     from sdcflows.workflows.fit.syn import INPUT_FIELDS as _syn_fields
     from sdcflows.workflows.outputs import init_fmap_derivatives_wf, init_fmap_reports_wf
-    from sdcflows.fieldmaps import EstimatorType
 
     INPUT_FIELDS = {
         EstimatorType.ANAT: _syn_fields,
@@ -93,28 +93,22 @@ def init_fmap_preproc_wf(
 
     workflow = Workflow(name=name)
 
-    out_fields = ("fmap", "fmap_coeff", "fmap_ref", "fmap_mask", "fmap_id", "method")
-    out_merge = {
-        f: pe.Node(niu.Merge(len(estimators)), name=f"out_merge_{f}")
-        for f in out_fields
-    }
+    out_fields = ('fmap', 'fmap_coeff', 'fmap_ref', 'fmap_mask', 'fmap_id', 'method')
+    out_merge = {f: pe.Node(niu.Merge(len(estimators)), name=f'out_merge_{f}') for f in out_fields}
     # Fieldmaps and coefficient files can come in pairs, ensure they are not flattened
-    out_merge["fmap"].inputs.no_flatten = True
-    out_merge["fmap_coeff"].inputs.no_flatten = True
+    out_merge['fmap'].inputs.no_flatten = True
+    out_merge['fmap_coeff'].inputs.no_flatten = True
 
-    outputnode = pe.Node(niu.IdentityInterface(fields=out_fields), name="outputnode")
+    outputnode = pe.Node(niu.IdentityInterface(fields=out_fields), name='outputnode')
 
     workflow.connect(
-        [
-            (mergenode, outputnode, [("out", field)])
-            for field, mergenode in out_merge.items()
-        ]
+        [(mergenode, outputnode, [('out', field)]) for field, mergenode in out_merge.items()]
     )
 
     for n, estimator in enumerate(estimators, 1):
         if fallback_total_readout_time is None:
             for f in estimator.sources:
-                if f.suffix in ("bold", "dwi", "epi", "sbref", "asl", "m0scan"):
+                if f.suffix in ('bold', 'dwi', 'epi', 'sbref', 'asl', 'm0scan'):
                     try:
                         get_trt(
                             f.metadata,
@@ -122,7 +116,7 @@ def init_fmap_preproc_wf(
                             use_estimate=use_metadata_estimates,
                         )
                     except ValueError:
-                        msg = f"Missing readout timing information for <{f.path}>."
+                        msg = f'Missing readout timing information for <{f.path}>.'
                         raise RuntimeError(msg)
 
         est_wf = estimator.get_workflow(
@@ -133,12 +127,10 @@ def init_fmap_preproc_wf(
             sloppy=sloppy,
             **kwargs,
         )
-        source_files = [
-            str(f.path) for f in estimator.sources if f.suffix not in ("T1w", "T2w")
-        ]
+        source_files = [str(f.path) for f in estimator.sources if f.suffix not in ('T1w', 'T2w')]
 
         out_map = pe.Node(
-            niu.IdentityInterface(fields=out_fields), name=f"out_{estimator.bids_id}"
+            niu.IdentityInterface(fields=out_fields), name=f'out_{estimator.bids_id}'
         )
         out_map.inputs.fmap_id = estimator.bids_id
 
@@ -146,18 +138,16 @@ def init_fmap_preproc_wf(
             output_dir=str(output_dir),
             write_coeff=True,
             bids_fmap_id=estimator.bids_id,
-            name=f"fmap_derivatives_wf_{estimator.sanitized_id}",
+            name=f'fmap_derivatives_wf_{estimator.sanitized_id}',
         )
         fmap_derivatives_wf.inputs.inputnode.source_files = source_files
-        fmap_derivatives_wf.inputs.inputnode.fmap_meta = [
-            f.metadata for f in estimator.sources
-        ]
+        fmap_derivatives_wf.inputs.inputnode.fmap_meta = [f.metadata for f in estimator.sources]
 
         fmap_reports_wf = init_fmap_reports_wf(
             output_dir=str(output_dir),
-            fmap_type=str(estimator.method).rpartition(".")[-1].lower(),
+            fmap_type=str(estimator.method).rpartition('.')[-1].lower(),
             bids_fmap_id=estimator.bids_id,
-            name=f"fmap_reports_wf_{estimator.sanitized_id}",
+            name=f'fmap_reports_wf_{estimator.sanitized_id}',
         )
         fmap_reports_wf.inputs.inputnode.source_files = source_files
 
@@ -165,7 +155,7 @@ def init_fmap_preproc_wf(
             fields = INPUT_FIELDS[estimator.method]
             inputnode = pe.Node(
                 niu.IdentityInterface(fields=fields),
-                name=f"in_{estimator.sanitized_id}",
+                name=f'in_{estimator.sanitized_id}',
             )
             # fmt:off
             workflow.connect([
@@ -196,6 +186,6 @@ def init_fmap_preproc_wf(
         # fmt:on
 
         for field, mergenode in out_merge.items():
-            workflow.connect(out_map, field, mergenode, f"in{n}")
+            workflow.connect(out_map, field, mergenode, f'in{n}')
 
     return workflow
diff --git a/sdcflows/workflows/fit/base.py b/sdcflows/workflows/fit/base.py
index 5720cb8059..7ad2f086be 100644
--- a/sdcflows/workflows/fit/base.py
+++ b/sdcflows/workflows/fit/base.py
@@ -33,7 +33,7 @@ def init_sdcflows_wf():
     from sdcflows.workflows.outputs import init_fmap_derivatives_wf, init_fmap_reports_wf
 
     # Create parent workflow
-    workflow = Workflow(name="sdcflows_wf")
+    workflow = Workflow(name='sdcflows_wf')
     workflow.base_dir = config.execution.work_dir
 
     subjects = collect_participants(
@@ -61,22 +61,18 @@ def init_sdcflows_wf():
                 output_dir=config.execution.output_dir,
                 bids_fmap_id=estim.bids_id,
                 write_coeff=True,
-                name=f"fmap_derivatives_{estim.sanitized_id}",
+                name=f'fmap_derivatives_{estim.sanitized_id}',
             )
 
-            source_paths = [
-                str(source.path.absolute()) for source in estim.sources
-            ]
+            source_paths = [str(source.path.absolute()) for source in estim.sources]
             derivs_wf.inputs.inputnode.source_files = source_paths
-            derivs_wf.inputs.inputnode.fmap_meta = [
-                source.metadata for source in estim.sources
-            ]
+            derivs_wf.inputs.inputnode.fmap_meta = [source.metadata for source in estim.sources]
 
             reportlets_wf = init_fmap_reports_wf(
                 fmap_type=estim.method,
                 output_dir=config.execution.output_dir,
                 bids_fmap_id=estim.bids_id,
-                name=f"fmap_reports_{estim.sanitized_id}",
+                name=f'fmap_reports_{estim.sanitized_id}',
             )
             reportlets_wf.inputs.inputnode.source_files = source_paths
 
diff --git a/sdcflows/workflows/fit/fieldmap.py b/sdcflows/workflows/fit/fieldmap.py
index 93307f00d3..106f69f53f 100644
--- a/sdcflows/workflows/fit/fieldmap.py
+++ b/sdcflows/workflows/fit/fieldmap.py
@@ -22,19 +22,19 @@
 #
 r"""Processing phase-difference and *directly measured* :math:`B_0` maps."""
 
-from nipype.pipeline import engine as pe
 from nipype.interfaces import utility as niu
+from nipype.pipeline import engine as pe
 from niworkflows.engine.workflows import LiterateWorkflow as Workflow
 
-INPUT_FIELDS = ("magnitude", "fieldmap")
+INPUT_FIELDS = ('magnitude', 'fieldmap')
 
 
 def init_fmap_wf(
     omp_nthreads=1,
     sloppy=False,
     debug=False,
-    mode="phasediff",
-    name="fmap_wf",
+    mode='phasediff',
+    name='fmap_wf',
     **kwargs,
 ):
     """
@@ -92,32 +92,32 @@ def init_fmap_wf(
 
     """
     from ...interfaces.bspline import (
-        BSplineApprox,
         DEFAULT_HF_ZOOMS_MM,
+        BSplineApprox,
     )
     from ...interfaces.fmap import CheckRegister
 
     workflow = Workflow(name=name)
-    inputnode = pe.Node(niu.IdentityInterface(fields=INPUT_FIELDS), name="inputnode")
+    inputnode = pe.Node(niu.IdentityInterface(fields=INPUT_FIELDS), name='inputnode')
     outputnode = pe.Node(
-        niu.IdentityInterface(fields=["fmap", "fmap_ref", "fmap_mask", "fmap_coeff", "method"]),
-        name="outputnode",
+        niu.IdentityInterface(fields=['fmap', 'fmap_ref', 'fmap_mask', 'fmap_coeff', 'method']),
+        name='outputnode',
     )
 
     def _unzip(fmap_spec):
         return fmap_spec
 
     unzip = pe.MapNode(
-        niu.Function(function=_unzip, output_names=["fmap_file", "meta"]),
+        niu.Function(function=_unzip, output_names=['fmap_file', 'meta']),
         run_without_submitting=True,
-        iterfield=["fmap_spec"],
-        name="unzip",
+        iterfield=['fmap_spec'],
+        name='unzip',
     )
 
     check_register = pe.Node(CheckRegister(), name='check_register')
 
     magnitude_wf = init_magnitude_wf(omp_nthreads=omp_nthreads)
-    bs_filter = pe.Node(BSplineApprox(), name="bs_filter")
+    bs_filter = pe.Node(BSplineApprox(), name='bs_filter')
     bs_filter.interface._always_run = debug
     bs_filter.inputs.bs_spacing = [DEFAULT_HF_ZOOMS_MM]
 
@@ -143,14 +143,14 @@ def _unzip(fmap_spec):
     ])
     # fmt: on
 
-    if mode == "phasediff":
+    if mode == 'phasediff':
         workflow.__desc__ = """\
 A *B<sub>0</sub>* nonuniformity map (or *fieldmap*) was estimated from the
 phase-drift map(s) measure with two consecutive GRE (gradient-recalled echo)
 acquisitions.
 """
         phdiff_wf = init_phdiff_wf(omp_nthreads, debug=debug)
-        outputnode.inputs.method = "FMB (fieldmap-based) - phase-difference map"
+        outputnode.inputs.method = 'FMB (fieldmap-based) - phase-difference map'
 
         # fmt: off
         workflow.connect([
@@ -167,19 +167,20 @@ def _unzip(fmap_spec):
         # fmt: on
     else:
         from niworkflows.interfaces.images import IntraModalMerge
+
         from ...interfaces.fmap import CheckB0Units
 
         workflow.__desc__ = """\
 A *B<sub>0</sub>* nonuniformity map (or *fieldmap*) was directly measured with
 an MRI scheme designed with that purpose such as SEI (Spiral-Echo Imaging).
 """
-        outputnode.inputs.method = "FMB (fieldmap-based) - directly measured B0 map"
+        outputnode.inputs.method = 'FMB (fieldmap-based) - directly measured B0 map'
         # Merge input fieldmap images (assumes all are given in the same units!)
         fmapmrg = pe.Node(
             IntraModalMerge(zero_based_avg=False, hmc=False, to_ras=False),
-            name="fmapmrg",
+            name='fmapmrg',
         )
-        units = pe.Node(CheckB0Units(), name="units", run_without_submitting=True)
+        units = pe.Node(CheckB0Units(), name='units', run_without_submitting=True)
 
         # fmt: off
         workflow.connect([
@@ -193,7 +194,7 @@ def _unzip(fmap_spec):
     return workflow
 
 
-def init_magnitude_wf(omp_nthreads, name="magnitude_wf"):
+def init_magnitude_wf(omp_nthreads, name='magnitude_wf'):
     """
     Prepare the magnitude part of :abbr:`GRE (gradient-recalled echo)` fieldmaps.
 
@@ -231,18 +232,19 @@ def init_magnitude_wf(omp_nthreads, name="magnitude_wf"):
 
     """
     from niworkflows.interfaces.images import IntraModalMerge
+
     from ..ancillary import init_brainextraction_wf
 
     workflow = Workflow(name=name)
-    inputnode = pe.Node(niu.IdentityInterface(fields=["magnitude"]), name="inputnode")
+    inputnode = pe.Node(niu.IdentityInterface(fields=['magnitude']), name='inputnode')
     outputnode = pe.Node(
-        niu.IdentityInterface(fields=["fmap_ref", "fmap_mask", "mask_report"]),
-        name="outputnode",
+        niu.IdentityInterface(fields=['fmap_ref', 'fmap_mask', 'mask_report']),
+        name='outputnode',
     )
 
     # Merge input magnitude images
     # Do not reorient to RAS to preserve the validity of PhaseEncodingDirection
-    magmrg = pe.Node(IntraModalMerge(hmc=False, to_ras=False), name="magmrg")
+    magmrg = pe.Node(IntraModalMerge(hmc=False, to_ras=False), name='magmrg')
     brainextraction_wf = init_brainextraction_wf()
 
     # fmt: off
@@ -259,7 +261,7 @@ def init_magnitude_wf(omp_nthreads, name="magnitude_wf"):
     return workflow
 
 
-def init_phdiff_wf(omp_nthreads, debug=False, name="phdiff_wf"):
+def init_phdiff_wf(omp_nthreads, debug=False, name='phdiff_wf'):
     r"""
     Generate a :math:`B_0` field from consecutive-phases and phase-difference maps.
 
@@ -314,6 +316,7 @@ def init_phdiff_wf(omp_nthreads, debug=False, name="phdiff_wf"):
 
     """
     from nipype.interfaces.fsl import PRELUDE
+
     from ...interfaces.fmap import Phasediff2Fieldmap, PhaseMap2rads, SubtractPhases
 
     workflow = Workflow(name=name)
@@ -322,30 +325,28 @@ def init_phdiff_wf(omp_nthreads, debug=False, name="phdiff_wf"):
 """
 
     inputnode = pe.Node(
-        niu.IdentityInterface(fields=["magnitude", "phase", "phase_meta", "mask"]),
-        name="inputnode",
+        niu.IdentityInterface(fields=['magnitude', 'phase', 'phase_meta', 'mask']),
+        name='inputnode',
     )
 
     outputnode = pe.Node(
-        niu.IdentityInterface(fields=["fieldmap"]),
-        name="outputnode",
+        niu.IdentityInterface(fields=['fieldmap']),
+        name='outputnode',
     )
 
     # phase diff -> radians
     phmap2rads = pe.MapNode(
         PhaseMap2rads(),
-        name="phmap2rads",
-        iterfield=["in_file"],
+        name='phmap2rads',
+        iterfield=['in_file'],
         run_without_submitting=True,
     )
     # FSL PRELUDE will perform phase-unwrapping
-    prelude = pe.Node(PRELUDE(), name="prelude")
+    prelude = pe.Node(PRELUDE(), name='prelude')
 
-    calc_phdiff = pe.Node(
-        SubtractPhases(), name="calc_phdiff", run_without_submitting=True
-    )
+    calc_phdiff = pe.Node(SubtractPhases(), name='calc_phdiff', run_without_submitting=True)
     calc_phdiff.interface._always_run = debug
-    compfmap = pe.Node(Phasediff2Fieldmap(), name="compfmap")
+    compfmap = pe.Node(Phasediff2Fieldmap(), name='compfmap')
 
     # fmt: off
     workflow.connect([
@@ -392,4 +393,4 @@ def _get_units(intuple):
     """
     if isinstance(intuple, list):
         intuple = intuple[0]
-    return intuple[1]["Units"]
+    return intuple[1]['Units']
diff --git a/sdcflows/workflows/fit/pepolar.py b/sdcflows/workflows/fit/pepolar.py
index a353da65d3..25ae08e827 100644
--- a/sdcflows/workflows/fit/pepolar.py
+++ b/sdcflows/workflows/fit/pepolar.py
@@ -21,14 +21,14 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Datasets with multiple phase encoded directions."""
-from nipype.pipeline import engine as pe
-from nipype.interfaces import utility as niu
 
+from nipype.interfaces import utility as niu
+from nipype.pipeline import engine as pe
 from niworkflows.engine.workflows import LiterateWorkflow as Workflow
 
 from ... import data
 
-INPUT_FIELDS = ("metadata", "in_data")
+INPUT_FIELDS = ('metadata', 'in_data')
 _PEPOLAR_DESC = """\
 A *B<sub>0</sub>*-nonuniformity map (or *fieldmap*) was estimated based on two (or more)
 echo-planar imaging (EPI) references """
@@ -41,7 +41,7 @@ def init_topup_wf(
     omp_nthreads=1,
     sloppy=False,
     debug=False,
-    name="pepolar_estimate_wf",
+    name='pepolar_estimate_wf',
     **kwargs,
 ):
     """
@@ -91,13 +91,13 @@ def init_topup_wf(
 
     """
     from nipype.interfaces.fsl.epi import TOPUP
-    from niworkflows.interfaces.nibabel import MergeSeries, ReorientImage
     from niworkflows.interfaces.images import RobustAverage
+    from niworkflows.interfaces.nibabel import MergeSeries, ReorientImage
 
-    from ...utils.misc import front as _front
-    from ...interfaces.epi import GetReadoutTime, SortPEBlips
-    from ...interfaces.utils import UniformGrid, PadSlices, ReorientImageAndMetadata
     from ...interfaces.bspline import TOPUPCoeffReorient
+    from ...interfaces.epi import GetReadoutTime, SortPEBlips
+    from ...interfaces.utils import PadSlices, ReorientImageAndMetadata, UniformGrid
+    from ...utils.misc import front as _front
     from ..ancillary import init_brainextraction_wf
 
     workflow = Workflow(name=name)
@@ -105,31 +105,31 @@ def init_topup_wf(
 {_PEPOLAR_DESC} with `topup` (@topup; FSL {TOPUP().version}).
 """
 
-    inputnode = pe.Node(niu.IdentityInterface(fields=INPUT_FIELDS), name="inputnode")
+    inputnode = pe.Node(niu.IdentityInterface(fields=INPUT_FIELDS), name='inputnode')
     outputnode = pe.Node(
         niu.IdentityInterface(
             fields=[
-                "fmap",
-                "fmap_ref",
-                "fmap_coeff",
-                "fmap_mask",
-                "jacobians",
-                "xfms",
-                "out_warps",
-                "method",
+                'fmap',
+                'fmap_ref',
+                'fmap_coeff',
+                'fmap_mask',
+                'jacobians',
+                'xfms',
+                'out_warps',
+                'method',
             ]
         ),
-        name="outputnode",
+        name='outputnode',
     )
-    outputnode.inputs.method = "PEB/PEPOLAR (phase-encoding based / PE-POLARity)"
+    outputnode.inputs.method = 'PEB/PEPOLAR (phase-encoding based / PE-POLARity)'
 
     # Calculate the total readout time of each run
     readout_time = pe.MapNode(
         GetReadoutTime(
             use_estimate=use_metadata_estimates,
         ),
-        name="readout_time",
-        iterfield=["metadata", "in_file"],
+        name='readout_time',
+        iterfield=['metadata', 'in_file'],
         run_without_submitting=True,
     )
     if fallback_total_readout_time is not None:
@@ -137,38 +137,32 @@ def init_topup_wf(
     # Average each run so that topup is not overwhelmed (see #279)
     runwise_avg = pe.MapNode(
         RobustAverage(num_threads=omp_nthreads),
-        name="runwise_avg",
-        iterfield="in_file",
+        name='runwise_avg',
+        iterfield='in_file',
     )
     # Regrid all to the reference (grid_reference=0 means first averaged run)
-    regrid = pe.Node(UniformGrid(reference=grid_reference), name="regrid")
+    regrid = pe.Node(UniformGrid(reference=grid_reference), name='regrid')
     # Sort PE blips to ensure reproducibility
-    sort_pe_blips = pe.Node(
-        SortPEBlips(), name="sort_pe_blips", run_without_submitting=True
-    )
+    sort_pe_blips = pe.Node(SortPEBlips(), name='sort_pe_blips', run_without_submitting=True)
     # Merge into one 4D file
-    concat_blips = pe.Node(MergeSeries(affine_tolerance=1e-4), name="concat_blips")
+    concat_blips = pe.Node(MergeSeries(affine_tolerance=1e-4), name='concat_blips')
     # Pad dimensions so that they meet TOPUP's expectations
-    pad_blip_slices = pe.Node(PadSlices(), name="pad_blip_slices")
+    pad_blip_slices = pe.Node(PadSlices(), name='pad_blip_slices')
     # Run 3dVolReg between runs: uses RobustAverage for consistency and to generate
     # debugging artifacts (typically, one wants to look at the average across uncorrected runs)
-    setwise_avg = pe.Node(RobustAverage(num_threads=omp_nthreads), name="setwise_avg")
+    setwise_avg = pe.Node(RobustAverage(num_threads=omp_nthreads), name='setwise_avg')
     # The core of the implementation
     # Feed the input images in LAS orientation, so FSL does not run funky reorientations
-    to_las = pe.Node(ReorientImageAndMetadata(target_orientation="LAS"), name="to_las")
+    to_las = pe.Node(ReorientImageAndMetadata(target_orientation='LAS'), name='to_las')
     topup = pe.Node(
-        TOPUP(
-            config=str(data.load(f"flirtsch/b02b0{'_quick' * sloppy}.cnf"))
-        ),
-        name="topup",
+        TOPUP(config=str(data.load(f'flirtsch/b02b0{"_quick" * sloppy}.cnf'))),
+        name='topup',
     )
     # "Generalize" topup coefficients and store them in a spatially-correct NIfTI file
-    fix_coeff = pe.Node(
-        TOPUPCoeffReorient(), name="fix_coeff", run_without_submitting=True
-    )
+    fix_coeff = pe.Node(TOPUPCoeffReorient(), name='fix_coeff', run_without_submitting=True)
 
     # Average the output
-    ref_average = pe.Node(RobustAverage(num_threads=omp_nthreads), name="ref_average")
+    ref_average = pe.Node(RobustAverage(num_threads=omp_nthreads), name='ref_average')
 
     # Sophisticated brain extraction of fMRIPrep
     brainextraction_wf = init_brainextraction_wf()
@@ -208,8 +202,8 @@ def init_topup_wf(
 
     if not debug:
         # Roll orientation back to original
-        from_las = pe.Node(ReorientImage(), name="from_las")
-        from_las_fmap = pe.Node(ReorientImage(), name="from_las_fmap")
+        from_las = pe.Node(ReorientImage(), name='from_las')
+        from_las_fmap = pe.Node(ReorientImage(), name='from_las_fmap')
         # fmt: off
         workflow.connect([
             (setwise_avg, from_las, [("out_file", "target_file")]),
@@ -226,9 +220,9 @@ def init_topup_wf(
     from sdcflows.interfaces.bspline import ApplyCoeffsField
 
     # Separate the runs again, as our ApplyCoeffsField corrects them separately
-    unwarp = pe.Node(ApplyCoeffsField(jacobian=True), name="unwarp")
+    unwarp = pe.Node(ApplyCoeffsField(jacobian=True), name='unwarp')
     unwarp.interface._always_run = True
-    concat_corrected = pe.Node(MergeSeries(), name="concat_corrected")
+    concat_corrected = pe.Node(MergeSeries(), name='concat_corrected')
 
     # fmt:off
     workflow.connect([
@@ -245,7 +239,7 @@ def init_topup_wf(
     return workflow
 
 
-def init_3dQwarp_wf(omp_nthreads=1, debug=False, name="pepolar_estimate_wf"):
+def init_3dQwarp_wf(omp_nthreads=1, debug=False, name='pepolar_estimate_wf'):
     """
     Create the PEPOLAR field estimation workflow based on AFNI's ``3dQwarp``.
 
@@ -284,33 +278,33 @@ def init_3dQwarp_wf(omp_nthreads=1, debug=False, name="pepolar_estimate_wf"):
 
     """
     from nipype.interfaces import afni
-    from niworkflows.interfaces.header import CopyHeader
+    from niworkflows.func.util import init_enhance_and_skullstrip_bold_wf
     from niworkflows.interfaces.fixes import (
-        FixHeaderRegistration as Registration,
         FixHeaderApplyTransforms as ApplyTransforms,
     )
+    from niworkflows.interfaces.fixes import (
+        FixHeaderRegistration as Registration,
+    )
     from niworkflows.interfaces.freesurfer import StructuralReference
-    from niworkflows.func.util import init_enhance_and_skullstrip_bold_wf
-    from ...utils.misc import front as _front, last as _last
-    from ...interfaces.utils import Flatten, ConvertWarp
+    from niworkflows.interfaces.header import CopyHeader
+
+    from ...interfaces.utils import ConvertWarp, Flatten
+    from ...utils.misc import front as _front
+    from ...utils.misc import last as _last
 
     workflow = Workflow(name=name)
     workflow.__desc__ = f"""{_PEPOLAR_DESC} \
 with `3dQwarp` (@afni; AFNI {''.join(['%02d' % v for v in afni.Info().version() or []])}).
 """
 
-    inputnode = pe.Node(
-        niu.IdentityInterface(fields=["in_data", "metadata"]), name="inputnode"
-    )
+    inputnode = pe.Node(niu.IdentityInterface(fields=['in_data', 'metadata']), name='inputnode')
 
-    outputnode = pe.Node(
-        niu.IdentityInterface(fields=["fmap", "fmap_ref"]), name="outputnode"
-    )
+    outputnode = pe.Node(niu.IdentityInterface(fields=['fmap', 'fmap_ref']), name='outputnode')
 
-    flatten = pe.Node(Flatten(), name="flatten")
+    flatten = pe.Node(Flatten(), name='flatten')
     sort_pe = pe.Node(
-        niu.Function(function=_sorted_pe, output_names=["sorted", "qwarp_args"]),
-        name="sort_pe",
+        niu.Function(function=_sorted_pe, output_names=['sorted', 'qwarp_args']),
+        name='sort_pe',
         run_without_submitting=True,
     )
 
@@ -323,52 +317,48 @@ def init_3dQwarp_wf(omp_nthreads=1, debug=False, name="pepolar_estimate_wf"):
             # 7-DOF (rigid + intensity)
             no_iteration=True,
             subsample_threshold=200,
-            out_file="template.nii.gz",
+            out_file='template.nii.gz',
         ),
-        name="merge_pes",
-        iterfield=["in_files"],
+        name='merge_pes',
+        iterfield=['in_files'],
     )
 
-    pe0_wf = init_enhance_and_skullstrip_bold_wf(
-        omp_nthreads=omp_nthreads, name="pe0_wf"
-    )
-    pe1_wf = init_enhance_and_skullstrip_bold_wf(
-        omp_nthreads=omp_nthreads, name="pe1_wf"
-    )
+    pe0_wf = init_enhance_and_skullstrip_bold_wf(omp_nthreads=omp_nthreads, name='pe0_wf')
+    pe1_wf = init_enhance_and_skullstrip_bold_wf(omp_nthreads=omp_nthreads, name='pe1_wf')
 
     align_pes = pe.Node(
         Registration(
-            from_file=data.load("translation_rigid.json"),
+            from_file=data.load('translation_rigid.json'),
             output_warped_image=True,
         ),
-        name="align_pes",
+        name='align_pes',
         n_procs=omp_nthreads,
     )
 
     qwarp = pe.Node(
         afni.QwarpPlusMinus(
             blur=[-1, -1],
-            environ={"OMP_NUM_THREADS": f"{min(omp_nthreads, 4)}"},
+            environ={'OMP_NUM_THREADS': f'{min(omp_nthreads, 4)}'},
             minpatch=9,
             nopadWARP=True,
             noweight=True,
             pblur=[0.05, 0.05],
         ),
-        name="qwarp",
+        name='qwarp',
         n_procs=min(omp_nthreads, 4),
     )
 
-    to_ants = pe.Node(ConvertWarp(), name="to_ants", mem_gb=0.01)
+    to_ants = pe.Node(ConvertWarp(), name='to_ants', mem_gb=0.01)
 
-    cphdr_warp = pe.Node(CopyHeader(), name="cphdr_warp", mem_gb=0.01)
+    cphdr_warp = pe.Node(CopyHeader(), name='cphdr_warp', mem_gb=0.01)
 
     unwarp_reference = pe.Node(
         ApplyTransforms(
             dimension=3,
             float=True,
-            interpolation="LanczosWindowedSinc",
+            interpolation='LanczosWindowedSinc',
         ),
-        name="unwarp_reference",
+        name='unwarp_reference',
     )
 
     # fmt: off
@@ -431,19 +421,17 @@ def _sorted_pe(inlist):
     out_ref = [inlist[0][0]]
     out_opp = []
 
-    ref_pe = inlist[0][1]["PhaseEncodingDirection"]
+    ref_pe = inlist[0][1]['PhaseEncodingDirection']
     for d, m in inlist[1:]:
-        pe = m["PhaseEncodingDirection"]
+        pe = m['PhaseEncodingDirection']
         if pe == ref_pe:
             out_ref.append(d)
         elif pe[0] == ref_pe[0]:
             out_opp.append(d)
         else:
-            raise ValueError("Cannot handle orthogonal PE encodings.")
+            raise ValueError('Cannot handle orthogonal PE encodings.')
 
     return (
         [out_ref, out_opp],
-        {"i": "-noYdis -noZdis", "j": "-noXdis -noZdis", "k": "-noXdis -noYdis"}[
-            ref_pe[0]
-        ],
+        {'i': '-noYdis -noZdis', 'j': '-noXdis -noZdis', 'k': '-noXdis -noYdis'}[ref_pe[0]],
     )
diff --git a/sdcflows/workflows/fit/syn.py b/sdcflows/workflows/fit/syn.py
index 3d8e87d5f5..57ef8251eb 100644
--- a/sdcflows/workflows/fit/syn.py
+++ b/sdcflows/workflows/fit/syn.py
@@ -23,21 +23,22 @@
 """
 Estimating the susceptibility distortions without fieldmaps.
 """
+
 import json
 
-from nipype.pipeline import engine as pe
 from nipype.interfaces import utility as niu
+from nipype.pipeline import engine as pe
 from niworkflows.engine.workflows import LiterateWorkflow as Workflow
 
 from ... import data
 
 DEFAULT_MEMORY_MIN_GB = 0.01
 INPUT_FIELDS = (
-    "epi_ref",
-    "epi_mask",
-    "anat_ref",
-    "anat_mask",
-    "sd_prior",
+    'epi_ref',
+    'epi_mask',
+    'anat_ref',
+    'anat_mask',
+    'sd_prior',
 )
 MAX_LAPLACIAN_WEIGHT = 0.5
 
@@ -48,7 +49,7 @@ def init_syn_sdc_wf(
     fallback_total_readout_time=None,
     sloppy=False,
     debug=False,
-    name="syn_sdc_wf",
+    name='syn_sdc_wf',
     omp_nthreads=1,
     laplacian_weight=None,
     **kwargs,
@@ -111,31 +112,34 @@ def init_syn_sdc_wf(
         Short description of the estimation method that was run.
 
     """
-    from packaging.version import parse as parseversion, Version
     from nipype.interfaces.ants import ImageMath
     from niworkflows.interfaces.fixes import (
         FixHeaderApplyTransforms as ApplyTransforms,
+    )
+    from niworkflows.interfaces.fixes import (
         FixHeaderRegistration as Registration,
     )
     from niworkflows.interfaces.nibabel import (
         IntensityClip,
         RegridToZooms,
     )
-    from ...utils.misc import front as _pop, last as _pull
-    from ...interfaces.epi import GetReadoutTime
-    from ...interfaces.fmap import DisplacementsField2Fieldmap
+    from packaging.version import Version
+    from packaging.version import parse as parseversion
+
+    from ...interfaces.brainmask import BinaryDilation, Union
     from ...interfaces.bspline import (
+        DEFAULT_HF_ZOOMS_MM,
         ApplyCoeffsField,
         BSplineApprox,
-        DEFAULT_HF_ZOOMS_MM,
     )
-    from ...interfaces.brainmask import BinaryDilation, Union
+    from ...interfaces.epi import GetReadoutTime
+    from ...interfaces.fmap import DisplacementsField2Fieldmap
+    from ...utils.misc import front as _pop
+    from ...utils.misc import last as _pull
 
     ants_version = Registration().version
-    if ants_version and parseversion(ants_version) < Version("2.2.0"):
-        raise RuntimeError(
-            f"Please upgrade ANTs to 2.2 or older ({ants_version} found)."
-        )
+    if ants_version and parseversion(ants_version) < Version('2.2.0'):
+        raise RuntimeError(f'Please upgrade ANTs to 2.2 or older ({ants_version} found).')
 
     workflow = Workflow(name=name)
     workflow.__desc__ = f"""\
@@ -144,17 +148,17 @@ def init_syn_sdc_wf(
 The deformation field is that resulting from co-registering the EPI reference
 to the same-subject's T1w-reference [@fieldmapless1; @fieldmapless2].
 Registration is performed with `antsRegistration`
-(ANTs {ants_version or "-- version unknown"}), and
+(ANTs {ants_version or '-- version unknown'}), and
 the process regularized by constraining deformation to be nonzero only
 along the phase-encoding direction.
 """
 
-    inputnode = pe.Node(niu.IdentityInterface(INPUT_FIELDS), name="inputnode")
+    inputnode = pe.Node(niu.IdentityInterface(INPUT_FIELDS), name='inputnode')
     outputnode = pe.Node(
         niu.IdentityInterface(
-            ["fmap", "fmap_ref", "fmap_coeff", "fmap_mask", "out_warp", "method"]
+            ['fmap', 'fmap_ref', 'fmap_coeff', 'fmap_mask', 'out_warp', 'method']
         ),
-        name="outputnode",
+        name='outputnode',
     )
     outputnode.inputs.method = 'FLB ("fieldmap-less", SyN-based)'
 
@@ -162,7 +166,7 @@ def init_syn_sdc_wf(
         GetReadoutTime(
             use_estimate=use_metadata_estimates,
         ),
-        name="readout_time",
+        name='readout_time',
         run_without_submitting=True,
     )
     if fallback_total_readout_time is not None:
@@ -171,65 +175,65 @@ def init_syn_sdc_wf(
     warp_dir = pe.Node(
         niu.Function(function=_warp_dir),
         run_without_submitting=True,
-        name="warp_dir",
+        name='warp_dir',
     )
     warp_dir.inputs.nlevels = 2
-    anat_dilmsk = pe.Node(BinaryDilation(), name="anat_dilmsk")
+    anat_dilmsk = pe.Node(BinaryDilation(), name='anat_dilmsk')
     amask2epi = pe.Node(
-        ApplyTransforms(interpolation="MultiLabel", transforms="identity"),
-        name="amask2epi",
+        ApplyTransforms(interpolation='MultiLabel', transforms='identity'),
+        name='amask2epi',
     )
 
     # Calculate laplacian maps
     lap_anat = pe.Node(
-        ImageMath(operation="Laplacian", op2="1.5 1", copy_header=True), name="lap_anat"
+        ImageMath(operation='Laplacian', op2='1.5 1', copy_header=True), name='lap_anat'
     )
-    lap_anat_norm = pe.Node(niu.Function(function=_norm_lap), name="lap_anat_norm")
+    lap_anat_norm = pe.Node(niu.Function(function=_norm_lap), name='lap_anat_norm')
     anat_merge = pe.Node(
         niu.Merge(2),
-        name="anat_merge",
+        name='anat_merge',
         run_without_submitting=True,
     )
 
-    clip_epi = pe.Node(IntensityClip(p_min=35.0, p_max=99.9), name="clip_epi")
+    clip_epi = pe.Node(IntensityClip(p_min=35.0, p_max=99.9), name='clip_epi')
     lap_epi = pe.Node(
-        ImageMath(operation="Laplacian", op2="1.5 1", copy_header=True), name="lap_epi"
+        ImageMath(operation='Laplacian', op2='1.5 1', copy_header=True), name='lap_epi'
     )
-    lap_epi_norm = pe.Node(niu.Function(function=_norm_lap), name="lap_epi_norm")
+    lap_epi_norm = pe.Node(niu.Function(function=_norm_lap), name='lap_epi_norm')
     epi_merge = pe.Node(
         niu.Merge(2),
-        name="epi_merge",
+        name='epi_merge',
         run_without_submitting=True,
     )
 
-    epi_umask = pe.Node(Union(), name="epi_umask")
+    epi_umask = pe.Node(Union(), name='epi_umask')
     moving_masks = pe.Node(
         niu.Merge(2),
-        name="moving_masks",
+        name='moving_masks',
         run_without_submitting=True,
     )
-    moving_masks.inputs.in1 = "NULL"
+    moving_masks.inputs.in1 = 'NULL'
 
     fixed_masks = pe.Node(
         niu.Merge(2),
-        name="fixed_masks",
+        name='fixed_masks',
         mem_gb=DEFAULT_MEMORY_MIN_GB,
         run_without_submitting=True,
     )
 
     # Set a manageable size for the epi reference
-    find_zooms = pe.Node(niu.Function(function=_adjust_zooms), name="find_zooms")
-    zooms_epi = pe.Node(RegridToZooms(), name="zooms_epi")
+    find_zooms = pe.Node(niu.Function(function=_adjust_zooms), name='find_zooms')
+    zooms_epi = pe.Node(RegridToZooms(), name='zooms_epi')
 
-    syn_config = data.load(f"sd_syn{'_sloppy' * sloppy}.json")
+    syn_config = data.load(f'sd_syn{"_sloppy" * sloppy}.json')
 
-    vox_params = pe.Node(niu.Function(function=_mm2vox), name="vox_params")
+    vox_params = pe.Node(niu.Function(function=_mm2vox), name='vox_params')
     vox_params.inputs.registration_config = json.loads(syn_config.read_text())
 
     # SyN Registration Core
     syn = pe.Node(
         Registration(from_file=syn_config),
-        name="syn",
+        name='syn',
         n_procs=omp_nthreads,
     )
     syn.inputs.output_warped_image = debug
@@ -246,31 +250,27 @@ def init_syn_sdc_wf(
         ]
 
     if debug:
-        syn.inputs.args = "--write-interval-volumes 2"
+        syn.inputs.args = '--write-interval-volumes 2'
 
     # Extract the corresponding fieldmap in Hz
-    extract_field = pe.Node(DisplacementsField2Fieldmap(), name="extract_field")
+    extract_field = pe.Node(DisplacementsField2Fieldmap(), name='extract_field')
 
-    unwarp = pe.Node(ApplyCoeffsField(jacobian=False), name="unwarp")
+    unwarp = pe.Node(ApplyCoeffsField(jacobian=False), name='unwarp')
 
     # Check zooms (avoid very expensive B-Splines fitting)
     zooms_field = pe.Node(
-        ApplyTransforms(
-            interpolation="BSpline", transforms="identity", args="-u float"
-        ),
-        name="zooms_field",
+        ApplyTransforms(interpolation='BSpline', transforms='identity', args='-u float'),
+        name='zooms_field',
     )
     zooms_bmask = pe.Node(
-        ApplyTransforms(
-            interpolation="MultiLabel", transforms="identity", args="-u uchar"
-        ),
-        name="zooms_bmask",
+        ApplyTransforms(interpolation='MultiLabel', transforms='identity', args='-u uchar'),
+        name='zooms_bmask',
     )
 
     # Regularize with B-Splines
     bs_filter = pe.Node(
         BSplineApprox(recenter=False, debug=debug, extrapolate=not debug),
-        name="bs_filter",
+        name='bs_filter',
     )
     bs_filter.interface._always_run = debug
     bs_filter.inputs.bs_spacing = [DEFAULT_HF_ZOOMS_MM]
@@ -343,7 +343,7 @@ def init_syn_preprocessing_wf(
     *,
     atlas_threshold=3,
     debug=False,
-    name="syn_preprocessing_wf",
+    name='syn_preprocessing_wf',
     omp_nthreads=1,
     auto_bold_nss=False,
     t1w_inversion=False,
@@ -411,98 +411,97 @@ def init_syn_preprocessing_wf(
         the cost function of SyN.
 
     """
-    from niworkflows.interfaces.nibabel import (
-        IntensityClip,
-        ApplyMask,
-        GenerateSamplingReference,
-    )
     from niworkflows.interfaces.fixes import (
         FixHeaderApplyTransforms as ApplyTransforms,
+    )
+    from niworkflows.interfaces.fixes import (
         FixHeaderRegistration as Registration,
     )
+    from niworkflows.interfaces.nibabel import (
+        ApplyMask,
+        GenerateSamplingReference,
+        IntensityClip,
+    )
     from niworkflows.workflows.epi.refmap import init_epi_reference_wf
-    from ...interfaces.utils import Deoblique, DenoiseImage
-    from ...interfaces.brainmask import BrainExtraction, BinaryDilation
+
+    from ...interfaces.brainmask import BinaryDilation, BrainExtraction
+    from ...interfaces.utils import DenoiseImage, Deoblique
 
     workflow = Workflow(name=name)
 
     inputnode = pe.Node(
         niu.IdentityInterface(
             fields=[
-                "in_epis",
-                "t_masks",
-                "in_meta",
-                "in_anat",
-                "mask_anat",
-                "std2anat_xfm",
+                'in_epis',
+                't_masks',
+                'in_meta',
+                'in_anat',
+                'mask_anat',
+                'std2anat_xfm',
             ]
         ),
-        name="inputnode",
+        name='inputnode',
     )
     outputnode = pe.Node(
-        niu.IdentityInterface(
-            fields=["epi_ref", "epi_mask", "anat_ref", "anat_mask", "sd_prior"]
-        ),
-        name="outputnode",
+        niu.IdentityInterface(fields=['epi_ref', 'epi_mask', 'anat_ref', 'anat_mask', 'sd_prior']),
+        name='outputnode',
     )
 
-    deob_epi = pe.Node(Deoblique(), name="deob_epi")
+    deob_epi = pe.Node(Deoblique(), name='deob_epi')
 
     anat2epi = pe.Node(
         ApplyTransforms(invert_transform_flags=[True]),
-        name="anat2epi",
+        name='anat2epi',
         n_procs=omp_nthreads,
         mem_gb=0.3,
     )
     mask2epi = pe.Node(
-        ApplyTransforms(invert_transform_flags=[True], interpolation="MultiLabel"),
-        name="mask2epi",
+        ApplyTransforms(invert_transform_flags=[True], interpolation='MultiLabel'),
+        name='mask2epi',
         n_procs=omp_nthreads,
         mem_gb=0.3,
     )
     mask_dtype = pe.Node(
-        niu.Function(function=_set_dtype, input_names=["in_file", "dtype"]),
-        name="mask_dtype",
+        niu.Function(function=_set_dtype, input_names=['in_file', 'dtype']),
+        name='mask_dtype',
     )
-    mask_dtype.inputs.dtype = "uint8"
+    mask_dtype.inputs.dtype = 'uint8'
 
     epi_reference_wf = init_epi_reference_wf(
         omp_nthreads=omp_nthreads,
         auto_bold_nss=auto_bold_nss,
     )
-    epi_brain = pe.Node(BrainExtraction(), name="epi_brain")
+    epi_brain = pe.Node(BrainExtraction(), name='epi_brain')
     merge_output = pe.Node(
         niu.Function(function=_merge_meta),
-        name="merge_output",
+        name='merge_output',
         run_without_submitting=True,
     )
-    mask_anat = pe.Node(ApplyMask(), name="mask_anat")
-    clip_anat = pe.Node(IntensityClip(p_min=0.0, p_max=99.8), name="clip_anat")
-    ref_anat = pe.Node(
-        DenoiseImage(copy_header=True), name="ref_anat", n_procs=omp_nthreads
-    )
+    mask_anat = pe.Node(ApplyMask(), name='mask_anat')
+    clip_anat = pe.Node(IntensityClip(p_min=0.0, p_max=99.8), name='clip_anat')
+    ref_anat = pe.Node(DenoiseImage(copy_header=True), name='ref_anat', n_procs=omp_nthreads)
 
     epi2anat = pe.Node(
-        Registration(from_file=data.load("affine.json")),
-        name="epi2anat",
+        Registration(from_file=data.load('affine.json')),
+        name='epi2anat',
         n_procs=omp_nthreads,
     )
     epi2anat.inputs.output_warped_image = debug
     epi2anat.inputs.output_inverse_warped_image = debug
     if debug:
-        epi2anat.inputs.args = "--write-interval-volumes 5"
+        epi2anat.inputs.args = '--write-interval-volumes 5'
 
     def _remove_first_mask(in_file):
         if not isinstance(in_file, list):
             in_file = [in_file]
 
-        in_file.insert(0, "NULL")
+        in_file.insert(0, 'NULL')
         return in_file
 
-    anat_dilmsk = pe.Node(BinaryDilation(), name="anat_dilmsk")
-    epi_dilmsk = pe.Node(BinaryDilation(), name="epi_dilmsk")
+    anat_dilmsk = pe.Node(BinaryDilation(), name='anat_dilmsk')
+    epi_dilmsk = pe.Node(BinaryDilation(), name='epi_dilmsk')
 
-    sampling_ref = pe.Node(GenerateSamplingReference(), name="sampling_ref")
+    sampling_ref = pe.Node(GenerateSamplingReference(), name='sampling_ref')
 
     if sd_prior:
         from niworkflows.interfaces.nibabel import Binarize
@@ -512,24 +511,22 @@ def _remove_first_mask(in_file):
         # 1) MNI -> anat; 2) ATLAS -> MNI
         transform_list = pe.Node(
             niu.Merge(3),
-            name="transform_list",
+            name='transform_list',
             mem_gb=DEFAULT_MEMORY_MIN_GB,
             run_without_submitting=True,
         )
-        transform_list.inputs.in3 = data.load(
-            "fmap_atlas_2_MNI152NLin2009cAsym_affine.mat"
-        )
+        transform_list.inputs.in3 = data.load('fmap_atlas_2_MNI152NLin2009cAsym_affine.mat')
         prior2epi = pe.Node(
             ApplyTransforms(
                 invert_transform_flags=[True, False, False],
-                input_image=str(data.load("fmap_atlas.nii.gz")),
+                input_image=str(data.load('fmap_atlas.nii.gz')),
             ),
-            name="prior2epi",
+            name='prior2epi',
             n_procs=omp_nthreads,
             mem_gb=0.3,
         )
 
-        prior_msk = pe.Node(Binarize(thresh_low=atlas_threshold), name="prior_msk")
+        prior_msk = pe.Node(Binarize(thresh_low=atlas_threshold), name='prior_msk')
 
         workflow.connect([
             (inputnode, transform_list, [("std2anat_xfm", "in2")]),
@@ -542,7 +539,7 @@ def _remove_first_mask(in_file):
 
     else:
         # no prior to be used -> set anatomical mask as prior
-        workflow.connect(mask_dtype, "out", outputnode, "sd_prior")
+        workflow.connect(mask_dtype, 'out', outputnode, 'sd_prior')
 
     workflow.connect([
         (inputnode, epi_reference_wf, [("in_epis", "inputnode.in_files")]),
@@ -579,7 +576,7 @@ def _remove_first_mask(in_file):
         from niworkflows.interfaces.nibabel import RegridToZooms
 
         regrid_anat = pe.Node(
-            RegridToZooms(zooms=(2.0, 2.0, 2.0), smooth=True), name="regrid_anat"
+            RegridToZooms(zooms=(2.0, 2.0, 2.0), smooth=True), name='regrid_anat'
         )
         # fmt:off
         workflow.connect([
@@ -595,15 +592,15 @@ def _remove_first_mask(in_file):
         # fmt:on
 
     if not auto_bold_nss:
-        workflow.connect(inputnode, "t_masks", epi_reference_wf, "inputnode.t_masks")
+        workflow.connect(inputnode, 't_masks', epi_reference_wf, 'inputnode.t_masks')
 
     return workflow
 
 
 def _warp_dir(moving_image, fixed_image, pe_dir, nlevels=2):
     """Extract the ``restrict_deformation`` argument from metadata."""
-    import numpy as np
     import nibabel as nb
+    import numpy as np
 
     moving = nb.load(moving_image)
     fixed = nb.load(fixed_image)
@@ -611,14 +608,14 @@ def _warp_dir(moving_image, fixed_image, pe_dir, nlevels=2):
     if np.any(nb.affines.obliquity(fixed.affine) > 0.05):
         from nipype import logging
 
-        logging.getLogger("nipype.interface").warn(
-            "Running fieldmap-less registration on an oblique dataset"
+        logging.getLogger('nipype.interface').warn(
+            'Running fieldmap-less registration on an oblique dataset'
         )
 
-    moving_axcodes = nb.aff2axcodes(moving.affine, ["RR", "AA", "SS"])
-    moving_pe_axis = moving_axcodes["ijk".index(pe_dir[0])]
+    moving_axcodes = nb.aff2axcodes(moving.affine, ['RR', 'AA', 'SS'])
+    moving_pe_axis = moving_axcodes['ijk'.index(pe_dir[0])]
 
-    fixed_axcodes = nb.aff2axcodes(fixed.affine, ["RR", "AA", "SS"])
+    fixed_axcodes = nb.aff2axcodes(fixed.affine, ['RR', 'AA', 'SS'])
 
     deformation = [0.1, 0.1, 0.1]
     deformation[fixed_axcodes.index(moving_pe_axis)] = 1.0
@@ -633,19 +630,16 @@ def _mm2vox(moving_image, fixed_image, pe_dir, registration_config):
 
     moving = nb.load(moving_image)
     # Use duplicate axcodes to ignore sign
-    moving_axcodes = nb.aff2axcodes(moving.affine, ["RR", "AA", "SS"])
-    moving_pe_axis = moving_axcodes["ijk".index(pe_dir[0])]
+    moving_axcodes = nb.aff2axcodes(moving.affine, ['RR', 'AA', 'SS'])
+    moving_pe_axis = moving_axcodes['ijk'.index(pe_dir[0])]
 
     fixed = nb.load(fixed_image)
-    fixed_axcodes = nb.aff2axcodes(fixed.affine, ["RR", "AA", "SS"])
+    fixed_axcodes = nb.aff2axcodes(fixed.affine, ['RR', 'AA', 'SS'])
 
     zooms = nb.affines.voxel_sizes(fixed.affine)
     pe_res = zooms[fixed_axcodes.index(moving_pe_axis)]
 
-    return [
-        [*level_params[:2], level_params[2] / pe_res]
-        for level_params in params
-    ]
+    return [[*level_params[:2], level_params[2] / pe_res] for level_params in params]
 
 
 def _merge_meta(epi_ref, meta_list):
@@ -653,10 +647,10 @@ def _merge_meta(epi_ref, meta_list):
     return (epi_ref, meta_list[0])
 
 
-def _set_dtype(in_file, dtype="int16"):
+def _set_dtype(in_file, dtype='int16'):
     """Change the dtype of an image."""
-    import numpy as np
     import nibabel as nb
+    import numpy as np
 
     img = nb.load(in_file)
     if img.header.get_data_dtype() == np.dtype(dtype):
@@ -664,7 +658,7 @@ def _set_dtype(in_file, dtype="int16"):
 
     from nipype.utils.filemanip import fname_presuffix
 
-    out_file = fname_presuffix(in_file, suffix=f"_{dtype}")
+    out_file = fname_presuffix(in_file, suffix=f'_{dtype}')
     hdr = img.header.copy()
     hdr.set_data_dtype(dtype)
     img.__class__(img.dataobj, img.affine, hdr).to_filename(out_file)
@@ -686,8 +680,9 @@ def _adjust_zooms(in_anat, in_epi, z_max=2.2, z_min=1.8):
 def match_histogram(reference, image, ref_mask=None, img_mask=None):
     """Match the histogram of the T2-like anatomical with the EPI."""
     import os
-    import numpy as np
+
     import nibabel as nb
+    import numpy as np
     from nipype.utils.filemanip import fname_presuffix
     from skimage.exposure import match_histograms
 
@@ -707,7 +702,7 @@ def match_histogram(reference, image, ref_mask=None, img_mask=None):
         else np.asanyarray(nb.load(img_mask).dataobj) > 0
     )
 
-    out_file = fname_presuffix(image, suffix="_matched", newpath=os.getcwd())
+    out_file = fname_presuffix(image, suffix='_matched', newpath=os.getcwd())
     img_data[img_mask] = match_histograms(
         img_data[img_mask],
         ref_data[ref_mask],
@@ -724,8 +719,9 @@ def match_histogram(reference, image, ref_mask=None, img_mask=None):
 def _norm_lap(in_file):
     """Brought over from nirodents."""
     from pathlib import Path
-    import numpy as np
+
     import nibabel as nb
+    import numpy as np
     from nipype.utils.filemanip import fname_presuffix
 
     img = nb.load(in_file)
@@ -738,9 +734,9 @@ def _norm_lap(in_file):
     data = np.clip(data, a_min=-1.0, a_max=1.0)
 
     out_file = fname_presuffix(
-        Path(in_file).name, suffix="_norm", newpath=str(Path.cwd().absolute())
+        Path(in_file).name, suffix='_norm', newpath=str(Path.cwd().absolute())
     )
     hdr = img.header.copy()
-    hdr.set_data_dtype("float32")
-    img.__class__(data.astype("float32"), img.affine, hdr).to_filename(out_file)
+    hdr.set_data_dtype('float32')
+    img.__class__(data.astype('float32'), img.affine, hdr).to_filename(out_file)
     return out_file
diff --git a/sdcflows/workflows/fit/tests/test_fit.py b/sdcflows/workflows/fit/tests/test_fit.py
index 6b7b862594..2bd97849c5 100644
--- a/sdcflows/workflows/fit/tests/test_fit.py
+++ b/sdcflows/workflows/fit/tests/test_fit.py
@@ -21,27 +21,31 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test that workflows build."""
-import pytest
+
 import sys
 
-from .. import fieldmap  # noqa
-from .. import pepolar  # noqa
-from .. import syn  # noqa
+import pytest
+
+from .. import (
+    fieldmap,  # noqa
+    pepolar,  # noqa
+    syn,  # noqa
+)
 
 
 @pytest.mark.parametrize(
-    "workflow,kwargs",
+    'workflow,kwargs',
     (
-        ("sdcflows.workflows.fit.fieldmap.init_fmap_wf", {"mode": "mapped"}),
-        ("sdcflows.workflows.fit.fieldmap.init_fmap_wf", {}),
-        ("sdcflows.workflows.fit.fieldmap.init_phdiff_wf", {"omp_nthreads": 1}),
-        ("sdcflows.workflows.fit.pepolar.init_3dQwarp_wf", {}),
-        ("sdcflows.workflows.fit.pepolar.init_topup_wf", {}),
-        ("sdcflows.workflows.fit.syn.init_syn_sdc_wf", {"omp_nthreads": 1}),
+        ('sdcflows.workflows.fit.fieldmap.init_fmap_wf', {'mode': 'mapped'}),
+        ('sdcflows.workflows.fit.fieldmap.init_fmap_wf', {}),
+        ('sdcflows.workflows.fit.fieldmap.init_phdiff_wf', {'omp_nthreads': 1}),
+        ('sdcflows.workflows.fit.pepolar.init_3dQwarp_wf', {}),
+        ('sdcflows.workflows.fit.pepolar.init_topup_wf', {}),
+        ('sdcflows.workflows.fit.syn.init_syn_sdc_wf', {'omp_nthreads': 1}),
     ),
 )
 def test_build_1(workflow, kwargs):
     """Make sure the workflow builds."""
-    module = ".".join(workflow.split(".")[:-1])
-    func = workflow.split(".")[-1]
+    module = '.'.join(workflow.split('.')[:-1])
+    func = workflow.split('.')[-1]
     getattr(sys.modules[module], func)(**kwargs)
diff --git a/sdcflows/workflows/fit/tests/test_pepolar.py b/sdcflows/workflows/fit/tests/test_pepolar.py
index e95128d153..188bb05411 100644
--- a/sdcflows/workflows/fit/tests/test_pepolar.py
+++ b/sdcflows/workflows/fit/tests/test_pepolar.py
@@ -21,6 +21,7 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test pepolar type of fieldmaps."""
+
 import pytest
 from nipype.pipeline import engine as pe
 
@@ -28,17 +29,17 @@
 
 
 @pytest.mark.slow
-@pytest.mark.parametrize("ds", ("ds001771", "HCP101006"))
+@pytest.mark.parametrize('ds', ('ds001771', 'HCP101006'))
 def test_topup_wf(tmpdir, bids_layouts, workdir, outdir, ds):
     """Test preparation workflow."""
     layout = bids_layouts[ds]
     epi_path = sorted(
-        layout.get(suffix="epi", extension=["nii", "nii.gz"], scope="raw"),
+        layout.get(suffix='epi', extension=['nii', 'nii.gz'], scope='raw'),
         key=lambda k: k.path,
     )
     in_data = [f.path for f in epi_path]
 
-    wf = pe.Workflow(name=f"topup_{ds}")
+    wf = pe.Workflow(name=f'topup_{ds}')
     topup_wf = init_topup_wf(omp_nthreads=2, debug=True, sloppy=True)
     metadata = [layout.get_metadata(f.path) for f in epi_path]
 
@@ -48,18 +49,18 @@ def test_topup_wf(tmpdir, bids_layouts, workdir, outdir, ds):
     if outdir:
         from ...outputs import init_fmap_derivatives_wf, init_fmap_reports_wf
 
-        outdir = outdir / "unittests" / f"topup_{ds}"
+        outdir = outdir / 'unittests' / f'topup_{ds}'
         fmap_derivatives_wf = init_fmap_derivatives_wf(
             output_dir=str(outdir),
             write_coeff=True,
-            bids_fmap_id="pepolar_id",
+            bids_fmap_id='pepolar_id',
         )
         fmap_derivatives_wf.inputs.inputnode.source_files = in_data
         fmap_derivatives_wf.inputs.inputnode.fmap_meta = metadata
 
         fmap_reports_wf = init_fmap_reports_wf(
             output_dir=str(outdir),
-            fmap_type="pepolar",
+            fmap_type='pepolar',
         )
         fmap_reports_wf.inputs.inputnode.source_files = in_data
 
@@ -81,4 +82,4 @@ def test_topup_wf(tmpdir, bids_layouts, workdir, outdir, ds):
     if workdir:
         wf.base_dir = str(workdir)
 
-    wf.run(plugin="Linear")
+    wf.run(plugin='Linear')
diff --git a/sdcflows/workflows/fit/tests/test_phdiff.py b/sdcflows/workflows/fit/tests/test_phdiff.py
index 94932f6243..d536c3d399 100644
--- a/sdcflows/workflows/fit/tests/test_phdiff.py
+++ b/sdcflows/workflows/fit/tests/test_phdiff.py
@@ -21,27 +21,26 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test phase-difference type of fieldmaps."""
-from pathlib import Path
+
 from json import loads
+from pathlib import Path
 
 import pytest
 
-from ..fieldmap import init_fmap_wf, Workflow
+from ..fieldmap import Workflow, init_fmap_wf
 
 
 @pytest.mark.slow
 @pytest.mark.parametrize(
-    "fmap_file",
+    'fmap_file',
     [
-        ("ds001600/sub-1/fmap/sub-1_acq-v4_phasediff.nii.gz",),
+        ('ds001600/sub-1/fmap/sub-1_acq-v4_phasediff.nii.gz',),
         (
-            "ds001600/sub-1/fmap/sub-1_acq-v2_phase1.nii.gz",
-            "ds001600/sub-1/fmap/sub-1_acq-v2_phase2.nii.gz",
+            'ds001600/sub-1/fmap/sub-1_acq-v2_phase1.nii.gz',
+            'ds001600/sub-1/fmap/sub-1_acq-v2_phase2.nii.gz',
         ),
-        (
-            "ds001771/derivatives/openneuro/sub-36/fmap/sub-36_acq-topup1_fieldmap.nii.gz",
-        ),
-        ("HCP101006/sub-101006/fmap/sub-101006_phasediff.nii.gz",),
+        ('ds001771/derivatives/openneuro/sub-36/fmap/sub-36_acq-topup1_fieldmap.nii.gz',),
+        ('HCP101006/sub-101006/fmap/sub-101006_phasediff.nii.gz',),
     ],
 )
 def test_phdiff(tmpdir, datadir, workdir, outdir, fmap_file):
@@ -50,14 +49,12 @@ def test_phdiff(tmpdir, datadir, workdir, outdir, fmap_file):
 
     fmap_path = [datadir / f for f in fmap_file]
     fieldmaps = [
-        (str(f.absolute()), loads(Path(str(f).replace(".nii.gz", ".json")).read_text()))
+        (str(f.absolute()), loads(Path(str(f).replace('.nii.gz', '.json')).read_text()))
         for f in fmap_path
     ]
 
-    wf = Workflow(
-        name=f"phdiff_{fmap_path[0].name.replace('.nii.gz', '').replace('-', '_')}"
-    )
-    mode = "mapped" if "fieldmap" in fmap_path[0].name else "phasediff"
+    wf = Workflow(name=f'phdiff_{fmap_path[0].name.replace(".nii.gz", "").replace("-", "_")}')
+    mode = 'mapped' if 'fieldmap' in fmap_path[0].name else 'phasediff'
     phdiff_wf = init_fmap_wf(
         omp_nthreads=2,
         debug=True,
@@ -66,27 +63,25 @@ def test_phdiff(tmpdir, datadir, workdir, outdir, fmap_file):
     )
     phdiff_wf.inputs.inputnode.fieldmap = fieldmaps
     phdiff_wf.inputs.inputnode.magnitude = [
-        f.replace("diff", "1")
-        .replace("phase", "magnitude")
-        .replace("fieldmap", "magnitude")
+        f.replace('diff', '1').replace('phase', 'magnitude').replace('fieldmap', 'magnitude')
         for f, _ in fieldmaps
     ]
 
     if outdir:
         from ...outputs import init_fmap_derivatives_wf, init_fmap_reports_wf
 
-        outdir = outdir / "unittests" / fmap_file[0].split("/")[0]
+        outdir = outdir / 'unittests' / fmap_file[0].split('/')[0]
         fmap_derivatives_wf = init_fmap_derivatives_wf(
             output_dir=str(outdir),
             write_coeff=True,
-            bids_fmap_id="phasediff_id",
+            bids_fmap_id='phasediff_id',
         )
         fmap_derivatives_wf.inputs.inputnode.source_files = [f for f, _ in fieldmaps]
         fmap_derivatives_wf.inputs.inputnode.fmap_meta = [f for _, f in fieldmaps]
 
         fmap_reports_wf = init_fmap_reports_wf(
             output_dir=str(outdir),
-            fmap_type=mode if len(fieldmaps) == 1 else "phases",
+            fmap_type=mode if len(fieldmaps) == 1 else 'phases',
         )
         fmap_reports_wf.inputs.inputnode.source_files = [f for f, _ in fieldmaps]
 
@@ -109,4 +104,4 @@ def test_phdiff(tmpdir, datadir, workdir, outdir, fmap_file):
     if workdir:
         wf.base_dir = str(workdir)
 
-    wf.run(plugin="Linear")
+    wf.run(plugin='Linear')
diff --git a/sdcflows/workflows/fit/tests/test_syn.py b/sdcflows/workflows/fit/tests/test_syn.py
index 44fc6e93a8..40428d0a0c 100644
--- a/sdcflows/workflows/fit/tests/test_syn.py
+++ b/sdcflows/workflows/fit/tests/test_syn.py
@@ -24,19 +24,19 @@
 
 import json
 
-import numpy as np
 import nibabel as nb
+import numpy as np
 import pytest
 from nipype.pipeline import engine as pe
 
 from .... import data
 from ..syn import (
-    init_syn_sdc_wf,
-    init_syn_preprocessing_wf,
     _adjust_zooms,
-    _set_dtype,
     _mm2vox,
+    _set_dtype,
     _warp_dir,
+    init_syn_preprocessing_wf,
+    init_syn_sdc_wf,
 )
 
 
@@ -44,10 +44,10 @@
 @pytest.mark.slow
 def test_syn_wf(tmpdir, datadir, workdir, outdir, sloppy_mode):
     """Build and run an SDC-SyN workflow."""
-    derivs_path = datadir / "ds000054" / "derivatives"
-    smriprep = derivs_path / "smriprep-0.6" / "sub-100185" / "anat"
+    derivs_path = datadir / 'ds000054' / 'derivatives'
+    smriprep = derivs_path / 'smriprep-0.6' / 'sub-100185' / 'anat'
 
-    wf = pe.Workflow(name="test_syn")
+    wf = pe.Workflow(name='test_syn')
 
     prep_wf = init_syn_preprocessing_wf(
         omp_nthreads=4,
@@ -58,31 +58,27 @@ def test_syn_wf(tmpdir, datadir, workdir, outdir, sloppy_mode):
     prep_wf.inputs.inputnode.in_epis = [
         str(
             datadir
-            / "ds000054"
-            / "sub-100185"
-            / "func"
-            / "sub-100185_task-machinegame_run-01_bold.nii.gz"
+            / 'ds000054'
+            / 'sub-100185'
+            / 'func'
+            / 'sub-100185_task-machinegame_run-01_bold.nii.gz'
         ),
         str(
             datadir
-            / "ds000054"
-            / "sub-100185"
-            / "func"
-            / "sub-100185_task-machinegame_run-02_bold.nii.gz"
+            / 'ds000054'
+            / 'sub-100185'
+            / 'func'
+            / 'sub-100185_task-machinegame_run-02_bold.nii.gz'
         ),
     ]
     prep_wf.inputs.inputnode.in_meta = [
-        json.loads((datadir / "ds000054" / "task-machinegame_bold.json").read_text()),
+        json.loads((datadir / 'ds000054' / 'task-machinegame_bold.json').read_text()),
     ] * 2
     prep_wf.inputs.inputnode.std2anat_xfm = str(
-        smriprep / "sub-100185_from-MNI152NLin2009cAsym_to-T1w_mode-image_xfm.h5"
-    )
-    prep_wf.inputs.inputnode.in_anat = str(
-        smriprep / "sub-100185_desc-preproc_T1w.nii.gz"
-    )
-    prep_wf.inputs.inputnode.mask_anat = str(
-        smriprep / "sub-100185_desc-brain_mask.nii.gz"
+        smriprep / 'sub-100185_from-MNI152NLin2009cAsym_to-T1w_mode-image_xfm.h5'
     )
+    prep_wf.inputs.inputnode.in_anat = str(smriprep / 'sub-100185_desc-preproc_T1w.nii.gz')
+    prep_wf.inputs.inputnode.mask_anat = str(smriprep / 'sub-100185_desc-brain_mask.nii.gz')
 
     syn_wf = init_syn_sdc_wf(
         debug=sloppy_mode,
@@ -105,32 +101,26 @@ def test_syn_wf(tmpdir, datadir, workdir, outdir, sloppy_mode):
     if outdir:
         from ...outputs import init_fmap_derivatives_wf, init_fmap_reports_wf
 
-        outdir = outdir / "unittests" / "test_syn"
+        outdir = outdir / 'unittests' / 'test_syn'
         fmap_derivatives_wf = init_fmap_derivatives_wf(
             output_dir=str(outdir),
             write_coeff=True,
-            bids_fmap_id="sdcsyn",
+            bids_fmap_id='sdcsyn',
         )
         fmap_derivatives_wf.inputs.inputnode.source_files = [
             str(
-                derivs_path
-                / "sdcflows-tests"
-                / "sub-100185_task-machinegame_run-1_boldref.nii.gz"
+                derivs_path / 'sdcflows-tests' / 'sub-100185_task-machinegame_run-1_boldref.nii.gz'
             )
         ]
-        fmap_derivatives_wf.inputs.inputnode.fmap_meta = {
-            "PhaseEncodingDirection": "j-"
-        }
+        fmap_derivatives_wf.inputs.inputnode.fmap_meta = {'PhaseEncodingDirection': 'j-'}
 
         fmap_reports_wf = init_fmap_reports_wf(
             output_dir=str(outdir),
-            fmap_type="sdcsyn",
+            fmap_type='sdcsyn',
         )
         fmap_reports_wf.inputs.inputnode.source_files = [
             str(
-                derivs_path
-                / "sdcflows-tests"
-                / "sub-100185_task-machinegame_run-1_boldref.nii.gz"
+                derivs_path / 'sdcflows-tests' / 'sub-100185_task-machinegame_run-1_boldref.nii.gz'
             )
         ]
 
@@ -151,11 +141,11 @@ def test_syn_wf(tmpdir, datadir, workdir, outdir, sloppy_mode):
     if workdir:
         wf.base_dir = str(workdir)
 
-    wf.run(plugin="Linear")
+    wf.run(plugin='Linear')
 
 
-@pytest.mark.parametrize("laplacian_weight", [None, (0.5, 0.1), (0.8, -1.0)])
-@pytest.mark.parametrize("sloppy", [True, False])
+@pytest.mark.parametrize('laplacian_weight', [None, (0.5, 0.1), (0.8, -1.0)])
+@pytest.mark.parametrize('sloppy', [True, False])
 def test_syn_wf_inputs(sloppy, laplacian_weight):
     """Test the input validation of the SDC-SyN workflow."""
     from sdcflows.workflows.fit.syn import MAX_LAPLACIAN_WEIGHT
@@ -178,7 +168,7 @@ def test_syn_wf_inputs(sloppy, laplacian_weight):
     assert wf.inputs.syn.metric_weight == metric_weight
 
 
-@pytest.mark.parametrize("sd_prior", [True, False])
+@pytest.mark.parametrize('sd_prior', [True, False])
 def test_syn_preprocessing_wf_inputs(sd_prior):
     """Test appropriate instantiation of the SDC-SyN preprocessing workflow."""
 
@@ -196,22 +186,22 @@ def test_syn_preprocessing_wf_inputs(sd_prior):
         assert prep_wf.inputs.prior_msk.thresh_low
 
 
-@pytest.mark.parametrize("ants_version", ["2.2.0", "2.1.0", None])
+@pytest.mark.parametrize('ants_version', ['2.2.0', '2.1.0', None])
 def test_syn_wf_version(monkeypatch, ants_version):
     """Ensure errors are triggered with ANTs < 2.2."""
     from niworkflows.interfaces.fixes import FixHeaderRegistration as Registration
 
-    monkeypatch.setattr(Registration, "version", ants_version)
-    if ants_version == "2.1.0":
+    monkeypatch.setattr(Registration, 'version', ants_version)
+    if ants_version == '2.1.0':
         with pytest.raises(RuntimeError):
             init_syn_sdc_wf(debug=True, sloppy=True, omp_nthreads=4)
     else:
         wf = init_syn_sdc_wf(debug=True, sloppy=True, omp_nthreads=4)
-        assert (ants_version or "version unknown") in wf.__desc__
+        assert (ants_version or 'version unknown') in wf.__desc__
 
 
 @pytest.mark.parametrize(
-    "anat_res,epi_res,retval",
+    'anat_res,epi_res,retval',
     [
         ((1.0, 1.0, 1.0), (2.0, 2.0, 2.0), (1.8, 1.8, 1.8)),
         ((1.8, 1.8, 1.8), (2.0, 2.0, 2.0), (1.9, 1.9, 1.9)),
@@ -221,57 +211,57 @@ def test_syn_wf_version(monkeypatch, ants_version):
 )
 def test_adjust_zooms(anat_res, epi_res, retval, tmpdir, datadir):
     """Exercise the adjust zooms function node."""
-    import numpy as np
     import nibabel as nb
+    import numpy as np
 
     tmpdir.chdir()
     nb.Nifti1Image(
         np.zeros((10, 10, 10)),
         np.diag(list(anat_res) + [1]),
         None,
-    ).to_filename("anat.nii.gz")
+    ).to_filename('anat.nii.gz')
     nb.Nifti1Image(
         np.zeros((10, 10, 10)),
         np.diag(list(epi_res) + [1]),
         None,
-    ).to_filename("epi.nii.gz")
+    ).to_filename('epi.nii.gz')
 
-    assert _adjust_zooms("anat.nii.gz", "epi.nii.gz") == retval
+    assert _adjust_zooms('anat.nii.gz', 'epi.nii.gz') == retval
 
 
 @pytest.mark.parametrize(
-    "in_dtype,out_dtype",
+    'in_dtype,out_dtype',
     [
-        ("float32", "int16"),
-        ("int16", "int16"),
-        ("uint8", "int16"),
-        ("float64", "int16"),
+        ('float32', 'int16'),
+        ('int16', 'int16'),
+        ('uint8', 'int16'),
+        ('float64', 'int16'),
     ],
 )
 def test_ensure_dtype(in_dtype, out_dtype, tmpdir):
     """Exercise the set dtype function node."""
-    import numpy as np
     import nibabel as nb
+    import numpy as np
 
     tmpdir.chdir()
     nb.Nifti1Image(
         np.zeros((10, 10, 10), dtype=in_dtype),
         np.eye(4),
         None,
-    ).to_filename(f"{in_dtype}.nii.gz")
+    ).to_filename(f'{in_dtype}.nii.gz')
 
-    out_file = _set_dtype(f"{in_dtype}.nii.gz")
+    out_file = _set_dtype(f'{in_dtype}.nii.gz')
     if in_dtype == out_dtype:
-        assert out_file == f"{in_dtype}.nii.gz"
+        assert out_file == f'{in_dtype}.nii.gz'
     else:
-        assert out_file == f"{in_dtype}_{out_dtype}.nii.gz"
+        assert out_file == f'{in_dtype}_{out_dtype}.nii.gz'
 
 
 def axcodes2aff(axcodes):
     """Return an affine matrix from axis codes."""
     return nb.orientations.inv_ornt_aff(
         nb.orientations.ornt_transform(
-            nb.orientations.axcodes2ornt("RAS"),
+            nb.orientations.axcodes2ornt('RAS'),
             nb.orientations.axcodes2ornt(axcodes),
         ),
         (10, 10, 10),
@@ -279,22 +269,22 @@ def axcodes2aff(axcodes):
 
 
 @pytest.mark.parametrize(
-    ("fixed_ornt", "moving_ornt", "ijk", "index"),
+    ('fixed_ornt', 'moving_ornt', 'ijk', 'index'),
     [
-        ("RAS", "RAS", "i", 0),
-        ("RAS", "RAS", "j", 1),
-        ("RAS", "RAS", "k", 2),
-        ("RAS", "PSL", "i", 1),
-        ("RAS", "PSL", "j", 2),
-        ("RAS", "PSL", "k", 0),
-        ("PSL", "RAS", "i", 2),
-        ("PSL", "RAS", "j", 0),
-        ("PSL", "RAS", "k", 1),
+        ('RAS', 'RAS', 'i', 0),
+        ('RAS', 'RAS', 'j', 1),
+        ('RAS', 'RAS', 'k', 2),
+        ('RAS', 'PSL', 'i', 1),
+        ('RAS', 'PSL', 'j', 2),
+        ('RAS', 'PSL', 'k', 0),
+        ('PSL', 'RAS', 'i', 2),
+        ('PSL', 'RAS', 'j', 0),
+        ('PSL', 'RAS', 'k', 1),
     ],
 )
 def test_mm2vox(tmp_path, fixed_ornt, moving_ornt, ijk, index):
-    fixed_path = tmp_path / "fixed.nii.gz"
-    moving_path = tmp_path / "moving.nii.gz"
+    fixed_path = tmp_path / 'fixed.nii.gz'
+    moving_path = tmp_path / 'moving.nii.gz'
 
     # Use separate zooms to make identifying the conversion easier
     fixed_aff = np.diag((2, 3, 4, 1))
@@ -307,36 +297,34 @@ def test_mm2vox(tmp_path, fixed_ornt, moving_ornt, ijk, index):
         moving_path,
     )
 
-    config = json.loads(data.load.readable("sd_syn.json").read_text())
+    config = json.loads(data.load.readable('sd_syn.json').read_text())
 
-    params = config["transform_parameters"]
+    params = config['transform_parameters']
     mm_values = np.array([level[2] for level in params])
 
     vox_params = _mm2vox(str(moving_path), str(fixed_path), ijk, config)
     vox_values = [level[2] for level in vox_params]
-    assert [
-        mm_level[:2] == vox_level[:2] for mm_level, vox_level in zip(params, vox_params)
-    ]
+    assert [mm_level[:2] == vox_level[:2] for mm_level, vox_level in zip(params, vox_params)]
     assert np.array_equal(vox_values, mm_values / [2, 3, 4][index])
 
 
 @pytest.mark.parametrize(
-    ("fixed_ornt", "moving_ornt", "ijk", "index"),
+    ('fixed_ornt', 'moving_ornt', 'ijk', 'index'),
     [
-        ("RAS", "RAS", "i", 0),
-        ("RAS", "RAS", "j", 1),
-        ("RAS", "RAS", "k", 2),
-        ("RAS", "PSL", "i", 1),
-        ("RAS", "PSL", "j", 2),
-        ("RAS", "PSL", "k", 0),
-        ("PSL", "RAS", "i", 2),
-        ("PSL", "RAS", "j", 0),
-        ("PSL", "RAS", "k", 1),
+        ('RAS', 'RAS', 'i', 0),
+        ('RAS', 'RAS', 'j', 1),
+        ('RAS', 'RAS', 'k', 2),
+        ('RAS', 'PSL', 'i', 1),
+        ('RAS', 'PSL', 'j', 2),
+        ('RAS', 'PSL', 'k', 0),
+        ('PSL', 'RAS', 'i', 2),
+        ('PSL', 'RAS', 'j', 0),
+        ('PSL', 'RAS', 'k', 1),
     ],
 )
 def test_warp_dir(tmp_path, fixed_ornt, moving_ornt, ijk, index):
-    fixed_path = tmp_path / "fixed.nii.gz"
-    moving_path = tmp_path / "moving.nii.gz"
+    fixed_path = tmp_path / 'fixed.nii.gz'
+    moving_path = tmp_path / 'moving.nii.gz'
 
     nb.save(
         nb.Nifti1Image(np.zeros((10, 10, 10)), axcodes2aff(fixed_ornt)),
diff --git a/sdcflows/workflows/outputs.py b/sdcflows/workflows/outputs.py
index 35e0c72004..aeac11f92d 100644
--- a/sdcflows/workflows/outputs.py
+++ b/sdcflows/workflows/outputs.py
@@ -21,10 +21,11 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Writing out outputs."""
+
 import re
 
-from nipype.pipeline import engine as pe
 from nipype.interfaces import utility as niu
+from nipype.pipeline import engine as pe
 from niworkflows.interfaces.bids import DerivativesDataSink as _DDS
 from niworkflows.interfaces.nibabel import MergeSeries
 
@@ -32,7 +33,7 @@
 class DerivativesDataSink(_DDS):
     """Overload the ``out_path_base`` setting."""
 
-    out_path_base = "sdcflows"
+    out_path_base = 'sdcflows'
 
 
 del _DDS
@@ -44,7 +45,7 @@ def init_fmap_reports_wf(
     fmap_type,
     bids_fmap_id=None,
     custom_entities=None,
-    name="fmap_reports_wf",
+    name='fmap_reports_wf',
 ):
     """
     Set up a battery of datasinks to store reports in the right location.
@@ -79,29 +80,27 @@ def init_fmap_reports_wf(
 
     custom_entities = custom_entities or {}
     if bids_fmap_id:
-        custom_entities["fmapid"] = re.sub(r'[^a-zA-Z0-9]', '', bids_fmap_id)
+        custom_entities['fmapid'] = re.sub(r'[^a-zA-Z0-9]', '', bids_fmap_id)
 
     workflow = pe.Workflow(name=name)
     inputnode = pe.Node(
-        niu.IdentityInterface(
-            fields=["source_files", "fieldmap", "fmap_ref", "fmap_mask"]
-        ),
-        name="inputnode",
+        niu.IdentityInterface(fields=['source_files', 'fieldmap', 'fmap_ref', 'fmap_mask']),
+        name='inputnode',
     )
 
-    fmap_rpt = pe.Node(FieldmapReportlet(), "fmap_rpt")
+    fmap_rpt = pe.Node(FieldmapReportlet(), 'fmap_rpt')
     fmap_rpt.interface._always_run = True
 
     ds_fmap_report = pe.Node(
         DerivativesDataSink(
             base_directory=str(output_dir),
-            datatype="figures",
-            suffix="fieldmap",
+            datatype='figures',
+            suffix='fieldmap',
             desc=fmap_type,
-            dismiss_entities=("fmap",),
+            dismiss_entities=('fmap',),
             allowed_entities=tuple(custom_entities.keys()),
         ),
-        name="ds_fmap_report",
+        name='ds_fmap_report',
     )
     for k, v in custom_entities.items():
         setattr(ds_fmap_report.inputs, k, v)
@@ -125,7 +124,7 @@ def init_fmap_derivatives_wf(
     output_dir,
     bids_fmap_id=None,
     custom_entities=None,
-    name="fmap_derivatives_wf",
+    name='fmap_derivatives_wf',
     write_coeff=False,
 ):
     """
@@ -158,42 +157,42 @@ def init_fmap_derivatives_wf(
     """
     custom_entities = custom_entities or {}
     if bids_fmap_id:
-        custom_entities["fmapid"] = re.sub(r'[^a-zA-Z0-9]', '', bids_fmap_id)
+        custom_entities['fmapid'] = re.sub(r'[^a-zA-Z0-9]', '', bids_fmap_id)
 
     workflow = pe.Workflow(name=name)
     inputnode = pe.Node(
         niu.IdentityInterface(
-            fields=["source_files", "fieldmap", "fmap_coeff", "fmap_ref", "fmap_meta"]
+            fields=['source_files', 'fieldmap', 'fmap_coeff', 'fmap_ref', 'fmap_meta']
         ),
-        name="inputnode",
+        name='inputnode',
     )
 
-    merge_fmap = pe.Node(MergeSeries(), name="merge_fmap")
+    merge_fmap = pe.Node(MergeSeries(), name='merge_fmap')
 
     ds_reference = pe.Node(
         DerivativesDataSink(
             base_directory=output_dir,
             compress=True,
-            suffix="fieldmap",
-            datatype="fmap",
-            dismiss_entities=("fmap",),
+            suffix='fieldmap',
+            datatype='fmap',
+            dismiss_entities=('fmap',),
             allowed_entities=tuple(custom_entities.keys()),
         ),
-        name="ds_reference",
+        name='ds_reference',
     )
 
     ds_fieldmap = pe.Node(
         DerivativesDataSink(
             base_directory=output_dir,
-            desc="preproc",
-            suffix="fieldmap",
-            datatype="fmap",
+            desc='preproc',
+            suffix='fieldmap',
+            datatype='fmap',
             compress=True,
             allowed_entities=tuple(custom_entities.keys()),
         ),
-        name="ds_fieldmap",
+        name='ds_fieldmap',
     )
-    ds_fieldmap.inputs.Units = "Hz"
+    ds_fieldmap.inputs.Units = 'Hz'
     if bids_fmap_id:
         ds_fieldmap.inputs.B0FieldIdentifier = bids_fmap_id
 
@@ -223,16 +222,16 @@ def init_fmap_derivatives_wf(
     ds_coeff = pe.MapNode(
         DerivativesDataSink(
             base_directory=output_dir,
-            suffix="fieldmap",
-            datatype="fmap",
+            suffix='fieldmap',
+            datatype='fmap',
             compress=True,
             allowed_entities=tuple(custom_entities.keys()),
         ),
-        name="ds_coeff",
-        iterfield=("in_file", "desc"),
+        name='ds_coeff',
+        iterfield=('in_file', 'desc'),
     )
 
-    gen_desc = pe.Node(niu.Function(function=_gendesc), name="gen_desc")
+    gen_desc = pe.Node(niu.Function(function=_gendesc), name='gen_desc')
 
     for k, v in custom_entities.items():
         setattr(ds_coeff.inputs, k, v)
@@ -267,9 +266,9 @@ def _gendesc(infiles):
         infiles = [infiles]
 
     if len(infiles) == 1:
-        return "coeff"
+        return 'coeff'
 
-    return [f"coeff{i}" for i, _ in enumerate(infiles)]
+    return [f'coeff{i}' for i, _ in enumerate(infiles)]
 
 
 def _getname(infile):
@@ -308,7 +307,7 @@ def _getsourcetype(infiles):
     from pathlib import Path
 
     fname = Path(infiles[0]).name
-    return "epi" if fname.endswith(("_epi.nii.gz", "_epi.nii")) else "magnitude"
+    return 'epi' if fname.endswith(('_epi.nii.gz', '_epi.nii')) else 'magnitude'
 
 
 def _selectintent(metadata):
@@ -338,6 +337,4 @@ def _selectintent(metadata):
     """
     from bids.utils import listify
 
-    return sorted(
-        set([el for m in listify(metadata) for el in listify(m.get("IntendedFor", []))])
-    )
+    return sorted(set([el for m in listify(metadata) for el in listify(m.get('IntendedFor', []))]))
diff --git a/sdcflows/workflows/tests/test_ancillary.py b/sdcflows/workflows/tests/test_ancillary.py
index 57e71c4030..102a6d0ee0 100644
--- a/sdcflows/workflows/tests/test_ancillary.py
+++ b/sdcflows/workflows/tests/test_ancillary.py
@@ -21,30 +21,30 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Check the tools submodule."""
+
 import pytest
-from nipype.pipeline import engine as pe
 from nipype.interfaces import utility as niu
+from nipype.pipeline import engine as pe
 from nireports.interfaces.reporting.masks import SimpleShowMaskRPT
+
 from ..ancillary import init_brainextraction_wf
 
 
 @pytest.mark.slow
-@pytest.mark.parametrize("folder", ["magnitude/ds000054", "magnitude/ds000217"])
+@pytest.mark.parametrize('folder', ['magnitude/ds000054', 'magnitude/ds000217'])
 def test_brainmasker(tmpdir, datadir, workdir, outdir, folder):
     """Exercise the brain masking tool."""
     tmpdir.chdir()
 
-    wf = pe.Workflow(name=f"test_mask_{folder.replace('/', '_')}")
+    wf = pe.Workflow(name=f'test_mask_{folder.replace("/", "_")}')
     if workdir:
         wf.base_dir = str(workdir)
 
-    input_files = [
-        str(f) for f in (datadir / "brain-extraction-tests" / folder).glob("*.nii.gz")
-    ]
+    input_files = [str(f) for f in (datadir / 'brain-extraction-tests' / folder).glob('*.nii.gz')]
 
-    inputnode = pe.Node(niu.IdentityInterface(fields=("in_file",)), name="inputnode")
-    inputnode.iterables = ("in_file", input_files)
-    merger = pe.Node(niu.Function(function=_merge), name="merger")
+    inputnode = pe.Node(niu.IdentityInterface(fields=('in_file',)), name='inputnode')
+    inputnode.iterables = ('in_file', input_files)
+    merger = pe.Node(niu.Function(function=_merge), name='merger')
 
     brainmask_wf = init_brainextraction_wf()
 
@@ -56,9 +56,9 @@ def test_brainmasker(tmpdir, datadir, workdir, outdir, folder):
     # fmt:on
 
     if outdir:
-        out_path = outdir / "masks" / folder.split("/")[-1]
+        out_path = outdir / 'masks' / folder.split('/')[-1]
         out_path.mkdir(exist_ok=True, parents=True)
-        report = pe.Node(SimpleShowMaskRPT(), name="report")
+        report = pe.Node(SimpleShowMaskRPT(), name='report')
         report.interface._always_run = True
 
         def _report_name(fname, out_path):
@@ -67,9 +67,9 @@ def _report_name(fname, out_path):
             return str(
                 out_path
                 / Path(fname)
-                .name.replace(".nii", "_mask.svg")
-                .replace("_magnitude", "_desc-magnitude")
-                .replace(".gz", "")
+                .name.replace('.nii', '_mask.svg')
+                .replace('_magnitude', '_desc-magnitude')
+                .replace('.gz', '')
             )
 
         # fmt: off
@@ -96,6 +96,6 @@ def _merge(in_file):
     from pathlib import Path
 
     data = data.mean(-1)
-    out_file = (Path() / "merged.nii.gz").absolute()
+    out_file = (Path() / 'merged.nii.gz').absolute()
     img.__class__(data, img.affine, img.header).to_filename(out_file)
     return str(out_file)
diff --git a/sdcflows/workflows/tests/test_base.py b/sdcflows/workflows/tests/test_base.py
index 2cb77cf089..89f5731ec6 100644
--- a/sdcflows/workflows/tests/test_base.py
+++ b/sdcflows/workflows/tests/test_base.py
@@ -21,8 +21,11 @@
 #     https://www.nipreps.org/community/licensing/
 #
 """Test the base workflow."""
+
 from pathlib import Path
+
 import pytest
+
 from sdcflows import fieldmaps as fm
 from sdcflows.utils.wrangler import find_estimators
 from sdcflows.workflows.base import init_fmap_preproc_wf
@@ -30,15 +33,13 @@
 
 @pytest.mark.veryslow
 @pytest.mark.slow
-@pytest.mark.parametrize(
-    "dataset,subject", [("ds000054", "100185"), ("HCP101006", "101006")]
-)
+@pytest.mark.parametrize('dataset,subject', [('ds000054', '100185'), ('HCP101006', '101006')])
 def test_fmap_wf(tmpdir, workdir, outdir, bids_layouts, dataset, subject):
     """Test the encompassing of the wrangler and the workflow creator."""
     if outdir is None:
         outdir = Path(str(tmpdir))
 
-    outdir = outdir / "test_base" / dataset
+    outdir = outdir / 'test_base' / dataset
     fm._estimators.clear()
     estimators = find_estimators(layout=bids_layouts[dataset], subject=subject)
     wf = init_fmap_preproc_wf(
@@ -56,19 +57,19 @@ def test_fmap_wf(tmpdir, workdir, outdir, bids_layouts, dataset, subject):
         if estimator.method != fm.EstimatorType.PEPOLAR:
             continue
 
-        inputnode = wf.get_node(f"in_{estimator.bids_id}")
+        inputnode = wf.get_node(f'in_{estimator.bids_id}')
         inputnode.inputs.in_data = [str(f.path) for f in estimator.sources]
         inputnode.inputs.metadata = [f.metadata for f in estimator.sources]
 
     if workdir:
         wf.base_dir = str(workdir)
 
-    res = wf.run(plugin="Linear")
+    res = wf.run(plugin='Linear')
 
     # Regression test for when out_merge_fmap_coeff was flattened and would
     # have twice as many elements as the other nodes
     assert all(
         len(node.result.outputs.out) == len(estimators)
         for node in res.nodes
-        if node.name.startswith("out_merge_")
+        if node.name.startswith('out_merge_')
     )
diff --git a/sdcflows/workflows/tests/test_integration.py b/sdcflows/workflows/tests/test_integration.py
index 644e23530c..c70a535a89 100644
--- a/sdcflows/workflows/tests/test_integration.py
+++ b/sdcflows/workflows/tests/test_integration.py
@@ -22,24 +22,26 @@
 #
 """Test the base workflow."""
 
-from pathlib import Path
 import json
-import pytest
+from pathlib import Path
+
 import numpy as np
+import pytest
 from nipype.interfaces import utility as niu
 from nipype.pipeline import engine as pe
+from nireports.interfaces.reporting.base import (
+    SimpleBeforeAfterRPT as SimpleBeforeAfter,
+)
+
 from sdcflows import fieldmaps as sfm
 from sdcflows.interfaces.reportlets import FieldmapReportlet
 from sdcflows.workflows.apply import correction as swac
 from sdcflows.workflows.apply import registration as swar
-from nireports.interfaces.reporting.base import (
-    SimpleBeforeAfterRPT as SimpleBeforeAfter,
-)
 
 
 @pytest.mark.slow
-@pytest.mark.parametrize("pe0", ["LR", "PA"])
-@pytest.mark.parametrize("mode", ["pepolar", "phasediff"])
+@pytest.mark.parametrize('pe0', ['LR', 'PA'])
+@pytest.mark.parametrize('mode', ['pepolar', 'phasediff'])
 def test_integration_wf(tmpdir, workdir, outdir, datadir, pe0, mode):
     """Build a ``FieldmapEstimation`` workflow and test estimation and correction."""
 
@@ -48,49 +50,45 @@ def test_integration_wf(tmpdir, workdir, outdir, datadir, pe0, mode):
     if not outdir:
         outdir = Path.cwd()
 
-    session = "15" if pe0 == "LR" else "14"
+    session = '15' if pe0 == 'LR' else '14'
 
     pe1 = pe0[::-1]
 
-    datadir = datadir / "hcph-pilot_fieldmaps"
+    datadir = datadir / 'hcph-pilot_fieldmaps'
 
-    wf = pe.Workflow(name=f"hcph_{mode}_{pe0}")
+    wf = pe.Workflow(name=f'hcph_{mode}_{pe0}')
 
     # Execute in temporary directory
     wf.base_dir = str(workdir or tmpdir)
 
     # Prepare some necessary data and metadata
     metadata = json.loads(
-        (datadir / f"sub-pilot_ses-{session}_acq-b0_dir-{pe0}_dwi.json").read_text()
+        (datadir / f'sub-pilot_ses-{session}_acq-b0_dir-{pe0}_dwi.json').read_text()
     )
     unwarp_input = (
-        datadir / f"sub-pilot_ses-{session}_acq-b0_dir-{pe0}_desc-mockmotion_dwi.nii.gz"
+        datadir / f'sub-pilot_ses-{session}_acq-b0_dir-{pe0}_desc-mockmotion_dwi.nii.gz'
     ).absolute()
     unwarp_xfms = np.load(
-        datadir / f"sub-pilot_ses-{session}_acq-b0_dir-{pe0}_desc-mockmotion_dwi.npy"
+        datadir / f'sub-pilot_ses-{session}_acq-b0_dir-{pe0}_desc-mockmotion_dwi.npy'
     ).tolist()
 
     # Generate a warped reference for reportlet
-    warped_ref = pe.Node(
-        niu.Function(function=_transform_and_average), name="warped_ref"
-    )
+    warped_ref = pe.Node(niu.Function(function=_transform_and_average), name='warped_ref')
     warped_ref.inputs.in_file = str(unwarp_input)
     warped_ref.inputs.in_xfm = unwarp_xfms
 
     # Create an unwarp workflow and connect
-    step2 = swac.init_unwarp_wf(
-        omp_nthreads=6
-    )  # six async threads should be doable on Circle
+    step2 = swac.init_unwarp_wf(omp_nthreads=6)  # six async threads should be doable on Circle
     step2.inputs.inputnode.metadata = metadata
     step2.inputs.inputnode.distorted = str(unwarp_input)
     step2.inputs.inputnode.hmc_xforms = unwarp_xfms
 
-    if mode == "pepolar":
+    if mode == 'pepolar':
         # Generate an estimator workflow with the estimator object
         estimator = sfm.FieldmapEstimation(
             sources=[
-                datadir / f"sub-pilot_ses-{session}_acq-b0_dir-{pe1}_epi.nii.gz",
-                datadir / f"sub-pilot_ses-{session}_acq-b0_dir-{pe0}_desc-3dvolreg_dwi.nii.gz",
+                datadir / f'sub-pilot_ses-{session}_acq-b0_dir-{pe1}_epi.nii.gz',
+                datadir / f'sub-pilot_ses-{session}_acq-b0_dir-{pe0}_desc-3dvolreg_dwi.nii.gz',
             ],
         )
         step1 = estimator.get_workflow(omp_nthreads=6, debug=False, sloppy=True)
@@ -98,23 +96,22 @@ def test_integration_wf(tmpdir, workdir, outdir, datadir, pe0, mode):
         # Set inputs to estimator
         step1.inputs.inputnode.metadata = [
             json.loads(
-                (datadir / f"sub-pilot_ses-{session}_acq-b0_dir-{pe1}_epi.json").read_text()
+                (datadir / f'sub-pilot_ses-{session}_acq-b0_dir-{pe1}_epi.json').read_text()
             ),
             metadata,
         ]
         step1.inputs.inputnode.in_data = [
-            str((datadir / f"sub-pilot_ses-{session}_acq-b0_dir-{pe1}_epi.nii.gz").absolute()),
+            str((datadir / f'sub-pilot_ses-{session}_acq-b0_dir-{pe1}_epi.nii.gz').absolute()),
             str(
                 (
-                    datadir
-                    / f"sub-pilot_ses-{session}_acq-b0_dir-{pe0}_desc-3dvolreg_dwi.nii.gz"
+                    datadir / f'sub-pilot_ses-{session}_acq-b0_dir-{pe0}_desc-3dvolreg_dwi.nii.gz'
                 ).absolute()
             ),
         ]
     else:
         # Generate an estimator workflow with the estimator object
         estimator = sfm.FieldmapEstimation(
-            sources=[datadir / f"sub-pilot_ses-{session}_phasediff.nii.gz"],
+            sources=[datadir / f'sub-pilot_ses-{session}_phasediff.nii.gz'],
         )
         step1 = estimator.get_workflow(omp_nthreads=6, debug=False)
 
@@ -122,21 +119,21 @@ def test_integration_wf(tmpdir, workdir, outdir, datadir, pe0, mode):
         coeff2epi_wf.inputs.inputnode.target_mask = str(
             (
                 datadir
-                / f"sub-pilot_ses-{session}_acq-b0_dir-{pe0}_desc-aftersdcbrain_mask.nii.gz"
+                / f'sub-pilot_ses-{session}_acq-b0_dir-{pe0}_desc-aftersdcbrain_mask.nii.gz'
             ).absolute()
         )
 
         # Check fmap2epi alignment
         rpt_coeff2epi = pe.Node(
             SimpleBeforeAfter(
-                after_label="GRE (mag)",
-                before_label="EPI (ref)",
+                after_label='GRE (mag)',
+                before_label='EPI (ref)',
                 out_report=str(
-                    outdir / f"sub-pilot_ses-{session}_desc-aligned+{pe0}_fieldmap.svg"
+                    outdir / f'sub-pilot_ses-{session}_desc-aligned+{pe0}_fieldmap.svg'
                 ),
                 dismiss_affine=True,
             ),
-            name="rpt_coeff2epi",
+            name='rpt_coeff2epi',
         )
 
         # fmt:off
@@ -158,22 +155,20 @@ def test_integration_wf(tmpdir, workdir, outdir, datadir, pe0, mode):
     # Show a reportlet
     rpt_fieldmap = pe.Node(
         FieldmapReportlet(
-            out_report=str(
-                outdir / f"sub-pilot_ses-{session}_desc-{mode}+{pe0}_fieldmap.svg"
-            ),
+            out_report=str(outdir / f'sub-pilot_ses-{session}_desc-{mode}+{pe0}_fieldmap.svg'),
         ),
-        name="rpt_fieldmap",
+        name='rpt_fieldmap',
     )
 
     # Write reportlet
     rpt_correct = pe.Node(
         SimpleBeforeAfter(
-            after_label="Corrected",
-            before_label="Distorted",
-            out_report=str(outdir / f"sub-pilot_ses-{session}_desc-{mode}+{pe0}_dwi.svg"),
+            after_label='Corrected',
+            before_label='Distorted',
+            out_report=str(outdir / f'sub-pilot_ses-{session}_desc-{mode}+{pe0}_dwi.svg'),
             # dismiss_affine=True,
         ),
-        name="rpt_correct",
+        name='rpt_correct',
     )
 
     # fmt:off
@@ -196,18 +191,15 @@ def test_integration_wf(tmpdir, workdir, outdir, datadir, pe0, mode):
 
 
 def _transform_and_average(in_file, in_xfm):
-    import numpy as np
     from pathlib import Path
-    from nitransforms.linear import LinearTransformsMapping
+
+    import numpy as np
     from nipype.utils.filemanip import fname_presuffix
+    from nitransforms.linear import LinearTransformsMapping
 
-    out = fname_presuffix(
-        in_file, suffix="_reference", newpath=str(Path.cwd().absolute())
-    )
+    out = fname_presuffix(in_file, suffix='_reference', newpath=str(Path.cwd().absolute()))
 
-    realigned = LinearTransformsMapping(np.array(in_xfm), reference=in_file).apply(
-        in_file
-    )
+    realigned = LinearTransformsMapping(np.array(in_xfm), reference=in_file).apply(in_file)
 
     data = np.asanyarray(realigned.dataobj).mean(-1)
 
diff --git a/tools/cache_templateflow.py b/tools/cache_templateflow.py
index 814b56169d..f992308841 100644
--- a/tools/cache_templateflow.py
+++ b/tools/cache_templateflow.py
@@ -7,6 +7,6 @@
 # ///
 from templateflow import api as tfapi
 
-tfapi.get("MNI152NLin2009cAsym", resolution=2, desc="brain", suffix="mask")
-tfapi.get("MNI152NLin2009cAsym", resolution=1, label="brain", suffix="probseg")
-tfapi.get("MNI152NLin2009cAsym", resolution=2, desc="fMRIPrep", suffix="boldref")
+tfapi.get('MNI152NLin2009cAsym', resolution=2, desc='brain', suffix='mask')
+tfapi.get('MNI152NLin2009cAsym', resolution=1, label='brain', suffix='probseg')
+tfapi.get('MNI152NLin2009cAsym', resolution=2, desc='fMRIPrep', suffix='boldref')