|
|
|
|
|
|
|
|
from __future__ import absolute_import |
|
|
|
|
|
import os |
|
|
import shutil |
|
|
import tempfile |
|
|
from distutils.core import setup |
|
|
|
|
|
from .Dependencies import cythonize, extended_iglob |
|
|
from ..Utils import is_package_dir |
|
|
from ..Compiler import Options |
|
|
|
|
|
try: |
|
|
import multiprocessing |
|
|
parallel_compiles = int(multiprocessing.cpu_count() * 1.5) |
|
|
except ImportError: |
|
|
multiprocessing = None |
|
|
parallel_compiles = 0 |
|
|
|
|
|
|
|
|
class _FakePool(object): |
|
|
def map_async(self, func, args): |
|
|
try: |
|
|
from itertools import imap |
|
|
except ImportError: |
|
|
imap=map |
|
|
for _ in imap(func, args): |
|
|
pass |
|
|
|
|
|
def close(self): |
|
|
pass |
|
|
|
|
|
def terminate(self): |
|
|
pass |
|
|
|
|
|
def join(self): |
|
|
pass |
|
|
|
|
|
|
|
|
def parse_directives(option, name, value, parser): |
|
|
dest = option.dest |
|
|
old_directives = dict(getattr(parser.values, dest, |
|
|
Options.get_directive_defaults())) |
|
|
directives = Options.parse_directive_list( |
|
|
value, relaxed_bool=True, current_settings=old_directives) |
|
|
setattr(parser.values, dest, directives) |
|
|
|
|
|
|
|
|
def parse_options(option, name, value, parser): |
|
|
dest = option.dest |
|
|
options = dict(getattr(parser.values, dest, {})) |
|
|
for opt in value.split(','): |
|
|
if '=' in opt: |
|
|
n, v = opt.split('=', 1) |
|
|
v = v.lower() not in ('false', 'f', '0', 'no') |
|
|
else: |
|
|
n, v = opt, True |
|
|
options[n] = v |
|
|
setattr(parser.values, dest, options) |
|
|
|
|
|
|
|
|
def parse_compile_time_env(option, name, value, parser): |
|
|
dest = option.dest |
|
|
old_env = dict(getattr(parser.values, dest, {})) |
|
|
new_env = Options.parse_compile_time_env(value, current_settings=old_env) |
|
|
setattr(parser.values, dest, new_env) |
|
|
|
|
|
|
|
|
def find_package_base(path): |
|
|
base_dir, package_path = os.path.split(path) |
|
|
while os.path.isfile(os.path.join(base_dir, '__init__.py')): |
|
|
base_dir, parent = os.path.split(base_dir) |
|
|
package_path = '%s/%s' % (parent, package_path) |
|
|
return base_dir, package_path |
|
|
|
|
|
|
|
|
def cython_compile(path_pattern, options): |
|
|
pool = None |
|
|
all_paths = map(os.path.abspath, extended_iglob(path_pattern)) |
|
|
try: |
|
|
for path in all_paths: |
|
|
if options.build_inplace: |
|
|
base_dir = path |
|
|
while not os.path.isdir(base_dir) or is_package_dir(base_dir): |
|
|
base_dir = os.path.dirname(base_dir) |
|
|
else: |
|
|
base_dir = None |
|
|
|
|
|
if os.path.isdir(path): |
|
|
|
|
|
paths = [os.path.join(path, '**', '*.{py,pyx}')] |
|
|
else: |
|
|
|
|
|
paths = [path] |
|
|
|
|
|
ext_modules = cythonize( |
|
|
paths, |
|
|
nthreads=options.parallel, |
|
|
exclude_failures=options.keep_going, |
|
|
exclude=options.excludes, |
|
|
compiler_directives=options.directives, |
|
|
compile_time_env=options.compile_time_env, |
|
|
force=options.force, |
|
|
quiet=options.quiet, |
|
|
depfile=options.depfile, |
|
|
**options.options) |
|
|
|
|
|
if ext_modules and options.build: |
|
|
if len(ext_modules) > 1 and options.parallel > 1: |
|
|
if pool is None: |
|
|
try: |
|
|
pool = multiprocessing.Pool(options.parallel) |
|
|
except OSError: |
|
|
pool = _FakePool() |
|
|
pool.map_async(run_distutils, [ |
|
|
(base_dir, [ext]) for ext in ext_modules]) |
|
|
else: |
|
|
run_distutils((base_dir, ext_modules)) |
|
|
except: |
|
|
if pool is not None: |
|
|
pool.terminate() |
|
|
raise |
|
|
else: |
|
|
if pool is not None: |
|
|
pool.close() |
|
|
pool.join() |
|
|
|
|
|
|
|
|
def run_distutils(args): |
|
|
base_dir, ext_modules = args |
|
|
script_args = ['build_ext', '-i'] |
|
|
cwd = os.getcwd() |
|
|
temp_dir = None |
|
|
try: |
|
|
if base_dir: |
|
|
os.chdir(base_dir) |
|
|
temp_dir = tempfile.mkdtemp(dir=base_dir) |
|
|
script_args.extend(['--build-temp', temp_dir]) |
|
|
setup( |
|
|
script_name='setup.py', |
|
|
script_args=script_args, |
|
|
ext_modules=ext_modules, |
|
|
) |
|
|
finally: |
|
|
if base_dir: |
|
|
os.chdir(cwd) |
|
|
if temp_dir and os.path.isdir(temp_dir): |
|
|
shutil.rmtree(temp_dir) |
|
|
|
|
|
|
|
|
def parse_args(args): |
|
|
from optparse import OptionParser |
|
|
parser = OptionParser(usage='%prog [options] [sources and packages]+') |
|
|
|
|
|
parser.add_option('-X', '--directive', metavar='NAME=VALUE,...', |
|
|
dest='directives', default={}, type="str", |
|
|
action='callback', callback=parse_directives, |
|
|
help='set a compiler directive') |
|
|
parser.add_option('-E', '--compile-time-env', metavar='NAME=VALUE,...', |
|
|
dest='compile_time_env', default={}, type="str", |
|
|
action='callback', callback=parse_compile_time_env, |
|
|
help='set a compile time environment variable') |
|
|
parser.add_option('-s', '--option', metavar='NAME=VALUE', |
|
|
dest='options', default={}, type="str", |
|
|
action='callback', callback=parse_options, |
|
|
help='set a cythonize option') |
|
|
parser.add_option('-2', dest='language_level', action='store_const', const=2, default=None, |
|
|
help='use Python 2 syntax mode by default') |
|
|
parser.add_option('-3', dest='language_level', action='store_const', const=3, |
|
|
help='use Python 3 syntax mode by default') |
|
|
parser.add_option('--3str', dest='language_level', action='store_const', const='3str', |
|
|
help='use Python 3 syntax mode by default') |
|
|
parser.add_option('-a', '--annotate', dest='annotate', action='store_true', |
|
|
help='generate annotated HTML page for source files') |
|
|
|
|
|
parser.add_option('-x', '--exclude', metavar='PATTERN', dest='excludes', |
|
|
action='append', default=[], |
|
|
help='exclude certain file patterns from the compilation') |
|
|
|
|
|
parser.add_option('-b', '--build', dest='build', action='store_true', |
|
|
help='build extension modules using distutils') |
|
|
parser.add_option('-i', '--inplace', dest='build_inplace', action='store_true', |
|
|
help='build extension modules in place using distutils (implies -b)') |
|
|
parser.add_option('-j', '--parallel', dest='parallel', metavar='N', |
|
|
type=int, default=parallel_compiles, |
|
|
help=('run builds in N parallel jobs (default: %d)' % |
|
|
parallel_compiles or 1)) |
|
|
parser.add_option('-f', '--force', dest='force', action='store_true', |
|
|
help='force recompilation') |
|
|
parser.add_option('-q', '--quiet', dest='quiet', action='store_true', |
|
|
help='be less verbose during compilation') |
|
|
|
|
|
parser.add_option('--lenient', dest='lenient', action='store_true', |
|
|
help='increase Python compatibility by ignoring some compile time errors') |
|
|
parser.add_option('-k', '--keep-going', dest='keep_going', action='store_true', |
|
|
help='compile as much as possible, ignore compilation failures') |
|
|
parser.add_option('-M', '--depfile', action='store_true', help='produce depfiles for the sources') |
|
|
|
|
|
options, args = parser.parse_args(args) |
|
|
if not args: |
|
|
parser.error("no source files provided") |
|
|
if options.build_inplace: |
|
|
options.build = True |
|
|
if multiprocessing is None: |
|
|
options.parallel = 0 |
|
|
if options.language_level: |
|
|
assert options.language_level in (2, 3, '3str') |
|
|
options.options['language_level'] = options.language_level |
|
|
return options, args |
|
|
|
|
|
|
|
|
def main(args=None): |
|
|
options, paths = parse_args(args) |
|
|
|
|
|
if options.lenient: |
|
|
|
|
|
Options.error_on_unknown_names = False |
|
|
Options.error_on_uninitialized = False |
|
|
|
|
|
if options.annotate: |
|
|
Options.annotate = True |
|
|
|
|
|
for path in paths: |
|
|
cython_compile(path, options) |
|
|
|
|
|
|
|
|
if __name__ == '__main__': |
|
|
main() |
|
|
|
