rest
sphinx.ext.autodoc
pair: automatic; documentation single: docstring
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
~sphinx.ext.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 <sphinx.ext.napoleon>
extension. napoleon <sphinx.ext.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 :rstpy:module
, :rstpy: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 :rstpy:module
, :rstpy:class
etc. directive.
Note
Just as :rstpy:class
respects the current :rstpy:module
, :rstautoclass
will also do so. Likewise, :rstautomethod
will respect the current :rstpy:class
.
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
Options and advanced usage
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:
Tip
You can use autodoc directive options to temporarily override or extend default options which takes list as an input. For example:
.. autoclass:: Noodle :members: eat :private-members: +_spicy, _garlickly
3.5 The default options can be overridden or extended temporarily.
autodoc considers a member private if its docstring contains
:meta private:
in itsinfo-field-lists
. For example:def my_function(my_arg, my_other_arg): """blah blah blah :meta private: """3.0
autodoc considers a member public if its docstring contains
:meta public:
in itsinfo-field-lists
, even if it starts with an underscore. For example:def _my_function(my_arg, my_other_arg): """blah blah blah :meta public: """3.1
autodoc considers a variable member does not have any default value if its docstring contains
:meta hide-value:
in itsinfo-field-lists
. Example:var1 = None #: :meta hide-value:3.5
For classes and exceptions, members inherited from base classes will be left out when documenting all members, unless you give the
inherited-members
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.It can take an ancestor class not to document inherited members from it. By default, members of
object
class are not documented. To show them all, giveNone
to the option.For example; If your class
Foo
is derived fromlist
class and you don't want to documentlist.__len__()
, you should specify a option:inherited-members: list
to avoid special members of list class.Another example; If your class Foo has
__str__
special method and autodoc directive has bothinherited-members
andspecial-members
,__str__
will be documented as in the past, but other special method that are not implemented in your classFoo
.Note: this will lead to markup errors if the inherited members come from a module whose docstrings are not reST formatted.
0.3
3.0
It takes an ancestor class name as an argument.
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.
0.4
The :rst
automodule
, :rstautoclass
and :rstautoexception
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 with :rstautomodule
, this will be inserted for every class that is documented in the module).0.4
All autodoc directives support the
noindex
flag option that has the same effect as for standard :rstpy:function
etc. directives: no index entries are generated for the documented object (and all autodocumented members).0.4
:rst
automodule
also recognizes thesynopsis
,platform
anddeprecated
options that the standard :rstpy:module
directive supports.0.5
:rst
automodule
and :rstautoclass
also has anmember-order
option that can be used to override the global value ofautodoc_member_order
for one directive.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.0.6
In an :rst
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.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.1.3
As a hint to autodoc extension, you can put a
::
separator in between module name and object name to let autodoc know the correct module name if it is ambiguous. :.. autoclass:: module.name::Noodle
:rst
autoclass
also recognizes theclass-doc-from
option that can be used to override the global value ofautoclass_content
.4.1
These work exactly like :rst
autoclass
etc., but do not offer the options used for automatic member documentation.:rst
autodata
and :rstautoattribute
support theannotation
option. The option controls how the value of variable is shown. If specified without arguments, only the name of the variable will be printed, and its value is not shown:.. autodata:: CD_DRIVE :annotation:
If the option specified with arguments, it is printed after the name as a value of the variable:
.. autodata:: CD_DRIVE :annotation: = your CD device name
By default, without
annotation
option, Sphinx tries to obtain the value of the variable and print it after the name.The
no-value
option can be used instead of a blankannotation
to show the type hint but not the value:.. autodata:: CD_DRIVE :no-value:
If both the
annotation
andno-value
options are used,no-value
has no effect.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."""
0.6 :rst
autodata
and :rstautoattribute
can now extract docstrings.1.1 Comment docs are now allowed on the same line after an assignment.
1.2 :rst
autodata
and :rstautoattribute
have anannotation
option.2.0 :rst
autodecorator
added.3.4 :rst
autodata
and :rstautoattribute
now have ano-value
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.
There are also config values that you can set:
autoclass_content
This value selects what content will be inserted into the main body of an :rstautoclass
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 using :rstautomethod
or themembers
option to :rstautoclass
."both"
Both the class' and the
__init__
method's docstring are concatenated and inserted."init"
Only the
__init__
method's docstring is inserted.
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.
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.
0.6
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'
.
1.0
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': True,
'exclude-members': '__weakref__'
}
Setting None
or True
to the value is equivalent to giving only the option name to the directives.
The supported options are 'members'
, 'member-order'
, 'undoc-members'
, 'private-members'
, 'special-members'
, 'inherited-members'
, 'show-inheritance'
, 'ignore-module-all'
, 'imported-members'
, 'exclude-members'
and 'class-doc-from'
.
1.8
2.0 Accepts True
as a value.
2.1 Added 'imported-members'
.
4.1 Added 'class-doc-from'
.
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.
autodoc will continue to look for multiple signature lines, stopping at the first line that does not look like a signature. This is useful for declaring overloaded function signatures.
1.1
3.1
Support overloaded signatures
4.0
Overloaded signatures do not need to be separated by a backslash
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.
1.3
1.6 This config value only requires to declare the top-level modules that should be mocked.
autodoc_typehints
This value controls how to represent typehints. The setting takes the following values:
'signature'
-- Show typehints as its signature (default)'description'
-- Show typehints as content of function or method'none'
-- Do not show typehints
2.1
3.0
New option 'description'
is added.
autodoc_typehints_description_target
This value controls whether the types of undocumented parameters and return values are documented when autodoc_typehints
is set to description
.
The default value is "all"
, meaning that types are documented for all parameters and return values, whether they are documented or not.
When set to "documented"
, types will only be documented for a parameter or a return value that is already documented by the docstring.
4.0
autodoc_type_aliases
A dictionary for users defined type aliases__ that maps a type name to the full-qualified object name. It is used to keep type aliases not evaluated in the document. Defaults to empty ({}
).
The type aliases are only available if your program enables Postponed Evaluation of Annotations (PEP 563)__ feature via from __future__ import annotations
.
For example, there is code using a type alias:
from __future__ import annotations
AliasType = Union[List[Dict[Tuple[int, str], Set[int]]], Tuple[str, List[str]]]
def f() -> AliasType:
...
If autodoc_type_aliases
is not set, autodoc will generate internal mark-up from this code as following:
.. py:function:: f() -> Union[List[Dict[Tuple[int, str], Set[int]]], Tuple[str, List[str]]]
...
If you set autodoc_type_aliases
as {'AliasType': 'your.module.AliasType'}
, it generates the following document internally:
.. py:function:: f() -> your.module.AliasType:
...
3.3
autodoc_preserve_defaults
If True, the default argument values of functions will be not evaluated on generating document. It preserves them as is in the source code.
4.0
Added as an experimental feature. This will be integrated into autodoc core in the future.
autodoc_warningiserror
This value controls the behavior of sphinx-build -W
during importing modules. If False
is given, autodoc forcedly 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 from parents.
The default is True
.
1.7
suppress_warnings
autodoc
supports to suppress warning messages via suppress_warnings
. It allows following warnings types in addition:
- autodoc
- autodoc.import_object
autodoc provides the following additional events:
autodoc-process-docstring (app, what, name, obj, options, lines)
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.
- param app
the Sphinx application object
- param what
the type of the object which the docstring belongs to (one of
"module"
,"class"
,"exception"
,"function"
,"method"
,"attribute"
)- param name
the fully qualified name of the object
- param obj
the object itself
- param 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- param lines
the lines of the docstring, see above
autodoc-before-process-signature (app, obj, bound_method)
2.4
Emitted before autodoc formats a signature for an object. The event handler can modify an object to change its signature.
- param app
the Sphinx application object
- param obj
the object itself
- param bound_method
a boolean indicates an object is bound method or not
autodoc-process-signature (app, what, name, obj, options, signature, return_annotation)
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.
- param app
the Sphinx application object
- param what
the type of the object which the docstring belongs to (one of
"module"
,"class"
,"exception"
,"function"
,"method"
,"attribute"
)- param name
the fully qualified name of the object
- param obj
the object itself
- param 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- param 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.- param 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
:
cut_lines
between
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)
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 returns False
.
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 return None
to fall back to the skipping behavior of autodoc and other enabled extensions.
- param app
the Sphinx application object
- param what
the type of the object which the docstring belongs to (one of
"module"
,"class"
,"exception"
,"function"
,"method"
,"attribute"
)- param name
the fully qualified name of the object
- param obj
the object itself
- param skip
a boolean indicating if autodoc will skip this member if the user handler does not override the decision
- param 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