Merge pull request numpy#27051 from HaoZeke/fixCompilerAvail

TST: Refactor to consistently use CompilerChecker

Author: rgommers

doc/source/f2py/f2py-testing.rst

@@ -50,6 +50,17 @@ functions will be appended to ``self.module`` data member. Thus, the child class
 be able to access the fortran functions specified in source file by calling
 ``self.module.[fortran_function_name]``.
 
+.. versionadded:: v2.0.0b1
+
+Each of the ``f2py`` tests should run without failure if no Fortran compilers
+are present on the host machine. To facilitate this, the ``CompilerChecker`` is
+used, essentially providing a ``meson`` dependent set of utilities namely
+``has_{c,f77,f90,fortran}_compiler()``.
+
+For the CLI tests in ``test_f2py2e``, flags which are expected to call ``meson``
+or otherwise depend on a compiler need to call ``compiler_check_f2pycli()``
+instead of ``f2pycli()``.
+
 Example
 ~~~~~~~
 
@@ -77,4 +88,4 @@ A test can be implemented as follows::
 
 We override the ``sources`` data member to provide the source file. The source files
 are compiled and subroutines are attached to module data member when the class object
-is created. The ``test_module`` function calls the subroutines and tests their results.
+is created. The ``test_module`` function calls the subroutines and tests their results.

numpy/f2py/tests/test_f2py2e.py

@@ -9,6 +9,18 @@
 from numpy.f2py.f2py2e import main as f2pycli
 from numpy.testing._private.utils import NOGIL_BUILD
 
+#######################
+# F2PY Test utilities #
+######################
+
+# Tests for CLI commands which call meson will fail if no compilers are present, these are to be skipped
+
+def compiler_check_f2pycli():
+    if not util.has_fortran_compiler():
+        pytest.skip("CLI command needs a Fortran compiler")
+    else:
+        f2pycli()
+
 #########################
 # CLI utils and classes #
 #########################
@@ -50,9 +62,9 @@ def get_io_paths(fname_inp, mname="untitled"):
     )
 
 
-##############
-# CLI Fixtures and Tests #
-#############
+################
+# CLI Fixtures #
+################
 
 
 @pytest.fixture(scope="session")
@@ -110,6 +122,9 @@ def f2cmap_f90(tmpdir_factory):
     fmap.write_text(f2cmap, encoding="ascii")
     return fn
 
+#########
+# Tests #
+#########
 
 def test_gh22819_cli(capfd, gh22819_cli, monkeypatch):
     """Check that module names are handled correctly
@@ -199,8 +214,7 @@ def test_gen_pyf_no_overwrite(capfd, hello_world_f90, monkeypatch):
             assert "Use --overwrite-signature to overwrite" in err
 
 
-@pytest.mark.skipif((platform.system() != 'Linux') or (sys.version_info <= (3, 12)),
-                    reason='Compiler and 3.12 required')
+@pytest.mark.skipif(sys.version_info <= (3, 12), reason="Python 3.12 required")
 def test_untitled_cli(capfd, hello_world_f90, monkeypatch):
     """Check that modules are named correctly
 
@@ -209,7 +223,7 @@ def test_untitled_cli(capfd, hello_world_f90, monkeypatch):
     ipath = Path(hello_world_f90)
     monkeypatch.setattr(sys, "argv", f"f2py --backend meson -c {ipath}".split())
     with util.switchdir(ipath.parent):
-        f2pycli()
+        compiler_check_f2pycli()
         out, _ = capfd.readouterr()
         assert "untitledmodule.c" in out
 
@@ -226,7 +240,7 @@ def test_no_py312_distutils_fcompiler(capfd, hello_world_f90, monkeypatch):
         sys, "argv", f"f2py {ipath} -c --fcompiler=gfortran -m {MNAME}".split()
     )
     with util.switchdir(ipath.parent):
-        f2pycli()
+        compiler_check_f2pycli()
         out, _ = capfd.readouterr()
         assert "--fcompiler cannot be used with meson" in out
     monkeypatch.setattr(
@@ -759,7 +773,7 @@ def test_no_freethreading_compatible(hello_world_f90, monkeypatch):
     monkeypatch.setattr(sys, "argv", f'f2py -m blah {ipath} -c --no-freethreading-compatible'.split())
 
     with util.switchdir(ipath.parent):
-        f2pycli()
+        compiler_check_f2pycli()
         cmd = f"{sys.executable} -c \"import blah; blah.hi();"
         if NOGIL_BUILD:
             cmd += "import sys; assert sys._is_gil_enabled() is True\""
@@ -784,7 +798,7 @@ def test_freethreading_compatible(hello_world_f90, monkeypatch):
     monkeypatch.setattr(sys, "argv", f'f2py -m blah {ipath} -c --freethreading-compatible'.split())
 
     with util.switchdir(ipath.parent):
-        f2pycli()
+        compiler_check_f2pycli()
         cmd = f"{sys.executable} -c \"import blah; blah.hi();"
         if NOGIL_BUILD:
             cmd += "import sys; assert sys._is_gil_enabled() is False\""

numpy/f2py/tests/util.py

@@ -26,6 +26,102 @@
 from importlib import import_module
 from numpy.f2py._backends._meson import MesonBackend
 
+#
+# Check if compilers are available at all...
+#
+
+def check_language(lang, code_snippet=None):
+    if sys.platform == "win32":
+        pytest.skip("No Fortran tests on Windows (Issue #25134)", allow_module_level=True)
+    tmpdir = tempfile.mkdtemp()
+    try:
+        meson_file = os.path.join(tmpdir, "meson.build")
+        with open(meson_file, "w") as f:
+            f.write("project('check_compilers')\n")
+            f.write(f"add_languages('{lang}')\n")
+            if code_snippet:
+                f.write(f"{lang}_compiler = meson.get_compiler('{lang}')\n")
+                f.write(f"{lang}_code = '''{code_snippet}'''\n")
+                f.write(
+                    f"_have_{lang}_feature ="
+                    f"{lang}_compiler.compiles({lang}_code,"
+                    f" name: '{lang} feature check')\n"
+                )
+        try:
+            runmeson = subprocess.run(
+                ["meson", "setup", "btmp"],
+                check=False,
+                cwd=tmpdir,
+                capture_output=True,
+            )
+        except subprocess.CalledProcessError:
+            pytest.skip("meson not present, skipping compiler dependent test", allow_module_level=True)
+        return runmeson.returncode == 0
+    finally:
+        shutil.rmtree(tmpdir)
+    return False
+
+
+fortran77_code = '''
+C Example Fortran 77 code
+      PROGRAM HELLO
+      PRINT *, 'Hello, Fortran 77!'
+      END
+'''
+
+fortran90_code = '''
+! Example Fortran 90 code
+program hello90
+  type :: greeting
+    character(len=20) :: text
+  end type greeting
+
+  type(greeting) :: greet
+  greet%text = 'hello, fortran 90!'
+  print *, greet%text
+end program hello90
+'''
+
+# Dummy class for caching relevant checks
+class CompilerChecker:
+    def __init__(self):
+        self.compilers_checked = False
+        self.has_c = False
+        self.has_f77 = False
+        self.has_f90 = False
+
+    def check_compilers(self):
+        if (not self.compilers_checked) and (not sys.platform == "cygwin"):
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                futures = [
+                    executor.submit(check_language, "c"),
+                    executor.submit(check_language, "fortran", fortran77_code),
+                    executor.submit(check_language, "fortran", fortran90_code)
+                ]
+
+                self.has_c = futures[0].result()
+                self.has_f77 = futures[1].result()
+                self.has_f90 = futures[2].result()
+
+            self.compilers_checked = True
+
+if not IS_WASM:
+    checker = CompilerChecker()
+    checker.check_compilers()
+
+def has_c_compiler():
+    return checker.has_c
+
+def has_f77_compiler():
+    return checker.has_f77
+
+def has_f90_compiler():
+    return checker.has_f90
+
+def has_fortran_compiler():
+    return (checker.has_f90 and checker.has_f77)
+
+
 #
 # Maintaining a temporary module directory
 #
@@ -109,6 +205,9 @@ def build_module(source_files, options=[], skip=[], only=[], module_name=None):
     code = f"import sys; sys.path = {sys.path!r}; import numpy.f2py; numpy.f2py.main()"
 
     d = get_module_dir()
+    # gh-27045 : Skip if no compilers are found
+    if not has_fortran_compiler():
+        pytest.skip("No Fortran compiler available")
 
     # Copy files
     dst_sources = []
@@ -199,92 +298,6 @@ def build_code(source_code,
                             module_name=module_name)
 
 
-#
-# Check if compilers are available at all...
-#
-
-def check_language(lang, code_snippet=None):
-    tmpdir = tempfile.mkdtemp()
-    try:
-        meson_file = os.path.join(tmpdir, "meson.build")
-        with open(meson_file, "w") as f:
-            f.write("project('check_compilers')\n")
-            f.write(f"add_languages('{lang}')\n")
-            if code_snippet:
-                f.write(f"{lang}_compiler = meson.get_compiler('{lang}')\n")
-                f.write(f"{lang}_code = '''{code_snippet}'''\n")
-                f.write(
-                    f"_have_{lang}_feature ="
-                    f"{lang}_compiler.compiles({lang}_code,"
-                    f" name: '{lang} feature check')\n"
-                )
-        runmeson = subprocess.run(
-            ["meson", "setup", "btmp"],
-            check=False,
-            cwd=tmpdir,
-            capture_output=True,
-        )
-        return runmeson.returncode == 0
-    finally:
-        shutil.rmtree(tmpdir)
-    return False
-
-fortran77_code = '''
-C Example Fortran 77 code
-      PROGRAM HELLO
-      PRINT *, 'Hello, Fortran 77!'
-      END
-'''
-
-fortran90_code = '''
-! Example Fortran 90 code
-program hello90
-  type :: greeting
-    character(len=20) :: text
-  end type greeting
-
-  type(greeting) :: greet
-  greet%text = 'hello, fortran 90!'
-  print *, greet%text
-end program hello90
-'''
-
-# Dummy class for caching relevant checks
-class CompilerChecker:
-    def __init__(self):
-        self.compilers_checked = False
-        self.has_c = False
-        self.has_f77 = False
-        self.has_f90 = False
-
-    def check_compilers(self):
-        if (not self.compilers_checked) and (not sys.platform == "cygwin"):
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                futures = [
-                    executor.submit(check_language, "c"),
-                    executor.submit(check_language, "fortran", fortran77_code),
-                    executor.submit(check_language, "fortran", fortran90_code)
-                ]
-
-                self.has_c = futures[0].result()
-                self.has_f77 = futures[1].result()
-                self.has_f90 = futures[2].result()
-
-            self.compilers_checked = True
-
-if not IS_WASM:
-    checker = CompilerChecker()
-    checker.check_compilers()
-
-def has_c_compiler():
-    return checker.has_c
-
-def has_f77_compiler():
-    return checker.has_f77
-
-def has_f90_compiler():
-    return checker.has_f90
-
 #
 # Building with meson
 #
@@ -303,6 +316,11 @@ def build_meson(source_files, module_name=None, **kwargs):
     """
     Build a module via Meson and import it.
     """
+
+    # gh-27045 : Skip if no compilers are found
+    if not has_fortran_compiler():
+        pytest.skip("No Fortran compiler available")
+
     build_dir = get_module_dir()
     if module_name is None:
         module_name = get_temp_module_name()
@@ -327,13 +345,7 @@ def build_meson(source_files, module_name=None, **kwargs):
         extra_dat=kwargs.get("extra_dat", {}),
     )
 
-    # Compile the module
-    # NOTE: Catch-all since without distutils it is hard to determine which
-    # compiler stack is on the CI
-    try:
-        backend.compile()
-    except subprocess.CalledProcessError:
-        pytest.skip("Failed to compile module")
+    backend.compile()
 
     # Import the compiled module
     sys.path.insert(0, f"{build_dir}/{backend.meson_build_dir}")
@@ -369,6 +381,7 @@ def setup_class(cls):
         F2PyTest._has_c_compiler = has_c_compiler()
         F2PyTest._has_f77_compiler = has_f77_compiler()
         F2PyTest._has_f90_compiler = has_f90_compiler()
+        F2PyTest._has_fortran_compiler = has_fortran_compiler()
 
     def setup_method(self):
         if self.module is not None:
@@ -386,7 +399,7 @@ def setup_method(self):
             pytest.skip("No Fortran 77 compiler available")
         if needs_f90 and not self._has_f90_compiler:
             pytest.skip("No Fortran 90 compiler available")
-        if needs_pyf and not (self._has_f90_compiler or self._has_f77_compiler):
+        if needs_pyf and not self._has_fortran_compiler:
             pytest.skip("No Fortran compiler available")
 
         # Build the module