diff --git a/.github/workflows/pylint.yml b/.github/workflows/pylint.yml
new file mode 100644
index 0000000..383e65c
--- /dev/null
+++ b/.github/workflows/pylint.yml
@@ -0,0 +1,23 @@
+name: Pylint
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pylint
+    - name: Analysing the code with pylint
+      run: |
+        pylint $(git ls-files '*.py')
diff --git a/.github/workflows/python-package-mac.yml b/.github/workflows/python-package-mac.yml
index 1755148..5387086 100644
--- a/.github/workflows/python-package-mac.yml
+++ b/.github/workflows/python-package-mac.yml
@@ -12,8 +12,8 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        python-version: ["3.6", "3.7", "3.8", "3.9", "3.10"]
-        xcode-version: [latest-stable, 11]
+        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"]
+        xcode-version: [latest-stable, 14]
 
     steps:
       - uses: actions/checkout@v2
@@ -30,6 +30,7 @@ jobs:
           python -m pip install --upgrade pip
           pip install flake8
           if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+          if [ -f requirements-dev.txt ]; then pip install -r requirements-dev.txt; fi
       - name: Lint with flake8
         run: |
           # stop the build if there are Python syntax errors or undefined names
@@ -41,7 +42,7 @@ jobs:
           pip install .
       - name: Test of run_tests.py
         run: |
-          python setup.py build test
+          python run_tests.py
       - name: Run end to end tests with e2etest.py
         run: |
           mkdir empty
diff --git a/.github/workflows/python-package-ubuntu.yml b/.github/workflows/python-package-ubuntu.yml
index 5fcdd10..c39db49 100644
--- a/.github/workflows/python-package-ubuntu.yml
+++ b/.github/workflows/python-package-ubuntu.yml
@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.6", "3.7", "3.8", "3.9", "3.10"]
+        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"]
 
     steps:
       - uses: actions/checkout@v2
@@ -45,7 +45,7 @@ jobs:
           pip install .
       - name: Test of run_tests.py
         run: |
-          python setup.py build test
+          python run_tests.py
       - name: Run end to end tests with e2etest.py
         run: |
           mkdir empty
diff --git a/bootstrap.py b/bootstrap.py
index f73ff1a..c147415 100755
--- a/bootstrap.py
+++ b/bootstrap.py
@@ -10,73 +10,94 @@
 __authors__ = ["Frédéric-Emmanuel Picca", "Jérôme Kieffer"]
 __contact__ = "jerome.kieffer@esrf.eu"
 __license__ = "MIT"
-__date__ = "09/07/2020"
+__date__ = "03/03/2023"
 
 import sys
 import os
-import distutils.util
 import subprocess
 import logging
-import collections
-from argparse import ArgumentParser
-
+if sys.version_info[:2] < (3, 11):
+    import tomli
+else:
+    import tomllib as tomli
 logging.basicConfig()
 logger = logging.getLogger("bootstrap")
 
 
-def is_debug_python():
-    """Returns true if the Python interpreter is in debug mode."""
-    try:
-        import sysconfig
-    except ImportError:  # pragma nocover
-        # Python < 2.7
-        import distutils.sysconfig as sysconfig
+def get_project_name(root_dir):
+    """Retrieve project name by running python setup.py --name in root_dir.
 
-    if sysconfig.get_config_var("Py_DEBUG"):
-        return True
+    :param str root_dir: Directory where to run the command.
+    :return: The name of the project stored in root_dir
+    """
+    logger.debug("Getting project name in %s", root_dir)
+    with open("pyproject.toml") as f:
+        pyproject = tomli.loads(f.read())
+    return pyproject.get("project", {}).get("name")
 
-    return hasattr(sys, "gettotalrefcount")
 
+def build_project(name, root_dir):
+    """Build locally the project using meson
 
-def _distutils_dir_name(dname="lib"):
-    """
-    Returns the name of a distutils build directory
+    :param str name: Name of the project.
+    :param str root_dir: Root directory of the project
+    :return: The path to the directory were build was performed
     """
-    platform = distutils.util.get_platform()
-    architecture = "%s.%s-%i.%i" % (dname, platform,
-                                    sys.version_info[0], sys.version_info[1])
-    if is_debug_python():
-        architecture += "-pydebug"
-    return architecture
-
-
-def _distutils_scripts_name():
-    """Return the name of the distrutils scripts sirectory"""
-    f = "scripts-{version[0]}.{version[1]}"
-    return f.format(version=sys.version_info)
+    extra = []
+    libdir = "lib"
+    if sys.platform == "win32":
+        libdir = "Lib"
+        # extra = ["--buildtype", "plain"]
+
+    build = os.path.join(root_dir, "build")
+    if not(os.path.isdir(build) and os.path.isdir(os.path.join(build, name))):
+        p = subprocess.Popen(["meson", "setup", "build"],
+                         shell=False, cwd=root_dir, env=os.environ)
+        p.wait()
+    p = subprocess.Popen(["meson", "configure", "--prefix", "/"] + extra,
+                     shell=False, cwd=build, env=os.environ)
+    p.wait()
+    p = subprocess.Popen(["meson", "install", "--destdir", "."],
+                     shell=False, cwd=build, env=os.environ)
+    logger.debug("meson install ended with rc= %s", p.wait())
+
+    home = None
+    if os.environ.get("PYBUILD_NAME") == name:
+        # we are in the debian packaging way
+        home = os.environ.get("PYTHONPATH", "").split(os.pathsep)[-1]
+    if not home:
+        if os.environ.get("BUILDPYTHONPATH"):
+            home = os.path.abspath(os.environ.get("BUILDPYTHONPATH", ""))
+        else:
+            if sys.platform == "win32":
+                home = os.path.join(build, libdir, "site-packages")
+            else:
+                python_version = f"python{sys.version_info.major}.{sys.version_info.minor}"
+                home = os.path.join(build, libdir, python_version, "site-packages")
+            home = os.path.abspath(home)
 
+    cnt = 0
+    while not os.path.isdir(home):
+        cnt += 1
+        home = os.path.split(home)[0]
+    for _ in range(cnt):
+        n = os.listdir(home)[0]
+        home = os.path.join(home, n)
 
-def _get_available_scripts(path):
-    res = []
-    try:
-        res = " ".join([s.rstrip('.py') for s in os.listdir(path)])
-    except OSError:
-        res = ["no script available, did you ran "
-               "'python setup.py build' before bootstrapping ?"]
-    return res
+    logger.warning("Building %s to %s", name, home)
 
+    return home
 
-if sys.version_info[0] >= 3:  # Python3
 
-    def execfile(fullpath, globals=None, locals=None):
-        "Python3 implementation for execfile"
-        with open(fullpath) as f:
-            try:
-                data = f.read()
-            except UnicodeDecodeError:
-                raise SyntaxError("Not a Python script")
-            code = compile(data, fullpath, 'exec')
-            exec(code, globals, locals)
+def execfile(fullpath, globals=None, locals=None):
+    "Python3 implementation for execfile"
+    with open(fullpath) as f:
+        try:
+            data = f.read()
+        except UnicodeDecodeError:
+            raise SyntaxError("Not a Python script")
+        code = compile(data, fullpath, 'exec')
+        exec(code, globals, locals)
 
 
 def run_file(filename, argv):
@@ -117,21 +138,18 @@ def run_file(filename, argv):
         run.wait()
 
 
-def run_entry_point(entry_point, argv):
+def run_entry_point(target_name, entry_point, argv):
     """
     Execute an entry_point using the current python context
-    (http://setuptools.readthedocs.io/en/latest/setuptools.html#automatic-script-creation)
 
     :param str entry_point: A string identifying a function from a module
-        (NAME = PACKAGE.MODULE:FUNCTION [EXTRA])
+        (NAME = PACKAGE.MODULE:FUNCTION)
+    :param argv: list of arguments
     """
     import importlib
-    elements = entry_point.split("=")
-    target_name = elements[0].strip()
-    elements = elements[1].split(":")
+    elements = entry_point.split(":")
     module_name = elements[0].strip()
-    # Take care of entry_point optional "extra" requirements declaration
-    function_name = elements[1].split()[0].strip()
+    function_name = elements[1].strip()
 
     logger.info("Execute target %s (function %s from module %s) using importlib", target_name, function_name, module_name)
     full_args = [target_name]
@@ -163,74 +181,49 @@ def find_executable(target):
     if os.path.isfile(target):
         return ("path", os.path.abspath(target))
 
-    # search the file from setup.py
-    import setup
-    config = setup.get_project_configuration(dry_run=True)
-    # scripts from project configuration
-    if "scripts" in config:
-        for script_name in config["scripts"]:
-            if os.path.basename(script_name) == target:
-                return ("path", os.path.abspath(script_name))
-    # entry-points from project configuration
-    if "entry_points" in config:
-        for kind in config["entry_points"]:
-            for entry_point in config["entry_points"][kind]:
-                elements = entry_point.split("=")
-                name = elements[0].strip()
-                if name == target:
-                    return ("entry_point", entry_point)
-
-    # search the file from env PATH
-    for dirname in os.environ.get("PATH", "").split(os.pathsep):
-        path = os.path.join(dirname, target)
-        if os.path.isfile(path):
-            return ("path", path)
+    # search the executable in pyproject.toml
+    with open(os.path.join(PROJECT_DIR, "pyproject.toml")) as f:
+        pyproject = tomli.loads(f.read())
 
+    scripts = {}
+    scripts.update(pyproject.get("project", {}).get("scripts", {}))
+    scripts.update(pyproject.get("project", {}).get("gui-scripts", {}))
+
+    for script, entry_point in scripts.items():
+        if script == target:
+            print(script, entry_point)
+            return ("entry_point", target, entry_point)
     return None, None
 
 
-def main(argv):
-    parser = ArgumentParser(prog="bootstrap", usage="./bootstrap.py <script>",
-                            description=__doc__)
-    parser.add_argument("script", nargs="*")
-    parser.add_argument("-m", help="run library module as a script (terminates option list)")
+PROJECT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_NAME = get_project_name(PROJECT_DIR)
+logger.info("Project name: %s", PROJECT_NAME)
 
-    Options = collections.namedtuple("Options", ["script", "module"])
-    if len(argv) == 1:
-        options = Options(script=None, module=None)
+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:
-        if argv[1] in ["-h", "--help"]:
-            parser.print_help()
-            return
-        if argv[1] == "-m":
-            if len(argv) < 3:
-                parser.parse_args(argv[1:])
-                return
-            options = Options(script=None, module=argv[2:])
-        else:
-            options = Options(script=argv[1:], module=None)
-
-    if options.script is not None:
-        logger.info("Executing %s from source checkout", options.script)
-        script = options.script[0]
-        argv = options.script[1:]
-        kind, target = find_executable(script)
-        if kind == "path":
-            run_file(target, argv)
-        elif kind == "entry_point":
-            run_entry_point(target, argv)
+        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:]
+        res = find_executable(script)
+        if res[0] == "path":
+            run_file(res[1], argv)
+        elif res[0] == "entry_point":
+            run_entry_point(res[1], res[2], argv)
         else:
-            logger.error("Script %s not found", options.script)
-    elif options.module is not None:
-        logging.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
+            logger.error("Script %s not found", script)
     else:
         logging.info("Running IPython by default")
         logger.info("Patch the sys.argv: %s", sys.argv)
@@ -245,28 +238,3 @@ def main(argv):
         else:
             embed()
 
-
-if __name__ == "__main__":
-    home = os.path.dirname(os.path.abspath(__file__))
-    LIBPATH = os.path.join(home, 'build', _distutils_dir_name('lib'))
-    cwd = os.getcwd()
-    os.chdir(home)
-    build = subprocess.Popen([sys.executable, "setup.py", "build"],
-                         shell=False, cwd=os.path.dirname(os.path.abspath(__file__)))
-    build_rc = build.wait()
-    if not os.path.exists(LIBPATH):
-        logger.warning("`lib` directory does not exist, trying common Python3 lib")
-        LIBPATH = os.path.join(os.path.split(LIBPATH)[0], "lib")
-    os.chdir(cwd)
-
-    if build_rc == 0:
-        logger.info("Build process ended.")
-    else:
-        logger.error("Build process ended with rc=%s", build_rc)
-        sys.exit(-1)
-
-    sys.path.insert(0, LIBPATH)
-    logger.info("Patched sys.path with %s", LIBPATH)
-
-    main(sys.argv)
-
diff --git a/build-deb.sh b/build-deb.sh
index 274431a..e2d8a8a 100755
--- a/build-deb.sh
+++ b/build-deb.sh
@@ -3,7 +3,7 @@
 #    Project: FreeSaS
 #             https://github.com/kif/freesas
 #
-#    Copyright (C) 2015-2020 European Synchrotron Radiation Facility, Grenoble, France
+#    Copyright (C) 2015-2023 European Synchrotron Radiation Facility, Grenoble, France
 #
 #    Principal author:       Jérôme Kieffer (Jerome.Kieffer@ESRF.eu)
 #
@@ -56,12 +56,15 @@ then
             stretch)
                 debian_version=9
                 ;;
-            buster)  
+            buster)
                 debian_version=10
                 ;;
             bullseye)
                 debian_version=11
                 ;;
+            bookworm)
+                debian_version=12
+                ;;
         esac
     fi
 
@@ -78,21 +81,25 @@ build_directory=${project_directory}/build/${target_system}
 if [ -d /usr/lib/ccache ];
 then
    export PATH=/usr/lib/ccache:$PATH
+   export CCACHE_DIR=${HOME}/.ccache
 fi
 
 usage="usage: $(basename "$0") [options]
+
 Build the Debian ${debian_version} package of the ${project} library.
+
 If the build succeed the directory dist/debian${debian_version} will
 contains the packages.
+
 optional arguments:
     --help          Show this help text
     --install       Install the packages generated at the end of
                     the process using 'sudo dpkg'
     --stdeb-py3     Build using stdeb for python3
-    --stdeb-py2.py3 Build using stdeb for python2 and python3
     --debian9       Simulate a debian 9 Stretch system
     --debian10      Simulate a debian 10 Buster system
     --debian11      Simulate a debian 11 Bullseye system
+    --debian12      Simulate a debian 12 Bookworm system
 "
 
 install=0
@@ -141,6 +148,13 @@ do
           build_directory=${project_directory}/build/${target_system}
           shift
           ;;
+      --debian12)
+          debian_version=12
+          target_system=debian${debian_version}
+          dist_directory=${project_directory}/dist/${target_system}
+          build_directory=${project_directory}/build/${target_system}
+          shift
+          ;;
       -*)
           echo "Error: Unknown option: $1" >&2
           echo "$usage"
@@ -164,30 +178,38 @@ clean_up()
 build_deb() {
     tarname=${project}_${debianversion}.orig.tar.gz
     clean_up
-    python3 setup.py debian_src
-    python3 setup.py testdata
+    if [ $debian_version -le 11 ]
+    then
+       python3 setup.py debian_src
+       directory=${project}-${strictversion}
+    else
+       python3 -m build -s
+       echo ${source_project}-${strictversion}.tar.gz dist/${tarname}
+       ln -s ${source_project}-${strictversion}.tar.gz dist/${tarname}
+       directory=${source_project}-${strictversion}
+    fi
     cp -f dist/${tarname} ${build_directory}
     if [ -f dist/${project}-testimages.tar.gz ]
     then
       cp -f dist/${project}-testimages.tar.gz ${build_directory}
     fi
-    
+
     cd ${build_directory}
     tar -xzf ${tarname}
-    
-    directory=${project}-${strictversion}
+
+
     newname=${deb_name}_${debianversion}.orig.tar.gz
-    
-    #echo tarname $tarname newname $newname
+
+    echo tarname $tarname newname $newname
     if [ $tarname != $newname ]
     then
       if [ -h $newname ]
       then
         rm ${newname}
       fi
-        ln -s ${tarname} ${newname}
+      ln -s ${tarname} ${newname}
     fi
-    
+
     if [ -f ${project}-testimages.tar.gz ]
     then
       if [ ! -h  ${deb_name}_${debianversion}.orig-testimages.tar.gz ]
@@ -195,27 +217,23 @@ build_deb() {
         ln -s ${project}-testimages.tar.gz ${deb_name}_${debianversion}.orig-testimages.tar.gz
       fi
     fi
-    
+
     cd ${directory}
     cp -r ${project_directory}/package/${target_system} debian
     cp ${project_directory}/copyright debian
-    
+
     #handle test images
     if [ -f ../${deb_name}_${debianversion}.orig-testimages.tar.gz ]
     then
-      if [ ! -d testimages ]
-      then
-        mkdir testimages
-      fi
-      cd testimages
-      tar -xzf  ../../${deb_name}_${debianversion}.orig-testimages.tar.gz
-      cd ..
+        cd ..
+        tar -xzf  ${deb_name}_${debianversion}.orig-testimages.tar.gz
+        cd -
     else
       # Disable to skip tests during build
       echo No test data
-      #export PYBUILD_DISABLE_python2=test
-      #export PYBUILD_DISABLE_python3=test
-      #export DEB_BUILD_OPTIONS=nocheck
+      export PYBUILD_DISABLE_python2=test
+      export PYBUILD_DISABLE_python3=test
+      export DEB_BUILD_OPTIONS=nocheck ${DEB_BUILD_OPTIONS} 
     fi
 
     case $debian_version in
@@ -228,14 +246,17 @@ build_deb() {
         11)
             debian_name=bullseye
             ;;
+        12)
+            debian_name=bookworm
+            ;;
     esac
 
-    dch --force-distribution  -v ${debianversion}-1 "upstream development build of ${project} ${version}"
+    dch --force-distribution -v ${debianversion}-1 "upstream development build of ${project} ${version}"
     dch --force-distribution -D ${debian_name}-backports -l~bpo${debian_version}+ "${project} snapshot ${version} built for ${target_system}"
     #dch --bpo "${project} snapshot ${version} built for ${target_system}"
     dpkg-buildpackage -r
     rc=$?
-    
+
     if [ $rc -eq 0 ]; then
       # move packages to dist directory
       echo Build succeeded...
@@ -264,7 +285,8 @@ build_stdeb () {
     tar -xzf ${tarname}
     cd ${project}-${strictversion}
 
-    if [ $stdeb_all_python -eq 1 ]; then
+    if [ $stdeb_all_python -eq 1  ]
+    then
       echo Using Python 2+3
       python3 setup.py --command-packages=stdeb.command sdist_dsc --with-python2=True --with-python3=True --no-python3-scripts=True build --no-cython bdist_deb
       rc=$?
@@ -293,7 +315,7 @@ fi
 
 
 if [ $install -eq 1 ]; then
-  sudo -- su -c  "dpkg -i ${dist_directory}/*.deb"
+  sudo su -c  "dpkg -i ${dist_directory}/*.deb"
 fi
 
 exit "$rc"
diff --git a/build-doc.py b/build-doc.py
new file mode 100755
index 0000000..c1e1a66
--- /dev/null
+++ b/build-doc.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+import os
+import sys
+import logging
+import bootstrap
+from sphinx.cmd.build import main
+logger = logging.getLogger(__name__)
+PROJECT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_NAME = bootstrap.get_project_name(PROJECT_DIR)
+logger.info("Project name: %s", PROJECT_NAME)
+LIBPATH = bootstrap.build_project(PROJECT_NAME, PROJECT_DIR)
+if __name__ == '__main__':
+    sys.path.insert(0, LIBPATH)
+    os.environ["PYTHONPATH"]=os.pathsep.join(sys.path)
+    print(os.environ["PYTHONPATH"])
+    dest_dir = os.path.join(PROJECT_DIR, "build", "sphinx")
+    if not os.path.isdir(dest_dir):
+        os.makedirs(dest_dir)
+    argv = ["-b", "html",
+            os.path.join(PROJECT_DIR,"doc","source"),
+            dest_dir ]
+    print(f"run sphinx with those arguments {argv}")
+    sys.exit(main(argv)) 
diff --git a/doc/source/conf.py b/doc/source/conf.py
index 7edcce1..909da52 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -102,6 +102,7 @@
     'sphinx.ext.viewcode',
     'sphinx.ext.doctest',
     # 'sphinxext-archive',
+    'sphinxcontrib.programoutput',
     'nbsphinx'
 
 ]
diff --git a/doc/source/dummy_atom_model.rst b/doc/source/dummy_atom_model.rst
index fb02ee9..8cab8cd 100644
--- a/doc/source/dummy_atom_model.rst
+++ b/doc/source/dummy_atom_model.rst
@@ -141,7 +141,7 @@ SuPyComb script
 
 | Several options are available for the supycomb program:
 
-.. command-output:: supycomb.py --help
+.. command-output:: supycomb --help
 
 | Slow mode / fast mode:
 | For the slow mode, the optimization of the NSD is done for each symmetry
diff --git a/e2etest/e2etest_bift.py b/e2etest/e2etest_bift.py
index 3addf24..ec077d9 100644
--- a/e2etest/e2etest_bift.py
+++ b/e2etest/e2etest_bift.py
@@ -2,7 +2,7 @@
 
 __authors__ = ["Martha Brennich"]
 __license__ = "MIT"
-__date__ = "16/07/2021"
+__date__ = "29/11/2023"
 
 import unittest
 import pathlib
@@ -14,7 +14,7 @@
 import codecs
 import parse
 from numpy import loadtxt
-from freesas.test.utilstests import get_datafile
+from freesas.test.utilstest import get_datafile
 
 logger = logging.getLogger(__name__)
 
diff --git a/e2etest/e2etest_cormap.py b/e2etest/e2etest_cormap.py
index c5abc77..758317e 100644
--- a/e2etest/e2etest_cormap.py
+++ b/e2etest/e2etest_cormap.py
@@ -2,7 +2,7 @@
 
 __authors__ = ["Martha Brennich"]
 __license__ = "MIT"
-__date__ = "02/04/2022"
+__date__ = "29/11/2023"
 
 import unittest
 import pathlib
@@ -11,7 +11,7 @@
 from subprocess import run, PIPE, STDOUT
 from os import linesep
 from os.path import normpath
-from freesas.test.utilstests import get_datafile
+from freesas.test.utilstest import get_datafile
 
 logger = logging.getLogger(__name__)
 
diff --git a/e2etest/e2etest_freesas.py b/e2etest/e2etest_freesas.py
index 19ff14b..2de4059 100644
--- a/e2etest/e2etest_freesas.py
+++ b/e2etest/e2etest_freesas.py
@@ -25,7 +25,7 @@
 
 __authors__ = ["Martha Brennich"]
 __license__ = "MIT"
-__date__ = "16/07/2021"
+__date__ = "29/11/2023"
 
 import unittest
 import pathlib
@@ -34,7 +34,7 @@
 from subprocess import run, Popen, PIPE, STDOUT
 from os import linesep
 import PyPDF2
-from freesas.test.utilstests import get_datafile
+from freesas.test.utilstest import get_datafile
 
 logger = logging.getLogger(__name__)
 
diff --git a/e2etest/e2etest_guinier_apps.py b/e2etest/e2etest_guinier_apps.py
index d07f3f5..3a0893b 100644
--- a/e2etest/e2etest_guinier_apps.py
+++ b/e2etest/e2etest_guinier_apps.py
@@ -2,7 +2,7 @@
 
 __authors__ = ["Martha Brennich"]
 __license__ = "MIT"
-__date__ = "16/07/2021"
+__date__ = "29/11/2023"
 
 import unittest
 import pathlib
@@ -11,7 +11,7 @@
 from os import linesep
 from os.path import normpath
 from platform import system
-from freesas.test.utilstests import get_datafile
+from freesas.test.utilstest import get_datafile
 logger = logging.getLogger(__name__)
 
 
diff --git a/freesas/_distance.pyx b/freesas/_distance.pyx
deleted file mode 100644
index d93fc3a..0000000
--- a/freesas/_distance.pyx
+++ /dev/null
@@ -1,79 +0,0 @@
-#Cython module to calculate distances of set of atoms
-
-__author__ = "Jerome Kieffer"
-__license__ = "MIT"
-__copyright__ = "2015, ESRF"
-
-import sys
-import cython
-cimport numpy
-import numpy
-from cython cimport floating
-from libc.math cimport sqrt, fabs, exp
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-def calc_invariants(floating[:, :] atoms):
-    """
-    Calculate the invariants of the structure, i.e fineness, radius of gyration and diameter of the model.
-
-    Nota: to economize size*numpy.sqrt, the sqrt is taken at the end of the calculation. 
-    We should have done s += sqrt(d) and then s/size, but we do s+= d and then sqrt(s/size).
-    You can check that the result is the same.
-
-    @param atoms: 2d-array with atom coordinates:[[x,y,z],...]
-    @return: 3-tuple containing (fineness, Rg, Dmax)
-        * average distance between an atoms and its nearest neighbor
-        * radius of gyration of the model
-        * diameter of the model
-    """
-    cdef:
-        int i, j, size
-        floating d, x1, y1, z1, dx, dy, dz, big, d2, sum_d2, d2max
-    size = atoms.shape[0]
-    assert atoms.shape[1] >= 3
-    big = sys.maxsize
-    s = 0.0
-    sum_d2 = 0.0 
-    d2max = 0.0
-    for i in range(size):
-        x1 = atoms[i, 0]
-        y1 = atoms[i, 1]
-        z1 = atoms[i, 2]
-        d = big
-        for j in range(size):
-            if i == j:
-                continue
-            dx = atoms[j, 0] - x1
-            dy = atoms[j, 1] - y1
-            dz = atoms[j, 2] - z1
-            d2 = dx * dx + dy * dy + dz * dz
-            sum_d2 += d2
-            d2max = max(d2max, d2)
-            d = min(d, d2)
-        s += d
-    return sqrt(s / size), sqrt(sum_d2 / 2.0) / size, sqrt(d2max)
-
-
-cdef inline floating hard_sphere(floating pos, floating radius)nogil:
-    """Density using hard spheres
-    @param pos: fabs(d1-d)
-    """
-    if pos > 2.0 * radius:
-        return 0.0 
-    return (4 * radius + pos) * (2 * radius - pos) ** 2 / (16.0 * radius ** 3)
-
-cdef inline floating soft_sphere(floating pos, floating radius)nogil:
-    """Density using soft spheres (gaussian density)
-    @param pos: fabs(d1-d)
-    @param radius: radius of the equivalent hard sphere
-    """
-    cdef floating sigma = 0.40567 * radius
-    return exp(- pos * pos / (2.0 * sigma * sigma)) * 0.3989422804014327 / sigma
-
-
-IF HAVE_OPENMP:
-    include "_distance_omp.pxi"
-ELSE:
-    include "_distance_nomp.pxi"
diff --git a/freesas/_distance_omp.pxi b/freesas/_distance_omp.pxi
deleted file mode 100644
index 32139d2..0000000
--- a/freesas/_distance_omp.pxi
+++ /dev/null
@@ -1,108 +0,0 @@
-#OpenMP version of distance calculation
-
-from cython import parallel
-cimport openmp 
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-def calc_distance(floating[:, :] atoms1, floating[:, :] atoms2, floating fineness1, floating fineness2):
-    """
-    Calculate the Normalized Spatial Discrepancy (NSD) between two molecules
-    
-    @param atoms1,atoms2: 2d-array with atom coordinates[[x,y,z],...]
-    @param fineness1, fineness2: fineness of each molecule
-    @return: NSD atoms1-atoms2
-    """
-    
-    cdef:
-        int i, j, size1 = atoms1.shape[0], size2 = atoms2.shape[0]
-        int threadid, numthreads = openmp.omp_get_max_threads() 
-        double d, d2, dx, dy, dz, x1, y1, z1
-        double s1 = 0.0, s2 = 0.0, big = sys.maxsize
-        double[:, ::1] min_col = numpy.zeros((numthreads, size2), numpy.float64) + big
-    assert atoms1.shape[1] >= 3
-    assert atoms2.shape[1] >= 3
-    assert size1 > 0
-    assert size2 > 0
-    
-    for i in parallel.prange(size1, nogil=True):
-        threadid = parallel.threadid()
-        x1 = atoms1[i, 0]
-        y1 = atoms1[i, 1]
-        z1 = atoms1[i, 2]
-        d = big
-        for j in range(size2):            
-            dx = atoms2[j, 0] - x1
-            dy = atoms2[j, 1] - y1
-            dz = atoms2[j, 2] - z1
-            d2 = dx * dx + dy * dy + dz * dz
-            d = min(d, d2)
-            min_col[threadid, j] = min(min_col[threadid, j], d2) 
-        s1 += d
-    for j in parallel.prange(size2, nogil=True):
-        d = big
-        for i in range(numthreads):
-            d = min(d, min_col[i, j])
-        s2 += d
-
-    return sqrt(0.5 * ((1.0 / (size1 * fineness2 * fineness2)) * s1 + (1.0 / (size2 * fineness1 * fineness1)) * s2))
-
-
-@cython.wraparound(False)
-@cython.boundscheck(False)
-@cython.cdivision(True)
-def calc_density(floating[:, :] atoms, floating dmax, int npt, floating r=0.0, bint hard=True):
-    """
-    Calculate the density rho(r)
-    
-    #TODO: formula for rigid sphere:
-    A = (4*R+d)*(2*R-d)**2/16.0/R**3
-    
-    @param atoms: 2d-array with atom coordinates[[x,y,z],...]
-    @param dmax: Diameter of the model
-    @param npt: number of point in the density
-    @param r: radius of an atom
-    @param hard: use hard spheres model
-    @return: 1d-array of 
-    """
-    
-    cdef:
-        int i, j, k, size = atoms.shape[0]        
-        int threadid, numthreads = openmp.omp_get_max_threads()
-        int width = 1 if hard else 2 
-        floating d, dmax_plus, dx, dy, dz, x1, y1, z1
-        floating delta, d_min, d_max, d1, den 
-        double[:, ::1] tmp = numpy.zeros((numthreads, npt), numpy.float64)
-        double[::1] out = numpy.zeros(npt, numpy.float64)
-        double s
-        
-    assert atoms.shape[1] >= 3
-    assert size > 0
-    assert dmax > 0
-    dmax_plus = dmax * (1.0 + numpy.finfo(numpy.float32).eps)
-    delta = dmax_plus / npt
-    
-    for i in parallel.prange(size, nogil=True):
-        threadid = parallel.threadid()
-        x1 = atoms[i, 0]
-        y1 = atoms[i, 1]
-        z1 = atoms[i, 2]
-        for j in range(size):
-            dx = atoms[j, 0] - x1
-            dy = atoms[j, 1] - y1
-            dz = atoms[j, 2] - z1
-            d = sqrt(dx * dx + dy * dy + dz * dz)
-            d_min = max(0.0, d - width * r)
-            d_max = min(dmax, d + width * r)
-            for k in range(<int>(d_min / delta), <int>(d_max / delta)+1):
-                if hard:
-                    tmp[threadid, k] += hard_sphere(fabs(k * delta - d), r)
-                else:
-                    tmp[threadid, k] += soft_sphere(fabs(k * delta - d), r)
-    for j in parallel.prange(npt, nogil=True):
-        s = 0
-        for i in range(numthreads):
-            s = s + tmp[i, j]
-        out[j] += s
-
-    return numpy.asarray(out)
diff --git a/freesas/setup.py b/freesas/setup.py
deleted file mode 100644
index c5101fb..0000000
--- a/freesas/setup.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# coding: utf-8
-# /*##########################################################################
-# Copyright (C) 2016-2018 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
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ############################################################################*/
-
-__authors__ = ["V. Valls"]
-__license__ = "MIT"
-__date__ = "12/05/2020"
-
-from numpy.distutils.misc_util import Configuration
-import platform
-import os
-import numpy
-
-
-def create_extension_config(name, extra_sources=None, can_use_openmp=False):
-    """
-    Util function to create numpy extension from the current pyFAI project.
-    Prefer using numpy add_extension without it.
-    """
-    include_dirs = [numpy.get_include()]
-
-    if can_use_openmp:
-        extra_link_args = ['-fopenmp']
-        extra_compile_args = ['-fopenmp']
-    else:
-        extra_link_args = []
-        extra_compile_args = ["-ftree-vectorize"]
-
-    sources = ["%s.pyx" % name]
-    if extra_sources is not None:
-        sources.extend(extra_sources)
-
-    config = dict(
-        name=name,
-        sources=sources,
-        include_dirs=include_dirs,
-        language='c',
-        extra_link_args=extra_link_args,
-        extra_compile_args=extra_compile_args
-    )
-
-    return config
-
-
-def configuration(parent_package='', top_path=None):
-    config = Configuration('freesas', parent_package, top_path)
-
-    ext_modules = [
-        create_extension_config("_distance", can_use_openmp=True),
-        create_extension_config("_cormap", can_use_openmp=False),
-        create_extension_config("_autorg", can_use_openmp=False),
-        create_extension_config("_bift", can_use_openmp=False),
-    ]
-
-    for ext_config in ext_modules:
-        config.add_extension(**ext_config)
-
-    config.add_subpackage('test')
-    config.add_subpackage('app')
-
-    return config
-
-
-if __name__ == "__main__":
-    from numpy.distutils.core import setup
-    setup(configuration=configuration)
diff --git a/freesas/test/utilstests.py b/freesas/test/utilstests.py
deleted file mode 100644
index d899f57..0000000
--- a/freesas/test/utilstests.py
+++ /dev/null
@@ -1,24 +0,0 @@
-#!usr/bin/env python
-# coding: utf-8
-
-__author__ = "Jérôme Kieffer"
-__license__ = "MIT"
-__date__ = "19/07/2021"
-__copyright__ = "2015-2021, ESRF"
-
-import logging
-logger = logging.getLogger("utilstest")
-from silx.resources import ExternalResources
-downloader = ExternalResources("freesas", "http://www.silx.org/pub/freesas/testdata", "FREESAS_TESTDATA")
-
-
-def get_datafile(name):
-    """Provides the full path of a test file,
-    downloading it from the internet if needed
-
-    :param name: name of the file to get
-    :return: full path of the datafile
-    """
-    logger.info(f"Download file {name}")
-    fullpath = downloader.getfile(name)
-    return fullpath
diff --git a/meson.build b/meson.build
new file mode 100644
index 0000000..8aab68b
--- /dev/null
+++ b/meson.build
@@ -0,0 +1,24 @@
+project('FreeSAS',
+  'c', 'cython',
+  license: 'MIT',
+  version: run_command(['src/freesas/_version.py', '--wheel'],
+   			           check:true).stdout().strip(),
+)
+
+# Seek the backend
+if meson.backend() != 'ninja'
+  error('Ninja backend required')
+endif
+
+cc = meson.get_compiler('c')
+m_dep = cc.find_library('m', required : false)
+if m_dep.found()
+  add_project_link_arguments('-lm', language : 'c')
+endif
+
+# https://mesonbuild.com/Python-module.html
+py_mod = import('python')
+py = py_mod.find_installation()
+py_dep = py.dependency()
+
+subdir('src/freesas')
diff --git a/package/debian12/changelog b/package/debian12/changelog
new file mode 100644
index 0000000..9c0d0d7
--- /dev/null
+++ b/package/debian12/changelog
@@ -0,0 +1,5 @@
+freesas (0.7.0-1) unstable; urgency=low
+
+  * Initial release (Closes: #??????)
+
+ -- Jerome Kieffer <jerome.kieffer@esrf.fr>  Fri, 31 Aug 2017 11:00:20 +0100
diff --git a/package/debian12/clean b/package/debian12/clean
new file mode 100644
index 0000000..668a363
--- /dev/null
+++ b/package/debian12/clean
@@ -0,0 +1 @@
+*.egg-info/*
\ No newline at end of file
diff --git a/package/debian12/compat b/package/debian12/compat
new file mode 100644
index 0000000..f599e28
--- /dev/null
+++ b/package/debian12/compat
@@ -0,0 +1 @@
+10
diff --git a/package/debian12/control b/package/debian12/control
new file mode 100644
index 0000000..5eab425
--- /dev/null
+++ b/package/debian12/control
@@ -0,0 +1,68 @@
+Source: freesas
+Maintainer: Debian Science Maintainers <debian-science-maintainers@lists.alioth.debian.org>
+Uploaders: Jerome Kieffer <jerome.kieffer@esrf.fr>,
+           Picca Frédéric-Emmanuel <picca@debian.org>
+Section: science
+Priority: extra
+Build-Depends: cython3,
+               debhelper,
+               dh-python,
+               devscripts,
+               python3-tomli,
+               python3-mesonpy,
+               python3-all-dev,               
+               python3-numpy,
+               python3-matplotlib,
+               python3-scipy,
+               python3-sphinx,
+               python3-nbsphinx,
+               python3-sphinxcontrib.programoutput,
+               python3-sphinx-rtd-theme,
+               python3-silx,
+               python3-pyfai,
+               openstack-pkg-tools,
+               help2man
+Standards-Version: 3.9.8
+Vcs-Browser: https://anonscm.debian.org/cgit/debian-science/packages/freesas.git
+Vcs-Git: git://anonscm.debian.org/debian-science/packages/freesas.git
+Homepage: https://github.com/kif/freesas
+X-Python3-Version: >= 3.7
+
+Package: freesas
+Architecture: all
+Depends: ${misc:Depends},
+         ${python:Depends},
+         ${shlibs:Depends},
+         python3-pkg-resources,
+         python3-freesas (>= ${source:Version})
+Description: Free tools for small angle scattering analysis - Executables
+ .
+ This uses the Python 3 version of the package.
+
+
+Package: python3-freesas
+Architecture: any
+Section: python
+Depends: ${misc:Depends},
+         ${python3:Depends},
+         ${shlibs:Depends},
+         python3-numpy,
+         python3-matplotlib,
+         python3-scipy,
+         python3-six,
+         python3-pyfai
+# Recommends:
+# Suggests: python3-rfoo
+Description: Free tools for small angle scattering analysis - Python3
+ .
+ This is the Python 3 version of the package.
+
+
+Package: freesas-doc
+Architecture: all
+Section: doc
+Depends: ${misc:Depends},
+         ${sphinxdoc:Depends}
+Description: Free tools for small angle scattering analysis - Documentation
+ .
+ This is the common documentation package.
diff --git a/package/debian12/gbp.conf b/package/debian12/gbp.conf
new file mode 100644
index 0000000..f68d262
--- /dev/null
+++ b/package/debian12/gbp.conf
@@ -0,0 +1,2 @@
+[DEFAULT]
+debian-branch = master
\ No newline at end of file
diff --git a/package/debian12/python-freesas-doc.doc-base b/package/debian12/python-freesas-doc.doc-base
new file mode 100644
index 0000000..b77cb80
--- /dev/null
+++ b/package/debian12/python-freesas-doc.doc-base
@@ -0,0 +1,9 @@
+Document: freesas-manual
+Title: freesas documentation manual
+Author: Jérôme Kieffer <jerome.kieffer@esrf.eu>
+Abstract: Toolbox for X-Ray data analysis 
+Section: Science/Data Analysis
+
+Format: HTML
+Index: /usr/share/doc/python-freesas-doc/html/index.html
+Files: /usr/share/doc/python-freesas-doc/html/*
diff --git a/package/debian12/rules b/package/debian12/rules
new file mode 100755
index 0000000..ad49325
--- /dev/null
+++ b/package/debian12/rules
@@ -0,0 +1,41 @@
+#!/usr/bin/make -f
+
+export DH_VERBOSE=1
+export PYBUILD_NAME=freesas
+export PYBUILD_SYSTEM=pyproject
+
+# Make does not offer a recursive wildcard function, so here's one:
+rwildcard=$(wildcard $1$2) $(foreach d,$(wildcard $1*),$(call rwildcard,$d/,$2))
+
+# How to recursively find all files with the same name in a given folder
+ALL_PYX := $(call rwildcard,src,*.pyx)
+#NOTA: No space before *
+
+%:
+	dh $@ --with python3,sphinxdoc --buildsystem=pybuild
+
+override_dh_clean:
+	dh_clean
+	# remove the cython generated file to force rebuild
+	rm -f $(patsubst %.pyx,%.cpp,${ALL_PYX})
+	rm -f $(patsubst %.pyx,%.c,${ALL_PYX})
+	rm -f $(patsubst %.pyx,%.html,${ALL_PYX})
+	rm -rf build/html
+	rm -rf build/man
+	rm -rf *.egg-info
+
+override_dh_install:
+	dh_numpy3
+
+	# move the scripts to right package
+	dh_install -p freesas debian/python3-freesas/usr/bin/* usr/bin
+	rm -rf debian/python3-freesas/usr/bin
+	dh_install
+
+override_dh_auto_test:
+	dh_auto_test -- -s custom --test-args="env PYTHONPATH={build_dir} FREESAS_TESTDATA=../testdata {interpreter} run_tests.py -v"
+
+override_dh_installdocs:
+	python3 build-doc.py
+	dh_installdocs "build/sphinx" -p freesas-doc
+	dh_installdocs
diff --git a/package/debian12/source/format b/package/debian12/source/format
new file mode 100644
index 0000000..163aaf8
--- /dev/null
+++ b/package/debian12/source/format
@@ -0,0 +1 @@
+3.0 (quilt)
diff --git a/package/debian12/source/options b/package/debian12/source/options
new file mode 100644
index 0000000..6e88e49
--- /dev/null
+++ b/package/debian12/source/options
@@ -0,0 +1 @@
+extend-diff-ignore="^[^/]+\.egg-info/"
\ No newline at end of file
diff --git a/package/debian12/watch b/package/debian12/watch
new file mode 100644
index 0000000..8f43589
--- /dev/null
+++ b/package/debian12/watch
@@ -0,0 +1,5 @@
+version=3
+opts=repacksuffix=+dfsg,\
+uversionmangle=s/(rc|a|b|c)/~$1/,\
+dversionmangle=s/\+dfsg// \
+http://pypi.debian.net/freesas/freesas-(.+)\.(?:zip|tgz|tbz|txz|(?:tar\.(?:gz|bz2|xz)))
diff --git a/pyproject.toml b/pyproject.toml
index 482cc8d..ae32867 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,9 +1,73 @@
+[project]
+name = 'freesas'
+dynamic = ['version',]
+license = {file = 'copyright'}
+requires-python = '>=3.7'
+readme = 'README.md'
+description = 'Small angle scattering tools ... but unlike most others, free and written in Python'
+
+authors = [
+  { name = 'Guillaume Bonamis'}, 
+  { name = 'Martha Brennich'},
+  { name = 'Jérôme Kieffer', email = 'jerome.kieffer@esrf.fr'},
+]
+classifiers = [
+    'Development Status :: 5 - Production/Stable',
+    'Environment :: Console',
+    'Intended Audience :: Developers',
+    'Intended Audience :: Education',
+    'Intended Audience :: Science/Research',
+    'License :: OSI Approved :: MIT License',
+    'Natural Language :: English',
+    'Operating System :: MacOS :: MacOS X',
+    'Operating System :: Microsoft :: Windows',
+    'Operating System :: Unix',
+    'Operating System :: POSIX',
+    'Programming Language :: Cython',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: Implementation :: CPython',
+    'Topic :: Scientific/Engineering :: Physics',
+    'Topic :: Software Development :: Libraries :: Python Modules',
+    'Topic :: Scientific/Engineering :: Bio-Informatics',
+]
+
+dependencies = [
+   'numpy',
+   'scipy',
+   'matplotlib'
+]
 [build-system]
+build-backend = 'mesonpy'
 requires = [
-    "wheel",
-    "setuptools<60.0.0",
-    "numpy>=1.12",
-    "Cython>=0.21.1",
-    "scipy",
+    'meson-python>=0.11',
+    "meson>=0.64; platform_system=='Windows'",
+    "meson>=0.63; platform_system!='Windows'",
+    'ninja',
+    'wheel',
+    'Cython>=0.29',
+    "numpy<1.26.0; platform_machine == 'ppc64le'",
+    "numpy; platform_machine != 'ppc64le'",
+    'pyproject-metadata>=0.5.0',
+    'tomli>=1.0.0',
+    'scipy'
 ]
-build-backend = "setuptools.build_meta"
+
+[project.urls]
+homepage = 'http://silx.org'
+documentation = 'http://www.silx.org/doc/freesas/latest/'
+source = 'https://github.com/silx-kit/freeas'
+download = 'https://github.com/silx-kit/freesas/releases'
+tracker = 'https://github.com/silx-kit/freesas/issues'
+
+[project.scripts]
+free_gpa = 'freesas.app.auto_gpa:main'
+free_guinier = 'freesas.app.auto_guinier:main'
+free_rg = 'freesas.app.autorg:main'
+cormapy = 'freesas.app.cormap:main'
+supycomb = 'freesas.app.supycomb:main'
+free_bift = 'freesas.app.bift:main'
+extract_ascii = 'freesas.app.extract_ascii:main'
+
+[project.gui-scripts]
+freesas = 'freesas.app.plot_sas:main'
+
diff --git a/requirements-dev.txt b/requirements-dev.txt
index edea7bc..120a6b0 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -2,4 +2,6 @@ coverage
 lxml
 sphinx
 sphinx-rtd-theme
-nbsphinx
\ No newline at end of file
+nbsphinx
+meson
+ninja
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index de95a4b..2e7b671 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,7 +1,8 @@
 numpy
 scipy
 cython
-setuptools<60
+tomli; python_version < '3.12'  
 matplotlib
 silx
 pyFAI
+meson-python
diff --git a/run_tests.py b/run_tests.py
old mode 100644
new mode 100755
index 9639914..ca697bc
--- a/run_tests.py
+++ b/run_tests.py
@@ -2,7 +2,7 @@
 # coding: utf-8
 # /*##########################################################################
 #
-# Copyright (c) 2015-2018 European Synchrotron Radiation Facility
+# Copyright (C) 2015-2023 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,18 +32,18 @@
 """
 
 __authors__ = ["Jérôme Kieffer", "Thomas Vincent"]
-__date__ = "16/04/2020"
+__date__ = "29/11/2023"
 __license__ = "MIT"
 
-import distutils.util
+import sys
 import logging
+logging.basicConfig(level=logging.INFO)
 import os
-import subprocess
-import sys
+from argparse import ArgumentParser
 import time
 import unittest
 import collections
-from argparse import ArgumentParser
+import tempfile
 
 
 class StreamHandlerUnittestReady(logging.StreamHandler):
@@ -80,14 +80,14 @@ def createBasicHandler():
 # Capture all default warnings
 logging.captureWarnings(True)
 import warnings
-
-warnings.simplefilter("default")
+warnings.simplefilter('default')
 
 logger = logging.getLogger("run_tests")
 logger.setLevel(logging.WARNING)
 
 logger.info("Python %s %s", sys.version, tuple.__itemsize__ * 8)
-
+if sys.version_info.major < 3:
+    logger.error("freesas no more support Python2")
 
 try:
     import resource
@@ -95,9 +95,19 @@ def createBasicHandler():
     resource = None
     logger.warning("resource module missing")
 
-import importlib
+try:
+    import importlib
+    importer = importlib.import_module
+except ImportError:
 
-importer = importlib.import_module
+    def importer(name):
+        module = __import__(name)
+        # returns the leaf module, instead of the root module
+        subnames = name.split(".")
+        subnames.pop(0)
+        for subname in subnames:
+            module = getattr(module, subname)
+            return module
 
 try:
     import numpy
@@ -106,6 +116,20 @@ def createBasicHandler():
 else:
     logger.info("Numpy %s", numpy.version.version)
 
+try:
+    import scipy
+except ImportError:
+    logger.warning("Scipy missing")
+else:
+    logger.info("Scipy %s from %s", scipy.version.version, scipy.__path__)
+
+try:
+    import fabio
+except ImportError:
+    logger.warning("FabIO missing")
+else:
+    logger.info("FabIO %s", fabio.version)
+
 try:
     import h5py
 except Exception as error:
@@ -113,23 +137,17 @@ def createBasicHandler():
 else:
     logger.info("h5py %s", h5py.version.version)
 
+try:
+    import Cython
+except ImportError:
+    logger.warning("Cython missing")
+else:
+    logger.info("Cython %s", Cython.__version__)
 
-def get_project_name(root_dir):
-    """Retrieve project name by running python setup.py --name in root_dir.
-
-    :param str root_dir: Directory where to run the command.
-    :return: The name of the project stored in root_dir
-    """
-    logger.debug("Getting project name in %s", root_dir)
-    p = subprocess.Popen(
-        [sys.executable, "setup.py", "--name"],
-        shell=False,
-        cwd=root_dir,
-        stdout=subprocess.PIPE,
-    )
-    name, _stderr_data = p.communicate()
-    logger.debug("subprocess ended with rc= %s", p.returncode)
-    return name.split()[-1].decode("ascii")
+PROJECT_DIR = os.path.dirname(os.path.abspath(__file__))
+from bootstrap import get_project_name, build_project
+PROJECT_NAME = get_project_name(PROJECT_DIR)
+logger.info("Project name: %s", PROJECT_NAME)
 
 
 class TextTestResultWithSkipList(unittest.TextTestResult):
@@ -154,14 +172,13 @@ def printGroupedList(self, flavour, errors):
         for err, tests in grouped.items():
             self.stream.writeln(self.separator1)
             for test in tests:
-                self.stream.writeln(
-                    "%s: %s" % (flavour, self.getDescription(test))
-                )
+                self.stream.writeln("%s: %s" % (flavour, self.getDescription(test)))
             self.stream.writeln(self.separator2)
             self.stream.writeln("%s" % err)
 
 
 class ProfileTextTestResult(unittest.TextTestRunner.resultclass):
+
     def __init__(self, *arg, **kwarg):
         unittest.TextTestRunner.resultclass.__init__(self, *arg, **kwarg)
         self.logger = logging.getLogger("memProf")
@@ -171,10 +188,9 @@ def __init__(self, *arg, **kwarg):
     def startTest(self, test):
         unittest.TextTestRunner.resultclass.startTest(self, test)
         if resource:
-            self.__mem_start = resource.getrusage(
-                resource.RUSAGE_SELF
-            ).ru_maxrss
-        self.__time_start = time.time()
+            self.__mem_start = \
+                resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+        self.__time_start = time.perf_counter()
 
     def stopTest(self, test):
         unittest.TextTestRunner.resultclass.stopTest(self, test)
@@ -184,21 +200,68 @@ def stopTest(self, test):
         else:
             ratio = 1e-3
         if resource:
-            memusage = (
-                resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-                - self.__mem_start
-            ) * ratio
+            memusage = (resource.getrusage(resource.RUSAGE_SELF).ru_maxrss -
+                        self.__mem_start) * ratio
         else:
             memusage = 0
-        self.logger.info(
-            "Time: %.3fs \t RAM: %.3f Mb\t%s",
-            time.time() - self.__time_start,
-            memusage,
-            test.id(),
-        )
+        self.logger.info("Time: %.3fs \t RAM: %.3f Mb\t%s",
+                         time.perf_counter() - self.__time_start,
+                         memusage, test.id())
+
+
+def report_uncovered_files(cov, build_dir, inject_xml=None):
+    """
+    Generate a report of all modules uncovered by the tests
+
+    :param cov: test coverage instance
+    :param str build_dir: Build directory
+    :return: Text report
+    """
+    if build_dir.endswith("freesas"):
+        build_dir = os.path.dirname(build_dir)
+    import fnmatch
+
+    existing_files = []
+    for root, _dirnames, filenames in os.walk(PROJECT_NAME):
+        for filename in fnmatch.filter(filenames, '*.py'):
+            existing_files.append(os.path.join(root, filename))
+    existing_files = filter(lambda x: not x.endswith("/setup.py"), existing_files)
+    existing_files = filter(lambda x: "/test/" not in x, existing_files)
+    existing_files = filter(lambda x: "/third_party/" not in x, existing_files)
+
+    if inject_xml is None:
+        fd, fn = tempfile.mkstemp(suffix=".xml")
+        os.close(fd)
+        cov.xml_report(outfile=fn)
+    else:
+        fn = inject_xml
+    from lxml import etree
+    xml = etree.parse(fn)
+    classes = xml.xpath("//class")
+
+    build_dir = os.path.abspath(build_dir)
+
+    covered_files = []
+
+    for cl in classes:
+        filename = cl.get("filename")
+        filename = os.path.abspath(filename)
+        if filename.startswith(build_dir):
+            filename = filename[len(build_dir) + 1:]
+            covered_files.append(filename)
+
+    uncovered_files = set(existing_files) - set(covered_files)
+    uncovered_files = sorted(list(uncovered_files))
+    text = ""
+    text += "Uncovered files (%d)\n" % len(uncovered_files)
+    text += "-" * (len(text) - 1) + "\n"
+    for filename in uncovered_files:
+        text += "* %s\n" % filename
 
+    return text
 
-def report_rst(cov, package, version="0.0.0", base=""):
+
+def report_rst(cov, package, version="0.0.0", base="", inject_xml=None):
     """
     Generate a report of test coverage in RST (for Sphinx inclusion)
 
@@ -207,12 +270,12 @@ def report_rst(cov, package, version="0.0.0", base=""):
     :param str base: base directory of modules to include in the report
     :return: RST string
     """
-    import tempfile
-
-    fd, fn = tempfile.mkstemp(suffix=".xml")
-    os.close(fd)
-    cov.xml_report(outfile=fn)
-
+    if inject_xml is None:
+        fd, fn = tempfile.mkstemp(suffix=".xml")
+        os.close(fd)
+        cov.xml_report(outfile=fn)
+    else:
+        fn = inject_xml
     from lxml import etree
 
     xml = etree.parse(fn)
@@ -220,59 +283,50 @@ def report_rst(cov, package, version="0.0.0", base=""):
 
     line0 = "Test coverage report for %s" % package
     res = [line0, "=" * len(line0), ""]
-    res.append(
-        "Measured on *%s* version %s, %s"
-        % (package, version, time.strftime("%d/%m/%Y"))
-    )
-    res += [
-        "",
-        ".. csv-table:: Test suite coverage",
-        '   :header: "Name", "Stmts", "Exec", "Cover"',
-        "   :widths: 35, 8, 8, 8",
-        "",
-    ]
+    res.append("Measured on *%s* version %s, %s" %
+               (package, version, time.strftime("%d/%m/%Y")))
+    res += ["",
+            ".. csv-table:: Test suite coverage",
+            '   :header: "Name", "Stmts", "Exec", "Cover"',
+            '   :widths: 35, 8, 8, 8',
+            '']
     tot_sum_lines = 0
     tot_sum_hits = 0
 
     for cl in classes:
         name = cl.get("name")
         fname = cl.get("filename")
-        if not os.path.abspath(fname).startswith(base):
-            continue
-        lines = cl.find("lines").getchildren()
-        hits = [int(i.get("hits")) for i in lines]
+        if os.path.abspath(fname).startswith(base):
+            lines = cl.find("lines").getchildren()
+            hits = [int(i.get("hits")) for i in lines]
 
-        sum_hits = sum(hits)
-        sum_lines = len(lines)
+            sum_hits = sum(hits)
+            sum_lines = len(lines)
 
-        cover = 100.0 * sum_hits / sum_lines if sum_lines else 0
+            cover = 100.0 * sum_hits / sum_lines if sum_lines else 0
 
-        if base:
-            name = os.path.relpath(fname, base)
+            if base:
+                name = os.path.relpath(fname, base)
 
-        res.append(
-            '   "%s", "%s", "%s", "%.1f %%"'
-            % (name, sum_lines, sum_hits, cover)
-        )
-        tot_sum_lines += sum_lines
-        tot_sum_hits += sum_hits
+            res.append('   "%s", "%s", "%s", "%.1f %%"' %
+                       (name, sum_lines, sum_hits, cover))
+            tot_sum_lines += sum_lines
+            tot_sum_hits += sum_hits
     res.append("")
-    res.append(
-        '   "%s total", "%s", "%s", "%.1f %%"'
-        % (
-            package,
-            tot_sum_lines,
-            tot_sum_hits,
-            100.0 * tot_sum_hits / tot_sum_lines if tot_sum_lines else 0,
-        )
-    )
+    res.append('   "%s total", "%s", "%s", "%.1f %%"' %
+               (package, tot_sum_lines, tot_sum_hits,
+                100.0 * tot_sum_hits / tot_sum_lines if tot_sum_lines else 0))
     res.append("")
     return os.linesep.join(res)
 
 
 def is_debug_python():
     """Returns true if the Python interpreter is in debug mode."""
-    import sysconfig
+    try:
+        import sysconfig
+    except ImportError:  # pragma nocover
+        # Python < 2.7
+        import distutils.sysconfig as sysconfig
 
     if sysconfig.get_config_var("Py_DEBUG"):
         return True
@@ -280,240 +334,181 @@ def is_debug_python():
     return hasattr(sys, "gettotalrefcount")
 
 
-def build_project(name, root_dir):
-    """Run python setup.py build for the project.
-
-    Build directory can be modified by environment variables.
-
-    :param str name: Name of the project.
-    :param str root_dir: Root directory of the project
-    :return: The path to the directory were build was performed
-    """
-    platform = distutils.util.get_platform()
-    architecture = "lib.%s-%i.%i" % (
-        platform,
-        sys.version_info[0],
-        sys.version_info[1],
-    )
-    if is_debug_python():
-        architecture += "-pydebug"
-
-    if os.environ.get("PYBUILD_NAME") == name:
-        # we are in the debian packaging way
-        home = os.environ.get("PYTHONPATH", "").split(os.pathsep)[-1]
-    elif os.environ.get("BUILDPYTHONPATH"):
-        home = os.path.abspath(os.environ.get("BUILDPYTHONPATH", ""))
-    else:
-        home = os.path.join(root_dir, "build", architecture)
-
-    logger.warning("Building %s to %s", name, home)
-    p = subprocess.Popen(
-        [sys.executable, "setup.py", "build"], shell=False, cwd=root_dir
-    )
-    logger.debug("subprocess ended with rc= %s", p.wait())
-
-    if os.path.isdir(home):
-        return home
-    alt_home = os.path.join(os.path.dirname(home), "lib")
-    if os.path.isdir(alt_home):
-        return alt_home
-
-
-def import_project_module(project_name, project_dir):
-    """Import project module, from the system of from the project directory"""
-    # Prevent importing from source directory
-    if os.path.dirname(os.path.abspath(__file__)) == os.path.abspath(
-        sys.path[0]
-    ):
-        removed_from_sys_path = sys.path.pop(0)
-        logger.info("Patched sys.path, removed: '%s'", removed_from_sys_path)
-
-    if "--installed" in sys.argv:
-        try:
-            module = importer(project_name)
-        except ImportError:
-            raise ImportError(
-                "%s not installed: Cannot run tests on installed version"
-                % PROJECT_NAME
-            )
-    else:  # Use built source
-        build_dir = build_project(project_name, project_dir)
-        if build_dir is None:
-            logging.error("Built project is not available !!! investigate")
-        sys.path.insert(0, build_dir)
-        logger.warning("Patched sys.path, added: '%s'", build_dir)
-        module = importer(project_name)
-    return module
+# Prevent importing from source directory
+if os.path.dirname(os.path.abspath(__file__)) == os.path.abspath(sys.path[0]):
+    removed_from_sys_path = sys.path.pop(0)
+    logger.info("Patched sys.path, removed: '%s'", removed_from_sys_path)
 
 
 def get_test_options(project_module):
     """Returns the test options if available, else None"""
-    module_name = project_module.__name__ + ".test.utils"
-    logger.info("Import %s", module_name)
+    module_name = project_module.__name__ + '.test.utilstest'
+    logger.info(f'Import {module_name}')
     try:
         test_utils = importer(module_name)
-    except ImportError:
-        logger.warning(
-            "No module named '%s'. No test options available.", module_name
-        )
+    except ImportError as error:
+        logger.warning("No module named '%s'. No test options available. %s", module_name, error)
         return None
 
     test_options = getattr(test_utils, "test_options", None)
     return test_options
 
 
-if __name__ == "__main__":  # Needed for multiprocessing support on Windows
-    PROJECT_DIR = os.path.dirname(os.path.abspath(__file__))
-    PROJECT_NAME = get_project_name(PROJECT_DIR)
-    logger.info("Project name: %s", PROJECT_NAME)
+if "-i" in sys.argv or "--installed" in sys.argv:
+    for bad_path in (".", os.getcwd(), PROJECT_DIR):
+        if bad_path in sys.path:
+            sys.path.remove(bad_path)
+    try:
+        module = importer(PROJECT_NAME)
+    except Exception:
+        logger.error("Cannot run tests on installed version: %s not installed or raising error.",
+                     PROJECT_NAME)
+        raise
+    else:
+        print("Running tests on system-wide installed project")
+else:
+    build_dir = build_project(PROJECT_NAME, PROJECT_DIR)
+    sys.path.insert(0, build_dir)
+    logger.warning("Patched sys.path, added: '%s'", build_dir)
+    module = importer(PROJECT_NAME)
+
+epilog = """Environment variables:
+WITH_QT_TEST=False to disable graphical tests
+PYFAI_OPENCL=False to disable OpenCL tests.
+PYFAI_LOW_MEM: set to True to skip all tests >100Mb
+WITH_GL_TEST=False to disable tests using OpenGL
+"""
+parser = ArgumentParser(description='Run the tests.',
+                        epilog=epilog)
+
+test_options = get_test_options(module)
+"""Contains extra configuration for the tests."""
+test_options.add_parser_argument(parser)
+
+default_test_name = f"{PROJECT_NAME}.test.suite"
+parser.add_argument("test_name", nargs='*',
+                    default=(default_test_name,),
+                    help="Test names to run (Default: %s)" % default_test_name)
+
+parser.add_argument("--installed",
+                    action="store_true", dest="installed", default=False,
+                    help=("Test the installed version instead of" +
+                          "building from the source"))
+parser.add_argument("-c", "--coverage", dest="coverage",
+                    action="store_true", default=False,
+                    help=("Report code coverage" +
+                          "(requires 'coverage' and 'lxml' module)"))
+parser.add_argument("-m", "--memprofile", dest="memprofile",
+                    action="store_true", default=False,
+                    help="Report memory profiling")
+parser.add_argument("-v", "--verbose", default=0,
+                    action="count", dest="verbose",
+                    help="Increase verbosity. Option -v prints additional " +
+                         "INFO messages. Use -vv for full verbosity, " +
+                         "including debug messages and test help strings.")
+parser.add_argument("--qt-binding", dest="qt_binding", default=None,
+                    help="Force using a Qt binding, from 'PyQt4', 'PyQt5', or 'PySide'")
+
+options = parser.parse_args()
+sys.argv = [sys.argv[0]]
+
+test_verbosity = 1
+use_buffer = True
+if options.verbose == 1:
+    logging.root.setLevel(logging.INFO)
+    logger.info("Set log level: INFO")
+    test_verbosity = 2
+    use_buffer = False
+elif options.verbose > 1:
+    logging.root.setLevel(logging.DEBUG)
+    logger.info("Set log level: DEBUG")
+    test_verbosity = 2
+    use_buffer = False
+
+if options.coverage:
+    logger.info("Running test-coverage")
+    import coverage
+    omits = ["*test*", "*third_party*", "*/setup.py",
+             # temporary test modules (silx.math.fit.test.test_fitmanager)
+             "*customfun.py", ]
+    try:
+        coverage_class = coverage.Coverage
+    except AttributeError:
+        coverage_class = coverage.coverage
+    print(f"|{PROJECT_NAME}|")
+    cov = coverage_class(include=[f"*/{PROJECT_NAME}/*"],
+                         omit=omits)
+    cov.start()
+
+if options.qt_binding:
+    binding = options.qt_binding.lower()
+    if binding == "pyqt4":
+        logger.info("Force using PyQt4")
+        import PyQt4.QtCore  # noqa
+    elif binding == "pyqt5":
+        logger.info("Force using PyQt5")
+        import PyQt5.QtCore  # noqa
+    elif binding == "pyside":
+        logger.info("Force using PySide")
+        import PySide.QtCore  # noqa
+    elif binding == "pyside2":
+        logger.info("Force using PySide2")
+        import PySide2.QtCore  # noqa
+    else:
+        raise ValueError("Qt binding '%s' is unknown" % options.qt_binding)
 
-    project_module = import_project_module(PROJECT_NAME, PROJECT_DIR)
-    PROJECT_VERSION = getattr(project_module, "version", "")
-    PROJECT_PATH = project_module.__path__[0]
+PROJECT_VERSION = getattr(module, 'version', '')
+PROJECT_PATH = module.__path__[0]
 
-    test_options = get_test_options(project_module)
-    """Contains extra configuration for the tests."""
+# Run the tests
+runnerArgs = {}
+runnerArgs["verbosity"] = test_verbosity
+runnerArgs["buffer"] = use_buffer
+if options.memprofile:
+    runnerArgs["resultclass"] = ProfileTextTestResult
+else:
+    runnerArgs["resultclass"] = TextTestResultWithSkipList
+runner = unittest.TextTestRunner(**runnerArgs)
 
-    epilog = """Environment variables:
-    SILX_OPENCL=False to disable OpenCL tests
-    SILX_TEST_LOW_MEM=True to disable tests taking large amount of memory
-    GPU=False to disable the use of a GPU with OpenCL test
-    WITH_GL_TEST=False to disable tests using OpenGL
-    """
-    parser = ArgumentParser(description="Run the tests.", epilog=epilog)
-
-    parser.add_argument(
-        "--installed",
-        action="store_true",
-        dest="installed",
-        default=False,
-        help=(
-            "Test the installed version instead of"
-            + "building from the source"
-        ),
-    )
-    parser.add_argument(
-        "-c",
-        "--coverage",
-        dest="coverage",
-        action="store_true",
-        default=False,
-        help=(
-            "Report code coverage" + "(requires 'coverage' and 'lxml' module)"
-        ),
-    )
-    parser.add_argument(
-        "-m",
-        "--memprofile",
-        dest="memprofile",
-        action="store_true",
-        default=False,
-        help="Report memory profiling",
-    )
-    parser.add_argument(
-        "-v",
-        "--verbose",
-        default=0,
-        action="count",
-        dest="verbose",
-        help="Increase verbosity. Option -v prints additional "
-        + "INFO messages. Use -vv for full verbosity, "
-        + "including debug messages and test help strings.",
-    )
-    if test_options is not None:
-        test_options.add_parser_argument(parser)
-
-    default_test_name = "%s.test.suite" % PROJECT_NAME
-    parser.add_argument(
-        "test_name",
-        nargs="*",
-        default=(default_test_name,),
-        help="Test names to run (Default: %s)" % default_test_name,
-    )
-    options = parser.parse_args()
-    sys.argv = [sys.argv[0]]
-
-    test_verbosity = 1
-    use_buffer = True
-    if options.verbose == 1:
-        logging.root.setLevel(logging.INFO)
-        logger.info("Set log level: INFO")
-        test_verbosity = 2
-        use_buffer = False
-    elif options.verbose > 1:
-        logging.root.setLevel(logging.DEBUG)
-        logger.info("Set log level: DEBUG")
-        test_verbosity = 2
-        use_buffer = False
-
-    if options.coverage:
-        logger.info("Running test-coverage")
-        import coverage
-
-        omits = [
-            "*test*",
-            "*third_party*",
-            "*/setup.py",
-            # temporary test modules (silx.math.fit.test.test_fitmanager)
-            "*customfun.py",
-        ]
-        try:
-            cov = coverage.Coverage(omit=omits)
-        except AttributeError:
-            cov = coverage.coverage(omit=omits)
-        cov.start()
-
-    # Run the tests
-    runnerArgs = {}
-    runnerArgs["verbosity"] = test_verbosity
-    runnerArgs["buffer"] = use_buffer
-    if options.memprofile:
-        runnerArgs["resultclass"] = ProfileTextTestResult
-    else:
-        runnerArgs["resultclass"] = TextTestResultWithSkipList
-    runner = unittest.TextTestRunner(**runnerArgs)
+logger.warning("Test %s %s from %s",
+               PROJECT_NAME, PROJECT_VERSION, PROJECT_PATH)
 
-    logger.warning(
-        "Test %s %s from %s", PROJECT_NAME, PROJECT_VERSION, PROJECT_PATH
-    )
+test_module_name = PROJECT_NAME + '.test'
+logger.info('Import %s', test_module_name)
+test_module = importer(test_module_name)
 
-    test_module_name = PROJECT_NAME + ".test"
-    logger.info("Import %s", test_module_name)
-    test_module = importer(test_module_name)
-    test_suite = unittest.TestSuite()
+test_suite = unittest.TestSuite()
 
-    if test_options is not None:
-        # Configure the test options according to the command lines and the the environment
-        test_options.configure(options)
-    else:
-        logger.warning("No test options available.")
+if test_options is not None:
+    # Configure the test options according to the command lines and the the environment
+    test_options.configure(options)
+    print(test_options)
+else:
+    logger.warning("No test options available.")
 
-    if not options.test_name:
-        # Do not use test loader to avoid cryptic exception
-        # when an error occur during import
-        project_test_suite = getattr(test_module, "suite")
-        test_suite.addTest(project_test_suite())
-    else:
-        test_suite.addTest(
-            unittest.defaultTestLoader.loadTestsFromNames(options.test_name)
-        )
+if not options.test_name:
+    # Do not use test loader to avoid cryptic exception
+    # when an error occur during import
+    project_test_suite = getattr(test_module, 'suite')
+    test_suite.addTest(project_test_suite())
+else:
+    test_suite.addTest(
+        unittest.defaultTestLoader.loadTestsFromNames(options.test_name))
 
-    # Display the result when using CTRL-C
-    unittest.installHandler()
+# Display the result when using CTRL-C
+unittest.installHandler()
 
-    result = runner.run(test_suite)
+result = runner.run(test_suite)
 
-    if result.wasSuccessful():
-        exit_status = 0
-    else:
-        exit_status = 1
+exit_status = 0 if result.wasSuccessful() else 1 
 
-    if options.coverage:
-        cov.stop()
-        cov.save()
-        with open("coverage.rst", "w") as fn:
-            fn.write(
-                report_rst(cov, PROJECT_NAME, PROJECT_VERSION, PROJECT_PATH)
-            )
+if options.coverage:
+    cov.stop()
+    cov.save()
+    with open("coverage.rst", "w") as fn:
+        fn.write(report_rst(cov, PROJECT_NAME, PROJECT_VERSION, PROJECT_PATH))
+    print(cov.report())
+    print("")
+    print(report_uncovered_files(cov, PROJECT_PATH))
 
-    sys.exit(exit_status)
+sys.exit(exit_status)
diff --git a/setup.py b/setup.py
deleted file mode 100644
index 9662744..0000000
--- a/setup.py
+++ /dev/null
@@ -1,1050 +0,0 @@
-#!/usr/bin/python3
-# coding: utf8
-# /*##########################################################################
-#
-# Copyright (c) 2015-2020 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
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
-__authors__ = ["Jérôme Kieffer", "Thomas Vincent"]
-__date__ = "19/07/2021"
-__license__ = "MIT"
-
-import sys
-import os
-import platform
-import shutil
-import logging
-import glob
-
-PROJECT = "freesas"
-if sys.version_info[0] < 3:
-    raise SystemError(f"{PROJECT} requires Python3 !")
-
-logging.basicConfig(level=logging.INFO)
-
-logger = logging.getLogger("freesas.setup")
-
-try:
-    from setuptools._distutils.command.clean import clean as Clean
-    from setuptools._distutils.command.build import build as _build
-except (ImportError) as err:
-    print(f"Unable to use setuptools, {type(err)}: {err}")
-    from distutils.command.clean import clean as Clean
-    from distutils.command.build import build as _build
-
-try:
-    from setuptools import Command
-    from setuptools.command.build_py import build_py as _build_py
-    from setuptools.command.sdist import sdist
-
-    try:
-        from Cython.Build import build_ext
-
-        logger.info("Use setuptools with cython")
-    except ImportError:
-        from setuptools.command.build_ext import build_ext
-
-        logger.info("Use setuptools, cython is missing")
-except ImportError as err:
-    print(f"Unable to use setuptools, {type(err)}: {err}")
-    try:
-        from numpy.distutils.core import Command
-    except ImportError:
-        from distutils.core import Command
-    from distutils.command.build_py import build_py as _build_py
-    from distutils.command.sdist import sdist
-
-    try:
-        from Cython.Build import build_ext
-
-        logger.info("Use distutils with cython")
-    except ImportError:
-        from distutils.command.build_ext import build_ext
-
-        logger.info("Use distutils, cython is missing")
-try:
-    import sphinx
-    import sphinx.util.console
-
-    sphinx.util.console.color_terminal = lambda: False
-    from sphinx.setup_command import BuildDoc
-except ImportError:
-    sphinx = None
-
-if (
-    "LANG" not in os.environ
-    and platform.system() == "Darwin"
-    and sys.version_info[0] > 2
-):
-    print(
-        """WARNING: the LANG environment variable is not defined,
-an utf-8 LANG is mandatory to use setup.py, you may face unexpected UnicodeError.
-export LANG=en_US.utf-8
-export LC_ALL=en_US.utf-8
-"""
-    )
-
-
-def get_version():
-    """Returns current version number from version.py file"""
-    dirname = os.path.dirname(os.path.abspath(__file__))
-    sys.path.insert(0, dirname)
-    import version
-
-    sys.path = sys.path[1:]
-    return version.strictversion
-
-
-def get_readme():
-    """Returns content of README.rst file"""
-    dirname = os.path.dirname(os.path.abspath(__file__))
-    filename = os.path.join(dirname, "README.md")
-    with open(filename, "r", encoding="utf-8") as fp:
-        long_description = fp.read()
-    return long_description
-
-
-classifiers = [
-    "Development Status :: 5 - Production/Stable",
-    "Environment :: Console",
-    "Intended Audience :: Developers",
-    "Intended Audience :: Education",
-    "Intended Audience :: Science/Research",
-    "License :: OSI Approved :: MIT License",
-    "Natural Language :: English",
-    "Operating System :: MacOS :: MacOS X",
-    "Operating System :: Microsoft :: Windows",
-    "Operating System :: Unix",
-    "Operating System :: POSIX",
-    "Programming Language :: Cython",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: Implementation :: CPython",
-    "Topic :: Scientific/Engineering :: Physics",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Topic :: Scientific/Engineering :: Bio-Informatics",
-]
-
-# ########## #
-# version.py #
-# ########## #
-
-
-class build_py(_build_py):
-    """
-    Enhanced build_py which copies version.py to <PROJECT>._version.py
-    """
-
-    def find_package_modules(self, package, package_dir):
-        modules = _build_py.find_package_modules(self, package, package_dir)
-        if package == PROJECT:
-            modules.append((PROJECT, "_version", "version.py"))
-        return modules
-
-
-########
-# Test #
-########
-
-
-class PyTest(Command):
-    """Command to start tests running the script: run_tests.py"""
-
-    user_options = []
-
-    description = "Execute the unittests"
-
-    def initialize_options(self):
-        pass
-
-    def finalize_options(self):
-        pass
-
-    def run(self):
-        import subprocess
-
-        errno = subprocess.call([sys.executable, "run_tests.py"])
-        if errno != 0:
-            raise SystemExit(errno)
-
-
-# ################### #
-# build_doc command   #
-# ################### #
-
-
-if sphinx is None:
-
-    class SphinxExpectedCommand(Command):
-        """Command to inform that sphinx is missing"""
-
-        user_options = []
-
-        def initialize_options(self):
-            pass
-
-        def finalize_options(self):
-            pass
-
-        def run(self):
-            raise RuntimeError(
-                "Sphinx is required to build or test the documentation.\n"
-                "Please install Sphinx (http://www.sphinx-doc.org)."
-            )
-
-
-class BuildMan(Command):
-    """Command to build man pages"""
-
-    description = "Build man pages of the provided entry points"
-
-    user_options = []
-
-    def initialize_options(self):
-        pass
-
-    def finalize_options(self):
-        pass
-
-    def entry_points_iterator(self):
-        """Iterate other entry points available on the project."""
-        entry_points = self.distribution.entry_points
-        console_scripts = entry_points.get("console_scripts", [])
-        gui_scripts = entry_points.get("gui_scripts", [])
-        scripts = []
-        scripts.extend(console_scripts)
-        scripts.extend(gui_scripts)
-        for script in scripts:
-            # Remove ending extra dependencies
-            script = script.split("[")[0]
-            elements = script.split("=")
-            target_name = elements[0].strip()
-            elements = elements[1].split(":")
-            module_name = elements[0].strip()
-            function_name = elements[1].strip()
-            yield target_name, module_name, function_name
-
-    def run_targeted_script(
-        self, target_name, script_name, env, log_output=False
-    ):
-        """Execute targeted script using --help and --version to help checking
-        errors. help2man is not very helpful to do it for us.
-
-        :return: True is both return code are equal to 0
-        :rtype: bool
-        """
-        import subprocess
-
-        if log_output:
-            extra_args = {}
-        else:
-            try:
-                # Python 3
-                from subprocess import DEVNULL
-            except ImportError:
-                # Python 2
-                import os
-
-                DEVNULL = open(os.devnull, "wb")
-            extra_args = {"stdout": DEVNULL, "stderr": DEVNULL}
-
-        succeeded = True
-        command_line = [sys.executable, script_name, "--help"]
-        if log_output:
-            logger.info(
-                "See the following execution of: %s", " ".join(command_line)
-            )
-        p = subprocess.Popen(command_line, env=env, **extra_args)
-        status = p.wait()
-        if log_output:
-            logger.info("Return code: %s", status)
-        succeeded = succeeded and status == 0
-        command_line = [sys.executable, script_name, "--version"]
-        if log_output:
-            logger.info(
-                "See the following execution of: %s", " ".join(command_line)
-            )
-        p = subprocess.Popen(command_line, env=env, **extra_args)
-        status = p.wait()
-        if log_output:
-            logger.info("Return code: %s", status)
-        succeeded = succeeded and status == 0
-        return succeeded
-
-    def run(self):
-        build = self.get_finalized_command("build")
-        path = sys.path
-        path.insert(0, os.path.abspath(build.build_lib))
-
-        env = dict((str(k), str(v)) for k, v in os.environ.items())
-        env["PYTHONPATH"] = os.pathsep.join(path)
-        if not os.path.isdir("build/man"):
-            os.makedirs("build/man")
-        import subprocess
-        import tempfile
-        import stat
-
-        script_name = None
-        workdir = tempfile.mkdtemp()
-
-        entry_points = self.entry_points_iterator()
-        for target_name, module_name, function_name in entry_points:
-            logger.info("Build man for entry-point target '%s'" % target_name)
-            # help2man expect a single executable file to extract the help
-            # we create it, execute it, and delete it at the end
-
-            try:
-                # create a launcher using the right python interpreter
-                script_name = os.path.join(workdir, target_name)
-                with open(script_name, "wt") as script:
-                    script.write("#!%s\n" % sys.executable)
-                    script.write("import %s as app\n" % module_name)
-                    script.write("app.%s()\n" % function_name)
-                # make it executable
-                mode = os.stat(script_name).st_mode
-                os.chmod(script_name, mode + stat.S_IEXEC)
-
-                # execute help2man
-                man_file = "build/man/%s.1" % target_name
-                command_line = [
-                    "help2man",
-                    "-N",
-                    script_name,
-                    "-o",
-                    man_file,
-                    "--no-discard-stderr",
-                ]
-
-                p = subprocess.Popen(command_line, env=env)
-                status = p.wait()
-                if status != 0:
-                    logger.info(
-                        "Error while generating man file for target '%s'.",
-                        target_name,
-                    )
-                    self.run_targeted_script(
-                        target_name, script_name, env, True
-                    )
-                    raise RuntimeError(
-                        "Fail to generate '%s' man documentation" % target_name
-                    )
-            finally:
-                # clean up the script
-                if script_name is not None:
-                    os.remove(script_name)
-        os.rmdir(workdir)
-
-
-if sphinx is not None:
-
-    class BuildDocCommand(BuildDoc):
-        """Command to build documentation using sphinx.
-
-        Project should have already be built.
-        """
-
-        def run(self):
-            # make sure the python path is pointing to the newly built
-            # code so that the documentation is built on this and not a
-            # previously installed version
-
-            build = self.get_finalized_command("build")
-            sys.path.insert(0, os.path.abspath(build.build_lib))
-
-            # # Copy .ui files to the path:
-            # dst = os.path.join(
-            #     os.path.abspath(build.build_lib), "silx", "gui")
-            # if not os.path.isdir(dst):
-            #     os.makedirs(dst)
-            # for i in os.listdir("gui"):
-            #     if i.endswith(".ui"):
-            #         src = os.path.join("gui", i)
-            #         idst = os.path.join(dst, i)
-            #         if not os.path.exists(idst):
-            #             shutil.copy(src, idst)
-
-            # Build the Users Guide in HTML and TeX format
-            for builder in ["html", "latex"]:
-                self.builder = builder
-                self.builder_target_dir = os.path.join(self.build_dir, builder)
-                self.mkpath(self.builder_target_dir)
-                BuildDoc.run(self)
-            sys.path.pop(0)
-
-
-else:
-    BuildDocCommand = SphinxExpectedCommand
-
-# ################### #
-# test_doc command    #
-# ################### #
-
-if sphinx is not None:
-
-    class TestDocCommand(BuildDoc):
-        """Command to test the documentation using sphynx doctest.
-
-        http://www.sphinx-doc.org/en/1.4.8/ext/doctest.html
-        """
-
-        def run(self):
-            # make sure the python path is pointing to the newly built
-            # code so that the documentation is built on this and not a
-            # previously installed version
-
-            build = self.get_finalized_command("build")
-            sys.path.insert(0, os.path.abspath(build.build_lib))
-
-            # Build the Users Guide in HTML and TeX format
-            for builder in ["doctest"]:
-                self.builder = builder
-                self.builder_target_dir = os.path.join(self.build_dir, builder)
-                self.mkpath(self.builder_target_dir)
-                BuildDoc.run(self)
-            sys.path.pop(0)
-
-
-else:
-    TestDocCommand = SphinxExpectedCommand
-
-# ############################# #
-# numpy.distutils Configuration #
-# ############################# #
-
-
-def configuration(parent_package="", top_path=None):
-    """Recursive construction of package info to be used in setup().
-
-    See http://docs.scipy.org/doc/numpy/reference/distutils.html#numpy.distutils.misc_util.Configuration
-    """
-    try:
-        from numpy.distutils.misc_util import Configuration
-    except ImportError:
-        raise ImportError(
-            "To install this package, you must install numpy first\n"
-            "(See https://pypi.python.org/pypi/numpy)"
-        )
-    config = Configuration(None, parent_package, top_path)
-    config.set_options(
-        ignore_setup_xxx_py=True,
-        assume_default_configuration=True,
-        delegate_options_to_subpackages=True,
-        quiet=True,
-    )
-    config.add_subpackage(PROJECT)
-    return config
-
-
-# ############## #
-# Compiler flags #
-# ############## #
-
-
-class Build(_build):
-    """Command to support more user options for the build."""
-
-    user_options = [
-        (
-            "no-openmp",
-            None,
-            "do not use OpenMP for compiled extension modules",
-        ),
-        ("openmp", None, "use OpenMP for the compiled extension modules"),
-        ("force-cython", None, "recompile all Cython extension modules"),
-    ]
-    user_options.extend(_build.user_options)
-
-    boolean_options = ["no-openmp", "openmp", "force-cython"]
-    boolean_options.extend(_build.boolean_options)
-
-    def initialize_options(self):
-        _build.initialize_options(self)
-        self.no_openmp = None
-        self.openmp = None
-        self.no_cython = None
-        self.force_cython = None
-
-    def finalize_options(self):
-        _build.finalize_options(self)
-        if not self.force_cython:
-            self.force_cython = self._parse_env_as_bool("FORCE_CYTHON") is True
-        self.finalize_openmp_options()
-
-    def _parse_env_as_bool(self, key):
-        content = os.environ.get(key, "")
-        value = content.lower()
-        if value in ["1", "true", "yes", "y"]:
-            return True
-        if value in ["0", "false", "no", "n"]:
-            return False
-        if value in ["none", ""]:
-            return None
-        msg = "Env variable '%s' contains '%s'. But a boolean or an empty \
-            string was expected. Variable ignored."
-        logger.warning(msg, key, content)
-        return None
-
-    def finalize_openmp_options(self):
-        """Check if extensions must be compiled with OpenMP.
-
-        The result is stored into the object.
-        """
-        if self.openmp:
-            use_openmp = True
-        elif self.no_openmp:
-            use_openmp = False
-        else:
-            env_with_openmp = self._parse_env_as_bool("WITH_OPENMP")
-            if env_with_openmp is not None:
-                use_openmp = env_with_openmp
-            else:
-                # Use it by default
-                use_openmp = True
-
-        if use_openmp:
-            if platform.system() == "Darwin":
-                # By default Xcode5 & XCode6 do not support OpenMP, Xcode4 is OK.
-                osx = tuple([int(i) for i in platform.mac_ver()[0].split(".")])
-                if osx >= (10, 8):
-                    logger.warning(
-                        "OpenMP support ignored. Your platform does not support it."
-                    )
-                    use_openmp = False
-
-        # Remove attributes used by distutils parsing
-        # use 'use_openmp' instead
-        del self.no_openmp
-        del self.openmp
-        self.use_openmp = use_openmp
-
-
-class BuildExt(build_ext):
-    """Handle extension compilation.
-
-    Command-line argument and environment can custom:
-
-    - The use of cython to cythonize files, else a default version is used
-    - Build extension with support of OpenMP (by default it is enabled)
-    - If building with MSVC, compiler flags are converted from gcc flags.
-    """
-
-    COMPILE_ARGS_CONVERTER = {"-fopenmp": "/openmp"}
-
-    LINK_ARGS_CONVERTER = {"-fopenmp": ""}
-
-    description = "Build extensions"
-
-    def finalize_options(self):
-        build_ext.finalize_options(self)
-        build_obj = self.distribution.get_command_obj("build")
-        self.use_openmp = build_obj.use_openmp
-        self.force_cython = build_obj.force_cython
-
-    def patch_extension(self, ext):
-        """
-        Patch an extension according to requested Cython and OpenMP usage.
-
-        :param Extension ext: An extension
-        """
-        # Cytonize
-        from Cython.Build import cythonize
-
-        patched_exts = cythonize(
-            [ext],
-            compiler_directives={"embedsignature": True, "language_level": 3},
-            force=self.force_cython,
-            compile_time_env={"HAVE_OPENMP": self.use_openmp},
-        )
-
-        ext.sources = patched_exts[0].sources
-
-        # Remove OpenMP flags if OpenMP is disabled
-        if not self.use_openmp:
-            ext.extra_compile_args = [
-                f for f in ext.extra_compile_args if f != "-fopenmp"
-            ]
-            ext.extra_link_args = [
-                f for f in ext.extra_link_args if f != "-fopenmp"
-            ]
-
-        # Convert flags from gcc to MSVC if required
-        if self.compiler.compiler_type == "msvc":
-            extra_compile_args = [
-                self.COMPILE_ARGS_CONVERTER.get(f, f)
-                for f in ext.extra_compile_args
-            ]
-            # Avoid empty arg
-            ext.extra_compile_args = [arg for arg in extra_compile_args if arg]
-
-            extra_link_args = [
-                self.LINK_ARGS_CONVERTER.get(f, f) for f in ext.extra_link_args
-            ]
-            # Avoid empty arg
-            ext.extra_link_args = [arg for arg in extra_link_args if arg]
-
-        elif self.compiler.compiler_type == "unix":
-            # Avoids runtime symbol collision for manylinux1 platform
-            # See issue #1070
-            extern = 'extern "C" ' if ext.language == "c++" else ""
-            return_type = "void" if sys.version_info[0] <= 2 else "PyObject*"
-
-            ext.extra_compile_args.append("-fvisibility=hidden")
-
-            import numpy
-
-            numpy_version = [
-                int(i) for i in numpy.version.short_version.split(".", 2)[:2]
-            ]
-            if numpy_version < [1, 16]:
-                ext.extra_compile_args.append(
-                    """-D'PyMODINIT_FUNC=%s__attribute__((visibility("default"))) %s ' """
-                    % (extern, return_type)
-                )
-            else:
-                ext.define_macros.append(
-                    (
-                        "PyMODINIT_FUNC",
-                        '%s__attribute__((visibility("default"))) %s '
-                        % (extern, return_type),
-                    )
-                )
-
-    def is_debug_interpreter(self):
-        """
-        Returns true if the script is executed with a debug interpreter.
-
-        It looks to be a non-standard code. It is not working for Windows and
-        Mac. But it have to work at least for Debian interpreters.
-
-        :rtype: bool
-        """
-        if sys.version_info >= (3, 0):
-            # It is normalized on Python 3
-            # But it is not available on Windows CPython
-            if hasattr(sys, "abiflags"):
-                return "d" in sys.abiflags
-        else:
-            # It's a Python 2 interpreter
-            # pydebug is not available on Windows/Mac OS interpreters
-            if hasattr(sys, "pydebug"):
-                return sys.pydebug
-
-        # We can't know if we uses debug interpreter
-        return False
-
-    def patch_compiler(self):
-        """
-        Patch the compiler to:
-        - always compile extensions with debug symboles (-g)
-        - only compile asserts in debug mode (-DNDEBUG)
-
-        Plus numpy.distutils/setuptools/distutils inject a lot of duplicated
-        flags. This function tries to clean up default debug options.
-        """
-        build_obj = self.distribution.get_command_obj("build")
-        if build_obj.debug:
-            debug_mode = build_obj.debug
-        else:
-            # Force debug_mode also when it uses python-dbg
-            # It is needed for Debian packaging
-            debug_mode = self.is_debug_interpreter()
-
-        if self.compiler.compiler_type == "unix":
-            args = list(self.compiler.compiler_so)
-            # clean up debug flags -g is included later in another way
-            must_be_cleaned = ["-DNDEBUG", "-g"]
-            args = filter(lambda x: x not in must_be_cleaned, args)
-            args = list(args)
-
-            # always insert symbols
-            args.append("-g")
-
-            # On MacOS, we set the optimization level to avoid trouble with AppleClang 10
-            if platform.system() == "Darwin":
-                args.append("-O0")
-            # only strip asserts in release mode
-            if not debug_mode:
-                args.append("-DNDEBUG")
-            # patch options
-            self.compiler.compiler_so = list(args)
-
-    def build_extensions(self):
-        self.patch_compiler()
-        for ext in self.extensions:
-            self.patch_extension(ext)
-        build_ext.build_extensions(self)
-
-
-################################################################################
-# Clean command
-################################################################################
-
-
-class CleanCommand(Clean):
-    description = "Remove build artifacts from the source tree"
-
-    def expand(self, path_list):
-        """Expand a list of path using glob magic.
-
-        :param list[str] path_list: A list of path which may contains magic
-        :rtype: list[str]
-        :returns: A list of path without magic
-        """
-        path_list2 = []
-        for path in path_list:
-            if glob.has_magic(path):
-                iterator = glob.iglob(path)
-                path_list2.extend(iterator)
-            else:
-                path_list2.append(path)
-        return path_list2
-
-    def find(self, path_list):
-        """Find a file pattern if directories.
-
-        Could be done using "**/*.c" but it is only supported in Python 3.5.
-
-        :param list[str] path_list: A list of path which may contains magic
-        :rtype: list[str]
-        :returns: A list of path without magic
-        """
-        import fnmatch
-
-        path_list2 = []
-        for pattern in path_list:
-            for root, _, filenames in os.walk("."):
-                for filename in fnmatch.filter(filenames, pattern):
-                    path_list2.append(os.path.join(root, filename))
-        return path_list2
-
-    def run(self):
-        Clean.run(self)
-
-        cython_files = self.find(["*.pyx"])
-        cythonized_files = [
-            path.replace(".pyx", ".c") for path in cython_files
-        ]
-        cythonized_files += [
-            path.replace(".pyx", ".cpp") for path in cython_files
-        ]
-
-        # really remove the directories
-        # and not only if they are empty
-        to_remove = [self.build_base]
-        to_remove = self.expand(to_remove)
-        to_remove += cythonized_files
-
-        if not self.dry_run:
-            for path in to_remove:
-                try:
-                    if os.path.isdir(path):
-                        shutil.rmtree(path)
-                    else:
-                        os.remove(path)
-                    logger.info("removing '%s'", path)
-                except OSError:
-                    pass
-
-
-################################################################################
-# Debian source tree
-################################################################################
-
-
-class sdist_debian(sdist):
-    """
-    Tailor made sdist for debian
-    * remove auto-generated doc
-    * remove cython generated .c files
-    * remove cython generated .cpp files
-    * remove .bat files
-    * include .l man files
-    """
-
-    description = (
-        "Create a source distribution for Debian (tarball, zip file, etc.)"
-    )
-
-    @staticmethod
-    def get_debian_name():
-        import version
-
-        name = "%s_%s" % (PROJECT, version.debianversion)
-        return name
-
-    def prune_file_list(self):
-        sdist.prune_file_list(self)
-        to_remove = ["doc/build", "doc/pdf", "doc/html", "pylint", "epydoc"]
-        print("Removing files for debian")
-        for rm in to_remove:
-            self.filelist.exclude_pattern(pattern="*", anchor=False, prefix=rm)
-
-        # this is for Cython files specifically: remove C & html files
-        search_root = os.path.dirname(os.path.abspath(__file__))
-        for root, _, files in os.walk(search_root):
-            for afile in files:
-                if os.path.splitext(afile)[1].lower() == ".pyx":
-                    base_file = os.path.join(root, afile)[
-                        len(search_root) + 1 : -4
-                    ]
-                    self.filelist.exclude_pattern(pattern=base_file + ".c")
-                    self.filelist.exclude_pattern(pattern=base_file + ".cpp")
-                    self.filelist.exclude_pattern(pattern=base_file + ".html")
-
-        # do not include third_party/_local files
-        # self.filelist.exclude_pattern(pattern="*", prefix="fabio/third_party/_local")
-
-    def make_distribution(self):
-        self.prune_file_list()
-        sdist.make_distribution(self)
-        dest = self.archive_files[0]
-        dirname, basename = os.path.split(dest)
-        base, ext = os.path.splitext(basename)
-        while ext in [".zip", ".tar", ".bz2", ".gz", ".Z", ".lz", ".orig"]:
-            base, ext = os.path.splitext(base)
-        # if ext:
-        #     dest = "".join((base, ext))
-        # else:
-        #     dest = base
-        # sp = dest.split("-")
-        # base = sp[:-1]
-        # nr = sp[-1]
-        debian_arch = os.path.join(
-            dirname, self.get_debian_name() + ".orig.tar.gz"
-        )
-        os.rename(self.archive_files[0], debian_arch)
-        self.archive_files = [debian_arch]
-        print("Building debian .orig.tar.gz in %s" % self.archive_files[0])
-
-#===============================================================================
-# Create a tarball with all test data
-#===============================================================================
-
-class TestData(Command):
-    """
-    Tailor made tarball with test data
-    """
-    user_options = []
-
-    def initialize_options(self):
-        pass
-
-    def finalize_options(self):
-        pass
-
-    def download_images(self):
-        """
-        Download all test images and
-        """
-        root_dir = os.path.dirname(os.path.abspath(__file__))
-        print(os.getcwd())
-        print(os.listdir(root_dir))
-        testimages = os.path.join(root_dir, PROJECT, "resources", "all_testdata.json")
-        print(testimages)
-        import json
-        with open(testimages) as f:
-            all_files = set(json.load(f))
-        return list(all_files)
-
-    def run(self):
-        datafiles = self.download_images()
-        dist = "dist"
-        root_dir = os.path.dirname(os.path.abspath(__file__))
-        arch = os.path.join(root_dir, dist, PROJECT + "-testimages.tar.gz")
-        print("Building testdata tarball in %s" % arch)
-        if not os.path.isdir(dist):
-            os.mkdir(dist)
-        if os.path.exists(arch):
-            os.unlink(arch)
-        import tarfile
-        from silx.resources import ExternalResources
-        downloader = ExternalResources("freesas", "http://www.silx.org/pub/freesas/testdata", "FREESAS_TESTDATA")
-        with tarfile.open(name=arch, mode='w:gz') as tarball:
-            for afile in datafiles:
-                tarball.add(downloader.getfile(afile), afile)
-        print(f"export FREESAS_TESTDATA={downloader.data_home}")
-        
-# ##### #
-# setup #
-# ##### #
-
-def get_project_configuration(dry_run):
-    """Returns project arguments for setup"""
-    # Use installed numpy version as minimal required version
-    # This is useful for wheels to advertise the numpy version they were built with
-    if dry_run:
-        numpy_requested_version = ""
-    else:
-        from numpy.version import version as numpy_version
-
-        numpy_requested_version = ">=%s" % numpy_version
-        logger.info("Install requires: numpy %s", numpy_requested_version)
-
-    install_requires = [
-        # for most of the computation
-        "numpy%s" % numpy_requested_version,
-        # for the script launcher
-        "setuptools",
-        "six",
-        "scipy",
-    ]
-
-    setup_requires = ["setuptools", "numpy", "cython", "scipy"]
-
-    package_data = {
-        # Resources files for silx
-        # 'silx.resources': [
-        #    'gui/logo/*.png',
-        #    'gui/logo/*.svg',
-        #    'gui/icons/*.png',
-        #    'gui/icons/*.svg',
-        #    'gui/icons/*.mng',
-        #    'gui/icons/*.gif',
-        #    'gui/icons/*/*.png',
-        #    'opencl/*.cl',
-        #    'opencl/image/*.cl',
-        #    'opencl/sift/*.cl',
-        #    'opencl/codec/*.cl',
-        #    'gui/colormaps/*.npy'],
-        # 'silx.examples': ['*.png'],
-    }
-
-    console_scripts = [
-        "free_gpa = freesas.app.auto_gpa:main",
-        "free_guinier = freesas.app.auto_guinier:main",
-        "free_rg = freesas.app.autorg:main",
-        "cormapy = freesas.app.cormap:main",
-        "supycomb = freesas.app.supycomb:main",
-        "free_bift = freesas.app.bift:main",
-        "freesas = freesas.app.plot_sas:main",
-        "extract_ascii = freesas.app.extract_ascii:main",
-    ]
-
-    # Non windows os are fine with the previous script names, so we can support both
-    if platform.system() != "Windows":
-        console_scripts.extend(
-            [
-                "auto_gpa.py = freesas.app.auto_gpa:main",
-                "auto_guinier.py = freesas.app.auto_guinier:main",
-                "autorg.py = freesas.app.autorg:main",
-                "cormap.py = freesas.app.cormap:main",
-                "supycomb.py = freesas.app.supycomb:main",
-                "bift.py = freesas.app.bift:main",
-            ]
-        )
-
-    entry_points = {
-        "console_scripts": console_scripts,
-        # 'gui_scripts': [],
-    }
-
-    cmdclass = dict(
-        build=Build,
-        build_py=build_py,
-        test=PyTest,
-        build_doc=BuildDocCommand,
-        test_doc=TestDocCommand,
-        build_ext=BuildExt,
-        build_man=BuildMan,
-        clean=CleanCommand,
-        debian_src=sdist_debian,
-        testdata=TestData
-    )
-
-    if dry_run:
-        # DRY_RUN implies actions which do not require NumPy
-        #
-        # And they are required to succeed without Numpy for example when
-        # pip is used to install silx when Numpy is not yet present in
-        # the system.
-        setup_kwargs = {}
-    else:
-        config = configuration()
-        setup_kwargs = config.todict()
-
-    setup_kwargs.update(
-        name=PROJECT,
-        version=get_version(),
-        url="http://www.silx.org/",
-        author="Guillaume Bonamis, Martha Brennich, Jerome Kieffer",
-        author_email="jerome.kieffer@esrf.fr",
-        classifiers=classifiers,
-        description="Free tools to analyze Small angle scattering data",
-        long_description=get_readme(),
-        install_requires=install_requires,
-        setup_requires=setup_requires,
-        cmdclass=cmdclass,
-        package_data=package_data,
-        zip_safe=False,
-        entry_points=entry_points,
-        python_requires=">=3.6",
-    )
-    #      packages=["freesas", "freesas.test"],
-    #      data_files=glob.glob("testdata/*"),
-    #      scripts=script_files,
-    #      install_requires=['numpy', "six"],
-    #      ext_modules=ext_modules,
-
-    return setup_kwargs
-
-
-def setup_package():
-    """Run setup(**kwargs)
-
-    Depending on the command, it either runs the complete setup which depends on numpy,
-    or a *dry run* setup with no dependency on numpy.
-    """
-
-    # Check if action requires build/install
-    dry_run = len(sys.argv) == 1 or (
-        len(sys.argv) >= 2
-        and (
-            "--help" in sys.argv[1:]
-            or sys.argv[1]
-            in ("--help-commands", "egg_info", "--version", "clean", "--name")
-        )
-    )
-
-    if dry_run:
-        # DRY_RUN implies actions which do not require dependencies, like NumPy
-        try:
-            from setuptools import setup
-
-            logger.info("Use setuptools.setup")
-        except ImportError:
-            from distutils.core import setup
-
-            logger.info("Use distutils.core.setup")
-    else:
-        try:
-            from setuptools import setup
-        except ImportError:
-            from numpy.distutils.core import setup
-
-            logger.info("Use numpy.distutils.setup")
-
-    setup_kwargs = get_project_configuration(dry_run)
-    setup(**setup_kwargs)
-
-
-if __name__ == "__main__":
-    setup_package()
diff --git a/freesas/__init__.py b/src/freesas/__init__.py
similarity index 74%
rename from freesas/__init__.py
rename to src/freesas/__init__.py
index 79072af..e3f1517 100644
--- a/freesas/__init__.py
+++ b/src/freesas/__init__.py
@@ -1,7 +1,7 @@
 # coding: utf-8
 # /*##########################################################################
 #
-# Copyright (c) 2015-2018 European Synchrotron Radiation Facility
+# Copyright (c) 2015-2023 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
@@ -23,22 +23,12 @@
 #
 # ###########################################################################*/
 """
-The silx package contains the following main sub-packages:
 
-- silx.gui: Qt widgets for data visualization and data file browsing
-- silx.image: Some processing functions for 2D images
-- silx.io: Reading and writing data files (HDF5/NeXus, SPEC, ...)
-- silx.math: Some processing functions for 1D, 2D, 3D, nD arrays
-- silx.opencl: OpenCL-based data processing
-- silx.sx: High-level silx functions suited for (I)Python console.
-- silx.utils: Miscellaneous convenient functions
-
-See silx documentation: http://www.silx.org/doc/silx/latest/
 """
 
 __authors__ = ["Jérôme Kieffer"]
 __license__ = "MIT"
-__date__ = "31/08/2018"
+__date__ = "27/11/2023"
 
 import os as _os
 import logging as _logging
diff --git a/src/freesas/_version.py b/src/freesas/_version.py
new file mode 100755
index 0000000..76d28c5
--- /dev/null
+++ b/src/freesas/_version.py
@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2015-2023 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
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# 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:
+* version = "1.2.3" or "1.2.3-beta4"
+* version_info = named tuple (1,2,3,"beta",4)
+* hexversion: 0x010203B4
+* strictversion = "1.2.3b4
+* debianversion = "1.2.3~beta4"
+* calc_hexversion: the function to transform a version_tuple into an integer
+
+This is called hexversion since it only really looks meaningful when viewed as the
+result of passing it to the built-in hex() function.
+The version_info value may be used for a more human-friendly encoding of the same information.
+
+The hexversion is a 32-bit number with the following layout:
+Bits (big endian order)     Meaning
+1-8     PY_MAJOR_VERSION (the 2 in 2.1.0a3)
+9-16     PY_MINOR_VERSION (the 1 in 2.1.0a3)
+17-24     PY_MICRO_VERSION (the 0 in 2.1.0a3)
+25-28     PY_RELEASE_LEVEL (0xA for alpha, 0xB for beta, 0xC for release candidate and 0xF for final)
+29-32     PY_RELEASE_SERIAL (the 3 in 2.1.0a3, zero for final releases)
+
+Thus 2.1.0a3 is hexversion 0x020100a3.
+
+"""
+
+__authors__ = ["Jérôme Kieffer"]
+__license__ = "MIT"
+__copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
+__date__ = "04/12/2023"
+__status__ = "production"
+__docformat__ = 'restructuredtext'
+__all__ = ["date", "version_info", "strictversion", "hexversion", "debianversion",
+           "calc_hexversion", "citation"]
+
+RELEASE_LEVEL_VALUE = {"dev": 0,
+                       "alpha": 10,
+                       "beta": 11,
+                       "candidate": 12,
+                       "final": 15}
+
+PRERELEASE_NORMALIZED_NAME = {"dev": "a",
+                              "alpha": "a",
+                              "beta": "b",
+                              "candidate": "rc"}
+MAJOR = 0
+MINOR = 9
+MICRO = 9
+RELEV = "dev"  # <16
+SERIAL = 1  # <16
+
+date = __date__
+
+try:
+    from collections import namedtuple
+except ImportError:
+    """Work around against issue https://github.com/pypa/build/issues/705"""
+    wheel_version = f"{MAJOR}.{MINOR}.{MICRO}" if RELEV == "final" else f"{MAJOR}.{MINOR}.{MICRO}{PRERELEASE_NORMALIZED_NAME[RELEV]}{SERIAL}"
+    print(wheel_version)
+    import sys
+    sys.exit(0)
+    
+
+_version_info = namedtuple("version_info", ["major", "minor", "micro", "releaselevel", "serial"])
+
+version_info = _version_info(MAJOR, MINOR, MICRO, RELEV, SERIAL)
+
+strictversion = version = debianversion = "%d.%d.%d" % version_info[:3]
+
+_dated_version = namedtuple("dated_version", ["version", "date"])
+dated_version = _dated_version(version=version, date=date)
+
+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])
+
+
+
+def calc_hexversion(major=0, minor=0, micro=0, releaselevel="dev", serial=0, string=None):
+    """Calculate the hexadecimal version number from the tuple version_info:
+
+    :param major: integer
+    :param minor: integer
+    :param micro: integer
+    :param relev: integer or string
+    :param serial: integer
+    :param string: version number as a string
+    :return: integer always increasing with revision numbers
+    """
+    if string is not None:
+        global _PATTERN
+        if _PATTERN is None:
+            import re
+            _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)
+        result = result.groups()
+        major, minor, micro = int(result[0]), int(result[1]), int(result[2])
+        releaselevel = result[3]
+        if releaselevel is None:
+            releaselevel = 0
+
+    try:
+        releaselevel = int(releaselevel)
+    except ValueError:
+        releaselevel = RELEASE_LEVEL_VALUE.get(releaselevel, 0)
+
+    hex_version = int(serial)
+    hex_version |= releaselevel * 1 << 4
+    hex_version |= int(micro) * 1 << 8
+    hex_version |= int(minor) * 1 << 16
+    hex_version |= int(major) * 1 << 24
+    return hex_version
+
+
+hexversion = calc_hexversion(*version_info)
+
+citation = "doi:10.1107/S1600577522007238"
+
+if __name__ == "__main__":
+    from argparse import ArgumentParser
+
+    parser = ArgumentParser(usage="print the version of the software")
+    parser.add_argument("--wheel", action="store_true", dest="wheel", default=None,
+                        help="print version formated for wheel")
+    parser.add_argument("--debian", action="store_true", dest="debian", default=None,
+                        help="print version formated for debian")
+    options = parser.parse_args()
+    if options.debian:
+        print(debianversion)
+    elif options.wheel:
+        print(strictversion)
+    else:
+        print(version)
diff --git a/freesas/align.py b/src/freesas/align.py
similarity index 100%
rename from freesas/align.py
rename to src/freesas/align.py
diff --git a/freesas/app/__init__.py b/src/freesas/app/__init__.py
similarity index 100%
rename from freesas/app/__init__.py
rename to src/freesas/app/__init__.py
diff --git a/freesas/app/auto_gpa.py b/src/freesas/app/auto_gpa.py
similarity index 100%
rename from freesas/app/auto_gpa.py
rename to src/freesas/app/auto_gpa.py
diff --git a/freesas/app/auto_guinier.py b/src/freesas/app/auto_guinier.py
similarity index 100%
rename from freesas/app/auto_guinier.py
rename to src/freesas/app/auto_guinier.py
diff --git a/freesas/app/autorg.py b/src/freesas/app/autorg.py
similarity index 100%
rename from freesas/app/autorg.py
rename to src/freesas/app/autorg.py
diff --git a/freesas/app/bift.py b/src/freesas/app/bift.py
similarity index 100%
rename from freesas/app/bift.py
rename to src/freesas/app/bift.py
diff --git a/freesas/app/cormap.py b/src/freesas/app/cormap.py
similarity index 100%
rename from freesas/app/cormap.py
rename to src/freesas/app/cormap.py
diff --git a/freesas/app/extract_ascii.py b/src/freesas/app/extract_ascii.py
similarity index 100%
rename from freesas/app/extract_ascii.py
rename to src/freesas/app/extract_ascii.py
diff --git a/src/freesas/app/meson.build b/src/freesas/app/meson.build
new file mode 100644
index 0000000..aac2c24
--- /dev/null
+++ b/src/freesas/app/meson.build
@@ -0,0 +1,14 @@
+py.install_sources([
+    '__init__.py',
+    'auto_gpa.py',
+    'auto_guinier.py',
+    'autorg.py',
+    'bift.py',
+    'cormap.py',
+    'extract_ascii.py',
+    'plot_sas.py',
+    'supycomb.py'
+],
+  pure: false,    # Will be installed next to binaries
+  subdir: 'freesas/app'  # Folder relative to site-packages to install to
+)
diff --git a/freesas/app/plot_sas.py b/src/freesas/app/plot_sas.py
similarity index 100%
rename from freesas/app/plot_sas.py
rename to src/freesas/app/plot_sas.py
diff --git a/freesas/app/supycomb.py b/src/freesas/app/supycomb.py
similarity index 100%
rename from freesas/app/supycomb.py
rename to src/freesas/app/supycomb.py
diff --git a/freesas/autorg.py b/src/freesas/autorg.py
similarity index 100%
rename from freesas/autorg.py
rename to src/freesas/autorg.py
diff --git a/freesas/average.py b/src/freesas/average.py
similarity index 100%
rename from freesas/average.py
rename to src/freesas/average.py
diff --git a/freesas/bift.py b/src/freesas/bift.py
similarity index 100%
rename from freesas/bift.py
rename to src/freesas/bift.py
diff --git a/freesas/collections.py b/src/freesas/collections.py
similarity index 100%
rename from freesas/collections.py
rename to src/freesas/collections.py
diff --git a/freesas/cormap.py b/src/freesas/cormap.py
similarity index 100%
rename from freesas/cormap.py
rename to src/freesas/cormap.py
diff --git a/freesas/decorators.py b/src/freesas/decorators.py
similarity index 100%
rename from freesas/decorators.py
rename to src/freesas/decorators.py
diff --git a/src/freesas/ext/__init__.py b/src/freesas/ext/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/freesas/_autorg.pyx b/src/freesas/ext/_autorg.pyx
similarity index 99%
rename from freesas/_autorg.pyx
rename to src/freesas/ext/_autorg.pyx
index 2e2d009..74751c3 100644
--- a/freesas/_autorg.pyx
+++ b/src/freesas/ext/_autorg.pyx
@@ -23,7 +23,6 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
-from builtins import None, NotImplementedError
 
 """
 Loosely based on the autoRg implementation in BioXTAS RAW by J. Hopkins
@@ -57,7 +56,9 @@ class NoGuinierRegionError(Error):
 
 
 import cython
-cimport numpy as cnumpy
+from .shared_types cimport int8_t, uint8_t, int16_t, uint16_t, \
+                           int32_t, uint32_t, int64_t, uint64_t,\
+                           float32_t, float64_t, floating, any_int_t, any_t
 import numpy as numpy 
 from libc.math cimport sqrt, log, fabs, exp, atanh, ceil, NAN
 from .isnan cimport isfinite 
@@ -67,7 +68,7 @@ logger = logging.getLogger(__name__)
 from .collections import RG_RESULT, FIT_RESULT
 
 DTYPE = numpy.float64
-ctypedef double DTYPE_t
+ctypedef float64_t DTYPE_t
 
 # Definition of a few constants
 cdef: 
@@ -232,7 +233,7 @@ cdef inline void guinier_space(int start,
                                DTYPE_t[::1] sigma, 
                                DTYPE_t[::1] q2, 
                                DTYPE_t[::1] lnI, 
-                               DTYPE_t[::1] I2_over_sigma2) nogil:
+                               DTYPE_t[::1] I2_over_sigma2) noexcept nogil:
         "Initialize q², ln(I) and I/sigma array"
         cdef:
             int idx
@@ -636,7 +637,7 @@ cdef class AutoGuinier:
         """
         cdef:
             int start, stop, end, size, lower, upper, i
-            cnumpy.int32_t[::1] unweigted_start, unweigted_stop
+            int32_t[::1] unweigted_start, unweigted_stop
             DTYPE_t[::1] weigted_start,weigted_stop
             DTYPE_t max_weight, weight, qmin_Rg, qmax_Rg, RMSD 
         end = <int> numpy.max(fits[:,5])
@@ -1011,7 +1012,6 @@ def autoRg(sasm):
     cdef:
         DTYPE_t quality, intercept, slope, sigma_slope, lower, upper, r_sqr
         bint aggregated = 0
-        cnumpy.ndarray qualities
         DTYPE_t[::1] q_ary, i_ary, sigma_ary, lgi_ary, q2_ary, wg_ary, 
         DTYPE_t[::1] fit_data
         int[::1] offsets, data_range
@@ -1020,7 +1020,7 @@ def autoRg(sasm):
         int start, end, nb_fit, array_size, block_size=39 #page of 4k
         int idx_min, idx_max, idx, err
         DTYPE_t[:, ::1] fit_mv, tmp_mv
-        cnumpy.ndarray[DTYPE_t, ndim=2] fit_array
+        # DTYPE_t[:, :] fit_array
         
     raw_size = len(sasm)
     q_ary = numpy.empty(raw_size, dtype=DTYPE)
diff --git a/freesas/_bift.pyx b/src/freesas/ext/_bift.pyx
similarity index 99%
rename from freesas/_bift.pyx
rename to src/freesas/ext/_bift.pyx
index 586a877..030fcfa 100644
--- a/freesas/_bift.pyx
+++ b/src/freesas/ext/_bift.pyx
@@ -18,17 +18,16 @@ cdef:
     list authors
     str __license__, __copyright__, __date__
 
-__authors__ = ["Jerome Kieffer", "Jesse Hopkins"]
+__authors__ = ["Jérôme Kieffer", "Jesse Hopkins"]
 __license__ = "MIT"
-__copyright__ = "2020, ESRF"
-__date__ = "10/06/2020"
+__copyright__ = "2020-2023, ESRF"
+__date__ = "27/11/2023"
 
 import time
 import cython
 from cython.parallel import prange
 from cython.view cimport array as cvarray
 import numpy
-cimport numpy as cnumpy
 from libc.math cimport sqrt, fabs, pi, sin, log, exp, isfinite
 
 from scipy.linalg import lapack
@@ -59,7 +58,7 @@ cpdef inline double blas_ddot(double[::1] a, double[::1] b) nogil:
     return ddot(&n, a0, &one, b0, &one)
 
 
-cpdef int blas_dgemm(double[:,::1] a, double[:,::1] b, double[:,::1] c, double alpha=1.0, double beta=0.0) nogil except -1:
+cpdef int blas_dgemm(double[:,::1] a, double[:,::1] b, double[:,::1] c, double alpha=1.0, double beta=0.0) noexcept nogil:
     "Wrapper for double matrix-matrix multiplication C = AxB "
     cdef:
         char *transa = 'n'
@@ -87,7 +86,7 @@ cpdef int blas_dgemm(double[:,::1] a, double[:,::1] b, double[:,::1] c, double a
     return 0
 
 
-cpdef int lapack_svd(double[:, ::1] A, double[::1] eigen, double[::1] work) nogil except -1:
+cpdef int lapack_svd(double[:, ::1] A, double[::1] eigen, double[::1] work) noexcept nogil:
     cdef:
         char *jobN = 'n'
         int n, lda, lwork, info, one=1
@@ -505,7 +504,7 @@ cdef class BIFT:
                             double[:, ::1] transp_matrix,
                             double[:, ::1] B,
                             double[::1] sum_dia
-                            ) nogil except -1:
+                            ) noexcept nogil:
 
         cdef:
             double tmp, ql, prefactor, delta_r, il, varl
@@ -959,7 +958,8 @@ cdef class BIFT:
             double area, ev_max, evidence_avg, evidence_std,
             double Dmax_avg, Dmax_std, alpha_avg, alpha_std, chi2_avg, chi2_std,
             double regularization_avg, regularization_std, Rg_std, Rg_avg, I0_avg, I0_std
-            cnumpy.ndarray radius, densities, evidences, Dmaxs, alphas, chi2s, regularizations, proba, density_avg, density_std, areas, area2s, Rgs
+            #2d densities,
+            # 1d radius, evidences, Dmaxs, alphas, chi2s, regularizations, proba, density_avg, density_std, areas, area2s, Rgs
 
         best_key, best, nvalid = self.get_best()
         if nvalid < 2:
diff --git a/freesas/_cormap.pyx b/src/freesas/ext/_cormap.pyx
similarity index 100%
rename from freesas/_cormap.pyx
rename to src/freesas/ext/_cormap.pyx
diff --git a/freesas/_distance_nomp.pxi b/src/freesas/ext/_distance.pyx
similarity index 55%
rename from freesas/_distance_nomp.pxi
rename to src/freesas/ext/_distance.pyx
index 28a608f..b0aeffd 100644
--- a/freesas/_distance_nomp.pxi
+++ b/src/freesas/ext/_distance.pyx
@@ -1,4 +1,76 @@
-#Serial version of distance calculation
+#Cython module to calculate distances of set of atoms
+
+__author__ = "Jérôme Kieffer"
+__license__ = "MIT"
+__copyright__ = "2023, ESRF"
+
+import sys
+import cython
+import numpy
+from cython cimport floating
+from libc.math cimport sqrt, fabs, exp
+
+
+@cython.wraparound(False)
+@cython.boundscheck(False)
+def calc_invariants(floating[:, :] atoms):
+    """
+    Calculate the invariants of the structure, i.e fineness, radius of gyration and diameter of the model.
+
+    Nota: to economize size*numpy.sqrt, the sqrt is taken at the end of the calculation. 
+    We should have done s += sqrt(d) and then s/size, but we do s+= d and then sqrt(s/size).
+    You can check that the result is the same.
+
+    @param atoms: 2d-array with atom coordinates:[[x,y,z],...]
+    @return: 3-tuple containing (fineness, Rg, Dmax)
+        * average distance between an atoms and its nearest neighbor
+        * radius of gyration of the model
+        * diameter of the model
+    """
+    cdef:
+        int i, j, size
+        floating d, x1, y1, z1, dx, dy, dz, big, d2, sum_d2, d2max
+    size = atoms.shape[0]
+    assert atoms.shape[1] >= 3
+    big = sys.maxsize
+    s = 0.0
+    sum_d2 = 0.0 
+    d2max = 0.0
+    for i in range(size):
+        x1 = atoms[i, 0]
+        y1 = atoms[i, 1]
+        z1 = atoms[i, 2]
+        d = big
+        for j in range(size):
+            if i == j:
+                continue
+            dx = atoms[j, 0] - x1
+            dy = atoms[j, 1] - y1
+            dz = atoms[j, 2] - z1
+            d2 = dx * dx + dy * dy + dz * dz
+            sum_d2 += d2
+            d2max = max(d2max, d2)
+            d = min(d, d2)
+        s += d
+    return sqrt(s / size), sqrt(sum_d2 / 2.0) / size, sqrt(d2max)
+
+
+cdef inline floating hard_sphere(floating pos, floating radius) noexcept nogil:
+    """Density using hard spheres
+    @param pos: fabs(d1-d)
+    """
+    if pos > 2.0 * radius:
+        return 0.0 
+    return (4 * radius + pos) * (2 * radius - pos) ** 2 / (16.0 * radius ** 3)
+
+cdef inline floating soft_sphere(floating pos, floating radius) noexcept nogil:
+    """Density using soft spheres (gaussian density)
+    @param pos: fabs(d1-d)
+    @param radius: radius of the equivalent hard sphere
+    """
+    cdef floating sigma = 0.40567 * radius
+    return exp(- pos * pos / (2.0 * sigma * sigma)) * 0.3989422804014327 / sigma
+
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
@@ -86,3 +158,4 @@ def calc_density(floating[:, :] atoms, floating dmax, int npt, floating r=0.0, b
                 else:
                     out[k] += soft_sphere(fabs(k * delta - d), r)
     return numpy.asarray(out)
+
diff --git a/freesas/include/isnan.h b/src/freesas/ext/include/isnan.h
similarity index 100%
rename from freesas/include/isnan.h
rename to src/freesas/ext/include/isnan.h
diff --git a/freesas/isnan.pxd b/src/freesas/ext/isnan.pxd
similarity index 100%
rename from freesas/isnan.pxd
rename to src/freesas/ext/isnan.pxd
diff --git a/src/freesas/ext/meson.build b/src/freesas/ext/meson.build
new file mode 100644
index 0000000..4f3862c
--- /dev/null
+++ b/src/freesas/ext/meson.build
@@ -0,0 +1,31 @@
+py.extension_module('_distance',
+        '_distance.pyx',
+        dependencies : py_dep,
+        include_directories : ['include'],
+        install: true,
+        subdir: 'freesas',
+        )
+
+py.extension_module('_cormap',
+        '_cormap.pyx',
+        dependencies : py_dep,
+        include_directories : ['include'],
+        install: true,
+        subdir: 'freesas',
+        )
+
+py.extension_module('_autorg',
+        '_autorg.pyx',
+        dependencies : py_dep,
+        include_directories : ['include'],
+        install: true,
+        subdir: 'freesas',
+        )
+
+py.extension_module('_bift',
+        '_bift.pyx',
+        dependencies : py_dep,
+        include_directories : ['include'],
+        install: true,
+        subdir: 'freesas',
+        )
diff --git a/src/freesas/ext/shared_types.pxd b/src/freesas/ext/shared_types.pxd
new file mode 100644
index 0000000..46524cb
--- /dev/null
+++ b/src/freesas/ext/shared_types.pxd
@@ -0,0 +1,33 @@
+"""This replaces the `cimport numpy` for C-level datatypes"""
+
+from libc.stdint cimport int8_t, uint8_t, int16_t, uint16_t, \
+                         int32_t, uint32_t, int64_t, uint64_t
+
+ctypedef double float64_t
+ctypedef float float32_t
+
+from cython cimport floating
+
+ctypedef fused any_int_t:
+    uint8_t
+    uint16_t
+    uint32_t
+    uint64_t
+    int8_t
+    int16_t
+    int32_t
+    int64_t
+
+ctypedef fused any_t:
+    int
+    long
+    uint8_t
+    uint16_t
+    uint32_t
+    uint64_t
+    int8_t
+    int16_t
+    int32_t
+    int64_t
+    float32_t
+    float64_t
diff --git a/src/freesas/ext/shared_types.pyx b/src/freesas/ext/shared_types.pyx
new file mode 100644
index 0000000..e9a2dfa
--- /dev/null
+++ b/src/freesas/ext/shared_types.pyx
@@ -0,0 +1 @@
+"Place-holder"
diff --git a/freesas/fitting.py b/src/freesas/fitting.py
similarity index 97%
rename from freesas/fitting.py
rename to src/freesas/fitting.py
index 9242c40..8a7986e 100644
--- a/freesas/fitting.py
+++ b/src/freesas/fitting.py
@@ -5,14 +5,14 @@
 __contact__ = "martha.brennich@googlemail.com"
 __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
-__date__ = "21/03/2021"
+__date__ = "29/11/2023"
 __status__ = "development"
 __docformat__ = "restructuredtext"
 
 import sys
 import logging
 import platform
-from os import linesep as os_linesep
+import os
 from pathlib import Path
 from contextlib import contextmanager
 from typing import Callable, List, Optional, IO, Generator
@@ -46,7 +46,7 @@ def collect_files(file_list: List[str]) -> List[Path]:
     :param file_list: file list as returned by the argparser
     :return: A list of Path objects which includes only existing files
     """
-    files = [Path(i) for i in file_list if Path(i).exists()]
+    files = [Path(i) for i in file_list if os.path.exists(i)]
     if platform.system() == "Windows" and files == []:
         files = list(Path.cwd().glob(file_list[0]))
         files.sort()
@@ -78,7 +78,7 @@ def get_linesep(output_destination: IO[str]) -> str:
     """
     # pylint: disable=R1705
     if output_destination == sys.stdout:
-        return os_linesep
+        return os.linesep
     else:
         return "\n"
 
@@ -209,7 +209,7 @@ def run_guinier_fit(
                     IndexError,
                 ) as err:
                     sys.stderr.write(
-                        f"{afile}, {err.__class__.__name__}: {err} {os_linesep}"
+                        f"{afile}, {err.__class__.__name__}: {err} {os.linesep}"
                     )
                 else:
                     res = rg_result_to_output_line(
diff --git a/freesas/invariants.py b/src/freesas/invariants.py
similarity index 100%
rename from freesas/invariants.py
rename to src/freesas/invariants.py
diff --git a/src/freesas/meson.build b/src/freesas/meson.build
new file mode 100644
index 0000000..4a0b86b
--- /dev/null
+++ b/src/freesas/meson.build
@@ -0,0 +1,26 @@
+subdir('app')
+subdir('ext')
+subdir('test')
+
+
+py.install_sources([
+    '_version.py',
+    '__init__.py',
+    'align.py',
+    'autorg.py',
+    'average.py',
+    'bift.py',
+    'collections.py',
+    'cormap.py',
+    'decorators.py',
+    'fitting.py',
+    'invariants.py',
+    'model.py',
+    'plot.py',
+    'sas_argparser.py',
+    'sasio.py',
+    'transformations.py',
+],
+  pure: false,    # Will be installed next to binaries
+  subdir: 'freesas'  # Folder relative to site-packages to install to
+)
diff --git a/freesas/model.py b/src/freesas/model.py
similarity index 100%
rename from freesas/model.py
rename to src/freesas/model.py
diff --git a/freesas/plot.py b/src/freesas/plot.py
similarity index 100%
rename from freesas/plot.py
rename to src/freesas/plot.py
diff --git a/freesas/sas_argparser.py b/src/freesas/sas_argparser.py
similarity index 100%
rename from freesas/sas_argparser.py
rename to src/freesas/sas_argparser.py
diff --git a/freesas/sasio.py b/src/freesas/sasio.py
similarity index 100%
rename from freesas/sasio.py
rename to src/freesas/sasio.py
diff --git a/freesas/test/__init__.py b/src/freesas/test/__init__.py
similarity index 100%
rename from freesas/test/__init__.py
rename to src/freesas/test/__init__.py
diff --git a/src/freesas/test/meson.build b/src/freesas/test/meson.build
new file mode 100644
index 0000000..9273818
--- /dev/null
+++ b/src/freesas/test/meson.build
@@ -0,0 +1,19 @@
+py.install_sources([
+'__init__.py',
+'mock_open_38.py',
+'test_align.py',
+'test_all.py',
+'test_autorg.py',
+'test_average.py',
+'test_bift.py',
+'test_cormap.py',
+'test_distance.py',
+'test_fitting.py',
+'test_model.py',
+'test_sas_argparser.py',
+'test_sasio.py',
+'utilstest.py',
+],
+  pure: false,    # Will be installed next to binaries
+  subdir: 'freesas/test'  # Folder relative to site-packages to install to
+)
diff --git a/freesas/test/mock_open_38.py b/src/freesas/test/mock_open_38.py
similarity index 100%
rename from freesas/test/mock_open_38.py
rename to src/freesas/test/mock_open_38.py
diff --git a/freesas/test/test_align.py b/src/freesas/test/test_align.py
similarity index 99%
rename from freesas/test/test_align.py
rename to src/freesas/test/test_align.py
index 3137e63..93bea7a 100644
--- a/freesas/test/test_align.py
+++ b/src/freesas/test/test_align.py
@@ -7,7 +7,7 @@
 
 import numpy
 import unittest
-from .utilstests import get_datafile
+from .utilstest import get_datafile
 from ..model import SASModel
 from ..align import AlignModels
 from ..transformations import translation_matrix, euler_matrix
diff --git a/freesas/test/test_all.py b/src/freesas/test/test_all.py
similarity index 100%
rename from freesas/test/test_all.py
rename to src/freesas/test/test_all.py
diff --git a/freesas/test/test_autorg.py b/src/freesas/test/test_autorg.py
similarity index 99%
rename from freesas/test/test_autorg.py
rename to src/freesas/test/test_autorg.py
index e27560f..3acbc1b 100644
--- a/freesas/test/test_autorg.py
+++ b/src/freesas/test/test_autorg.py
@@ -25,7 +25,7 @@
 
 __authors__ = ["J. Kieffer"]
 __license__ = "MIT"
-__date__ = "10/06/2020"
+__date__ = "29/11/2023"
 
 import logging
 import unittest
@@ -34,7 +34,7 @@
 import numpy
 from scipy.stats import linregress
 
-from .utilstests import get_datafile
+from .utilstest import get_datafile
 from ..autorg import (
     autoRg,
     RG_RESULT,
diff --git a/freesas/test/test_average.py b/src/freesas/test/test_average.py
similarity index 98%
rename from freesas/test/test_average.py
rename to src/freesas/test/test_average.py
index 317bd11..ddd6b80 100644
--- a/freesas/test/test_average.py
+++ b/src/freesas/test/test_average.py
@@ -8,7 +8,7 @@
 
 import numpy
 import unittest
-from .utilstests import get_datafile
+from .utilstest import get_datafile
 from ..model import SASModel
 from ..average import Grid, AverModels
 
diff --git a/freesas/test/test_bift.py b/src/freesas/test/test_bift.py
similarity index 98%
rename from freesas/test/test_bift.py
rename to src/freesas/test/test_bift.py
index c1b27bb..dd5eb17 100644
--- a/freesas/test/test_bift.py
+++ b/src/freesas/test/test_bift.py
@@ -25,11 +25,11 @@
 
 __authors__ = ["J. Kieffer"]
 __license__ = "MIT"
-__date__ = "10/06/2020"
+__date__ = "29/11/2023"
 
 import numpy
 import unittest
-from .utilstests import get_datafile
+from .utilstest import get_datafile
 from ..bift import auto_bift
 from .._bift import BIFT, distribution_parabola, distribution_sphere, \
                     ensure_edges_zero, smooth_density
diff --git a/freesas/test/test_cormap.py b/src/freesas/test/test_cormap.py
similarity index 100%
rename from freesas/test/test_cormap.py
rename to src/freesas/test/test_cormap.py
diff --git a/freesas/test/test_distance.py b/src/freesas/test/test_distance.py
similarity index 96%
rename from freesas/test/test_distance.py
rename to src/freesas/test/test_distance.py
index 490e6a6..d02a30a 100644
--- a/freesas/test/test_distance.py
+++ b/src/freesas/test/test_distance.py
@@ -5,11 +5,11 @@
 __author__ = "Jérôme Kieffer"
 __license__ = "MIT"
 __copyright__ = "2015, ESRF"
-__date__ = "16/12/2015"
+__date__ = "29/11/2023"
 
 import numpy
 import unittest
-from .utilstests import get_datafile
+from .utilstest import get_datafile
 from ..model import SASModel
 import logging
 logging.basicConfig(level=logging.INFO)
diff --git a/freesas/test/test_fitting.py b/src/freesas/test/test_fitting.py
similarity index 100%
rename from freesas/test/test_fitting.py
rename to src/freesas/test/test_fitting.py
diff --git a/freesas/test/test_model.py b/src/freesas/test/test_model.py
similarity index 97%
rename from freesas/test/test_model.py
rename to src/freesas/test/test_model.py
index bdbeb9c..b8e1e19 100644
--- a/freesas/test/test_model.py
+++ b/src/freesas/test/test_model.py
@@ -10,7 +10,7 @@
 import unittest
 import os
 import tempfile
-from .utilstests import get_datafile
+from .utilstest import get_datafile
 from ..model import SASModel
 from ..transformations import translation_from_matrix, euler_from_matrix
 import logging
@@ -50,8 +50,8 @@ def test_same(self):
         m = SASModel()
         m.read(self.testfile)
         m.save(self.outfile)
-        infile = open(self.testfile).read()
-        outfile = open(self.outfile).read()
+        with open(self.testfile) as f: infile=f.read()
+        with open(self.outfile) as f: outfile=f.read()
         self.assertEqual(infile, outfile, msg="file content is the same")
 
     def test_rfactor(self):
diff --git a/freesas/test/test_sas_argparser.py b/src/freesas/test/test_sas_argparser.py
similarity index 100%
rename from freesas/test/test_sas_argparser.py
rename to src/freesas/test/test_sas_argparser.py
diff --git a/freesas/test/test_sasio.py b/src/freesas/test/test_sasio.py
similarity index 100%
rename from freesas/test/test_sasio.py
rename to src/freesas/test/test_sasio.py
diff --git a/src/freesas/test/utilstest.py b/src/freesas/test/utilstest.py
new file mode 100644
index 0000000..79453bb
--- /dev/null
+++ b/src/freesas/test/utilstest.py
@@ -0,0 +1,80 @@
+#!usr/bin/env python
+# coding: utf-8
+
+__author__ = "Jérôme Kieffer"
+__license__ = "MIT"
+__date__ = "28/11/2023"
+__copyright__ = "2015-2021, ESRF"
+
+import os
+import logging
+logger = logging.getLogger("utilstest")
+from silx.resources import ExternalResources
+downloader = ExternalResources("freesas", "http://www.silx.org/pub/freesas/testdata", "FREESAS_TESTDATA")
+
+
+def get_datafile(name):
+    """Provides the full path of a test file,
+    downloading it from the internet if needed
+
+    :param name: name of the file to get
+    :return: full path of the datafile
+    """
+    logger.info(f"Download file {name}")
+    fullpath = downloader.getfile(name)
+    return fullpath
+
+def clean():
+    pass
+
+class TestOptions(object):
+    """
+    Class providing useful stuff for preparing tests.
+    """
+    def __init__(self):
+        self.TEST_LOW_MEM = False
+        """Skip tests using too much memory"""
+
+        self.TEST_RANDOM = False
+        """Use a random seed to generate random values"""
+
+        self.options = None
+
+    def __repr__(self):
+        return f"TEST_LOW_MEM={self.TEST_LOW_MEM} "\
+               f"TEST_RANDOM={self.TEST_RANDOM} "
+    @property
+    def low_mem(self):
+        """For compatibility"""
+        return self.TEST_LOW_MEM
+
+    def configure(self, parsed_options=None):
+        """Configure the TestOptions class from the command line arguments and the
+        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':
+            self.TEST_LOW_MEM = True
+
+        if parsed_options is not None and parsed_options.random:
+            self.TEST_RANDOM = True
+        if os.environ.get('FREESAS_RANDOM', 'False').lower() in ("1", "true", "on"):
+            self.TEST_RANDOM = True
+
+
+    def add_parser_argument(self, parser):
+        """Add extrat arguments to the test argument parser
+
+        :param ArgumentParser parser: An argument parser
+        """
+        parser.add_argument("-l", "--low-mem", dest="low_mem", default=False,
+                            action="store_true",
+                            help="Disable test with large memory consumption (>100Mbyte")
+        parser.add_argument("-r", "--random", dest="random", default=False,
+                            action="store_true",
+                            help="Enable actual random number to be generated. By default, stable seed ensures reproducibility of tests")
+
+
+test_options = TestOptions() #singleton
diff --git a/freesas/transformations.py b/src/freesas/transformations.py
similarity index 100%
rename from freesas/transformations.py
rename to src/freesas/transformations.py
diff --git a/version.py b/version.py
deleted file mode 100644
index 94e2ff4..0000000
--- a/version.py
+++ /dev/null
@@ -1,121 +0,0 @@
-#!/usr/bin/env python3
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2015-2021 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
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# 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:
-* version = "1.2.3" or "1.2.3-beta4"
-* version_info = named tuple (1,2,3,"beta",4)
-* hexversion: 0x010203B4
-* strictversion = "1.2.3b4
-* debianversion = "1.2.3~beta4"
-* calc_hexversion: the function to transform a version_tuple into an integer
-
-This is called hexversion since it only really looks meaningful when viewed as the
-result of passing it to the built-in hex() function.
-The version_info value may be used for a more human-friendly encoding of the same information.
-
-The hexversion is a 32-bit number with the following layout:
-Bits (big endian order)     Meaning
-1-8     PY_MAJOR_VERSION (the 2 in 2.1.0a3)
-9-16     PY_MINOR_VERSION (the 1 in 2.1.0a3)
-17-24     PY_MICRO_VERSION (the 0 in 2.1.0a3)
-25-28     PY_RELEASE_LEVEL (0xA for alpha, 0xB for beta, 0xC for release candidate and 0xF for final)
-29-32     PY_RELEASE_SERIAL (the 3 in 2.1.0a3, zero for final releases)
-
-Thus 2.1.0a3 is hexversion 0x020100a3.
-
-"""
-
-__authors__ = ["Jérôme Kieffer"]
-__license__ = "MIT"
-__copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
-__date__ = "25/01/2021"
-__status__ = "production"
-__docformat__ = 'restructuredtext'
-__all__ = ["date", "version_info", "strictversion", "hexversion", "debianversion",
-           "calc_hexversion"]
-
-RELEASE_LEVEL_VALUE = {"dev": 0,
-                       "alpha": 10,
-                       "beta": 11,
-                       "candidate": 12,
-                       "final": 15}
-
-PRERELEASE_NORMALIZED_NAME = {"dev": "a",
-                              "alpha": "a",
-                              "beta": "b",
-                              "candidate": "rc"}
-MAJOR = 0
-MINOR = 9
-MICRO = 2
-RELEV = "dev"  # <16
-SERIAL = 0  # <16
-
-date = __date__
-
-from collections import namedtuple
-_version_info = namedtuple("version_info", ["major", "minor", "micro", "releaselevel", "serial"])
-
-version_info = _version_info(MAJOR, MINOR, MICRO, RELEV, SERIAL)
-
-strictversion = version = debianversion = "%d.%d.%d" % version_info[:3]
-
-_dated_version = namedtuple("dated_version", ["version", "date"])
-dated_version = _dated_version(version=version, date=date)
-
-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])
-
-
-def calc_hexversion(major=0, minor=0, micro=0, releaselevel="dev", serial=0):
-    """Calculate the hexadecimal version number from the tuple version_info:
-
-    :param major: integer
-    :param minor: integer
-    :param micro: integer
-    :param relev: integer or string
-    :param serial: integer
-    :return: integer always increasing with revision numbers
-    """
-    try:
-        releaselevel = int(releaselevel)
-    except ValueError:
-        releaselevel = RELEASE_LEVEL_VALUE.get(releaselevel, 0)
-
-    hex_version = int(serial)
-    hex_version |= releaselevel * 1 << 4
-    hex_version |= int(micro) * 1 << 8
-    hex_version |= int(minor) * 1 << 16
-    hex_version |= int(major) * 1 << 24
-    return hex_version
-
-
-hexversion = calc_hexversion(*version_info)
-
-if __name__ == "__main__":
-    print(version)
diff --git a/version.py b/version.py
new file mode 120000
index 0000000..d202c29
--- /dev/null
+++ b/version.py
@@ -0,0 +1 @@
+src/freesas/_version.py
\ No newline at end of file