setupinfo.py

# Copyright (c) The PyAMF Project.
# See LICENSE.txt for details.

"""
Meta data and helper functions for setup
"""

importsys
importos.path
importfnmatch

try:
fromCython.Distutilsimportbuild_ext

have_cython=True
exceptImportError:
fromsetuptools.command.build_extimportbuild_ext

have_cython=False


fromsetuptools.commandimporttest, sdist
fromsetuptoolsimportExtension
fromdistutils.coreimportDistribution


_version=None

jython=sys.platform.startswith('java')
can_compile_extensions=notjython


classMyDistribution(Distribution):
"""
 This seems to be is the only obvious way to add a global option to
 distutils.

 Provide the ability to disable building the extensions for any called
 command.
 """

global_options=Distribution.global_options+ [
 ('disable-ext', None, 'Disable building extensions.')
 ]

deffinalize_options(self):
Distribution.finalize_options(self)

try:
i=self.script_args.index('--disable-ext')
exceptValueError:
self.disable_ext=False
else:
self.disable_ext=True
self.script_args.pop(i)


classMyBuildExt(build_ext):
"""
 The companion to L{MyDistribution} that checks to see if building the
 extensions are disabled.
 """

defrun(self, *args, **kwargs):
ifself.distribution.disable_ext:
return

build_ext.run(self, *args, **kwargs)


classMySDist(sdist.sdist):
"""
 We generate the Cython code for a source distribution
 """

defcythonise(self):
ext=MyBuildExt(self.distribution)
ext.initialize_options()
ext.finalize_options()

ext.check_extensions_list(ext.extensions)

foreinext.extensions:
e.sources=ext.cython_sources(e.sources, e)

defrun(self):
ifnothave_cython:
print('ERROR - Cython is required to build source distributions')

raiseSystemExit(1)

self.cythonise()

returnsdist.sdist.run(self)


classTestCommand(test.test):
"""
 Ensures that unittest2 is imported if required and replaces the old
 unittest module.
 """

defrun_tests(self):
try:
importunittest2

sys.modules['unittest'] =unittest2
exceptImportError:
pass

returntest.test.run_tests(self)


defset_version(version):
global_version

_version=version


defget_version():
v=''
prev=None

forxin_version:
ifprevisnotNone:
ifisinstance(x, int):
v+='.'

prev=x
v+=str(x)

returnv.strip('.')


defget_extras_require():
return {
'wsgi': ['wsgiref'],
'twisted': ['Twisted>=2.5.0'],
'django': ['Django>=0.96'],
'sqlalchemy': ['SQLAlchemy>=0.4'],
'elixir': ['Elixir>=0.7.1'],
'lxml': ['lxml>=2.2'],
 }


defget_package_data():
return {
'cpyamf': ['*.pxd'],
 }


defextra_setup_args():
"""
 Extra kwargs to supply in the call to C{setup}.

 This is used to supply custom commands, not metadata - that should live in
 setup.py itself.
 """
return {
'distclass': MyDistribution,
'cmdclass': {
'test': TestCommand,
'build_ext': MyBuildExt,
'sdist': MySDist
 },
'package_data': get_package_data(),
 }


defget_install_requirements():
"""
 Returns a list of dependencies for PyAMF to function correctly on the
 target platform.
 """
install_requires= ['defusedxml']

ifsys.version_info< (2, 5):
install_requires.extend(["elementtree>=1.2.6", "uuid>=1.30"])

if'dev'inget_version():
ifcan_compile_extensions:
install_requires.extend(['Cython>=0.13'])

returninstall_requires


defget_test_requirements():
"""
 Returns a list of required packages to run the test suite.
 """
tests_require= []

ifsys.version_info< (2, 7):
tests_require.extend(['unittest2'])

returntests_require


defwrite_version_py(filename='pyamf/_version.py'):
"""
 """
ifos.path.exists(filename):
os.remove(filename)

content="""\
# THIS FILE IS GENERATED BY PYAMF SETUP.PY
from pyamf.versions import Version

version = Version(*%(version)r)
"""
a=open(filename, 'wt')

try:
a.write(content% {'version': _version})
finally:
a.close()


defmake_extension(mod_name, **extra_options):
"""
 Tries is best to return an Extension instance based on the mod_name
 """
base_name=os.path.join(mod_name.replace('.', os.path.sep))

ifhave_cython:
forextin ['.pyx', '.py']:
source=base_name+ext

ifos.path.exists(source):
returnExtension(mod_name, [source], **extra_options)

print('WARNING: Could not find Cython source for %r'% (mod_name,))
else:
source=base_name+'.c'

ifos.path.exists(source):
returnExtension(mod_name, [source], **extra_options)

print('WARNING: Could not build extension for %r, no source found'% (
mod_name,))


defread(fname):
returnopen(os.path.join(os.path.dirname(__file__), fname)).read()


defget_extensions():
"""
 Return a list of Extension instances that can be compiled.
 """
ifnotcan_compile_extensions:
print(80*'*')
print('WARNING:')
print(
'\tAn optional code optimization (C extension) could not be '
'compiled.\n\n'
 )
print('\tOptimizations for this package will not be available!\n\n')
print('Compiling extensions is not supported on %r'% (sys.platform,))
print(80*'*')

return []

extensions= []

forpinrecursive_glob('.', '*.pyx'):
mod_name=os.path.splitext(p)[0].replace(os.path.sep, '.')

e=make_extension(mod_name)

ife:
extensions.append(e)

returnextensions


defget_trove_classifiers():
"""
 Return a list of trove classifiers that are setup dependent.
 """
classifiers= []

defdev_status():
version=get_version()

if'dev'inversion:
return'Development Status :: 2 - Pre-Alpha'
elif'alpha'inversion:
return'Development Status :: 3 - Alpha'
elif'beta'inversion:
return'Development Status :: 4 - Beta'
else:
return'Development Status :: 5 - Production/Stable'

returnclassifiers+ [dev_status()]


defrecursive_glob(path, pattern):
matches= []

forroot, dirnames, filenamesinos.walk(path):
forfilenameinfnmatch.filter(filenames, pattern):
matches.append(os.path.normpath(os.path.join(root, filename)))

returnmatches