# Copyright 2024 The Bazel Authors. All rights reserved.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

"""Returns information about the local Python runtime as JSON."""

import glob

import json

import os

import sys

import sysconfig

from typing import Any

_IS_WINDOWS = sys.platform == "win32"

_IS_DARWIN = sys.platform == "darwin"

def _get_abi_flags(get_config) -> str:

"""Returns the ABI flags for the Python runtime."""

# sys.abiflags may not exist, but it still may be set in the config.

abi_flags = getattr(sys, "abiflags", None)

if abi_flags is None:

abi_flags = get_config("ABIFLAGS") or get_config("abiflags") or ""

return abi_flags

def _search_directories(get_config, base_executable) -> list[str]:

"""Returns a list of library directories to search for shared libraries."""

# There's several types of libraries with different names and a plethora

# of settings, and many different config variables to check:

#

# LIBPL is used in python-config when shared library is not enabled:

# https://github.com/python/cpython/blob/v3.12.0/Misc/python-config.in#L63

#

# LIBDIR may also be the python directory with library files.

# https://stackoverflow.com/questions/47423246/get-pythons-lib-path

# See also: MULTIARCH

#

# On MacOS, the LDLIBRARY may be a relative path under /Library/Frameworks,

# such as "Python.framework/Versions/3.12/Python", not a file under the

# LIBDIR/LIBPL directory, so include PYTHONFRAMEWORKPREFIX.

lib_dirs = [

get_config(x) for x in ("PYTHONFRAMEWORKPREFIX", "LIBPL", "LIBDIR")

]

# On Debian, with multiarch enabled, prior to Python 3.10, `LIBDIR` didn't

# tell the location of the libs, just the base directory. The `MULTIARCH`

# sysconfig variable tells the subdirectory within it with the libs.

# See:

# https://wiki.debian.org/Python/MultiArch

# https://git.launchpad.net/ubuntu/+source/python3.12/tree/debian/changelog#n842

multiarch = get_config("MULTIARCH")

if multiarch:

for x in ("LIBPL", "LIBDIR"):

config_value = get_config(x)

if config_value and not config_value.endswith(multiarch):

lib_dirs.append(os.path.join(config_value, multiarch))

if not _IS_DARWIN:

for exec_dir in (

os.path.dirname(base_executable) if base_executable else None,

get_config("BINDIR"),

):

if not exec_dir:

continue

if _IS_WINDOWS:

# On Windows DLLs go in the same directory as the executable, while .lib

# files live in the lib/ or libs/ subdirectory.

lib_dirs.append(exec_dir)

lib_dirs.append(os.path.join(exec_dir, "lib"))

lib_dirs.append(os.path.join(exec_dir, "libs"))

else:

# On most non-windows systems the executable is in a bin/ directory and

# the libraries are in a sibling lib/ directory.

lib_dirs.append(os.path.join(os.path.dirname(exec_dir), "lib"))

# Dedup and remove empty values, keeping the order.

return list(dict.fromkeys(d for d in lib_dirs if d))

def _default_library_names(version, abi_flags) -> tuple[str, ...]:

"""Returns a list of default library files to search for shared libraries."""

if _IS_WINDOWS:

return (

f"python{version}{abi_flags}.dll",

f"python{version}.dll",

)

elif _IS_DARWIN:

return (

f"libpython{version}{abi_flags}.dylib",

f"libpython{version}.dylib",

)

else:

return (

f"libpython{version}{abi_flags}.so",

f"libpython{version}.so",

f"libpython{version}{abi_flags}.so.1.0",

f"libpython{version}.so.1.0",

)

def _search_library_names(get_config, version, abi_flags) -> list[str]:

"""Returns a list of library files to search for shared libraries."""

# Quoting configure.ac in the cpython code base:

# "INSTSONAME is the name of the shared library that will be use to install

# on the system - some systems like version suffix, others don't.""

#

# A typical INSTSONAME is 'libpython3.8.so.1.0' on Linux, or

# 'Python.framework/Versions/3.9/Python' on MacOS.

#

# A typical LDLIBRARY is 'libpythonX.Y.so' on Linux, or 'pythonXY.dll' on

# Windows, or 'Python.framework/Versions/3.9/Python' on MacOS.

#

# A typical LIBRARY is 'libpythonX.Y.a' on Linux.

lib_names = [

get_config(x) for x in (

"LDLIBRARY",

"INSTSONAME",

"PY3LIBRARY",

"LIBRARY",

"DLLLIBRARY",

)

]

# Include the default libraries for the system.

lib_names.extend(_default_library_names(version, abi_flags))

# Also include the abi3 libraries for the system.

lib_names.extend(_default_library_names(sys.version_info.major, abi_flags))

# Uniqify, preserving order.

return list(dict.fromkeys(k for k in lib_names if k))

def _get_python_library_info(base_executable) -> dict[str, Any]:

"""Returns a dictionary with the static and dynamic python libraries."""

config_vars = sysconfig.get_config_vars()

# VERSION is X.Y in Linux/macOS and XY in Windows. This is used to

# construct library paths such as python3.12, so ensure it exists.

version = config_vars.get("VERSION")

if not version:

if _IS_WINDOWS:

version = f"{sys.version_info.major}{sys.version_info.minor}"

else:

version = f"{sys.version_info.major}.{sys.version_info.minor}"

defines = []

if config_vars.get("Py_GIL_DISABLED", "0") == "1":

defines.append("Py_GIL_DISABLED")

# Avoid automatically linking the libraries on windows via pydefine.h

# pragma comment(lib ...)

if _IS_WINDOWS:

defines.append("Py_NO_LINK_LIB")

# sys.abiflags may not exist, but it still may be set in the config.

abi_flags = _get_abi_flags(config_vars.get)

search_directories = _search_directories(config_vars.get, base_executable)

search_libnames = _search_library_names(config_vars.get, version,

abi_flags)

# Used to test whether the library is an abi3 library or a full api library.

abi3_libraries = _default_library_names(sys.version_info.major, abi_flags)

# Found libraries

static_libraries: dict[str, None] = {}

dynamic_libraries: dict[str, None] = {}

interface_libraries: dict[str, None] = {}

abi_dynamic_libraries: dict[str, None] = {}

abi_interface_libraries: dict[str, None] = {}

for root_dir in search_directories:

for libname in search_libnames:

composed_path = os.path.join(root_dir, libname)

is_abi3_file = os.path.basename(composed_path) in abi3_libraries

# Check whether the library exists and add it to the appropriate list.

if os.path.exists(composed_path) or os.path.isdir(composed_path):

if is_abi3_file:

if not libname.endswith(".a"):

abi_dynamic_libraries[composed_path] = None

elif libname.endswith(".a"):

static_libraries[composed_path] = None

else:

dynamic_libraries[composed_path] = None

interface_path = None

if libname.endswith(".dll"):

# On windows a .lib file may be an "import library" or a static

# library. The file could be inspected to determine which it is;

# typically python is used as a shared library.

#

# On Windows, extensions should link with the pythonXY.lib interface

# libraries.

#

# See: https://docs.python.org/3/extending/windows.html

# https://learn.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-creation

interface_path = os.path.join(root_dir, libname[:-3] + "lib")

elif libname.endswith(".so"):

# It's possible, though unlikely, that interface stubs (.ifso) exist.

interface_path = os.path.join(root_dir, libname[:-2] + "ifso")

# Check whether an interface library exists.

if interface_path and os.path.exists(interface_path):

if is_abi3_file:

abi_interface_libraries[interface_path] = None

else:

interface_libraries[interface_path] = None

# Additional DLLs are needed on Windows to link properly.

dlls = []

if _IS_WINDOWS:

dlls.extend(

glob.glob(os.path.join(os.path.dirname(base_executable), "*.dll")))

dlls = [

x for x in dlls

if x not in dynamic_libraries and x not in abi_dynamic_libraries

]

def _unique_basenames(inputs: dict[str, None]) -> list[str]:

"""Returns a list of paths, keeping only the first path for each basename."""

result = []

seen = set()

for k in inputs:

b = os.path.basename(k)

if b not in seen:

seen.add(b)

result.append(k)

return result

# When no libraries are found it's likely that the python interpreter is not

# configured to use shared or static libraries (minilinux). If this seems

# suspicious try running `uv tool run find_libpython --list-all -v`

return {

"dynamic_libraries": _unique_basenames(dynamic_libraries),

"static_libraries": _unique_basenames(static_libraries),

"interface_libraries": _unique_basenames(interface_libraries),

"abi_dynamic_libraries": _unique_basenames(abi_dynamic_libraries),

"abi_interface_libraries": _unique_basenames(abi_interface_libraries),

"abi_flags": abi_flags,

"shlib_suffix": ".dylib" if _IS_DARWIN else "",

"additional_dlls": dlls,

"defines": defines,

}

def _get_base_executable() -> str:

"""Returns the base executable path."""

return getattr(sys, "_base_executable", None) or sys.executable

data = {

"major": sys.version_info.major,

"minor": sys.version_info.minor,

"micro": sys.version_info.micro,

"include": sysconfig.get_path("include"),

"implementation_name": sys.implementation.name,

"base_executable": _get_base_executable(),

}

data.update(_get_python_library_info(_get_base_executable()))

print(json.dumps(data))