Python utility.kwargs_get_boolean函数代码示例

def main(command_name, command_dir, version, description, *args, **kwargs):
#===============================================================================
    """
    Called by running script to execute command with command line arguments.
    """
    # The "package" keyword flags when running from a package zip __main__.py.
    package = utility.kwargs_get_boolean(kwargs, 'package', default=False)
    # The "standalone" keyword allows environment.py to skip the library search.
    standalone = utility.kwargs_get_boolean(kwargs, 'standalone', default=False)
    # The "state_directory" keyword overrides ~/.<command_name> as the
    # directory used for runtime state files.
    state_directory = utility.kwargs_get_string(kwargs, 'state_directory', default=None)
    try:
        # Pre-scan for verbose, debug, and dry-run options so that early code
        # can display verbose and debug messages, and obey dry-run.
        opts = cli.preprocess_options(base_cli_spec.options, args)
        utility.set_verbose(opts.verbose)
        utility.set_debug(opts.debug)

        # Load the configuration and state
        permanent_path = os.path.join(os.getcwd(), environment.config_name)
        local_path     = os.path.join(os.getcwd(), environment.config_name_local)
        config = VoltConfig(permanent_path, local_path)

        # Initialize the environment
        environment.initialize(standalone, command_name, command_dir, version)

        # Initialize the state directory (for runtime state files).
        if state_directory is None:
            state_directory = '~/.%s' % environment.command_name
        state_directory = os.path.expandvars(os.path.expanduser(state_directory))
        utility.set_state_directory(state_directory)

        # Search for modules based on both this file's and the calling script's location.
        verbspace = load_verbspace(command_name, command_dir, config, version,
                                   description, package)

        # Make internal commands available to user commands via runner.verbspace().
        internal_verbspaces = {}
        if command_name not in internal_commands:
            for internal_command in internal_commands:
                internal_verbspace = load_verbspace(internal_command, None, config, version,
                                                    'Internal "%s" command' % internal_command,
                                                    package)
                internal_verbspaces[internal_command] = internal_verbspace

        # Run the command
        run_command(verbspace, internal_verbspaces, config, *args)

    except KeyboardInterrupt:
        sys.stderr.write('\n')
        utility.abort('break')

 def __init__(self, name, help, **kwargs):
     # For now the only intelligence is to check for absolute paths when required.
     # TODO: Add options to check for directories, files, attributes, etc..
     self.absolute = utility.kwargs_get_boolean(kwargs, 'absolute', default = False)
     self.exists   = utility.kwargs_get_boolean(kwargs, 'exists', default = False)
     requirements = []
     if self.absolute:
         requirements.append('absolute path')
     if self.exists:
         requirements.append('must exist')
     if requirements:
         help2 = ' (%s)' % ', '.join(requirements)
     StringArgument.__init__(self, name, help + help2, **kwargs)

 def java_execute(self, java_class, java_opts_override, *args, **kwargs):
     """
     Execute a Java program.
     """
     if utility.kwargs_get_boolean(kwargs, 'daemon', default=False):
         kwargs['daemonizer'] = self._get_daemonizer(**kwargs)
     self.java.execute(java_class, java_opts_override, *args, **kwargs)

 def help(self, *args, **kwargs):
     """
     Display help for command.
     """
     # The only valid keyword argument is 'all' for now.
     context = '%s.help()' % self.__class__.__name__
     all = utility.kwargs_get_boolean(kwargs, 'all', default = False)
     if all:
         for verb_name in self.verbspace.verb_names:
             verb_spec = self.verbspace.verbs[verb_name].cli_spec
             if not verb_spec.baseverb and not verb_spec.hideverb:
                 sys.stdout.write('\n===== Verb: %s =====\n\n' % verb_name)
                 self._print_verb_help(verb_name)
         for verb_name in self.verbspace.verb_names:
             verb_spec = self.verbspace.verbs[verb_name].cli_spec
             if verb_spec.baseverb and not verb_spec.hideverb:
                 sys.stdout.write('\n===== Common Verb: %s =====\n\n' % verb_name)
                 self._print_verb_help(verb_name)
     else:
         if args:
             for name in args:
                 for verb_name in self.verbspace.verb_names:
                     if verb_name == name.lower():
                         sys.stdout.write('\n')
                         self._print_verb_help(verb_name)
                         break
                 else:
                     utility.error('Verb "%s" was not found.' % name)
                     self.usage()
         else:
             self.usage()

 def execute(self, java_class, java_opts_override, *args, **kwargs):
     """
     Run a Java command line with option overrides.
     Supported keyword arguments:
         classpath           Java classpath.
         daemon              Run as background (daemon) process if True.
         daemon_name         Daemon name.
         daemon_description  Daemon description for messages.
         daemon_output       Output directory for PID files and stdout/error capture.
     """
     self.initialize()
     classpath = self.classpath
     kwargs_classpath = kwargs.get('classpath', None)
     if kwargs_classpath:
         classpath = ':'.join((kwargs_classpath, classpath))
     java_args = [environment.java]
     java_opts = utility.merge_java_options(environment.java_opts, java_opts_override)
     java_args.extend(java_opts)
     java_args.append('-Dlog4j.configuration=file://%s' % os.environ['LOG4J_CONFIG_PATH'])
     java_args.append('-Djava.library.path=default')
     java_args.extend(('-classpath', classpath))
     java_args.append(java_class)
     for arg in args:
         if arg is not None:
             java_args.append(arg)
     daemonizer = utility.kwargs_get(kwargs, 'daemonizer')
     if daemonizer:
         # Run as a daemon process. Does not return.
         daemonizer.start_daemon(*java_args)
     elif utility.kwargs_get_boolean(kwargs, 'exec'):
         # Replace the current process. Does not return.
         utility.exec_cmd(*java_args)
     else:
         # Run as a sub-process. Returns when the sub-process exits.
         return utility.run_cmd(*java_args)

 def __init__(self, name, help, **kwargs):
     # For now the only intelligence is to check for absolute paths when required.
     # TODO: Add options to check existence, directories, files, attributes, etc..
     self.absolute = utility.kwargs_get_boolean(kwargs, 'absolute', default = False)
     help2 = help
     if self.absolute:
         help2 += ' (absolute path)'
     StringArgument.__init__(self, name, help2, **kwargs)

 def __init__(self, name, help, **kwargs):
     self.name      = name
     self.help      = help
     self.min_count = kwargs.get('min_count', 1)
     self.max_count = kwargs.get('max_count', 1)
     self.optional = utility.kwargs_get_boolean(kwargs, 'optional', default=False)
     # A max_count value of None is interpreted as infinity.
     if self.max_count is None:
         self.max_count = sys.maxint