pkgconf 2.4.3.post1__tar.gz → 2.4.3.post3__tar.gz

{pkgconf-2.4.3.post1 → pkgconf-2.4.3.post3}/.github/workflows/build.yml

@@ -33,15 +33,17 @@ jobs:
       matrix:
         os:
           - ubuntu-latest
+          - ubuntu-24.04-arm
           - windows-latest
-          - macos-13
-          - macos-14
+          - windows-11-arm
+          - macos-13      # x86-64
+          - macos-latest  # arm64
       fail-fast: false
     steps:
       - uses: actions/checkout@v4
         with:
           submodules: true
-      - uses: pypa/cibuildwheel@v2.18.1
+      - uses: pypa/cibuildwheel@2edf5784998b7b1ab70445baced23069e839541e # 3.0.0rc2
       - uses: actions/upload-artifact@v4
         if: always()
         with:
@@ -56,9 +58,9 @@ jobs:
       - uses: docker/setup-qemu-action@v3
         with:
           platforms: all
-      - uses: pypa/cibuildwheel@v2.18.1
+      - uses: pypa/cibuildwheel@2edf5784998b7b1ab70445baced23069e839541e # 3.0.0rc2
         env:
-          CIBW_ARCHS_LINUX: aarch64 ppc64le s390x
+          CIBW_ARCHS_LINUX: ppc64le s390x
       - uses: actions/upload-artifact@v4
         if: always()
         with:

{pkgconf-2.4.3.post1 → pkgconf-2.4.3.post3}/.github/workflows/test.yml

@@ -15,19 +15,23 @@ concurrency:
 
 jobs:
   pytest:
-    runs-on: ${{ matrix.os }}-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os:
-          - ubuntu
-          - windows
-          - macos
+          - ubuntu-latest
+          - windows-latest
+          - windows-11-arm
+          - macos-latest
         python:
-          - '3.9'
           - '3.10'
           - '3.11'
           - '3.12'
           - '3.13'
+          - '3.14-dev'
+        exclude:
+          - os: windows-11-arm
+            python: '3.10'
       fail-fast: false
     steps:
       - uses: actions/checkout@v4

{pkgconf-2.4.3.post1 → pkgconf-2.4.3.post3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pkgconf
-Version: 2.4.3.post1
+Version: 2.4.3.post3
 Summary: `pkgconf` is a program which helps with discovering library dependencies and configuring compiler and linker flags.
 Author-Email: Ralf Gommers <ralf.gommers@gmail.com>, =?utf-8?q?Filipe_La=C3=ADns?= <lains@riseup.net>
 License: Copyright (c) 2024 pypackaging-native contributors
@@ -36,9 +36,8 @@ Classifier: Operating System :: MacOS
 Project-URL: homepage, https://pkgconf-pypi.readthedocs.io/en/latest/
 Project-URL: issues, https://github.com/pypackaging-native/pkgconf-pypi/issues
 Project-URL: source, https://github.com/pypackaging-native/pkgconf-pypi
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: colorama; os_name == "nt"
-Requires-Dist: importlib_metadata; python_version < "3.10"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov>=5; extra == "test"
@@ -64,7 +63,7 @@ Description-Content-Type: text/markdown
 [![PyPI version](https://badge.fury.io/py/pkgconf.svg)](https://pypi.org/project/pkgconf/)
 [![Discord](https://img.shields.io/discord/803025117553754132?label=Discord%20chat%20pkgconf-pypi)](https://discord.gg/pypa)
 
-This goal of this repo is to facility building and publishing of
+This goal of this repo is to facilitate building and publishing of
 [pkgconf](https://github.com/pkgconf/pkgconf) binaries on PyPI, primarily for
 ease of installing in a cross-platform manner. This is useful when `pkgconf` is
 for example needed in workflows of other Python packages.

{pkgconf-2.4.3.post1 → pkgconf-2.4.3.post3}/README.md

@@ -9,7 +9,7 @@
 [![PyPI version](https://badge.fury.io/py/pkgconf.svg)](https://pypi.org/project/pkgconf/)
 [![Discord](https://img.shields.io/discord/803025117553754132?label=Discord%20chat%20pkgconf-pypi)](https://discord.gg/pypa)
 
-This goal of this repo is to facility building and publishing of
+This goal of this repo is to facilitate building and publishing of
 [pkgconf](https://github.com/pkgconf/pkgconf) binaries on PyPI, primarily for
 ease of installing in a cross-platform manner. This is useful when `pkgconf` is
 for example needed in workflows of other Python packages.

{pkgconf-2.4.3.post1 → pkgconf-2.4.3.post3}/meson.build

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: MIT
 
 project('pkgconf-pypi',
-  version : '2.4.3-1',
+  version : '2.4.3-3',
   license : 'MIT AND ISC',
   license_files : ['LICENSE'],
   meson_version : '>=1.3.2',
@@ -16,7 +16,9 @@ py.install_sources(
   [
     'src/pkgconf/__init__.py',
     'src/pkgconf/__main__.py',
+    'src/pkgconf/_path_entrypoints.py',
     'src/pkgconf/diagnose.py',
+    'src/pkgconf/py.typed',
   ],
   subdir: 'pkgconf',
 )

{pkgconf-2.4.3.post1 → pkgconf-2.4.3.post3}/pyproject.toml

@@ -11,7 +11,7 @@ requires = ['meson-python', 'wheel']
 
 [project]
 name = 'pkgconf'
-version = '2.4.3-1'
+version = '2.4.3-3'
 description = '`pkgconf` is a program which helps with discovering library dependencies and configuring compiler and linker flags.'
 readme = 'README.md'
 license = {file = 'LICENSE'}
@@ -31,10 +31,9 @@ classifiers = [
   'Operating System :: Unix',
   'Operating System :: MacOS'
 ]
-requires-python = '>= 3.9'
+requires-python = '>= 3.10'
 dependencies = [
   'colorama; os_name == "nt"',
-  'importlib_metadata; python_version < "3.10"',
 ]
 
 [project.optional-dependencies]

pkgconf-2.4.3.post3/src/pkgconf/__init__.py

@@ -0,0 +1,103 @@
+import logging
+import os
+import pathlib
+import shlex
+import shutil
+import subprocess
+import sysconfig
+import warnings
+
+from typing import Any
+
+import pkgconf._path_entrypoints
+
+from pkgconf._path_entrypoints import PathWarning
+
+
+__version__ = '2.4.3-3'
+
+
+_LOGGER = logging.getLogger(__name__)
+_CLI_LOGGER = _LOGGER.getChild('cli')
+
+
+def _get_system_executable() -> pathlib.Path | None:
+    if os.environ.get('PKGCONF_PYPI_EMBEDDED_ONLY'):
+        return None
+
+    scripts = sysconfig.get_path('scripts')
+    path_list = os.environ.get('PATH', os.defpath).split(os.pathsep)
+    if scripts in path_list:
+        path_list.remove(scripts)
+    path = os.pathsep.join(path_list)
+
+    executable = shutil.which('pkgconf', path=path) or shutil.which('pkg-config', path=path)
+    if executable:
+        return pathlib.Path(executable)
+    return None
+
+
+def get_executable() -> pathlib.Path:
+    """Get the pkgconf executable."""
+    executable: pathlib.Path | None
+
+    if os.name == 'posix':
+        executable_name = 'pkgconf'
+    elif os.name == 'nt':
+        executable_name = 'pkgconf.EXE'
+    else:
+        raise NotImplementedError
+
+    for path in __path__:
+        executable = pathlib.Path(path) / '.bin' / executable_name
+        if executable.exists():
+            return executable
+
+    warnings.warn('Bundled pkgconf not found, using the system executable', stacklevel=2)
+    executable = _get_system_executable()
+    if executable:
+        return executable
+
+    msg = 'No pkgconf/pkg-config executable available'
+    raise RuntimeError(msg)
+
+
+def _entry_points() -> list[pkgconf._path_entrypoints.EntryPoint]:
+    return pkgconf._path_entrypoints.entry_points(group='pkg_config')
+
+
+def get_pkg_config_path() -> list[str]:
+    """Calculate PKG_CONFIG_PATH for Python packages in the current environment.
+
+    Python packages may register a directory for their pkg-config files by
+    specifying a "pkg-config" entrypoint.
+
+    TODO: Document the entrypoint creation and point to that here.
+    [project.entry-points.pkg-config]
+    entrypoint-name = 'project.package'
+    """
+    return [ep.path for ep in _entry_points()]
+
+
+def run_pkgconf(*args: str, **subprocess_kwargs: Any) -> subprocess.CompletedProcess[bytes | str]:
+    """Run the pkgconf executable.
+
+    :param args: Arguments to pass to the pkgconf call.
+    :param subprocess_kwargs: Keyword arguments to pass to the subprocess.run call.
+    """
+    env = os.environ.copy()
+    PKG_CONFIG_PATH = env.get('PKG_CONFIG_PATH', '').split(os.pathsep) + get_pkg_config_path()
+    PKG_CONFIG_PATH = list(dict.fromkeys(PKG_CONFIG_PATH))  # Remove duplicated entried
+    env['PKG_CONFIG_PATH'] = os.pathsep.join(PKG_CONFIG_PATH)
+    cmd = [os.fspath(get_executable()), *args]
+    _CLI_LOGGER.info('Running the Python pkgconf')
+    _CLI_LOGGER.info('$ ' + shlex.join(('PKG_CONFIG_PATH=' + shlex.quote(env['PKG_CONFIG_PATH']), *cmd)))
+    return subprocess.run(cmd, env=env, **subprocess_kwargs)
+
+
+__all__ = [
+    'PathWarning',
+    'get_executable',
+    'get_pkg_config_path',
+    'run_pkgconf',
+]

{pkgconf-2.4.3.post1 → pkgconf-2.4.3.post3}/src/pkgconf/__main__.py

@@ -6,7 +6,7 @@ import sys
 import sysconfig
 import warnings
 
-from typing import Optional, TextIO, Union
+from typing import TextIO
 
 import pkgconf
 
@@ -99,17 +99,17 @@ def _setup_cli():
 
     logging.basicConfig(
         stream=sys.stderr,
-        format=f'{dim}> %(message)s{reset}',
-        level=logging.INFO,
+        format=f'{dim}> %(message)s{reset} [%(levelname)s:%(name)s]',
     )
+    pkgconf._CLI_LOGGER.setLevel(logging.INFO)
 
     def _showwarning(
-        message: Union[Warning, str],
+        message: Warning | str,
         category: type[Warning],
         filename: str,
         lineno: int,
-        file: Optional[TextIO] = None,
-        line: Optional[str] = None,
+        file: TextIO | None = None,
+        line: str | None = None,
     ) -> None:  # pragma: no cover
         print(f'{yellow}WARNING{reset} {message}', file=sys.stderr)
 

pkgconf-2.4.3.post3/src/pkgconf/_path_entrypoints.py

@@ -0,0 +1,266 @@
+import contextlib
+import importlib.machinery
+import importlib.metadata
+import importlib.resources
+import importlib.util
+import operator
+import os
+import pathlib
+import pickle
+import sys
+import types
+import warnings
+
+from collections.abc import Callable, Iterable
+from typing import Any, ParamSpec, TypeVar
+
+import pkgconf
+
+
+P = ParamSpec('P')
+T = TypeVar('T')
+
+
+# Import system helpers
+
+
+def import_module_no_exec(name: str) -> types.ModuleType:
+    """Return a module object with all the module attributes set, but without executing it.
+
+    WARNING: This places uninitialized modules in sys.modules.
+    """
+    if name in sys.modules:
+        return sys.modules[name]
+    # Import parent without execution
+    if parent := name.rpartition('.')[0]:
+        import_module_no_exec(parent)
+    # Find module spec
+    spec = importlib.util.find_spec(name)
+    if not spec:
+        msg = f'No module named {name!r}'
+        raise ModuleNotFoundError(msg)
+    # Create module object without executing, and save it sys.modules
+    module = sys.modules[name] = importlib.util.module_from_spec(spec)
+    return module
+
+
+def module_path(name: str) -> str:
+    """Resolve module name to file-system path.
+
+    WARNING: This places uninitialized modules in sys.modules.
+    """
+    module = import_module_no_exec(name)
+    # Check if submodule_search_locations is set on the spec.
+    if module.__spec__.submodule_search_locations:
+        # If it contains a single path, use it.
+        if len(module.__spec__.submodule_search_locations) == 1:
+            return module.__spec__.submodule_search_locations[0]
+    # Traversables often implement __fspath__, attempt to use it.
+    traversable = importlib.resources.files(module)
+    if isinstance(traversable, os.PathLike):
+        return os.fsdecode(os.fspath(traversable))
+    # Give up :/
+    msg = f'Unable to resolve the path for {name}'
+    raise ValueError(msg)
+
+
+# Helpers to run the import helpers isolated from the import state of the main process/interpreter
+
+_subinterpreter = None
+
+
+def run_in_subinterpreter(fn: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    """Run callable in a subinterpreter — using concurrent.interpreters."""
+    assert sys.version_info >= (3, 14)
+
+    import concurrent.interpreters
+
+    global _subinterpreter
+
+    if _subinterpreter is None:
+        _subinterpreter = concurrent.interpreters.create()
+
+    return _subinterpreter.call(fn, *args, **kwargs)
+
+
+_worker = None
+_WORKER_CODE = r"""
+import sys, pickle
+
+stdin, stdout = sys.stdin.buffer, sys.stdout.buffer
+
+while True:
+    try:
+        length_data = stdin.read(4)
+        if not length_data:
+            break
+        length = int.from_bytes(length_data, "big")
+        payload = stdin.read(length)
+        fn, args, kwargs = pickle.loads(payload)
+        try:
+            result = fn(*args, **kwargs)
+            data = pickle.dumps((True, result))
+        except Exception as e:
+            data = pickle.dumps((False, e))
+        stdout.write(len(data).to_bytes(4, "big"))
+        stdout.write(data)
+        stdout.flush()
+    except Exception:
+        break
+"""
+
+
+def _make_worker():
+    """Start worker subprocess and assign callable to _worker."""
+    global _worker
+    import subprocess
+
+    proc = subprocess.Popen(
+        [sys.executable, '-u', '-c', _WORKER_CODE],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+    )
+
+    def _worker_fn(fn: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+        payload = pickle.dumps((fn, args, kwargs))
+        length = len(payload).to_bytes(4, 'big')
+
+        proc.stdin.write(length)
+        proc.stdin.write(payload)
+        proc.stdin.flush()
+
+        length_data = proc.stdout.read(4)
+        if not length_data:
+            msg = 'Subprocess died'
+            raise RuntimeError(msg)
+        resp_length = int.from_bytes(length_data, 'big')
+        data = proc.stdout.read(resp_length)
+        ok, value = pickle.loads(data)
+
+        if ok:
+            return value
+        else:
+            raise value
+
+    _worker = _worker_fn
+
+
+def run_in_subprocess(fn: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    """Run callable in a subprocess."""
+    if _worker is None:
+        _make_worker()
+
+    return _worker(fn, *args, **kwargs)
+
+
+def run_in_isolated_context(fn: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    try:
+        if sys.version_info >= (3, 14):
+            return run_in_subinterpreter(fn, *args, **kwargs)
+    except Exception:
+        pkgconf._LOGGER.exception(f'Failed to run {fn} in subinterpreter, falling back to subprocess')
+    return run_in_subprocess(fn, *args, **kwargs)
+
+
+@contextlib.contextmanager
+def replace_sys_modules() -> Iterable[None]:
+    original = sys.modules
+    sys.modules = original.copy()
+    try:
+        yield
+    finally:
+        sys.modules = original
+
+
+# Entrypoint helpers
+
+
+class EntryPoint:
+    def __init__(self, entrypoint: importlib.metadata.EntryPoint) -> None:
+        self._ep = entrypoint
+
+    @property
+    def name(self) -> str:
+        return self._ep.name
+
+    @property
+    def value(self) -> str:
+        return self._ep.value
+
+    @property
+    def group(self) -> str:
+        return self._ep.group
+
+    @property
+    def dist(self) -> importlib.metadata.Distribution | None:
+        return self._ep.dist
+
+    @property
+    def path(self) -> str:
+        try:
+            return self._resolve_via_import_system()
+        except Exception:
+            msg = 'Failed to resolve the entrypoint path via the import system (see log for details)'
+            pkgconf._LOGGER.exception(msg)
+            warnings.warn(PathWarning(msg, self), stacklevel=2)
+        # Fallback method
+        return self._resolve_via_translation()
+
+    def _resolve_via_import_system(self) -> str:
+        # module_path is not safe to run directly in the execution context, as
+        # it alters the import state, so try to run it in an isolated context.
+        try:
+            return run_in_isolated_context(module_path, self.value)
+        except Exception:
+            pkgconf._LOGGER.exception('Failed to run module_path in isolated context')
+        # Fallback to running in the current context, but try to save and
+        # restore the original import state.
+        with replace_sys_modules():
+            return module_path(self.value)
+
+    def _resolve_via_translation(self) -> str:
+        assert self.dist
+        subpath = pathlib.PurePath(*self.value.split('.'))
+        dist_path = self.dist.locate_file(subpath)
+        assert isinstance(dist_path, os.PathLike)
+        return os.fsdecode(os.fspath(dist_path))
+
+
+def entry_points(**select_params: Any) -> list[EntryPoint]:
+    original_eps = importlib.metadata.entry_points(**select_params)
+    our_eps = map(EntryPoint, original_eps)
+    valid_eps = filter(operator.attrgetter('path'), our_eps)
+    return sorted(valid_eps, key=operator.attrgetter('name'))
+
+
+class PathWarning(Warning):
+    def __init__(self, message: str, entrypoint: EntryPoint) -> None:
+        super().__init__(message)
+        self._entrypoint = entrypoint
+        self._logger = pkgconf._LOGGER.getChild(self.__class__.__name__)
+        self._logger.warning(
+            message,
+            extra={
+                'entrypoint': self._entrypoint,
+                'distribution': self._distribution_info(),
+            },
+        )
+
+    def _distribution_info(self) -> str:
+        assert self._entrypoint.dist
+        info = f'{self._entrypoint.dist.name}-{self._entrypoint.dist.version}'
+        if metadata_path := self._find_metadata_path():
+            info += f' at {metadata_path!r}'
+        return info
+
+    def _find_metadata_path(self) -> str | None:
+        assert self._entrypoint.dist
+        try:
+            dist_root = self._entrypoint.dist.locate_file('')
+        except NotImplementedError:
+            return None
+
+        for file in self._entrypoint.dist.files or []:
+            if file.parts[0].endswith('.dist-info'):
+                return str(dist_root / file.parts[0])
+        return None

{pkgconf-2.4.3.post1 → pkgconf-2.4.3.post3}/src/pkgconf/diagnose.py

@@ -7,10 +7,10 @@ def report() -> None:
     print(f'pkgconf executable: {pkgconf.get_executable()}')
 
     print('entrypoints:')
-    for entrypoint in pkgconf._find_entrypoints():
+    for entrypoint in pkgconf._entry_points():
         print(f'  {entrypoint.name}:')
         print(f'    value: {entrypoint.value}')
-        print(f'     path: {pkgconf._resolve_entrypoint_path(entrypoint)}')
+        print(f'     path: {entrypoint.path}')
 
     print(f'PKG_CONFIG_PATH: {os.pathsep.join(pkgconf.get_pkg_config_path())}')
 

{pkgconf-2.4.3.post1 → pkgconf-2.4.3.post3}/tests/conftest.py

@@ -41,7 +41,13 @@ def self_wheel(tmp_path_factory):
 @pytest.fixture
 def env(tmpdir, self_wheel):
     """Make a virtual environment with our project installed."""
-    env = environment_helpers.create_venv(tmpdir, system_site_packages=True)
+    env = environment_helpers.create_venv(tmpdir)
+
+    # Write .pth file pointing to the current environment
+    current_env = environment_helpers.CurrentEnvironment()
+    purelib, platlib = current_env.scheme['purelib'], current_env.scheme['platlib']
+    env.scheme['purelib'].joinpath('base-env.pth').write_text(f'{purelib!s}\n{platlib!s}\n')
+
     env.install_wheel(self_wheel)
     return env
 

pkgconf-2.4.3.post3/tests/packages/inplace/example/include/example.h

@@ -0,0 +1,3 @@
+/* Some header-only library... */
+
+#define FOO "bar"

pkgconf-2.4.3.post3/tests/packages/inplace/example/pkgconf/example.pc

@@ -0,0 +1,8 @@
+prefix=${pcfiledir}/..
+includedir=${prefix}/include
+
+Name: example
+Description: Example header library
+Version: 1.0.0
+Cflags: -I${includedir}
+Libs:

pkgconf-2.4.3.post3/tests/packages/inplace/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+build-backend = 'hatchling.build'
+requires = ['hatchling']
+
+[project]
+name = 'example'
+version = '1.0.0'
+
+[project.entry-points.pkg_config]
+example = 'example.pkgconf'
+
+[tool.hatch.build.targets.wheel]
+packages = ['example']

{pkgconf-2.4.3.post1 → pkgconf-2.4.3.post3}/tests/test_entrypoints.py

@@ -1,6 +1,4 @@
-import os
 import re
-import shutil
 import subprocess
 import sys
 
@@ -13,8 +11,7 @@ import pkgconf.__main__
 @pytest.mark.parametrize('name', ['pkgconf', 'pkg-config'])
 def test_entries(env, name):
     # TODO: Check PKG_CONFIG_PATH is correctly set
-    path = shutil.which(name, path=env.scripts)
-    help_text = subprocess.check_output([os.fspath(path), '--help'])
+    help_text = env.run_script('pkgconf', '--help')
     assert help_text.decode().startswith('usage: pkgconf')
 
 

{pkgconf-2.4.3.post1 → pkgconf-2.4.3.post3}/tests/test_python_module.py

@@ -1,5 +1,6 @@
 import os
 import pathlib
+import shutil
 import subprocess
 
 import pytest
@@ -69,3 +70,19 @@ def test_get_executable_fallback_to_system(mocker):
         executable = pkgconf.get_executable()
 
     assert executable == pkgconf._get_system_executable()
+
+
+def test_inplace_editable(env, tmp_path, packages, data):
+    dst = tmp_path / 'inplace'
+    shutil.copytree(packages / 'inplace', dst)
+
+    env.install(['-e', dst])
+
+    src = os.fspath(data / 'needs-example-lib.c')
+    bin = os.fspath(tmp_path / 'needs-example-lib')
+
+    cflags = env.run_interpreter('-m', 'pkgconf', '--cflags', 'example').decode().split()
+    subprocess.check_call(['gcc', '-o', bin, src, *cflags])
+    out = subprocess.check_output([bin])
+
+    assert out == b'bar'