diff --git a/bootstrap.py b/bootstrap.py
index e6b4208..71b28a8 100755
--- a/bootstrap.py
+++ b/bootstrap.py
@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 """
 Bootstrap helps you to test scripts without installing them
 by patching your PYTHONPATH on the fly
@@ -10,20 +9,21 @@
 __authors__ = ["Frédéric-Emmanuel Picca", "Jérôme Kieffer"]
 __contact__ = "jerome.kieffer@esrf.eu"
 __license__ = "MIT"
-__date__ = "12/07/2024"
+__date__ = "02/09/2026"
 
-import sys
+import argparse
+import logging
 import os
 import subprocess
-import logging
-if sys.version_info[:2] < (3, 11):
-    import tomli
-else:
+import sys
+
+try:
     import tomllib as tomli
+except ImportError:
+    import tomli
 logging.basicConfig()
 logger = logging.getLogger("bootstrap")
 
-LIBPATH = ""
 
 def get_project_name(root_dir):
     """Retrieve project name by running python setup.py --name in root_dir.
@@ -50,9 +50,10 @@ def build_project(name, root_dir):
         libdir = "Lib"
         # extra = ["--buildtype", "plain"]
 
-    build = os.path.join(root_dir, "build")
+    build_dir = f"build_py{sys.version_info[0]}{sys.version_info[1]}"
+    build = os.path.join(root_dir, build_dir)
     if not(os.path.isdir(build) and os.path.isdir(os.path.join(build, name))):
-        p = subprocess.Popen(["meson", "setup", "build"],
+        p = subprocess.Popen(["meson", "setup", build_dir],
                          shell=False, cwd=root_dir, env=os.environ)
         p.wait()
     p = subprocess.Popen(["meson", "configure", "--prefix", "/"] + extra,
@@ -77,12 +78,14 @@ def build_project(name, root_dir):
                 home = os.path.join(build, libdir, python_version, "site-packages")
             home = os.path.abspath(home)
 
-    cnt = 0
+    tmp = []
     while not os.path.isdir(home):
-        cnt += 1
-        home = os.path.split(home)[0]
-    for _ in range(cnt):
-        n = os.listdir(home)[0]
+        home, last = os.path.split(home)
+        tmp.append(last)
+    for _ in tmp:
+        for n in os.listdir(home):
+            if os.path.isdir(os.path.join(home, n)):
+                break
         home = os.path.join(home, n)
 
     logger.warning("Building %s to %s", name, home)
@@ -98,7 +101,7 @@ def execfile(fullpath, globals=None, locals=None):
         except UnicodeDecodeError:
             raise SyntaxError("Not a Python script")
         code = compile(data, fullpath, 'exec')
-        exec(code, globals, locals)
+        exec(code, globals, locals)  # noqa: S102
 
 
 def run_file(filename, argv):
@@ -117,14 +120,14 @@ def run_file(filename, argv):
         # Providing globals() as locals will force to feed the file into
         # globals() (for examples imports).
         # Without this any function call from the executed file loses imports
-        old_argv = sys.argv
-        sys.argv = full_args
-        logger.info("Patch the sys.argv: %s", sys.argv)
-        logger.info("Executing %s.main()", filename)
-        print("########### EXECFILE ###########")
-        module_globals = globals().copy()
-        module_globals['__file__'] = filename
         try:
+            old_argv = sys.argv
+            sys.argv = full_args
+            logger.info("Patch the sys.argv: %s", sys.argv)
+            logger.info("Executing %s.main()", filename)
+            print("########### EXECFILE ###########")
+            module_globals = globals().copy()
+            module_globals['__file__'] = filename
             execfile(filename, module_globals, module_globals)
         finally:
             sys.argv = old_argv
@@ -155,10 +158,10 @@ def run_entry_point(target_name, entry_point, argv):
     logger.info("Execute target %s (function %s from module %s) using importlib", target_name, function_name, module_name)
     full_args = [target_name]
     full_args.extend(argv)
-    old_argv = sys.argv
-    sys.argv = full_args
-    print("########### IMPORTLIB ###########")
     try:
+        old_argv = sys.argv
+        sys.argv = full_args
+        print("########### IMPORTLIB ###########")
         module = importlib.import_module(module_name)
         if hasattr(module, function_name):
             func = getattr(module, function_name)
@@ -177,7 +180,7 @@ def find_executable(target):
     - Then search the script from the PATH environment variable.
 
     :param str target: Name of the script
-    :returns: Returns a tuple: kind, name.
+    :returns: Returns a tuple: (kind, name) or (kind, name, entry_point).
     """
     if os.path.isfile(target):
         return ("path", os.path.abspath(target))
@@ -192,50 +195,95 @@ def find_executable(target):
 
     for script, entry_point in scripts.items():
         if script == target:
-            print(script, entry_point)
+            #print(script, entry_point)
             return ("entry_point", target, entry_point)
     return None, None
 
 
-PROJECT_DIR = os.path.dirname(os.path.abspath(__file__))
-PROJECT_NAME = get_project_name(PROJECT_DIR)
-logger.info("Project name: %s", PROJECT_NAME)
-
-if __name__ == "__main__":
-    LIBPATH = build_project(PROJECT_NAME, PROJECT_DIR)
-    if len(sys.argv) < 2:
-        logger.warning("usage: ./bootstrap.py <script>\n")
-        script = None
-    else:
-        script = sys.argv[1]
-
-    if script:
-        logger.info("Executing %s from source checkout", script)
-    else:
-        logging.info("Running iPython by default")
-    sys.path.insert(0, LIBPATH)
-    logger.info("Patched sys.path with %s", LIBPATH)
-
-    if script:
-        argv = sys.argv[2:]
+def main(argv):
+    parser = argparse.ArgumentParser(
+        prog="bootstrap", usage="./bootstrap.py <script>", description=__doc__
+    )
+    parser.add_argument("script", nargs=argparse.REMAINDER)
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument(
+        "-m",
+        nargs=argparse.REMAINDER,
+        dest="module",
+        help="run library module as a script (terminates option list)",
+    )
+    # group.add_argument(
+    #     "-j",
+    #     "--jupyter",
+    #     action="store_true",
+    #     help="Start jupyter notebook rather than IPython console",
+    # )
+    options = parser.parse_args()
+
+    # if options.jupyter:
+    #     if options.script:
+    #         logger.error("-j, --jupyter is mutually exclusive with other options")
+    #         parser.print_help()
+    #         return
+
+    #     logger.info("Start Jupyter notebook")
+    #     from notebook.notebookapp import main as notebook_main
+
+    #     os.environ["PYTHONPATH"] = (
+    #         LIBPATH + os.pathsep + os.environ.get("PYTHONPATH", "")
+    #     )
+    #     notebook_main(argv=[])
+
+    if options.script:
+        logger.info("Executing %s from source checkout", options.script)
+        script = options.script[0]
+        argv = options.script[1:]
         res = find_executable(script)
-        if res[0] == "path":
+        kind = res[0]
+        # print(res)
+        if kind == "path":
             run_file(res[1], argv)
-        elif res[0] == "entry_point":
+        elif kind == "entry_point":
             run_entry_point(res[1], res[2], argv)
         else:
-            logger.error("Script %s not found", script)
+            logger.error("Script %s not found", options.script)
+
+    elif options.module:
+        logger.info("Running module %s", options.module)
+        import runpy
+
+        module = options.module[0]
+        try:
+            old = sys.argv
+            sys.argv = [None] + options.module[1:]
+            runpy.run_module(module, run_name="__main__", alter_sys=True)
+        finally:
+            sys.argv = old
+
     else:
-        logging.info("Running IPython by default")
-        logger.info("Patch the sys.argv: %s", sys.argv)
-        sys.path.insert(2, "")
+        logger.info("Running IPython by default")
         try:
-            from IPython import embed
-        except Exception as err:
+            from IPython import start_ipython
+        except ImportError as err:
             logger.error("Unable to execute iPython, using normal Python")
             logger.error(err)
             import code
             code.interact()
         else:
-            embed()
+            start_ipython(argv=[])
+
+
+PROJECT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_NAME = get_project_name(PROJECT_DIR)
+logger.info("Project name: %s", PROJECT_NAME)
+
+
+if __name__ == "__main__":
+    home = os.path.dirname(os.path.abspath(__file__))
+    LIBPATH = build_project(PROJECT_NAME, PROJECT_DIR)
+
+
+    sys.path.insert(0, LIBPATH)
+    logger.info("Patched sys.path with %s", LIBPATH)
 
+    main(sys.argv)
diff --git a/e2etest/e2etest_bift.py b/e2etest/e2etest_bift.py
index ec077d9..f9c60d6 100644
--- a/e2etest/e2etest_bift.py
+++ b/e2etest/e2etest_bift.py
@@ -2,11 +2,13 @@
 
 __authors__ = ["Martha Brennich"]
 __license__ = "MIT"
-__date__ = "29/11/2023"
+__date__ = "02/09/2026"
 
 import unittest
 import pathlib
 import logging
+import shutil
+import tempfile
 from platform import system
 from subprocess import run, PIPE, STDOUT
 from os import linesep
@@ -27,15 +29,28 @@
 class TestBIFT(unittest.TestCase):
     """End to end tests for free_bift"""
 
-    cwd = pathlib.Path.cwd()
     test_location = pathlib.Path(__file__)
     test_data_location = pathlib.Path(test_location.parent, "e2etest_data")
     bsa_filename = pathlib.Path(get_datafile("bsa_005_sub.dat"))
     sas_curve2_filename = pathlib.Path(get_datafile("SASDF52.dat"))
     SASDFX7 = pathlib.Path(get_datafile("SASDFX7.dat"))
-    expected_outfile_name_bsa = pathlib.Path(
-        cwd, bsa_filename.name
-    ).with_suffix(".out")
+
+    @classmethod
+    def setUpClass(cls):
+        """Send the output to a directory of our own, so that neither the
+        current directory nor the directory holding the downloaded test data
+        gets polluted."""
+        super().setUpClass()
+        cls.output_dir = pathlib.Path(tempfile.mkdtemp(prefix="e2etest_bift_"))
+        cls.output_template = str(cls.output_dir / "{basename}.out")
+        cls.expected_outfile_name_bsa = pathlib.Path(
+            cls.output_dir, cls.bsa_filename.name
+        ).with_suffix(".out")
+
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls.output_dir, ignore_errors=True)
+        super().tearDownClass()
 
     def __init__(self, testName, **extra_kwargs):
         super().__init__(testName)
@@ -61,7 +76,12 @@ def test_bm29_bsa_without_arguments_creates_out_file(self):
         """
 
         run_app = run(
-            [free_bift, normpath(str(self.bsa_filename))],
+            [
+                free_bift,
+                "--output",
+                self.output_template,
+                normpath(str(self.bsa_filename)),
+            ],
             stdout=PIPE,
             stderr=STDOUT,
             check=True,
@@ -80,7 +100,12 @@ def test_bm29_bsa_out_file_has_the_expected_format(self):
         """
 
         _ = run(
-            [free_bift, normpath(str(self.bsa_filename))],
+            [
+                free_bift,
+                "--output",
+                self.output_template,
+                normpath(str(self.bsa_filename)),
+            ],
             stdout=PIPE,
             stderr=STDOUT,
             check=True,
@@ -153,7 +178,12 @@ def test_bm29_bsa_result_numerically_matches_expectations(self):
         """
 
         run_app_ = run(
-            [free_bift, normpath(str(self.bsa_filename))],
+            [
+                free_bift,
+                "--output",
+                self.output_template,
+                normpath(str(self.bsa_filename)),
+            ],
             stdout=PIPE,
             stderr=STDOUT,
             check=True,
@@ -213,7 +243,12 @@ def test_free_bift_outputs_one_line_summary(self):
         """
 
         run_app = run(
-            [free_bift, normpath(str(self.bsa_filename))],
+            [
+                free_bift,
+                "--output",
+                self.output_template,
+                normpath(str(self.bsa_filename)),
+            ],
             stdout=PIPE,
             stderr=STDOUT,
             check=True,
@@ -224,7 +259,8 @@ def test_free_bift_outputs_one_line_summary(self):
         else:
             run_app_output = str(run_app.stdout, encoding="utf-8")[:-1]
         run_app_output_parsed = parse.parse(
-            "bsa_005_sub.out: Dmax= {Dmax}±{Dmax_err}; 𝛂= {alpha}±{alpha_err}; S₀= {S0}±{S0_err}; χ²= {chi_squared}±{chi_squared_err}; logP= {logP}±{logP_err}; Rg= {Rg}±{Rg_err}; I₀= {I0}±{I0_err}",
+            str(self.expected_outfile_name_bsa)
+            + ": Dmax= {Dmax}±{Dmax_err}; 𝛂= {alpha}±{alpha_err}; S₀= {S0}±{S0_err}; χ²= {chi_squared}±{chi_squared_err}; logP= {logP}±{logP_err}; Rg= {Rg}±{Rg_err}; I₀= {I0}±{I0_err}",
             run_app_output,
         )
         self.assertListEqual(
@@ -254,7 +290,12 @@ def test_free_bift_values_of_one_line_summary_match_expectations(self):
         """
 
         run_app = run(
-            [free_bift, normpath(str(self.bsa_filename))],
+            [
+                free_bift,
+                "--output",
+                self.output_template,
+                normpath(str(self.bsa_filename)),
+            ],
             stdout=PIPE,
             stderr=STDOUT,
             check=True,
@@ -265,7 +306,8 @@ def test_free_bift_values_of_one_line_summary_match_expectations(self):
         else:
             run_app_output = str(run_app.stdout, encoding="utf-8")[:-1]
         run_app_output_parsed = parse.parse(
-            "bsa_005_sub.out: Dmax= {Dmax}±{Dmax_err}; 𝛂= {alpha}±{alpha_err}; S₀= {S0}±{S0_err}; χ²= {chi_squared}±{chi_squared_err}; logP= {logP}±{logP_err}; Rg= {Rg}±{Rg_err}; I₀= {I0}±{I0_err}",
+            str(self.expected_outfile_name_bsa)
+            + ": Dmax= {Dmax}±{Dmax_err}; 𝛂= {alpha}±{alpha_err}; S₀= {S0}±{S0_err}; χ²= {chi_squared}±{chi_squared_err}; logP= {logP}±{logP_err}; Rg= {Rg}±{Rg_err}; I₀= {I0}±{I0_err}",
             run_app_output,
         )
         self.assertAlmostEqual(
diff --git a/pyproject.toml b/pyproject.toml
index 67a78eb..c7ed463 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -74,3 +74,17 @@ free_dnn = 'freesas.app.dnn:main'
 [project.gui-scripts]
 freesas = 'freesas.app.plot_sas:main'
 
+
+[tool.cibuildwheel]
+# Skip 32-bit builds and PyPy
+skip = ["*-win32", "*-manylinux_i686", "pp*", "*musllinux*"]
+
+[tool.coverage.run]
+branch = true
+
+[tool.coverage.report]
+
+ignore_errors = true
+
+[tool.coverage.html]
+directory = "coverage_html_report"
diff --git a/run_tests.py b/run_tests.py
index ca697bc..c4997a5 100755
--- a/run_tests.py
+++ b/run_tests.py
@@ -2,7 +2,7 @@
 # coding: utf-8
 # /*##########################################################################
 #
-# Copyright (C) 2015-2023 European Synchrotron Radiation Facility
+# Copyright (C) 2015-2026 European Synchrotron Radiation Facility
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -32,7 +32,7 @@
 """
 
 __authors__ = ["Jérôme Kieffer", "Thomas Vincent"]
-__date__ = "29/11/2023"
+__date__ = "20/08/2026"
 __license__ = "MIT"
 
 import sys
@@ -44,6 +44,7 @@
 import unittest
 import collections
 import tempfile
+import platform
 
 
 class StreamHandlerUnittestReady(logging.StreamHandler):
@@ -505,7 +506,7 @@ def get_test_options(project_module):
 if options.coverage:
     cov.stop()
     cov.save()
-    with open("coverage.rst", "w") as fn:
+    with open("coverage.rst", "w", encoding="utf-8") as fn:
         fn.write(report_rst(cov, PROJECT_NAME, PROJECT_VERSION, PROJECT_PATH))
     print(cov.report())
     print("")
diff --git a/src/freesas/__init__.py b/src/freesas/__init__.py
index 80b7c1f..73a60e6 100644
--- a/src/freesas/__init__.py
+++ b/src/freesas/__init__.py
@@ -1,4 +1,3 @@
-# coding: utf-8
 # /*##########################################################################
 #
 # Copyright (c) 2015-2023 European Synchrotron Radiation Facility
@@ -22,14 +21,14 @@
 # THE SOFTWARE.
 #
 # ###########################################################################*/
-""" """
+"""Small angle scattering tools, free and written in Python."""
 
 __authors__ = ["Jérôme Kieffer"]
 __license__ = "MIT"
 __date__ = "06/02/2026"
 
-import os as _os
 import logging as _logging
+import os as _os
 
 _logging.getLogger(__name__).addHandler(_logging.NullHandler())
 
@@ -48,5 +47,5 @@
     )
 except ImportError:
     raise RuntimeError(
-        "Do NOT use %s from its sources: build it and use the built version" % project
+        f"Do NOT use {project} from its sources: build it and use the built version"
     )
diff --git a/src/freesas/align.py b/src/freesas/align.py
index 84aa075..0c85407 100644
--- a/src/freesas/align.py
+++ b/src/freesas/align.py
@@ -2,17 +2,19 @@
 __license__ = "MIT"
 __copyright__ = "2015, ESRF"
 
+import itertools
+import logging
 import os
 import sys
-import numpy
+
 import matplotlib
 
 # matplotlib.use('Agg')
 import matplotlib.pyplot as plt
-from freesas.model import SASModel
-import itertools
+import numpy
 from scipy.optimize import fmin
-import logging
+
+from freesas.model import SASModel
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("log_freesas")
@@ -27,7 +29,7 @@ def __init__(self):
         self.validmodels = []
 
     def __repr_(self):
-        return "Preparation of %s models for alignment" % len(self.inputfiles)
+        return f"Preparation of {len(self.inputfiles)} models for alignment"
 
     def assign_models(self, molecule=None):
         """
@@ -50,8 +52,7 @@ def assign_models(self, molecule=None):
                 self.sasmodels.append(model)
             if len(self.inputfiles) != len(self.sasmodels):
                 logger.error(
-                    "Problem of assignment\n%s models for %s files"
-                    % (len(self.sasmodels), len(self.inputfiles))
+                    f"Problem of assignment\n{len(self.sasmodels)} models for {len(self.inputfiles)} files"
                 )
 
         elif len(molecule) != 0:
@@ -140,14 +141,14 @@ def rfactorplot(self, filename=None, save=False):
             [0.5, dammif_files + 0.5],
             [Rmax, Rmax],
             "-r",
-            label="R$_{max}$ = %.3f" % Rmax,
+            label=f"R$_{{max}}$ = {Rmax:.3f}",
         )
         ax2.set_ylabel("R factor in percent")
         ax2.set_xticks(xticks)
         ax2.set_xticklabels(labels, rotation=90)
         ax2.legend(loc=8)
 
-        bbox_props = dict(fc="pink", ec="r", lw=1)
+        bbox_props = {"fc": "pink", "ec": "r", "lw": 1}
         for i in range(dammif_files):
             if not self.validmodels[i]:
                 ax2.text(
@@ -160,7 +161,7 @@ def rfactorplot(self, filename=None, save=False):
                     size=10,
                     bbox=bbox_props,
                 )
-                logger.info("model %s discarded, Rfactor > Rmax" % self.inputfiles[i])
+                logger.info(f"model {self.inputfiles[i]} discarded, Rfactor > Rmax")
 
         if save:
             fig.savefig(filename)
@@ -191,7 +192,7 @@ def __init__(self, files, slow=True, enantiomorphs=True):
         self.reference = None
 
     def __repr__(self):
-        return "alignment process for %s models" % len(self.models)
+        return f"alignment process for {len(self.models)} models"
 
     def assign_models(self):
         """
@@ -209,8 +210,7 @@ def assign_models(self):
             self.models.append(model)
         if len(self.inputfiles) != len(self.models):
             logger.error(
-                "Problem of assignment\n%s models for %s files"
-                % (len(self.models), len(self.inputfiles))
+                f"Problem of assignment\n{len(self.models)} models for {len(self.inputfiles)} files"
             )
 
         return self.models
@@ -225,7 +225,7 @@ def optimize(self, reference, molecule, symmetry):
         :return p: transformation parameters optimized
         :return dist: NSD after optimization
         """
-        p, dist, niter, nfuncalls, warmflag = fmin(
+        p, dist, niter, _nfuncalls, _warmflag = fmin(
             reference.dist_after_movement,
             molecule.can_param,
             args=(molecule, symmetry),
@@ -237,7 +237,7 @@ def optimize(self, reference, molecule, symmetry):
         if niter == 200:
             logger.debug("convergence not reached")
         else:
-            logger.debug("convergence reach after %s iterations" % niter)
+            logger.debug(f"convergence reach after {niter} iterations")
         return p, dist
 
     def alignment_sym(self, reference, molecule):
@@ -365,7 +365,7 @@ def plotNSDarray(self, rmax=None, filename=None, save=False):
                     ax1.text(
                         i,
                         j,
-                        "%.2f" % nsd,
+                        f"{nsd:.2f}",
                         ha="center",
                         va="center",
                         size=12 * 8 // dammif_files,
@@ -373,7 +373,7 @@ def plotNSDarray(self, rmax=None, filename=None, save=False):
                     ax1.text(
                         j,
                         i,
-                        "%.2f" % nsd,
+                        f"{nsd:.2f}",
                         ha="center",
                         va="center",
                         size=12 * 8 // dammif_files,
@@ -405,13 +405,13 @@ def plotNSDarray(self, rmax=None, filename=None, save=False):
             [0.5, dammif_files + 0.5],
             [nsd_max, nsd_max],
             "-r",
-            label="NSD$_{max}$ = %.2f" % nsd_max,
+            label=f"NSD$_{{max}}$ = {nsd_max:.2f}",
         )
         ax2.set_title("NSD between any model and all others")
         ax2.set_ylabel("Normalized Spatial Discrepancy")
         ax2.set_xticks(xticks)
         ax2.set_xticklabels(labels, rotation=90)
-        bbox_props = dict(fc="cyan", ec="b", lw=1)
+        bbox_props = {"fc": "cyan", "ec": "b", "lw": 1}
         ax2.text(
             self.reference + 0.95,
             data[self.reference] / 2,
@@ -424,7 +424,7 @@ def plotNSDarray(self, rmax=None, filename=None, save=False):
         )
         ax2.legend(loc=8)
 
-        bbox_props = dict(fc="pink", ec="r", lw=1)
+        bbox_props = {"fc": "pink", "ec": "r", "lw": 1}
         valid_number = 0
         for i in range(dammif_files):
             if data[i] > nsd_max:
@@ -438,14 +438,13 @@ def plotNSDarray(self, rmax=None, filename=None, save=False):
                     size=10,
                     bbox=bbox_props,
                 )
-                logger.debug("model %s discarded, nsd > nsd_max" % self.inputfiles[i])
+                logger.debug(f"model {self.inputfiles[i]} discarded, nsd > nsd_max")
             elif not valid_models[i]:
                 if rmax:
                     ax2.text(
                         i + 0.95,
                         data[self.reference] / 2,
-                        "Discarded, Rfactor = %s > Rmax = %s"
-                        % (100.0 * self.models[i].rfactor, rmax),
+                        f"Discarded, Rfactor = {100.0 * self.models[i].rfactor} > Rmax = {rmax}",
                         ha="center",
                         va="center",
                         rotation=90,
@@ -467,7 +466,7 @@ def plotNSDarray(self, rmax=None, filename=None, save=False):
                 if valid_models[i] == 1.0:
                     valid_number += 1
 
-        logger.debug("%s valid models" % valid_number)
+        logger.debug(f"{valid_number} valid models")
 
         if save:
             fig.savefig(filename)
@@ -515,7 +514,7 @@ def alignment_reference(self, ref_number=None):
                 molecule = models[i]
                 symmetry, p = self.alignment_sym(reference, molecule)
                 if not self.slow:
-                    p, dist = self.optimize(reference, molecule, symmetry)
+                    p, _dist = self.optimize(reference, molecule, symmetry)
                 molecule.atoms = molecule.transform(
                     p, symmetry
                 )  # molecule sent on its canonical position
diff --git a/src/freesas/app/__init__.py b/src/freesas/app/__init__.py
index 4776656..392040b 100644
--- a/src/freesas/app/__init__.py
+++ b/src/freesas/app/__init__.py
@@ -1,4 +1,3 @@
-# coding: utf-8
 # /*##########################################################################
 #
 # Copyright (c) 2016-2018 European Synchrotron Radiation Facility
diff --git a/src/freesas/app/auto_gpa.py b/src/freesas/app/auto_gpa.py
index 666afc9..a5ee36c 100644
--- a/src/freesas/app/auto_gpa.py
+++ b/src/freesas/app/auto_gpa.py
@@ -1,5 +1,3 @@
-#!/usr/bin/python3
-# coding: utf-8
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -29,17 +27,15 @@
 __copyright__ = "2021, ESRF"
 __date__ = "19/03/2021"
 
-import sys
 import logging
+
 from freesas.autorg import auto_gpa
-from freesas.sas_argparser import GuinierParser
 from freesas.fitting import run_guinier_fit
+from freesas.sas_argparser import GuinierParser
 
 logging.basicConfig(level=logging.WARNING)
 logger = logging.getLogger("auto_gpa")
 
-if sys.version_info < (3, 6):
-    logger.error("This code uses F-strings and requires Python 3.6+")
 
 
 def build_parser() -> GuinierParser:
diff --git a/src/freesas/app/auto_guinier.py b/src/freesas/app/auto_guinier.py
index b435c97..aea9ee6 100644
--- a/src/freesas/app/auto_guinier.py
+++ b/src/freesas/app/auto_guinier.py
@@ -1,5 +1,3 @@
-#!/usr/bin/python3
-# coding: utf-8
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -29,17 +27,15 @@
 __copyright__ = "2021, ESRF"
 __date__ = "19/03/2021"
 
-import sys
 import logging
+
 from freesas.autorg import auto_guinier
-from freesas.sas_argparser import GuinierParser
 from freesas.fitting import run_guinier_fit
+from freesas.sas_argparser import GuinierParser
 
 logging.basicConfig(level=logging.WARNING)
 logger = logging.getLogger("auto_guinier")
 
-if sys.version_info < (3, 6):
-    logger.error("This code uses F-strings and requires Python 3.6+")
 
 
 def build_parser() -> GuinierParser:
diff --git a/src/freesas/app/autorg.py b/src/freesas/app/autorg.py
index 6190b74..38e9eba 100644
--- a/src/freesas/app/autorg.py
+++ b/src/freesas/app/autorg.py
@@ -1,5 +1,3 @@
-#!/usr/bin/python3
-# coding: utf-8
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -29,17 +27,15 @@
 __copyright__ = "2021, ESRF"
 __date__ = "19/03/2021"
 
-import sys
 import logging
+
 from freesas.autorg import autoRg
-from freesas.sas_argparser import GuinierParser
 from freesas.fitting import run_guinier_fit
+from freesas.sas_argparser import GuinierParser
 
 logging.basicConfig(level=logging.WARNING)
 logger = logging.getLogger("auto_gpa")
 
-if sys.version_info < (3, 6):
-    logger.error("This code uses F-strings and requires Python 3.6+")
 
 
 def build_parser() -> GuinierParser:
diff --git a/src/freesas/app/bift.py b/src/freesas/app/bift.py
index a77e00f..b2ca749 100644
--- a/src/freesas/app/bift.py
+++ b/src/freesas/app/bift.py
@@ -1,5 +1,3 @@
-#!/usr/bin/python3
-# coding: utf-8
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -27,26 +25,38 @@
 __author__ = "Jérôme Kieffer"
 __license__ = "MIT"
 __copyright__ = "2017-2026, ESRF"
-__date__ = "06/02/2026"
+__date__ = "02/09/2026"
 
-import sys
+import io
 import logging
 import platform
+import sys
 import traceback
+
 from freesas import bift
-from freesas.sasio import (
-    load_scattering_data,
-    convert_inverse_angstrom_to_nanometer,
+from freesas.autorg import (
+    InsufficientDataError,
+    NoGuinierRegionError,
 )
-from freesas.sas_argparser import SASParser
 from freesas.fitting import (
-    set_logging_level,
     collect_files,
+    set_logging_level,
+)
+from freesas.sas_argparser import (
+    SASParser,
+    check_output_template,
+    format_output_filename,
+)
+from freesas.sasio import (
+    convert_inverse_angstrom_to_nanometer,
+    load_scattering_data,
 )
 
 logging.basicConfig(level=logging.WARNING)
 logger = logging.getLogger("bift")
 
+DEFAULT_OUTPUT_TEMPLATE = "{dirname}/{basename}.out"
+
 
 def build_parser() -> SASParser:
     """Build parser for input and return list of files.
@@ -70,7 +80,7 @@ def build_parser() -> SASParser:
     """
     parser = SASParser(prog="free_bift", description=description, epilog=epilog)
     parser.add_file_argument(help_text="I(q) files to convert into p(r)")
-    parser.add_output_filename_argument()
+    parser.add_output_template_argument(DEFAULT_OUTPUT_TEMPLATE)
     parser.add_q_unit_argument()
     parser.add_argument(
         "-n",
@@ -106,25 +116,35 @@ def build_parser() -> SASParser:
 def main():
     """Entry point for bift app."""
     if platform.system() == "Windows":
-        sys.stdout = open(1, "w", encoding="utf-16", closefd=False)
+        sys.stdout = io.TextIOWrapper(
+            sys.stdout.buffer, encoding="utf-16", write_through=True
+        )
 
     parser = build_parser()
     args = parser.parse_args()
     set_logging_level(args.verbose)
+    check_output_template(args.output)
     files = collect_files(args.file)
 
     for afile in files:
         try:
             data = load_scattering_data(afile)
-        except Exception:
+        except OSError:
+            logger.error("Unable to read file %s", afile)
+        except ValueError:
             logger.error("Unable to parse file %s", afile)
         else:
             if args.unit == "Å":
                 data = convert_inverse_angstrom_to_nanometer(data)
             try:
                 bo = bift.auto_bift(data, npt=args.npt, scan_size=args.scan)
-            except Exception as err:
-                print("%s: %s %s" % (afile, err.__class__.__name__, err))
+            except (
+                InsufficientDataError,
+                NoGuinierRegionError,
+                ValueError,
+                IndexError,
+            ) as err:
+                print(f"{afile}: {err.__class__.__name__} {err}")
                 if logging.root.level < logging.WARNING:
                     traceback.print_exc(file=sys.stdout)
             else:
@@ -133,11 +153,11 @@ def main():
                         args.mc, args.threshold, npt=args.npt
                     )
                 except RuntimeError as err:
-                    print("%s: %s %s" % (afile, err.__class__.__name__, err))
+                    print(f"{afile}: {err.__class__.__name__} {err}")
                     if logging.root.level < logging.WARNING:
                         traceback.print_exc(file=sys.stdout)
                 else:
-                    dest = afile.stem + ".out"
+                    dest = format_output_filename(args.output, afile, mkdir=True)
                     print(stats.save(dest, source=afile))
 
 
diff --git a/src/freesas/app/cormap.py b/src/freesas/app/cormap.py
index 82e5a7f..4ef6a3c 100644
--- a/src/freesas/app/cormap.py
+++ b/src/freesas/app/cormap.py
@@ -1,20 +1,18 @@
-#!/usr/bin/python3
-# coding: utf-8
-
 __author__ = "Jérôme Kieffer"
 __license__ = "MIT"
 __copyright__ = "2015, ESRF"
 __date__ = "06/02/2026"
 
-import os
-import logging
 import glob
+import logging
+import os
 import platform
-from itertools import combinations
 from collections import namedtuple
+from itertools import combinations
+
 from freesas.cormap import gof
-from freesas.sasio import load_scattering_data
 from freesas.sas_argparser import SASParser
+from freesas.sasio import load_scattering_data
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("cormap")
@@ -46,7 +44,7 @@ def parse():
         files = glob.glob(args.file[0])
         files.sort()
     input_len = len(files)
-    logger.debug("%s input files" % input_len)
+    logger.debug(f"{input_len} input files")
     return files
 
 
@@ -67,10 +65,12 @@ def compare(lstfiles):
         data.append(d)
     for a, b in combinations(data, 2):
         r = gof(a.data, b.data)
-        res.append("%6i vs. %6i          %6i     %8.6f" % (a.index, b.index, r.c, r.P))
+        res.append(
+            f"{a.index:6d} vs. {b.index:6d}          {r.c:6d}     {r.P:8.6f}"
+        )
     res.append("")
     for a in data:
-        res.append("%6i         %8f + %8f * %s" % (a.index, 0.0, 1.0, a.filename))
+        res.append(f"{a.index:6d}         {0.0:8f} + {1.0:8f} * {a.filename}")
     res.append("")
     print(os.linesep.join(res))
     return res
diff --git a/src/freesas/app/dnn.py b/src/freesas/app/dnn.py
index fb58cf7..d7f6e55 100644
--- a/src/freesas/app/dnn.py
+++ b/src/freesas/app/dnn.py
@@ -1,5 +1,3 @@
-#!/usr/bin/python3
-# coding: utf-8
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -29,16 +27,14 @@
 __copyright__ = "2024, ESRF"
 __date__ = "11/09/2024"
 
-import sys
 import logging
-from freesas.sas_argparser import SASParser
+
 from freesas.fitting import run_dnn
+from freesas.sas_argparser import SASParser
 
 logging.basicConfig(level=logging.WARNING)
 logger = logging.getLogger("free_dnn")
 
-if sys.version_info < (3, 6):
-    logger.error("This code uses F-strings and requires Python 3.6+")
 
 
 def build_parser() -> SASParser:
diff --git a/src/freesas/app/extract_ascii.py b/src/freesas/app/extract_ascii.py
index d859e76..f5d767a 100644
--- a/src/freesas/app/extract_ascii.py
+++ b/src/freesas/app/extract_ascii.py
@@ -1,5 +1,3 @@
-#!/usr/bin/python3
-# coding: utf-8
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -29,32 +27,49 @@
 __copyright__ = "2020-2026, ESRF"
 __date__ = "06/02/2026"
 
+import copy
+import glob
 import io
-import os
-import sys
+import json
 import logging
-import glob
+import os
 import platform
 import posixpath
-from collections import namedtuple, OrderedDict
-import json
+import sys
 import zipfile
-import copy
+from collections import OrderedDict, namedtuple
+
 import pyFAI
 from pyFAI.io import Nexus
-from freesas.sas_argparser import SASParser
+
+from freesas.sas_argparser import (
+    SASParser,
+    check_output_template,
+    format_output_filename,
+)
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("extract_ascii")
 
-if sys.version_info[0] < 3:
-    logger.error("This code requires Python 3.4+")
 
 NexusJuice = namedtuple(
     "NexusJuice",
     "filename h5path npt unit q I poni mask energy polarization signal2d error2d buffer concentration",
 )
 
+class AnyIndex(str):
+    """String which accepts any format specification, used to display the
+    pattern of the generated file names, i.e. sample_*.dat"""
+
+    def __format__(self, format_spec):
+        return str(self)
+
+
+#: Default output templates, one per extraction mode
+DEFAULT_OUTPUT_TEMPLATE = "{dirname}/{basename}.dat"
+DEFAULT_ALL_OUTPUT_TEMPLATE = "{dirname}/{basename}_{index:04d}.dat"
+DEFAULT_ZIP_OUTPUT_TEMPLATE = "{dirname}/{basename}.zip"
+
 
 def parse():
     """Parse input and return list of files.
@@ -65,7 +80,6 @@ def parse():
     """
     parser = SASParser(prog="extract-ascii.py", description=description, epilog=epilog)
     # Commented option need to be implemented
-    # parser.add_argument("-o", "--output", action='store', help="Output filename, by default the same with .dat extension", default=None, type=str)
     # parser.add_argument("-u", "--unit", action='store', help="Unit for q: inverse nm or Angstrom?", default="nm", type=str)
     # parser.add_argument("-n", "--normalize", action='store', help="Re-normalize all intensities with this factor ", default=1.0, type=float)
     parser.add_file_argument("HDF5 input data")
@@ -83,6 +97,15 @@ def parse():
         help="extract every individual frame into a zip-file",
         default=False,
     )
+    # the actual default depends on the extraction mode, main() picks it
+    parser.add_output_template_argument(
+        None,
+        extra_fields={"index": "number of the frame, only used with --all"},
+        described_default=(
+            f"{DEFAULT_OUTPUT_TEMPLATE}, {DEFAULT_ALL_OUTPUT_TEMPLATE} with "
+            f"--all, {DEFAULT_ZIP_OUTPUT_TEMPLATE} with --zip"
+        ),
+    )
     return parser.parse_args()
 
 
@@ -267,23 +290,23 @@ def write_ascii(results, output=None, hdr="#", linesep=os.linesep):
         headers.append(hdr + " " + results["comments"])
     else:
         headers.append(hdr)
-    headers.append(hdr + " Sample c= %s mg/ml" % results.get("concentration", -1))
+    headers.append(hdr + " Sample c= {} mg/ml".format(results.get("concentration", -1)))
     headers += [hdr, hdr + " Sample environment:"]
     if "geometry" in results:
-        headers.append(hdr + " Detector = %s" % results["geometry"]["detector"])
-        headers.append(hdr + " SampleDistance = %s" % results["geometry"]["dist"])
-        headers.append(hdr + " WaveLength = %s" % results["geometry"]["wavelength"])
+        headers.append(hdr + " Detector = {}".format(results["geometry"]["detector"]))
+        headers.append(hdr + " SampleDistance = {}".format(results["geometry"]["dist"]))
+        headers.append(hdr + " WaveLength = {}".format(results["geometry"]["wavelength"]))
     headers.append(hdr)
     if "comments" in results:
-        headers.append(hdr + " title = %s" % results["comment"])
+        headers.append(hdr + " title = {}".format(results["comment"]))
     if "to_merge" in results:
         headers.append(
             hdr + " Frames merged: " + " ".join([str(i) for i in results["to_merge"]])
         )
     if "normalization" in results:
-        headers.append(hdr + " Normalization = %s" % results["normalization"])
+        headers.append(hdr + " Normalization = {}".format(results["normalization"]))
     if "mask" in results:
-        headers.append(hdr + " Mask = %s" % results["mask"])
+        headers.append(hdr + " Mask = {}".format(results["mask"]))
     headers.append(hdr)
     headers.append(hdr + (" N 3" if "std" in results else " N 2"))
     line = hdr + " L "
@@ -302,19 +325,18 @@ def write_ascii(results, output=None, hdr="#", linesep=os.linesep):
     if "storage temperature" in results:
         headers.append(
             hdr
-            + " Storage Temperature (degrees C): %s" % results["storage temperature"]
+            + " Storage Temperature (degrees C): {}".format(results["storage temperature"])
         )
     if "exposure temperature" in results:
         headers.append(
             hdr
-            + " Measurement Temperature (degrees C): %s"
-            % results["exposure temperature"]
+            + " Measurement Temperature (degrees C): {}".format(results["exposure temperature"])
         )
 
-    headers.append(hdr + " Concentration: %s" % results.get("concentration", -1))
+    headers.append(hdr + " Concentration: {}".format(results.get("concentration", -1)))
     if "buffer" in results:
-        headers.append(hdr + " Buffer: %s" % results["buffer"])
-    headers.append(hdr + " Code: %s" % results.get("sample", ""))
+        headers.append(hdr + " Buffer: {}".format(results["buffer"]))
+    headers.append(hdr + " Code: {}".format(results.get("sample", "")))
 
     def write(headers, file_):
 
@@ -323,12 +345,12 @@ def write(headers, file_):
 
         if "std" in results:
             data = [
-                "%14.6e\t%14.6e\t%14.6e" % (q, intensity, std)
+                f"{q:14.6e}\t{intensity:14.6e}\t{std:14.6e}"
                 for q, intensity, std in zip(results["q"], results["I"], results["std"])
             ]
         else:
             data = [
-                "%14.6e\t%14.6e\t" % (q, intensity)
+                f"{q:14.6e}\t{intensity:14.6e}\t"
                 for q, intensity in zip(results["q"], results["I"])
             ]
         data.append("")
@@ -354,24 +376,40 @@ def main():
         files.sort()
     input_len = len(files)
     logger.debug("%s input files", input_len)
+
+    if args.output:
+        template = args.output
+    elif args.all:
+        template = DEFAULT_ALL_OUTPUT_TEMPLATE
+    elif args.zip:
+        template = DEFAULT_ZIP_OUTPUT_TEMPLATE
+    else:
+        template = DEFAULT_OUTPUT_TEMPLATE
+    check_output_template(template, index=0)
+    if args.all and "{index" not in template:
+        logger.warning(
+            "Output template %s has no {index} field: every frame of a given "
+            "file will be written to the same output file",
+            template,
+        )
+
     for src in files:
         print(f"{src} \t --> ", end="")
         if args.all:
-            dest = os.path.splitext(src)[0] + "_%04i.dat"
             for idx, frame in enumerate(extract_all(src)):
-                print(src, " --> ", dest % idx)
-                write_ascii(frame, dest % idx)
-            print(dest)
+                dest = format_output_filename(template, src, mkdir=True, index=idx)
+                print(src, " --> ", dest)
+                write_ascii(frame, dest)
+            print(format_output_filename(template, src, index=AnyIndex("*")))
         elif args.zip:
-            base = os.path.splitext(src)[0]
-            dest = base + ".zip"
-            destz = base + "_%04i.dat"
+            dest = format_output_filename(template, src, mkdir=True, index=0)
+            destz = os.path.splitext(src)[0] + "_%04i.dat"
             with zipfile.ZipFile(dest, "w") as z:
                 for idx, frame in enumerate(extract_all(src)):
                     z.writestr(destz % idx, write_ascii(frame))
             print(dest)
         else:
-            dest = os.path.splitext(src)[0] + ".dat"
+            dest = format_output_filename(template, src, mkdir=True, index=0)
             write_ascii(extract_averaged(src), dest)
             print(dest)
 
diff --git a/src/freesas/app/plot_sas.py b/src/freesas/app/plot_sas.py
index 9b5bb62..4c2f721 100644
--- a/src/freesas/app/plot_sas.py
+++ b/src/freesas/app/plot_sas.py
@@ -1,5 +1,3 @@
-#!/usr/bin/python3
-# coding: utf-8
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -31,24 +29,30 @@
 __copyright__ = "2020, ESRF"
 __date__ = "14/05/2020"
 
-import platform
 import logging
+import platform
 from pathlib import Path
-from matplotlib.pyplot import switch_backend
+
 from matplotlib.backends.backend_pdf import PdfPages
+from matplotlib.pyplot import switch_backend
+
 from freesas import plot
+from freesas.autorg import InsufficientDataError, NoGuinierRegionError
+from freesas.sas_argparser import (
+    SASParser,
+    check_output_template,
+    format_output_filename,
+)
 from freesas.sasio import (
-    load_scattering_data,
     convert_inverse_angstrom_to_nanometer,
+    load_scattering_data,
 )
-from freesas.autorg import InsufficientDataError, NoGuinierRegionError
-from freesas.sas_argparser import SASParser
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("plot_sas")
 
 
-def set_backend(output: Path = None, output_format: str = None):
+def set_backend(output: Path | None = None, output_format: str | None = None):
     """Explicitely set silent backend based on format or filename
     Needed on MacOS
     @param output: Name of the specified output file
@@ -78,7 +82,11 @@ def parse():
     small angle scattering algorithms. """
     parser = SASParser(prog="freesas.py", description=description, epilog=epilog)
     parser.add_file_argument(help_text="dat files to plot")
-    parser.add_output_filename_argument()
+    # a plain file name still means "one single output", a template means
+    # "one figure per input file"
+    parser.add_output_template_argument(
+        None, described_default="show the figures in a window"
+    )
     parser.add_output_data_format("jpeg", "svg", "png", "pdf")
     parser.add_q_unit_argument()
     return parser.parse_args()
@@ -110,11 +118,15 @@ def main():
     logger.debug("%s input files", input_len)
     figures = []
 
-    if args.output and len(files) > 1:
+    # a template produces one file per input file, a plain name a single output
+    use_template = bool(args.output) and "{" in args.output
+    if use_template:
+        check_output_template(args.output)
+    elif args.output and len(files) > 1:
         logger.warning("Only PDF export is possible in multi-frame mode")
     if args.output and platform.system() == "Darwin":
-        if len(files) == 1:
-            set_backend(args.output, args.format)
+        if use_template or len(files) == 1:
+            set_backend(Path(args.output), args.format)
         elif len(files) > 1:
             set_backend(output_format="pdf")
     for afile in files:
@@ -128,9 +140,13 @@ def main():
             figures.append(fig)
             if args.output is None:
                 fig.show()
+            elif use_template:
+                dest = format_output_filename(args.output, afile, mkdir=True)
+                fig.savefig(dest, format=args.format)
+                logger.debug("%s --> %s", afile, dest)
             elif len(files) == 1:
                 fig.savefig(args.output, format=args.format)
-    if len(figures) > 1 and args.output:
+    if len(figures) > 1 and args.output and not use_template:
         with PdfPages(args.output) as pdf_output_file:
             for fig in figures:
                 pdf_output_file.savefig(fig)
diff --git a/src/freesas/app/supycomb.py b/src/freesas/app/supycomb.py
index 53e8343..9e6239b 100644
--- a/src/freesas/app/supycomb.py
+++ b/src/freesas/app/supycomb.py
@@ -1,19 +1,27 @@
-#!/usr/bin/python3
 __author__ = "Guillaume Bonamis"
 __license__ = "MIT"
 __copyright__ = "2015, ESRF"
 __date__ = "09/07/2020"
 
 import logging
-from os.path import dirname, abspath
-from freesas.align import InputModels, AlignModels
-from freesas.sas_argparser import SASParser
+from os.path import abspath, dirname
+
+from freesas.align import AlignModels, InputModels
+from freesas.sas_argparser import (
+    SASParser,
+    check_output_template,
+    format_output_filename,
+)
 
 base = dirname(dirname(abspath(__file__)))
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("supycomb")
 
+#: Default output templates, for two models and for more
+DEFAULT_OUTPUT_TEMPLATE = "aligned.pdb"
+DEFAULT_MULTI_OUTPUT_TEMPLATE = "model-{index:02d}.pdb"
+
 
 def parse():
     """Parse input and return list of files.
@@ -61,12 +69,14 @@ def parse():
         default="YES",
         help="Use GUI for figures or not, default: %(default)s",
     )
-    parser.add_argument(
-        "-o",
-        "--output",
-        type=str,
-        default="aligned.pdb",
-        help="output filename, default: %(default)s",
+    # the default depends on the number of input models, main() picks it
+    parser.add_output_template_argument(
+        None,
+        extra_fields={"index": "number of the model, starting at 1"},
+        described_default=(
+            f"{DEFAULT_OUTPUT_TEMPLATE} for two models, "
+            f"{DEFAULT_MULTI_OUTPUT_TEMPLATE} for more"
+        ),
     )
     return parser.parse_args()
 
@@ -76,7 +86,7 @@ def main():
 
     args = parse()
     input_len = len(args.file)
-    logger.info("%s input files" % input_len)
+    logger.info(f"{input_len} input files")
     selection = InputModels()
 
     if args.mode == "SLOW":
@@ -106,13 +116,29 @@ def main():
 
     align = AlignModels(args.file, slow=slow, enantiomorphs=enantiomorphs)
     if input_len == 2:
-        align.outputfiles = args.output
+        template = args.output or DEFAULT_OUTPUT_TEMPLATE
+        check_output_template(template, index=0)
+        # only the second model gets aligned onto the first one and saved
+        align.outputfiles = str(
+            format_output_filename(template, args.file[1], mkdir=True, index=2)
+        )
         align.assign_models()
         dist = align.alignment_2models()
-        logger.info("%s and %s aligned" % (args.file[0], args.file[1]))
-        logger.info("NSD after optimized alignment = %.2f" % dist)
+        logger.info(f"{args.file[0]} and {args.file[1]} aligned")
+        logger.info(f"NSD after optimized alignment = {dist:.2f}")
     else:
-        align.outputfiles = ["model-%02i.pdb" % (i + 1) for i in range(input_len)]
+        template = args.output or DEFAULT_MULTI_OUTPUT_TEMPLATE
+        check_output_template(template, index=0)
+        if "{index" not in template and "{basename" not in template:
+            logger.warning(
+                "Output template %s has neither {index} nor {basename} field: "
+                "every aligned model will be written to the same file",
+                template,
+            )
+        align.outputfiles = [
+            str(format_output_filename(template, afile, mkdir=True, index=idx + 1))
+            for idx, afile in enumerate(args.file)
+        ]
         selection.inputfiles = args.file
         selection.models_selection()
         selection.rfactorplot(save=save)
diff --git a/src/freesas/autorg.py b/src/freesas/autorg.py
index 3255462..8891e60 100644
--- a/src/freesas/autorg.py
+++ b/src/freesas/autorg.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """Functions for calculating the radius of gyration and forward scattering intensity."""
 
 __authors__ = ["Jérôme Kieffer"]
@@ -7,21 +6,22 @@
 __date__ = "06/02/2026"
 
 import logging
+
 import numpy
 from scipy.optimize import curve_fit
+
 from ._autorg import (  # noqa
-    RG_RESULT,
-    guinier,
-    NoGuinierRegionError,
     DTYPE,
+    FIT_RESULT,
+    RG_RESULT,
+    AutoGuinier,
     InsufficientDataError,
+    NoGuinierRegionError,
     autoRg,
-    AutoGuinier,
+    guinier,
     linear_fit,
-    FIT_RESULT,
 )
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -152,7 +152,7 @@ def auto_guinier(data, Rg_min=1.0, qRg_max=1.3, relax=1.2):
         data, q_ary, i_ary, sigma_ary, Rg_min, qRg_max, relax
     )
     if start0 < 0:
-        raise InsufficientDataError("Minimum region size is %s" % guinier.min_size)
+        raise InsufficientDataError(f"Minimum region size is {guinier.min_size}")
     guinier.guinier_space(
         start0, stop0, q_ary, i_ary, sigma_ary, q2_ary, lnI_ary, wg_ary
     )
@@ -161,7 +161,7 @@ def auto_guinier(data, Rg_min=1.0, qRg_max=1.3, relax=1.2):
         q2_ary, lnI_ary, wg_ary, start0, stop0, Rg_min, qRg_max, relax
     )
 
-    cnt, relaxed, qRg_max, aslope_max = guinier.count_valid(fits, qRg_max, relax)
+    cnt, _relaxed, qRg_max, _aslope_max = guinier.count_valid(fits, qRg_max, relax)
     # valid_fits = fits[fits[:, 9] < qRg_max]
     if cnt == 0:
         raise NoGuinierRegionError(qRg_max)
@@ -170,7 +170,7 @@ def auto_guinier(data, Rg_min=1.0, qRg_max=1.3, relax=1.2):
     start, stop = guinier.find_region(fits, qRg_max)
 
     # Now average out the
-    Rg_avg, Rg_std, I0_avg, I0_std, good = guinier.average_values(fits, start, stop)
+    Rg_avg, Rg_std, I0_avg, I0_std, _good = guinier.average_values(fits, start, stop)
 
     aggregated = guinier.check_aggregation(
         q2_ary, lnI_ary, wg_ary, start0, stop, Rg=Rg_avg, threshold=False
diff --git a/src/freesas/average.py b/src/freesas/average.py
index 32c0e2a..e9db53c 100644
--- a/src/freesas/average.py
+++ b/src/freesas/average.py
@@ -3,6 +3,7 @@
 __copyright__ = "2015, ESRF"
 
 import numpy
+
 from freesas.model import SASModel
 
 
@@ -22,7 +23,7 @@ def __init__(self, inputfiles):
         self.coordknots = []
 
     def __repr__(self):
-        return "Grid with %i knots" % self.nbknots
+        return f"Grid with {self.nbknots} knots"
 
     def spatial_extent(self):
         """
@@ -171,7 +172,7 @@ def __init__(self, inputfiles, grid):
         self.grid = grid
 
     def __repr__(self):
-        return "Average SAS model with %i atoms" % len(self.atoms)
+        return f"Average SAS model with {len(self.atoms)} atoms"
 
     def read_files(self, reference=None):
         """
@@ -246,18 +247,18 @@ def make_header(self):
         Create the layout of the pdb file for the averaged model.
         """
         header = []
-        header.append("Number of files averaged : %s\n" % len(self.inputfiles))
+        header.append(f"Number of files averaged : {len(self.inputfiles)}\n")
         for i in self.inputfiles:
             header.append(i + "\n")
-        header.append("Total number of dots in the grid : %s\n" % self.grid.shape[0])
+        header.append(f"Total number of dots in the grid : {self.grid.shape[0]}\n")
 
         decade = 1
         for i in range(self.grid.shape[0]):
             line = "ATOM         CA  ASP    1                                    20.00   2 201\n"
-            line = line[:7] + "%4.i" % (i + 1) + line[11:]
+            line = line[:7] + f"{i + 1:4d}" + line[11:]
             if not (i + 1) % 10:
                 decade += 1
-            line = line[:21] + "%4.i" % decade + line[25:]
+            line = line[:21] + f"{decade:4d}" + line[25:]
             header.append(line)
         self.header = header
         return header
@@ -278,9 +279,9 @@ def save_aver(self, filename):
             for line in self.header:
                 if line.startswith("ATOM"):
                     if nr < self.grid.shape[0] and self.grid[nr, 4] != 0:
-                        coord = "%8.3f%8.3f%8.3f" % tuple(self.grid[nr, 0:3])
-                        occ = "%6.2f" % self.grid[nr, 3]
-                        contrib = "%2.f" % self.grid[nr, 4]
+                        coord = "{:8.3f}{:8.3f}{:8.3f}".format(*tuple(self.grid[nr, 0:3]))
+                        occ = f"{self.grid[nr, 3]:6.2f}"
+                        contrib = f"{self.grid[nr, 4]:2.0f}"
                         line = (
                             line[:30] + coord + occ + line[60:66] + contrib + line[68:]
                         )
diff --git a/src/freesas/bift.py b/src/freesas/bift.py
index 4e932f1..e4bcab1 100644
--- a/src/freesas/bift.py
+++ b/src/freesas/bift.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
 Bayesian Inverse Fourier Transform
 
@@ -18,10 +17,11 @@
 
 import logging
 from math import log
+
 from scipy.optimize import minimize
-from ._bift import BIFT
-from .autorg import auto_guinier, NoGuinierRegionError
 
+from ._bift import BIFT
+from .autorg import NoGuinierRegionError, auto_guinier
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/freesas/containers.py b/src/freesas/containers.py
index 1ae5272..e67b791 100644
--- a/src/freesas/containers.py
+++ b/src/freesas/containers.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -30,12 +29,14 @@
 __authors__ = ["Jérôme Kieffer"]
 __license__ = "MIT"
 __copyright__ = "2020-2026 ESRF"
-__date__ = "09/03/2026"
+__date__ = "01/09/2026"
 
 from collections import namedtuple
 from typing import NamedTuple
+
 import numpy
 
+
 # Used in AutoRg
 class RG_RESULT(NamedTuple):
     Rg: float|None=None
@@ -133,17 +134,15 @@ def save(self, filename, source=None):
             f"I₀= {self.I0_avg:.2f}±{self.I0_std:.2f}",
         ]
         with open(filename, "wt", encoding="utf-8") as out:
-            out.write("# %s %s" % (source or filename, "\n"))
-            for txt in res:
-                out.write(f"# {txt} \n")
+            out.write("# {} {}".format(source or filename, "\n"))
+            out.writelines(f"# {txt} \n" for txt in res)
             out.write("\n# r\tp(r)\tsigma_p(r)\n")
-            for r, p, s in zip(
+            out.writelines("{}\t{}\t{}{}".format(r, p, s, "\n") for r, p, s in zip(
                 self.radius.astype(numpy.float32),
                 self.density_avg.astype(numpy.float32),
                 self.density_std.astype(numpy.float32),
-            ):
-                out.write("%s\t%s\t%s%s" % (r, p, s, "\n"))
-        return filename + ": " + "; ".join(res)
+            ))
+        return f"{filename}: " + "; ".join(res)
 
 
 # Used in Cormap
diff --git a/src/freesas/cormap.py b/src/freesas/cormap.py
index 517fd53..8281fa5 100644
--- a/src/freesas/cormap.py
+++ b/src/freesas/cormap.py
@@ -2,10 +2,12 @@
 __license__ = "MIT"
 __copyright__ = "2017, ESRF"
 
+from math import log2
+
 import numpy
-from math import log
-from .containers import GOF
+
 from ._cormap import measure_longest
+from .containers import GOF
 
 
 class LongestRunOfHeads:
@@ -59,7 +61,7 @@ def __call__(self, n, c):
         delta = 2**n - self.A(n, c)
         if delta <= 0:
             return 0
-        return 2.0 ** (log(delta, 2) - n)
+        return 2.0 ** (log2(delta) - n)
 
     def probaHeadOrTail(self, n, c):
         """Calculate the probability of a longest run of head or tails to occur
@@ -75,7 +77,7 @@ def probaHeadOrTail(self, n, c):
         delta = self.B(n, c) - self.B(n, c - 1)
         if delta <= 0:
             return 0
-        return min(2.0 ** (log(delta, 2.0) - n), 1.0)
+        return min(2.0 ** (log2(delta) - n), 1.0)
 
     def probaLongerRun(self, n, c):
         """Calculate the probability for the longest run of heads or tails to exceed the observed length
@@ -91,7 +93,7 @@ def probaLongerRun(self, n, c):
         delta = (2**n) - self.B(n, c)
         if delta <= 0:
             return 0
-        return min(2.0 ** (log(delta, 2.0) - n), 1.0)
+        return min(2.0 ** (log2(delta) - n), 1.0)
 
 
 LROH = LongestRunOfHeads()
diff --git a/src/freesas/decorators.py b/src/freesas/decorators.py
index c135392..6717af3 100644
--- a/src/freesas/decorators.py
+++ b/src/freesas/decorators.py
@@ -1,4 +1,3 @@
-# coding: utf-8
 #
 #    Project: Free SAS tools
 #             https://github.com/kif/freesas
@@ -34,9 +33,9 @@
 __status__ = "development"
 __docformat__ = "restructuredtext"
 
+import logging
 import sys
 import time
-import logging
 
 timelog = logging.getLogger("freesas.timeit")
 
diff --git a/src/freesas/dnn.py b/src/freesas/dnn.py
index a3d61d4..f4a1f56 100644
--- a/src/freesas/dnn.py
+++ b/src/freesas/dnn.py
@@ -1,10 +1,12 @@
-import numpy as np
+import io
 import json
-import h5py
+import os
 import zipfile
+
+import h5py
+import numpy as np
+
 from .resources import resource_filename
-import io
-import os
 
 
 # Activation functions
diff --git a/src/freesas/fitting.py b/src/freesas/fitting.py
index 37ab0a1..2476b03 100644
--- a/src/freesas/fitting.py
+++ b/src/freesas/fitting.py
@@ -9,24 +9,27 @@
 __status__ = "development"
 __docformat__ = "restructuredtext"
 
-import sys
 import logging
-import platform
 import os
-from pathlib import Path
+import platform
+import sys
+from collections.abc import Callable, Generator
 from contextlib import contextmanager
-from typing import Callable, List, Optional, IO, Generator
+from pathlib import Path
+from typing import IO
+
 from numpy import ndarray
+
 from .autorg import (
     RG_RESULT,
     InsufficientDataError,
     NoGuinierRegionError,
 )
+from .sas_argparser import GuinierParser, SASParser
 from .sasio import (
-    load_scattering_data,
     convert_inverse_angstrom_to_nanometer,
+    load_scattering_data,
 )
-from .sas_argparser import GuinierParser, SASParser
 
 
 def set_logging_level(verbose_flag: int) -> None:
@@ -40,7 +43,7 @@ def set_logging_level(verbose_flag: int) -> None:
         logging.root.setLevel(logging.DEBUG)
 
 
-def collect_files(file_list: List[str]) -> List[Path]:
+def collect_files(file_list: list[str]) -> list[Path]:
     """
     Take file list from argparser and return list of paths
     :param file_list: file list as returned by the argparser
@@ -55,7 +58,7 @@ def collect_files(file_list: List[str]) -> List[Path]:
 
 @contextmanager
 def get_output_destination(
-    output_path: Optional[Path] = None,
+    output_path: Path | None = None,
 ) -> Generator[IO[str], None, None]:
     """
     Return file or stdout object to write output to
@@ -83,7 +86,7 @@ def get_linesep(output_destination: IO[str]) -> str:
         return "\n"
 
 
-def get_guinier_header(linesep: str, output_format: Optional[str] = None) -> str:
+def get_guinier_header(linesep: str, output_format: str | None = None) -> str:
     """Return appropriate header line for selected output format
     :param output_format: output format from string parser
     :param linesep: correct linesep for chosen destination
@@ -91,25 +94,14 @@ def get_guinier_header(linesep: str, output_format: Optional[str] = None) -> str
     # pylint: disable=R1705
     if output_format == "csv":
         return (
-            ",".join(
-                (
-                    "File",
-                    "Rg",
-                    "Rg StDev",
-                    "I(0)",
-                    "I(0) StDev",
-                    "First point",
-                    "Last point",
-                    "Quality,Aggregated",
-                )
-            )
+            "File,Rg,Rg StDev,I(0),I(0) StDev,First point,Last point,Quality,Aggregated"
             + linesep
         )
     else:
         return ""
 
 
-def get_dnn_header(linesep: str, output_format: Optional[str] = None) -> str:
+def get_dnn_header(linesep: str, output_format: str | None = None) -> str:
     """Return appropriate header line for selected output format
     :param output_format: output format from string parser
     :param linesep: correct linesep for chosen destination
@@ -117,13 +109,7 @@ def get_dnn_header(linesep: str, output_format: Optional[str] = None) -> str:
     # pylint: disable=R1705
     if output_format == "csv":
         return (
-            ",".join(
-                (
-                    "File",
-                    "Rg",
-                    "Dmax",
-                )
-            )
+            "File,Rg,Dmax"
             + linesep
         )
     else:
@@ -134,7 +120,7 @@ def rg_result_to_output_line(
     rg_result: RG_RESULT,
     afile: Path,
     linesep: str,
-    output_format: Optional[str] = None,
+    output_format: str | None = None,
 ) -> str:
     """Return result line formatted according to selected output format
     :param rg_result: Result of an rg fit
@@ -185,7 +171,7 @@ def dnn_result_to_output_line(
     dnn_result: tuple,
     afile: Path,
     linesep: str,
-    output_format: Optional[str] = None,
+    output_format: str | None = None,
 ) -> str:
     """Return result line formatted according to selected output format
     :param dnn_result: Result of an dnn inference, 2 tuple
diff --git a/src/freesas/invariants.py b/src/freesas/invariants.py
index 5cabc89..0b46f3c 100644
--- a/src/freesas/invariants.py
+++ b/src/freesas/invariants.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -36,7 +35,9 @@
 __date__ = "06/02/2026"
 
 import logging
+
 import numpy
+
 from .containers import RT_RESULT
 
 try:
@@ -84,7 +85,7 @@ def calc_Porod(data, guinier):
     :param Guinier: result of a Guinier fit (instance of RT_RESULT)
     :return: Volume calculated according to Porrod's formula
     """
-    q, intensity, dI = extrapolate(data, guinier).T
+    q, intensity, _dI = extrapolate(data, guinier).T
 
     denom = trapezoid(intensity * q**2, q)
     volume = 2 * numpy.pi**2 * guinier.I0 / denom
diff --git a/src/freesas/model.py b/src/freesas/model.py
index 4e1886d..a911247 100644
--- a/src/freesas/model.py
+++ b/src/freesas/model.py
@@ -1,13 +1,11 @@
-#!/usr/bin/env python
-# coding: utf-8
-
 __author__ = "Guillaume Bonamis"
 __license__ = "MIT"
 __copyright__ = "2015, ESRF"
 
 import os
-from math import sqrt
 import threading
+from math import sqrt
+
 import numpy
 
 try:
@@ -61,7 +59,7 @@ def __init__(self, molecule=None):
         self._sem = threading.Semaphore()
 
     def __repr__(self):
-        return "SAS model with %i atoms" % len(self.atoms)
+        return f"SAS model with {len(self.atoms)} atoms"
 
     def read(self, filename):
         """
@@ -105,7 +103,7 @@ def save(self, filename):
                     if nr < self.atoms.shape[0]:
                         line = (
                             line[:30]
-                            + "%8.3f%8.3f%8.3f" % tuple(self.atoms[nr])
+                            + "{:8.3f}{:8.3f}{:8.3f}".format(*tuple(self.atoms[nr]))
                             + line[54:]
                         )
                     else:
diff --git a/src/freesas/nexus_parser.py b/src/freesas/nexus_parser.py
index 7fb2565..c47f2cf 100644
--- a/src/freesas/nexus_parser.py
+++ b/src/freesas/nexus_parser.py
@@ -3,15 +3,15 @@
 __copyright__ = "2017, ESRF"
 __date__ = "06/02/2026"
 
-import sys
+import logging
 import os
-import zipfile
 import posixpath
-import logging
-from typing import Union
-from silx.io.nxdata import NXdata
+import sys
+import zipfile
 from dataclasses import dataclass
+
 import numpy
+from silx.io.nxdata import NXdata
 
 logger = logging.getLogger(__name__)
 
@@ -26,10 +26,10 @@
 class IntegratedPattern:
     """Store one pyFAI integrated pattern"""
 
-    point: Union[float, int, None]
+    point: float | int | None
     radial: numpy.ndarray
     intensity: numpy.ndarray
-    intensity_errors: Union[numpy.ndarray, None] = None
+    intensity_errors: numpy.ndarray | None = None
     radial_name: str = ""
     radial_units: str = ""
     intensity_name: str = ""
@@ -138,9 +138,8 @@ def visit_item(self, name, obj):
                             self.skip.add(posixpath.join(name, key, sub))
             else:
                 node[path[-1]] = {}
-        if isinstance(obj, h5py.Dataset):
-            if len(obj.shape) <= 1:
-                node[path[-1]] = obj[()]
+        if isinstance(obj, h5py.Dataset) and len(obj.shape) <= 1:
+            node[path[-1]] = obj[()]
 
     def save(self, filename):
         with zipfile.ZipFile(filename, "w") as z:
diff --git a/src/freesas/plot.py b/src/freesas/plot.py
index 1795382..172aaf6 100644
--- a/src/freesas/plot.py
+++ b/src/freesas/plot.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
 Functions to generating graphs related to SAS.
 """
@@ -9,6 +8,7 @@
 __date__ = "09/03/2026"
 
 import logging
+
 import numpy
 from matplotlib.pyplot import subplots
 
@@ -52,7 +52,7 @@ def scatter_plot(
     intensity = data.T[1]
     try:
         err = data.T[2]
-    except Exception:
+    except IndexError:
         err = None
     if ax:
         fig = ax.figure
@@ -109,7 +109,7 @@ def scatter_plot(
             )
         else:
             ax.plot(q, intensity, label=label_exp, color=exp_color, alpha=0.5)
-        label_guinier += ": $R_g=$%.2f %s, $I_0=$%.2f" % (rg, unit, I0)
+        label_guinier += f": $R_g=${rg:.2f} {unit}, $I_0=${I0:.2f}"
         ax.plot(
             q_guinier,
             I_guinier,
@@ -132,17 +132,11 @@ def scatter_plot(
         T = numpy.outer(q_ext, r / numpy.pi)
         T = (4 * numpy.pi * (r[-1] - r[0]) / (len(r) - 1)) * numpy.sinc(T)
         p = stats.density_avg
-        label_ift += ": $D_{max}=$%.2f %s,\n    $R_g=$%.2f %s, $I_0=$%.2f" % (
-            stats.Dmax_avg,
-            unit,
-            stats.Rg_avg,
-            unit,
-            stats.I0_avg,
-        )
+        label_ift += f": $D_{{max}}=${stats.Dmax_avg:.2f} {unit},\n    $R_g=${stats.Rg_avg:.2f} {unit}, $I_0=${stats.I0_avg:.2f}"
         ax.plot(q_ext, T.dot(p), label=label_ift, color=ift_color)
 
     ax.set_ylabel("$I(q)$ (log scale)", fontsize=fontsize)
-    ax.set_xlabel("$q$ (%s$^{-1}$)" % unit, fontsize=fontsize)
+    ax.set_xlabel(f"$q$ ({unit}$^{{-1}}$)", fontsize=fontsize)
     ax.set_title(title)
     ax.set_yscale("log")
     #     ax.set_ylim(ymin=I.min() * 10, top=I.max() * 1.1)
@@ -154,7 +148,7 @@ def scatter_plot(
     for lbl in [label_exp, label_guinier, label_ift]:
         try:
             idx = lab.index(lbl)
-        except Exception:
+        except ValueError:
             continue
         ordered_lab.append(lab[idx])
         ordered_crv.append(crv[idx])
@@ -198,7 +192,7 @@ def kratky_plot(
     intensity = data.T[1]
     try:
         err = data.T[2]
-    except Exception:
+    except IndexError:
         err = None
     if ax:
         fig = ax.figure
@@ -353,12 +347,12 @@ def guinier_plot(
     ax.plot(
         q2[:end],
         intercept + slope * q2[:end],
-        label="ln[$I(q)$] = %.2f %.2f * $q^2$" % (intercept, slope),
+        label=f"ln[$I(q)$] = {intercept:.2f} {slope:.2f} * $q^2$",
         color="crimson",
     )
     ax.set_ylabel("ln[$I(q)$]", fontsize=fontsize)
-    ax.set_xlabel("$q^2$ (%s$^{-2}$)" % unit, fontsize=fontsize)
-    ax.set_title("Guinier plot: $R_{g}=$%.2f %s $I_{0}=$%.2f" % (Rg, unit, I0))
+    ax.set_xlabel(f"$q^2$ ({unit}$^{{-2}}$)", fontsize=fontsize)
+    ax.set_title(f"Guinier plot: $R_{{g}}=${Rg:.2f} {unit} $I_{{0}}=${I0:.2f}")
     ax.legend()
     ax.tick_params(axis="x", labelsize=labelsize)
     ax.tick_params(axis="y", labelsize=labelsize)
@@ -407,21 +401,13 @@ def density_plot(
         ift.radius,
         ift.density_avg,
         ift.density_std,
-        label="BIFT: χ$_{r}^{2}=$%.2f\n $D_{max}=$%.2f %s\n $R_{g}=$%.2f %s\n $I_{0}=$%.2f"
-        % (
-            stats.chi2r_avg,
-            stats.Dmax_avg,
-            unit,
-            stats.Rg_avg,
-            unit,
-            stats.I0_avg,
-        ),
+        label=f"BIFT: χ$_{{r}}^{{2}}=${stats.chi2r_avg:.2f}\n $D_{{max}}=${stats.Dmax_avg:.2f} {unit}\n $R_{{g}}=${stats.Rg_avg:.2f} {unit}\n $I_{{0}}=${stats.I0_avg:.2f}",
         capsize=0,
         color="blue",
         ecolor="lightblue",
     )
     ax.set_ylabel("$p(r)$", fontsize=fontsize)
-    ax.set_xlabel("$r$ (%s)" % unit, fontsize=fontsize)
+    ax.set_xlabel(f"$r$ ({unit})", fontsize=fontsize)
     ax.set_title("Pair distribution function")
     ax.legend()
     ax.tick_params(axis="x", labelsize=labelsize)
@@ -443,23 +429,12 @@ def plot_all(
     labelsize=None,
     fontsize=None,
 ):
-    from . import bift, autorg
+    from . import autorg, bift
 
-    try:
-        guinier = autorg.autoRg(data)
-    except autorg.InsufficientDataError:
-        raise
+    guinier = autorg.autoRg(data)
     logger.debug(guinier)
-    try:
-        bo = bift.auto_bift(data, npt=100, scan_size=11, Dmax_over_Rg=3)
-    except (
-        autorg.InsufficientDataError,
-        autorg.NoGuinierRegionError,
-        ValueError,
-    ):
-        raise
-    else:
-        ift = bo.calc_stats()
+    bo = bift.auto_bift(data, npt=100, scan_size=11, Dmax_over_Rg=3)
+    ift = bo.calc_stats()
     logger.debug(ift)
     fig, ax = subplots(2, 2, figsize=(12, 10))
     scatter_plot(
diff --git a/src/freesas/resources/__init__.py b/src/freesas/resources/__init__.py
index d9a4c26..6c9dc1e 100644
--- a/src/freesas/resources/__init__.py
+++ b/src/freesas/resources/__init__.py
@@ -1,4 +1,3 @@
-# coding: utf-8
 # /*##########################################################################
 #
 # Copyright (C) 2016-2024 European Synchrotron Radiation Facility
@@ -59,24 +58,16 @@
 __date__ = "07/03/2024"
 
 
+import logging
 import os
 import sys
-import logging
 
 logger = logging.getLogger(__name__)
 
 # importlib_resources is useful when this package is stored in a zip
 # When importlib.resources is not available, the resources dir defaults to the
 # directory containing this module.
-if sys.version_info >= (3, 9):
-    import importlib.resources as importlib_resources
-else:
-    try:
-        import importlib_resources
-    except ImportError:
-        logger.info("Unable to import importlib_resources")
-        logger.debug("Backtrace", exc_info=True)
-        importlib_resources = None
+import importlib.resources as importlib_resources
 
 if importlib_resources is not None:
     import atexit
diff --git a/src/freesas/sas_argparser.py b/src/freesas/sas_argparser.py
index 7a3fd1c..3bd10b9 100644
--- a/src/freesas/sas_argparser.py
+++ b/src/freesas/sas_argparser.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
 Generalized arg parser for freeSAS apps to ensure unified command line API.
 """
@@ -6,12 +5,20 @@
 __author__ = "Martha Brennich"
 __license__ = "MIT"
 __copyright__ = "2020, ESRF"
-__date__ = "09/08/2020"
+__date__ = "02/09/2026"
 
 import argparse
+import sys
 from pathlib import Path
+
 from freesas import dated_version as freesas_version
 
+#: Fields every output template understands, with their description
+OUTPUT_TEMPLATE_FIELDS = {
+    "dirname": "directory of the input file",
+    "basename": "name of the input file, without its extension",
+}
+
 
 def parse_unit(unit_input: str) -> str:
     """
@@ -28,6 +35,54 @@ def parse_unit(unit_input: str) -> str:
         return unit_input
 
 
+def check_output_template(template: str, **extra_fields) -> None:
+    """
+    Exit with an explicit message if an output template uses an unknown field
+    or a format specification which does not apply to that field.
+
+    Meant to be called once, before any file gets processed, so that a typo in
+    the template does not show up after a lengthy computation.
+
+    :param template: the template provided by the user
+    :param extra_fields: fields the calling app supports on top of the common
+                         ones, as name: sample value. The value matters: it is
+                         what the format specification gets checked against,
+                         i.e. index=0 for a field used as {index:02d}.
+    """
+    known = {**dict.fromkeys(OUTPUT_TEMPLATE_FIELDS, ""), **extra_fields}
+    try:
+        template.format(**known)
+    except (KeyError, IndexError) as err:
+        sys.exit(f"Invalid output template {template!r}: unknown field {err}")
+    except ValueError as err:
+        sys.exit(f"Invalid output template {template!r}: {err}")
+
+
+def format_output_filename(
+    template: str, source, mkdir: bool = False, **extra_fields
+) -> Path:
+    """
+    Build the name of an output file by substituting the fields of a template.
+
+    :param template: template of the file name, i.e. "{dirname}/{basename}.out"
+    :param source: name or Path of the input file the output is derived from
+    :param mkdir: create the directory of the output file if it is missing,
+                  which a template pointing outside of the input directory
+                  usually needs
+    :param extra_fields: additional fields to substitute, i.e. index=3
+    :return: Path of the file to write to
+    """
+    source = Path(source)
+    destination = Path(
+        template.format(
+            dirname=source.parent, basename=source.stem, **extra_fields
+        )
+    )
+    if mkdir:
+        destination.parent.mkdir(parents=True, exist_ok=True)
+    return destination
+
+
 class SASParser:
     """
     Wrapper class for argparse ArgumentParser that provides predefined argument.
@@ -48,12 +103,8 @@ def __init__(self, prog: str, description: str, epilog: str, **kwargs):
         :param kwargs:       additional kwargs for argparse ArgumentParser
         """
 
-        self.usage = "%s [OPTIONS] FILES " % (prog)
-        version = "%s version %s from %s" % (
-            prog,
-            freesas_version.version,
-            freesas_version.date,
-        )
+        self.usage = f"{prog} [OPTIONS] FILES "
+        version = f"{prog} version {freesas_version.version} from {freesas_version.date}"
 
         self.parser = argparse.ArgumentParser(
             usage=self.usage, description=description, epilog=epilog, **kwargs
@@ -109,7 +160,41 @@ def add_output_filename_argument(self):
             type=Path,
         )
 
-    def add_output_data_format(self, *formats: str, default: str = None):
+    def add_output_template_argument(
+        self,
+        default: str | None,
+        extra_fields: dict[str, str] | None = None,
+        described_default: str | None = None,
+    ):
+        """
+        Add the -o/--output argument, taking a template for the file name
+        instead of a plain file name, so that one output file can be produced
+        per input file.
+
+        :param default: template used when the argument is not provided. Pass
+                        None when the default depends on the other options, the
+                        app is then in charge of picking one.
+        :param extra_fields: fields supported on top of the common ones,
+                             as name: description
+        :param described_default: default advertised in the help text, when it
+                                  cannot be given as `default`
+        """
+        fields = {**OUTPUT_TEMPLATE_FIELDS, **(extra_fields or {})}
+        described = ", ".join(
+            f"{{{name}}} ({description})" for name, description in fields.items()
+        )
+        self.add_argument(
+            "-o",
+            "--output",
+            action="store",
+            default=default,
+            type=str,
+            help="Template for the name of the output file. The fields "
+            f"{described} are substituted for every processed file. "
+            f"Default: {described_default or default}",
+        )
+
+    def add_output_data_format(self, *formats: str, default: str | None = None):
         """Add default argument for specifying output format."""
         help_string = "Output format: " + ", ".join(formats)
         self.add_argument(
diff --git a/src/freesas/sasio.py b/src/freesas/sasio.py
index 8f39e7d..3a4b8e2 100644
--- a/src/freesas/sasio.py
+++ b/src/freesas/sasio.py
@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 #
 #    Project: FreeSAS
 #             https://github.com/kif/freesas
@@ -22,11 +20,11 @@
 __docformat__ = "restructuredtext"
 
 import io
-from typing import List, Union
 from os import PathLike
-from numpy import loadtxt, array, ndarray
 
-PathType = Union[PathLike, str, bytes, io.StringIO, io.BytesIO]
+from numpy import array, loadtxt, ndarray
+
+PathType = PathLike | str | bytes | io.StringIO | io.BytesIO
 
 
 def load_scattering_data(filename: PathType) -> ndarray:
@@ -59,7 +57,7 @@ def load_scattering_data(filename: PathType) -> ndarray:
     return data
 
 
-def parse_ascii_data(input_file_text: List[str], number_of_columns: int) -> ndarray:
+def parse_ascii_data(input_file_text: list[str], number_of_columns: int) -> ndarray:
     """
     Parse data from an ascii file into an N column numpy array
 
diff --git a/src/freesas/test/__init__.py b/src/freesas/test/__init__.py
index ff7e07c..c792ffb 100644
--- a/src/freesas/test/__init__.py
+++ b/src/freesas/test/__init__.py
@@ -1,6 +1,3 @@
-#!usr/bin/env python
-# coding: utf-8
-
 __author__ = "Jérôme Kieffer"
 __license__ = "MIT"
 __date__ = "15/01/2021"
@@ -8,6 +5,7 @@
 
 import sys
 import unittest
+
 from .test_all import suite
 
 
diff --git a/src/freesas/test/meson.build b/src/freesas/test/meson.build
index 3b82001..5d5e79b 100644
--- a/src/freesas/test/meson.build
+++ b/src/freesas/test/meson.build
@@ -1,6 +1,5 @@
 py.install_sources([
 '__init__.py',
-'mock_open_38.py',
 'test_align.py',
 'test_all.py',
 'test_autorg.py',
diff --git a/src/freesas/test/mock_open_38.py b/src/freesas/test/mock_open_38.py
deleted file mode 100644
index a61b188..0000000
--- a/src/freesas/test/mock_open_38.py
+++ /dev/null
@@ -1,100 +0,0 @@
-"""
-This is the Python 3.8 implementation of mock_open taken from
-https://github.com/python/cpython/blob/3.8/Lib/unittest/mock.py
-Hence:
-"Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
-2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Python Software Foundation;
-All Rights Reserved"
-"""
-
-import io
-from unittest.mock import MagicMock, DEFAULT
-
-
-file_spec = None
-# sentinel = _Sentinel()
-# DEFAULT = sentinel.DEFAULT
-
-
-def _to_stream(read_data):
-    if isinstance(read_data, bytes):
-        return io.BytesIO(read_data)
-    else:
-        return io.StringIO(read_data)
-
-
-def mock_open(mock=None, read_data=""):
-    """
-    A helper function to create a mock to replace the use of `open`. It works
-    for `open` called directly or used as a context manager.
-    The `mock` argument is the mock object to configure. If `None` (the
-    default) then a `MagicMock` will be created for you, with the API limited
-    to methods or attributes available on standard file handles.
-    `read_data` is a string for the `read`, `readline` and `readlines` of the
-    file handle to return.  This is an empty string by default.
-    """
-    _read_data = _to_stream(read_data)
-    _state = [_read_data, None]
-
-    def _readlines_side_effect(*args, **kwargs):
-        if handle.readlines.return_value is not None:
-            return handle.readlines.return_value
-        return _state[0].readlines(*args, **kwargs)
-
-    def _read_side_effect(*args, **kwargs):
-        if handle.read.return_value is not None:
-            return handle.read.return_value
-        return _state[0].read(*args, **kwargs)
-
-    def _readline_side_effect(*args, **kwargs):
-        yield from _iter_side_effect()
-        while True:
-            yield _state[0].readline(*args, **kwargs)
-
-    def _iter_side_effect():
-        if handle.readline.return_value is not None:
-            while True:
-                yield handle.readline.return_value
-        for line in _state[0]:
-            yield line
-
-    def _next_side_effect():
-        if handle.readline.return_value is not None:
-            return handle.readline.return_value
-        return next(_state[0])
-
-    global file_spec
-    if file_spec is None:
-        import _io
-
-        file_spec = list(set(dir(_io.TextIOWrapper)).union(set(dir(_io.BytesIO))))
-
-    if mock is None:
-        mock = MagicMock(name="open", spec=open)
-
-    handle = MagicMock(spec=file_spec)
-    handle.__enter__.return_value = handle
-
-    handle.write.return_value = None
-    handle.read.return_value = None
-    handle.readline.return_value = None
-    handle.readlines.return_value = None
-
-    handle.read.side_effect = _read_side_effect
-    _state[1] = _readline_side_effect()
-    handle.readline.side_effect = _state[1]
-    handle.readlines.side_effect = _readlines_side_effect
-    handle.__iter__.side_effect = _iter_side_effect
-    handle.__next__.side_effect = _next_side_effect
-
-    def reset_data(*args, **kwargs):
-        _state[0] = _to_stream(read_data)
-        if handle.readline.side_effect == _state[1]:
-            # Only reset the side effect if the user hasn't overridden it.
-            _state[1] = _readline_side_effect()
-            handle.readline.side_effect = _state[1]
-        return DEFAULT
-
-    mock.side_effect = reset_data
-    mock.return_value = handle
-    return mock
diff --git a/src/freesas/test/test_align.py b/src/freesas/test/test_align.py
index 9b6ebd5..34aa4a4 100644
--- a/src/freesas/test/test_align.py
+++ b/src/freesas/test/test_align.py
@@ -1,15 +1,15 @@
-#!/usr/bin/python
-
 __author__ = "Guillaume"
 __license__ = "MIT"
 __copyright__ = "2015, ESRF"
 
-import numpy
+import logging
 import unittest
-from .utilstest import get_datafile
+
+import numpy
+
 from ..align import AlignModels
-from ..transformations import translation_matrix, euler_matrix
-import logging
+from ..transformations import euler_matrix, translation_matrix
+from .utilstest import get_datafile
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("AlignModels_test")
@@ -69,7 +69,7 @@ def test_alignment(self):
             logger.error(m.dist(n, m.atoms, n.atoms))
             logger.error("pb of movement")
         dist = align.alignment_2models(save=False)
-        self.assertAlmostEqual(dist, 0, 12, msg="NSD unequal 0, %s!=0" % dist)
+        self.assertAlmostEqual(dist, 0, 12, msg=f"NSD unequal 0, {dist}!=0")
 
     def test_usefull_alignment(self):
         inputfiles = [self.testfile1, self.testfile2]
@@ -83,7 +83,7 @@ def test_usefull_alignment(self):
         self.assertGreaterEqual(
             dist_before,
             dist_after,
-            "increase of distance after alignment %s<%s" % (dist_before, dist_after),
+            f"increase of distance after alignment {dist_before}<{dist_after}",
         )
 
     def test_optimisation_align(self):
@@ -101,8 +101,7 @@ def test_optimisation_align(self):
         self.assertGreaterEqual(
             dist_before,
             dist_after,
-            "increase of distance after optimized alignment %s<%s"
-            % (dist_before, dist_after),
+            f"increase of distance after optimized alignment {dist_before}<{dist_after}",
         )
 
     def test_alignment_intruder(self):
@@ -129,7 +128,7 @@ def test_alignment_intruder(self):
         self.assertEqual(
             num_intr,
             intruder,
-            msg="not find the good intruder, %s!=%s" % (num_intr, intruder),
+            msg=f"not find the good intruder, {num_intr}!={intruder}",
         )
 
     def test_reference(self):
diff --git a/src/freesas/test/test_all.py b/src/freesas/test/test_all.py
index 01c7681..5b9357c 100644
--- a/src/freesas/test/test_all.py
+++ b/src/freesas/test/test_all.py
@@ -1,23 +1,23 @@
-#!/usr/bin/env python
-# coding: utf-8
-
 __author__ = "Guillaume"
 __license__ = "MIT"
 __copyright__ = "2015, ESRF"
 __date__ = "03/07/2024"
 
 import unittest
-from . import test_model
-from . import test_align
-from . import test_distance
-from . import test_cormap
-from . import test_autorg
-from . import test_bift
-from . import test_sasio
-from . import test_sas_argparser
-from . import test_fitting
-from . import test_resources
-from . import test_dnn
+
+from . import (
+    test_align,
+    test_autorg,
+    test_bift,
+    test_cormap,
+    test_distance,
+    test_dnn,
+    test_fitting,
+    test_model,
+    test_resources,
+    test_sas_argparser,
+    test_sasio,
+)
 
 
 def suite():
diff --git a/src/freesas/test/test_autorg.py b/src/freesas/test/test_autorg.py
index d26c08f..a8b5576 100644
--- a/src/freesas/test/test_autorg.py
+++ b/src/freesas/test/test_autorg.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -29,22 +28,23 @@
 
 import logging
 import unittest
-from math import sqrt, pi
+from math import pi, sqrt
+from typing import ClassVar
 
 import numpy
 from scipy.stats import linregress
 
-from .utilstest import get_datafile
+from .._autorg import curate_data  # pylint: disable=E0401
+from .._bift import distribution_sphere  # pylint: disable=E0401
 from ..autorg import (
-    autoRg,
     RG_RESULT,
-    linear_fit,
     auto_gpa,
     auto_guinier,
+    autoRg,
+    linear_fit,
 )
-from .._autorg import curate_data  # pylint: disable=E0401
 from ..invariants import calc_Rambo_Tainer
-from .._bift import distribution_sphere  # pylint: disable=E0401
+from .utilstest import get_datafile
 
 logger = logging.getLogger(__name__)
 
@@ -72,7 +72,7 @@ def __init__(self, testName, **extra_kwargs):
         self.extra_arg = extra_kwargs
 
     # Reference implementation
-    atsas_autorg = {
+    atsas_autorg: ClassVar = {
         "Version": "Atsas 2.6.1",
         "Rg": 2.98016,
         "sigma_Rg": 0.156859,
@@ -88,11 +88,11 @@ def test_atsas(self):
         logger.info("test file: %s", self.testfile)
         data = numpy.loadtxt(self.testfile)
         atsas_result = self.atsas_autorg.copy()
-        logger.debug("Reference version: %s" % atsas_result.pop("Version"))
+        logger.debug("Reference version: {}".format(atsas_result.pop("Version")))
         atsas_result = RG_RESULT(**atsas_result)
         free_result = autoRg(data)
-        logger.debug("Ref: %s" % (atsas_result,))
-        logger.debug("Obt: %s" % (free_result,))
+        logger.debug(f"Ref: {atsas_result}")
+        logger.debug(f"Obt: {free_result}")
         self.assertAlmostEqual(
             atsas_result.Rg, free_result.Rg, 1, "RG fits within 2 digits"
         )
diff --git a/src/freesas/test/test_average.py b/src/freesas/test/test_average.py
index 33873c0..cf51eaa 100644
--- a/src/freesas/test/test_average.py
+++ b/src/freesas/test/test_average.py
@@ -1,17 +1,16 @@
-#!/usr/bin/python
-# coding: utf-8
-
 __author__ = "Guillaume"
 __license__ = "MIT"
 __copyright__ = "2015, ESRF"
 
-import numpy
+import logging
 import unittest
-from .utilstest import get_datafile
-from ..model import SASModel
-from ..average import Grid, AverModels
+from typing import ClassVar
 
-import logging
+import numpy
+
+from ..average import AverModels, Grid
+from ..model import SASModel
+from .utilstest import get_datafile
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("AlignModels_test")
@@ -20,7 +19,7 @@
 class TestAverage(unittest.TestCase):
     testfile1 = get_datafile("model-01.pdb")
     testfile2 = get_datafile("model-02.pdb")
-    inputfiles = [testfile1, testfile2]
+    inputfiles: ClassVar = [testfile1, testfile2]
     grid = Grid(inputfiles)
 
     def test_gridsize(self):
@@ -49,8 +48,7 @@ def test_knots(self):
         self.assertGreater(
             threshold,
             gap,
-            msg="final number of knots too different of wanted number: %s != %s"
-            % (nbknots, grid.nbknots),
+            msg=f"final number of knots too different of wanted number: {nbknots} != {grid.nbknots}",
         )
 
     def test_makegrid(self):
diff --git a/src/freesas/test/test_bift.py b/src/freesas/test/test_bift.py
index e6918fd..f4a06eb 100644
--- a/src/freesas/test/test_bift.py
+++ b/src/freesas/test/test_bift.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -29,9 +28,10 @@
 
 import logging
 import time
-import numpy
 import unittest
-from ..bift import auto_bift
+
+import numpy
+
 from .._bift import (
     BIFT,
     distribution_parabola,
@@ -39,6 +39,7 @@
     ensure_edges_zero,
     smooth_density,
 )
+from ..bift import auto_bift
 
 try:
     from numpy import trapezoid  # numpy 2
@@ -55,7 +56,7 @@ class TestBIFT(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        super(TestBIFT, cls).setUpClass()
+        super().setUpClass()
         cls.r = numpy.linspace(0, cls.DMAX, cls.NPT + 1)
         dr = cls.DMAX / cls.NPT
         cls.p = -cls.r * (cls.r - cls.DMAX)  # Nice parabola
@@ -74,14 +75,14 @@ def setUpClass(cls):
 
     @classmethod
     def tearDownClass(cls):
-        super(TestBIFT, cls).tearDownClass()
+        super().tearDownClass()
         cls.r = cls.p = cls.I = cls.q = cls.err = None
 
     def test_autobift(self):
         data = numpy.vstack((self.q, self.I, self.err)).T
         t0 = time.perf_counter()
         bo = auto_bift(data)
-        key, value, valid = bo.get_best()
+        key, _value, _valid = bo.get_best()
         #         print("key is ", key)
         stats = bo.calc_stats()
         #         print("stat is ", stats)
diff --git a/src/freesas/test/test_cormap.py b/src/freesas/test/test_cormap.py
index c026631..e6d1251 100644
--- a/src/freesas/test/test_cormap.py
+++ b/src/freesas/test/test_cormap.py
@@ -1,15 +1,13 @@
-#!/usr/bin/python
-# coding: utf-8
-
 __author__ = "Jérôme Kieffer"
 __license__ = "MIT"
 __copyright__ = "2017-2026, ESRF"
 
-import numpy
-import unittest
 import logging
-from .. import cormap
+import unittest
+
+import numpy
 
+from .. import cormap
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("test_cormap")
diff --git a/src/freesas/test/test_distance.py b/src/freesas/test/test_distance.py
index cc5a3e2..2db394f 100644
--- a/src/freesas/test/test_distance.py
+++ b/src/freesas/test/test_distance.py
@@ -1,16 +1,15 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
 __author__ = "Jérôme Kieffer"
 __license__ = "MIT"
 __copyright__ = "2015, ESRF"
 __date__ = "09/03/2026"
 
-import numpy
+import logging
 import unittest
-from .utilstest import get_datafile
+
+import numpy
+
 from ..model import SASModel
-import logging
+from .utilstest import get_datafile
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("cdistance_test")
@@ -26,10 +25,10 @@ def test_invariants(self):
         f_np, r_np, d_np = m.calc_invariants(False)
         f_cy, r_cy, d_cy = m.calc_invariants(True)
         self.assertAlmostEqual(
-            f_np, f_cy, 10, "fineness is the same %s!=%s" % (f_np, f_cy)
+            f_np, f_cy, 10, f"fineness is the same {f_np}!={f_cy}"
         )
-        self.assertAlmostEqual(r_np, r_cy, 10, "Rg is the same %s!=%s" % (r_np, r_cy))
-        self.assertAlmostEqual(d_np, d_cy, 10, "Dmax is the same %s!=%s" % (d_np, d_cy))
+        self.assertAlmostEqual(r_np, r_cy, 10, f"Rg is the same {r_np}!={r_cy}")
+        self.assertAlmostEqual(d_np, d_cy, 10, f"Dmax is the same {d_np}!={d_cy}")
 
     def test_distance(self):
         m = SASModel()
@@ -39,7 +38,7 @@ def test_distance(self):
         f_np = m.dist(n, m.atoms, n.atoms, False)
         f_cy = m.dist(n, m.atoms, n.atoms, True)
         self.assertAlmostEqual(
-            f_np, f_cy, 5, "distance is the same %s!=%s" % (f_np, f_cy)
+            f_np, f_cy, 5, f"distance is the same {f_np}!={f_cy}"
         )
 
     def test_same(self):
diff --git a/src/freesas/test/test_dnn.py b/src/freesas/test/test_dnn.py
index f404619..a082ed7 100644
--- a/src/freesas/test/test_dnn.py
+++ b/src/freesas/test/test_dnn.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -27,22 +26,23 @@
 __license__ = "MIT"
 __date__ = "06/02/2026"
 
-import unittest
 import logging
+import unittest
+
 import numpy as np
-from .utilstest import get_datafile
-from ..sasio import load_scattering_data
+
 from ..dnn import (
     DNN,
     DenseLayer,
     forward_propagation,
+    linear,
     preprocess,
-    tanh,
     relu,
     sigmoid,
-    linear,
+    tanh,
 )
-
+from ..sasio import load_scattering_data
+from .utilstest import get_datafile
 
 logger = logging.getLogger(__name__)
 
@@ -82,7 +82,7 @@ def test_preprocess(self):
         """
         datfile = get_datafile("bsa_005_sub.dat")
         data = load_scattering_data(datfile)
-        q, intensity, sigma = data.T
+        q, intensity, _sigma = data.T
         Iprep = preprocess(q, intensity)
         self.assertEqual(Iprep.max(), 1, msg="range 0-1")
         self.assertEqual(Iprep.shape, (1024,), msg="size 1024")
diff --git a/src/freesas/test/test_fitting.py b/src/freesas/test/test_fitting.py
index b9a24d8..28afd62 100644
--- a/src/freesas/test/test_fitting.py
+++ b/src/freesas/test/test_fitting.py
@@ -1,6 +1,3 @@
-#!/usr/bin/python
-# coding: utf-8
-
 """Test the functionality of fitting module."""
 
 __authors__ = ["Martha Brennich"]
@@ -8,36 +5,31 @@
 __date__ = "12/09/2024"
 
 
-import unittest
-from unittest.mock import patch, MagicMock
-import logging
-import sys
+import contextlib
 import importlib
+import logging
+import pathlib
 import platform
+import sys
+import unittest
+from collections.abc import Callable
 from io import StringIO
-import pathlib
-import contextlib
 from types import SimpleNamespace
-from typing import Callable
-from errno import ENOENT
+from unittest.mock import MagicMock, mock_open, patch
+
 import numpy
+
+from ..autorg import RG_RESULT, InsufficientDataError, NoGuinierRegionError
 from ..fitting import (
-    set_logging_level,
-    get_output_destination,
     get_guinier_header,
-    rg_result_to_output_line,
     get_linesep,
+    get_output_destination,
+    rg_result_to_output_line,
     run_guinier_fit,
+    set_logging_level,
 )
-from ..autorg import RG_RESULT, InsufficientDataError, NoGuinierRegionError
 from ..sas_argparser import GuinierParser
 
-if sys.version_info.minor > 6:
-    from unittest.mock import mock_open
-else:
-    from .mock_open_38 import mock_open
-
-
 logger = logging.getLogger(__name__)
 
 
@@ -236,12 +228,14 @@ def test_get_output_destination_with_path_input_returns_writable_io(
         """Test that by calling get_output_destination with a Path as input
         we obtain write access to the file of Path."""
         mocked_open = mock_open()
-        with patch("builtins.open", mocked_open):
-            with get_output_destination(pathlib.Path("test")) as destination:
-                self.assertTrue(
-                    destination.writable(),
-                    msg="file destination is writable",
-                )
+        with (
+            patch("builtins.open", mocked_open),
+            get_output_destination(pathlib.Path("test")) as destination,
+        ):
+            self.assertTrue(
+                destination.writable(),
+                msg="file destination is writable",
+            )
         mocked_open.assert_called_once_with(pathlib.Path("test"), "w")
 
     def test_get_output_destination_without_input_returns_stdout(
@@ -328,10 +322,7 @@ def os_stat_mock(path, **_):
             if "good" in pathlib.Path(path).name:
                 pass
             else:
-                if sys.version_info.minor > 7:
-                    raise ValueError
-                else:
-                    raise OSError(ENOENT, "dummy")
+                raise ValueError
 
         mocked_stat = MagicMock(side_effect=os_stat_mock)
         with patch("os.stat", mocked_stat):
@@ -352,24 +343,23 @@ def test_collect_files_globs_on_windows(self):
         """Test that collect_files globs on Windows if no existent files provided."""
 
         def os_stat_mock(path):
-            if sys.version_info.minor > 7:
-                raise ValueError
-            else:
-                raise OSError(ENOENT, "dummy")
+            raise ValueError
 
         mocked_stat = MagicMock(side_effect=os_stat_mock)
         mocked_glob = MagicMock(
             side_effect=[(p for p in [pathlib.Path("pathA"), pathlib.Path("pathB")])]
         )
-        with patch("os.stat", mocked_stat):
-            with patch.object(pathlib.Path, "glob", mocked_glob):
-                fit = importlib.import_module("..fitting", "freesas.subpkg")
-                fit = importlib.reload(fit)
-                self.assertEqual(
-                    fit.collect_files(["testgood"]),
-                    [pathlib.Path("pathA"), pathlib.Path("pathB")],
-                    msg="collect_files on windows returns list if fiel argument does not exist",
-                )
+        with (
+            patch("os.stat", mocked_stat),
+            patch.object(pathlib.Path, "glob", mocked_glob),
+        ):
+            fit = importlib.import_module("..fitting", "freesas.subpkg")
+            fit = importlib.reload(fit)
+            self.assertEqual(
+                fit.collect_files(["testgood"]),
+                [pathlib.Path("pathA"), pathlib.Path("pathB")],
+                msg="collect_files on windows returns list if fiel argument does not exist",
+            )
         mocked_glob.assert_called_once()
 
         # Reload without the patch
@@ -578,13 +568,15 @@ def dummy_fit_function(input_data: numpy.ndarray) -> RG_RESULT:
         )
         output_catcher_stdout = StringIO()
         output_catcher_stderr = StringIO()
-        with contextlib.redirect_stdout(output_catcher_stdout):
-            with contextlib.redirect_stderr(output_catcher_stderr):
-                run_guinier_fit(
-                    fit_function=dummy_fit_function,
-                    parser=dummy_parser,
-                    logger=logger,
-                )
+        with (
+            contextlib.redirect_stdout(output_catcher_stdout),
+            contextlib.redirect_stderr(output_catcher_stderr),
+        ):
+            run_guinier_fit(
+                fit_function=dummy_fit_function,
+                parser=dummy_parser,
+                logger=logger,
+            )
         expected_stdout_output = (
             "test2 Rg=3.1000(±0.1000) I0=103.0000(±2.5000) [13-207] 5010.00% linesep"
         )
@@ -634,13 +626,15 @@ def dummy_fit_function(input_data: numpy.ndarray) -> RG_RESULT:
         )
         output_catcher_stdout = StringIO()
         output_catcher_stderr = StringIO()
-        with contextlib.redirect_stdout(output_catcher_stdout):
-            with contextlib.redirect_stderr(output_catcher_stderr):
-                run_guinier_fit(
-                    fit_function=dummy_fit_function,
-                    parser=dummy_parser,
-                    logger=logger,
-                )
+        with (
+            contextlib.redirect_stdout(output_catcher_stdout),
+            contextlib.redirect_stderr(output_catcher_stderr),
+        ):
+            run_guinier_fit(
+                fit_function=dummy_fit_function,
+                parser=dummy_parser,
+                logger=logger,
+            )
         expected_stdout_output = (
             "test2 Rg=3.1000(±0.1000) I0=103.0000(±2.5000) [13-207] 5010.00% linesep"
         )
@@ -694,13 +688,15 @@ def dummy_fit_function(input_data: numpy.ndarray) -> RG_RESULT:
         )
         output_catcher_stdout = StringIO()
         output_catcher_stderr = StringIO()
-        with contextlib.redirect_stdout(output_catcher_stdout):
-            with contextlib.redirect_stderr(output_catcher_stderr):
-                run_guinier_fit(
-                    fit_function=dummy_fit_function,
-                    parser=dummy_parser,
-                    logger=logger,
-                )
+        with (
+            contextlib.redirect_stdout(output_catcher_stdout),
+            contextlib.redirect_stderr(output_catcher_stderr),
+        ):
+            run_guinier_fit(
+                fit_function=dummy_fit_function,
+                parser=dummy_parser,
+                logger=logger,
+            )
         expected_stdout_output = (
             "test2 Rg=3.1000(±0.1000) I0=103.0000(±2.5000) [13-207] 5010.00% linesep"
         )
@@ -752,13 +748,15 @@ def dummy_fit_function(input_data: numpy.ndarray) -> RG_RESULT:
         )
         output_catcher_stdout = StringIO()
         output_catcher_stderr = StringIO()
-        with contextlib.redirect_stdout(output_catcher_stdout):
-            with contextlib.redirect_stderr(output_catcher_stderr):
-                run_guinier_fit(
-                    fit_function=dummy_fit_function,
-                    parser=dummy_parser,
-                    logger=logger,
-                )
+        with (
+            contextlib.redirect_stdout(output_catcher_stdout),
+            contextlib.redirect_stderr(output_catcher_stderr),
+        ):
+            run_guinier_fit(
+                fit_function=dummy_fit_function,
+                parser=dummy_parser,
+                logger=logger,
+            )
         expected_stdout_output = (
             "test2 Rg=3.1000(±0.1000) I0=103.0000(±2.5000) [13-207] 5010.00% linesep"
         )
@@ -810,13 +808,15 @@ def dummy_fit_function(input_data: numpy.ndarray) -> RG_RESULT:
         )
         output_catcher_stdout = StringIO()
         output_catcher_stderr = StringIO()
-        with contextlib.redirect_stdout(output_catcher_stdout):
-            with contextlib.redirect_stderr(output_catcher_stderr):
-                run_guinier_fit(
-                    fit_function=dummy_fit_function,
-                    parser=dummy_parser,
-                    logger=logger,
-                )
+        with (
+            contextlib.redirect_stdout(output_catcher_stdout),
+            contextlib.redirect_stderr(output_catcher_stderr),
+        ):
+            run_guinier_fit(
+                fit_function=dummy_fit_function,
+                parser=dummy_parser,
+                logger=logger,
+            )
         expected_stdout_output = (
             "test2 Rg=3.1000(±0.1000) I0=103.0000(±2.5000) [13-207] 5010.00% linesep"
         )
@@ -868,13 +868,15 @@ def dummy_fit_function(input_data: numpy.ndarray) -> RG_RESULT:
         )
         output_catcher_stdout = StringIO()
         output_catcher_stderr = StringIO()
-        with contextlib.redirect_stdout(output_catcher_stdout):
-            with contextlib.redirect_stderr(output_catcher_stderr):
-                run_guinier_fit(
-                    fit_function=dummy_fit_function,
-                    parser=dummy_parser,
-                    logger=logger,
-                )
+        with (
+            contextlib.redirect_stdout(output_catcher_stdout),
+            contextlib.redirect_stderr(output_catcher_stderr),
+        ):
+            run_guinier_fit(
+                fit_function=dummy_fit_function,
+                parser=dummy_parser,
+                logger=logger,
+            )
         expected_stdout_output = (
             "test2 Rg=3.1000(±0.1000) I0=103.0000(±2.5000) [13-207] 5010.00% linesep"
         )
diff --git a/src/freesas/test/test_model.py b/src/freesas/test/test_model.py
index c95b2b0..1b0d165 100644
--- a/src/freesas/test/test_model.py
+++ b/src/freesas/test/test_model.py
@@ -1,18 +1,17 @@
-#!/usr/bin/env python
-# coding: utf-8
-
 __author__ = "Guillaume"
 __license__ = "MIT"
 __copyright__ = "2015, ESRF"
 
-import numpy
-import unittest
+import logging
 import os
 import tempfile
-from .utilstest import get_datafile
+import unittest
+
+import numpy
+
 from ..model import SASModel
-from ..transformations import translation_from_matrix, euler_from_matrix
-import logging
+from ..transformations import euler_from_matrix, translation_from_matrix
+from .utilstest import get_datafile
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("SASModel_test")
@@ -64,7 +63,7 @@ def test_rfactor(self):
         self.assertEqual(
             m.rfactor,
             n.rfactor,
-            msg="R-factor is not the same %s != %s" % (m.rfactor, n.rfactor),
+            msg=f"R-factor is not the same {m.rfactor} != {n.rfactor}",
         )
 
     def test_init(self):
@@ -80,8 +79,7 @@ def test_centroid(self):
         m.centroid()
         if len(m.com) != 3:
             logger.error(
-                "center of mass has not been saved correctly : length of COM position vector = %s!=3"
-                % (len(m.com))
+                f"center of mass has not been saved correctly : length of COM position vector = {len(m.com)}!=3"
             )
         mol_centered = m.atoms[:, 0:3] - m.com
         center = mol_centered.mean(axis=0)
@@ -90,8 +88,7 @@ def test_centroid(self):
             norm,
             0,
             12,
-            msg="molecule is not centered : norm of the COM position vector %s!=0"
-            % (norm),
+            msg=f"molecule is not centered : norm of the COM position vector {norm}!=0",
         )
 
     def test_inertia_tensor(self):
@@ -99,15 +96,14 @@ def test_inertia_tensor(self):
         m.inertiatensor()
         tensor = m.inertensor
         assert tensor.shape == (3, 3), (
-            "inertia tensor has not been saved correctly : shape of inertia matrix = %s"
-            % (tensor.shape)
+            f"inertia tensor has not been saved correctly : shape of inertia matrix = {tensor.shape}"
         )
 
     def test_canonical_translate(self):
         m = assign_random_mol()
         trans = m.canonical_translate()
         if trans.shape != (4, 4):
-            logger.error("pb with translation matrix shape: shape=%s" % (trans.shape))
+            logger.error(f"pb with translation matrix shape: shape={trans.shape}")
         com = m.com
         com_componants = [com[0], com[1], com[2]]
         trans_vect = [-trans[0, -1], -trans[1, -1], -trans[2, -1]]
@@ -124,7 +120,7 @@ def test_canonical_rotate(self):
             logger.error("enantiomer has not been selected")
         det = numpy.linalg.det(rot)
         self.assertAlmostEqual(
-            det, 1, 10, msg="rotation matrix determinant is not 1: %s" % (det)
+            det, 1, 10, msg=f"rotation matrix determinant is not 1: {det}"
         )
 
     def test_canonical_parameters(self):
@@ -151,7 +147,7 @@ def test_dist(self):
         m = assign_random_mol()
         n = SASModel(m.atoms)
         distance = m.dist(n, m.atoms, n.atoms)
-        self.assertEqual(distance, 0, msg="NSD different of 0: %s!=0" % (distance))
+        self.assertEqual(distance, 0, msg=f"NSD different of 0: {distance}!=0")
 
     def test_can_transform(self):
         m = assign_random_mol()
@@ -182,7 +178,7 @@ def test_dist_move(self):
         p0 = m.can_param
         dist_after_mvt = m.dist_after_movement(p0, n, [1, 1, 1])
         self.assertEqual(
-            dist_after_mvt, 0, msg="NSD different of 0: %s!=0" % (dist_after_mvt)
+            dist_after_mvt, 0, msg=f"NSD different of 0: {dist_after_mvt}!=0"
         )
 
     def test_reverse_transform(self):
@@ -193,7 +189,7 @@ def test_reverse_transform(self):
         m.atoms = m.transform(m.can_param, [1, 1, 1], reverse=True)
         dist = m.dist(n, m.atoms, n.atoms)
         self.assertAlmostEqual(
-            dist, 0.0, 10, msg="pb with reverse transformation : %s != 0.0" % dist
+            dist, 0.0, 10, msg=f"pb with reverse transformation : {dist} != 0.0"
         )
 
 
diff --git a/src/freesas/test/test_resources.py b/src/freesas/test/test_resources.py
index 13bd3b4..e98a96d 100644
--- a/src/freesas/test/test_resources.py
+++ b/src/freesas/test/test_resources.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -27,9 +26,10 @@
 __license__ = "MIT"
 __date__ = "28/06/2024"
 
-import unittest
 import logging
 import os
+import unittest
+
 from ..resources import resource_filename
 
 logger = logging.getLogger(__name__)
diff --git a/src/freesas/test/test_sas_argparser.py b/src/freesas/test/test_sas_argparser.py
index 713a074..94fe09c 100644
--- a/src/freesas/test/test_sas_argparser.py
+++ b/src/freesas/test/test_sas_argparser.py
@@ -1,6 +1,3 @@
-#!/usr/bin/python
-# coding: utf-8
-
 """Test the functionality of SASParser and GuinierParser"""
 
 __authors__ = ["Martha Brennich"]
@@ -8,14 +5,14 @@
 __date__ = "06/02/2026"
 
 
-import unittest
-import logging
-import io
 import contextlib
+import io
+import logging
+import unittest
 from pathlib import Path
-from .. import dated_version as freesas_version
-from ..sas_argparser import SASParser, GuinierParser
 
+from .. import dated_version as freesas_version
+from ..sas_argparser import GuinierParser, SASParser
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/freesas/test/test_sasio.py b/src/freesas/test/test_sasio.py
index cc641fc..c635afd 100644
--- a/src/freesas/test/test_sasio.py
+++ b/src/freesas/test/test_sasio.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 #
 #    Project: freesas
 #             https://github.com/kif/freesas
@@ -27,14 +26,16 @@
 __license__ = "MIT"
 __date__ = "16/09/2022"
 
-import unittest
-import logging
 import io
-from numpy import array, allclose
+import logging
+import unittest
+
+from numpy import allclose, array
+
 from ..sasio import (
-    parse_ascii_data,
-    load_scattering_data,
     convert_inverse_angstrom_to_nanometer,
+    load_scattering_data,
+    parse_ascii_data,
 )
 
 logger = logging.getLogger(__name__)
diff --git a/src/freesas/test/utilstest.py b/src/freesas/test/utilstest.py
index df8efce..e0933ea 100644
--- a/src/freesas/test/utilstest.py
+++ b/src/freesas/test/utilstest.py
@@ -1,13 +1,12 @@
-#!usr/bin/env python
-# coding: utf-8
-
 __author__ = "Jérôme Kieffer"
 __license__ = "MIT"
 __date__ = "06/02/2026"
 __copyright__ = "2015-2026, ESRF"
 
-import os
+import atexit
 import logging
+import os
+
 from silx.resources import ExternalResources
 
 logger = logging.getLogger("utilstest")
@@ -16,6 +15,16 @@
 )
 
 
+@atexit.register
+def _release_downloader_lock():
+    """Drop the filelock held by the downloader while the interpreter is still alive.
+
+    Left to the interpreter shutdown, `BaseFileLock.__del__` runs after the `os`
+    module globals have been cleared and reports an unraisable TypeError on stderr.
+    """
+    downloader.lock = None
+
+
 def get_datafile(name):
     """Provides the full path of a test file,
     downloading it from the internet if needed
@@ -59,9 +68,7 @@ def configure(self, parsed_options=None):
         environment variables
         """
 
-        if parsed_options is not None and parsed_options.low_mem:
-            self.TEST_LOW_MEM = True
-        elif os.environ.get("FREESAS_LOW_MEM", "True") == "False":
+        if parsed_options is not None and parsed_options.low_mem or os.environ.get("FREESAS_LOW_MEM", "True") == "False":
             self.TEST_LOW_MEM = True
 
         if parsed_options is not None and parsed_options.random:
diff --git a/src/freesas/transformations.py b/src/freesas/transformations.py
index dfd5b58..2b584ef 100644
--- a/src/freesas/transformations.py
+++ b/src/freesas/transformations.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # transformations.py
 
 # Copyright (c) 2006-2015, Christoph Gohlke
@@ -699,7 +698,7 @@ def shear_from_matrix(matrix):
     w, V = numpy.linalg.eig(M33)
     i = numpy.where(abs(numpy.real(w) - 1.0) < 1e-4)[0]
     if len(i) < 2:
-        raise ValueError("no two linear independent eigenvectors found %s" % w)
+        raise ValueError(f"no two linear independent eigenvectors found {w}")
     V = numpy.real(V[:, i]).squeeze().T
     lenorm = -1.0
     for i0, i1 in ((0, 1), (0, 2), (1, 2)):
@@ -1712,7 +1711,7 @@ def arcball_nearest_axis(point, axes):
     "rzyz": (2, 1, 1, 1),
 }
 
-_TUPLE2AXES = dict((v, k) for k, v in _AXES2TUPLE.items())
+_TUPLE2AXES = {v: k for k, v in _AXES2TUPLE.items()}
 
 
 def vector_norm(data, axis=None, out=None):
@@ -1932,7 +1931,7 @@ def _import_module(name, package=None, warn=True, prefix="_py_", ignore="_"):
             module = import_module("." + name, package=package)
     except ImportError:
         if warn:
-            warnings.warn("failed to import module %s" % name)
+            warnings.warn(f"failed to import module {name}")
     else:
         for attr in dir(module):
             if ignore and attr.startswith(ignore):
diff --git a/version.py b/version.py
index af1c4d9..c56eb24 100755
--- a/version.py
+++ b/version.py
@@ -1,8 +1,6 @@
 #!/usr/bin/env python3
-# coding: utf-8
-# /*##########################################################################
 #
-# Copyright (c) 2015-2023 European Synchrotron Radiation Facility
+# Copyright (c) 2015-2026 European Synchrotron Radiation Facility
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +20,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 #
-# ###########################################################################*/
 """Unique place where the version number is defined.
 
 provides:
@@ -52,15 +49,20 @@
 __authors__ = ["Jérôme Kieffer"]
 __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
-__date__ = "11/09/2024"
+__date__ = "02/09/2026"
 __status__ = "production"
 __docformat__ = 'restructuredtext'
-__all__ = ["date", "version_info", "strictversion", "hexversion", "debianversion",
-           "calc_hexversion", "citation"]
-
-
-from collections import namedtuple
-
+__all__ = [
+    "calc_hexversion",
+    "citation",
+    "date",
+    "debianversion",
+    "hexversion",
+    "strictversion",
+    "version_info",
+]
+
+from typing import NamedTuple
 
 RELEASE_LEVEL_VALUE = {"dev": 0,
                        "alpha": 10,
@@ -73,26 +75,37 @@
                               "beta": "b",
                               "candidate": "rc"}
 MAJOR = 2026
-MINOR = 3
+MINOR = 9
 MICRO = 0
-RELEV = "final"  # <16
-SERIAL = 0  # <16
-
+RELEV = "dev"  # <16
+SERIAL = 0     # <16
 date = __date__
 
-_version_info = namedtuple("version_info", ["major", "minor", "micro", "releaselevel", "serial"])
+class _VersionInfo(NamedTuple):
+    major: int
+    minor: int
+    micro: int
+    releaselevel: str
+    serial: int
 
-version_info = _version_info(MAJOR, MINOR, MICRO, RELEV, SERIAL)
+class _DatedVersion(NamedTuple):
+    version: str
+    date: str
 
-strictversion = version = debianversion = "%d.%d.%d" % version_info[:3]
+version_info = _VersionInfo(MAJOR, MINOR, MICRO, RELEV, SERIAL)
 
-_dated_version = namedtuple("dated_version", ["version", "date"])
-dated_version = _dated_version(version=version, date=date)
 
+strictversion = version = debianversion = f"{version_info[0]}.{version_info[1]}.{version_info[2]}"
 if version_info.releaselevel != "final":
-    version += "-%s%s" % version_info[-2:]
-    debianversion += "~adev%i" % version_info[-1] if RELEV == "dev" else "~%s%i" % version_info[-2:]
-    strictversion += PRERELEASE_NORMALIZED_NAME[version_info[3]] + str(version_info[-1])
+    _prerelease = PRERELEASE_NORMALIZED_NAME[version_info[3]]
+    version += f"-{_prerelease}{version_info[-1]}"
+    debianversion += (
+        f"~adev{version_info[-1]}"
+        if RELEV == "dev"
+        else f"~{_prerelease}{version_info[-1]}"
+    )
+    strictversion += _prerelease + str(version_info[-1])
+dated_version = _DatedVersion(version=version, date=date)
 
 
 
@@ -114,7 +127,7 @@ def calc_hexversion(major=0, minor=0, micro=0, releaselevel="dev", serial=0, str
             _PATTERN = re.compile(r"(\d+)\.(\d+)\.(\d+)(\w+)?$")
         result = _PATTERN.match(string)
         if result is None:
-            raise ValueError("'%s' is not a valid version" % string)
+            raise ValueError(f"'{string}' is not a valid version")
         result = result.groups()
         major, minor, micro = int(result[0]), int(result[1]), int(result[2])
         releaselevel = result[3]
@@ -135,7 +148,6 @@ def calc_hexversion(major=0, minor=0, micro=0, releaselevel="dev", serial=0, str
 
 
 hexversion = calc_hexversion(*version_info)
-
 citation = "doi:10.1107/S1600577522007238"
 
 if __name__ == "__main__":