py2docfx 0.1.11.dev1827111__py3-none-any.whl → 0.1.11.dev1859874__py3-none-any.whl

py2docfx/venv/template/Lib/site-packages/sphinx/builders/xml.py

@@ -1,117 +0,0 @@
-"""Docutils-native XML and pseudo-XML builders."""
-
-from __future__ import annotations
-
-from os import path
-from typing import Any, Iterator
-
-from docutils import nodes
-from docutils.io import StringOutput
-from docutils.nodes import Node
-from docutils.writers.docutils_xml import XMLTranslator
-
-from sphinx.application import Sphinx
-from sphinx.builders import Builder
-from sphinx.locale import __
-from sphinx.util import logging
-from sphinx.util.osutil import ensuredir, os_path
-from sphinx.writers.xml import PseudoXMLWriter, XMLWriter
-
-logger = logging.getLogger(__name__)
-
-
-class XMLBuilder(Builder):
-    """
-    Builds Docutils-native XML.
-    """
-    name = 'xml'
-    format = 'xml'
-    epilog = __('The XML files are in %(outdir)s.')
-
-    out_suffix = '.xml'
-    allow_parallel = True
-
-    _writer_class: type[XMLWriter] | type[PseudoXMLWriter] = XMLWriter
-    default_translator_class = XMLTranslator
-
-    def init(self) -> None:
-        pass
-
-    def get_outdated_docs(self) -> Iterator[str]:
-        for docname in self.env.found_docs:
-            if docname not in self.env.all_docs:
-                yield docname
-                continue
-            targetname = path.join(self.outdir, docname + self.out_suffix)
-            try:
-                targetmtime = path.getmtime(targetname)
-            except Exception:
-                targetmtime = 0
-            try:
-                srcmtime = path.getmtime(self.env.doc2path(docname))
-                if srcmtime > targetmtime:
-                    yield docname
-            except OSError:
-                # source doesn't exist anymore
-                pass
-
-    def get_target_uri(self, docname: str, typ: str | None = None) -> str:
-        return docname
-
-    def prepare_writing(self, docnames: set[str]) -> None:
-        self.writer = self._writer_class(self)
-
-    def write_doc(self, docname: str, doctree: Node) -> None:
-        # work around multiple string % tuple issues in docutils;
-        # replace tuples in attribute values with lists
-        doctree = doctree.deepcopy()
-        for domain in self.env.domains.values():
-            xmlns = "xmlns:" + domain.name
-            doctree[xmlns] = "https://www.sphinx-doc.org/"  # type: ignore
-        for node in doctree.findall(nodes.Element):
-            for att, value in node.attributes.items():
-                if isinstance(value, tuple):
-                    node.attributes[att] = list(value)
-                value = node.attributes[att]
-                if isinstance(value, list):
-                    for i, val in enumerate(value):
-                        if isinstance(val, tuple):
-                            value[i] = list(val)
-        destination = StringOutput(encoding='utf-8')
-        self.writer.write(doctree, destination)
-        outfilename = path.join(self.outdir, os_path(docname) + self.out_suffix)
-        ensuredir(path.dirname(outfilename))
-        try:
-            with open(outfilename, 'w', encoding='utf-8') as f:
-                f.write(self.writer.output)
-        except OSError as err:
-            logger.warning(__("error writing file %s: %s"), outfilename, err)
-
-    def finish(self) -> None:
-        pass
-
-
-class PseudoXMLBuilder(XMLBuilder):
-    """
-    Builds pseudo-XML for display purposes.
-    """
-    name = 'pseudoxml'
-    format = 'pseudoxml'
-    epilog = __('The pseudo-XML files are in %(outdir)s.')
-
-    out_suffix = '.pseudoxml'
-
-    _writer_class = PseudoXMLWriter
-
-
-def setup(app: Sphinx) -> dict[str, Any]:
-    app.add_builder(XMLBuilder)
-    app.add_builder(PseudoXMLBuilder)
-
-    app.add_config_value('xml_pretty', True, 'env')
-
-    return {
-        'version': 'builtin',
-        'parallel_read_safe': True,
-        'parallel_write_safe': True,
-    }

py2docfx/venv/template/Lib/site-packages/sphinx/cmd/__init__.py

@@ -1 +0,0 @@
-"""Modules for command line executables."""

py2docfx/venv/template/Lib/site-packages/sphinx/cmd/build.py

@@ -1,324 +0,0 @@
-"""Build documentation from a provided source."""
-
-from __future__ import annotations
-
-import argparse
-import bdb
-import locale
-import multiprocessing
-import os
-import pdb  # NoQA: T100
-import sys
-import traceback
-from os import path
-from typing import Any, TextIO
-
-from docutils.utils import SystemMessage
-
-import sphinx.locale
-from sphinx import __display_version__, package_dir
-from sphinx.application import Sphinx
-from sphinx.errors import SphinxError
-from sphinx.locale import __
-from sphinx.util import Tee
-from sphinx.util.console import color_terminal, nocolor, red, terminal_safe  # type: ignore
-from sphinx.util.docutils import docutils_namespace, patch_docutils
-from sphinx.util.exceptions import format_exception_cut_frames, save_traceback
-from sphinx.util.osutil import abspath, ensuredir
-
-
-def handle_exception(
-    app: Sphinx | None, args: Any, exception: BaseException, stderr: TextIO = sys.stderr
-) -> None:
-    if isinstance(exception, bdb.BdbQuit):
-        return
-
-    if args.pdb:
-        print(red(__('Exception occurred while building, starting debugger:')),
-              file=stderr)
-        traceback.print_exc()
-        pdb.post_mortem(sys.exc_info()[2])
-    else:
-        print(file=stderr)
-        if args.verbosity or args.traceback:
-            traceback.print_exc(None, stderr)
-            print(file=stderr)
-        if isinstance(exception, KeyboardInterrupt):
-            print(__('Interrupted!'), file=stderr)
-        elif isinstance(exception, SystemMessage):
-            print(red(__('reST markup error:')), file=stderr)
-            print(terminal_safe(exception.args[0]), file=stderr)
-        elif isinstance(exception, SphinxError):
-            print(red('%s:' % exception.category), file=stderr)
-            print(str(exception), file=stderr)
-        elif isinstance(exception, UnicodeError):
-            print(red(__('Encoding error:')), file=stderr)
-            print(terminal_safe(str(exception)), file=stderr)
-            tbpath = save_traceback(app, exception)
-            print(red(__('The full traceback has been saved in %s, if you want '
-                         'to report the issue to the developers.') % tbpath),
-                  file=stderr)
-        elif isinstance(exception, RuntimeError) and 'recursion depth' in str(exception):
-            print(red(__('Recursion error:')), file=stderr)
-            print(terminal_safe(str(exception)), file=stderr)
-            print(file=stderr)
-            print(__('This can happen with very large or deeply nested source '
-                     'files. You can carefully increase the default Python '
-                     'recursion limit of 1000 in conf.py with e.g.:'), file=stderr)
-            print('    import sys; sys.setrecursionlimit(1500)', file=stderr)
-        else:
-            print(red(__('Exception occurred:')), file=stderr)
-            print(format_exception_cut_frames().rstrip(), file=stderr)
-            tbpath = save_traceback(app, exception)
-            print(red(__('The full traceback has been saved in %s, if you '
-                         'want to report the issue to the developers.') % tbpath),
-                  file=stderr)
-            print(__('Please also report this if it was a user error, so '
-                     'that a better error message can be provided next time.'),
-                  file=stderr)
-            print(__('A bug report can be filed in the tracker at '
-                     '<https://github.com/sphinx-doc/sphinx/issues>. Thanks!'),
-                  file=stderr)
-
-
-def jobs_argument(value: str) -> int:
-    """
-    Special type to handle 'auto' flags passed to 'sphinx-build' via -j flag. Can
-    be expanded to handle other special scaling requests, such as setting job count
-    to cpu_count.
-    """
-    if value == 'auto':
-        return multiprocessing.cpu_count()
-    else:
-        jobs = int(value)
-        if jobs <= 0:
-            raise argparse.ArgumentTypeError(__('job number should be a positive number'))
-        else:
-            return jobs
-
-
-def get_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        usage='%(prog)s [OPTIONS] SOURCEDIR OUTPUTDIR [FILENAMES...]',
-        epilog=__('For more information, visit <https://www.sphinx-doc.org/>.'),
-        description=__("""
-Generate documentation from source files.
-
-sphinx-build generates documentation from the files in SOURCEDIR and places it
-in OUTPUTDIR. It looks for 'conf.py' in SOURCEDIR for the configuration
-settings. The 'sphinx-quickstart' tool may be used to generate template files,
-including 'conf.py'
-
-sphinx-build can create documentation in different formats. A format is
-selected by specifying the builder name on the command line; it defaults to
-HTML. Builders can also perform other tasks related to documentation
-processing.
-
-By default, everything that is outdated is built. Output only for selected
-files can be built by specifying individual filenames.
-"""))
-
-    parser.add_argument('--version', action='version', dest='show_version',
-                        version='%%(prog)s %s' % __display_version__)
-
-    parser.add_argument('sourcedir',
-                        help=__('path to documentation source files'))
-    parser.add_argument('outputdir',
-                        help=__('path to output directory'))
-    parser.add_argument('filenames', nargs='*',
-                        help=__('a list of specific files to rebuild. Ignored '
-                                'if -a is specified'))
-
-    group = parser.add_argument_group(__('general options'))
-    group.add_argument('-b', metavar='BUILDER', dest='builder',
-                       default='html',
-                       help=__('builder to use (default: html)'))
-    group.add_argument('-a', action='store_true', dest='force_all',
-                       help=__('write all files (default: only write new and '
-                               'changed files)'))
-    group.add_argument('-E', action='store_true', dest='freshenv',
-                       help=__('don\'t use a saved environment, always read '
-                               'all files'))
-    group.add_argument('-d', metavar='PATH', dest='doctreedir',
-                       help=__('path for the cached environment and doctree '
-                               'files (default: OUTPUTDIR/.doctrees)'))
-    group.add_argument('-j', metavar='N', default=1, type=jobs_argument, dest='jobs',
-                       help=__('build in parallel with N processes where '
-                               'possible (special value "auto" will set N to cpu-count)'))
-    group = parser.add_argument_group('build configuration options')
-    group.add_argument('-c', metavar='PATH', dest='confdir',
-                       help=__('path where configuration file (conf.py) is '
-                               'located (default: same as SOURCEDIR)'))
-    group.add_argument('-C', action='store_true', dest='noconfig',
-                       help=__('use no config file at all, only -D options'))
-    group.add_argument('-D', metavar='setting=value', action='append',
-                       dest='define', default=[],
-                       help=__('override a setting in configuration file'))
-    group.add_argument('-A', metavar='name=value', action='append',
-                       dest='htmldefine', default=[],
-                       help=__('pass a value into HTML templates'))
-    group.add_argument('-t', metavar='TAG', action='append',
-                       dest='tags', default=[],
-                       help=__('define tag: include "only" blocks with TAG'))
-    group.add_argument('-n', action='store_true', dest='nitpicky',
-                       help=__('nit-picky mode, warn about all missing '
-                               'references'))
-
-    group = parser.add_argument_group(__('console output options'))
-    group.add_argument('-v', action='count', dest='verbosity', default=0,
-                       help=__('increase verbosity (can be repeated)'))
-    group.add_argument('-q', action='store_true', dest='quiet',
-                       help=__('no output on stdout, just warnings on stderr'))
-    group.add_argument('-Q', action='store_true', dest='really_quiet',
-                       help=__('no output at all, not even warnings'))
-    group.add_argument('--color', action='store_const', const='yes',
-                       default='auto',
-                       help=__('do emit colored output (default: auto-detect)'))
-    group.add_argument('-N', '--no-color', dest='color', action='store_const',
-                       const='no',
-                       help=__('do not emit colored output (default: '
-                               'auto-detect)'))
-    group.add_argument('-w', metavar='FILE', dest='warnfile',
-                       help=__('write warnings (and errors) to given file'))
-    group.add_argument('-W', action='store_true', dest='warningiserror',
-                       help=__('turn warnings into errors'))
-    group.add_argument('--keep-going', action='store_true', dest='keep_going',
-                       help=__("with -W, keep going when getting warnings"))
-    group.add_argument('-T', action='store_true', dest='traceback',
-                       help=__('show full traceback on exception'))
-    group.add_argument('-P', action='store_true', dest='pdb',
-                       help=__('run Pdb on exception'))
-
-    return parser
-
-
-def make_main(argv: list[str] = sys.argv[1:]) -> int:
-    """Sphinx build "make mode" entry."""
-    from sphinx.cmd import make_mode
-    return make_mode.run_make_mode(argv[1:])
-
-
-def _parse_arguments(argv: list[str] = sys.argv[1:]) -> argparse.Namespace:
-    parser = get_parser()
-    args = parser.parse_args(argv)
-
-    if args.noconfig:
-        args.confdir = None
-    elif not args.confdir:
-        args.confdir = args.sourcedir
-
-    if not args.doctreedir:
-        args.doctreedir = os.path.join(args.outputdir, '.doctrees')
-
-    if args.force_all and args.filenames:
-        parser.error(__('cannot combine -a option and filenames'))
-
-    if args.color == 'no' or (args.color == 'auto' and not color_terminal()):
-        nocolor()
-
-    status: TextIO | None = sys.stdout
-    warning: TextIO | None = sys.stderr
-    error = sys.stderr
-
-    if args.quiet:
-        status = None
-
-    if args.really_quiet:
-        status = warning = None
-
-    if warning and args.warnfile:
-        try:
-            warnfile = abspath(args.warnfile)
-            ensuredir(path.dirname(warnfile))
-            warnfp = open(args.warnfile, 'w', encoding="utf-8")
-        except Exception as exc:
-            parser.error(__('cannot open warning file %r: %s') % (
-                args.warnfile, exc))
-        warning = Tee(warning, warnfp)  # type: ignore
-        error = warning
-
-    args.status = status
-    args.warning = warning
-    args.error = error
-
-    confoverrides = {}
-    for val in args.define:
-        try:
-            key, val = val.split('=', 1)
-        except ValueError:
-            parser.error(__('-D option argument must be in the form name=value'))
-        confoverrides[key] = val
-
-    for val in args.htmldefine:
-        try:
-            key, val = val.split('=')
-        except ValueError:
-            parser.error(__('-A option argument must be in the form name=value'))
-        try:
-            val = int(val)
-        except ValueError:
-            pass
-        confoverrides['html_context.%s' % key] = val
-
-    if args.nitpicky:
-        confoverrides['nitpicky'] = True
-
-    args.confoverrides = confoverrides
-
-    return args
-
-
-def build_main(argv: list[str] = sys.argv[1:]) -> int:
-    """Sphinx build "main" command-line entry."""
-    args = _parse_arguments(argv)
-
-    app = None
-    try:
-        confdir = args.confdir or args.sourcedir
-        with patch_docutils(confdir), docutils_namespace():
-            app = Sphinx(args.sourcedir, args.confdir, args.outputdir,
-                         args.doctreedir, args.builder, args.confoverrides, args.status,
-                         args.warning, args.freshenv, args.warningiserror,
-                         args.tags, args.verbosity, args.jobs, args.keep_going,
-                         args.pdb)
-            app.build(args.force_all, args.filenames)
-            return app.statuscode
-    except (Exception, KeyboardInterrupt) as exc:
-        handle_exception(app, args, exc, args.error)
-        return 2
-
-
-def _bug_report_info() -> int:
-    from platform import platform, python_implementation
-
-    import docutils
-    import jinja2
-    import pygments
-
-    print('Please paste all output below into the bug report template\n\n')
-    print('```text')
-    print(f'Platform:              {sys.platform}; ({platform()})')
-    print(f'Python version:        {sys.version})')
-    print(f'Python implementation: {python_implementation()}')
-    print(f'Sphinx version:        {sphinx.__display_version__}')
-    print(f'Docutils version:      {docutils.__version__}')
-    print(f'Jinja2 version:        {jinja2.__version__}')
-    print(f'Pygments version:      {pygments.__version__}')
-    print('```')
-    return 0
-
-
-def main(argv: list[str] = sys.argv[1:]) -> int:
-    sphinx.locale.setlocale(locale.LC_ALL, '')
-    sphinx.locale.init_console(os.path.join(package_dir, 'locale'), 'sphinx')
-
-    if argv[:1] == ['--bug-report']:
-        return _bug_report_info()
-    if argv[:1] == ['-M']:
-        return make_main(argv)
-    else:
-        return build_main(argv)
-
-
-if __name__ == '__main__':
-    raise SystemExit(main())

py2docfx/venv/template/Lib/site-packages/sphinx/cmd/make_mode.py

@@ -1,161 +0,0 @@
-"""sphinx-build -M command-line handling.
-
-This replaces the old, platform-dependent and once-generated content
-of Makefile / make.bat.
-
-This is in its own module so that importing it is fast.  It should not
-import the main Sphinx modules (like sphinx.applications, sphinx.builders).
-"""
-
-from __future__ import annotations
-
-import os
-import subprocess
-import sys
-from os import path
-
-import sphinx
-from sphinx.cmd.build import build_main
-from sphinx.util.console import blue, bold, color_terminal, nocolor  # type: ignore
-from sphinx.util.osutil import cd, rmtree
-
-BUILDERS = [
-    ("",      "html",        "to make standalone HTML files"),
-    ("",      "dirhtml",     "to make HTML files named index.html in directories"),
-    ("",      "singlehtml",  "to make a single large HTML file"),
-    ("",      "pickle",      "to make pickle files"),
-    ("",      "json",        "to make JSON files"),
-    ("",      "htmlhelp",    "to make HTML files and an HTML help project"),
-    ("",      "qthelp",      "to make HTML files and a qthelp project"),
-    ("",      "devhelp",     "to make HTML files and a Devhelp project"),
-    ("",      "epub",        "to make an epub"),
-    ("",      "latex",       "to make LaTeX files, you can set PAPER=a4 or PAPER=letter"),
-    ("posix", "latexpdf",    "to make LaTeX and PDF files (default pdflatex)"),
-    ("posix", "latexpdfja",  "to make LaTeX files and run them through platex/dvipdfmx"),
-    ("",      "text",        "to make text files"),
-    ("",      "man",         "to make manual pages"),
-    ("",      "texinfo",     "to make Texinfo files"),
-    ("posix", "info",        "to make Texinfo files and run them through makeinfo"),
-    ("",      "gettext",     "to make PO message catalogs"),
-    ("",      "changes",     "to make an overview of all changed/added/deprecated items"),
-    ("",      "xml",         "to make Docutils-native XML files"),
-    ("",      "pseudoxml",   "to make pseudoxml-XML files for display purposes"),
-    ("",      "linkcheck",   "to check all external links for integrity"),
-    ("",      "doctest",     "to run all doctests embedded in the documentation "
-                             "(if enabled)"),
-    ("",      "coverage",    "to run coverage check of the documentation (if enabled)"),
-    ("",      "clean",       "to remove everything in the build directory"),
-]
-
-
-class Make:
-    def __init__(self, srcdir: str, builddir: str, opts: list[str]) -> None:
-        self.srcdir = srcdir
-        self.builddir = builddir
-        self.opts = opts
-        self.makecmd = os.environ.get('MAKE', 'make')  # refer $MAKE to determine make command
-
-    def builddir_join(self, *comps: str) -> str:
-        return path.join(self.builddir, *comps)
-
-    def build_clean(self) -> int:
-        srcdir = path.abspath(self.srcdir)
-        builddir = path.abspath(self.builddir)
-        if not path.exists(self.builddir):
-            return 0
-        elif not path.isdir(self.builddir):
-            print("Error: %r is not a directory!" % self.builddir)
-            return 1
-        elif srcdir == builddir:
-            print("Error: %r is same as source directory!" % self.builddir)
-            return 1
-        elif path.commonpath([srcdir, builddir]) == builddir:
-            print("Error: %r directory contains source directory!" % self.builddir)
-            return 1
-        print("Removing everything under %r..." % self.builddir)
-        for item in os.listdir(self.builddir):
-            rmtree(self.builddir_join(item))
-        return 0
-
-    def build_help(self) -> None:
-        if not color_terminal():
-            nocolor()
-
-        print(bold("Sphinx v%s" % sphinx.__display_version__))
-        print("Please use `make %s' where %s is one of" % ((blue('target'),) * 2))
-        for osname, bname, description in BUILDERS:
-            if not osname or os.name == osname:
-                print(f'  {blue(bname.ljust(10))}  {description}')
-
-    def build_latexpdf(self) -> int:
-        if self.run_generic_build('latex') > 0:
-            return 1
-
-        if sys.platform == 'win32':
-            makecmd = os.environ.get('MAKE', 'make.bat')
-        else:
-            makecmd = self.makecmd
-        try:
-            with cd(self.builddir_join('latex')):
-                return subprocess.call([makecmd, 'all-pdf'])
-        except OSError:
-            print('Error: Failed to run: %s' % makecmd)
-            return 1
-
-    def build_latexpdfja(self) -> int:
-        if self.run_generic_build('latex') > 0:
-            return 1
-
-        if sys.platform == 'win32':
-            makecmd = os.environ.get('MAKE', 'make.bat')
-        else:
-            makecmd = self.makecmd
-        try:
-            with cd(self.builddir_join('latex')):
-                return subprocess.call([makecmd, 'all-pdf'])
-        except OSError:
-            print('Error: Failed to run: %s' % makecmd)
-            return 1
-
-    def build_info(self) -> int:
-        if self.run_generic_build('texinfo') > 0:
-            return 1
-        try:
-            with cd(self.builddir_join('texinfo')):
-                return subprocess.call([self.makecmd, 'info'])
-        except OSError:
-            print('Error: Failed to run: %s' % self.makecmd)
-            return 1
-
-    def build_gettext(self) -> int:
-        dtdir = self.builddir_join('gettext', '.doctrees')
-        if self.run_generic_build('gettext', doctreedir=dtdir) > 0:
-            return 1
-        return 0
-
-    def run_generic_build(self, builder: str, doctreedir: str | None = None) -> int:
-        # compatibility with old Makefile
-        papersize = os.getenv('PAPER', '')
-        opts = self.opts
-        if papersize in ('a4', 'letter'):
-            opts.extend(['-D', 'latex_elements.papersize=' + papersize + 'paper'])
-        if doctreedir is None:
-            doctreedir = self.builddir_join('doctrees')
-
-        args = ['-b', builder,
-                '-d', doctreedir,
-                self.srcdir,
-                self.builddir_join(builder)]
-        return build_main(args + opts)
-
-
-def run_make_mode(args: list[str]) -> int:
-    if len(args) < 3:
-        print('Error: at least 3 arguments (builder, source '
-              'dir, build dir) are required.', file=sys.stderr)
-        return 1
-    make = Make(args[1], args[2], args[3:])
-    run_method = 'build_' + args[0]
-    if hasattr(make, run_method):
-        return getattr(make, run_method)()
-    return make.run_generic_build(args[0])