aboutsummaryrefslogtreecommitdiff
path: root/.venv/lib/python3.12/site-packages/docutils/frontend.py
diff options
context:
space:
mode:
Diffstat (limited to '.venv/lib/python3.12/site-packages/docutils/frontend.py')
-rw-r--r--.venv/lib/python3.12/site-packages/docutils/frontend.py1065
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()