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

py2docfx/venv/template/Lib/site-packages/sphinx/ext/viewcode.py

@@ -1,341 +0,0 @@
-"""Add links to module code in Python object descriptions."""
-
-from __future__ import annotations
-
-import posixpath
-import traceback
-from os import path
-from typing import Any, Generator, Iterable, cast
-
-from docutils import nodes
-from docutils.nodes import Element, Node
-
-import sphinx
-from sphinx import addnodes
-from sphinx.application import Sphinx
-from sphinx.builders import Builder
-from sphinx.builders.html import StandaloneHTMLBuilder
-from sphinx.environment import BuildEnvironment
-from sphinx.locale import _, __
-from sphinx.pycode import ModuleAnalyzer
-from sphinx.transforms.post_transforms import SphinxPostTransform
-from sphinx.util import get_full_modname, logging
-from sphinx.util.display import status_iterator
-from sphinx.util.nodes import make_refnode
-
-logger = logging.getLogger(__name__)
-
-
-OUTPUT_DIRNAME = '_modules'
-
-
-class viewcode_anchor(Element):
-    """Node for viewcode anchors.
-
-    This node will be processed in the resolving phase.
-    For viewcode supported builders, they will be all converted to the anchors.
-    For not supported builders, they will be removed.
-    """
-
-
-def _get_full_modname(app: Sphinx, modname: str, attribute: str) -> str | None:
-    try:
-        return get_full_modname(modname, attribute)
-    except AttributeError:
-        # sphinx.ext.viewcode can't follow class instance attribute
-        # then AttributeError logging output only verbose mode.
-        logger.verbose('Didn\'t find %s in %s', attribute, modname)
-        return None
-    except Exception as e:
-        # sphinx.ext.viewcode follow python domain directives.
-        # because of that, if there are no real modules exists that specified
-        # by py:function or other directives, viewcode emits a lot of warnings.
-        # It should be displayed only verbose mode.
-        logger.verbose(traceback.format_exc().rstrip())
-        logger.verbose('viewcode can\'t import %s, failed with error "%s"', modname, e)
-        return None
-
-
-def is_supported_builder(builder: Builder) -> bool:
-    if builder.format != 'html':
-        return False
-    elif builder.name == 'singlehtml':
-        return False
-    elif builder.name.startswith('epub') and not builder.config.viewcode_enable_epub:
-        return False
-    else:
-        return True
-
-
-def doctree_read(app: Sphinx, doctree: Node) -> None:
-    env = app.builder.env
-    if not hasattr(env, '_viewcode_modules'):
-        env._viewcode_modules = {}  # type: ignore
-
-    def has_tag(modname: str, fullname: str, docname: str, refname: str) -> bool:
-        entry = env._viewcode_modules.get(modname, None)  # type: ignore
-        if entry is False:
-            return False
-
-        code_tags = app.emit_firstresult('viewcode-find-source', modname)
-        if code_tags is None:
-            try:
-                analyzer = ModuleAnalyzer.for_module(modname)
-                analyzer.find_tags()
-            except Exception:
-                env._viewcode_modules[modname] = False  # type: ignore
-                return False
-
-            code = analyzer.code
-            tags = analyzer.tags
-        else:
-            code, tags = code_tags
-
-        if entry is None or entry[0] != code:
-            entry = code, tags, {}, refname
-            env._viewcode_modules[modname] = entry  # type: ignore
-        _, tags, used, _ = entry
-        if fullname in tags:
-            used[fullname] = docname
-            return True
-
-        return False
-
-    for objnode in list(doctree.findall(addnodes.desc)):
-        if objnode.get('domain') != 'py':
-            continue
-        names: set[str] = set()
-        for signode in objnode:
-            if not isinstance(signode, addnodes.desc_signature):
-                continue
-            modname = signode.get('module')
-            fullname = signode.get('fullname')
-            refname = modname
-            if env.config.viewcode_follow_imported_members:
-                new_modname = app.emit_firstresult(
-                    'viewcode-follow-imported', modname, fullname,
-                )
-                if not new_modname:
-                    new_modname = _get_full_modname(app, modname, fullname)
-                modname = new_modname
-            if not modname:
-                continue
-            fullname = signode.get('fullname')
-            if not has_tag(modname, fullname, env.docname, refname):
-                continue
-            if fullname in names:
-                # only one link per name, please
-                continue
-            names.add(fullname)
-            pagename = posixpath.join(OUTPUT_DIRNAME, modname.replace('.', '/'))
-            signode += viewcode_anchor(reftarget=pagename, refid=fullname, refdoc=env.docname)
-
-
-def env_merge_info(app: Sphinx, env: BuildEnvironment, docnames: Iterable[str],
-                   other: BuildEnvironment) -> None:
-    if not hasattr(other, '_viewcode_modules'):
-        return
-    # create a _viewcode_modules dict on the main environment
-    if not hasattr(env, '_viewcode_modules'):
-        env._viewcode_modules = {}  # type: ignore
-    # now merge in the information from the subprocess
-    for modname, entry in other._viewcode_modules.items():
-        if modname not in env._viewcode_modules:  # type: ignore
-            env._viewcode_modules[modname] = entry  # type: ignore
-        else:
-            if env._viewcode_modules[modname]:  # type: ignore
-                used = env._viewcode_modules[modname][2]  # type: ignore
-                for fullname, docname in entry[2].items():
-                    if fullname not in used:
-                        used[fullname] = docname
-
-
-def env_purge_doc(app: Sphinx, env: BuildEnvironment, docname: str) -> None:
-    modules = getattr(env, '_viewcode_modules', {})
-
-    for modname, entry in list(modules.items()):
-        if entry is False:
-            continue
-
-        code, tags, used, refname = entry
-        for fullname in list(used):
-            if used[fullname] == docname:
-                used.pop(fullname)
-
-        if len(used) == 0:
-            modules.pop(modname)
-
-
-class ViewcodeAnchorTransform(SphinxPostTransform):
-    """Convert or remove viewcode_anchor nodes depends on builder."""
-    default_priority = 100
-
-    def run(self, **kwargs: Any) -> None:
-        if is_supported_builder(self.app.builder):
-            self.convert_viewcode_anchors()
-        else:
-            self.remove_viewcode_anchors()
-
-    def convert_viewcode_anchors(self) -> None:
-        for node in self.document.findall(viewcode_anchor):
-            anchor = nodes.inline('', _('[source]'), classes=['viewcode-link'])
-            refnode = make_refnode(self.app.builder, node['refdoc'], node['reftarget'],
-                                   node['refid'], anchor)
-            node.replace_self(refnode)
-
-    def remove_viewcode_anchors(self) -> None:
-        for node in list(self.document.findall(viewcode_anchor)):
-            node.parent.remove(node)
-
-
-def get_module_filename(app: Sphinx, modname: str) -> str | None:
-    """Get module filename for *modname*."""
-    source_info = app.emit_firstresult('viewcode-find-source', modname)
-    if source_info:
-        return None
-    else:
-        try:
-            filename, source = ModuleAnalyzer.get_module_source(modname)
-            return filename
-        except Exception:
-            return None
-
-
-def should_generate_module_page(app: Sphinx, modname: str) -> bool:
-    """Check generation of module page is needed."""
-    module_filename = get_module_filename(app, modname)
-    if module_filename is None:
-        # Always (re-)generate module page when module filename is not found.
-        return True
-
-    builder = cast(StandaloneHTMLBuilder, app.builder)
-    basename = modname.replace('.', '/') + builder.out_suffix
-    page_filename = path.join(app.outdir, '_modules/', basename)
-
-    try:
-        if path.getmtime(module_filename) <= path.getmtime(page_filename):
-            # generation is not needed if the HTML page is newer than module file.
-            return False
-    except OSError:
-        pass
-
-    return True
-
-
-def collect_pages(app: Sphinx) -> Generator[tuple[str, dict[str, Any], str], None, None]:
-    env = app.builder.env
-    if not hasattr(env, '_viewcode_modules'):
-        return
-    if not is_supported_builder(app.builder):
-        return
-    highlighter = app.builder.highlighter  # type: ignore
-    urito = app.builder.get_relative_uri
-
-    modnames = set(env._viewcode_modules)
-
-    for modname, entry in status_iterator(
-            sorted(env._viewcode_modules.items()),
-            __('highlighting module code... '), "blue",
-            len(env._viewcode_modules),
-            app.verbosity, lambda x: x[0]):
-        if not entry:
-            continue
-        if not should_generate_module_page(app, modname):
-            continue
-
-        code, tags, used, refname = entry
-        # construct a page name for the highlighted source
-        pagename = posixpath.join(OUTPUT_DIRNAME, modname.replace('.', '/'))
-        # highlight the source using the builder's highlighter
-        if env.config.highlight_language in {'default', 'none'}:
-            lexer = env.config.highlight_language
-        else:
-            lexer = 'python'
-        highlighted = highlighter.highlight_block(code, lexer, linenos=False)
-        # split the code into lines
-        lines = highlighted.splitlines()
-        # split off wrap markup from the first line of the actual code
-        before, after = lines[0].split('<pre>')
-        lines[0:1] = [before + '<pre>', after]
-        # nothing to do for the last line; it always starts with </pre> anyway
-        # now that we have code lines (starting at index 1), insert anchors for
-        # the collected tags (HACK: this only works if the tag boundaries are
-        # properly nested!)
-        maxindex = len(lines) - 1
-        for name, docname in used.items():
-            type, start, end = tags[name]
-            backlink = urito(pagename, docname) + '#' + refname + '.' + name
-            lines[start] = (
-                '<div class="viewcode-block" id="%s"><a class="viewcode-back" '
-                'href="%s">%s</a>' % (name, backlink, _('[docs]')) +
-                lines[start])
-            lines[min(end, maxindex)] += '</div>'
-        # try to find parents (for submodules)
-        parents = []
-        parent = modname
-        while '.' in parent:
-            parent = parent.rsplit('.', 1)[0]
-            if parent in modnames:
-                parents.append({
-                    'link': urito(pagename,
-                                  posixpath.join(OUTPUT_DIRNAME, parent.replace('.', '/'))),
-                    'title': parent})
-        parents.append({'link': urito(pagename, posixpath.join(OUTPUT_DIRNAME, 'index')),
-                        'title': _('Module code')})
-        parents.reverse()
-        # putting it all together
-        context = {
-            'parents': parents,
-            'title': modname,
-            'body': (_('<h1>Source code for %s</h1>') % modname +
-                     '\n'.join(lines)),
-        }
-        yield (pagename, context, 'page.html')
-
-    if not modnames:
-        return
-
-    html = ['\n']
-    # the stack logic is needed for using nested lists for submodules
-    stack = ['']
-    for modname in sorted(modnames):
-        if modname.startswith(stack[-1]):
-            stack.append(modname + '.')
-            html.append('<ul>')
-        else:
-            stack.pop()
-            while not modname.startswith(stack[-1]):
-                stack.pop()
-                html.append('</ul>')
-            stack.append(modname + '.')
-        relative_uri = urito(posixpath.join(OUTPUT_DIRNAME, 'index'),
-                             posixpath.join(OUTPUT_DIRNAME, modname.replace('.', '/')))
-        html.append(f'<li><a href="{relative_uri}">{modname}</a></li>\n')
-    html.append('</ul>' * (len(stack) - 1))
-    context = {
-        'title': _('Overview: module code'),
-        'body': (_('<h1>All modules for which code is available</h1>') +
-                 ''.join(html)),
-    }
-
-    yield (posixpath.join(OUTPUT_DIRNAME, 'index'), context, 'page.html')
-
-
-def setup(app: Sphinx) -> dict[str, Any]:
-    app.add_config_value('viewcode_import', None, False)
-    app.add_config_value('viewcode_enable_epub', False, False)
-    app.add_config_value('viewcode_follow_imported_members', True, False)
-    app.connect('doctree-read', doctree_read)
-    app.connect('env-merge-info', env_merge_info)
-    app.connect('env-purge-doc', env_purge_doc)
-    app.connect('html-collect-pages', collect_pages)
-    # app.add_config_value('viewcode_include_modules', [], 'env')
-    # app.add_config_value('viewcode_exclude_modules', [], 'env')
-    app.add_event('viewcode-find-source')
-    app.add_event('viewcode-follow-imported')
-    app.add_post_transform(ViewcodeAnchorTransform)
-    return {
-        'version': sphinx.__display_version__,
-        'env_version': 1,
-        'parallel_read_safe': True
-    }

py2docfx/venv/template/Lib/site-packages/sphinx/extension.py

@@ -1,82 +0,0 @@
-"""Utilities for Sphinx extensions."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from packaging.version import InvalidVersion, Version
-
-from sphinx.config import Config
-from sphinx.errors import VersionRequirementError
-from sphinx.locale import __
-from sphinx.util import logging
-
-if TYPE_CHECKING:
-    from sphinx.application import Sphinx
-
-logger = logging.getLogger(__name__)
-
-
-class Extension:
-    def __init__(self, name: str, module: Any, **kwargs: Any) -> None:
-        self.name = name
-        self.module = module
-        self.metadata = kwargs
-        self.version = kwargs.pop('version', 'unknown version')
-
-        # The extension supports parallel read or not.  The default value
-        # is ``None``.  It means the extension does not tell the status.
-        # It will be warned on parallel reading.
-        self.parallel_read_safe = kwargs.pop('parallel_read_safe', None)
-
-        # The extension supports parallel write or not.  The default value
-        # is ``True``.  Sphinx writes parallelly documents even if
-        # the extension does not tell its status.
-        self.parallel_write_safe = kwargs.pop('parallel_write_safe', True)
-
-
-def verify_needs_extensions(app: Sphinx, config: Config) -> None:
-    """Check that extensions mentioned in :confval:`needs_extensions` satisfy the version
-    requirement, and warn if an extension is not loaded.
-
-    Warns if an extension in :confval:`needs_extension` is not loaded.
-
-    :raises VersionRequirementError: if the version of an extension in
-    :confval:`needs_extension` is unknown or older than the required version.
-    """
-    if config.needs_extensions is None:
-        return
-
-    for extname, reqversion in config.needs_extensions.items():
-        extension = app.extensions.get(extname)
-        if extension is None:
-            logger.warning(__('The %s extension is required by needs_extensions settings, '
-                              'but it is not loaded.'), extname)
-            continue
-
-        fulfilled = True
-        if extension.version == 'unknown version':
-            fulfilled = False
-        else:
-            try:
-                if Version(reqversion) > Version(extension.version):
-                    fulfilled = False
-            except InvalidVersion:
-                if reqversion > extension.version:
-                    fulfilled = False
-
-        if not fulfilled:
-            raise VersionRequirementError(__('This project needs the extension %s at least in '
-                                             'version %s and therefore cannot be built with '
-                                             'the loaded version (%s).') %
-                                          (extname, reqversion, extension.version))
-
-
-def setup(app: Sphinx) -> dict[str, Any]:
-    app.connect('config-inited', verify_needs_extensions, priority=800)
-
-    return {
-        'version': 'builtin',
-        'parallel_read_safe': True,
-        'parallel_write_safe': True,
-    }

py2docfx/venv/template/Lib/site-packages/sphinx/highlighting.py

@@ -1,184 +0,0 @@
-"""Highlight code blocks using Pygments."""
-
-from __future__ import annotations
-
-from functools import partial
-from importlib import import_module
-from typing import Any
-
-from pygments import highlight
-from pygments.filters import ErrorToken
-from pygments.formatter import Formatter
-from pygments.formatters import HtmlFormatter, LatexFormatter
-from pygments.lexer import Lexer
-from pygments.lexers import (CLexer, PythonConsoleLexer, PythonLexer, RstLexer, TextLexer,
-                             get_lexer_by_name, guess_lexer)
-from pygments.style import Style
-from pygments.styles import get_style_by_name
-from pygments.util import ClassNotFound
-
-from sphinx.locale import __
-from sphinx.pygments_styles import NoneStyle, SphinxStyle
-from sphinx.util import logging, texescape
-
-logger = logging.getLogger(__name__)
-
-lexers: dict[str, Lexer] = {}
-lexer_classes: dict[str, type[Lexer] | partial[Lexer]] = {
-    'none': partial(TextLexer, stripnl=False),
-    'python': partial(PythonLexer, stripnl=False),
-    'pycon': partial(PythonConsoleLexer, stripnl=False),
-    'rest': partial(RstLexer, stripnl=False),
-    'c': partial(CLexer, stripnl=False),
-}
-
-
-escape_hl_chars = {ord('\\'): '\\PYGZbs{}',
-                   ord('{'): '\\PYGZob{}',
-                   ord('}'): '\\PYGZcb{}'}
-
-# used if Pygments is available
-# MEMO: no use of \protected here to avoid having to do hyperref extras,
-# (if in future code highlighting in sectioning titles is activated):
-# the definitions here use only robust, protected or chardef tokens,
-# which are all known to the hyperref re-encoding for bookmarks.
-# The " is troublesome because we would like to use \text\textquotedbl
-# but \textquotedbl is *defined to raise an error* (!) if the font
-# encoding is OT1.  This however could happen from 'fontenc' key.
-# MEMO: the Pygments escapes with \char`\<char> syntax, if the document
-# uses old OT1 font encoding, work correctly only in monospace font.
-# MEMO: the Pygmentize output mark-up is always with a {} after.
-_LATEX_ADD_STYLES = r'''
-% Sphinx redefinitions
-% Originally to obtain a straight single quote via package textcomp, then
-% to fix problems for the 5.0.0 inline code highlighting (captions!).
-% The \text is from amstext, a dependency of sphinx.sty.  It is here only
-% to avoid build errors if for some reason expansion is in math mode.
-\def\PYGZbs{\text\textbackslash}
-\def\PYGZus{\_}
-\def\PYGZob{\{}
-\def\PYGZcb{\}}
-\def\PYGZca{\text\textasciicircum}
-\def\PYGZam{\&}
-\def\PYGZlt{\text\textless}
-\def\PYGZgt{\text\textgreater}
-\def\PYGZsh{\#}
-\def\PYGZpc{\%}
-\def\PYGZdl{\$}
-\def\PYGZhy{\sphinxhyphen}% defined in sphinxlatexstyletext.sty
-\def\PYGZsq{\text\textquotesingle}
-\def\PYGZdq{"}
-\def\PYGZti{\text\textasciitilde}
-\makeatletter
-% use \protected to allow syntax highlighting in captions
-\protected\def\PYG#1#2{\PYG@reset\PYG@toks#1+\relax+{\PYG@do{#2}}}
-\makeatother
-'''
-
-
-class PygmentsBridge:
-    # Set these attributes if you want to have different Pygments formatters
-    # than the default ones.
-    html_formatter = HtmlFormatter
-    latex_formatter = LatexFormatter
-
-    def __init__(self, dest: str = 'html', stylename: str = 'sphinx',
-                 latex_engine: str | None = None) -> None:
-        self.dest = dest
-        self.latex_engine = latex_engine
-
-        style = self.get_style(stylename)
-        self.formatter_args: dict[str, Any] = {'style': style}
-        if dest == 'html':
-            self.formatter = self.html_formatter
-        else:
-            self.formatter = self.latex_formatter
-            self.formatter_args['commandprefix'] = 'PYG'
-
-    def get_style(self, stylename: str) -> Style:
-        if stylename is None or stylename == 'sphinx':
-            return SphinxStyle
-        elif stylename == 'none':
-            return NoneStyle
-        elif '.' in stylename:
-            module, stylename = stylename.rsplit('.', 1)
-            return getattr(import_module(module), stylename)
-        else:
-            return get_style_by_name(stylename)
-
-    def get_formatter(self, **kwargs: Any) -> Formatter:
-        kwargs.update(self.formatter_args)
-        return self.formatter(**kwargs)
-
-    def get_lexer(self, source: str, lang: str, opts: dict | None = None,
-                  force: bool = False, location: Any = None) -> Lexer:
-        if not opts:
-            opts = {}
-
-        # find out which lexer to use
-        if lang in {'py', 'python', 'py3', 'python3', 'default'}:
-            if source.startswith('>>>'):
-                # interactive session
-                lang = 'pycon'
-            else:
-                lang = 'python'
-        if lang == 'pycon3':
-            lang = 'pycon'
-
-        if lang in lexers:
-            # just return custom lexers here (without installing raiseonerror filter)
-            return lexers[lang]
-        elif lang in lexer_classes:
-            lexer = lexer_classes[lang](**opts)
-        else:
-            try:
-                if lang == 'guess':
-                    lexer = guess_lexer(source, **opts)
-                else:
-                    lexer = get_lexer_by_name(lang, **opts)
-            except ClassNotFound:
-                logger.warning(__('Pygments lexer name %r is not known'), lang,
-                               location=location)
-                lexer = lexer_classes['none'](**opts)
-
-        if not force:
-            lexer.add_filter('raiseonerror')
-
-        return lexer
-
-    def highlight_block(self, source: str, lang: str, opts: dict | None = None,
-                        force: bool = False, location: Any = None, **kwargs: Any) -> str:
-        if not isinstance(source, str):
-            source = source.decode()
-
-        lexer = self.get_lexer(source, lang, opts, force, location)
-
-        # highlight via Pygments
-        formatter = self.get_formatter(**kwargs)
-        try:
-            hlsource = highlight(source, lexer, formatter)
-        except ErrorToken:
-            # this is most probably not the selected language,
-            # so let it pass unhighlighted
-            if lang == 'default':
-                pass  # automatic highlighting failed.
-            else:
-                logger.warning(__('Could not lex literal_block as "%s". '
-                                  'Highlighting skipped.'), lang,
-                               type='misc', subtype='highlighting_failure',
-                               location=location)
-            lexer = self.get_lexer(source, 'none', opts, force, location)
-            hlsource = highlight(source, lexer, formatter)
-
-        if self.dest == 'html':
-            return hlsource
-        else:
-            # MEMO: this is done to escape Unicode chars with non-Unicode engines
-            return texescape.hlescape(hlsource, self.latex_engine)
-
-    def get_stylesheet(self) -> str:
-        formatter = self.get_formatter()
-        if self.dest == 'html':
-            return formatter.get_style_defs('.highlight')
-        else:
-            return formatter.get_style_defs() + _LATEX_ADD_STYLES