1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
|
.. highlight:: rest
:mod:`sphinx.ext.autodoc` -- Include documentation from docstrings
==================================================================
.. module:: sphinx.ext.autodoc
:synopsis: Include documentation from docstrings.
.. index:: 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 :data:`sys.path` -- adapt your
:data:`sys.path` in the configuration file accordingly.
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.
:mod:`autodoc` provides several directives that are versions of the usual
:rst:dir:`py:module`, :rst:dir:`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 :rst:dir:`py:module`,
:rst:dir:`py:class` etc. directive.
.. note::
Just as :rst:dir:`py:class` respects the current :rst:dir:`py:module`,
:rst:dir:`autoclass` will also do so. Likewise, :rst:dir:`automethod` will
respect the current :rst:dir:`py:class`.
.. rst:directive:: 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; 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 flag options described
below) the default, see :confval:`autodoc_default_flags`.
* 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 the ``private-members`` flag option is given.
.. versionadded:: 1.1
* Python "special" members (that is, those named like ``__special__``) will
be included if the ``special-members`` flag option is given::
.. autoclass:: my.Class
:members:
:private-members:
:special-members:
would document both "private" and "special" members of the class.
.. versionadded:: 1.1
.. versionchanged:: 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 to ``members``::
.. 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.
.. versionadded:: 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.
.. versionadded:: 0.4
* The :rst:dir:`automodule`, :rst:dir:`autoclass` and
:rst:dir:`autoexception` directives also support a flag option called
``show-inheritance``. When given, a list of base classes will be inserted
just below the class signature (when used with :rst:dir:`automodule`, this
will be inserted for every class that is documented in the module).
.. versionadded:: 0.4
* All autodoc directives support the ``noindex`` flag option that has the
same effect as for standard :rst:dir:`py:function` etc. directives: no
index entries are generated for the documented object (and all
autodocumented members).
.. versionadded:: 0.4
* :rst:dir:`automodule` also recognizes the ``synopsis``, ``platform`` and
``deprecated`` options that the standard :rst:dir:`py:module` directive
supports.
.. versionadded:: 0.5
* :rst:dir:`automodule` and :rst:dir:`autoclass` also has an ``member-order``
option that can be used to override the global value of
:confval:`autodoc_member_order` for one directive.
.. versionadded:: 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.
.. versionadded:: 0.6
* In an :rst:dir:`automodule` directive with the ``members`` option set, only
module members whose ``__module__`` attribute is equal to the module name
as given to ``automodule`` will be documented. This is to prevent
documentation of imported classes or functions. Set the
``imported-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.
.. versionadded:: 1.2
* Add a list of modules in the :confval:`autodoc_mock_imports` to prevent
import errors to halt the building process when some external dependencies
are not importable at build time.
.. versionadded:: 1.3
.. rst:directive:: autofunction
autodata
automethod
autoattribute
These work exactly like :rst:dir:`autoclass` etc.,
but do not offer the options used for automatic member documentation.
:rst:dir:`autodata` and :rst:dir:`autoattribute` support
the ``annotation`` 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."""
.. versionchanged:: 0.6
:rst:dir:`autodata` and :rst:dir:`autoattribute` can now extract docstrings.
.. versionchanged:: 1.1
Comment docs are now allowed on the same line after an assignment.
.. versionchanged:: 1.2
:rst:dir:`autodata` and :rst:dir:`autoattribute` have
an ``annotation`` 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, :func:`functools.wraps` can be used to create
well-behaved decorating functions.
There are also new config values that you can set:
.. confval:: autoclass_content
This value selects what content will be inserted into the main body of an
:rst:dir:`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 using
:rst:dir:`automethod` or the ``members`` option to :rst:dir:`autoclass`.
``"both"``
Both the class' and the ``__init__`` method's docstring are concatenated
and inserted.
``"init"``
Only the ``__init__`` method's docstring is inserted.
.. versionadded:: 0.3
.. confval:: 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.
.. versionadded:: 0.6
.. versionchanged:: 1.0
Support for ``'bysource'``.
.. confval:: 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'`` and ``'show-inheritance'``.
If you set one of these flags in this config value, you can use a negated
form, :samp:`'no-{flag}'`, in an autodoc directive, to disable it once.
For example, if ``autodoc_default_flags`` is set to ``['members',
'undoc-members']``, and you write a directive like this::
.. automodule:: foo
:no-undoc-members:
the directive will be interpreted as if only ``:members:`` was given.
.. versionadded:: 1.0
.. confval:: 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.
.. versionadded:: 1.1
.. confval:: 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.
.. versionadded:: 1.3
Docstring preprocessing
-----------------------
autodoc provides the following additional events:
.. event:: autodoc-process-docstring (app, what, name, obj, options, lines)
.. versionadded:: 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`` and
``noindex`` 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
.. event:: autodoc-process-signature (app, what, name, obj, options, signature, return_annotation)
.. versionadded:: 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`` and
``noindex`` 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)"``, or ``None`` 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"``, or ``None`` if there is no return annotation
The :mod:`sphinx.ext.autodoc` module provides factory functions for commonly
needed docstring processing in event :event:`autodoc-process-docstring`:
.. autofunction:: cut_lines
.. autofunction:: between
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:
.. event:: autodoc-skip-member (app, what, name, obj, skip, options)
.. versionadded:: 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``.
: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`` and
``noindex`` that are true if the flag option of same name was given to the
auto directive
|