Sphinx documentation contents¶
Installing Sphinx¶
Overview¶
Sphinx is written in Python and supports both Python 2.7 and Python 3.3+. We recommend the latter.
Linux¶
Debian/Ubuntu¶
Install either python3-sphinx
(Python 3) or python-sphinx
(Python 2)
using apt-get:
$ apt-get install python3-sphinx
If it not already present, this will install Python for you.
RHEL, CentOS¶
Install python-sphinx
using yum:
$ yum install python-sphinx
If it not already present, this will install Python for you.
Other distributions¶
Most Linux distributions have Sphinx in their package repositories. Usually
the package is called python3-sphinx
, python-sphinx
or sphinx
. Be
aware that there are at least two other packages with sphinx
in their name:
a speech recognition toolkit (CMU Sphinx) and a full-text search database
(Sphinx search).
macOS¶
Sphinx can be installed using Homebrew, MacPorts, or as part of a Python distribution such as Anaconda.
MacPorts¶
Install either python36-sphinx
(Python 3) or python27-sphinx
(Python 2)
using port:
$ sudo port install py36-sphinx
To set up the executable paths, use the port select
command:
$ sudo port select --set python python36
$ sudo port select --set sphinx py36-sphinx
For more information, refer to the package overview.
Anaconda¶
$ conda install sphinx
Windows¶
Todo
Could we start packaging this?
Most Windows users do not have Python installed by default, so we begin with the installation of Python itself. If you are unsure, open the Command Prompt (⊞Win-r and type cmd). Once the command prompt is open, type python --version and press Enter. If Python is available, you will see the version of Python printed to the screen. If you do not have Python installed, refer to the Hitchhikers Guide to Python’s Python on Windows installation guides. You can install either Python 3 or Python 2.7. Python 3 is recommended.
Once Python is installed, you can install Sphinx using pip. Refer to the pip installation instructions below for more information.
Installation from PyPI¶
Sphinx packages are published on the Python Package Index. The preferred tool for installing packages from PyPI is pip. This tool is provided with all modern versions of Python.
On Linux or MacOS, you should open your terminal and run the following command.
$ pip install -U sphinx
On Windows, you should open Command Prompt (⊞Win-r and type cmd) and run the same command.
C:\> pip install -U sphinx
After installation, type sphinx-build --version on the command prompt. If everything worked fine, you will see the version number for the Sphinx package you just installed.
Installation from PyPI also allows you to install the latest development
release. You will not generally need (or want) to do this, but it can be
useful if you see a possible bug in the latest stable release. To do this, use
the --pre
flag.
$ pip install -U --pre sphinx
Installation from source¶
You can install Sphinx directly from a clone of the Git repository. This can be done either by cloning the repo and installing from the local clone, on simply installing directly via git.
$ git clone https://github.com/sphinx-doc/sphinx
$ cd sphinx
$ pip install .
$ pip install git+https://github.com/sphinx-doc/sphinx
You can also download a snapshot of the Git repo in either tar.gz or zip format. Once downloaded and extracted, these can be installed with pip as above.
Getting Started¶
Once Sphinx is installed, you can proceed with setting up your first Sphinx project. To ease the process of getting started, Sphinx provides a tool, sphinx-quickstart, which will generate a documentation source directory and populate it with some defaults. We’re going to use the sphinx-quickstart tool here, though it’s use by no means necessary.
Setting up the documentation sources¶
The root directory of a Sphinx collection of reStructuredText document
sources is called the source directory. This directory also contains
the Sphinx configuration file conf.py
, where you can configure all
aspects of how Sphinx reads your sources and builds your documentation. [1]
Sphinx comes with a script called sphinx-quickstart that sets up a
source directory and creates a default conf.py
with the most useful
configuration values from a few questions it asks you. To use this, run:
$ sphinx-quickstart
Answer each question asked. Be sure to say yes to the autodoc
extension, as
we will use this later.
There is also an automatic “API documentation” generator called sphinx-apidoc; see sphinx-apidoc for details.
Defining document structure¶
Let’s assume you’ve run sphinx-quickstart. It created a source
directory with conf.py
and a master document, index.rst
(if you
accepted the defaults). The main function of the master document is to
serve as a welcome page, and to contain the root of the “table of contents
tree” (or toctree). This is one of the main things that Sphinx adds to
reStructuredText, a way to connect multiple files to a single hierarchy of
documents.
The toctree
directive initially is empty, and looks like so:
.. toctree::
:maxdepth: 2
You add documents listing them in the content of the directive:
.. toctree::
:maxdepth: 2
usage/installation
usage/quickstart
...
This is exactly how the toctree
for this documentation looks. The
documents to include are given as document names, which in short
means that you leave off the file name extension and use forward slashes
(/
) as directory separators.
Read more about the toctree directive.
You can now create the files you listed in the toctree
and add content, and
their section titles will be inserted (up to the maxdepth
level) at the
place where the toctree
directive is placed. Also, Sphinx now knows about
the order and hierarchy of your documents. (They may contain toctree
directives themselves, which means you can create deeply nested hierarchies if
necessary.)
Adding content¶
In Sphinx source files, you can use most features of standard
reStructuredText. There are also several features added by Sphinx.
For example, you can add cross-file references in a portable way (which works
for all output types) using the ref
role.
For an example, if you are viewing the HTML version you can look at the source for this document – use the “Show Source” link in the sidebar.
Todo
Update the below link when we add new guides on these.
See reStructuredText for a more in-depth
introduction to reStructuredText, including markup added by Sphinx.
Running the build¶
Now that you have added some files and content, let’s make a first build of the docs. A build is started with the sphinx-build program:
$ sphinx-build -b html sourcedir builddir
where sourcedir is the source directory, and builddir is the
directory in which you want to place the built documentation.
The -b
option selects a builder; in this example
Sphinx will build HTML files.
Refer to the sphinx-build man page for all
options that sphinx-build supports.
However, sphinx-quickstart script creates a Makefile
and a
make.bat
which make life even easier for you. These can be executed by
running make with the name of the builder. For example.
$ make html
This will build HTML docs in the build directory you chose. Execute make without an argument to see which targets are available.
How do I generate PDF documents?
make latexpdf
runs the LaTeX builder
and readily invokes the pdfTeX
toolchain for you.
Todo
Move this whole section into a guide on rST or directives
Documenting objects¶
One of Sphinx’s main objectives is easy documentation of objects (in a very general sense) in any domain. A domain is a collection of object types that belong together, complete with markup to create and reference descriptions of these objects.
The most prominent domain is the Python domain. For example, to document
Python’s built-in function enumerate()
, you would add this to one of your
source files.
.. py:function:: enumerate(sequence[, start=0])
Return an iterator that yields tuples of an index and an item of the
*sequence*. (And so on.)
This is rendered like this:
-
enumerate
(sequence[, start=0])¶ Return an iterator that yields tuples of an index and an item of the sequence. (And so on.)
The argument of the directive is the signature of the object you describe, the content is the documentation for it. Multiple signatures can be given, each in its own line.
The Python domain also happens to be the default domain, so you don’t need to prefix the markup with the domain name.
.. function:: enumerate(sequence[, start=0])
...
does the same job if you keep the default setting for the default domain.
There are several more directives for documenting other types of Python
objects, for example py:class
or py:method
. There is
also a cross-referencing role for each of these object types. This
markup will create a link to the documentation of enumerate()
.
The :py:func:`enumerate` function can be used for ...
And here is the proof: A link to enumerate()
.
Again, the py:
can be left out if the Python domain is the default one. It
doesn’t matter which file contains the actual documentation for
enumerate()
; Sphinx will find it and create a link to it.
Each domain will have special rules for how the signatures can look like, and make the formatted output look pretty, or add specific features like links to parameter types, e.g. in the C/C++ domains.
See Domains for all the available domains
and their directives/roles.
Basic configuration¶
Earlier we mentioned that the conf.py
file controls how Sphinx
processes your documents. In that file, which is executed as a Python source
file, you assign configuration values. For advanced users: since it is
executed by Sphinx, you can do non-trivial tasks in it, like extending
sys.path
or importing a module to find out the version you are
documenting.
The config values that you probably want to change are already put into the
conf.py
by sphinx-quickstart and initially commented out
(with standard Python syntax: a #
comments the rest of the line). To
change the default value, remove the hash sign and modify the value. To
customize a config value that is not automatically added by
sphinx-quickstart, just add an additional assignment.
Keep in mind that the file uses Python syntax for strings, numbers, lists and
so on. The file is saved in UTF-8 by default, as indicated by the encoding
declaration in the first line. If you use non-ASCII characters in any string
value, you need to use Python Unicode strings (like project = u'Exposé'
).
See Configuration for documentation of all available
config values.
Todo
Move this entire doc to a different section
Autodoc¶
When documenting Python code, it is common to put a lot of documentation in the source files, in documentation strings. Sphinx supports the inclusion of docstrings from your modules with an extension (an extension is a Python module that provides additional features for Sphinx projects) called autodoc.
In order to use autodoc, you need to activate it in conf.py
by
putting the string 'sphinx.ext.autodoc'
into the list assigned to the
extensions
config value. Then, you have a few additional directives
at your disposal.
For example, to document the function io.open()
, reading its signature and
docstring from the source file, you’d write this:
.. autofunction:: io.open
You can also document whole classes or even modules automatically, using member options for the auto directives, like
.. automodule:: io
:members:
autodoc needs to import your modules in order to extract the docstrings.
Therefore, you must add the appropriate path to sys.path
in your
conf.py
.
Warning
autodoc
imports the modules to be documented. If any
modules have side effects on import, these will be executed by autodoc
when sphinx-build
is run.
If you document scripts (as opposed to library modules), make sure their
main routine is protected by a if __name__ == '__main__'
condition.
See
sphinx.ext.autodoc
for the complete description of the
features of autodoc.
Todo
Move this doc to another section
Intersphinx¶
Many Sphinx documents including the Python documentation are published on
the internet. When you want to make links to such documents from your
documentation, you can do it with sphinx.ext.intersphinx
.
In order to use intersphinx, you need to activate it in conf.py
by
putting the string 'sphinx.ext.intersphinx'
into the extensions
list and set up the intersphinx_mapping
config value.
For example, to link to io.open()
in the Python library manual, you need to
setup your intersphinx_mapping
like:
intersphinx_mapping = {'python': ('https://docs.python.org/3', None)}
And now, you can write a cross-reference like :py:func:`io.open`
. Any
cross-reference that has no matching target in the current documentation set,
will be looked up in the documentation sets configured in
intersphinx_mapping
(this needs access to the URL in order to
download the list of valid targets). Intersphinx also works for some other
domain’s roles including :ref:
, however it doesn’t work for
:doc:
as that is non-domain role.
See
sphinx.ext.intersphinx
for the complete description of the
features of intersphinx.
More topics to be covered¶
- Other extensions:
- Static files
- Selecting a theme
- Setuptools integration
- Templating
- Using extensions
- Writing extensions
Footnotes
[1] | This is the usual layout. However, conf.py can also live in
another directory, the configuration directory. Refer to the
sphinx-build man page for more information. |
reStructuredText¶
reStructuredText (reST) is the default plaintext markup language used by both Docutils and Sphinx. Docutils provides the basic reStructuredText syntax, while Sphinx extends this to support additional functionality.
The below guides go through the most important aspects of reST. For the authoritative reStructuredText reference, refer to the docutils documentation.
reStructuredText Primer¶
reStructuredText is the default plaintext markup language used by Sphinx. This section is a brief introduction to reStructuredText (reST) concepts and syntax, intended to provide authors with enough information to author documents productively. Since reST was designed to be a simple, unobtrusive markup language, this will not take too long.
See also
The authoritative reStructuredText User Documentation. The “ref” links in this document link to the description of the individual constructs in the reST reference.
Paragraphs¶
The paragraph (ref) is the most basic block in a reST document. Paragraphs are simply chunks of text separated by one or more blank lines. As in Python, indentation is significant in reST, so all lines of the same paragraph must be left-aligned to the same level of indentation.
Inline markup¶
The standard reST inline markup is quite simple: use
- one asterisk:
*text*
for emphasis (italics), - two asterisks:
**text**
for strong emphasis (boldface), and - backquotes:
``text``
for code samples.
If asterisks or backquotes appear in running text and could be confused with inline markup delimiters, they have to be escaped with a backslash.
Be aware of some restrictions of this markup:
- it may not be nested,
- content may not start or end with whitespace:
* text*
is wrong, - it must be separated from surrounding text by non-word characters. Use a
backslash escaped space to work around that:
thisis\ *one*\ word
.
These restrictions may be lifted in future versions of the docutils.
It is also possible to replace or expand upon some of this inline markup with roles. Refer to Roles for more information.
Lists and Quote-like blocks¶
List markup (ref) is natural: just place an asterisk at
the start of a paragraph and indent properly. The same goes for numbered
lists; they can also be autonumbered using a #
sign:
* This is a bulleted list.
* It has two items, the second
item uses two lines.
1. This is a numbered list.
2. It has two items too.
#. This is a numbered list.
#. It has two items too.
Nested lists are possible, but be aware that they must be separated from the parent list items by blank lines:
* this is
* a list
* with a nested list
* and some subitems
* and here the parent list continues
Definition lists (ref) are created as follows:
term (up to a line of text)
Definition of the term, which must be indented
and can even consist of multiple paragraphs
next term
Description.
Note that the term cannot have more than one line of text.
Quoted paragraphs (ref) are created by just indenting them more than the surrounding paragraphs.
Line blocks (ref) are a way of preserving line breaks:
| These lines are
| broken exactly like in
| the source file.
There are also several more special blocks available:
- field lists (ref, with caveats noted in Field Lists)
- option lists (ref)
- quoted literal blocks (ref)
- doctest blocks (ref)
Literal blocks¶
Literal code blocks (ref) are introduced by ending a
paragraph with the special marker ::
. The literal block must be indented
(and, like all paragraphs, separated from the surrounding ones by blank
lines):
This is a normal text paragraph. The next paragraph is a code sample::
It is not processed in any way, except
that the indentation is removed.
It can span multiple lines.
This is a normal text paragraph again.
The handling of the ::
marker is smart:
- If it occurs as a paragraph of its own, that paragraph is completely left out of the document.
- If it is preceded by whitespace, the marker is removed.
- If it is preceded by non-whitespace, the marker is replaced by a single colon.
That way, the second sentence in the above example’s first paragraph would be rendered as “The next paragraph is a code sample:”.
Code highlighting can be enabled for these literal blocks on a document-wide
basis using the highlight
directive and on a project-wide basis
using the highlight_language
configuration option. The
code-block
directive can be used to set highlighting on a
block-by-block basis. These directives are discussed later.
Doctest blocks¶
Doctest blocks (ref) are interactive Python sessions cut-and-pasted into docstrings. They do not require the literal blocks syntax. The doctest block must end with a blank line and should not end with with an unused prompt:
>>> 1 + 1
2
Tables¶
For grid tables (ref), you have to “paint” the cell grid yourself. They look like this:
+------------------------+------------+----------+----------+
| Header row, column 1 | Header 2 | Header 3 | Header 4 |
| (header rows optional) | | | |
+========================+============+==========+==========+
| body row 1, column 1 | column 2 | column 3 | column 4 |
+------------------------+------------+----------+----------+
| body row 2 | ... | ... | |
+------------------------+------------+----------+----------+
Simple tables (ref) are easier to write, but limited: they must contain more than one row, and the first column cells cannot contain multiple lines. They look like this:
===== ===== =======
A B A and B
===== ===== =======
False False False
True False False
False True False
True True True
===== ===== =======
Two more syntaxes are supported: CSV tables and List tables. They use an explicit markup block. Refer to Tables for more information.
Hyperlinks¶
External links¶
Use `Link text <https://domain.invalid/>`_
for inline web links. If the
link text should be the web address, you don’t need special markup at all, the
parser finds links and mail addresses in ordinary text.
Important
There must be a space between the link text and the opening < for the URL.
You can also separate the link and the target definition (ref), like this:
This is a paragraph that contains `a link`_.
.. _a link: https://domain.invalid/
Internal links¶
Internal linking is done via a special reST role provided by Sphinx, see the section on specific markup, Cross-referencing arbitrary locations.
Sections¶
Section headers (ref) are created by underlining (and optionally overlining) the section title with a punctuation character, at least as long as the text:
=================
This is a heading
=================
Normally, there are no heading levels assigned to certain characters as the structure is determined from the succession of headings. However, this convention is used in Python’s Style Guide for documenting which you may follow:
#
with overline, for parts*
with overline, for chapters=
, for sections-
, for subsections^
, for subsubsections"
, for paragraphs
Of course, you are free to use your own marker characters (see the reST documentation), and use a deeper nesting level, but keep in mind that most target formats (HTML, LaTeX) have a limited supported nesting depth.
Field Lists¶
Field lists (ref) are sequences of fields marked up like this:
:fieldname: Field content
They are commonly used in Python documentation:
def my_function(my_arg, my_other_arg):
"""A function just for me.
:param my_arg: The first of my arguments.
:param my_other_arg: The second of my arguments.
:returns: A message (just for me, of course).
"""
Sphinx extends standard docutils behavior and intercepts field lists specified at the beginning of documents. Refer to Field Lists for more information.
Roles¶
A role or “custom interpreted text role” (ref) is an inline
piece of explicit markup. It signifies that that the enclosed text should be
interpreted in a specific way. Sphinx uses this to provide semantic markup and
cross-referencing of identifiers, as described in the appropriate section. The
general syntax is :rolename:`content`
.
Docutils supports the following roles:
- emphasis – equivalent of
*emphasis*
- strong – equivalent of
**strong**
- literal – equivalent of
``literal``
- subscript – subscript text
- superscript – superscript text
- title-reference – for titles of books, periodicals, and other materials
Refer to Roles for roles added by Sphinx.
Explicit Markup¶
“Explicit markup” (ref) is used in reST for most constructs that need special handling, such as footnotes, specially-highlighted paragraphs, comments, and generic directives.
An explicit markup block begins with a line starting with ..
followed by
whitespace and is terminated by the next paragraph at the same level of
indentation. (There needs to be a blank line between explicit markup and
normal paragraphs. This may all sound a bit complicated, but it is intuitive
enough when you write it.)
Directives¶
A directive (ref) is a generic block of explicit markup. Along with roles, it is one of the extension mechanisms of reST, and Sphinx makes heavy use of it.
Docutils supports the following directives:
Admonitions: attention, caution, danger, error, hint, important, note, tip, warning and the generic admonition. (Most themes style only “note” and “warning” specially.)
Images:
Additional body elements:
- contents (a local, i.e. for the current file only, table of contents)
- container (a container with a custom class, useful to generate an
outer
<div>
in HTML) - rubric (a heading without relation to the document sectioning)
- topic, sidebar (special highlighted body elements)
- parsed-literal (literal block that supports inline markup)
- epigraph (a block quote with optional attribution line)
- highlights, pull-quote (block quotes with their own class attribute)
- compound (a compound paragraph)
Special tables:
- table (a table with title)
- csv-table (a table generated from comma-separated values)
- list-table (a table generated from a list of lists)
Special directives:
HTML specifics:
Influencing markup:
- default-role (set a new default role)
- role (create a new role)
Since these are only per-file, better use Sphinx’s facilities for setting the
default_role
.
Directives added by Sphinx are described in Directives.
Basically, a directive consists of a name, arguments, options and content. (Keep this terminology in mind, it is used in the next chapter describing custom directives.) Looking at this example,
.. function:: foo(x)
foo(y, z)
:module: some.module.name
Return a line of text input from the user.
function
is the directive name. It is given two arguments here, the
remainder of the first line and the second line, as well as one option
module
(as you can see, options are given in the lines immediately
following the arguments and indicated by the colons). Options must be indented
to the same level as the directive content.
The directive content follows after a blank line and is indented relative to the directive start.
Images¶
reST supports an image directive (ref), used like so:
.. image:: gnu.png
(options)
When used within Sphinx, the file name given (here gnu.png
) must either be
relative to the source file, or absolute which means that they are relative to
the top source directory. For example, the file sketch/spam.rst
could
refer to the image images/spam.png
as ../images/spam.png
or
/images/spam.png
.
Sphinx will automatically copy image files over to a subdirectory of the output
directory on building (e.g. the _static
directory for HTML output.)
Interpretation of image size options (width
and height
) is as follows:
if the size has no unit or the unit is pixels, the given size will only be
respected for output channels that support pixels. Other units (like pt
for
points) will be used for HTML and LaTeX output (the latter replaces pt
by
bp
as this is the TeX unit such that 72bp=1in
).
Sphinx extends the standard docutils behavior by allowing an asterisk for the extension:
.. image:: gnu.*
Sphinx then searches for all images matching the provided pattern and
determines their type. Each builder then chooses the best image out of these
candidates. For instance, if the file name gnu.*
was given and two files
gnu.pdf
and gnu.png
existed in the source tree, the LaTeX
builder would choose the former, while the HTML builder would prefer the
latter. Supported image types and choosing priority are defined at
Builders.
Note that image file names should not contain spaces.
Changed in version 0.4: Added the support for file names ending in an asterisk.
Changed in version 0.6: Image paths can now be absolute.
Changed in version 1.5: latex target supports pixels (default is 96px=1in
).
Footnotes¶
For footnotes (ref), use [#name]_
to mark the footnote
location, and add the footnote body at the bottom of the document after a
“Footnotes” rubric heading, like so:
Lorem ipsum [#f1]_ dolor sit amet ... [#f2]_
.. rubric:: Footnotes
.. [#f1] Text of the first footnote.
.. [#f2] Text of the second footnote.
You can also explicitly number the footnotes ([1]_
) or use auto-numbered
footnotes without names ([#]_
).
Citations¶
Standard reST citations (ref) are supported, with the additional feature that they are “global”, i.e. all citations can be referenced from all files. Use them like so:
Lorem ipsum [Ref]_ dolor sit amet.
.. [Ref] Book or article reference, URL or whatever.
Citation usage is similar to footnote usage, but with a label that is not
numeric or begins with #
.
Substitutions¶
reST supports “substitutions” (ref), which
are pieces of text and/or markup referred to in the text by |name|
. They
are defined like footnotes with explicit markup blocks, like this:
.. |name| replace:: replacement *text*
or this:
.. |caution| image:: warning.png
:alt: Warning!
See the reST reference for substitutions for details.
If you want to use some substitutions for all documents, put them into
rst_prolog
or rst_epilog
or put them into a separate file
and include it into all documents you want to use them in, using the
include
directive. (Be sure to give the include file a file name
extension differing from that of other source files, to avoid Sphinx finding it
as a standalone document.)
Sphinx defines some default substitutions, see Substitutions.
Comments¶
Every explicit markup block which isn’t a valid markup construct (like the footnotes above) is regarded as a comment (ref). For example:
.. This is a comment.
You can indent text after a comment start to form multiline comments:
..
This whole indented block
is a comment.
Still in the comment.
Source encoding¶
Since the easiest way to include special characters like em dashes or copyright
signs in reST is to directly write them as Unicode characters, one has to
specify an encoding. Sphinx assumes source files to be encoded in UTF-8 by
default; you can change this with the source_encoding
config value.
Gotchas¶
There are some problems one commonly runs into while authoring reST documents:
- Separation of inline markup: As said above, inline markup spans must be separated from the surrounding text by non-word characters, you have to use a backslash-escaped space to get around that. See the reference for the details.
- No nested inline markup: Something like
*see :func:`foo`*
is not possible.
Footnotes
[1] | When the default domain contains a class directive, this
directive will be shadowed. Therefore, Sphinx re-exports it as
rst-class . |
Roles¶
Sphinx uses interpreted text roles to insert semantic markup into documents.
They are written as :rolename:`content`
.
Note
The default role (`content`
) has no special meaning by default. You are
free to use it for anything you like, e.g. variable names; use the
default_role
config value to set it to a known role – the
any
role to find anything or the py:obj
role to find
Python objects are very useful for this.
See Domains for roles added by domains.
Cross-referencing syntax¶
Cross-references are generated by many semantic interpreted text roles.
Basically, you only need to write :role:`target`
, and a link will be
created to the item named target of the type indicated by role. The link’s
text will be the same as target.
There are some additional facilities, however, that make cross-referencing roles more versatile:
You may supply an explicit title and reference target, like in reST direct hyperlinks:
:role:`title <target>`
will refer to target, but the link text will be title.If you prefix the content with
!
, no reference/hyperlink will be created.If you prefix the content with
~
, the link text will only be the last component of the target. For example,:py:meth:`~Queue.Queue.get`
will refer toQueue.Queue.get
but only displayget
as the link text. This does not work with all cross-reference roles, but is domain specific.In HTML output, the link’s
title
attribute (that is e.g. shown as a tool-tip on mouse-hover) will always be the full target name.
Cross-referencing anything¶
-
:any:
¶ New in version 1.3.
This convenience role tries to do its best to find a valid target for its reference text.
First, it tries standard cross-reference targets that would be referenced by
doc
,ref
oroption
.Custom objects added to the standard domain by extensions (see
Sphinx.add_object_type()
) are also searched.Then, it looks for objects (targets) in all loaded domains. It is up to the domains how specific a match must be. For example, in the Python domain a reference of
:any:`Builder`
would match thesphinx.builders.Builder
class.
If none or multiple targets are found, a warning will be emitted. In the case of multiple targets, you can change “any” to a specific role.
This role is a good candidate for setting
default_role
. If you do, you can write cross-references without a lot of markup overhead. For example, in this Python function documentation.. function:: install() This function installs a `handler` for every signal known by the `signal` module. See the section `about-signals` for more information.
there could be references to a glossary term (usually
:term:`handler`
), a Python module (usually:py:mod:`signal`
or:mod:`signal`
) and a section (usually:ref:`about-signals`
).The
any
role also works together with theintersphinx
extension: when no local cross-reference is found, all object types of intersphinx inventories are also searched.
Cross-referencing objects¶
These roles are described with their respective domains:
Cross-referencing arbitrary locations¶
-
:ref:
¶ To support cross-referencing to arbitrary locations in any document, the standard reST labels are used. For this to work label names must be unique throughout the entire documentation. There are two ways in which you can refer to labels:
If you place a label directly before a section title, you can reference to it with
:ref:`label-name`
. For example:.. _my-reference-label: Section to cross-reference -------------------------- This is the text of the section. It refers to the section itself, see :ref:`my-reference-label`.
The
:ref:
role would then generate a link to the section, with the link title being “Section to cross-reference”. This works just as well when section and reference are in different source files.Automatic labels also work with figures. For example:
.. _my-figure: .. figure:: whatever Figure caption
In this case, a reference
:ref:`my-figure`
would insert a reference to the figure with link text “Figure caption”.The same works for tables that are given an explicit caption using the table directive.
Labels that aren’t placed before a section title can still be referenced, but you must give the link an explicit title, using this syntax:
:ref:`Link title <label-name>`
.
Note
Reference labels must start with an underscore. When referencing a label, the underscore must be omitted (see examples above).
Using
ref
is advised over standard reStructuredText links to sections (like`Section title`_
) because it works across files, when section headings are changed, will raise warnings if incorrect, and works for all builders that support cross-references.
Cross-referencing documents¶
New in version 0.6.
There is also a way to directly link to documents:
-
:doc:
¶ Link to the specified document; the document name can be specified in absolute or relative fashion. For example, if the reference
:doc:`parrot`
occurs in the documentsketches/index
, then the link refers tosketches/parrot
. If the reference is:doc:`/people`
or:doc:`../people`
, the link refers topeople
.If no explicit link text is given (like usual:
:doc:`Monty Python members </people>`
), the link caption will be the title of the given document.
Referencing downloadable files¶
New in version 0.6.
-
:download:
¶ This role lets you link to files within your source tree that are not reST documents that can be viewed, but files that can be downloaded.
When you use this role, the referenced file is automatically marked for inclusion in the output when building (obviously, for HTML output only). All downloadable files are put into the
_downloads
subdirectory of the output directory; duplicate filenames are handled.An example:
See :download:`this example script <../example.py>`.
The given filename is usually relative to the directory the current source file is contained in, but if it absolute (starting with
/
), it is taken as relative to the top source directory.The
example.py
file will be copied to the output directory, and a suitable link generated to it.Not to show unavailable download links, you should wrap whole paragraphs that have this role:
.. only:: builder_html See :download:`this example script <../example.py>`.
Cross-referencing figures by figure number¶
New in version 1.3.
Changed in version 1.5: numref role can also refer sections. And numref allows {name} for the link text.
-
:numref:
¶ Link to the specified figures, tables, code-blocks and sections; the standard reST labels are used. When you use this role, it will insert a reference to the figure with link text by its figure number like “Fig. 1.1”.
If an explicit link text is given (as usual:
:numref:`Image of Sphinx (Fig. %s) <my-figure>`
), the link caption will serve as title of the reference. As placeholders, %s and {number} get replaced by the figure number and {name} by the figure caption. If no explicit link text is given, thenumfig_format
setting is used as fall-back default.If
numfig
isFalse
, figures are not numbered, so this role inserts not a reference but the label or the link text.
Cross-referencing other items of interest¶
The following roles do possibly create a cross-reference, but do not refer to objects:
-
:envvar:
¶ An environment variable. Index entries are generated. Also generates a link to the matching
envvar
directive, if it exists.
-
:token:
¶ The name of a grammar token (used to create links between
productionlist
directives).
-
:keyword:
¶ The name of a keyword in Python. This creates a link to a reference label with that name, if it exists.
-
:option:
¶ A command-line option to an executable program. This generates a link to a
option
directive, if it exists.
The following role creates a cross-reference to a term in a glossary:
-
:term:
¶ Reference to a term in a glossary. A glossary is created using the
glossary
directive containing a definition list with terms and definitions. It does not have to be in the same file as theterm
markup, for example the Python docs have one global glossary in theglossary.rst
file.If you use a term that’s not explained in a glossary, you’ll get a warning during build.
Math¶
-
:math:
¶ Role for inline math. Use like this:
Since Pythagoras, we know that :math:`a^2 + b^2 = c^2`.
-
:eq:
¶ Same as
math:numref
.
Other semantic markup¶
The following roles don’t do anything special except formatting the text in a different style:
-
:abbr:
¶ An abbreviation. If the role content contains a parenthesized explanation, it will be treated specially: it will be shown in a tool-tip in HTML, and output only once in LaTeX.
Example:
:abbr:`LIFO (last-in, first-out)`
.New in version 0.6.
-
:command:
¶ The name of an OS-level command, such as
rm
.
-
:dfn:
¶ Mark the defining instance of a term in the text. (No index entries are generated.)
-
:file:
¶ The name of a file or directory. Within the contents, you can use curly braces to indicate a “variable” part, for example:
... is installed in :file:`/usr/lib/python2.{x}/site-packages` ...
In the built documentation, the
x
will be displayed differently to indicate that it is to be replaced by the Python minor version.
-
:guilabel:
¶ Labels presented as part of an interactive user interface should be marked using
guilabel
. This includes labels from text-based interfaces such as those created usingcurses
or other text-based libraries. Any label used in the interface should be marked with this role, including button labels, window titles, field names, menu and menu selection names, and even values in selection lists.Changed in version 1.0: An accelerator key for the GUI label can be included using an ampersand; this will be stripped and displayed underlined in the output (example:
:guilabel:`&Cancel`
). To include a literal ampersand, double it.
-
:kbd:
¶ Mark a sequence of keystrokes. What form the key sequence takes may depend on platform- or application-specific conventions. When there are no relevant conventions, the names of modifier keys should be spelled out, to improve accessibility for new users and non-native speakers. For example, an xemacs key sequence may be marked like
:kbd:`C-x C-f`
, but without reference to a specific application or platform, the same sequence should be marked as:kbd:`Control-x Control-f`
.
-
:mailheader:
¶ The name of an RFC 822-style mail header. This markup does not imply that the header is being used in an email message, but can be used to refer to any header of the same “style.” This is also used for headers defined by the various MIME specifications. The header name should be entered in the same way it would normally be found in practice, with the camel-casing conventions being preferred where there is more than one common usage. For example:
:mailheader:`Content-Type`
.
-
:makevar:
¶ The name of a make variable.
-
:manpage:
¶ A reference to a Unix manual page including the section, e.g.
:manpage:`ls(1)`
. Creates a hyperlink to an external site rendering the manpage ifmanpages_url
is defined.
Menu selections should be marked using the
menuselection
role. This is used to mark a complete sequence of menu selections, including selecting submenus and choosing a specific operation, or any subsequence of such a sequence. The names of individual selections should be separated by-->
.For example, to mark the selection “Start > Programs”, use this markup:
:menuselection:`Start --> Programs`
When including a selection that includes some trailing indicator, such as the ellipsis some operating systems use to indicate that the command opens a dialog, the indicator should be omitted from the selection name.
menuselection
also supports ampersand accelerators just likeguilabel
.
-
:mimetype:
¶ The name of a MIME type, or a component of a MIME type (the major or minor portion, taken alone).
-
:newsgroup:
¶ The name of a Usenet newsgroup.
Todo
Is this not part of the standard domain?
-
:program:
¶ The name of an executable program. This may differ from the file name for the executable for some platforms. In particular, the
.exe
(or other) extension should be omitted for Windows programs.
-
:regexp:
¶ A regular expression. Quotes should not be included.
-
:samp:
¶ A piece of literal text, such as code. Within the contents, you can use curly braces to indicate a “variable” part, as in
file
. For example, in:samp:`print 1+{variable}`
, the partvariable
would be emphasized.If you don’t need the “variable part” indication, use the standard
``code``
instead.Changed in version 1.8: Allowed to escape curly braces with backslash
There is also an index
role to generate index entries.
The following roles generate external links:
-
:pep:
¶ A reference to a Python Enhancement Proposal. This generates appropriate index entries. The text “PEP number” is generated; in the HTML output, this text is a hyperlink to an online copy of the specified PEP. You can link to a specific section by saying
:pep:`number#anchor`
.
-
:rfc:
¶ A reference to an Internet Request for Comments. This generates appropriate index entries. The text “RFC number” is generated; in the HTML output, this text is a hyperlink to an online copy of the specified RFC. You can link to a specific section by saying
:rfc:`number#anchor`
.
Note that there are no special roles for including hyperlinks as you can use the standard reST markup for that purpose.
Substitutions¶
The documentation system provides three substitutions that are defined by default. They are set in the build configuration file.
-
|release|
Replaced by the project release the documentation refers to. This is meant to be the full version string including alpha/beta/release candidate tags, e.g.
2.5.2b3
. Set byrelease
.
-
|version|
Replaced by the project version the documentation refers to. This is meant to consist only of the major and minor version parts, e.g.
2.5
, even for version 2.5.1. Set byversion
.
Directives¶
As previously discussed, a directive is a generic block of explicit markup. While Docutils provides a number of directives, Sphinx provides many more and uses directives as one of the primary extension mechanisms.
See Domains for roles added by domains.
See also
Refer to the reStructuredText Primer for an overview of the directives provided by Docutils.
Table of contents¶
Since reST does not have facilities to interconnect several documents, or split
documents into multiple output files, Sphinx uses a custom directive to add
relations between the single files the documentation is made of, as well as
tables of contents. The toctree
directive is the central element.
Note
Simple “inclusion” of one file in another can be done with the include directive.
Note
For local tables of contents, use the standard reST contents directive.
-
.. toctree::
¶ This directive inserts a “TOC tree” at the current location, using the individual TOCs (including “sub-TOC trees”) of the documents given in the directive body. Relative document names (not beginning with a slash) are relative to the document the directive occurs in, absolute names are relative to the source directory. A numeric
maxdepth
option may be given to indicate the depth of the tree; by default, all levels are included. [1]Consider this example (taken from the Python docs’ library reference index):
.. toctree:: :maxdepth: 2 intro strings datatypes numeric (many more documents listed here)
This accomplishes two things:
- Tables of contents from all those documents are inserted, with a maximum
depth of two, that means one nested heading.
toctree
directives in those documents are also taken into account. - Sphinx knows the relative order of the documents
intro
,strings
and so forth, and it knows that they are children of the shown document, the library index. From this information it generates “next chapter”, “previous chapter” and “parent chapter” links.
Entries
Document titles in the
toctree
will be automatically read from the title of the referenced document. If that isn’t what you want, you can specify an explicit title and target using a similar syntax to reST hyperlinks (and Sphinx’s cross-referencing syntax). This looks like:.. toctree:: intro All about strings <strings> datatypes
The second line above will link to the
strings
document, but will use the title “All about strings” instead of the title of thestrings
document.You can also add external links, by giving an HTTP URL instead of a document name.
Section numbering
If you want to have section numbers even in HTML output, give the toplevel toctree a
numbered
option. For example:.. toctree:: :numbered: foo bar
Numbering then starts at the heading of
foo
. Sub-toctrees are automatically numbered (don’t give thenumbered
flag to those).Numbering up to a specific depth is also possible, by giving the depth as a numeric argument to
numbered
.Additional options
You can use
caption
option to provide a toctree caption and you can usename
option to provide implicit target name that can be referenced by usingref
:.. toctree:: :caption: Table of Contents :name: mastertoc foo
If you want only the titles of documents in the tree to show up, not other headings of the same level, you can use the
titlesonly
option:.. toctree:: :titlesonly: foo bar
You can use “globbing” in toctree directives, by giving the
glob
flag option. All entries are then matched against the list of available documents, and matches are inserted into the list alphabetically. Example:.. toctree:: :glob: intro* recipe/* *
This includes first all documents whose names start with
intro
, then all documents in therecipe
folder, then all remaining documents (except the one containing the directive, of course.) [2]The special entry name
self
stands for the document containing the toctree directive. This is useful if you want to generate a “sitemap” from the toctree.You can use the
reversed
flag option to reverse the order of the entries in the list. This can be useful when using theglob
flag option to reverse the ordering of the files. Example:.. toctree:: :glob: :reversed: recipe/*
You can also give a “hidden” option to the directive, like this:
.. toctree:: :hidden: doc_1 doc_2
This will still notify Sphinx of the document hierarchy, but not insert links into the document at the location of the directive – this makes sense if you intend to insert these links yourself, in a different style, or in the HTML sidebar.
In cases where you want to have only one top-level toctree and hide all other lower level toctrees you can add the “includehidden” option to the top-level toctree entry:
.. toctree:: :includehidden: doc_1 doc_2
All other toctree entries can then be eliminated by the “hidden” option.
In the end, all documents in the source directory (or subdirectories) must occur in some
toctree
directive; Sphinx will emit a warning if it finds a file that is not included, because that means that this file will not be reachable through standard navigation.Use
exclude_patterns
to explicitly exclude documents or directories from building completely. Use the “orphan” metadata to let a document be built, but notify Sphinx that it is not reachable via a toctree.The “master document” (selected by
master_doc
) is the “root” of the TOC tree hierarchy. It can be used as the documentation’s main page, or as a “full table of contents” if you don’t give amaxdepth
option.Changed in version 0.3: Added “globbing” option.
Changed in version 0.6: Added “numbered” and “hidden” options as well as external links and support for “self” references.
Changed in version 1.0: Added “titlesonly” option.
Changed in version 1.1: Added numeric argument to “numbered”.
Changed in version 1.2: Added “includehidden” option.
Changed in version 1.3: Added “caption” and “name” option.
- Tables of contents from all those documents are inserted, with a maximum
depth of two, that means one nested heading.
Special names¶
Sphinx reserves some document names for its own use; you should not try to create documents with these names – it will cause problems.
The special document names (and pages generated for them) are:
genindex
,modindex
,search
These are used for the general index, the Python module index, and the search page, respectively.
The general index is populated with entries from modules, all index-generating object descriptions, and from
index
directives.The Python module index contains one entry per
py:module
directive.The search page contains a form that uses the generated JSON search index and JavaScript to full-text search the generated documents for search words; it should work on every major browser that supports modern JavaScript.
every name beginning with
_
Though only few such names are currently used by Sphinx, you should not create documents or document-containing directories with such names. (Using
_
as a prefix for a custom template directory is fine.)
Warning
Be careful with unusual characters in filenames. Some formats may interpret these characters in unexpected ways:
- Do not use the colon
:
for HTML based formats. Links to other parts may not work. - Do not use the plus
+
for the ePub format. Some resources may not be found.
Paragraph-level markup¶
These directives create short paragraphs and can be used inside information units as well as normal text.
-
.. note::
An especially important bit of information about an API that a user should be aware of when using whatever bit of API the note pertains to. The content of the directive should be written in complete sentences and include all appropriate punctuation.
Example:
.. note:: This function is not suitable for sending spam e-mails.
-
.. warning::
An important bit of information about an API that a user should be very aware of when using whatever bit of API the warning pertains to. The content of the directive should be written in complete sentences and include all appropriate punctuation. This differs from
note
in that it is recommended overnote
for information regarding security.
-
.. versionadded::
version
¶ This directive documents the version of the project which added the described feature to the library or C API. When this applies to an entire module, it should be placed at the top of the module section before any prose.
The first argument must be given and is the version in question; you can add a second argument consisting of a brief explanation of the change.
Example:
.. versionadded:: 2.5 The *spam* parameter.
Note that there must be no blank line between the directive head and the explanation; this is to make these blocks visually continuous in the markup.
-
.. versionchanged::
version
¶ Similar to
versionadded
, but describes when and what changed in the named feature in some way (new parameters, changed side effects, etc.).
-
.. deprecated::
version
¶ Similar to
versionchanged
, but describes when the feature was deprecated. An explanation can also be given, for example to inform the reader what should be used instead. Example:.. deprecated:: 3.1 Use :func:`spam` instead.
-
.. seealso::
¶ Many sections include a list of references to module documentation or external documents. These lists are created using the
seealso
directive.The
seealso
directive is typically placed in a section just before any subsections. For the HTML output, it is shown boxed off from the main flow of the text.The content of the
seealso
directive should be a reST definition list. Example:.. seealso:: Module :py:mod:`zipfile` Documentation of the :py:mod:`zipfile` standard module. `GNU tar manual, Basic Tar Format <http://link>`_ Documentation for tar archive files, including GNU tar extensions.
There’s also a “short form” allowed that looks like this:
.. seealso:: modules :py:mod:`zipfile`, :py:mod:`tarfile`
New in version 0.5: The short form.
-
.. rubric::
title
¶ This directive creates a paragraph heading that is not used to create a table of contents node.
Note
If the title of the rubric is “Footnotes” (or the selected language’s equivalent), this rubric is ignored by the LaTeX writer, since it is assumed to only contain footnote definitions and therefore would create an empty heading.
-
.. centered::
¶ This directive creates a centered boldfaced line of text. Use it as follows:
.. centered:: LICENSE AGREEMENT
Deprecated since version 1.1: This presentation-only directive is a legacy from older versions. Use a
rst-class
directive instead and add an appropriate style.
-
.. hlist::
¶ This directive must contain a bullet list. It will transform it into a more compact list by either distributing more than one item horizontally, or reducing spacing between items, depending on the builder.
For builders that support the horizontal distribution, there is a
columns
option that specifies the number of columns; it defaults to 2. Example:.. hlist:: :columns: 3 * A list of * short items * that should be * displayed * horizontally
New in version 0.6.
Showing code examples¶
There are multiple ways to show syntax-highlighted literal code blocks in
Sphinx: using reST doctest blocks; using reST
literal blocks, optionally in combination with the
highlight
directive; using the code-block
directive; and
using the literalinclude
directive. Doctest blocks can only be used
to show interactive Python sessions, while the remaining three can be used for
other languages. Of these three, literal blocks are useful when an entire
document, or at least large sections of it, use code blocks with the same
syntax and which should be styled in the same manner. On the other hand, the
code-block
directive makes more sense when you want more fine-tuned
control over the styling of each block or when you have a document containing
code blocks using multiple varied syntaxes. Finally, the
literalinclude
directive is useful for including entire code files
in your documentation.
In all cases, Syntax highlighting is provided by Pygments. When using literal blocks, this is configured using
any highlight
directives in the source file. When a highlight
directive is encountered, it is used until the next highlight
directive is
encountered. If there is no highlight
directive in the file, the global
highlighting language is used. This defaults to python
but can be
configured using the highlight_language
config value. The following
values are supported:
none
(no highlighting)default
(similar topython3
but with a fallback tonone
without warning highlighting fails; the default whenhighlight_language
isn’t set)guess
(let Pygments guess the lexer based on contents, only works with certain well-recognizable languages)python
rest
c
- … and any other lexer alias that Pygments supports
If highlighting with the selected language fails (i.e. Pygments emits an “Error” token), the block is not highlighted in any way.
Important
The list of lexer aliases supported is tied to the Pygment version. If you want to ensure consistent highlighting, you should fix your version of Pygments.
-
.. highlight::
language
¶ Example:
.. highlight:: c
This language is used until the next
highlight
directive is encountered. As discussed previously, language can be any lexer alias supported by Pygments.Additional options
Pygments can generate line numbers for code blocks. To enable this, use the
linenothreshold
option... highlight:: python :linenothreshold: 5
This will produce line numbers for all code blocks longer than five lines.
-
.. code-block::
language
¶ Example:
.. code-block:: ruby Some Ruby code.
The directive’s alias name
sourcecode
works as well. As withhighlight
’slanguage
option,language
can be any lexer alias supported by Pygments.Additional options
Pygments can generate line numbers for code blocks. To enable this for, use the
linenos
flag option... code-block:: ruby :linenos: Some more Ruby code.
The first line number can be selected with the
lineno-start
option. If present,linenos
flag is automatically activated:.. code-block:: ruby :lineno-start: 10 Some more Ruby code, with line numbering starting at 10.
Additionally, an
emphasize-lines
option can be given to have Pygments emphasize particular lines:.. code-block:: python :emphasize-lines: 3,5 def some_function(): interesting = False print 'This line is highlighted.' print 'This one is not...' print '...but this one is.'
A
caption
option can be given to show that name before the code block. Aname
option can be provided implicit target name that can be referenced by usingref
. For example:.. code-block:: python :caption: this.py :name: this-py print 'Explicit is better than implicit.'
A
dedent
option can be given to strip indentation characters from the code block. For example:.. code-block:: ruby :dedent: 4 some ruby code
Changed in version 1.1: The
emphasize-lines
option has been added.Changed in version 1.3: The
lineno-start
,caption
,name
anddedent
options have been added.Changed in version 1.6.6: LaTeX supports the
emphasize-lines
option.
-
.. literalinclude::
filename
¶ Longer displays of verbatim text may be included by storing the example text in an external file containing only plain text. The file may be included using the
literalinclude
directive. [3] For example, to include the Python source fileexample.py
, use:.. literalinclude:: example.py
The file name is usually relative to the current file’s path. However, if it is absolute (starting with
/
), it is relative to the top source directory.Additional options
Like
code-block
, the directive supports thelinenos
flag option to switch on line numbers, thelineno-start
option to select the first line number, theemphasize-lines
option to emphasize particular lines, thename
option to provide an implicit target name, thededent
option to strip indentation characters for the code block, and alanguage
option to select a language different from the current file’s standard language. In addition, it supports thecaption
option; however, this can be provided with no argument to use the filename as the caption. Example with options:.. literalinclude:: example.rb :language: ruby :emphasize-lines: 12,15-18 :linenos:
Tabs in the input are expanded if you give a
tab-width
option with the desired tab width.Include files are assumed to be encoded in the
source_encoding
. If the file has a different encoding, you can specify it with theencoding
option:.. literalinclude:: example.py :encoding: latin-1
The directive also supports including only parts of the file. If it is a Python module, you can select a class, function or method to include using the
pyobject
option:.. literalinclude:: example.py :pyobject: Timer.start
This would only include the code lines belonging to the
start()
method in theTimer
class within the file.Alternately, you can specify exactly which lines to include by giving a
lines
option:.. literalinclude:: example.py :lines: 1,3,5-10,20-
This includes the lines 1, 3, 5 to 10 and lines 20 to the last line.
Another way to control which part of the file is included is to use the
start-after
andend-before
options (or only one of them). Ifstart-after
is given as a string option, only lines that follow the first line containing that string are included. Ifend-before
is given as a string option, only lines that precede the first lines containing that string are included. Thestart-at
andend-at
options behave in a similar way, but the lines containing the matched string are included.With lines selected using
start-after
it is still possible to uselines
, the first allowed line having by convention the line number1
.When lines have been selected in any of the ways described above, the line numbers in
emphasize-lines
refer to those selected lines, counted consecutively starting at1
.When specifying particular parts of a file to display, it can be useful to display the original line numbers. This can be done using the
lineno-match
option, which is however allowed only when the selection consists of contiguous lines.You can prepend and/or append a line to the included code, using the
prepend
andappend
option, respectively. This is useful e.g. for highlighting PHP code that doesn’t include the<?php
/?>
markers.If you want to show the diff of the code, you can specify the old file by giving a
diff
option:.. literalinclude:: example.py :diff: example.py.orig
This shows the diff between
example.py
andexample.py.orig
with unified diff format.Changed in version 0.4.3: Added the
encoding
option.Changed in version 0.6: Added the
pyobject
,lines
,start-after
andend-before
options, as well as support for absolute filenames.Changed in version 1.0: Added the
prepend
,append
, andtab-width
options.Changed in version 1.3: Added the
diff
,lineno-match
,caption
,name
, anddedent
options.Changed in version 1.5: Added the
start-at
, andend-at
options.Changed in version 1.6: With both
start-after
andlines
in use, the first line as perstart-after
is considered to be with line number1
forlines
.
Glossary¶
-
.. glossary::
This directive must contain a reST definition-list-like markup with terms and definitions. The definitions will then be referencable with the
term
role. Example:.. glossary:: environment A structure where information about all documents under the root is saved, and used for cross-referencing. The environment is pickled after the parsing stage, so that successive runs only need to read and parse new and changed documents. source directory The directory which, including its subdirectories, contains all source files for one Sphinx project.
In contrast to regular definition lists, multiple terms per entry are allowed, and inline markup is allowed in terms. You can link to all of the terms. For example:
.. glossary:: term 1 term 2 Definition of both terms.
(When the glossary is sorted, the first term determines the sort order.)
If you want to specify “grouping key” for general index entries, you can put a “key” as “term : key”. For example:
.. glossary:: term 1 : A term 2 : B Definition of both terms.
Note that “key” is used for grouping key as is. The “key” isn’t normalized; key “A” and “a” become different groups. The whole characters in “key” is used instead of a first character; it is used for “Combining Character Sequence” and “Surrogate Pairs” grouping key.
In i18n situation, you can specify “localized term : key” even if original text only have “term” part. In this case, translated “localized term” will be categorized in “key” group.
New in version 0.6: You can now give the glossary directive a
:sorted:
flag that will automatically sort the entries alphabetically.Changed in version 1.1: Now supports multiple terms and inline markup in terms.
Changed in version 1.4: Index key for glossary term should be considered experimental.
Meta-information markup¶
Identifies the author of the current section. The argument should include the author’s name such that it can be used for presentation and email address. The domain name portion of the address should be lower case. Example:
.. sectionauthor:: Guido van Rossum <guido@python.org>
By default, this markup isn’t reflected in the output in any way (it helps keep track of contributions), but you can set the configuration value
show_authors
toTrue
to make them produce a paragraph in the output.
The
codeauthor
directive, which can appear multiple times, names the authors of the described code, just likesectionauthor
names the author(s) of a piece of documentation. It too only produces output if theshow_authors
configuration value isTrue
.
Index-generating markup¶
Sphinx automatically creates index entries from all object descriptions (like functions, classes or attributes) like discussed in Domains.
However, there is also explicit markup available, to make the index more comprehensive and enable index entries in documents where information is not mainly contained in information units, such as the language reference.
-
.. index::
<entries>
¶ This directive contains one or more index entries. Each entry consists of a type and a value, separated by a colon.
For example:
.. index:: single: execution; context module: __main__ module: sys triple: module; search; path The execution context --------------------- ...
This directive contains five entries, which will be converted to entries in the generated index which link to the exact location of the index statement (or, in case of offline media, the corresponding page number).
Since index directives generate cross-reference targets at their location in the source, it makes sense to put them before the thing they refer to – e.g. a heading, as in the example above.
The possible entry types are:
- single
- Creates a single index entry. Can be made a subentry by separating the subentry text with a semicolon (this notation is also used below to describe what entries are created).
- pair
pair: loop; statement
is a shortcut that creates two index entries, namelyloop; statement
andstatement; loop
.- triple
- Likewise,
triple: module; search; path
is a shortcut that creates three index entries, which aremodule; search path
,search; path, module
andpath; module search
. - see
see: entry; other
creates an index entry that refers fromentry
toother
.- seealso
- Like
see
, but inserts “see also” instead of “see”. - module, keyword, operator, object, exception, statement, builtin
- These all create two index entries. For example,
module: hashlib
creates the entriesmodule; hashlib
andhashlib; module
. (These are Python-specific and therefore deprecated.)
You can mark up “main” index entries by prefixing them with an exclamation mark. The references to “main” entries are emphasized in the generated index. For example, if two pages contain
.. index:: Python
and one page contains
.. index:: ! Python
then the backlink to the latter page is emphasized among the three backlinks.
For index directives containing only “single” entries, there is a shorthand notation:
.. index:: BNF, grammar, syntax, notation
This creates four index entries.
Changed in version 1.1: Added
see
andseealso
types, as well as marking main entries.
-
:index:
¶ While the
index
directive is a block-level markup and links to the beginning of the next paragraph, there is also a corresponding role that sets the link target directly where it is used.The content of the role can be a simple phrase, which is then kept in the text and used as an index entry. It can also be a combination of text and index entry, styled like with explicit targets of cross-references. In that case, the “target” part can be a full entry as described for the directive above. For example:
This is a normal reST :index:`paragraph` that contains several :index:`index entries <pair: index; entry>`.
New in version 1.1.
Including content based on tags¶
-
.. only::
<expression>
¶ Include the content of the directive only if the expression is true. The expression should consist of tags, like this:
.. only:: html and draft
Undefined tags are false, defined tags (via the
-t
command-line option or withinconf.py
, see here) are true. Boolean expressions, also using parentheses (likehtml and (latex or draft)
) are supported.The format and the name of the current builder (
html
,latex
ortext
) are always set as a tag [4]. To make the distinction between format and name explicit, they are also added with the prefixformat_
andbuilder_
, e.g. the epub builder defines the tagshtml
,epub
,format_html
andbuilder_epub
.These standard tags are set after the configuration file is read, so they are not available there.
All tags must follow the standard Python identifier syntax as set out in the Identifiers and keywords documentation. That is, a tag expression may only consist of tags that conform to the syntax of Python variables. In ASCII, this consists of the uppercase and lowercase letters
A
throughZ
, the underscore_
and, except for the first character, the digits0
through9
.New in version 0.6.
Changed in version 1.2: Added the name of the builder and the prefixes.
Warning
This directive is designed to control only content of document. It could not control sections, labels and so on.
Tables¶
Use reStructuredText tables, i.e. either
- grid table syntax (ref),
- simple table syntax (ref),
- csv-table syntax,
- or list-table syntax.
The table directive serves as optional wrapper of the grid and simple syntaxes.
They work fine in HTML output, however there are some gotchas when using tables in LaTeX: the column width is hard to determine correctly automatically. For this reason, the following directive exists:
-
.. tabularcolumns::
column spec
¶ This directive gives a “column spec” for the next table occurring in the source file. The spec is the second argument to the LaTeX
tabulary
package’s environment (which Sphinx uses to translate tables). It can have values like|l|l|l|
which means three left-adjusted, nonbreaking columns. For columns with longer text that should automatically be broken, use either the standard
p{width}
construct, or tabulary’s automatic specifiers:L
flush left column with automatic width R
flush right column with automatic width C
centered column with automatic width J
justified column with automatic width The automatic widths of the
LRCJ
columns are attributed bytabulary
in proportion to the observed shares in a first pass where the table cells are rendered at their natural “horizontal” widths.By default, Sphinx uses a table layout with
J
for every column.New in version 0.3.
Changed in version 1.6: Merged cells may now contain multiple paragraphs and are much better handled, thanks to custom Sphinx LaTeX macros. This novel situation motivated the switch to
J
specifier and notL
by default.Hint
Sphinx actually uses
T
specifier having done\newcolumntype{T}{J}
. To revert to previous default, insert\newcolumntype{T}{L}
in the LaTeX preamble (seelatex_elements
).A frequent issue with tabulary is that columns with little contents are “squeezed”. The minimal column width is a tabulary parameter called
\tymin
. You may set it globally in the LaTeX preamble via\setlength{\tymin}{40pt}
for example.Else, use the
tabularcolumns
directive with an explicitp{40pt}
(for example) for that column. You may use alsol
specifier but this makes the task of setting column widths more difficult if some merged cell intersects that column.Warning
Tables with more than 30 rows are rendered using
longtable
, nottabulary
, in order to allow pagebreaks. TheL
,R
, … specifiers do not work for these tables.Tables that contain list-like elements such as object descriptions, blockquotes or any kind of lists cannot be set out of the box with
tabulary
. They are therefore set with the standard LaTeXtabular
(orlongtable
) environment if you don’t give atabularcolumns
directive. If you do, the table will be set withtabulary
but you must use thep{width}
construct (or Sphinx’s\X
and\Y
specifiers described below) for the columns containing these elements.Literal blocks do not work with
tabulary
at all, so tables containing a literal block are always set withtabular
. The verbatim environment used for literal blocks only works inp{width}
(and\X
or\Y
) columns, hence Sphinx generates such column specs for tables containing literal blocks.Since Sphinx 1.5, the
\X{a}{b}
specifier is used (there is a backslash in the specifier letter). It is likep{width}
with the width set to a fractiona/b
of the current line width. You can use it in thetabularcolumns
(it is not a problem if some LaTeX macro is also called\X
.)It is not needed for
b
to be the total number of columns, nor for the sum of the fractions of the\X
specifiers to add up to one. For example|\X{2}{5}|\X{1}{5}|\X{1}{5}|
is legitimate and the table will occupy 80% of the line width, the first of its three columns having the same width as the sum of the next two.This is used by the
:widths:
option of the table directive.Since Sphinx 1.6, there is also the
\Y{f}
specifier which admits a decimal argument, such has\Y{0.15}
: this would have the same effect as\X{3}{20}
.Changed in version 1.6: Merged cells from complex grid tables (either multi-row, multi-column, or both) now allow blockquotes, lists, literal blocks, … as do regular cells.
Sphinx’s merged cells interact well with
p{width}
,\X{a}{b}
,Y{f}
and tabulary’s columns.Note
tabularcolumns
conflicts with:widths:
option of table directives. If both are specified,:widths:
option will be ignored.
Math¶
The input language for mathematics is LaTeX markup. This is the de-facto standard for plain-text math notation and has the added advantage that no further translation is necessary when building LaTeX output.
Keep in mind that when you put math markup in Python docstrings read by
autodoc
, you either have to double all backslashes,
or use Python raw strings (r"raw"
).
-
.. math::
¶ Directive for displayed math (math that takes the whole line for itself).
The directive supports multiple equations, which should be separated by a blank line:
.. math:: (a + b)^2 = a^2 + 2ab + b^2 (a - b)^2 = a^2 - 2ab + b^2
In addition, each single equation is set within a
split
environment, which means that you can have multiple aligned lines in an equation, aligned at&
and separated by\\
:.. math:: (a + b)^2 &= (a + b)(a + b) \\ &= a^2 + 2ab + b^2
For more details, look into the documentation of the AmSMath LaTeX package.
When the math is only one line of text, it can also be given as a directive argument:
.. math:: (a + b)^2 = a^2 + 2ab + b^2
Normally, equations are not numbered. If you want your equation to get a number, use the
label
option. When given, it selects an internal label for the equation, by which it can be cross-referenced, and causes an equation number to be issued. Seeeq
for an example. The numbering style depends on the output format.There is also an option
nowrap
that prevents any wrapping of the given math in a math environment. When you give this option, you must make sure yourself that the math is properly set up. For example:.. math:: :nowrap: \begin{eqnarray} y & = & ax^2 + bx + c \\ f(x) & = & x^2 + 2xy + y^2 \end{eqnarray}
Grammar production displays¶
Special markup is available for displaying the productions of a formal grammar. The markup is simple and does not attempt to model all aspects of BNF (or any derived forms), but provides enough to allow context-free grammars to be displayed in a way that causes uses of a symbol to be rendered as hyperlinks to the definition of the symbol. There is this directive:
-
.. productionlist::
[name]
¶ This directive is used to enclose a group of productions. Each production is given on a single line and consists of a name, separated by a colon from the following definition. If the definition spans multiple lines, each continuation line must begin with a colon placed at the same column as in the first line.
The argument to
productionlist
serves to distinguish different sets of production lists that belong to different grammars.Blank lines are not allowed within
productionlist
directive arguments.The definition can contain token names which are marked as interpreted text (e.g.
sum ::= `integer` "+" `integer`
) – this generates cross-references to the productions of these tokens. Outside of the production list, you can reference to token productions usingtoken
.Note that no further reST parsing is done in the production, so that you don’t have to escape
*
or|
characters.
The following is an example taken from the Python Reference Manual:
.. productionlist::
try_stmt: try1_stmt | try2_stmt
try1_stmt: "try" ":" `suite`
: ("except" [`expression` ["," `target`]] ":" `suite`)+
: ["else" ":" `suite`]
: ["finally" ":" `suite`]
try2_stmt: "try" ":" `suite`
: "finally" ":" `suite`
Footnotes
[1] | The LaTeX writer only refers the maxdepth option of first toctree
directive in the document. |
[2] | A note on available globbing syntax: you can use the standard shell
constructs * , ? , [...] and [!...] with the feature that
these all don’t match slashes. A double star ** can be used to
match any sequence of characters including slashes. |
[3] | There is a standard .. include directive, but it raises errors if the
file is not found. This one only emits a warning. |
[4] | For most builders name and format are the same. At the moment only builders derived from the html builder distinguish between the builder format and the builder name. Note that the current builder tag is not available in |
Field Lists¶
As previously discussed, field lists are sequences of fields marked up like this:
:fieldname: Field content
Sphinx provides custom behavior for bibliographic fields compared to docutils.
File-wide metadata¶
A field list near the top of a file is normally parsed by docutils as the docinfo which is generally used to record the author, date of publication and other metadata. However, in Sphinx, a field list preceding any other markup is moved from the docinfo to the Sphinx environment as document metadata and is not displayed in the output; a field list appearing after the document title will be part of the docinfo as normal and will be displayed in the output.
At the moment, these metadata fields are recognized:
tocdepth
The maximum depth for a table of contents of this file.
:tocdepth: 2
New in version 0.4.
nocomments
If set, the web application won’t display a comment form for a page generated from this source file.
:nocomments:
orphan
If set, warnings about this file not being included in any toctree will be suppressed.
:orphan:
New in version 1.0.
Domains¶
New in version 1.0.
Originally, Sphinx was conceived for a single project, the documentation of the
Python language. Shortly afterwards, it was made available for everyone as a
documentation tool, but the documentation of Python modules remained deeply
built in – the most fundamental directives, like function
, were designed
for Python objects. Since Sphinx has become somewhat popular, interest
developed in using it for many different purposes: C/C++ projects, JavaScript,
or even reStructuredText markup (like in this documentation).
While this was always possible, it is now much easier to easily support documentation of projects using different programming languages or even ones not supported by the main Sphinx distribution, by providing a domain for every such purpose.
A domain is a collection of markup (reStructuredText directives and
roles) to describe and link to objects belonging together,
e.g. elements of a programming language. Directive and role names in a domain
have names like domain:name
, e.g. py:function
. Domains can also
provide custom indices (like the Python Module Index).
Having domains means that there are no naming problems when one set of documentation wants to refer to e.g. C++ and Python classes. It also means that extensions that support the documentation of whole new languages are much easier to write.
This section describes what the domains that are included with Sphinx provide. The domain API is documented as well, in the section Domain API.
Basic Markup¶
Most domains provide a number of object description directives, used to
describe specific objects provided by modules. Each directive requires one or
more signatures to provide basic information about what is being described, and
the content should be the description. The basic version makes entries in the
general index; if no index entry is desired, you can give the directive option
flag :noindex:
. An example using a Python domain directive:
.. py:function:: spam(eggs)
ham(eggs)
Spam or ham the foo.
This describes the two Python functions spam
and ham
. (Note that when
signatures become too long, you can break them if you add a backslash to lines
that are continued in the next line. Example:
.. py:function:: filterwarnings(action, message='', category=Warning, \
module='', lineno=0, append=False)
:noindex:
(This example also shows how to use the :noindex:
flag.)
The domains also provide roles that link back to these object descriptions. For example, to link to one of the functions described in the example above, you could say
The function :py:func:`spam` does a similar thing.
As you can see, both directive and role names contain the domain name and the directive name.
Default Domain
For documentation describing objects from solely one domain, authors will not
have to state again its name at each directive, role, etc… after
having specified a default. This can be done either via the config
value primary_domain
or via this directive:
-
.. default-domain::
name
¶ Select a new default domain. While the
primary_domain
selects a global default, this only has an effect within the same file.
If no other default is selected, the Python domain (named py
) is the
default one, mostly for compatibility with documentation written for older
versions of Sphinx.
Directives and roles that belong to the default domain can be mentioned without giving the domain name, i.e.
.. function:: pyfunc()
Describes a Python function.
Reference to :func:`pyfunc`.
Cross-referencing syntax¶
For cross-reference roles provided by domains, the same facilities exist as for general cross-references. See Cross-referencing syntax.
In short:
- You may supply an explicit title and reference target:
:role:`title <target>`
will refer to target, but the link text will be title. - If you prefix the content with
!
, no reference/hyperlink will be created. - If you prefix the content with
~
, the link text will only be the last component of the target. For example,:py:meth:`~Queue.Queue.get`
will refer toQueue.Queue.get
but only displayget
as the link text.
The Python Domain¶
The Python domain (name py) provides the following directives for module declarations:
-
.. py:module::
name
¶ This directive marks the beginning of the description of a module (or package submodule, in which case the name should be fully qualified, including the package name). It does not create content (like e.g.
py:class
does).This directive will also cause an entry in the global module index.
The
platform
option, if present, is a comma-separated list of the platforms on which the module is available (if it is available on all platforms, the option should be omitted). The keys are short identifiers; examples that are in use include “IRIX”, “Mac”, “Windows”, and “Unix”. It is important to use a key which has already been used when applicable.The
synopsis
option should consist of one sentence describing the module’s purpose – it is currently only used in the Global Module Index.The
deprecated
option can be given (with no value) to mark a module as deprecated; it will be designated as such in various locations then.
-
.. py:currentmodule::
name
¶ This directive tells Sphinx that the classes, functions etc. documented from here are in the given module (like
py:module
), but it will not create index entries, an entry in the Global Module Index, or a link target forpy:mod
. This is helpful in situations where documentation for things in a module is spread over multiple files or sections – one location has thepy:module
directive, the others onlypy:currentmodule
.
The following directives are provided for module and class contents:
-
.. py:function::
name(parameters)
¶ Describes a module-level function. The signature should include the parameters as given in the Python function definition, see Python Signatures. For example:
.. py:function:: Timer.repeat(repeat=3, number=1000000)
For methods you should use
py:method
.The description normally includes information about the parameters required and how they are used (especially whether mutable objects passed as parameters are modified), side effects, and possible exceptions.
This information can (in any
py
directive) optionally be given in a structured form, see Info field lists.
-
.. py:data::
name
¶ Describes global data in a module, including both variables and values used as “defined constants.” Class and object attributes are not documented using this environment.
-
.. py:exception::
name
¶ Describes an exception class. The signature can, but need not include parentheses with constructor arguments.
-
.. py:class::
name
¶ -
.. py:class::
name(parameters)
Describes a class. The signature can optionally include parentheses with parameters which will be shown as the constructor arguments. See also Python Signatures.
Methods and attributes belonging to the class should be placed in this directive’s body. If they are placed outside, the supplied name should contain the class name so that cross-references still work. Example:
.. py:class:: Foo .. py:method:: quux() -- or -- .. py:class:: Bar .. py:method:: Bar.quux()
The first way is the preferred one.
-
.. py:attribute::
name
¶ Describes an object data attribute. The description should include information about the type of the data to be expected and whether it may be changed directly.
-
.. py:method::
name(parameters)
¶ Describes an object method. The parameters should not include the
self
parameter. The description should include similar information to that described forfunction
. See also Python Signatures and Info field lists.
-
.. py:staticmethod::
name(parameters)
¶ Like
py:method
, but indicates that the method is a static method.New in version 0.4.
-
.. py:classmethod::
name(parameters)
¶ Like
py:method
, but indicates that the method is a class method.New in version 0.6.
-
.. py:decorator::
name
¶ -
.. py:decorator::
name(parameters)
Describes a decorator function. The signature should represent the usage as a decorator. For example, given the functions
def removename(func): func.__name__ = '' return func def setnewname(name): def decorator(func): func.__name__ = name return func return decorator
the descriptions should look like this:
.. py:decorator:: removename Remove name of the decorated function. .. py:decorator:: setnewname(name) Set name of the decorated function to *name*.
(as opposed to
.. py:decorator:: removename(func)
.)There is no
py:deco
role to link to a decorator that is marked up with this directive; rather, use thepy:func
role.
-
.. py:decoratormethod::
name
¶ -
.. py:decoratormethod::
name(signature)
Same as
py:decorator
, but for decorators that are methods.Refer to a decorator method using the
py:meth
role.
Python Signatures¶
Signatures of functions, methods and class constructors can be given like they would be written in Python.
Default values for optional arguments can be given (but if they contain commas, they will confuse the signature parser). Python 3-style argument annotations can also be given as well as return type annotations:
.. py:function:: compile(source : string, filename, symbol='file') -> ast object
For functions with optional parameters that don’t have default values (typically functions implemented in C extension modules without keyword argument support), you can use brackets to specify the optional parts:
compile
(source[, filename[, symbol]])¶
It is customary to put the opening bracket before the comma.
Info field lists¶
New in version 0.4.
Inside Python object description directives, reST field lists with these fields are recognized and formatted nicely:
param
,parameter
,arg
,argument
,key
,keyword
: Description of a parameter.type
: Type of a parameter. Creates a link if possible.raises
,raise
,except
,exception
: That (and when) a specific exception is raised.var
,ivar
,cvar
: Description of a variable.vartype
: Type of a variable. Creates a link if possible.returns
,return
: Description of the return value.rtype
: Return type. Creates a link if possible.
Note
In current release, all var
, ivar
and cvar
are represented as
“Variable”. There is no difference at all.
The field names must consist of one of these keywords and an argument (except
for returns
and rtype
, which do not need an argument). This is best
explained by an example:
.. py:function:: send_message(sender, recipient, message_body, [priority=1])
Send a message to a recipient
:param str sender: The person sending the message
:param str recipient: The recipient of the message
:param str message_body: The body of the message
:param priority: The priority of the message, can be a number 1-5
:type priority: integer or None
:return: the message id
:rtype: int
:raises ValueError: if the message_body exceeds 160 characters
:raises TypeError: if the message_body is not a basestring
This will render like this:
send_message
(sender, recipient, message_body[, priority=1])Send a message to a recipient
Parameters:
- sender (str) – The person sending the message
- recipient (str) – The recipient of the message
- message_body (str) – The body of the message
- priority (integer or None) – The priority of the message, can be a number 1-5
Returns: the message id
Return type: int
Raises:
- ValueError – if the message_body exceeds 160 characters
- TypeError – if the message_body is not a basestring
It is also possible to combine parameter type and description, if the type is a single word, like this:
:param int priority: The priority of the message, can be a number 1-5
New in version 1.5.
Container types such as lists and dictionaries can be linked automatically using the following syntax:
:type priorities: list(int)
:type priorities: list[int]
:type mapping: dict(str, int)
:type mapping: dict[str, int]
:type point: tuple(float, float)
:type point: tuple[float, float]
Multiple types in a type field will be linked automatically if separated by the word “or”:
:type an_arg: int or None
:vartype a_var: str or int
:rtype: float or str
Cross-referencing Python objects¶
The following roles refer to objects in modules and are possibly hyperlinked if a matching identifier is found:
-
:py:mod:
¶ Reference a module; a dotted name may be used. This should also be used for package names.
-
:py:func:
¶ Reference a Python function; dotted names may be used. The role text needs not include trailing parentheses to enhance readability; they will be added automatically by Sphinx if the
add_function_parentheses
config value isTrue
(the default).
-
:py:data:
¶ Reference a module-level variable.
-
:py:const:
¶ Reference a “defined” constant. This may be a Python variable that is not intended to be changed.
-
:py:class:
¶ Reference a class; a dotted name may be used.
-
:py:meth:
¶ Reference a method of an object. The role text can include the type name and the method name; if it occurs within the description of a type, the type name can be omitted. A dotted name may be used.
-
:py:attr:
¶ Reference a data attribute of an object.
-
:py:exc:
¶ Reference an exception. A dotted name may be used.
-
:py:obj:
¶ Reference an object of unspecified type. Useful e.g. as the
default_role
.New in version 0.4.
The name enclosed in this markup can include a module name and/or a class name.
For example, :py:func:`filter`
could refer to a function named filter
in the current module, or the built-in function of that name. In contrast,
:py:func:`foo.filter`
clearly refers to the filter
function in the
foo
module.
Normally, names in these roles are searched first without any further
qualification, then with the current module name prepended, then with the
current module and class name (if any) prepended. If you prefix the name with
a dot, this order is reversed. For example, in the documentation of Python’s
codecs
module, :py:func:`open`
always refers to the built-in
function, while :py:func:`.open`
refers to codecs.open()
.
A similar heuristic is used to determine whether the name is an attribute of the currently documented class.
Also, if the name is prefixed with a dot, and no exact match is found, the
target is taken as a suffix and all object names with that suffix are searched.
For example, :py:meth:`.TarFile.close`
references the
tarfile.TarFile.close()
function, even if the current module is not
tarfile
. Since this can get ambiguous, if there is more than one possible
match, you will get a warning from Sphinx.
Note that you can combine the ~
and .
prefixes:
:py:meth:`~.TarFile.close`
will reference the tarfile.TarFile.close()
method, but the visible link caption will only be close()
.
The C Domain¶
The C domain (name c) is suited for documentation of C API.
-
.. c:function::
function prototype
¶ Describes a C function. The signature should be given as in C, e.g.:
.. c:function:: PyObject* PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
This is also used to describe function-like preprocessor macros. The names of the arguments should be given so they may be used in the description.
Note that you don’t have to backslash-escape asterisks in the signature, as it is not parsed by the reST inliner.
-
.. c:member::
declaration
¶ Describes a C struct member. Example signature:
.. c:member:: PyObject* PyTypeObject.tp_bases
The text of the description should include the range of values allowed, how the value should be interpreted, and whether the value can be changed. References to structure members in text should use the
member
role.
-
.. c:macro::
name
¶ Describes a “simple” C macro. Simple macros are macros which are used for code expansion, but which do not take arguments so cannot be described as functions. This is a simple C-language
#define
. Examples of its use in the Python documentation includePyObject_HEAD
andPy_BEGIN_ALLOW_THREADS
.
-
.. c:type::
name
¶ Describes a C type (whether defined by a typedef or struct). The signature should just be the type name.
-
.. c:var::
declaration
¶ Describes a global C variable. The signature should include the type, such as:
.. c:var:: PyObject* PyClass_Type
Cross-referencing C constructs¶
The following roles create cross-references to C-language constructs if they are defined in the documentation:
-
:c:func:
¶ Reference a C-language function. Should include trailing parentheses.
-
:c:member:
¶ Reference a C-language member of a struct.
-
:c:macro:
¶ Reference a “simple” C macro, as defined above.
-
:c:type:
¶ Reference a C-language type.
-
:c:data:
¶ Reference a C-language variable.
The C++ Domain¶
The C++ domain (name cpp) supports documenting C++ projects.
Directives¶
The following directives are available. All declarations can start with a
visibility statement (public
, private
or protected
).
-
.. cpp:class::
class specifier
¶ Describe a class/struct, possibly with specification of inheritance, e.g.,:
.. cpp:class:: MyClass : public MyBase, MyOtherBase
The class can be directly declared inside a nested scope, e.g.,:
.. cpp:class:: OuterScope::MyClass : public MyBase, MyOtherBase
A class template can be declared:
.. cpp:class:: template<typename T, std::size_t N> std::array
or with a line break:
.. cpp:class:: template<typename T, std::size_t N> \ std::array
Full and partial template specialisations can be declared:
.. cpp:class:: template<> \ std::array<bool, 256> .. cpp:class:: template<typename T> \ std::array<T, 42>
-
.. cpp:function::
(member) function prototype
¶ Describe a function or member function, e.g.,:
.. cpp:function:: bool myMethod(int arg1, std::string arg2) A function with parameters and types. .. cpp:function:: bool myMethod(int, double) A function with unnamed parameters. .. cpp:function:: const T &MyClass::operator[](std::size_t i) const An overload for the indexing operator. .. cpp:function:: operator bool() const A casting operator. .. cpp:function:: constexpr void foo(std::string &bar[2]) noexcept A constexpr function. .. cpp:function:: MyClass::MyClass(const MyClass&) = default A copy constructor with default implementation.
Function templates can also be described:
.. cpp:function:: template<typename U> \ void print(U &&u)
and function template specialisations:
.. cpp:function:: template<> \ void print(int i)
-
.. cpp:member::
(member) variable declaration
¶ -
.. cpp:var::
(member) variable declaration
¶ Describe a variable or member variable, e.g.,:
.. cpp:member:: std::string MyClass::myMember .. cpp:var:: std::string MyClass::myOtherMember[N][M] .. cpp:member:: int a = 42
Variable templates can also be described:
.. cpp:member:: template<class T> \ constexpr T pi = T(3.1415926535897932385)
-
.. cpp:type::
typedef declaration
¶ -
.. cpp:type::
name
-
.. cpp:type::
type alias declaration
Describe a type as in a typedef declaration, a type alias declaration, or simply the name of a type with unspecified type, e.g.,:
.. cpp:type:: std::vector<int> MyList A typedef-like declaration of a type. .. cpp:type:: MyContainer::const_iterator Declaration of a type alias with unspecified type. .. cpp:type:: MyType = std::unordered_map<int, std::string> Declaration of a type alias.
A type alias can also be templated:
.. cpp:type:: template<typename T> \ MyContainer = std::vector<T>
The example are rendered as follows.
-
typedef std::vector<int>
MyList
¶ A typedef-like declaration of a type.
-
type
MyContainer
::
const_iterator
¶ Declaration of a type alias with unspecified type.
-
using
MyType
= std::unordered_map<int, std::string>¶ Declaration of a type alias.
-
typedef std::vector<int>
-
.. cpp:enum::
unscoped enum declaration
¶ -
.. cpp:enum-struct::
scoped enum declaration
¶ -
.. cpp:enum-class::
scoped enum declaration
¶ Describe a (scoped) enum, possibly with the underlying type specified. Any enumerators declared inside an unscoped enum will be declared both in the enum scope and in the parent scope. Examples:
.. cpp:enum:: MyEnum An unscoped enum. .. cpp:enum:: MySpecificEnum : long An unscoped enum with specified underlying type. .. cpp:enum-class:: MyScopedEnum A scoped enum. .. cpp:enum-struct:: protected MyScopedVisibilityEnum : std::underlying_type<MySpecificEnum>::type A scoped enum with non-default visibility, and with a specified underlying type.
-
.. cpp:enumerator::
name
¶ -
.. cpp:enumerator::
name = constant
Describe an enumerator, optionally with its value defined, e.g.,:
.. cpp:enumerator:: MyEnum::myEnumerator .. cpp:enumerator:: MyEnum::myOtherEnumerator = 42
-
.. cpp:union::
name
¶ Describe a union.
-
.. cpp:concept::
template-parameter-list name
¶ Warning
The support for concepts is experimental. It is based on the current draft standard and the Concepts Technical Specification. The features may change as they evolve.
Describe a concept. It must have exactly 1 template parameter list. The name may be a nested name. Example:
.. cpp:concept:: template<typename It> std::Iterator Proxy to an element of a notional sequence that can be compared, indirected, or incremented. **Notation** .. cpp:var:: It r An lvalue. **Valid Expressions** - :cpp:expr:`*r`, when :cpp:expr:`r` is dereferenceable. - :cpp:expr:`++r`, with return type :cpp:expr:`It&`, when :cpp:expr:`r` is incrementable.
This will render as follows:
Options¶
Some directives support options:
:noindex:
, see Basic Markup.:tparam-line-spec:
, for templated declarations. If specified, each template parameter will be rendered on a separate line.
Anonymous Entities¶
C++ supposrts anonymous namespaces, classes, enums, and unions.
For the sake of documentation they must be given some name that starts with @
,
e.g., @42
or @data
.
These names can also be used in cross-references and (type) expressions,
though nested symbols will be found even when omitted.
The @...
name will always be rendered as [anonymous] (possibly as a link).
Example:
.. cpp:class:: Data
.. cpp:union:: @data
.. cpp:var:: int a
.. cpp:var:: double b
Explicit ref: :cpp:var:`Data::@data::a`. Short-hand ref: :cpp:var:`Data::a`.
This will be rendered as:
-
class
Data
¶
Explicit ref: Data::@data::a
. Short-hand ref: Data::a
.
Constrained Templates¶
Warning
The support for concepts is experimental. It is based on the current draft standard and the Concepts Technical Specification. The features may change as they evolve.
Note
Sphinx does not currently support requires
clauses.
Placeholders¶
Declarations may use the name of a concept to introduce constrained template
parameters, or the keyword auto
to introduce unconstrained template
parameters:
.. cpp:function:: void f(auto &&arg)
A function template with a single unconstrained template parameter.
.. cpp:function:: void f(std::Iterator it)
A function template with a single template parameter, constrained by the
Iterator concept.
Template Introductions¶
Simple constrained function or class templates can be declared with a template introduction instead of a template parameter list:
.. cpp:function:: std::Iterator{It} void advance(It &it)
A function template with a template parameter constrained to be an
Iterator.
.. cpp:class:: std::LessThanComparable{T} MySortedContainer
A class template with a template parameter constrained to be
LessThanComparable.
They are rendered as follows.
-
std::Iterator{
It
}
voidadvance
(It &it)¶ A function template with a template parameter constrained to be an Iterator.
-
std::LessThanComparable{
T
}
classMySortedContainer
¶ A class template with a template parameter constrained to be LessThanComparable.
Note however that no checking is performed with respect to parameter
compatibility. E.g., Iterator{A, B, C}
will be accepted as an introduction
even though it would not be valid C++.
Inline Expressions and Tpes¶
-
:cpp:expr:
¶ -
:cpp:texpr:
¶ Insert a C++ expression or type either as inline code (
cpp:expr
) or inline text (cpp:texpr
). For example:.. cpp:var:: int a = 42 .. cpp:function:: int f(int i) An expression: :cpp:expr:`a * f(a)` (or as text: :cpp:texpr:`a * f(a)`). A type: :cpp:expr:`const MySortedContainer<int>&` (or as text :cpp:texpr:`const MySortedContainer<int>&`).
will be rendered as follows:
-
int
a
= 42¶
-
int
f
(int i)¶
An expression:
a * f(a)
(or as text: :cpp:texpr:`a * f(a)`).A type:
const MySortedContainer<int>&
(or as text :cpp:texpr:`const MySortedContainer<int>&`).-
int
Namespacing¶
Declarations in the C++ domain are as default placed in global scope. The
current scope can be changed using three namespace directives. They manage a
stack declarations where cpp:namespace
resets the stack and changes a given
scope.
The cpp:namespace-push
directive changes the scope to a given inner scope
of the current one.
The cpp:namespace-pop
directive undoes the most recent
cpp:namespace-push
directive.
-
.. cpp:namespace::
scope specification
¶ Changes the current scope for the subsequent objects to the given scope, and resets the namespace directive stack. Note that the namespace does not need to correspond to C++ namespaces, but can end in names of classes, e.g.,:
.. cpp:namespace:: Namespace1::Namespace2::SomeClass::AnInnerClass
All subsequent objects will be defined as if their name were declared with the scope prepended. The subsequent cross-references will be searched for starting in the current scope.
Using
NULL
,0
, ornullptr
as the scope will change to global scope.A namespace declaration can also be templated, e.g.,:
.. cpp:class:: template<typename T> \ std::vector .. cpp:namespace:: template<typename T> std::vector .. cpp:function:: std::size_t size() const
declares
size
as a member function of the class templatestd::vector
. Equivalently this could have been declared using:.. cpp:class:: template<typename T> \ std::vector .. cpp:function:: std::size_t size() const
or:
.. cpp:class:: template<typename T> \ std::vector
-
.. cpp:namespace-push::
scope specification
¶ Change the scope relatively to the current scope. For example, after:
.. cpp:namespace:: A::B .. cpp:namespace-push:: C::D
the current scope will be
A::B::C::D
.
-
.. cpp:namespace-pop::
Undo the previous
cpp:namespace-push
directive (not just pop a scope). For example, after:.. cpp:namespace:: A::B .. cpp:namespace-push:: C::D .. cpp:namespace-pop::
the current scope will be
A::B
(notA::B::C
).If no previous
cpp:namespace-push
directive has been used, but only acpp:namespace
directive, then the current scope will be reset to global scope. That is,.. cpp:namespace:: A::B
is equivalent to:.. cpp:namespace:: nullptr .. cpp:namespace-push:: A::B
Info field lists¶
The C++ directives support the following info fields (see also Info field lists):
- param, parameter, arg, argument: Description of a parameter.
- tparam: Description of a template parameter.
- returns, return: Description of a return value.
- throws, throw, exception: Description of a possibly thrown exception.
Cross-referencing¶
These roles link to the given declaration types:
-
:cpp:any:
¶ -
:cpp:class:
¶ -
:cpp:func:
¶ -
:cpp:member:
¶ -
:cpp:var:
¶ -
:cpp:type:
¶ -
:cpp:concept:
¶ -
:cpp:enum:
¶ -
:cpp:enumerator:
¶ Reference a C++ declaration by name (see below for details). The name must be properly qualified relative to the position of the link.
Note on References with Templates Parameters/Arguments
These roles follow the Sphinx Cross-referencing syntax rules. This means care must be
taken when referencing a (partial) template specialization, e.g. if the link looks like
this: :cpp:class:`MyClass<int>`
.
This is interpreted as a link to int
with a title of MyClass
.
In this case, escape the opening angle bracket with a backslash,
like this: :cpp:class:`MyClass\<int>`
.
When a custom title is not needed it may be useful to use the roles for inline expressions,
cpp:expr
and cpp:texpr
, where angle brackets do not need escaping.
Declarations without template parameters and template arguments¶
For linking to non-templated declarations the name must be a nested name, e.g.,
f
or MyClass::f
.
Overloaded (member) functions¶
When a (member) function is referenced using just its name, the reference
will point to an arbitrary matching overload.
The cpp:any
and cpp:func
roles will an alternative
format, which simply is a complete function declaration.
This will resolve to the exact matching overload.
As example, consider the following class declaration:
References using the cpp:func
role:
- Arbitrary overload:
C::f
,C::f()
- Also arbitrary overload:
C::f()
,C::f()
- Specific overload:
void C::f()
,void C::f()
- Specific overload:
void C::f(int)
,void C::f(int)()
- Specific overload:
void C::f(double)
,void C::f(double)()
- Specific overload:
void C::f(double) const
,void C::f(double) const()
Note that the add_function_parentheses
configuration variable
does not influence specific overload references.
Templated declarations¶
Assume the following declarations.
In general the reference must include the template parameter declarations, and template arguments for the prefix of qualified names. For example:
template\<typename TOuter> Wrapper::Outer
(template<typename TOuter> Wrapper::Outer
)template\<typename TOuter> template\<typename TInner> Wrapper::Outer<TOuter>::Inner
(template<typename TOuter> template<typename TInner> Wrapper::Outer<TOuter>::Inner
)
Currently the lookup only succeed if the template parameter identifiers are equal strings.
That is, template\<typename UOuter> Wrapper::Outer
will not work.
As a shorthand notation, if a template parameter list is omitted, then the lookup will assume either a primary template or a non-template, but not a partial template specialisation. This means the following references work as well:
Wrapper::Outer
(Wrapper::Outer
)Wrapper::Outer::Inner
(Wrapper::Outer::Inner
)template\<typename TInner> Wrapper::Outer::Inner
(template<typename TInner> Wrapper::Outer::Inner
)
(Full) Template Specialisations¶
Assume the following declarations.
In general the reference must include a template parameter list for each
template argument list. The full specialisation above can therefore be
referenced with template\<> Outer\<int>
(template<>
Outer<int>
) and template\<> template\<> Outer\<int>::Inner\<bool>
(template<> template<> Outer<int>::Inner<bool>
). As a
shorthand the empty template parameter list can be omitted, e.g.,
Outer\<int>
(Outer<int>
) and Outer\<int>::Inner\<bool>
(Outer<int>::Inner<bool>
).
Partial Template Specialisations¶
Assume the following declaration.
References to partial specialisations must always include the template
parameter lists, e.g., template\<typename T> Outer\<T*>
(template<typename T> Outer<T*>
). Currently the lookup only
succeed if the template parameter identifiers are equal strings.
Configuration Variables¶
The Standard Domain¶
The so-called “standard” domain collects all markup that doesn’t warrant a domain of its own. Its directives and roles are not prefixed with a domain name.
The standard domain is also where custom object descriptions, added using the
add_object_type()
API, are placed.
There is a set of directives allowing documenting command-line programs:
-
.. option::
name args, name args, ...
¶ Describes a command line argument or switch. Option argument names should be enclosed in angle brackets. Examples:
.. option:: dest_dir Destination directory. .. option:: -m <module>, --module <module> Run a module as a script.
The directive will create cross-reference targets for the given options, referencable by
option
(in the example case, you’d use something like:option:`dest_dir`
,:option:`-m`
, or:option:`--module`
).cmdoption
directive is a deprecated alias for theoption
directive.
-
.. envvar::
name
¶ Describes an environment variable that the documented code or program uses or defines. Referencable by
envvar
.
-
.. program::
name
¶ Like
py:currentmodule
, this directive produces no output. Instead, it serves to notify Sphinx that all followingoption
directives document options for the program called name.If you use
program
, you have to qualify the references in youroption
roles by the program name, so if you have the following situation.. program:: rm .. option:: -r Work recursively. .. program:: svn .. option:: -r revision Specify the revision to work upon.
then
:option:`rm -r`
would refer to the first option, while:option:`svn -r`
would refer to the second one.The program name may contain spaces (in case you want to document subcommands like
svn add
andsvn commit
separately).New in version 0.5.
There is also a very generic object description directive, which is not tied to any domain:
The JavaScript Domain¶
The JavaScript domain (name js) provides the following directives:
-
.. js:module::
name
¶ This directive sets the module name for object declarations that follow after. The module name is used in the global module index and in cross references. This directive does not create an object heading like
py:class
would, for example.By default, this directive will create a linkable entity and will cause an entry in the global module index, unless the
noindex
option is specified. If this option is specified, the directive will only update the current module name.To clear the current module, set the module name to
null
orNone
New in version 1.6.
-
.. js:function::
name(signature)
¶ Describes a JavaScript function or method. If you want to describe arguments as optional use square brackets as documented for Python signatures.
You can use fields to give more details about arguments and their expected types, errors which may be thrown by the function, and the value being returned:
.. js:function:: $.getJSON(href, callback[, errback]) :param string href: An URI to the location of the resource. :param callback: Gets called with the object. :param errback: Gets called in case the request fails. And a lot of other text so we need multiple lines. :throws SomeError: For whatever reason in that case. :returns: Something.
This is rendered as:
-
$.
getJSON
(href, callback[, errback])¶ Arguments: - href (string) – An URI to the location of the resource.
- callback – Gets called with the object.
- errback – Gets called in case the request fails. And a lot of other text so we need multiple lines.
Throws: SomeError – For whatever reason in that case.
Returns: Something.
-
-
.. js:method::
name(signature)
¶ This directive is an alias for
js:function
, however it describes a function that is implemented as a method on a class object.New in version 1.6.
-
.. js:class::
name
¶ Describes a constructor that creates an object. This is basically like a function but will show up with a class prefix:
.. js:class:: MyAnimal(name[, age]) :param string name: The name of the animal :param number age: an optional age for the animal
This is rendered as:
-
class
MyAnimal
(name[, age])¶ Arguments: - name (string) – The name of the animal
- age (number) – an optional age for the animal
-
class
-
.. js:data::
name
¶ Describes a global variable or constant.
-
.. js:attribute::
object.name
¶ Describes the attribute name of object.
These roles are provided to refer to the described objects:
The reStructuredText domain¶
The reStructuredText domain (name rst) provides the following directives:
-
.. rst:directive::
name
¶ Describes a reST directive. The name can be a single directive name or actual directive syntax (.. prefix and :: suffix) with arguments that will be rendered differently. For example:
.. rst:directive:: foo Foo description. .. rst:directive:: .. bar:: baz Bar description.
will be rendered as:
-
.. rst:role::
name
¶ Describes a reST role. For example:
.. rst:role:: foo Foo description.
will be rendered as:
-
:foo:
¶ Foo description.
-
These roles are provided to refer to the described objects:
The Math Domain¶
The math domain (name math) provides the following roles:
.. rst:role:: math:numref
Role for cross-referencing equations defined by
math
directive via their label. Example:.. math:: e^{i\pi} + 1 = 0 :label: euler Euler's identity, equation :math:numref:`euler`, was elected one of the most beautiful mathematical formulas.New in version 1.8.
Markdown¶
Markdown is a lightweight markup language with a simplistic plain text formatting syntax. It exists in many syntactically different flavors. To support Markdown-based documentation, Sphinx can use recommonmark. recommonmark is a Docutils bridge to CommonMark-py, a Python package for parsing the CommonMark Markdown flavor.
Configuration¶
To configure your Sphinx project for Markdown support, proceed as follows:
Install recommonmark:
pip install recommonmark
Add the Markdown parser to the
source_parsers
configuration variable in your Sphinx configuration file:source_parsers = { '.md': 'recommonmark.parser.CommonMarkParser', }
You can replace
.md
with a filename extension of your choice.Add the Markdown filename extension to the
source_suffix
configuration variable:source_suffix = ['.rst', '.md']
You can further configure recommonmark to allow custom syntax that standard CommonMark doesn’t support. Read more in the recommonmark documentation.
Configuration¶
The configuration directory must contain a file named conf.py
.
This file (containing Python code) is called the “build configuration file”
and contains (almost) all configuration needed to customize Sphinx input
and output behavior.
An optional file docutils.conf can be added to the configuration directory to adjust Docutils configuration if not otherwise overridden or set by Sphinx.
The configuration file is executed as Python code at build time (using
execfile()
, and with the current directory set to its containing
directory), and therefore can execute arbitrarily complex code. Sphinx then
reads simple names from the file’s namespace as its configuration.
Important points to note:
- If not otherwise documented, values must be strings, and their default is the empty string.
- The term “fully-qualified name” refers to a string that names an importable
Python object inside a module; for example, the FQN
"sphinx.builders.Builder"
means theBuilder
class in thesphinx.builders
module. - Remember that document names use
/
as the path separator and don’t contain the file name extension. - Since
conf.py
is read as a Python file, the usual rules apply for encodings and Unicode support: declare the encoding using an encoding cookie (a comment like# -*- coding: utf-8 -*-
) and use Unicode string literals when you include non-ASCII characters in configuration values. - The contents of the config namespace are pickled (so that Sphinx can find out
when configuration changes), so it may not contain unpickleable values –
delete them from the namespace with
del
if appropriate. Modules are removed automatically, so you don’t need todel
your imports after use.
General configuration¶
-
extensions
¶ A list of strings that are module names of extensions. These can be extensions coming with Sphinx (named
sphinx.ext.*
) or custom ones.Note that you can extend
sys.path
within the conf file if your extensions live in another directory – but make sure you use absolute paths. If your extension path is relative to the configuration directory, useos.path.abspath()
like so:import sys, os sys.path.append(os.path.abspath('sphinxext')) extensions = ['extname']
That way, you can load an extension called
extname
from the subdirectorysphinxext
.The configuration file itself can be an extension; for that, you only need to provide a
setup()
function in it.
-
source_suffix
¶ The file extensions of source files. Sphinx considers the files with this suffix as sources. This value can be a dictionary mapping file extensions to file types. For example:
source_suffix = { '.rst': 'restructuredtext', '.txt': 'restructuredtext', '.md': 'markdown', }
By default, Sphinx only supports
'restrcturedtext'
file type. You can add a new file type using source parser extensions. Please read a document of the extension to know what file type the extension supports.This also allows a list of file extensions. In that case, Sphinx conciders that all they are
'restructuredtext'
. Default is{'.rst': 'restructuredtext'}
.Note
file extensions have to start with dot (like
.rst
).Changed in version 1.3: Can now be a list of extensions.
Changed in version 1.8: Support file type mapping
-
source_encoding
¶ The encoding of all reST source files. The recommended encoding, and the default value, is
'utf-8-sig'
.New in version 0.5: Previously, Sphinx accepted only UTF-8 encoded sources.
-
source_parsers
¶ If given, a dictionary of parser classes for different source suffices. The keys are the suffix, the values can be either a class or a string giving a fully-qualified name of a parser class. The parser class can be either
docutils.parsers.Parser
orsphinx.parsers.Parser
. Files with a suffix that is not in the dictionary will be parsed with the default reStructuredText parser.For example:
source_parsers = {'.md': 'recommonmark.parser.CommonMarkParser'}
Note
Refer to Markdown for more information on using Markdown with Sphinx.
New in version 1.3.
Deprecated since version 1.8: Now Sphinx provides an API
Sphinx.add_source_parser()
to register a source parser. Please use it instead.
-
master_doc
¶ The document name of the “master” document, that is, the document that contains the root
toctree
directive. Default is'contents'
.
-
exclude_patterns
¶ A list of glob-style patterns that should be excluded when looking for source files. [1] They are matched against the source file names relative to the source directory, using slashes as directory separators on all platforms.
Example patterns:
'library/xml.rst'
– ignores thelibrary/xml.rst
file (replaces entry inunused_docs
)'library/xml'
– ignores thelibrary/xml
directory'library/xml*'
– ignores all files and directories starting withlibrary/xml
'**/.svn'
– ignores all.svn
directories
exclude_patterns
is also consulted when looking for static files inhtml_static_path
andhtml_extra_path
.New in version 1.0.
-
templates_path
¶ A list of paths that contain extra templates (or templates that overwrite builtin/theme-specific templates). Relative paths are taken as relative to the configuration directory.
Changed in version 1.3: As these files are not meant to be built, they are automatically added to
exclude_patterns
.
-
template_bridge
¶ A string with the fully-qualified name of a callable (or simply a class) that returns an instance of
TemplateBridge
. This instance is then used to render HTML documents, and possibly the output of other builders (currently the changes builder). (Note that the template bridge must be made theme-aware if HTML themes are to be used.)
-
rst_epilog
¶ A string of reStructuredText that will be included at the end of every source file that is read. This is a possible place to add substitutions that should be available in every file (another being
rst_prolog
). An example:rst_epilog = """ .. |psf| replace:: Python Software Foundation """
New in version 0.6.
-
rst_prolog
¶ A string of reStructuredText that will be included at the beginning of every source file that is read. This is a possible place to add substitutions that should be available in every file (another being
rst_epilog
). An example:rst_prolog = """ .. |psf| replace:: Python Software Foundation """
New in version 1.0.
-
primary_domain
¶ The name of the default domain. Can also be
None
to disable a default domain. The default is'py'
. Those objects in other domains (whether the domain name is given explicitly, or selected by adefault-domain
directive) will have the domain name explicitly prepended when named (e.g., when the default domain is C, Python functions will be named “Python function”, not just “function”).New in version 1.0.
-
default_role
¶ The name of a reST role (builtin or Sphinx extension) to use as the default role, that is, for text marked up
`like this`
. This can be set to'py:obj'
to make`filter`
a cross-reference to the Python function “filter”. The default isNone
, which doesn’t reassign the default role.The default role can always be set within individual documents using the standard reST
default-role
directive.New in version 0.4.
-
keep_warnings
¶ If true, keep warnings as “system message” paragraphs in the built documents. Regardless of this setting, warnings are always written to the standard error stream when
sphinx-build
is run.The default is
False
, the pre-0.5 behavior was to always keep them.New in version 0.5.
-
suppress_warnings
¶ A list of warning types to suppress arbitrary warning messages.
Sphinx supports following warning types:
- app.add_node
- app.add_directive
- app.add_role
- app.add_generic_role
- app.add_source_parser
- download.not_readable
- image.not_readable
- ref.term
- ref.ref
- ref.numref
- ref.keyword
- ref.option
- ref.citation
- ref.footnote
- ref.doc
- ref.python
- misc.highlighting_failure
- toc.secnum
- epub.unknown_project_files
You can choose from these types.
Now, this option should be considered experimental.
New in version 1.4.
Changed in version 1.5: Added
misc.highlighting_failure
Changed in version 1.5.1: Added
epub.unknown_project_files
Changed in version 1.6: Added
ref.footnote
-
needs_sphinx
¶ If set to a
major.minor
version string like'1.1'
, Sphinx will compare it with its version and refuse to build if it is too old. Default is no requirement.New in version 1.0.
Changed in version 1.4: also accepts micro version string
-
needs_extensions
¶ This value can be a dictionary specifying version requirements for extensions in
extensions
, e.g.needs_extensions = {'sphinxcontrib.something': '1.5'}
. The version strings should be in the formmajor.minor
. Requirements do not have to be specified for all extensions, only for those you want to check.This requires that the extension specifies its version to Sphinx (see Developing extensions for Sphinx for how to do that).
New in version 1.3.
-
manpages_url
¶ A URL to cross-reference
manpage
directives. If this is defined tohttps://manpages.debian.org/{path}
, the:manpage:`man(1)`
role will link to <https://manpages.debian.org/man(1)>. The patterns available are:page
- the manual page (man
)section
- the manual section (1
)path
- the original manual page and section specified (man(1)
)
This also supports manpages specified as
man.1
.Note
This currently affects only HTML writers but could be expanded in the future.
New in version 1.7.
-
nitpicky
¶ If true, Sphinx will warn about all references where the target cannot be found. Default is
False
. You can activate this mode temporarily using the-n
command-line switch.New in version 1.0.
-
nitpick_ignore
¶ A list of
(type, target)
tuples (by default empty) that should be ignored when generating warnings in “nitpicky mode”. Note thattype
should include the domain name if present. Example entries would be('py:func', 'int')
or('envvar', 'LD_LIBRARY_PATH')
.New in version 1.1.
-
numfig
¶ If true, figures, tables and code-blocks are automatically numbered if they have a caption. The
numref
role is enabled. Obeyed so far only by HTML and LaTeX builders. Default isFalse
.Note
The LaTeX builder always assigns numbers whether this option is enabled or not.
New in version 1.3.
-
numfig_format
¶ A dictionary mapping
'figure'
,'table'
,'code-block'
and'section'
to strings that are used for format of figure numbers. As a special character,%s
will be replaced to figure number.Default is to use
'Fig. %s'
for'figure'
,'Table %s'
for'table'
,'Listing %s'
for'code-block'
and'Section'
for'section'
.New in version 1.3.
-
numfig_secnum_depth
¶ - if set to
0
, figures, tables and code-blocks are continuously numbered starting at1
. - if
1
(default) numbers will bex.1
,x.2
, … withx
the section number (top level sectioning; nox.
if no section). This naturally applies only if section numbering has been activated via the:numbered:
option of thetoctree
directive. 2
means that numbers will bex.y.1
,x.y.2
, … if located in a sub-section (but stillx.1
,x.2
, … if located directly under a section and1
,2
, … if not in any top level section.)- etc…
New in version 1.3.
Changed in version 1.7: The LaTeX builder obeys this setting (if
numfig
is set toTrue
).- if set to
-
smartquotes
¶ If true, the Docutils Smart Quotes transform, originally based on SmartyPants (limited to English) and currently applying to many languages, will be used to convert quotes and dashes to typographically correct entities. Default:
True
.New in version 1.6.6: It replaces deprecated
html_use_smartypants
. It applies by default to all builders exceptman
andtext
(seesmartquotes_excludes
.)A docutils.conf file located in the configuration directory (or a global
~/.docutils
file) is obeyed unconditionally if it deactivates smart quotes via the corresponding Docutils option. But if it activates them, thensmartquotes
does prevail.
-
smartquotes_action
¶ This string, for use with Docutils
0.14
or later, customizes the Smart Quotes transform. See the filesmartquotes.py
at the Docutils repository for details. The default'qDe'
educates normal quote characters"
,'
, em- and en-Dashes---
,--
, and ellipses...
.New in version 1.6.6.
-
smartquotes_excludes
¶ This is a
dict
whose default is:{'languages': ['ja'], 'builders': ['man', 'text']}
Each entry gives a sufficient condition to ignore the
smartquotes
setting and deactivate the Smart Quotes transform. Accepted keys are as above'builders'
or'languages'
. The values are lists.Note
Currently, in case of invocation of make with multiple targets, the first target name is the only one which is tested against the
'builders'
entry and it decides for all. Also, amake text
followingmake html
needs to be issued in the formmake text O="-E"
to force re-parsing of source files, as the cached ones are already transformed. On the other hand the issue does not arise with direct usage of sphinx-build as it caches (in its default usage) the parsed source files in per builder locations.New in version 1.6.6.
-
tls_verify
¶ If true, Sphinx verifies server certifications. Default is
True
.New in version 1.5.
-
tls_cacerts
¶ A path to a certification file of CA or a path to directory which contains the certificates. This also allows a dictionary mapping hostname to the path to certificate file. The certificates are used to verify server certifications.
New in version 1.5.
Project information¶
-
project
¶ The documented project’s name.
The author name(s) of the document. The default value is
'unknown'
.
-
copyright
¶ A copyright statement in the style
'2008, Author Name'
.
-
version
¶ The major project version, used as the replacement for
|version|
. For example, for the Python documentation, this may be something like2.6
.
-
release
¶ The full project version, used as the replacement for
|release|
and e.g. in the HTML templates. For example, for the Python documentation, this may be something like2.6.0rc1
.If you don’t need the separation provided between
version
andrelease
, just set them both to the same value.
-
today
¶ -
today_fmt
¶ These values determine how to format the current date, used as the replacement for
|today|
.- If you set
today
to a non-empty value, it is used. - Otherwise, the current time is formatted using
time.strftime()
and the format given intoday_fmt
.
The default is now
today
and atoday_fmt
of'%B %d, %Y'
(or, if translation is enabled withlanguage
, an equivalent format for the selected locale).- If you set
-
highlight_language
¶ The default language to highlight source code in. The default is
'python3'
. The value should be a valid Pygments lexer name, see Showing code examples for more details.New in version 0.5.
Changed in version 1.4: The default is now
'default'
. It is similar to'python3'
; it is mostly a superset of'python'
but it fallbacks to'none'
without warning if failed.'python3'
and other languages will emit warning if failed. If you prefer Python 2 only highlighting, you can set it back to'python'
.
-
highlight_options
¶ A dictionary of options that modify how the lexer specified by
highlight_language
generates highlighted source code. These are lexer-specific; for the options understood by each, see the Pygments documentation.New in version 1.3.
-
pygments_style
¶ The style name to use for Pygments highlighting of source code. If not set, either the theme’s default style or
'sphinx'
is selected for HTML output.Changed in version 0.3: If the value is a fully-qualified name of a custom Pygments style class, this is then used as custom style.
-
add_function_parentheses
¶ A boolean that decides whether parentheses are appended to function and method role text (e.g. the content of
:func:`input`
) to signify that the name is callable. Default isTrue
.
-
add_module_names
¶ A boolean that decides whether module names are prepended to all object names (for object types where a “module” of some kind is defined), e.g. for
py:function
directives. Default isTrue
.
A boolean that decides whether
codeauthor
andsectionauthor
directives produce any output in the built files.
-
modindex_common_prefix
¶ A list of prefixes that are ignored for sorting the Python module index (e.g., if this is set to
['foo.']
, thenfoo.bar
is shown underB
, notF
). This can be handy if you document a project that consists of a single package. Works only for the HTML builder currently. Default is[]
.New in version 0.6.
-
trim_footnote_reference_space
¶ Trim spaces before footnote references that are necessary for the reST parser to recognize the footnote, but do not look too nice in the output.
New in version 0.6.
-
trim_doctest_flags
¶ If true, doctest flags (comments looking like
# doctest: FLAG, ...
) at the ends of lines and<BLANKLINE>
markers are removed for all code blocks showing interactive Python sessions (i.e. doctests). Default isTrue
. See the extensiondoctest
for more possibilities of including doctests.New in version 1.0.
Changed in version 1.1: Now also removes
<BLANKLINE>
.
Options for internationalization¶
These options influence Sphinx’s Native Language Support. See the documentation on Internationalization for details.
-
language
¶ The code for the language the docs are written in. Any text automatically generated by Sphinx will be in that language. Also, Sphinx will try to substitute individual paragraphs from your documents with the translation sets obtained from
locale_dirs
. Sphinx will search language-specific figures named by figure_language_filename and substitute them for original figures. In the LaTeX builder, a suitable language will be selected as an option for the Babel package. Default isNone
, which means that no translation will be done.New in version 0.5.
Changed in version 1.4: Support figure substitution
Currently supported languages by Sphinx are:
bn
– Bengalica
– Catalancs
– Czechda
– Danishde
– Germanen
– Englishes
– Spanishet
– Estonianeu
– Basquefa
– Iranianfi
– Finnishfr
– Frenchhe
– Hebrewhr
– Croatianhu
– Hungarianid
– Indonesianit
– Italianja
– Japaneseko
– Koreanlt
– Lithuanianlv
– Latvianmk
– Macedoniannb_NO
– Norwegian Bokmalne
– Nepalinl
– Dutchpl
– Polishpt_BR
– Brazilian Portuguesept_PT
– European Portugueseru
– Russiansi
– Sinhalask
– Slovaksl
– Sloveniansv
– Swedishtr
– Turkishuk_UA
– Ukrainianvi
– Vietnamesezh_CN
– Simplified Chinesezh_TW
– Traditional Chinese
-
locale_dirs
¶ New in version 0.5.
Directories in which to search for additional message catalogs (see
language
), relative to the source directory. The directories on this path are searched by the standardgettext
module.Internal messages are fetched from a text domain of
sphinx
; so if you add the directory./locale
to this setting, the message catalogs (compiled from.po
format using msgfmt) must be in./locale/language/LC_MESSAGES/sphinx.mo
. The text domain of individual documents depends ongettext_compact
.The default is
['locales']
.Changed in version 1.5: Use
locales
directory as a default value
-
gettext_compact
¶ New in version 1.1.
If true, a document’s text domain is its docname if it is a top-level project file and its very base directory otherwise.
By default, the document
markup/code.rst
ends up in themarkup
text domain. With this option set toFalse
, it ismarkup/code
.
-
gettext_uuid
¶ If true, Sphinx generates uuid information for version tracking in message catalogs. It is used for:
- Add uid line for each msgids in .pot files.
- Calculate similarity between new msgids and previously saved old msgids. This calculation takes a long time.
If you want to accelerate the calculation, you can use
python-levenshtein
3rd-party package written in C by using pip install python-levenshtein.The default is
False
.New in version 1.3.
-
gettext_location
¶ If true, Sphinx generates location information for messages in message catalogs.
The default is
True
.New in version 1.3.
-
gettext_auto_build
¶ If true, Sphinx builds mo file for each translation catalog files.
The default is
True
.New in version 1.3.
-
gettext_additional_targets
¶ To specify names to enable gettext extracting and translation applying for i18n additionally. You can specify below names:
Index: index terms Literal-block: literal blocks: ::
andcode-block
.Doctest-block: doctest block Raw: raw content Image: image/figure uri and alt For example:
gettext_additional_targets = ['literal-block', 'image']
.The default is
[]
.New in version 1.3.
-
figure_language_filename
¶ The filename format for language-specific figures. The default value is
{root}.{language}{ext}
. It will be expanded todirname/filename.en.png
from.. image:: dirname/filename.png
. The available format tokens are:{root}
- the filename, including any path component, without the file extension, e.g.dirname/filename
{path}
- the directory path component of the filename, with a trailing slash if non-empty, e.g.dirname/
{basename}
- the filename without the directory path or file extension components, e.g.filename
{ext}
- the file extension, e.g..png
{language}
- the translation language, e.g.en
For example, setting this to
{path}{language}/{basename}{ext}
will expand todirname/en/filename.png
instead.New in version 1.4.
Changed in version 1.5: Added
{path}
and{basename}
tokens.
Options for Math¶
These options influence Math notations.
-
math_number_all
¶ Set this option to
True
if you want all displayed math to be numbered. The default isFalse
.
-
math_eqref_format
¶ A string that are used for format of label of references to equations. As a special character,
{number}
will be replaced to equaition number.Example:
'Eq.{number}'
is rendered asEq.10
-
math_numfig
¶ If
True
, displayed math equations are numbered across pages whennumfig
is enabled. Thenumfig_secnum_depth
setting is respected. Theeq
, notnumref
, role must be used to reference equation numbers. Default isTrue
.New in version 1.7.
Options for HTML output¶
These options influence HTML as well as HTML Help output, and other builders that use Sphinx’s HTMLWriter class.
-
html_theme
¶ The “theme” that the HTML output should use. See the section about theming. The default is
'alabaster'
.New in version 0.6.
-
html_theme_options
¶ A dictionary of options that influence the look and feel of the selected theme. These are theme-specific. For the options understood by the builtin themes, see this section.
New in version 0.6.
-
html_theme_path
¶ A list of paths that contain custom themes, either as subdirectories or as zip files. Relative paths are taken as relative to the configuration directory.
New in version 0.6.
-
html_style
¶ The style sheet to use for HTML pages. A file of that name must exist either in Sphinx’s
static/
path, or in one of the custom paths given inhtml_static_path
. Default is the stylesheet given by the selected theme. If you only want to add or override a few things compared to the theme’s stylesheet, use CSS@import
to import the theme’s stylesheet.
-
html_title
¶ The “title” for HTML documentation generated with Sphinx’s own templates. This is appended to the
<title>
tag of individual pages, and used in the navigation bar as the “topmost” element. It defaults to'<project> v<revision> documentation'
.
-
html_short_title
¶ A shorter “title” for the HTML docs. This is used in for links in the header and in the HTML Help docs. If not given, it defaults to the value of
html_title
.New in version 0.4.
-
html_baseurl
¶ The URL which points to the root of the HTML documentation. It is used to indicate the location of document like
canonical_url
.
-
html_context
¶ A dictionary of values to pass into the template engine’s context for all pages. Single values can also be put in this dictionary using the
-A
command-line option ofsphinx-build
.New in version 0.5.
-
html_logo
¶ If given, this must be the name of an image file (path relative to the configuration directory) that is the logo of the docs. It is placed at the top of the sidebar; its width should therefore not exceed 200 pixels. Default:
None
.New in version 0.4.1: The image file will be copied to the
_static
directory of the output HTML, but only if the file does not already exist there.
-
html_favicon
¶ If given, this must be the name of an image file (path relative to the configuration directory) that is the favicon of the docs. Modern browsers use this as the icon for tabs, windows and bookmarks. It should be a Windows-style icon file (
.ico
), which is 16x16 or 32x32 pixels large. Default:None
.New in version 0.4: The image file will be copied to the
_static
directory of the output HTML, but only if the file does not already exist there.
-
html_css_files
¶ A list of CSS files. The entry must be a filename string or a tuple containing the filename string and the attributes dictionary. The filename must be relative to the
html_static_path
, or a full URI with scheme likehttp://example.org/style.css
. The attributes is used for attributes of<link>
tag. It defaults to an empty list.Example:
html_css_files = ['custom.css' 'https://example.com/css/custom.css', ('print.css', {'media': 'print'})]
New in version 1.8.
-
html_js_files
¶ A list of JavaScript filename. The entry must be a filename string or a tuple containing the filename string and the attributes dictionary. The filename must be relative to the
html_static_path
, or a full URI with scheme likehttp://example.org/script.js
. The attributes is used for attributes of<script>
tag. It defaults to an empty list.Example:
html_js_files = ['script.js', 'https://example.com/scripts/custom.js', ('custom.js', {'async': 'async'})]
New in version 1.8.
-
html_static_path
¶ A list of paths that contain custom static files (such as style sheets or script files). Relative paths are taken as relative to the configuration directory. They are copied to the output’s
_static
directory after the theme’s static files, so a file nameddefault.css
will overwrite the theme’sdefault.css
.As these files are not meant to be built, they are automatically excluded from source files.
Note
For security reasons, dotfiles under
html_static_path
will not be copied. If you would like to copy them intentionally, please add each filepath to this setting:html_static_path = ['_static', '_static/.htaccess']
Another way to do that, you can also use
html_extra_path
. It allows to copy dotfiles under the directories.Changed in version 0.4: The paths in
html_static_path
can now contain subdirectories.Changed in version 1.0: The entries in
html_static_path
can now be single files.Changed in version 1.8: The files under
html_static_path
are excluded from source files.
-
html_extra_path
¶ A list of paths that contain extra files not directly related to the documentation, such as
robots.txt
or.htaccess
. Relative paths are taken as relative to the configuration directory. They are copied to the output directory. They will overwrite any existing file of the same name.As these files are not meant to be built, they are automatically excluded from source files.
New in version 1.2.
Changed in version 1.4: The dotfiles in the extra directory will be copied to the output directory. And it refers
exclude_patterns
on copying extra files and directories, and ignores if path matches to patterns.
-
html_last_updated_fmt
¶ If this is not None, a ‘Last updated on:’ timestamp is inserted at every page bottom, using the given
strftime()
format. The empty string is equivalent to'%b %d, %Y'
(or a locale-dependent equivalent).
-
html_use_smartypants
¶ If true, quotes and dashes are converted to typographically correct entities. Default:
True
.Deprecated since version 1.6: To disable smart quotes, use rather
smartquotes
.
-
html_add_permalinks
¶ Sphinx will add “permalinks” for each heading and description environment as paragraph signs that become visible when the mouse hovers over them.
This value determines the text for the permalink; it defaults to
"¶"
. Set it toNone
or the empty string to disable permalinks.New in version 0.6: Previously, this was always activated.
Changed in version 1.1: This can now be a string to select the actual text of the link. Previously, only boolean values were accepted.
Custom sidebar templates, must be a dictionary that maps document names to template names.
The keys can contain glob-style patterns [1], in which case all matching documents will get the specified sidebars. (A warning is emitted when a more than one glob-style pattern matches for any document.)
The values can be either lists or single strings.
If a value is a list, it specifies the complete list of sidebar templates to include. If all or some of the default sidebars are to be included, they must be put into this list as well.
The default sidebars (for documents that don’t match any pattern) are defined by theme itself. Builtin themes are using these templates by default:
['localtoc.html', 'relations.html', 'sourcelink.html', 'searchbox.html']
.If a value is a single string, it specifies a custom sidebar to be added between the
'sourcelink.html'
and'searchbox.html'
entries. This is for compatibility with Sphinx versions before 1.0.
Deprecated since version 1.7: a single string value for
html_sidebars
will be removed in 2.0Builtin sidebar templates that can be rendered are:
- localtoc.html – a fine-grained table of contents of the current document
- globaltoc.html – a coarse-grained table of contents for the whole documentation set, collapsed
- relations.html – two links to the previous and next documents
- sourcelink.html – a link to the source of the current document, if
enabled in
html_show_sourcelink
- searchbox.html – the “quick search” box
Example:
html_sidebars = { '**': ['globaltoc.html', 'sourcelink.html', 'searchbox.html'], 'using/windows': ['windowssidebar.html', 'searchbox.html'], }
This will render the custom template
windowssidebar.html
and the quick search box within the sidebar of the given document, and render the default sidebars for all other pages (except that the local TOC is replaced by the global TOC).New in version 1.0: The ability to use globbing keys and to specify multiple sidebars.
Note that this value only has no effect if the chosen theme does not possess a sidebar, like the builtin scrolls and haiku themes.
-
html_additional_pages
¶ Additional templates that should be rendered to HTML pages, must be a dictionary that maps document names to template names.
Example:
html_additional_pages = { 'download': 'customdownload.html', }
This will render the template
customdownload.html
as the pagedownload.html
.
-
html_domain_indices
¶ If true, generate domain-specific indices in addition to the general index. For e.g. the Python domain, this is the global module index. Default is
True
.This value can be a bool or a list of index names that should be generated. To find out the index name for a specific index, look at the HTML file name. For example, the Python module index has the name
'py-modindex'
.New in version 1.0.
-
html_use_index
¶ If true, add an index to the HTML documents. Default is
True
.New in version 0.4.
-
html_split_index
¶ If true, the index is generated twice: once as a single page with all the entries, and once as one page per starting letter. Default is
False
.New in version 0.4.
-
html_copy_source
¶ If true, the reST sources are included in the HTML build as
_sources/name
. The default isTrue
.Warning
If this config value is set to
False
, the JavaScript search function will only display the titles of matching documents, and no excerpt from the matching contents.
-
html_show_sourcelink
¶ If true (and
html_copy_source
is true as well), links to the reST sources will be added to the sidebar. The default isTrue
.New in version 0.6.
-
html_sourcelink_suffix
¶ Suffix to be appended to source links (see
html_show_sourcelink
), unless they have this suffix already. Default is'.txt'
.New in version 1.5.
-
html_use_opensearch
¶ If nonempty, an OpenSearch description file will be output, and all pages will contain a
<link>
tag referring to it. Since OpenSearch doesn’t support relative URLs for its search page location, the value of this option must be the base URL from which these documents are served (without trailing slash), e.g."https://docs.python.org"
. The default is''
.
-
html_file_suffix
¶ This is the file name suffix for generated HTML files. The default is
".html"
.New in version 0.4.
-
html_link_suffix
¶ Suffix for generated links to HTML files. The default is whatever
html_file_suffix
is set to; it can be set differently (e.g. to support different web server setups).New in version 0.6.
-
html_show_copyright
¶ If true, “(C) Copyright …” is shown in the HTML footer. Default is
True
.New in version 1.0.
-
html_show_sphinx
¶ If true, “Created using Sphinx” is shown in the HTML footer. Default is
True
.New in version 0.4.
-
html_output_encoding
¶ Encoding of HTML output files. Default is
'utf-8'
. Note that this encoding name must both be a valid Python encoding name and a valid HTMLcharset
value.New in version 1.0.
-
html_compact_lists
¶ If true, a list all whose items consist of a single paragraph and/or a sub-list all whose items etc… (recursive definition) will not use the
<p>
element for any of its items. This is standard docutils behavior. Default:True
.New in version 1.0.
-
html_secnumber_suffix
¶ Suffix for section numbers. Default:
". "
. Set to" "
to suppress the final dot on section numbers.New in version 1.0.
-
html_search_language
¶ Language to be used for generating the HTML full-text search index. This defaults to the global language selected with
language
. If there is no support for this language,"en"
is used which selects the English language.Support is present for these languages:
da
– Danishnl
– Dutchen
– Englishfi
– Finnishfr
– Frenchde
– Germanhu
– Hungarianit
– Italianja
– Japaneseno
– Norwegianpt
– Portuguesero
– Romanianru
– Russianes
– Spanishsv
– Swedishtr
– Turkishzh
– Chinese
New in version 1.1: With support for
en
andja
.Changed in version 1.3: Added additional languages.
-
html_search_options
¶ A dictionary with options for the search language support, empty by default. The meaning of these options depends on the language selected.
The English support has no options.
The Japanese support has these options:
Type: type is dotted module path string to specify Splitter implementation which should be derived from
sphinx.search.ja.BaseSplitter
. If not specified or None is specified,'sphinx.search.ja.DefaultSplitter'
will be used.You can choose from these modules:
‘sphinx.search.ja.DefaultSplitter’: TinySegmenter algorithm. This is default splitter. ‘sphinx.search.ja.MeCabSplitter’: MeCab binding. To use this splitter, ‘mecab’ python binding or dynamic link library (‘libmecab.so’ for linux, ‘libmecab.dll’ for windows) is required. ‘sphinx.search.ja.JanomeSplitter’: Janome binding. To use this splitter, Janome is required. Deprecated since version 1.6:
'mecab'
,'janome'
and'default'
is deprecated. To keep compatibility,'mecab'
,'janome'
and'default'
are also acceptable.Other option values depend on splitter value which you choose.
- Options for
'mecab'
: dic_enc: dic_enc option is the encoding for the MeCab algorithm. dict: dict option is the dictionary to use for the MeCab algorithm. lib: lib option is the library name for finding the MeCab library via ctypes if the Python binding is not installed. For example:
html_search_options = { 'type': 'mecab', 'dic_enc': 'utf-8', 'dict': '/path/to/mecab.dic', 'lib': '/path/to/libmecab.so', }
- Options for
'janome'
: user_dic: user_dic option is the user dictionary file path for Janome. user_dic_enc: user_dic_enc option is the encoding for the user dictionary file specified by user_dic
option. Default is ‘utf8’.
New in version 1.1.
Changed in version 1.4: html_search_options for Japanese is re-organized and any custom splitter can be used by type settings.
The Chinese support has these options:
dict
– thejieba
dictionary path if want to use custom dictionary.
- Options for
-
html_search_scorer
¶ The name of a JavaScript file (relative to the configuration directory) that implements a search results scorer. If empty, the default will be used.
New in version 1.2.
-
html_scaled_image_link
¶ If true, images itself links to the original image if it doesn’t have ‘target’ option or scale related options: ‘scale’, ‘width’, ‘height’. The default is
True
.New in version 1.3.
-
html_math_renderer
¶ The name of math_renderer extension for HTML output. The default is
'mathjax'
.New in version 1.8.
-
html_experimental_html5_writer
¶ Output is processed with HTML5 writer. This feature needs docutils 0.13 or newer. Default is
False
.New in version 1.6.
Options for Single HTML output¶
Custom sidebar templates, must be a dictionary that maps document names to template names. And it only allows a key named ‘index’. All other keys are ignored. For more information, refer to
html_sidebars
. By default, it is same ashtml_sidebars
.
Options for HTML help output¶
-
htmlhelp_basename
¶ Output file base name for HTML help builder. Default is
'pydoc'
.
Options for Apple Help output¶
New in version 1.3.
These options influence the Apple Help output. This builder derives from the HTML builder, so the HTML options also apply where appropriate.
Note
Apple Help output will only work on Mac OS X 10.6 and higher, as it requires the hiutil and codesign command line tools, neither of which are Open Source.
You can disable the use of these tools using
applehelp_disable_external_tools
, but the result will not be a
valid help book until the indexer is run over the .lproj
folders within
the bundle.
-
applehelp_bundle_id
¶ The bundle ID for the help book bundle.
Warning
You must set this value in order to generate Apple Help.
-
applehelp_dev_region
¶ The development region. Defaults to
'en-us'
, which is Apple’s recommended setting.
-
applehelp_bundle_version
¶ The bundle version (as a string). Defaults to
'1'
.
-
applehelp_icon
¶ The help bundle icon file, or
None
for no icon. According to Apple’s documentation, this should be a 16-by-16 pixel version of the application’s icon with a transparent background, saved as a PNG file.
-
applehelp_kb_product
¶ The product tag for use with
applehelp_kb_url
. Defaults to'<project>-<release>'
.
-
applehelp_kb_url
¶ The URL for your knowledgebase server, e.g.
https://example.com/kbsearch.py?p='product'&q='query'&l='lang'
. Help Viewer will replace the values'product'
,'query'
and'lang'
at runtime with the contents ofapplehelp_kb_product
, the text entered by the user in the search box and the user’s system language respectively.Defaults to
None
for no remote search.
-
applehelp_remote_url
¶ The URL for remote content. You can place a copy of your Help Book’s
Resources
folder at this location and Help Viewer will attempt to use it to fetch updated content.e.g. if you set it to
https://example.com/help/Foo/
and Help Viewer wants a copy ofindex.html
for an English speaking customer, it will look athttps://example.com/help/Foo/en.lproj/index.html
.Defaults to
None
for no remote content.
-
applehelp_index_anchors
¶ If
True
, tell the help indexer to index anchors in the generated HTML. This can be useful for jumping to a particular topic using theAHLookupAnchor
function or theopenHelpAnchor:inBook:
method in your code. It also allows you to usehelp:anchor
URLs; see the Apple documentation for more information on this topic.
-
applehelp_min_term_length
¶ Controls the minimum term length for the help indexer. Defaults to
None
, which means the default will be used.
-
applehelp_stopwords
¶ Either a language specification (to use the built-in stopwords), or the path to a stopwords plist, or
None
if you do not want to use stopwords. The default stopwords plist can be found at/usr/share/hiutil/Stopwords.plist
and contains, at time of writing, stopwords for the following languages:Language Code English en German de Spanish es French fr Swedish sv Hungarian hu Italian it Defaults to
language
, or if that is not set, toen
.
-
applehelp_locale
¶ Specifies the locale to generate help for. This is used to determine the name of the
.lproj
folder inside the Help Book’sResources
, and is passed to the help indexer.Defaults to
language
, or if that is not set, toen
.
-
applehelp_title
¶ Specifies the help book title. Defaults to
'<project> Help'
.
-
applehelp_codesign_identity
¶ Specifies the identity to use for code signing, or
None
if code signing is not to be performed.Defaults to the value of the environment variable
CODE_SIGN_IDENTITY
, which is set by Xcode for script build phases, orNone
if that variable is not set.
-
applehelp_codesign_flags
¶ A list of additional arguments to pass to codesign when signing the help book.
Defaults to a list based on the value of the environment variable
OTHER_CODE_SIGN_FLAGS
, which is set by Xcode for script build phases, or the empty list if that variable is not set.
-
applehelp_indexer_path
¶ The path to the hiutil program. Defaults to
'/usr/bin/hiutil'
.
-
applehelp_codesign_path
¶ The path to the codesign program. Defaults to
'/usr/bin/codesign'
.
-
applehelp_disable_external_tools
¶ If
True
, the builder will not run the indexer or the code signing tool, no matter what other settings are specified.This is mainly useful for testing, or where you want to run the Sphinx build on a non-Mac OS X platform and then complete the final steps on OS X for some reason.
Defaults to
False
.
Options for epub output¶
These options influence the epub output. As this builder derives from the HTML builder, the HTML options also apply where appropriate. The actual values for some of the options is not really important, they just have to be entered into the Dublin Core metadata.
-
epub_theme
¶ The HTML theme for the epub output. Since the default themes are not optimized for small screen space, using the same theme for HTML and epub output is usually not wise. This defaults to
'epub'
, a theme designed to save visual space.
-
epub_theme_options
¶ A dictionary of options that influence the look and feel of the selected theme. These are theme-specific. For the options understood by the builtin themes, see this section.
New in version 1.2.
-
epub_title
¶ The title of the document. It defaults to the
html_title
option but can be set independently for epub creation.
-
epub_description
¶ The description of the document. The default value is
'unknown'
.New in version 1.4.
Changed in version 1.5: Renamed from
epub3_description
The author of the document. This is put in the Dublin Core metadata. It defaults to the
author
option.
-
epub_contributor
¶ The name of a person, organization, etc. that played a secondary role in the creation of the content of an EPUB Publication. The default value is
'unknown'
.New in version 1.4.
Changed in version 1.5: Renamed from
epub3_contributor
-
epub_language
¶ The language of the document. This is put in the Dublin Core metadata. The default is the
language
option or'en'
if unset.
-
epub_publisher
¶ The publisher of the document. This is put in the Dublin Core metadata. You may use any sensible string, e.g. the project homepage. The defaults to the
author
option.
-
epub_copyright
¶ The copyright of the document. It defaults to the
copyright
option but can be set independently for epub creation.
-
epub_identifier
¶ An identifier for the document. This is put in the Dublin Core metadata. For published documents this is the ISBN number, but you can also use an alternative scheme, e.g. the project homepage. The default value is
'unknown'
.
-
epub_scheme
¶ The publication scheme for the
epub_identifier
. This is put in the Dublin Core metadata. For published books the scheme is'ISBN'
. If you use the project homepage,'URL'
seems reasonable. The default value is'unknown'
.
-
epub_uid
¶ A unique identifier for the document. This is put in the Dublin Core metadata. You may use a XML’s Name format string. You can’t use hyphen, period, numbers as a first character. The default value is
'unknown'
.
-
epub_cover
¶ The cover page information. This is a tuple containing the filenames of the cover image and the html template. The rendered html cover page is inserted as the first item in the spine in
content.opf
. If the template filename is empty, no html cover page is created. No cover at all is created if the tuple is empty. Examples:epub_cover = ('_static/cover.png', 'epub-cover.html') epub_cover = ('_static/cover.png', '') epub_cover = ()
The default value is
()
.New in version 1.1.
-
epub_css_files
¶ A list of CSS files. The entry must be a filename string or a tuple containing the filename string and the attributes dictionary. For more information, see
html_css_files
.New in version 1.8.
-
epub_guide
¶ Meta data for the guide element of
content.opf
. This is a sequence of tuples containing the type, the uri and the title of the optional guide information. See the OPF documentation at http://idpf.org/epub for details. If possible, default entries for the cover and toc types are automatically inserted. However, the types can be explicitly overwritten if the default entries are not appropriate. Example:epub_guide = (('cover', 'cover.html', u'Cover Page'),)
The default value is
()
.
-
epub_pre_files
¶ Additional files that should be inserted before the text generated by Sphinx. It is a list of tuples containing the file name and the title. If the title is empty, no entry is added to
toc.ncx
. Example:epub_pre_files = [ ('index.html', 'Welcome'), ]
The default value is
[]
.
-
epub_post_files
¶ Additional files that should be inserted after the text generated by Sphinx. It is a list of tuples containing the file name and the title. This option can be used to add an appendix. If the title is empty, no entry is added to
toc.ncx
. The default value is[]
.
-
epub_exclude_files
¶ A list of files that are generated/copied in the build directory but should not be included in the epub file. The default value is
[]
.
-
epub_tocdepth
¶ The depth of the table of contents in the file
toc.ncx
. It should be an integer greater than zero. The default value is 3. Note: A deeply nested table of contents may be difficult to navigate.
-
epub_tocdup
¶ This flag determines if a toc entry is inserted again at the beginning of its nested toc listing. This allows easier navigation to the top of a chapter, but can be confusing because it mixes entries of different depth in one list. The default value is
True
.
-
epub_tocscope
¶ This setting control the scope of the epub table of contents. The setting can have the following values:
'default'
– include all toc entries that are not hidden (default)'includehidden'
– include all toc entries
New in version 1.2.
-
epub_fix_images
¶ This flag determines if sphinx should try to fix image formats that are not supported by some epub readers. At the moment palette images with a small color table are upgraded. You need the Python Image Library (Pillow the successor of the PIL) installed to use this option. The default value is
False
because the automatic conversion may lose information.New in version 1.2.
-
epub_max_image_width
¶ This option specifies the maximum width of images. If it is set to a value greater than zero, images with a width larger than the given value are scaled accordingly. If it is zero, no scaling is performed. The default value is
0
. You need the Python Image Library (Pillow) installed to use this option.New in version 1.2.
-
epub_show_urls
¶ Control whether to display URL addresses. This is very useful for readers that have no other means to display the linked URL. The settings can have the following values:
'inline'
– display URLs inline in parentheses (default)'footnote'
– display URLs in footnotes'no'
– do not display URLs
The display of inline URLs can be customized by adding CSS rules for the class
link-target
.New in version 1.2.
-
epub_use_index
¶ If true, add an index to the epub document. It defaults to the
html_use_index
option but can be set independently for epub creation.New in version 1.2.
-
epub_writing_mode
¶ It specifies writing direction. It can accept
'horizontal'
(default) and'vertical'
epub_writing_mode
'horizontal'
'vertical'
writing-mode [2] horizontal-tb
vertical-rl
page progression left to right right to left iBook’s Scroll Theme support scroll-axis is vertical. scroll-axis is horizontal. [2] https://developer.mozilla.org/en-US/docs/Web/CSS/writing-mode
Options for LaTeX output¶
These options influence LaTeX output. Refer to LaTeX customization for more information.
-
latex_engine
¶ The LaTeX engine to build the docs. The setting can have the following values:
'pdflatex'
– PDFLaTeX (default)'xelatex'
– XeLaTeX'lualatex'
– LuaLaTeX'platex'
– pLaTeX (default iflanguage
is'ja'
)
PDFLaTeX’s support for Unicode characters covers those from the document language (the LaTeX
babel
andinputenc
packages map them to glyph slots in the document font, at various encodings allowing each only 256 characters; Sphinx uses by default (except for Cyrillic languages) thetimes
package), but stray characters from other scripts or special symbols may require adding extra LaTeX packages or macros to the LaTeX preamble.If your project uses such extra Unicode characters, switching the engine to XeLaTeX or LuaLaTeX and setting up the document to use an OpenType font with wide-enough glyph coverage is often easier than sticking with PDFLaTeX and trying to get it to work with the Unicode characters.
The
latex_elements
'fontpkg'
key allows to set up the document fonts, see this example. Currently, for XeLaTeX and LuaLaTeX, Sphinx leaves this key empty and LaTeX then defaults to the Latin Modern font family (from the TeX distribution fonts). This font family provides good coverage of Latin scripts (European languages, Vietnamese) but Cyrillic requires some other OpenType font; for example Computer Modern Unicode (see babel-russian documentation on how to load it in the LaTeX document). In future, it is planned Sphinx will provide another default choice of OpenType font than Latin Modern, perhaps Libertinus, which is included in recent TeX distributions and supports Latin and Cyrillic and also has an accompanying math font.With XeLaTeX and LuaLaTeX, Sphinx configures the LaTeX document to use polyglossia. For some languages the babel support appears preferable; Sphinx uses currently babel for French and perhaps will also for some more languages in future. One can use the
latex_elements
'babel'
key to override Sphinx’s default.
-
latex_documents
¶ This value determines how to group the document tree into LaTeX source files. It must be a list of tuples
(startdocname, targetname, title, author, documentclass, toctree_only)
, where the items are:- startdocname
- String that specifies the document name of the LaTeX file’s master
document. All documents referenced by the startdoc document in TOC trees
will be included in the LaTeX file. (If you want to use the default master
document for your LaTeX build, provide your
master_doc
here.) - targetname
- File name of the LaTeX file in the output directory.
- title
- LaTeX document title. Can be empty to use the title of the startdoc document. This is inserted as LaTeX markup, so special characters like a backslash or ampersand must be represented by the proper LaTeX commands if they are to be inserted literally.
- author
- Author for the LaTeX document. The same LaTeX markup caveat as for title
applies. Use
\\and
to separate multiple authors, as in:'John \\and Sarah'
(backslashes must be Python-escaped to reach LaTeX). - documentclass
- Normally, one of
'manual'
or'howto'
(provided by Sphinx and based on'report'
, resp.'article'
; Japanese documents use'jsbook'
, resp.'jreport'
.) “howto” (non-Japanese) documents will not get appendices. Also they have a simpler title page. Other document classes can be given. Independently of the document class, the “sphinx” package is always loaded in order to define Sphinx’s custom LaTeX commands. - toctree_only
- Must be
True
orFalse
. If true, the startdoc document itself is not included in the output, only the documents referenced by it via TOC trees. With this option, you can put extra stuff in the master document that shows up in the HTML, but not the LaTeX output.
New in version 1.2: In the past including your own document class required you to prepend the document class name with the string “sphinx”. This is not necessary anymore.
New in version 0.3: The 6th item
toctree_only
. Tuples with 5 items are still accepted.
-
latex_logo
¶ If given, this must be the name of an image file (relative to the configuration directory) that is the logo of the docs. It is placed at the top of the title page. Default:
None
.
-
latex_toplevel_sectioning
¶ This value determines the topmost sectioning unit. It should be chosen from
'part'
,'chapter'
or'section'
. The default isNone
; the topmost sectioning unit is switched by documentclass:section
is used if documentclass will behowto
, otherwisechapter
will be used.Note that if LaTeX uses
\part
command, then the numbering of sectioning units one level deep gets off-sync with HTML numbering, because LaTeX numbers continuously\chapter
(or\section
forhowto
.)New in version 1.4.
-
latex_appendices
¶ A list of document names to append as an appendix to all manuals.
-
latex_domain_indices
¶ If true, generate domain-specific indices in addition to the general index. For e.g. the Python domain, this is the global module index. Default is
True
.This value can be a bool or a list of index names that should be generated, like for
html_domain_indices
.New in version 1.0.
-
latex_show_pagerefs
¶ If true, add page references after internal references. This is very useful for printed copies of the manual. Default is
False
.New in version 1.0.
-
latex_show_urls
¶ Control whether to display URL addresses. This is very useful for printed copies of the manual. The setting can have the following values:
'no'
– do not display URLs (default)'footnote'
– display URLs in footnotes'inline'
– display URLs inline in parentheses
New in version 1.0.
Changed in version 1.1: This value is now a string; previously it was a boolean value, and a true value selected the
'inline'
display. For backwards compatibility,True
is still accepted.
-
latex_use_latex_multicolumn
¶ The default is
False
: it means that Sphinx’s own macros are used for merged cells from grid tables. They allow general contents (literal blocks, lists, blockquotes, …) but may have problems if thetabularcolumns
directive was used to inject LaTeX mark-up of the type>{..}
,<{..}
,@{..}
as column specification.Setting to
True
means to use LaTeX’s standard\multicolumn
; this is incompatible with literal blocks in the horizontally merged cell, and also with multiple paragraphs in such cell if the table is rendered usingtabulary
.New in version 1.6.
-
latex_use_xindy
¶ If
True
, the PDF build from the LaTeX files created by Sphinx will use xindy (doc) rather than makeindex for preparing the index of general terms (fromindex
usage). This means that words with UTF-8 characters will get ordered correctly for thelanguage
.- This option is ignored if
latex_engine
is'platex'
(Japanese documents; mendex replaces makeindex then). - The default is
True
for'xelatex'
or'lualatex'
as makeindex, if any indexed term starts with a non-ascii character, creates.ind
files containing invalid bytes for UTF-8 encoding. With'lualatex'
this then breaks the PDF build. - The default is
False
for'pdflatex'
butTrue
is recommended for non-English documents as soon as some indexed terms use non-ascii characters from the language script.
Sphinx adds to xindy base distribution some dedicated support for using
'pdflatex'
engine with Cyrillic scripts. And whether with'pdflatex'
or Unicode engines, Cyrillic documents handle correctly the indexing of Latin names, even with diacritics.New in version 1.8.
- This option is ignored if
-
latex_elements
¶ New in version 0.5.
A dictionary that contains LaTeX snippets that override those Sphinx usually puts into the generated
.tex
files.Keep in mind that backslashes must be doubled in Python string literals to avoid interpretation as escape sequences.
Keys that you may want to override include:
'papersize'
Paper size option of the document class (
'a4paper'
or'letterpaper'
), default'letterpaper'
.'pointsize'
Point size option of the document class (
'10pt'
,'11pt'
or'12pt'
), default'10pt'
.'pxunit'
the value of the
px
when used in image attributeswidth
andheight
. The default value is'0.75bp'
which achieves96px=1in
(in TeX1in = 72bp = 72.27pt
.) To obtain for example100px=1in
use'0.01in'
or'0.7227pt'
(the latter leads to TeX computing a more precise value, due to the smaller unit used in the specification); for72px=1in
, simply use'1bp'
; for90px=1in
, use'0.8bp'
or'0.803pt'
.New in version 1.5.
'sphinxsetup'
A comma separated list of
key=value
package options for the Sphinx LaTeX style, default empty. See LaTeX customization.New in version 1.5.
'passoptionstopackages'
A string which will be positioned early in the preamble, designed to contain
\\PassOptionsToPackage{options}{foo}
commands. Default empty.New in version 1.4.
'babel'
“babel” package inclusion, default
'\\usepackage{babel}'
(the suitable document language string is passed as class option, andenglish
is used if no language.) For Japanese documents, the default is the empty string.Changed in version 1.5: For
latex_engine
set to'xelatex'
, the default is'\\usepackage{polyglossia}\n\\setmainlanguage{<language>}'
.Changed in version 1.6:
'lualatex'
uses same default setting as'xelatex'
Changed in version 1.7.6: For French,
xelatex
andlualatex
default to usingbabel
, notpolyglossia
.'fontpkg'
Font package inclusion, default
'\\usepackage{times}'
(which uses Times for text, Helvetica for sans serif and Courier for code-blocks).Changed in version 1.2: Defaults to
''
when thelanguage
uses the Cyrillic script.Changed in version 1.5: Defaults to
''
whenlatex_engine
is'xelatex'
.Changed in version 1.6: Defaults to
''
also with'lualatex'
.'fncychap'
Inclusion of the “fncychap” package (which makes fancy chapter titles), default
'\\usepackage[Bjarne]{fncychap}'
for English documentation (this option is slightly customized by Sphinx),'\\usepackage[Sonny]{fncychap}'
for internationalized docs (because the “Bjarne” style uses numbers spelled out in English). Other “fncychap” styles you can try are “Lenny”, “Glenn”, “Conny”, “Rejne” and “Bjornstrup”. You can also set this to''
to disable fncychap.'preamble'
Additional preamble content, default empty. See LaTeX customization.
'atendofbody'
Additional document content (right before the indices), default empty.
New in version 1.5.
'figure_align'
Latex figure float alignment, default ‘htbp’ (here, top, bottom, page). Whenever an image doesn’t fit into the current page, it will be ‘floated’ into the next page but may be preceded by any other text. If you don’t like this behavior, use ‘H’ which will disable floating and position figures strictly in the order they appear in the source.
New in version 1.3.
'footer'
Additional footer content (before the indices), default empty.
Deprecated since version 1.5: Use
'atendofbody'
key instead.
Keys that don’t need to be overridden unless in special cases are:
'extraclassoptions'
The default is the empty string. Example:
'extraclassoptions': 'openany'
will allow chapters (for documents of the'manual'
type) to start on any page.New in version 1.2.
Changed in version 1.6: Added this documentation.
'maxlistdepth'
LaTeX allows by default at most 6 levels for nesting list and quote-like environments, with at most 4 enumerated lists, and 4 bullet lists. Setting this key for example to
'10'
(as a string) will allow up to 10 nested levels (of all sorts). Leaving it to the empty string means to obey the LaTeX default.Warning
- Using this key may prove incompatible with some LaTeX packages or special document classes which do their own list customization.
- The key setting is silently ignored if
\usepackage{enumitem}
is executed inside the document preamble. Use then rather the dedicated commands of this LaTeX package.
New in version 1.5.
'inputenc'
“inputenc” package inclusion, defaults to
'\\usepackage[utf8]{inputenc}'
when using pdflatex. Otherwise empty.Changed in version 1.4.3: Previously
'\\usepackage[utf8]{inputenc}'
was used for all compilers.'cmappkg'
“cmap” package inclusion, default
'\\usepackage{cmap}'
.New in version 1.2.
'fontenc'
“fontenc” package inclusion, default
'\\usepackage[T1]{fontenc}'
.Changed in version 1.5: Defaults to
'\\usepackage{fontspec}'
whenlatex_engine
is'xelatex'
.Changed in version 1.6:
'lualatex'
also usesfontspec
per default.'geometry'
“geometry” package inclusion, the default definition is:
'\\usepackage{geometry}'
with an additional
[dvipdfm]
for Japanese documents. The Sphinx LaTeX style file executes:\PassOptionsToPackage{hmargin=1in,vmargin=1in,marginpar=0.5in}{geometry}
which can be customized via corresponding ‘sphinxsetup’ options.
New in version 1.5.
Changed in version 1.5.2:
dvipdfm
option iflatex_engine
is'platex'
.New in version 1.5.3: The ‘sphinxsetup’ keys for the margins.
Changed in version 1.5.3: The location in the LaTeX file has been moved to after
\usepackage{sphinx}
and\sphinxsetup{..}
, hence also after insertion of'fontpkg'
key. This is in order to handle the paper layout options in a special way for Japanese documents: the text width will be set to an integer multiple of the zenkaku width, and the text height to an integer multiple of the baseline. See the hmargin documentation for more.'hyperref'
“hyperref” package inclusion; also loads package “hypcap” and issues
\urlstyle{same}
. This is done aftersphinx.sty
file is loaded and before executing the contents of'preamble'
key.Attention
Loading of packages “hyperref” and “hypcap” is mandatory.
New in version 1.5: Previously this was done from inside
sphinx.sty
.'maketitle'
“maketitle” call, default
'\\maketitle'
(but it has been redefined by the Sphinxmanual
andhowto
classes.) Override if you want to generate a differently-styled title page.'releasename'
value that prefixes
'release'
element on title page, default'Release'
. As for title and author used in the tuples oflatex_documents
, it is inserted as LaTeX markup.'tableofcontents'
“tableofcontents” call, default
'\\sphinxtableofcontents'
(it is a wrapper of unmodified\tableofcontents
, which may itself be customized by user loaded packages.) Override if you want to generate a different table of contents or put content between the title page and the TOC.Changed in version 1.5: Previously the meaning of
\tableofcontents
itself was modified by Sphinx. This created an incompatibility with dedicated packages modifying it also such as “tocloft” or “etoc”.'transition'
Commands used to display transitions, default
'\n\n\\bigskip\\hrule\\bigskip\n\n'
. Override if you want to display transitions differently.New in version 1.2.
Changed in version 1.6: Remove unneeded
{}
after\\hrule
.'printindex'
“printindex” call, the last thing in the file, default
'\\printindex'
. Override if you want to generate the index differently or append some content after the index. For example'\\footnotesize\\raggedright\\printindex'
is advisable when the index is full of long entries.'fvset'
Customization of
fancyvrb
LaTeX package. Currently, Sphinx uses this key to set the fontsize in code-blocks according to thelatex_engine
.'pdflatex'
uses'fvset': '\\fvset{fontsize=\\small}'
, to mitigate the size difference between the default monospaced font (Courier) and the default text font (Times). You may need to modify this if you use custom fonts.'xelatex'
and'lualatex'
use'\\fvset{fontsize=auto}'
, as there is no size difference between the regular and the monospaced fonts used by default by Sphinx with these engines.
New in version 1.8.
Keys that are set by other options and therefore should not be overridden are:
'docclass'
'classoptions'
'title'
'date'
'release'
'author'
'logo'
'makeindex'
-
latex_docclass
¶ A dictionary mapping
'howto'
and'manual'
to names of real document classes that will be used as the base for the two Sphinx classes. Default is to use'article'
for'howto'
and'report'
for'manual'
.New in version 1.0.
Changed in version 1.5: In Japanese docs (
language
is'ja'
), by default'jreport'
is used for'howto'
and'jsbook'
for'manual'
.
-
latex_additional_files
¶ A list of file names, relative to the configuration directory, to copy to the build directory when building LaTeX output. This is useful to copy files that Sphinx doesn’t copy automatically, e.g. if they are referenced in custom LaTeX added in
latex_elements
. Image files that are referenced in source files (e.g. via.. image::
) are copied automatically.You have to make sure yourself that the filenames don’t collide with those of any automatically copied files.
New in version 0.6.
Changed in version 1.2: This overrides the files which is provided from Sphinx such as
sphinx.sty
.
Options for text output¶
These options influence text output.
-
text_newlines
¶ Determines which end-of-line character(s) are used in text output.
'unix'
: use Unix-style line endings (\n
)'windows'
: use Windows-style line endings (\r\n
)'native'
: use the line ending style of the platform the documentation is built on
Default:
'unix'
.New in version 1.1.
-
text_sectionchars
¶ A string of 7 characters that should be used for underlining sections. The first character is used for first-level headings, the second for second-level headings and so on.
The default is
'*=-~"+`'
.New in version 1.1.
-
text_add_secnumbers
¶ A boolean that decides whether section numbers are included in text output. Default is
True
.New in version 1.7.
-
text_secnumber_suffix
¶ Suffix for section numbers in text output. Default:
". "
. Set to" "
to suppress the final dot on section numbers.New in version 1.7.
Options for manual page output¶
These options influence manual page output.
-
man_pages
¶ This value determines how to group the document tree into manual pages. It must be a list of tuples
(startdocname, name, description, authors, section)
, where the items are:- startdocname
- String that specifies the document name of the manual page’s master
document. All documents referenced by the startdoc document in TOC trees
will be included in the manual file. (If you want to use the default
master document for your manual pages build, use your
master_doc
here.) - name
- Name of the manual page. This should be a short string without spaces or special characters. It is used to determine the file name as well as the name of the manual page (in the NAME section).
- description
- Description of the manual page. This is used in the NAME section.
- authors
- A list of strings with authors, or a single string. Can be an empty string or list if you do not want to automatically generate an AUTHORS section in the manual page.
- section
- The manual page section. Used for the output file name as well as in the manual page header.
New in version 1.0.
-
man_show_urls
¶ If true, add URL addresses after links. Default is
False
.New in version 1.1.
Options for Texinfo output¶
These options influence Texinfo output.
-
texinfo_documents
¶ This value determines how to group the document tree into Texinfo source files. It must be a list of tuples
(startdocname, targetname, title, author, dir_entry, description, category, toctree_only)
, where the items are:- startdocname
- String that specifies the document name of the the Texinfo file’s
master document. All documents referenced by the startdoc document in
TOC trees will be included in the Texinfo file. (If you want to use the
default master document for your Texinfo build, provide your
master_doc
here.) - targetname
- File name (no extension) of the Texinfo file in the output directory.
- title
- Texinfo document title. Can be empty to use the title of the startdoc
document. Inserted as Texinfo markup, so special characters like
@
and{}
will need to be escaped to be inserted literally. - author
- Author for the Texinfo document. Inserted as Texinfo markup. Use
@*
to separate multiple authors, as in:'John@*Sarah'
. - dir_entry
- The name that will appear in the top-level
DIR
menu file. - description
- Descriptive text to appear in the top-level
DIR
menu file. - category
- Specifies the section which this entry will appear in the top-level
DIR
menu file. - toctree_only
- Must be
True
orFalse
. If true, the startdoc document itself is not included in the output, only the documents referenced by it via TOC trees. With this option, you can put extra stuff in the master document that shows up in the HTML, but not the Texinfo output.
New in version 1.1.
-
texinfo_appendices
¶ A list of document names to append as an appendix to all manuals.
New in version 1.1.
-
texinfo_domain_indices
¶ If true, generate domain-specific indices in addition to the general index. For e.g. the Python domain, this is the global module index. Default is
True
.This value can be a bool or a list of index names that should be generated, like for
html_domain_indices
.New in version 1.1.
-
texinfo_show_urls
¶ Control how to display URL addresses.
'footnote'
– display URLs in footnotes (default)'no'
– do not display URLs'inline'
– display URLs inline in parentheses
New in version 1.1.
If true, do not generate a
@detailmenu
in the “Top” node’s menu containing entries for each sub-node in the document. Default isFalse
.New in version 1.2.
-
texinfo_elements
¶ A dictionary that contains Texinfo snippets that override those Sphinx usually puts into the generated
.texi
files.Keys that you may want to override include:
'paragraphindent'
Number of spaces to indent the first line of each paragraph, default
2
. Specify0
for no indentation.'exampleindent'
Number of spaces to indent the lines for examples or literal blocks, default
4
. Specify0
for no indentation.'preamble'
Texinfo markup inserted near the beginning of the file.
'copying'
Texinfo markup inserted within the
@copying
block and displayed after the title. The default value consists of a simple title page identifying the project.
Keys that are set by other options and therefore should not be overridden are:
'author'
'body'
'date'
'direntry'
'filename'
'project'
'release'
'title'
New in version 1.1.
Options for QtHelp output¶
These options influence qthelp output. As this builder derives from the HTML builder, the HTML options also apply where appropriate.
-
qthelp_namespace
¶ The namespace for the qthelp file. It defaults to
org.sphinx.<project_name>.<project_version>
.
-
qthelp_theme
¶ The HTML theme for the qthelp output. This defaults to
'nonav'
.
-
qthelp_theme_options
¶ A dictionary of options that influence the look and feel of the selected theme. These are theme-specific. For the options understood by the builtin themes, see this section.
Options for the linkcheck builder¶
-
linkcheck_ignore
¶ A list of regular expressions that match URIs that should not be checked when doing a
linkcheck
build. Example:linkcheck_ignore = [r'http://localhost:\d+/']
New in version 1.1.
-
linkcheck_retries
¶ The number of times the linkcheck builder will attempt to check a URL before declaring it broken. Defaults to 1 attempt.
New in version 1.4.
-
linkcheck_timeout
¶ A timeout value, in seconds, for the linkcheck builder. The default is to use Python’s global socket timeout.
New in version 1.1.
-
linkcheck_workers
¶ The number of worker threads to use when checking links. Default is 5 threads.
New in version 1.1.
-
linkcheck_anchors
¶ If true, check the validity of
#anchor
s in links. Since this requires downloading the whole document, it’s considerably slower when enabled. Default isTrue
.New in version 1.2.
-
linkcheck_anchors_ignore
¶ A list of regular expressions that match anchors Sphinx should skip when checking the validity of anchors in links. This allows skipping anchors that a website’s JavaScript adds to control dynamic pages or when triggering an internal REST request. Default is
["^!"]
.Note
If you want to ignore anchors of a specific page or of pages that match a specific pattern (but still check occurrences of the same page(s) that don’t have anchors), use
linkcheck_ignore
instead, for example as follows:linkcheck_ignore = [ 'http://www.sphinx-doc.org/en/1.7/intro.html#' ]
New in version 1.5.
Options for the XML builder¶
-
xml_pretty
¶ If true, pretty-print the XML. Default is
True
.New in version 1.2.
Footnotes
[1] | (1, 2) A note on available globbing syntax: you can use the standard shell
constructs * , ? , [...] and [!...] with the feature that
these all don’t match slashes. A double star ** can be used to
match any sequence of characters including slashes. |
Options for the C++ domain¶
-
cpp_index_common_prefix
¶ A list of prefixes that will be ignored when sorting C++ objects in the global index. For example
['awesome_lib::']
.New in version 1.5.
-
cpp_id_attributes
¶ A list of strings that the parser additionally should accept as attributes. This can for example be used when attributes have been
#define
d for portability.New in version 1.5.
-
cpp_paren_attributes
¶ A list of strings that the parser additionally should accept as attributes with one argument. That is, if
my_align_as
is in the list, thenmy_align_as(X)
is parsed as an attribute for all stringsX
that have balanced brances (()
,[]
, and{}
). This can for example be used when attributes have been#define
d for portability.New in version 1.5.
Example of configuration file¶
# -*- coding: utf-8 -*-
#
# test documentation build configuration file, created by
# sphinx-quickstart on Sun Jun 26 00:00:43 2016.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
# import os
# import sys
# sys.path.insert(0, os.path.abspath('.'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = []
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The encoding of source files.
#
# source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'test'
copyright = u'2016, test'
author = u'test'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = u'test'
# The full version, including alpha/beta/rc tags.
release = u'test'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#
# today = ''
#
# Else, today_fmt is used as the format for a strftime call.
#
# today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# These patterns also affect html_static_path and html_extra_path
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
# The reST default role (used for this markup: `text`) to use for all
# documents.
#
# default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#
# add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#
# add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#
# show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
# modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
# keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = 'alabaster'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
# html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
# html_theme_path = []
# The name for this set of Sphinx documents.
# "<project> v<release> documentation" by default.
#
# html_title = u'test vtest'
# A shorter title for the navigation bar. Default is the same as html_title.
#
# html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#
# html_logo = None
# The name of an image file (relative to this directory) to use as a favicon of
# the docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#
# html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#
# html_extra_path = []
# If not None, a 'Last updated on:' timestamp is inserted at every page
# bottom, using the given strftime format.
# The empty string is equivalent to '%b %d, %Y'.
#
# html_last_updated_fmt = None
# Custom sidebar templates, maps document names to template names.
#
# html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#
# html_additional_pages = {}
# If false, no module index is generated.
#
# html_domain_indices = True
# If false, no index is generated.
#
# html_use_index = True
# If true, the index is split into individual pages for each letter.
#
# html_split_index = False
# If true, links to the reST sources are added to the pages.
#
# html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#
# html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#
# html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#
# html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
# html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh'
#
# html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# 'ja' uses this config value.
# 'zh' user can custom change `jieba` dictionary path.
#
# html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
#
# html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = 'testdoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'test.tex', u'test Documentation',
u'test', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#
# latex_logo = None
# If true, show page references after internal links.
#
# latex_show_pagerefs = False
# If true, show URL addresses after external links.
#
# latex_show_urls = False
# Documents to append as an appendix to all manuals.
#
# latex_appendices = []
# If false, no module index is generated.
#
# latex_domain_indices = True
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'test', u'test Documentation',
[author], 1)
]
# If true, show URL addresses after external links.
#
# man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'test', u'test Documentation',
author, 'test', 'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#
# texinfo_appendices = []
# If false, no module index is generated.
#
# texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#
# texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
#
# texinfo_no_detailmenu = False
# -- A random example -----------------------------------------------------
import sys, os
sys.path.insert(0, os.path.abspath('.'))
exclude_patterns = ['zzz']
numfig = True
#language = 'ja'
extensions.append('sphinx.ext.todo')
extensions.append('sphinx.ext.autodoc')
#extensions.append('sphinx.ext.autosummary')
extensions.append('sphinx.ext.intersphinx')
extensions.append('sphinx.ext.mathjax')
extensions.append('sphinx.ext.viewcode')
extensions.append('sphinx.ext.graphviz')
autosummary_generate = True
html_theme = 'default'
#source_suffix = ['.rst', '.txt']
Builders¶
These are the built-in Sphinx builders. More builders can be added by extensions.
The builder’s “name” must be given to the -b command-line option of sphinx-build to select a builder.
-
class
sphinx.builders.html.
StandaloneHTMLBuilder
[source]¶ This is the standard HTML builder. Its output is a directory with HTML files, complete with style sheets and optionally the reST sources. There are quite a few configuration values that customize the output of this builder, see the chapter Options for HTML output for details.
-
name
= 'html'¶
-
format
= 'html'¶
-
supported_image_types
= ['image/svg+xml', 'image/png', 'image/gif', 'image/jpeg']¶
-
-
class
sphinx.builders.html.
DirectoryHTMLBuilder
[source]¶ This is a subclass of the standard HTML builder. Its output is a directory with HTML files, where each file is called
index.html
and placed in a subdirectory named like its page name. For example, the documentmarkup/rest.rst
will not result in an output filemarkup/rest.html
, butmarkup/rest/index.html
. When generating links between pages, theindex.html
is omitted, so that the URL would look likemarkup/rest/
.-
name
= 'dirhtml'¶
-
format
= 'html'¶
-
supported_image_types
= ['image/svg+xml', 'image/png', 'image/gif', 'image/jpeg']¶
New in version 0.6.
-
-
class
sphinx.builders.html.
SingleFileHTMLBuilder
[source]¶ This is an HTML builder that combines the whole project in one output file. (Obviously this only works with smaller projects.) The file is named like the master document. No indices will be generated.
-
name
= 'singlehtml'¶
-
format
= 'html'¶
-
supported_image_types
= ['image/svg+xml', 'image/png', 'image/gif', 'image/jpeg']¶
New in version 1.0.
-
-
class
sphinx.builders.htmlhelp.
HTMLHelpBuilder
[source]¶ This builder produces the same output as the standalone HTML builder, but also generates HTML Help support files that allow the Microsoft HTML Help Workshop to compile them into a CHM file.
-
name
= 'htmlhelp'¶
-
format
= 'html'¶
-
supported_image_types
= ['image/png', 'image/gif', 'image/jpeg']¶
-
-
class
sphinx.builders.qthelp.
QtHelpBuilder
[source]¶ This builder produces the same output as the standalone HTML builder, but also generates Qt help collection support files that allow the Qt collection generator to compile them.
-
name
= 'qthelp'¶
-
format
= 'html'¶
-
supported_image_types
= ['image/svg+xml', 'image/png', 'image/gif', 'image/jpeg']¶
-
-
class
sphinx.builders.applehelp.
AppleHelpBuilder
[source]¶ This builder produces an Apple Help Book based on the same output as the standalone HTML builder.
If the source directory contains any
.lproj
folders, the one corresponding to the selected language will have its contents merged with the generated output. These folders will be ignored by all other documentation types.In order to generate a valid help book, this builder requires the command line tool hiutil, which is only available on Mac OS X 10.6 and above. You can disable the indexing step by setting
applehelp_disable_external_tools
toTrue
, in which case the output will not be valid until hiutil has been run on all of the.lproj
folders within the bundle.-
name
= 'applehelp'¶
-
format
= 'html'¶
-
supported_image_types
= ['image/png', 'image/gif', 'image/jpeg', 'image/tiff', 'image/jp2', 'image/svg+xml']¶
New in version 1.3.
-
-
class
sphinx.builders.devhelp.
DevhelpBuilder
[source]¶ This builder produces the same output as the standalone HTML builder, but also generates GNOME Devhelp support file that allows the GNOME Devhelp reader to view them.
-
name
= 'devhelp'¶
-
format
= 'html'¶
-
supported_image_types
= ['image/png', 'image/gif', 'image/jpeg']¶
-
-
class
sphinx.builders.epub3.
Epub3Builder
[source]¶ This builder produces the same output as the standalone HTML builder, but also generates an epub file for ebook readers. See Epub info for details about it. For definition of the epub format, have a look at http://idpf.org/epub or https://en.wikipedia.org/wiki/EPUB. The builder creates EPUB 3 files.
-
name
= 'epub'¶
-
format
= 'html'¶
-
supported_image_types
= ['image/svg+xml', 'image/png', 'image/gif', 'image/jpeg']¶
New in version 1.4.
Changed in version 1.5: Since Sphinx-1.5, the epub3 builder is used for the default builder of epub.
-
-
class
sphinx.builders.latex.
LaTeXBuilder
[source]¶ This builder produces a bunch of LaTeX files in the output directory. You have to specify which documents are to be included in which LaTeX files via the
latex_documents
configuration value. There are a few configuration values that customize the output of this builder, see the chapter Options for LaTeX output for details.The produced LaTeX file uses several LaTeX packages that may not be present in a “minimal” TeX distribution installation. For example, on Ubuntu, the following packages need to be installed for successful PDF builds:
texlive-latex-recommended
texlive-fonts-recommended
texlive-latex-extra
latexmk
(formake latexpdf
on GNU/Linux and MacOS X)latex-xcolor
(old Ubuntu)texlive-luatex
,texlive-xetex
(seelatex_engine
)
The testing of Sphinx LaTeX is done on Ubuntu trusty with the above mentioned packages, which are from a TeXLive 2013 snapshot dated February 2014.
Changed in version 1.6: Formerly, testing had been done on Ubuntu precise (TeXLive 2009).
Note
Since 1.6,
make latexpdf
useslatexmk
(not on Windows). This makes sure the needed number of runs is automatically executed to get the cross-references, bookmarks, indices, and tables of contents right.One can pass to
latexmk
options via theLATEXMKOPTS
Makefile variable. For example:make latexpdf LATEXMKOPTS="-silent"
reduces console output to a minimum.
Also, if
latexmk
version is 4.52b or higher (Jan 17)LATEXMKOPTS="-xelatex"
will speed up PDF builds via XeLateX in case of numerous graphics inclusions.make latexpdf LATEXMKOPTS="-xelatex"
To pass options directly to the
(pdf|xe|lua)latex
executable, use variableLATEXOPTS
.make latexpdf LATEXOPTS="--interaction=nonstopmode"
-
name
= 'latex'¶
-
format
= 'latex'¶
-
supported_image_types
= ['application/pdf', 'image/png', 'image/jpeg']¶
Note that a direct PDF builder is being provided by rinohtype. The builder’s
name is rinoh
. Refer to the rinohtype manual for details.
-
class
sphinx.builders.text.
TextBuilder
[source]¶ This builder produces a text file for each reST file – this is almost the same as the reST source, but with much of the markup stripped for better readability.
-
name
= 'text'¶
-
format
= 'text'¶
-
supported_image_types
= []¶
New in version 0.4.
-
-
class
sphinx.builders.manpage.
ManualPageBuilder
[source]¶ This builder produces manual pages in the groff format. You have to specify which documents are to be included in which manual pages via the
man_pages
configuration value.-
name
= 'man'¶
-
format
= 'man'¶
-
supported_image_types
= []¶
New in version 1.0.
-
-
class
sphinx.builders.texinfo.
TexinfoBuilder
[source]¶ This builder produces Texinfo files that can be processed into Info files by the makeinfo program. You have to specify which documents are to be included in which Texinfo files via the
texinfo_documents
configuration value.The Info format is the basis of the on-line help system used by GNU Emacs and the terminal-based program info. See Texinfo info for more details. The Texinfo format is the official documentation system used by the GNU project. More information on Texinfo can be found at https://www.gnu.org/software/texinfo/.
-
name
= 'texinfo'¶
-
format
= 'texinfo'¶
-
supported_image_types
= ['image/png', 'image/jpeg', 'image/gif']¶
New in version 1.1.
-
-
class
sphinx.builders.html.
SerializingHTMLBuilder
[source]¶ This builder uses a module that implements the Python serialization API (pickle, simplejson, phpserialize, and others) to dump the generated HTML documentation. The pickle builder is a subclass of it.
A concrete subclass of this builder serializing to the PHP serialization format could look like this:
import phpserialize class PHPSerializedBuilder(SerializingHTMLBuilder): name = 'phpserialized' implementation = phpserialize out_suffix = '.file.phpdump' globalcontext_filename = 'globalcontext.phpdump' searchindex_filename = 'searchindex.phpdump'
-
implementation
¶ A module that implements dump(), load(), dumps() and loads() functions that conform to the functions with the same names from the pickle module. Known modules implementing this interface are simplejson, phpserialize, plistlib, and others.
-
out_suffix
¶ The suffix for all regular files.
-
globalcontext_filename
¶ The filename for the file that contains the “global context”. This is a dict with some general configuration values such as the name of the project.
-
searchindex_filename
¶ The filename for the search index Sphinx generates.
See Serialization builder details for details about the output format.
New in version 0.5.
-
-
class
sphinx.builders.html.
PickleHTMLBuilder
[source]¶ This builder produces a directory with pickle files containing mostly HTML fragments and TOC information, for use of a web application (or custom postprocessing tool) that doesn’t use the standard HTML templates.
See Serialization builder details for details about the output format.
-
name
= 'pickle'¶ The old name
web
still works as well.
-
format
= 'html'¶
-
supported_image_types
= ['image/svg+xml', 'image/png', 'image/gif', 'image/jpeg']¶
The file suffix is
.fpickle
. The global context is calledglobalcontext.pickle
, the search indexsearchindex.pickle
.-
-
class
sphinx.builders.html.
JSONHTMLBuilder
[source]¶ This builder produces a directory with JSON files containing mostly HTML fragments and TOC information, for use of a web application (or custom postprocessing tool) that doesn’t use the standard HTML templates.
See Serialization builder details for details about the output format.
-
name
= 'json'¶
-
format
= 'html'¶
-
supported_image_types
= ['image/svg+xml', 'image/png', 'image/gif', 'image/jpeg']¶
The file suffix is
.fjson
. The global context is calledglobalcontext.json
, the search indexsearchindex.json
.New in version 0.5.
-
-
class
sphinx.builders.gettext.
MessageCatalogBuilder
[source]¶ This builder produces gettext-style message catalogs. Each top-level file or subdirectory grows a single
.pot
catalog template.See the documentation on Internationalization for further reference.
-
name
= u'gettext'¶
-
format
= ''¶
-
supported_image_types
= []¶
New in version 1.1.
-
-
class
sphinx.builders.changes.
ChangesBuilder
[source]¶ This builder produces an HTML overview of all
versionadded
,versionchanged
anddeprecated
directives for the currentversion
. This is useful to generate a ChangeLog file, for example.-
name
= 'changes'¶
-
format
= ''¶
-
supported_image_types
= []¶
-
-
class
sphinx.builders.dummy.
DummyBuilder
[source]¶ This builder produces no output. The input is only parsed and checked for consistency. This is useful for linting purposes.
-
name
= 'dummy'¶
-
supported_image_types
= []¶
New in version 1.4.
-
-
class
sphinx.builders.linkcheck.
CheckExternalLinksBuilder
[source]¶ This builder scans all documents for external links, tries to open them with
requests
, and writes an overview which ones are broken and redirected to standard output and tooutput.txt
in the output directory.-
name
= 'linkcheck'¶
-
format
= ''¶
-
supported_image_types
= []¶
Changed in version 1.5: Since Sphinx-1.5, the linkcheck builder comes to use requests module.
-
-
class
sphinx.builders.xml.
XMLBuilder
[source]¶ This builder produces Docutils-native XML files. The output can be transformed with standard XML tools such as XSLT processors into arbitrary final forms.
-
name
= 'xml'¶
-
format
= 'xml'¶
-
supported_image_types
= []¶
New in version 1.2.
-
-
class
sphinx.builders.xml.
PseudoXMLBuilder
[source]¶ This builder is used for debugging the Sphinx/Docutils “Reader to Transform to Writer” pipeline. It produces compact pretty-printed “pseudo-XML”, files where nesting is indicated by indentation (no end-tags). External attributes for all elements are output, and internal attributes for any leftover “pending” elements are also given.
-
name
= 'pseudoxml'¶
-
format
= 'pseudoxml'¶
-
supported_image_types
= []¶
New in version 1.2.
-
Built-in Sphinx extensions that offer more builders are:
Serialization builder details¶
All serialization builders outputs one file per source file and a few special
files. They also copy the reST source files in the directory _sources
under the output directory.
The PickleHTMLBuilder
is a builtin subclass that implements the pickle
serialization interface.
The files per source file have the extensions of
out_suffix
, and are arranged in directories
just as the source files are. They unserialize to a dictionary (or dictionary
like structure) with these keys:
body
- The HTML “body” (that is, the HTML rendering of the source file), as rendered by the HTML translator.
title
- The title of the document, as HTML (may contain markup).
toc
- The table of contents for the file, rendered as an HTML
<ul>
. display_toc
- A boolean that is
True
if thetoc
contains more than one entry. current_page_name
- The document name of the current file.
parents
,prev
andnext
- Information about related chapters in the TOC tree. Each relation is a
dictionary with the keys
link
(HREF for the relation) andtitle
(title of the related document, as HTML).parents
is a list of relations, whileprev
andnext
are a single relation. sourcename
- The name of the source file under
_sources
.
The special files are located in the root output directory. They are:
SerializingHTMLBuilder.globalcontext_filename
A pickled dict with these keys:
project
,copyright
,release
,version
- The same values as given in the configuration file.
style
html_style
.last_updated
- Date of last build.
builder
- Name of the used builder, in the case of pickles this is always
'pickle'
. titles
- A dictionary of all documents’ titles, as HTML strings.
SerializingHTMLBuilder.searchindex_filename
An index that can be used for searching the documentation. It is a pickled list with these entries:
- A list of indexed docnames.
- A list of document titles, as HTML strings, in the same order as the first list.
- A dict mapping word roots (processed by an English-language stemmer) to a list of integers, which are indices into the first list.
environment.pickle
The build environment. This is always a pickle file, independent of the builder and a copy of the environment that was used when the builder was started.
Todo
Document common members.
Unlike the other pickle files this pickle file requires that the
sphinx
package is available on unpickling.
Extensions¶
Since many projects will need special features in their documentation, Sphinx allows adding “extensions” to the build process, each of which can modify almost any aspect of document processing.
This chapter describes the extensions bundled with Sphinx. For the API documentation on writing your own extension, refer to Developing extensions for Sphinx.
Built-in extensions¶
These extensions are built in and can be activated by respective entries in the
extensions
configuration value:
sphinx.ext.autodoc
– Include documentation from docstrings¶
This extension can import the modules you are documenting, and pull in documentation from docstrings in a semi-automatic way.
Note
For Sphinx (actually, the Python interpreter that executes Sphinx) to find
your module, it must be importable. That means that the module or the
package must be in one of the directories on sys.path
– adapt your
sys.path
in the configuration file accordingly.
Warning
autodoc
imports the modules to be documented. If any
modules have side effects on import, these will be executed by autodoc
when sphinx-build
is run.
If you document scripts (as opposed to library modules), make sure their main
routine is protected by a if __name__ == '__main__'
condition.
For this to work, the docstrings must of course be written in correct reStructuredText. You can then use all of the usual Sphinx markup in the docstrings, and it will end up correctly in the documentation. Together with hand-written documentation, this technique eases the pain of having to maintain two locations for documentation, while at the same time avoiding auto-generated-looking pure API documentation.
If you prefer NumPy or Google style docstrings over reStructuredText,
you can also enable the napoleon
extension.
napoleon
is a preprocessor that converts your
docstrings to correct reStructuredText before autodoc
processes them.
autodoc
provides several directives that are versions of the usual
py:module
, py:class
and so forth. On parsing time, they
import the corresponding module and extract the docstring of the given objects,
inserting them into the page source under a suitable py:module
,
py:class
etc. directive.
Note
Just as py:class
respects the current py:module
,
autoclass
will also do so. Likewise, automethod
will
respect the current py:class
.
-
.. automodule::
¶ -
.. autoclass::
¶ -
.. autoexception::
¶ Document a module, class or exception. All three directives will by default only insert the docstring of the object itself:
.. autoclass:: Noodle
will produce source like this:
.. class:: Noodle Noodle's docstring.
The “auto” directives can also contain content of their own, it will be inserted into the resulting non-auto directive source after the docstring (but before any automatic member documentation).
Therefore, you can also mix automatic and non-automatic member documentation, like so:
.. autoclass:: Noodle :members: eat, slurp .. method:: boil(time=10) Boil the noodle *time* minutes.
Options and advanced usage
If you want to automatically document members, there’s a
members
option:.. automodule:: noodle :members:
will document all module members (recursively), and
.. autoclass:: Noodle :members:
will document all non-private member functions and properties (that is, those whose name doesn’t start with
_
).For modules,
__all__
will be respected when looking for members unless you give theignore-module-all
flag option. Withoutignore-module-all
, the order of the members will also be the order in__all__
.You can also give an explicit list of members; only these will then be documented:
.. autoclass:: Noodle :members: eat, slurp
If you want to make the
members
option (or other options described below) the default, seeautodoc_default_options
.Tip
You can use a negated form,
'no-flag'
, as an option of autodoc directive, to disable it temporarily. For example:.. automodule:: foo :no-undoc-members:
Members without docstrings will be left out, unless you give the
undoc-members
flag option:.. automodule:: noodle :members: :undoc-members:
“Private” members (that is, those named like
_private
or__private
) will be included if theprivate-members
flag option is given.New in version 1.1.
Python “special” members (that is, those named like
__special__
) will be included if thespecial-members
flag option is given:.. autoclass:: my.Class :members: :private-members: :special-members:
would document both “private” and “special” members of the class.
New in version 1.1.
Changed in version 1.2: The option can now take arguments, i.e. the special members to document.
For classes and exceptions, members inherited from base classes will be left out when documenting all members, unless you give the
inherited-members
flag option, in addition tomembers
:.. autoclass:: Noodle :members: :inherited-members:
This can be combined with
undoc-members
to document all available members of the class or module.Note: this will lead to markup errors if the inherited members come from a module whose docstrings are not reST formatted.
New in version 0.3.
It’s possible to override the signature for explicitly documented callable objects (functions, methods, classes) with the regular syntax that will override the signature gained from introspection:
.. autoclass:: Noodle(type) .. automethod:: eat(persona)
This is useful if the signature from the method is hidden by a decorator.
New in version 0.4.
The
automodule
,autoclass
andautoexception
directives also support a flag option calledshow-inheritance
. When given, a list of base classes will be inserted just below the class signature (when used withautomodule
, this will be inserted for every class that is documented in the module).New in version 0.4.
All autodoc directives support the
noindex
flag option that has the same effect as for standardpy:function
etc. directives: no index entries are generated for the documented object (and all autodocumented members).New in version 0.4.
automodule
also recognizes thesynopsis
,platform
anddeprecated
options that the standardpy:module
directive supports.New in version 0.5.
automodule
andautoclass
also has anmember-order
option that can be used to override the global value ofautodoc_member_order
for one directive.New in version 0.6.
The directives supporting member documentation also have a
exclude-members
option that can be used to exclude single member names from documentation, if all members are to be documented.New in version 0.6.
In an
automodule
directive with themembers
option set, only module members whose__module__
attribute is equal to the module name as given toautomodule
will be documented. This is to prevent documentation of imported classes or functions. Set theimported-members
option if you want to prevent this behavior and document all available members. Note that attributes from imported modules will not be documented, because attribute documentation is discovered by parsing the source file of the current module.New in version 1.2.
Add a list of modules in the
autodoc_mock_imports
to prevent import errors to halt the building process when some external dependencies are not importable at build time.New in version 1.3.
-
.. autofunction::
¶ -
.. autodata::
¶ -
.. automethod::
¶ -
.. autoattribute::
¶ These work exactly like
autoclass
etc., but do not offer the options used for automatic member documentation.autodata
andautoattribute
support theannotation
option. Without this option, the representation of the object will be shown in the documentation. When the option is given without arguments, only the name of the object will be printed:.. autodata:: CD_DRIVE :annotation:
You can tell sphinx what should be printed after the name:
.. autodata:: CD_DRIVE :annotation: = your CD device name
For module data members and class attributes, documentation can either be put into a comment with special formatting (using a
#:
to start the comment instead of just#
), or in a docstring after the definition. Comments need to be either on a line of their own before the definition, or immediately after the assignment on the same line. The latter form is restricted to one line only.This means that in the following class definition, all attributes can be autodocumented:
class Foo: """Docstring for class Foo.""" #: Doc comment for class attribute Foo.bar. #: It can have multiple lines. bar = 1 flox = 1.5 #: Doc comment for Foo.flox. One line only. baz = 2 """Docstring for class attribute Foo.baz.""" def __init__(self): #: Doc comment for instance attribute qux. self.qux = 3 self.spam = 4 """Docstring for instance attribute spam."""
Changed in version 0.6:
autodata
andautoattribute
can now extract docstrings.Changed in version 1.1: Comment docs are now allowed on the same line after an assignment.
Changed in version 1.2:
autodata
andautoattribute
have anannotation
option.Note
If you document decorated functions or methods, keep in mind that autodoc retrieves its docstrings by importing the module and inspecting the
__doc__
attribute of the given function or method. That means that if a decorator replaces the decorated function with another, it must copy the original__doc__
to the new function.From Python 2.5,
functools.wraps()
can be used to create well-behaved decorating functions.
There are also new config values that you can set:
-
autoclass_content
¶ This value selects what content will be inserted into the main body of an
autoclass
directive. The possible values are:"class"
- Only the class’ docstring is inserted. This is the default. You can
still document
__init__
as a separate method usingautomethod
or themembers
option toautoclass
. "both"
- Both the class’ and the
__init__
method’s docstring are concatenated and inserted. "init"
- Only the
__init__
method’s docstring is inserted.
New in version 0.3.
If the class has no
__init__
method or if the__init__
method’s docstring is empty, but the class has a__new__
method’s docstring, it is used instead.New in version 1.4.
-
autodoc_member_order
¶ This value selects if automatically documented members are sorted alphabetical (value
'alphabetical'
), by member type (value'groupwise'
) or by source order (value'bysource'
). The default is alphabetical.Note that for source order, the module must be a Python module with the source code available.
New in version 0.6.
Changed in version 1.0: Support for
'bysource'
.
-
autodoc_default_flags
¶ This value is a list of autodoc directive flags that should be automatically applied to all autodoc directives. The supported flags are
'members'
,'undoc-members'
,'private-members'
,'special-members'
,'inherited-members'
,'show-inheritance'
,'ignore-module-all'
and'exclude-members'
.New in version 1.0.
Deprecated since version 1.8: Integrated into
autodoc_default_options
.
-
autodoc_default_options
¶ The default options for autodoc directives. They are applied to all autodoc directives automatically. It must be a dictionary which maps option names to the values. For example:
autodoc_default_options = { 'members': 'var1, var2', 'member-order': 'bysource', 'special-members': '__init__', 'undoc-members': None, 'exclude-members': '__weakref__' }
Setting
None
is equivalent to giving the option name in the list format (i.e. it means “yes/true/on”).The supported options are
'members'
,'undoc-members'
,'private-members'
,'special-members'
,'inherited-members'
,'show-inheritance'
,'ignore-module-all'
and'exclude-members'
.New in version 1.8.
-
autodoc_docstring_signature
¶ Functions imported from C modules cannot be introspected, and therefore the signature for such functions cannot be automatically determined. However, it is an often-used convention to put the signature into the first line of the function’s docstring.
If this boolean value is set to
True
(which is the default), autodoc will look at the first line of the docstring for functions and methods, and if it looks like a signature, use the line as the signature and remove it from the docstring content.New in version 1.1.
-
autodoc_mock_imports
¶ This value contains a list of modules to be mocked up. This is useful when some external dependencies are not met at build time and break the building process. You may only specify the root package of the dependencies themselves and omit the sub-modules:
autodoc_mock_imports = ["django"]
Will mock all imports under the
django
package.New in version 1.3.
Changed in version 1.6: This config value only requires to declare the top-level modules that should be mocked.
-
autodoc_warningiserror
¶ This value controls the behavior of
sphinx-build -W
during importing modules. IfFalse
is given, autodoc forcely suppresses the error if the imported module emits warnings. By default,True
.
-
autodoc_inherit_docstrings
¶ This value controls the docstrings inheritance. If set to True the docstring for classes or methods, if not explicitly set, is inherited form parents.
The default is
True
.New in version 1.7.
Docstring preprocessing¶
autodoc provides the following additional events:
-
autodoc-process-docstring
(app, what, name, obj, options, lines)¶ New in version 0.4.
Emitted when autodoc has read and processed a docstring. lines is a list of strings – the lines of the processed docstring – that the event handler can modify in place to change what Sphinx puts into the output.
Parameters: - app – the Sphinx application object
- what – the type of the object which the docstring belongs to (one of
"module"
,"class"
,"exception"
,"function"
,"method"
,"attribute"
) - name – the fully qualified name of the object
- obj – the object itself
- options – the options given to the directive: an object with attributes
inherited_members
,undoc_members
,show_inheritance
andnoindex
that are true if the flag option of same name was given to the auto directive - lines – the lines of the docstring, see above
-
autodoc-process-signature
(app, what, name, obj, options, signature, return_annotation)¶ New in version 0.5.
Emitted when autodoc has formatted a signature for an object. The event handler can return a new tuple
(signature, return_annotation)
to change what Sphinx puts into the output.Parameters: - app – the Sphinx application object
- what – the type of the object which the docstring belongs to (one of
"module"
,"class"
,"exception"
,"function"
,"method"
,"attribute"
) - name – the fully qualified name of the object
- obj – the object itself
- options – the options given to the directive: an object with attributes
inherited_members
,undoc_members
,show_inheritance
andnoindex
that are true if the flag option of same name was given to the auto directive - signature – function signature, as a string of the form
"(parameter_1, parameter_2)"
, orNone
if introspection didn’t succeed and signature wasn’t specified in the directive. - return_annotation – function return annotation as a string of the form
" -> annotation"
, orNone
if there is no return annotation
The sphinx.ext.autodoc
module provides factory functions for commonly
needed docstring processing in event autodoc-process-docstring
:
-
sphinx.ext.autodoc.
cut_lines
(pre, post=0, what=None)[source]¶ Return a listener that removes the first pre and last post lines of every docstring. If what is a sequence of strings, only docstrings of a type in what will be processed.
Use like this (e.g. in the
setup()
function ofconf.py
):from sphinx.ext.autodoc import cut_lines app.connect('autodoc-process-docstring', cut_lines(4, what=['module']))
This can (and should) be used in place of
automodule_skip_lines
.
-
sphinx.ext.autodoc.
between
(marker, what=None, keepempty=False, exclude=False)[source]¶ Return a listener that either keeps, or if exclude is True excludes, lines between lines that match the marker regular expression. If no line matches, the resulting docstring would be empty, so no change will be made unless keepempty is true.
If what is a sequence of strings, only docstrings of a type in what will be processed.
Skipping members¶
autodoc allows the user to define a custom method for determining whether a member should be included in the documentation by using the following event:
-
autodoc-skip-member
(app, what, name, obj, skip, options)¶ New in version 0.5.
Emitted when autodoc has to decide whether a member should be included in the documentation. The member is excluded if a handler returns
True
. It is included if the handler returnsFalse
.If more than one enabled extension handles the
autodoc-skip-member
event, autodoc will use the first non-None
value returned by a handler. Handlers should returnNone
to fall back to the skipping behavior of autodoc and other enabled extensions.Parameters: - app – the Sphinx application object
- what – the type of the object which the docstring belongs to (one of
"module"
,"class"
,"exception"
,"function"
,"method"
,"attribute"
) - name – the fully qualified name of the object
- obj – the object itself
- skip – a boolean indicating if autodoc will skip this member if the user handler does not override the decision
- options – the options given to the directive: an object with attributes
inherited_members
,undoc_members
,show_inheritance
andnoindex
that are true if the flag option of same name was given to the auto directive
sphinx.ext.autosectionlabel
– Allow reference sections using its title¶
New in version 1.4.
This extension allows you to refer sections its title. This affects to the
reference role (ref
).
For example:
A Plain Title
-------------
This is the text of the section.
It refers to the section title, see :ref:`A Plain Title`.
Internally, this extension generates the labels for each section. If same
section names are used in whole of document, any one is used for a target by
default. The autosectionlabel_prefix_document
configuration variable can be
used to make headings which appear multiple times but in different documents
unique.
Configuration¶
-
autosectionlabel_prefix_document
¶ True to prefix each section label with the name of the document it is in, followed by a colon. For example,
index:Introduction
for a section calledIntroduction
that appears in documentindex.rst
. Useful for avoiding ambiguity when the same section heading appears in different documents.
sphinx.ext.autosummary
– Generate autodoc summaries¶
New in version 0.6.
This extension generates function/method/attribute summary lists, similar to those output e.g. by Epydoc and other API doc generation tools. This is especially useful when your docstrings are long and detailed, and putting each one of them on a separate page makes them easier to read.
The sphinx.ext.autosummary
extension does this in two parts:
- There is an
autosummary
directive for generating summary listings that contain links to the documented items, and short summary blurbs extracted from their docstrings. - Optionally, the convenience script sphinx-autogen or the new
autosummary_generate
config value can be used to generate short “stub” files for the entries listed in theautosummary
directives. These files by default contain only the correspondingsphinx.ext.autodoc
directive, but can be customized with templates.
-
.. autosummary::
¶ Insert a table that contains links to documented items, and a short summary blurb (the first sentence of the docstring) for each of them.
The
autosummary
directive can also optionally serve as atoctree
entry for the included items. Optionally, stub.rst
files for these items can also be automatically generated.For example,
.. currentmodule:: sphinx .. autosummary:: environment.BuildEnvironment util.relative_uri
produces a table like this:
environment.BuildEnvironment
(app)The environment in which the ReST files are translated. util.relative_uri
(base, to)Return a relative URL from base
toto
.Autosummary preprocesses the docstrings and signatures with the same
autodoc-process-docstring
andautodoc-process-signature
hooks asautodoc
.Options
If you want the
autosummary
table to also serve as atoctree
entry, use thetoctree
option, for example:.. autosummary:: :toctree: DIRNAME sphinx.environment.BuildEnvironment sphinx.util.relative_uri
The
toctree
option also signals to the sphinx-autogen script that stub pages should be generated for the entries listed in this directive. The option accepts a directory name as an argument; sphinx-autogen will by default place its output in this directory. If no argument is given, output is placed in the same directory as the file that contains the directive.If you don’t want the
autosummary
to show function signatures in the listing, include thenosignatures
option:.. autosummary:: :nosignatures: sphinx.environment.BuildEnvironment sphinx.util.relative_uri
You can specify a custom template with the
template
option. For example,.. autosummary:: :template: mytemplate.rst sphinx.environment.BuildEnvironment
would use the template
mytemplate.rst
in yourtemplates_path
to generate the pages for all entries listed. See Customizing templates below.New in version 1.0.
sphinx-autogen – generate autodoc stub pages¶
The sphinx-autogen script can be used to conveniently generate stub
documentation pages for items included in autosummary
listings.
For example, the command
$ sphinx-autogen -o generated *.rst
will read all autosummary
tables in the *.rst
files that have
the :toctree:
option set, and output corresponding stub pages in directory
generated
for all documented items. The generated pages by default contain
text of the form:
sphinx.util.relative_uri
========================
.. autofunction:: sphinx.util.relative_uri
If the -o
option is not given, the script will place the output files in the
directories specified in the :toctree:
options.
For more information, refer to the sphinx-autogen documentation
Generating stub pages automatically¶
If you do not want to create stub pages with sphinx-autogen, you can also use this new config value:
-
autosummary_generate
¶ Boolean indicating whether to scan all found documents for autosummary directives, and to generate stub pages for each.
Can also be a list of documents for which stub pages should be generated.
The new files will be placed in the directories specified in the
:toctree:
options of the directives.
Customizing templates¶
New in version 1.0.
You can customize the stub page templates, in a similar way as the HTML Jinja
templates, see Templating. (TemplateBridge
is not supported.)
Note
If you find yourself spending much time tailoring the stub templates, this may indicate that it’s a better idea to write custom narrative documentation instead.
Autosummary uses the following Jinja template files:
autosummary/base.rst
– fallback templateautosummary/module.rst
– template for modulesautosummary/class.rst
– template for classesautosummary/function.rst
– template for functionsautosummary/attribute.rst
– template for class attributesautosummary/method.rst
– template for class methods
The following variables available in the templates:
-
name
¶ Name of the documented object, excluding the module and class parts.
-
objname
¶ Name of the documented object, excluding the module parts.
-
fullname
¶ Full name of the documented object, including module and class parts.
-
module
¶ Name of the module the documented object belongs to.
-
class
¶ Name of the class the documented object belongs to. Only available for methods and attributes.
-
underline
¶ A string containing
len(full_name) * '='
. Use theunderline
filter instead.
-
members
¶ List containing names of all members of the module or class. Only available for modules and classes.
-
inherited_members
¶ List containing names of all inherited members of class. Only available for classes.
New in version 1.8.0.
-
functions
¶ List containing names of “public” functions in the module. Here, “public” here means that the name does not start with an underscore. Only available for modules.
-
classes
¶ List containing names of “public” classes in the module. Only available for modules.
-
exceptions
¶ List containing names of “public” exceptions in the module. Only available for modules.
-
methods
¶ List containing names of “public” methods in the class. Only available for classes.
-
attributes
¶ List containing names of “public” attributes in the class. Only available for classes.
Additionally, the following filters are available
-
escape
(s)¶ Escape any special characters in the text to be used in formatting RST contexts. For instance, this prevents asterisks making things bold. This replaces the builtin Jinja escape filter that does html-escaping.
-
underline
(s, line='=') Add a title underline to a piece of text.
For instance, {{ fullname | escape | underline }}
should be used to produce
the title of a page.
Note
You can use the autosummary
directive in the stub pages.
Stub pages are generated also based on these directives.
sphinx.ext.coverage
– Collect doc coverage stats¶
This extension features one additional builder, the CoverageBuilder
.
-
class
sphinx.ext.coverage.
CoverageBuilder
[source]¶ To use this builder, activate the coverage extension in your configuration file and give
-b coverage
on the command line.
Todo
Write this section.
Several new configuration values can be used to specify what the builder should check:
-
coverage_ignore_modules
¶
-
coverage_ignore_functions
¶
-
coverage_ignore_classes
¶
-
coverage_c_path
¶
-
coverage_c_regexes
¶
-
coverage_ignore_c_items
¶
-
coverage_write_headline
¶ Set to
False
to not write headlines.New in version 1.1.
-
coverage_skip_undoc_in_source
¶ Skip objects that are not documented in the source with a docstring.
False
by default.New in version 1.1.
sphinx.ext.doctest
– Test snippets in the documentation¶
This extension allows you to test snippets in the documentation in a natural way. It works by collecting specially-marked up code blocks and running them as doctest tests.
Within one document, test code is partitioned in groups, where each group consists of:
- zero or more setup code blocks (e.g. importing the module to test)
- one or more test blocks
When building the docs with the doctest
builder, groups are collected for
each document and run one after the other, first executing setup code blocks,
then the test blocks in the order they appear in the file.
There are two kinds of test blocks:
- doctest-style blocks mimic interactive sessions by interleaving Python code (including the interpreter prompt) and output.
- code-output-style blocks consist of an ordinary piece of Python code, and optionally, a piece of output for that code.
Directives¶
The group argument below is interpreted as follows: if it is empty, the block
is assigned to the group named default
. If it is *
, the block is
assigned to all groups (including the default
group). Otherwise, it must be
a comma-separated list of group names.
-
.. testsetup::
[group]
¶ A setup code block. This code is not shown in the output for other builders, but executed before the doctests of the group(s) it belongs to.
-
.. testcleanup::
[group]
¶ A cleanup code block. This code is not shown in the output for other builders, but executed after the doctests of the group(s) it belongs to.
New in version 1.1.
-
.. doctest::
[group]
¶ A doctest-style code block. You can use standard
doctest
flags for controlling how actual output is compared with what you give as output. The default set of flags is specified by thedoctest_default_flags
configuration variable.This directive supports three options:
hide
, a flag option, hides the doctest block in other builders. By default it is shown as a highlighted doctest block.options
, a string option, can be used to give a comma-separated list of doctest flags that apply to each example in the tests. (You still can give explicit flags per example, with doctest comments, but they will show up in other builders too.)pyversion
, a string option, can be used to specify the required Python version for the example to be tested. For instance, in the following case the example will be tested only for Python versions greather than 3.3:.. doctest:: :pyversion: > 3.3
The following operands are supported:
~=
: Compatible release clause==
: Version matching clause!=
: Version exclusion clause<=
,>=
: Inclusive ordered comparison clause<
,>
: Exclusive ordered comparison clause===
: Arbitrary equality clause.
pyversion
option is followed PEP-440: Version Specifiers.New in version 1.6.
Changed in version 1.7: Supported PEP-440 operands and notations
Note that like with standard doctests, you have to use
<BLANKLINE>
to signal a blank line in the expected output. The<BLANKLINE>
is removed when building presentation output (HTML, LaTeX etc.).Also, you can give inline doctest options, like in doctest:
>>> datetime.date.now() # doctest: +SKIP datetime.date(2008, 1, 1)
They will be respected when the test is run, but stripped from presentation output.
-
.. testcode::
[group]
¶ A code block for a code-output-style test.
This directive supports one option:
hide
, a flag option, hides the code block in other builders. By default it is shown as a highlighted code block.
Note
Code in a
testcode
block is always executed all at once, no matter how many statements it contains. Therefore, output will not be generated for bare expressions – useprint
. Example:.. testcode:: 1+1 # this will give no output! print 2+2 # this will give output .. testoutput:: 4
Also, please be aware that since the doctest module does not support mixing regular output and an exception message in the same snippet, this applies to testcode/testoutput as well.
-
.. testoutput::
[group]
¶ The corresponding output, or the exception message, for the last
testcode
block.This directive supports two options:
hide
, a flag option, hides the output block in other builders. By default it is shown as a literal block without highlighting.options
, a string option, can be used to give doctest flags (comma-separated) just like in normal doctest blocks.
Example:
.. testcode:: print 'Output text.' .. testoutput:: :hide: :options: -ELLIPSIS, +NORMALIZE_WHITESPACE Output text.
The following is an example for the usage of the directives. The test via
doctest
and the test via testcode
and
testoutput
are equivalent.
The parrot module
=================
.. testsetup:: *
import parrot
The parrot module is a module about parrots.
Doctest example:
.. doctest::
>>> parrot.voom(3000)
This parrot wouldn't voom if you put 3000 volts through it!
Test-Output example:
.. testcode::
parrot.voom(3000)
This would output:
.. testoutput::
This parrot wouldn't voom if you put 3000 volts through it!
Skipping tests conditionally¶
skipif
, a string option, can be used to skip directives conditionally. This
may be useful e.g. when a different set of tests should be run depending on the
environment (hardware, network/VPN, optional dependencies or different versions
of dependencies). The skipif
option is supported by all of the doctest
directives. Below are typical use cases for skipif
when used for different
directives:
testsetup
andtestcleanup
- conditionally skip test setup and/or cleanup
- customize setup/cleanup code per environment
doctest
- conditionally skip both a test and its output verification
testcode
- conditionally skip a test
- customize test code per environment
testoutput
- conditionally skip output assertion for a skipped test
- expect different output depending on the environment
The value of the skipif
option is evaluated as a Python expression. If the
result is a true value, the directive is omitted from the test run just as if
it wasn’t present in the file at all.
Instead of repeating an expression, the doctest_global_setup
configuration option can be used to assign it to a variable which can then be
used instead.
Here’s an example which skips some tests if Pandas is not installed:
extensions = ['sphinx.ext.doctest']
doctest_global_setup = '''
try:
import pandas as pd
except ImportError:
pd = None
'''
.. testsetup::
:skipif: pd is None
data = pd.Series([42])
.. doctest::
:skipif: pd is None
>>> data.iloc[0]
42
.. testcode::
:skipif: pd is None
print(data.iloc[-1])
.. testoutput::
:skipif: pd is None
42
Configuration¶
The doctest extension uses the following configuration values:
-
doctest_default_flags
¶ By default, these options are enabled:
ELLIPSIS
, allowing you to put ellipses in the expected output that match anything in the actual output;IGNORE_EXCEPTION_DETAIL
, causing everything following the leftmost colon and any module information in the exception name to be ignored;DONT_ACCEPT_TRUE_FOR_1
, rejecting “True” in the output where “1” is given – the default behavior of accepting this substitution is a relic of pre-Python 2.2 times.
New in version 1.5.
-
doctest_path
¶ A list of directories that will be added to
sys.path
when the doctest builder is used. (Make sure it contains absolute paths.)
-
doctest_global_setup
¶ Python code that is treated like it were put in a
testsetup
directive for every file that is tested, and for every group. You can use this to e.g. import modules you will always need in your doctests.New in version 0.6.
-
doctest_global_cleanup
¶ Python code that is treated like it were put in a
testcleanup
directive for every file that is tested, and for every group. You can use this to e.g. remove any temporary files that the tests leave behind.New in version 1.1.
-
doctest_test_doctest_blocks
¶ If this is a nonempty string (the default is
'default'
), standard reST doctest blocks will be tested too. They will be assigned to the group name given.reST doctest blocks are simply doctests put into a paragraph of their own, like so:
Some documentation text. >>> print 1 1 Some more documentation text.
(Note that no special
::
is used to introduce a doctest block; docutils recognizes them from the leading>>>
. Also, no additional indentation is used, though it doesn’t hurt.)If this value is left at its default value, the above snippet is interpreted by the doctest builder exactly like the following:
Some documentation text. .. doctest:: >>> print 1 1 Some more documentation text.
This feature makes it easy for you to test doctests in docstrings included with the
autodoc
extension without marking them up with a special directive.Note though that you can’t have blank lines in reST doctest blocks. They will be interpreted as one block ending and another one starting. Also, removal of
<BLANKLINE>
and# doctest:
options only works indoctest
blocks, though you may settrim_doctest_flags
to achieve that in all code blocks with Python console content.
sphinx.ext.extlinks
– Markup to shorten external links¶
Module author: Georg Brandl
New in version 1.0.
This extension is meant to help with the common pattern of having many external links that point to URLs on one and the same site, e.g. links to bug trackers, version control web interfaces, or simply subpages in other websites. It does so by providing aliases to base URLs, so that you only need to give the subpage name when creating a link.
Let’s assume that you want to include many links to issues at the Sphinx
tracker, at https://github.com/sphinx-doc/sphinx/issues/num
. Typing
this URL again and again is tedious, so you can use extlinks
to avoid repeating yourself.
The extension adds one new config value:
-
extlinks
¶ This config value must be a dictionary of external sites, mapping unique short alias names to a base URL and a prefix. For example, to create an alias for the above mentioned issues, you would add
extlinks = {'issue': ('https://github.com/sphinx-doc/sphinx/issues/%s', 'issue ')}
Now, you can use the alias name as a new role, e.g.
:issue:`123`
. This then inserts a link to https://github.com/sphinx-doc/sphinx/issues/123. As you can see, the target given in the role is substituted in the base URL in the place of%s
.The link caption depends on the second item in the tuple, the prefix:
- If the prefix is
None
, the link caption is the full URL. - If the prefix is the empty string, the link caption is the partial URL
given in the role content (
123
in this case.) - If the prefix is a non-empty string, the link caption is the partial URL,
prepended by the prefix – in the above example, the link caption would be
issue 123
.
You can also use the usual “explicit title” syntax supported by other roles that generate links, i.e.
:issue:`this issue <123>`
. In this case, the prefix is not relevant.- If the prefix is
Note
Since links are generated from the role in the reading stage, they appear as
ordinary links to e.g. the linkcheck
builder.
sphinx.ext.githubpages
– Publish HTML docs in GitHub Pages¶
New in version 1.4.
This extension creates .nojekyll
file on generated HTML directory to publish
the document on GitHub Pages.
sphinx.ext.graphviz
– Add Graphviz graphs¶
New in version 0.6.
This extension allows you to embed Graphviz graphs in your documents.
It adds these directives:
-
.. graphviz::
¶ Directive to embed graphviz code. The input code for
dot
is given as the content. For example:.. graphviz:: digraph foo { "bar" -> "baz"; }
In HTML output, the code will be rendered to a PNG or SVG image (see
graphviz_output_format
). In LaTeX output, the code will be rendered to an embeddable PDF file.You can also embed external dot files, by giving the file name as an argument to
graphviz
and no additional content:.. graphviz:: external.dot
As for all file references in Sphinx, if the filename is absolute, it is taken as relative to the source directory.
Changed in version 1.1: Added support for external files.
-
.. graph::
¶ Directive for embedding a single undirected graph. The name is given as a directive argument, the contents of the graph are the directive content. This is a convenience directive to generate
graph <name> { <content> }
.For example:
.. graph:: foo "bar" -- "baz";
Note
The graph name is passed unchanged to Graphviz. If it contains non-alphanumeric characters (e.g. a dash), you will have to double-quote it.
-
.. digraph::
¶ Directive for embedding a single directed graph. The name is given as a directive argument, the contents of the graph are the directive content. This is a convenience directive to generate
digraph <name> { <content> }
.For example:
.. digraph:: foo "bar" -> "baz" -> "quux";
New in version 1.0: All three directives support an alt
option that determines the image’s
alternate text for HTML output. If not given, the alternate text defaults to
the graphviz code.
New in version 1.1: All three directives support a caption
option that can be used to give a
caption to the diagram.
Changed in version 1.4: All three directives support a graphviz_dot
option that can be switch the
dot
command within the directive.
New in version 1.5: All three directives support a align
option to align the graph horizontal.
The values “left”, “center”, “right” are allowed.
New in version 1.6: All three directives support a name
option to set the label to graph.
There are also these new config values:
-
graphviz_dot
¶ The command name with which to invoke
dot
. The default is'dot'
; you may need to set this to a full path ifdot
is not in the executable search path.Since this setting is not portable from system to system, it is normally not useful to set it in
conf.py
; rather, giving it on the sphinx-build command line via the-D
option should be preferable, like this:sphinx-build -b html -D graphviz_dot=C:\graphviz\bin\dot.exe . _build/html
-
graphviz_dot_args
¶ Additional command-line arguments to give to dot, as a list. The default is an empty list. This is the right place to set global graph, node or edge attributes via dot’s
-G
,-N
and-E
options.
-
graphviz_output_format
¶ The output format for Graphviz when building HTML files. This must be either
'png'
or'svg'
; the default is'png'
. If'svg'
is used, in order to make the URL links work properly, an appropriatetarget
attribute must be set, such as"_top"
and"_blank"
. For example, the link in the following graph should work in the svg output:.. graphviz:: digraph example { a [label="sphinx", href="http://sphinx-doc.org", target="_top"]; b [label="other"]; a -> b; }
New in version 1.0: Previously, output always was PNG.
sphinx.ext.ifconfig
– Include content based on configuration¶
This extension is quite simple, and features only one directive:
-
.. ifconfig::
¶ Include content of the directive only if the Python expression given as an argument is
True
, evaluated in the namespace of the project’s configuration (that is, all registered variables fromconf.py
are available).For example, one could write
.. ifconfig:: releaselevel in ('alpha', 'beta', 'rc') This stuff is only included in the built docs for unstable versions.
To make a custom config value known to Sphinx, use
add_config_value()
in the setup function inconf.py
, e.g.:def setup(app): app.add_config_value('releaselevel', '', 'env')
The second argument is the default value, the third should always be
'env'
for such values (it selects if Sphinx re-reads the documents if the value changes).
sphinx.ext.imgconverter
– A reference image converter using Imagemagick¶
New in version 1.6.
This extension converts images in your document to appropriate format for builders. For example, it allows you to use SVG images with LaTeX builder. As a result, you don’t mind what image format the builder supports.
Internally, this extension uses Imagemagick to convert images.
Note
Imagemagick rasterizes a SVG image on conversion. As a result, the image
becomes not scalable. To avoid that, please use other image converters like
sphinxcontrib-svg2pdfconverter (which uses Inkscape or
rsvg-convert
).
sphinx.ext.inheritance_diagram
– Include inheritance diagrams¶
New in version 0.6.
This extension allows you to include inheritance diagrams, rendered via the
Graphviz extension
.
It adds this directive:
-
.. inheritance-diagram::
¶ This directive has one or more arguments, each giving a module or class name. Class names can be unqualified; in that case they are taken to exist in the currently described module (see
py:module
).For each given class, and each class in each given module, the base classes are determined. Then, from all classes and their base classes, a graph is generated which is then rendered via the graphviz extension to a directed graph.
This directive supports an option called
parts
that, if given, must be an integer, advising the directive to remove that many parts of module names from the displayed names. (For example, if all your class names start withlib.
, you can give:parts: 1
to remove that prefix from the displayed node names.)It also supports a
private-bases
flag option; if given, private base classes (those whose name starts with_
) will be included.You can use
caption
option to give a caption to the diagram.Changed in version 1.1: Added
private-bases
option; previously, all bases were always included.Changed in version 1.5: Added
caption
optionIt also supports a
top-classes
option which requires one or more class names separated by comma. If specified inheritance traversal will stop at the specified class names. Given the following Python module:""" A / \ B C / \ / \ E D F """ class A(object): pass class B(A): pass class C(A): pass class D(B, C): pass class E(B): pass class F(C): pass
If you have specified a module in the inheritance diagram like this:
.. inheritance-diagram:: dummy.test :top-classes: dummy.test.B, dummy.test.C
any base classes which are ancestors to
top-classes
and are also defined in the same module will be rendered as stand alone nodes. In this example class A will be rendered as stand alone node in the graph. This is a known issue due to how this extension works internally.If you don’t want class A (or any other ancestors) to be visible then specify only the classes you would like to generate the diagram for like this:
.. inheritance-diagram:: dummy.test.D dummy.test.E dummy.test.F :top-classes: dummy.test.B, dummy.test.C
Changed in version 1.7: Added
top-classes
option to limit the scope of inheritance graphs.
Configuration¶
-
inheritance_graph_attrs
¶ A dictionary of graphviz graph attributes for inheritance diagrams.
For example:
inheritance_graph_attrs = dict(rankdir="LR", size='"6.0, 8.0"', fontsize=14, ratio='compress')
-
inheritance_node_attrs
¶ A dictionary of graphviz node attributes for inheritance diagrams.
For example:
inheritance_node_attrs = dict(shape='ellipse', fontsize=14, height=0.75, color='dodgerblue1', style='filled')
-
inheritance_edge_attrs
¶ A dictionary of graphviz edge attributes for inheritance diagrams.
-
inheritance_alias
¶ Allows mapping the full qualified name of the class to custom values (useful when exposing the underlying path of a class is not desirable, e.g. it’s a private class and should not be instantiated by the user).
For example:
inheritance_alias = {'_pytest.Magic': 'pytest.Magic'}
sphinx.ext.intersphinx
– Link to other projects’ documentation¶
New in version 0.5.
This extension can generate automatic links to the documentation of objects in other projects.
Usage is simple: whenever Sphinx encounters a cross-reference that has no
matching target in the current documentation set, it looks for targets in the
documentation sets configured in intersphinx_mapping
. A reference
like :py:class:`zipfile.ZipFile`
can then link to the Python documentation
for the ZipFile class, without you having to specify where it is located
exactly.
When using the “new” format (see below), you can even force lookup in a foreign
set by prefixing the link target appropriately. A link like :ref:`comparison
manual <python:comparisons>`
will then link to the label “comparisons” in the
doc set “python”, if it exists.
Behind the scenes, this works as follows:
- Each Sphinx HTML build creates a file named
objects.inv
that contains a mapping from object names to URIs relative to the HTML set’s root. - Projects using the Intersphinx extension can specify the location of such
mapping files in the
intersphinx_mapping
config value. The mapping will then be used to resolve otherwise missing references to objects into links to the other documentation. - By default, the mapping file is assumed to be at the same location as the rest of the documentation; however, the location of the mapping file can also be specified individually, e.g. if the docs should be buildable without Internet access.
Configuration¶
To use Intersphinx linking, add 'sphinx.ext.intersphinx'
to your
extensions
config value, and use these new config values to activate
linking:
-
intersphinx_mapping
¶ This config value contains the locations and names of other projects that should be linked to in this documentation.
Relative local paths for target locations are taken as relative to the base of the built documentation, while relative local paths for inventory locations are taken as relative to the source directory.
When fetching remote inventory files, proxy settings will be read from the
$HTTP_PROXY
environment variable.Old format for this config value
This is the format used before Sphinx 1.0. It is still recognized.
A dictionary mapping URIs to either
None
or an URI. The keys are the base URI of the foreign Sphinx documentation sets and can be local paths or HTTP URIs. The values indicate where the inventory file can be found: they can beNone
(at the same location as the base URI) or another local or HTTP URI.New format for this config value
New in version 1.0.
A dictionary mapping unique identifiers to a tuple
(target, inventory)
. Eachtarget
is the base URI of a foreign Sphinx documentation set and can be a local path or an HTTP URI. Theinventory
indicates where the inventory file can be found: it can beNone
(at the same location as the base URI) or another local or HTTP URI.The unique identifier can be used to prefix cross-reference targets, so that it is clear which intersphinx set the target belongs to. A link like
:ref:`comparison manual <python:comparisons>`
will link to the label “comparisons” in the doc set “python”, if it exists.Example
To add links to modules and objects in the Python standard library documentation, use:
intersphinx_mapping = {'python': ('https://docs.python.org/3', None)}
This will download the corresponding
objects.inv
file from the Internet and generate links to the pages under the given URI. The downloaded inventory is cached in the Sphinx environment, so it must be re-downloaded whenever you do a full rebuild.A second example, showing the meaning of a non-
None
value of the second tuple item:intersphinx_mapping = {'python': ('https://docs.python.org/3', 'python-inv.txt')}
This will read the inventory from
python-inv.txt
in the source directory, but still generate links to the pages underhttps://docs.python.org/3
. It is up to you to update the inventory file as new objects are added to the Python documentation.Multiple target for the inventory
New in version 1.3.
Alternative files can be specified for each inventory. One can give a tuple for the second inventory tuple item as shown in the following example. This will read the inventory iterating through the (second) tuple items until the first successful fetch. The primary use case for this to specify mirror sites for server downtime of the primary inventory:
intersphinx_mapping = {'python': ('https://docs.python.org/3', (None, 'python-inv.txt'))}
-
intersphinx_cache_limit
¶ The maximum number of days to cache remote inventories. The default is
5
, meaning five days. Set this to a negative value to cache inventories for unlimited time.
-
intersphinx_timeout
¶ The number of seconds for timeout. The default is
None
, meaning do not timeout.Note
timeout is not a time limit on the entire response download; rather, an exception is raised if the server has not issued a response for timeout seconds.
Showing all links of an Intersphinx mapping file¶
To show all Intersphinx links and their targets of an Intersphinx mapping file,
run python -msphinx.ext.intersphinx url-or-path
. This is helpful when
searching for the root cause of a broken Intersphinx link in a documentation
project. The following example prints the Intersphinx mapping of the Python 3
documentation:
$ python -msphinx.ext.intersphinx https://docs.python.org/3/objects.inv
sphinx.ext.linkcode
– Add external links to source code¶
Module author: Pauli Virtanen
New in version 1.2.
This extension looks at your object descriptions (.. class::
,
.. function::
etc.) and adds external links to code hosted
somewhere on the web. The intent is similar to the
sphinx.ext.viewcode
extension, but assumes the source code can be
found somewhere on the Internet.
In your configuration, you need to specify a linkcode_resolve
function that returns an URL based on the object.
Configuration¶
-
linkcode_resolve
¶ This is a function
linkcode_resolve(domain, info)
, which should return the URL to source code corresponding to the object in given domain with given information.The function should return
None
if no link is to be added.The argument
domain
specifies the language domain the object is in.info
is a dictionary with the following keys guaranteed to be present (dependent on the domain):py
:module
(name of the module),fullname
(name of the object)c
:names
(list of names for the object)cpp
:names
(list of names for the object)javascript
:object
(name of the object),fullname
(name of the item)
Example:
def linkcode_resolve(domain, info): if domain != 'py': return None if not info['module']: return None filename = info['module'].replace('.', '/') return "https://somesite/sourcerepo/%s.py" % filename
Math support for HTML outputs in Sphinx¶
New in version 0.5.
Changed in version 1.8: Math support for non-HTML builders is integrated to sphinx-core. So mathbase extension is no longer needed.
Since mathematical notation isn’t natively supported by HTML in any way, Sphinx gives a math support to HTML document with several extensions.
sphinx.ext.imgmath
– Render math as images¶
New in version 1.4.
This extension renders math via LaTeX and dvipng or dvisvgm into PNG or SVG images. This of course means that the computer where the docs are built must have both programs available.
There are various config values you can set to influence how the images are built:
-
imgmath_image_format
¶ The output image format. The default is
'png'
. It should be either'png'
or'svg'
.
-
imgmath_latex
¶ The command name with which to invoke LaTeX. The default is
'latex'
; you may need to set this to a full path iflatex
is not in the executable search path.Since this setting is not portable from system to system, it is normally not useful to set it in
conf.py
; rather, giving it on the sphinx-build command line via the-D
option should be preferable, like this:sphinx-build -b html -D imgmath_latex=C:\tex\latex.exe . _build/html
This value should only contain the path to the latex executable, not further arguments; use
imgmath_latex_args
for that purpose.
-
imgmath_dvipng
¶ The command name with which to invoke
dvipng
. The default is'dvipng'
; you may need to set this to a full path ifdvipng
is not in the executable search path. This option is only used whenimgmath_image_format
is set to'png'
.
-
imgmath_dvisvgm
¶ The command name with which to invoke
dvisvgm
. The default is'dvisvgm'
; you may need to set this to a full path ifdvisvgm
is not in the executable search path. This option is only used whenimgmath_image_format
is'svg'
.
-
imgmath_latex_args
¶ Additional arguments to give to latex, as a list. The default is an empty list.
-
imgmath_latex_preamble
¶ Additional LaTeX code to put into the preamble of the short LaTeX files that are used to translate the math snippets. This is empty by default. Use it e.g. to add more packages whose commands you want to use in the math.
-
imgmath_dvipng_args
¶ Additional arguments to give to dvipng, as a list. The default value is
['-gamma', '1.5', '-D', '110', '-bg', 'Transparent']
which makes the image a bit darker and larger then it is by default, and produces PNGs with a transparent background. This option is used only whenimgmath_image_format
is'png'
.
-
imgmath_dvisvgm_args
¶ Additional arguments to give to dvisvgm, as a list. The default value is
['--no-fonts']
. This option is used only whenimgmath_image_format
is'svg'
.
-
imgmath_use_preview
¶ dvipng
has the ability to determine the “depth” of the rendered text: for example, when typesetting a fraction inline, the baseline of surrounding text should not be flush with the bottom of the image, rather the image should extend a bit below the baseline. This is what TeX calls “depth”. When this is enabled, the images put into the HTML document will get avertical-align
style that correctly aligns the baselines.Unfortunately, this only works when the preview-latex package is installed. Therefore, the default for this option is
False
.Currently this option is only used when
imgmath_image_format
is'png'
.
-
imgmath_add_tooltips
¶ Default:
True
. If false, do not add the LaTeX code as an “alt” attribute for math images.
-
imgmath_font_size
¶ The font size (in
pt
) of the displayed math. The default value is12
. It must be a positive integer.
sphinx.ext.mathjax
– Render math via JavaScript¶
New in version 1.1.
This extension puts math as-is into the HTML files. The JavaScript package MathJax is then loaded and transforms the LaTeX markup to readable math live in the browser.
Because MathJax (and the necessary fonts) is very large, it is not included in Sphinx.
-
mathjax_path
¶ The path to the JavaScript file to include in the HTML files in order to load MathJax.
The default is the
https://
URL that loads the JS files from the cdnjs Content Delivery Network. See the MathJax Getting Started page for details. If you want MathJax to be available offline, you have to download it and set this value to a different path.The path can be absolute or relative; if it is relative, it is relative to the
_static
directory of the built docs.For example, if you put MathJax into the static path of the Sphinx docs, this value would be
MathJax/MathJax.js
. If you host more than one Sphinx documentation set on one server, it is advisable to install MathJax in a shared location.You can also give a full
https://
URL different from the CDN URL.
-
mathjax_options
¶ The options to script tag for mathjax. For example, you can set integrity option with following setting:
mathjax_options = { 'integrity': 'sha384-......', }
The default is empty (
{}
).
-
mathjax_config
¶ The inline configuration options for mathjax. The value is used as a parameter of
MathJax.Hub.Config()
. For more information, please read Using in-line configuration options.For example:
mathjax_config = { 'extensions': ['tex2jax.js'], 'jax': ['input/TeX', 'output/HTML-CSS'], }
The default is empty (not configured).
sphinx.ext.jsmath
– Render math via JavaScript¶
This extension works just as the MathJax extension does, but uses the older package jsMath. It provides this config value:
-
jsmath_path
¶ The path to the JavaScript file to include in the HTML files in order to load JSMath. There is no default.
The path can be absolute or relative; if it is relative, it is relative to the
_static
directory of the built docs.For example, if you put JSMath into the static path of the Sphinx docs, this value would be
jsMath/easy/load.js
. If you host more than one Sphinx documentation set on one server, it is advisable to install jsMath in a shared location.
sphinx.ext.napoleon
– Support for NumPy and Google style docstrings¶
Module author: Rob Ruana
New in version 1.3.
Overview¶
Are you tired of writing docstrings that look like this:
:param path: The path of the file to wrap
:type path: str
:param field_storage: The :class:`FileStorage` instance to wrap
:type field_storage: FileStorage
:param temporary: Whether or not to delete the file when the File
instance is destructed
:type temporary: bool
:returns: A buffered writable file descriptor
:rtype: BufferedFileStorage
reStructuredText is great, but it creates visually dense, hard to read docstrings. Compare the jumble above to the same thing rewritten according to the Google Python Style Guide:
Args:
path (str): The path of the file to wrap
field_storage (FileStorage): The :class:`FileStorage` instance to wrap
temporary (bool): Whether or not to delete the file when the File
instance is destructed
Returns:
BufferedFileStorage: A buffered writable file descriptor
Much more legible, no?
Napoleon is a extension that enables Sphinx to parse both NumPy and Google style docstrings - the style recommended by Khan Academy.
Napoleon is a pre-processor that parses NumPy and Google style docstrings and converts them to reStructuredText before Sphinx attempts to parse them. This happens in an intermediate step while Sphinx is processing the documentation, so it doesn’t modify any of the docstrings in your actual source code files.
Getting Started¶
After setting up Sphinx to build your docs, enable napoleon in the Sphinx conf.py file:
# conf.py # Add napoleon to the extensions list extensions = ['sphinx.ext.napoleon']
Use sphinx-apidoc to build your API documentation:
$ sphinx-apidoc -f -o docs/source projectdir
Docstrings¶
Napoleon interprets every docstring that autodoc
can find, including docstrings on: modules
, classes
, attributes
,
methods
, functions
, and variables
. Inside each docstring,
specially formatted Sections are parsed and converted to
reStructuredText.
All standard reStructuredText formatting still works as expected.
Docstring Sections¶
All of the following section headers are supported:
Args
(alias of Parameters)Arguments
(alias of Parameters)Attention
Attributes
Caution
Danger
Error
Example
Examples
Hint
Important
Keyword Args
(alias of Keyword Arguments)Keyword Arguments
Methods
Note
Notes
Other Parameters
Parameters
Return
(alias of Returns)Returns
Raises
References
See Also
Tip
Todo
Warning
Warnings
(alias of Warning)Warns
Yield
(alias of Yields)Yields
Google vs NumPy¶
Napoleon supports two styles of docstrings: Google and NumPy. The main difference between the two styles is that Google uses indention to separate sections, whereas NumPy uses underlines.
Google style:
def func(arg1, arg2):
"""Summary line.
Extended description of function.
Args:
arg1 (int): Description of arg1
arg2 (str): Description of arg2
Returns:
bool: Description of return value
"""
return True
NumPy style:
def func(arg1, arg2):
"""Summary line.
Extended description of function.
Parameters
----------
arg1 : int
Description of arg1
arg2 : str
Description of arg2
Returns
-------
bool
Description of return value
"""
return True
NumPy style tends to require more vertical space, whereas Google style tends to use more horizontal space. Google style tends to be easier to read for short and simple docstrings, whereas NumPy style tends be easier to read for long and in-depth docstrings.
The Khan Academy recommends using Google style.
The choice between styles is largely aesthetic, but the two styles should not be mixed. Choose one style for your project and be consistent with it.
See also
For complete examples:
Type Annotations¶
PEP 484 introduced a standard way to express types in Python code. This is an alternative to expressing types directly in docstrings. One benefit of expressing types according to PEP 484 is that type checkers and IDEs can take advantage of them for static code analysis.
Google style with Python 3 type annotations:
def func(arg1: int, arg2: str) -> bool:
"""Summary line.
Extended description of function.
Args:
arg1: Description of arg1
arg2: Description of arg2
Returns:
Description of return value
"""
return True
Google style with types in docstrings:
def func(arg1, arg2):
"""Summary line.
Extended description of function.
Args:
arg1 (int): Description of arg1
arg2 (str): Description of arg2
Returns:
bool: Description of return value
"""
return True
Note
Python 2/3 compatible annotations aren’t currently supported by Sphinx and won’t show up in the docs.
Configuration¶
Listed below are all the settings used by napoleon and their default values. These settings can be changed in the Sphinx conf.py file. Make sure that “sphinx.ext.napoleon” is enabled in conf.py:
# conf.py
# Add any Sphinx extension module names here, as strings
extensions = ['sphinx.ext.napoleon']
# Napoleon settings
napoleon_google_docstring = True
napoleon_numpy_docstring = True
napoleon_include_init_with_doc = False
napoleon_include_private_with_doc = False
napoleon_include_special_with_doc = True
napoleon_use_admonition_for_examples = False
napoleon_use_admonition_for_notes = False
napoleon_use_admonition_for_references = False
napoleon_use_ivar = False
napoleon_use_param = True
napoleon_use_rtype = True
-
napoleon_google_docstring
¶ True to parse Google style docstrings. False to disable support for Google style docstrings. Defaults to True.
-
napoleon_numpy_docstring
¶ True to parse NumPy style docstrings. False to disable support for NumPy style docstrings. Defaults to True.
-
napoleon_include_init_with_doc
¶ True to list
__init___
docstrings separately from the class docstring. False to fall back to Sphinx’s default behavior, which considers the__init___
docstring as part of the class documentation. Defaults to False.If True:
def __init__(self): \"\"\" This will be included in the docs because it has a docstring \"\"\" def __init__(self): # This will NOT be included in the docs
-
napoleon_include_private_with_doc
¶ True to include private members (like
_membername
) with docstrings in the documentation. False to fall back to Sphinx’s default behavior. Defaults to False.If True:
def _included(self): """ This will be included in the docs because it has a docstring """ pass def _skipped(self): # This will NOT be included in the docs pass
-
napoleon_include_special_with_doc
¶ True to include special members (like
__membername__
) with docstrings in the documentation. False to fall back to Sphinx’s default behavior. Defaults to True.If True:
def __str__(self): """ This will be included in the docs because it has a docstring """ return unicode(self).encode('utf-8') def __unicode__(self): # This will NOT be included in the docs return unicode(self.__class__.__name__)
-
napoleon_use_admonition_for_examples
¶ True to use the
.. admonition::
directive for the Example and Examples sections. False to use the.. rubric::
directive instead. One may look better than the other depending on what HTML theme is used. Defaults to False.This NumPy style snippet will be converted as follows:
Example ------- This is just a quick example
If True:
.. admonition:: Example This is just a quick example
If False:
.. rubric:: Example This is just a quick example
-
napoleon_use_admonition_for_notes
¶ True to use the
.. admonition::
directive for Notes sections. False to use the.. rubric::
directive instead. Defaults to False.Note
The singular Note section will always be converted to a
.. note::
directive.See also
napoleon_use_admonition_for_examples
-
napoleon_use_admonition_for_references
¶ True to use the
.. admonition::
directive for References sections. False to use the.. rubric::
directive instead. Defaults to False.See also
napoleon_use_admonition_for_examples
-
napoleon_use_ivar
¶ True to use the
:ivar:
role for instance variables. False to use the.. attribute::
directive instead. Defaults to False.This NumPy style snippet will be converted as follows:
Attributes ---------- attr1 : int Description of `attr1`
If True:
:ivar attr1: Description of `attr1` :vartype attr1: int
If False:
.. attribute:: attr1 *int* Description of `attr1`
-
napoleon_use_param
¶ True to use a
:param:
role for each function parameter. False to use a single:parameters:
role for all the parameters. Defaults to True.This NumPy style snippet will be converted as follows:
Parameters ---------- arg1 : str Description of `arg1` arg2 : int, optional Description of `arg2`, defaults to 0
If True:
:param arg1: Description of `arg1` :type arg1: str :param arg2: Description of `arg2`, defaults to 0 :type arg2: int, optional
If False:
:parameters: * **arg1** (*str*) -- Description of `arg1` * **arg2** (*int, optional*) -- Description of `arg2`, defaults to 0
-
napoleon_use_keyword
¶ True to use a
:keyword:
role for each function keyword argument. False to use a single:keyword arguments:
role for all the keywords. Defaults to True.This behaves similarly to
napoleon_use_param
. Note unlike docutils,:keyword:
and:param:
will not be treated the same way - there will be a separate “Keyword Arguments” section, rendered in the same fashion as “Parameters” section (type links created if possible)See also
napoleon_use_param
-
napoleon_use_rtype
¶ True to use the
:rtype:
role for the return type. False to output the return type inline with the description. Defaults to True.This NumPy style snippet will be converted as follows:
Returns ------- bool True if successful, False otherwise
If True:
:returns: True if successful, False otherwise :rtype: bool
If False:
:returns: *bool* -- True if successful, False otherwise
sphinx.ext.todo
– Support for todo items¶
Module author: Daniel Bültmann
New in version 0.5.
There are two additional directives when using this extension:
-
.. todo::
¶ Use this directive like, for example,
note
.It will only show up in the output if
todo_include_todos
isTrue
.New in version 1.3.2: This directive supports an
class
option that determines the class attribute for HTML output. If not given, the class defaults toadmonition-todo
.
-
.. todolist::
¶ This directive is replaced by a list of all todo directives in the whole documentation, if
todo_include_todos
isTrue
.
These can be configured as seen below.
Configuration¶
-
todo_include_todos
¶ If this is
True
,todo
andtodolist
produce output, else they produce nothing. The default isFalse
.
-
todo_emit_warnings
¶ If this is
True
,todo
emits a warning for each TODO entries. The default isFalse
.New in version 1.5.
-
todo_link_only
¶ If this is
True
,todolist
produce output without file path and line, The default isFalse
.New in version 1.4.
autodoc provides the following an additional event:
-
todo-defined
(app, node)¶ New in version 1.5.
Emitted when a todo is defined. node is the defined
sphinx.ext.todo.todo_node
node.
sphinx.ext.viewcode
– Add links to highlighted source code¶
Module author: Georg Brandl
New in version 1.0.
This extension looks at your Python object descriptions (.. class::
, ..
function::
etc.) and tries to find the source files where the objects are
contained. When found, a separate HTML page will be output for each module with
a highlighted version of the source code, and a link will be added to all object
descriptions that leads to the source code of the described object. A link back
from the source to the description will also be inserted.
Warning
Basically, viewcode
extension will import the modules being linked to.
If any modules have side effects on import, these will be executed when
sphinx-build
is run.
If you document scripts (as opposed to library modules), make sure their
main routine is protected by a if __name__ == '__main__'
condition.
In addition, if you don’t want to import the modules by viewcode
,
you can tell the location of the location of source code to viewcode
using the viewcode-find-source
event.
If viewcode_follow_imported_members
is enabled,
you will also need to resolve imported attributes
using the viewcode-follow-imported
event.
This extension works only on HTML related builders like html
,
applehelp
, devhelp
, htmlhelp
, qthelp
and so on except
singlehtml
. By default epub
builder doesn’t
support this extension (see viewcode_enable_epub
).
Configuration¶
-
viewcode_follow_imported_members
¶ If this is
True
, viewcode extension will follow alias objects that imported from another module such as functions, classes and attributes. As side effects, this option else they produce nothing. The default isTrue
.New in version 1.3.
Changed in version 1.8: Renamed from
viewcode_import
toviewcode_follow_imported_members
.
-
viewcode_enable_epub
¶ If this is
True
, viewcode extension is also enabled even if you use epub builders. This extension generates pages outside toctree, but this is not preferred as epub format.Until 1.4.x, this extension is always enabled. If you want to generate epub as same as 1.4.x, you should set
True
, but epub format checker’s score becomes worse.The default is
False
.New in version 1.5.
Warning
Not all epub readers support pages generated by viewcode extension. These readers ignore links to pages are not under toctree.
Some reader’s rendering result are corrupted and epubcheck’s score becomes worse even if the reader supports.
-
viewcode-find-source
(app, modname)¶ New in version 1.8.
Find the source code for a module. An event handler for this event should return a tuple of the source code itself and a dictionary of tags. The dictionary maps the name of a class, function, attribute, etc to a tuple of its type, the start line number, and the end line number. The type should be one of “class”, “def”, or “other”.
Parameters: - app – The Sphinx application object.
- modname – The name of the module to find source code for.
-
viewcode-follow-imported
(app, modname, attribute)¶ New in version 1.8.
Find the name of the original module for an attribute.
Parameters: - app – The Sphinx application object.
- modname – The name of the module that the attribute belongs to.
- attribute – The name of the member to follow.
Third-party extensions¶
Todo
This should reference the GitHub organization now
You can find several extensions contributed by users in the Sphinx Contrib repository. It is open for anyone who wants to maintain an extension publicly; just send a short message asking for write permissions.
There are also several extensions hosted elsewhere. The Sphinx extension survey and awesome-sphinxdoc contains a comprehensive list.
If you write an extension that you think others will find useful or you think should be included as a part of Sphinx, please write to the project mailing list (join here).
Where to put your own extensions?¶
Extensions local to a project should be put within the project’s directory
structure. Set Python’s module search path, sys.path
, accordingly so that
Sphinx can find them. For example, if your extension foo.py
lies in the
exts
subdirectory of the project root, put into conf.py
:
import sys, os
sys.path.append(os.path.abspath('exts'))
extensions = ['foo']
You can also install extensions anywhere else on sys.path
, e.g. in the
site-packages
directory.
Introduction¶
This is the documentation for the Sphinx documentation builder. Sphinx is a tool that translates a set of reStructuredText source files into various output formats, automatically producing cross-references, indices, etc. That is, if you have a directory containing a bunch of reST-formatted documents (and possibly subdirectories of docs in there as well), Sphinx can generate a nicely-organized arrangement of HTML files (in some other directory) for easy browsing and navigation. But from the same source, it can also generate a PDF file using LaTeX.
The focus is on hand-written documentation, rather than auto-generated API docs. Though there is support for that kind of documentation as well (which is intended to be freely mixed with hand-written content), if you need pure API docs have a look at Epydoc, which also understands reST.
For a great “introduction” to writing docs in general – the whys and hows, see also Write the docs, written by Eric Holscher.
Conversion from other systems¶
This section is intended to collect helpful hints for those wanting to migrate to reStructuredText/Sphinx from other documentation systems.
- Gerard Flanagan has written a script to convert pure HTML to reST; it can be found at the Python Package Index.
- For converting the old Python docs to Sphinx, a converter was written which can be found at the Python SVN repository. It contains generic code to convert Python-doc-style LaTeX markup to Sphinx reST.
- Marcin Wojdyr has written a script to convert Docbook to reST with Sphinx markup; it is at GitHub.
- Christophe de Vienne wrote a tool to convert from Open/LibreOffice documents to Sphinx: odt2sphinx.
- To convert different markups, Pandoc is a very helpful tool.
Use with other systems¶
See the pertinent section in the FAQ list.
Prerequisites¶
Sphinx needs at least Python 2.7 or Python 3.4 to run, as well as the docutils and Jinja2 libraries. Sphinx should work with docutils version 0.10 or some (not broken) SVN trunk snapshot. If you like to have source code highlighting support, you must also install the Pygments library.
Usage¶
See Getting Started for an introduction. It also contains links to more advanced sections in this manual for the topics it discusses.
Man Pages¶
These are the applications provided as part of Sphinx.
Core Applications¶
sphinx-quickstart¶
Synopsis¶
sphinx-quickstart
Description¶
sphinx-quickstart is an interactive tool that asks some questions about your project and then generates a complete documentation directory and sample Makefile to be used with sphinx-build(1).
Options¶
-
-q
,
--quiet
¶
Quiet mode that will skip interactive wizard to specify options. This option requires -p, -a and -v options.
-
-h
,
--help
,
--version
¶
Display usage summary or Sphinx version.
Structure Options
-
--sep
¶
If specified, separate source and build directories.
-
--dot
=DOT
¶ Inside the root directory, two more directories will be created; “_templates” for custom HTML templates and “_static” for custom stylesheets and other static files. You can enter another prefix (such as “.”) to replace the underscore.
Project Basic Options
-
--suffix
=SUFFIX
¶ Source file suffix. (see
source_suffix
).
-
--master
=MASTER
¶ Master document name. (see
master_doc
).
-
--epub
¶
Use epub.
Extension Options
-
--ext-autodoc
¶
Enable sphinx.ext.autodoc extension.
-
--ext-doctest
¶
Enable sphinx.ext.doctest extension.
-
--ext-intersphinx
¶
Enable sphinx.ext.intersphinx extension.
-
--ext-todo
¶
Enable sphinx.ext.todo extension.
-
--ext-coverage
¶
Enable sphinx.ext.coverage extension.
-
--ext-imgmath
¶
Enable sphinx.ext.imgmath extension.
-
--ext-mathjax
¶
Enable sphinx.ext.mathjax extension.
-
--ext-ifconfig
¶
Enable sphinx.ext.ifconfig extension.
-
--ext-viewcode
¶
Enable sphinx.ext.viewcode extension.
-
--ext-githubpages
¶
Enable sphinx.ext.githubpages extension.
-
--extensions
=EXTENSIONS
¶ Enable arbitrary extensions.
Makefile and Batchfile Creation Options
-
--use-make-mode
(-m)
,
--no-use-make-mode
(-M)
¶ Makefile/make.bat
uses (or doesn’t use) make-mode. Default isuse
, which generates a more conciseMakefile/make.bat
.Changed in version 1.5: make-mode is default.
-
--makefile
,
--no-makefile
¶
Create (or not create) makefile.
-
--batchfile
,
--no-batchfile
¶
Create (or not create) batchfile
Project templating
New in version 1.5: Project templating options for sphinx-quickstart
-
-t
,
--templatedir
=TEMPLATEDIR
¶ Template directory for template files. You can modify the templates of sphinx project files generated by quickstart. Following Jinja2 template files are allowed:
master_doc.rst_t
conf.py_t
Makefile_t
Makefile.new_t
make.bat_t
make.bat.new_t
In detail, please refer the system template files Sphinx provides. (
sphinx/templates/quickstart
)
-
-d
NAME=VALUE
¶ Define a template variable
See also¶
sphinx-build(1)
sphinx-build¶
Synopsis¶
sphinx-build [options] <sourcedir> <outputdir> [filenames …]
Description¶
sphinx-build generates documentation from the files in
<sourcedir>
and places it in the <outputdir>
.
sphinx-build looks for <sourcedir>/conf.py
for the configuration
settings. sphinx-quickstart(1) 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.
For a list of available options, refer to sphinx-build -b
.
Options¶
-
-b
buildername
¶ The most important option: it selects a builder. The most common builders are:
- html
- Build HTML pages. This is the default builder.
- dirhtml
- Build HTML pages, but with a single directory per document. Makes for
prettier URLs (no
.html
) if served from a webserver. - singlehtml
- Build a single HTML with the whole content.
- htmlhelp, qthelp, devhelp, epub
- Build HTML files with additional information for building a documentation collection in one of these formats.
- applehelp
- Build an Apple Help Book. Requires hiutil and codesign, which are not Open Source and presently only available on Mac OS X 10.6 and higher.
- latex
- Build LaTeX sources that can be compiled to a PDF document using pdflatex.
- man
- Build manual pages in groff format for UNIX systems.
- texinfo
- Build Texinfo files that can be processed into Info files using makeinfo.
- text
- Build plain text files.
- gettext
- Build gettext-style message catalogs (
.pot
files). - doctest
- Run all doctests in the documentation, if the
doctest
extension is enabled. - linkcheck
- Check the integrity of all external links.
- xml
- Build Docutils-native XML files.
- pseudoxml
- Build compact pretty-printed “pseudo-XML” files displaying the internal structure of the intermediate document trees.
See Builders for a list of all builders shipped with Sphinx. Extensions can add their own builders.
-
-M
buildername
¶ Alternative to
-b
. Uses the Sphinx make_mode module, which provides the same build functionality as a default Makefile or Make.bat. In addition to all Sphinx Builders, the following build pipelines are available:- latexpdf
- Build LaTeX files and run them through pdflatex, or as per
latex_engine
setting. Iflanguage
is set to'ja'
, will use automatically the platex/dvipdfmx latex to PDF pipeline. - info
- Build Texinfo files and run them through makeinfo.
Important
Sphinx only recognizes the
-M
option if it is placed first.New in version 1.2.1.
-
-a
¶
If given, always write all output files. The default is to only write output files for new and changed source files. (This may not apply to all builders.)
-
-E
¶
Don’t use a saved environment (the structure caching all cross-references), but rebuild it completely. The default is to only read and parse source files that are new or have changed since the last run.
-
-t
tag
¶ Define the tag tag. This is relevant for
only
directives that only include their content if this tag is set.New in version 0.6.
-
-d
path
¶ Since Sphinx has to read and parse all source files before it can write an output file, the parsed source files are cached as “doctree pickles”. Normally, these files are put in a directory called
.doctrees
under the build directory; with this option you can select a different cache directory (the doctrees can be shared between all builders).
-
-j
N
¶ Distribute the build over N processes in parallel, to make building on multiprocessor machines more effective. Note that not all parts and not all builders of Sphinx can be parallelized. If
auto
argument is given, Sphinx uses the number of CPUs as N.New in version 1.2: This option should be considered experimental.
Changed in version 1.7: Support
auto
argument.
-
-c
path
¶ Don’t look for the
conf.py
in the source directory, but use the given configuration directory instead. Note that various other files and paths given by configuration values are expected to be relative to the configuration directory, so they will have to be present at this location too.New in version 0.3.
-
-C
¶
Don’t look for a configuration file; only take options via the
-D
option.New in version 0.5.
-
-D
setting=value
¶ Override a configuration value set in the
conf.py
file. The value must be a number, string, list or dictionary value.For lists, you can separate elements with a comma like this:
-D html_theme_path=path1,path2
.For dictionary values, supply the setting name and key like this:
-D latex_elements.docclass=scrartcl
.For boolean values, use
0
or1
as the value.Changed in version 0.6: The value can now be a dictionary value.
Changed in version 1.3: The value can now also be a list value.
-
-A
name=value
¶ Make the name assigned to value in the HTML templates.
New in version 0.5.
-
-n
¶
Run in nit-picky mode. Currently, this generates warnings for all missing references. See the config value
nitpick_ignore
for a way to exclude some references as “known missing”.
-
-N
¶
Do not emit colored output.
-
-v
¶
Increase verbosity (loglevel). This option can be given up to three times to get more debug logging output. It implies
-T
.New in version 1.2.
-
-q
¶
Do not output anything on standard output, only write warnings and errors to standard error.
-
-Q
¶
Do not output anything on standard output, also suppress warnings. Only errors are written to standard error.
-
-w
file
¶ Write warnings (and errors) to the given file, in addition to standard error.
-
-W
¶
Turn warnings into errors. This means that the build stops at the first warning and
sphinx-build
exits with exit status 1.
-
--keep-going
¶
With -W option, keep going processing when getting warnings to the end of build, and
sphinx-build
exits with exit status 1.New in version 1.8.
-
-T
¶
Display the full traceback when an unhandled exception occurs. Otherwise, only a summary is displayed and the traceback information is saved to a file for further analysis.
New in version 1.2.
-
-P
¶
(Useful for debugging only.) Run the Python debugger,
pdb
, if an unhandled exception occurs while building.
-
-h
,
--help
,
--version
¶
Display usage summary or Sphinx version.
New in version 1.2.
You can also give one or more filenames on the command line after the source and build directories. Sphinx will then try to build only these output files (and their dependencies).
Environment Variables¶
The sphinx-build refers following environment variables:
-
MAKE
A path to make command. A command name is also allowed. sphinx-build uses it to invoke sub-build process on make-mode.
Makefile Options
The Makefile
and make.bat
files created by
sphinx-quickstart usually run sphinx-build only with the
-b
and -d
options. However, they support the following
variables to customize behavior:
-
PAPER
This sets the
'papersize'
key oflatex_elements
: i.e.PAPER=a4
sets it to'a4paper'
andPAPER=letter
to'letterpaper'
.Note
Usage of this environment variable got broken at Sphinx 1.5 as
a4
orletter
ended up as option to LaTeX document in place of the neededa4paper
, resp.letterpaper
. Fixed at 1.7.7.
-
SPHINXBUILD
The command to use instead of
sphinx-build
.
-
BUILDDIR
The build directory to use instead of the one chosen in sphinx-quickstart.
-
SPHINXOPTS
Additional options for sphinx-build.
Deprecation Warnings¶
If any deprecation warning like RemovedInSphinxXXXWarning
are displayed
when building a user’s document, some Sphinx extension is using deprecated
features. In that case, please report it to author of the extension.
To disable the deprecation warnings, please set PYTHONWARNINGS=
environment
variable to your environment. For example:
PYTHONWARNINGS= make html
(Linux/Mac)export PYTHONWARNINGS=
and domake html
(Linux/Mac)set PYTHONWARNINGS=
and domake html
(Windows)- modify your Makefile/make.bat and set the environment variable
See also¶
sphinx-quickstart(1)
Additional Applications¶
sphinx-apidoc¶
Synopsis¶
sphinx-apidoc [OPTIONS] -o <OUTPUT_PATH> <MODULE_PATH> [EXCLUDE_PATTERN, …]
Description¶
sphinx-apidoc is a tool for automatic generation of Sphinx sources
that, using the autodoc
extension, document a whole package in the
style of other automatic API documentation tools.
MODULE_PATH is the path to a Python package to document, and OUTPUT_PATH is the directory where the generated sources are placed. Any EXCLUDE_PATTERNs given are fnmatch-style file and/or directory patterns that will be excluded from generation.
Warning
sphinx-apidoc
generates source files that use sphinx.ext.autodoc
to document all found modules. If any modules have side effects on import,
these will be executed by autodoc
when sphinx-build
is run.
If you document scripts (as opposed to library modules), make sure their main
routine is protected by a if __name__ == '__main__'
condition.
Options¶
-
-o
<OUTPUT_PATH>
¶ Directory to place the output files. If it does not exist, it is created.
-
-f
,
--force
¶
Force overwritting of any existing generated files.
-
-l
,
--follow-links
¶
Follow symbolic links.
-
-n
,
--dry-run
¶
Do not create any files.
-
-s
<suffix>
¶ Suffix for the source files generated. Defaults to
rst
.
-
-d
<MAXDEPTH>
¶ Maximum depth for the generated table of contents file.
-
--tocfile
¶
Filename for a table of contents file. Defaults to
modules
.
-
-F
,
--full
¶
Generate a full Sphinx project (
conf.py
,Makefile
etc.) using the same mechanism as sphinx-quickstart.
-
-e
,
--separate
¶
Put documentation for each module on its own page.
New in version 1.2.
-
-E
,
--no-headings
¶
Do not create headings for the modules/packages. This is useful, for example, when docstrings already contain headings.
-
-P
,
--private
¶
Include “_private” modules.
New in version 1.2.
-
--implicit-namespaces
¶
By default sphinx-apidoc processes sys.path searching for modules only. Python 3.3 introduced PEP 420 implicit namespaces that allow module path structures such as
foo/bar/module.py
orfoo/bar/baz/__init__.py
(notice thatbar
andfoo
are namespaces, not modules).Interpret paths recursively according to PEP-0420.
-
-M
,
--module-first
¶
Put module documentation before submodule documentation.
These options are used when --full
is specified:
-
-a
¶
Append module_path to sys.path.
Environment¶
-
SPHINX_APIDOC_OPTIONS
¶ A comma-separated list of option to append to generated
automodule
directives. Defaults tomembers,undoc-members,show-inheritance
.
See also¶
sphinx-build(1), sphinx-autogen(1)
sphinx-autogen¶
Synopsis¶
sphinx-autogen [options] <sourcefile> …
Description¶
sphinx-autogen is a tool for automatic generation of Sphinx sources
that, using the autodoc
extension, document items included in
autosummary
listing(s).
sourcefile is the path to one or more reStructuredText documents containing
autosummary
entries with the :toctree::
option set. sourcefile
can be an fnmatch
-style pattern.
Options¶
-
-o
<outputdir>
¶ Directory to place the output file. If it does not exist, it is created. Defaults to the value passed to the
:toctree:
option.
-
-s
<suffix>
,
--suffix
<suffix>
¶ Default suffix to use for generated files. Defaults to
rst
.
-
-t
<templates>
,
--templates
<templates>
¶ Custom template directory. Defaults to
None
.
-
-i
,
--imported-members
¶
Document imported members.
Example¶
Given the following directory structure:
docs
├── index.rst
└── ...
foobar
├── foo
│ └── __init__.py
└── bar
├── __init__.py
└── baz
└── __init__.py
and assuming docs/index.rst
contained the following:
Modules
=======
.. autosummary::
:toctree: modules
foobar.foo
foobar.bar
foobar.bar.baz
If you run the following:
$ PYTHONPATH=. sphinx-autodoc doc/index.rst
then the following stub files will be created in docs
:
docs
├── index.rst
└── modules
├── foobar.bar.rst
├── foobar.bar.baz.rst
└── foobar.foo.rst
and each of those files will contain a autodoc
directive and some
other information.
See also¶
sphinx-build(1), sphinx-apidoc(1)
Internationalization¶
New in version 1.1.
Complementary to translations provided for Sphinx-generated messages such as navigation bars, Sphinx provides mechanisms facilitating document translations in itself. See the Options for internationalization for details on configuration.

Workflow visualization of translations in Sphinx. (The stick-figure is taken from an XKCD comic.)
Sphinx internationalization details¶
gettext [1] is an established standard for internationalization and localization. It naively maps messages in a program to a translated string. Sphinx uses these facilities to translate whole documents.
Initially project maintainers have to collect all translatable strings (also
referred to as messages) to make them known to translators. Sphinx extracts
these through invocation of sphinx-build -b gettext
.
Every single element in the doctree will end up in a single message which results in lists being equally split into different chunks while large paragraphs will remain as coarsely-grained as they were in the original document. This grants seamless document updates while still providing a little bit of context for translators in free-text passages. It is the maintainer’s task to split up paragraphs which are too large as there is no sane automated way to do that.
After Sphinx successfully ran the
MessageCatalogBuilder
you will find a
collection of .pot
files in your output directory. These are catalog
templates and contain messages in your original language only.
They can be delivered to translators which will transform them to .po
files
— so called message catalogs — containing a mapping from the original
messages to foreign-language strings.
Gettext compiles them into a binary format known as binary catalogs through
msgfmt for efficiency reasons. If you make these files discoverable
with locale_dirs
for your language
, Sphinx will pick them
up automatically.
An example: you have a document usage.rst
in your Sphinx project. The
gettext builder will put its messages into usage.pot
. Imagine you have
Spanish translations [2] on your hands in usage.po
— for your builds to
be translated you need to follow these instructions:
Compile your message catalog to a locale directory, say
locale
, so it ends up in./locale/es/LC_MESSAGES/usage.mo
in your source directory (wherees
is the language code for Spanish.)msgfmt "usage.po" -o "locale/es/LC_MESSAGES/usage.mo"
Set
locale_dirs
to["locale/"]
.Run your desired build.
Translating with sphinx-intl¶
Quick guide¶
sphinx-intl is a useful tool to work with Sphinx translation flow. This section describe an easy way to translate with sphinx-intl.
Install sphinx-intl by pip install sphinx-intl or easy_install sphinx-intl.
Add configurations to your conf.py:
locale_dirs = ['locale/'] # path is example but recommended. gettext_compact = False # optional.
This case-study assumes that
locale_dirs
is set to ‘locale/’ andgettext_compact
is set to False (the Sphinx document is already configured as such).Extract document’s translatable messages into pot files:
$ make gettext
As a result, many pot files are generated under
_build/gettext
directory.Setup/Update your locale_dir:
$ sphinx-intl update -p _build/gettext -l de -l ja
Done. You got these directories that contain po files:
- ./locale/de/LC_MESSAGES/
- ./locale/ja/LC_MESSAGES/
Translate your po files under ./locale/<lang>/LC_MESSAGES/.
make translated document.
You need a
language
parameter inconf.py
or you may also specify the parameter on the command line (for BSD/GNU make):$ make -e SPHINXOPTS="-D language='de'" html
command line (for Windows cmd.exe):
> set SPHINXOPTS=-D language=de > .\make.bat html
command line (for PowerShell):
> Set-Item env:SPHINXOPTS "-D language=de" > .\make.bat html
Congratulations! You got the translated documentation in the _build/html
directory.
New in version 1.3: sphinx-build that is invoked by make command will build po files into mo files.
If you are using 1.2.x or earlier, please invoke sphinx-intl build
command
before make command.
Translating¶
Translate po file under ./locale/de/LC_MESSAGES
directory.
The case of builders.po file for sphinx document:
# a5600c3d2e3d48fc8c261ea0284db79b
#: ../../builders.rst:4
msgid "Available builders"
msgstr "<FILL HERE BY TARGET LANGUAGE>"
Another case, msgid is multi-line text and contains reStructuredText syntax:
# 302558364e1d41c69b3277277e34b184
#: ../../builders.rst:9
msgid ""
"These are the built-in Sphinx builders. More builders can be added by "
":ref:`extensions <extensions>`."
msgstr ""
"FILL HERE BY TARGET LANGUAGE FILL HERE BY TARGET LANGUAGE FILL HERE "
"BY TARGET LANGUAGE :ref:`EXTENSIONS <extensions>` FILL HERE."
Please be careful not to break reST notation. Most po-editors will help you with that.
Update your po files by new pot files¶
If a document is updated, it is necessary to generate updated pot files and to apply differences to translated po files. In order to apply the updating difference of a pot file to po file, use the sphinx-intl update command.
$ sphinx-intl update -p _build/locale
Using Transifex service for team translation¶
Transifex is one of several services that allow collaborative translation via a web interface. It has a nifty Python-based command line client that makes it easy to fetch and push translations.
Install transifex-client
You need tx command to upload resources (pot files).
$ pip install transifex-client
See also
Create your transifex account and create new project for your document
Currently, transifex does not allow for a translation project to have more than one version of the document, so you’d better include a version number in your project name.
For example:
Project ID: sphinx-document-test_1_0
Project URL: https://www.transifex.com/projects/p/sphinx-document-test_1_0/
Create config files for tx command
This process will create
.tx/config
in the current directory, as well as a~/.transifexrc
file that includes auth information.$ tx init Creating .tx folder... Transifex instance [https://www.transifex.com]: ... Please enter your transifex username: <transifex-username> Password: <transifex-password> ... Done.
Upload pot files to transifex service
Register pot files to
.tx/config
file:$ cd /your/document/root $ sphinx-intl update-txconfig-resources --pot-dir _build/locale \ --transifex-project-name sphinx-document-test_1_0
and upload pot files:
$ tx push -s Pushing translations for resource sphinx-document-test_1_0.builders: Pushing source file (locale/pot/builders.pot) Resource does not exist. Creating... ... Done.
Forward the translation on transifex
Pull translated po files and make translated html
Get translated catalogs and build mo files (ex. for ‘de’):
$ cd /your/document/root $ tx pull -l de Pulling translations for resource sphinx-document-test_1_0.builders (...) -> de: locale/de/LC_MESSAGES/builders.po ... Done.
Invoke make html (for BSD/GNU make):
$ make -e SPHINXOPTS="-D language='de'" html
That’s all!
Tip
Translating locally and on Transifex
If you want to push all language’s po files, you can be done by using tx push -t command. Watch out! This operation overwrites translations in transifex.
In other words, if you have updated each in the service and local po files, it would take much time and effort to integrate them.
Contributing to Sphinx reference translation¶
The recommended way for new contributors to translate Sphinx reference is to join the translation team on Transifex.
There is sphinx translation page for Sphinx (master) documentation.
- Login to transifex service.
- Go to sphinx translation page.
- Click
Request language
and fill form. - Wait acceptance by transifex sphinx translation maintainers.
- (after acceptance) translate on transifex.
Footnotes
[1] | See the GNU gettext utilities for details on that software suite. |
[2] | Because nobody expects the Spanish Inquisition! |
HTML theming support¶
New in version 0.6.
Sphinx supports changing the appearance of its HTML output via themes. A theme is a collection of HTML templates, stylesheet(s) and other static files. Additionally, it has a configuration file which specifies from which theme to inherit, which highlighting style to use, and what options exist for customizing the theme’s look and feel.
Themes are meant to be project-unaware, so they can be used for different projects without change.
Using a theme¶
Using an existing theme is easy. If the theme is builtin to Sphinx, you only
need to set the html_theme
config value. With the
html_theme_options
config value you can set theme-specific options
that change the look and feel. For example, you could have the following in
your conf.py
:
html_theme = "classic"
html_theme_options = {
"rightsidebar": "true",
"relbarbgcolor": "black"
}
That would give you the classic theme, but with a sidebar on the right side and a black background for the relation bar (the bar with the navigation links at the page’s top and bottom).
If the theme does not come with Sphinx, it can be in two static forms: either a
directory (containing theme.conf
and other needed files), or a zip file
with the same contents. Either of them must be put where Sphinx can find it;
for this there is the config value html_theme_path
. It gives a list
of directories, relative to the directory containing conf.py
, that can
contain theme directories or zip files. For example, if you have a theme in the
file blue.zip
, you can put it right in the directory containing
conf.py
and use this configuration:
html_theme = "blue"
html_theme_path = ["."]
The third form is a python package. If a theme you want to use is distributed as a python package, you can use it after installing
# installing theme package
$ pip install sphinxjp.themes.dotted
# use it in your conf.py
html_theme = "dotted"
Builtin themes¶
Theme overview | |
alabaster |
classic |
sphinxdoc |
scrolls |
agogo |
traditional |
nature |
haiku |
pyramid |
bizstyle |
Sphinx comes with a selection of themes to choose from.
These themes are:
basic – This is a basically unstyled layout used as the base for the other themes, and usable as the base for custom themes as well. The HTML contains all important elements like sidebar and relation bar. There are these options (which are inherited by the other themes):
- nosidebar (true or false): Don’t include the sidebar. Defaults to
False
. - sidebarwidth (int or str): Width of the sidebar in pixels. This can be an int, which is interpreted as pixels or a valid CSS dimension string such as ‘70em’ or ‘50%’. Defaults to 230 pixels.
- body_min_width (int or str): Minimal width of the document body. This can be an int, which is interpreted as pixels or a valid CSS dimension string such as ‘70em’ or ‘50%’. Use 0 if you don’t want a width limit. Defaults may depend on the theme (often 450px).
- body_max_width (int or str): Maximal width of the document body. This can be an int, which is interpreted as pixels or a valid CSS dimension string such as ‘70em’ or ‘50%’. Use ‘none’ if you don’t want a width limit. Defaults may depend on the theme (often 800px).
- nosidebar (true or false): Don’t include the sidebar. Defaults to
alabaster – Alabaster theme is a modified “Kr” Sphinx theme from @kennethreitz (especially as used in his Requests project), which was itself originally based on @mitsuhiko’s theme used for Flask & related projects. Check out at its installation page how to set up properly
html_sidebars
for its use.classic – This is the classic theme, which looks like the Python 2 documentation. It can be customized via these options:
- rightsidebar (true or false): Put the sidebar on the right side.
Defaults to
False
. - stickysidebar (true or false): Make the sidebar “fixed” so that it
doesn’t scroll out of view for long body content. This may not work well
with all browsers. Defaults to
False
. - collapsiblesidebar (true or false): Add an experimental JavaScript
snippet that makes the sidebar collapsible via a button on its side.
Defaults to
False
. - externalrefs (true or false): Display external links differently from
internal links. Defaults to
False
.
There are also various color and font options that can change the color scheme without having to write a custom stylesheet:
- footerbgcolor (CSS color): Background color for the footer line.
- footertextcolor (CSS color): Text color for the footer line.
- sidebarbgcolor (CSS color): Background color for the sidebar.
- sidebarbtncolor (CSS color): Background color for the sidebar collapse
button (used when collapsiblesidebar is
True
). - sidebartextcolor (CSS color): Text color for the sidebar.
- sidebarlinkcolor (CSS color): Link color for the sidebar.
- relbarbgcolor (CSS color): Background color for the relation bar.
- relbartextcolor (CSS color): Text color for the relation bar.
- relbarlinkcolor (CSS color): Link color for the relation bar.
- bgcolor (CSS color): Body background color.
- textcolor (CSS color): Body text color.
- linkcolor (CSS color): Body link color.
- visitedlinkcolor (CSS color): Body color for visited links.
- headbgcolor (CSS color): Background color for headings.
- headtextcolor (CSS color): Text color for headings.
- headlinkcolor (CSS color): Link color for headings.
- codebgcolor (CSS color): Background color for code blocks.
- codetextcolor (CSS color): Default text color for code blocks, if not set differently by the highlighting style.
- bodyfont (CSS font-family): Font for normal text.
- headfont (CSS font-family): Font for headings.
- rightsidebar (true or false): Put the sidebar on the right side.
Defaults to
sphinxdoc – The theme originally used by this documentation. It features a sidebar on the right side. There are currently no options beyond nosidebar and sidebarwidth.
Note
The Sphinx documentation now uses an adjusted version of the sphinxdoc theme.
scrolls – A more lightweight theme, based on the Jinja documentation. The following color options are available:
- headerbordercolor
- subheadlinecolor
- linkcolor
- visitedlinkcolor
- admonitioncolor
agogo – A theme created by Andi Albrecht. The following options are supported:
- bodyfont (CSS font family): Font for normal text.
- headerfont (CSS font family): Font for headings.
- pagewidth (CSS length): Width of the page content, default 70em.
- documentwidth (CSS length): Width of the document (without sidebar), default 50em.
- sidebarwidth (CSS length): Width of the sidebar, default 20em.
- bgcolor (CSS color): Background color.
- headerbg (CSS value for “background”): background for the header area, default a grayish gradient.
- footerbg (CSS value for “background”): background for the footer area, default a light gray gradient.
- linkcolor (CSS color): Body link color.
- headercolor1, headercolor2 (CSS color): colors for <h1> and <h2> headings.
- headerlinkcolor (CSS color): Color for the backreference link in headings.
- textalign (CSS text-align value): Text alignment for the body, default
is
justify
.
nature – A greenish theme. There are currently no options beyond nosidebar and sidebarwidth.
pyramid – A theme from the Pyramid web framework project, designed by Blaise Laflamme. There are currently no options beyond nosidebar and sidebarwidth.
haiku – A theme without sidebar inspired by the Haiku OS user guide. The following options are supported:
- full_logo (true or false, default
False
): If this is true, the header will only show thehtml_logo
. Use this for large logos. If this is false, the logo (if present) will be shown floating right, and the documentation title will be put in the header. - textcolor, headingcolor, linkcolor, visitedlinkcolor, hoverlinkcolor (CSS colors): Colors for various body elements.
- full_logo (true or false, default
traditional – A theme resembling the old Python documentation. There are currently no options beyond nosidebar and sidebarwidth.
epub – A theme for the epub builder. This theme tries to save visual space which is a sparse resource on ebook readers. The following options are supported:
- relbar1 (true or false, default
True
): If this is true, the relbar1 block is inserted in the epub output, otherwise it is omitted. - footer (true or false, default
True
): If this is true, the footer block is inserted in the epub output, otherwise it is omitted.
- relbar1 (true or false, default
- bizstyle – A simple bluish theme. The following options are supported
beyond nosidebar and sidebarwidth:
- rightsidebar (true or false): Put the sidebar on the right side.
Defaults to
False
.
- rightsidebar (true or false): Put the sidebar on the right side.
Defaults to
New in version 1.3: ‘alabaster’, ‘sphinx_rtd_theme’ and ‘bizstyle’ theme.
Changed in version 1.3: The ‘default’ theme has been renamed to ‘classic’. ‘default’ is still available, however it will emit a notice that it is an alias for the new ‘alabaster’ theme.
Creating themes¶
As said, themes are either a directory or a zipfile (whose name is the theme name), containing the following:
- A
theme.conf
file, see below. - HTML templates, if needed.
- A
static/
directory containing any static files that will be copied to the output static directory on build. These can be images, styles, script files.
The theme.conf
file is in INI format [1] (readable by the standard
Python ConfigParser
module) and has the following structure:
[theme]
inherit = base theme
stylesheet = main CSS name
pygments_style = stylename
sidebars = localtoc.html, relations.html, sourcelink.html, searchbox.html
[options]
variable = default value
- The inherit setting gives the name of a “base theme”, or
none
. The base theme will be used to locate missing templates (most themes will not have to supply most templates if they usebasic
as the base theme), its options will be inherited, and all of its static files will be used as well. - The stylesheet setting gives the name of a CSS file which will be
referenced in the HTML header. If you need more than one CSS file, either
include one from the other via CSS’
@import
, or use a custom HTML template that adds<link rel="stylesheet">
tags as necessary. Setting thehtml_style
config value will override this setting. - The pygments_style setting gives the name of a Pygments style to use for
highlighting. This can be overridden by the user in the
pygments_style
config value. - The sidebars setting gives the comma separated list of sidebar templates
for constructing sidebars. This can be overridden by the user in the
html_sidebars
config value. - The options section contains pairs of variable names and default values.
These options can be overridden by the user in
html_theme_options
and are accessible from all templates astheme_<name>
.
New in version 1.7: sidebar settings
Distribute your theme as a python package¶
As a way to distribute your theme, you can use python package. Python package brings to users easy setting up ways.
To distribute your theme as a python package, please define an entry point
called sphinx.html_themes
in your setup.py file, and write a setup()
function to register your themes using add_html_theme()
API in it:
# 'setup.py'
setup(
...
entry_points = {
'sphinx.html_themes': [
'name_of_theme = your_package',
]
},
...
)
# 'your_package.py'
from os import path
def setup(app):
app.add_html_theme('name_of_theme', path.abspath(path.dirname(__file__)))
If your theme package contains two or more themes, please call add_html_theme()
twice or more.
New in version 1.2: ‘sphinx_themes’ entry_points feature.
Deprecated since version 1.6: sphinx_themes
entry_points has been deprecated.
New in version 1.6: sphinx.html_themes
entry_points feature.
Templating¶
The guide to templating is helpful if you want to write your own templates. What is important to keep in mind is the order in which Sphinx searches for templates:
- First, in the user’s
templates_path
directories. - Then, in the selected theme.
- Then, in its base theme, its base’s base theme, etc.
When extending a template in the base theme with the same name, use the theme
name as an explicit directory: {% extends "basic/layout.html" %}
. From a
user templates_path
template, you can still use the “exclamation mark”
syntax as described in the templating document.
Static templates¶
Since theme options are meant for the user to configure a theme more easily, without having to write a custom stylesheet, it is necessary to be able to template static files as well as HTML files. Therefore, Sphinx supports so-called “static templates”, like this:
If the name of a file in the static/
directory of a theme (or in the user’s
static path, for that matter) ends with _t
, it will be processed by the
template engine. The _t
will be left from the final file name. For
example, the classic theme has a file static/classic.css_t
which uses
templating to put the color options into the stylesheet. When a documentation
is built with the classic theme, the output directory will contain a
_static/classic.css
file where all template tags have been processed.
[1] | It is not an executable Python file, as opposed to conf.py ,
because that would pose an unnecessary security risk if themes are
shared. |
Third Party Themes¶
Theme overview | |
sphinx_rtd_theme |
sphinx_rtd_theme – Read the Docs Sphinx Theme. This is a mobile-friendly sphinx theme that was made for readthedocs.org. View a working demo over on readthedocs.org. You can get install and options information at Read the Docs Sphinx Theme page.
Changed in version 1.4: sphinx_rtd_theme has become optional.
Besides this, there are a lot of third party themes. You can find them on PyPI, GitHub, sphinx-themes.org and so on.
Setuptools integration¶
Sphinx supports integration with setuptools and distutils through a custom
command - BuildDoc
.
Using setuptools integration¶
The Sphinx build can then be triggered from distutils, and some Sphinx
options can be set in setup.py
or setup.cfg
instead of Sphinx’s own
configuration file.
For instance, from setup.py
:
# this is only necessary when not using setuptools/distribute
from sphinx.setup_command import BuildDoc
cmdclass = {'build_sphinx': BuildDoc}
name = 'My project'
version = '1.2'
release = '1.2.0'
setup(
name=name,
author='Bernard Montgomery',
version=release,
cmdclass=cmdclass,
# these are optional and override conf.py settings
command_options={
'build_sphinx': {
'project': ('setup.py', name),
'version': ('setup.py', version),
'release': ('setup.py', release),
'source_dir': ('setup.py', 'doc')}},
)
Note
If you set Sphinx options directly in the setup()
command, replace
hyphens in variable names with underscores. In the example above,
source-dir
becomes source_dir
.
Or add this section in setup.cfg
:
[build_sphinx]
project = 'My project'
version = 1.2
release = 1.2.0
source-dir = 'doc'
Once configured, call this by calling the relevant command on setup.py
:
$ python setup.py build_sphinx
Options for setuptools integration¶
-
fresh-env
¶ A boolean that determines whether the saved environment should be discarded on build. Default is false.
This can also be set by passing the -E flag to
setup.py
:$ python setup.py build_sphinx -E
-
all-files
¶ A boolean that determines whether all files should be built from scratch. Default is false.
This can also be set by passing the -a flag to
setup.py
:$ python setup.py build_sphinx -a
-
source-dir
¶ The target source directory. This can be relative to the
setup.py
orsetup.cfg
file, or it can be absolute. It defaults to./doc
or./docs
if either contains a file namedconf.py
(checking./doc
first); otherwise it defaults to the current directory.This can also be set by passing the -s flag to
setup.py
:$ python setup.py build_sphinx -s $SOURCE_DIR
-
build-dir
¶ The target build directory. This can be relative to the
setup.py
orsetup.cfg
file, or it can be absolute. Default is./build/sphinx
.
-
config-dir
¶ Location of the configuration directory. This can be relative to the
setup.py
orsetup.cfg
file, or it can be absolute. Default is to use source-dir.This can also be set by passing the -c flag to
setup.py
:$ python setup.py build_sphinx -c $CONFIG_DIR
New in version 1.0.
-
builder
¶ The builder or list of builders to use. Default is
html
.This can also be set by passing the -b flag to
setup.py
:$ python setup.py build_sphinx -b $BUILDER
Changed in version 1.6: This can now be a comma- or space-separated list of builders
-
warning-is-error
¶ A boolean that ensures Sphinx warnings will result in a failed build. Default is false.
This can also be set by passing the -W flag to
setup.py
:$ python setup.py build_sphinx -W
New in version 1.5.
-
project
¶ The documented project’s name. Default is
''
.New in version 1.0.
-
version
¶ The short X.Y version. Default is
''
.New in version 1.0.
-
release
¶ The full version, including alpha/beta/rc tags. Default is
''
.New in version 1.0.
-
today
¶ How to format the current date, used as the replacement for
|today|
. Default is''
.New in version 1.0.
-
link-index
¶ A boolean that ensures index.html will be linked to the master doc. Default is false.
This can also be set by passing the -i flag to
setup.py
:$ python setup.py build_sphinx -i
New in version 1.0.
-
copyright
¶ The copyright string. Default is
''
.New in version 1.3.
-
nitpicky
¶ Run in nit-picky mode. Currently, this generates warnings for all missing references. See the config value
nitpick_ignore
for a way to exclude some references as “known missing”.New in version 1.8.
-
pdb
¶ A boolean to configure
pdb
on exception. Default is false.New in version 1.5.
Templating¶
Sphinx uses the Jinja templating engine for its HTML templates. Jinja is a text-based engine, and inspired by Django templates, so anyone having used Django will already be familiar with it. It also has excellent documentation for those who need to make themselves familiar with it.
Do I need to use Sphinx’s templates to produce HTML?¶
No. You have several other options:
- You can write a
TemplateBridge
subclass that calls your template engine of choice, and set thetemplate_bridge
configuration value accordingly. - You can write a custom builder that derives from
StandaloneHTMLBuilder
and calls your template engine of choice. - You can use the
PickleHTMLBuilder
that produces pickle files with the page contents, and postprocess them using a custom tool, or use them in your Web application.
Jinja/Sphinx Templating Primer¶
The default templating language in Sphinx is Jinja. It’s Django/Smarty inspired and easy to understand. The most important concept in Jinja is template inheritance, which means that you can overwrite only specific blocks within a template, customizing it while also keeping the changes at a minimum.
To customize the output of your documentation you can override all the templates (both the layout templates and the child templates) by adding files with the same name as the original filename into the template directory of the structure the Sphinx quickstart generated for you.
Sphinx will look for templates in the folders of templates_path
first, and if it can’t find the template it’s looking for there, it falls back
to the selected theme’s templates.
A template contains variables, which are replaced with values when the template is evaluated, tags, which control the logic of the template and blocks which are used for template inheritance.
Sphinx’s basic theme provides base templates with a couple of blocks it will
fill with data. These are located in the themes/basic
subdirectory of
the Sphinx installation directory, and used by all builtin Sphinx themes.
Templates with the same name in the templates_path
override templates
supplied by the selected theme.
For example, to add a new link to the template area containing related links all
you have to do is to add a new template called layout.html
with the
following contents:
{% extends "!layout.html" %}
{% block rootrellink %}
<li><a href="https://project.invalid/">Project Homepage</a> »</li>
{{ super() }}
{% endblock %}
By prefixing the name of the overridden template with an exclamation mark, Sphinx will load the layout template from the underlying HTML theme.
Important: If you override a block, call {{ super() }}
somewhere to
render the block’s original content in the extended template – unless you
don’t want that content to show up.
Working with the builtin templates¶
The builtin basic theme supplies the templates that all builtin Sphinx themes are based on. It has the following elements you can override or use:
Blocks¶
The following blocks exist in the layout.html
template:
- doctype
- The doctype of the output format. By default this is XHTML 1.0 Transitional as this is the closest to what Sphinx and Docutils generate and it’s a good idea not to change it unless you want to switch to HTML 5 or a different but compatible XHTML doctype.
- linktags
- This block adds a couple of
<link>
tags to the head section of the template. - extrahead
- This block is empty by default and can be used to add extra contents into
the
<head>
tag of the generated HTML file. This is the right place to add references to JavaScript or extra CSS files. - relbar1 / relbar2
This block contains the relation bar, the list of related links (the parent documents on the left, and the links to index, modules etc. on the right). relbar1 appears before the document, relbar2 after the document. By default, both blocks are filled; to show the relbar only before the document, you would override relbar2 like this:
{% block relbar2 %}{% endblock %}
- rootrellink / relbaritems
- Inside the relbar there are three sections: The rootrellink, the links
from the documentation and the custom relbaritems. The rootrellink is a
block that by default contains a list item pointing to the master document
by default, the relbaritems is an empty block. If you override them to
add extra links into the bar make sure that they are list items and end with
the
reldelim1
. - document
- The contents of the document itself. It contains the block “body” where the
individual content is put by subtemplates like
page.html
. - sidebar1 / sidebar2
A possible location for a sidebar. sidebar1 appears before the document and is empty by default, sidebar2 after the document and contains the default sidebar. If you want to swap the sidebar location override this and call the sidebar helper:
{% block sidebar1 %}{{ sidebar() }}{% endblock %} {% block sidebar2 %}{% endblock %}
(The sidebar2 location for the sidebar is needed by the
sphinxdoc.css
stylesheet, for example.)- sidebarlogo
- The logo location within the sidebar. Override this if you want to place some content at the top of the sidebar.
- footer
- The block for the footer div. If you want a custom footer or markup before or after it, override this one.
The following four blocks are only used for pages that do not have assigned a
list of custom sidebars in the html_sidebars
config value. Their use
is deprecated in favor of separate sidebar templates, which can be included via
html_sidebars
.
- sidebartoc
The table of contents within the sidebar.
Deprecated since version 1.0.
- sidebarrel
The relation links (previous, next document) within the sidebar.
Deprecated since version 1.0.
- sidebarsourcelink
The “Show source” link within the sidebar (normally only shown if this is enabled by
html_show_sourcelink
).Deprecated since version 1.0.
- sidebarsearch
The search box within the sidebar. Override this if you want to place some content at the bottom of the sidebar.
Deprecated since version 1.0.
Configuration Variables¶
Inside templates you can set a couple of variables used by the layout template
using the {% set %}
tag:
-
reldelim1
¶ The delimiter for the items on the left side of the related bar. This defaults to
' »'
Each item in the related bar ends with the value of this variable.
-
reldelim2
¶ The delimiter for the items on the right side of the related bar. This defaults to
' |'
. Each item except of the last one in the related bar ends with the value of this variable.
Overriding works like this:
{% extends "!layout.html" %}
{% set reldelim1 = ' >' %}
-
script_files
¶ Add additional script files here, like this:
{% set script_files = script_files + ["_static/myscript.js"] %}
Helper Functions¶
Sphinx provides various Jinja functions as helpers in the template. You can use them to generate links or output multiply used elements.
-
pathto
(document)¶ Return the path to a Sphinx document as a URL. Use this to refer to built documents.
-
pathto
(file, 1) Return the path to a file which is a filename relative to the root of the generated output. Use this to refer to static files.
-
hasdoc
(document)¶ Check if a document with the name document exists.
Return the rendered sidebar.
-
relbar
()¶ Return the rendered relation bar.
-
warning
(message)¶ Emit a warning message.
Global Variables¶
These global variables are available in every template and are safe to use. There are more, but most of them are an implementation detail and might change in the future.
-
builder
¶ The name of the builder (e.g.
html
orhtmlhelp
).
-
docstitle
¶ The title of the documentation (the value of
html_title
), except when the “single-file” builder is used, when it is set toNone
.
-
embedded
¶ True if the built HTML is meant to be embedded in some viewing application that handles navigation, not the web browser, such as for HTML help or Qt help formats. In this case, the sidebar is not included.
-
favicon
¶ The path to the HTML favicon in the static path, or
''
.
-
file_suffix
¶ The value of the builder’s
out_suffix
attribute, i.e. the file name extension that the output files will get. For a standard HTML builder, this is usually.html
.
-
has_source
¶ True if the reST document sources are copied (if
html_copy_source
isTrue
).
-
last_updated
¶ The build date.
-
logo
¶ The path to the HTML logo image in the static path, or
''
.
-
master_doc
¶ The value of
master_doc
, for usage withpathto()
.
-
pagename
¶ The “page name” of the current file, i.e. either the document name if the file is generated from a reST source, or the equivalent hierarchical name relative to the output directory (
[directory/]filename_without_extension
).
-
rellinks
¶ A list of links to put at the left side of the relbar, next to “next” and “prev”. This usually contains links to the general index and other indices, such as the Python module index. If you add something yourself, it must be a tuple
(pagename, link title, accesskey, link text)
.
-
shorttitle
¶ The value of
html_short_title
.
-
show_source
¶ True if
html_show_sourcelink
isTrue
.
-
sphinx_version
¶ The version of Sphinx used to build.
-
style
¶ The name of the main stylesheet, as given by the theme or
html_style
.
-
title
¶ The title of the current document, as used in the
<title>
tag.
-
use_opensearch
¶ The value of
html_use_opensearch
.
In addition to these values, there are also all theme options available
(prefixed by theme_
), as well as the values given by the user in
html_context
.
In documents that are created from source files (as opposed to automatically-generated files like the module index, or documents that already are in HTML form), these variables are also available:
-
body
¶ A string containing the content of the page in HTML form as produced by the HTML builder, before the theme is applied.
-
display_toc
¶ A boolean that is True if the toc contains more than one entry.
-
meta
¶ Document metadata (a dictionary), see File-wide metadata.
A string containing the page’s HTML meta tags.
-
next
¶ The next document for the navigation. This variable is either false or has two attributes link and title. The title contains HTML markup. For example, to generate a link to the next page, you can use this snippet:
{% if next %} <a href="{{ next.link|e }}">{{ next.title }}</a> {% endif %}
-
page_source_suffix
¶ The suffix of the file that was rendered. Since we support a list of
source_suffix
, this will allow you to properly link to the original source file.
-
sourcename
¶ The name of the copied source file for the current document. This is only nonempty if the
html_copy_source
value isTrue
. This has empty value on creating automatically-generated files.
-
title
The page title.
-
toc
¶ The local table of contents for the current page, rendered as HTML bullet lists.
-
toctree
¶ A callable yielding the global TOC tree containing the current page, rendered as HTML bullet lists. Optional keyword arguments:
collapse
(True
by default): if true, all TOC entries that are not ancestors of the current page are collapsedmaxdepth
(defaults to the max depth selected in the toctree directive): the maximum depth of the tree; set it to-1
to allow unlimited depthtitles_only
(False
by default): if true, put only toplevel document titles in the treeincludehidden
(False
by default): if true, the TOC tree will also contain hidden entries.
LaTeX customization¶
For details of the LaTeX/PDF builder command line invocation, refer to
LaTeXBuilder
.
Basic customization¶
The latex target does not benefit from prepared themes.
Basic customization is obtained via usage of the Options for LaTeX output. For example:
# inside conf.py
latex_engine = 'xelatex'
latex_elements = {
'fontpkg': r'''
\setmainfont{DejaVu Serif}
\setsansfont{DejaVu Sans}
\setmonofont{DejaVu Sans Mono}
''',
'preamble': r'''
\usepackage[titles]{tocloft}
\cftsetpnumwidth {1.25cm}\cftsetrmarg{1.5cm}
\setlength{\cftchapnumwidth}{0.75cm}
\setlength{\cftsecindent}{\cftchapnumwidth}
\setlength{\cftsecnumwidth}{1.25cm}
''',
'fncychap': r'\usepackage[Bjornstrup]{fncychap}',
'printindex': r'\footnotesize\raggedright\printindex',
}
latex_show_urls = 'footnote'
If the size of the 'preamble'
contents becomes inconvenient, one may move
all needed macros into some file mystyle.tex.txt
of the project source
repertory, and get LaTeX to import it at run time:
'preamble': r'\input{mystyle.tex.txt}',
# or, if the \ProvidesPackage LaTeX macro is used in a file mystyle.sty
'preamble': r'\usepackage{mystyle}',
It is then needed to set appropriately latex_additional_files
, for
example:
latex_additional_files = ["mystyle.sty"]
The LaTeX style file options¶
Additional customization is possible via LaTeX options of the Sphinx style file.
The sphinxsetup interface¶
The 'sphinxsetup'
key of latex_elements
provides a convenient
interface:
latex_elements = {
'sphinxsetup': 'key1=value1, key2=value2, ...',
}
- some values may be LaTeX macros, then the backslashes must be Python-escaped, or the whole must be a Python raw string,
- LaTeX boolean keys require lowercase
true
orfalse
values, - spaces around the commas and equal signs are ignored, spaces inside LaTeX macros may be significant.
If non-empty, it will be passed as argument to the \sphinxsetup
macro
inside the document preamble, like this:
\usepackage{sphinx}
\sphinxsetup{key1=value1, key2=value2,...}
New in version 1.5.
Hint
It is possible to insert further uses of the \sphinxsetup
LaTeX macro
directly into the body of the document, via the help of the raw
directive. Here is how this present chapter in PDF is styled:
.. raw:: latex
\begingroup
\sphinxsetup{%
verbatimwithframe=false,
VerbatimColor={named}{OldLace},
TitleColor={named}{DarkGoldenrod},
hintBorderColor={named}{LightCoral},
attentionborder=3pt,
attentionBorderColor={named}{Crimson},
attentionBgColor={named}{FloralWhite},
noteborder=2pt,
noteBorderColor={named}{Olive},
cautionborder=3pt,
cautionBorderColor={named}{Cyan},
cautionBgColor={named}{LightCyan}}
at the start of the chapter and:
.. raw:: latex
\endgroup
at its end.
The colors used in the above are provided by the svgnames
option of the
“xcolor” package:
latex_elements = {
'passoptionstopackages': r'\PassOptionsToPackage{svgnames}{xcolor}',
}
The available styling options¶
hmargin, vmargin
The dimensions of the horizontal (resp. vertical) margins, passed as
hmargin
(resp.vmargin
) option to thegeometry
package. The default is1in
, which is equivalent to{1in,1in}
. Example:'sphinxsetup': 'hmargin={2in,1.5in}, vmargin={1.5in,2in}, marginpar=1in',
Japanese documents currently accept only the one-dimension format for these parameters. The
geometry
package is then passed suitable options to get the text width set to an exact multiple of the zenkaku width, and the text height set to an integer multiple of the baselineskip, with the closest fit for the margins.Hint
For Japanese
'manual'
docclass with pointsize11pt
or12pt
, use thenomag
extra document class option (cf.'extraclassoptions'
key oflatex_elements
) or so-called TeX “true” units:'sphinxsetup': 'hmargin=1.5truein, vmargin=1.5truein, marginpar=5zw',
New in version 1.5.3.
marginpar
The
\marginparwidth
LaTeX dimension, defaults to0.5in
. For Japanese documents, the value is modified to be the closest integer multiple of the zenkaku width.New in version 1.5.3.
verbatimwithframe
- default
true
. Boolean to specify ifcode-block
s and literal includes are framed. Setting it tofalse
does not deactivate use of package “framed”, because it is still in use for the optional background colour. verbatimwrapslines
- default
true
. Tells whether long lines incode-block
’s contents should wrap. literalblockcappos
default
t
for “top”. Decides the caption position. Alternative isb
(“bottom”).New in version 1.7.
verbatimhintsturnover
default
true
. Iftrue
, code-blocks display “continued on next page”, “continued from previous page” hints in case of pagebreaks.New in version 1.6.3.
Changed in version 1.7: the default changed from
false
totrue
.verbatimcontinuedalign
,verbatimcontinuesalign
default
c
. Horizontal position relative to the framed contents: eitherl
(left aligned),r
(right aligned) orc
(centered).New in version 1.7.
parsedliteralwraps
default
true
. Tells whether long lines in parsed-literal’s contents should wrap.New in version 1.5.2: set this option value to
false
to recover former behaviour.inlineliteralwraps
default
true
. Allows linebreaks inside inline literals: but extra potential break-points (additionally to those allowed by LaTeX at spaces or for hyphenation) are currently inserted only after the characters. , ; ? ! /
. Due to TeX internals, white space in the line will be stretched (or shrunk) in order to accomodate the linebreak.New in version 1.5: set this option value to
false
to recover former behaviour.verbatimvisiblespace
- default
\textcolor{red}{\textvisiblespace}
. When a long code line is split, the last space character from the source code line right before the linebreak location is typeset using this. verbatimcontinued
A LaTeX macro inserted at start of continuation code lines. Its (complicated…) default typesets a small red hook pointing to the right:
\makebox[2\fontcharwd\font`\x][r]{\textcolor{red}{\tiny$\hookrightarrow$}}
Changed in version 1.5: The breaking of long code lines was added at 1.4.2. The default definition of the continuation symbol was changed at 1.5 to accomodate various font sizes (e.g. code-blocks can be in footnotes).
TitleColor
- default
{rgb}{0.126,0.263,0.361}
. The colour for titles (as configured via use of package “titlesec”.)
Warning
Colours set via 'sphinxsetup'
must obey the syntax of the
argument of the color/xcolor
packages \definecolor
command.
InnerLinkColor
- default
{rgb}{0.208,0.374,0.486}
. A colour passed tohyperref
as value oflinkcolor
andcitecolor
. OuterLinkColor
- default
{rgb}{0.216,0.439,0.388}
. A colour passed tohyperref
as value offilecolor
,menucolor
, andurlcolor
. VerbatimColor
- default
{rgb}{1,1,1}
. The background colour forcode-block
s. The default is white. VerbatimBorderColor
- default
{rgb}{0,0,0}
. The frame color, defaults to black. VerbatimHighlightColor
default
{rgb}{0.878,1,1}
. The color for highlighted lines.New in version 1.6.6.
Note
Starting with this colour key, and for all others coming next, the actual names declared to “color” or “xcolor” are prefixed with “sphinx”.
verbatimsep
- default
\fboxsep
. The separation between code lines and the frame. verbatimborder
- default
\fboxrule
. The width of the frame aroundcode-block
s. shadowsep
- default
5pt
. The separation between contents and frame for contents and topic boxes. shadowsize
- default
4pt
. The width of the lateral “shadow” to the right. shadowrule
- default
\fboxrule
. The width of the frame around topic boxes. noteBorderColor
,hintBorderColor
,importantBorderColor
,tipBorderColor
- default
{rgb}{0,0,0}
(black). The colour for the two horizontal rules used by Sphinx in LaTeX for styling a note type admonition. noteborder
,hintborder
,importantborder
,tipborder
- default
0.5pt
. The width of the two horizontal rules.
warningBorderColor
,cautionBorderColor
,attentionBorderColor
,dangerBorderColor
,errorBorderColor
- default
{rgb}{0,0,0}
(black). The colour for the admonition frame.
warningBgColor
,cautionBgColor
,attentionBgColor
,dangerBgColor
,errorBgColor
- default
{rgb}{1,1,1}
(white). The background colours for the respective admonitions. warningBorder
,cautionBorder
,attentionBorder
,dangerBorder
,errorBorder
- default
1pt
. The width of the frame. AtStartFootnote
- default
\mbox{ }
. LaTeX macros inserted at the start of the footnote text at bottom of page, after the footnote number. BeforeFootnote
default
\leavevmode\unskip
. LaTeX macros inserted before the footnote mark. The default removes possible space before it (else, TeX could insert a linebreak there).New in version 1.5.
HeaderFamily
- default
\sffamily\bfseries
. Sets the font used by headings.
LaTeX macros and environments¶
Here are some macros from the package file sphinx.sty
and class files
sphinxhowto.cls
, sphinxmanual.cls
, which have public names
thus allowing redefinitions. Check the respective files for the defaults.
Macros¶
text styling commands
\sphinx<foo>
with<foo>
being one ofstrong
,bfcode
,email
,tablecontinued
,titleref
,menuselection
,accelerator
,crossref
,termref
,optional
.New in version 1.4.5: Use of
\sphinx
prefixed macro names to limit possibilities of conflict with LaTeX packages.more text styling:
\sphinxstyle<bar>
with<bar>
one ofindexentry
,indexextra
,indexpageref
,topictitle
,sidebartitle
,othertitle
,sidebarsubtitle
,theadfamily
,emphasis
,literalemphasis
,strong
,literalstrong
,abbreviation
,literalintitle
,codecontinued
,codecontinues
New in version 1.5: these macros were formerly hard-coded as non customizable
\texttt
,\emph
, etc…New in version 1.6:
\sphinxstyletheadfamily
which defaults to\sffamily
and allows multiple paragraphs in header cells of tables.New in version 1.6.3:
\sphinxstylecodecontinued
and\sphinxstylecodecontinues
.the table of contents is typeset via
\sphinxtableofcontents
which is a wrapper (whose definition can be found insphinxhowto.cls
or insphinxmanual.cls
) of standard\tableofcontents
.Changed in version 1.5: formerly, the meaning of
\tableofcontents
was modified by Sphinx.the
\maketitle
command is redefined by the class filessphinxmanual.cls
andsphinxhowto.cls
.the citation reference is typeset via
\sphinxcite
which is a wrapper of standard\cite
.
Environments¶
a figure may have an optional legend with arbitrary body elements: they are rendered in a
sphinxlegend
environment. The default definition issues\small
, and ends with\par
.New in version 1.5.6: formerly, the
\small
was hardcoded in LaTeX writer and the ending\par
was lacking.for each admonition type
<foo>
, the used environment is namedsphinx<foo>
. They may be\renewenvironment
‘d individually, and must then be defined with one argument (it is the heading of the notice, for exampleWarning:
for warning directive, if English is the document language). Their default definitions use either the sphinxheavybox (for the first listed directives) or the sphinxlightbox environments, configured to use the parameters (colours, border thickness) specific to each type, which can be set via'sphinxsetup'
string.Changed in version 1.5: use of public environment names, separate customizability of the parameters, such as
noteBorderColor
,noteborder
,warningBgColor
,warningBorderColor
,warningborder
, …the contents directive (with
:local:
option) and the topic directive are implemented by environmentsphinxShadowBox
.New in version 1.4.2: former code refactored into an environment allowing page breaks.
Changed in version 1.5: options
shadowsep
,shadowsize
,shadowrule
.the literal blocks (via
::
orcode-block
), are implemented usingsphinxVerbatim
environment which is a wrapper ofVerbatim
environment from packagefancyvrb.sty
. It adds the handling of the top caption and the wrapping of long lines, and a frame which allows pagebreaks. Inside tables the used environment issphinxVerbatimintable
(it does not draw a frame, but allows a caption).Changed in version 1.5:
Verbatim
keeps exact same meaning as infancyvrb.sty
(also under the nameOriginalVerbatim
);sphinxVerbatimintable
is used inside tables.New in version 1.5: options
verbatimwithframe
,verbatimwrapslines
,verbatimsep
,verbatimborder
.New in version 1.6.6: support for
:emphasize-lines:
optionNew in version 1.6.6: easier customizability of the formatting via exposed to user LaTeX macros such as
\sphinxVerbatimHighlightLine
.the bibliography uses
sphinxthebibliography
and the Python Module index as well as the general index both usesphinxtheindex
; these environments are wrappers of thethebibliography
and respectivelytheindex
environments as provided by the document class (or packages).Changed in version 1.5: formerly, the original environments were modified by Sphinx.
Miscellany¶
the section, subsection, … headings are set using titlesec’s
\titleformat
command.for the
'manual'
docclass, the chapter headings can be customized using fncychap’s commands\ChNameVar
,\ChNumVar
,\ChTitleVar
. Filesphinx.sty
has custom re-definitions in case of fncychap optionBjarne
.Changed in version 1.5: formerly, use of fncychap with other styles than
Bjarne
was dysfunctional.
Hint
As an experimental feature, Sphinx can use user-defined template file for
LaTeX source if you have a file named _templates/latex.tex_t
in your
project.
New in version 1.5: currently all template variables are unstable and undocumented.
Additional files longtable.tex_t
, tabulary.tex_t
and
tabular.tex_t
can be added to _templates/
to configure some aspects
of table rendering (such as the caption position).
New in version 1.6: currently all template variables are unstable and undocumented.
Developing extensions for Sphinx¶
Since many projects will need special features in their documentation, Sphinx is designed to be extensible on several levels.
This is what you can do in an extension: First, you can add new builders to support new output formats or actions on the parsed documents. Then, it is possible to register custom reStructuredText roles and directives, extending the markup. And finally, there are so-called “hook points” at strategic places throughout the build process, where an extension can register a hook and run specialized code.
An extension is simply a Python module. When an extension is loaded, Sphinx
imports this module and executes its setup()
function, which in turn
notifies Sphinx of everything the extension offers – see the extension tutorial
for examples.
The configuration file itself can be treated as an extension if it contains a
setup()
function. All other extensions to load must be listed in the
extensions
configuration value.
Discovery of builders by entry point¶
New in version 1.6.
Builder extensions can be discovered by means of entry points so
that they do not have to be listed in the extensions
configuration
value.
Builder extensions should define an entry point in the sphinx.builders
group. The name of the entry point needs to match your builder’s
name
attribute, which is the name passed to the
sphinx-build -b
option. The entry point value should equal the
dotted name of the extension module. Here is an example of how an entry point
for ‘mybuilder’ can be defined in the extension’s setup.py
:
setup(
# ...
entry_points={
'sphinx.builders': [
'mybuilder = my.extension.module',
],
}
)
Note that it is still necessary to register the builder using
add_builder()
in the extension’s setup()
function.
Extension metadata¶
New in version 1.3.
The setup()
function can return a dictionary. This is treated by Sphinx
as metadata of the extension. Metadata keys currently recognized are:
'version'
: a string that identifies the extension version. It is used for extension version requirement checking (seeneeds_extensions
) and informational purposes. If not given,"unknown version"
is substituted.'env_version'
: an integer that identifies the version of env data structure if the extension stores any data to environment. It is used to detect the data structure has been changed from last build. The extensions have to increment the version when data structure has changed. If not given, Sphinx considers the extension does not stores any data to environment.'parallel_read_safe'
: a boolean that specifies if parallel reading of source files can be used when the extension is loaded. It defaults toFalse
, i.e. you have to explicitly specify your extension to be parallel-read-safe after checking that it is.'parallel_write_safe'
: a boolean that specifies if parallel writing of output files can be used when the extension is loaded. Since extensions usually don’t negatively influence the process, this defaults toTrue
.
APIs used for writing extensions¶
Tutorial: Writing a simple extension¶
This section is intended as a walkthrough for the creation of custom extensions. It covers the basics of writing and activating an extension, as well as commonly used features of extensions.
As an example, we will cover a “todo” extension that adds capabilities to include todo entries in the documentation, and to collect these in a central place. (A similar “todo” extension is distributed with Sphinx.)
Important objects¶
There are several key objects whose API you will use while writing an extension. These are:
- Application
The application object (usually called
app
) is an instance ofSphinx
. It controls most high-level functionality, such as the setup of extensions, event dispatching and producing output (logging).If you have the environment object, the application is available as
env.app
.- Environment
The build environment object (usually called
env
) is an instance ofBuildEnvironment
. It is responsible for parsing the source documents, stores all metadata about the document collection and is serialized to disk after each build.Its API provides methods to do with access to metadata, resolving references, etc. It can also be used by extensions to cache information that should persist for incremental rebuilds.
If you have the application or builder object, the environment is available as
app.env
orbuilder.env
.- Builder
The builder object (usually called
builder
) is an instance of a specific subclass ofBuilder
. Each builder class knows how to convert the parsed documents into an output format, or otherwise process them (e.g. check external links).If you have the application object, the builder is available as
app.builder
.- Config
The config object (usually called
config
) provides the values of configuration values set inconf.py
as attributes. It is an instance ofConfig
.The config is available as
app.config
orenv.config
.
Build Phases¶
One thing that is vital in order to understand extension mechanisms is the way in which a Sphinx project is built: this works in several phases.
Phase 0: Initialization
In this phase, almost nothing of interest to us happens. The source directory is searched for source files, and extensions are initialized. Should a stored build environment exist, it is loaded, otherwise a new one is created.
Phase 1: Reading
In Phase 1, all source files (and on subsequent builds, those that are new or changed) are read and parsed. This is the phase where directives and roles are encountered by docutils, and the corresponding code is executed. The output of this phase is a doctree for each source file; that is a tree of docutils nodes. For document elements that aren’t fully known until all existing files are read, temporary nodes are created.
There are nodes provided by docutils, which are documented in the docutils documentation. Additional nodes are provided by Sphinx and documented here.
During reading, the build environment is updated with all meta- and cross reference data of the read documents, such as labels, the names of headings, described Python objects and index entries. This will later be used to replace the temporary nodes.
The parsed doctrees are stored on the disk, because it is not possible to hold all of them in memory.
Phase 2: Consistency checks
Some checking is done to ensure no surprises in the built documents.
Phase 3: Resolving
Now that the metadata and cross-reference data of all existing documents is known, all temporary nodes are replaced by nodes that can be converted into output using components called tranform. For example, links are created for object references that exist, and simple literal nodes are created for those that don’t.
Phase 4: Writing
This phase converts the resolved doctrees to the desired output format, such as HTML or LaTeX. This happens via a so-called docutils writer that visits the individual nodes of each doctree and produces some output in the process.
Note
Some builders deviate from this general build plan, for example, the builder that checks external links does not need anything more than the parsed doctrees and therefore does not have phases 2–4.
Extension Design¶
We want the extension to add the following to Sphinx:
- A “todo” directive, containing some content that is marked with “TODO”, and only shown in the output if a new config value is set. (Todo entries should not be in the output by default.)
- A “todolist” directive that creates a list of all todo entries throughout the documentation.
For that, we will need to add the following elements to Sphinx:
- New directives, called
todo
andtodolist
. - New document tree nodes to represent these directives, conventionally also
called
todo
andtodolist
. We wouldn’t need new nodes if the new directives only produced some content representable by existing nodes. - A new config value
todo_include_todos
(config value names should start with the extension name, in order to stay unique) that controls whether todo entries make it into the output. - New event handlers: one for the
doctree-resolved
event, to replace the todo and todolist nodes, and one forenv-purge-doc
(the reason for that will be covered later).
The Setup Function¶
The new elements are added in the extension’s setup function. Let us create a
new Python module called todo.py
and add the setup function:
def setup(app):
app.add_config_value('todo_include_todos', False, 'html')
app.add_node(todolist)
app.add_node(todo,
html=(visit_todo_node, depart_todo_node),
latex=(visit_todo_node, depart_todo_node),
text=(visit_todo_node, depart_todo_node))
app.add_directive('todo', TodoDirective)
app.add_directive('todolist', TodolistDirective)
app.connect('doctree-resolved', process_todo_nodes)
app.connect('env-purge-doc', purge_todos)
return {'version': '0.1'} # identifies the version of our extension
The calls in this function refer to classes and functions not yet written. What the individual calls do is the following:
add_config_value()
lets Sphinx know that it should recognize the new config valuetodo_include_todos
, whose default value should beFalse
(this also tells Sphinx that it is a boolean value).If the third argument was
'html'
, HTML documents would be full rebuild if the config value changed its value. This is needed for config values that influence reading (build phase 1).add_node()
adds a new node class to the build system. It also can specify visitor functions for each supported output format. These visitor functions are needed when the new nodes stay until phase 4 – since thetodolist
node is always replaced in phase 3, it doesn’t need any.We need to create the two node classes
todo
andtodolist
later.add_directive()
adds a new directive, given by name and class.The handler functions are created later.
Finally,
connect()
adds an event handler to the event whose name is given by the first argument. The event handler function is called with several arguments which are documented with the event.
The Node Classes¶
Let’s start with the node classes:
from docutils import nodes
class todo(nodes.Admonition, nodes.Element):
pass
class todolist(nodes.General, nodes.Element):
pass
def visit_todo_node(self, node):
self.visit_admonition(node)
def depart_todo_node(self, node):
self.depart_admonition(node)
Node classes usually don’t have to do anything except inherit from the standard
docutils classes defined in docutils.nodes
. todo
inherits from
Admonition
because it should be handled like a note or warning, todolist
is just a “general” node.
The Directive Classes¶
A directive class is a class deriving usually from
docutils.parsers.rst.Directive
. The directive interface is also
covered in detail in the docutils documentation; the important thing is that
the class should have attributes that configure the allowed markup,
and a run
method that returns a list of nodes.
The todolist
directive is quite simple:
from docutils.parsers.rst import Directive
class TodolistDirective(Directive):
def run(self):
return [todolist('')]
An instance of our todolist
node class is created and returned. The
todolist directive has neither content nor arguments that need to be handled.
The todo
directive function looks like this:
from sphinx.locale import _
class TodoDirective(Directive):
# this enables content in the directive
has_content = True
def run(self):
env = self.state.document.settings.env
targetid = "todo-%d" % env.new_serialno('todo')
targetnode = nodes.target('', '', ids=[targetid])
todo_node = todo('\n'.join(self.content))
todo_node += nodes.title(_('Todo'), _('Todo'))
self.state.nested_parse(self.content, self.content_offset, todo_node)
if not hasattr(env, 'todo_all_todos'):
env.todo_all_todos = []
env.todo_all_todos.append({
'docname': env.docname,
'lineno': self.lineno,
'todo': todo_node.deepcopy(),
'target': targetnode,
})
return [targetnode, todo_node]
Several important things are covered here. First, as you can see, you can refer
to the build environment instance using self.state.document.settings.env
.
Then, to act as a link target (from the todolist), the todo directive needs to
return a target node in addition to the todo node. The target ID (in HTML, this
will be the anchor name) is generated by using env.new_serialno
which
returns a new unique integer on each call and therefore leads to unique target
names. The target node is instantiated without any text (the first two
arguments).
On creating admonition node, the content body of the directive are parsed using
self.state.nested_parse
. The first argument gives the content body, and
the second one gives content offset. The third argument gives the parent node
of parsed result, in our case the todo
node.
Then, the todo node is added to the environment. This is needed to be able to
create a list of all todo entries throughout the documentation, in the place
where the author puts a todolist
directive. For this case, the environment
attribute todo_all_todos
is used (again, the name should be unique, so it is
prefixed by the extension name). It does not exist when a new environment is
created, so the directive must check and create it if necessary. Various
information about the todo entry’s location are stored along with a copy of the
node.
In the last line, the nodes that should be put into the doctree are returned: the target node and the admonition node.
The node structure that the directive returns looks like this:
+--------------------+
| target node |
+--------------------+
+--------------------+
| todo node |
+--------------------+
\__+--------------------+
| admonition title |
+--------------------+
| paragraph |
+--------------------+
| ... |
+--------------------+
The Event Handlers¶
Finally, let’s look at the event handlers. First, the one for the
env-purge-doc
event:
def purge_todos(app, env, docname):
if not hasattr(env, 'todo_all_todos'):
return
env.todo_all_todos = [todo for todo in env.todo_all_todos
if todo['docname'] != docname]
Since we store information from source files in the environment, which is
persistent, it may become out of date when the source file changes. Therefore,
before each source file is read, the environment’s records of it are cleared,
and the env-purge-doc
event gives extensions a chance to do the same.
Here we clear out all todos whose docname matches the given one from the
todo_all_todos
list. If there are todos left in the document, they will be
added again during parsing.
The other handler belongs to the doctree-resolved
event. This event is
emitted at the end of phase 3 and allows custom resolving to be done:
def process_todo_nodes(app, doctree, fromdocname):
if not app.config.todo_include_todos:
for node in doctree.traverse(todo):
node.parent.remove(node)
# Replace all todolist nodes with a list of the collected todos.
# Augment each todo with a backlink to the original location.
env = app.builder.env
for node in doctree.traverse(todolist):
if not app.config.todo_include_todos:
node.replace_self([])
continue
content = []
for todo_info in env.todo_all_todos:
para = nodes.paragraph()
filename = env.doc2path(todo_info['docname'], base=None)
description = (
_('(The original entry is located in %s, line %d and can be found ') %
(filename, todo_info['lineno']))
para += nodes.Text(description, description)
# Create a reference
newnode = nodes.reference('', '')
innernode = nodes.emphasis(_('here'), _('here'))
newnode['refdocname'] = todo_info['docname']
newnode['refuri'] = app.builder.get_relative_uri(
fromdocname, todo_info['docname'])
newnode['refuri'] += '#' + todo_info['target']['refid']
newnode.append(innernode)
para += newnode
para += nodes.Text('.)', '.)')
# Insert into the todolist
content.append(todo_info['todo'])
content.append(para)
node.replace_self(content)
It is a bit more involved. If our new “todo_include_todos” config value is false, all todo and todolist nodes are removed from the documents.
If not, todo nodes just stay where and how they are. Todolist nodes are
replaced by a list of todo entries, complete with backlinks to the location
where they come from. The list items are composed of the nodes from the todo
entry and docutils nodes created on the fly: a paragraph for each entry,
containing text that gives the location, and a link (reference node containing
an italic node) with the backreference. The reference URI is built by
app.builder.get_relative_uri
which creates a suitable URI depending on the
used builder, and appending the todo node’s (the target’s) ID as the anchor
name.
Application API¶
Each Sphinx extension is a Python module with at least a setup()
function. This function is called at initialization time with one argument,
the application object representing the Sphinx process.
-
class
sphinx.application.
Sphinx
[source]¶ This application object has the public API described in the following.
Extension setup¶
These methods are usually called in an extension’s setup()
function.
Examples of using the Sphinx extension API can be seen in the sphinx.ext
package.
-
Sphinx.
setup_extension
(name)[source]¶ Import and setup a Sphinx extension module. No-op if called twice.
-
Sphinx.
add_directive
(name, directiveclass)[source]
-
Sphinx.
add_directive_to_domain
(domain, name, directiveclass)[source]
-
Sphinx.
add_object_type
(directivename, rolename, indextemplate='', parse_node=None, ref_nodeclass=None, objname='', doc_field_types=[])[source]¶
-
Sphinx.
add_crossref_type
(directivename, rolename, indextemplate='', ref_nodeclass=None, objname='')[source]¶
Emitting events¶
Producing messages / logging¶
The application object also provides support for emitting leveled messages.
Note
There is no “error” call: in Sphinx, errors are defined as things that stop
the build; just raise an exception (sphinx.errors.SphinxError
or a
custom subclass) to do that.
Deprecated since version 1.6: Please use Logging API instead.
-
Sphinx.
warn
(message, location=None, type=None, subtype=None)[source]¶ Emit a warning.
If location is given, it should either be a tuple of (docname, lineno) or a string describing the location of the warning as well as possible.
type and subtype are used to suppress warnings with
suppress_warnings
.
Sphinx runtime information¶
The application object also provides runtime information as attributes.
-
Sphinx.
srcdir
¶ Source directory.
-
Sphinx.
confdir
¶ Directory containing
conf.py
.
-
Sphinx.
doctreedir
¶ Directory for storing pickled doctrees.
-
Sphinx.
outdir
¶ Directory for storing built document.
Sphinx core events¶
These events are known to the core. The arguments shown are given to the
registered event handlers. Use connect()
in an extension’s setup
function (note that conf.py
can also have a setup
function) to connect
handlers to the events. Example:
def source_read_handler(app, docname, source):
print('do something here...')
def setup(app):
app.connect('source-read', source_read_handler)
-
builder-inited
(app)¶ Emitted when the builder object has been created. It is available as
app.builder
.
-
config-inited
(app, config)¶ Emitted when the config object has been initialized.
New in version 1.8.
-
env-get-outdated
(app, env, added, changed, removed)¶ Emitted when the environment determines which source files have changed and should be re-read. added, changed and removed are sets of docnames that the environment has determined. You can return a list of docnames to re-read in addition to these.
New in version 1.1.
-
env-purge-doc
(app, env, docname)¶ Emitted when all traces of a source file should be cleaned from the environment, that is, if the source file is removed or before it is freshly read. This is for extensions that keep their own caches in attributes of the environment.
For example, there is a cache of all modules on the environment. When a source file has been changed, the cache’s entries for the file are cleared, since the module declarations could have been removed from the file.
New in version 0.5.
-
env-before-read-docs
(app, env, docnames)¶ Emitted after the environment has determined the list of all added and changed files and just before it reads them. It allows extension authors to reorder the list of docnames (inplace) before processing, or add more docnames that Sphinx did not consider changed (but never add any docnames that are not in
env.found_docs
).You can also remove document names; do this with caution since it will make Sphinx treat changed files as unchanged.
New in version 1.3.
-
source-read
(app, docname, source)¶ Emitted when a source file has been read. The source argument is a list whose single element is the contents of the source file. You can process the contents and replace this item to implement source-level transformations.
For example, if you want to use
$
signs to delimit inline math, like in LaTeX, you can use a regular expression to replace$...$
by:math:`...`
.New in version 0.5.
-
doctree-read
(app, doctree)¶ Emitted when a doctree has been parsed and read by the environment, and is about to be pickled. The doctree can be modified in-place.
-
missing-reference
(app, env, node, contnode)¶ Emitted when a cross-reference to a Python module or object cannot be resolved. If the event handler can resolve the reference, it should return a new docutils node to be inserted in the document tree in place of the node node. Usually this node is a
reference
node containing contnode as a child.Parameters: - env – The build environment (
app.builder.env
). - node – The
pending_xref
node to be resolved. Its attributesreftype
,reftarget
,modname
andclassname
attributes determine the type and target of the reference. - contnode – The node that carries the text and formatting inside the future reference and should be a child of the returned reference node.
New in version 0.5.
- env – The build environment (
-
doctree-resolved
(app, doctree, docname)¶ Emitted when a doctree has been “resolved” by the environment, that is, all references have been resolved and TOCs have been inserted. The doctree can be modified in place.
Here is the place to replace custom nodes that don’t have visitor methods in the writers, so that they don’t cause errors when the writers encounter them.
-
env-merge-info
(app, env, docnames, other)¶ This event is only emitted when parallel reading of documents is enabled. It is emitted once for every subprocess that has read some documents.
You must handle this event in an extension that stores data in the environment in a custom location. Otherwise the environment in the main process will not be aware of the information stored in the subprocess.
other is the environment object from the subprocess, env is the environment from the main process. docnames is a set of document names that have been read in the subprocess.
For a sample of how to deal with this event, look at the standard
sphinx.ext.todo
extension. The implementation is often similar to that ofenv-purge-doc
, only that information is not removed, but added to the main environment from the other environment.New in version 1.3.
-
env-updated
(app, env)¶ Emitted when the
update()
method of the build environment has completed, that is, the environment and all doctrees are now up-to-date.You can return an iterable of docnames from the handler. These documents will then be considered updated, and will be (re-)written during the writing phase.
New in version 0.5.
Changed in version 1.3: The handlers’ return value is now used.
-
env-check-consistency
(app, env)¶ Emitted when Consistency checks phase. You can check consistency of metadata for whole of documents.
New in version 1.6: As a experimental event
-
html-collect-pages
(app)¶ Emitted when the HTML builder is starting to write non-document pages. You can add pages to write by returning an iterable from this event consisting of
(pagename, context, templatename)
.New in version 1.0.
-
html-page-context
(app, pagename, templatename, context, doctree)¶ Emitted when the HTML builder has created a context dictionary to render a template with – this can be used to add custom elements to the context.
The pagename argument is the canonical name of the page being rendered, that is, without
.html
suffix and using slashes as path separators. The templatename is the name of the template to render, this will be'page.html'
for all pages from reST documents.The context argument is a dictionary of values that are given to the template engine to render the page and can be modified to include custom values. Keys must be strings.
The doctree argument will be a doctree when the page is created from a reST documents; it will be
None
when the page is created from an HTML template alone.You can return a string from the handler, it will then replace
'page.html'
as the HTML template for this page.New in version 0.4.
Changed in version 1.3: The return value can now specify a template name.
-
build-finished
(app, exception)¶ Emitted when a build has finished, before Sphinx exits, usually used for cleanup. This event is emitted even when the build process raised an exception, given as the exception argument. The exception is reraised in the application after the event handlers have run. If the build process raised no exception, exception will be
None
. This allows to customize cleanup actions depending on the exception status.New in version 0.5.
Checking the Sphinx version¶
Use this to adapt your extension to API changes in Sphinx.
-
sphinx.
version_info
= (1, 7, 9, 'final', 0)¶ tuple() -> empty tuple tuple(iterable) -> tuple initialized from iterable’s items
If the argument is a tuple, the return value is the same object.
The Config object¶
The template bridge¶
-
class
sphinx.application.
TemplateBridge
[source]¶ This class defines the interface for a “template bridge”, that is, a class that renders templates given a template name and a context.
-
init
(builder, theme=None, dirs=None)[source]¶ 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
sphinx.theming.Theme
object or None; in the latter case, dirs can be list of fixed directories to look for templates.
-
newest_template_mtime
()[source]¶ 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
.
-
Build environment API¶
-
class
sphinx.environment.
BuildEnvironment
[source]¶ Attributes
-
srcdir
¶ Source directory.
-
doctreedir
¶ Directory for storing pickled doctrees.
-
found_docs
¶ A set of all existing docnames.
-
metadata
¶ Dictionary mapping docnames to “metadata” (see File-wide metadata).
-
titles
¶ Dictionary mapping docnames to the docutils node for their main title.
-
docname
¶ Returns the docname of the document currently being parsed.
Utility methods
-
warn
(docname, msg, lineno=None, **kwargs)[source]¶ Emit a warning.
This differs from using
app.warn()
in that the warning may not be emitted instantly, but collected for emitting all warnings after the update of the environment.
-
doc2path
(docname, base=True, suffix=None)[source]¶ Return the filename for the document name.
If base is True, return absolute path under self.srcdir. If base is None, return relative path to self.srcdir. If base is a path string, return absolute path under that. If suffix is not None, add it instead of config.source_suffix.
-
relfn2path
(filename, docname=None)[source]¶ Return paths to a file referenced from a document, relative to documentation root and absolute.
In the input “filename”, absolute filenames are taken as relative to the source dir, while relative filenames are relative to the dir of the containing document.
-
note_dependency
(filename)[source]¶ Add filename as a dependency of the current document.
This means that the document will be rebuilt if this file changes.
filename should be absolute or relative to the source directory.
-
Builder API¶
Todo
Expand this.
-
class
sphinx.builders.
Builder
[source]¶ This is the base class for all builders.
These attributes should be set on builder classes:
-
name
= ''¶ The builder’s name, for the -b command line option.
-
format
= ''¶ The builder’s output format, or ‘’ if no document output is produced.
-
epilog
= ''¶ The message emitted upon successful build completion. This can be a printf-style template string with the following keys:
outdir
,project
-
supported_image_types
= []¶ The list of MIME types of image formats supported by the builder. Image files are searched in the order in which they appear here.
-
supported_remote_images
= False¶
-
supported_data_uri_images
= False¶
-
default_translator_class
= None¶
These methods are predefined and will be called from the application:
-
get_relative_uri
(from_, to, typ=None)[source]¶ Return a relative URI between two source filenames.
May raise environment.NoUri if there’s no way to return a sensible URI.
-
build
(docnames, summary=None, method='update')[source]¶ Main build method.
First updates the environment, and then calls
write()
.
These methods can be overridden in concrete builder classes:
-
init
()[source]¶ Load necessary templates and perform initialization. The default implementation does nothing.
-
get_outdated_docs
()[source]¶ Return an iterable of output files that are outdated, or a string describing what an update build will build.
If the builder does not output individual files corresponding to source files, return a string here. If it does, return an iterable of those files that need to be written.
-
get_target_uri
(docname, typ=None)[source]¶ Return the target URI for a document name.
typ can be used to qualify the link characteristic for individual builders.
-
prepare_writing
(docnames)[source]¶ A place where you can add logic before
write_doc()
is run
-
Environment Collector API¶
-
class
sphinx.environment.collectors.
EnvironmentCollector
[source]¶ An EnvironmentCollector is a specific data collector from each document.
It gathers data and stores
BuildEnvironment
as a database. Examples of specific data would be images, download files, section titles, metadatas, index entries and toctrees, etc.-
clear_doc
(app, env, docname)[source]¶ Remove specified data of a document.
This method is called on the removal of the document.
-
get_outdated_docs
(app, env, added, changed, removed)[source]¶ Return a list of docnames to re-read.
This methods is called before reading the documents.
-
get_updated_docs
(app, env)[source]¶ Return a list of docnames to re-read.
This methods is called after reading the whole of documents (experimental).
-
Docutils markup API¶
This section describes the API for adding ReST markup elements (roles and directives).
Roles¶
Directives¶
Directives are handled by classes derived from
docutils.parsers.rst.Directive
. They have to be registered by an extension
using Sphinx.add_directive()
or Sphinx.add_directive_to_domain()
.
-
class
docutils.parsers.rst.
Directive
[source]¶ The markup syntax of the new directive is determined by the follow five class attributes:
-
required_arguments
= 0¶ Number of required directive arguments.
-
optional_arguments
= 0¶ Number of optional arguments after the required arguments.
-
final_argument_whitespace
= False¶ May the final argument contain whitespace?
-
option_spec
= None¶ Mapping of option names to validator functions.
Option validator functions take a single parameter, the option argument (or
None
if not given), and should validate it or convert it to the proper form. They raiseValueError
orTypeError
to indicate failure.There are several predefined and possibly useful validators in the
docutils.parsers.rst.directives
module.
-
has_content
= False¶ May the directive have content?
New directives must implement the
run()
method:-
run
()[source]¶ This method must process the directive arguments, options and content, and return a list of Docutils/Sphinx nodes that will be inserted into the document tree at the point where the directive was encountered.
Instance attributes that are always set on the directive are:
-
name
¶ The directive name (useful when registering the same directive class under multiple names).
-
arguments
¶ The arguments given to the directive, as a list.
-
options
¶ The options given to the directive, as a dictionary mapping option names to validated/converted values.
-
content
¶ The directive content, if given, as a
ViewList
.
-
lineno
¶ The absolute line number on which the directive appeared. This is not always a useful value; use
srcline
instead.
-
content_offset
¶ Internal offset of the directive content. Used when calling
nested_parse
(see below).
-
block_text
¶ The string containing the entire directive.
-
ViewLists¶
Docutils represents document source lines in a class
docutils.statemachine.ViewList
. This is a list with extended functionality
– for one, slicing creates views of the original list, and also the list
contains information about the source line numbers.
The Directive.content
attribute is a ViewList. If you generate content
to be parsed as ReST, you have to create a ViewList yourself. Important for
content generation are the following points:
- The constructor takes a list of strings (lines) and a source (document) name.
- The
.append()
method takes a line and a source name as well.
Parsing directive content as ReST¶
Many directives will contain more markup that must be parsed. To do this, use
one of the following APIs from the Directive.run()
method:
self.state.nested_parse
sphinx.util.nodes.nested_parse_with_titles()
– this allows titles in the parsed content.
Both APIs parse the content into a given node. They are used like this:
node = docutils.nodes.paragraph()
# either
nested_parse_with_titles(self.state, self.result, node)
# or
self.state.nested_parse(self.result, 0, node)
Note
sphinx.util.docutils.switch_source_input()
allows to change a target file
during nested_parse. It is useful to mixed contents. For example, sphinx.
ext.autodoc
uses it to parse docstrings:
from sphinx.util.docutils import switch_source_input
# Switch source_input between parsing content.
# Inside this context, all parsing errors and warnings are reported as
# happened in new source_input (in this case, ``self.result``).
with switch_source_input(self.state, self.result):
node = docutils.nodes.paragraph()
self.state.nested_parse(self.result, 0, node)
Deprecated since version 1.7: Until Sphinx-1.6, sphinx.ext.autodoc.AutodocReporter
is used for this purpose.
For now, it is replaced by switch_source_input()
.
If you don’t need the wrapping node, you can use any concrete node type and
return node.children
from the Directive.
See also
- Creating directives
- HOWTO of the Docutils documentation
Domain API¶
-
class
sphinx.domains.
Domain
(env)[source]¶ A Domain is meant to be a group of “object” description directives for objects of a similar nature, and corresponding roles to create references to them. Examples would be Python modules, classes, functions etc., elements of a templating language, Sphinx roles and directives, etc.
Each domain has a separate storage for information about existing objects and how to reference them in self.data, which must be a dictionary. It also must implement several functions that expose the object information in a uniform way to parts of Sphinx that allow the user to reference or search for objects in a domain-agnostic way.
About self.data: since all object and cross-referencing information is stored on a BuildEnvironment instance, the domain.data object is also stored in the env.domaindata dict under the key domain.name. Before the build process starts, every active domain is instantiated and given the environment object; the domaindata dict must then either be nonexistent or a dictionary whose ‘version’ key is equal to the domain class’
data_version
attribute. Otherwise, IOError is raised and the pickled environment is discarded.-
directive
(name)[source]¶ Return a directive adapter class that always gives the registered directive its full name (‘domain:name’) as
self.name
.
-
get_objects
()[source]¶ Return an iterable of “object descriptions”, which are tuples with five items:
- name – fully qualified name
- dispname – name to display when searching/linking
- type – object type, a key in
self.object_types
- docname – the document where it is to be found
- anchor – the anchor name for the object
- priority – how “important” the object is (determines placement
in search results)
- 1: default priority (placed before full-text matches)
- 0: object is important (placed before default-priority objects)
- 2: object is unimportant (placed after full-text matches)
- -1: object should not show up in search at all
-
merge_domaindata
(docnames, otherdata)[source]¶ Merge in data regarding docnames from a different domaindata inventory (coming from a subprocess in parallel builds).
-
process_doc
(env, docname, document)[source]¶ Process a document after it is read by the environment.
-
process_field_xref
(pnode)[source]¶ Process a pending xref created in a doc field. For example, attach information about the current scope.
-
resolve_any_xref
(env, fromdocname, builder, target, node, contnode)[source]¶ Resolve the pending_xref node with the given target.
The reference comes from an “any” or similar role, which means that we don’t know the type. Otherwise, the arguments are the same as for
resolve_xref()
.The method must return a list (potentially empty) of tuples
('domain:role', newnode)
, where'domain:role'
is the name of a role that could have created the same reference, e.g.'py:func'
.newnode
is whatresolve_xref()
would return.New in version 1.3.
-
resolve_xref
(env, fromdocname, builder, typ, target, node, contnode)[source]¶ Resolve the pending_xref node with the given typ and target.
This method should return a new node, to replace the xref node, containing the contnode which is the markup content of the cross-reference.
If no resolution can be found, None can be returned; the xref node will then given to the ‘missing-reference’ event, and if that yields no resolution, replaced by contnode.
The method can also raise
sphinx.environment.NoUri
to suppress the ‘missing-reference’ event being emitted.
-
role
(name)[source]¶ Return a role adapter function that always gives the registered role its full name (‘domain:name’) as the first argument.
-
dangling_warnings
= {}¶ role name -> a warning message if reference is missing
-
data
= None¶ data value
-
data_version
= 0¶ data version, bump this when the format of self.data changes
-
directives
= {}¶ directive name -> directive class
-
indices
= []¶ a list of Index subclasses
-
initial_data
= {}¶ data value for a fresh environment
-
label
= ''¶ domain label: longer, more descriptive (used in messages)
-
name
= ''¶ domain name: should be short, but unique
-
object_types
= {}¶ type (usually directive) name -> ObjType instance
-
roles
= {}¶ role name -> role callable
-
-
class
sphinx.domains.
ObjType
(lname, *roles, **attrs)[source]¶ An ObjType is the description for a type of object that a domain can document. In the object_types attribute of Domain subclasses, object type names are mapped to instances of this class.
Constructor arguments:
- lname: localized name of the type (do not include domain name)
- roles: all the roles that can refer to an object of this type
- attrs: object attributes – currently only “searchprio” is known,
which defines the object’s priority in the full-text search index,
see
Domain.get_objects()
.
-
class
sphinx.domains.
Index
(domain)[source]¶ An Index is the description for a domain-specific index. To add an index to a domain, subclass Index, overriding the three name attributes:
- name is an identifier used for generating file names.
- localname is the section title for the index.
- shortname is a short name for the index, for use in the relation bar in HTML output. Can be empty to disable entries in the relation bar.
and providing a
generate()
method. Then, add the index class to your domain’s indices list. Extensions can add indices to existing domains usingadd_index_to_domain()
.-
generate
(docnames=None)[source]¶ Return entries for the index given by name. If docnames is given, restrict to entries referring to these docnames.
The return value is a tuple of
(content, collapse)
, where collapse is a boolean that determines if sub-entries should start collapsed (for output formats that support collapsing sub-entries).content is a sequence of
(letter, entries)
tuples, where letter is the “heading” for the given entries, usually the starting letter.entries is a sequence of single entries, where a single entry is a sequence
[name, subtype, docname, anchor, extra, qualifier, descr]
. The items in this sequence have the following meaning:- name – the name of the index entry to be displayed
- subtype – sub-entry related type: 0 – normal entry 1 – entry with sub-entries 2 – sub-entry
- docname – docname where the entry is located
- anchor – anchor for the entry within docname
- extra – extra info for the entry
- qualifier – qualifier for the description
- descr – description for the entry
Qualifier and description are not rendered e.g. in LaTeX output.
Parser API¶
The docutils documentation describes parsers as follows:
The Parser analyzes the input document and creates a node tree representation.
In Sphinx, the parser modules works as same as docutils. The parsers are
registered to Sphinx by extensions using Application APIs;
Sphinx.add_source_suffix()
and Sphinx.add_source_parser()
.
The source suffix is a mapping from file suffix to file type. For example,
.rst
file is mapped to 'restructuredtext'
type. Sphinx uses the
file type to looking for parsers from registered list. On searching,
Sphinx refers to the Parser.supported
attribute and picks up a parser
which contains the file type in the attribute.
The users can override the source suffix mappings using
source_suffix
like following:
# a mapping from file suffix to file types
source_suffix = {
'.rst': 'restructuredtext',
'.md': 'markdown',
}
You should indicate file types your parser supports. This will allow users to configure their settings appropriately.
-
class
sphinx.parsers.
Parser
[source]¶ A base class of source parsers. The additonal parsers should inherits this class instead of
docutils.parsers.Parser
. Compared withdocutils.parsers.Parser
, this class improves accessibility to Sphinx APIs.The subclasses can access following objects and functions:
- self.app
- The application object (
sphinx.application.Sphinx
) - self.config
- The config object (
sphinx.config.Config
) - self.env
- The environment object (
sphinx.environment.BuildEnvironment
) - self.warn()
- Emit a warning. (Same as
sphinx.application.Sphinx.warn()
) - self.info()
- Emit a informational message. (Same as
sphinx.application.Sphinx.info()
)
Doctree node classes added by Sphinx¶
Nodes for domain-specific object descriptions¶
-
class
sphinx.addnodes.
desc
(rawsource='', *children, **attributes)[source]¶ Node for object descriptions.
This node is similar to a “definition list” with one definition. It contains one or more
desc_signature
and adesc_content
.
-
class
sphinx.addnodes.
desc_signature
(rawsource='', text='', *children, **attributes)[source]¶ Node for object signatures.
The “term” part of the custom Sphinx definition list.
As default the signature is a single line signature, but set
is_multiline = True
to describe a multi-line signature. In that case all child nodes must bedesc_signature_line
nodes.
-
class
sphinx.addnodes.
desc_signature_line
(rawsource='', text='', *children, **attributes)[source]¶ Node for a line in a multi-line object signatures.
It should only be used in a
desc_signature
withis_multiline
set. Setadd_permalink = True
for the line that should get the permalink.
-
class
sphinx.addnodes.
desc_addname
(rawsource='', text='', *children, **attributes)[source]¶ Node for additional name parts (module name, class name).
-
class
sphinx.addnodes.
desc_type
(rawsource='', text='', *children, **attributes)[source]¶ Node for return types or object type names.
-
class
sphinx.addnodes.
desc_returns
(rawsource='', text='', *children, **attributes)[source]¶ Node for a “returns” annotation (a la -> in Python).
-
class
sphinx.addnodes.
desc_name
(rawsource='', text='', *children, **attributes)[source]¶ Node for the main object name.
-
class
sphinx.addnodes.
desc_parameterlist
(rawsource='', text='', *children, **attributes)[source]¶ Node for a general parameter list.
-
class
sphinx.addnodes.
desc_parameter
(rawsource='', text='', *children, **attributes)[source]¶ Node for a single parameter.
-
class
sphinx.addnodes.
desc_optional
(rawsource='', text='', *children, **attributes)[source]¶ Node for marking optional parts of the parameter list.
New admonition-like constructs¶
Other paragraph-level nodes¶
New inline nodes¶
-
class
sphinx.addnodes.
index
(rawsource='', text='', *children, **attributes)[source]¶ Node for index entries.
This node is created by the
index
directive and has one attribute,entries
. Its value is a list of 5-tuples of(entrytype, entryname, target, ignored, key)
.entrytype is one of “single”, “pair”, “double”, “triple”.
key is categolziation characters (usually it is single character) for general index page. For the detail of this, please see also:
glossary
and issue #2320.
-
class
sphinx.addnodes.
pending_xref
(rawsource='', *children, **attributes)[source]¶ Node for cross-references that cannot be resolved without complete information about all documents.
These nodes are resolved before writing output, in BuildEnvironment.resolve_references.
-
class
sphinx.addnodes.
literal_emphasis
(rawsource='', text='', *children, **attributes)[source]¶ Node that behaves like emphasis, but further text processors are not applied (e.g. smartypants for HTML output).
Special nodes¶
-
class
sphinx.addnodes.
only
(rawsource='', *children, **attributes)[source]¶ Node for “only” directives (conditional inclusion based on tags).
-
class
sphinx.addnodes.
meta
(rawsource='', *children, **attributes)[source]¶ Node for meta directive – same as docutils’ standard meta node, but pickleable.
-
class
sphinx.addnodes.
highlightlang
(rawsource='', *children, **attributes)[source]¶ Inserted to set the highlight language and line number options for subsequent code blocks.
You should not need to generate the nodes below in extensions.
-
class
sphinx.addnodes.
glossary
(rawsource='', *children, **attributes)[source]¶ Node to insert a glossary.
-
class
sphinx.addnodes.
toctree
(rawsource='', *children, **attributes)[source]¶ Node for inserting a “TOC tree”.
-
class
sphinx.addnodes.
start_of_file
(rawsource='', *children, **attributes)[source]¶ Node to mark start of a new file, used in the LaTeX builder only.
Logging API¶
-
sphinx.util.logging.
getLogger
(name)[source]¶ Get logger wrapped by SphinxLoggerAdapter.
Sphinx logger always uses
sphinx.*
namesapce to be independent from settings of root logger. It enables to log stably even if 3rd party extension or imported application resets logger settings.
-
class
sphinx.util.logging.
SphinxLoggerAdapter
(logging.LoggerAdapter)[source]¶ LoggerAdapter allowing
type
andsubtype
keywords.-
error
(msg, *args, **kwargs)¶
-
critical
(msg, *args, **kwargs)¶
-
warning
(msg, *args, **kwargs)¶ Logs a message on this logger with the specified level. Basically, the arguments are as with python’s logging module.
In addition, Sphinx logger supports following keyword arguments:
- type, *subtype*
- Categories of warning logs. It is used to suppress
warnings by
suppress_warnings
setting. - location
Where the warning happened. It is used to include the path and line number in each log. It allows docname, tuple of docname and line number and nodes:
logger = sphinx.util.logging.getLogger(__name__) logger.warning('Warning happened!', location='index') logger.warning('Warning happened!', location=('chapter1/index', 10)) logger.warning('Warning happened!', location=some_node)
- color
- The color of logs. By default, error level logs are colored as
"darkred"
, critical level ones is not colored, and warning level ones are colored as"red"
.
-
info
(msg, *args, **kwargs)¶
-
debug
(msg, *args, **kwargs)¶ Logs a message to this logger with the specified level. Basically, the arguments are as with python’s logging module.
In addition, Sphinx logger supports following keyword arguments:
- nonl
- If true, the logger does not fold lines at the end of the log message.
The default is
False
. - location
- Where the message emitted. For more detail, see
SphinxLoggerAdapter.warning()
. - color
- The color of logs. By default, info and verbose level logs are not colored,
and deug level ones are colored as
"darkgray"
.
-
i18n API¶
-
sphinx.locale.
init
(locale_dirs, language, catalog='sphinx')[source]¶ Look for message catalogs in locale_dirs and ensure that there is at least a NullTranslations catalog set in translators. If called multiple times or if several
.mo
files are found, their contents are merged together (thus makinginit
reentrable).
Utilities¶
Sphinx provides utility classes and functions to develop extensions.
Base classes for components¶
These base classes are useful to allow your extensions to obtain Sphinx
components (e.g. Config
, BuildEnvironment
and so on) easily.
Note
The subclasses of them might not work with bare docutils because they are strongly coupled with Sphinx.
-
class
sphinx.transforms.
SphinxTransform
(document, startnode=None)[source]¶ A base class of Transforms.
Compared with
docutils.transforms.Transform
, this class improves accessibility to Sphinx APIs.The subclasses can access following objects and functions:
- self.app
- The application object (
sphinx.application.Sphinx
) - self.config
- The config object (
sphinx.config.Config
) - self.env
- The environment object (
sphinx.environment.BuildEnvironment
)
-
class
sphinx.transforms.post_transforms.images.
ImageConverter
(*args, **kwargs)[source]¶ A base class images converter.
The concrete image converters should derive this class and overrides the following methods and attributes:
- default_priority (if needed)
- conversion_rules
- is_available()
- convert()
-
conversion_rules
= []¶ A conversion rules between two mimetypes which this converters supports
Deprecated APIs¶
On developing Sphinx, we are always careful to the compatibility of our APIs. But, sometimes, the change of interface are needed for some reasons. In such cases, we’ve marked them as deprecated. And they are kept during the two major versions (for more details, please see Deprecation policy).
The following is a list of deprecated interfaces.
Target | Deprecated | (will be) Removed | Alternatives |
---|---|---|---|
highlightlang |
1.8 | 4.0 | highlight |
add_stylesheet() |
1.8 | 4.0 | add_css_file() |
add_javascript() |
1.8 | 4.0 | add_js_file() |
autodoc_default_flags |
1.8 | 4.0 | autodoc_default_options |
content arguments of sphinx.util.image.guess_mimetype() |
1.8 | 3.0 | N/A |
gettext_compact arguments of
sphinx.util.i18n.find_catalog_source_files() |
1.8 | 3.0 | N/A |
sphinx.io.SphinxI18nReader.set_lineno_for_reporter() |
1.8 | 3.0 | N/A |
sphinx.io.SphinxI18nReader.line |
1.8 | 3.0 | N/A |
sphinx.directives.other.VersionChanges |
1.8 | 3.0 | sphinx.domains.changeset.VersionChanges |
sphinx.highlighting.PygmentsBridge.unhighlight() |
1.8 | 3.0 | N/A |
trim_doctest_flags arguments of
sphinx.highlighting.PygmentsBridge |
1.8 | 3.0 | N/A |
sphinx.ext.mathbase |
1.8 | 3.0 | N/A |
sphinx.ext.mathbase.MathDomain |
1.8 | 3.0 | sphinx.domains.math.MathDomain |
sphinx.ext.mathbase.MathDirective |
1.8 | 3.0 | sphinx.directives.patches.MathDirective |
sphinx.ext.mathbase.math_role() |
1.8 | 3.0 | docutils.parsers.rst.roles.math_role() |
sphinx.ext.mathbase.setup_math() |
1.8 | 3.0 | add_html_math_renderer() |
sphinx.ext.mathbase.is_in_section_title() |
1.8 | 3.0 | N/A |
sphinx.ext.mathbase.get_node_equation_number() |
1.8 | 3.0 | sphinx.util.math.get_node_equation_number() |
sphinx.ext.mathbase.wrap_displaymath() |
1.8 | 3.0 | sphinx.util.math.wrap_displaymath() |
sphinx.ext.mathbase.math (node) |
1.8 | 3.0 | docutils.nodes.math |
sphinx.ext.mathbase.displaymath (node) |
1.8 | 3.0 | docutils.nodes.math_block |
sphinx.ext.mathbase.eqref (node) |
1.8 | 3.0 | sphinx.builders.latex.nodes.math_reference |
viewcode_import (config value) |
1.8 | 3.0 | viewcode_follow_imported_members |
sphinx.writers.latex.Table.caption_footnotetexts |
1.8 | 3.0 | N/A |
sphinx.writers.latex.Table.header_footnotetexts |
1.8 | 3.0 | N/A |
sphinx.writers.latex.LaTeXTranslator.footnotestack |
1.8 | 3.0 | N/A |
sphinx.writers.latex.LaTeXTranslator.in_container_literal_block |
1.8 | 3.0 | N/A |
sphinx.writers.latex.LaTeXTranslator.next_section_ids |
1.8 | 3.0 | N/A |
sphinx.writers.latex.LaTeXTranslator.next_hyperlink_ids |
1.8 | 3.0 | N/A |
sphinx.writers.latex.LaTeXTranslator.restrict_footnote() |
1.8 | 3.0 | N/A |
sphinx.writers.latex.LaTeXTranslator.unrestrict_footnote() |
1.8 | 3.0 | N/A |
sphinx.writers.latex.LaTeXTranslator.push_hyperlink_ids() |
1.8 | 3.0 | N/A |
sphinx.writers.latex.LaTeXTranslator.pop_hyperlink_ids() |
1.8 | 3.0 | N/A |
sphinx.writers.latex.LaTeXTranslator.bibitems |
1.8 | 3.0 | N/A |
sphinx.writers.latex.LaTeXTranslator.hlsettingstack |
1.8 | 3.0 | N/A |
sphinx.writers.latex.ExtBabel.get_shorthandoff() |
1.8 | 3.0 | N/A |
sphinx.writers.html.HTMLTranslator.highlightlang() |
1.8 | 3.0 | N/A |
sphinx.writers.html.HTMLTranslator.highlightlang_base() |
1.8 | 3.0 | N/A |
sphinx.writers.html.HTMLTranslator.highlightlangopts() |
1.8 | 3.0 | N/A |
sphinx.writers.html.HTMLTranslator.highlightlinenothreshold() |
1.8 | 3.0 | N/A |
sphinx.writers.html5.HTMLTranslator.highlightlang() |
1.8 | 3.0 | N/A |
sphinx.writers.html5.HTMLTranslator.highlightlang_base() |
1.8 | 3.0 | N/A |
sphinx.writers.html5.HTMLTranslator.highlightlangopts() |
1.8 | 3.0 | N/A |
sphinx.writers.html5.HTMLTranslator.highlightlinenothreshold() |
1.8 | 3.0 | N/A |
sphinx.writers.latex.LaTeXTranslator.check_latex_elements() |
1.8 | 3.0 | Nothing |
sphinx.application.CONFIG_FILENAME |
1.8 | 3.0 | sphinx.config.CONFIG_FILENAME |
Config.check_unicode() |
1.8 | 3.0 | sphinx.config.check_unicode() |
Config.check_types() |
1.8 | 3.0 | sphinx.config.check_confval_types() |
dirname , filename and tags arguments of
Config.__init__() |
1.8 | 3.0 | Config.read() |
The value of html_search_options |
1.8 | 3.0 | see html_search_options |
sphinx.versioning.prepare() |
1.8 | 3.0 | sphinx.versioning.UIDTransform |
Sphinx.override_domain() |
1.8 | 3.0 | add_domain() |
Sphinx.import_object() |
1.8 | 3.0 | sphinx.util.import_object() |
suffix argument of
add_source_parser() |
1.8 | 3.0 | add_source_suffix() |
BuildEnvironment.load() |
1.8 | 3.0 | pickle.load() |
BuildEnvironment.loads() |
1.8 | 3.0 | pickle.loads() |
BuildEnvironment.frompickle() |
1.8 | 3.0 | pickle.load() |
BuildEnvironment.dump() |
1.8 | 3.0 | pickle.dump() |
BuildEnvironment.dumps() |
1.8 | 3.0 | pickle.dumps() |
BuildEnvironment.topickle() |
1.8 | 3.0 | pickle.dump() |
BuildEnvironment._nitpick_ignore |
1.8 | 3.0 | nitpick_ignore |
BuildEnvironment.versionchanges |
1.8 | 3.0 | N/A |
BuildEnvironment.update() |
1.8 | 3.0 | Builder.read() |
BuildEnvironment.read_doc() |
1.8 | 3.0 | Builder.read_doc() |
BuildEnvironment._read_serial() |
1.8 | 3.0 | Builder.read() |
BuildEnvironment._read_parallel() |
1.8 | 3.0 | Builder.read() |
BuildEnvironment.write_doctree() |
1.8 | 3.0 | Builder.write_doctree() |
BuildEnvironment.note_versionchange() |
1.8 | 3.0 | ChangesDomain.note_changeset() |
warn() (template helper function) |
1.8 | 3.0 | warning() |
source_parsers |
1.8 | 3.0 | add_source_parser() |
sphinx.util.docutils.directive_helper() |
1.8 | 3.0 | Directive class of docutils |
sphinx.cmdline |
1.8 | 3.0 | sphinx.cmd.build |
sphinx.make_mode |
1.8 | 3.0 | sphinx.cmd.make_mode |
sphinx.locale.l_() |
1.8 | 3.0 | sphinx.locale._() |
sphinx.locale.lazy_gettext() |
1.8 | 3.0 | sphinx.locale._() |
sphinx.locale.mygettext() |
1.8 | 3.0 | sphinx.locale._() |
sphinx.util.copy_static_entry() |
1.5 | 3.0 | sphinx.util.fileutil.copy_asset() |
sphinx.build_main() |
1.7 | 2.0 | sphinx.cmd.build.build_main() |
sphinx.ext.intersphinx.debug() |
1.7 | 2.0 | sphinx.ext.intersphinx.inspect_main() |
sphinx.ext.autodoc.format_annotation() |
1.7 | 2.0 | sphinx.util.inspect.Signature |
sphinx.ext.autodoc.formatargspec() |
1.7 | 2.0 | sphinx.util.inspect.Signature |
sphinx.ext.autodoc.AutodocReporter |
1.7 | 2.0 | sphinx.util.docutils.switch_source_input() |
sphinx.ext.autodoc.add_documenter() |
1.7 | 2.0 | add_autodocumenter() |
sphinx.ext.autodoc.AutoDirective._register |
1.7 | 2.0 | add_autodocumenter() |
AutoDirective._special_attrgetters |
1.7 | 2.0 | add_autodoc_attrgetter() |
Sphinx.warn() , Sphinx.info() |
1.6 | 2.0 | Logging API |
BuildEnvironment.set_warnfunc() |
1.6 | 2.0 | Logging API |
BuildEnvironment.note_toctree() |
1.6 | 2.0 | Toctree.note() (in sphinx.environment.adapters.toctree ) |
BuildEnvironment.get_toc_for() |
1.6 | 2.0 | Toctree.get_toc_for() (in sphinx.environment.adapters.toctree ) |
BuildEnvironment.get_toctree_for() |
1.6 | 2.0 | Toctree.get_toctree_for() (in sphinx.environment.adapters.toctree ) |
BuildEnvironment.create_index() |
1.6 | 2.0 | IndexEntries.create_index() (in sphinx.environment.adapters.indexentries ) |
sphinx.websupport |
1.6 | 2.0 | sphinxcontrib-websupport |
StandaloneHTMLBuilder.css_files |
1.6 | 2.0 | add_stylesheet() |
document.settings.gettext_compact |
1.8 | 1.8 | gettext_compact |
Sphinx.status_iterator() |
1.6 | 1.7 | sphinx.util.status_iterator() |
Sphinx.old_status_iterator() |
1.6 | 1.7 | sphinx.util.old_status_iterator() |
Sphinx._directive_helper() |
1.6 | 1.7 | sphinx.util.docutils.directive_helper() |
sphinx.util.compat.Directive |
1.6 | 1.7 | docutils.parsers.rst.Directive |
sphinx.util.compat.docutils_version |
1.6 | 1.7 | sphinx.util.docutils.__version_info__ |
Note
On deprecating on public APIs (internal functions and classes), we also follow the policy as much as possible.
Sphinx Web Support¶
New in version 1.1.
Sphinx provides a Python API to easily integrate Sphinx documentation into your web application. To learn more read the Web Support Quick Start.
Web Support Quick Start¶
Building Documentation Data¶
To make use of the web support package in your application you’ll need to build
the data it uses. This data includes pickle files representing documents,
search indices, and node data that is used to track where comments and other
things are in a document. To do this you will need to create an instance of the
WebSupport
class and call its build()
method:
from sphinxcontrib.websupport import WebSupport
support = WebSupport(srcdir='/path/to/rst/sources/',
builddir='/path/to/build/outdir',
search='xapian')
support.build()
This will read reStructuredText sources from srcdir and place the necessary data in builddir. The builddir will contain two sub-directories: one named “data” that contains all the data needed to display documents, search through documents, and add comments to documents. The other directory will be called “static” and contains static files that should be served from “/static”.
Note
If you wish to serve static files from a path other than “/static”, you can
do so by providing the staticdir keyword argument when creating the
WebSupport
object.
Integrating Sphinx Documents Into Your Webapp¶
Now that the data is built, it’s time to do something useful with it. Start off
by creating a WebSupport
object for your application:
from sphinxcontrib.websupport import WebSupport
support = WebSupport(datadir='/path/to/the/data',
search='xapian')
You’ll only need one of these for each set of documentation you will be working
with. You can then call its get_document()
method to access
individual documents:
contents = support.get_document('contents')
This will return a dictionary containing the following items:
- body: The main body of the document as HTML
- sidebar: The sidebar of the document as HTML
- relbar: A div containing links to related documents
- title: The title of the document
- css: Links to CSS files used by Sphinx
- script: JavaScript containing comment options
This dict can then be used as context for templates. The goal is to be easy to integrate with your existing templating system. An example using Jinja2 is:
{%- extends "layout.html" %}
{%- block title %}
{{ document.title }}
{%- endblock %}
{% block css %}
{{ super() }}
{{ document.css|safe }}
<link rel="stylesheet" href="/static/websupport-custom.css" type="text/css">
{% endblock %}
{%- block script %}
{{ super() }}
{{ document.script|safe }}
{%- endblock %}
{%- block relbar %}
{{ document.relbar|safe }}
{%- endblock %}
{%- block body %}
{{ document.body|safe }}
{%- endblock %}
{%- block sidebar %}
{{ document.sidebar|safe }}
{%- endblock %}
Authentication¶
To use certain features such as voting, it must be possible to authenticate
users. The details of the authentication are left to your application. Once a
user has been authenticated you can pass the user’s details to certain
WebSupport
methods using the username and moderator keyword
arguments. The web support package will store the username with comments and
votes. The only caveat is that if you allow users to change their username you
must update the websupport package’s data:
support.update_username(old_username, new_username)
username should be a unique string which identifies a user, and moderator
should be a boolean representing whether the user has moderation privileges.
The default value for moderator is False
.
An example Flask function that checks whether a user is logged in and then retrieves a document is:
from sphinxcontrib.websupport.errors import *
@app.route('/<path:docname>')
def doc(docname):
username = g.user.name if g.user else ''
moderator = g.user.moderator if g.user else False
try:
document = support.get_document(docname, username, moderator)
except DocumentNotFoundError:
abort(404)
return render_template('doc.html', document=document)
The first thing to notice is that the docname is just the request path. This
makes accessing the correct document easy from a single view. If the user is
authenticated, then the username and moderation status are passed along with the
docname to get_document()
. The web support package will then
add this data to the COMMENT_OPTIONS
that are used in the template.
Note
This only works if your documentation is served from your document root. If it is served from another directory, you will need to prefix the url route with that directory, and give the docroot keyword argument when creating the web support object:
support = WebSupport(..., docroot='docs')
@app.route('/docs/<path:docname>')
Performing Searches¶
To use the search form built-in to the Sphinx sidebar, create a function to
handle requests to the url ‘search’ relative to the documentation root. The
user’s search query will be in the GET parameters, with the key q. Then use
the get_search_results()
method to retrieve
search results. In Flask that would be like this:
@app.route('/search')
def search():
q = request.args.get('q')
document = support.get_search_results(q)
return render_template('doc.html', document=document)
Note that we used the same template to render our search results as we did to
render our documents. That’s because get_search_results()
returns a context dict in the same format that get_document()
does.
Comments & Proposals¶
Now that this is done it’s time to define the functions that handle the AJAX
calls from the script. You will need three functions. The first function is
used to add a new comment, and will call the web support method
add_comment()
:
@app.route('/docs/add_comment', methods=['POST'])
def add_comment():
parent_id = request.form.get('parent', '')
node_id = request.form.get('node', '')
text = request.form.get('text', '')
proposal = request.form.get('proposal', '')
username = g.user.name if g.user is not None else 'Anonymous'
comment = support.add_comment(text, node_id='node_id',
parent_id='parent_id',
username=username, proposal=proposal)
return jsonify(comment=comment)
You’ll notice that both a parent_id and node_id are sent with the
request. If the comment is being attached directly to a node, parent_id
will be empty. If the comment is a child of another comment, then node_id
will be empty. Then next function handles the retrieval of comments for a
specific node, and is aptly named
get_data()
:
@app.route('/docs/get_comments')
def get_comments():
username = g.user.name if g.user else None
moderator = g.user.moderator if g.user else False
node_id = request.args.get('node', '')
data = support.get_data(node_id, username, moderator)
return jsonify(**data)
The final function that is needed will call process_vote()
,
and will handle user votes on comments:
@app.route('/docs/process_vote', methods=['POST'])
def process_vote():
if g.user is None:
abort(401)
comment_id = request.form.get('comment_id')
value = request.form.get('value')
if value is None or comment_id is None:
abort(400)
support.process_vote(comment_id, g.user.id, value)
return "success"
Comment Moderation¶
By default, all comments added through add_comment()
are
automatically displayed. If you wish to have some form of moderation, you can
pass the displayed keyword argument:
comment = support.add_comment(text, node_id='node_id',
parent_id='parent_id',
username=username, proposal=proposal,
displayed=False)
You can then create a new view to handle the moderation of comments. It will be called when a moderator decides a comment should be accepted and displayed:
@app.route('/docs/accept_comment', methods=['POST'])
def accept_comment():
moderator = g.user.moderator if g.user else False
comment_id = request.form.get('id')
support.accept_comment(comment_id, moderator=moderator)
return 'OK'
Rejecting comments happens via comment deletion.
To perform a custom action (such as emailing a moderator) when a new comment is
added but not displayed, you can pass callable to the WebSupport
class when instantiating your support object:
def moderation_callback(comment):
"""Do something..."""
support = WebSupport(..., moderation_callback=moderation_callback)
The moderation callback must take one argument, which will be the same comment
dict that is returned by add_comment()
.
The WebSupport Class¶
-
class
sphinxcontrib.websupport.
WebSupport
[source]¶ The main API class for the web support package. All interactions with the web support package should occur through this class.
The class takes the following keyword arguments:
- srcdir
- The directory containing reStructuredText source files.
- builddir
- The directory that build data and static files should be placed in. This
should be used when creating a
WebSupport
object that will be used to build data. - datadir
- The directory that the web support data is in. This should be used when
creating a
WebSupport
object that will be used to retrieve data. - search
- This may contain either a string (e.g. ‘xapian’) referencing a built-in
search adapter to use, or an instance of a subclass of
BaseSearch
. - storage
- This may contain either a string representing a database uri, or an
instance of a subclass of
StorageBackend
. If this is not provided, a new sqlite database will be created. - moderation_callback
- A callable to be called when a new comment is added that is not displayed. It must accept one argument: a dictionary representing the comment that was added.
- staticdir
If the static files should be created in a different location and not in
'/static'
, this should be a string with the name of that location (e.g.builddir + '/static_files'
).Note
If you specify
staticdir
, you will typically want to adjuststaticroot
accordingly.- staticroot
- If the static files are not served from
'/static'
, this should be a string with the name of that location (e.g.'/static_files'
). - docroot
- If the documentation is not served from the base path of a URL, this
should be a string specifying that path (e.g.
'docs'
).
Changed in version 1.6: WebSupport class is moved to sphinxcontrib.websupport from sphinx.websupport.
Please add sphinxcontrib-websupport
package in your dependency and use
moved class instead.
Methods¶
-
WebSupport.
build
()[source]¶ Build the documentation. Places the data into the outdir directory. Use it like this:
support = WebSupport(srcdir, builddir, search='xapian') support.build()
This will read reStructured text files from srcdir. Then it will build the pickles and search index, placing them into builddir. It will also save node data to the database.
-
WebSupport.
get_document
(docname, username='', moderator=False)[source]¶ Load and return a document from a pickle. The document will be a dict object which can be used to render a template:
support = WebSupport(datadir=datadir) support.get_document('index', username, moderator)
In most cases docname will be taken from the request path and passed directly to this function. In Flask, that would be something like this:
@app.route('/<path:docname>') def index(docname): username = g.user.name if g.user else '' moderator = g.user.moderator if g.user else False try: document = support.get_document(docname, username, moderator) except DocumentNotFoundError: abort(404) render_template('doc.html', document=document)
The document dict that is returned contains the following items to be used during template rendering.
- body: The main body of the document as HTML
- sidebar: The sidebar of the document as HTML
- relbar: A div containing links to related documents
- title: The title of the document
- css: Links to css files used by Sphinx
- script: Javascript containing comment options
This raises
DocumentNotFoundError
if a document matching docname is not found.Parameters: docname – the name of the document to load.
-
WebSupport.
get_data
(node_id, username=None, moderator=False)[source]¶ Get the comments and source associated with node_id. If username is given vote information will be included with the returned comments. The default CommentBackend returns a dict with two keys, source, and comments. source is raw source of the node and is used as the starting point for proposals a user can add. comments is a list of dicts that represent a comment, each having the following items:
Key Contents text The comment text. username The username that was stored with the comment. id The comment’s unique identifier. rating The comment’s current rating. age The time in seconds since the comment was added. time A dict containing time information. It contains the following keys: year, month, day, hour, minute, second, iso, and delta. iso is the time formatted in ISO 8601 format. delta is a printable form of how old the comment is (e.g. “3 hours ago”). vote If user_id was given, this will be an integer representing the vote. 1 for an upvote, -1 for a downvote, or 0 if unvoted. node The id of the node that the comment is attached to. If the comment’s parent is another comment rather than a node, this will be null. parent The id of the comment that this comment is attached to if it is not attached to a node. children A list of all children, in this format. proposal_diff An HTML representation of the differences between the the current source and the user’s proposed source. Parameters: - node_id – the id of the node to get comments for.
- username – the username of the user viewing the comments.
- moderator – whether the user is a moderator.
-
WebSupport.
add_comment
(text, node_id='', parent_id='', displayed=True, username=None, time=None, proposal=None, moderator=False)[source]¶ Add a comment to a node or another comment. Returns the comment in the same format as
get_comments()
. If the comment is being attached to a node, pass in the node’s id (as a string) with the node keyword argument:comment = support.add_comment(text, node_id=node_id)
If the comment is the child of another comment, provide the parent’s id (as a string) with the parent keyword argument:
comment = support.add_comment(text, parent_id=parent_id)
If you would like to store a username with the comment, pass in the optional username keyword argument:
comment = support.add_comment(text, node=node_id, username=username)
Parameters: - parent_id – the prefixed id of the comment’s parent.
- text – the text of the comment.
- displayed – for moderation purposes
- username – the username of the user making the comment.
- time – the time the comment was created, defaults to now.
-
WebSupport.
process_vote
(comment_id, username, value)[source]¶ Process a user’s vote. The web support package relies on the API user to perform authentication. The API user will typically receive a comment_id and value from a form, and then make sure the user is authenticated. A unique username must be passed in, which will also be used to retrieve the user’s past voting data. An example, once again in Flask:
@app.route('/docs/process_vote', methods=['POST']) def process_vote(): if g.user is None: abort(401) comment_id = request.form.get('comment_id') value = request.form.get('value') if value is None or comment_id is None: abort(400) support.process_vote(comment_id, g.user.name, value) return "success"
Parameters: - comment_id – the comment being voted on
- username – the unique username of the user voting
- value – 1 for an upvote, -1 for a downvote, 0 for an unvote.
-
WebSupport.
get_search_results
(q)[source]¶ Perform a search for the query q, and create a set of search results. Then render the search results as html and return a context dict like the one created by
get_document()
:document = support.get_search_results(q)
Parameters: q – the search query
Search Adapters¶
To create a custom search adapter you will need to subclass the
BaseSearch
class. Then create an instance of the new class and pass
that as the search keyword argument when you create the WebSupport
object:
support = WebSupport(srcdir=srcdir,
builddir=builddir,
search=MySearch())
For more information about creating a custom search adapter, please see the
documentation of the BaseSearch
class below.
Changed in version 1.6: BaseSearch class is moved to sphinxcontrib.websupport.search from sphinx.websupport.search.
BaseSearch Methods¶
The following methods are defined in the BaseSearch class. Some methods do not need to be overridden, but some (add_document()
andhandle_query()
) must be overridden in your subclass. For a working example, look at the built-in adapter for whoosh.
-
BaseSearch.
init_indexing
(changed=[])[source]¶ Called by the builder to initialize the search indexer. changed is a list of pagenames that will be reindexed. You may want to remove these from the search index before indexing begins.
Parameters: changed – a list of pagenames that will be re-indexed
-
BaseSearch.
finish_indexing
()[source]¶ Called by the builder when writing has been completed. Use this to perform any finalization or cleanup actions after indexing is complete.
-
BaseSearch.
feed
(pagename, filename, title, doctree)[source]¶ Called by the builder to add a doctree to the index. Converts the doctree to text and passes it to
add_document()
. You probably won’t want to override this unless you need access to the doctree. Overrideadd_document()
instead.Parameters: - pagename – the name of the page to be indexed
- filename – the name of the original source file
- title – the title of the page to be indexed
- doctree – is the docutils doctree representation of the page
-
BaseSearch.
add_document
(pagename, filename, title, text)[source]¶ Called by
feed()
to add a document to the search index. This method should should do everything necessary to add a single document to the search index.pagename is name of the page being indexed. It is the combination of the source files relative path and filename, minus the extension. For example, if the source file is “ext/builders.rst”, the pagename would be “ext/builders”. This will need to be returned with search results when processing a query.
Parameters: - pagename – the name of the page being indexed
- filename – the name of the original source file
- title – the page’s title
- text – the full text of the page
-
BaseSearch.
query
(q)[source]¶ Called by the web support api to get search results. This method compiles the regular expression to be used when
extracting context
, then callshandle_query()
. You won’t want to override this unless you don’t want to use the includedextract_context()
method. Overridehandle_query()
instead.Parameters: q – the search query string.
-
BaseSearch.
handle_query
(q)[source]¶ Called by
query()
to retrieve search results for a search query q. This should return an iterable containing tuples of the following format:(<path>, <title>, <context>)
path and title are the same values that were passed to
add_document()
, and context should be a short text snippet of the text surrounding the search query in the document.The
extract_context()
method is provided as a simple way to create the context.Parameters: q – the search query
Storage Backends¶
To create a custom storage backend you will need to subclass the
StorageBackend
class. Then create an instance of the new class and
pass that as the storage keyword argument when you create the
WebSupport
object:
support = WebSupport(srcdir=srcdir,
builddir=builddir,
storage=MyStorage())
For more information about creating a custom storage backend, please see the
documentation of the StorageBackend
class below.
-
class
sphinxcontrib.websupport.storage.
StorageBackend
[source]¶ Defines an interface for storage backends.
Changed in version 1.6: StorageBackend class is moved to sphinxcontrib.websupport.storage from sphinx.websupport.storage.
StorageBackend Methods¶
-
StorageBackend.
pre_build
()[source]¶ Called immediately before the build process begins. Use this to prepare the StorageBackend for the addition of nodes.
-
StorageBackend.
add_node
(id, document, source)[source]¶ Add a node to the StorageBackend.
Parameters: - id – a unique id for the comment.
- document – the name of the document the node belongs to.
- source – the source files name.
-
StorageBackend.
post_build
()[source]¶ Called after a build has completed. Use this to finalize the addition of nodes if needed.
-
StorageBackend.
add_comment
(text, displayed, username, time, proposal, node_id, parent_id, moderator)[source]¶ Called when a comment is being added.
Parameters: - text – the text of the comment
- displayed – whether the comment should be displayed
- username – the name of the user adding the comment
- time – a date object with the time the comment was added
- proposal – the text of the proposal the user made
- node_id – the id of the node that the comment is being added to
- parent_id – the id of the comment’s parent comment.
- moderator – whether the user adding the comment is a moderator
-
StorageBackend.
delete_comment
(comment_id, username, moderator)[source]¶ Delete a comment.
Raises
UserNotAuthorizedError
if moderator is False and username doesn’t match the username on the comment.Parameters: - comment_id – The id of the comment being deleted.
- username – The username of the user requesting the deletion.
- moderator – Whether the user is a moderator.
-
StorageBackend.
get_data
(node_id, username, moderator)[source]¶ Called to retrieve all data for a node. This should return a dict with two keys, source and comments as described by
WebSupport
’sget_data()
method.Parameters: - node_id – The id of the node to get data for.
- username – The name of the user requesting the data.
- moderator – Whether the requestor is a moderator.
-
StorageBackend.
process_vote
(comment_id, username, value)[source]¶ Process a vote that is being cast. value will be either -1, 0, or 1.
Parameters: - comment_id – The id of the comment being voted on.
- username – The username of the user casting the vote.
- value – The value of the vote being cast.
-
StorageBackend.
update_username
(old_username, new_username)[source]¶ If a user is allowed to change their username this method should be called so that there is not stagnate data in the storage system.
Parameters: - old_username – The username being changed.
- new_username – What the username is being changed to.
Sphinx FAQ¶
This is a list of Frequently Asked Questions about Sphinx. Feel free to suggest new entries!
How do I…¶
- … create PDF files without LaTeX?
- rinohtype provides a PDF builder that can be used as a drop-in replacement for the LaTeX builder.
- … get section numbers?
- They are automatic in LaTeX output; for HTML, give a
:numbered:
option to thetoctree
directive where you want to start numbering. - … customize the look of the built HTML files?
- Use themes, see HTML theming support.
- … add global substitutions or includes?
- Add them in the
rst_prolog
orrst_epilog
config value. - … display the whole TOC tree in the sidebar?
- Use the
toctree
callable in a custom layout template, probably in thesidebartoc
block. - … write my own extension?
- See the extension tutorial.
- … convert from my existing docs using MoinMoin markup?
- The easiest way is to convert to xhtml, then convert xhtml to reST. You’ll still need to mark up classes and such, but the headings and code examples come through cleanly.
- … create HTML slides from Sphinx documents?
- See the “Hieroglyph” package at https://github.com/nyergler/hieroglyph.
For many more extensions and other contributed stuff, see the sphinx-contrib repository.
Using Sphinx with…¶
- Read the Docs
- https://readthedocs.org is a documentation hosting service based around Sphinx. They will host sphinx documentation, along with supporting a number of other features including version support, PDF generation, and more. The Getting Started guide is a good place to start.
- Epydoc
- There’s a third-party extension providing an api role which refers to Epydoc’s API docs for a given identifier.
- Doxygen
- Michael Jones is developing a reST/Sphinx bridge to doxygen called breathe.
- SCons
- Glenn Hutchings has written a SCons build script to build Sphinx documentation; it is hosted here: https://bitbucket.org/zondo/sphinx-scons
- PyPI
- Jannis Leidel wrote a setuptools command that automatically uploads Sphinx documentation to the PyPI package documentation area at https://pythonhosted.org/.
- GitHub Pages
- Directories starting with underscores are ignored by default which breaks static files in Sphinx. GitHub’s preprocessor can be disabled to support Sphinx HTML output properly.
- MediaWiki
- See https://bitbucket.org/kevindunn/sphinx-wiki/wiki/Home, a project by Kevin Dunn.
- Google Analytics
You can use a custom
layout.html
template, like this:{% extends "!layout.html" %} {%- block extrahead %} {{ super() }} <script type="text/javascript"> var _gaq = _gaq || []; _gaq.push(['_setAccount', 'XXX account number XXX']); _gaq.push(['_trackPageview']); </script> {% endblock %} {% block footer %} {{ super() }} <div class="footer">This page uses <a href="https://analytics.google.com/"> Google Analytics</a> to collect statistics. You can disable it by blocking the JavaScript coming from www.google-analytics.com. <script type="text/javascript"> (function() { var ga = document.createElement('script'); ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js'; ga.setAttribute('async', 'true'); document.documentElement.firstChild.appendChild(ga); })(); </script> </div> {% endblock %}
Epub info¶
The following list gives some hints for the creation of epub files:
Split the text into several files. The longer the individual HTML files are, the longer it takes the ebook reader to render them. In extreme cases, the rendering can take up to one minute.
Try to minimize the markup. This also pays in rendering time.
For some readers you can use embedded or external fonts using the CSS
@font-face
directive. This is extremely useful for code listings which are often cut at the right margin. The default Courier font (or variant) is quite wide and you can only display up to 60 characters on a line. If you replace it with a narrower font, you can get more characters on a line. You may even use FontForge and create narrow variants of some free font. In my case I get up to 70 characters on a line.You may have to experiment a little until you get reasonable results.
Test the created epubs. You can use several alternatives. The ones I am aware of are Epubcheck, Calibre, FBreader (although it does not render the CSS), and Bookworm. For Bookworm, you can download the source from https://code.google.com/archive/p/threepress and run your own local server.
Large floating divs are not displayed properly. If they cover more than one page, the div is only shown on the first page. In that case you can copy the
epub.css
from thesphinx/themes/epub/static/
directory to your local_static/
directory and remove the float settings.Files that are inserted outside of the
toctree
directive must be manually included. This sometimes applies to appendixes, e.g. the glossary or the indices. You can add them with theepub_post_files
option.The handling of the epub cover page differs from the reStructuredText procedure which automatically resolves image paths and puts the images into the
_images
directory. For the epub cover page put the image in thehtml_static_path
directory and reference it with its full path in theepub_cover
config option.kindlegen command can convert from epub3 resulting file to
.mobi
file for Kindle. You can getyourdoc.mobi
under_build/epub
after the following command:$ make epub $ kindlegen _build/epub/yourdoc.epub
The kindlegen command doesn’t accept documents that have section titles surrounding
toctree
directive:Section Title ============= .. toctree:: subdocument Section After Toc Tree ======================
kindlegen assumes all documents order in line, but the resulting document has complicated order for kindlegen:
``parent.xhtml`` -> ``child.xhtml`` -> ``parent.xhtml``
If you get the following error, fix your document structure:
Error(prcgen):E24011: TOC section scope is not included in the parent chapter:(title) Error(prcgen):E24001: The table of content could not be built.
Texinfo info¶
There are two main programs for reading Info files, info
and GNU Emacs. The
info
program has less features but is available in most Unix environments
and can be quickly accessed from the terminal. Emacs provides better font and
color display and supports extensive customization (of course).
Displaying Links¶
One noticeable problem you may encounter with the generated Info files is how references are displayed. If you read the source of an Info file, a reference to this section would look like:
* note Displaying Links: target-id
In the stand-alone reader, info
, references are displayed just as they
appear in the source. Emacs, on the other-hand, will by default replace
*note:
with see
and hide the target-id
. For example:
The exact behavior of how Emacs displays references is dependent on the variable
Info-hide-note-references
. If set to the value of hide
, Emacs will hide
both the *note:
part and the target-id
. This is generally the best way
to view Sphinx-based documents since they often make frequent use of links and
do not take this limitation into account. However, changing this variable
affects how all Info documents are displayed and most do take this behavior
into account.
If you want Emacs to display Info files produced by Sphinx using the value
hide
for Info-hide-note-references
and the default value for all other
Info files, try adding the following Emacs Lisp code to your start-up file,
~/.emacs.d/init.el
.
(defadvice info-insert-file-contents (after
sphinx-info-insert-file-contents
activate)
"Hack to make `Info-hide-note-references' buffer-local and
automatically set to `hide' iff it can be determined that this file
was created from a Texinfo file generated by Docutils or Sphinx."
(set (make-local-variable 'Info-hide-note-references)
(default-value 'Info-hide-note-references))
(save-excursion
(save-restriction
(widen) (goto-char (point-min))
(when (re-search-forward
"^Generated by \\(Sphinx\\|Docutils\\)"
(save-excursion (search-forward "\x1f" nil t)) t)
(set (make-local-variable 'Info-hide-note-references)
'hide)))))
Notes¶
The following notes may be helpful if you want to create Texinfo files:
Each section corresponds to a different
node
in the Info file.Colons (
:
) cannot be properly escaped in menu entries and xrefs. They will be replaced with semicolons (;
).Links to external Info files can be created using the somewhat official URI scheme
info
. For example:info:Texinfo#makeinfo_options
Inline markup
The standard formatting for
*strong*
and_emphasis_
can result in ambiguous output when used to markup parameter names and other values. Since this is a fairly common practice, the default formatting has been changed so thatemphasis
andstrong
are now displayed like`literal'
s.The standard formatting can be re-enabled by adding the following to your
conf.py
:texinfo_elements = {'preamble': """ @definfoenclose strong,*,* @definfoenclose emph,_,_ """}
Glossary¶
- builder
A class (inheriting from
Builder
) that takes parsed documents and performs an action on them. Normally, builders translate the documents to an output format, but it is also possible to use the builder builders that e.g. check for broken links in the documentation, or build coverage information.See Builders for an overview over Sphinx’s built-in builders.
- configuration directory
- The directory containing
conf.py
. By default, this is the same as the source directory, but can be set differently with the -c command-line option. - directive
A reStructuredText markup element that allows marking a block of content with special meaning. Directives are supplied not only by docutils, but Sphinx and custom extensions can add their own. The basic directive syntax looks like this:
.. directivename:: argument ... :option: value Content of the directive.
See Directives for more information.
- document name
Since reST source files can have different extensions (some people like
.txt
, some like.rst
– the extension can be configured withsource_suffix
) and different OSes have different path separators, Sphinx abstracts them: document names are always relative to the source directory, the extension is stripped, and path separators are converted to slashes. All values, parameters and such referring to “documents” expect such document names.Examples for document names are
index
,library/zipfile
, orreference/datamodel/types
. Note that there is no leading or trailing slash.- domain
A domain is a collection of markup (reStructuredText directives and roles) to describe and link to objects belonging together, e.g. elements of a programming language. Directive and role names in a domain have names like
domain:name
, e.g.py:function
.Having domains means that there are no naming problems when one set of documentation wants to refer to e.g. C++ and Python classes. It also means that extensions that support the documentation of whole new languages are much easier to write.
For more information, refer to Domains.
- environment
- A structure where information about all documents under the root is saved, and used for cross-referencing. The environment is pickled after the parsing stage, so that successive runs only need to read and parse new and changed documents.
- extension
A custom role, directive or other aspect of Sphinx that allows users to modify any aspect of the build process within Sphinx.
For more information, refer to Extensions.
- master document
- The document that contains the root
toctree
directive. - object
- The basic building block of Sphinx documentation. Every “object
directive” (e.g.
function
orobject
) creates such a block; and most objects can be cross-referenced to. - RemoveInSphinxXXXWarning
- The feature which is warned will be removed in Sphinx-XXX version. It usually caused from Sphinx extensions which is using deprecated. See also Deprecation Warnings.
- role
- A reStructuredText markup element that allows marking a piece of text.
Like directives, roles are extensible. The basic syntax looks like this:
:rolename:`content`
. See Inline markup for details. - source directory
- The directory which, including its subdirectories, contains all source files for one Sphinx project.
- reStructuredText
- An easy-to-read, what-you-see-is-what-you-get plaintext markup syntax and parser system.
Sphinx Developer’s Guide¶
Abstract
This document describes the development process of Sphinx, a documentation system used by developers to document systems used by other developers to develop other systems that may also be documented using Sphinx.
The Sphinx source code is managed using Git and is hosted on GitHub.
git clone git://github.com/sphinx-doc/sphinx
Community
- sphinx-users <sphinx-users@googlegroups.com>
- Mailing list for user support.
- sphinx-dev <sphinx-dev@googlegroups.com>
- Mailing list for development related discussions.
- #sphinx-doc on irc.freenode.net
- IRC channel for development questions and user support.
Bug Reports and Feature Requests¶
If you have encountered a problem with Sphinx or have an idea for a new feature, please submit it to the issue tracker on GitHub or discuss it on the sphinx-dev mailing list.
For bug reports, please include the output produced during the build process and also the log file Sphinx creates after it encounters an unhandled exception. The location of this file should be shown towards the end of the error message.
Including or providing a link to the source files involved may help us fix the issue. If possible, try to create a minimal project that produces the error and post that instead.
Contributing to Sphinx¶
The recommended way for new contributors to submit code to Sphinx is to fork the repository on GitHub and then submit a pull request after committing the changes. The pull request will then need to be approved by one of the core developers before it is merged into the main repository.
- Check for open issues or open a fresh issue to start a discussion around a feature idea or a bug.
- If you feel uncomfortable or uncertain about an issue or your changes, feel free to email the sphinx-dev mailing list.
- Fork the repository on GitHub to start making your changes to the
master
branch for next major version, orX.Y
branch for next minor version (see Branch Model). - Write a test which shows that the bug was fixed or that the feature works as expected.
- Send a pull request and bug the maintainer until it gets merged and published. Make sure to add yourself to AUTHORS and the change to CHANGES.
Getting Started¶
These are the basic steps needed to start developing on Sphinx.
Create an account on GitHub.
Fork the main Sphinx repository (sphinx-doc/sphinx) using the GitHub interface.
Clone the forked repository to your machine.
git clone https://github.com/USERNAME/sphinx cd sphinx
Checkout the appropriate branch.
For changes that should be included in the next minor release (namely bug fixes), use the
X.Y
branch.git checkout X.Y
For new features or other substantial changes that should wait until the next major release, use the
master
branch (see Branch Model for detail).Setup a virtual environment.
This is not necessary for unit testing, thanks to
tox
, but it is necessary if you wish to runsphinx-build
locally or run unit tests without the help oftox
.virtualenv ~/.venv . ~/.venv/bin/activate pip install -e .
Create a new working branch. Choose any name you like.
git checkout -b feature-xyz
Hack, hack, hack.
For tips on working with the code, see the Coding Guide.
Test, test, test.
Testing is best done through
tox
, which provides a number of targets and allows testing against multiple different Python environments:To list all possible targets:
tox -av
To run unit tests for a specific Python version, such as 3.6:
tox -e py36
To run unit tests for a specific Python version and turn on deprecation warnings on so they’re shown in the test output:
PYTHONWARNINGS=all tox -e py36
To run code style and type checks:
tox -e mypy tox -e flake8
Arguments to
pytest
can be passed viatox
, e.g. in order to run a particular test:tox -e py36 tests/test_module.py::test_new_feature
To build the documentation:
tox -e docs
To build the documentation in multiple formats:
tox -e docs -- -b html,latexpdf
To run JavaScript tests with Karma, execute the following commands (requires Node.js):
npm install npm run test
You can also test by installing dependencies in your local environment.
pip install .[test]
New unit tests should be included in the
tests
directory where necessary:- For bug fixes, first add a test that fails without your changes and passes after they are applied.
- Tests that need a
sphinx-build
run should be integrated in one of the existing test modules if possible. New tests that to@with_app
and thenbuild_all
for a few assertions are not good since the test suite should not take more than a minute to run.
Please add a bullet point to
CHANGES
if the fix or feature is not trivial (small doc updates, typo fixes). Then commit:git commit -m '#42: Add useful new feature that does this.'
GitHub recognizes certain phrases that can be used to automatically update the issue tracker.
For example:
git commit -m 'Closes #42: Fix invalid markup in docstring of Foo.bar.'
would close issue #42.
Push changes in the branch to your forked repository on GitHub.
git push origin feature-xyz
Submit a pull request from your branch to the respective branch (
master
orX.Y
).Wait for a core developer to review your changes.
Core Developers¶
The core developers of Sphinx have write access to the main repository. They can commit changes, accept/reject pull requests, and manage items on the issue tracker.
You do not need to be a core developer or have write access to be involved in the development of Sphinx. You can submit patches or create pull requests from forked repositories and have a core developer add the changes for you.
The following are some general guidelines for core developers:
- Questionable or extensive changes should be submitted as a pull request instead of being committed directly to the main repository. The pull request should be reviewed by another core developer before it is merged.
- Trivial changes can be committed directly but be sure to keep the repository in a good working state and that all tests pass before pushing your changes.
- When committing code written by someone else, please attribute the original
author in the commit message and any relevant
CHANGES
entry.
Locale updates¶
The parts of messages in Sphinx that go into builds are translated into several
locales. The translations are kept as gettext .po
files translated from the
master template sphinx/locale/sphinx.pot
.
Sphinx uses Babel to extract messages
and maintain the catalog files. It is integrated in setup.py
:
- Use
python setup.py extract_messages
to update the.pot
template. - Use
python setup.py update_catalog
to update all existing language catalogs insphinx/locale/*/LC_MESSAGES
with the current messages in the template file. - Use
python setup.py compile_catalog
to compile the.po
files to binary.mo
files and.js
files.
When an updated .po
file is submitted, run compile_catalog to commit both
the source and the compiled catalogs.
When a new locale is submitted, add a new directory with the ISO 639-1 language
identifier and put sphinx.po
in there. Don’t forget to update the possible
values for language
in doc/config.rst
.
The Sphinx core messages can also be translated on Transifex. There exists a client tool named tx
in the
Python package “transifex_client”, which can be used to pull translations in
.po
format from Transifex. To do this, go to sphinx/locale
and then run
tx pull -f -l LANG
where LANG is an existing language identifier. It is
good practice to run python setup.py update_catalog
afterwards to make sure
the .po
file has the canonical Babel formatting.
Coding Guide¶
- Try to use the same code style as used in the rest of the project. See the Pocoo Styleguide for more information.
- For non-trivial changes, please update the
CHANGES
file. If your changes alter existing behavior, please document this. - New features should be documented. Include examples and use cases where appropriate. If possible, include a sample that is displayed in the generated output.
- When adding a new configuration variable, be sure to document it and update
sphinx/quickstart.py
if it’s important enough. - Use the included utils/check_sources.py script to check for common formatting issues (trailing whitespace, lengthy lines, etc).
- Add appropriate unit tests.
Debugging Tips¶
Delete the build cache before building documents if you make changes in the code by running the command
make clean
or using thesphinx-build -E
option.Use the
sphinx-build -P
option to runpdb
on exceptions.Use
node.pformat()
andnode.asdom().toxml()
to generate a printable representation of the document structure.Set the configuration variable
keep_warnings
toTrue
so warnings will be displayed in the generated output.Set the configuration variable
nitpicky
toTrue
so that Sphinx will complain about references without a known target.Set the debugging options in the Docutils configuration file.
JavaScript stemming algorithms in
sphinx/search/*.py
(excepten.py
) are generated by this modified snowballcode generator. Generated JSX files are in this repository. You can get the resulting JavaScript files using the following command:npm install node_modules/.bin/grunt build # -> dest/*.global.js
Branch Model¶
Sphinx project uses following branches for developing.
master
- Used for main development. All improvement and refactoring, bug fixes are allowed.
X.Y
- Where
X.Y
is theMAJOR.MINOR
release. Used to maintain current stable release. Only bug fixes and stable changes are allowed. Only the most recent stable release is currently retained. When a new version is released, the old release branch will be deleted and replaced by an equivalent tag.
Deprecating a feature¶
There are a couple reasons that code in Sphinx might be deprecated:
- If a feature has been improved or modified in a backwards-incompatible way, the old feature or behavior will be deprecated.
- Sometimes Sphinx will include a backport of a Python library that’s not included in a version of Python that Sphinx currently supports. When Sphinx no longer needs to support the older version of Python that doesn’t include the library, the library will be deprecated in Sphinx.
As the Deprecation policy describes, the first release of Sphinx that
deprecates a feature (A.B
) should raise a RemovedInSphinxXXWarning
(where XX
is the Sphinx version where the feature will be removed) when the
deprecated feature is invoked. Assuming we have good test coverage, these
warnings are converted to errors when running the test suite with warnings
enabled:
pytest -Wall
Thus, when adding a RemovedInSphinxXXWarning
you need to eliminate or
silence any warnings generated when running the tests.
Deprecation policy¶
A feature release may deprecate certain features from previous releases. If a feature is deprecated in feature release 1.A, it will continue to work in all 1.A.x versions (for all versions of x) but raise warnings. Deprecated features will be removed in the first 1.B release, or 1.B.1 for features deprecated in the last 1.A.x feature release to ensure deprecations are done over at least 2 feature releases.
So, for example, if we decided to start the deprecation of a function in Sphinx 1.4:
- Sphinx 1.4.x will contain a backwards-compatible replica of the function
which will raise a
RemovedInSphinx16Warning
. - Sphinx 1.5 (the version that follows 1.4) will still contain the backwards-compatible replica.
- Sphinx 1.6 will remove the feature outright.
The warnings are displayed by default. You can turn off display of these warnings with:
PYTHONWARNINGS= make html
(Linux/Mac)export PYTHONWARNINGS=
and domake html
(Linux/Mac)set PYTHONWARNINGS=
and domake html
(Windows)
Unit Testing¶
Sphinx has been tested with pytest runner. Sphinx developers write unit tests
using pytest notation. Utility functions and pytest fixtures for testing are
provided in sphinx.testing
. If you are a developer of Sphinx extensions,
you can write unit tests with using pytest. At this time, sphinx.testing
will help your test implementation.
How to use pytest fixtures that are provided by sphinx.testing
?
You can require 'sphinx.testing.fixtures'
in your test modules or
conftest.py
files like this:
pytest_plugins = 'sphinx.testing.fixtures'
If you want to know more detailed usage, please refer to tests/conftest.py
and other test_*.py
files under tests
directory.
Note
Prior to Sphinx - 1.5.2, Sphinx was running the test with nose.
New in version 1.6: sphinx.testing
as a experimental.
New in version 1.8: Sphinx also runs JavaScript tests.
Changes in Sphinx¶
Release 1.8.2 (released Nov 11, 2018)¶
Incompatible changes¶
- #5497: Do not include MathJax.js and jsmath.js unless it is really needed
Features added¶
- #5471: Show appropriate deprecation warnings
Bugs fixed¶
- #5490: latex: enumerated list causes a crash with recommonmark
- #5492: sphinx-build fails to build docs w/ Python < 3.5.2
- #3704: latex: wrong
\label
positioning for figures with a legend - #5496: C++, fix assertion when a symbol is declared more than twice.
- #5493: gettext: crashed with broken template
- #5495: csv-table directive with file option in included file is broken (refs: #4821)
- #5498: autodoc: unable to find type hints for a
functools.partial
- #5480: autodoc: unable to find type hints for unresolvable Forward references
- #5419: incompatible math_block node has been generated
- #5548: Fix ensuredir() in case of pre-existing file
- #5549: graphviz Correctly deal with non-existing static dir
- #3002: i18n: multiple footnote_references referring same footnote causes duplicated node_ids
- #5563: latex: footnote_references generated by extension causes LaTeX builder crashed
- #5561: make all-pdf fails with old xindy version
- #5557: quickstart: –no-batchfile isn’t honored
- #3080: texinfo: multiline rubrics are broken
- #3080: texinfo: multiline citations are broken
Release 1.8.1 (released Sep 22, 2018)¶
Incompatible changes¶
- LaTeX
\pagestyle
commands have been moved to the LaTeX template. No changes in PDF, except possibly if\sphinxtableofcontents
, which contained them, had been customized inconf.py
. (refs: #5455)
Bugs fixed¶
- #5418: Incorrect default path for sphinx-build -d/doctrees files
- #5421: autodoc emits deprecation warning for
autodoc_default_flags
- #5422: lambda object causes PicklingError on storing environment
- #5417: Sphinx fails to build with syntax error in Python 2.7.5
- #4911: add latexpdf to make.bat for non make-mode
- #5436: Autodoc does not work with enum subclasses with properties/methods
- #5437: autodoc: crashed on modules importing eggs
- #5433: latex: ImportError: cannot import name ‘DEFAULT_SETTINGS’
- #5431: autodoc:
autofunction
emits a warning for callable objects - #5457: Fix TypeError in error message when override is prohibited
- #5453: PDF builds of ‘howto’ documents have no page numbers
- #5463: mathbase: math_role and MathDirective was disappeared in 1.8.0
- #5454: latex: Index has disappeared from PDF for Japanese documents
- #5432: py domain:
:type:
field can’t process:term:
references - #5426: py domain: TypeError has been raised for class attribute
Release 1.8.0 (released Sep 13, 2018)¶
Dependencies¶
1.8.0b1
- LaTeX:
latex_use_xindy
, ifTrue
(default forxelatex/lualatex
), instructsmake latexpdf
to use xindy for general index. Make sure your LaTeX distribution includes it. (refs: #5134) - LaTeX:
latexmk
is required formake latexpdf
on Windows
Incompatible changes¶
1.8.0b2
- #5282: html theme: refer
pygments_style
settings of HTML themes preferentially - The URL of download files are changed
- #5127: quickstart:
Makefile
andmake.bat
are not overwritten if exists
1.8.0b1
- #5156: the
sphinx.ext.graphviz: extension runs `dot
in the directory of the document being built instead of in the root directory of the documentation. - #4460: extensions which stores any data to environment should return the version of its env data structure as metadata. In detail, please see Extension metadata.
- Sphinx expects source parser modules to have supported file formats as
Parser.supported
attribute - The default value of
epub_author
andepub_publisher
are changed from'unknown'
to the value ofauthor
. This is same as aconf.py
file sphinx-build generates. - The
gettext_compact
attribute is removed fromdocument.settings
object. Please useconfig.gettext_compact
instead. - The processing order on reading phase is changed. smart_quotes, sphinx
domains,
doctree-read
event and versioning doctrees are invoked earlier than so far. For more details, please read a description ofSphinx.add_transform()
- #4827: All
substitution_definition
nodes are removed from doctree on reading phase docutils.conf
on$HOME
and/etc
directories are ignored. Onlydocutils.conf
on confdir is refered.- #789:
:samp:
role supports to escape curly braces with backslash - #4811: The files under
html_static_path
are excluded from source files. - latex: Use
\sphinxcite
for citation references instead\hyperref
- The config value
viewcode_import
is renamed toviewcode_follow_imported_members
(refs: #4035) - #1857: latex:
latex_show_pagerefs
does not add pagerefs for citations - #4648: latex: Now “rubric” elements are rendered as unnumbered section title
- #4983: html: The anchor for productionlist tokens has been changed
- Modifying a template variable
script_files
in templates is allowed now. Please useapp.add_js_file()
instead. - #5072: Save environment object also with only new documents
- #5035: qthelp builder allows dashes in
qthelp_namespace
- LaTeX: with lualatex or xelatex use by default xindy as UTF-8 able replacement of makeindex (refs: #5134). After upgrading Sphinx, please clean latex build repertory of existing project before new build.
- #5163: html: hlist items are now aligned to top
highlightlang
directive is processed on resolving phase- #4000: latex: LaTeX template has been chaned. Following elements are moved
into the template:
\begin{document}
shorthandoff
variablemaketitle
variabletableofcontents
variable
Deprecated¶
1.8.0b2
sphinx.io.SphinxI18nReader.set_lineno_for_reporter()
is deprecatedsphinx.io.SphinxI18nReader.line
is deprecatedsphinx.util.i18n.find_catalog_source_file()
has changed; the gettext_compact argument has been deprecated- #5403:
sphinx.util.images.guess_mimetype()
has changed; the content argument has been deprecated
1.8.0b1
source_parsers
is deprecatedautodoc_default_flags
is deprecated- quickstart:
--epub
option becomes default, so it is deprecated - Drop function based directive support. For now, Sphinx only supports class
based directives (see
Directive
) sphinx.util.docutils.directive_helper()
is deprecatedsphinx.cmdline
is deprecatedsphinx.make_mode
is deprecatedsphinx.locale.l_()
is deprecated- #2157: helper function
warn()
for HTML themes is deprecated app.override_domain()
is deprecatedapp.add_stylesheet()
is deprecatedapp.add_javascript()
is deprecatedapp.import_object()
is deprecatedapp.add_source_parser()
has changed; the suffix argument has been deprecatedsphinx.versioning.prepare()
is deprecatedConfig.__init__()
has changed; the dirname, filename and tags argument has been deprecatedConfig.check_types()
is deprecatedConfig.check_unicode()
is deprecatedsphinx.application.CONFIG_FILENAME
is deprecatedhighlightlang
directive is deprecatedBuildEnvironment.load()
is deprecatedBuildEnvironment.loads()
is deprecatedBuildEnvironment.frompickle()
is deprecatedenv.read_doc()
is deprecatedenv.update()
is deprecatedenv._read_serial()
is deprecatedenv._read_parallel()
is deprecatedenv.write_doctree()
is deprecatedenv._nitpick_ignore
is deprecatedenv.versionchanges
is deprecatedenv.dump()
is deprecatedenv.dumps()
is deprecatedenv.topickle()
is deprecatedenv.note_versionchange()
is deprecatedsphinx.writers.latex.Table.caption_footnotetexts
is deprecatedsphinx.writers.latex.Table.header_footnotetexts
is deprecatedsphinx.writers.latex.LaTeXTranslator.footnotestack
is deprecatedsphinx.writers.latex.LaTeXTranslator.in_container_literal_block
is deprecatedsphinx.writers.latex.LaTeXTranslator.next_section_ids
is deprecatedsphinx.writers.latex.LaTeXTranslator.next_hyperlink_ids
is deprecatedsphinx.writers.latex.LaTeXTranslator.restrict_footnote()
is deprecatedsphinx.writers.latex.LaTeXTranslator.unrestrict_footnote()
is deprecatedsphinx.writers.latex.LaTeXTranslator.push_hyperlink_ids()
is deprecatedsphinx.writers.latex.LaTeXTranslator.pop_hyperlink_ids()
is deprecatedsphinx.writers.latex.LaTeXTranslator.check_latex_elements()
is deprecatedsphinx.writers.latex.LaTeXTranslator.bibitems
is deprecatedsphinx.writers.latex.LaTeXTranslator.hlsettingstack
is deprecatedsphinx.writers.latex.ExtBabel.get_shorthandoff()
is deprecatedsphinx.writers.html.HTMLTranslator.highlightlang
is deprecatedsphinx.writers.html.HTMLTranslator.highlightlang_base
is deprecatedsphinx.writers.html.HTMLTranslator.highlightlangopts
is deprecatedsphinx.writers.html.HTMLTranslator.highlightlinenothreshold
is deprecatedsphinx.writers.html5.HTMLTranslator.highlightlang
is deprecatedsphinx.writers.html5.HTMLTranslator.highlightlang_base
is deprecatedsphinx.writers.html5.HTMLTranslator.highlightlangopts
is deprecatedsphinx.writers.html5.HTMLTranslator.highlightlinenothreshold
is deprecatedsphinx.ext.mathbase
extension is deprecatedsphinx.ext.mathbase.math
node is deprecatedsphinx.ext.mathbase.displaymath
node is deprecatedsphinx.ext.mathbase.eqref
node is deprecatedsphinx.ext.mathbase.is_in_section_title()
is deprecatedsphinx.ext.mathbase.MathDomain
is deprecatedsphinx.ext.mathbase.MathDirective
is deprecatedsphinx.ext.mathbase.math_role
is deprecatedsphinx.ext.mathbase.setup_math()
is deprecatedsphinx.directives.other.VersionChanges
is deprecatedsphinx.highlighting.PygmentsBridge.unhighlight()
is deprecatedsphinx.ext.mathbase.get_node_equation_number()
is deprecatedsphinx.ext.mathbase.wrap_displaymath()
is deprecated- The
trim_doctest_flags
argument ofsphinx.highlighting.PygmentsBridge
is deprecated
For more details, see deprecation APIs list
Features added¶
1.8.0b2
- #5388: Ensure frozen object descriptions are reproducible
- #5362: apidoc: Add
--tocfile
option to change the filename of ToC
1.8.0b1
- Add
config-inited
event - Add
sphinx.config.Any
to represent the config value accepts any type of value source_suffix
allows a mapping fileext to file types- Add
author
as a configuration value - #2852: imgconverter: Support to convert GIF to PNG
sphinx-build
command supports i18n console output- Add
app.add_message_catalog()
andsphinx.locale.get_translations()
to support translation for 3rd party extensions - helper function
warning()
for HTML themes is added - Add
Domain.enumerable_nodes
to manage own enumerable nodes for domains (experimental) - Add a new keyword argument
override
to Application APIs - LaTeX: new key
'fvset'
forlatex_elements
. For XeLaTeX/LuaLaTeX its default setsfanvyvrb
to use normal, not small, fontsize in code-blocks (refs: #4793) - Add
html_css_files
andepub_css_files
for adding CSS files from configuration - Add
html_js_files
for adding JS files from configuration - #4834: Ensure set object descriptions are reproducible.
- #4828: Allow to override
numfig_format
partially. Full definition is not needed. - Improve warning messages during including (refs: #4818)
- LaTeX: separate customizability of
guilabel
andmenuselection
(refs: #4830) - Add
Config.read()
classmethod to create a new config object from configuration file - #4866: Wrap graphviz diagrams in
<div>
tag - viewcode: Add
viewcode-find-source
andviewcode-follow-imported
to load source code without loading - #4785: napoleon: Add strings to translation file for localisation
- #4927: Display a warning when invalid values are passed to linenothreshold option of highlight directive
- C++:
- Add a
cpp:texpr
role as a sibling tocpp:expr
. - Add support for unions.
- #3593, #2683: add support for anonymous entities using names staring with
@
. - #5147: add support for (most) character literals.
- Cross-referencing entities inside primary templates is supported, and now properly documented.
- #1552: add new cross-referencing format for
cpp:any
andcpp:func
roles, for referencing specific function overloads.
- Add a
- #3606: MathJax should be loaded with async attribute
- html: Output
canonical_url
metadata ifhtml_baseurl
set (refs: #4193) - #5029: autosummary: expose
inherited_members
to template - #3784: mathjax: Add
mathjax_options
to give options to script tag for mathjax - #4362: latex: Don’t overwrite .tex file if document not changed
- #1431: latex: Add alphanumeric enumerated list support
- Add
latex_use_xindy
for UTF-8 savvy indexing, defaults toTrue
iflatex_engine
is'xelatex'
or'lualatex'
. (refs: #5134, #5192, #5212) - #4976:
SphinxLoggerAdapter.info()
now supportslocation
parameter - #5122: setuptools: support nitpicky option
- #2820: autoclass directive supports nested class
- Add
app.add_html_math_renderer()
to register a math renderer for HTML - Apply
trim_doctest_flags
to all builders (cf. text, manpages) - #5140: linkcheck: Add better Accept header to HTTP client
- #4614: sphinx-build: Add
--keep-going
option to show all warnings - Add
math:numref
role to refer equations (Same aseq
) - quickstart: epub builder is enabled by default
- #5246: Add
singlehtml_sidebars
to configure sidebars for singlehtml builder - #5273: doctest: Skip doctest conditionally
- #5306: autodoc: emit a warning for invalid typehints
- #4075, #5215: autodoc: Add
autodoc_default_options
which accepts option values as dict
Bugs fixed¶
1.8.0b2
- html: search box overrides to other elements if scrolled
- i18n: warnings for translation catalogs have wrong line numbers (refs: #5321)
- #5325: latex: cross references has been broken by multiply labeled objects
- C++, fixes for symbol addition and lookup. Lookup should no longer break in partial builds. See also #5337.
- #5348: download reference to remote file is not displayed
- #5282: html theme:
pygments_style
of theme was overrided byconf.py
by default - #4379: toctree shows confusible warning when document is excluded
- #2401: autodoc:
:members:
causes:special-members:
not to be shown - autodoc: ImportError is replaced by AttributeError for deeper module
- #2720, #4034: Incorrect links with
:download:
, duplicate names, and parallel builds - #5290: autodoc: failed to analyze source code in egg package
- #5399: Sphinx crashes if unknown po file exists
1.8.0b1
- i18n: message catalogs were reset on each initialization
- #4850: latex: footnote inside footnote was not rendered
- #4945: i18n: fix lang_COUNTRY not fallback correctly for IndexBuilder. Thanks to Shengjing Zhu.
- #4983: productionlist directive generates invalid IDs for the tokens
- #5132: (lualatex) PDF build fails if indexed word starts with Unicode character
- #5133: latex: index headings “Symbols” and “Numbers” not internationalized
- #5114: sphinx-build: Handle errors on scanning documents
- epub: spine has been broken when “self” is listed on toctree (refs: #4611)
- #344: autosummary does not understand docstring of module level attributes
- #5191: C++, prevent nested declarations in functions to avoid lookup problems.
- #5126: C++, add missing isPack method for certain template parameter types.
- #5187: C++, parse attributes on declerators as well.
- C++, parse delete expressions and basic new expressions as well.
- #5002: graphviz: SVGs do not adapt to the column width
Documentation¶
1.8.0b1
- #5083: Fix wrong make.bat option for internationalization.
- #5115: napoleon: add admonitions added by #4613 to the docs.
Release 1.7.10 (in development)¶
Dependencies¶
Incompatible changes¶
Deprecated¶
Features added¶
Bugs fixed¶
Testing¶
Release 1.7.9 (released Sep 05, 2018)¶
Features added¶
- #5359: Make generated texinfo files reproducible by sorting the anchors
Bugs fixed¶
- #5361: crashed on incremental build if document uses include directive
Release 1.7.8 (released Aug 29, 2018)¶
Incompatible changes¶
- The type of
env.included
has been changed to dict of set
Bugs fixed¶
- #5320: intersphinx: crashed if invalid url given
- #5326: manpage: crashed when invalid docname is specified as
man_pages
- #5322: autodoc:
Any
typehint causes formatting error - #5327: “document isn’t included in any toctree” warning on rebuild with generated files
- #5335: quickstart: escape sequence has been displayed with MacPorts’ python
Release 1.7.7 (released Aug 19, 2018)¶
Bugs fixed¶
- #5198: document not in toctree warning when including files only for parallel builds
- LaTeX: reduce “Token not allowed in a PDF string” hyperref warnings in latex console output (refs: #5236)
- LaTeX: suppress “remreset Warning: The remreset package is obsolete” in latex console output with recent LaTeX (refs: #5237)
- #5234: PDF output: usage of PAPER environment variable is broken since Sphinx 1.5
- LaTeX: fix the
latex_engine
documentation regarding Latin Modern font with XeLaTeX/LuaLateX (refs: #5251) - #5280: autodoc: Fix wrong type annotations for complex typing
- autodoc: Optional types are wrongly rendered
- #5291: autodoc crashed by ForwardRef types
- #5211: autodoc: No docs generated for functools.partial functions
- #5306: autodoc:
getargspec()
raises NameError for invalid typehints - #5298: imgmath: math_number_all causes equations to have two numbers in html
- #5294: sphinx-quickstart blank prompts in PowerShell
Release 1.7.6 (released Jul 17, 2018)¶
Bugs fixed¶
- #5037: LaTeX
\sphinxupquote{}
breaks in Russian - sphinx.testing uses deprecated pytest API;
Node.get_marker(name)
- #5016: crashed when recommonmark.AutoStrictify is enabled
- #5022: latex: crashed with docutils package provided by Debian/Ubuntu
- #5009: latex: a label for table is vanished if table does not have a caption
- #5048: crashed with numbered toctree
- #2410: C, render empty argument lists for macros.
- C++, fix lookup of full template specializations with no template arguments.
- #4667: C++, fix assertion on missing references in global scope when using intersphinx. Thanks to Alan M. Carroll.
- #5019: autodoc: crashed by Form Feed Character
- #5032: autodoc: loses the first staticmethod parameter for old styled classes
- #5036: quickstart: Typing Ctrl-U clears the whole of line
- #5066: html: “relations” sidebar is not shown by default
- #5091: latex: curly braces in index entries are not handled correctly
- #5070: epub: Wrong internal href fragment links
- #5104: apidoc: Interface of
sphinx.apidoc:main()
has changed - #4272: PDF builds of French projects have issues with XeTeX
- #5076: napoleon raises RuntimeError with python 3.7
- #5125: sphinx-build: Interface of
sphinx:main()
has changed - sphinx-build:
sphinx.cmd.build.main()
referssys.argv
instead of given argument - #5146: autosummary: warning is emitted when the first line of docstring ends with literal notation
- autosummary: warnings of autosummary indicates wrong location (refs: #5146)
- #5143: autodoc: crashed on inspecting dict like object which does not support sorting
- #5139: autodoc: Enum argument missing if it shares value with another
- #4946: py domain: rtype field could not handle “None” as a type
- #5176: LaTeX: indexing of terms containing
@
,!
, or"
fails - #5161: html: crashes if copying static files are failed
- #5167: autodoc: Fix formatting type annotations for tuples with more than two arguments
- #3329: i18n: crashed by auto-symbol footnote references
- #5158: autosummary: module summary has been broken when it starts with heading
Release 1.7.5 (released May 29, 2018)¶
Bugs fixed¶
- #4924: html search: Upper characters problem in any other languages
- #4932: apidoc: some subpackage is ignored if sibling subpackage contains a module starting with underscore
- #4863, #4938, #4939: i18n doesn’t handle node.title correctly tat used for contents, topic, admonition, table and section.
- #4913: i18n: literal blocks in bullet list are not translated
- #4962: C++, raised TypeError on duplicate declaration.
- #4825: C++, properly parse expr roles and give better error messages when (escaped) line breaks are present.
- C++, properly use
desc_addname
nodes for prefixes of names. - C++, parse pack expansions in function calls.
- #4915, #4916: links on search page are broken when using dirhtml builder
- #4969: autodoc: constructor method should not have return annotation
- latex: deeply nested enumerated list which is beginning with non-1 causes LaTeX engine crashed
- #4978: latex: shorthandoff is not set up for Brazil locale
- #4928: i18n: Ignore dot-directories like .git/ in LC_MESSAGES/
- #4946: py domain: type field could not handle “None” as a type
- #4979: latex: Incorrect escaping of curly braces in index entries
- #4956: autodoc: Failed to extract document from a subclass of the class on mocked module
- #4973: latex: glossary directive adds whitespace to each item
- #4980: latex: Explicit labels on code blocks are duplicated
- #4919: node.asdom() crashes if toctree has :numbered: option
- #4914: autodoc: Parsing error when using dataclasses without default values
- #4931: autodoc: crashed when handler for autodoc-skip-member raises an error
- #4931: autodoc: crashed when subclass of mocked class are processed by napoleon module
- #5007: sphinx-build crashes when error log contains a “%” character
Release 1.7.4 (released Apr 25, 2018)¶
Bugs fixed¶
- #4885, #4887: domains: Crashed with duplicated objects
- #4889: latex: sphinx.writers.latex causes recusrive import
Release 1.7.3 (released Apr 23, 2018)¶
Bugs fixed¶
- #4769: autodoc loses the first staticmethod parameter
- #4790: autosummary: too wide two column tables in PDF builds
- #4795: Latex customization via
_templates/longtable.tex_t
is broken - #4789: imgconverter: confused by convert.exe of Windows
- #4783: On windows, Sphinx crashed when drives of srcdir and outdir are different
- #4812: autodoc ignores type annotated variables
- #4817: wrong URLs on warning messages
- #4784: latex:
latex_show_urls
assigns incorrect footnote numbers if hyperlinks exists inside substitutions - #4837: latex with class memoir Error: Font command
\sf
is not supported - #4803: latex: too slow in proportion to number of auto numbered footnotes
- #4838: htmlhelp: The entries in .hhp file is not ordered
- toctree directive tries to glob for URL having query_string
- #4871: html search: Upper characters problem in German
- #4717: latex: Compilation for German docs failed with LuaLaTeX and XeLaTeX
- #4459: duplicated labels detector does not work well in parallel build
- #4878: Crashed with extension which returns invalid metadata
Release 1.7.2 (released Mar 21, 2018)¶
Incompatible changes¶
- #4520: apidoc: folders with an empty __init__.py are no longer excluded from TOC
Bugs fixed¶
- #4669: sphinx.build_main and sphinx.make_main throw NameError
- #4685: autosummary emits meaningless warnings
- autodoc: crashed when invalid options given
- pydomain: always strip parenthesis if empty (refs: #1042)
- #4689: autosummary: unexpectedly strips docstrings containing “i.e.”
- #4701: viewcode: Misplaced
<div>
in viewcode html output - #4444: Don’t require numfig to use :numref: on sections
- #4727: Option clash for package textcomp
- #4725: Sphinx does not work with python 3.5.0 and 3.5.1
- #4716: Generation PDF file with TexLive on Windows, file not found error
- #4574: vertical space before equation in latex
- #4720: message when an image is mismatched for builder is not clear
- #4655, #4684: Incomplete localization strings in Polish and Chinese
- #2286: Sphinx crashes when error is happens in rendering HTML pages
- #4688: Error to download remote images having long URL
- #4754: sphinx/pycode/__init__.py raises AttributeError
- #1435: qthelp builder should htmlescape keywords
- epub: Fix docTitle elements of toc.ncx is not escaped
- #4520: apidoc: Subpackage not in toc (introduced in 1.6.6) now fixed
- #4767: html: search highlighting breaks mathjax equations
Release 1.7.1 (released Feb 23, 2018)¶
Deprecated¶
- #4623:
sphinx.build_main()
is deprecated. - autosummary: The interface of
sphinx.ext.autosummary.get_documenter()
has been changed (Since 1.7.0) - #4664:
sphinx.ext.intersphinx.debug()
is deprecated.
For more details, see deprecation APIs list
Bugs fixed¶
- #4608: epub: Invalid meta tag is generated
- #4260: autodoc: keyword only argument separator is not disappeared if it is appeared at top of the argument list
- #4622: epub:
epub_scheme
does not effect to content.opf - #4627: graphviz: Fit graphviz images to page
- #4617: quickstart: PROJECT_DIR argument is required
- #4623: sphinx.build_main no longer exists in 1.7.0
- #4615: The argument of
sphinx.build
has been changed in 1.7.0 - autosummary: The interface of
sphinx.ext.autosummary.get_documenter()
has been changed - #4630: Have order on msgids in sphinx.pot deterministic
- #4563: autosummary: Incorrect end of line punctuation detection
- #4577: Enumerated sublists with explicit start with wrong number
- #4641: A external link in TOC cannot contain “?” with
:glob:
option - C++, add missing parsing of explicit casts and typeid in expression parsing.
- C++, add missing parsing of
this
in expression parsing. - #4655: Fix incomplete localization strings in Polish
- #4653: Fix error reporting for parameterless ImportErrors
- #4664: Reading objects.inv fails again
- #4662:
any
refs withterm
targets crash when an ambiguity is encountered
Release 1.7.0 (released Feb 12, 2018)¶
Incompatible changes¶
1.7.0b1
- #3668: The arguments has changed of main functions for each command
- #3893: Unknown html_theme_options throw warnings instead of errors
- #3927: Python parameter/variable types should match classes, not all objects
- #3962: sphinx-apidoc now recognizes given directory as an implicit namespace
package when
--implicit-namespaces
option given, not subdirectories of given directory. - #3929: apidoc: Move sphinx.apidoc to sphinx.ext.apidoc
- #4226: apidoc: Generate new style makefile (make-mode)
- #4274: sphinx-build returns 2 as an exit code on argument error
- #4389: output directory will be created after loading extensions
- autodoc does not generate warnings messages to the generated document even if
keep_warnings
is True. They are only emitted to stderr. - shebang line is removed from generated conf.py
- #2557: autodoc:
autodoc_mock_imports
only mocks specified modules with their descendants. It does not mock their ancestors. If you want to mock them, please specify the name of ancestors explicitly. - #3620: html theme: move DOCUMENTATION_OPTIONS to independent JavaScript file (refs: #4295)
- #4246: Limit width of text body for all themes. Conifigurable via theme
options
body_min_width
andbody_max_width
. - #4771: apidoc: The
exclude_patterns
arguments are ignored if they are placed just after command line options
1.7.0b2
- #4467: html theme: Rename
csss
block tocss
Deprecated¶
1.7.0b1
- using a string value for
html_sidebars
is deprecated and only list values will be accepted at 2.0. format_annotation()
andformatargspec()
is deprecated. Please usesphinx.util.inspect.Signature
instead.sphinx.ext.autodoc.AutodocReporter
is replaced bysphinx.util.docutils. switch_source_input()
and now deprecated. It will be removed in Sphinx-2.0.sphinx.ext.autodoc.add_documenter()
andAutoDirective._register
is now deprecated. Please useapp.add_autodocumenter()
instead.AutoDirective._special_attrgetters
is now deprecated. Please useapp.add_autodoc_attrgetter()
instead.
Features added¶
1.7.0b1
- C++, handle
decltype(auto)
. - #2406: C++, add proper parsing of expressions, including linking of identifiers.
- C++, add a
cpp:expr
role for inserting inline C++ expressions or types. - C++, support explicit member instantiations with shorthand
template
prefix. - C++, make function parameters linkable, like template params.
- #3638: Allow to change a label of reference to equation using
math_eqref_format
- Now
suppress_warnings
accepts following configurations:ref.python
(ref: #3866)
- #3872: Add latex key to configure literal blocks caption position in PDF output (refs #3792, #1723)
- In case of missing docstring try to retrieve doc from base classes (ref: #3140)
- #4023: Clarify error message when any role has more than one target.
- #3973: epub: allow to override build date
- #3972: epub: Sort manifest entries by filename
- #4052: viewcode: Sort before highlighting module code
- #1448: qthelp: Add new config value;
qthelp_namespace
- #4140: html themes: Make body tag inheritable
- #4168: improve zh search with jieba
- HTML themes can set up default sidebars through
theme.conf
- #3160: html: Use
<kdb>
to represent:kbd:
role - #4212: autosummary: catch all exceptions when importing modules
- #4166: Add
math_numfig
for equation numbering by section (refs: #3991, #4080). Thanks to Oliver Jahn. - #4311: Let LaTeX obey
numfig_secnum_depth
for figures, tables, and code-blocks - #947: autodoc now supports ignore-module-all to ignore a module’s
__all__
- #4332: Let LaTeX obey
math_numfig
for equation numbering - #4093: sphinx-build creates empty directories for unknown targets/builders
- Add
top-classes
option for thesphinx.ext.inheritance_diagram
extension to limit the scope of inheritance graphs. - #4183: doctest:
:pyversion:
option also follows PEP-440 specification - #4235: html: Add
manpages_url
to make manpage roles to hyperlinks - #3570: autodoc: Do not display ‘typing.’ module for type hints
- #4354: sphinx-build now emits finish message. Builders can modify it through
Builder.epilog
attribute - #4245: html themes: Add
language
to javascript vars list - #4079: html: Add
notranslate
class to each code-blocks, literals and maths to let Google Translate know they are not translatable - #4137: doctest: doctest block is always highlighted as python console (pycon)
- #4137: doctest: testcode block is always highlighted as python
- #3998: text: Assign section numbers by default. You can control it using
text_add_secnumbers
andtext_secnumber_suffix
1.7.0b2
- #4271: sphinx-build supports an option called
-j auto
to adjust numbers of processes automatically. - Napoleon: added option to specify custom section tags.
Features removed¶
1.7.0b1
- Configuration variables
- html_use_smartypants
- latex_keep_old_macro_names
- latex_elements[‘footer’]
- utility methods of
sphinx.application.Sphinx
class- buildername (property)
- _display_chunk()
- old_status_iterator()
- status_iterator()
- _directive_helper()
- utility methods of
sphinx.environment.BuildEnvironment
class- currmodule (property)
- currclass (property)
- epub2 builder
- prefix and colorfunc parameter for warn()
sphinx.util.compat
modulesphinx.util.nodes.process_only_nodes()
- LaTeX environment
notice
, usesphinxadmonition
instead - LaTeX
\sphinxstylethead
, use\sphinxstyletheadfamily
- C++, support of function concepts. Thanks to mickk-on-cpp.
- Not used and previously not documented LaTeX macros
\shortversion
and\setshortversion
Bugs fixed¶
1.7.0b1
- #3882: Update the order of files for HTMLHelp and QTHelp
- #3962: sphinx-apidoc does not recognize implicit namespace packages correctly
- #4094: C++, allow empty template argument lists.
- C++, also hyperlink types in the name of declarations with qualified names.
- C++, do not add index entries for declarations inside concepts.
- C++, support the template disambiguator for dependent names.
- #4314: For PDF ‘howto’ documents, numbering of code-blocks differs from the one of figures and tables
- #4330: PDF ‘howto’ documents have an incoherent default LaTeX tocdepth counter setting
- #4198: autosummary emits multiple ‘autodoc-process-docstring’ event. Thanks to Joel Nothman.
- #4081: Warnings and errors colored the same when building
- latex: Do not display ‘Release’ label if
release
is not set
1.7.0b2
- #4415: autodoc classifies inherited classmethods as regular methods
- #4415: autodoc classifies inherited staticmethods as regular methods
- #4472: DOCUMENTATION_OPTIONS is not defined
- #4491: autodoc: prefer _MockImporter over other importers in sys.meta_path
- #4490: autodoc: type annotation is broken with python 3.7.0a4+
- utils package is no longer installed
- #3952: apidoc: module header is too escaped
- #4275: Formats accepted by sphinx.util.i18n.format_date are limited
- #4493: recommonmark raises AttributeError if AutoStructify enabled
- #4209: intersphinx: In link title, “v” should be optional if target has no version
- #4230: slowdown in writing pages with sphinx 1.6
- #4522: epub: document is not rebuilt even if config changed
1.7.0b3
- #4019: inheritance_diagram AttributeError stoping make process
- #4531: autosummary: methods are not treated as attributes
- #4538: autodoc:
sphinx.ext.autodoc.Options
has been moved - #4539: autodoc emits warnings for partialmethods
- #4223: doctest: failing tests reported in wrong file, at wrong line
- i18n: message catalogs are not compiled if specific filenames are given for
sphinx-build
as arguments (refs: #4560) - #4027: sphinx.ext.autosectionlabel now expects labels to be the same as they are in the raw source; no smart quotes, nothig fancy.
- #4581: apidoc: Excluded modules still included
Testing¶
1.7.0b1
- Add support for docutils 0.14
- Add tests for the
sphinx.ext.inheritance_diagram
extension.
Release 1.6.7 (released Feb 04, 2018)¶
Bugs fixed¶
- #1922: html search: Upper characters problem in French
- #4412: Updated jQuery version from 3.1.0 to 3.2.1
- #4438: math: math with labels with whitespace cause html error
- #2437: make full reference for classes, aliased with “alias of”
- #4434: pure numbers as link targets produce warning
- #4477: Build fails after building specific files
- #4449: apidoc: include “empty” packages that contain modules
- #3917: citation labels are tranformed to ellipsis
- #4501: graphviz: epub3 validation error caused if graph is not clickable
- #4514: graphviz: workaround for wrong map ID which graphviz generates
- #4525: autosectionlabel does not support parallel build
- #3953: Do not raise warning when there is a working intersphinx inventory
- #4487: math: ValueError is raised on parallel build. Thanks to jschueller.
- #2372: autosummary: invalid signatures are shown for type annotated functions
- #3942: html: table is not aligned to center even if
:align: center
Release 1.6.6 (released Jan 08, 2018)¶
Features added¶
- #4181: autodoc: Sort dictionary keys when possible
VerbatimHighlightColor
is a new LaTeX ‘sphinxsetup’ key (refs: #4285)- Easier customizability of LaTeX macros involved in rendering of code-blocks
- Show traceback if conf.py raises an exception (refs: #4369)
- Add
smartquotes
to disable smart quotes throughconf.py
(refs: #3967) - Add
smartquotes_action
andsmartquotes_excludes
(refs: #4142, #4357)
Bugs fixed¶
- #4334: sphinx-apidoc: Don’t generate references to non-existing files in TOC
- #4206: latex: reST label between paragraphs loses paragraph break
- #4231: html: Apply fixFirefoxAnchorBug only under Firefox
- #4221: napoleon depends on autodoc, but users need to load it manually
- #2298: automodule fails to document a class attribute
- #4099: C++: properly link class reference to class from inside constructor
- #4267: PDF build broken by Unicode U+2116 NUMERO SIGN character
- #4249: PDF output: Pygments error highlighting increases line spacing in code blocks
- #1238: Support
:emphasize-lines:
in PDF output - #4279: Sphinx crashes with pickling error when run with multiple processes and remote image
- #1421: Respect the quiet flag in sphinx-quickstart
- #4281: Race conditions when creating output directory
- #4315: For PDF ‘howto’ documents,
latex_toplevel_sectioning='part'
generates\chapter
commands - #4214: Two todolist directives break sphinx-1.6.5
- Fix links to external option docs with intersphinx (refs: #3769)
- #4091: Private members not documented without :undoc-members:
Release 1.6.5 (released Oct 23, 2017)¶
Features added¶
- #4107: Make searchtools.js compatible with pre-Sphinx1.5 templates
- #4112: Don’t override the smart_quotes setting if it was already set
- #4125: Display reference texts of original and translated passages on i18n warning message
- #4147: Include the exception when logging PO/MO file read/write
Bugs fixed¶
- #4085: Failed PDF build from image in parsed-literal using
:align:
option - #4100: Remove debug print from autodoc extension
- #3987: Changing theme from alabaster causes HTML build to fail
- #4096: C++, don’t crash when using the wrong role type. Thanks to mitya57.
- #4070, #4111: crashes when the warning message contains format strings (again)
- #4108: Search word highlighting breaks SVG images
- #3692: Unable to build HTML if writing .buildinfo failed
- #4152: HTML writer crashes if a field list is placed on top of the document
- #4063: Sphinx crashes when labeling directive
.. todolist::
- #4134: [doc]
docutils.conf
is not documented explicitly - #4169: Chinese language doesn’t trigger Chinese search automatically
- #1020: ext.todo todolist not linking to the page in pdflatex
- #3965: New quickstart generates wrong SPHINXBUILD in Makefile
- #3739:
:module:
option is ignored at content of pyobjects - #4149: Documentation: Help choosing
latex_engine
- #4090: [doc]
latex_additional_files
with extra LaTeX macros should not use.tex
extension - Failed to convert reST parser error to warning (refs: #4132)
Release 1.6.4 (released Sep 26, 2017)¶
Features added¶
- #3926: Add
autodoc_warningiserror
to suppress the behavior of-W
option during importing target modules on autodoc
Bugs fixed¶
- #3924: docname lost after dynamically parsing RST in extension
- #3946: Typo in sphinx.sty (this was a bug with no effect in default context)
pep: and :rfc: does not supports default-role
directive (refs: #3960)- #3960: default_role = ‘guilabel’ not functioning
- Missing
texinputs_win/Makefile
to be used in latexpdf builder on windows. - #4026: nature: Fix macOS Safari scrollbar color
- #3877: Fix for C++ multiline signatures.
- #4006: Fix crash on parallel build
- #3969: private instance attributes causes AttributeError
- #4041: C++, remove extra name linking in function pointers.
- #4038: C, add missing documentation of
member
role. - #4044: An empty multicolumn cell causes extra row height in PDF output
- #4049: Fix typo in output of sphinx-build -h
- #4062: hashlib.sha1() must take bytes, not unicode on Python 3
- Avoid indent after index entries in latex (refs: #4066)
- #4070: crashes when the warning message contains format strings
- #4067: Return non-zero exit status when make subprocess fails
- #4055: graphviz: the :align: option does not work for SVG output
- #4055: graphviz: the :align: center option does not work for latex output
- #4051:
warn()
function for HTML theme outputs ‘None’ string
Release 1.6.3 (released Jul 02, 2017)¶
Features added¶
- latex: hint that code-block continues on next page (refs: #3764, #3792)
Bugs fixed¶
- #3821: Failed to import sphinx.util.compat with docutils-0.14rc1
- #3829: sphinx-quickstart template is incomplete regarding use of alabaster
- #3772: ‘str object’ has no attribute ‘filename’
- Emit wrong warnings if citation label includes hyphens (refs: #3565)
- #3858: Some warnings are not colored when using –color option
- #3775: Remove unwanted whitespace in default template
- #3835: sphinx.ext.imgmath fails to convert SVG images if project directory name contains spaces
- #3850: Fix color handling in make mode’s help command
- #3865: use of self.env.warn in sphinx extension fails
- #3824: production lists apply smart quotes transform since Sphinx 1.6.1
- latex: fix
\sphinxbfcode
swallows initial space of argument - #3878: Quotes in auto-documented class attributes should be straight quotes in PDF output
- #3881: LaTeX figure floated to next page sometimes leaves extra vertical whitespace
- #3885: duplicated footnotes raises IndexError
- #3873: Failure of deprecation warning mechanism of
sphinx.util.compat.Directive
- #3874: Bogus warnings for “citation not referenced” for cross-file citations
- #3860: Don’t download images when builders not supported images
- #3860: Remote image URIs without filename break builders not supported remote images
- #3833: command line messages are translated unintentionally with
language
setting. - #3840: make checking
epub_uid
strict - #3851, #3706: Fix about box drawing characters for PDF output
- #3900: autosummary could not find methods
- #3902: Emit error if
latex_documents
contains non-unicode string in py2
Release 1.6.2 (released May 28, 2017)¶
Incompatible changes¶
- #3789: Do not require typing module for python>=3.5
Bugs fixed¶
- #3754: HTML builder crashes if HTML theme appends own stylesheets
- #3756: epub: Entity ‘mdash’ not defined
- #3758: Sphinx crashed if logs are emitted in conf.py
- #3755: incorrectly warns about dedent with literalinclude
- #3742: RTD PDF builds of Sphinx own docs are
missing an index entry in the bookmarks and table of contents. This is
rtfd/readthedocs.org#2857 issue, a workaround
is obtained using some extra LaTeX code in Sphinx’s own
conf.py
- #3770: Build fails when a “code-block” has the option emphasize-lines and the number indicated is higher than the number of lines
- #3774: Incremental HTML building broken when using citations
- #3763: got epubcheck validations error if epub_cover is set
- #3779: ‘ImportError’ in sphinx.ext.autodoc due to broken ‘sys.meta_path’. Thanks to Tatiana Tereshchenko.
- #3796: env.resolve_references() crashes when non-document node given
- #3803: Sphinx crashes with invalid PO files
- #3791: PDF “continued on next page” for long tables isn’t internationalized
- #3788: smartquotes emits warnings for unsupported languages
- #3807: latex Makefile for
make latexpdf
is only for unixen - #3781: double hyphens in option directive are compiled as endashes
- #3817: latex builder raises AttributeError
Release 1.6.1 (released May 16, 2017)¶
Dependencies¶
1.6b1
- (updated) latex output is tested with Ubuntu trusty’s texlive packages (Feb. 2014) and earlier tex installations may not be fully compliant, particularly regarding Unicode engines xelatex and lualatex
- (added) latexmk is required for
make latexpdf
on GNU/Linux and Mac OS X (refs: #3082)
Incompatible changes¶
1.6b1
- #1061, #2336, #3235: Now generation of autosummary doesn’t contain imported members by default. Thanks to Luc Saffre.
- LaTeX
\includegraphics
command isn’t overloaded: only\sphinxincludegraphics
has the custom code to fit image to available width if oversized. - The subclasses of
sphinx.domains.Index
should overridegenerate()
method. The default implementation raises NotImplementedError - LaTeX positioned long tables horizontally centered, and short ones
flushed left (no text flow around table.) The position now defaults to center in
both cases, and it will obey Docutils 0.13
:align:
option (refs #3415, #3377) - option directive also allows all punctuations for the option name (refs: #3366)
- #3413: if
literalinclude
’s:start-after:
is used, make:lines:
relative (refs #3412) literalinclude
directive does not allow the combination of:diff:
option and other options (refs: #3416)- LuaLaTeX engine uses
fontspec
like XeLaTeX. It is advisedlatex_engine = 'lualatex'
be used only on up-to-date TeX installs (refs #3070, #3466) latex_keep_old_macro_names
default value has been changed fromTrue
toFalse
. This means that some LaTeX macros for styling are by default defined only with\sphinx..
prefixed names. (refs: #3429)- Footer “Continued on next page” of LaTeX longtable’s now not framed (refs: #3497)
- #3529: The arguments of
BuildEnvironment.__init__
is changed - #3082: Use latexmk for pdf (and dvi) targets (Unix-like platforms only)
- #3558: Emit warnings if footnotes and citations are not referenced. The
warnings can be suppressed by
suppress_warnings
. - latex made available (non documented) colour macros from a file distributed
with pdftex engine for Plain TeX. This is removed in order to provide better
support for multiple TeX engines. Only interface from
color
orxcolor
packages should be used by extensions of Sphinx latex writer. (refs #3550) Builder.env
is not filled at instantiation- #3594: LaTeX: single raw directive has been considered as block level element
- #3639: If
html_experimental_html5_writer
is available, epub builder use it by default. Sphinx.add_source_parser()
raises an error if duplicated
1.6b2
- #3345: Replace the custom smartypants code with Docutils’ smart_quotes. Thanks to Dmitry Shachnev, and to Günter Milde at Docutils.
1.6b3
- LaTeX package
eqparbox
is not used and not loaded by Sphinx anymore - LaTeX package
multirow
is not used and not loaded by Sphinx anymore - Add line numbers to citation data in std domain
1.6 final
- LaTeX package
threeparttable
is not used and not loaded by Sphinx anymore (refs #3686, #3532, #3377)
Features removed¶
- Configuration variables
- epub3_contributor
- epub3_description
- epub3_page_progression_direction
- html_translator_class
- html_use_modindex
- latex_font_size
- latex_paper_size
- latex_preamble
- latex_use_modindex
- latex_use_parts
termsep
node- defindex.html template
- LDML format support in
today
,today_fmt
andhtml_last_updated_fmt
:inline:
option for the directives of sphinx.ext.graphviz extension- sphinx.ext.pngmath extension
sphinx.util.compat.make_admonition()
Features added¶
1.6b1
- #3136: Add
:name:
option to the directives insphinx.ext.graphviz
- #2336: Add
imported_members
option tosphinx-autogen
command to document imported members. - C++, add
:tparam-line-spec:
option to templated declarations. When specified, each template parameter will be rendered on a separate line. - #3359: Allow sphinx.js in a user locale dir to override sphinx.js from Sphinx
- #3303: Add
:pyversion:
option to the doctest directive. - #3378: (latex) support for
:widths:
option of table directives (refs: #3379, #3381) - #3402: Allow to suppress “download file not readable” warnings using
suppress_warnings
. - #3377: latex: Add support for Docutils 0.13
:align:
option for tables (but does not implement text flow around table). - latex: footnotes from inside tables are hyperlinked (except from captions or headers) (refs: #3422)
- Emit warning if over dedent has detected on
literalinclude
directive (refs: #3416) - Use for LuaLaTeX same default settings as for XeLaTeX (i.e.
fontspec
andpolyglossia
). (refs: #3070, #3466) - Make
'extraclassoptions'
key oflatex_elements
public (refs #3480) - #3463: Add warning messages for required EPUB3 metadata. Add default value to
epub_description
to avoid warning like other settings. - #3476: setuptools: Support multiple builders
- latex: merged cells in LaTeX tables allow code-blocks, lists, blockquotes… as do normal cells (refs: #3435)
- HTML builder uses experimental HTML5 writer if
html_experimental_html5_writer
is True and docutils 0.13 or later is installed. - LaTeX macros to customize space before and after tables in PDF output (refs #3504)
- #3348: Show decorators in literalinclude and viewcode directives
- #3108: Show warning if :start-at: and other literalinclude options does not match to the text
- #3609: Allow to suppress “duplicate citation” warnings using
suppress_warnings
- #2803: Discovery of builders by entry point
- #1764, #1676: Allow setting ‘rel’ and ‘title’ attributes for stylesheets
- #3589: Support remote images on non-HTML builders
- #3589: Support images in Data URI on non-HTML builders
- #2961: improve
autodoc_mock_imports
. Now the config value only requires to declare the top-level modules that should be mocked. Thanks to Robin Jarry. - #3449: On py3, autodoc use inspect.signature for more accurate signature calculation. Thanks to Nathaniel J. Smith.
- #3641: Epub theme supports HTML structures that are generated by HTML5 writer.
- #3644 autodoc uses inspect instead of checking types. Thanks to Jeroen Demeyer.
- Add a new extension;
sphinx.ext.imgconverter
. It converts images in the document to appropriate format for builders - latex: Use templates to render tables (refs #3389, 2a37b0e)
1.6b2
LATEXMKOPTS
variable for the Makefile in$BUILDDIR/latex
to pass options tolatexmk
when executingmake latexpdf
(refs #3695, #3720)- Add a new event
env-check-consistency
to check consistency to extensions - Add
Domain.check_consistency()
to check consistency
Bugs fixed¶
1.6b1
literalinclude
directive expands tabs after dedent-ing (refs: #3416)- #1574: Paragraphs in table cell doesn’t work in Latex output
- #3288: Table with merged headers not wrapping text
- #3491: Inconsistent vertical space around table and longtable in PDF
- #3506: Depart functions for all admonitions in HTML writer now properly pass
node
todepart_admonition
. - #2693: Sphinx latex style file wrongly inhibits colours for section headings for latex+dvi(ps,pdf,pdfmx)
- C++, properly look up
any
references. - #3624: sphinx.ext.intersphinx couldn’t load inventories compressed with gzip
- #3551: PDF information dictionary is lacking author and title data
- #3351: intersphinx does not refers context like
py:module
,py:class
and so on. - Fail to load template file if the parent template is archived
1.6b2
- #3661: sphinx-build crashes on parallel build
- #3669: gettext builder fails with “ValueError: substring not found”
- #3660: Sphinx always depends on sphinxcontrib-websupport and its dependencies
- #3472: smart quotes getting wrong in latex (at least with list of strings via autoattribute) (refs: #3345, #3666)
1.6b3
- #3588: No compact (p tag) html output in the i18n document build even when
html_compact_lists
is True. - The
make latexpdf
from 1.6b1 (for GNU/Linux and Mac OS, usinglatexmk
) aborted earlier in case of LaTeX errors than was the case with 1.5 series, due to hard-coded usage of--halt-on-error
option. (refs #3695) - #3683: sphinx.websupport module is not provided by default
- #3683: Failed to build document if builder.css_file.insert() is called
- #3714: viewcode extension not taking
highlight_code='none'
in account - #3698: Moving :doc: to std domain broke backwards compatibility
- #3633: misdetect unreferenced citations
1.6 final
- LaTeX tables do not allow multiple paragraphs in a header cell
- LATEXOPTS is not passed over correctly to pdflatex since 1.6b3
- #3532: Figure or literal block captions in cells of short tables cause havoc in PDF output
- Fix: in PDF captions of tables are rendered differently whether table is of longtable class or not (refs #3686)
- #3725: Todo looks different from note in LaTeX output
- #3479: stub-columns have no effect in LaTeX output
- #3738: Nonsensical code in theming.py
- #3746: PDF builds fail with latexmk 4.48 or earlier due to undefined
options
-pdfxe
and-pdflua
Deprecated¶
1.6b1
sphinx.util.compat.Directive
class is now deprecated. Please use insteaddocutils.parsers.rst.Directive
sphinx.util.compat.docutils_version
is now deprecated#2367:
Sphinx.warn()
,Sphinx.info()
and other logging methods are now deprecated. Please usesphinx.util.logging
(Logging API) instead.#3318:
notice
is now deprecated as LaTeX environment name and will be removed at Sphinx 1.7. Extension authors please usesphinxadmonition
instead (as Sphinx does since 1.5.)Sphinx.status_iterator()
andSphinx.old_status_iterator()
is now deprecated. Please usesphinx.util:status_iterator()
instead.Sphinx._directive_helper()
is deprecated. Please usesphinx.util.docutils.directive_helper()
instead.BuildEnvironment.set_warnfunc()
is now deprecatedFollowing methods of
BuildEnvironment
is now deprecated.BuildEnvironment.note_toctree()
BuildEnvironment.get_toc_for()
BuildEnvironment.get_toctree_for()
BuildEnvironment.create_index()
Please use
sphinx.environment.adapters
modules instead.latex package
footnote
is not loaded anymore by its bundled replacementfootnotehyper-sphinx
. The redefined macros keep the same names as in the original package.#3429: deprecate config setting
latex_keep_old_macro_names
. It will be removed at 1.7, and already its default value has changed fromTrue
toFalse
.#3221: epub2 builder is deprecated
#3254:
sphinx.websupport
is now separated into independent package;sphinxcontrib-websupport
.sphinx.websupport
will be removed in Sphinx-2.0.#3628:
sphinx_themes
entry_point is deprecated. Please usesphinx.html_themes
instead.
1.6b2
- #3662:
builder.css_files
is deprecated. Please useadd_stylesheet()
API instead.
1.6 final
- LaTeX
\sphinxstylethead
is deprecated at 1.6 and will be removed at 1.7. Please move customization into new macro\sphinxstyletheadfamily
.
Release 1.6 (unreleased)¶
- not released (because of package script error)
Release 1.5.6 (released May 15, 2017)¶
Bugs fixed¶
- #3614: Sphinx crashes with requests-2.5.0
- #3618: autodoc crashes with tupled arguments
- #3664: No space after the bullet in items of a latex list produced by Sphinx
- #3657: EPUB builder crashes if document startswith genindex exists
- #3588: No compact (p tag) html output in the i18n document build even when
html_compact_lists
is True. - #3685: AttributeError when using 3rd party domains
- #3702: LaTeX writer styles figure legends with a hard-coded
\small
- #3708: LaTeX writer allows irc scheme
- #3717: Stop enforcing that favicon’s must be .ico
- #3731, #3732: Protect isenumclass predicate against non-class arguments
- #3320: Warning about reference target not being found for container types
- Misspelled ARCHIVEPREFIX in Makefile for latex build repertory
Release 1.5.5 (released Apr 03, 2017)¶
Bugs fixed¶
- #3597: python domain raises UnboundLocalError if invalid name given
- #3599: Move to new Mathjax CDN
Release 1.5.4 (released Apr 02, 2017)¶
Features added¶
- #3470: Make genindex support all kinds of letters, not only Latin ones
Bugs fixed¶
- #3445: setting
'inputenc'
key to\\usepackage[utf8x]{inputenc}
leads to failed PDF build - EPUB file has duplicated
nav.xhtml
link incontent.opf
except first time build - #3488: objects.inv has broken when
release
orversion
contain return code - #2073, #3443, #3490: gettext builder that writes pot files unless the content are same without creation date. Thanks to Yoshiki Shibukawa.
- #3487: intersphinx: failed to refer options
- #3496: latex longtable’s last column may be much wider than its contents
- #3507: wrong quotes in latex output for productionlist directive
- #3533: Moving from Sphinx 1.3.1 to 1.5.3 breaks LaTeX compilation of links rendered as code
- #2665, #2607: Link names in C++ docfields, and make it possible for other domains.
- #3542: C++, fix parsing error of non-type template argument with template.
- #3065, #3520: python domain fails to recognize nested class
- #3575: Problems with pdflatex in a Turkish document built with sphinx has reappeared (refs #2997, #2397)
- #3577: Fix intersphinx debug tool
- A LaTeX command such as
\\large
inserted in the title items oflatex_documents
causes failed PDF build (refs #3551, #3567)
Release 1.5.3 (released Feb 26, 2017)¶
Features added¶
- Support requests-2.0.0 (experimental) (refs: #3367)
- (latex) PDF page margin dimensions may be customized (refs: #3387)
literalinclude
directive allows combination of:pyobject:
and:lines:
options (refs: #3416)- #3400: make-mode doesn’t use subprocess on building docs
Bugs fixed¶
- #3370: the caption of code-block is not picked up for translation
- LaTeX:
release
is not escaped (refs: #3362) - #3364: sphinx-quickstart prompts overflow on Console with 80 chars width
- since 1.5, PDF’s TOC and bookmarks lack an entry for general Index (refs: #3383)
- #3392:
'releasename'
inlatex_elements
is not working - #3356: Page layout for Japanese
'manual'
docclass has a shorter text area - #3394: When
'pointsize'
is not10pt
, Japanese'manual'
document gets wrong PDF page dimensions - #3399: quickstart: conf.py was not overwritten by template
- #3366: option directive does not allow punctuations
- #3410: return code in
release
breaks html search - #3427: autodoc: memory addresses are not stripped on Windows
- #3428: xetex build tests fail due to fontspec v2.6 defining
\strong
- #3349: Result of
IndexBuilder.load()
is broken - #3450:   is appeared in EPUB docs
- #3418: Search button is misaligned in nature and pyramid theme
- #3421: Could not translate a caption of tables
- #3552: linkcheck raises UnboundLocalError
Release 1.5.2 (released Jan 22, 2017)¶
Incompatible changes¶
- Dependency requirement updates: requests 2.4.0 or above (refs: #3268, #3310)
Features added¶
- #3241: emit latex warning if buggy titlesec (ref #3210)
- #3194: Refer the $MAKE environment variable to determine
make
command - Emit warning for nested numbered toctrees (refs: #3142)
- #978:
intersphinx_mapping
also allows a list as a parameter - #3340: (LaTeX) long lines in parsed-literal are wrapped like in
code-block
, inline math and footnotes are fully functional.
Bugs fixed¶
- #3246: xapian search adapter crashes
- #3253: In Py2 environment, building another locale with a non-captioned
toctree produces
None
captions - #185: References to section title including raw node has broken
- #3255: In Py3.4 environment, autodoc doesn’t support documentation for attributes of Enum class correctly.
- #3261:
latex_use_parts
makes sphinx crash - The warning type
misc.highlighting_failure
does not work - #3294:
add_latex_package()
make crashes non-LaTeX builders - The caption of table are rendered as invalid HTML (refs: #3287)
- #3268: Sphinx crashes with requests package from Debian jessie
- #3284: Sphinx crashes on parallel build with an extension which raises unserializable exception
- #3315: Bibliography crashes on latex build with docclass ‘memoir’
- #3328: Could not refer rubric implicitly
- #3329: emit warnings if po file is invalid and can’t read it. Also writing mo too
- #3337: Ugly rendering of definition list term’s classifier
- #3335: gettext does not extract field_name of a field in a field_list
- #2952: C++, fix refs to operator() functions.
- Fix Unicode super- and subscript digits in
code-block
and parsed-literal LaTeX output (ref #3342) - LaTeX writer: leave
"
character inside parsed-literal as is (ref #3341) - #3234: intersphinx failed for encoded inventories
- #3158: too much space after captions in PDF output
- #3317: An URL in parsed-literal contents gets wrongly rendered in PDF if with hyphen
- LaTeX crash if the filename of an image inserted in parsed-literal via a substitution contains an hyphen (ref #3340)
- LaTeX rendering of inserted footnotes in parsed-literal is wrong (ref #3340)
- Inline math in parsed-literal is not rendered well by LaTeX (ref #3340)
- #3308: Parsed-literals don’t wrap very long lines with pdf builder (ref #3340)
- #3295: Could not import extension sphinx.builders.linkcheck
- #3285: autosummary: asterisks are escaped twice
- LaTeX, pass dvipdfm option to geometry package for Japanese documents (ref #3363)
- Fix parselinenos() could not parse left half open range (cf. “-4”)
Release 1.5.1 (released Dec 13, 2016)¶
Features added¶
- #3214: Allow to suppress “unknown mimetype” warnings from epub builder using
suppress_warnings
.
Bugs fixed¶
- #3195: Can not build in parallel
- #3198: AttributeError is raised when toctree has ‘self’
- #3211: Remove untranslated sphinx locale catalogs (it was covered by untranslated it_IT)
- #3212: HTML Builders crashes with docutils-0.13
- #3207: more latex problems with references inside parsed-literal directive
(
\DUrole
) - #3205: sphinx.util.requests crashes with old pyOpenSSL (< 0.14)
- #3220: KeyError when having a duplicate citation
- #3200: LaTeX: xref inside desc_name not allowed
- #3228:
build_sphinx
command crashes when missing dependency - #2469: Ignore updates of catalog files for gettext builder. Thanks to Hiroshi Ohkubo.
- #3183: Randomized jump box order in generated index page.
Release 1.5 (released Dec 5, 2016)¶
Incompatible changes¶
1.5a1
- latex, package fancybox is not longer a dependency of sphinx.sty
- Use
'locales'
as a default value oflocale_dirs
- latex, package ifthen is not any longer a dependency of sphinx.sty
- latex, style file does not modify fancyvrb’s Verbatim (also available as OriginalVerbatim) but uses sphinxVerbatim for name of custom wrapper.
- latex, package newfloat is not used (and not included) anymore (ref #2660; it was used since 1.3.4 and shipped with Sphinx since 1.4).
- latex, literal blocks in tables do not use OriginalVerbatim but sphinxVerbatimintable which handles captions and wraps lines (ref #2704).
- latex, replace
pt
by TeX equivalentbp
if found inwidth
orheight
attribute of an image. - latex, if
width
orheight
attribute of an image is given with no unit, usepx
rather than ignore it. - latex: Separate stylesheets of pygments to independent .sty file
- #2454: The filename of sourcelink is now changed. The value of
html_sourcelink_suffix
will be appended to the original filename (likeindex.rst.txt
). sphinx.util.copy_static_entry()
is now deprecated. Usesphinx.util.fileutil.copy_asset()
instead.sphinx.util.osutil.filecopy()
skips copying if the file has not been changed (ref: #2510, #2753)- Internet Explorer 6-8, Opera 12.1x or Safari 5.1+ support is dropped because jQuery version is updated from 1.11.0 to 3.1.0 (ref: #2634, #2773)
- QtHelpBuilder doens’t generate search page (ref: #2352)
- QtHelpBuilder uses
nonav
theme instead of default one to improve readability. - latex: To provide good default settings to Japanese documents, Sphinx uses
jreport
andjsbook
as docclass iflanguage
isja
. sphinx-quickstart
now allows a project version is empty- Fix :download: role on epub/qthelp builder. They ignore the role because they don’t support it.
sphinx.ext.viewcode
doesn’t work on epub building by default.viewcode_enable_epub
optionsphinx.ext.viewcode
disabled on singlehtml builder.- Use make-mode of
sphinx-quickstart
by default. To disable this, use-M
option - Fix
genindex.html
, Sphinx’s document template, link address to itself to satisfy xhtml standard. - Use epub3 builder by default. And the old epub builder is renamed to epub2.
- Fix
epub
andepub3
builders that contained links togenindex
even ifepub_use_index = False
. html_translator_class
is now deprecated. UseSphinx.set_translator()
API instead.- Drop python 2.6 and 3.3 support
- Drop epub3 builder’s
epub3_page_progression_direction
option (useepub3_writing_mode
). - #2877: Rename
latex_elements['footer']
tolatex_elements['atendofbody']
1.5a2
- #2983: Rename
epub3_description
andepub3_contributor
toepub_description
andepub_contributor
. - Remove themes/basic/defindex.html; no longer used
- Sphinx does not ship anymore (but still uses) LaTeX style file
fncychap
- #2435: Slim down quickstarted conf.py
- The
sphinx.sty
latex package does not load itself “hyperref”, as this is done later in the preamble of the latex output via'hyperref'
key. - Sphinx does not ship anymore a custom modified LaTeX style file
tabulary
. The non-modified package is used. - #3057: By default, footnote marks in latex PDF output are not preceded by a
space anymore,
\sphinxBeforeFootnote
allows user customization if needed. - LaTeX target requires that option
hyperfootnotes
of packagehyperref
be left unchanged to its default (i.e.true
) (refs: #3022)
1.5 final
- #2986:
themes/basic/defindex.html
is now deprecated - Emit warnings that will be deprecated in Sphinx 1.6 by default. Users can change the behavior by setting the environment variable PYTHONWARNINGS. Please refer Deprecation Warnings.
- #2454: new JavaScript variable
SOURCELINK_SUFFIX
is added
Deprecated¶
These features are removed in Sphinx-1.6:
- LDML format support in i18n feature
sphinx.addnodes.termsep
- Some functions and classes in
sphinx.util.pycompat
:zip_longest
,product
,all
,any
,next
,open
,class_types
,base_exception
,relpath
,StringIO
,BytesIO
. Please use the standard library version instead;
If any deprecation warning like RemovedInSphinxXXXWarning
are displayed,
please refer Deprecation Warnings.
Features added¶
1.5a1
- #2951: Add
--implicit-namespaces
PEP-0420 support to apidoc. - Add
:caption:
option for sphinx.ext.inheritance_diagram. - #2471: Add config variable for default doctest flags.
- Convert linkcheck builder to requests for better encoding handling
- #2463, #2516: Add keywords of “meta” directive to search index
:maxdepth:
option of toctree affectssecnumdepth
(ref: #2547)- #2575: Now
sphinx.ext.graphviz
allows:align:
option - Show warnings if unknown key is specified to
latex_elements
- Show warnings if no domains match with
primary_domain
(ref: #2001) - C++, show warnings when the kind of role is misleading for the kind
of target it refers to (e.g., using the
class
role for a function). - latex, writer abstracts more of text styling into customizable macros, e.g.
the
visit_emphasis
will output\sphinxstyleemphasis
rather than\emph
(which may be in use elsewhere or in an added LaTeX package). See list at end ofsphinx.sty
(ref: #2686) - latex, public names for environments and parameters used by note, warning,
and other admonition types, allowing full customizability from the
'preamble'
key or an input file (ref: feature request #2674, #2685) - latex, better computes column widths of some tables (as a result, there will be slight changes as tables now correctly fill the line width; ref: #2708)
- latex, sphinxVerbatim environment is more easily customizable (ref: #2704).
In addition to already existing VerbatimColor and VerbatimBorderColor:
- two lengths
\sphinxverbatimsep
and\sphinxverbatimborder
, - booleans
\ifsphinxverbatimwithframe
and\ifsphinxverbatimwrapslines
.
- two lengths
- latex, captions for literal blocks inside tables are handled, and long code lines wrapped to fit table cell (ref: #2704)
- #2597: Show warning messages as darkred
- latex, allow image dimensions using px unit (default is 96px=1in)
- Show warnings if invalid dimension units found
- #2650: Add
--pdb
option to setup.py command - latex, make the use of
\small
for code listings customizable (ref #2721) - #2663: Add
--warning-is-error
option to setup.py command - Show warnings if deprecated latex options are used
- Add sphinx.config.ENUM to check the config values is in candidates
- math: Add hyperlink marker to each equations in HTML output
- Add new theme
nonav
that doesn’t include any navigation links. This is for any help generator like qthelp. - #2680:
sphinx.ext.todo
now emits warnings iftodo_emit_warnings
enabled. Also, it emits an additional event namedtodo-defined
to handle the TODO entries in 3rd party extensions. - Python domain signature parser now uses the xref mixin for ‘exceptions’, allowing exception classes to be autolinked.
- #2513: Add
latex_engine
to switch the LaTeX engine by conf.py - #2682: C++, basic support for attributes (C++11 style and GNU style). The new configuration variables ‘cpp_id_attributes’ and ‘cpp_paren_attributes’ can be used to introduce custom attributes.
- #1958: C++, add configuration variable ‘cpp_index_common_prefix’ for removing prefixes from the index text of C++ objects.
- C++, added concept directive. Thanks to mickk-on-cpp.
- C++, added support for template introduction syntax. Thanks to mickk-on-cpp.
- #2725: latex builder: allow to use user-defined template file (experimental)
- apidoc now avoids invalidating cached files by not writing to files whose content doesn’t change. This can lead to significant performance wins if apidoc is run frequently.
- #2851:
sphinx.ext.math
emits missing-reference event if equation not found - #1210:
eqref
role now supports cross reference - #2892: Added
-a
(--append-syspath
) option tosphinx-apidoc
- #1604: epub3 builder: Obey font-related CSS when viewing in iBooks.
- #646:
option
directive support ‘.’ character as a part of options - Add document about kindlegen and fix document structure for it.
- #2474: Add
intersphinx_timeout
option tosphinx.ext.intersphinx
- #2926: EPUB3 builder supports vertical mode (
epub3_writing_mode
option) - #2695:
build_sphinx
subcommand for setuptools handles exceptions as same assphinx-build
does - #326:
numref
role can also refer sections - #2916:
numref
role can also refer caption as an its linktext
1.5a2
- #3008:
linkcheck
builder ignores self-signed certificate URL - #3020: new
'geometry'
key tolatex_elements
whose default uses LaTeX style filegeometry.sty
to set page layout - #2843: Add :start-at: and :end-at: options to literalinclude directive
- #2527: Add
:reversed:
option to toctree directive - Add
-t
and-d
option tosphinx-quickstart
to support templating generated sphinx project. - #3028: Add
{path}
and{basename}
to the format offigure_language_filename
- new
'hyperref'
key in thelatex_elements
dictionary (ref #3030) - #3022: Allow code-blocks in footnotes for LaTeX PDF output
1.5b1
- #2513: A better default settings for XeLaTeX
- #3096:
'maxlistdepth'
key to work around LaTeX list limitations - #3060: autodoc supports documentation for attributes of Enum class. Now autodoc render just the value of Enum attributes instead of Enum attribute representation.
- Add
--extensions
tosphinx-quickstart
to support enable arbitrary extensions from command line (ref: #2904) - #3104, #3122:
'sphinxsetup'
for key=value styling of Sphinx LaTeX - #3071: Autodoc: Allow mocked module decorators to pass-through functions unchanged
- #2495: linkcheck: Allow skipping anchor checking using
linkcheck_anchors_ignore
- #3083: let Unicode no-break space act like LaTeX
~
(fixed #3019) - #3116: allow word wrap in PDF output for inline literals (ref #3110)
- #930: sphinx-apidoc allow wildcards for excluding paths. Thanks to Nick Coghlan.
- #3121: add
inlineliteralwraps
option to control if inline literal word-wraps in latex
1.5 final
- #3095: Add
tls_verify
andtls_cacerts
to support self-signed HTTPS servers in linkcheck and intersphinx - #2215: make.bat generated by sphinx-quickstart can be called from another dir. Thanks to Timotheus Kampik.
- #3185: Add new warning type
misc.highlighting_failure
Bugs fixed¶
1.5a1
- #2707: (latex) the column width is badly computed for tabular
- #2799: Sphinx installs roles and directives automatically on importing sphinx module. Now Sphinx installs them on running application.
sphinx.ext.autodoc
crashes if target code imports * from mock modules byautodoc_mock_imports
.- #1953:
Sphinx.add_node
does not add handlers the translator installed byhtml_translator_class
- #1797: text builder inserts blank line on top
- #2894: quickstart main() doesn’t use argv argument
- #2874: gettext builder could not extract all text under the
only
directives - #2485: autosummary crashes with multiple source_suffix values
- #1734: Could not translate the caption of toctree directive
- Could not translate the content of meta directive (ref: #1734)
- #2550: external links are opened in help viewer
- #2687: Running Sphinx multiple times produces ‘already registered’ warnings
1.5a2
- #2810: Problems with pdflatex in an Italian document
- Use
latex_elements.papersize
to specify papersize of LaTeX in Makefile - #2988: linkcheck: retry with GET request if denied HEAD request
- #2990: linkcheck raises “Can’t convert ‘bytes’ object to str implicitly” error if linkcheck_anchors enabled
- #3004: Invalid link types “top” and “up” are used
- #3009: Bad rendering of parsed-literals in LaTeX since Sphinx 1.4.4
- #3000:
option
directive generates invalid HTML anchors - #2984: Invalid HTML has been generated if
html_split_index
enabled - #2986: themes/basic/defindex.html should be changed for html5 friendly
- #2987: Invalid HTML has been generated if multiple IDs are assigned to a list
- #2891: HTML search does not provide all the results
- #1986: Title in PDF Output
- #147: Problem with latex chapter style
- #3018: LaTeX problem with page layout dimensions and chapter titles
- Fix an issue with
\pysigline
in LaTeX style file (ref #3023) - #3038:
sphinx.ext.math*
raises TypeError if labels are duplicated - #3031: incompatibility with LaTeX package
tocloft
- #3003: literal blocks in footnotes are not supported by Latex
- #3047: spacing before footnote in pdf output is not coherent and allows breaks
- #3045: HTML search index creator should ignore “raw” content if now html
- #3039: English stemmer returns wrong word if the word is capitalized
- Fix make-mode Makefile template (ref #3056, #2936)
1.5b1
- #2432: Fix unwanted * between varargs and keyword only args. Thanks to Alex Grönholm.
- #3062: Failed to build PDF using 1.5a2 (undefined
\hypersetup
for Japanese documents since PR#3030) - Better rendering of multiline signatures in html.
- #777: LaTeX output “too deeply nested” (ref #3096)
- Let LaTeX image inclusion obey
scale
before textwidth fit (ref #2865, #3059) - #3019: LaTeX fails on description of C function with arguments (ref #3083)
- fix latex inline literals where
< > -
gobbled a space
1.5 final
- #3069: Even if
'babel'
key is set to empty string, LaTeX output contains one\addto\captions...
- #3123: user
'babel'
key setting is not obeyed anymore - #3155: Fix JavaScript for
html_sourcelink_suffix
fails with IE and Opera - #3085: keep current directory after breaking build documentation. Thanks to Timotheus Kampik.
- #3181: pLaTeX crashes with a section contains endash
- #3180: latex: add stretch/shrink between successive singleline or multipleline cpp signatures (ref #3072)
- #3128: globing images does not support .svgz file
- #3015: fix a broken test on Windows.
- #1843: Fix documentation of descriptor classes that have a custom metaclass. Thanks to Erik Bray.
- #3190: util.split_docinfo fails to parse multi-line field bodies
- #3024, #3037: In Python3, application.Sphinx._log crushed when the log message cannot be encoded into console encoding.
Testing¶
- To simplify, sphinx uses external mock package even if unittest.mock exists.
Release 1.4.9 (released Nov 23, 2016)¶
Bugs fixed¶
- #2936: Fix doc/Makefile that can’t build man because doc/man exists
- #3058: Using the same ‘caption’ attribute in multiple ‘toctree’ directives results in warning / error
- #3068: Allow the ‘=’ character in the -D option of sphinx-build.py
- #3074:
add_source_parser()
crashes in debug mode - #3135:
sphinx.ext.autodoc
crashes with plain Callable - #3150: Fix query word splitter in JavaScript. It behaves as same as Python’s regular expression.
- #3093: gettext build broken on substituted images.
- #3093: gettext build broken on image node under
note
directive. - imgmath: crashes on showing error messages if image generation failed
- #3117: LaTeX writer crashes if admonition is placed before first section title
- #3164: Change search order of
sphinx.ext.inheritance_diagram
Release 1.4.8 (released Oct 1, 2016)¶
Bugs fixed¶
- #2996: The wheel package of Sphinx got crash with ImportError
Release 1.4.7 (released Oct 1, 2016)¶
Bugs fixed¶
- #2890: Quickstart should return an error consistently on all error conditions
- #2870: flatten genindex columns’ heights.
- #2856: Search on generated HTML site doesnt find some symbols
- #2882: Fall back to a GET request on 403 status in linkcheck
- #2902: jsdump.loads fails to load search index if keywords starts with underscore
- #2900: Fix epub content.opf: add auto generated orphan files to spine.
- #2899: Fix
hasdoc()
function in Jinja2 template. It can detectgenindex
,search
collectly. - #2901: Fix epub result: skip creating links from image tags to original image files.
- #2917: inline code is hyphenated on HTML
- #1462: autosummary warns for namedtuple with attribute with trailing underscore
- Could not reference equations if
:nowrap:
option specified - #2873: code-block overflow in latex (due to commas)
- #1060, #2056: sphinx.ext.intersphinx: broken links are generated if relative
paths are used in
intersphinx_mapping
- #2931: code-block directive with same :caption: causes warning of duplicate
target. Now
code-block
andliteralinclude
does not define hyperlink target using its caption automatially. - #2962: latex: missing label of longtable
- #2968: autodoc: show-inheritance option breaks docstrings
Release 1.4.6 (released Aug 20, 2016)¶
Incompatible changes¶
- #2867: linkcheck builder crashes with six-1.4. Now Sphinx depends on six-1.5 or later
Bugs fixed¶
- applehelp: Sphinx crashes if
hiutil
orcodesign
commands not found - Fix
make clean
abort issue when build dir contains regular files likeDS_Store
. - Reduce epubcheck warnings/errors:
- Fix DOCTYPE to html5
- Change extension from .html to .xhtml.
- Disable search page on epub results
- #2778: Fix autodoc crashes if obj.__dict__ is a property method and raises exception
- Fix duplicated toc in epub3 output.
- #2775: Fix failing linkcheck with servers not supporting identidy encoding
- #2833: Fix formatting instance annotations in ext.autodoc.
- #1911:
-D
option ofsphinx-build
does not override theextensions
variable - #2789:
sphinx.ext.intersphinx
generates wrong hyperlinks if the inventory is given - parsing errors for caption of code-blocks are displayed in document (ref: #2845)
- #2846:
singlehtml
builder does not include figure numbers - #2816: Fix data from builds cluttering the
Domain.initial_data
class attributes
Release 1.4.5 (released Jul 13, 2016)¶
Incompatible changes¶
- latex, inclusion of non-inline images from image directive resulted in non-coherent whitespaces depending on original image width; new behaviour by necessity differs from earlier one in some cases. (ref: #2672)
- latex, use of
\includegraphics
to refer to Sphinx custom variant is deprecated; in future it will revert to original LaTeX macro, custom one already has alternative name\sphinxincludegraphics
.
Features added¶
- new config option
latex_keep_old_macro_names
, defaults to True. If False, lets macros (for text styling) be defined only with\sphinx
-prefixed names. - latex writer allows user customization of “shadowed” boxes (topics), via three length variables.
- woff-format web font files now supported by the epub builder.
Bugs fixed¶
- jsdump fix for python 3: fixes the HTML search on python > 3
- #2676: (latex) Error with verbatim text in captions since Sphinx 1.4.4
- #2629: memoir class crashes LaTeX. Fixed
by latex_keep_old_macro_names=False
(ref 2675) - #2684:
sphinx.ext.intersphinx
crashes with six-1.4.1 - #2679:
float
package needed for'figure_align': 'H'
latex option - #2671: image directive may lead to inconsistent spacing in pdf
- #2705:
toctree
generates empty bullet_list if:titlesonly:
specified - #2479:
sphinx.ext.viewcode
uses python2 highlighter by default - #2700: HtmlHelp builder has hard coded index.html
- latex, since 1.4.4 inline literal text is followed by spurious space
- #2722: C++, fix id generation for var/member declarations to include namespaces.
- latex, images (from image directive) in lists or quoted blocks did not obey indentation (fixed together with #2671)
- #2733: since Sphinx-1.4.4
make latexpdf
generates lots of hyperref warnings - #2731:
sphinx.ext.autodoc
does not access propertymethods which raises any exceptions - #2666: C++, properly look up nested names involving constructors.
- #2579: Could not refer a label including both spaces and colons via
sphinx.ext.intersphinx
- #2718: Sphinx crashes if the document file is not readable
- #2699: hyperlinks in help HTMLs are broken if
html_file_suffix
is set - #2723: extra spaces in latex pdf output from multirow cell
- #2735: latexpdf
Underfull \hbox (badness 10000)
warnings from title page - #2667: latex crashes if resized images appeared in section title
- #2763: (html) Provide default value for required
alt
attribute for image tags of SVG source, required to validate and now consistent w/ other formats.
Release 1.4.4 (released Jun 12, 2016)¶
Bugs fixed¶
- #2630: Latex sphinx.sty Notice Enviroment formatting problem
- #2632: Warning directives fail in quote environment latex build
- #2633: Sphinx crashes with old styled indices
- Fix a
\begin{\minipage}
typo in sphinx.sty from 1.4.2 (ref: 68becb1) - #2622: Latex produces empty pages after title and table of contents
- #2640: 1.4.2 LaTeX crashes if code-block inside warning directive
- Let LaTeX use straight quotes also in inline code (ref #2627)
- #2351: latex crashes if enumerated lists are placed on footnotes
- #2646: latex crashes if math contains twice empty lines
- #2480:
sphinx.ext.autodoc
: memory addresses were shown - latex: allow code-blocks appearing inside lists and quotes at maximal nesting depth (ref #777, #2624, #2651)
- #2635: Latex code directives produce inconsistent frames based on viewing resolution
- #2639: Sphinx now bundles iftex.sty
- Failed to build PDF with framed.sty 0.95
- Sphinx now bundles needspace.sty
Release 1.4.3 (released Jun 5, 2016)¶
Bugs fixed¶
- #2530: got “Counter too large” error on building PDF if large numbered footnotes existed in admonitions
width
option of figure directive does not work ifalign
option specified at same time (ref: #2595)- #2590: The
inputenc
package breaks compiling under lualatex and xelatex - #2540: date on latex front page use different font
- Suppress “document isn’t included in any toctree” warning if the document is included (ref: #2603)
- #2614: Some tables in PDF output will end up shifted if user sets non zero parindent in preamble
- #2602: URL redirection breaks the hyperlinks generated by
sphinx.ext.intersphinx
- #2613: Show warnings if merged extensions are loaded
- #2619: make sure amstext LaTeX package always loaded (ref: d657225, 488ee52, 9d82cad and #2615)
- #2593: latex crashes if any figures in the table
Release 1.4.2 (released May 29, 2016)¶
Features added¶
- Now
suppress_warnings
accepts following configurations (ref: #2451, #2466):app.add_node
app.add_directive
app.add_role
app.add_generic_role
app.add_source_parser
image.data_uri
image.nonlocal_uri
- #2453: LaTeX writer allows page breaks in topic contents; and their horizontal extent now fits in the line width (with shadow in margin). Also warning-type admonitions allow page breaks and their vertical spacing has been made more coherent with the one for hint-type notices (ref #2446).
- #2459: the framing of literal code-blocks in LaTeX output (and not only the code lines themselves) obey the indentation in lists or quoted blocks.
- #2343: the long source lines in code-blocks are wrapped (without modifying the line numbering) in LaTeX output (ref #1534, #2304).
Bugs fixed¶
- #2370: the equations are slightly misaligned in LaTeX writer
- #1817, #2077: suppress pep8 warnings on conf.py generated by sphinx-quickstart
- #2407: building docs crash if document includes large data image URIs
- #2436: Sphinx does not check version by
needs_sphinx
if loading extensions failed - #2397: Setup shorthandoff for turkish documents
- #2447: VerbatimBorderColor wrongly used also for captions of PDF
- #2456: C++, fix crash related to document merging (e.g., singlehtml and Latex builders).
- #2446: latex(pdf) sets local tables of contents (or more generally topic nodes) in unbreakable boxes, causes overflow at bottom
- #2476: Omit MathJax markers if :nowrap: is given
- #2465: latex builder fails in case no caption option is provided to toctree directive
- Sphinx crashes if self referenced toctree found
- #2481: spelling mistake for mecab search splitter. Thanks to Naoki Sato.
- #2309: Fix could not refer “indirect hyperlink targets” by ref-role
- intersphinx fails if mapping URL contains any port
- #2088: intersphinx crashes if the mapping URL requires basic auth
- #2304: auto line breaks in latexpdf codeblocks
- #1534: Word wrap long lines in Latex verbatim blocks
- #2460: too much white space on top of captioned literal blocks in PDF output
- Show error reason when multiple math extensions are loaded (ref: #2499)
- #2483: any figure number was not assigned if figure title contains only non text objects
- #2501: Unicode subscript numbers are normalized in LaTeX
- #2492: Figure directive with :figwidth: generates incorrect Latex-code
- The caption of figure is always put on center even if
:align:
was specified - #2526: LaTeX writer crashes if the section having only images
- #2522: Sphinx touches mo files under installed directory that caused permission error.
- #2536: C++, fix crash when an immediately nested scope has the same name as the current scope.
- #2555: Fix crash on any-references with unicode.
- #2517: wrong bookmark encoding in PDF if using LuaLaTeX
- #2521: generated Makefile causes BSD make crashed if sphinx-build not found
- #2470:
typing
backport package causes autodoc errors with python 2.7 sphinx.ext.intersphinx
crashes if non-string value is used for key ofintersphinx_mapping
- #2518:
intersphinx_mapping
disallows non alphanumeric keys - #2558: unpack error on devhelp builder
- #2561: Info builder crashes when a footnote contains a link
- #2565: The descriptions of objects generated by
sphinx.ext.autosummary
overflow lines at LaTeX writer - Extend pdflatex config in sphinx.sty to subparagraphs (ref: #2551)
- #2445:
rst_prolog
andrst_epilog
affect to non reST sources - #2576:
sphinx.ext.imgmath
crashes if subprocess raises error - #2577:
sphinx.ext.imgmath
: Invalid argument are passed to dvisvgm - #2556: Xapian search does not work with Python 3
- #2581: The search doesn’t work if language=”es” (spanish)
- #2382: Adjust spacing after abbreviations on figure numbers in LaTeX writer
- #2383: The generated footnote by
latex_show_urls
overflows lines - #2497, #2552: The label of search button does not fit for the button itself
Release 1.4.1 (released Apr 12, 2016)¶
Incompatible changes¶
- The default format of
today_fmt
andhtml_last_updated_fmt
is back to strftime format again. Locale Date Markup Language is also supported for backward compatibility until Sphinx-1.5.
Translations¶
- Added Welsh translation, thanks to Geraint Palmer.
- Added Greek translation, thanks to Stelios Vitalis.
- Added Esperanto translation, thanks to Dinu Gherman.
- Added Hindi translation, thanks to Purnank H. Ghumalia.
- Added Romanian translation, thanks to Razvan Stefanescu.
Bugs fixed¶
- C++, added support for
extern
andthread_local
. - C++, type declarations are now using the prefixes
typedef
,using
, andtype
, depending on the style of declaration. - #2413: C++, fix crash on duplicate declarations
- #2394: Sphinx crashes when html_last_updated_fmt is invalid
- #2408: dummy builder not available in Makefile and make.bat
- #2412: hyperlink targets are broken in LaTeX builder
- figure directive crashes if non paragraph item is given as caption
- #2418: time formats no longer allowed in today_fmt
- #2395: Sphinx crashes if unicode character in image filename
- #2396: “too many values to unpack” in genindex-single
- #2405: numref link in PDF jumps to the wrong location
- #2414: missing number in PDF hyperlinks to code listings
- #2440: wrong import for gmtime. Thanks to Uwe L. Korn.
Release 1.4 (released Mar 28, 2016)¶
Incompatible changes¶
- Drop
PorterStemmer
package support. UsePyStemmer
instead ofPorterStemmer
to accelerate stemming. - sphinx_rtd_theme has become optional. Please install it manually. Refs #2087, #2086, #1845 and #2097. Thanks to Victor Zverovich.
- #2231: Use DUrole instead of DUspan for custom roles in LaTeX writer. It enables to take title of roles as an argument of custom macros.
- #2022: ‘Thumbs.db’ and ‘.DS_Store’ are added to
exclude_patterns
default values in conf.py that will be provided on sphinx-quickstart. - #2027, #2208: The
html_title
accepts string values only. And The None value cannot be accepted. sphinx.ext.graphviz
: show graph image in inline by default- #2060, #2224: The
manpage
role now generatesphinx.addnodes.manpage
node instead ofsphinx.addnodes.literal_emphasis
node. - #2022:
html_extra_path
also copies dotfiles in the extra directory, and refers toexclude_patterns
to exclude extra files and directories. - #2300: enhance autoclass:: to use the docstring of __new__ if __init__ method’s is missing of empty
- #2251: Previously, under glossary directives, multiple terms for one definition are
converted into single
term
node and the each terms in the term node are separated bytermsep
node. In new implementation, each terms are converted into individualterm
nodes andtermsep
node is removed. By this change, output layout of every builders are changed a bit. - The default highlight language is now Python 3. This means that source code
is highlighted as Python 3 (which is mostly a superset of Python 2), and no
parsing is attempted to distinguish valid code. To get the old behavior back,
add
highlight_language = "python"
to conf.py. - Locale Date Markup Language like
"MMMM dd, YYYY"
is default format fortoday_fmt
andhtml_last_updated_fmt
. However strftime format like"%B %d, %Y"
is also supported for backward compatibility until Sphinx-1.5. Later format will be disabled from Sphinx-1.5. - #2327:
latex_use_parts
is deprecated now. Uselatex_toplevel_sectioning
instead. - #2337: Use
\url{URL}
macro instead of\href{URL}{URL}
in LaTeX writer. - #1498: manpage writer: don’t make whole of item in definition list bold if it includes strong node.
- #582: Remove hint message from quick search box for html output.
- #2378: Sphinx now bundles newfloat.sty
Features added¶
- #2092: add todo directive support in napoleon package.
- #1962: when adding directives, roles or nodes from an extension, warn if such an element is already present (built-in or added by another extension).
- #1909: Add “doc” references to Intersphinx inventories.
- C++ type alias support (e.g.,
.. type:: T = int
). - C++ template support for classes, functions, type aliases, and variables (#1729, #1314).
- C++, added new scope management directives
namespace-push
andnamespace-pop
. - #1970: Keyboard shortcuts to navigate Next and Previous topics
- Intersphinx: Added support for fetching Intersphinx inventories with URLs using HTTP basic auth.
- C++, added support for template parameter in function info field lists.
- C++, added support for pointers to member (function).
- #2113: Allow
:class:
option to code-block directive. - #2192: Imgmath (pngmath with svg support).
- #2200: Support XeTeX and LuaTeX for the LaTeX builder.
- #1906: Use xcolor over color for fcolorbox where available for LaTeX output.
- #2216: Texinputs makefile improvements.
- #2170: Support for Chinese language search index.
- #2214: Add sphinx.ext.githubpages to publish the docs on GitHub Pages
- #1030: Make page reference names for latex_show_pagerefs translatable
- #2162: Add Sphinx.add_source_parser() to add source_suffix and source_parsers from extension
- #2207: Add sphinx.parsers.Parser class; a base class for new parsers
- #656: Add
graphviz_dot
option to graphviz directives to switch thedot
command - #1939: Added the
dummy
builder: syntax check without output. - #2230: Add
math_number_all
option to number all displayed math in math extensions - #2235:
needs_sphinx
supports micro version comparison - #2282: Add “language” attribute to html tag in the “basic” theme
- #1779: Add EPUB 3 builder
- #1751: Add
todo_link_only
to avoid file path and line indication ontodolist
. Thanks to Francesco Montesano. - #2199: Use
imagesize
package to obtain size of images. - #1099: Add configurable retries to the linkcheck builder. Thanks to Alex Gaynor.
Also don’t check anchors starting with
!
. - #2300: enhance autoclass:: to use the docstring of __new__ if __init__ method’s is missing of empty
- #1858: Add Sphinx.add_enumerable_node() to add enumerable nodes for numfig feature
- #1286, #2099: Add
sphinx.ext.autosectionlabel
extension to allow reference sections using its title. Thanks to Tadhg O’Higgins. - #1854: Allow to choose Janome for Japanese splitter.
- #1853: support custom text splitter on html search with
language='ja'
. - #2320: classifier of glossary terms can be used for index entries grouping key. The classifier also be used for translation. See also Glossary.
- #2308: Define
\tablecontinued
macro to redefine the style of continued label for longtables. - Select an image by similarity if multiple images are globbed by
.. image:: filename.*
- #1921: Support figure substitutions by
language
andfigure_language_filename
- #2245: Add
latex_elements["passoptionstopackages"]
option to call PassOptionsToPackages in early stage of preambles. - #2340: Math extension: support alignment of multiple equations for MathJAX.
- #2338: Define
\titleref
macro to redefine the style oftitle-reference
roles. - Define
\menuselection
and\accelerator
macros to redefine the style ofmenuselection
roles. - Define
\crossref
macro to redefine the style of references - #2301: Texts in the classic html theme should be hyphenated.
- #2355: Define
\termref
macro to redefine the style ofterm
roles. - Add
suppress_warnings
to suppress arbitrary warning message (experimental) - #2229: Fix no warning is given for unknown options
- #2327: Add
latex_toplevel_sectioning
to switch the top level sectioning of LaTeX document.
Bugs fixed¶
- #1913: C++, fix assert bug for enumerators in next-to-global and global scope.
- C++, fix parsing of ‘signed char’ and ‘unsigned char’ as types.
- C++, add missing support for ‘friend’ functions.
- C++, add missing support for virtual base classes (thanks to Rapptz).
- C++, add support for final classes.
- C++, fix parsing of types prefixed with ‘enum’.
- #2023: Dutch search support uses Danish stemming info.
- C++, add support for user-defined literals.
- #1804: Now html output wraps overflowed long-line-text in the sidebar. Thanks to Hassen ben tanfous.
- #2183: Fix porterstemmer causes
make json
to fail. - #1899: Ensure list is sent to OptParse.
- #2164: Fix wrong check for pdftex inside sphinx.sty (for graphicx package option).
- #2165, #2218: Remove faulty and non-need conditional from sphinx.sty.
- Fix broken LaTeX code is generated if unknown language is given
- #1944: Fix rst_prolog breaks file-wide metadata
- #2074: make gettext should use canonical relative paths for .pot. Thanks to anatoly techtonik.
- #2311: Fix sphinx.ext.inheritance_diagram raises AttributeError
- #2251: Line breaks in .rst files are transferred to .pot files in a wrong way.
- #794: Fix date formatting in latex output is not localized
- Remove
image/gif
from supported_image_types of LaTeX writer (#2272) - Fix ValueError is raised if LANGUAGE is empty string
- Fix unpack warning is shown when the directives generated from
Sphinx.add_crossref_type
is used - The default highlight language is now
default
. This means that source code is highlighted as Python 3 (which is mostly a superset of Python 2) if possible. To get the old behavior back, addhighlight_language = "python"
to conf.py. - #2329: Refresh environment forcely if source directory has changed.
- #2331: Fix code-blocks are filled by block in dvi; remove
xcdraw
option from xcolor package - Fix the confval type checker emits warnings if unicode is given to confvals which expects string value
- #2360: Fix numref in LaTeX output is broken
- #2361: Fix additional paragraphs inside the “compound” directive are indented
- #2364: Fix KeyError ‘rootSymbol’ on Sphinx upgrade from older version.
- #2348: Move amsmath and amssymb to before fontpkg on LaTeX writer.
- #2368: Ignore emacs lock files like
.#foo.rst
by default. - #2262: literal_block and its caption has been separated by pagebreak in LaTeX output.
- #2319: Fix table counter is overrided by code-block’s in LaTeX. Thanks to jfbu.
- Fix unpack warning if combinated with 3rd party domain extensions.
- #1153: Fix figures in sidebar causes latex build error.
- #2358: Fix user-preamble could not override the tocdepth definition.
- #2358: Redece tocdepth if
part
orchapter
is used for top_sectionlevel. - #2351: Fix footnote spacing
- #2363: Fix
toctree()
in templates generates broken links in SingleHTMLBuilder. - #2366: Fix empty hyperref is generated on toctree in HTML builder.
Documentation¶
- #1757: Fix for usage of
html_last_updated_fmt
. Thanks to Ralf Hemmecke.
Release 1.3.6 (released Feb 29, 2016)¶
Features added¶
- #1873, #1876, #2278: Add
page_source_suffix
html context variable. This should be introduced withsource_parsers
feature. Thanks for Eric Holscher.
Bugs fixed¶
- #2265: Fix babel is used in spite of disabling it on
latex_elements
- #2295: Avoid mutating dictionary errors while enumerating members in autodoc with Python 3
- #2291: Fix pdflatex “Counter too large” error from footnotes inside tables of contents
- #2292: Fix some footnotes disappear from LaTeX output
- #2287:
sphinx.transforms.Locale
always uses rst parser. Sphinx i18n feature should support parsers that specified source_parsers. - #2290: Fix
sphinx.ext.mathbase
use of amsfonts may break user choice of math fonts - #2324: Print a hint how to increase the recursion limit when it is hit.
- #1565, #2229: Revert new warning; the new warning will be triggered from version 1.4 on.
- #2329: Refresh environment forcely if source directory has changed.
- #2019: Fix the domain objects in search result are not escaped
Release 1.3.5 (released Jan 24, 2016)¶
Bugs fixed¶
- Fix line numbers was not shown on warnings in LaTeX and texinfo builders
- Fix filenames were not shown on warnings of citations
- Fix line numbers was not shown on warnings in LaTeX and texinfo builders
- Fix line numbers was not shown on warnings of indices
- #2026: Fix LaTeX builder raises error if parsed-literal includes links
- #2243: Ignore strange docstring types for classes, do not crash
- #2247: Fix #2205 breaks make html for definition list with classifiers that contains regular-expression like string
- #1565: Sphinx will now emit a warning that highlighting was skipped if the syntax
is incorrect for
code-block
,literalinclude
and so on. - #2211: Fix paragraphs in table cell doesn’t work in Latex output
- #2253:
:pyobject:
option ofliteralinclude
directive can’t detect indented body block when the block starts with blank or comment lines. - Fix TOC is not shown when no
:maxdepth:
for toctrees (ref: #771) - Fix warning message for
:numref:
if target is in orphaned doc (ref: #2244)
Release 1.3.4 (released Jan 12, 2016)¶
Bugs fixed¶
- #2134: Fix figure caption with reference causes latex build error
- #2094: Fix rubric with reference not working in Latex
- #2147: Fix literalinclude code in latex does not break in pages
- #1833: Fix email addresses is showed again if latex_show_urls is not None
- #2176: sphinx.ext.graphviz: use <object> instead of <img> to embed svg
- #967: Fix SVG inheritance diagram is not hyperlinked (clickable)
- #1237: Fix footnotes not working in definition list in LaTeX
- #2168: Fix raw directive does not work for text writer
- #2171: Fix cannot linkcheck url with unicode
- #2182: LaTeX: support image file names with more than 1 dots
- #2189: Fix previous sibling link for first file in subdirectory uses last file, not intended previous from root toctree
- #2003: Fix decode error under python2 (only) when
make linkcheck
is run - #2186: Fix LaTeX output of mathbb in math
- #1480, #2188: LaTeX: Support math in section titles
- #2071: Fix same footnote in more than two section titles => LaTeX/PDF Bug
- #2040: Fix UnicodeDecodeError in sphinx-apidoc when author contains non-ascii characters
- #2193: Fix shutil.SameFileError if source directory and destination directory are same
- #2178: Fix unparseable C++ cross-reference when referencing a function with :cpp:any:
- #2206: Fix Sphinx latex doc build failed due to a footnotes
- #2201: Fix wrong table caption for tables with over 30 rows
- #2213: Set <blockquote> in the classic theme to fit with <p>
- #1815: Fix linkcheck does not raise an exception if warniserror set to true and link is broken
- #2197: Fix slightly cryptic error message for missing index.rst file
- #1894: Unlisted phony targets in quickstart Makefile
- #2125: Fix unifies behavior of collapsed fields (
GroupedField
andTypedField
) - #1408: Check latex_logo validity before copying
- #771: Fix latex output doesn’t set tocdepth
- #1820: On Windows, console coloring is broken with colorama version 0.3.3. Now sphinx use colorama>=0.3.5 to avoid this problem.
- #2072: Fix footnotes in chapter-titles do not appear in PDF output
- #1580: Fix paragraphs in longtable don’t work in Latex output
- #1366: Fix centered image not centered in latex
- #1860: Fix man page using
:samp:
with braces - font doesn’t reset - #1610: Sphinx crashes in japanese indexing in some systems
- Fix Sphinx crashes if mecab initialization failed
- #2160: Fix broken TOC of PDFs if section includes an image
- #2172: Fix dysfunctional admonition py@lightbox in sphinx.sty. Thanks to jfbu.
- #2198,#2205:
make gettext
generate broken msgid for definition lists. - #2062: Escape characters in doctests are treated incorrectly with Python 2.
- #2225: Fix if the option does not begin with dash, linking is not performed
- #2226: Fix math is not HTML-encoded when :nowrap: is given (jsmath, mathjax)
- #1601, #2220: ‘any’ role breaks extended domains behavior. Affected extensions doesn’t support resolve_any_xref and resolve_xref returns problematic node instead of None. sphinxcontrib-httpdomain is one of them.
- #2229: Fix no warning is given for unknown options
Release 1.3.3 (released Dec 2, 2015)¶
Bugs fixed¶
- #2177: Fix parallel hangs
- #2012: Fix exception occurred if
numfig_format
is invalid - #2142: Provide non-minified JS code in
sphinx/search/non-minified-js/*.js
for source distribution on PyPI. - #2148: Error while building devhelp target with non-ASCII document.
Release 1.3.2 (released Nov 29, 2015)¶
Features added¶
- #1935: Make “numfig_format” overridable in latex_elements.
Bugs fixed¶
- #1976: Avoid “2.0” version of Babel because it doesn’t work with Windows environment.
- Add a “default.css” stylesheet (which imports “classic.css”) for compatibility.
- #1788: graphviz extension raises exception when caption option is present.
- #1789:
:pyobject:
option ofliteralinclude
directive includes following lines after class definitions - #1790:
literalinclude
strips empty lines at the head and tail - #1802: load plugin themes automatically when theme.conf use it as ‘inherit’. Thanks to Takayuki Hirai.
- #1794: custom theme extended from alabaster or sphinx_rtd_theme can’t find base theme.
- #1834: compatibility for docutils-0.13: handle_io_errors keyword argument for docutils.io.FileInput cause TypeError.
- #1823: ‘.’ as <module_path> for sphinx-apidoc cause an unfriendly error. Now ‘.’ is converted to absolute path automatically.
- Fix a crash when setting up extensions which do not support metadata.
- #1784: Provide non-minified JS code in
sphinx/search/non-minified-js/*.js
- #1822, #1892: Fix regression for #1061. autosummary can’t generate doc for imported members since sphinx-1.3b3. Thanks to Eric Larson.
- #1793, #1819: “see also” misses a linebreak in text output. Thanks to Takayuki Hirai.
- #1780, #1866: “make text” shows “class” keyword twice. Thanks to Takayuki Hirai.
- #1871: Fix for LaTeX output of tables with one column and multirows.
- Work around the lack of the HTMLParserError exception in Python 3.5.
- #1949: Use
safe_getattr
in the coverage builder to avoid aborting with descriptors that have custom behavior. - #1915: Do not generate smart quotes in doc field type annotations.
- #1796: On py3, automated .mo building caused UnicodeDecodeError.
- #1923: Use babel features only if the babel latex element is nonempty.
- #1942: Fix a KeyError in websupport.
- #1903: Fix strange id generation for glossary terms.
make text
will crush if a definition list item has more than 1 classifiers as:term : classifier1 : classifier2
.- #1855: make gettext generates broken po file for definition lists with classifier.
- #1869: Fix problems when dealing with files containing non-ASCII characters. Thanks to Marvin Schmidt.
- #1798: Fix building LaTeX with references in titles.
- #1725: On py2 environment, doctest with using non-ASCII characters causes
'ascii' codec can't decode byte
exception. - #1540: Fix RuntimeError with circular referenced toctree
- #1983: i18n translation feature breaks references which uses section name.
- #1990: Use caption of toctree to title of tableofcontents in LaTeX
- #1987: Fix ampersand is ignored in
:menuselection:
and:guilabel:
on LaTeX builder - #1994: More supporting non-standard parser (like recommonmark parser) for Translation and WebSupport feature. Now node.rawsource is fall backed to node.astext() during docutils transforming.
- #1989: “make blahblah” on Windows indicate help messages for sphinx-build every time. It was caused by wrong make.bat that generated by Sphinx-1.3.0/1.3.1.
- On Py2 environment, conf.py that is generated by sphinx-quickstart should have u prefixed config value for ‘version’ and ‘release’.
- #2102: On Windows + Py3, using
|today|
and non-ASCII date format will raise UnicodeEncodeError. - #1974: UnboundLocalError: local variable ‘domain’ referenced before assignment when
using
any
role andsphinx.ext.intersphinx
in same time. - #2121: multiple words search doesn’t find pages when words across on the page title and the page content.
- #1884, #1885: plug-in html themes cannot inherit another plug-in theme. Thanks to Suzumizaki.
- #1818:
sphinx.ext.todo
directive generates broken html class attribute as ‘admonition-‘ whenlanguage
is specified with non-ASCII linguistic area like ‘ru’ or ‘ja’. To fix this, nowtodo
directive can use:class:
option. - #2140: Fix footnotes in table has broken in LaTeX
- #2127: MecabBinder for html searching feature doesn’t work with Python 3. Thanks to Tomoko Uchida.
Release 1.3.1 (released Mar 17, 2015)¶
Bugs fixed¶
- #1769: allows generating quickstart files/dirs for destination dir that doesn’t overwrite existent files/dirs. Thanks to WAKAYAMA shirou.
- #1773: sphinx-quickstart doesn’t accept non-ASCII character as a option argument.
- #1766: the message “least Python 2.6 to run” is at best misleading.
- #1772: cross reference in docstrings like
:param .write:
breaks building. - #1770, #1774:
literalinclude
with empty file occurs exception. Thanks to Takayuki Hirai. - #1777: Sphinx 1.3 can’t load extra theme. Thanks to tell-k.
- #1776:
source_suffix = ['.rst']
cause unfriendly error on prior version. - #1771: automated .mo building doesn’t work properly.
- #1783: Autodoc: Python2 Allow unicode string in __all__. Thanks to Jens Hedegaard Nielsen.
- #1781: Setting
html_domain_indices
to a list raises a type check warnings.
Release 1.3 (released Mar 10, 2015)¶
Incompatible changes¶
- Roles
ref
,term
andmenusel
now don’t generate emphasis nodes anymore. If you want to keep italic style, adapt your stylesheet. - Role
numref
uses%s
as special character to indicate position of figure numbers instead#
symbol.
Features added¶
- Add convenience directives and roles to the C++ domain:
directive
cpp:var
as alias forcpp:member
, role:cpp:var
as alias for:cpp:member
, and roleany
for cross-reference to any C++ declaraction. #1577, #1744 - The
source_suffix
config value can now be a list of multiple suffixes. - Add the ability to specify source parsers by source suffix with the
source_parsers
config value. - #1675: A new builder, AppleHelpBuilder, has been added that builds Apple Help Books.
Bugs fixed¶
- 1.3b3 change breaks a previous gettext output that contains duplicated msgid such as “foo bar” and “version changes in 1.3: foo bar”.
- #1745: latex builder cause maximum recursion depth exceeded when a footnote has a footnote mark itself.
- #1748: SyntaxError in sphinx/ext/ifconfig.py with Python 2.6.
- #1658, #1750: No link created (and warning given) if option does not begin with -, / or +. Thanks to Takayuki Hirai.
- #1753: C++, added missing support for more complex declarations.
- #1700: Add
:caption:
option fortoctree
. - #1742:
:name:
option is provided fortoctree
,code-block
andliteralinclude
dirctives. - #1756: Incorrect section titles in search that was introduced from 1.3b3.
- #1746: C++, fixed name lookup procedure, and added missing lookups in declarations.
- #1765: C++, fix old id generation to use fully qualified names.
Documentation¶
- #1651: Add
vartype
field descritpion for python domain.
Release 1.3b3 (released Feb 24, 2015)¶
Incompatible changes¶
- Dependency requirement updates: docutils 0.11, Pygments 2.0
- The
gettext_enables
config value has been renamed togettext_additional_targets
. - #1735: Use https://docs.python.org/ instead of
http
protocol. It was used forsphinx.ext.intersphinx
and some documentation.
Features added¶
- #1346: Add new default theme;
- Add ‘alabaster’ theme.
- Add ‘sphinx_rtd_theme’ theme.
- The ‘default’ html theme has been renamed to ‘classic’. ‘default’ is still available, however it will emit notice a recommendation that using new ‘alabaster’ theme.
- Added
highlight_options
configuration value. - The
language
config value is now available in the HTML templates. - The
env-updated
event can now return a value, which is interpreted as an iterable of additional docnames that need to be rewritten. - #772: Support for scoped and unscoped enums in C++. Enumerators in unscoped enums are injected into the parent scope in addition to the enum scope.
- Add
todo_include_todos
config option to quickstart conf file, handled as described in documentation. - HTML breadcrumb items tag has class “nav-item” and “nav-item-N” (like nav-item-0, 1, 2…).
- New option
sphinx-quickstart --use-make-mode
for generating Makefile that use sphinx-build make-mode. - #1235: i18n: several node can be translated if it is set to
gettext_additional_targets
in conf.py. Supported nodes are:- ‘literal-block’
- ‘doctest-block’
- ‘raw’
- ‘image’
- #1227: Add
html_scaled_image_link
config option to conf.py, to control scaled image link.
Bugs fixed¶
- LaTeX writer now generates correct markup for cells spanning multiple rows.
- #1674: Do not crash if a module’s
__all__
is not a list of strings. - #1629: Use VerbatimBorderColor to add frame to code-block in LaTeX
- On windows, make-mode didn’t work on Win32 platform if sphinx was invoked as
python sphinx-build.py
. - #1687: linkcheck now treats 401 Unauthorized responses as “working”.
- #1690: toctrees with
glob
option now can also contain entries for single documents with explicit title. - #1591: html search results for C++ elements now has correct interpage links.
- bizstyle theme: nested long title pages make long breadcrumb that breaks page layout.
- bizstyle theme: all breadcrumb items become ‘Top’ on some mobile browser (iPhone5s safari).
- #1722: restore
toctree()
template function behavior that was changed at 1.3b1. - #1732: i18n: localized table caption raises exception.
- #1718:
:numref:
does not work with capital letters in the label - #1630: resolve CSS conflicts,
div.container
css target for literal block wrapper now renamed todiv.literal-block-wrapper
. sphinx.util.pycompat
has been restored in its backwards-compatibility; slated for removal in Sphinx 1.4.- #1719: LaTeX writer does not respect
numref_format
option in captions
Release 1.3b2 (released Dec 5, 2014)¶
Incompatible changes¶
- update bundled ez_setup.py for setuptools-7.0 that requires Python 2.6 or later.
Features added¶
- #1597: Added possibility to return a new template name from
html-page-context
. - PR#314, #1150: Configuration values are now checked for their type. A warning is raised if the configured and the default value do not have the same type and do not share a common non-trivial base class.
Bugs fixed¶
- PR#311: sphinx-quickstart does not work on python 3.4.
- Fix
autodoc_docstring_signature
not working with signatures in class docstrings. - Rebuilding cause crash unexpectedly when source files were added.
- #1607: Fix a crash when building latexpdf with “howto” class
- #1251: Fix again. Sections which depth are lower than :tocdepth: should not be shown on localtoc sidebar.
- make-mode didn’t work on Win32 platform if sphinx was installed by wheel package.
Release 1.3b1 (released Oct 10, 2014)¶
Incompatible changes¶
- Dropped support for Python 2.5, 3.1 and 3.2.
- Dropped support for docutils versions up to 0.9.
- Removed the
sphinx.ext.oldcmarkup
extension. - The deprecated config values
exclude_trees
,exclude_dirnames
andunused_docs
have been removed. - A new node,
sphinx.addnodes.literal_strong
, has been added, for text that should appear literally (i.e. no smart quotes) in strong font. Custom writers will have to be adapted to handle this node. - PR#269, #1476: replace
<tt>
tag by<code>
. User customized stylesheets should be updated If the css contain some styles fortt>
tag. Thanks to Takeshi Komiya. - #1543:
templates_path
is automatically added toexclude_patterns
to avoid reading autosummary rst templates in the templates directory. - Custom domains should implement the new
Domain.resolve_any_xref
method to make theany
role work properly. - gettext builder: gettext doesn’t emit uuid information to generated pot files
by default. Please set
True
togettext_uuid
to emit uuid information. Additionally, if thepython-levenshtein
3rd-party package is installed, it will improve the calculation time. - gettext builder: disable extracting/apply ‘index’ node by default. Please set
‘index’ to
gettext_enables
to enable extracting index entries. - PR#307: Add frame to code-block in LaTeX. Thanks to Takeshi Komiya.
Features added¶
- Add support for Python 3.4.
- Add support for docutils 0.12
- Added
sphinx.ext.napoleon
extension for NumPy and Google style docstring support. - Added support for parallel reading (parsing) of source files with the
sphinx-build -j
option. Third-party extensions will need to be checked for compatibility and may need to be adapted if they store information in the build environment object. Seeenv-merge-info
. - Added the
any
role that can be used to find a cross-reference of any type in any domain. Custom domains should implement the newDomain.resolve_any_xref
method to make this work properly. - Exception logs now contain the last 10 messages emitted by Sphinx.
- Added support for extension versions (a string returned by
setup()
, these can be shown in the traceback log files). Version requirements for extensions can be specified in projects using the newneeds_extensions
config value. - Changing the default role within a document with the default-role directive is now supported.
- PR#214: Added stemming support for 14 languages, so that the built-in document search can now handle these. Thanks to Shibukawa Yoshiki.
- PR#296, PR#303, #76: numfig feature: Assign numbers to figures, tables and
code-blocks. This feature is configured with
numfig
,numfig_secnum_depth
andnumfig_format
. Alsonumref
role is available. Thanks to Takeshi Komiya. - PR#202: Allow “.” and “~” prefixed references in
:param:
doc fields for Python. - PR#184: Add
autodoc_mock_imports
, allowing to mock imports of external modules that need not be present when autodocumenting. - #925: Allow list-typed config values to be provided on the command line,
like
-D key=val1,val2
. - #668: Allow line numbering of
code-block
andliteralinclude
directives to start at an arbitrary line number, with a newlineno-start
option. - PR#172, PR#266: The
code-block
andliteralinclude
directives now can have acaption
option that shows a filename before the code in the output. Thanks to Nasimul Haque, Takeshi Komiya. - Prompt for the document language in sphinx-quickstart.
- PR#217: Added config values to suppress UUID and location information in generated gettext catalogs.
- PR#236, #1456: apidoc: Add a -M option to put module documentation before submodule documentation. Thanks to Wes Turner and Luc Saffre.
- #1434: Provide non-minified JS files for jquery.js and underscore.js to clarify the source of the minified files.
- PR#252, #1291: Windows color console support. Thanks to meu31.
- PR#255: When generating latex references, also insert latex target/anchor for the ids defined on the node. Thanks to Olivier Heurtier.
- PR#229: Allow registration of other translators. Thanks to Russell Sim.
- Add app.set_translator() API to register or override a Docutils translator
class like
html_translator_class
. - PR#267, #1134: add ‘diff’ parameter to literalinclude. Thanks to Richard Wall and WAKAYAMA shirou.
- PR#272: Added ‘bizstyle’ theme. Thanks to Shoji KUMAGAI.
- Automatically compile
*.mo
files from*.po
files whengettext_auto_build
is True (default) and*.po
is newer than*.mo
file. - #623:
sphinx.ext.viewcode
supports imported function/class aliases. - PR#275:
sphinx.ext.intersphinx
supports multiple target for the inventory. Thanks to Brigitta Sipocz. - PR#261: Added the
env-before-read-docs
event that can be connected to modify the order of documents before they are read by the environment. - #1284: Program options documented with
option
can now start with+
. - PR#291: The caption of
code-block
is recognised as a title of ref target. Thanks to Takeshi Komiya. - PR#298: Add new API:
add_latex_package()
. Thanks to Takeshi Komiya. - #1344: add
gettext_enables
to enable extracting ‘index’ to gettext catalog output / applying translation catalog to generated documentation. - PR#301, #1583: Allow the line numbering of the directive
literalinclude
to match that of the included file, using a newlineno-match
option. Thanks to Jeppe Pihl. - PR#299: add various options to sphinx-quickstart. Quiet mode option
--quiet
will skips wizard mode. Thanks to WAKAYAMA shirou. - #1623: Return types specified with
:rtype:
are now turned into links if possible.
Bugs fixed¶
- #1438: Updated jQuery version from 1.8.3 to 1.11.1.
- #1568: Fix a crash when a “centered” directive contains a reference.
- Now sphinx.ext.autodoc works with python-2.5 again.
- #1563:
add_search_language()
raises AssertionError for correct type of argument. Thanks to rikoman. - #1174: Fix smart quotes being applied inside roles like
program
ormakevar
. - PR#235: comment db schema of websupport lacked a length of the node_id field. Thanks to solos.
- #1466,PR#241: Fix failure of the cpp domain parser to parse C+11 “variadic templates” declarations. Thanks to Victor Zverovich.
- #1459,PR#244: Fix default mathjax js path point to
http://
that cause mixed-content error on HTTPS server. Thanks to sbrandtb and robo9k. - PR#157: autodoc remove spurious signatures from @property decorated attributes. Thanks to David Ham.
- PR#159: Add coverage targets to quickstart generated Makefile and make.bat. Thanks to Matthias Troffaes.
- #1251: When specifying toctree :numbered: option and :tocdepth: metadata,
sub section number that is larger depth than
:tocdepth:
is shrunk. - PR#260: Encode underscore in citation labels for latex export. Thanks to Lennart Fricke.
- PR#264: Fix could not resolve xref for figure node with :name: option. Thanks to Takeshi Komiya.
- PR#265: Fix could not capture caption of graphviz node by xref. Thanks to Takeshi Komiya.
- PR#263, #1013, #1103: Rewrite of C++ domain. Thanks to Jakob Lykke Andersen.
- Hyperlinks to all found nested names and template arguments (#1103).
- Support for function types everywhere, e.g., in std::function<bool(int, int)> (#1013).
- Support for virtual functions.
- Changed interpretation of function arguments to following standard prototype declarations, i.e., void f(arg) means that arg is the type of the argument, instead of it being the name.
- Updated tests.
- Updated documentation with elaborate description of what declarations are supported and how the namespace declarations influence declaration and cross-reference lookup.
- Index names may be different now. Elements are indexed by their fully qualified name. It should be rather easy to change this behaviour and potentially index by namespaces/classes as well.
- PR#258, #939: Add dedent option for
code-block
andliteralinclude
. Thanks to Zafar Siddiqui. - PR#268: Fix numbering section does not work at singlehtml mode. It still ad-hoc fix because there is a issue that section IDs are conflicted. Thanks to Takeshi Komiya.
- PR#273, #1536: Fix RuntimeError with numbered circular toctree. Thanks to Takeshi Komiya.
- PR#274: Set its URL as a default title value if URL appears in toctree. Thanks to Takeshi Komiya.
- PR#276, #1381:
rfc
andpep
roles support custom link text. Thanks to Takeshi Komiya. - PR#277, #1513: highlights for function pointers in argument list of
c:function
. Thanks to Takeshi Komiya. - PR#278: Fix section entries were shown twice if toctree has been put under only directive. Thanks to Takeshi Komiya.
- #1547: pgen2 tokenizer doesn’t recognize
...
literal (Ellipsis for py3). - PR#294: On LaTeX builder, wrap float environment on writing literal_block to avoid separation of caption and body. Thanks to Takeshi Komiya.
- PR#295, #1520:
make.bat latexpdf
mechanism tocd
back to the current directory. Thanks to Peter Suter. - PR#297, #1571: Add imgpath property to all builders. It make easier to develop builder extensions. Thanks to Takeshi Komiya.
- #1584: Point to master doc in HTML “top” link.
- #1585: Autosummary of modules broken in Sphinx-1.2.3.
- #1610: Sphinx cause AttributeError when MeCab search option is enabled and python-mecab is not installed.
- #1674: Do not crash if a module’s
__all__
is not a list of strings. - #1673: Fix crashes with
nitpick_ignore
and:doc:
references. - #1686: ifconfig directive doesn’t care about default config values.
- #1642: Fix only one search result appearing in Chrome.
Documentation¶
- Add clarification about the syntax of tags. (
doc/markup/misc.rst
)
Release 1.2.3 (released Sep 1, 2014)¶
Features added¶
- #1518:
sphinx-apidoc
command now has a--version
option to show version information and exit - New locales: Hebrew, European Portuguese, Vietnamese.
Bugs fixed¶
- #636: Keep straight single quotes in literal blocks in the LaTeX build.
- #1419: Generated i18n sphinx.js files are missing message catalog entries from ‘.js_t’ and ‘.html’. The issue was introduced from Sphinx-1.1
- #1363: Fix i18n: missing python domain’s cross-references with currentmodule directive or currentclass directive.
- #1444: autosummary does not create the description from attributes docstring.
- #1457: In python3 environment, make linkcheck cause “Can’t convert ‘bytes’ object to str implicitly” error when link target url has a hash part. Thanks to Jorge_C.
- #1467: Exception on Python3 if nonexistent method is specified by automethod
- #1441: autosummary can’t handle nested classes correctly.
- #1499: With non-callable
setup
in a conf.py, now sphinx-build emits a user-friendly error message. - #1502: In autodoc, fix display of parameter defaults containing backslashes.
- #1226: autodoc, autosummary: importing setup.py by automodule will invoke
setup process and execute
sys.exit()
. Now sphinx avoids SystemExit exception and emits warnings without unexpected termination. - #1503: py:function directive generate incorrectly signature when specifying
a default parameter with an empty list
[]
. Thanks to Geert Jansen. - #1508: Non-ASCII filename raise exception on make singlehtml, latex, man, texinfo and changes.
- #1531: On Python3 environment, docutils.conf with ‘source_link=true’ in the general section cause type error.
- PR#270, #1533: Non-ASCII docstring cause UnicodeDecodeError when uses with inheritance-diagram directive. Thanks to WAKAYAMA shirou.
- PR#281, PR#282, #1509: TODO extension not compatible with websupport. Thanks to Takeshi Komiya.
- #1477: gettext does not extract nodes.line in a table or list.
- #1544:
make text
generates wrong table when it has empty table cells. - #1522: Footnotes from table get displayed twice in LaTeX. This problem has been appeared from Sphinx-1.2.1 by #949.
- #508: Sphinx every time exit with zero when is invoked from setup.py command.
ex.
python setup.py build_sphinx -b doctest
return zero even if doctest failed.
Release 1.2.2 (released Mar 2, 2014)¶
Bugs fixed¶
- PR#211: When checking for existence of the
html_logo
file, check the full relative path and not the basename. - PR#212: Fix traceback with autodoc and
__init__
methods without docstring. - PR#213: Fix a missing import in the setup command.
- #1357: Option names documented by
option
are now again allowed to not start with a dash or slash, and referencing them will work correctly. - #1358: Fix handling of image paths outside of the source directory when using the “wildcard” style reference.
- #1374: Fix for autosummary generating overly-long summaries if first line doesn’t end with a period.
- #1383: Fix Python 2.5 compatibility of sphinx-apidoc.
- #1391: Actually prevent using “pngmath” and “mathjax” extensions at the same time in sphinx-quickstart.
- #1386: Fix bug preventing more than one theme being added by the entry point mechanism.
- #1370: Ignore “toctree” nodes in text writer, instead of raising.
- #1364: Fix ‘make gettext’ fails when the ‘.. todolist::’ directive is present.
- #1367: Fix a change of PR#96 that break sphinx.util.docfields.Field.make_field
interface/behavior for
item
argument usage.
Documentation¶
- Extended the documentation about building extensions.
Release 1.2.1 (released Jan 19, 2014)¶
Bugs fixed¶
- #1335: Fix autosummary template overloading with exclamation prefix like
{% extends "!autosummary/class.rst" %}
cause infinite recursive function call. This was caused by PR#181. - #1337: Fix autodoc with
autoclass_content="both"
uses uselessobject.__init__
docstring when class does not have__init__
. This was caused by a change for #1138. - #1340: Can’t search alphabetical words on the HTML quick search generated with language=’ja’.
- #1319: Do not crash if the
html_logo
file does not exist. - #603: Do not use the HTML-ized title for building the search index (that resulted in “literal” being found on every page with a literal in the title).
- #751: Allow production lists longer than a page in LaTeX by using longtable.
- #764: Always look for stopwords lowercased in JS search.
- #814: autodoc: Guard against strange type objects that don’t have
__bases__
. - #932: autodoc: Do not crash if
__doc__
is not a string. - #933: Do not crash if an
option
value is malformed (contains spaces but no option name). - #908: On Python 3, handle error messages from LaTeX correctly in the pngmath extension.
- #943: In autosummary, recognize “first sentences” to pull from the docstring if they contain uppercase letters.
- #923: Take the entire LaTeX document into account when caching
pngmath-generated images. This rebuilds them correctly when
pngmath_latex_preamble
changes. - #901: Emit a warning when using docutils’ new “math” markup without a Sphinx math extension active.
- #845: In code blocks, when the selected lexer fails, display line numbers nevertheless if configured.
- #929: Support parsed-literal blocks in LaTeX output correctly.
- #949: Update the tabulary.sty packed with Sphinx.
- #1050: Add anonymous labels into
objects.inv
to be referenced viaintersphinx
. - #1095: Fix print-media stylesheet being included always in the “scrolls” theme.
- #1085: Fix current classname not getting set if class description has
:noindex:
set. - #1181: Report option errors in autodoc directives more gracefully.
- #1155: Fix autodocumenting C-defined methods as attributes in Python 3.
- #1233: Allow finding both Python classes and exceptions with the “class” and “exc” roles in intersphinx.
- #1198: Allow “image” for the “figwidth” option of the figure directive as documented by docutils.
- #1152: Fix pycode parsing errors of Python 3 code by including two grammar versions for Python 2 and 3, and loading the appropriate version for the running Python version.
- #1017: Be helpful and tell the user when the argument to
option
does not match the required format. - #1345: Fix two bugs with
nitpick_ignore
; now you don’t have to remove the store environment for changes to have effect. - #1072: In the JS search, fix issues searching for upper-cased words by lowercasing words before stemming.
- #1299: Make behavior of the
math
directive more consistent and avoid producing empty environments in LaTeX output. - #1308: Strip HTML tags from the content of “raw” nodes before feeding it to the search indexer.
- #1249: Fix duplicate LaTeX page numbering for manual documents.
- #1292: In the linkchecker, retry HEAD requests when denied by HTTP 405. Also make the redirect code apparent and tweak the output a bit to be more obvious.
- #1285: Avoid name clashes between C domain objects and section titles.
- #848: Always take the newest code in incremental rebuilds with the
sphinx.ext.viewcode
extension. - #979, #1266: Fix exclude handling in
sphinx-apidoc
. - #1302: Fix regression in
sphinx.ext.inheritance_diagram
when documenting classes that can’t be pickled. - #1316: Remove hard-coded
font-face
resources from epub theme. - #1329: Fix traceback with empty translation msgstr in .po files.
- #1300: Fix references not working in translated documents in some instances.
- #1283: Fix a bug in the detection of changed files that would try to access doctrees of deleted documents.
- #1330: Fix
exclude_patterns
behavior with subdirectories in thehtml_static_path
. - #1323: Fix emitting empty
<ul>
tags in the HTML writer, which is not valid HTML. - #1147: Don’t emit a sidebar search box in the “singlehtml” builder.
Documentation¶
- #1325: Added a “Intersphinx” tutorial section. (
doc/tutorial.rst
)
Release 1.2 (released Dec 10, 2013)¶
Features added¶
- Added
sphinx.version_info
tuple for programmatic checking of the Sphinx version.
Incompatible changes¶
- Removed the
sphinx.ext.refcounting
extension – it is very specific to CPython and has no place in the main distribution.
Bugs fixed¶
- Restore
versionmodified
CSS class for versionadded/changed and deprecated directives. - PR#181: Fix
html_theme_path = ['.']
is a trigger of rebuild all documents always (This change keeps the current “theme changes cause a rebuild” feature). - #1296: Fix invalid charset in HTML help generated HTML files for default locale.
- PR#190: Fix gettext does not extract figure caption and rubric title inside other blocks. Thanks to Michael Schlenker.
- PR#176: Make sure setup_command test can always import Sphinx. Thanks to Dmitry Shachnev.
- #1311: Fix test_linkcode.test_html fails with C locale and Python 3.
- #1269: Fix ResourceWarnings with Python 3.2 or later.
- #1138: Fix: When
autodoc_docstring_signature = True
andautoclass_content = 'init'
or'both'
, __init__ line should be removed from class documentation.
Release 1.2 beta3 (released Oct 3, 2013)¶
Features added¶
- The Sphinx error log files will now include a list of the loaded extensions for help in debugging.
Incompatible changes¶
- PR#154: Remove “sphinx” prefix from LaTeX class name except ‘sphinxmanual’ and ‘sphinxhowto’. Now you can use your custom document class without ‘sphinx’ prefix. Thanks to Erik B.
Bugs fixed¶
- #1265: Fix i18n: crash when translating a section name that is pointed to from a named target.
- A wrong condition broke the search feature on first page that is usually index.rst. This issue was introduced in 1.2b1.
- #703: When Sphinx can’t decode filenames with non-ASCII characters, Sphinx now catches UnicodeError and will continue if possible instead of raising the exception.
Release 1.2 beta2 (released Sep 17, 2013)¶
Features added¶
apidoc
now ignores “_private” modules by default, and has an option-P
to include them.apidoc
now has an option to not generate headings for packages and modules, for the case that the module docstring already includes a reST heading.- PR#161:
apidoc
can now write each module to a standalone page instead of combining all modules in a package on one page. - Builders: rebuild i18n target document when catalog updated.
- Support docutils.conf ‘writers’ and ‘html4css1 writer’ section in the HTML writer. The latex, manpage and texinfo writers also support their respective ‘writers’ sections.
- The new
html_extra_path
config value allows to specify directories with files that should be copied directly to the HTML output directory. - Autodoc directives for module data and attributes now support an
annotation
option, so that the default display of the data/attribute value can be overridden. - PR#136: Autodoc directives now support an
imported-members
option to include members imported from different modules. - New locales: Macedonian, Sinhala, Indonesian.
- Theme package collection by using setuptools plugin mechanism.
Incompatible changes¶
- PR#144, #1182: Force timezone offset to LocalTimeZone on POT-Creation-Date that was generated by gettext builder. Thanks to masklinn and Jakub Wilk.
Bugs fixed¶
- PR#132: Updated jQuery version to 1.8.3.
- PR#141, #982: Avoid crash when writing PNG file using Python 3. Thanks to Marcin Wojdyr.
- PR#145: In parallel builds, sphinx drops second document file to write. Thanks to tychoish.
- PR#151: Some styling updates to tables in LaTeX.
- PR#153: The “extensions” config value can now be overridden.
- PR#155: Added support for some C++11 function qualifiers.
- Fix: ‘make gettext’ caused UnicodeDecodeError when templates contain utf-8 encoded strings.
- #828: use inspect.getfullargspec() to be able to document functions with keyword-only arguments on Python 3.
- #1090: Fix i18n: multiple cross references (term, ref, doc) in the same line return the same link.
- #1157: Combination of ‘globaltoc.html’ and hidden toctree caused exception.
- #1159: fix wrong generation of objects inventory for Python modules, and add a workaround in intersphinx to fix handling of affected inventories.
- #1160: Citation target missing caused an AssertionError.
- #1162, PR#139: singlehtml builder didn’t copy images to _images/.
- #1173: Adjust setup.py dependencies because Jinja2 2.7 discontinued compatibility with Python < 3.3 and Python < 2.6. Thanks to Alexander Dupuy.
- #1185: Don’t crash when a Python module has a wrong or no encoding declared, and non-ASCII characters are included.
- #1188: sphinx-quickstart raises UnicodeEncodeError if “Project version” includes non-ASCII characters.
- #1189: “Title underline is too short” WARNING is given when using fullwidth characters to “Project name” on quickstart.
- #1190: Output TeX/texinfo/man filename has no basename (only extension) when using non-ASCII characters in the “Project name” on quickstart.
- #1192: Fix escaping problem for hyperlinks in the manpage writer.
- #1193: Fix i18n: multiple link references in the same line return the same link.
- #1176: Fix i18n: footnote reference number missing for auto numbered named footnote and auto symbol footnote.
- PR#146,#1172: Fix ZeroDivisionError in parallel builds. Thanks to tychoish.
- #1204: Fix wrong generation of links to local intersphinx targets.
- #1206: Fix i18n: gettext did not translate admonition directive’s title.
- #1232: Sphinx generated broken ePub files on Windows.
- #1259: Guard the debug output call when emitting events; to prevent the repr() implementation of arbitrary objects causing build failures.
- #1142: Fix NFC/NFD normalizing problem of rst filename on Mac OS X.
- #1234: Ignoring the string consists only of white-space characters.
Release 1.2 beta1 (released Mar 31, 2013)¶
Incompatible changes¶
- Removed
sphinx.util.compat.directive_dwim()
andsphinx.roles.xfileref_role()
which were deprecated since version 1.0. - PR#122: the files given in
latex_additional_files
now override TeX files included by Sphinx, such assphinx.sty
. - PR#124: the node generated by
versionadded
,versionchanged
anddeprecated
directives now includes all added markup (such as “New in version X”) as child nodes, and no additional text must be generated by writers. - PR#99: the
seealso
directive now generates admonition nodes instead of the customseealso
node.
Features added¶
- Markup
- The
toctree
directive and thetoctree()
template function now have anincludehidden
option that includes hidden toctree entries (bugs #790 and #1047). A bug in themaxdepth
option for thetoctree()
template function has been fixed (bug #1046). - PR#99: Strip down seealso directives to normal admonitions. This removes their unusual CSS classes (admonition-see-also), inconsistent LaTeX admonition title (“See Also” instead of “See also”), and spurious indentation in the text builder.
- The
- HTML builder
- #783: Create a link to full size image if it is scaled with width or height.
- #1067: Improve the ordering of the JavaScript search results: matches in titles come before matches in full text, and object results are better categorized. Also implement a pluggable search scorer.
- #1053: The “rightsidebar” and “collapsiblesidebar” HTML theme options now work together.
- Update to jQuery 1.7.1 and Underscore.js 1.3.1.
- Texinfo builder
- An “Index” node is no longer added when there are no entries.
- “deffn” categories are no longer capitalized if they contain capital letters.
desc_annotation
nodes are now rendered.strong
andemphasis
nodes are now formatted likeliteral
s. The reason for this is because the standard Texinfo markup (*strong*
and_emphasis_
) resulted in confusing output due to the common usage of using these constructs for documenting parameter names.- Field lists formatting has been tweaked to better display “Info field lists”.
system_message
andproblematic
nodes are now formatted in a similar fashion as done by the text builder.- “en-dash” and “em-dash” conversion of hyphens is no longer performed in option directive signatures.
@ref
is now used instead of@pxref
for cross-references which prevents the word “see” from being added before the link (does not affect the Info output).- The
@finalout
command has been added for better TeX output. transition
nodes are now formatted using underscores (“_”) instead of asterisks (“*”).- The default value for the
paragraphindent
has been changed from 2 to 0 meaning that paragraphs are no longer indented by default. - #1110: A new configuration value
texinfo_no_detailmenu
has been added for controlling whether a@detailmenu
is added in the “Top” node’s menu. - Detailed menus are no longer created except for the “Top” node.
- Fixed an issue where duplicate domain indices would result in invalid output.
- LaTeX builder:
- PR#115: Add
'transition'
item inlatex_elements
for customizing how transitions are displayed. Thanks to Jeff Klukas. - PR#114: The LaTeX writer now includes the “cmap” package by default. The
'cmappkg'
item inlatex_elements
can be used to control this. Thanks to Dmitry Shachnev. - The
'fontpkg'
item inlatex_elements
now defaults to''
when thelanguage
uses the Cyrillic script. Suggested by Dmitry Shachnev. - The
latex_documents
,texinfo_documents
, andman_pages
configuration values will be set to default values based on themaster_doc
if not explicitly set inconf.py
. Previously, if these values were not set, no output would be generated by their respective builders.
- PR#115: Add
- Internationalization:
- Add i18n capabilities for custom templates. For example: The Sphinx
reference documentation in doc directory provides a
sphinx.pot
file with message strings fromdoc/_templates/*.html
when usingmake gettext
. - PR#61,#703: Add support for non-ASCII filename handling.
- Add i18n capabilities for custom templates. For example: The Sphinx
reference documentation in doc directory provides a
- Other builders:
- Added the Docutils-native XML and pseudo-XML builders. See
XMLBuilder
andPseudoXMLBuilder
. - PR#45: The linkcheck builder now checks
#anchor
s for existence. - PR#123, #1106: Add
epub_use_index
configuration value. If provided, it will be used instead ofhtml_use_index
for epub builder. - PR#126: Add
epub_tocscope
configuration value. The setting controls the generation of the epub toc. The user can now also include hidden toc entries. - PR#112: Add
epub_show_urls
configuration value.
- Added the Docutils-native XML and pseudo-XML builders. See
- Extensions:
- PR#52:
special_members
flag to autodoc now behaves likemembers
. - PR#47: Added
sphinx.ext.linkcode
extension. - PR#25: In inheritance diagrams, the first line of the class docstring is now the tooltip for the class.
- PR#52:
- Command-line interfaces:
- PR#75: Added
--follow-links
option to sphinx-apidoc. - #869: sphinx-build now has the option
-T
for printing the full traceback after an unhandled exception. - sphinx-build now supports the standard
--help
and--version
options. - sphinx-build now provides more specific error messages when called with invalid options or arguments.
- sphinx-build now has a verbose option
-v
which can be repeated for greater effect. A single occurrence provides a slightly more verbose output than normal. Two or more occurrences of this option provides more detailed output which may be useful for debugging.
- PR#75: Added
- Locales:
- PR#74: Fix some Russian translation.
- PR#54: Added Norwegian bokmaal translation.
- PR#35: Added Slovak translation.
- PR#28: Added Hungarian translation.
- #1113: Add Hebrew locale.
- #1097: Add Basque locale.
- #1037: Fix typos in Polish translation. Thanks to Jakub Wilk.
- #1012: Update Estonian translation.
- Optimizations:
- Speed up building the search index by caching the results of the word stemming routines. Saves about 20 seconds when building the Python documentation.
- PR#108: Add experimental support for parallel building with a new
sphinx-build -j
option.
Documentation¶
- PR#88: Added the “Sphinx Developer’s Guide” (
doc/devguide.rst
) which outlines the basic development process of the Sphinx project. - Added a detailed “Installing Sphinx” document (
doc/install.rst
).
Bugs fixed¶
- PR#124: Fix paragraphs in versionmodified are ignored when it has no
dangling paragraphs. Fix wrong html output (nested
<p>
tag). Fix versionmodified is not translatable. Thanks to Nozomu Kaneko. - PR#111: Respect add_autodoc_attrgetter() even when inherited-members is set. Thanks to A. Jesse Jiryu Davis.
- PR#97: Fix footnote handling in translated documents.
- Fix text writer not handling visit_legend for figure directive contents.
- Fix text builder not respecting wide/fullwidth characters: title underline width, table layout width and text wrap width.
- Fix leading space in LaTeX table header cells.
- #1132: Fix LaTeX table output for multi-row cells in the first column.
- #1128: Fix Unicode errors when trying to format time strings with a non-standard locale.
- #1127: Fix traceback when autodoc tries to tokenize a non-Python file.
- #1126: Fix double-hyphen to en-dash conversion in wrong places such as command-line option names in LaTeX.
- #1123: Allow whitespaces in filenames given to
literalinclude
. - #1120: Added improvements about i18n for themes “basic”, “haiku” and “scrolls” that Sphinx built-in. Thanks to Leonardo J. Caballero G.
- #1118: Updated Spanish translation. Thanks to Leonardo J. Caballero G.
- #1117: Handle .pyx files in sphinx-apidoc.
- #1112: Avoid duplicate download files when referenced from documents in different ways (absolute/relative).
- #1111: Fix failure to find uppercase words in search when
html_search_language
is ‘ja’. Thanks to Tomo Saito. - #1108: The text writer now correctly numbers enumerated lists with non-default start values (based on patch by Ewan Edwards).
- #1102: Support multi-context “with” statements in autodoc.
- #1090: Fix gettext not extracting glossary terms.
- #1074: Add environment version info to the generated search index to avoid compatibility issues with old builds.
- #1070: Avoid un-pickling issues when running Python 3 and the saved environment was created under Python 2.
- #1069: Fixed error caused when autodoc would try to format signatures of “partial” functions without keyword arguments (patch by Artur Gaspar).
- #1062: sphinx.ext.autodoc use __init__ method signature for class signature.
- #1055: Fix web support with relative path to source directory.
- #1043: Fix sphinx-quickstart asking again for yes/no questions because
input()
returns values with an extra ‘r’ on Python 3.2.0 + Windows. Thanks to Régis Décamps. - #1041: Fix failure of the cpp domain parser to parse a const type with a modifier.
- #1038: Fix failure of the cpp domain parser to parse C+11 “static constexpr” declarations. Thanks to Jakub Wilk.
- #1029: Fix intersphinx_mapping values not being stable if the mapping has plural key/value set with Python 3.3.
- #1028: Fix line block output in the text builder.
- #1024: Improve Makefile/make.bat error message if Sphinx is not found. Thanks to Anatoly Techtonik.
- #1018: Fix “container” directive handling in the text builder.
- #1015: Stop overriding jQuery contains() in the JavaScript.
- #1010: Make pngmath images transparent by default; IE7+ should handle it.
- #1008: Fix test failures with Python 3.3.
- #995: Fix table-of-contents and page numbering for the LaTeX “howto” class.
- #976: Fix gettext does not extract index entries.
- PR#72: #975: Fix gettext not extracting definition terms before docutils 0.10.
- #961: Fix LaTeX output for triple quotes in code snippets.
- #958: Do not preserve
environment.pickle
after a failed build. - #955: Fix i18n transformation.
- #940: Fix gettext does not extract figure caption.
- #920: Fix PIL packaging issue that allowed to import
Image
without PIL namespace. Thanks to Marc Schlaich. - #723: Fix the search function on local files in WebKit based browsers.
- #440: Fix coarse timestamp resolution in some filesystem generating a wrong list of outdated files.
Release 1.1.3 (Mar 10, 2012)¶
- PR#40: Fix
safe_repr
function to decode bytestrings with non-ASCII characters correctly. - PR#37: Allow configuring sphinx-apidoc via
SPHINX_APIDOC_OPTIONS
. - PR#34: Restore Python 2.4 compatibility.
- PR#36: Make the “bibliography to TOC” fix in LaTeX output specific to the document class.
- #695: When the highlight language “python” is specified explicitly, do not try to parse the code to recognize non-Python snippets.
- #859: Fix exception under certain circumstances when not finding appropriate objects to link to.
- #860: Do not crash when encountering invalid doctest examples, just emit a warning.
- #864: Fix crash with some settings of
modindex_common_prefix
. - #862: Fix handling of
-D
and-A
options on Python 3. - #851: Recognize and warn about circular toctrees, instead of running into recursion errors.
- #853: Restore compatibility with docutils trunk.
- #852: Fix HtmlHelp index entry links again.
- #854: Fix inheritance_diagram raising attribute errors on builtins.
- #832: Fix crashes when putting comments or lone terms in a glossary.
- #834, #818: Fix HTML help language/encoding mapping for all Sphinx supported languages.
- #844: Fix crashes when dealing with Unicode output in doctest extension.
- #831: Provide
--project
flag in setup_command as advertised. - #875: Fix reading config files under Python 3.
- #876: Fix quickstart test under Python 3.
- #870: Fix spurious KeyErrors when removing documents.
- #892: Fix single-HTML builder misbehaving with the master document in a subdirectory.
- #873: Fix assertion errors with empty
only
directives. - #816: Fix encoding issues in the Qt help builder.
Release 1.1.2 (Nov 1, 2011) – 1.1.1 is a silly version number anyway!¶
- #809: Include custom fixers in the source distribution.
Release 1.1.1 (Nov 1, 2011)¶
- #791: Fix QtHelp, DevHelp and HtmlHelp index entry links.
- #792: Include “sphinx-apidoc” in the source distribution.
- #797: Don’t crash on a misformatted glossary.
- #801: Make intersphinx work properly without SSL support.
- #805: Make the
Sphinx.add_index_to_domain
method work correctly. - #780: Fix Python 2.5 compatibility.
Release 1.1 (Oct 9, 2011)¶
Incompatible changes¶
- The
py:module
directive doesn’t output itsplatform
option value anymore. (It was the only thing that the directive did output, and therefore quite inconsistent.) - Removed support for old dependency versions; requirements are now:
- Pygments >= 1.2
- Docutils >= 0.7
- Jinja2 >= 2.3
Features added¶
- Added Python 3.x support.
- New builders and subsystems:
- Added a Texinfo builder.
- Added i18n support for content, a
gettext
builder and related utilities. - Added the
websupport
library and builder. - #98: Added a
sphinx-apidoc
script that autogenerates a hierarchy of source files containing autodoc directives to document modules and packages. - #273: Add an API for adding full-text search support for languages other than English. Add support for Japanese.
- Markup:
- #138: Added an
index
role, to make inline index entries. - #454: Added more index markup capabilities: marking see/seealso entries, and main entries for a given key.
- #460: Allowed limiting the depth of section numbers for HTML using the
toctree
’snumbered
option. - #586: Implemented improved
glossary
markup which allows multiple terms per definition. - #478: Added
py:decorator
directive to describe decorators. - C++ domain now supports array definitions.
- C++ domain now supports doc fields (
:param x:
inside directives). - Section headings in
only
directives are now correctly handled. - Added
emphasize-lines
option to source code directives. - #678: C++ domain now supports superclasses.
- #138: Added an
- HTML builder:
- Added
pyramid
theme. - #559:
html_add_permalinks
is now a string giving the text to display in permalinks. - #259: HTML table rows now have even/odd CSS classes to enable “Zebra styling”.
- #554: Add theme option
sidebarwidth
to the basic theme.
- Added
- Other builders:
- #516: Added new value of the
latex_show_urls
option to show the URLs in footnotes. - #209: Added
text_newlines
andtext_sectionchars
config values. - Added
man_show_urls
config value. - #472: linkcheck builder: Check links in parallel, use HTTP HEAD
requests and allow configuring the timeout. New config values:
linkcheck_timeout
andlinkcheck_workers
. - #521: Added
linkcheck_ignore
config value. - #28: Support row/colspans in tables in the LaTeX builder.
- #516: Added new value of the
- Configuration and extensibility:
- #537: Added
nitpick_ignore
. - #306: Added
env-get-outdated
event. Application.add_stylesheet()
now accepts full URIs.
- #537: Added
- Autodoc:
- #564: Add
autodoc_docstring_signature
. When enabled (the default), autodoc retrieves the signature from the first line of the docstring, if it is found there. - #176: Provide
private-members
option for autodoc directives. - #520: Provide
special-members
option for autodoc directives. - #431: Doc comments for attributes can now be given on the same line as the assignment.
- #437: autodoc now shows values of class data attributes.
- autodoc now supports documenting the signatures of
functools.partial
objects.
- #564: Add
- Other extensions:
- Added the
sphinx.ext.mathjax
extension. - #443: Allow referencing external graphviz files.
- Added
inline
option to graphviz directives, and fixed the default (block-style) in LaTeX output. - #590: Added
caption
option to graphviz directives. - #553: Added
testcleanup
blocks in the doctest extension. - #594:
trim_doctest_flags
now also removes<BLANKLINE>
indicators. - #367: Added automatic exclusion of hidden members in inheritance diagrams, and an option to selectively enable it.
- Added
pngmath_add_tooltips
. - The math extension displaymath directives now support
name
in addition tolabel
for giving the equation label, for compatibility with Docutils.
- Added the
- New locales:
- #221: Added Swedish locale.
- #526: Added Iranian locale.
- #694: Added Latvian locale.
- Added Nepali locale.
- #714: Added Korean locale.
- #766: Added Estonian locale.
- Bugs fixed:
- #778: Fix “hide search matches” link on pages linked by search.
- Fix the source positions referenced by the “viewcode” extension.
Release 1.0.8 (Sep 23, 2011)¶
- #627: Fix tracebacks for AttributeErrors in autosummary generation.
- Fix the
abbr
role when the abbreviation has newlines in it. - #727: Fix the links to search results with custom object types.
- #648: Fix line numbers reported in warnings about undefined references.
- #696, #666: Fix C++ array definitions and template arguments that are not type names.
- #633: Allow footnotes in section headers in LaTeX output.
- #616: Allow keywords to be linked via intersphinx.
- #613: Allow Unicode characters in production list token names.
- #720: Add dummy visitors for graphviz nodes for text and man.
- #704: Fix image file duplication bug.
- #677: Fix parsing of multiple signatures in C++ domain.
- #637: Ignore Emacs lock files when looking for source files.
- #544: Allow .pyw extension for importable modules in autodoc.
- #700: Use
$(MAKE)
in quickstart-generated Makefiles. - #734: Make sidebar search box width consistent in browsers.
- #644: Fix spacing of centered figures in HTML output.
- #767: Safely encode SphinxError messages when printing them to sys.stderr.
- #611: Fix LaTeX output error with a document with no sections but a link target.
- Correctly treat built-in method descriptors as methods in autodoc.
- #706: Stop monkeypatching the Python textwrap module.
- #657: viewcode now works correctly with source files that have non-ASCII encoding.
- #669: Respect the
noindex
flag option in py:module directives. - #675: Fix IndexErrors when including nonexisting lines with
literalinclude
. - #676: Respect custom function/method parameter separator strings.
- #682: Fix JS incompatibility with jQuery >= 1.5.
- #693: Fix double encoding done when writing HTMLHelp .hhk files.
- #647: Do not apply SmartyPants in parsed-literal blocks.
- C++ domain now supports array definitions.
Release 1.0.7 (Jan 15, 2011)¶
- #347: Fix wrong generation of directives of static methods in autosummary.
- #599: Import PIL as
from PIL import Image
. - #558: Fix longtables with captions in LaTeX output.
- Make token references work as hyperlinks again in LaTeX output.
- #572: Show warnings by default when reference labels cannot be found.
- #536: Include line number when complaining about missing reference targets in nitpicky mode.
- #590: Fix inline display of graphviz diagrams in LaTeX output.
- #589: Build using app.build() in setup command.
- Fix a bug in the inheritance diagram exception that caused base classes to be skipped if one of them is a builtin.
- Fix general index links for C++ domain objects.
- #332: Make admonition boundaries in LaTeX output visible.
- #573: Fix KeyErrors occurring on rebuild after removing a file.
- Fix a traceback when removing files with globbed toctrees.
- If an autodoc object cannot be imported, always re-read the document containing the directive on next build.
- If an autodoc object cannot be imported, show the full traceback of the import error.
- Fix a bug where the removal of download files and images wasn’t noticed.
- #571: Implement
~
cross-reference prefix for the C domain. - Fix regression of LaTeX output with the fix of #556.
- #568: Fix lookup of class attribute documentation on descriptors so that comment documentation now works.
- Fix traceback with
only
directives preceded by targets. - Fix tracebacks occurring for duplicate C++ domain objects.
- Fix JavaScript domain links to objects with
$
in their name.
Release 1.0.6 (Jan 04, 2011)¶
- #581: Fix traceback in Python domain for empty cross-reference targets.
- #283: Fix literal block display issues on Chrome browsers.
- #383, #148: Support sorting a limited range of accented characters in the general index and the glossary.
- #570: Try decoding
-D
and-A
command-line arguments with the locale’s preferred encoding. - #528: Observe
locale_dirs
when looking for the JS translations file. - #574: Add special code for better support of Japanese documents in the LaTeX builder.
- Regression of #77: If there is only one parameter given with
:param:
markup, the bullet list is now suppressed again. - #556: Fix missing paragraph breaks in LaTeX output in certain situations.
- #567: Emit the
autodoc-process-docstring
event even for objects without a docstring so that it can add content. - #565: In the LaTeX builder, not only literal blocks require different table handling, but also quite a few other list-like block elements.
- #515: Fix tracebacks in the viewcode extension for Python objects that do not have a valid signature.
- Fix strange reports of line numbers for warnings generated from autodoc-included docstrings, due to different behavior depending on docutils version.
- Several fixes to the C++ domain.
Release 1.0.5 (Nov 12, 2010)¶
- #557: Add CSS styles required by docutils 0.7 for aligned images and figures.
- In the Makefile generated by LaTeX output, do not delete pdf files on clean; they might be required images.
- #535: Fix LaTeX output generated for line blocks.
- #544: Allow
.pyw
as a source file extension.
Release 1.0.4 (Sep 17, 2010)¶
- #524: Open intersphinx inventories in binary mode on Windows, since version 2 contains zlib-compressed data.
- #513: Allow giving non-local URIs for JavaScript files, e.g. in the JSMath extension.
- #512: Fix traceback when
intersphinx_mapping
is empty.
Release 1.0.3 (Aug 23, 2010)¶
- #495: Fix internal vs. external link distinction for links coming from a docutils table-of-contents.
- #494: Fix the
maxdepth
option for thetoctree()
template callable when used withcollapse=True
. - #507: Fix crash parsing Python argument lists containing brackets in string literals.
- #501: Fix regression when building LaTeX docs with figures that don’t have captions.
- #510: Fix inheritance diagrams for classes that are not picklable.
- #497: Introduce separate background color for the sidebar collapse button, making it easier to see.
- #502, #503, #496: Fix small layout bugs in several builtin themes.
Release 1.0.2 (Aug 14, 2010)¶
- #490: Fix cross-references to objects of types added by the
add_object_type()
API function. - Fix handling of doc field types for different directive types.
- Allow breaking long signatures, continuing with backlash-escaped newlines.
- Fix unwanted styling of C domain references (because of a namespace clash with Pygments styles).
- Allow references to PEPs and RFCs with explicit anchors.
- #471: Fix LaTeX references to figures.
- #482: When doing a non-exact search, match only the given type of object.
- #481: Apply non-exact search for Python reference targets with
.name
for modules too. - #484: Fix crash when duplicating a parameter in an info field list.
- #487: Fix setting the default role to one provided by the
oldcmarkup
extension. - #488: Fix crash when json-py is installed, which provides a
json
module but is incompatible to simplejson. - #480: Fix handling of target naming in intersphinx.
- #486: Fix removal of
!
for all cross-reference roles.
Release 1.0.1 (Jul 27, 2010)¶
- #470: Fix generated target names for reST domain objects; they are not in the same namespace.
- #266: Add Bengali language.
- #473: Fix a bug in parsing JavaScript object names.
- #474: Fix building with SingleHTMLBuilder when there is no toctree.
- Fix display names for objects linked to by intersphinx with explicit targets.
- Fix building with the JSON builder.
- Fix hyperrefs in object descriptions for LaTeX.
Release 1.0 (Jul 23, 2010)¶
Incompatible changes¶
- Support for domains has been added. A domain is a collection of
directives and roles that all describe objects belonging together,
e.g. elements of a programming language. A few builtin domains are
provided:
- Python
- C
- C++
- JavaScript
- reStructuredText
- The old markup for defining and linking to C directives is now
deprecated. It will not work anymore in future versions without
activating the
oldcmarkup
extension; in Sphinx 1.0, it is activated by default. - Removed support for old dependency versions; requirements are now:
- docutils >= 0.5
- Jinja2 >= 2.2
- Removed deprecated elements:
exclude_dirs
config valuesphinx.builder
module
Features added¶
- General:
- Added a “nitpicky” mode that emits warnings for all missing
references. It is activated by the
sphinx-build -n
command-line switch or thenitpicky
config value. - Added
latexpdf
target in quickstart Makefile.
- Added a “nitpicky” mode that emits warnings for all missing
references. It is activated by the
- Markup:
- The
menuselection
andguilabel
roles now support ampersand accelerators. - New more compact doc field syntax is now recognized:
:param type name: description
. - Added
tab-width
option toliteralinclude
directive. - Added
titlesonly
option totoctree
directive. - Added the
prepend
andappend
options to theliteralinclude
directive. - #284: All docinfo metadata is now put into the document metadata, not just the author.
- The
ref
role can now also reference tables by caption. - The include directive now supports absolute paths, which are interpreted as relative to the source directory.
- In the Python domain, references like
:func:`.name`
now look for matching names with any prefix if no direct match is found.
- The
- Configuration:
- Added
rst_prolog
config value. - Added
html_secnumber_suffix
config value to control section numbering format. - Added
html_compact_lists
config value to control docutils’ compact lists feature. - The
html_sidebars
config value can now contain patterns as keys, and the values can be lists that explicitly select which sidebar templates should be rendered. That means that the builtin sidebar contents can be included only selectively. html_static_path
can now contain single file entries.- The new universal config value
exclude_patterns
makes the oldunused_docs
,exclude_trees
andexclude_dirnames
obsolete. - Added
html_output_encoding
config value. - Added the
latex_docclass
config value and made the “twoside” documentclass option overridable by “oneside”. - Added the
trim_doctest_flags
config value, which is true by default. - Added
html_show_copyright
config value. - Added
latex_show_pagerefs
andlatex_show_urls
config values. - The behavior of
html_file_suffix
changed slightly: the empty string now means “no suffix” instead of “default suffix”, useNone
for “default suffix”.
- Added
- New builders:
- Added a builder for the Epub format.
- Added a builder for manual pages.
- Added a single-file HTML builder.
- HTML output:
- Inline roles now get a CSS class with their name, allowing styles to
customize their appearance. Domain-specific roles get two classes,
domain
anddomain-rolename
. - References now get the class
internal
if they are internal to the whole project, as opposed to internal to the current page. - External references can be styled differently with the new
externalrefs
theme option for the default theme. - In the default theme, the sidebar can experimentally now be made
collapsible using the new
collapsiblesidebar
theme option. - #129: Toctrees are now wrapped in a
div
tag with classtoctree-wrapper
in HTML output. - The
toctree
callable in templates now has amaxdepth
keyword argument to control the depth of the generated tree. - The
toctree
callable in templates now accepts atitles_only
keyword argument. - Added
htmltitle
block in layout template. - In the JavaScript search, allow searching for object names including
the module name, like
sys.argv
. - Added new theme
haiku
, inspired by the Haiku OS user guide. - Added new theme
nature
. - Added new theme
agogo
, created by Andi Albrecht. - Added new theme
scrolls
, created by Armin Ronacher. - #193: Added a
visitedlinkcolor
theme option to the default theme. - #322: Improved responsiveness of the search page by loading the search index asynchronously.
- Inline roles now get a CSS class with their name, allowing styles to
customize their appearance. Domain-specific roles get two classes,
- Extension API:
- Added
html-collect-pages
. - Added
needs_sphinx
config value andrequire_sphinx()
application API method. - #200: Added
add_stylesheet()
application API method.
- Added
- Extensions:
- Added the
viewcode
extension. - Added the
extlinks
extension. - Added support for source ordering of members in autodoc, with
autodoc_member_order = 'bysource'
. - Added
autodoc_default_flags
config value, which can be used to select default flags for all autodoc directives. - Added a way for intersphinx to refer to named labels in other projects, and to specify the project you want to link to.
- #280: Autodoc can now document instance attributes assigned in
__init__
methods. - Many improvements and fixes to the
autosummary
extension, thanks to Pauli Virtanen. - #309: The
graphviz
extension can now output SVG instead of PNG images, controlled by thegraphviz_output_format
config value. - Added
alt
option tographviz
extension directives. - Added
exclude
argument toautodoc.between()
.
- Added the
- Translations:
- Added Croatian translation, thanks to Bojan Mihelač.
- Added Turkish translation, thanks to Firat Ozgul.
- Added Catalan translation, thanks to Pau Fernández.
- Added simplified Chinese translation.
- Added Danish translation, thanks to Hjorth Larsen.
- Added Lithuanian translation, thanks to Dalius Dobravolskas.
- Bugs fixed:
- #445: Fix links to result pages when using the search function
of HTML built with the
dirhtml
builder. - #444: In templates, properly re-escape values treated with the “striptags” Jinja filter.
- #445: Fix links to result pages when using the search function
of HTML built with the
Projects using Sphinx¶
This is an (incomplete) alphabetic list of projects that use Sphinx or are experimenting with using it for their documentation. If you like to be included, please mail to the Google group.
I’ve grouped the list into sections to make it easier to find interesting examples.
Documentation using the alabaster theme¶
- Alabaster
- Blinker
- Calibre
- Click (customized)
- coala (customized)
- CodePy
- Fabric
- Fityk
- Flask
- Flask-OpenID
- Invoke
- Jinja
- Lino (customized)
- marbl
- MDAnalysis (customized)
- MeshPy
- PyCUDA
- PyOpenCL
- PyLangAcq
- pytest (customized)
- python-apt
- PyVisfile
- Requests
- searx
- Spyder (customized)
- Tablib
- urllib3 (customized)
- Werkzeug (customized)
Documentation using the classic theme¶
- Advanced Generic Widgets (customized)
- Apache CouchDB (customized)
- APSW
- Arb
- Bazaar (customized)
- Beautiful Soup
- Blender
- Bugzilla
- Buildbot
- CMake (customized)
- Chaco (customized)
- Cormoran
- DEAP (customized)
- Director
- EZ-Draw (customized)
- F2py
- Generic Mapping Tools (GMT) (customized)
- Genomedata
- GetFEM++ (customized)
- Glasgow Haskell Compiler (customized)
- Grok (customized)
- GROMACS
- GSL Shell
- Hands-on Python Tutorial
- Kaa (customized)
- Leo
- LEPL (customized)
- Mayavi (customized)
- MediaGoblin (customized)
- mpmath
- OpenCV (customized)
- OpenEXR
- OpenGDA
- Peach^3 (customized)
- Plone (customized)
- PyEMD
- Pyevolve
- Pygame (customized)
- PyMQI
- PyQt4 (customized)
- PyQt5 (customized)
- Python 2
- Python 3 (customized)
- Python Packaging Authority (customized)
- Ring programming language (customized)
- SageMath (customized)
- Segway
- simuPOP (customized)
- Sprox (customized)
- SymPy
- TurboGears (customized)
- tvtk
- Varnish (customized, alabaster for index)
- Waf
- wxPython Phoenix (customized)
- z3c
- zc.async (customized)
- Zope (customized)
Documentation using the sphinxdoc theme¶
- cartopy
- Jython
- Matplotlib
- MDAnalysis Tutorial
- NetworkX
- PyCantonese
- Pyre
- pySPACE
- Pysparse
- PyTango
- Python Wild Magic (customized)
- Reteisi (customized)
- Sqlkit (customized)
- Turbulenz
Documentation using the nature theme¶
- Alembic
- Cython
- easybuild
- jsFiddle
- libLAS (customized)
- Lmod
- MapServer (customized)
- Pandas
- pyglet (customized)
- Setuptools
- Spring Python
- StatsModels (customized)
- Sylli
Documentation using another builtin theme¶
- Breathe (haiku)
- MPipe (sphinx13)
- NLTK (agogo)
- Programmieren mit PyGTK und Glade (German) (agogo, customized)
- PyPubSub (bizstyle)
- Pylons (pyramid)
- Pyramid web framework (pyramid)
- Sphinx (sphinx13) :-)
- Valence (haiku, customized)
Documentation using sphinx_rtd_theme¶
- Annotator
- Ansible (customized)
- Arcade
- aria2
- ASE
- Autofac
- BigchainDB
- Blocks
- bootstrap-datepicker
- Certbot
- Chainer (customized)
- CherryPy
- CodeIgniter
- Conda
- Corda
- Dask
- Databricks (customized)
- Dataiku DSS
- edX
- Electrum
- Elemental
- ESWP3
- Ethereum Homestead
- Fidimag
- Flake8
- GeoNode
- Godot
- Graylog
- GPAW (customized)
- HDF5 for Python (h5py)
- Hyperledger Fabric
- Hyperledger Sawtooth
- IdentityServer
- Idris
- javasphinx
- Julia
- Jupyter Notebook
- Lasagne
- latexindent.pl
- Linguistica
- Linux kernel
- MathJax
- MDTraj (customized)
- MICrobial Community Analysis (micca)
- MicroPython
- Minds (customized)
- Mink
- Mockery
- mod_wsgi
- MoinMoin
- Mopidy
- MyHDL
- Nextflow
- NICOS (customized)
- Pelican
- picamera
- Pillow
- pip
- Paver
- peewee
- Phinx
- phpMyAdmin
- PROS (customized)
- Pweave
- PyPy
- python-sqlparse
- PyVISA
- Read The Docs
- Free your information from their silos (French) (customized)
- Releases Sphinx extension
- Qtile
- Quex
- Satchmo
- Scapy
- SimPy
- SlamData
- Solidity
- Sonos Controller (SoCo)
- Sphinx AutoAPI
- sphinx-argparse
- Sphinx-Gallery (customized)
- SpotBugs
- StarUML
- Sublime Text Unofficial Documentation
- SunPy
- Sylius
- Tango Controls (customized)
- Topshelf
- Theano
- ThreatConnect
- Tuleap
- TYPO3 (customized)
- uWSGI
- Wagtail
- Web Application Attack and Audit Framework (w3af)
- Weblate
- x265
- ZeroNet
Documentation using sphinx_bootstrap_theme¶
Documentation using a custom theme or integrated in a website¶
- Apache Cassandra
- Astropy
- Bokeh
- Boto 3
- CakePHP
- CasperJS
- Ceph
- Chef
- CKAN
- Confluent Platform
- Django
- Doctrine
- Enterprise Toolkit for Acrobat products
- Gameduino
- gensim
- GeoServer
- gevent
- GHC - Glasgow Haskell Compiler
- Guzzle
- H2O.ai
- Istihza (Turkish Python documentation project)
- Kombu
- Lasso
- Mako
- MirrorBrain
- MongoDB
- Music21
- MyHDL
- nose
- ns-3
- NumPy
- ObjectListView
- OpenERP
- OpenCV
- OpenLayers
- OpenTURNS
- Open vSwitch
- PlatformIO
- PyEphem
- Pygments
- Plone User Manual (German)
- PSI4
- PyMOTW
- python-aspectlib (sphinx_py3doc_enhanced_theme)
- QGIS
- qooxdoo
- Roundup
- SaltStack
- scikit-learn
- SciPy
- Scrapy
- Seaborn
- Selenium
- Self
- Substance D
- Sulu
- SQLAlchemy
- tinyTiM
- Twisted
- Ubuntu Packaging Guide
- WebFaction
- WTForms
Homepages and other non-documentation sites¶
- Arizona State University PHY494/PHY598/CHM598 Simulation approaches to Bio-and Nanophysics (classic)
- Benoit Boissinot (classic, customized)
- Computer Networks, Parallelization, and Simulation Laboratory (CNPSLab) (sphinx_rtd_theme)
- Deep Learning Tutorials (sphinxdoc)
- Loyola University Chicago COMP 339-439 Distributed Systems course (sphinx_bootstrap_theme)
- Pylearn2 (sphinxdoc, customized)
- PyXLL (sphinx_bootstrap_theme, customized)
- SciPy Cookbook (sphinx_rtd_theme)
- The Wine Cellar Book (sphinxdoc)
- Thomas Cokelaer’s Python, Sphinx and reStructuredText tutorials (standard)
- UC Berkeley ME233 Advanced Control Systems II course (sphinxdoc)
Books produced using Sphinx¶
- “Die Wahrheit des Sehens. Der DEKALOG von Krzysztof Kieślowski”
- “Expert Python Programming”
- “Expert Python Programming” (Japanese translation)
- “The Hitchhiker’s Guide to Python”
- “LassoGuide”
- “Learning Sphinx” (in Japanese)
- “Mercurial: the definitive guide (Second edition)”
- “Pioneers and Prominent Men of Utah”
- “Pomodoro Technique Illustrated” (Japanese translation)
- “Python Professional Programming” (in Japanese)
- “Redmine Primer 5th Edition (in Japanese)”
- “The repoze.bfg Web Application Framework”
- “Simple and Steady Way of Learning for Software Engineering” (in Japanese)
- “Software-Dokumentation mit Sphinx”
- “Theoretical Physics Reference”
- “The Varnish Book”
Theses produced using Sphinx¶
Projects integrating Sphinx functionality¶
- Read the Docs, a software-as-a-service documentation hosting platform, uses Sphinx to automatically build documentation updates that are pushed to GitHub
- Spyder, the Scientific Python Development Environment, uses Sphinx in its help pane to render rich documentation for functions, classes and methods automatically or on-demand
Sphinx authors¶
Sphinx is written and maintained by Georg Brandl <georg@python.org>.
Substantial parts of the templates were written by Armin Ronacher <armin.ronacher@active-4.com>.
Other co-maintainers:
- Takayuki Shimizukawa <shimizukawa@gmail.com>
- Daniel Neuhäuser <@DasIch>
- Jon Waltman <@jonwaltman>
- Rob Ruana <@RobRuana>
- Robert Lehmann <@lehmannro>
- Roland Meister <@rolmei>
- Takeshi Komiya <@tk0miya>
- Jean-François Burnol <@jfbu>
- Yoshiki Shibukawa <@shibu_jp>
- Timotheus Kampik - <@TimKam>
Other contributors, listed alphabetically, are:
- Alastair Houghton – Apple Help builder
- Alexander Todorov – inheritance_diagram tests and improvements
- Andi Albrecht – agogo theme
- Jakob Lykke Andersen – Rewritten C++ domain
- Henrique Bastos – SVG support for graphviz extension
- Daniel Bültmann – todo extension
- Marco Buttu – doctest extension (pyversion option)
- Etienne Desautels – apidoc module
- Michael Droettboom – inheritance_diagram extension
- Charles Duffy – original graphviz extension
- Kevin Dunn – MathJax extension
- Josip Dzolonga – coverage builder
- Buck Evan – dummy builder
- Matthew Fernandez – todo extension fix
- Hernan Grecco – search improvements
- Horst Gutmann – internationalization support
- Martin Hans – autodoc improvements
- Zac Hatfield-Dodds – doctest reporting improvements
- Doug Hellmann – graphviz improvements
- Tim Hoffmann – theme improvements
- Dave Kuhlman – original LaTeX writer
- Blaise Laflamme – pyramid theme
- Chris Lamb – reproducibility fixes
- Thomas Lamb – linkcheck builder
- Łukasz Langa – partial support for autodoc
- Martin Larralde – additional napoleon admonitions
- Ian Lee – quickstart improvements
- Robert Lehmann – gettext builder (GSOC project)
- Dan MacKinlay – metadata fixes
- Martin Mahner – nature theme
- Will Maier – directory HTML builder
- Jacob Mason – websupport library (GSOC project)
- Glenn Matthews – python domain signature improvements
- Kurt McKee – documentation updates
- Roland Meister – epub builder
- Ezio Melotti – collapsible sidebar JavaScript
- Bruce Mitchener – Minor epub improvement
- Daniel Neuhäuser – JavaScript domain, Python 3 support (GSOC)
- Christopher Perkins – autosummary integration
- Benjamin Peterson – unittests
- T. Powers – HTML output improvements
- Jeppe Pihl – literalinclude improvements
- Rob Ruana – napoleon extension
- Stefan Seefeld – toctree improvements
- Gregory Szorc – performance improvements
- Taku Shimizu – epub3 builder
- Antonio Valentino – qthelp builder, docstring inheritance
- Filip Vavera – napoleon todo directive
- Pauli Virtanen – autodoc improvements, autosummary extension
- Stefan van der Walt – autosummary extension
- Thomas Waldmann – apidoc module fixes
- John Waltman – Texinfo builder
- Barry Warsaw – setup command improvements
- Sebastian Wiesner – image handling, distutils support
- Michael Wilson – Intersphinx HTTP basic auth support
- Matthew Woodcraft – text output improvements
- Joel Wurtz – cellspanning support in LaTeX
- Hong Xu – svg support in imgmath extension and various bug fixes
- Stephen Finucane – setup command improvements and documentation
- Daniel Pizetta – inheritance diagram improvements
Many thanks for all contributions!
There are also a few modules or functions incorporated from other authors and projects:
- sphinx.util.jsdump uses the basestring encoding from simplejson, written by Bob Ippolito, released under the MIT license
- sphinx.util.stemmer was written by Vivake Gupta, placed in the Public Domain