setup.py

   1 from distutils.core import setup, Extension
   2 from distutils.sysconfig import get_python_lib
   3 import os, os.path
   4 import sys
   5
   6 if 'sdist' in sys.argv and sys.platform != "win32" and sys.version_info >= (2,4):
   7     # Record the current revision in .hgrev
   8     import subprocess # os.popen is cleaner but deprecated
   9     changeset = subprocess.Popen("hg identify --id --rev tip".split(),
  10                                  stdout=subprocess.PIPE).stdout.read()
  11     rev = changeset.decode('ISO-8859-1').strip()
  12     hgrev = open('.hgrev', 'w')
  13     hgrev.write(rev)
  14     hgrev.close()
  15
  16 if sys.platform == "darwin":
  17     # Don't create resource files on OS X tar.
  18     os.environ['COPY_EXTENDED_ATTRIBUTES_DISABLE'] = 'true'
  19     os.environ['COPYFILE_DISABLE'] = 'true'
  20
  21 setup_args = {}
  22
  23 def add_command_class(name, cls):
  24     cmdclasses = setup_args.get('cmdclass', {})
  25     cmdclasses[name] = cls
  26     setup_args['cmdclass'] = cmdclasses
  27
  28 if sys.version_info[0] >= 3:
  29     import lib2to3.refactor
  30     from distutils.command.build_py \
  31          import build_py_2to3 as build_py
  32     # need to convert sources to Py3 on installation
  33     fixers = [ fix for fix in lib2to3.refactor.get_fixers_from_package("lib2to3.fixes")
  34                if fix.split('fix_')[-1] not in ('next',)
  35                ]
  36     build_py.fixer_names = fixers
  37     add_command_class("build_py", build_py)
  38
  39 pxd_include_dirs = [
  40     directory for directory, dirs, files in os.walk('Cython/Includes')
  41     if '__init__.pyx' in files or '__init__.pxd' in files
  42     or directory == 'Cython/Includes' or directory == 'Cython/Includes/Deprecated']
  43
  44 pxd_include_patterns = [
  45     p+'/*.pxd' for p in pxd_include_dirs ] + [
  46     p+'/*.pyx' for p in pxd_include_dirs ]
  47
  48 if sys.version_info < (2,4):
  49     install_base_dir = get_python_lib(prefix='')
  50     import glob
  51     patterns = pxd_include_patterns + [
  52         'Cython/Plex/*.pxd',
  53         'Cython/Compiler/*.pxd',
  54         'Cython/Runtime/*.pyx'
  55         ]
  56     setup_args['data_files'] = [
  57         (os.path.dirname(os.path.join(install_base_dir, pattern)),
  58          [ f for f in glob.glob(pattern) ])
  59         for pattern in patterns
  60         ]
  61 else:
  62     setup_args['package_data'] = {
  63         'Cython.Plex'     : ['*.pxd'],
  64         'Cython.Compiler' : ['*.pxd'],
  65         'Cython.Runtime'  : ['*.pyx', '*.pxd'],
  66         'Cython'          : [ p[7:] for p in pxd_include_patterns ],
  67         }
  68
  69 # This dict is used for passing extra arguments that are setuptools
  70 # specific to setup
  71 setuptools_extra_args = {}
  72
  73 # tells whether to include cygdb (the script and the Cython.Debugger package
  74 include_debugger = sys.version_info[:2] > (2, 4)
  75
  76 if 'setuptools' in sys.modules:
  77     setuptools_extra_args['zip_safe'] = False
  78     setuptools_extra_args['entry_points'] = {
  79         'console_scripts': [
  80             'cython = Cython.Compiler.Main:setuptools_main',
  81         ]
  82     }
  83     scripts = []
  84 else:
  85     if os.name == "posix":
  86         scripts = ["bin/cython"]
  87         if include_debugger:
  88             scripts.append('bin/cygdb')
  89     else:
  90         scripts = ["cython.py"]
  91         if include_debugger:
  92             scripts.append('cygdb.py')
  93
  94 def compile_cython_modules(profile=False, compile_more=False, cython_with_refnanny=False):
  95     source_root = os.path.abspath(os.path.dirname(__file__))
  96     compiled_modules = ["Cython.Plex.Scanners",
  97                         "Cython.Plex.Actions",
  98                         "Cython.Compiler.Scanning",
  99                         "Cython.Compiler.Parsing",
 100                         "Cython.Compiler.Visitor",
 101                         "Cython.Runtime.refnanny"]
 102     if compile_more:
 103         compiled_modules.extend([
 104             "Cython.Compiler.ParseTreeTransforms",
 105             "Cython.Compiler.Nodes",
 106             "Cython.Compiler.ExprNodes",
 107             "Cython.Compiler.ModuleNode",
 108             "Cython.Compiler.Optimize",
 109             ])
 110
 111     defines = []
 112     if cython_with_refnanny:
 113         defines.append(('CYTHON_REFNANNY', '1'))
 114
 115     extensions = []
 116     if sys.version_info[0] >= 3:
 117         from Cython.Distutils import build_ext as build_ext_orig
 118         for module in compiled_modules:
 119             source_file = os.path.join(source_root, *module.split('.'))
 120             if os.path.exists(source_file + ".py"):
 121                 pyx_source_file = source_file + ".py"
 122             else:
 123                 pyx_source_file = source_file + ".pyx"
 124             dep_files = []
 125             if os.path.exists(source_file + '.pxd'):
 126                 dep_files.append(source_file + '.pxd')
 127             if '.refnanny' in module:
 128                 defines_for_module = []
 129             else:
 130                 defines_for_module = defines
 131             extensions.append(
 132                 Extension(module, sources = [pyx_source_file],
 133                           define_macros = defines_for_module,
 134                           depends = dep_files)
 135                 )
 136
 137         class build_ext(build_ext_orig):
 138             # we must keep the original modules alive to make sure
 139             # their code keeps working when we remove them from
 140             # sys.modules
 141             dead_modules = []
 142
 143             def build_extensions(self):
 144                 # add path where 2to3 installed the transformed sources
 145                 # and make sure Python (re-)imports them from there
 146                 already_imported = [ module for module in sys.modules
 147                                      if module == 'Cython' or module.startswith('Cython.') ]
 148                 keep_alive = self.dead_modules.append
 149                 for module in already_imported:
 150                     keep_alive(sys.modules[module])
 151                     del sys.modules[module]
 152                 sys.path.insert(0, os.path.join(source_root, self.build_lib))
 153
 154                 if profile:
 155                     from Cython.Compiler.Options import directive_defaults
 156                     directive_defaults['profile'] = True
 157                     print("Enabled profiling for the Cython binary modules")
 158                 build_ext_orig.build_extensions(self)
 159
 160         setup_args['ext_modules'] = extensions
 161         add_command_class("build_ext", build_ext)
 162
 163     else: # Python 2.x
 164         from distutils.command.build_ext import build_ext as build_ext_orig
 165         try:
 166             class build_ext(build_ext_orig):
 167                 def build_extension(self, ext, *args, **kargs):
 168                     try:
 169                         build_ext_orig.build_extension(self, ext, *args, **kargs)
 170                     except StandardError:
 171                         print("Compilation of '%s' failed" % ext.sources[0])
 172             from Cython.Compiler.Main import compile
 173             from Cython import Utils
 174             if profile:
 175                 from Cython.Compiler.Options import directive_defaults
 176                 directive_defaults['profile'] = True
 177                 print("Enabled profiling for the Cython binary modules")
 178             source_root = os.path.dirname(__file__)
 179             for module in compiled_modules:
 180                 source_file = os.path.join(source_root, *module.split('.'))
 181                 if os.path.exists(source_file + ".py"):
 182                     pyx_source_file = source_file + ".py"
 183                 else:
 184                     pyx_source_file = source_file + ".pyx"
 185                 c_source_file = source_file + ".c"
 186                 source_is_newer = False
 187                 if not os.path.exists(c_source_file):
 188                     source_is_newer = True
 189                 else:
 190                     c_last_modified = Utils.modification_time(c_source_file)
 191                     if Utils.file_newer_than(pyx_source_file, c_last_modified):
 192                         source_is_newer = True
 193                     else:
 194                         pxd_source_file = source_file + ".pxd"
 195                         if os.path.exists(pxd_source_file) and Utils.file_newer_than(pxd_source_file, c_last_modified):
 196                             source_is_newer = True
 197                 if source_is_newer:
 198                     print("Compiling module %s ..." % module)
 199                     result = compile(pyx_source_file)
 200                     c_source_file = result.c_file
 201                 if c_source_file:
 202                     # Py2 distutils can't handle unicode file paths
 203                     if isinstance(c_source_file, unicode):
 204                         filename_encoding = sys.getfilesystemencoding()
 205                         if filename_encoding is None:
 206                             filename_encoding = sys.getdefaultencoding()
 207                         c_source_file = c_source_file.encode(filename_encoding)
 208                     if '.refnanny' in module:
 209                         defines_for_module = []
 210                     else:
 211                         defines_for_module = defines
 212                     extensions.append(
 213                         Extension(module, sources = [c_source_file],
 214                                   define_macros = defines_for_module)
 215                         )
 216                 else:
 217                     print("Compilation failed")
 218             if extensions:
 219                 setup_args['ext_modules'] = extensions
 220                 add_command_class("build_ext", build_ext)
 221         except Exception:
 222             print('''
 223 ERROR: %s
 224
 225 Extension module compilation failed, looks like Cython cannot run
 226 properly on this system.  To work around this, pass the option
 227 "--no-cython-compile".  This will install a pure Python version of
 228 Cython without compiling its own sources.
 229 ''' % sys.exc_info()[1])
 230             raise
 231
 232 cython_profile = '--cython-profile' in sys.argv
 233 if cython_profile:
 234     sys.argv.remove('--cython-profile')
 235
 236 try:
 237     sys.argv.remove("--cython-compile-all")
 238     cython_compile_more = True
 239 except ValueError:
 240     cython_compile_more = False
 241
 242 try:
 243     sys.argv.remove("--cython-with-refnanny")
 244     cython_with_refnanny = True
 245 except ValueError:
 246     cython_with_refnanny = False
 247
 248 try:
 249     sys.argv.remove("--no-cython-compile")
 250 except ValueError:
 251     compile_cython_modules(cython_profile, cython_compile_more, cython_with_refnanny)
 252
 253 setup_args.update(setuptools_extra_args)
 254
 255 from Cython import __version__ as version
 256
 257 packages = [
 258     'Cython',
 259     'Cython.Build',
 260     'Cython.Compiler',
 261     'Cython.Runtime',
 262     'Cython.Distutils',
 263     'Cython.Plex',
 264     'Cython.Tests',
 265     'Cython.Compiler.Tests',
 266 ]
 267
 268 if include_debugger:
 269     packages.append('Cython.Debugger')
 270
 271 setup(
 272   name = 'Cython',
 273   version = version,
 274   url = 'http://www.cython.org',
 275   author = 'Greg Ewing, Robert Bradshaw, Stefan Behnel, Dag Seljebotn, et al.',
 276   author_email = 'cython-dev@codespeak.net',
 277   description = "The Cython compiler for writing C extensions for the Python language.",
 278   long_description = """\
 279   The Cython language makes writing C extensions for the Python language as
 280   easy as Python itself.  Cython is a source code translator based on the
 281   well-known Pyrex_, but supports more cutting edge functionality and
 282   optimizations.
 283
 284   The Cython language is very close to the Python language (and most Python
 285   code is also valid Cython code), but Cython additionally supports calling C
 286   functions and declaring C types on variables and class attributes. This
 287   allows the compiler to generate very efficient C code from Cython code.
 288
 289   This makes Cython the ideal language for writing glue code for external C
 290   libraries, and for fast C modules that speed up the execution of Python
 291   code.
 292
 293   .. _Pyrex: http://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/
 294   """,
 295   classifiers = [
 296     "Development Status :: 5 - Production/Stable",
 297     "Intended Audience :: Developers",
 298     "License :: OSI Approved :: Apache Software License",
 299     "Operating System :: OS Independent",
 300     "Programming Language :: Python",
 301     "Programming Language :: Python :: 2",
 302     "Programming Language :: Python :: 3",
 303     "Programming Language :: C",
 304     "Programming Language :: Cython",
 305     "Topic :: Software Development :: Code Generators",
 306     "Topic :: Software Development :: Compilers",
 307     "Topic :: Software Development :: Libraries :: Python Modules"
 308   ],
 309
 310   scripts = scripts,
 311   packages=packages,
 312
 313   # pyximport
 314   py_modules = ["pyximport/__init__",
 315                 "pyximport/pyximport",
 316                 "pyximport/pyxbuild",
 317
 318                 "cython"],
 319
 320   **setup_args
 321   )