setup.py - platform/external/python/cryptography - Gitiles

 # This file is dual licensed under the terms of the Apache License, Version
 # 2.0, and the BSD License. See the LICENSE file in the root of this repository
 # for complete details.

 from __future__ import absolute_import, division, print_function

 import os
 import platform
 import subprocess
 import sys
 from distutils.command.build import build

 import pkg_resources

 from setuptools import find_packages, setup
 from setuptools.command.install import install
 from setuptools.command.test import test


 base_dir = os.path.dirname(__file__)
 src_dir = os.path.join(base_dir, "src")

 # When executing the setup.py, we need to be able to import ourselves, this
 # means that we need to add the src/ directory to the sys.path.
 sys.path.insert(0, src_dir)

 about = {}
 with open(os.path.join(src_dir, "cryptography", "__about__.py")) as f:
     exec(f.read(), about)


 SETUPTOOLS_DEPENDENCY = "setuptools"
 CFFI_DEPENDENCY = "cffi>=0.8"
 SIX_DEPENDENCY = "six>=1.4.1"
 VECTORS_DEPENDENCY = "cryptography_vectors=={0}".format(about['__version__'])

 requirements = [
     CFFI_DEPENDENCY,
     "pyasn1",
     SIX_DEPENDENCY,
     SETUPTOOLS_DEPENDENCY
 ]

 if sys.version_info < (3, 4):
     requirements.append("enum34")

 # If you add a new dep here you probably need to add it in the tox.ini as well
 test_requirements = [
     "pytest",
     "pretend",
     "iso8601",
 ]

 # If there's no vectors locally that probably means we are in a tarball and
 # need to go and get the matching vectors package from PyPi
 if not os.path.exists(os.path.join(base_dir, "vectors/setup.py")):
     test_requirements.append(VECTORS_DEPENDENCY)


 def cc_is_available():
     return sys.platform == "darwin" and list(map(
         int, platform.mac_ver()[0].split("."))) >= [10, 8, 0]


 backends = [
     "openssl = cryptography.hazmat.backends.openssl:backend"
 ]

 if cc_is_available():
     backends.append(
         "commoncrypto = cryptography.hazmat.backends.commoncrypto:backend",
     )


 def get_ext_modules():
     from cryptography.hazmat.bindings.commoncrypto.binding import (
         Binding as CommonCryptoBinding
     )
     from cryptography.hazmat.bindings.openssl.binding import (
         Binding as OpenSSLBinding
     )
     from cryptography.hazmat.primitives import constant_time, padding

     ext_modules = [
         OpenSSLBinding.ffi.verifier.get_extension(),
         constant_time._ffi.verifier.get_extension(),
         padding._ffi.verifier.get_extension()
     ]
     if cc_is_available():
         ext_modules.append(CommonCryptoBinding.ffi.verifier.get_extension())
     return ext_modules


 class CFFIBuild(build):
     """
     This class exists, instead of just providing ``ext_modules=[...]`` directly
     in ``setup()`` because importing cryptography requires we have several
     packages installed first.

     By doing the imports here we ensure that packages listed in
     ``setup_requires`` are already installed.
     """

     def finalize_options(self):
         self.distribution.ext_modules = get_ext_modules()
         build.finalize_options(self)


 class CFFIInstall(install):
     """
     As a consequence of CFFIBuild and it's late addition of ext_modules, we
     need the equivalent for the ``install`` command to install into platlib
     install-dir rather than purelib.
     """

     def finalize_options(self):
         self.distribution.ext_modules = get_ext_modules()
         install.finalize_options(self)


 class PyTest(test):
     def finalize_options(self):
         test.finalize_options(self)
         self.test_args = []
         self.test_suite = True

         # This means there's a vectors/ folder with the package in here.
         # cd into it, install the vectors package and then refresh sys.path
         if VECTORS_DEPENDENCY not in test_requirements:
             subprocess.check_call(
                 [sys.executable, "setup.py", "install"], cwd="vectors"
             )
             pkg_resources.get_distribution("cryptography_vectors").activate()

     def run_tests(self):
         # Import here because in module scope the eggs are not loaded.
         import pytest
         errno = pytest.main(self.test_args)
         sys.exit(errno)


 def keywords_with_side_effects(argv):
     """
     Get a dictionary with setup keywords that (can) have side effects.

     :param argv: A list of strings with command line arguments.
     :returns: A dictionary with keyword arguments for the ``setup()`` function.

     This setup.py script uses the setuptools 'setup_requires' feature because
     this is required by the cffi package to compile extension modules. The
     purpose of ``keywords_with_side_effects()`` is to avoid triggering the cffi
     build process as a result of setup.py invocations that don't need the cffi
     module to be built (setup.py serves the dual purpose of exposing package
     metadata).

     All of the options listed by ``python setup.py --help`` that print
     information should be recognized here. The commands ``clean``,
     ``egg_info``, ``register``, ``sdist`` and ``upload`` are also recognized.
     Any combination of these options and commands is also supported.

     This function was originally based on the `setup.py script`_ of SciPy (see
     also the discussion in `pip issue #25`_).

     .. _pip issue #25: https://github.com/pypa/pip/issues/25
     .. _setup.py script: https://github.com/scipy/scipy/blob/master/setup.py
     """
     no_setup_requires_arguments = (
         '-h', '--help',
         '-n', '--dry-run',
         '-q', '--quiet',
         '-v', '--verbose',
         '-V', '--version',
         '--author',
         '--author-email',
         '--classifiers',
         '--contact',
         '--contact-email',
         '--description',
         '--egg-base',
         '--fullname',
         '--help-commands',
         '--keywords',
         '--licence',
         '--license',
         '--long-description',
         '--maintainer',
         '--maintainer-email',
         '--name',
         '--no-user-cfg',
         '--obsoletes',
         '--platforms',
         '--provides',
         '--requires',
         '--url',
         'clean',
         'egg_info',
         'register',
         'sdist',
         'upload',
     )

     def is_short_option(argument):
         """Check whether a command line argument is a short option."""
         return len(argument) >= 2 and argument[0] == '-' and argument[1] != '-'

     def expand_short_options(argument):
         """Expand combined short options into canonical short options."""
         return ('-' + char for char in argument[1:])

     def argument_without_setup_requirements(argv, i):
         """Check whether a command line argument needs setup requirements."""
         if argv[i] in no_setup_requires_arguments:
             # Simple case: An argument which is either an option or a command
             # which doesn't need setup requirements.
             return True
         elif (is_short_option(argv[i]) and
               all(option in no_setup_requires_arguments
                   for option in expand_short_options(argv[i]))):
             # Not so simple case: Combined short options none of which need
             # setup requirements.
             return True
         elif argv[i - 1:i] == ['--egg-base']:
             # Tricky case: --egg-info takes an argument which should not make
             # us use setup_requires (defeating the purpose of this code).
             return True
         else:
             return False

     if all(argument_without_setup_requirements(argv, i)
            for i in range(1, len(argv))):
         return {
             "cmdclass": {
                 "build": DummyCFFIBuild,
                 "install": DummyCFFIInstall,
                 "test": DummyPyTest,
             }
         }
     else:
         return {
             "setup_requires": requirements,
             "cmdclass": {
                 "build": CFFIBuild,
                 "install": CFFIInstall,
                 "test": PyTest,
             }
         }


 setup_requires_error = ("Requested setup command that needs 'setup_requires' "
                         "while command line arguments implied a side effect "
                         "free command or option.")


 class DummyCFFIBuild(build):
     """
     This class makes it very obvious when ``keywords_with_side_effects()`` has
     incorrectly interpreted the command line arguments to ``setup.py build`` as
     one of the 'side effect free' commands or options.
     """

     def run(self):
         raise RuntimeError(setup_requires_error)


 class DummyCFFIInstall(install):
     """
     This class makes it very obvious when ``keywords_with_side_effects()`` has
     incorrectly interpreted the command line arguments to ``setup.py install``
     as one of the 'side effect free' commands or options.
     """

     def run(self):
         raise RuntimeError(setup_requires_error)


 class DummyPyTest(test):
     """
     This class makes it very obvious when ``keywords_with_side_effects()`` has
     incorrectly interpreted the command line arguments to ``setup.py test`` as
     one of the 'side effect free' commands or options.
     """

     def run_tests(self):
         raise RuntimeError(setup_requires_error)


 with open(os.path.join(base_dir, "README.rst")) as f:
     long_description = f.read()


 setup(
     name=about["__title__"],
     version=about["__version__"],

     description=about["__summary__"],
     long_description=long_description,
     license=about["__license__"],
     url=about["__uri__"],

     author=about["__author__"],
     author_email=about["__email__"],

     classifiers=[
         "Intended Audience :: Developers",
         "License :: OSI Approved :: Apache Software License",
         "License :: OSI Approved :: BSD License",
         "Natural Language :: English",
         "Operating System :: MacOS :: MacOS X",
         "Operating System :: POSIX",
         "Operating System :: POSIX :: BSD",
         "Operating System :: POSIX :: Linux",
         "Operating System :: Microsoft :: Windows",
         "Programming Language :: Python",
         "Programming Language :: Python :: 2",
         "Programming Language :: Python :: 2.6",
         "Programming Language :: Python :: 2.7",
         "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 3.2",
         "Programming Language :: Python :: 3.3",
         "Programming Language :: Python :: 3.4",
         "Programming Language :: Python :: Implementation :: CPython",
         "Programming Language :: Python :: Implementation :: PyPy",
         "Topic :: Security :: Cryptography",
     ],

     package_dir={"": "src"},
     packages=find_packages(where="src", exclude=["tests", "tests.*"]),
     include_package_data=True,

     install_requires=requirements,
     tests_require=test_requirements,

     # for cffi
     zip_safe=False,
     ext_package="cryptography",
     entry_points={
         "cryptography.backends": backends,
     },
     **keywords_with_side_effects(sys.argv)
 )
	# This file is dual licensed under the terms of the Apache License, Version
	# 2.0, and the BSD License. See the LICENSE file in the root of this repository
	# for complete details.

	from __future__ import absolute_import, division, print_function

	import os
	import platform
	import subprocess
	import sys
	from distutils.command.build import build

	import pkg_resources

	from setuptools import find_packages, setup
	from setuptools.command.install import install
	from setuptools.command.test import test


	base_dir = os.path.dirname(__file__)
	src_dir = os.path.join(base_dir, "src")

	# When executing the setup.py, we need to be able to import ourselves, this
	# means that we need to add the src/ directory to the sys.path.
	sys.path.insert(0, src_dir)

	about = {}
	with open(os.path.join(src_dir, "cryptography", "__about__.py")) as f:
	exec(f.read(), about)


	SETUPTOOLS_DEPENDENCY = "setuptools"
	CFFI_DEPENDENCY = "cffi>=0.8"
	SIX_DEPENDENCY = "six>=1.4.1"
	VECTORS_DEPENDENCY = "cryptography_vectors=={0}".format(about['__version__'])

	requirements = [
	CFFI_DEPENDENCY,
	"pyasn1",
	SIX_DEPENDENCY,
	SETUPTOOLS_DEPENDENCY
	]

	if sys.version_info < (3, 4):
	requirements.append("enum34")

	# If you add a new dep here you probably need to add it in the tox.ini as well
	test_requirements = [
	"pytest",
	"pretend",
	"iso8601",
	]

	# If there's no vectors locally that probably means we are in a tarball and
	# need to go and get the matching vectors package from PyPi
	if not os.path.exists(os.path.join(base_dir, "vectors/setup.py")):
	test_requirements.append(VECTORS_DEPENDENCY)


	def cc_is_available():
	return sys.platform == "darwin" and list(map(
	int, platform.mac_ver()[0].split("."))) >= [10, 8, 0]


	backends = [
	"openssl = cryptography.hazmat.backends.openssl:backend"
	]

	if cc_is_available():
	backends.append(
	"commoncrypto = cryptography.hazmat.backends.commoncrypto:backend",
	)


	def get_ext_modules():
	from cryptography.hazmat.bindings.commoncrypto.binding import (
	Binding as CommonCryptoBinding
	)
	from cryptography.hazmat.bindings.openssl.binding import (
	Binding as OpenSSLBinding
	)
	from cryptography.hazmat.primitives import constant_time, padding

	ext_modules = [
	OpenSSLBinding.ffi.verifier.get_extension(),
	constant_time._ffi.verifier.get_extension(),
	padding._ffi.verifier.get_extension()
	]
	if cc_is_available():
	ext_modules.append(CommonCryptoBinding.ffi.verifier.get_extension())
	return ext_modules


	class CFFIBuild(build):
	"""
	This class exists, instead of just providing ``ext_modules=[...]`` directly
	in ``setup()`` because importing cryptography requires we have several
	packages installed first.

	By doing the imports here we ensure that packages listed in
	``setup_requires`` are already installed.
	"""

	def finalize_options(self):
	self.distribution.ext_modules = get_ext_modules()
	build.finalize_options(self)


	class CFFIInstall(install):
	"""
	As a consequence of CFFIBuild and it's late addition of ext_modules, we
	need the equivalent for the ``install`` command to install into platlib
	install-dir rather than purelib.
	"""

	def finalize_options(self):
	self.distribution.ext_modules = get_ext_modules()
	install.finalize_options(self)


	class PyTest(test):
	def finalize_options(self):
	test.finalize_options(self)
	self.test_args = []
	self.test_suite = True

	# This means there's a vectors/ folder with the package in here.
	# cd into it, install the vectors package and then refresh sys.path
	if VECTORS_DEPENDENCY not in test_requirements:
	subprocess.check_call(
	[sys.executable, "setup.py", "install"], cwd="vectors"
	)
	pkg_resources.get_distribution("cryptography_vectors").activate()

	def run_tests(self):
	# Import here because in module scope the eggs are not loaded.
	import pytest
	errno = pytest.main(self.test_args)
	sys.exit(errno)


	def keywords_with_side_effects(argv):
	"""
	Get a dictionary with setup keywords that (can) have side effects.

	:param argv: A list of strings with command line arguments.
	:returns: A dictionary with keyword arguments for the ``setup()`` function.

	This setup.py script uses the setuptools 'setup_requires' feature because
	this is required by the cffi package to compile extension modules. The
	purpose of ``keywords_with_side_effects()`` is to avoid triggering the cffi
	build process as a result of setup.py invocations that don't need the cffi
	module to be built (setup.py serves the dual purpose of exposing package
	metadata).

	All of the options listed by ``python setup.py --help`` that print
	information should be recognized here. The commands ``clean``,
	``egg_info``, ``register``, ``sdist`` and ``upload`` are also recognized.
	Any combination of these options and commands is also supported.

	This function was originally based on the `setup.py script`_ of SciPy (see
	also the discussion in `pip issue #25`_).

	.. _pip issue #25: https://github.com/pypa/pip/issues/25
	.. _setup.py script: https://github.com/scipy/scipy/blob/master/setup.py
	"""
	no_setup_requires_arguments = (
	'-h', '--help',
	'-n', '--dry-run',
	'-q', '--quiet',
	'-v', '--verbose',
	'-V', '--version',
	'--author',
	'--author-email',
	'--classifiers',
	'--contact',
	'--contact-email',
	'--description',
	'--egg-base',
	'--fullname',
	'--help-commands',
	'--keywords',
	'--licence',
	'--license',
	'--long-description',
	'--maintainer',
	'--maintainer-email',
	'--name',
	'--no-user-cfg',
	'--obsoletes',
	'--platforms',
	'--provides',
	'--requires',
	'--url',
	'clean',
	'egg_info',
	'register',
	'sdist',
	'upload',
	)

	def is_short_option(argument):
	"""Check whether a command line argument is a short option."""
	return len(argument) >= 2 and argument[0] == '-' and argument[1] != '-'

	def expand_short_options(argument):
	"""Expand combined short options into canonical short options."""
	return ('-' + char for char in argument[1:])

	def argument_without_setup_requirements(argv, i):
	"""Check whether a command line argument needs setup requirements."""
	if argv[i] in no_setup_requires_arguments:
	# Simple case: An argument which is either an option or a command
	# which doesn't need setup requirements.
	return True
	elif (is_short_option(argv[i]) and
	all(option in no_setup_requires_arguments
	for option in expand_short_options(argv[i]))):
	# Not so simple case: Combined short options none of which need
	# setup requirements.
	return True
	elif argv[i - 1:i] == ['--egg-base']:
	# Tricky case: --egg-info takes an argument which should not make
	# us use setup_requires (defeating the purpose of this code).
	return True
	else:
	return False

	if all(argument_without_setup_requirements(argv, i)
	for i in range(1, len(argv))):
	return {
	"cmdclass": {
	"build": DummyCFFIBuild,
	"install": DummyCFFIInstall,
	"test": DummyPyTest,
	}
	}
	else:
	return {
	"setup_requires": requirements,
	"cmdclass": {
	"build": CFFIBuild,
	"install": CFFIInstall,
	"test": PyTest,
	}
	}


	setup_requires_error = ("Requested setup command that needs 'setup_requires' "
	"while command line arguments implied a side effect "
	"free command or option.")


	class DummyCFFIBuild(build):
	"""
	This class makes it very obvious when ``keywords_with_side_effects()`` has
	incorrectly interpreted the command line arguments to ``setup.py build`` as
	one of the 'side effect free' commands or options.
	"""

	def run(self):
	raise RuntimeError(setup_requires_error)


	class DummyCFFIInstall(install):
	"""
	This class makes it very obvious when ``keywords_with_side_effects()`` has
	incorrectly interpreted the command line arguments to ``setup.py install``
	as one of the 'side effect free' commands or options.
	"""

	def run(self):
	raise RuntimeError(setup_requires_error)


	class DummyPyTest(test):
	"""
	This class makes it very obvious when ``keywords_with_side_effects()`` has
	incorrectly interpreted the command line arguments to ``setup.py test`` as
	one of the 'side effect free' commands or options.
	"""

	def run_tests(self):
	raise RuntimeError(setup_requires_error)


	with open(os.path.join(base_dir, "README.rst")) as f:
	long_description = f.read()


	setup(
	name=about["__title__"],
	version=about["__version__"],

	description=about["__summary__"],
	long_description=long_description,
	license=about["__license__"],
	url=about["__uri__"],

	author=about["__author__"],
	author_email=about["__email__"],

	classifiers=[
	"Intended Audience :: Developers",
	"License :: OSI Approved :: Apache Software License",
	"License :: OSI Approved :: BSD License",
	"Natural Language :: English",
	"Operating System :: MacOS :: MacOS X",
	"Operating System :: POSIX",
	"Operating System :: POSIX :: BSD",
	"Operating System :: POSIX :: Linux",
	"Operating System :: Microsoft :: Windows",
	"Programming Language :: Python",
	"Programming Language :: Python :: 2",
	"Programming Language :: Python :: 2.6",
	"Programming Language :: Python :: 2.7",
	"Programming Language :: Python :: 3",
	"Programming Language :: Python :: 3.2",
	"Programming Language :: Python :: 3.3",
	"Programming Language :: Python :: 3.4",
	"Programming Language :: Python :: Implementation :: CPython",
	"Programming Language :: Python :: Implementation :: PyPy",
	"Topic :: Security :: Cryptography",
	],

	package_dir={"": "src"},
	packages=find_packages(where="src", exclude=["tests", "tests.*"]),
	include_package_data=True,

	install_requires=requirements,
	tests_require=test_requirements,

	# for cffi
	zip_safe=False,
	ext_package="cryptography",
	entry_points={
	"cryptography.backends": backends,
	},
	**keywords_with_side_effects(sys.argv)
	)