argo_navis: venv/lib/python2.7/site-packages/docutils/frontend.py comparison

comparison venv/lib/python2.7/site-packages/docutils/frontend.py @ 0:d67268158946 draft

planemo upload commit a3f181f5f126803c654b3a66dd4e83a48f7e203b

author	bcclaywell
date	Mon, 12 Oct 2015 17:43:33 -0400
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:d67268158946
+# $Id: frontend.py 7584 2013-01-01 20:00:21Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+"""
+Command-line and common processing for Docutils front-end tools.
+Exports the following classes:
+* `OptionParser`: Standard Docutils command-line processing.
+* `Option`: Customized version of `optparse.Option`; validation support.
+* `Values`: Runtime settings; objects are simple structs
+(``object.attribute``).  Supports cumulative list settings (attributes).
+* `ConfigParser`: Standard Docutils config file processing.
+Also exports the following functions:
+* Option callbacks: `store_multiple`, `read_config_file`.
+* Setting validators: `validate_encoding`,
+`validate_encoding_error_handler`,
+`validate_encoding_and_error_handler`,
+`validate_boolean`, `validate_ternary`, `validate_threshold`,
+`validate_colon_separated_string_list`,
+`validate_comma_separated_string_list`,
+`validate_dependency_file`.
+* `make_paths_absolute`.
+* SettingSpec manipulation: `filter_settings_spec`.
+"""
+__docformat__ = 'reStructuredText'
+import os
+import os.path
+import sys
+import warnings
+import ConfigParser as CP
+import codecs
+import optparse
+from optparse import SUPPRESS_HELP
+import docutils
+import docutils.utils
+import docutils.nodes
+from docutils.utils.error_reporting import locale_encoding, ErrorOutput, ErrorString
+def store_multiple(option, opt, value, parser, *args, **kwargs):
+"""
+Store multiple values in `parser.values`.  (Option callback.)
+Store `None` for each attribute named in `args`, and store the value for
+each key (attribute name) in `kwargs`.
+"""
+for attribute in args:
+setattr(parser.values, attribute, None)
+for key, value in kwargs.items():
+setattr(parser.values, key, value)
+def read_config_file(option, opt, value, parser):
+"""
+Read a configuration file during option processing.  (Option callback.)
+"""
+try:
+new_settings = parser.get_config_file_settings(value)
+except ValueError, error:
+parser.error(error)
+parser.values.update(new_settings, parser)
+def validate_encoding(setting, value, option_parser,
+config_parser=None, config_section=None):
+try:
+codecs.lookup(value)
+except LookupError:
+raise (LookupError('setting "%s": unknown encoding: "%s"'
+% (setting, value)),
+None, sys.exc_info()[2])
+return value
+def validate_encoding_error_handler(setting, value, option_parser,
+config_parser=None, config_section=None):
+try:
+codecs.lookup_error(value)
+except LookupError:
+raise (LookupError(
+'unknown encoding error handler: "%s" (choices: '
+'"strict", "ignore", "replace", "backslashreplace", '
+'"xmlcharrefreplace", and possibly others; see documentation for '
+'the Python ``codecs`` module)' % value),
+None, sys.exc_info()[2])
+return value
+def validate_encoding_and_error_handler(
+setting, value, option_parser, config_parser=None, config_section=None):
+"""
+Side-effect: if an error handler is included in the value, it is inserted
+into the appropriate place as if it was a separate setting/option.
+"""
+if ':' in value:
+encoding, handler = value.split(':')
+validate_encoding_error_handler(
+setting + '_error_handler', handler, option_parser,
+config_parser, config_section)
+if config_parser:
+config_parser.set(config_section, setting + '_error_handler',
+handler)
+else:
+setattr(option_parser.values, setting + '_error_handler', handler)
+else:
+encoding = value
+validate_encoding(setting, encoding, option_parser,
+config_parser, config_section)
+return encoding
+def validate_boolean(setting, value, option_parser,
+config_parser=None, config_section=None):
+"""Check/normalize boolean settings:
+True:  '1', 'on', 'yes', 'true'
+False: '0', 'off', 'no','false', ''
+"""
+if isinstance(value, bool):
+return value
+try:
+return option_parser.booleans[value.strip().lower()]
+except KeyError:
+raise (LookupError('unknown boolean value: "%s"' % value),
+None, sys.exc_info()[2])
+def validate_ternary(setting, value, option_parser,
+config_parser=None, config_section=None):
+"""Check/normalize three-value settings:
+True:  '1', 'on', 'yes', 'true'
+False: '0', 'off', 'no','false', ''
+any other value: returned as-is.
+"""
+if isinstance(value, bool) or value is None:
+return value
+try:
+return option_parser.booleans[value.strip().lower()]
+except KeyError:
+return value
+def validate_nonnegative_int(setting, value, option_parser,
+config_parser=None, config_section=None):
+value = int(value)
+if value < 0:
+raise ValueError('negative value; must be positive or zero')
+return value
+def validate_threshold(setting, value, option_parser,
+config_parser=None, config_section=None):
+try:
+return int(value)
+except ValueError:
+try:
+return option_parser.thresholds[value.lower()]
+except (KeyError, AttributeError):
+raise (LookupError('unknown threshold: %r.' % value),
+None, sys.exc_info[2])
+def validate_colon_separated_string_list(
+setting, value, option_parser, config_parser=None, config_section=None):
+if not isinstance(value, list):
+value = value.split(':')
+else:
+last = value.pop()
+value.extend(last.split(':'))
+return value
+def validate_comma_separated_list(setting, value, option_parser,
+config_parser=None, config_section=None):
+"""Check/normalize list arguments (split at "," and strip whitespace).
+"""
+# `value` is already a ``list`` when  given as command line option
+# and "action" is "append" and ``unicode`` or ``str`` else.
+if not isinstance(value, list):
+value = [value]
+# this function is called for every option added to `value`
+# -> split the last item and append the result:
+last = value.pop()
+items = [i.strip(u' \t\n') for i in last.split(u',') if i.strip(u' \t\n')]
+value.extend(items)
+return value
+def validate_url_trailing_slash(
+setting, value, option_parser, config_parser=None, config_section=None):
+if not value:
+return './'
+elif value.endswith('/'):
+return value
+else:
+return value + '/'
+def validate_dependency_file(setting, value, option_parser,
+config_parser=None, config_section=None):
+try:
+return docutils.utils.DependencyList(value)
+except IOError:
+return docutils.utils.DependencyList(None)
+def validate_strip_class(setting, value, option_parser,
+config_parser=None, config_section=None):
+# value is a comma separated string list:
+value = validate_comma_separated_list(setting, value, option_parser,
+config_parser, config_section)
+# validate list elements:
+for cls in value:
+normalized = docutils.nodes.make_id(cls)
+if cls != normalized:
+raise ValueError('invalid class value %r (perhaps %r?)'
+% (cls, normalized))
+return value
+def make_paths_absolute(pathdict, keys, base_path=None):
+"""
+Interpret filesystem path settings relative to the `base_path` given.
+Paths are values in `pathdict` whose keys are in `keys`.  Get `keys` from
+`OptionParser.relative_path_settings`.
+"""
+if base_path is None:
+base_path = os.getcwdu() # type(base_path) == unicode
+# to allow combining non-ASCII cwd with unicode values in `pathdict`
+for key in keys:
+if key in pathdict:
+value = pathdict[key]
+if isinstance(value, list):
+value = [make_one_path_absolute(base_path, path)
+for path in value]
+elif value:
+value = make_one_path_absolute(base_path, value)
+pathdict[key] = value
+def make_one_path_absolute(base_path, path):
+return os.path.abspath(os.path.join(base_path, path))
+def filter_settings_spec(settings_spec, *exclude, **replace):
+"""Return a copy of `settings_spec` excluding/replacing some settings.
+`settings_spec` is a tuple of configuration settings with a structure
+described for docutils.SettingsSpec.settings_spec.
+Optional positional arguments are names of to-be-excluded settings.
+Keyword arguments are option specification replacements.
+(See the html4strict writer for an example.)
+"""
+settings = list(settings_spec)
+# every third item is a sequence of option tuples
+for i in range(2, len(settings), 3):
+newopts = []
+for opt_spec in settings[i]:
+# opt_spec is ("<help>", [<option strings>], {<keyword args>})
+opt_name = [opt_string[2:].replace('-', '_')
+for opt_string in opt_spec[1]
+if opt_string.startswith('--')
+][0]
+if opt_name in exclude:
+continue
+if opt_name in replace.keys():
+newopts.append(replace[opt_name])
+else:
+newopts.append(opt_spec)
+settings[i] = tuple(newopts)
+return tuple(settings)
+class Values(optparse.Values):
+"""
+Updates list attributes by extension rather than by replacement.
+Works in conjunction with the `OptionParser.lists` instance attribute.
+"""
+def __init__(self, *args, **kwargs):
+optparse.Values.__init__(self, *args, **kwargs)
+if (not hasattr(self, 'record_dependencies')
+or self.record_dependencies is None):
+# Set up dependency list, in case it is needed.
+self.record_dependencies = docutils.utils.DependencyList()
+def update(self, other_dict, option_parser):
+if isinstance(other_dict, Values):
+other_dict = other_dict.__dict__
+other_dict = other_dict.copy()
+for setting in option_parser.lists.keys():
+if (hasattr(self, setting) and setting in other_dict):
+value = getattr(self, setting)
+if value:
+value += other_dict[setting]
+del other_dict[setting]
+self._update_loose(other_dict)
+def copy(self):
+"""Return a shallow copy of `self`."""
+return self.__class__(defaults=self.__dict__)
+class Option(optparse.Option):
+ATTRS = optparse.Option.ATTRS + ['validator', 'overrides']
+def process(self, opt, value, values, parser):
+"""
+Call the validator function on applicable settings and
+evaluate the 'overrides' option.
+Extends `optparse.Option.process`.
+"""
+result = optparse.Option.process(self, opt, value, values, parser)
+setting = self.dest
+if setting:
+if self.validator:
+value = getattr(values, setting)
+try:
+new_value = self.validator(setting, value, parser)
+except Exception, error:
+raise (optparse.OptionValueError(
+'Error in option "%s":\n    %s'
+% (opt, ErrorString(error))),
+None, sys.exc_info()[2])
+setattr(values, setting, new_value)
+if self.overrides:
+setattr(values, self.overrides, None)
+return result
+class OptionParser(optparse.OptionParser, docutils.SettingsSpec):
+"""
+Parser for command-line and library use.  The `settings_spec`
+specification here and in other Docutils components are merged to build
+the set of command-line options and runtime settings for this process.
+Common settings (defined below) and component-specific settings must not
+conflict.  Short options are reserved for common settings, and components
+are restrict to using long options.
+"""
+standard_config_files = [
+'/etc/docutils.conf',           # system-wide
+'./docutils.conf',              # project-specific
+'~/.docutils']                  # user-specific
+"""Docutils configuration files, using ConfigParser syntax.  Filenames
+will be tilde-expanded later.  Later files override earlier ones."""
+threshold_choices = 'info 1 warning 2 error 3 severe 4 none 5'.split()
+"""Possible inputs for for --report and --halt threshold values."""
+thresholds = {'info': 1, 'warning': 2, 'error': 3, 'severe': 4, 'none': 5}
+"""Lookup table for --report and --halt threshold values."""
+booleans={'1': True, 'on': True, 'yes': True, 'true': True,
+'0': False, 'off': False, 'no': False, 'false': False, '': False}
+"""Lookup table for boolean configuration file settings."""
+default_error_encoding = getattr(sys.stderr, 'encoding',
+None) or locale_encoding or 'ascii'
+default_error_encoding_error_handler = 'backslashreplace'
+settings_spec = (
+'General Docutils Options',
+None,
+(('Specify the document title as metadata.',
+['--title'], {}),
+('Include a "Generated by Docutils" credit and link.',
+['--generator', '-g'], {'action': 'store_true',
+'validator': validate_boolean}),
+('Do not include a generator credit.',
+['--no-generator'], {'action': 'store_false', 'dest': 'generator'}),
+('Include the date at the end of the document (UTC).',
+['--date', '-d'], {'action': 'store_const', 'const': '%Y-%m-%d',
+'dest': 'datestamp'}),
+('Include the time & date (UTC).',
+['--time', '-t'], {'action': 'store_const',
+'const': '%Y-%m-%d %H:%M UTC',
+'dest': 'datestamp'}),
+('Do not include a datestamp of any kind.',
+['--no-datestamp'], {'action': 'store_const', 'const': None,
+'dest': 'datestamp'}),
+('Include a "View document source" link.',
+['--source-link', '-s'], {'action': 'store_true',
+'validator': validate_boolean}),
+('Use <URL> for a source link; implies --source-link.',
+['--source-url'], {'metavar': '<URL>'}),
+('Do not include a "View document source" link.',
+['--no-source-link'],
+{'action': 'callback', 'callback': store_multiple,
+'callback_args': ('source_link', 'source_url')}),
+('Link from section headers to TOC entries.  (default)',
+['--toc-entry-backlinks'],
+{'dest': 'toc_backlinks', 'action': 'store_const', 'const': 'entry',
+'default': 'entry'}),
+('Link from section headers to the top of the TOC.',
+['--toc-top-backlinks'],
+{'dest': 'toc_backlinks', 'action': 'store_const', 'const': 'top'}),
+('Disable backlinks to the table of contents.',
+['--no-toc-backlinks'],
+{'dest': 'toc_backlinks', 'action': 'store_false'}),
+('Link from footnotes/citations to references. (default)',
+['--footnote-backlinks'],
+{'action': 'store_true', 'default': 1,
+'validator': validate_boolean}),
+('Disable backlinks from footnotes and citations.',
+['--no-footnote-backlinks'],
+{'dest': 'footnote_backlinks', 'action': 'store_false'}),
+('Enable section numbering by Docutils.  (default)',
+['--section-numbering'],
+{'action': 'store_true', 'dest': 'sectnum_xform',
+'default': 1, 'validator': validate_boolean}),
+('Disable section numbering by Docutils.',
+['--no-section-numbering'],
+{'action': 'store_false', 'dest': 'sectnum_xform'}),
+('Remove comment elements from the document tree.',
+['--strip-comments'],
+{'action': 'store_true', 'validator': validate_boolean}),
+('Leave comment elements in the document tree. (default)',
+['--leave-comments'],
+{'action': 'store_false', 'dest': 'strip_comments'}),
+('Remove all elements with classes="<class>" from the document tree. '
+'Warning: potentially dangerous; use with caution. '
+'(Multiple-use option.)',
+['--strip-elements-with-class'],
+{'action': 'append', 'dest': 'strip_elements_with_classes',
+'metavar': '<class>', 'validator': validate_strip_class}),
+('Remove all classes="<class>" attributes from elements in the '
+'document tree. Warning: potentially dangerous; use with caution. '
+'(Multiple-use option.)',
+['--strip-class'],
+{'action': 'append', 'dest': 'strip_classes',
+'metavar': '<class>', 'validator': validate_strip_class}),
+('Report system messages at or higher than <level>: "info" or "1", '
+'"warning"/"2" (default), "error"/"3", "severe"/"4", "none"/"5"',
+['--report', '-r'], {'choices': threshold_choices, 'default': 2,
+'dest': 'report_level', 'metavar': '<level>',
+'validator': validate_threshold}),
+('Report all system messages.  (Same as "--report=1".)',
+['--verbose', '-v'], {'action': 'store_const', 'const': 1,
+'dest': 'report_level'}),
+('Report no system messages.  (Same as "--report=5".)',
+['--quiet', '-q'], {'action': 'store_const', 'const': 5,
+'dest': 'report_level'}),
+('Halt execution at system messages at or above <level>.  '
+'Levels as in --report.  Default: 4 (severe).',
+['--halt'], {'choices': threshold_choices, 'dest': 'halt_level',
+'default': 4, 'metavar': '<level>',
+'validator': validate_threshold}),
+('Halt at the slightest problem.  Same as "--halt=info".',
+['--strict'], {'action': 'store_const', 'const': 1,
+'dest': 'halt_level'}),
+('Enable a non-zero exit status for non-halting system messages at '
+'or above <level>.  Default: 5 (disabled).',
+['--exit-status'], {'choices': threshold_choices,
+'dest': 'exit_status_level',
+'default': 5, 'metavar': '<level>',
+'validator': validate_threshold}),
+('Enable debug-level system messages and diagnostics.',
+['--debug'], {'action': 'store_true', 'validator': validate_boolean}),
+('Disable debug output.  (default)',
+['--no-debug'], {'action': 'store_false', 'dest': 'debug'}),
+('Send the output of system messages to <file>.',
+['--warnings'], {'dest': 'warning_stream', 'metavar': '<file>'}),
+('Enable Python tracebacks when Docutils is halted.',
+['--traceback'], {'action': 'store_true', 'default': None,
+'validator': validate_boolean}),
+('Disable Python tracebacks.  (default)',
+['--no-traceback'], {'dest': 'traceback', 'action': 'store_false'}),
+('Specify the encoding and optionally the '
+'error handler of input text.  Default: <locale-dependent>:strict.',
+['--input-encoding', '-i'],
+{'metavar': '<name[:handler]>',
+'validator': validate_encoding_and_error_handler}),
+('Specify the error handler for undecodable characters.  '
+'Choices: "strict" (default), "ignore", and "replace".',
+['--input-encoding-error-handler'],
+{'default': 'strict', 'validator': validate_encoding_error_handler}),
+('Specify the text encoding and optionally the error handler for '
+'output.  Default: UTF-8:strict.',
+['--output-encoding', '-o'],
+{'metavar': '<name[:handler]>', 'default': 'utf-8',
+'validator': validate_encoding_and_error_handler}),
+('Specify error handler for unencodable output characters; '
+'"strict" (default), "ignore", "replace", '
+'"xmlcharrefreplace", "backslashreplace".',
+['--output-encoding-error-handler'],
+{'default': 'strict', 'validator': validate_encoding_error_handler}),
+('Specify text encoding and error handler for error output.  '
+'Default: %s:%s.'
+% (default_error_encoding, default_error_encoding_error_handler),
+['--error-encoding', '-e'],
+{'metavar': '<name[:handler]>', 'default': default_error_encoding,
+'validator': validate_encoding_and_error_handler}),
+('Specify the error handler for unencodable characters in '
+'error output.  Default: %s.'
+% default_error_encoding_error_handler,
+['--error-encoding-error-handler'],
+{'default': default_error_encoding_error_handler,
+'validator': validate_encoding_error_handler}),
+('Specify the language (as BCP 47 language tag).  Default: en.',
+['--language', '-l'], {'dest': 'language_code', 'default': 'en',
+'metavar': '<name>'}),
+('Write output file dependencies to <file>.',
+['--record-dependencies'],
+{'metavar': '<file>', 'validator': validate_dependency_file,
+'default': None}),           # default set in Values class
+('Read configuration settings from <file>, if it exists.',
+['--config'], {'metavar': '<file>', 'type': 'string',
+'action': 'callback', 'callback': read_config_file}),
+("Show this program's version number and exit.",
+['--version', '-V'], {'action': 'version'}),
+('Show this help message and exit.',
+['--help', '-h'], {'action': 'help'}),
+# Typically not useful for non-programmatical use:
+(SUPPRESS_HELP, ['--id-prefix'], {'default': ''}),
+(SUPPRESS_HELP, ['--auto-id-prefix'], {'default': 'id'}),
+# Hidden options, for development use only:
+(SUPPRESS_HELP, ['--dump-settings'], {'action': 'store_true'}),
+(SUPPRESS_HELP, ['--dump-internals'], {'action': 'store_true'}),
+(SUPPRESS_HELP, ['--dump-transforms'], {'action': 'store_true'}),
+(SUPPRESS_HELP, ['--dump-pseudo-xml'], {'action': 'store_true'}),
+(SUPPRESS_HELP, ['--expose-internal-attribute'],
+{'action': 'append', 'dest': 'expose_internals',
+'validator': validate_colon_separated_string_list}),
+(SUPPRESS_HELP, ['--strict-visitor'], {'action': 'store_true'}),
+))
+"""Runtime settings and command-line options common to all Docutils front
+ends.  Setting specs specific to individual Docutils components are also
+used (see `populate_from_components()`)."""
+settings_defaults = {'_disable_config': None,
+'_source': None,
+'_destination': None,
+'_config_files': None}
+"""Defaults for settings that don't have command-line option equivalents."""
+relative_path_settings = ('warning_stream',)
+config_section = 'general'
+version_template = ('%%prog (Docutils %s [%s], Python %s, on %s)'
+% (docutils.__version__, docutils.__version_details__,
+sys.version.split()[0], sys.platform))
+"""Default version message."""
+def __init__(self, components=(), defaults=None, read_config_files=None,
+*args, **kwargs):
+"""
+`components` is a list of Docutils components each containing a
+``.settings_spec`` attribute.  `defaults` is a mapping of setting
+default overrides.
+"""
+self.lists = {}
+"""Set of list-type settings."""
+self.config_files = []
+"""List of paths of applied configuration files."""
+optparse.OptionParser.__init__(
+self, option_class=Option, add_help_option=None,
+formatter=optparse.TitledHelpFormatter(width=78),
+*args, **kwargs)
+if not self.version:
+self.version = self.version_template
+# Make an instance copy (it will be modified):
+self.relative_path_settings = list(self.relative_path_settings)
+self.components = (self,) + tuple(components)
+self.populate_from_components(self.components)
+self.set_defaults_from_dict(defaults or {})
+if read_config_files and not self.defaults['_disable_config']:
+try:
+config_settings = self.get_standard_config_settings()
+except ValueError, error:
+self.error(error)
+self.set_defaults_from_dict(config_settings.__dict__)
+def populate_from_components(self, components):
+"""
+For each component, first populate from the `SettingsSpec.settings_spec`
+structure, then from the `SettingsSpec.settings_defaults` dictionary.
+After all components have been processed, check for and populate from
+each component's `SettingsSpec.settings_default_overrides` dictionary.
+"""
+for component in components:
+if component is None:
+continue
+settings_spec = component.settings_spec
+self.relative_path_settings.extend(
+component.relative_path_settings)
+for i in range(0, len(settings_spec), 3):
+title, description, option_spec = settings_spec[i:i+3]
+if title:
+group = optparse.OptionGroup(self, title, description)
+self.add_option_group(group)
+else:
+group = self        # single options
+for (help_text, option_strings, kwargs) in option_spec:
+option = group.add_option(help=help_text, *option_strings,
+**kwargs)
+if kwargs.get('action') == 'append':
+self.lists[option.dest] = 1
+if component.settings_defaults:
+self.defaults.update(component.settings_defaults)
+for component in components:
+if component and component.settings_default_overrides:
+self.defaults.update(component.settings_default_overrides)
+def get_standard_config_files(self):
+"""Return list of config files, from environment or standard."""
+try:
+config_files = os.environ['DOCUTILSCONFIG'].split(os.pathsep)
+except KeyError:
+config_files = self.standard_config_files
+# If 'HOME' is not set, expandvars() requires the 'pwd' module which is
+# not available under certain environments, for example, within
+# mod_python.  The publisher ends up in here, and we need to publish
+# from within mod_python.  Therefore we need to avoid expanding when we
+# are in those environments.
+expand = os.path.expanduser
+if 'HOME' not in os.environ:
+try:
+import pwd
+except ImportError:
+expand = lambda x: x
+return [expand(f) for f in config_files if f.strip()]
+def get_standard_config_settings(self):
+settings = Values()
+for filename in self.get_standard_config_files():
+settings.update(self.get_config_file_settings(filename), self)
+return settings
+def get_config_file_settings(self, config_file):
+"""Returns a dictionary containing appropriate config file settings."""
+parser = ConfigParser()
+parser.read(config_file, self)
+self.config_files.extend(parser._files)
+base_path = os.path.dirname(config_file)
+applied = {}
+settings = Values()
+for component in self.components:
+if not component:
+continue
+for section in (tuple(component.config_section_dependencies or ())
++ (component.config_section,)):
+if section in applied:
+continue
+applied[section] = 1
+settings.update(parser.get_section(section), self)
+make_paths_absolute(
+settings.__dict__, self.relative_path_settings, base_path)
+return settings.__dict__
+def check_values(self, values, args):
+"""Store positional arguments as runtime settings."""
+values._source, values._destination = self.check_args(args)
+make_paths_absolute(values.__dict__, self.relative_path_settings)
+values._config_files = self.config_files
+return values
+def check_args(self, args):
+source = destination = None
+if args:
+source = args.pop(0)
+if source == '-':           # means stdin
+source = None
+if args:
+destination = args.pop(0)
+if destination == '-':      # means stdout
+destination = None
+if args:
+self.error('Maximum 2 arguments allowed.')
+if source and source == destination:
+self.error('Do not specify the same file for both source and '
+'destination.  It will clobber the source file.')
+return source, destination
+def set_defaults_from_dict(self, defaults):
+self.defaults.update(defaults)
+def get_default_values(self):
+"""Needed to get custom `Values` instances."""
+defaults = Values(self.defaults)
+defaults._config_files = self.config_files
+return defaults
+def get_option_by_dest(self, dest):
+"""
+Get an option by its dest.
+If you're supplying a dest which is shared by several options,
+it is undefined which option of those is returned.
+A KeyError is raised if there is no option with the supplied
+dest.
+"""
+for group in self.option_groups + [self]:
+for option in group.option_list:
+if option.dest == dest:
+return option
+raise KeyError('No option with dest == %r.' % dest)
+class ConfigParser(CP.RawConfigParser):
+old_settings = {
+'pep_stylesheet': ('pep_html writer', 'stylesheet'),
+'pep_stylesheet_path': ('pep_html writer', 'stylesheet_path'),
+'pep_template': ('pep_html writer', 'template')}
+"""{old setting: (new section, new setting)} mapping, used by
+`handle_old_config`, to convert settings from the old [options] section."""
+old_warning = """
+The "[option]" section is deprecated.  Support for old-format configuration
+files may be removed in a future Docutils release.  Please revise your
+configuration files.  See <http://docutils.sf.net/docs/user/config.html>,
+section "Old-Format Configuration Files".
+"""
+not_utf8_error = """\
+Unable to read configuration file "%s": content not encoded as UTF-8.
+Skipping "%s" configuration file.
+"""
+def __init__(self, *args, **kwargs):
+CP.RawConfigParser.__init__(self, *args, **kwargs)
+self._files = []
+"""List of paths of configuration files read."""
+self._stderr = ErrorOutput()
+"""Wrapper around sys.stderr catching en-/decoding errors"""
+def read(self, filenames, option_parser):
+if type(filenames) in (str, unicode):
+filenames = [filenames]
+for filename in filenames:
+try:
+# Config files must be UTF-8-encoded:
+fp = codecs.open(filename, 'r', 'utf-8')
+except IOError:
+continue
+try:
+if sys.version_info < (3,2):
+CP.RawConfigParser.readfp(self, fp, filename)
+else:
+CP.RawConfigParser.read_file(self, fp, filename)
+except UnicodeDecodeError:
+self._stderr.write(self.not_utf8_error % (filename, filename))
+fp.close()
+continue
+fp.close()
+self._files.append(filename)
+if self.has_section('options'):
+self.handle_old_config(filename)
+self.validate_settings(filename, option_parser)
+def handle_old_config(self, filename):
+warnings.warn_explicit(self.old_warning, ConfigDeprecationWarning,
+filename, 0)
+options = self.get_section('options')
+if not self.has_section('general'):
+self.add_section('general')
+for key, value in options.items():
+if key in self.old_settings:
+section, setting = self.old_settings[key]
+if not self.has_section(section):
+self.add_section(section)
+else:
+section = 'general'
+setting = key
+if not self.has_option(section, setting):
+self.set(section, setting, value)
+self.remove_section('options')
+def validate_settings(self, filename, option_parser):
+"""
+Call the validator function and implement overrides on all applicable
+settings.
+"""
+for section in self.sections():
+for setting in self.options(section):
+try:
+option = option_parser.get_option_by_dest(setting)
+except KeyError:
+continue
+if option.validator:
+value = self.get(section, setting)
+try:
+new_value = option.validator(
+setting, value, option_parser,
+config_parser=self, config_section=section)
+except Exception, error:
+raise (ValueError(
+'Error in config file "%s", section "[%s]":\n'
+'    %s\n'
+'        %s = %s'
+% (filename, section, ErrorString(error),
+setting, value)), None, sys.exc_info()[2])
+self.set(section, setting, new_value)
+if option.overrides:
+self.set(section, option.overrides, None)
+def optionxform(self, optionstr):
+"""
+Transform '-' to '_' so the cmdline form of option names can be used.
+"""
+return optionstr.lower().replace('-', '_')
+def get_section(self, section):
+"""
+Return a given section as a dictionary (empty if the section
+doesn't exist).
+"""
+section_dict = {}
+if self.has_section(section):
+for option in self.options(section):
+section_dict[option] = self.get(section, option)
+return section_dict
+class ConfigDeprecationWarning(DeprecationWarning):
+"""Warning for deprecated configuration file features."""

Mercurial > repos > bcclaywell > argo_navis

comparison venv/lib/python2.7/site-packages/docutils/frontend.py @ 0:d67268158946 draft