Inheritance diagram for argparse._ActionsContainer:

Public Member Functions
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
	argument_default

	conflict_handler

	description

	prefix_chars

Private Member Functions
def	_add_action (self, action)

def	_add_container_actions (self, container)

def	_check_conflict (self, action)

def	_get_handler (self)

def	_get_optional_kwargs (self, args, kwargs)

def	_get_positional_kwargs (self, dest, kwargs)

def	_handle_conflict_error (self, action, conflicting_actions)

def	_handle_conflict_resolve (self, action, conflicting_actions)

def	_pop_action_class (self, kwargs, default=None)

def	_registry_get (self, registry_name, value, default=None)

def	_remove_action (self, action)

Private Attributes
	_action_groups

	_actions

	_defaults

	_has_negative_number_optionals

	_mutually_exclusive_groups

	_negative_number_matcher

	_option_string_actions

	_registries

Detailed Description

Definition at line 1161 of file argparse.py.

Constructor & Destructor Documentation

def argparse._ActionsContainer.__init__	(	self,
		description,
		prefix_chars,
		argument_default,
		conflict_handler
	)

Definition at line 1167 of file argparse.py.

                  conflict_handler):
         super(_ActionsContainer, self).__init__()
 
         self.description = description
         self.argument_default = argument_default
         self.prefix_chars = prefix_chars
         self.conflict_handler = conflict_handler
 
         # set up registries
         self._registries = {}
 
         # register actions
         self.register('action', None, _StoreAction)
         self.register('action', 'store', _StoreAction)
         self.register('action', 'store_const', _StoreConstAction)
         self.register('action', 'store_true', _StoreTrueAction)
         self.register('action', 'store_false', _StoreFalseAction)
         self.register('action', 'append', _AppendAction)
         self.register('action', 'append_const', _AppendConstAction)
         self.register('action', 'count', _CountAction)
         self.register('action', 'help', _HelpAction)
         self.register('action', 'version', _VersionAction)
         self.register('action', 'parsers', _SubParsersAction)
 
         # raise an exception if the conflict handler is invalid
         self._get_handler()
 
         # action storage
         self._actions = []
         self._option_string_actions = {}
 
         # groups
         self._action_groups = []
         self._mutually_exclusive_groups = []
 
         # defaults storage
         self._defaults = {}
 
         # determines whether an "option" looks like a negative number
         self._negative_number_matcher = _re.compile(r'^-\d+|-\d*.\d+$')
 
         # whether or not there are any optionals that look like negative
         # numbers -- uses a list so it can be shared and edited
         self._has_negative_number_optionals = []
 

Member Function Documentation

def argparse._ActionsContainer._add_action	(	self,
		action
	)

private

Definition at line 1277 of file argparse.py.

References argparse._ActionsContainer._check_conflict(), python.rootplot.argparse._ActionsContainer._check_conflict(), 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, and python.rootplot.argparse._ArgumentGroup._option_string_actions.

Referenced by argparse._ActionsContainer._add_container_actions(), and argparse._ActionsContainer.add_argument().

     def _add_action(self, action):
         # resolve any conflicts
         self._check_conflict(action)
 
         # add to actions list
         self._actions.append(action)
         action.container = self
 
         # index the action by any option strings it has
         for option_string in action.option_strings:
             self._option_string_actions[option_string] = action
 
         # set the flag if any option strings look like negative numbers
         for option_string in action.option_strings:
             if self._negative_number_matcher.match(option_string):
                 if not self._has_negative_number_optionals:
                     self._has_negative_number_optionals.append(True)
 
         # return the created action
         return action
 

def argparse._ActionsContainer._add_container_actions	(	self,
		container
	)

private

Definition at line 1301 of file argparse.py.

References crabWrapper._, argparse._ActionsContainer._action_groups, python.rootplot.argparse._ActionsContainer._action_groups, argparse._ActionsContainer._add_action(), argparse._ActionsContainer.add_argument_group(), python.rootplot.argparse._ActionsContainer.add_argument_group(), argparse._ActionsContainer.add_mutually_exclusive_group(), and python.rootplot.argparse._ActionsContainer.add_mutually_exclusive_group().

     def _add_container_actions(self, container):
         # collect groups by titles
         title_group_map = {}
         for group in self._action_groups:
             if group.title in title_group_map:
                 msg = _('cannot merge actions - two groups are named %r')
                 raise ValueError(msg % (group.title))
             title_group_map[group.title] = group
 
         # map each action to its group
         group_map = {}
         for group in container._action_groups:
 
             # if a group with the title exists, use that, otherwise
             # create a new group matching the container's group
             if group.title not in title_group_map:
                 title_group_map[group.title] = self.add_argument_group(
                     title=group.title,
                     description=group.description,
                     conflict_handler=group.conflict_handler)
 
             # map the actions to their new group
             for action in group._group_actions:
                 group_map[action] = title_group_map[group.title]
 
         # add container's mutually exclusive groups
         # NOTE: if add_mutually_exclusive_group ever gains title= and
         # description= then this code will need to be expanded as above
         for group in container._mutually_exclusive_groups:
             mutex_group = self.add_mutually_exclusive_group(
                 required=group.required)
 
             # map the actions to their new mutex group
             for action in group._group_actions:
                 group_map[action] = mutex_group
 
         # add all actions to this container or their group
         for action in container._actions:
             group_map.get(action, self)._add_action(action)
 

def argparse._ActionsContainer._check_conflict	(	self,
		action
	)

private

Definition at line 1414 of file argparse.py.

References argparse._ActionsContainer._get_handler(), python.rootplot.argparse._ActionsContainer._get_handler(), argparse._ActionsContainer._option_string_actions, python.rootplot.argparse._ActionsContainer._option_string_actions, python.rootplot.argparse._ArgumentGroup._option_string_actions, and argparse._ActionsContainer.conflict_handler.

Referenced by argparse._ActionsContainer._add_action().

     def _check_conflict(self, action):
 
         # find all options that conflict with this option
         confl_optionals = []
         for option_string in action.option_strings:
             if option_string in self._option_string_actions:
                 confl_optional = self._option_string_actions[option_string]
                 confl_optionals.append((option_string, confl_optional))
 
         # resolve any conflicts
         if confl_optionals:
             conflict_handler = self._get_handler()
             conflict_handler(action, confl_optionals)
 

def argparse._ActionsContainer._get_handler ( self )

private

Definition at line 1405 of file argparse.py.

References crabWrapper._, argparse._ActionsContainer.conflict_handler, and python.rootplot.argparse._ActionsContainer.conflict_handler.

Referenced by argparse._ActionsContainer._check_conflict().

     def _get_handler(self):
         # determine function from conflict handler string
         handler_func_name = '_handle_conflict_%s' % self.conflict_handler
         try:
             return getattr(self, handler_func_name)
         except AttributeError:
             msg = _('invalid conflict_resolution value: %r')
             raise ValueError(msg % self.conflict_handler)
 

def argparse._ActionsContainer._get_optional_kwargs	(	self,
		args,
		kwargs
	)

private

Definition at line 1357 of file argparse.py.

References crabWrapper._, argparse._set, cmsPerfStripChart.dict, argparse._ActionsContainer.prefix_chars, and python.rootplot.argparse._ActionsContainer.prefix_chars.

Referenced by argparse._ActionsContainer.add_argument().

     def _get_optional_kwargs(self, *args, **kwargs):
         # determine short and long option strings
         option_strings = []
         long_option_strings = []
         for option_string in args:
             # error on one-or-fewer-character option strings
             if len(option_string) < 2:
                 msg = _('invalid option string %r: '
                         'must be at least two characters long')
                 raise ValueError(msg % option_string)
 
             # error on strings that don't start with an appropriate prefix
             if not option_string[0] in self.prefix_chars:
                 msg = _('invalid option string %r: '
                         'must start with a character %r')
                 tup = option_string, self.prefix_chars
                 raise ValueError(msg % tup)
 
             # error on strings that are all prefix characters
             if not (_set(option_string) - _set(self.prefix_chars)):
                 msg = _('invalid option string %r: '
                         'must contain characters other than %r')
                 tup = option_string, self.prefix_chars
                 raise ValueError(msg % tup)
 
             # strings starting with two prefix characters are long options
             option_strings.append(option_string)
             if option_string[0] in self.prefix_chars:
                 if option_string[1] in self.prefix_chars:
                     long_option_strings.append(option_string)
 
         # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
         dest = kwargs.pop('dest', None)
         if dest is None:
             if long_option_strings:
                 dest_option_string = long_option_strings[0]
             else:
                 dest_option_string = option_strings[0]
             dest = dest_option_string.lstrip(self.prefix_chars)
             dest = dest.replace('-', '_')
 
         # return the updated keyword arguments
         return dict(kwargs, dest=dest, option_strings=option_strings)
 

def argparse._ActionsContainer._get_positional_kwargs	(	self,
		dest,
		kwargs
	)

private

Definition at line 1341 of file argparse.py.

References crabWrapper._, and cmsPerfStripChart.dict.

Referenced by argparse._ActionsContainer.add_argument().

     def _get_positional_kwargs(self, dest, **kwargs):
         # make sure required is not specified
         if 'required' in kwargs:
             msg = _("'required' is an invalid argument for positionals")
             raise TypeError(msg)
 
         # mark positional arguments as required if at least one is
         # always required
         if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
             kwargs['required'] = True
         if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
             kwargs['required'] = True
 
         # return the keyword arguments with no option strings
         return dict(kwargs, dest=dest, option_strings=[])
 

def argparse._ActionsContainer._handle_conflict_error	(	self,
		action,
		conflicting_actions
	)

private

Definition at line 1428 of file argparse.py.

References crabWrapper._, and join().

     def _handle_conflict_error(self, action, conflicting_actions):
         message = _('conflicting option string(s): %s')
         conflict_string = ', '.join([option_string
                                      for option_string, action
                                      in conflicting_actions])
         raise ArgumentError(action, message % conflict_string)
 

def argparse._ActionsContainer._handle_conflict_resolve	(	self,
		action,
		conflicting_actions
	)

private

Definition at line 1435 of file argparse.py.

     def _handle_conflict_resolve(self, action, conflicting_actions):
 
         # remove all conflicting options
         for option_string, action in conflicting_actions:
 
             # remove the conflicting option
             action.option_strings.remove(option_string)
             self._option_string_actions.pop(option_string, None)
 
             # if the option now has no option string, remove it from the
             # container holding it
             if not action.option_strings:
                 action.container._remove_action(action)
 
 

def argparse._ActionsContainer._pop_action_class	(	self,
		kwargs,
		default = `None`
	)

private

Definition at line 1401 of file argparse.py.

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

Referenced by argparse._ActionsContainer.add_argument(), and argparse.ArgumentParser.add_subparsers().

     def _pop_action_class(self, kwargs, default=None):
         action = kwargs.pop('action', default)
         return self._registry_get('action', action, action)
 

def argparse._ActionsContainer._registry_get	(	self,
		registry_name,
		value,
		default = `None`
	)

private

Definition at line 1219 of file argparse.py.

References argparse._ActionsContainer._registries, python.rootplot.argparse._ActionsContainer._registries, python.rootplot.argparse._ArgumentGroup._registries, and reco.get().

Referenced by argparse.ArgumentParser._get_value(), and argparse._ActionsContainer._pop_action_class().

     def _registry_get(self, registry_name, value, default=None):
         return self._registries[registry_name].get(value, default)
 

def argparse._ActionsContainer._remove_action	(	self,
		action
	)

private

Definition at line 1298 of file argparse.py.

     def _remove_action(self, action):
         self._actions.remove(action)
 

def argparse._ActionsContainer.add_argument	(	self,
		args,
		kwargs
	)

add_argument(dest, ..., name=value, ...)
add_argument(option_string, option_string, ..., name=value, ...)

Definition at line 1237 of file argparse.py.

     def add_argument(self, *args, **kwargs):
         """
         add_argument(dest, ..., name=value, ...)
         add_argument(option_string, option_string, ..., name=value, ...)
         """
 
         # if no positional args are supplied or only one is supplied and
         # it doesn't look like an option string, parse a positional
         # argument
         chars = self.prefix_chars
         if not args or len(args) == 1 and args[0][0] not in chars:
             kwargs = self._get_positional_kwargs(*args, **kwargs)
 
         # otherwise, we're adding an optional argument
         else:
             kwargs = self._get_optional_kwargs(*args, **kwargs)
 
         # if no default was supplied, use the parser-level default
         if 'default' not in kwargs:
             dest = kwargs['dest']
             if dest in self._defaults:
                 kwargs['default'] = self._defaults[dest]
             elif self.argument_default is not None:
                 kwargs['default'] = self.argument_default
 
         # create the action object, and add it to the parser
         action_class = self._pop_action_class(kwargs)
         action = action_class(**kwargs)
         return self._add_action(action)
 

def argparse._ActionsContainer.add_argument_group	(	self,
		args,
		kwargs
	)

Definition at line 1267 of file argparse.py.

Referenced by argparse._ActionsContainer._add_container_actions(), and argparse.ArgumentParser.add_subparsers().

     def add_argument_group(self, *args, **kwargs):
         group = _ArgumentGroup(self, *args, **kwargs)
         self._action_groups.append(group)
         return group
 

def argparse._ActionsContainer.add_mutually_exclusive_group	(	self,
		kwargs
	)

Definition at line 1272 of file argparse.py.

Referenced by argparse._ActionsContainer._add_container_actions().

     def add_mutually_exclusive_group(self, **kwargs):
         group = _MutuallyExclusiveGroup(self, **kwargs)
         self._mutually_exclusive_groups.append(group)
         return group
 

def argparse._ActionsContainer.register	(	self,
		registry_name,
		value,
		object
	)

Definition at line 1215 of file argparse.py.

     def register(self, registry_name, value, object):
         registry = self._registries.setdefault(registry_name, {})
         registry[value] = object
 

def argparse._ActionsContainer.set_defaults	(	self,
		kwargs
	)

Definition at line 1225 of file argparse.py.

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

     def set_defaults(self, **kwargs):
         self._defaults.update(kwargs)
 
         # if these defaults match any existing arguments, replace
         # the previous default on the object with the new one
         for action in self._actions:
             if action.dest in kwargs:
                 action.default = kwargs[action.dest]
 