diff options
Diffstat (limited to '.venv/lib/python3.12/site-packages/docutils/frontend.py')
-rw-r--r-- | .venv/lib/python3.12/site-packages/docutils/frontend.py | 1065 |
1 files changed, 1065 insertions, 0 deletions
diff --git a/.venv/lib/python3.12/site-packages/docutils/frontend.py b/.venv/lib/python3.12/site-packages/docutils/frontend.py new file mode 100644 index 00000000..2499c628 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/docutils/frontend.py @@ -0,0 +1,1065 @@ +# $Id: frontend.py 9540 2024-02-17 10:36:59Z 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. + +This module is provisional. +Major changes will happen with the switch from the deprecated +"optparse" module to "arparse". + +Applications should use the high-level API provided by `docutils.core`. +See https://docutils.sourceforge.io/docs/api/runtime-settings.html. + +Exports the following classes: + +* `OptionParser`: Standard Docutils command-line processing. + Deprecated. Will be replaced by an ArgumentParser. +* `Option`: Customized version of `optparse.Option`; validation support. + Deprecated. Will be removed. +* `Values`: Runtime settings; objects are simple structs + (``object.attribute``). Supports cumulative list settings (attributes). + Deprecated. Will be removed. +* `ConfigParser`: Standard Docutils config file processing. + Provisional. Details will change. + +Also exports the following functions: + +Interface function: + `get_default_settings()`. New in 0.19. + +Option callbacks: + `store_multiple()`, `read_config_file()`. Deprecated. + +Setting validators: + `validate_encoding()`, `validate_encoding_error_handler()`, + `validate_encoding_and_error_handler()`, + `validate_boolean()`, `validate_ternary()`, + `validate_nonnegative_int()`, `validate_threshold()`, + `validate_colon_separated_string_list()`, + `validate_comma_separated_list()`, + `validate_url_trailing_slash()`, + `validate_dependency_file()`, + `validate_strip_class()` + `validate_smartquotes_locales()`. + + Provisional. + +Misc: + `make_paths_absolute()`, `filter_settings_spec()`. Provisional. +""" + +__docformat__ = 'reStructuredText' + + +import codecs +import configparser +import optparse +from optparse import SUPPRESS_HELP +import os +import os.path +from pathlib import Path +import sys +import warnings + +import docutils +from docutils import io, utils + + +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 as err: + parser.error(err) + parser.values.update(new_settings, parser) + + +def validate_encoding(setting, value=None, option_parser=None, + config_parser=None, config_section=None): + # All arguments except `value` are ignored + # (kept for compatibility with "optparse" module). + # If there is only one positional argument, it is interpreted as `value`. + if value is None: + value = setting + if value == '': + return None # allow overwriting a config file value + try: + codecs.lookup(value) + except LookupError: + raise LookupError('setting "%s": unknown encoding: "%s"' + % (setting, value)) + return value + + +def validate_encoding_error_handler(setting, value=None, option_parser=None, + config_parser=None, config_section=None): + # All arguments except `value` are ignored + # (kept for compatibility with "optparse" module). + # If there is only one positional argument, it is interpreted as `value`. + if value is None: + value = setting + 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) + 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 were a separate setting/option. + """ + if ':' in value: + encoding, handler = value.split(':') + validate_encoding_error_handler(handler) + if config_parser: + config_parser.set(config_section, setting + '_error_handler', + handler) + else: + setattr(option_parser.values, setting + '_error_handler', handler) + else: + encoding = value + return validate_encoding(encoding) + + +def validate_boolean(setting, value=None, option_parser=None, + config_parser=None, config_section=None): + """Check/normalize boolean settings: + True: '1', 'on', 'yes', 'true' + False: '0', 'off', 'no','false', '' + + All arguments except `value` are ignored + (kept for compatibility with "optparse" module). + If there is only one positional argument, it is interpreted as `value`. + """ + if value is None: + value = setting + if isinstance(value, bool): + return value + try: + return OptionParser.booleans[value.strip().lower()] + except KeyError: + raise LookupError('unknown boolean value: "%s"' % value) + + +def validate_ternary(setting, value=None, option_parser=None, + 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. + + All arguments except `value` are ignored + (kept for compatibility with "optparse" module). + If there is only one positional argument, it is interpreted as `value`. + """ + if value is None: + value = setting + if isinstance(value, bool) or value is None: + return value + try: + return OptionParser.booleans[value.strip().lower()] + except KeyError: + return value + + +def validate_nonnegative_int(setting, value=None, option_parser=None, + config_parser=None, config_section=None): + # All arguments except `value` are ignored + # (kept for compatibility with "optparse" module). + # If there is only one positional argument, it is interpreted as `value`. + if value is None: + value = setting + value = int(value) + if value < 0: + raise ValueError('negative value; must be positive or zero') + return value + + +def validate_threshold(setting, value=None, option_parser=None, + config_parser=None, config_section=None): + # All arguments except `value` are ignored + # (kept for compatibility with "optparse" module). + # If there is only one positional argument, it is interpreted as `value`. + if value is None: + value = setting + try: + return int(value) + except ValueError: + try: + return OptionParser.thresholds[value.lower()] + except (KeyError, AttributeError): + raise LookupError('unknown threshold: %r.' % value) + + +def validate_colon_separated_string_list( + setting, value=None, option_parser=None, + config_parser=None, config_section=None): + # All arguments except `value` are ignored + # (kept for compatibility with "optparse" module). + # If there is only one positional argument, it is interpreted as `value`. + if value is None: + value = setting + 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=None, option_parser=None, + config_parser=None, config_section=None): + """Check/normalize list arguments (split at "," and strip whitespace). + + All arguments except `value` are ignored + (kept for compatibility with "optparse" module). + If there is only one positional argument, it is interpreted as `value`. + """ + if value is None: + value = setting + # `value` may be ``bytes``, ``str``, or a ``list`` (when given as + # command line option and "action" is "append"). + 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(' \t\n') for i in last.split(',') if i.strip(' \t\n')] + value.extend(items) + return value + + +def validate_math_output(setting, value=None, option_parser=None, + config_parser=None, config_section=None): + """Check "math-output" setting, return list with "format" and "options". + + See also https://docutils.sourceforge.io/docs/user/config.html#math-output + + Argument list for compatibility with "optparse" module. + All arguments except `value` are ignored. + If there is only one positional argument, it is interpreted as `value`. + """ + if value is None: + value = setting + + formats = ('html', 'latex', 'mathml', 'mathjax') + tex2mathml_converters = ('', 'latexml', 'ttm', 'blahtexml', 'pandoc') + + if not value: + return [] + values = value.split(maxsplit=1) + format = values[0].lower() + try: + options = values[1] + except IndexError: + options = '' + if format not in formats: + raise LookupError(f'Unknown math output format: "{value}",\n' + f' choose from {formats}.') + if format == 'mathml': + converter = options.lower() + if converter not in tex2mathml_converters: + raise LookupError(f'MathML converter "{options}" not supported,\n' + f' choose from {tex2mathml_converters}.') + options = converter + return [format, options] + + +def validate_url_trailing_slash(setting, value=None, option_parser=None, + config_parser=None, config_section=None): + # All arguments except `value` are ignored + # (kept for compatibility with "optparse" module). + # If there is only one positional argument, it is interpreted as `value`. + if value is None: + value = setting + if not value: + return './' + elif value.endswith('/'): + return value + else: + return value + '/' + + +def validate_dependency_file(setting, value=None, option_parser=None, + config_parser=None, config_section=None): + # All arguments except `value` are ignored + # (kept for compatibility with "optparse" module). + # If there is only one positional argument, it is interpreted as `value`. + if value is None: + value = setting + try: + return utils.DependencyList(value) + except OSError: + # TODO: warn/info? + return utils.DependencyList(None) + + +def validate_strip_class(setting, value=None, option_parser=None, + config_parser=None, config_section=None): + # All arguments except `value` are ignored + # (kept for compatibility with "optparse" module). + # If there is only one positional argument, it is interpreted as `value`. + if value is None: + value = setting + # value is a comma separated string list: + value = validate_comma_separated_list(value) + # 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 validate_smartquotes_locales(setting, value=None, option_parser=None, + config_parser=None, config_section=None): + """Check/normalize a comma separated list of smart quote definitions. + + Return a list of (language-tag, quotes) string tuples. + + All arguments except `value` are ignored + (kept for compatibility with "optparse" module). + If there is only one positional argument, it is interpreted as `value`. + """ + if value is None: + value = setting + # value is a comma separated string list: + value = validate_comma_separated_list(value) + # validate list elements + lc_quotes = [] + for item in value: + try: + lang, quotes = item.split(':', 1) + except AttributeError: + # this function is called for every option added to `value` + # -> ignore if already a tuple: + lc_quotes.append(item) + continue + except ValueError: + raise ValueError('Invalid value "%s".' + ' Format is "<language>:<quotes>".' + % item.encode('ascii', 'backslashreplace')) + # parse colon separated string list: + quotes = quotes.strip() + multichar_quotes = quotes.split(':') + if len(multichar_quotes) == 4: + quotes = multichar_quotes + elif len(quotes) != 4: + raise ValueError('Invalid value "%s". Please specify 4 quotes\n' + ' (primary open/close; secondary open/close).' + % item.encode('ascii', 'backslashreplace')) + lc_quotes.append((lang, quotes)) + return lc_quotes + + +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 = Path.cwd() + else: + base_path = Path(base_path) + for key in keys: + if key in pathdict: + value = pathdict[key] + if isinstance(value, list): + value = [str((base_path/path).resolve()) for path in value] + elif value: + value = str((base_path/value).resolve()) + pathdict[key] = value + + +def make_one_path_absolute(base_path, path): + # deprecated, will be removed + warnings.warn('frontend.make_one_path_absolute() will be removed ' + 'in Docutils 0.23.', DeprecationWarning, stacklevel=2) + 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 + (cf. `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): + """Storage for option values. + + Updates list attributes by extension rather than by replacement. + Works in conjunction with the `OptionParser.lists` instance attribute. + + Deprecated. Will be removed. + """ + + def __init__(self, *args, **kwargs): + warnings.warn('frontend.Values class will be removed ' + 'in Docutils 0.21 or later.', + DeprecationWarning, stacklevel=2) + super().__init__(*args, **kwargs) + if getattr(self, 'record_dependencies', None) is None: + # Set up dummy dependency list. + self.record_dependencies = utils.DependencyList() + + def update(self, other_dict, option_parser): + if isinstance(other_dict, Values): + other_dict = other_dict.__dict__ + other_dict = dict(other_dict) # also works with ConfigParser sections + 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`.""" + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=DeprecationWarning) + return self.__class__(defaults=self.__dict__) + + def setdefault(self, name, default): + """Return ``self.name`` or ``default``. + + If ``self.name`` is unset, set ``self.name = default``. + """ + if getattr(self, name, None) is None: + setattr(self, name, default) + return getattr(self, name) + + +class Option(optparse.Option): + """Add validation and override support to `optparse.Option`. + + Deprecated. Will be removed. + """ + + ATTRS = optparse.Option.ATTRS + ['validator', 'overrides'] + + def __init__(self, *args, **kwargs): + warnings.warn('The frontend.Option class will be removed ' + 'in Docutils 0.21 or later.', + DeprecationWarning, stacklevel=2) + super().__init__(*args, **kwargs) + + def process(self, opt, value, values, parser): + """ + Call the validator function on applicable settings and + evaluate the 'overrides' option. + Extends `optparse.Option.process`. + """ + result = super().process(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 as err: + raise optparse.OptionValueError( + 'Error in option "%s":\n %s' + % (opt, io.error_string(err))) + setattr(values, setting, new_value) + if self.overrides: + setattr(values, self.overrides, None) + return result + + +class OptionParser(optparse.OptionParser, docutils.SettingsSpec): + """ + Settings 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 restricted to using long options. + + Deprecated. + Will be replaced by a subclass of `argparse.ArgumentParser`. + """ + + 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 io._locale_encoding # noqa + or 'ascii') + + default_error_encoding_error_handler = 'backslashreplace' + + settings_spec = ( + 'General Docutils Options', + None, + (('Output destination name. Obsoletes the <destination> ' + 'positional argument. Default: None (stdout).', + ['--output'], {'metavar': '<destination>'}), + ('Specify the document title as metadata.', + ['--title'], {'metavar': '<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'}), + ('Base directory for absolute paths when reading ' + 'from the local filesystem. Default "/".', + ['--root-prefix'], + {'default': '/', 'metavar': '<path>'}), + ('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': True, + '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': True, '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: <auto-detect>: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 optionally 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': '%'}), + # 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 without command-line option equivalents. + + See https://docutils.sourceforge.io/docs/user/config.html#internal-settings + """ + + config_section = 'general' + + version_template = ('%%prog (Docutils %s%s, Python %s, on %s)' + % (docutils.__version__, + docutils.__version_details__ + and ' [%s]'%docutils.__version_details__ or '', + sys.version.split()[0], sys.platform)) + """Default version message.""" + + def __init__(self, components=(), defaults=None, read_config_files=False, + *args, **kwargs): + """Set up OptionParser instance. + + `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.""" + + self.relative_path_settings = ['warning_stream'] # will be modified + + warnings.warn('The frontend.OptionParser class will be replaced ' + 'by a subclass of argparse.ArgumentParser ' + 'in Docutils 0.21 or later.', + DeprecationWarning, stacklevel=2) + super().__init__(option_class=Option, add_help_option=None, + formatter=optparse.TitledHelpFormatter(width=78), + *args, **kwargs) + if not self.version: + self.version = self.version_template + self.components = (self, *components) + self.populate_from_components(self.components) + self.defaults.update(defaults or {}) + if read_config_files and not self.defaults['_disable_config']: + try: + config_settings = self.get_standard_config_settings() + except ValueError as err: + self.error(err) + self.defaults.update(config_settings.__dict__) + + def populate_from_components(self, components): + """Collect settings specification from components. + + For each component, 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] = True + 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) + + @classmethod + def get_standard_config_files(cls): + """Return list of config files, from environment or standard.""" + if 'DOCUTILSCONFIG' in os.environ: + config_files = os.environ['DOCUTILSCONFIG'].split(os.pathsep) + else: + config_files = cls.standard_config_files + return [os.path.expanduser(f) for f in config_files if f.strip()] + + def get_standard_config_settings(self): + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=DeprecationWarning) + 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.""" + config_parser = ConfigParser() + # parse config file, add filename if found and successfully read. + applied = set() + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=DeprecationWarning) + self.config_files += config_parser.read(config_file, self) + 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.add(section) + if config_parser.has_section(section): + settings.update(config_parser[section], self) + make_paths_absolute(settings.__dict__, + self.relative_path_settings, + os.path.dirname(config_file)) + 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): + # deprecated, will be removed + warnings.warn('OptionParser.set_defaults_from_dict() will be removed ' + 'in Docutils 0.22 or with the switch to ArgumentParser.', + DeprecationWarning, stacklevel=2) + self.defaults.update(defaults) + + def get_default_values(self): + """Needed to get custom `Values` instances.""" + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=DeprecationWarning) + 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(configparser.RawConfigParser): + """Parser for Docutils configuration files. + + See https://docutils.sourceforge.io/docs/user/config.html. + + Option key normalization includes conversion of '-' to '_'. + + Config file encoding is "utf-8". Encoding errors are reported + and the affected file(s) skipped. + + This class is provisional and will change in future versions. + """ + + 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.\n' + 'Support for old-format configuration files will be removed in ' + 'Docutils 2.0. Please revise your configuration files. ' + 'See <https://docutils.sourceforge.io/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 read(self, filenames, option_parser=None): + # Currently, if a `docutils.frontend.OptionParser` instance is + # supplied, setting values are validated. + if option_parser is not None: + warnings.warn('frontend.ConfigParser.read(): parameter ' + '"option_parser" will be removed ' + 'in Docutils 0.21 or later.', + DeprecationWarning, stacklevel=2) + read_ok = [] + if isinstance(filenames, str): + filenames = [filenames] + for filename in filenames: + # Config files are UTF-8-encoded: + try: + read_ok += super().read(filename, encoding='utf-8') + except UnicodeDecodeError: + sys.stderr.write(self.not_utf8_error % (filename, filename)) + continue + if 'options' in self: + self.handle_old_config(filename) + if option_parser is not None: + self.validate_settings(filename, option_parser) + return read_ok + + 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 as err: + raise ValueError(f'Error in config file "{filename}", ' + f'section "[{section}]":\n' + f' {io.error_string(err)}\n' + f' {setting} = {value}') + self.set(section, setting, new_value) + if option.overrides: + self.set(section, option.overrides, None) + + def optionxform(self, optionstr): + """ + Lowercase and transform '-' to '_'. + + So the cmdline form of option names can be used in config files. + """ + return optionstr.lower().replace('-', '_') + + def get_section(self, section): + """ + Return a given section as a dictionary. + + Return empty dictionary if the section doesn't exist. + + Deprecated. Use the configparser "Mapping Protocol Access" and + catch KeyError. + """ + warnings.warn('frontend.OptionParser.get_section() ' + 'will be removed in Docutils 0.21 or later.', + DeprecationWarning, stacklevel=2) + try: + return dict(self[section]) + except KeyError: + return {} + + +class ConfigDeprecationWarning(FutureWarning): + """Warning for deprecated configuration file features.""" + + +def get_default_settings(*components): + """Return default runtime settings for `components`. + + Return a `frontend.Values` instance with defaults for generic Docutils + settings and settings from the `components` (`SettingsSpec` instances). + + This corresponds to steps 1 and 2 in the `runtime settings priority`__. + + __ https://docutils.sourceforge.io/docs/api/runtime-settings.html + #settings-priority + """ + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=DeprecationWarning) + return OptionParser(components).get_default_values() |