def show_fcompilers(dist=None): """Print list of available compilers (used by the "--help-fcompiler" option to "config_fc"). """ if dist is None: from distutils.dist import Distribution from numpy.distutils.command.config_compiler import config_fc dist = Distribution() dist.script_name = os.path.basename(sys.argv[0]) dist.script_args = ['config_fc'] + sys.argv[1:] try: dist.script_args.remove('--help-fcompiler') except ValueError: pass dist.cmdclass['config_fc'] = config_fc dist.parse_config_files() dist.parse_command_line() compilers = [] compilers_na = [] compilers_ni = [] if not fcompiler_class: load_all_fcompiler_classes() platform_compilers = available_fcompilers_for_platform() for compiler in platform_compilers: v = None log.set_verbosity(-2) try: c = new_fcompiler(compiler=compiler, verbose=dist.verbose) c.customize(dist) v = c.get_version() except (DistutilsModuleError, CompilerNotFound) as e: log.debug("show_fcompilers: %s not found" % (compiler, )) log.debug(repr(e)) if v is None: compilers_na.append( ("fcompiler=" + compiler, None, fcompiler_class[compiler][2])) else: c.dump_properties() compilers.append(("fcompiler=" + compiler, None, fcompiler_class[compiler][2] + ' (%s)' % v)) compilers_ni = list(set(fcompiler_class.keys()) - set(platform_compilers)) compilers_ni = [("fcompiler=" + fc, None, fcompiler_class[fc][2]) for fc in compilers_ni] compilers.sort() compilers_na.sort() compilers_ni.sort() pretty_printer = FancyGetopt(compilers) pretty_printer.print_help("Fortran compilers found:") pretty_printer = FancyGetopt(compilers_na) pretty_printer.print_help("Compilers available for this " "platform, but not found:") if compilers_ni: pretty_printer = FancyGetopt(compilers_ni) pretty_printer.print_help("Compilers not available on this platform:") print("For compiler details, run 'config_fc --verbose' setup command.")
def parse_command_line(self): # # We now have enough information to show the Macintosh dialog # that allows the user to interactively specify the "command line". # toplevel_options = self._get_toplevel_options() # We have to parse the command line a bit at a time -- global # options, then the first command, then its options, and so on -- # because each command will be handled by a different class, and # the options that are valid for a particular class aren't known # until we have loaded the command class, which doesn't happen # until we know what the command is. self.commands = [] parser = FancyGetopt(toplevel_options + self.display_options) parser.set_negative_aliases(self.negative_opt) parser.set_aliases({'licence': 'license'}) args = parser.getopt(args=self.script_args, object=self) option_order = parser.get_option_order() log.set_verbosity(self.verbose) # for display options we return immediately if self.handle_display_options(option_order): return while args: args = self._parse_command_opts(parser, args) if args is None: # user asked for help (and got it) return # All is well: return true return True
def parse_command_line(self): toplevel_options = self._get_toplevel_options() self.commands = [] parser = FancyGetopt(toplevel_options + self.display_options) parser.set_negative_aliases(self.negative_opt) parser.set_aliases({'licence': 'license'}) args = parser.getopt(args=self.script_args, object=self) option_order = parser.get_option_order() log.set_verbosity(self.verbose) if self.handle_display_options(option_order): return else: while args: args = self._parse_command_opts(parser, args) if args is None: return if self.help: self._show_help(parser, display_options=len(self.commands) == 0, commands=self.commands) return if not self.commands: raise DistutilsArgError, 'no commands supplied' return 1
def parse_command_line(self): """Parse the setup script's command line, taken from the 'script_args' instance attribute (which defaults to 'sys.argv[1:]' -- see 'setup()' in core.py). This list is first processed for "global options" -- options that set attributes of the Distribution instance. Then, it is alternately scanned for Distutils commands and options for that command. Each new command terminates the options for the previous command. The allowed options for a command are determined by the 'user_options' attribute of the command class -- thus, we have to be able to load command classes in order to parse the command line. Any error in that 'options' attribute raises DistutilsGetoptError; any error on the command-line raises DistutilsArgError. If no Distutils commands were found on the command line, raises DistutilsArgError. Return true if command-line was successfully parsed and we should carry on with executing commands; false if no errors but we shouldn't execute commands (currently, this only happens if user asks for help). """ # We have to parse the command line a bit at a time -- global # options, then the first command, then its options, and so on -- # because each command will be handled by a different class, and # the options that are valid for a particular class aren't known # until we have loaded the command class, which doesn't happen # until we know what the command is. self.commands = [] parser = FancyGetopt(self.global_options + self.display_options) parser.set_negative_aliases(self.negative_opt) parser.set_aliases({'license': 'licence'}) args = parser.getopt(args=self.script_args, object=self) option_order = parser.get_option_order() # for display options we return immediately if self.handle_display_options(option_order): return while args: args = self._parse_command_opts(parser, args) if args is None: # user asked for help (and got it) return # Handle the cases of --help as a "global" option, ie. # "setup.py --help" and "setup.py --help command ...". For the # former, we show global options (--verbose, --dry-run, etc.) # and display-only options (--name, --version, etc.); for the # latter, we omit the display-only options and show help for # each command listed on the command line. if self.help: self._show_help(parser, display_options=len(self.commands) == 0, commands=self.commands) return # Oops, no commands found -- an end-user error if not self.commands: raise DistutilsArgError, "no commands supplied" # All is well: return true return 1
def show_formats(): """Print list of available formats (arguments to "--format" option).""" from distutils.fancy_getopt import FancyGetopt formats = [] for fmt in bdist.format_commands: formats.append(("formats=" + fmt, None, bdist.format_command[fmt][1])) pretty_printer = FancyGetopt(formats) pretty_printer.print_help("List of available distribution formats:")
def show_formats(): from distutils.fancy_getopt import FancyGetopt from distutils.archive_util import ARCHIVE_FORMATS formats = [] for format in ARCHIVE_FORMATS.keys(): formats.append(('formats=' + format, None, ARCHIVE_FORMATS[format][2])) formats.sort() FancyGetopt(formats).print_help('List of available source distribution formats:') return
def show_formats(): from distutils.fancy_getopt import FancyGetopt formats = [] for format in bdist.format_commands: formats.append( ('formats=' + format, None, bdist.format_command[format][1])) pretty_printer = FancyGetopt(formats) pretty_printer.print_help('List of available distribution formats:') return
def show_compilers(): from distutils.fancy_getopt import FancyGetopt compilers = [] for compiler in compiler_class.keys(): compilers.append( ('compiler=' + compiler, None, compiler_class[compiler][2])) compilers.sort() pretty_printer = FancyGetopt(compilers) pretty_printer.print_help('List of available compilers:') return
def show_compilers(): """Print list of available compilers (used by the "--help-compiler" options to "build", "build_ext", "build_clib"). """ from distutils.fancy_getopt import FancyGetopt compilers = [] for compiler in compiler_class.keys(): compilers.append( ('compiler=' + compiler, None, compiler_class[compiler][2])) compilers.sort() pretty_printer = FancyGetopt(compilers) pretty_printer.print_help('List of available compilers:')
def show_formats(): """Print all possible values for the 'formats' option (used by the "--help-formats" command-line option). """ from distutils.fancy_getopt import FancyGetopt from distutils.archive_util import ARCHIVE_FORMATS formats = [] for format in ARCHIVE_FORMATS.keys(): formats.append(("formats=" + format, None, ARCHIVE_FORMATS[format][2])) formats.sort() FancyGetopt(formats).print_help( "List of available source distribution formats:")
def show_compilers(): """Print list of available compilers (used by the "--help-compiler" options to "build", "build_ext", "build_clib"). """ # XXX this "knows" that the compiler option it's describing is # "--compiler", which just happens to be the case for the three # commands that use it. from distutils.fancy_getopt import FancyGetopt compilers = [] for compiler in compiler_class.keys(): compilers.append( ("compiler=" + compiler, None, compiler_class[compiler][2])) compilers.sort() pretty_printer = FancyGetopt(compilers) pretty_printer.print_help("List of available compilers:")
def dump_properties(self): """Print out the attributes of a compiler instance.""" props = [] for key in list(self.executables.keys()) + \ ['version','libraries','library_dirs', 'object_switch','compile_switch']: if hasattr(self, key): v = getattr(self, key) props.append((key, None, '= ' + repr(v))) props.sort() pretty_printer = FancyGetopt(props) for l in pretty_printer.generate_help("%s instance properties:" \ % (self.__class__.__name__)): if l[:4] == ' --': l = ' ' + l[4:] print(l)
def parse_command_line(self): """Parse the setup script's command line, taken from the 'script_args' instance attribute (which defaults to 'sys.argv[1:]' -- see 'setup()' in core.py). This list is first processed for "global options" -- options that set attributes of the Distribution instance. Then, it is alternately scanned for Distutils commands and options for that command. Each new command terminates the options for the previous command. The allowed options for a command are determined by the 'user_options' attribute of the command class -- thus, we have to be able to load command classes in order to parse the command line. Any error in that 'options' attribute raises DistutilsGetoptError; any error on the command-line raises DistutilsArgError. If no Distutils commands were found on the command line, raises DistutilsArgError. Return true if command-line was successfully parsed and we should carry on with executing commands; false if no errors but we shouldn't execute commands (currently, this only happens if user asks for help). """ toplevel_options = self._get_toplevel_options() self.commands = [] parser = FancyGetopt(toplevel_options + self.display_options) parser.set_negative_aliases(self.negative_opt) parser.set_aliases({'licence': 'license'}) args = parser.getopt(args=self.script_args, object=self) option_order = parser.get_option_order() log.set_verbosity(self.verbose) if self.handle_display_options(option_order): return else: while args: args = self._parse_command_opts(parser, args) if args is None: return if self.help: self._show_help(parser, display_options=len(self.commands) == 0, commands=self.commands) return if not self.commands: raise DistutilsArgError, 'no commands supplied' return 1
def show_formats(): DOC_FORMATS = { 'html': (BuildDocs, [], "(default) create folder 'build/docs/html' " "with html documentation"), 'latex': (BuildDocs, [], "create folder 'build/docs/latex' with latex " "source files "), 'pdf': (BuildDocs, [], "make pdf file from generated latex in " "'build/docs/latex'. requires latex install with pdflatex command"), 'html,latex,...': (None, [], "generate more than one format"), 'all': (BuildDocs, [], "build html, latex, and pdf") } from distutils.fancy_getopt import FancyGetopt formats = [] for format in DOC_FORMATS.keys(): formats.append(("formats=" + format, None, DOC_FORMATS[format][2])) formats.sort() pretty_printer = FancyGetopt(formats) pretty_printer.print_help("Available doc formats:")
def dump_properties(self): """Print out the attributes of a compiler instance.""" props = [] for key in list(self.executables.keys()) + [ "version", "libraries", "library_dirs", "object_switch", "compile_switch", ]: if hasattr(self, key): v = getattr(self, key) props.append((key, None, "= " + repr(v))) props.sort() pretty_printer = FancyGetopt(props) for l in pretty_printer.generate_help("%s instance properties:" % (self.__class__.__name__)): if l[:4] == " --": l = " " + l[4:] print(l)
def runit(cmd, usage): if cmd not in ['sdist_dsc', 'bdist_deb']: raise ValueError('unknown command %r' % cmd) # process command-line options bool_opts = list(map(translate_longopt, stdeb_cmd_bool_opts)) parser = FancyGetopt(stdeb_cmdline_opts + [ ('help', 'h', "show detailed help message"), ]) optobj = OptObj() args = parser.getopt(object=optobj) for option in optobj.__dict__: value = getattr(optobj, option) is_string = type(value) == str if option in bool_opts and is_string: setattr(optobj, option, strtobool(value)) if hasattr(optobj, 'help'): print(usage) parser.set_option_table(stdeb_cmdline_opts) parser.print_help("Options:") return 0 if len(args) != 1: log.error('not given single argument (distfile), args=%r', args) print(usage) return 1 sdist_file = args[0] final_dist_dir = optobj.__dict__.get('dist_dir', 'deb_dist') tmp_dist_dir = os.path.join(final_dist_dir, 'tmp_py2dsc') if os.path.exists(tmp_dist_dir): shutil.rmtree(tmp_dist_dir) os.makedirs(tmp_dist_dir) if not os.path.isfile(sdist_file): log.error("Package %s not found." % sdist_file) sys.exit(1) patch_file = optobj.__dict__.get('patch_file', None) patch_level = int(optobj.__dict__.get('patch_level', 0)) patch_posix = int(optobj.__dict__.get('patch_posix', 0)) expand_dir = os.path.join(tmp_dist_dir, 'stdeb_tmp') if os.path.exists(expand_dir): shutil.rmtree(expand_dir) if not os.path.exists(tmp_dist_dir): os.mkdir(tmp_dist_dir) os.mkdir(expand_dir) expand_sdist_file(os.path.abspath(sdist_file), cwd=expand_dir) # now the sdist package is expanded in expand_dir expanded_root_files = os.listdir(expand_dir) assert len(expanded_root_files) == 1 repackaged_dirname = expanded_root_files[0] fullpath_repackaged_dirname = os.path.join(tmp_dist_dir, repackaged_dirname) base_dir = os.path.join(expand_dir, expanded_root_files[0]) if os.path.exists(fullpath_repackaged_dirname): # prevent weird build errors if this dir exists shutil.rmtree(fullpath_repackaged_dirname) os.renames(base_dir, fullpath_repackaged_dirname) del base_dir # no longer useful ############################################## if patch_file is not None: log.info('py2dsc applying patch %s', patch_file) apply_patch(patch_file, posix=patch_posix, level=patch_level, cwd=fullpath_repackaged_dirname) patch_already_applied = 1 else: patch_already_applied = 0 ############################################## abs_dist_dir = os.path.abspath(final_dist_dir) extra_args = [] for long in parser.long_opts: if long in ['dist-dir=', 'patch-file=']: continue # dealt with by this invocation attr = parser.get_attr_name(long).rstrip('=') if hasattr(optobj, attr): val = getattr(optobj, attr) if attr == 'extra_cfg_file': val = os.path.abspath(val) if long in bool_opts or long.replace('-', '_') in bool_opts: extra_args.append('--%s' % long) else: extra_args.append('--' + long + str(val)) if patch_already_applied == 1: extra_args.append('--patch-already-applied') if cmd == 'bdist_deb': extra_args.append('bdist_deb') args = [ sys.executable, 'setup.py', '--command-packages', 'stdeb.command', 'sdist_dsc', '--dist-dir=%s' % abs_dist_dir, '--use-premade-distfile=%s' % os.path.abspath(sdist_file) ] + extra_args log.info('-=' * 35 + '-') # print >> sys.stderr, '-='*20 # print >> sys.stderr, "Note that the .cfg file(s), if present, have not "\ # "been read at this stage. If options are necessary, pass them "\ # "from the command line" log.info("running the following command in directory: %s\n%s", fullpath_repackaged_dirname, ' '.join(args)) log.info('-=' * 35 + '-') try: returncode = subprocess.call( args, cwd=fullpath_repackaged_dirname, ) except Exception: log.error('ERROR running: %s', ' '.join(args)) log.error('ERROR in %s', fullpath_repackaged_dirname) raise if returncode: log.error('ERROR running: %s', ' '.join(args)) log.error('ERROR in %s', fullpath_repackaged_dirname) # log.error(' stderr: %s'res.stderr.read()) # print >> sys.stderr, 'ERROR running: %s'%(' '.join(args),) # print >> sys.stderr, res.stderr.read() return returncode # raise RuntimeError('returncode %d'%returncode) # result = res.stdout.read().strip() shutil.rmtree(tmp_dist_dir) return returncode
"""distutils.ccompiler
("home=", None, ""), ("install-base=", None, ""), ("install-data=", None, ""), ("install-headers=", None, ""), ("install-lib=", None, ""), ("install-platlib=", None, ""), ("install-purelib=", None, ""), ("install-scripts=", None, ""), ("prefix=", None, ""), ("root=", None, ""), ("user", None, ""), ] # typeshed doesn't permit Tuple[str, None, str], see python/typeshed#3469. _distutils_getopt = FancyGetopt(_options) # type: ignore def parse_distutils_args(args): # type: (List[str]) -> Dict[str, str] """Parse provided arguments, returning an object that has the matched arguments. Any unknown arguments are ignored. """
"""distutils.command.bdist
# Copyright (C) 2010-2016 Dominik Kriegner <*****@*****.**> from setuptools import setup, Extension, find_packages from setuptools.command.build_ext import build_ext from distutils.fancy_getopt import FancyGetopt from distutils.command.install import INSTALL_SCHEMES import glob import os.path import sys import numpy cliopts = [] cliopts.append(("without-openmp", None, "build without OpenMP support")) options = FancyGetopt(option_table=cliopts) # Modify the data install dir to match the source install dir for scheme in INSTALL_SCHEMES.values(): scheme['data'] = scheme['purelib'] # first read all the arguments passed to the script # we need to do this otherwise the --help commands would not work args = sys.argv[1:] try: # search the arguments for options we would like to use # get new args with the custom options stripped away args, opts = options.getopt(args) except: pass
"""distutils.command.sdist
from distutils.core import setup from distutils.extension import Extension from distutils.fancy_getopt import FancyGetopt # Parse options for specsrc lopt = 'specsrc=' sopt = 'z' idopt = 'prefix=' isopt = 'd' ldopt = 'install-lib=' lsopt = 'i' opts = [(lopt, sopt, 'location of spec sources'), (ldopt, lsopt, 'installation directory'), (idopt, isopt, 'installation directory')] args, options = FancyGetopt(opts).getopt() specsrc = "../../.." # default value for specsrc #specsrc = "." # default value for specsrc # if SPECSRC in environment use that if "SPECSRC" in os.environ: specsrc = os.environ["SPECSRC"] # Assing specsrc if it is in option list # then leave a clean sys.argv for distutils try: specsrc = options.specsrc lopt = '--%s%s' % (lopt, specsrc) sopt = '-%s' % sopt if lopt in sys.argv:
except DistutilsModuleError: pass except Exception, msg: log.warn(msg) if v is None: compilers_na.append(("fcompiler="+compiler, None, fcompiler_class[compiler][2])) elif v=='N/A': compilers_ni.append(("fcompiler="+compiler, None, fcompiler_class[compiler][2])) else: compilers.append(("fcompiler="+compiler, None, fcompiler_class[compiler][2] + ' (%s)' % v)) compilers.sort() compilers_na.sort() pretty_printer = FancyGetopt(compilers) pretty_printer.print_help("List of available Fortran compilers:") pretty_printer = FancyGetopt(compilers_na) pretty_printer.print_help("List of unavailable Fortran compilers:") if compilers_ni: pretty_printer = FancyGetopt(compilers_ni) pretty_printer.print_help("List of unimplemented Fortran compilers:") print "For compiler details, run 'config_fc --verbose' setup command." def dummy_fortran_file(): import tempfile dummy_name = tempfile.mktemp()+'__dummy' dummy = open(dummy_name+'.f','w') dummy.write(" subroutine dummy()\n end\n") dummy.close() def rm_file(name=dummy_name,log_threshold=log._global_log.threshold):