setupext.Matplotlib(),

setupext.Python(),

setupext.Platform(),

setupext.FreeType(),

setupext.Qhull(),

setupext.Tests(),

setupext.BackendMacOSX(),

"""Return whether a flag name is supported on the specified compiler."""

import tempfile

with tempfile.NamedTemporaryFile('w', suffix='.cpp') as f:

f.write('int main (int argc, char **argv) { return 0; }')

try:

self.compile([f.name], extra_postargs=[flagname])

except Exception as exc:

# https://github.com/pypa/setuptools/issues/2698

if type(exc).__name__ != "CompileError":

raise

return False

def finalize_options(self):

# If coverage is enabled then need to keep the .o and .gcno files in a

# non-temporary directory otherwise coverage info not collected.

cppflags = os.getenv('CPPFLAGS')

if cppflags and '--coverage' in cppflags:

self.build_temp = 'build'

self.distribution.ext_modules[:] = [

ext

for package in good_packages

for ext in package.get_extensions()

]

super().finalize_options()

def add_optimization_flags(self):

"""

env = os.environ.copy()

if sys.platform == 'win32':

return env

enable_lto = setupext.config.getboolean('libs', 'enable_lto',

fallback=None)

def prepare_flags(name, enable_lto):

"""

if name in os.environ:

if '-fno-lto' in os.environ[name]:

if enable_lto is True:

raise ValueError('Configuration enable_lto=True, but '

'{0} contains -fno-lto'.format(name))

enable_lto = False

return [os.environ[name]], enable_lto

return [], enable_lto

_, enable_lto = prepare_flags('CFLAGS', enable_lto) # Only check lto.

cppflags, enable_lto = prepare_flags('CPPFLAGS', enable_lto)

cxxflags, enable_lto = prepare_flags('CXXFLAGS', enable_lto)

ldflags, enable_lto = prepare_flags('LDFLAGS', enable_lto)

if enable_lto is False:

return env

if has_flag(self.compiler, '-fvisibility=hidden'):

for ext in self.extensions:

ext.extra_compile_args.append('-fvisibility=hidden')

cppflags.append('-fvisibility=hidden')

if has_flag(self.compiler, '-fvisibility-inlines-hidden'):

for ext in self.extensions:

if self.compiler.detect_language(ext.sources) != 'cpp':

continue

ext.extra_compile_args.append('-fvisibility-inlines-hidden')

cxxflags.append('-fvisibility-inlines-hidden')

ranlib = 'RANLIB' in env

if not ranlib and self.compiler.compiler_type == 'unix':

try:

result = subprocess.run(self.compiler.compiler +

['--version'],

stdout=subprocess.PIPE,

stderr=subprocess.STDOUT,

universal_newlines=True)

except Exception:

pass

else:

version = result.stdout.lower()

if 'gcc' in version:

ranlib = shutil.which('gcc-ranlib')

elif 'clang' in version:

if sys.platform == 'darwin':

ranlib = True

else:

ranlib = shutil.which('llvm-ranlib')

if ranlib and has_flag(self.compiler, '-flto'):

for ext in self.extensions:

ext.extra_compile_args.append('-flto')

cppflags.append('-flto')

ldflags.append('-flto')

# Needed so FreeType static library doesn't lose its LTO objects.

if isinstance(ranlib, str):

env['RANLIB'] = ranlib

env['CPPFLAGS'] = ' '.join(cppflags)

env['CXXFLAGS'] = ' '.join(cxxflags)

env['LDFLAGS'] = ' '.join(ldflags)

return env

def build_extensions(self):

if (self.compiler.compiler_type == 'msvc' and

os.environ.get('MPL_DISABLE_FH4')):

# Disable FH4 Exception Handling implementation so that we don't

# require VCRUNTIME140_1.dll. For more details, see:

# https://devblogs.microsoft.com/cppblog/making-cpp-exception-handling-smaller-x64/

# https://github.com/joerick/cibuildwheel/issues/423#issuecomment-677763904

for ext in self.extensions:

ext.extra_compile_args.append('/d2FH4-')

env = self.add_optimization_flags()

for package in good_packages:

package.do_custom_build(env)

# Make sure we don't accidentally use too modern C++ constructs, even

# though modern compilers default to enabling them. Enabling this for

# a single platform is enough; also only do this for C++-only

# extensions as clang refuses to compile C/ObjC with -std=c++11.

if sys.platform != "win32":

for ext in self.distribution.ext_modules[:]:

if not any(src.endswith((".c", ".m")) for src in ext.sources):

ext.extra_compile_args.append("-std=c++11")

return super().build_extensions()

def build_extension(self, ext):

# When C coverage is enabled, the path to the object file is saved.

# Since we re-use source files in multiple extensions, libgcov will

# complain at runtime that it is trying to save coverage for the same

# object file at different timestamps (since each source is compiled

# again for each extension). Thus, we need to use unique temporary

# build directories to store object files for each extension.

orig_build_temp = self.build_temp

self.build_temp = os.path.join(self.build_temp, ext.name)

try:

super().build_extension(ext)

finally:

# If packagers want to change the default backend, insert a `#backend: ...`

# line. Otherwise, use the default `##backend: Agg` which has no effect

# even after decommenting, which allows _auto_backend_sentinel to be filled

# in at import time.

template_lines = path.read_text(encoding="utf-8").splitlines(True)

backend_line_idx, = [ # Also asserts that there is a single such line.

idx for idx, line in enumerate(template_lines)

if "#backend:" in line]

template_lines[backend_line_idx] = (

"#backend: {}\n".format(setupext.options["backend"])

if setupext.options["backend"]

else "##backend: Agg\n")

def run(self):

super().run()

if not getattr(self, 'editable_mode', False):

update_matplotlibrc(

def make_release_tree(self, base_dir, files):

super().make_release_tree(base_dir, files)

update_matplotlibrc(