def run (self): # Build C file if os.path.exists ("src/compizconfig.pyx"): from Cython.Compiler.Main import compile as cython_compile cython_compile ("src/compizconfig.pyx") # Run regular sdist _sdist.run (self)
def run_cython(self, test_directory, module, targetdir, incdir, annotate, extra_compile_options=None): include_dirs = INCLUDE_DIRS[:] if incdir: include_dirs.append(incdir) source = self.find_module_source_file( os.path.join(test_directory, module + '.pyx')) target = os.path.join(targetdir, self.build_target_filename(module)) if extra_compile_options is None: extra_compile_options = {} try: CompilationOptions except NameError: from Cython.Compiler.Main import CompilationOptions from Cython.Compiler.Main import compile as cython_compile from Cython.Compiler.Main import default_options options = CompilationOptions( default_options, include_path = include_dirs, output_file = target, annotate = annotate, use_listing_file = False, cplus = self.language == 'cpp', language_level = self.language_level, generate_pxi = False, evaluate_tree_assertions = True, **extra_compile_options ) cython_compile(source, options=options, full_module_name=module)
def run(self): try: from Cython.Compiler.Main import compile as cython_compile from Cython.Compiler.Options import extra_warnings except ImportError: raise SystemExit('Cython needs to be installed for this command') directives = dict(extra_warnings) directives['embedsignature'] = True directives['language_level'] = 3 # http://trac.cython.org/cython_trac/ticket/714 directives['warn.maybe_uninitialized'] = False options = {'include_path': [ os.path.join(basedir, 'Include') ], 'recursive': False, 'verbose': True, 'timestamps': False, 'compiler_directives': directives, 'warning_errors': True, 'compile_time_env': {} } for sysname in ('linux', 'freebsd', 'darwin'): print('compiling capi.pyx to capi_%s.c...' % (sysname,)) options['compile_time_env']['TARGET_PLATFORM'] = sysname options['output_file'] = os.path.join(basedir, 'src', 'llfuse', 'capi_%s.c' % (sysname,)) res = cython_compile(os.path.join(basedir, 'src', 'llfuse', 'capi.pyx'), full_module_name='llfuse.capi', **options) if res.num_errors != 0: raise SystemExit('Cython encountered errors.')
def run(self): try: import Cython from Cython.Compiler.Main import compile as cython_compile from Cython.Compiler.Options import extra_warnings except ImportError: raise SystemExit('Cython needs to be installed for this command') from None if LooseVersion(Cython.__version__) < "0.17": raise SystemExit('Found Cython %s, but need 0.17 or newer' % (Cython.__version__,)) directives = dict(extra_warnings) directives['embedsignature'] = True directives['language_level'] = 3 options = { 'recursive': False, 'verbose': True, 'timestamps': False, 'compiler_directives': directives, 'warning_errors': True } # http://trac.cython.org/cython_trac/ticket/714 options['compiler_directives']['warn.maybe_uninitialized'] = False for extension in self.extensions: for file_ in extension.sources: (file_, ext) = os.path.splitext(file_) path = os.path.join(basedir, file_) if ext != '.c': continue if os.path.exists(path + '.pyx'): print('compiling %s to %s' % (file_ + '.pyx', file_ + ext)) res = cython_compile(path + '.pyx', full_module_name=extension.name, **options) if res.num_errors != 0: raise SystemExit('Cython encountered errors.') else: print('%s is up to date' % (file_ + ext,))
def run_cython(cython_file, c_file): assert have_cython msg('Cythonizing %s -> %s', cython_file, c_file) options = CythonCompilationOptions(cython_default_options) options.output_file = c_file try: result = cython_compile([cython_file], options) except (EnvironmentError, PyrexError), e: error_msg(str(e))
def run_cython(self, test_directory, module, targetdir, incdir, annotate): include_dirs = INCLUDE_DIRS[:] if incdir: include_dirs.append(incdir) source = self.find_module_source_file( os.path.join(test_directory, module + '.pyx')) target = os.path.join(targetdir, self.build_target_filename(module)) options = CompilationOptions( pyrex_default_options, include_path = include_dirs, output_file = target, annotate = annotate, use_listing_file = False, cplus = self.language == 'cpp', language_level = self.language_level, generate_pxi = False, evaluate_tree_assertions = True, ) cython_compile(source, options=options, full_module_name=module)
def _compile(code): with NamedTemporaryFile(suffix='.py') as f: f.write(code.encode('utf8')) f.flush() try: from StringIO import StringIO except ImportError: from io import StringIO old_stderr = sys.stderr try: sys.stderr = StringIO() result = cython_compile(f.name, language_level=3) finally: sys.stderr = old_stderr return result
def run(self): try: import Cython from Cython.Compiler.Main import compile as cython_compile from Cython.Compiler.Options import extra_warnings except ImportError: raise SystemExit( 'Cython needs to be installed for this command') from None cython_ver = [int(x) for x in Cython.__version__.split('.')] if cython_ver < [0, 17]: raise SystemExit('Found Cython %s, but need 0.17 or newer' % (Cython.__version__, )) directives = dict(extra_warnings) directives['embedsignature'] = True directives['language_level'] = 3 options = { 'recursive': False, 'verbose': True, 'timestamps': False, 'compiler_directives': directives, 'warning_errors': True } # http://trac.cython.org/cython_trac/ticket/714 options['compiler_directives']['warn.maybe_uninitialized'] = False for extension in self.extensions: for file_ in extension.sources: (file_, ext) = os.path.splitext(file_) path = os.path.join(basedir, file_) if ext != '.c': continue if os.path.exists(path + '.pyx'): print('compiling %s to %s' % (file_ + '.pyx', file_ + ext)) res = cython_compile(path + '.pyx', full_module_name=extension.name, **options) if res.num_errors != 0: raise SystemExit('Cython encountered errors.') else: print('%s is up to date' % (file_ + ext, ))
def cython_sources(self, sources, extension): """ Walk the list of source files in 'sources', looking for Cython source files (.pyx and .py). Run Cython on all that are found, and return a modified 'sources' list with Cython source files replaced by the generated C (or C++) files. """ if PyrexError == None: raise DistutilsPlatformError, \ ("Cython does not appear to be installed " "on platform '%s'") % os.name new_sources = [] pyrex_sources = [] pyrex_targets = {} # Setup create_list and cplus from the extension options if # Cython.Distutils.extension.Extension is used, otherwise just # use what was parsed from the command-line or the configuration file. # cplus will also be set to true is extension.language is equal to # 'C++' or 'c++'. #try: # create_listing = self.pyrex_create_listing or \ # extension.pyrex_create_listing # cplus = self.pyrex_cplus or \ # extension.pyrex_cplus or \ # (extension.language != None and \ # extension.language.lower() == 'c++') #except AttributeError: # create_listing = self.pyrex_create_listing # cplus = self.pyrex_cplus or \ # (extension.language != None and \ # extension.language.lower() == 'c++') create_listing = self.pyrex_create_listing or \ getattr(extension, 'pyrex_create_listing', 0) cplus = self.pyrex_cplus or getattr(extension, 'pyrex_cplus', 0) or \ (extension.language and extension.language.lower() == 'c++') pyrex_gen_pxi = self.pyrex_gen_pxi or getattr(extension, 'pyrex_gen_pxi', 0) # Set up the include_path for the Cython compiler: # 1. Start with the command line option. # 2. Add in any (unique) paths from the extension # pyrex_include_dirs (if Cython.Distutils.extension is used). # 3. Add in any (unique) paths from the extension include_dirs includes = self.pyrex_include_dirs try: for i in extension.pyrex_include_dirs: if not i in includes: includes.append(i) except AttributeError: pass for i in extension.include_dirs: if not i in includes: includes.append(i) # Set the target_ext to '.c'. Cython will change this to '.cpp' if # needed. if cplus: target_ext = '.cpp' else: target_ext = '.c' # Decide whether to drop the generated C files into the temp dir # or the source tree. if not self.inplace and (self.pyrex_c_in_temp or getattr(extension, 'pyrex_c_in_temp', 0)): target_dir = os.path.join(self.build_temp, "pyrex") else: target_dir = None newest_dependency = None for source in sources: (base, ext) = os.path.splitext(os.path.basename(source)) if ext == ".py": # FIXME: we might want to special case this some more ext = '.pyx' if ext == ".pyx": # Cython source file output_dir = target_dir or os.path.dirname(source) new_sources.append(os.path.join(output_dir, base + target_ext)) pyrex_sources.append(source) pyrex_targets[source] = new_sources[-1] elif ext == '.pxi' or ext == '.pxd': if newest_dependency is None \ or newer(source, newest_dependency): newest_dependency = source else: new_sources.append(source) if not pyrex_sources: return new_sources module_name = extension.name for source in pyrex_sources: target = pyrex_targets[source] rebuild = self.force or newer(source, target) if not rebuild and newest_dependency is not None: rebuild = newer(newest_dependency, target) if rebuild: log.info("cythoning %s to %s", source, target) self.mkpath(os.path.dirname(target)) options = CompilationOptions(pyrex_default_options, use_listing_file=create_listing, include_path=includes, output_file=target, cplus=cplus, generate_pxi=pyrex_gen_pxi) result = cython_compile(source, options=options, full_module_name=module_name) return new_sources
def cython_sources(self, sources, extension): """ Walk the list of source files in 'sources', looking for Cython source files (.pyx and .py). Run Cython on all that are found, and return a modified 'sources' list with Cython source files replaced by the generated C (or C++) files. """ if PyrexError == None: raise DistutilsPlatformError, \ ("Cython does not appear to be installed " "on platform '%s'") % os.name new_sources = [] pyrex_sources = [] pyrex_targets = {} # Setup create_list and cplus from the extension options if # Cython.Distutils.extension.Extension is used, otherwise just # use what was parsed from the command-line or the configuration file. # cplus will also be set to true is extension.language is equal to # 'C++' or 'c++'. #try: # create_listing = self.pyrex_create_listing or \ # extension.pyrex_create_listing # cplus = self.pyrex_cplus or \ # extension.pyrex_cplus or \ # (extension.language != None and \ # extension.language.lower() == 'c++') #except AttributeError: # create_listing = self.pyrex_create_listing # cplus = self.pyrex_cplus or \ # (extension.language != None and \ # extension.language.lower() == 'c++') create_listing = self.pyrex_create_listing or \ getattr(extension, 'pyrex_create_listing', 0) cplus = self.pyrex_cplus or getattr(extension, 'pyrex_cplus', 0) or \ (extension.language and extension.language.lower() == 'c++') pyrex_gen_pxi = self.pyrex_gen_pxi or getattr(extension, 'pyrex_gen_pxi', 0) # Set up the include_path for the Cython compiler: # 1. Start with the command line option. # 2. Add in any (unique) paths from the extension # pyrex_include_dirs (if Cython.Distutils.extension is used). # 3. Add in any (unique) paths from the extension include_dirs includes = self.pyrex_include_dirs try: for i in extension.pyrex_include_dirs: if not i in includes: includes.append(i) except AttributeError: pass for i in extension.include_dirs: if not i in includes: includes.append(i) # Set the target_ext to '.c'. Cython will change this to '.cpp' if # needed. if cplus: target_ext = '.cpp' else: target_ext = '.c' # Decide whether to drop the generated C files into the temp dir # or the source tree. if not self.inplace and (self.pyrex_c_in_temp or getattr(extension, 'pyrex_c_in_temp', 0)): target_dir = os.path.join(self.build_temp, "pyrex") else: target_dir = None newest_dependency = None for source in sources: (base, ext) = os.path.splitext(os.path.basename(source)) if ext == ".py": # FIXME: we might want to special case this some more ext = '.pyx' if ext == ".pyx": # Cython source file output_dir = target_dir or os.path.dirname(source) new_sources.append(os.path.join(output_dir, base + target_ext)) pyrex_sources.append(source) pyrex_targets[source] = new_sources[-1] elif ext == '.pxi' or ext == '.pxd': if newest_dependency is None \ or newer(source, newest_dependency): newest_dependency = source else: new_sources.append(source) if not pyrex_sources: return new_sources module_name = extension.name for source in pyrex_sources: target = pyrex_targets[source] rebuild = self.force or newer(source, target) if not rebuild and newest_dependency is not None: rebuild = newer(newest_dependency, target) if rebuild: log.info("cythoning %s to %s", source, target) self.mkpath(os.path.dirname(target)) options = CompilationOptions(pyrex_default_options, use_listing_file = create_listing, include_path = includes, output_file = target, cplus = cplus, generate_pxi = pyrex_gen_pxi) result = cython_compile(source, options=options, full_module_name=module_name) return new_sources
def cython_action(target, source, env): from Cython.Compiler.Main import compile as cython_compile res = cython_compile(str(source[0]))
cython_sources = [ fr0st_package_name + '/_utils.pyx' ] c_sources = [os.path.splitext(x)[0] + '.c' for x in cython_sources] if not os.path.exists(c_sources[0]): # Need to cythonize the source files try: from Cython.Compiler.Main import compile as cython_compile except ImportError: raise RuntimeError("Error: Source needs to be cythonized but Cython is not installed") #TODO: This doesn't honor any of the cython compile options. Meh? for source_file in cython_sources: cython_compile(source_file) ########################################################################### # And some InnoSetup stuff class InnoScript: def __init__(self, name, lib_dir, dist_dir, windows_exe_files = [], lib_files = [], version = "1.0"): self.lib_dir = lib_dir self.dist_dir = dist_dir if not self.dist_dir[-1] in "\\/": self.dist_dir += "\\" self.name = name self.version = version self.windows_exe_files = [self.chop(p) for p in windows_exe_files] self.lib_files = [self.chop(p) for p in lib_files]
def cython_sources(self, sources, extension): """ Walk the list of source files in 'sources', looking for Cython source files (.pyx and .py). Run Cython on all that are found, and return a modified 'sources' list with Cython source files replaced by the generated C (or C++) files. """ try: from Cython.Compiler.Main \ import CompilationOptions, \ default_options as cython_default_options, \ compile as cython_compile from Cython.Compiler.Errors import PyrexError except ImportError: e = sys.exc_info()[1] print("failed to import Cython: %s" % e) raise DistutilsPlatformError("Cython does not appear to be installed") new_sources = [] cython_sources = [] cython_targets = {} # Setup create_list and cplus from the extension options if # Cython.Distutils.extension.Extension is used, otherwise just # use what was parsed from the command-line or the configuration file. # cplus will also be set to true is extension.language is equal to # 'C++' or 'c++'. #try: # create_listing = self.cython_create_listing or \ # extension.cython_create_listing # cplus = self.cython_cplus or \ # extension.cython_cplus or \ # (extension.language != None and \ # extension.language.lower() == 'c++') #except AttributeError: # create_listing = self.cython_create_listing # cplus = self.cython_cplus or \ # (extension.language != None and \ # extension.language.lower() == 'c++') create_listing = self.cython_create_listing or \ getattr(extension, 'cython_create_listing', 0) line_directives = self.cython_line_directives or \ getattr(extension, 'cython_line_directives', 0) no_c_in_traceback = self.no_c_in_traceback or \ getattr(extension, 'no_c_in_traceback', 0) cplus = self.cython_cplus or getattr(extension, 'cython_cplus', 0) or \ (extension.language and extension.language.lower() == 'c++') cython_gen_pxi = self.cython_gen_pxi or getattr(extension, 'cython_gen_pxi', 0) cython_gdb = self.cython_gdb or getattr(extension, 'cython_gdb', False) cython_compile_time_env = self.cython_compile_time_env or \ getattr(extension, 'cython_compile_time_env', None) # Set up the include_path for the Cython compiler: # 1. Start with the command line option. # 2. Add in any (unique) paths from the extension # cython_include_dirs (if Cython.Distutils.extension is used). # 3. Add in any (unique) paths from the extension include_dirs includes = self.cython_include_dirs try: for i in extension.cython_include_dirs: if not i in includes: includes.append(i) except AttributeError: pass for i in extension.include_dirs: if not i in includes: includes.append(i) # Set up Cython compiler directives: # 1. Start with the command line option. # 2. Add in any (unique) entries from the extension # cython_directives (if Cython.Distutils.extension is used). directives = self.cython_directives if hasattr(extension, "cython_directives"): directives.update(extension.cython_directives) # Set the target_ext to '.c'. Cython will change this to '.cpp' if # needed. if cplus: target_ext = '.cpp' else: target_ext = '.c' # Decide whether to drop the generated C files into the temp dir # or the source tree. if not self.inplace and (self.cython_c_in_temp or getattr(extension, 'cython_c_in_temp', 0)): target_dir = os.path.join(self.build_temp, "pyrex") for package_name in extension.name.split('.')[:-1]: target_dir = os.path.join(target_dir, package_name) else: target_dir = None newest_dependency = None for source in sources: (base, ext) = os.path.splitext(os.path.basename(source)) if ext == ".py": # FIXME: we might want to special case this some more ext = '.pyx' if ext == ".pyx": # Cython source file output_dir = target_dir or os.path.dirname(source) new_sources.append(os.path.join(output_dir, base + target_ext)) cython_sources.append(source) cython_targets[source] = new_sources[-1] elif ext == '.pxi' or ext == '.pxd': if newest_dependency is None \ or newer(source, newest_dependency): newest_dependency = source else: new_sources.append(source) if not cython_sources: return new_sources module_name = extension.name for source in cython_sources: target = cython_targets[source] depends = [source] + list(extension.depends or ()) rebuild = self.force or newer_group(depends, target, 'newer') if not rebuild and newest_dependency is not None: rebuild = newer(newest_dependency, target) if rebuild: log.info("cythoning %s to %s", source, target) self.mkpath(os.path.dirname(target)) if self.inplace: output_dir = os.curdir else: output_dir = self.build_lib options = CompilationOptions(cython_default_options, use_listing_file = create_listing, include_path = includes, compiler_directives = directives, output_file = target, cplus = cplus, emit_linenums = line_directives, c_line_in_traceback = not no_c_in_traceback, generate_pxi = cython_gen_pxi, output_dir = output_dir, gdb_debug = cython_gdb, compile_time_env = cython_compile_time_env) result = cython_compile(source, options=options, full_module_name=module_name) else: log.info("skipping '%s' Cython extension (up-to-date)", target) return new_sources
def cython_sources(self, sources, extension): """ Walk the list of source files in 'sources', looking for Cython source files (.pyx and .py). Run Cython on all that are found, and return a modified 'sources' list with Cython source files replaced by the generated C (or C++) files. """ new_sources = [] cython_sources = [] cython_targets = {} # Setup create_list and cplus from the extension options if # Cython.Distutils.extension.Extension is used, otherwise just # use what was parsed from the command-line or the configuration file. # cplus will also be set to true is extension.language is equal to # 'C++' or 'c++'. #try: # create_listing = self.cython_create_listing or \ # extension.cython_create_listing # cplus = self.cython_cplus or \ # extension.cython_cplus or \ # (extension.language != None and \ # extension.language.lower() == 'c++') #except AttributeError: # create_listing = self.cython_create_listing # cplus = self.cython_cplus or \ # (extension.language != None and \ # extension.language.lower() == 'c++') create_listing = self.cython_create_listing or \ getattr(extension, 'cython_create_listing', 0) line_directives = self.cython_line_directives or \ getattr(extension, 'cython_line_directives', 0) no_c_in_traceback = self.no_c_in_traceback or \ getattr(extension, 'no_c_in_traceback', 0) cplus = self.cython_cplus or getattr(extension, 'cython_cplus', 0) or \ (extension.language and extension.language.lower() == 'c++') cython_gen_pxi = self.cython_gen_pxi or getattr( extension, 'cython_gen_pxi', 0) cython_gdb = self.cython_gdb or getattr(extension, 'cython_gdb', False) cython_compile_time_env = self.cython_compile_time_env or \ getattr(extension, 'cython_compile_time_env', None) # Set up the include_path for the Cython compiler: # 1. Start with the command line option. # 2. Add in any (unique) paths from the extension # cython_include_dirs (if Cython.Distutils.extension is used). # 3. Add in any (unique) paths from the extension include_dirs includes = list(self.cython_include_dirs) try: for i in extension.cython_include_dirs: if i not in includes: includes.append(i) except AttributeError: pass # In case extension.include_dirs is a generator, evaluate it and keep # result extension.include_dirs = list(extension.include_dirs) for i in extension.include_dirs: if i not in includes: includes.append(i) # Set up Cython compiler directives: # 1. Start with the command line option. # 2. Add in any (unique) entries from the extension # cython_directives (if Cython.Distutils.extension is used). directives = dict(self.cython_directives) if hasattr(extension, "cython_directives"): directives.update(extension.cython_directives) # Set the target file extension for C/C++ mode. if cplus: target_ext = '.cpp' else: target_ext = '.c' # Decide whether to drop the generated C files into the temp dir # or the source tree. if not self.inplace and (self.cython_c_in_temp or getattr(extension, 'cython_c_in_temp', 0)): target_dir = os.path.join(self.build_temp, "pyrex") for package_name in extension.name.split('.')[:-1]: target_dir = os.path.join(target_dir, package_name) else: target_dir = None newest_dependency = None for source in sources: (base, ext) = os.path.splitext(os.path.basename(source)) if ext == ".py": # FIXME: we might want to special case this some more ext = '.pyx' if ext == ".pyx": # Cython source file output_dir = target_dir or os.path.dirname(source) new_sources.append(os.path.join(output_dir, base + target_ext)) cython_sources.append(source) cython_targets[source] = new_sources[-1] elif ext == '.pxi' or ext == '.pxd': if newest_dependency is None \ or newer(source, newest_dependency): newest_dependency = source else: new_sources.append(source) if not cython_sources: return new_sources try: from Cython.Compiler.Main \ import CompilationOptions, \ default_options as cython_default_options, \ compile as cython_compile from Cython.Compiler.Errors import PyrexError except ImportError: e = sys.exc_info()[1] print("failed to import Cython: %s" % e) raise DistutilsPlatformError( "Cython does not appear to be installed") module_name = extension.name for source in cython_sources: target = cython_targets[source] depends = [source] + list(extension.depends or ()) if (source[-4:].lower() == ".pyx" and os.path.isfile(source[:-3] + "pxd")): depends += [source[:-3] + "pxd"] rebuild = self.force or newer_group(depends, target, 'newer') if not rebuild and newest_dependency is not None: rebuild = newer(newest_dependency, target) if rebuild: log.info("cythoning %s to %s", source, target) self.mkpath(os.path.dirname(target)) if self.inplace: output_dir = os.curdir else: output_dir = self.build_lib options = CompilationOptions( cython_default_options, use_listing_file=create_listing, include_path=includes, compiler_directives=directives, output_file=target, cplus=cplus, emit_linenums=line_directives, c_line_in_traceback=not no_c_in_traceback, generate_pxi=cython_gen_pxi, output_dir=output_dir, gdb_debug=cython_gdb, compile_time_env=cython_compile_time_env) result = cython_compile(source, options=options, full_module_name=module_name) else: log.info("skipping '%s' Cython extension (up-to-date)", target) return new_sources
def from_source(source, name=None, output_dir=None, check=False, keep=False, debug=False, ): out_file = (output_dir / name).add_ext(sysconfig.get_config_var('SO')) protocol = protocol_from_source(source, output_dir) if debug: protocol.set_property(('debug',), debug) temp_dir = Path.from_file(tempfile.gettempdir()) / name if not temp_dir.exists(): temp_dir.makedirs() protocol_data = protocol.data() source_chks = hashlib.sha1(source.encode('utf-8')).hexdigest() protoc_chks = hashlib.sha1(protocol_data.encode('utf-8')).hexdigest() if out_file.exists(): if check: checkfile_name = (output_dir / name).add_ext('.checksum') if checkfile_name.exists(): with checkfile_name.open('rt') as stream: source_ctrl = stream.readline().strip() output_ctrl = stream.readline().strip() protoc_ctrl = stream.readline().strip() with out_file.open('rb') as stream: output_data = stream.read() output_chks = hashlib.sha1(output_data).hexdigest() if (source_chks == source_ctrl and output_chks == output_ctrl and protoc_chks == protoc_ctrl): return False out_file.remove() if name is None: name = protocol.properties.get('package') if name is None: raise NameNotDefined() path = temp_dir / name pyx_file = path.add_ext('.pyx') with pyx_file.open('w') as stream: stream.write(protocol_data) options = CompilationOptions( verbose=True, ) cython_compile(pyx_file.str(), options=options) compiler = distutils.ccompiler.new_compiler(verbose=1) sysconfig.customize_compiler(compiler) if sys.platform == 'win32': protocyt_dir = Path.from_file(__file__).up() compiler.add_include_dir(str(protocyt_dir / 'includes')) libs_dir = Path.from_file(sysconfig.get_config_var('BINDIR')) / 'libs' compiler.add_library_dir(libs_dir.str()) compiler.add_include_dir(sysconfig.get_python_inc()) object_files = compiler.compile([path.add_ext('.c').str()], extra_postargs=['-fPIC'], output_dir=temp_dir.str()) compiler.link_shared_lib(object_files, name, output_dir=temp_dir.str()) compiler.move_file( compiler.library_filename(path.str(), 'shared'), out_file.str() ) if not keep: temp_dir.remove() result = True else: result = temp_dir if check: checkfile_name = (output_dir / name).add_ext('.checksum') with out_file.open('rb') as stream: output_chks = hashlib.sha1(stream.read()).hexdigest() with checkfile_name.open('wt') as stream: stream.write('{0}\n{1}\n{2}\n'.format( source_chks, output_chks, protoc_chks)) return result