numpy/setup.py at main · numpy/numpy

Go to file

mattip BUILD: error when building with python<3.9

Latest commit 40a920d

Jan 26, 2023

History

58 contributors

Users who have contributed to this file

executable file 484 lines (408 sloc) 17.8 KB

Raw Blame

	#!/usr/bin/env python3
	"""
	Numpy build options can be modified with a site.cfg file.
	See site.cfg.example for a template and more information.
	"""

	import os
	from pathlib import Path
	import sys
	import subprocess
	import textwrap
	import warnings
	import builtins
	import re


	# Python supported version checks. Keep right after stdlib imports to ensure we
	# get a sensible error for older Python versions
	if sys.version_info[:2] < (3, 9):
	raise RuntimeError("Python version >= 3.9 required.")


	import versioneer


	# This is a bit hackish: we are setting a global variable so that the main
	# numpy __init__ can detect if it is being loaded by the setup routine, to
	# avoid attempting to load components that aren't built yet. While ugly, it's
	# a lot more robust than what was previously being used.
	builtins.__NUMPY_SETUP__ = True

	# Needed for backwards code compatibility below and in some CI scripts.
	# The version components are changed from ints to strings, but only VERSION
	# seems to matter outside of this module and it was already a str.
	FULLVERSION = versioneer.get_version()

	# Capture the version string:
	# 1.22.0.dev0+ ... -> ISRELEASED == False, VERSION == 1.22.0
	# 1.22.0rc1+ ... -> ISRELEASED == False, VERSION == 1.22.0
	# 1.22.0 ... -> ISRELEASED == True, VERSION == 1.22.0
	# 1.22.0rc1 ... -> ISRELEASED == True, VERSION == 1.22.0
	ISRELEASED = re.search(r'(dev\|\+)', FULLVERSION) is None
	_V_MATCH = re.match(r'(\d+)\.(\d+)\.(\d+)', FULLVERSION)
	if _V_MATCH is None:
	raise RuntimeError(f'Cannot parse version {FULLVERSION}')
	MAJOR, MINOR, MICRO = _V_MATCH.groups()
	VERSION = '{}.{}.{}'.format(MAJOR, MINOR, MICRO)

	# The first version not in the `Programming Language :: Python :: ...` classifiers below
	if sys.version_info >= (3, 12):
	fmt = "NumPy {} may not yet support Python {}.{}."
	warnings.warn(
	fmt.format(VERSION, *sys.version_info[:2]),
	RuntimeWarning)
	del fmt

	# BEFORE importing setuptools, remove MANIFEST. Otherwise it may not be
	# properly updated when the contents of directories change (true for distutils,
	# not sure about setuptools).
	if os.path.exists('MANIFEST'):
	os.remove('MANIFEST')

	# We need to import setuptools here in order for it to persist in sys.modules.
	# Its presence/absence is used in subclassing setup in numpy/distutils/core.py.
	# However, we need to run the distutils version of sdist, so import that first
	# so that it is in sys.modules
	import numpy.distutils.command.sdist
	import setuptools
	if int(setuptools.__version__.split('.')[0]) >= 60:
	# setuptools >= 60 switches to vendored distutils by default; this
	# may break the numpy build, so make sure the stdlib version is used
	try:
	setuptools_use_distutils = os.environ['SETUPTOOLS_USE_DISTUTILS']
	except KeyError:
	os.environ['SETUPTOOLS_USE_DISTUTILS'] = "stdlib"
	else:
	if setuptools_use_distutils != "stdlib":
	raise RuntimeError("setuptools versions >= '60.0.0' require "
	"SETUPTOOLS_USE_DISTUTILS=stdlib in the environment")

	# Initialize cmdclass from versioneer
	from numpy.distutils.core import numpy_cmdclass
	cmdclass = versioneer.get_cmdclass(numpy_cmdclass)

	CLASSIFIERS = """\
	Development Status :: 5 - Production/Stable
	Intended Audience :: Science/Research
	Intended Audience :: Developers
	License :: OSI Approved :: BSD License
	Programming Language :: C
	Programming Language :: Python
	Programming Language :: Python :: 3
	Programming Language :: Python :: 3.8
	Programming Language :: Python :: 3.9
	Programming Language :: Python :: 3.10
	Programming Language :: Python :: 3.11
	Programming Language :: Python :: 3 :: Only
	Programming Language :: Python :: Implementation :: CPython
	Topic :: Software Development
	Topic :: Scientific/Engineering
	Typing :: Typed
	Operating System :: Microsoft :: Windows
	Operating System :: POSIX
	Operating System :: Unix
	Operating System :: MacOS
	"""


	def configuration(parent_package='', top_path=None):
	from numpy.distutils.misc_util import Configuration

	config = Configuration(None, parent_package, top_path)
	config.set_options(ignore_setup_xxx_py=True,
	assume_default_configuration=True,
	delegate_options_to_subpackages=True,
	quiet=True)

	config.add_subpackage('numpy')
	config.add_data_files(('numpy', 'LICENSE.txt'))
	config.add_data_files(('numpy', 'numpy/*.pxd'))

	config.get_version('numpy/version.py') # sets config.version

	return config


	def check_submodules():
	""" verify that the submodules are checked out and clean
	use `git submodule update --init`; on failure
	"""
	if not os.path.exists('.git'):
	return
	with open('.gitmodules') as f:
	for line in f:
	if 'path' in line:
	p = line.split('=')[-1].strip()
	if not os.path.exists(p):
	raise ValueError('Submodule {} missing'.format(p))

	proc = subprocess.Popen(['git', 'submodule', 'status'],
	stdout=subprocess.PIPE)
	status, _ = proc.communicate()
	status = status.decode("ascii", "replace")
	for line in status.splitlines():
	if line.startswith('-') or line.startswith('+'):
	raise ValueError('Submodule not clean: {}'.format(line))


	class concat_license_files():
	"""Merge LICENSE.txt and LICENSES_bundled.txt for sdist creation

	Done this way to keep LICENSE.txt in repo as exact BSD 3-clause (see
	gh-13447). This makes GitHub state correctly how NumPy is licensed.
	"""
	def __init__(self):
	self.f1 = 'LICENSE.txt'
	self.f2 = 'LICENSES_bundled.txt'

	def __enter__(self):
	"""Concatenate files and remove LICENSES_bundled.txt"""
	with open(self.f1, 'r') as f1:
	self.bsd_text = f1.read()

	with open(self.f1, 'a') as f1:
	with open(self.f2, 'r') as f2:
	self.bundled_text = f2.read()
	f1.write('\n\n')
	f1.write(self.bundled_text)

	def __exit__(self, exception_type, exception_value, traceback):
	"""Restore content of both files"""
	with open(self.f1, 'w') as f:
	f.write(self.bsd_text)


	# Need to inherit from versioneer version of sdist to get the encoded
	# version information.
	class sdist_checked(cmdclass['sdist']):
	""" check submodules on sdist to prevent incomplete tarballs """
	def run(self):
	check_submodules()
	with concat_license_files():
	super().run()


	def get_build_overrides():
	"""
	Custom build commands to add `-std=c99` to compilation
	"""
	from numpy.distutils.command.build_clib import build_clib
	from numpy.distutils.command.build_ext import build_ext
	from numpy._utils import _pep440

	def _needs_gcc_c99_flag(obj):
	if obj.compiler.compiler_type != 'unix':
	return False

	cc = obj.compiler.compiler[0]
	if "gcc" not in cc:
	return False

	# will print something like '4.2.1\n'
	out = subprocess.run([cc, '-dumpversion'],
	capture_output=True, text=True)
	# -std=c99 is default from this version on
	if _pep440.parse(out.stdout) >= _pep440.Version('5.0'):
	return False
	return True

	class new_build_clib(build_clib):
	def build_a_library(self, build_info, lib_name, libraries):
	from numpy.distutils.ccompiler_opt import NPY_CXX_FLAGS
	if _needs_gcc_c99_flag(self):
	build_info['extra_cflags'] = ['-std=c99']
	build_info['extra_cxxflags'] = NPY_CXX_FLAGS
	build_clib.build_a_library(self, build_info, lib_name, libraries)

	class new_build_ext(build_ext):
	def build_extension(self, ext):
	if _needs_gcc_c99_flag(self):
	if '-std=c99' not in ext.extra_compile_args:
	ext.extra_compile_args.append('-std=c99')
	build_ext.build_extension(self, ext)
	return new_build_clib, new_build_ext


	def generate_cython():
	# Check Cython version
	from numpy._utils import _pep440
	try:
	# try the cython in the installed python first (somewhat related to
	# scipy/scipy#2397)
	import Cython
	from Cython.Compiler.Version import version as cython_version
	except ImportError as e:
	# The `cython` command need not point to the version installed in the
	# Python running this script, so raise an error to avoid the chance of
	# using the wrong version of Cython.
	msg = 'Cython needs to be installed in Python as a module'
	raise OSError(msg) from e
	else:
	# Note: keep in sync with that in pyproject.toml
	# Update for Python 3.11
	required_version = '0.29.30'

	if _pep440.parse(cython_version) < _pep440.Version(required_version):
	cython_path = Cython.__file__
	msg = 'Building NumPy requires Cython >= {}, found {} at {}'
	msg = msg.format(required_version, cython_version, cython_path)
	raise RuntimeError(msg)

	# Process files
	cwd = os.path.abspath(os.path.dirname(__file__))
	print("Cythonizing sources")
	for d in ('random',):
	p = subprocess.call([sys.executable,
	os.path.join(cwd, 'tools', 'cythonize.py'),
	'numpy/{0}'.format(d)],
	cwd=cwd)
	if p != 0:
	raise RuntimeError("Running cythonize failed!")


	def parse_setuppy_commands():
	"""Check the commands and respond appropriately. Disable broken commands.

	Return a boolean value for whether or not to run the build or not (avoid
	parsing Cython and template files if False).
	"""
	args = sys.argv[1:]

	if not args:
	# User forgot to give an argument probably, let setuptools handle that.
	return True

	info_commands = ['--help-commands', '--name', '--version', '-V',
	'--fullname', '--author', '--author-email',
	'--maintainer', '--maintainer-email', '--contact',
	'--contact-email', '--url', '--license', '--description',
	'--long-description', '--platforms', '--classifiers',
	'--keywords', '--provides', '--requires', '--obsoletes',
	'version',]

	for command in info_commands:
	if command in args:
	return False

	# Note that 'alias', 'saveopts' and 'setopt' commands also seem to work
	# fine as they are, but are usually used together with one of the commands
	# below and not standalone. Hence they're not added to good_commands.
	good_commands = ('develop', 'sdist', 'build', 'build_ext', 'build_py',
	'build_clib', 'build_scripts', 'bdist_wheel', 'bdist_rpm',
	'bdist_wininst', 'bdist_msi', 'bdist_mpkg', 'build_src',
	'bdist_egg')

	for command in good_commands:
	if command in args:
	return True

	# The following commands are supported, but we need to show more
	# useful messages to the user
	if 'install' in args:
	print(textwrap.dedent("""
	Note: if you need reliable uninstall behavior, then install
	with pip instead of using `setup.py install`:

	- `pip install .` (from a git repo or downloaded source
	release)
	- `pip install numpy` (last NumPy release on PyPI)

	"""))
	return True

	if '--help' in args or '-h' in sys.argv[1]:
	print(textwrap.dedent("""
	NumPy-specific help
	-------------------

	To install NumPy from here with reliable uninstall, we recommend
	that you use `pip install .`. To install the latest NumPy release
	from PyPI, use `pip install numpy`.

	For help with build/installation issues, please ask on the
	numpy-discussion mailing list. If you are sure that you have run
	into a bug, please report it at https://github.com/numpy/numpy/issues.

	Setuptools commands help
	------------------------
	"""))
	return False

	# The following commands aren't supported. They can only be executed when
	# the user explicitly adds a --force command-line argument.
	bad_commands = dict(
	test="""
	`setup.py test` is not supported. Use one of the following
	instead:

	- `python runtests.py` (to build and test)
	- `python runtests.py --no-build` (to test installed numpy)
	- `>>> numpy.test()` (run tests for installed numpy
	from within an interpreter)
	""",
	upload="""
	`setup.py upload` is not supported, because it's insecure.
	Instead, build what you want to upload and upload those files
	with `twine upload -s <filenames>` instead.
	""",
	clean="""
	`setup.py clean` is not supported, use one of the following instead:

	- `git clean -xdf` (cleans all files)
	- `git clean -Xdf` (cleans all versioned files, doesn't touch
	files that aren't checked into the git repo)
	""",
	build_sphinx="""
	`setup.py build_sphinx` is not supported, use the
	Makefile under doc/""",
	flake8="`setup.py flake8` is not supported, use flake8 standalone",
	)
	bad_commands['nosetests'] = bad_commands['test']
	for command in ('upload_docs', 'easy_install', 'bdist', 'bdist_dumb',
	'register', 'check', 'install_data', 'install_headers',
	'install_lib', 'install_scripts', ):
	bad_commands[command] = "`setup.py %s` is not supported" % command

	for command in bad_commands.keys():
	if command in args:
	print(textwrap.dedent(bad_commands[command]) +
	"\nAdd `--force` to your command to use it anyway if you "
	"must (unsupported).\n")
	sys.exit(1)

	# Commands that do more than print info, but also don't need Cython and
	# template parsing.
	other_commands = ['egg_info', 'install_egg_info', 'rotate', 'dist_info']
	for command in other_commands:
	if command in args:
	return False

	# If we got here, we didn't detect what setup.py command was given
	raise RuntimeError("Unrecognized setuptools command: {}".format(args))


	def get_docs_url():
	if 'dev' in VERSION:
	return "https://numpy.org/devdocs"
	else:
	# For releases, this URL ends up on PyPI.
	# By pinning the version, users looking at old PyPI releases can get
	# to the associated docs easily.
	return "https://numpy.org/doc/{}.{}".format(MAJOR, MINOR)


	def setup_package():
	src_path = os.path.dirname(os.path.abspath(__file__))
	old_path = os.getcwd()
	os.chdir(src_path)
	sys.path.insert(0, src_path)

	# The f2py scripts that will be installed
	if sys.platform == 'win32':
	f2py_cmds = [
	'f2py = numpy.f2py.f2py2e:main',
	]
	else:
	f2py_cmds = [
	'f2py = numpy.f2py.f2py2e:main',
	'f2py%s = numpy.f2py.f2py2e:main' % sys.version_info[:1],
	'f2py%s.%s = numpy.f2py.f2py2e:main' % sys.version_info[:2],
	]

	cmdclass["sdist"] = sdist_checked
	metadata = dict(
	name='numpy',
	maintainer="NumPy Developers",
	maintainer_email="numpy-discussion@python.org",
	description="Fundamental package for array computing in Python",
	long_description=Path("README.md").read_text(encoding="utf-8"),
	long_description_content_type="text/markdown",
	url="https://www.numpy.org",
	author="Travis E. Oliphant et al.",
	download_url="https://pypi.python.org/pypi/numpy",
	project_urls={
	"Bug Tracker": "https://github.com/numpy/numpy/issues",
	"Documentation": get_docs_url(),
	"Source Code": "https://github.com/numpy/numpy",
	},
	license='BSD-3-Clause',
	classifiers=[_f for _f in CLASSIFIERS.split('\n') if _f],
	platforms=["Windows", "Linux", "Solaris", "Mac OS-X", "Unix"],
	test_suite='pytest',
	version=versioneer.get_version(),
	cmdclass=cmdclass,
	python_requires='>=3.8',
	zip_safe=False,
	entry_points={
	'console_scripts': f2py_cmds,
	'array_api': ['numpy = numpy.array_api'],
	'pyinstaller40': ['hook-dirs = numpy:_pyinstaller_hooks_dir'],
	},
	)

	if "--force" in sys.argv:
	run_build = True
	sys.argv.remove('--force')
	else:
	# Raise errors for unsupported commands, improve help output, etc.
	run_build = parse_setuppy_commands()

	if run_build:
	# patches distutils, even though we don't use it
	#from setuptools import setup
	from numpy.distutils.core import setup

	if 'sdist' not in sys.argv:
	# Generate Cython sources, unless we're generating an sdist
	generate_cython()

	metadata['configuration'] = configuration
	# Customize extension building
	cmdclass['build_clib'], cmdclass['build_ext'] = get_build_overrides()
	else:
	#from numpy.distutils.core import setup
	from setuptools import setup
	# workaround for broken --no-build-isolation with newer setuptools,
	# see gh-21288
	metadata["packages"] = []

	try:
	setup(**metadata)
	finally:
	del sys.path[0]
	os.chdir(old_path)
	return


	if __name__ == '__main__':
	setup_package()
	# This may avoid problems where numpy is installed via ``*_requires`` by
	# setuptools, the global namespace isn't reset properly, and then numpy is
	# imported later (which will then fail to load numpy extension modules).
	# See gh-7956 for details
	del builtins.__NUMPY_SETUP__