move build system to meson

Author: ndgrigorian

.flake8

@@ -41,7 +41,9 @@ per-file-ignores =
     mkl_fft/interfaces/scipy_fft.py: F401
     mkl_fft/interfaces/numpy_fft.py: F401
 
-exclude = _vendored/conv_template.py
+exclude =
+    _vendored/conv_template.py
+    _vendored/process_src_template.py
 
 filename = *.py, *.pyx, *.pxi, *.pxd
 max_line_length = 80

_vendored/README.md

@@ -1,5 +1,3 @@
 ## Vendored files
 
-File `conv_template.py` is copied from NumPy's numpy/distutils folder, since
-`numpy.distutils` is absent from the installation layout starting with
-Python 3.12
+Files `conv_template.py` and `process_src_template.py` are copied from NumPy's numpy/numpy/_build_utils folder

_vendored/conv_template.py

@@ -82,8 +82,8 @@
 __all__ = ['process_str', 'process_file']
 
 import os
-import sys
 import re
+import sys
 
 # names for replacement that are already global.
 global_names = {}
@@ -106,12 +106,12 @@ def parse_structure(astr, level):
     at zero. Returns an empty list if no loops found.
 
     """
-    if level == 0 :
+    if level == 0:
         loopbeg = "/**begin repeat"
         loopend = "/**end repeat**/"
-    else :
-        loopbeg = "/**begin repeat%d" % level
-        loopend = "/**end repeat%d**/" % level
+    else:
+        loopbeg = f"/**begin repeat{level}"
+        loopend = f"/**end repeat{level}**/"
 
     ind = 0
     line = 0
@@ -124,9 +124,9 @@ def parse_structure(astr, level):
         start2 = astr.find("\n", start2)
         fini1 = astr.find(loopend, start2)
         fini2 = astr.find("\n", fini1)
-        line += astr.count("\n", ind, start2+1)
-        spanlist.append((start, start2+1, fini1, fini2+1, line))
-        line += astr.count("\n", start2+1, fini2)
+        line += astr.count("\n", ind, start2 + 1)
+        spanlist.append((start, start2 + 1, fini1, fini2 + 1, line))
+        line += astr.count("\n", start2 + 1, fini2)
         ind = fini2
     spanlist.sort()
     return spanlist
@@ -135,10 +135,13 @@ def parse_structure(astr, level):
 def paren_repl(obj):
     torep = obj.group(1)
     numrep = obj.group(2)
-    return ','.join([torep]*int(numrep))
+    return ','.join([torep] * int(numrep))
+
 
 parenrep = re.compile(r"\(([^)]*)\)\*(\d+)")
 plainrep = re.compile(r"([^*]+)\*(\d+)")
+
+
 def parse_values(astr):
     # replaces all occurrences of '(a,b,c)*4' in astr
     # with 'a,b,c,a,b,c,a,b,c,a,b,c'. Empty braces generate
@@ -155,7 +158,7 @@ def parse_values(astr):
 named_re = re.compile(r"#\s*(\w*)\s*=([^#]*)#")
 exclude_vars_re = re.compile(r"(\w*)=(\w*)")
 exclude_re = re.compile(":exclude:")
-def parse_loop_header(loophead) :
+def parse_loop_header(loophead):
     """Find all named replacements in the header
 
     Returns a list of dictionaries, one for each loop iteration,
@@ -179,14 +182,13 @@ def parse_loop_header(loophead) :
         name = rep[0]
         vals = parse_values(rep[1])
         size = len(vals)
-        if nsub is None :
+        if nsub is None:
             nsub = size
-        elif nsub != size :
+        elif nsub != size:
             msg = "Mismatch in number of values, %d != %d\n%s = %s"
             raise ValueError(msg % (nsub, size, name, vals))
         names.append((name, vals))
 
-
     # Find any exclude variables
     excludes = []
 
@@ -200,30 +202,33 @@ def parse_loop_header(loophead) :
 
     # generate list of dictionaries, one for each template iteration
     dlist = []
-    if nsub is None :
+    if nsub is None:
         raise ValueError("No substitution variables found")
     for i in range(nsub):
         tmp = {name: vals[i] for name, vals in names}
         dlist.append(tmp)
     return dlist
 
+
 replace_re = re.compile(r"@(\w+)@")
-def parse_string(astr, env, level, line) :
-    lineno = "#line %d\n" % line
+
+
+def parse_string(astr, env, level, line):
+    lineno = f"#line {line}\n"
 
     # local function for string replacement, uses env
     def replace(match):
         name = match.group(1)
-        try :
+        try:
             val = env[name]
         except KeyError:
-            msg = 'line %d: no definition of key "%s"'%(line, name)
+            msg = f'line {line}: no definition of key "{name}"'
             raise ValueError(msg) from None
         return val
 
     code = [lineno]
     struct = parse_structure(astr, level)
-    if struct :
+    if struct:
         # recurse over inner loops
         oldend = 0
         newlevel = level + 1
@@ -234,18 +239,18 @@ def replace(match):
             oldend = sub[3]
             newline = line + sub[4]
             code.append(replace_re.sub(replace, pref))
-            try :
+            try:
                 envlist = parse_loop_header(head)
             except ValueError as e:
-                msg = "line %d: %s" % (newline, e)
+                msg = f"line {newline}: {e}"
                 raise ValueError(msg)
-            for newenv in envlist :
+            for newenv in envlist:
                 newenv.update(env)
                 newcode = parse_string(text, newenv, newlevel, newline)
                 code.extend(newcode)
         suff = astr[oldend:]
         code.append(replace_re.sub(replace, suff))
-    else :
+    else:
         # replace keys
         code.append(replace_re.sub(replace, astr))
     code.append('\n')
@@ -284,8 +289,8 @@ def process_file(source):
     try:
         code = process_str(''.join(lines))
     except ValueError as e:
-        raise ValueError('In "%s" loop at %s' % (sourcefile, e)) from None
-    return '#line 1 "%s"\n%s' % (sourcefile, code)
+        raise ValueError(f'In "{sourcefile}" loop at {e}') from None
+    return f'#line 1 "{sourcefile}"\n{code}'
 
 
 def unique_key(adict):
@@ -321,9 +326,10 @@ def main():
     try:
         writestr = process_str(allstr)
     except ValueError as e:
-        raise ValueError("In %s loop at %s" % (file, e)) from None
+        raise ValueError(f"In {file} loop at {e}") from None
 
     outfile.write(writestr)
 
+
 if __name__ == "__main__":
     main()

_vendored/process_src_template.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+import argparse
+import importlib.util
+import os
+
+
+def get_processor():
+    # Convoluted because we can't import from numpy
+    # (numpy is not yet built)
+    conv_template_path = os.path.join(
+        os.path.dirname(__file__),
+        'conv_template.py'
+    )
+    spec = importlib.util.spec_from_file_location(
+        'conv_template', conv_template_path
+    )
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod.process_file
+
+
+def process_and_write_file(fromfile, outfile):
+    """Process tempita templated file and write out the result.
+
+    The template file is expected to end in `.src`
+    (e.g., `.c.src` or `.h.src`).
+    Processing `npy_somefile.c.src` generates `npy_somefile.c`.
+
+    """
+    process_file = get_processor()
+    content = process_file(fromfile)
+    with open(outfile, 'w') as f:
+        f.write(content)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "infile",
+        type=str,
+        help="Path to the input file"
+    )
+    parser.add_argument(
+        "-o",
+        "--outfile",
+        type=str,
+        help="Path to the output file"
+    )
+    parser.add_argument(
+        "-i",
+        "--ignore",
+        type=str,
+        help="An ignored input - may be useful to add a "
+        "dependency between custom targets",
+    )
+    args = parser.parse_args()
+
+    if not args.infile.endswith('.src'):
+        raise ValueError(f"Unexpected extension: {args.infile}")
+
+    outfile_abs = os.path.join(os.getcwd(), args.outfile)
+    process_and_write_file(args.infile, outfile_abs)
+
+
+if __name__ == "__main__":
+    main()

meson.build

@@ -0,0 +1,95 @@
+project(
+    'mkl_fft',
+    ['c', 'cython'],
+    version: run_command(
+        'python', '-c',
+        'import os; exec(open("mkl_fft/_version.py").read()); print(__version__)',
+        check: true
+    ).stdout().strip(),
+    default_options: [
+        'buildtype=release',
+    ]
+)
+
+py = import('python').find_installation(pure: false)
+
+# numpy includes
+np_dir = run_command(py,
+    ['-c', 'import numpy; print(numpy.get_include())'],
+    check: true
+).stdout().strip()
+
+inc_np = include_directories(np_dir, 'mkl_fft/src', 'mkl_fft')
+
+# compiler/linker
+cc = meson.get_compiler('c')
+c_args = ['-DNDEBUG']
+
+mkl_dep = dependency('MKL', method: 'cmake',
+    modules: ['MKL::MKL'],
+    cmake_args: [
+        '-DMKL_ARCH=intel64',
+        '-DMKL_LINK=dynamic',
+        '-DMKL_THREADING=intel_thread',
+        '-DMKL_INTERFACE=lp64'
+    ],
+    required: true
+)
+
+# code gen
+src_file_cli = files('_vendored/process_src_template.py')
+
+gen_mklfft_c = custom_target(
+    'mklfft_c_generated',
+    output: 'mklfft.c',
+    input: 'mkl_fft/src/mklfft.c.src',
+    command: [py, src_file_cli, '@INPUT@', '-o', '@OUTPUT@'],
+)
+
+# cython
+py.extension_module(
+    '_pydfti',
+    sources: [
+        'mkl_fft/_pydfti.pyx',
+        gen_mklfft_c
+    ],
+    include_directories: inc_np,
+    dependencies: [mkl_dep],
+    c_args: c_args + [
+        '-DNPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION',
+        '-DPY_ARRAY_UNIQUE_SYMBOL=mkl_fft_ext'
+    ],
+    install: true,
+    subdir: 'mkl_fft'
+)
+
+# python
+py.install_sources(
+    [
+        'mkl_fft/__init__.py',
+        'mkl_fft/_fft_utils.py',
+        'mkl_fft/_init_helper.py',
+        'mkl_fft/_mkl_fft.py',
+        'mkl_fft/_patch_numpy.py',
+        'mkl_fft/_version.py',
+    ],
+    subdir: 'mkl_fft'
+)
+
+py.install_sources(
+    [
+        'mkl_fft/interfaces/__init__.py',
+        'mkl_fft/interfaces/_float_utils.py',
+        'mkl_fft/interfaces/_numpy_fft.py',
+        'mkl_fft/interfaces/_numpy_helper.py',
+        'mkl_fft/interfaces/_scipy_fft.py',
+        'mkl_fft/interfaces/numpy_fft.py',
+        'mkl_fft/interfaces/scipy_fft.py',
+    ],
+    subdir: 'mkl_fft/interfaces'
+)
+
+install_subdir(
+    'mkl_fft/tests',
+    install_dir: py.get_install_dir() / 'mkl_fft'
+)

pyproject.toml

@@ -24,13 +24,16 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 [build-system]
-build-backend = "setuptools.build_meta"
-requires = ["setuptools>=77", "Cython", "numpy", "mkl-devel"]
+build-backend = "mesonpy"
+requires = [
+  "meson-python>=0.13.0",
+  "Cython",
+  "numpy",
+  "mkl-devel"
+]
 
 [project]
-authors = [
-  {name = "Intel Corporation", email = "scripting@intel.com"}
-]
+authors = [{name = "Intel Corporation"}]
 classifiers = [
   "Development Status :: 5 - Production/Stable",
   "Intended Audience :: Science/Research",
@@ -68,7 +71,8 @@ Download = "http://github.com/IntelPython/mkl_fft"
 Homepage = "http://github.com/IntelPython/mkl_fft"
 
 [tool.black]
-exclude = "_vendored/conv_template.py"
+extend-exclude = "(^|/)_vendored/"
+force-exclude = "(^|/)_vendored/"
 line-length = 80
 
 [tool.cython-lint]
@@ -81,15 +85,5 @@ force_grid_wrap = 0
 include_trailing_comma = true
 line_length = 80
 multi_line_output = 3
-skip = ["_vendored/conv_template.py"]
+skip = ["_vendored/conv_template.py", "_vendored/process_src_template.py"]
 use_parentheses = true
-
-[tool.setuptools]
-include-package-data = true
-packages = ["mkl_fft", "mkl_fft.interfaces"]
-
-[tool.setuptools.dynamic]
-version = {attr = "mkl_fft._version.__version__"}
-
-[tool.setuptools.package-data]
-"mkl_fft" = ["tests/**/*.py"]