| Server IP : 127.0.0.1 / Your IP : 216.73.216.109 Web Server : Apache/2.4.54 (Win64) OpenSSL/1.1.1q PHP/8.1.10 System : Windows NT DESKTOP-E5T4RUN 10.0 build 19045 (Windows 10) AMD64 User : SERVERWEB ( 0) PHP Version : 8.1.10 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : C:/cygwin64/lib/python3.9/site-packages/sphinx/__pycache__/ |
Upload File : |
a
�ab�� � @ sX d Z ddlZddlZddlZddlZddlmZ ddlmZ ddlm Z ddl
m Z m Z m
Z
mZmZmZmZmZmZmZ ddlmZ ddlmZmZ dd lmZ dd
l m Z m Z dd l m Z dd l!m"Z" ddl#Z#dd
l#m$Z$m%Z% ddl&m'Z' ddl(m)Z) ddl*m+Z+m,Z, ddl-m.Z. ddl/m0Z0 ddl1m2Z2m3Z3m4Z4 ddl5m6Z6 ddl7m8Z8 ddl9m:Z: ddl;m<Z< ddl=m>Z> ddl?m@Z@ ddlAmBZB ddlCmDZD dd lEmZmFZFmGZG dd lHmIZI dd lJmKZK dd lLmMZM dd lNmOZO dd!lPmQZQmRZRmSZS dd"lTmUZU dd#lVmWZWmXZX e �r&dd$lmYZY dd%lZm[Z[ d&Z\d'Z]eF�^e_�Z`G d(d)� d)�ZaG d*d+� d+�ZbdS ),a
sphinx.application
~~~~~~~~~~~~~~~~~~
Sphinx application class and extensibility interface.
Gracefully adapted from the TextPress system by Armin.
:copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
� N)�deque)�StringIO)�path)
�IO�
TYPE_CHECKING�Any�Callable�Dict�List�Optional�Tuple�Type�Union)�nodes)�Element� TextElement)�Parser)� Directive�roles)� Transform)�Lexer)�locale� package_dir)�Config)�RemovedInSphinx60Warning)�Domain�Index)�BuildEnvironment)�EnvironmentCollector)�ApplicationError� ConfigError�VersionRequirementError)� EventManager)� Extension)�
lexer_classes)�__)�Project)�SphinxComponentRegistry)�XRefRole)�Theme)�docutils�logging�progress_message)�
BuildPhase)�bold)�CatalogRepository)�prefixed_warnings)�abspath� ensuredir�relpath)�Tags)� RoleFunction� TitleGetter)�Node)�Builder)5zsphinx.addnodeszsphinx.builders.changeszsphinx.builders.epub3zsphinx.builders.dirhtmlzsphinx.builders.dummyzsphinx.builders.gettextzsphinx.builders.htmlzsphinx.builders.latexzsphinx.builders.linkcheckzsphinx.builders.manpagezsphinx.builders.singlehtmlzsphinx.builders.texinfozsphinx.builders.textzsphinx.builders.xmlz
sphinx.configzsphinx.domains.czsphinx.domains.changesetzsphinx.domains.citationzsphinx.domains.cppzsphinx.domains.indexzsphinx.domains.javascriptzsphinx.domains.mathzsphinx.domains.pythonzsphinx.domains.rstzsphinx.domains.stdzsphinx.directiveszsphinx.directives.codezsphinx.directives.otherzsphinx.directives.patcheszsphinx.extensionzsphinx.parserszsphinx.registryz sphinx.roleszsphinx.transformsz%sphinx.transforms.compact_bullet_listzsphinx.transforms.i18nz sphinx.transforms.referencesz!sphinx.transforms.post_transformsz&sphinx.transforms.post_transforms.codez(sphinx.transforms.post_transforms.imageszsphinx.util.compatzsphinx.versioningz*sphinx.environment.collectors.dependenciesz#sphinx.environment.collectors.assetz&sphinx.environment.collectors.metadataz#sphinx.environment.collectors.titlez%sphinx.environment.collectors.toctreezsphinxcontrib.applehelpzsphinxcontrib.devhelpzsphinxcontrib.htmlhelpz sphinxcontrib.serializinghtmlzsphinxcontrib.qthelpZ alabasterzenvironment.picklec @ s� e Zd ZU dZeed< eed< dejej ddddddf e
e e
e
e
e
e e
e
eeee
eeedd�dd �Zdd
�d d �Zedd
�dd�Ze
dd�dd�Ze
dd�dd�Zdd
�dd�Zd�eee
dd�dd�Ze
dd�d d �Ze
dd �d d �Zd�e
eeed"�d#d$�Zedd%�d&d'�Zd(d)�e
ee e e d*f ed+�d,d-�Z d(d)�e
ee e e d*f ed+�d.d/�Z d�e d edd0�d1d2�Z!d�e
ee"ee
f edd3�d4d5�Z#e
dd�d6d7�Z$d�e
e e%j& edd8�d9d:�Z'd�e e( ee ee e f dd;�d<d=�Z)d�e e( e
e*ee eef dd>�d?d@�Z+d�e
e e, eddA�dBdC�Z-d�e
eeddD�dEdF�Z.d�e
eeddG�dHdI�Z/d�e e0 eddJ�dKdL�Z1d�e
e
e e, eddM�dNdO�Z2d�e
e
e"e3e4f eddP�dQdR�Z5d�e
e e6 eddS�dTdU�Z7dVdddVg dfe
e
e
ee e8 e
eeddW� dXdY�Z9d�e
e
e
e e8 e
eddZ�d[d\�Z:e e; dd]�d^d_�Z<e e; dd]�d`da�Z=d�e
ee e
eddb�dcdd�Z>d�e
eedde�dfdg�Z?d�e
ee
ddh�didj�Z@d�e
e
eddk�dldm�ZAe
e eB ddn�dodp�ZCd�eeddq�drds�ZDe eee
egef ddt�dudv�ZEeddw�dxdy�ZFd�e
e
eddz�d{d|�ZGd�e eH edd}�d~d�ZIe eJ dd��d�d��ZKe
e
dd��d�d��ZLd�e
e eef e eef dd��d�d��ZMe
e
dd��d�d��ZNe
ed��d�d��ZOd�d�� ZPeQe e
e
f d
�d�d���ZRdS )��Sphinxa The main application class and extensibility interface.
:ivar srcdir: Directory containing source.
:ivar confdir: Directory containing ``conf.py``.
:ivar doctreedir: Directory for storing pickled doctrees.
:ivar outdir: Directory for storing build documents.
�warningiserror�
_warncountNFr )�srcdir�confdir�outdir�
doctreedir� buildername�
confoverrides�status�warning�freshenvr: �tags� verbosity�parallel�
keep_going�returnc C s t j| _| | _i | _d | _d | _d | _t� | _ t
|�| _ t
|�| _ t
|�| _
t�| j �sjttd�| j ��t�| j �r�t�| j �s�ttd�| j ��| j | j kr�ttd���|
| _|d u r�t� | _d| _n || _d| _|d u r�t� | _n|| _d| _|
o�|| _| j�rd| _n|
| _t� | | j| j� t | �| _ t dd�| _ t!�"t#td �t$j% �� d| _&t'| �| _(|d u �r�| j | _)t*i |�p�i �| _+n$t
|�| _)t*�,| j)|�p�i | j(�| _+| j+�-� | �.� | j+j/�r�| j+j/t$j%k�r�t0td
�| j+j/ ��t1D ]}| �2|� �q�| j+jD ]}| �2|� �q | �3|� t�|��sjt4td ��� t5|� W d � n1 �s`0 Y | j+j �r�td �d
}t6|��8 t7| j+j ��r�| j+� | � n t8td���W d � n1 �s�0 Y | j+�9� | j �:d| j+� t;| j | j+j<�| _| �=|�| _| �>| � | �?� d S )Nz!Cannot find source directory (%s)z(Output directory (%s) is not a directoryz>Source directory and destination directory cannot be identicalTFr �
)�maxlenzRunning Sphinx v%szWThis project needs at least Sphinx v%s and therefore cannot be built with this version.zmaking output directoryz while setting up extension %s:zconf.pyz�'setup' as currently defined in conf.py isn't a Python callable. Please modify its definition to make it a callable function. This is needed for conf.py to behave as a Sphinx extension.z
config-inited)@r- ZINITIALIZATION�phaserF �
extensions�builder�env�projectr' �registryr1 r< r> r? r �isdirr r% �existsrG r Z_status�quietZ_warningr; rH r: r+ �setupr" �eventsr Z
messagelog�logger�infor. �sphinx�__display_version__�
statuscoder4 rE r= r �config�readZpre_init_values�
_init_i18nZ needs_sphinxr! �builtin_extensions�setup_extension�preload_builderr, r2 r0 �callabler Z init_values�emitr& Z
source_suffix�create_builder� _init_env�
_init_builder)�selfr< r= r> r? r@ rA rB rC rD r: rE rF rG rH � extension�prefix� rj �6/usr/lib/python3.9/site-packages/sphinx/application.py�__init__� s�
��
��
(
�$
zSphinx.__init__�rI c C s� | j jdu r t�g d�\| _}n�tjttd�| j j �dd� t | j
| j j | j j| j j �}|j
D ]*}|jdkr`|�� r`|�| j j| j j� q`t|j �}|dg7 }|t�td�g7 }t�|| j j�\| _}|s�| j jdkr�t�td�� nt�td �� dS )
zhLoad translated strings from the configured localedirs if enabled in
the configuration.
Nz loading translations [%s]... T)ZnonlrY r �enZdonez#not available for built-in messages)r\ �languager �initZ
translatorrW rX r. r% r/ r< � locale_dirsZsource_encodingZcatalogs�domainZ is_outdatedZwrite_moZ gettext_allow_fuzzy_translations�listr �joinr )rg Zhas_translationZrepo�catalogrq rj rj rk r^ s( � �
�
zSphinx._init_i18n)rD rI c
C s� t �| jt�}|s tj �|�s<t| �| _| j�| j | j
� n�zrt t d���R t
|d��(}t�|�| _| j�| � W d � n1 s�0 Y W d � n1 s�0 Y W n@ ty� } z(t�t d�|� | jdd� W Y d }~n
d }~0 0 d S )Nzloading pickled environment�rbz
failed: %sT)rD )r rt r? �ENV_PICKLE_FILENAME�osrS r rO Z
find_filesr\ rN r, r% �open�pickle�loadrU � ExceptionrW rX re )rg rD �filename�f�errrj rj rk re & s
LzSphinx._init_env)�namerI c C s | j �| |� d S )N)rQ ra �rg r� rj rj rk ra 5 s zSphinx.preload_builderr8 c C s( |d u rt �td�� d}| j�| |�S )Nz(No builder selected, using default: htmlZhtml)rW rX r% rQ rd r� rj rj rk rd 8 s zSphinx.create_builderc C s( | j �| j� | j �� | j�d� d S )Nzbuilder-inited)rN Zset_environmentrO rp rV rc �rg rj rj rk rf ? s
zSphinx._init_builder)� force_all� filenamesrI c
C s� t j| _�z4|r&| j�� | j�� n2|rD| j�|� | j�|� n| j�� | j� � | j
rj| j rjd| _ | j dkr|t
d�nt
d�}| j
r�| jr�| j
dkr�t
d�}q�t
d�}n | j
dkr�t
d�}nt
d�}t�t||| j
f �� nt�tt
d �| �� | j dk�r<| jj�r<t�d
� t�| jjt| j�| jjd � � W nZ t�y� } z@t�| jt�}t� |��rtt � |� | j � d |� � W Y d }~nd }~0 0 | j � d d � | j�!� d S )
N� r Z succeededzfinished with problemsz7build %s, %s warning (with warnings treated as errors).z8build %s, %s warnings (with warnings treated as errors).zbuild %s, %s warning.zbuild %s, %s warnings.z build %s.� )r> rP zbuild-finished)"r- ZREADINGrL rN Zcompile_all_catalogsZ build_allZcompile_specific_catalogsZbuild_specificZcompile_update_catalogsZ build_updater; rH r[ r% r: rW rX r. �epilogr3 r> r\ rP r| r rt r? rw �isfilerx �unlinkrV rc Zcleanup)rg r� r� rB �msgr Zenvfilerj rj rk �buildF sN
�
�
z Sphinx.build)�extnamerI c C s t �d|� | j�| |� dS )z�Import and setup a Sphinx extension module.
Load the extension given by the module *name*. Use this if your
extension needs the features provided by another extension. No-op if
called twice.
z [app] setting up extension: %rN)rW �debugrQ Zload_extension)rg r� rj rj rk r` { s zSphinx.setup_extension)�versionrI c C s |t jdd� krt|��dS )a Check the Sphinx version if requested.
Compare *version* with the version of the running Sphinx, and abort the
build when it is too old.
:param version: The required version in the form of ``major.minor``.
.. versionadded:: 1.0
N� )rY rZ r! )rg r� rj rj rk �require_sphinx� s
zSphinx.require_sphinx�� )�event�callback�priorityrI c C s& | j �|||�}t�d||||� |S )a? Register *callback* to be called when *event* is emitted.
For details on available core events and the arguments of callback
functions, please see :ref:`events`.
:param event: The name of target event
:param callback: Callback function for the event
:param priority: The priority of the callback. The callbacks will be invoked
in order of *priority* (ascending).
:return: A listener ID. It can be used for :meth:`disconnect`.
.. versionchanged:: 3.0
Support *priority*
z*[app] connecting event %r (%d): %r [id=%s])rV �connectrW r� )rg r� r� r� � listener_idrj rj rk r� � s
�zSphinx.connect)r� rI c C s t �d|� | j�|� dS )zvUnregister callback by *listener_id*.
:param listener_id: A listener_id that :meth:`connect` returns
z"[app] disconnecting event: [id=%s]N)rW r� rV �
disconnect)rg r� rj rj rk r� � s zSphinx.disconnectrj )�allowed_exceptions.)r� �argsr� rI c G s | j j|g|�R d|i�S )a� Emit *event* and pass *arguments* to the callback functions.
Return the return values of all callbacks as a list. Do not emit core
Sphinx events in extensions!
:param event: The name of event that will be emitted
:param args: The arguments for the event
:param allowed_exceptions: The list of exceptions that are allowed in the callbacks
.. versionchanged:: 3.1
Added *allowed_exceptions* to specify path-through exceptions
r� )rV rc �rg r� r� r� rj rj rk rc � s z Sphinx.emitc G s | j j|g|�R d|i�S )a� Emit *event* and pass *arguments* to the callback functions.
Return the result of the first callback that doesn't return ``None``.
:param event: The name of event that will be emitted
:param args: The arguments for the event
:param allowed_exceptions: The list of exceptions that are allowed in the callbacks
.. versionadded:: 0.5
.. versionchanged:: 3.1
Added *allowed_exceptions* to specify path-through exceptions
r� )rV �emit_firstresultr� rj rj rk r� � s �zSphinx.emit_firstresult)rN �overriderI c C s | j j||d� dS )a# Register a new builder.
:param builder: A builder class
:param override: If true, install the builder forcedly even if another builder
is already installed as the same name
.. versionchanged:: 1.8
Add *override* keyword.
�r� N)rQ � add_builder)rg rN r� rj rj rk r� � s
zSphinx.add_builder)r� �default�rebuild�typesrI c C s> t �d||||f� |dv r(|r$dnd}| j�||||� dS )ag Register a configuration value.
This is necessary for Sphinx to recognize new values and set default
values accordingly.
:param name: The name of the configuration value. It is recommended to be prefixed
with the extension name (ex. ``html_logo``, ``epub_title``)
:param default: The default value of the configuration.
:param rebuild: The condition of rebuild. It must be one of those values:
* ``'env'`` if a change in the setting only takes effect when a
document is parsed -- this means that the whole environment must be
rebuilt.
* ``'html'`` if a change in the setting needs a full rebuild of HTML
documents.
* ``''`` if a change in the setting will not need any special rebuild.
:param types: The type of configuration value. A list of types can be specified. For
example, ``[str]`` is used to describe a configuration that takes string
value.
.. versionchanged:: 0.4
If the *default* value is a callable, it will be called with the
config object as its argument in order to get the default value.
This can be used to implement config values whose default depends on
other values.
.. versionchanged:: 0.6
Changed *rebuild* from a simple boolean (equivalent to ``''`` or
``'env'``) to a string. However, booleans are still accepted and
converted internally.
z [app] adding config value: %r)FTrO r� N)rW r� r\ �add)rg r� r� r� r� rj rj rk �add_config_value� s " zSphinx.add_config_valuec C s t �d|� | j�|� dS )z�Register an event called *name*.
This is needed to be able to emit it.
:param name: The name of the event
z[app] adding event: %rN)rW r� rV r� r� rj rj rk � add_event s zSphinx.add_event)r� �translator_classr� rI c C s | j j|||d� dS )a� Register or override a Docutils translator class.
This is used to register a custom output translator or to replace a
builtin translator. This allows extensions to use a custom translator
and define custom nodes for the translator (see :meth:`add_node`).
:param name: The name of the builder for the translator
:param translator_class: A translator class
:param override: If true, install the translator forcedly even if another translator
is already installed as the same name
.. versionadded:: 1.3
.. versionchanged:: 1.8
Add *override* keyword.
r� N)rQ Zadd_translator)rg r� r� r� rj rj rk �set_translator s zSphinx.set_translator)�noder� �kwargsrI c K sX t �d||f� |s6t�|�r6t jtd�|jddd� t�|� | jj |fi |�� dS )a� Register a Docutils node class.
This is necessary for Docutils internals. It may also be used in the
future to validate nodes in the parsed documents.
:param node: A node class
:param kwargs: Visitor functions for each builder (see below)
:param override: If true, install the node forcedly even if another node is already
installed as the same name
Node visitor functions for the Sphinx HTML, LaTeX, text and manpage
writers can be given as keyword arguments: the keyword should be one or
more of ``'html'``, ``'latex'``, ``'text'``, ``'man'``, ``'texinfo'``
or any other supported translators, the value a 2-tuple of ``(visit,
depart)`` methods. ``depart`` can be ``None`` if the ``visit``
function raises :exc:`docutils.nodes.SkipNode`. Example:
.. code-block:: python
class math(docutils.nodes.Element): pass
def visit_math_html(self, node):
self.body.append(self.starttag(node, 'math'))
def depart_math_html(self, node):
self.body.append('</math>')
app.add_node(math, html=(visit_math_html, depart_math_html))
Obviously, translators for which you don't specify visitor methods will
choke on the node when encountered in a document to translate.
.. versionchanged:: 0.5
Added the support for keyword arguments giving visit functions.
z[app] adding node: %rzDnode class %r is already registered, its visitors will be overridden�app�add_node��typeZsubtypeN)
rW r� r* Zis_node_registeredrC r% �__name__Z
register_noderQ Zadd_translation_handlers)rg r� r� r� rj rj rk r� & s $
�
zSphinx.add_node)r� �figtype� title_getterr� r� rI c K s. | j j||||d� | j|fd|i|�� dS )a_ Register a Docutils node class as a numfig target.
Sphinx numbers the node automatically. And then the users can refer it
using :rst:role:`numref`.
:param node: A node class
:param figtype: The type of enumerable nodes. Each figtype has individual numbering
sequences. As system figtypes, ``figure``, ``table`` and
``code-block`` are defined. It is possible to add custom nodes to
these default figtypes. It is also possible to define new custom
figtype if a new figtype is given.
:param title_getter: A getter function to obtain the title of node. It takes an
instance of the enumerable node, and it must return its title as
string. The title is used to the default title of references for
:rst:role:`ref`. By default, Sphinx searches
``docutils.nodes.caption`` or ``docutils.nodes.title`` from the
node as a title.
:param kwargs: Visitor functions for each builder (same as :meth:`add_node`)
:param override: If true, install the node forcedly even if another node is already
installed as the same name
.. versionadded:: 1.4
r� r� N)rQ �add_enumerable_noder� )rg r� r� r� r� r� rj rj rk r� R s zSphinx.add_enumerable_node)r� �clsr� rI c C sD t �d||f� |s4t�|�r4t jtd�|ddd� t�||� dS )a^ Register a Docutils directive.
:param name: The name of the directive
:param cls: A directive class
:param override: If true, install the directive forcedly even if another directive
is already installed as the same name
For example, a custom directive named ``my-directive`` would be added
like this:
.. code-block:: python
from docutils.parsers.rst import Directive, directives
class MyDirective(Directive):
has_content = True
required_arguments = 1
optional_arguments = 0
final_argument_whitespace = True
option_spec = {
'class': directives.class_option,
'name': directives.unchanged,
}
def run(self):
...
def setup(app):
app.add_directive('my-directive', MyDirective)
For more details, see `the Docutils docs
<https://docutils.sourceforge.io/docs/howto/rst-directives.html>`__ .
.. versionchanged:: 0.6
Docutils 0.5-style directive classes are now supported.
.. deprecated:: 1.8
Docutils 0.4-style (function based) directives support is deprecated.
.. versionchanged:: 1.8
Add *override* keyword.
z[app] adding directive: %rz9directive %r is already registered, it will be overriddenr� �
add_directiver� N)rW r� r* Zis_directive_registeredrC r% Zregister_directive)rg r� r� r� rj rj rk r� o s )
�zSphinx.add_directive)r� �roler� rI c C sD t �d||f� |s4t�|�r4t jtd�|ddd� t�||� dS )a� Register a Docutils role.
:param name: The name of role
:param role: A role function
:param override: If true, install the role forcedly even if another role is already
installed as the same name
For more details about role functions, see `the Docutils docs
<https://docutils.sourceforge.io/docs/howto/rst-roles.html>`__ .
.. versionchanged:: 1.8
Add *override* keyword.
z[app] adding role: %r�4role %r is already registered, it will be overriddenr� �add_roler� N)rW r� r* �is_role_registeredrC r% �
register_role)rg r� r� r� rj rj rk r� � s
�zSphinx.add_role)r� � nodeclassr� rI c C sP t �d||f� |s4t�|�r4t jtd�|ddd� t�||�}t�||� dS )a� Register a generic Docutils role.
Register a Docutils role that does nothing but wrap its contents in the
node given by *nodeclass*.
If *override* is True, the given *nodeclass* is forcedly installed even if
a role named as *name* is already installed.
.. versionadded:: 0.6
.. versionchanged:: 1.8
Add *override* keyword.
z [app] adding generic role: %rr� r� �add_generic_roler� N) rW r� r* r� rC r% r Z GenericRoler� )rg r� r� r� r� rj rj rk r� � s
� zSphinx.add_generic_role)rr r� rI c C s | j j||d� dS )a8 Register a domain.
:param domain: A domain class
:param override: If true, install the domain forcedly even if another domain
is already installed as the same name
.. versionadded:: 1.0
.. versionchanged:: 1.8
Add *override* keyword.
r� N)rQ �
add_domain)rg rr r� rj rj rk r� � s zSphinx.add_domain)rr r� r� r� rI c C s | j j||||d� dS )a Register a Docutils directive in a domain.
Like :meth:`add_directive`, but the directive is added to the domain
named *domain*.
:param domain: The name of target domain
:param name: A name of directive
:param cls: A directive class
:param override: If true, install the directive forcedly even if another directive
is already installed as the same name
.. versionadded:: 1.0
.. versionchanged:: 1.8
Add *override* keyword.
r� N)rQ �add_directive_to_domain)rg rr r� r� r� rj rj rk r� � s z Sphinx.add_directive_to_domain)rr r� r� r� rI c C s | j j||||d� dS )a Register a Docutils role in a domain.
Like :meth:`add_role`, but the role is added to the domain named
*domain*.
:param domain: The name of the target domain
:param name: The name of the role
:param role: The role function
:param override: If true, install the role forcedly even if another role is already
installed as the same name
.. versionadded:: 1.0
.. versionchanged:: 1.8
Add *override* keyword.
r� N)rQ �add_role_to_domain)rg rr r� r� r� rj rj rk r� � s zSphinx.add_role_to_domain)rr �indexr� rI c C s | j �||� dS )a� Register a custom index for a domain.
Add a custom *index* class to the domain named *domain*.
:param domain: The name of the target domain
:param index: The index class
:param override: If true, install the index forcedly even if another index is
already installed as the same name
.. versionadded:: 1.0
.. versionchanged:: 1.8
Add *override* keyword.
N)rQ �add_index_to_domain)rg rr r� r� rj rj rk r� � s zSphinx.add_index_to_domainr� ) �
directivename�rolename�
indextemplate�
parse_node�
ref_nodeclass�objname�doc_field_typesr� rI c
C s | j j||||||||d� dS )aX
Register a new object type.
This method is a very convenient way to add a new :term:`object` type
that can be cross-referenced. It will do this:
- Create a new directive (called *directivename*) for documenting an
object. It will automatically add index entries if *indextemplate*
is nonempty; if given, it must contain exactly one instance of
``%s``. See the example below for how the template will be
interpreted.
- Create a new role (called *rolename*) to cross-reference to these
object descriptions.
- If you provide *parse_node*, it must be a function that takes a
string and a docutils node, and it must populate the node with
children parsed from the string. It must then return the name of the
item to be used in cross-referencing and index entries. See the
:file:`conf.py` file in the source for this documentation for an
example.
- The *objname* (if not given, will default to *directivename*) names
the type of object. It is used when listing objects, e.g. in search
results.
For example, if you have this call in a custom Sphinx extension::
app.add_object_type('directive', 'dir', 'pair: %s; directive')
you can use this markup in your documents::
.. rst:directive:: function
Document a function.
<...>
See also the :rst:dir:`function` directive.
For the directive, an index entry will be generated as if you had prepended ::
.. index:: pair: function; directive
The reference node will be of class ``literal`` (so it will be rendered
in a proportional font, as appropriate for code) unless you give the
*ref_nodeclass* argument, which must be a docutils node class. Most
useful are ``docutils.nodes.emphasis`` or ``docutils.nodes.strong`` --
you can also use ``docutils.nodes.generated`` if you want no further
text decoration. If the text should be treated as literal (e.g. no
smart quote replacement), but not have typewriter styling, use
``sphinx.addnodes.literal_emphasis`` or
``sphinx.addnodes.literal_strong``.
For the role content, you have the same syntactical possibilities as
for standard Sphinx roles (see :ref:`xref-syntax`).
If *override* is True, the given object_type is forcedly installed even if
an object_type having the same name is already installed.
.. versionchanged:: 1.8
Add *override* keyword.
r� N)rQ �add_object_type) rg r� r� r� r� r� r� r� r� rj rj rk r�
s ?�zSphinx.add_object_type)r� r� r� r� r� r� rI c C s | j j||||||d� dS )a Register a new crossref object type.
This method is very similar to :meth:`add_object_type` except that the
directive it generates must be empty, and will produce no output.
That means that you can add semantic targets to your sources, and refer
to them using custom roles instead of generic ones (like
:rst:role:`ref`). Example call::
app.add_crossref_type('topic', 'topic', 'single: %s',
docutils.nodes.emphasis)
Example usage::
.. topic:: application API
The application API
-------------------
Some random text here.
See also :topic:`this section <application API>`.
(Of course, the element following the ``topic`` directive needn't be a
section.)
If *override* is True, the given crossref_type is forcedly installed even if
a crossref_type having the same name is already installed.
.. versionchanged:: 1.8
Add *override* keyword.
r� N)rQ �add_crossref_type)rg r� r� r� r� r� r� rj rj rk r� P s #
�zSphinx.add_crossref_type)� transformrI c C s | j �|� dS )a= Register a Docutils transform to be applied after parsing.
Add the standard docutils :class:`Transform` subclass *transform* to
the list of transforms that are applied after Sphinx parses a reST
document.
:param transform: A transform class
.. list-table:: priority range categories for Sphinx transforms
:widths: 20,80
* - Priority
- Main purpose in Sphinx
* - 0-99
- Fix invalid nodes by docutils. Translate a doctree.
* - 100-299
- Preparation
* - 300-399
- early
* - 400-699
- main
* - 700-799
- Post processing. Deadline to modify text and referencing.
* - 800-899
- Collect referencing and referenced nodes. Domain processing.
* - 900-999
- Finalize and clean up.
refs: `Transform Priority Range Categories`__
__ https://docutils.sourceforge.io/docs/ref/transforms.html#transform-priority-range-categories
N)rQ �
add_transform�rg r� rj rj rk r� w s !zSphinx.add_transformc C s | j �|� dS )a Register a Docutils transform to be applied before writing.
Add the standard docutils :class:`Transform` subclass *transform* to
the list of transforms that are applied before Sphinx writes a
document.
:param transform: A transform class
N)rQ �add_post_transformr� rj rj rk r� � s zSphinx.add_post_transform)r} r� �loading_methodr� rI c K sb |dkrd|d< n|dkr"d|d< | j j|fd|i|�� t| jd�r^| jj|fd|i|�� dS )a� Register a JavaScript file to include in the HTML output.
:param filename: The filename of the JavaScript file. It must be relative to the HTML
static path, a full URI with scheme, or ``None`` value. The ``None``
value is used to create inline ``<script>`` tag. See the description
of *kwargs* below.
:param priority: The priority to determine the order of ``<script>`` tag for
JavaScript files. See list of "prority range for JavaScript
files" below. If the priority of the JavaScript files it the same
as others, the JavaScript files will be loaded in order of
registration.
:param loading_method: The loading method of the JavaScript file. ``'async'`` or
``'defer'`` is allowed.
:param kwargs: Extra keyword arguments are included as attributes of the ``<script>``
tag. A special keyword argument ``body`` is given, its value will be
added between the ``<script>`` tag.
Example::
app.add_js_file('example.js')
# => <script src="_static/example.js"></script>
app.add_js_file('example.js', loading_method="async")
# => <script src="_static/example.js" async="async"></script>
app.add_js_file(None, body="var myVariable = 'foo';")
# => <script>var myVariable = 'foo';</script>
.. list-table:: priority range for JavaScript files
:widths: 20,80
* - Priority
- Main purpose in Sphinx
* - 200
- default priority for built-in JavaScript files
* - 500
- default priority for extensions
* - 800
- default priority for :confval:`html_js_files`
A JavaScript file can be added to the specific HTML page when an extension
calls this method on :event:`html-page-context` event.
.. versionadded:: 0.5
.. versionchanged:: 1.8
Renamed from ``app.add_javascript()``.
And it allows keyword arguments as attributes of script tag.
.. versionchanged:: 3.5
Take priority argument. Allow to add a JavaScript file to the specific page.
.. versionchanged:: 4.4
Take loading_method argument. Allow to change the loading method of the
JavaScript file.
�asyncZdeferr� � add_js_fileN)rQ r� �hasattrrN )rg r} r� r� r� rj rj rk r� � s 9
zSphinx.add_js_file)r} r� r� rI c K sL t �d|� | jj|fd|i|�� t| jd�rH| jj|fd|i|�� dS )a[ Register a stylesheet to include in the HTML output.
:param filename: The filename of the CSS file. It must be relative to the HTML
static path, or a full URI with scheme.
:param priority: The priority to determine the order of ``<link>`` tag for the
CSS files. See list of "prority range for CSS files" below.
If the priority of the CSS files it the same as others, the
CSS files will be loaded in order of registration.
:param kwargs: Extra keyword arguments are included as attributes of the ``<link>``
tag.
Example::
app.add_css_file('custom.css')
# => <link rel="stylesheet" href="_static/custom.css" type="text/css" />
app.add_css_file('print.css', media='print')
# => <link rel="stylesheet" href="_static/print.css"
# type="text/css" media="print" />
app.add_css_file('fancy.css', rel='alternate stylesheet', title='fancy')
# => <link rel="alternate stylesheet" href="_static/fancy.css"
# type="text/css" title="fancy" />
.. list-table:: priority range for CSS files
:widths: 20,80
* - Priority
- Main purpose in Sphinx
* - 200
- default priority for built-in CSS files
* - 500
- default priority for extensions
* - 800
- default priority for :confval:`html_css_files`
A CSS file can be added to the specific HTML page when an extension calls
this method on :event:`html-page-context` event.
.. versionadded:: 1.0
.. versionchanged:: 1.6
Optional ``alternate`` and/or ``title`` attributes can be supplied
with the arguments *alternate* (a Boolean) and *title* (a string).
The default is no title and *alternate* = ``False``. For
more information, refer to the `documentation
<https://mdn.io/Web/CSS/Alternative_style_sheets>`__.
.. versionchanged:: 1.8
Renamed from ``app.add_stylesheet()``.
And it allows keyword arguments as attributes of link tag.
.. versionchanged:: 3.5
Take priority argument. Allow to add a CSS file to the specific page.
z[app] adding stylesheet: %rr� � add_css_fileN)rW r� rQ Z
add_css_filesr� rN r� )rg r} r� r� rj rj rk r� � s 8 zSphinx.add_css_file)r} � alternate�titlerI c C sF t �d� i }|r d|d< nd|d< |r0||d< | j|fi |�� dS )zGAn alias of :meth:`add_css_file`.
.. deprecated:: 1.8
zNThe app.add_stylesheet() is deprecated. Please use app.add_css_file() instead.zalternate stylesheet�relZ
stylesheetr� N)rW rC r� )rg r} r� r� Z
attributesrj rj rk �add_stylesheet$ s
zSphinx.add_stylesheet)� packagename�options�after_hyperrefrI c C s | j �|||� dS )a� Register a package to include in the LaTeX source code.
Add *packagename* to the list of packages that LaTeX source code will
include. If you provide *options*, it will be taken to the `\usepackage`
declaration. If you set *after_hyperref* truthy, the package will be
loaded after ``hyperref`` package.
.. code-block:: python
app.add_latex_package('mypackage')
# => \usepackage{mypackage}
app.add_latex_package('mypackage', 'foo,bar')
# => \usepackage[foo,bar]{mypackage}
.. versionadded:: 1.3
.. versionadded:: 3.1
*after_hyperref* option.
N)rQ �add_latex_package)rg r� r� r� rj rj rk r� 8 s zSphinx.add_latex_package)�alias�lexerrI c C s t �d||f� |t|< dS )a2 Register a new lexer for source code.
Use *lexer* to highlight code blocks with the given language *alias*.
.. versionadded:: 0.6
.. versionchanged:: 2.1
Take a lexer class as an argument. An instance of lexers are
still supported until Sphinx-3.x.
z[app] adding lexer: %rN)rW r� r$ )rg r� r� rj rj rk � add_lexerO s
zSphinx.add_lexer)r� r� rI c C sB t �d|� ddlm} | j�|j|� | jd|j ||d� dS )a� Register a new documenter class for the autodoc extension.
Add *cls* as a new documenter class for the :mod:`sphinx.ext.autodoc`
extension. It must be a subclass of
:class:`sphinx.ext.autodoc.Documenter`. This allows auto-documenting
new types of objects. See the source of the autodoc module for
examples on how to subclass :class:`Documenter`.
If *override* is True, the given *cls* is forcedly installed even if
a documenter having the same name is already installed.
See :ref:`autodoc_ext_tutorial`.
.. versionadded:: 0.6
.. versionchanged:: 2.2
Add *override* keyword.
z [app] adding autodocumenter: %rr )�AutodocDirective�autor� N)rW r� Z sphinx.ext.autodoc.directiver� rQ Zadd_documenterZobjtyper� )rg r� r� r� rj rj rk �add_autodocumenter\ s zSphinx.add_autodocumenter)�typ�getterrI c C s" t �d||f� | j�||� dS )a� Register a new ``getattr``-like function for the autodoc extension.
Add *getter*, which must be a function with an interface compatible to
the :func:`getattr` builtin, as the autodoc attribute getter for
objects that are instances of *typ*. All cases where autodoc needs to
get an attribute of a type are then handled by this function instead of
:func:`getattr`.
.. versionadded:: 0.6
z#[app] adding autodoc attrgetter: %rN)rW r� rQ �add_autodoc_attrgetter)rg r� r� rj rj rk r� s s z Sphinx.add_autodoc_attrgetter)r� rI c C s* t �d|� ddlm}m} |||j< dS )a� Register a new language for the HTML search index.
Add *cls*, which must be a subclass of
:class:`sphinx.search.SearchLanguage`, as a support language for
building the HTML full-text search index. The class must have a *lang*
attribute that indicates the language it should be used for. See
:confval:`html_search_language`.
.. versionadded:: 1.1
z [app] adding search language: %rr )�SearchLanguage� languagesN)rW r� Z
sphinx.searchr� r� �lang)rg r� r� r� rj rj rk �add_search_language� s zSphinx.add_search_language)�suffix�filetyper� rI c C s | j j|||d� dS )a3 Register a suffix of source files.
Same as :confval:`source_suffix`. The users can override this
using the config setting.
If *override* is True, the given *suffix* is forcedly installed even if
the same suffix is already installed.
.. versionadded:: 1.8
r� N)rQ �add_source_suffix)rg r� r� r� rj rj rk r� � s zSphinx.add_source_suffix)�parserr� rI c C s | j j||d� dS )a� Register a parser class.
If *override* is True, the given *parser* is forcedly installed even if
a parser for the same suffix is already installed.
.. versionadded:: 1.4
.. versionchanged:: 1.8
*suffix* argument is deprecated. It only accepts *parser* argument.
Use :meth:`add_source_suffix` API to register suffix instead.
.. versionchanged:: 1.8
Add *override* keyword.
r� N)rQ �add_source_parser)rg r� r� rj rj rk r� � s
zSphinx.add_source_parser)� collectorrI c C s t �d|� |� �| � dS )zxRegister an environment collector class.
Refer to :ref:`collector-api`.
.. versionadded:: 1.6
z&[app] adding environment collector: %rN)rW r� Zenable)rg r� rj rj rk �add_env_collector� s zSphinx.add_env_collector)r� �
theme_pathrI c C s t �d||� | j�||� dS )z�Register a HTML Theme.
The *name* is a name of theme, and *theme_path* is a full path to the
theme (refs: :ref:`distribute-your-theme`).
.. versionadded:: 1.6
z [app] adding HTML theme: %r, %rN)rW r� rQ �add_html_theme)rg r� r� rj rj rk r� � s zSphinx.add_html_theme)r� �inline_renderers�block_renderersrI c C s | j �|||� dS )a� Register a math renderer for HTML.
The *name* is a name of math renderer. Both *inline_renderers* and
*block_renderers* are used as visitor functions for the HTML writer:
the former for inline math node (``nodes.math``), the latter for
block math node (``nodes.math_block``). Regarding visitor functions,
see :meth:`add_node` for details.
.. versionadded:: 1.8
N)rQ �add_html_math_renderer)rg r� r� r� rj rj rk r� � s z Sphinx.add_html_math_renderer)ru �
locale_dirrI c C s$ t �|g| jj|� t �||� dS )z�Register a message catalog.
:param catalog: The name of the catalog
:param locale_dir: The base path of the message catalog
For more details, see :func:`sphinx.locale.get_translation()`.
.. versionadded:: 1.8
N)r rp r\ ro Z init_console)rg ru r� rj rj rk �add_message_catalog� s
zSphinx.add_message_catalog)r� rI c C s� |dkr d}t d�}t d�}n*|dkr<d}t d�}t d�}n td | ��| j�� D ]d}t||d
�}|d
u r�t�||j� t�t d �|� d S |sRt�||j� t�t d �|� d S qRd
S )z�Check whether parallel processing is allowed or not.
:param typ: A type of processing; ``'read'`` or ``'write'``.
r] Zparallel_read_safez�the %s extension does not declare if it is safe for parallel reading, assuming it isn't - please ask the extension author to check and make it explicitz1the %s extension is not safe for parallel reading�writeZparallel_write_safez�the %s extension does not declare if it is safe for parallel writing, assuming it isn't - please ask the extension author to check and make it explicitz1the %s extension is not safe for parallel writingz!parallel type %s is not supportedNzdoing serial %sFT)r% �
ValueErrorrM �values�getattrrW rC r� )rg r� �attrnameZmessage_not_declaredZmessage_not_safe�ext�allowedrj rj rk �is_parallel_allowed� s(
zSphinx.is_parallel_allowedc C s |dvrt d| ��|| j_dS )z�Set the policy to include assets in HTML pages.
- always: include the assets in all the pages
- per_page: include the assets only in pages where they are used
.. versionadded: 4.1
)�alwaysZper_pagezpolicy %s is not supportedN)r� rQ Zhtml_assets_policy)rg Zpolicyrj rj rk �set_html_assets_policy s z Sphinx.set_html_assets_policyc C s t �dt� | jjS )Nz app.html_themes is deprecated.)�warnings�warnr rQ � html_themesr� rj rj rk r s �zSphinx.html_themes)FN)r� )F)rj )F)F)NF)F)F)F)F)F)F)F)r� Nr� F)r� N)r� )FN)NF)F)F)F)NN)Sr� �
__module__� __qualname__�__doc__�bool�__annotations__�int�sys�stdout�stderr�strr r r r
rl r^ re ra rd rf r� r` r� r r� r� r r r
r| rc r� r� r r� r� r Z NodeVisitorr� r r� r6 r� r r� r� r� r r� r� r5 r( r� r r� r r� r� r r� r� r� r� r� r� r r� r� r� r� r� r r� r r� r� r� r� r� r� �propertyr rj rj rj rk r9 } s�
�
� 5
�� �� �� ' � �
� - �
� 0 �
� �� � �� C �� '# �
� B=� ��
�
�
� # r9 c @ s\ e Zd ZdZddeee dd�dd�Zed�dd �Z ee
dd
�d d �Z ee
ed
�d
d�Z dS )�TemplateBridgez�
This class defines the interface for a "template bridge", that is, a class
that renders templates given a template name and a context.
Nr8 )rN �theme�dirsrI c C s t d��dS )ab Called by the builder to initialize the template system.
*builder* is the builder object; you'll probably want to look at the
value of ``builder.config.templates_path``.
*theme* is a :class:`sphinx.theming.Theme` object or None; in the latter
case, *dirs* can be list of fixed directories to look for templates.
�!must be implemented in subclassesN��NotImplementedError)rg rN r
r rj rj rk rp s zTemplateBridge.initrm c C s dS )z�Called by the builder to determine if output files are outdated
because of template changes. Return the mtime of the newest template
file that was changed. The default implementation returns ``0``.
r rj r� rj rj rk �newest_template_mtime( s z$TemplateBridge.newest_template_mtime)�template�contextrI c C s t d��dS )zCalled by the builder to render a template given as a filename with
a specified context (a Python dictionary).
r Nr �rg r r rj rj rk �render/ s zTemplateBridge.renderc C s t d��dS )z}Called by the builder to render a template given as a string with a
specified context (a Python dictionary).
r Nr r rj rj rk �
render_string5 s z TemplateBridge.render_string)NN)
r� r r r r) r
r
rp �floatr r r r rj rj rj rk r s
r )cr rx rz r r� � collectionsr �ior r �typingr r r r r r
r r r
r r* r Zdocutils.nodesr r Zdocutils.parsersr Zdocutils.parsers.rstr r Zdocutils.transformsr Zpygments.lexerr rY r r Z
sphinx.configr Zsphinx.deprecationr Zsphinx.domainsr r Zsphinx.environmentr Z sphinx.environment.collectorsr Z
sphinx.errorsr r r! Z
sphinx.eventsr" Zsphinx.extensionr# Zsphinx.highlightingr$ Z
sphinx.localer% Zsphinx.projectr& Zsphinx.registryr' Z sphinx.rolesr( Zsphinx.themingr) Z sphinx.utilr+ r, Zsphinx.util.build_phaser- Zsphinx.util.consoler. Zsphinx.util.i18nr/ Zsphinx.util.loggingr0 Zsphinx.util.osutilr1 r2 r3 Zsphinx.util.tagsr4 Zsphinx.util.typingr5 r6 r7 Zsphinx.buildersr8 r_ rw Z getLoggerr� rW r9 r rj rj rj rk �<module> sn 0 <
#