Inheritance diagram for argparse.HelpFormatter:

Classes
class	_Section

Public Member Functions
def	__init__ (self, prog, indent_increment=2, max_help_position=24, width=None)

def	add_argument (self, action)

def	add_arguments (self, actions)

def	add_text (self, text)

def	add_usage (self, usage, actions, groups, prefix=None)

def	end_section (self)

def	format_help (self)

def	start_section (self, heading)

Private Member Functions
def	_add_item (self, func, args)

def	_dedent (self)

def	_expand_help (self, action)

def	_fill_text (self, text, width, indent)

def	_format_action (self, action)

def	_format_action_invocation (self, action)

def	_format_actions_usage (self, actions, groups)

def	_format_args (self, action, default_metavar)

def	_format_text (self, text)

def	_format_usage (self, usage, actions, groups, prefix)

def	_get_help_string (self, action)

def	_indent (self)

def	_iter_indented_subactions (self, action)

def	_join_parts (self, part_strings)

def	_metavar_formatter (self, action, default_metavar)

def	_split_lines (self, text, width)

Private Attributes
	_action_max_length

	_current_indent

	_current_section

	_indent_increment

	_level

	_long_break_matcher

	_max_help_position

	_prog

	_root_section

	_whitespace_matcher

	_width

Detailed Description

Formatter for generating usage messages and argument help strings.

Only the name of this class is considered a public API. All the methods
provided by the class are considered an implementation detail.

Definition at line 177 of file argparse.py.

Constructor & Destructor Documentation

def argparse.HelpFormatter.__init__	(	self,
		prog,
		indent_increment = `2`,
		max_help_position = `24`,
		width = `None`
	)

Definition at line 188 of file argparse.py.

References createfilelist.int.

                  width=None):
 
         # default setting for width
         if width is None:
             try:
                 width = int(_os.environ['COLUMNS'])
             except (KeyError, ValueError):
                 width = 80
             width -= 2
 
         self._prog = prog
         self._indent_increment = indent_increment
         self._max_help_position = max_help_position
         self._width = width
 
         self._current_indent = 0
         self._level = 0
         self._action_max_length = 0
 
         self._root_section = self._Section(self, None)
         self._current_section = self._root_section
 
         self._whitespace_matcher = _re.compile(r'\s+')
         self._long_break_matcher = _re.compile(r'\n\n\n+')
 

Member Function Documentation

def argparse.HelpFormatter._add_item	(	self,
		func,
		args
	)

private

Definition at line 258 of file argparse.py.

Referenced by argparse.HelpFormatter.add_argument(), argparse.HelpFormatter.add_text(), argparse.HelpFormatter.add_usage(), and argparse.HelpFormatter.start_section().

     def _add_item(self, func, args):
         self._current_section.items.append((func, args))
 

def argparse.HelpFormatter._dedent ( self )

private

Definition at line 220 of file argparse.py.

References argparse.HelpFormatter._current_indent, python.rootplot.argparse.HelpFormatter._current_indent, argparse.HelpFormatter._indent_increment, python.rootplot.argparse.HelpFormatter._indent_increment, PGeometricDet::Item._level, RPCMuonExtraStruct._level, TrackerGeometryCompare._level, MuonGeometryArrange._level, argparse.HelpFormatter._level, and python.rootplot.argparse.HelpFormatter._level.

Referenced by argparse.HelpFormatter._iter_indented_subactions(), and argparse.HelpFormatter.end_section().

     def _dedent(self):
         self._current_indent -= self._indent_increment
         assert self._current_indent >= 0, 'Indent decreased below 0.'
         self._level -= 1
 

def argparse.HelpFormatter._expand_help	(	self,
		action
	)

private

Definition at line 610 of file argparse.py.

References argparse.HelpFormatter._get_help_string(), python.rootplot.argparse.HelpFormatter._get_help_string(), python.rootplot.argparse.ArgumentDefaultsHelpFormatter._get_help_string(), argparse.HelpFormatter._prog, python.rootplot.argparse.HelpFormatter._prog, cmsPerfStripChart.dict, join(), list(), and harvestTrackValidationPlots.str.

Referenced by argparse.HelpFormatter._format_action().

     def _expand_help(self, action):
         params = dict(vars(action), prog=self._prog)
         for name in list(params):
             if params[name] is SUPPRESS:
                 del params[name]
         if params.get('choices') is not None:
             choices_str = ', '.join([str(c) for c in params['choices']])
             params['choices'] = choices_str
         return self._get_help_string(action) % params
 

def argparse.HelpFormatter._fill_text	(	self,
		text,
		width,
		indent
	)

private

Definition at line 635 of file argparse.py.

References digi_MixPreMix_cfi.strip.

Referenced by argparse.HelpFormatter._format_text().

     def _fill_text(self, text, width, indent):
         text = self._whitespace_matcher.sub(' ', text).strip()
         return _textwrap.fill(text, width, initial_indent=indent,
                                            subsequent_indent=indent)
 

def argparse.HelpFormatter._format_action	(	self,
		action
	)

private

Definition at line 507 of file argparse.py.

Referenced by argparse.HelpFormatter._format_action(), and argparse.HelpFormatter.add_argument().

     def _format_action(self, action):
         # determine the required width and the entry label
         help_position = min(self._action_max_length + 2,
                             self._max_help_position)
         help_width = self._width - help_position
         action_width = help_position - self._current_indent - 2
         action_header = self._format_action_invocation(action)
 
         # ho nelp; start on same line and add a final newline
         if not action.help:
             tup = self._current_indent, '', action_header
             action_header = '%*s%s\n' % tup
 
         # short action name; start on the same line and pad two spaces
         elif len(action_header) <= action_width:
             tup = self._current_indent, '', action_width, action_header
             action_header = '%*s%-*s  ' % tup
             indent_first = 0
 
         # long action name; start on the next line
         else:
             tup = self._current_indent, '', action_header
             action_header = '%*s%s\n' % tup
             indent_first = help_position
 
         # collect the pieces of the action help
         parts = [action_header]
 
         # if there was help for the action, add lines of help text
         if action.help:
             help_text = self._expand_help(action)
             help_lines = self._split_lines(help_text, help_width)
             parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
             for line in help_lines[1:]:
                 parts.append('%*s%s\n' % (help_position, '', line))
 
         # or add a newline if the description doesn't end with one
         elif not action_header.endswith('\n'):
             parts.append('\n')
 
         # if there are any sub-actions, add their help as well
         for subaction in self._iter_indented_subactions(action):
             parts.append(self._format_action(subaction))
 
         # return a single string
         return self._join_parts(parts)
 

def argparse.HelpFormatter._format_action_invocation	(	self,
		action
	)

private

Definition at line 554 of file argparse.py.

References argparse.HelpFormatter._format_args(), python.rootplot.argparse.HelpFormatter._format_args(), argparse.HelpFormatter._metavar_formatter(), python.rootplot.argparse.HelpFormatter._metavar_formatter(), and join().

Referenced by argparse.HelpFormatter._format_action(), and argparse.HelpFormatter.add_argument().

     def _format_action_invocation(self, action):
         if not action.option_strings:
             metavar, = self._metavar_formatter(action, action.dest)(1)
             return metavar
 
         else:
             parts = []
 
             # if the Optional doesn't take a value, format is:
             #    -s, --long
             if action.nargs == 0:
                 parts.extend(action.option_strings)
 
             # if the Optional takes a value, format is:
             #    -s ARGS, --long ARGS
             else:
                 default = action.dest.upper()
                 args_string = self._format_args(action, default)
                 for option_string in action.option_strings:
                     parts.append('%s %s' % (option_string, args_string))
 
             return ', '.join(parts)
 

def argparse.HelpFormatter._format_actions_usage	(	self,
		actions,
		groups
	)

private

Definition at line 412 of file argparse.py.

References argparse.HelpFormatter._format_args(), python.rootplot.argparse.HelpFormatter._format_args(), argparse._set, argparse._sorted, and join().

Referenced by argparse.HelpFormatter._format_usage().

     def _format_actions_usage(self, actions, groups):
         # find group indices and identify actions in groups
         group_actions = _set()
         inserts = {}
         for group in groups:
             try:
                 start = actions.index(group._group_actions[0])
             except ValueError:
                 continue
             else:
                 end = start + len(group._group_actions)
                 if actions[start:end] == group._group_actions:
                     for action in group._group_actions:
                         group_actions.add(action)
                     if not group.required:
                         inserts[start] = '['
                         inserts[end] = ']'
                     else:
                         inserts[start] = '('
                         inserts[end] = ')'
                     for i in range(start + 1, end):
                         inserts[i] = '|'
 
         # collect all actions format strings
         parts = []
         for i, action in enumerate(actions):
 
             # suppressed arguments are marked with None
             # remove | separators for suppressed arguments
             if action.help is SUPPRESS:
                 parts.append(None)
                 if inserts.get(i) == '|':
                     inserts.pop(i)
                 elif inserts.get(i + 1) == '|':
                     inserts.pop(i + 1)
 
             # produce all arg strings
             elif not action.option_strings:
                 part = self._format_args(action, action.dest)
 
                 # if it's in a group, strip the outer []
                 if action in group_actions:
                     if part[0] == '[' and part[-1] == ']':
                         part = part[1:-1]
 
                 # add the action string to the list
                 parts.append(part)
 
             # produce the first way to invoke the option in brackets
             else:
                 option_string = action.option_strings[0]
 
                 # if the Optional doesn't take a value, format is:
                 #    -s or --long
                 if action.nargs == 0:
                     part = '%s' % option_string
 
                 # if the Optional takes a value, format is:
                 #    -s ARGS or --long ARGS
                 else:
                     default = action.dest.upper()
                     args_string = self._format_args(action, default)
                     part = '%s %s' % (option_string, args_string)
 
                 # make it look optional if it's not required or in a group
                 if not action.required and action not in group_actions:
                     part = '[%s]' % part
 
                 # add the action string to the list
                 parts.append(part)
 
         # insert things at the necessary indices
         for i in _sorted(inserts, reverse=True):
             parts[i:i] = [inserts[i]]
 
         # join all the action items with spaces
         text = ' '.join([item for item in parts if item is not None])
 
         # clean up separators for mutually exclusive groups
         open = r'[\[(]'
         close = r'[\])]'
         text = _re.sub(r'(%s) ' % open, r'\1', text)
         text = _re.sub(r' (%s)' % close, r'\1', text)
         text = _re.sub(r'%s *%s' % (open, close), r'', text)
         text = _re.sub(r'\(([^|]*)\)', r'\1', text)
         text = text.strip()
 
         # return the text
         return text
 

def argparse.HelpFormatter._format_args	(	self,
		action,
		default_metavar
	)

private

Definition at line 593 of file argparse.py.

References argparse.HelpFormatter._metavar_formatter(), python.rootplot.argparse.HelpFormatter._metavar_formatter(), and join().

Referenced by argparse.HelpFormatter._format_action_invocation(), and argparse.HelpFormatter._format_actions_usage().

     def _format_args(self, action, default_metavar):
         get_metavar = self._metavar_formatter(action, default_metavar)
         if action.nargs is None:
             result = '%s' % get_metavar(1)
         elif action.nargs == OPTIONAL:
             result = '[%s]' % get_metavar(1)
         elif action.nargs == ZERO_OR_MORE:
             result = '[%s [%s ...]]' % get_metavar(2)
         elif action.nargs == ONE_OR_MORE:
             result = '%s [%s ...]' % get_metavar(2)
         elif action.nargs is PARSER:
             result = '%s ...' % get_metavar(1)
         else:
             formats = ['%s' for _ in range(action.nargs)]
             result = ' '.join(formats) % get_metavar(action.nargs)
         return result
 

def argparse.HelpFormatter._format_text	(	self,
		text
	)

private

Definition at line 502 of file argparse.py.

References argparse.HelpFormatter._current_indent, python.rootplot.argparse.HelpFormatter._current_indent, argparse.HelpFormatter._fill_text(), python.rootplot.argparse.HelpFormatter._fill_text(), python.rootplot.argparse.RawDescriptionHelpFormatter._fill_text(), Vispa.Main.RotatingIcon.RotatingIcon._width, Vispa.Gui.VispaWidget.TextField._width, TFitConstraintMGaus._width, argparse.HelpFormatter._width, and python.rootplot.argparse.HelpFormatter._width.

Referenced by argparse.HelpFormatter.add_text().

     def _format_text(self, text):
         text_width = self._width - self._current_indent
         indent = ' ' * self._current_indent
         return self._fill_text(text, text_width, indent) + '\n\n'
 

def argparse.HelpFormatter._format_usage	(	self,
		usage,
		actions,
		groups,
		prefix
	)

private

Definition at line 320 of file argparse.py.

References crabWrapper._, argparse.HelpFormatter._current_indent, python.rootplot.argparse.HelpFormatter._current_indent, argparse.HelpFormatter._format_actions_usage(), python.rootplot.argparse.HelpFormatter._format_actions_usage(), argparse.HelpFormatter._prog, python.rootplot.argparse.HelpFormatter._prog, Vispa.Main.RotatingIcon.RotatingIcon._width, Vispa.Gui.VispaWidget.TextField._width, TFitConstraintMGaus._width, argparse.HelpFormatter._width, python.rootplot.argparse.HelpFormatter._width, cmsPerfStripChart.dict, and join().

Referenced by argparse.HelpFormatter.add_usage().

     def _format_usage(self, usage, actions, groups, prefix):
         if prefix is None:
             prefix = _('usage: ')
 
         # if usage is specified, use that
         if usage is not None:
             usage = usage % dict(prog=self._prog)
 
         # if no optionals or positionals are available, usage is just prog
         elif usage is None and not actions:
             usage = '%(prog)s' % dict(prog=self._prog)
 
         # if optionals and positionals are available, calculate usage
         elif usage is None:
             prog = '%(prog)s' % dict(prog=self._prog)
 
             # split optionals from positionals
             optionals = []
             positionals = []
             for action in actions:
                 if action.option_strings:
                     optionals.append(action)
                 else:
                     positionals.append(action)
 
             # build full usage string
             format = self._format_actions_usage
             action_usage = format(optionals + positionals, groups)
             usage = ' '.join([s for s in [prog, action_usage] if s])
 
             # wrap the usage parts if it's too long
             text_width = self._width - self._current_indent
             if len(prefix) + len(usage) > text_width:
 
                 # break usage into wrappable parts
                 part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'
                 opt_usage = format(optionals, groups)
                 pos_usage = format(positionals, groups)
                 opt_parts = _re.findall(part_regexp, opt_usage)
                 pos_parts = _re.findall(part_regexp, pos_usage)
                 assert ' '.join(opt_parts) == opt_usage
                 assert ' '.join(pos_parts) == pos_usage
 
                 # helper for wrapping lines
                 def get_lines(parts, indent, prefix=None):
                     lines = []
                     line = []
                     if prefix is not None:
                         line_len = len(prefix) - 1
                     else:
                         line_len = len(indent) - 1
                     for part in parts:
                         if line_len + 1 + len(part) > text_width:
                             lines.append(indent + ' '.join(line))
                             line = []
                             line_len = len(indent) - 1
                         line.append(part)
                         line_len += len(part) + 1
                     if line:
                         lines.append(indent + ' '.join(line))
                     if prefix is not None:
                         lines[0] = lines[0][len(indent):]
                     return lines
 
                 # if prog is short, follow it with optionals or positionals
                 if len(prefix) + len(prog) <= 0.75 * text_width:
                     indent = ' ' * (len(prefix) + len(prog) + 1)
                     if opt_parts:
                         lines = get_lines([prog] + opt_parts, indent, prefix)
                         lines.extend(get_lines(pos_parts, indent))
                     elif pos_parts:
                         lines = get_lines([prog] + pos_parts, indent, prefix)
                     else:
                         lines = [prog]
 
                 # if prog is long, put it on its own line
                 else:
                     indent = ' ' * len(prefix)
                     parts = opt_parts + pos_parts
                     lines = get_lines(parts, indent)
                     if len(lines) > 1:
                         lines = []
                         lines.extend(get_lines(opt_parts, indent))
                         lines.extend(get_lines(pos_parts, indent))
                     lines = [prog] + lines
 
                 # join lines into usage
                 usage = '\n'.join(lines)
 
         # prefix with 'usage:'
         return '%s%s\n\n' % (prefix, usage)
 

def argparse.HelpFormatter._get_help_string	(	self,
		action
	)

private

Definition at line 640 of file argparse.py.

Referenced by argparse.HelpFormatter._expand_help().

     def _get_help_string(self, action):
         return action.help

def argparse.HelpFormatter._indent ( self )

private

Definition at line 216 of file argparse.py.

References argparse.HelpFormatter._current_indent, python.rootplot.argparse.HelpFormatter._current_indent, argparse.HelpFormatter._indent_increment, python.rootplot.argparse.HelpFormatter._indent_increment, PGeometricDet::Item._level, RPCMuonExtraStruct._level, TrackerGeometryCompare._level, MuonGeometryArrange._level, argparse.HelpFormatter._level, and python.rootplot.argparse.HelpFormatter._level.

Referenced by argparse.HelpFormatter._iter_indented_subactions(), ntuplePrintersDiff._IndentPrinter.indent(), ntuplePrintersDiff._IndentPrinter.setIndentFrom(), and argparse.HelpFormatter.start_section().

     def _indent(self):
         self._current_indent += self._indent_increment
         self._level += 1
 

def argparse.HelpFormatter._iter_indented_subactions	(	self,
		action
	)

private

Definition at line 620 of file argparse.py.

References argparse.HelpFormatter._dedent(), python.rootplot.argparse.HelpFormatter._dedent(), argparse.HelpFormatter._indent(), and python.rootplot.argparse.HelpFormatter._indent().

Referenced by argparse.HelpFormatter._format_action(), and argparse.HelpFormatter.add_argument().

     def _iter_indented_subactions(self, action):
         try:
             get_subactions = action._get_subactions
         except AttributeError:
             pass
         else:
             self._indent()
             for subaction in get_subactions():
                 yield subaction
             self._dedent()
 

def argparse.HelpFormatter._join_parts	(	self,
		part_strings
	)

private

Definition at line 315 of file argparse.py.

References join().

Referenced by argparse.HelpFormatter._format_action().

     def _join_parts(self, part_strings):
         return ''.join([part
                         for part in part_strings
                         if part and part is not SUPPRESS])
 

def argparse.HelpFormatter._metavar_formatter	(	self,
		action,
		default_metavar
	)

private

Definition at line 577 of file argparse.py.

References cmsPerfStripChart.format, join(), and harvestTrackValidationPlots.str.

Referenced by argparse.HelpFormatter._format_action_invocation(), and argparse.HelpFormatter._format_args().

     def _metavar_formatter(self, action, default_metavar):
         if action.metavar is not None:
             result = action.metavar
         elif action.choices is not None:
             choice_strs = [str(choice) for choice in action.choices]
             result = '{%s}' % ','.join(choice_strs)
         else:
             result = default_metavar
 
         def format(tuple_size):
             if isinstance(result, tuple):
                 return result
             else:
                 return (result, ) * tuple_size
         return format
 

def argparse.HelpFormatter._split_lines	(	self,
		text,
		width
	)

private

Definition at line 631 of file argparse.py.

References digi_MixPreMix_cfi.strip.

Referenced by argparse.HelpFormatter._format_action().

     def _split_lines(self, text, width):
         text = self._whitespace_matcher.sub(' ', text).strip()
         return _textwrap.wrap(text, width)
 

def argparse.HelpFormatter.add_argument	(	self,
		action
	)

Definition at line 283 of file argparse.py.

Referenced by argparse.HelpFormatter.add_arguments().

     def add_argument(self, action):
         if action.help is not SUPPRESS:
 
             # find all invocations
             get_invocation = self._format_action_invocation
             invocations = [get_invocation(action)]
             for subaction in self._iter_indented_subactions(action):
                 invocations.append(get_invocation(subaction))
 
             # update the maximum item length
             invocation_length = max([len(s) for s in invocations])
             action_length = invocation_length + self._current_indent
             self._action_max_length = max(self._action_max_length,
                                           action_length)
 
             # add the item to the list
             self._add_item(self._format_action, [action])
 

def argparse.HelpFormatter.add_arguments	(	self,
		actions
	)

Definition at line 301 of file argparse.py.

References argparse.HelpFormatter.add_argument(), python.rootplot.argparse.HelpFormatter.add_argument(), and python.rootplot.argparse._ActionsContainer.add_argument().

     def add_arguments(self, actions):
         for action in actions:
             self.add_argument(action)
 

def argparse.HelpFormatter.add_text	(	self,
		text
	)

Definition at line 274 of file argparse.py.

References argparse.HelpFormatter._add_item(), python.rootplot.argparse.HelpFormatter._add_item(), argparse.HelpFormatter._format_text(), and python.rootplot.argparse.HelpFormatter._format_text().

     def add_text(self, text):
         if text is not SUPPRESS and text is not None:
             self._add_item(self._format_text, [text])
 

def argparse.HelpFormatter.add_usage	(	self,
		usage,
		actions,
		groups,
		prefix = `None`
	)

Definition at line 278 of file argparse.py.

References argparse.HelpFormatter._add_item(), python.rootplot.argparse.HelpFormatter._add_item(), argparse.HelpFormatter._format_usage(), and python.rootplot.argparse.HelpFormatter._format_usage().

     def add_usage(self, usage, actions, groups, prefix=None):
         if usage is not SUPPRESS:
             args = usage, actions, groups, prefix
             self._add_item(self._format_usage, args)
 

def argparse.HelpFormatter.end_section ( self )

Definition at line 270 of file argparse.py.

References argparse.HelpFormatter._current_section, python.rootplot.argparse.HelpFormatter._current_section, argparse.HelpFormatter._dedent(), and python.rootplot.argparse.HelpFormatter._dedent().

     def end_section(self):
         self._current_section = self._current_section.parent
         self._dedent()
 

def argparse.HelpFormatter.format_help ( self )

Definition at line 308 of file argparse.py.

Referenced by argparse.ArgumentParser.print_help().

     def format_help(self):
         help = self._root_section.format_help()
         if help:
             help = self._long_break_matcher.sub('\n\n', help)
             help = help.strip('\n') + '\n'
         return help
 

def argparse.HelpFormatter.start_section	(	self,
		heading
	)

Definition at line 264 of file argparse.py.

References argparse.HelpFormatter._add_item(), python.rootplot.argparse.HelpFormatter._add_item(), argparse.HelpFormatter._current_section, python.rootplot.argparse.HelpFormatter._current_section, argparse.HelpFormatter._indent(), and python.rootplot.argparse.HelpFormatter._indent().

     def start_section(self, heading):
         self._indent()
         section = self._Section(self, self._current_section, heading)
         self._add_item(section.format_help, [])
         self._current_section = section
 