Meson

.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')

.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

.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

bootstrap.py

@@ -10,73 +10,94 @@
 __authors__ = ["Frédéric-Emmanuel Picca", "Jérôme Kieffer"]
 __contact__ = "[email protected]"
 __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)
-