Inheritance diagram for argparse.ArgumentParser:

Public Member Functions
def	__init__ (self, prog=None, usage=None, description=None, epilog=None, version=None, parents=[], formatter_class=HelpFormatter, prefix_chars='-', fromfile_prefix_chars=None, argument_default=None, conflict_handler='error', add_help=True)

def	add_subparsers (self, kwargs)

def	error (self, message)

def	exit (self, status=0, message=None)

def	format_help (self)

def	format_usage (self)

def	format_version (self)

def	parse_args (self, args=None, namespace=None)

def	parse_known_args (self, args=None, namespace=None)

def	print_help (self, file=None)

def	print_usage (self, file=None)

def	print_version (self, file=None)

Public Member Functions inherited from argparse._AttributeHolder
def	__repr__ (self)

Public Member Functions inherited from argparse._ActionsContainer
def	__init__ (self, description, prefix_chars, argument_default, conflict_handler)

def	add_argument (self, args, kwargs)

def	add_argument_group (self, args, kwargs)

def	add_mutually_exclusive_group (self, kwargs)

def	register (self, registry_name, value, object)

def	set_defaults (self, kwargs)

Public Attributes
	add_help

	epilog

	formatter_class

	fromfile_prefix_chars

	prog

	usage

	version

Public Attributes inherited from argparse._ActionsContainer
	argument_default

	conflict_handler

	description

	prefix_chars

Private Member Functions
def	_add_action (self, action)

def	_check_value (self, action, value)

def	_get_formatter (self)

def	_get_kwargs (self)

def	_get_nargs_pattern (self, action)

def	_get_option_tuples (self, option_string)

def	_get_optional_actions (self)

def	_get_positional_actions (self)

def	_get_value (self, action, arg_string)

def	_get_values (self, action, arg_strings)

def	_match_argument (self, action, arg_strings_pattern)

def	_match_arguments_partial (self, actions, arg_strings_pattern)

def	_parse_known_args (self, arg_strings, namespace)

def	_parse_optional (self, arg_string)

def	_print_message (self, message, file=None)

def	_read_args_from_files (self, arg_strings)

Private Attributes
	_optionals

	_positionals

	_subparsers

Detailed Description

Object for parsing command line strings into Python objects.

Keyword Arguments:
    - prog -- The name of the program (default: sys.argv[0])
    - usage -- A usage message (default: auto-generated from arguments)
    - description -- A description of what the program does
    - epilog -- Text following the argument descriptions
    - version -- Add a -v/--version option with the given version string
    - parents -- Parsers whose arguments should be copied into this one
    - formatter_class -- HelpFormatter class for printing help messages
    - prefix_chars -- Characters that prefix optional arguments
    - fromfile_prefix_chars -- Characters that prefix files containing
        additional arguments
    - argument_default -- The default value for all arguments
    - conflict_handler -- String indicating how to handle conflicts
    - add_help -- Add a -h/-help option

Definition at line 1503 of file argparse.py.

Constructor & Destructor Documentation

def argparse.ArgumentParser.__init__	(	self,
		prog = `None`,
		usage = `None`,
		description = `None`,
		epilog = `None`,
		version = `None`,
		parents = `[]`,
		formatter_class = `HelpFormatter`,
		prefix_chars = `'-'`,
		fromfile_prefix_chars = `None`,
		argument_default = `None`,
		conflict_handler = `'error'`,
		add_help = `True`
	)

Definition at line 1534 of file argparse.py.

                  add_help=True):
 
         superinit = super(ArgumentParser, self).__init__
         superinit(description=description,
                   prefix_chars=prefix_chars,
                   argument_default=argument_default,
                   conflict_handler=conflict_handler)
 
         # default setting for prog
         if prog is None:
             prog = _os.path.basename(_sys.argv[0])
 
         self.prog = prog
         self.usage = usage
         self.epilog = epilog
         self.version = version
         self.formatter_class = formatter_class
         self.fromfile_prefix_chars = fromfile_prefix_chars
         self.add_help = add_help
 
         add_group = self.add_argument_group
         self._positionals = add_group(_('positional arguments'))
         self._optionals = add_group(_('optional arguments'))
         self._subparsers = None
 
         # register types
         def identity(string):
             return string
         self.register('type', None, identity)
 
         # add help and version arguments if necessary
         # (using explicit default to override global argument_default)
         if self.add_help:
             self.add_argument(
                 '-h', '--help', action='help', default=SUPPRESS,
                 help=_('show this help message and exit'))
         if self.version:
             self.add_argument(
                 '-v', '--version', action='version', default=SUPPRESS,
                 help=_("show program's version number and exit"))
 
         # add parent arguments and defaults
         for parent in parents:
             self._add_container_actions(parent)
             try:
                 defaults = parent._defaults
             except AttributeError:
                 pass
             else:
                 self._defaults.update(defaults)
 

Member Function Documentation

def argparse.ArgumentParser._add_action	(	self,
		action
	)

private

Definition at line 1634 of file argparse.py.

     def _add_action(self, action):
         if action.option_strings:
             self._optionals._add_action(action)
         else:
             self._positionals._add_action(action)
         return action
 

def argparse.ArgumentParser._check_value	(	self,
		action,
		value
	)

private

Definition at line 2187 of file argparse.py.

References crabWrapper._, join(), and genParticles_cff.map.

Referenced by argparse.ArgumentParser._get_values().

     def _check_value(self, action, value):
         # converted value must be one of the choices (if specified)
         if action.choices is not None and value not in action.choices:
             tup = value, ', '.join(map(repr, action.choices))
             msg = _('invalid choice: %r (choose from %s)') % tup
             raise ArgumentError(action, msg)
 

def argparse.ArgumentParser._get_formatter ( self )

private

Definition at line 2231 of file argparse.py.

References argparse.ArgumentParser.formatter_class, python.rootplot.argparse.ArgumentParser.formatter_class, argparse.ArgumentParser.prog, and python.rootplot.argparse.ArgumentParser.prog.

Referenced by argparse.ArgumentParser.add_subparsers(), argparse.ArgumentParser.format_help(), argparse.ArgumentParser.format_usage(), and argparse.ArgumentParser.format_version().

     def _get_formatter(self):
         return self.formatter_class(prog=self.prog)
 

def argparse.ArgumentParser._get_kwargs ( self )

private

Definition at line 1588 of file argparse.py.

     def _get_kwargs(self):
         names = [
             'prog',
             'usage',
             'description',
             'version',
             'formatter_class',
             'conflict_handler',
             'add_help',
         ]
         return [(name, getattr(self, name)) for name in names]
 

def argparse.ArgumentParser._get_nargs_pattern	(	self,
		action
	)

private

Definition at line 2082 of file argparse.py.

References join().

Referenced by argparse.ArgumentParser._match_argument(), and argparse.ArgumentParser._match_arguments_partial().

     def _get_nargs_pattern(self, action):
         # in all examples below, we have to allow for '--' args
         # which are represented as '-' in the pattern
         nargs = action.nargs
 
         # the default (None) is assumed to be a single argument
         if nargs is None:
             nargs_pattern = '(-*A-*)'
 
         # allow zero or one arguments
         elif nargs == OPTIONAL:
             nargs_pattern = '(-*A?-*)'
 
         # allow zero or more arguments
         elif nargs == ZERO_OR_MORE:
             nargs_pattern = '(-*[A-]*)'
 
         # allow one or more arguments
         elif nargs == ONE_OR_MORE:
             nargs_pattern = '(-*A[A-]*)'
 
         # allow one argument followed by any number of options or arguments
         elif nargs is PARSER:
             nargs_pattern = '(-*A[-AO]*)'
 
         # all others should be integers
         else:
             nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
 
         # if this is an optional action, -- is not allowed
         if action.option_strings:
             nargs_pattern = nargs_pattern.replace('-*', '')
             nargs_pattern = nargs_pattern.replace('-', '')
 
         # return the pattern
         return nargs_pattern
 

def argparse.ArgumentParser._get_option_tuples	(	self,
		option_string
	)

private

Definition at line 2038 of file argparse.py.

References crabWrapper._, argparse._ActionsContainer._option_string_actions, python.rootplot.argparse._ActionsContainer._option_string_actions, python.rootplot.argparse._ArgumentGroup._option_string_actions, TreeStruct.error, MomentumConstraint.error, pat::MHT.error(), BinomialProbability.error(), CSCPairConstraint.error(), count_t.error(), Measurement1DFloat.error(), SiStripLaserRecHit2D.error, Measurement1D.error(), SaxToDom.error(), SamplingAnalysis.error(), pat::LookupTableRecord.error(), SaxToDom2.error(), FedTimingAnalysis.error(), EcalUncalibRecHitRatioMethodAlgo< C >::Ratio.error, ApvTimingAnalysis.error(), EcalUncalibRecHitRatioMethodAlgo< C >::Tmax.error, CSCPairResidualsConstraint.error(), edm::HLTGlobalStatus.error(), edm::HLTPathStatus.error(), edm::TriggerResultsByName.error(), reco::VertexCompositePtrCandidate.error(), stats_t< T >.error(), PTrajectoryStateOnDet.error(), cscdqm::XMLFileErrorHandler.error(), PhysicsTools::Calibration::Histogram< Value_t, Axis_t >.error(), lhef::LHERunInfo::XSec.error(), DDLSAX2Handler.error(), Rivet::HiggsTemplateCrossSections.error(), PhysicsTools::Calibration::Histogram2D< Value_t, AxisX_t, AxisY_t >.error(), MuonErrorMatrix.error, SimpleSAXParser::ParserError.error(), PhysicsTools::Calibration::Histogram3D< Value_t, AxisX_t, AxisY_t, AxisZ_t >.error(), funct::GaussIntegrator.error(), TriggerRatesMonitor::HLTRatesPlots.error, reco::Vertex.error(), CSCDCCExaminer.error(), reco::TrackBase.error(), MatacqTBRawEvent.error, dataset.Dataset.error, MatacqRawEvent.error, argparse.ArgumentParser.error(), python.rootplot.argparse.ArgumentParser.error(), argparse._ActionsContainer.prefix_chars, and python.rootplot.argparse._ActionsContainer.prefix_chars.

Referenced by argparse.ArgumentParser._parse_optional().

     def _get_option_tuples(self, option_string):
         result = []
 
         # option strings starting with two prefix characters are only
         # split at the '='
         chars = self.prefix_chars
         if option_string[0] in chars and option_string[1] in chars:
             if '=' in option_string:
                 option_prefix, explicit_arg = option_string.split('=', 1)
             else:
                 option_prefix = option_string
                 explicit_arg = None
             for option_string in self._option_string_actions:
                 if option_string.startswith(option_prefix):
                     action = self._option_string_actions[option_string]
                     tup = action, option_string, explicit_arg
                     result.append(tup)
 
         # single character options can be concatenated with their arguments
         # but multiple character options always have to have their argument
         # separate
         elif option_string[0] in chars and option_string[1] not in chars:
             option_prefix = option_string
             explicit_arg = None
             short_option_prefix = option_string[:2]
             short_explicit_arg = option_string[2:]
 
             for option_string in self._option_string_actions:
                 if option_string == short_option_prefix:
                     action = self._option_string_actions[option_string]
                     tup = action, option_string, short_explicit_arg
                     result.append(tup)
                 elif option_string.startswith(option_prefix):
                     action = self._option_string_actions[option_string]
                     tup = action, option_string, explicit_arg
                     result.append(tup)
 
         # shouldn't ever get here
         else:
             self.error(_('unexpected option string: %s') % option_string)
 
         # return the collected option tuples
         return result
 

def argparse.ArgumentParser._get_optional_actions ( self )

private

Definition at line 1641 of file argparse.py.

References argparse._ActionsContainer._actions, python.rootplot.argparse._ActionsContainer._actions, and python.rootplot.argparse._ArgumentGroup._actions.

     def _get_optional_actions(self):
         return [action
                 for action in self._actions
                 if action.option_strings]
 

def argparse.ArgumentParser._get_positional_actions ( self )

private

Definition at line 1646 of file argparse.py.

References argparse._ActionsContainer._actions, python.rootplot.argparse._ActionsContainer._actions, and python.rootplot.argparse._ArgumentGroup._actions.

Referenced by argparse.ArgumentParser._parse_known_args(), and argparse.ArgumentParser.add_subparsers().

     def _get_positional_actions(self):
         return [action
                 for action in self._actions
                 if not action.option_strings]
 

def argparse.ArgumentParser._get_value	(	self,
		action,
		arg_string
	)

private

Definition at line 2167 of file argparse.py.

References crabWrapper._, argparse._ActionsContainer._registry_get(), and python.rootplot.argparse._ActionsContainer._registry_get().

Referenced by argparse.ArgumentParser._get_values(), and argparse.ArgumentParser.parse_known_args().

     def _get_value(self, action, arg_string):
         type_func = self._registry_get('type', action.type, action.type)
         if not hasattr(type_func, '__call__'):
             if not hasattr(type_func, '__bases__'): # classic classes
                 msg = _('%r is not callable')
                 raise ArgumentError(action, msg % type_func)
 
         # convert the value to the appropriate type
         try:
             result = type_func(arg_string)
 
         # TypeErrors or ValueErrors indicate errors
         except (TypeError, ValueError):
             name = getattr(action.type, '__name__', repr(action.type))
             msg = _('invalid %s value: %r')
             raise ArgumentError(action, msg % (name, arg_string))
 
         # return the converted value
         return result
 

def argparse.ArgumentParser._get_values	(	self,
		action,
		arg_strings
	)

private

Definition at line 2122 of file argparse.py.

References argparse.ArgumentParser._check_value(), python.rootplot.argparse.ArgumentParser._check_value(), argparse.ArgumentParser._get_value(), and python.rootplot.argparse.ArgumentParser._get_value().

Referenced by argparse.ArgumentParser._parse_known_args().

     def _get_values(self, action, arg_strings):
         # for everything but PARSER args, strip out '--'
         if action.nargs is not PARSER:
             arg_strings = [s for s in arg_strings if s != '--']
 
         # optional argument produces a default when not present
         if not arg_strings and action.nargs == OPTIONAL:
             if action.option_strings:
                 value = action.const
             else:
                 value = action.default
             if isinstance(value, _basestring):
                 value = self._get_value(action, value)
                 self._check_value(action, value)
 
         # when nargs='*' on a positional, if there were no command-line
         # args, use the default if it is anything other than None
         elif (not arg_strings and action.nargs == ZERO_OR_MORE and
               not action.option_strings):
             if action.default is not None:
                 value = action.default
             else:
                 value = arg_strings
             self._check_value(action, value)
 
         # single argument or optional argument produces a single value
         elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
             arg_string, = arg_strings
             value = self._get_value(action, arg_string)
             self._check_value(action, value)
 
         # PARSER arguments convert all values, but check only the first
         elif action.nargs is PARSER:
             value = [self._get_value(action, v) for v in arg_strings]
             self._check_value(action, value[0])
 
         # all other types of nargs produce a list
         else:
             value = [self._get_value(action, v) for v in arg_strings]
             for v in value:
                 self._check_value(action, v)
 
         # return the converted value
         return value
 

def argparse.ArgumentParser._match_argument	(	self,
		action,
		arg_strings_pattern
	)

private

Definition at line 1953 of file argparse.py.

References crabWrapper._, argparse.ArgumentParser._get_nargs_pattern(), and python.rootplot.argparse.ArgumentParser._get_nargs_pattern().

Referenced by argparse.ArgumentParser._parse_known_args().

     def _match_argument(self, action, arg_strings_pattern):
         # match the pattern for this action to the arg strings
         nargs_pattern = self._get_nargs_pattern(action)
         match = _re.match(nargs_pattern, arg_strings_pattern)
 
         # raise an exception if we weren't able to find a match
         if match is None:
             nargs_errors = {
                 None: _('expected one argument'),
                 OPTIONAL: _('expected at most one argument'),
                 ONE_OR_MORE: _('expected at least one argument'),
             }
             default = _('expected %s argument(s)') % action.nargs
             msg = nargs_errors.get(action.nargs, default)
             raise ArgumentError(action, msg)
 
         # return the number of arguments matched
         return len(match.group(1))
 

def argparse.ArgumentParser._match_arguments_partial	(	self,
		actions,
		arg_strings_pattern
	)

private

Definition at line 1972 of file argparse.py.

References argparse.ArgumentParser._get_nargs_pattern(), python.rootplot.argparse.ArgumentParser._get_nargs_pattern(), and join().

Referenced by argparse.ArgumentParser._parse_known_args().

     def _match_arguments_partial(self, actions, arg_strings_pattern):
         # progressively shorten the actions list by slicing off the
         # final actions until we find a match
         result = []
         for i in range(len(actions), 0, -1):
             actions_slice = actions[:i]
             pattern = ''.join([self._get_nargs_pattern(action)
                                for action in actions_slice])
             match = _re.match(pattern, arg_strings_pattern)
             if match is not None:
                 result.extend([len(string) for string in match.groups()])
                 break
 
         # return the list of arg string counts
         return result
 

def argparse.ArgumentParser._parse_known_args	(	self,
		arg_strings,
		namespace
	)

private

Definition at line 1692 of file argparse.py.

Referenced by argparse.ArgumentParser.parse_known_args().

     def _parse_known_args(self, arg_strings, namespace):
         # replace arg strings that are file references
         if self.fromfile_prefix_chars is not None:
             arg_strings = self._read_args_from_files(arg_strings)
 
         # map all mutually exclusive arguments to the other arguments
         # they can't occur with
         action_conflicts = {}
         for mutex_group in self._mutually_exclusive_groups:
             group_actions = mutex_group._group_actions
             for i, mutex_action in enumerate(mutex_group._group_actions):
                 conflicts = action_conflicts.setdefault(mutex_action, [])
                 conflicts.extend(group_actions[:i])
                 conflicts.extend(group_actions[i + 1:])
 
         # find all option indices, and determine the arg_string_pattern
         # which has an 'O' if there is an option at an index,
         # an 'A' if there is an argument, or a '-' if there is a '--'
         option_string_indices = {}
         arg_string_pattern_parts = []
         arg_strings_iter = iter(arg_strings)
         for i, arg_string in enumerate(arg_strings_iter):
 
             # all args after -- are non-options
             if arg_string == '--':
                 arg_string_pattern_parts.append('-')
                 for arg_string in arg_strings_iter:
                     arg_string_pattern_parts.append('A')
 
             # otherwise, add the arg to the arg strings
             # and note the index if it was an option
             else:
                 option_tuple = self._parse_optional(arg_string)
                 if option_tuple is None:
                     pattern = 'A'
                 else:
                     option_string_indices[i] = option_tuple
                     pattern = 'O'
                 arg_string_pattern_parts.append(pattern)
 
         # join the pieces together to form the pattern
         arg_strings_pattern = ''.join(arg_string_pattern_parts)
 
         # converts arg strings to the appropriate and then takes the action
         seen_actions = _set()
         seen_non_default_actions = _set()
 
         def take_action(action, argument_strings, option_string=None):
             seen_actions.add(action)
             argument_values = self._get_values(action, argument_strings)
 
             # error if this argument is not allowed with other previously
             # seen arguments, assuming that actions that use the default
             # value don't really count as "present"
             if argument_values is not action.default:
                 seen_non_default_actions.add(action)
                 for conflict_action in action_conflicts.get(action, []):
                     if conflict_action in seen_non_default_actions:
                         msg = _('not allowed with argument %s')
                         action_name = _get_action_name(conflict_action)
                         raise ArgumentError(action, msg % action_name)
 
             # take the action if we didn't receive a SUPPRESS value
             # (e.g. from a default)
             if argument_values is not SUPPRESS:
                 action(self, namespace, argument_values, option_string)
 
         # function to convert arg_strings into an optional action
         def consume_optional(start_index):
 
             # get the optional identified at this index
             option_tuple = option_string_indices[start_index]
             action, option_string, explicit_arg = option_tuple
 
             # identify additional optionals in the same arg string
             # (e.g. -xyz is the same as -x -y -z if no args are required)
             match_argument = self._match_argument
             action_tuples = []
             while True:
 
                 # if we found no optional action, skip it
                 if action is None:
                     extras.append(arg_strings[start_index])
                     return start_index + 1
 
                 # if there is an explicit argument, try to match the
                 # optional's string arguments to only this
                 if explicit_arg is not None:
                     arg_count = match_argument(action, 'A')
 
                     # if the action is a single-dash option and takes no
                     # arguments, try to parse more single-dash options out
                     # of the tail of the option string
                     chars = self.prefix_chars
                     if arg_count == 0 and option_string[1] not in chars:
                         action_tuples.append((action, [], option_string))
                         for char in self.prefix_chars:
                             option_string = char + explicit_arg[0]
                             explicit_arg = explicit_arg[1:] or None
                             optionals_map = self._option_string_actions
                             if option_string in optionals_map:
                                 action = optionals_map[option_string]
                                 break
                         else:
                             msg = _('ignored explicit argument %r')
                             raise ArgumentError(action, msg % explicit_arg)
 
                     # if the action expect exactly one argument, we've
                     # successfully matched the option; exit the loop
                     elif arg_count == 1:
                         stop = start_index + 1
                         args = [explicit_arg]
                         action_tuples.append((action, args, option_string))
                         break
 
                     # error if a double-dash option did not use the
                     # explicit argument
                     else:
                         msg = _('ignored explicit argument %r')
                         raise ArgumentError(action, msg % explicit_arg)
 
                 # if there is no explicit argument, try to match the
                 # optional's string arguments with the following strings
                 # if successful, exit the loop
                 else:
                     start = start_index + 1
                     selected_patterns = arg_strings_pattern[start:]
                     arg_count = match_argument(action, selected_patterns)
                     stop = start + arg_count
                     args = arg_strings[start:stop]
                     action_tuples.append((action, args, option_string))
                     break
 
             # add the Optional to the list and return the index at which
             # the Optional's string args stopped
             assert action_tuples
             for action, args, option_string in action_tuples:
                 take_action(action, args, option_string)
             return stop
 
         # the list of Positionals left to be parsed; this is modified
         # by consume_positionals()
         positionals = self._get_positional_actions()
 
         # function to convert arg_strings into positional actions
         def consume_positionals(start_index):
             # match as many Positionals as possible
             match_partial = self._match_arguments_partial
             selected_pattern = arg_strings_pattern[start_index:]
             arg_counts = match_partial(positionals, selected_pattern)
 
             # slice off the appropriate arg strings for each Positional
             # and add the Positional and its args to the list
             for action, arg_count in zip(positionals, arg_counts):
                 args = arg_strings[start_index: start_index + arg_count]
                 start_index += arg_count
                 take_action(action, args)
 
             # slice off the Positionals that we just parsed and return the
             # index at which the Positionals' string args stopped
             positionals[:] = positionals[len(arg_counts):]
             return start_index
 
         # consume Positionals and Optionals alternately, until we have
         # passed the last option string
         extras = []
         start_index = 0
         if option_string_indices:
             max_option_string_index = max(option_string_indices)
         else:
             max_option_string_index = -1
         while start_index <= max_option_string_index:
 
             # consume any Positionals preceding the next option
             next_option_string_index = min([
                 index
                 for index in option_string_indices
                 if index >= start_index])
             if start_index != next_option_string_index:
                 positionals_end_index = consume_positionals(start_index)
 
                 # only try to parse the next optional if we didn't consume
                 # the option string during the positionals parsing
                 if positionals_end_index > start_index:
                     start_index = positionals_end_index
                     continue
                 else:
                     start_index = positionals_end_index
 
             # if we consumed all the positionals we could and we're not
             # at the index of an option string, there were extra arguments
             if start_index not in option_string_indices:
                 strings = arg_strings[start_index:next_option_string_index]
                 extras.extend(strings)
                 start_index = next_option_string_index
 
             # consume the next optional and any arguments for it
             start_index = consume_optional(start_index)
 
         # consume any positionals following the last Optional
         stop_index = consume_positionals(start_index)
 
         # if we didn't consume all the argument strings, there were extras
         extras.extend(arg_strings[stop_index:])
 
         # if we didn't use all the Positional objects, there were too few
         # arg strings supplied.
         if positionals:
             self.error(_('too few arguments'))
 
         # make sure all required actions were present
         for action in self._actions:
             if action.required:
                 if action not in seen_actions:
                     name = _get_action_name(action)
                     self.error(_('argument %s is required') % name)
 
         # make sure all required groups had one option present
         for group in self._mutually_exclusive_groups:
             if group.required:
                 for action in group._group_actions:
                     if action in seen_non_default_actions:
                         break
 
                 # if no actions were used, report the error
                 else:
                     names = [_get_action_name(action)
                              for action in group._group_actions
                              if action.help is not SUPPRESS]
                     msg = _('one of the arguments %s is required')
                     self.error(msg % ' '.join(names))
 
         # return the updated namespace and the extra arguments
         return namespace, extras
 

def argparse.ArgumentParser._parse_optional	(	self,
		arg_string
	)

private

Definition at line 1988 of file argparse.py.

References crabWrapper._, argparse.ArgumentParser._get_option_tuples(), python.rootplot.argparse.ArgumentParser._get_option_tuples(), argparse._ActionsContainer._has_negative_number_optionals, python.rootplot.argparse._ActionsContainer._has_negative_number_optionals, python.rootplot.argparse._ArgumentGroup._has_negative_number_optionals, argparse._ActionsContainer._option_string_actions, python.rootplot.argparse._ActionsContainer._option_string_actions, python.rootplot.argparse._ArgumentGroup._option_string_actions, TreeStruct.error, MomentumConstraint.error, pat::MHT.error(), BinomialProbability.error(), CSCPairConstraint.error(), count_t.error(), Measurement1DFloat.error(), SiStripLaserRecHit2D.error, Measurement1D.error(), SaxToDom.error(), SamplingAnalysis.error(), pat::LookupTableRecord.error(), SaxToDom2.error(), FedTimingAnalysis.error(), EcalUncalibRecHitRatioMethodAlgo< C >::Ratio.error, ApvTimingAnalysis.error(), EcalUncalibRecHitRatioMethodAlgo< C >::Tmax.error, CSCPairResidualsConstraint.error(), edm::HLTGlobalStatus.error(), edm::HLTPathStatus.error(), edm::TriggerResultsByName.error(), reco::VertexCompositePtrCandidate.error(), stats_t< T >.error(), PTrajectoryStateOnDet.error(), cscdqm::XMLFileErrorHandler.error(), PhysicsTools::Calibration::Histogram< Value_t, Axis_t >.error(), lhef::LHERunInfo::XSec.error(), DDLSAX2Handler.error(), Rivet::HiggsTemplateCrossSections.error(), PhysicsTools::Calibration::Histogram2D< Value_t, AxisX_t, AxisY_t >.error(), MuonErrorMatrix.error, SimpleSAXParser::ParserError.error(), PhysicsTools::Calibration::Histogram3D< Value_t, AxisX_t, AxisY_t, AxisZ_t >.error(), funct::GaussIntegrator.error(), TriggerRatesMonitor::HLTRatesPlots.error, reco::Vertex.error(), CSCDCCExaminer.error(), reco::TrackBase.error(), MatacqTBRawEvent.error, dataset.Dataset.error, MatacqRawEvent.error, argparse.ArgumentParser.error(), python.rootplot.argparse.ArgumentParser.error(), join(), argparse._ActionsContainer.prefix_chars, and python.rootplot.argparse._ActionsContainer.prefix_chars.

Referenced by argparse.ArgumentParser._parse_known_args().

     def _parse_optional(self, arg_string):
         # if it's an empty string, it was meant to be a positional
         if not arg_string:
             return None
 
         # if it doesn't start with a prefix, it was meant to be positional
         if not arg_string[0] in self.prefix_chars:
             return None
 
         # if it's just dashes, it was meant to be positional
         if not arg_string.strip('-'):
             return None
 
         # if the option string is present in the parser, return the action
         if arg_string in self._option_string_actions:
             action = self._option_string_actions[arg_string]
             return action, arg_string, None
 
         # search through all possible prefixes of the option string
         # and all actions in the parser for possible interpretations
         option_tuples = self._get_option_tuples(arg_string)
 
         # if multiple actions match, the option string was ambiguous
         if len(option_tuples) > 1:
             options = ', '.join([option_string
                 for action, option_string, explicit_arg in option_tuples])
             tup = arg_string, options
             self.error(_('ambiguous option: %s could match %s') % tup)
 
         # if exactly one action matched, this segmentation is good,
         # so return the parsed action
         elif len(option_tuples) == 1:
             option_tuple, = option_tuples
             return option_tuple
 
         # if it was not found as an option, but it looks like a negative
         # number, it was meant to be positional
         # unless there are negative-number-like options
         if self._negative_number_matcher.match(arg_string):
             if not self._has_negative_number_optionals:
                 return None
 
         # if it contains a space, it was meant to be a positional
         if ' ' in arg_string:
             return None
 
         # it was meant to be an optional but there is no such option
         # in this parser (though it might be a valid option in a subparser)
         return None, arg_string, None
 

def argparse.ArgumentParser._print_message	(	self,
		message,
		file = `None`
	)

private

Definition at line 2246 of file argparse.py.

Referenced by argparse.ArgumentParser.print_help(), argparse.ArgumentParser.print_usage(), and argparse.ArgumentParser.print_version().

     def _print_message(self, message, file=None):
         if message:
             if file is None:
                 file = _sys.stderr
             file.write(message)
 

def argparse.ArgumentParser._read_args_from_files	(	self,
		arg_strings
	)

private

Definition at line 1927 of file argparse.py.

References argparse.ArgumentParser._read_args_from_files(), python.rootplot.argparse.ArgumentParser._read_args_from_files(), TreeStruct.error, MomentumConstraint.error, pat::MHT.error(), BinomialProbability.error(), count_t.error(), CSCPairConstraint.error(), Measurement1DFloat.error(), SiStripLaserRecHit2D.error, Measurement1D.error(), SaxToDom.error(), SamplingAnalysis.error(), pat::LookupTableRecord.error(), SaxToDom2.error(), FedTimingAnalysis.error(), EcalUncalibRecHitRatioMethodAlgo< C >::Ratio.error, ApvTimingAnalysis.error(), EcalUncalibRecHitRatioMethodAlgo< C >::Tmax.error, CSCPairResidualsConstraint.error(), edm::HLTGlobalStatus.error(), edm::HLTPathStatus.error(), edm::TriggerResultsByName.error(), reco::VertexCompositePtrCandidate.error(), stats_t< T >.error(), PTrajectoryStateOnDet.error(), cscdqm::XMLFileErrorHandler.error(), PhysicsTools::Calibration::Histogram< Value_t, Axis_t >.error(), lhef::LHERunInfo::XSec.error(), DDLSAX2Handler.error(), Rivet::HiggsTemplateCrossSections.error(), PhysicsTools::Calibration::Histogram2D< Value_t, AxisX_t, AxisY_t >.error(), MuonErrorMatrix.error, SimpleSAXParser::ParserError.error(), PhysicsTools::Calibration::Histogram3D< Value_t, AxisX_t, AxisY_t, AxisZ_t >.error(), funct::GaussIntegrator.error(), TriggerRatesMonitor::HLTRatesPlots.error, reco::Vertex.error(), CSCDCCExaminer.error(), reco::TrackBase.error(), MatacqTBRawEvent.error, dataset.Dataset.error, MatacqRawEvent.error, argparse.ArgumentParser.error(), python.rootplot.argparse.ArgumentParser.error(), argparse.ArgumentParser.fromfile_prefix_chars, python.rootplot.argparse.ArgumentParser.fromfile_prefix_chars, and harvestTrackValidationPlots.str.

Referenced by argparse.ArgumentParser._parse_known_args(), and argparse.ArgumentParser._read_args_from_files().

     def _read_args_from_files(self, arg_strings):
         # expand arguments referencing files
         new_arg_strings = []
         for arg_string in arg_strings:
 
             # for regular arguments, just add them back into the list
             if arg_string[0] not in self.fromfile_prefix_chars:
                 new_arg_strings.append(arg_string)
 
             # replace arguments referencing files with the file content
             else:
                 try:
                     args_file = open(arg_string[1:])
                     try:
                         arg_strings = args_file.read().splitlines()
                         arg_strings = self._read_args_from_files(arg_strings)
                         new_arg_strings.extend(arg_strings)
                     finally:
                         args_file.close()
                 except IOError:
                     err = _sys.exc_info()[1]
                     self.error(str(err))
 
         # return the modified argument list
         return new_arg_strings
 

def argparse.ArgumentParser.add_subparsers	(	self,
		kwargs
	)

Definition at line 1603 of file argparse.py.

     def add_subparsers(self, **kwargs):
         if self._subparsers is not None:
             self.error(_('cannot have multiple subparser arguments'))
 
         # add the parser class to the arguments if it's not present
         kwargs.setdefault('parser_class', type(self))
 
         if 'title' in kwargs or 'description' in kwargs:
             title = _(kwargs.pop('title', 'subcommands'))
             description = _(kwargs.pop('description', None))
             self._subparsers = self.add_argument_group(title, description)
         else:
             self._subparsers = self._positionals
 
         # prog defaults to the usage message of this parser, skipping
         # optional arguments and with no "usage:" prefix
         if kwargs.get('prog') is None:
             formatter = self._get_formatter()
             positionals = self._get_positional_actions()
             groups = self._mutually_exclusive_groups
             formatter.add_usage(self.usage, positionals, groups, '')
             kwargs['prog'] = formatter.format_help().strip()
 
         # create the parsers action and add it to the positionals list
         parsers_class = self._pop_action_class(kwargs, 'parsers')
         action = parsers_class(option_strings=[], **kwargs)
         self._subparsers._add_action(action)
 
         # return the created parsers action
         return action
 

def argparse.ArgumentParser.error	(	self,
		message
	)

error(message: string)

Prints a usage message incorporating the message to stderr and
exits.

If you override this in a subclass, it should not return -- it
should either exit or raise an exception.

Definition at line 2260 of file argparse.py.

References crabWrapper._, CaloSegment.exit(), Vispa.Main.Application.Application.exit(), argparse.ArgumentParser.exit(), python.rootplot.argparse.ArgumentParser.exit(), argparse.ArgumentParser.print_usage(), python.rootplot.argparse.ArgumentParser.print_usage(), argparse.ArgumentParser.prog, and python.rootplot.argparse.ArgumentParser.prog.

Referenced by argparse.ArgumentParser._get_option_tuples(), argparse.ArgumentParser._parse_known_args(), argparse.ArgumentParser._parse_optional(), argparse.ArgumentParser._read_args_from_files(), argparse.ArgumentParser.add_subparsers(), Page1Parser.Page1Parser.check_for_whole_start_tag(), argparse.ArgumentParser.parse_args(), and argparse.ArgumentParser.parse_known_args().

     def error(self, message):
         """error(message: string)
 
         Prints a usage message incorporating the message to stderr and
         exits.
 
         If you override this in a subclass, it should not return -- it
         should either exit or raise an exception.
         """
         self.print_usage(_sys.stderr)
         self.exit(2, _('%s: error: %s\n') % (self.prog, message))

def argparse.ArgumentParser.exit	(	self,
		status = `0`,
		message = `None`
	)

Definition at line 2255 of file argparse.py.

Referenced by argparse.ArgumentParser.error().

     def exit(self, status=0, message=None):
         if message:
             _sys.stderr.write(message)
         _sys.exit(status)
 

def argparse.ArgumentParser.format_help ( self )

Definition at line 2203 of file argparse.py.

Referenced by argparse.ArgumentParser.print_help().

     def format_help(self):
         formatter = self._get_formatter()
 
         # usage
         formatter.add_usage(self.usage, self._actions,
                             self._mutually_exclusive_groups)
 
         # description
         formatter.add_text(self.description)
 
         # positionals, optionals and user-defined groups
         for action_group in self._action_groups:
             formatter.start_section(action_group.title)
             formatter.add_text(action_group.description)
             formatter.add_arguments(action_group._group_actions)
             formatter.end_section()
 
         # epilog
         formatter.add_text(self.epilog)
 
         # determine help from format above
         return formatter.format_help()
 

def argparse.ArgumentParser.format_usage ( self )

Definition at line 2197 of file argparse.py.

References argparse._ActionsContainer._actions, python.rootplot.argparse._ActionsContainer._actions, python.rootplot.argparse._ArgumentGroup._actions, argparse.ArgumentParser._get_formatter(), python.rootplot.argparse.ArgumentParser._get_formatter(), argparse._ActionsContainer._mutually_exclusive_groups, python.rootplot.argparse._ActionsContainer._mutually_exclusive_groups, argparse.ArgumentParser.usage, and python.rootplot.argparse.ArgumentParser.usage.

Referenced by argparse.ArgumentParser.print_usage().

     def format_usage(self):
         formatter = self._get_formatter()
         formatter.add_usage(self.usage, self._actions,
                             self._mutually_exclusive_groups)
         return formatter.format_help()
 

def argparse.ArgumentParser.format_version ( self )

Definition at line 2226 of file argparse.py.

References argparse.ArgumentParser._get_formatter(), python.rootplot.argparse.ArgumentParser._get_formatter(), MagFieldConfig.version, L1TUtmCutValue.version, MatrixInjector.MatrixInjector.version, confdbOfflineConverter.OfflineConverter.version, L1TUtmBin.version, options.ConnectionHLTMenu.version, TrackerInteractionGeometry.version, L1TUtmCondition.version, L1TUtmAlgorithm.version, L1TUtmScale.version, MatacqTBRawEvent::matacqHeader_t.version, DQMNet::CoreObject.version, L1TUtmObject.version, L1TUtmCut.version, XMLProcessor::_DBConfig.version, L1TUtmTriggerMenu.version, ScalersEventRecordRaw_v1.version, ScalersEventRecordRaw_v2.version, ScalersEventRecordRaw_v3.version, ScalersEventRecordRaw_v4.version, ScalersEventRecordRaw_v5.version, ScalersEventRecordRaw_v6.version, cmsHarvester.CMSHarvester.version, python.rootplot.argparse._VersionAction.version, argparse.ArgumentParser.version, and python.rootplot.argparse.ArgumentParser.version.

Referenced by argparse.ArgumentParser.print_version().

     def format_version(self):
         formatter = self._get_formatter()
         formatter.add_text(self.version)
         return formatter.format_help()
 

def argparse.ArgumentParser.parse_args	(	self,
		args = `None`,
		namespace = `None`
	)

Definition at line 1654 of file argparse.py.

References crabWrapper._, TreeStruct.error, MomentumConstraint.error, pat::MHT.error(), BinomialProbability.error(), count_t.error(), CSCPairConstraint.error(), Measurement1DFloat.error(), SiStripLaserRecHit2D.error, Measurement1D.error(), SaxToDom.error(), SamplingAnalysis.error(), pat::LookupTableRecord.error(), SaxToDom2.error(), FedTimingAnalysis.error(), EcalUncalibRecHitRatioMethodAlgo< C >::Ratio.error, ApvTimingAnalysis.error(), EcalUncalibRecHitRatioMethodAlgo< C >::Tmax.error, CSCPairResidualsConstraint.error(), edm::HLTGlobalStatus.error(), edm::HLTPathStatus.error(), edm::TriggerResultsByName.error(), reco::VertexCompositePtrCandidate.error(), stats_t< T >.error(), PTrajectoryStateOnDet.error(), cscdqm::XMLFileErrorHandler.error(), PhysicsTools::Calibration::Histogram< Value_t, Axis_t >.error(), lhef::LHERunInfo::XSec.error(), DDLSAX2Handler.error(), Rivet::HiggsTemplateCrossSections.error(), PhysicsTools::Calibration::Histogram2D< Value_t, AxisX_t, AxisY_t >.error(), MuonErrorMatrix.error, SimpleSAXParser::ParserError.error(), PhysicsTools::Calibration::Histogram3D< Value_t, AxisX_t, AxisY_t, AxisZ_t >.error(), funct::GaussIntegrator.error(), TriggerRatesMonitor::HLTRatesPlots.error, reco::Vertex.error(), CSCDCCExaminer.error(), reco::TrackBase.error(), MatacqTBRawEvent.error, dataset.Dataset.error, MatacqRawEvent.error, argparse.ArgumentParser.error(), python.rootplot.argparse.ArgumentParser.error(), join(), argparse.ArgumentParser.parse_known_args(), and python.rootplot.argparse.ArgumentParser.parse_known_args().

     def parse_args(self, args=None, namespace=None):
         args, argv = self.parse_known_args(args, namespace)
         if argv:
             msg = _('unrecognized arguments: %s')
             self.error(msg % ' '.join(argv))
         return args
 

def argparse.ArgumentParser.parse_known_args	(	self,
		args = `None`,
		namespace = `None`
	)

Definition at line 1661 of file argparse.py.

References argparse._ActionsContainer._actions, python.rootplot.argparse._ActionsContainer._actions, python.rootplot.argparse._ArgumentGroup._actions, argparse._ActionsContainer._defaults, python.rootplot.argparse._ActionsContainer._defaults, python.rootplot.argparse._ArgumentGroup._defaults, argparse.ArgumentParser._get_value(), python.rootplot.argparse.ArgumentParser._get_value(), argparse.ArgumentParser._parse_known_args(), python.rootplot.argparse.ArgumentParser._parse_known_args(), TreeStruct.error, MomentumConstraint.error, pat::MHT.error(), BinomialProbability.error(), CSCPairConstraint.error(), count_t.error(), Measurement1DFloat.error(), SiStripLaserRecHit2D.error, Measurement1D.error(), SaxToDom.error(), SamplingAnalysis.error(), pat::LookupTableRecord.error(), SaxToDom2.error(), FedTimingAnalysis.error(), EcalUncalibRecHitRatioMethodAlgo< C >::Ratio.error, ApvTimingAnalysis.error(), EcalUncalibRecHitRatioMethodAlgo< C >::Tmax.error, CSCPairResidualsConstraint.error(), edm::HLTGlobalStatus.error(), edm::HLTPathStatus.error(), edm::TriggerResultsByName.error(), reco::VertexCompositePtrCandidate.error(), stats_t< T >.error(), PTrajectoryStateOnDet.error(), cscdqm::XMLFileErrorHandler.error(), PhysicsTools::Calibration::Histogram< Value_t, Axis_t >.error(), lhef::LHERunInfo::XSec.error(), DDLSAX2Handler.error(), Rivet::HiggsTemplateCrossSections.error(), PhysicsTools::Calibration::Histogram2D< Value_t, AxisX_t, AxisY_t >.error(), MuonErrorMatrix.error, SimpleSAXParser::ParserError.error(), PhysicsTools::Calibration::Histogram3D< Value_t, AxisX_t, AxisY_t, AxisZ_t >.error(), funct::GaussIntegrator.error(), TriggerRatesMonitor::HLTRatesPlots.error, reco::Vertex.error(), CSCDCCExaminer.error(), reco::TrackBase.error(), MatacqTBRawEvent.error, dataset.Dataset.error, MatacqRawEvent.error, argparse.ArgumentParser.error(), python.rootplot.argparse.ArgumentParser.error(), and harvestTrackValidationPlots.str.

Referenced by argparse.ArgumentParser.parse_args().

     def parse_known_args(self, args=None, namespace=None):
         # args default to the system args
         if args is None:
             args = _sys.argv[1:]
 
         # default Namespace built from parser defaults
         if namespace is None:
             namespace = Namespace()
 
         # add any action defaults that aren't present
         for action in self._actions:
             if action.dest is not SUPPRESS:
                 if not hasattr(namespace, action.dest):
                     if action.default is not SUPPRESS:
                         default = action.default
                         if isinstance(action.default, _basestring):
                             default = self._get_value(action, default)
                         setattr(namespace, action.dest, default)
 
         # add any parser defaults that aren't present
         for dest in self._defaults:
             if not hasattr(namespace, dest):
                 setattr(namespace, dest, self._defaults[dest])
 
         # parse the arguments and exit if there are any errors
         try:
             return self._parse_known_args(args, namespace)
         except ArgumentError:
             err = _sys.exc_info()[1]
             self.error(str(err))
 

def argparse.ArgumentParser.print_help	(	self,
		file = `None`
	)

Definition at line 2240 of file argparse.py.

References argparse.ArgumentParser._print_message(), python.rootplot.argparse.ArgumentParser._print_message(), argparse.HelpFormatter._Section.format_help(), python.rootplot.argparse.HelpFormatter._Section.format_help(), argparse.HelpFormatter.format_help(), python.rootplot.argparse.HelpFormatter.format_help(), argparse.ArgumentParser.format_help(), and python.rootplot.argparse.ArgumentParser.format_help().

     def print_help(self, file=None):
         self._print_message(self.format_help(), file)
 

def argparse.ArgumentParser.print_usage	(	self,
		file = `None`
	)

Definition at line 2237 of file argparse.py.

References argparse.ArgumentParser._print_message(), python.rootplot.argparse.ArgumentParser._print_message(), cmsHarvester.CMSHarvesterHelpFormatter.format_usage(), argparse.ArgumentParser.format_usage(), and python.rootplot.argparse.ArgumentParser.format_usage().

Referenced by argparse.ArgumentParser.error().

     def print_usage(self, file=None):
         self._print_message(self.format_usage(), file)
 

def argparse.ArgumentParser.print_version	(	self,
		file = `None`
	)

Definition at line 2243 of file argparse.py.

References argparse.ArgumentParser._print_message(), python.rootplot.argparse.ArgumentParser._print_message(), CSCDDUHeader.format_version(), CSCVDMBHeaderFormat.format_version(), CSCDMBHeader2005.format_version(), CSCDMBHeader.format_version(), CSCDMBHeader2013.format_version(), CSCSPHeader.format_version(), argparse.ArgumentParser.format_version(), and python.rootplot.argparse.ArgumentParser.format_version().

     def print_version(self, file=None):
         self._print_message(self.format_version(), file)
 

Member Data Documentation

argparse.ArgumentParser._optionals

private

Definition at line 1556 of file argparse.py.

argparse.ArgumentParser._positionals

private

Definition at line 1555 of file argparse.py.

Referenced by argparse.ArgumentParser.add_subparsers().

argparse.ArgumentParser._subparsers

private

Definition at line 1557 of file argparse.py.

Referenced by argparse.ArgumentParser.add_subparsers().

argparse.ArgumentParser.add_help

Definition at line 1552 of file argparse.py.

argparse.ArgumentParser.epilog

Definition at line 1548 of file argparse.py.

Referenced by argparse.ArgumentParser.format_help().

argparse.ArgumentParser.formatter_class

Definition at line 1550 of file argparse.py.

Referenced by argparse.ArgumentParser._get_formatter().

argparse.ArgumentParser.fromfile_prefix_chars

Definition at line 1551 of file argparse.py.

Referenced by argparse.ArgumentParser._parse_known_args(), and argparse.ArgumentParser._read_args_from_files().

argparse.ArgumentParser.prog

Definition at line 1546 of file argparse.py.

Referenced by argparse.ArgumentParser._get_formatter(), and argparse.ArgumentParser.error().

argparse.ArgumentParser.usage

Definition at line 1547 of file argparse.py.

Referenced by argparse.ArgumentParser.add_subparsers(), argparse.ArgumentParser.format_help(), and argparse.ArgumentParser.format_usage().

argparse.ArgumentParser.version

Definition at line 1549 of file argparse.py.

Referenced by validation.Sample.datasetpattern(), validation.Sample.filename(), and argparse.ArgumentParser.format_version().

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation