Python argv.pop函数代码示例

def hfst_specific_option(option):
    if option in argv:
        index = argv.index(option)
        argv.pop(index)
        return True
    else:
        return False

	def test_main_with_gui_argument(self):
		argv.append("-g")
		pacsudoku = main()
		with open(self.default_config_file) as rawfile:
			actual_xml_content = rawfile.readlines()
		self.assertEqual([], actual_xml_content)
		argv.pop()
		pacsudoku.config_file.file.close()
		remove(self.default_config_file)

 def _targets_from_argv(self):
     argv.pop(0)  # remove script name
     if not len(argv):
         log.fatal("Nothing to do! Check the documentation and make sure to have a settings file.")
         exit(1)
         return []
     target = {"target_path": argv.pop(0)}
     if len(argv):
         target["backup_dir"] = argv.pop(0)
     yield target

	def test_main_with_valid_config_file(self):
		argv.append("-c")
		argv.append(self.my_config_file)
		pacsudoku = main()
		with open(self.my_config_file) as rawfile:
			actual_xml_content = rawfile.readlines()
		self.assertEqual(self.expected_xml_content, actual_xml_content)
		argv.pop()
		argv.pop()
		pacsudoku.config_file_handler.file.close()

def handle_args(argv):
    
    # Default settings:
    settings = {'root':False, 'port':'22', 'password':'', 'idfile':''}

    argv = argv[1:] # Discard the name of the program.
    for index, arg in enumerate(argv):
        #print(index, arg)
        if arg == '-r':
            settings['root'] = True
        elif arg == '-h':
            try:
                settings['hostname'] = argv.pop(index + 1)
            except IndexError:
                raise InputError('-h takes a positional argument.')
        elif arg == '-i':
            try:
                settings['idfile'] = argv.pop(index + 1)
            except IndexError:
                raise InputError('-i takes a positional argument.')
        elif arg == '-p':
            settings['password'] = True
        elif arg == '--install':
            install() # Not a setting that gets passed along.
            exit() # Also, it's the only thing we'll be doing, in that case.
        elif arg.startswith('-'):
            raise InputError('Unkown option ' + arg)
        # First positional is host.
        elif not 'host' in settings:
            # Check for the presence of a user.
            target = arg.split('@')
            if len(target) == 1:
                target = target[0]
            elif len(target) == 2:
                settings['user'] = target[0]
                target = target[1]
            else:
                raise InputError('Multiple @ symbols in connection string.')
            target = target.split(':')
            settings['host'] = target[0]
            if len(target) == 2:
                settings['port'] = target[1]
            elif len(target) > 2:
                raise InputError('Multiple : symbols in connection string.')
        # Second positional is bastion. or an intermediate host.
        elif not 'bastion' in settings:
            settings['bastion'] = arg
        else:
            raise InputError('Too many arguments')
    if settings['password']:
        settings['password'] = getpass(prompt='Please enter password: ')
    if not 'hostname' in settings:
        settings['hostname'] = settings['host']
    return settings

	def startup(self):
		argv.pop()
		
		p = Process(target=self.startWorker)
		p.start()

		p = Process(target=self.startRESTAPI)
		p.start()
		
		p = Process(target=self.startElasticsearch)
		p.start()

def process_batch_command(argv):
    if len(argv) > 0:
        command = str(argv[0]);
    else:
        command = "help"

    if len(argv) > 0:
        argv.pop(0)
        args = argv
    else:
        args = []

    return process_command(command, args)

def main(*args, **kwargs):
    """
    Upload a file to a Twitter account
    """
    argv.pop(0)
    status = str()
    if argv:
        status = argv.pop()
    unuploaded = True
    while unuploaded:
        try:
            api = create_api(read_keys())
            api.update_with_media("output.png", status)
            unuploaded = False
            print("Successfully uploaded!")
        except Exception as e:
            print("Error: {}".format(e))

def main(argv):
    argv.pop(0)
    entry = Entrypoint(args=argv)
    try:
        entry.exit_if_disabled()
        if not entry.is_handled and not entry.should_config:
            entry.log.warning("Running command without config")
            entry.launch()
        entry.config.set_to_env()
        entry.log.debug("Starting config")
        entry.run_pre_conf_cmds()
        entry.apply_conf()
        entry.run_post_conf_cmds()
        entry.launch()
    except Exception as e:
        entry.log.error(str(e))
        exit(1)

 def _construct(self):
     """
     Construct the argument parser.
     
     lense-devtools build {package} (optional) # Defaults to build all
     """
     self.parser = ArgumentParser(description=self._desc(), formatter_class=RawTextHelpFormatter)
     
     # Main argument
     self.parser.add_argument('command', help=self._command_help())
     
     # Argument flags
     self.parser.add_argument('-p', '--projects', help='A single project or comma seperated list of projects', action='append')
     self.parser.add_argument('-a', '--auto', help='Run in automated mode (avoid prompts)', action='store_true')
     
     # Parse arguments
     argv.pop(0)
     self.storage = vars(self.parser.parse_args(argv))

def main():
    prog = "mr_repo"
    if (len(argv) > 0):
        prog = argv.pop(0)
        # If prog does not look something like Mr. Repo then change it
        if None == re.search('mr(\.|)([-_ ]{0,2})repo', prog,
                flags=re.IGNORECASE):
            prog = "mr_repo"
    #Create an instance of MrRepo
    Repossesser(prog=prog, args=argv, execute=True, one_use=True)

def main_func():

    # Check the number of inputs
    numofinputs = len(sys.argv)

    # Conditional expressions
    if numofinputs > 5 :
        print ("Invalid arguments \nGood BYE")
    else :
        # Get the input arguments
        filename = argv.pop(1) # EXE name, File Name, Module Name
        operation = argv.pop(1) # DEBUG, INFO, WARN, ERROR, CRITICAL, EXCEPTION
        message = argv.pop(1) # Message to be printed
        logFile = argv.pop(1) # Log file

        # setup `logging` module
        logger = logging.getLogger(filename)
        fileHandler = logging.FileHandler('Logger.log')
        logger.setLevel(logging.INFO)
        formatter = logging.Formatter("[%(asctime)s] [%(name)s] : %(message)s")

        # setup `RainbowLoggingHandler`
        handler = RainbowLoggingHandler(sys.stderr, color_name=('grey', None , True),color_asctime=('green', None  , True))
        handler.setFormatter(formatter)
        fileHandler.setFormatter(formatter)
        logger.addHandler(fileHandler)
        logger.addHandler(handler)

        if operation == 'DEBUG' :
            logger.debug(message)
        if operation == 'INFO' :
            logger.info(message)
        if operation == 'WARN' :
            logger.warn(message)
        if operation == 'ERROR' :
            logger.error(message)
        if operation == 'CRITICAL' :
            logger.critical(message)
        if operation == 'EXCEPTION' :
            raise RuntimeError("InstallException!")
            logger.exception(message)
            logger.exception(e)

    def run(self):
        """
        Parse the command-line arguments and call the method corresponding to
        the situation.
        """
        # We're using a custom parser here to handle subcommands.
        argv = self.argv
        argc = len(argv)
        if argc == 0:
            return self.print_help()
        action = argv.pop(0)
        argc -= 1
        if action in HELP_FLAGS:
            self.print_version()
            return self.print_help()
        if action in ('-v', '-version', '--version'):
            return self.print_version()

        # Subcommands are defined as below:
        #   def action_some_keyword(self, ...)
        # defines an action 'some:keyword'. We might need to use classes for
        # subcommands like Thor (Ruby gem), but it'd be too much overhead for
        # now.
        name = 'action_%s' % action.replace(':', '_')
        if not hasattr(self, name):
            print("Unrecognized action '%s'" % action)
            return self.print_help()

        fun = getattr(self, name)

        # dynamically check if enough arguments were given on the command line
        spec = inspect.getargspec(fun)
        # skip 'self'
        spec_args = (spec.args or ())[1:]
        spec_defaults = spec.defaults or ()
        defaults_len = len(spec_defaults)
        required_len = len(spec_args) - defaults_len

        if argc < required_len or (argc > 0 and argv[0] in HELP_FLAGS):
            defaults = list(reversed(spec_args))[:defaults_len]
            args = []
            for arg in spec_args:
                fmt = '<%s>'
                if arg in defaults:
                    fmt = '[%s]' % fmt
                args.append(fmt % arg)

            if spec.varargs:
                args.append('[<%s...>]' % spec.varargs)

            print("Usage:\n\t%s %s %s" % (self.exe, action, ' '.join(args)))
            return False

        return fun(*argv)

def main():
  success = True
  argv.pop(0)

  if not argv:
    help()
    success = False

  while (argv):
    init_dir()
    command = argv.pop(0)

    if not command in commands:
      help();
      success = False
      break
    returncode = commands[command][0]()
    success = success and not bool(returncode)

  sys.exit(not success)

def main():
  success = True
  argv.pop(0)

  if not argv:
    help()
    success = False

  while (argv):
    # Make sure that we're always rooted in the dart root folder.
    os.chdir(dart_dir)
    command = argv.pop(0)

    if not command in commands:
      help();
      success = False
      break
    returncode = commands[command][0]()
    success = success and not bool(returncode)

  sys.exit(not success)