| import os |
| import sys |
| import itertools |
| from importlib.machinery import EXTENSION_SUFFIXES |
| from importlib.util import cache_from_source as _compiled_file_name |
| from typing import Dict, Iterator, List, Tuple |
| |
| from distutils.command.build_ext import build_ext as _du_build_ext |
| from distutils.ccompiler import new_compiler |
| from distutils.sysconfig import customize_compiler, get_config_var |
| from distutils import log |
| |
| from setuptools.errors import BaseError |
| from setuptools.extension import Extension, Library |
| |
| try: |
| # Attempt to use Cython for building extensions, if available |
| from Cython.Distutils.build_ext import build_ext as _build_ext |
| # Additionally, assert that the compiler module will load |
| # also. Ref #1229. |
| __import__('Cython.Compiler.Main') |
| except ImportError: |
| _build_ext = _du_build_ext |
| |
| # make sure _config_vars is initialized |
| get_config_var("LDSHARED") |
| from distutils.sysconfig import _config_vars as _CONFIG_VARS # noqa |
| |
| |
| def _customize_compiler_for_shlib(compiler): |
| if sys.platform == "darwin": |
| # building .dylib requires additional compiler flags on OSX; here we |
| # temporarily substitute the pyconfig.h variables so that distutils' |
| # 'customize_compiler' uses them before we build the shared libraries. |
| tmp = _CONFIG_VARS.copy() |
| try: |
| # XXX Help! I don't have any idea whether these are right... |
| _CONFIG_VARS['LDSHARED'] = ( |
| "gcc -Wl,-x -dynamiclib -undefined dynamic_lookup") |
| _CONFIG_VARS['CCSHARED'] = " -dynamiclib" |
| _CONFIG_VARS['SO'] = ".dylib" |
| customize_compiler(compiler) |
| finally: |
| _CONFIG_VARS.clear() |
| _CONFIG_VARS.update(tmp) |
| else: |
| customize_compiler(compiler) |
| |
| |
| have_rtld = False |
| use_stubs = False |
| libtype = 'shared' |
| |
| if sys.platform == "darwin": |
| use_stubs = True |
| elif os.name != 'nt': |
| try: |
| import dl |
| use_stubs = have_rtld = hasattr(dl, 'RTLD_NOW') |
| except ImportError: |
| pass |
| |
| |
| def if_dl(s): |
| return s if have_rtld else '' |
| |
| |
| def get_abi3_suffix(): |
| """Return the file extension for an abi3-compliant Extension()""" |
| for suffix in EXTENSION_SUFFIXES: |
| if '.abi3' in suffix: # Unix |
| return suffix |
| elif suffix == '.pyd': # Windows |
| return suffix |
| |
| |
| class build_ext(_build_ext): |
| editable_mode: bool = False |
| inplace: bool = False |
| |
| def run(self): |
| """Build extensions in build directory, then copy if --inplace""" |
| old_inplace, self.inplace = self.inplace, 0 |
| _build_ext.run(self) |
| self.inplace = old_inplace |
| if old_inplace: |
| self.copy_extensions_to_source() |
| |
| def _get_inplace_equivalent(self, build_py, ext: Extension) -> Tuple[str, str]: |
| fullname = self.get_ext_fullname(ext.name) |
| filename = self.get_ext_filename(fullname) |
| modpath = fullname.split('.') |
| package = '.'.join(modpath[:-1]) |
| package_dir = build_py.get_package_dir(package) |
| inplace_file = os.path.join(package_dir, os.path.basename(filename)) |
| regular_file = os.path.join(self.build_lib, filename) |
| return (inplace_file, regular_file) |
| |
| def copy_extensions_to_source(self): |
| build_py = self.get_finalized_command('build_py') |
| for ext in self.extensions: |
| inplace_file, regular_file = self._get_inplace_equivalent(build_py, ext) |
| |
| # Always copy, even if source is older than destination, to ensure |
| # that the right extensions for the current Python/platform are |
| # used. |
| if os.path.exists(regular_file) or not ext.optional: |
| self.copy_file(regular_file, inplace_file, level=self.verbose) |
| |
| if ext._needs_stub: |
| inplace_stub = self._get_equivalent_stub(ext, inplace_file) |
| self._write_stub_file(inplace_stub, ext, compile=True) |
| # Always compile stub and remove the original (leave the cache behind) |
| # (this behaviour was observed in previous iterations of the code) |
| |
| def _get_equivalent_stub(self, ext: Extension, output_file: str) -> str: |
| dir_ = os.path.dirname(output_file) |
| _, _, name = ext.name.rpartition(".") |
| return f"{os.path.join(dir_, name)}.py" |
| |
| def _get_output_mapping(self) -> Iterator[Tuple[str, str]]: |
| if not self.inplace: |
| return |
| |
| build_py = self.get_finalized_command('build_py') |
| opt = self.get_finalized_command('install_lib').optimize or "" |
| |
| for ext in self.extensions: |
| inplace_file, regular_file = self._get_inplace_equivalent(build_py, ext) |
| yield (regular_file, inplace_file) |
| |
| if ext._needs_stub: |
| # This version of `build_ext` always builds artifacts in another dir, |
| # when "inplace=True" is given it just copies them back. |
| # This is done in the `copy_extensions_to_source` function, which |
| # always compile stub files via `_compile_and_remove_stub`. |
| # At the end of the process, a `.pyc` stub file is created without the |
| # corresponding `.py`. |
| |
| inplace_stub = self._get_equivalent_stub(ext, inplace_file) |
| regular_stub = self._get_equivalent_stub(ext, regular_file) |
| inplace_cache = _compiled_file_name(inplace_stub, optimization=opt) |
| output_cache = _compiled_file_name(regular_stub, optimization=opt) |
| yield (output_cache, inplace_cache) |
| |
| def get_ext_filename(self, fullname): |
| so_ext = os.getenv('SETUPTOOLS_EXT_SUFFIX') |
| if so_ext: |
| filename = os.path.join(*fullname.split('.')) + so_ext |
| else: |
| filename = _build_ext.get_ext_filename(self, fullname) |
| so_ext = get_config_var('EXT_SUFFIX') |
| |
| if fullname in self.ext_map: |
| ext = self.ext_map[fullname] |
| use_abi3 = getattr(ext, 'py_limited_api') and get_abi3_suffix() |
| if use_abi3: |
| filename = filename[:-len(so_ext)] |
| so_ext = get_abi3_suffix() |
| filename = filename + so_ext |
| if isinstance(ext, Library): |
| fn, ext = os.path.splitext(filename) |
| return self.shlib_compiler.library_filename(fn, libtype) |
| elif use_stubs and ext._links_to_dynamic: |
| d, fn = os.path.split(filename) |
| return os.path.join(d, 'dl-' + fn) |
| return filename |
| |
| def initialize_options(self): |
| _build_ext.initialize_options(self) |
| self.shlib_compiler = None |
| self.shlibs = [] |
| self.ext_map = {} |
| self.editable_mode = False |
| |
| def finalize_options(self): |
| _build_ext.finalize_options(self) |
| self.extensions = self.extensions or [] |
| self.check_extensions_list(self.extensions) |
| self.shlibs = [ext for ext in self.extensions |
| if isinstance(ext, Library)] |
| if self.shlibs: |
| self.setup_shlib_compiler() |
| for ext in self.extensions: |
| ext._full_name = self.get_ext_fullname(ext.name) |
| for ext in self.extensions: |
| fullname = ext._full_name |
| self.ext_map[fullname] = ext |
| |
| # distutils 3.1 will also ask for module names |
| # XXX what to do with conflicts? |
| self.ext_map[fullname.split('.')[-1]] = ext |
| |
| ltd = self.shlibs and self.links_to_dynamic(ext) or False |
| ns = ltd and use_stubs and not isinstance(ext, Library) |
| ext._links_to_dynamic = ltd |
| ext._needs_stub = ns |
| filename = ext._file_name = self.get_ext_filename(fullname) |
| libdir = os.path.dirname(os.path.join(self.build_lib, filename)) |
| if ltd and libdir not in ext.library_dirs: |
| ext.library_dirs.append(libdir) |
| if ltd and use_stubs and os.curdir not in ext.runtime_library_dirs: |
| ext.runtime_library_dirs.append(os.curdir) |
| |
| if self.editable_mode: |
| self.inplace = True |
| |
| def setup_shlib_compiler(self): |
| compiler = self.shlib_compiler = new_compiler( |
| compiler=self.compiler, dry_run=self.dry_run, force=self.force |
| ) |
| _customize_compiler_for_shlib(compiler) |
| |
| if self.include_dirs is not None: |
| compiler.set_include_dirs(self.include_dirs) |
| if self.define is not None: |
| # 'define' option is a list of (name,value) tuples |
| for (name, value) in self.define: |
| compiler.define_macro(name, value) |
| if self.undef is not None: |
| for macro in self.undef: |
| compiler.undefine_macro(macro) |
| if self.libraries is not None: |
| compiler.set_libraries(self.libraries) |
| if self.library_dirs is not None: |
| compiler.set_library_dirs(self.library_dirs) |
| if self.rpath is not None: |
| compiler.set_runtime_library_dirs(self.rpath) |
| if self.link_objects is not None: |
| compiler.set_link_objects(self.link_objects) |
| |
| # hack so distutils' build_extension() builds a library instead |
| compiler.link_shared_object = link_shared_object.__get__(compiler) |
| |
| def get_export_symbols(self, ext): |
| if isinstance(ext, Library): |
| return ext.export_symbols |
| return _build_ext.get_export_symbols(self, ext) |
| |
| def build_extension(self, ext): |
| ext._convert_pyx_sources_to_lang() |
| _compiler = self.compiler |
| try: |
| if isinstance(ext, Library): |
| self.compiler = self.shlib_compiler |
| _build_ext.build_extension(self, ext) |
| if ext._needs_stub: |
| build_lib = self.get_finalized_command('build_py').build_lib |
| self.write_stub(build_lib, ext) |
| finally: |
| self.compiler = _compiler |
| |
| def links_to_dynamic(self, ext): |
| """Return true if 'ext' links to a dynamic lib in the same package""" |
| # XXX this should check to ensure the lib is actually being built |
| # XXX as dynamic, and not just using a locally-found version or a |
| # XXX static-compiled version |
| libnames = dict.fromkeys([lib._full_name for lib in self.shlibs]) |
| pkg = '.'.join(ext._full_name.split('.')[:-1] + ['']) |
| return any(pkg + libname in libnames for libname in ext.libraries) |
| |
| def get_outputs(self) -> List[str]: |
| if self.inplace: |
| return list(self.get_output_mapping().keys()) |
| return sorted(_build_ext.get_outputs(self) + self.__get_stubs_outputs()) |
| |
| def get_output_mapping(self) -> Dict[str, str]: |
| """See :class:`setuptools.commands.build.SubCommand`""" |
| mapping = self._get_output_mapping() |
| return dict(sorted(mapping, key=lambda x: x[0])) |
| |
| def __get_stubs_outputs(self): |
| # assemble the base name for each extension that needs a stub |
| ns_ext_bases = ( |
| os.path.join(self.build_lib, *ext._full_name.split('.')) |
| for ext in self.extensions |
| if ext._needs_stub |
| ) |
| # pair each base with the extension |
| pairs = itertools.product(ns_ext_bases, self.__get_output_extensions()) |
| return list(base + fnext for base, fnext in pairs) |
| |
| def __get_output_extensions(self): |
| yield '.py' |
| yield '.pyc' |
| if self.get_finalized_command('build_py').optimize: |
| yield '.pyo' |
| |
| def write_stub(self, output_dir, ext, compile=False): |
| stub_file = os.path.join(output_dir, *ext._full_name.split('.')) + '.py' |
| self._write_stub_file(stub_file, ext, compile) |
| |
| def _write_stub_file(self, stub_file: str, ext: Extension, compile=False): |
| log.info("writing stub loader for %s to %s", ext._full_name, stub_file) |
| if compile and os.path.exists(stub_file): |
| raise BaseError(stub_file + " already exists! Please delete.") |
| if not self.dry_run: |
| f = open(stub_file, 'w') |
| f.write( |
| '\n'.join([ |
| "def __bootstrap__():", |
| " global __bootstrap__, __file__, __loader__", |
| " import sys, os, pkg_resources, importlib.util" + |
| if_dl(", dl"), |
| " __file__ = pkg_resources.resource_filename" |
| "(__name__,%r)" |
| % os.path.basename(ext._file_name), |
| " del __bootstrap__", |
| " if '__loader__' in globals():", |
| " del __loader__", |
| if_dl(" old_flags = sys.getdlopenflags()"), |
| " old_dir = os.getcwd()", |
| " try:", |
| " os.chdir(os.path.dirname(__file__))", |
| if_dl(" sys.setdlopenflags(dl.RTLD_NOW)"), |
| " spec = importlib.util.spec_from_file_location(", |
| " __name__, __file__)", |
| " mod = importlib.util.module_from_spec(spec)", |
| " spec.loader.exec_module(mod)", |
| " finally:", |
| if_dl(" sys.setdlopenflags(old_flags)"), |
| " os.chdir(old_dir)", |
| "__bootstrap__()", |
| "" # terminal \n |
| ]) |
| ) |
| f.close() |
| if compile: |
| self._compile_and_remove_stub(stub_file) |
| |
| def _compile_and_remove_stub(self, stub_file: str): |
| from distutils.util import byte_compile |
| |
| byte_compile([stub_file], optimize=0, |
| force=True, dry_run=self.dry_run) |
| optimize = self.get_finalized_command('install_lib').optimize |
| if optimize > 0: |
| byte_compile([stub_file], optimize=optimize, |
| force=True, dry_run=self.dry_run) |
| if os.path.exists(stub_file) and not self.dry_run: |
| os.unlink(stub_file) |
| |
| |
| if use_stubs or os.name == 'nt': |
| # Build shared libraries |
| # |
| def link_shared_object( |
| self, objects, output_libname, output_dir=None, libraries=None, |
| library_dirs=None, runtime_library_dirs=None, export_symbols=None, |
| debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, |
| target_lang=None): |
| self.link( |
| self.SHARED_LIBRARY, objects, output_libname, |
| output_dir, libraries, library_dirs, runtime_library_dirs, |
| export_symbols, debug, extra_preargs, extra_postargs, |
| build_temp, target_lang |
| ) |
| else: |
| # Build static libraries everywhere else |
| libtype = 'static' |
| |
| def link_shared_object( |
| self, objects, output_libname, output_dir=None, libraries=None, |
| library_dirs=None, runtime_library_dirs=None, export_symbols=None, |
| debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, |
| target_lang=None): |
| # XXX we need to either disallow these attrs on Library instances, |
| # or warn/abort here if set, or something... |
| # libraries=None, library_dirs=None, runtime_library_dirs=None, |
| # export_symbols=None, extra_preargs=None, extra_postargs=None, |
| # build_temp=None |
| |
| assert output_dir is None # distutils build_ext doesn't pass this |
| output_dir, filename = os.path.split(output_libname) |
| basename, ext = os.path.splitext(filename) |
| if self.library_filename("x").startswith('lib'): |
| # strip 'lib' prefix; this is kludgy if some platform uses |
| # a different prefix |
| basename = basename[3:] |
| |
| self.create_static_lib( |
| objects, basename, output_dir, debug, target_lang |
| ) |
