def run_command_hooks(cmd_obj, hook_kind): """Run hooks registered for that command and phase. *cmd_obj* is a finalized command object; *hook_kind* is either 'pre_hook' or 'post_hook'. """ if hook_kind not in ('pre_hook', 'post_hook'): raise ValueError('invalid hook kind: %r' % hook_kind) hooks = getattr(cmd_obj, hook_kind, None) if hooks is None: return for hook in hooks.values(): if isinstance(hook, str): try: hook_obj = resolve_name(hook) except ImportError: err = sys.exc_info()[1] # For py3k raise DistutilsModuleError('cannot find hook %s: %s' % (hook,err)) else: hook_obj = hook if not hasattr(hook_obj, '__call__'): raise DistutilsOptionError('hook %r is not callable' % hook) log.info('running %s %s for command %s', hook_kind, hook, cmd_obj.get_command_name()) try : hook_obj(cmd_obj) except: e = sys.exc_info()[1] log.error('hook %s raised exception: %s\n' % (hook, e)) log.error(traceback.format_exc()) sys.exit(1)
def get_command_class(self, command): klass = self.cmdclass.get(command) if klass: return klass for pkgname in self.get_command_packages(): module_name = '%s.%s' % (pkgname, command) klass_name = command try: __import__(module_name) module = sys.modules[module_name] except ImportError: continue try: klass = getattr(module, klass_name) except AttributeError: raise DistutilsModuleError, "invalid command '%s' (no class '%s' in module '%s')" % ( command, klass_name, module_name) self.cmdclass[command] = klass return klass raise DistutilsModuleError("invalid command '%s'" % command)
def get_command_class(self, command): """Return the class that implements the Distutils command named by 'command'. First we check the 'cmdclass' dictionary; if the command is mentioned there, we fetch the class object from the dictionary and return it. Otherwise we load the command module ("distutils.command." + command) and fetch the command class from the module. The loaded class is also stored in 'cmdclass' to speed future calls to 'get_command_class()'. Raises DistutilsModuleError if the expected module could not be found, or if that module does not define the expected class. """ klass = self.cmdclass.get(command) if klass: return klass for pkgname in self.get_command_packages(): module_name = "%s.%s" % (pkgname, command) klass_name = command try: __import__(module_name) module = sys.modules[module_name] except ImportError: continue try: klass = getattr(module, klass_name) except AttributeError: raise DistutilsModuleError, \ "invalid command '%s' (no class '%s' in module '%s')" \ % (command, klass_name, module_name) self.cmdclass[command] = klass return klass raise DistutilsModuleError("invalid command '%s'" % command)
def client(self): try: from botocore.session import get_session except ImportError: raise DistutilsModuleError('botocore is required') return get_session().create_client('s3')
def finalize_options(self): self.extensions = self.distribution.ext_modules # Let Cython generate its files in the "cythonized" # subdirectory of the build_base directory. self.set_undefined_options('build', ('build_base', 'build_base')) self.build_dir = os.path.join(self.build_base, "cythonized") # Inherit some options from the 'build_ext' command if possible # (this in turn implies inheritance from the 'build' command) inherit_opts = [('build_lib', 'build_lib'), ('debug', 'debug'), ('force', 'force')] # Python 3.5 now has a parallel option as well if sys.version_info[:2] >= (3, 5): inherit_opts.append(('parallel', 'parallel')) self.set_undefined_options('build_ext', *inherit_opts) # Always produce debugging output unless SAGE_DEBUG=no is given # explicitly self.debug = os.environ.get('SAGE_DEBUG', None) != 'no' if self.debug: log.info('Enabling Cython debugging support') if self.profile is None: self.profile = os.environ.get('SAGE_PROFILE') == 'yes' if self.profile: log.info('Enabling Cython profiling support') if self.parallel is None: self.parallel = os.environ.get('SAGE_NUM_THREADS', '0') try: self.parallel = int(self.parallel) except ValueError: raise DistutilsOptionError("parallel should be an integer") try: import Cython except ImportError: raise DistutilsModuleError( "Cython must be installed and importable in order to run " "the cythonize command") # Cython compiler directives self.cython_directives = dict( auto_pickle=False, autotestdict=False, cdivision=True, embedsignature=True, fast_getattr=True, language_level="3str", preliminary_late_includes_cy28=True, profile=self.profile, ) self.compile_time_env = dict( PY_PLATFORM=sys.platform, # The following two constants are here only for backwards compatibility of user packages PY_VERSION_HEX=sys.hexversion, PY_MAJOR_VERSION=sys.version_info[0]) # We check the Cython version and some relevant configuration # options from the earlier build to see if we need to force a # recythonization. If the version or options have changed, we # must recythonize all files. self._version_file = os.path.join(self.build_dir, '.cython_version') self._version_stamp = json.dumps( { 'version': Cython.__version__, 'debug': self.debug, 'directives': self.cython_directives, 'compile_time_env': self.compile_time_env, }, sort_keys=True) # Read an already written version file if it exists and compare to the # current version stamp try: if open(self._version_file).read() == self._version_stamp: force = False else: # version_file exists but its contents are not what we # want => recythonize all Cython code. force = True # In case this cythonization is interrupted, we end up # in an inconsistent state with C code generated by # different Cython versions or with different options. # To ensure that this inconsistent state will be fixed, # we remove the version_file now to force a # recythonization the next time we build Sage. os.unlink(self._version_file) except IOError: # Most likely, the version_file does not exist # => (re)cythonize all Cython code. force = True # If the --force flag was given at the command line, always force; # otherwise use what we determined from reading the version file if self.force is None: self.force = force
def run(self): import django import codecs from pootle.apps.pootle_checks.constants import ( CHECK_NAMES, EXCLUDED_FILTERS) from translate.filters.checks import (TeeChecker, StandardChecker, StandardUnitChecker) from translate.lang.factory import get_all_languages try: from docutils.core import publish_parts except ImportError: from distutils.errors import DistutilsModuleError raise DistutilsModuleError("Please install the docutils library.") from pootle import syspath_override # noqa django.setup() def get_check_description(name, filterfunc): """Get a HTML snippet for a specific quality check description. The quality check description is extracted from the check function docstring (which uses reStructuredText) and rendered using docutils to get the HTML snippet. """ # Provide a header with an anchor to refer to. description = ('\n<h3 id="%s">%s</h3>\n\n' % (name, unicode(CHECK_NAMES[name]))) # Clean the leading whitespace on each docstring line so it gets # properly rendered. docstring = "\n".join(line.strip() for line in filterfunc.__doc__.split("\n")) # Render the reStructuredText in the docstring into HTML. description += publish_parts(docstring, writer_name="html")["body"] return description print("Regenerating Translate Toolkit quality checks descriptions") # Get a checker with the Translate Toolkit checks. Note that filters # that are not used in Pootle are excluded. checkerclasses = [StandardChecker, StandardUnitChecker] # Also include language-specific checks checkerclasses.extend([type(lang.checker) for lang in get_all_languages() if lang.checker is not None]) fd = TeeChecker( checkerclasses=checkerclasses ).getfilters(excludefilters=EXCLUDED_FILTERS) docs = sorted( get_check_description(name, f) for name, f in fd.items() ) # Output the quality checks descriptions to the HTML file. templates_dir = os.path.join( os.path.abspath(os.path.dirname(__file__)), "pootle", "templates" ) filename = os.path.join(templates_dir, "help/_ttk_quality_checks.html") with codecs.open(filename, "w", "utf-8") as f: f.write(u"\n".join(docs)) print("Checks templates written to %r" % (filename))
def switchpreference(array_preference): """ Find out if the set preference can be used ... """ have_numeric = 0 have_numarray = 0 have_numpy = 0 use_numeric = 0 use_numarray = 0 use_numpy = 0 try: import numpy have_numpy = 1 except ImportError: pass try: import Numeric have_numeric = 1 except ImportError: pass try: import numarray have_numarray = 1 except ImportError: pass #array_preference = 'numarray' if array_preference != None: if array_preference == 'numpy': if have_numpy == 1: use_numpy = 1 else: sys.stdout.write("Did not find the numpy module you asked for") if array_preference == 'Numeric': sys.stdout.write( "Numeric supported any longer. If you still need it write to [email protected]" ) # if have_numeric == 1: # use_numeric = 1 # else: # sys.stdout.write("Did not find the Numeric module you asked for") elif array_preference == 'numarray': sys.stdout.write( "numarray supported any longer. If you still need it write to [email protected]" ) # if have_numarray == 1: # use_numarray = 1 # else: # sys.stdout.write( "Did not find the numarray module you asked for") if use_numeric == 0 and use_numarray == 0 and use_numpy == 0: if have_numpy == 1: use_numpy = 1 elif have_numarray == 1: use_numarray = 1 elif have_numeric == 1: use_numeric = 1 else: raise DistutilsModuleError( "I need either numpy, nummarray, or Numeric!") if use_numpy == 1: use_numeric = 0 use_numarray = 0 nummodule = "numpy" elif use_numeric == 1: #print "Using Numeric as array Package" use_numpy = 0 use_numarray = 0 nummodule = "Numeric" elif use_numarray == 1: #print "Using nummarray as array Package" use_numeric = 0 use_numpy = 0 nummodule = "numarray" else: raise DistutilsModuleError( "I need either numpy, nummarray or Numeric!") return nummodule
return [] def run(self): if not self.bgen_files: return try: from BisonGen import Main, __version__ except ImportError, err: failure = str(err) else: if MINIMUM_VERSION > StrictVersion(__version__): failure = "found " + __version__ else: failure = None if failure: msg = "%s requires BisonGen %s (%s)" % (self.command_name, MINIMUM_VERSION, failure) raise DistutilsModuleError(msg) outputs = [] args = ['BisonGen', '--mode=c'] if self.force: args.append('--force') if not self.distribution.verbose: args.append('--quiet') for filename in self.bgen_files: outputs.extend(Main.Run(args + [filename])) return
def run(self): raise DistutilsModuleError('babel is not available')