meson-python 0.19.0__tar.gz → 0.20.0__tar.gz

{meson_python-0.19.0 → meson_python-0.20.0}/CHANGELOG.rst

@@ -11,6 +11,14 @@
 Changelog
 +++++++++
 
+0.20.0
+======
+
+- Add support for targeting the Android platform.
+
+Daniele Nicolodi, Malcolm Smith, Ralf Gommers --- 10-06-2026.
+
+
 0.19.0
 ======
 

{meson_python-0.19.0 → meson_python-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meson-python
-Version: 0.19.0
+Version: 0.20.0
 Summary: Meson Python build backend (PEP 517)
 Keywords: meson,build,backend,pep517,package
 Maintainer-Email: Ralf Gommers <ralf.gommers@gmail.com>, Daniele Nicolodi <daniele@grinta.net>, Henry Schreiner <HenrySchreinerIII@gmail.com>

{meson_python-0.19.0 → meson_python-0.20.0}/docs/changelog.rst

@@ -11,6 +11,14 @@
 Changelog
 +++++++++
 
+0.20.0
+======
+
+- Add support for targeting the Android platform.
+
+Daniele Nicolodi, Malcolm Smith, Ralf Gommers --- 10-06-2026.
+
+
 0.19.0
 ======
 

{meson_python-0.19.0 → meson_python-0.20.0}/mesonpy/__init__.py

@@ -15,6 +15,7 @@ import argparse
 import collections
 import contextlib
 import copy
+import dataclasses
 import difflib
 import fnmatch
 import functools
@@ -83,7 +84,7 @@ if typing.TYPE_CHECKING:  # pragma: no cover
     MesonArgs = Mapping[MesonArgsKeys, List[str]]
 
 
-__version__ = '0.19.0'
+__version__ = '0.20.0'
 
 
 _PYPROJECT_METADATA_VERSION = tuple(map(int, pyproject_metadata.__version__.split('.')[:2]))
@@ -120,13 +121,17 @@ def _compile_patterns(patterns: List[str]) -> Callable[[str], bool]:
     return typing.cast('Callable[[str], bool]', func)
 
 
+class _Entry(typing.NamedTuple):
+    dst: pathlib.Path
+    src: str
+
+
 def _map_to_wheel(
     sources: Dict[str, Dict[str, Any]],
-    exclude: List[str],
-    include: List[str],
-) -> DefaultDict[str, List[Tuple[pathlib.Path, str]]]:
+    exclude: List[str], include: List[str]
+) -> DefaultDict[str, List[_Entry]]:
     """Map files to the wheel, organized by wheel installation directory."""
-    wheel_files: DefaultDict[str, List[Tuple[pathlib.Path, str]]] = collections.defaultdict(list)
+    wheel_files: DefaultDict[str, List[_Entry]] = collections.defaultdict(list)
     packages: Dict[str, str] = {}
     excluded = _compile_patterns(exclude)
     included = _compile_patterns(include)
@@ -151,7 +156,8 @@ def _map_to_wheel(
                 other = packages.setdefault(package, path)
                 if other != path:
                     this = os.fspath(pathlib.Path(path, *destination.parts[1:]))
-                    that = os.fspath(other / next(d for d, s in wheel_files[other] if d.parts[0] == destination.parts[1]))
+                    module = next(entry.dst for entry in wheel_files[other] if entry.dst.parts[0] == destination.parts[1])
+                    that = os.fspath(other / module)
                     raise BuildError(
                         f'The {package} package is split between {path} and {other}: '
                         f'{this!r} and {that!r}, a "pure: false" argument may be missing in meson.build. '
@@ -174,9 +180,9 @@ def _map_to_wheel(
                         if relpath in exclude_files:
                             continue
                         filedst = dst / relpath
-                        wheel_files[path].append((filedst, filesrc))
+                        wheel_files[path].append(_Entry(filedst, filesrc))
             else:
-                wheel_files[path].append((dst, src))
+                wheel_files[path].append(_Entry(dst, src))
 
     return wheel_files
 
@@ -323,20 +329,14 @@ def _is_native(file: Path) -> bool:
             return f.read(4) == b'\x7fELF'  # ELF
 
 
+@dataclasses.dataclass
 class _WheelBuilder():
     """Helper class to build wheels from projects."""
 
-    def __init__(
-        self,
-        metadata: Metadata,
-        manifest: Dict[str, List[Tuple[pathlib.Path, str]]],
-        limited_api: bool,
-        allow_windows_shared_libs: bool,
-    ) -> None:
-        self._metadata = metadata
-        self._manifest = manifest
-        self._limited_api = limited_api
-        self._allow_windows_shared_libs = allow_windows_shared_libs
+    _metadata: Metadata
+    _manifest: Dict[str, List[_Entry]]
+    _limited_api: bool
+    _allow_windows_shared_libs: bool
 
     @property
     def _has_internal_libs(self) -> bool:
@@ -352,8 +352,8 @@ class _WheelBuilder():
         """Whether the wheel is architecture independent"""
         if self._manifest['platlib'] or self._manifest['mesonpy-libs']:
             return False
-        for _, file in self._manifest['scripts']:
-            if _is_native(file):
+        for entry in self._manifest['scripts']:
+            if _is_native(entry.src):
                 return False
         return True
 
@@ -430,14 +430,14 @@ class _WheelBuilder():
             # in {platlib} that look like extension modules, and raise
             # an exception if any of them has a Python version
             # specific extension filename suffix ABI tag.
-            for path, _ in self._manifest['platlib']:
-                match = _EXTENSION_SUFFIX_REGEX.match(path.name)
+            for entry in self._manifest['platlib']:
+                match = _EXTENSION_SUFFIX_REGEX.match(entry.dst.name)
                 if match:
                     abi = match.group('abi')
                     if abi is not None and abi != 'abi3':
                         raise BuildError(
                             f'The package declares compatibility with Python limited API but extension '
-                            f'module {os.fspath(path)!r} is tagged for a specific Python version.')
+                            f'module {os.fspath(entry.dst)!r} is tagged for a specific Python version.')
             return 'abi3'
         return None
 
@@ -519,8 +519,8 @@ class _EditableWheelBuilder(_WheelBuilder):
     def _top_level_modules(self) -> Collection[str]:
         modules = set()
         for type_ in self._manifest:
-            for path, _ in self._manifest[type_]:
-                name, dot, ext = path.parts[0].partition('.')
+            for entry in self._manifest[type_]:
+                name, dot, ext = entry.dst.parts[0].partition('.')
                 if dot:
                     # module
                     suffix = dot + ext
@@ -744,6 +744,38 @@ class Project():
                     self._meson_cross_file.write_text(cross_file_data, encoding='utf-8')
                     self._meson_args['setup'].extend(('--cross-file', os.fspath(self._meson_cross_file)))
 
+        # Simplify cross-compilation for Android with cibuildwheel: detect the
+        # cross-compilation environment set up by cibuildwheel and synthesize an
+        # appropriate cross file.
+        elif sysconfig.get_platform().startswith('android-') and 'CIBUILDWHEEL' in os.environ:
+            cpu = platform.machine()
+            cpu_family = 'x86' if cpu == 'i686' else 'arm' if cpu.startswith('arm') else cpu
+
+            # cibuildwheel uses environment variables to point to the cross
+            # compilation toolchain binaries thus the [binaries] section of
+            # the cross file is not needed.
+            cross_file_data = textwrap.dedent(f'''
+                [host_machine]
+                system = 'android'
+                subsystem = 'android'
+                kernel = 'linux'
+                cpu_family = {cpu_family!r}
+                cpu = {cpu!r}
+                endian = {sys.byteorder!r}
+
+                [properties]
+                # To obtain the correct wheel tags when cross-compiling
+                # cibuildwheel monkey-patches platform.system() and
+                # platform.machine() to simulate running on Android.
+                # This makes Meson believe that host and build machines
+                # match, and thus that host binaries can be run on the
+                # build machine when this is not actually the case.
+                # Override the auto-detection.
+                needs_exe_wrapper = true
+            ''')
+            self._meson_cross_file.write_text(cross_file_data, encoding='utf-8')
+            self._meson_args['setup'].extend(('--cross-file', os.fspath(self._meson_cross_file)))
+
         # Support iOS targets. iOS does not have native build tools and always
         # requires cross compilation: synthesize the appropriate cross file.
         elif sysconfig.get_platform().startswith('ios-'):
@@ -912,7 +944,7 @@ class Project():
         return json.loads(info.read_text(encoding='utf-8'))
 
     @property
-    def _manifest(self) -> DefaultDict[str, List[Tuple[pathlib.Path, str]]]:
+    def _manifest(self) -> DefaultDict[str, List[_Entry]]:
         """The files to be added to the wheel, organized by wheel path."""
 
         # Obtain the list of files Meson would install.

{meson_python-0.19.0 → meson_python-0.20.0}/pyproject.toml

@@ -16,7 +16,7 @@ requires = [
 
 [project]
 name = 'meson-python'
-version = '0.19.0'
+version = '0.20.0'
 description = 'Meson Python build backend (PEP 517)'
 readme = 'README.rst'
 requires-python = '>= 3.9'

{meson_python-0.19.0 → meson_python-0.20.0}/tests/test_project.py

@@ -378,6 +378,53 @@ def test_archflags_envvar_parsing_invalid(package_purelib_and_platlib, monkeypat
         os.environ.pop('_PYTHON_HOST_PLATFORM', None)
 
 
+@pytest.mark.parametrize(
+    ('cpu', 'cpu_family'),
+    [
+        ('aarch64', 'aarch64'),
+        ('armv7l', 'arm'),
+        ('armv8l', 'arm'),
+        ('i686', 'x86'),
+        ('x86_64', 'x86_64'),
+    ],
+)
+@pytest.mark.parametrize('cross', [True, False])
+def test_android_project(package_simple, monkeypatch, tmp_path, cpu, cpu_family, cross):
+    # Mock being on Android
+    monkeypatch.setattr(sys, 'platform', 'android')
+    monkeypatch.setattr(sys, 'byteorder', 'little')
+    monkeypatch.setattr(platform, 'system', Mock(return_value='Android'))
+    monkeypatch.setattr(platform, 'machine', Mock(return_value=cpu))
+    monkeypatch.setattr(sysconfig, 'get_platform', Mock(return_value='android-24'))
+    if cross:
+        monkeypatch.setenv('CIBUILDWHEEL', '1')
+
+        # Meson may require some tools to be configured when fatal warnings are enabled.
+        # Set the same set of variables as cibuildwheel.
+        for name in ['ar', 'as', 'cc', 'cxx', 'ld', 'nm', 'ranlib', 'readelf', 'strip']:
+            monkeypatch.setenv(name.upper(), f'/path/to/{name}')
+
+    # Create a project.
+    project = mesonpy.Project(source_dir=package_simple, build_dir=tmp_path)
+
+    # When cross-compiling, a cross file should be generated and used.
+    setup_args = project._meson_args['setup']
+    cross_path = tmp_path / 'meson-python-cross-file.ini'
+    if cross:
+        assert setup_args[-2:] == ['--cross-file', str(cross_path)]
+        cross_config = cross_path.read_text().splitlines()
+        assert "system = 'android'" in cross_config
+        assert "subsystem = 'android'" in cross_config
+        assert "kernel = 'linux'" in cross_config
+        assert f"cpu_family = '{cpu_family}'" in cross_config
+        assert f"cpu = '{cpu}'" in cross_config
+        assert "endian = 'little'" in cross_config
+        assert 'needs_exe_wrapper = true' in cross_config
+    else:
+        assert '--cross-file' not in setup_args
+        assert not cross_path.exists()
+
+
 @pytest.mark.skipif(sys.version_info < (3, 13), reason='requires Python 3.13 or higher')
 @pytest.mark.parametrize('multiarch', [
     'arm64-iphoneos',

{meson_python-0.19.0 → meson_python-0.20.0}/tests/test_tags.py

@@ -101,7 +101,8 @@ def test_ios_platform_tag(monkeypatch):
 
 def wheel_builder_test_factory(content, pure=True, limited_api=False):
     manifest = defaultdict(list)
-    manifest.update({key: [(pathlib.Path(x), os.path.join('build', x)) for x in value] for key, value in content.items()})
+    for key, value in content.items():
+        manifest[key] = [mesonpy._Entry(pathlib.Path(x), os.path.join('build', x)) for x in value]
     return mesonpy._WheelBuilder(None, manifest, limited_api, False)