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:')
def parse_command_line(self): """Parse the utility's command line, taken from the 'script_args' instance attribute (which defaults to 'sys.argv[1:]'. This list is first processed for "global options" -- options that set attributes of the CMDHelper instance. Then, it is alternately scanned for command line 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 CMDHelperGetoptError; any error on the command-line raises CMDHelperArgError. If no cmdhelper commands were found on the command line, raises CMDHelperArgError. 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() # 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) 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 # Handle the cases of --help as a "global" option, ie. # "some_utility.py --help" and "some_utility.py --help command ...". # For the former, we show global options (--verbose, --dry-run, etc.) # and display-only options (--help-commands, etc.); for the # latter, we omit the display-only options and show help for # each command listed on the command line. if self.help or not self.commands: self._show_help(parser, display_options=len(self.commands) == 0, commands=self.commands) return # 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 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_formats(): """Print list of available formats (arguments to "--format" option). """ 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:")
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): e = get_exception() 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 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() pretty_printer = FancyGetopt(formats) pretty_printer.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"). """ 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 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 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 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 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 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, args): """Parse the setup script's command line. 'args' must be a list of command-line arguments, most likely 'sys.argv[1:]' (see the 'setup()' function). 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 were 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 (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(): 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 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 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 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
"""distutils.dist
"""distutils.ccompiler
"""distutils.command.sdist
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 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() if sys.platform == "mac": import EasyDialogs cmdlist = self.get_command_list() self.script_args = EasyDialogs.GetArgv(toplevel_options + self.display_options, cmdlist) # 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 # 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
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 atexit import tempfile dummy_name = tempfile.mktemp()+'__dummy' dummy = open(dummy_name+'.f','w') dummy.write(" subroutine dummy()\n end\n") dummy.close()
"""distutils.command.bdist
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 dummy_fortran_file(): fo, name = make_temp_file(suffix='.f') fo.write(" subroutine dummy()\n end\n") fo.close() return name[:-2]
("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. """
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 dummy_fortran_file(): fo, name = make_temp_file(suffix='.f') fo.write(" subroutine dummy()\n end\n") fo.close() return name[:-2]
def runit(cmd,usage): if cmd not in ['sdist_dsc','bdist_deb']: raise ValueError('unknown command %r'%cmd) # process command-line options bool_opts = 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: 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
# 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
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
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): e = get_exception() 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.")
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):
import glob import os.path import sys from distutils.command.install import INSTALL_SCHEMES from distutils.errors import DistutilsArgError from distutils.fancy_getopt import FancyGetopt import numpy from setuptools import Extension, find_packages, setup from setuptools.command.build_ext import build_ext 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 DistutilsArgError: pass
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:
def runit(): # process command-line options bool_opts = map(translate_longopt, stdeb_cmd_bool_opts) bool_opts.append("process-dependencies") parser = FancyGetopt(stdeb_cmdline_opts + [("help", "h", "show detailed help message")] + EXTRA_OPTS) optobj = OptObj() args = parser.getopt(object=optobj) idx = PackageIndex() 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 + EXTRA_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] package = None 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): for ext in EXTENSIONS: if sdist_file.endswith(ext): raise IOError, "File not found" package = Requirement.parse(sdist_file) log.info("Package %s not found, trying PyPI..." % sdist_file) dist = idx.fetch_distribution(package, final_dist_dir, force_scan=True, source=True) if hasattr(dist, "location"): sdist_file = dist.location else: raise Exception, "Distribution not found on PyPi" log.info("Got %s", sdist_file) dist = list(distros_for_filename(sdist_file))[0] idx.scan_egg_links(dist.location) package = idx.obtain(Requirement.parse(dist.project_name)) if hasattr(optobj, "process_dependencies"): if bool(int(getattr(optobj, "process_dependencies"))): backup_argv = sys.argv[:] oldargv = sys.argv[:] oldargv.pop(-1) if package.requires(): log.info("Processing package dependencies for %s", package) for req in package.requires(): # print >> sys.stderr new_argv = oldargv + ["%s" % req] log.info("Bulding dependency package %s", req) log.info(" running '%s'", " ".join(new_argv)) sys.argv = new_argv runit() # print >> sys.stderr if package.requires(): log.info("Completed building dependencies " "for %s, continuing...", package) sys.argv = backup_argv if package is not None and hasattr(optobj, "extra_cfg_file"): # Allow one to have patch-files setup on config file for example local_parser = SafeConfigParser() local_parser.readfp(open(optobj.__dict__.get("extra_cfg_file"))) if local_parser.has_section(package.project_name): for opt in local_parser.options(package.project_name): _opt = opt.replace("_", "-") if parser.has_option(_opt) or parser.has_option(_opt + "="): setattr(optobj, opt, local_parser.get(package.project_name, opt)) 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=", "process-dependencies"]: 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") args = [ sys.executable, "-c", "import stdeb, sys; f='setup.py'; " + "sys.argv[0]=f; execfile(f,{'__file__':f,'__name__':'__main__'})", "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: 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
(opt,) = get_config_vars('OPT') os.environ['OPT'] = " ".join( flag for flag in opt.split() if flag != '-Wstrict-prototypes' ) import commands cliopts =[] cliopts.append(("boostlibdir=",None,"BOOST library path")) cliopts.append(("boostincdir=",None,"BOOST header path")) cliopts.append(("with-debug",None,"append debuging options")) cliopts.append(("with-cpp11",None,"add C++11 support")) cliopts.append(("plugin-path=",None,"sets the default plugin search path")) op = FancyGetopt(option_table=cliopts) args,opts = op.getopt() debug = False cpp_11_support = False default_plugin_path = "/usr/lib/cdma/plugins" for o,v in op.get_option_order(): if o == "with-debug": debug = True if o == "boostlibdir": boost_library_dir = v if o == "boostincdir": boost_inc_dir = v