| Oct | NOV | Dec |
| 09 | ||
| 2019 | 2020 | 2021 |
COLLECTED BY
Formed in 2009, the Archive Team (not to be confused with the archive.org Archive-It Team) is a rogue archivist collective dedicated to saving copies of rapidly dying or deleted websites for the sake of history and digital heritage. The group is 100% composed of volunteers and interested parties, and has expanded into a large amount of related projects for saving online and digital history.
History is littered with hundreds of conflicts over the future of a community, group, location or business that were "resolved" when one of the parties stepped ahead and destroyed what was there. With the original point of contention destroyed, the debates would fall to the wayside. Archive Team believes that by duplicated condemned data, the conversation and debate can continue, as well as the richness and insight gained by keeping the materials. Our projects have ranged in size from a single volunteer downloading the data to a small-but-critical site, to over 100 volunteers stepping forward to acquire terabytes of user-created data to save for future generations.
The main site for Archive Team is at archiveteam.org and contains up to the date information on various projects, manifestos, plans and walkthroughs.
This collection contains the output of many Archive Team projects, both ongoing and completed. Thanks to the generous providing of disk space by the Internet Archive, multi-terabyte datasets can be made available, as well as in use by the Wayback Machine, providing a path back to lost websites and work.
Our collection has grown to the point of having sub-collections for the type of data we acquire. If you are seeking to browse the contents of these collections, the Wayback Machine is the best first stop. Otherwise, you are free to dig into the stacks to see what you may find.
The Archive Team Panic Downloads are full pulldowns of currently extant websites, meant to serve as emergency backups for needed sites that are in danger of closing, or which will be missed dearly if suddenly lost due to hard drive crashes or server failures.
Collection: Archive Team: URLs
●Python »
Python Developer's Guide »
This sentence has a footnote reference. [#]_ This is the next sentence.
Footnotes should be gathered at the end of a file, or if the file is very long,
at the end of a section. The docutils will automatically create backlinks to
the footnote reference.
Footnotes may appear in the middle of sentences where appropriate.
ssl). Littering the documentation of these modules with red
warning boxes for problems that are due to the task at hand, rather than
specifically to Python’s support for that task, doesn’t make for a good
reading experience.
Instead, these security concerns should be gathered into a dedicated
“Security Considerations” section within the module’s documentation, and
cross-referenced from the documentation of affected interfaces with a note
similar to "Please refer tothe :ref:`security-considerations` section
for important information onhow toavoid common mistakes.".
Similarly, if there is a common error that affects many interfaces in a
module (e.g. OS level pipe buffers filling up and stalling child processes),
these can be documented in a “Common Errors” section and cross-referenced
rather than repeated for every affected interface.
str.rpartition() method is better
demonstrated with an example splitting the domain from a URL than it would be
with an example of removing the last word from a line of Monty Python dialog.
The ellipsis for the sys.ps2 secondary interpreter prompt should only
be used sparingly, where it is necessary to clearly differentiate between input
lines and output lines. Besides contributing visual clutter, it makes it
difficult for readers to cut-and-paste examples so they can experiment with
variations.
all(). The short 4-line code
equivalent is easily digested; it re-emphasizes the early-out behavior; and it
clarifies the handling of the corner-case where the iterable is empty. In
addition, it serves as a model for people wanting to implement a commonly
requested alternative where all() would return the specific object
evaluating to False whenever the function terminates early.
A more questionable example is the code for itertools.groupby(). Its code
equivalent borders on being too complex to be a quick aid to understanding.
Despite its complexity, the code equivalent was kept because it serves as a
model to alternative implementations and because the operation of the “grouper”
is more easily shown in code than in English prose.
An example of when not to use a code equivalent is for the oct() function.
The exact steps in converting a number to octal doesn’t add value for a user
trying to learn what the function does.
*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.
reST also allows for custom “interpreted text roles”’, which signify 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`.
# 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 continuesDefinition lists 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.Paragraphs are quoted by just indenting them more than the surrounding paragraphs.
::. The literal block must be indented:
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:”.
`Link text <http://target>`_ 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.
================= 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, for the Python documentation, here is a suggested convention: ●
# with overline, for parts
●* with overline, for chapters
●=, for sections
●-, for subsections
●^, for subsubsections
●", for paragraphs
.. 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.)
.. function:: foo(x) foo(y, z) :bar: no 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 bar
(as you can see, options are given in the lines immediately following the
arguments and indicated by the colons).
The directive content follows after a blank line and is indented relative to the
directive start.
[#]_ 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 [#]_ dolor sit amet ... [#]_ .. rubric:: Footnotes .. [#] Text of the first footnote. .. [#] Text of the second footnote.You can also explicitly number the footnotes for better context.
sectionauthor
Identifies the author of the current section. The argument should include
the author’s name such that it can be used for presentation (though it isn’t)
and email address. The domain name portion of the address should be lower
case. Example:
.. sectionauthor:: Guido van Rossum <guido@python.org>Currently, this markup isn’t reflected in the output in any way, but it helps keep track of contributions.
:mod:`parrot` -- Dead parrot access =================================== .. module:: parrot :platform: Unix, Windows :synopsis: Analyze and reanimate dead parrots. .. moduleauthor:: Eric Cleese <eric@python.invalid> .. moduleauthor:: John Idle <john@python.invalid>As you can see, the module-specific markup consists of two directives, the
module directive and the moduleauthor directive.
module
This directive marks the beginning of the description of a module, package,
or submodule. The name should be fully qualified (i.e. including the
package name for submodules).
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.
moduleauthor
The moduleauthor directive, which can appear multiple times, names the
authors of the module code, just like sectionauthor names the author(s)
of a piece of documentation. It too does not result in any output currently.
Note
It is important to make the section title of a module-describing file
meaningful since that value will be inserted in the table-of-contents trees
in overview files.
:noindex:. The
following example shows all of the features of this directive type:
.. function:: spam(eggs) ham(eggs) :noindex: Spam or ham the foo.The signatures of object methods or data attributes should not include the class name, but be nested in a class directive. The generated files will reflect this nesting, and the target identifiers (for HTML output) will use both the class and method name, to enable consistent cross-references. If you describe methods belonging to an abstract protocol such as context managers, use a class directive with a (pseudo-)type name too to make the index entries more informative. The directives are:
c:function
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
Describes a C struct member. Example signature:
.. c:member:: PyObject* PyTypeObject.tp_basesThe 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
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 not to be used for simple constant definitions. Examples
of its use in the Python documentation include PyObject_HEAD and
Py_BEGIN_ALLOW_THREADS.
c:type
Describes a C type. The signature should just be the type name.
c:var
Describes a global C variable. The signature should include the type, such
as:
.. c:var:: PyObject* PyClass_Type
data
Describes global data in a module, including both variables and values used
as “defined constants.” Class and object attributes are not documented
using this directive.
exception
Describes an exception class. The signature can, but need not include
parentheses with constructor arguments.
function
Describes a module-level function. The signature should include the
parameters, enclosing optional parameters in brackets. Default values can be
given if it enhances clarity. For example:
.. function:: repeat([repeat=3[, number=1000000]])Object methods are not documented using this directive. Bound object methods placed in the module namespace as part of the public interface of the module are documented using this, as they are equivalent to normal functions for most purposes. The description should include information about the parameters required and how they are used (especially whether mutable objects passed as parameters are modified), side effects, and possible exceptions. A small example may be provided.
coroutinefunction
Describes a module-level coroutine. The description should include similar
information to that described for function.
decorator
Describes a decorator function. The signature should not represent the
signature of the actual function, but 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 decoratorthe descriptions should look like this:
.. decorator:: removename Remove name of the decorated function. .. decorator:: setnewname(name) Set name of the decorated function to *name*.There is no
deco role to link to a decorator that is marked up with
this directive; rather, use the :func: role.
class
Describes a class. The signature can include parentheses with parameters
which will be shown as the constructor arguments.
attribute
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. This directive should be nested in a class directive,
like in this example:
.. class:: Spam Description of the class. .. attribute:: ham Description of the attribute.If is also possible to document an attribute outside of a class directive, for example if the documentation for different attributes and methods is split in multiple sections. The class name should then be included explicitly:
.. attribute:: Spam.eggs
method
Describes an object method. The parameters should not include the self
parameter. The description should include similar information to that
described for function. This directive should be nested in a class
directive, like in the example above.
coroutinemethod
Describes an object coroutine method. The parameters should not include the
self parameter. The description should include similar information to
that described for function. This directive should be nested in a
class directive.
decoratormethod
Same as decorator, but for decorators that are methods.
Refer to a decorator method using the :meth: role.
staticmethod
Describes an object static method. The description should include similar
information to that described for function. This directive should be
nested in a class directive.
classmethod
Describes an object class method. The parameters should not include the
cls parameter. The description should include similar information to
that described for function. This directive should be nested in a
class directive.
abstractmethod
Describes an object abstract method. The description should include similar
information to that described for function. This directive should be
nested in a class directive.
opcode
Describes a Python bytecode instruction.
cmdoption
Describes a Python command line option or switch. Option argument names
should be enclosed in angle brackets. Example:
.. cmdoption:: -m <module> Run a module as a script.
envvar
Describes an environment variable that Python uses or defines.
There is also a generic version of these directives:
describe
This directive produces the same formatting as the specific ones explained
above but does not create index entries or cross-referencing targets. It is
used, for example, to describe the directives in this document. Example:
.. describe:: opcode Describes a Python bytecode instruction.
:: at the end of the
preceding paragraph and delimited by indentation.
Representing an interactive session requires including the prompts and output
along with the Python code. No special markup is required for interactive
sessions. After the last line of input or output presented, there should not be
an “unused” primary prompt; this is an example of what not to do:
>>> 1 + 1 2 >>>Syntax highlighting is handled in a smart way: There is a “highlighting language” for each source file. By default, this is
'python' as the majority of files will have to highlight Python
snippets.
Within Python highlighting mode, interactive sessions are recognized
automatically and highlighted appropriately.
The highlighting language can be changed using the highlight
directive, used as follows:
.. highlight::cThis language is used until the next
highlight directive is
encountered.
The code-block directive can be used to specify the highlight language
of a single code block, e.g.:
.. code-block:: c #include <stdio.h> void main() { printf("Hello world!\n"); }The values normally used for the highlighting language are: ●
python (the default)
●c
●rest
●none (no highlighting)
If highlighting with the current language fails, the block is not highlighted
in any way.
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. [1] For example, to include the Python source
file example.py, use:
.. literalinclude:: example.pyThe file name is relative to the current file’s path. Documentation-specific include files should be placed in the
Doc/includes subdirectory.
*var*.
For all other roles, you have to write :rolename:`content`.
There are some additional facilities 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.
For the Python object roles, if you prefix the content with ~, the link
text will only be the last component of the target. For example,
:meth:`~Queue.Queue.get` will refer to Queue.Queue.get but only
display get as the link text.
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.
The following roles refer to objects in modules and are possibly hyperlinked if
a matching identifier is found:
mod
The name of a module; a dotted name may be used. This should also be used
for package names.
func
The name of a Python function; dotted names may be used. The role text
should not include trailing parentheses to enhance readability. The
parentheses are stripped when searching for identifiers.
data
The name of a module-level variable or constant.
const
The name of a “defined” constant. This may be a C-language #define
or a Python variable that is not intended to be changed.
class
A class name; a dotted name may be used.
meth
The name of a method of an object. The role text should include the type
name and the method name. A dotted name may be used.
attr
The name of a data attribute of an object.
exc
The name of an exception. A dotted name may be used.
The name enclosed in this markup can include a module name and/or a class name.
For example, :func:`filter` could refer to a function named filter in
the current module, or the built-in function of that name. In contrast,
: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 the
codecs module, :func:`open` always refers to the built-in function,
while :func:`.open` refers to codecs.open().
A similar heuristic is used to determine whether the name is an attribute of
the currently documented class.
c:data
The name of a C-language variable.
c:func
The name of a C-language function. Should include trailing parentheses.
c:macro
The name of a “simple” C macro, as defined above.
c:type
The name of a C-language type.
c:member
The name of a C type member, as defined above.
envvar
An environment variable. Index entries are generated.
keyword
The name of a Python keyword. Using this role will generate a link to the
documentation of the keyword. True, False and None do not use
this role, but simple code markup (``True``), given that they’re
fundamental to the language and should be known to any programmer.
option
A command-line option of Python. The leading hyphen(s) must be included.
If a matching cmdoption directive exists, it is linked to. For options
of other programs or scripts, use simple ``code`` markup.
token
The name of a grammar token (used in the reference manual to create links
between production displays).
term
Reference to a term in the glossary. The 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 the term
markup, in fact, by default the Python docs have one global glossary
in the glossary.rst file.
If you use a term that’s not explained in a glossary, you’ll get a warning
during build.
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:
``spam`` is installed in :file:`/usr/lib/python2.{x}/site-packages` ...In the built documentation, the
xwill 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 using curses 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.
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)`.
menuselection
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.
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.
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:.
If you don’t need the “variable part” indication, use the standard
``code`` instead.
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. Such
hyperlinks should not be a substitute for properly documenting the
language in the manuals.
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.
Note that there are no special roles for including hyperlinks as you can use
the standard reST markup for that purpose.
:ref:`label-name` role.
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: invocation is replaced with the section title.
Alternatively, you can reference any label (not just section titles)
if you provide the link text :ref:`link text <reference-label>`.
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 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. In the interest of not scaring users away from pages filled
with warnings, this directive should only be chosen over note for
information regarding the possibility of crashes, data loss, or security
implications.
versionadded
This directive documents the version of Python which added the described
feature, or a part of it, 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. The second
argument is optional and can be used to describe the details of the feature.
Example:
.. versionadded:: 3.5
versionchanged
Similar to versionadded, but describes when and what changed in the named
feature in some way (new parameters, changed side effects, platform support,
etc.). This one must have the second argument (explanation of the change).
Example:
.. versionchanged:: 3.1 The *spam* parameter was added.Note that there should be no blank line between the directive head and the explanation; this is to make these blocks visually continuous in the markup.
deprecated
Indicates the version from which the described feature is deprecated.
There is one required argument: the version from which the feature is
deprecated.
Example:
.. deprecated:: 3.8
deprecated-removed
Like deprecated, but it also indicates in which version the feature is
removed.
There are two required arguments: the version from which the feature is
deprecated, and the version in which the feature is removed.
Example:
.. deprecated-removed:: 3.8 4.0
impl-detail
This directive is used to mark CPython-specific information. Use either with
a block content or a single sentence as an argument, i.e. either
.. impl-detail:: This describes some implementation detail. More explanation.or
.. impl-detail:: This shortly mentions an implementation detail.“CPython implementation detail:” is automatically prepended to the content.
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
sub-sections. 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 :mod:`zipfile` Documentation of the :mod:`zipfile` standard module. `GNU tar manual, Basic Tar Format <http://link>`_ Documentation for tar archive files, including GNU tar extensions.
rubric
This directive creates a paragraph heading that is not used to create a
table of contents node. It is currently used for the “Footnotes” caption.
centered
This directive creates a centered boldfaced paragraph. Use it as follows:
.. centered:: Paragraph contents.
toctree directive is the central element.
toctree
This directive inserts a “TOC tree” at the current location, using the
individual TOCs (including “sub-TOC trees”) of the files given in the
directive body. A numeric maxdepth option may be given to indicate the
depth of the tree; by default, all levels are included.
Consider this example (taken from the library reference index):
.. toctree:: :maxdepth: 2 intro strings datatypes numeric (many more files listed here)This accomplishes two things: ●Tables of contents from all those files are inserted, with a maximum depth of two, that means one nested heading.
toctree directives in those
files are also taken into account.
●Sphinx knows that the relative order of the files intro,
strings and so forth, and it knows that they are children of the
shown file, the library index. From this information it generates “next
chapter”, “previous chapter” and “parent chapter” links.
In the end, all files included in the build process must occur in one
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.
The special file contents.rst at the root of the source directory is the
“root” of the TOC tree hierarchy; from it the “Contents” page is generated.
index and 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; pathThis 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). 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,
namely loop; statement and statement; loop.
triple
Likewise, triple: module; search; path is a shortcut that creates three
index entries, which are module; search path, search; path, module
and path; module search.
module, keyword, operator, object, exception, statement, builtin
These all create two index entries. For example, module: hashlib
creates the entries module; hashlib and hashlib; module. The
builtin entry type is slightly different in that “built-in function” is used
in place of “builtin” when creating the two entries.
For index directives containing only “single” entries, there is a shorthand
notation:
.. index:: BNF, grammar, syntax, notationThis creates four index entries.
productionlist
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.
Blank lines are not allowed within productionlist directive arguments.
The definition can contain token names which are marked as interpreted text
(e.g. unaryneg ::= "-" `integer`) – this generates cross-references
to the productions of these tokens.
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`
conf.py.
|release|
Replaced by the Python release the documentation refers to. This is the full
version string including alpha/beta/release candidate tags, e.g. 2.5.2b3.
|version|
Replaced by the Python version the documentation refers to. This consists
only of the major and minor version parts, e.g. 2.5, even for version
2.5.1.
|today|
Replaced by either today’s date, or the date set in the build configuration
file. Normally has the format April 14, 2007.
Footnotes
| [1] | There is a standard include directive, but it raises errors if the
file is not found. This one only emits a warning. |
Misc/NEWS on demand; and
python-docs-theme, the Sphinx theme for the Python documentation.
To build the documentation, follow the instructions from one of the sections
below. You can view the documentation after building the HTML by pointing
a browser at the file Doc/build/html/index.html.
You are expected to have installed the latest stable version of
Sphinx and blurb on your system or in a virtualenv (which can be
created using make venv), so that the Makefile can find the
sphinx-build command. You can also specify the location of
sphinx-build with the SPHINXBUILD make variable.
cd Doc
make venv
make html
or alternatively make -C Doc/ venv html.
You can also use make help to see a list of targets supported by
make. Note that make check is automatically run when
you submit a pull request, so you should make
sure that it runs without errors.
On Windows, a make.bat batchfile tries to emulate make
as closely as possible, but the venv target is not implemented, so you will
probably want to make sure you are working in a virtual environment before
proceeding, otherwise all dependencies will be automatically installed on your
system.
When ready, run the following from the root of your repository clone to build the output as HTML:
cd Doc
make html
You can also use make help to see a list of targets supported by
make.bat.
See also Doc/README.rst for more information.
sphinx-build -b<builder> . build/<builder>where
<builder> is one of html, text, latex, or htmlhelp (for explanations
see the make targets above).
| Language | Contact | Links |
|---|---|---|
| Arabic (ar) | Abdur-Rahmaan Janhangeer | GitHub |
| Bengali as spoken in India (bn_IN) | Kushal Das | GitHub |
| French (fr) | Julien Palard (mdk) | GitHub |
| Hindi as spoken in india (hi_IN) | GitHub | |
| Hungarian (hu) | Tamás Bajusz (gbtami) | GitHub Mailing List |
| Indonesian (id) | Oon Arfiandwi | GitHub |
| Italian (it) | ||
| Japanese (ja) | Kinebuchi Tomohiko (cocoatomo) | GitHub Doc |
| Korean (ko) | GitHub Doc | |
| Lithuanian (lt) | ||
| Polish (pl) | GitHub Translations Doc | |
| Portuguese (pt) | Gustavo Toffo | |
| Portuguese as spoken in Brasil (pt-br) | Marco Rougeth | GitHub Wiki Telegram article |
| Russian (ru) | ||
| Simplified Chinese (zh-cn) | Shengjing Zhu | Transifex GitHub Doc |
| Spanish (es) | Raúl Cumplido | GitHub |
| Traditional Chinese (zh-tw) | 廖偉涵 Adrian Liaw | GitHub Transifex Doc |
| Turkish (tr) | GitHub |
tutorial/, bugs.py and library/functions
are complete, ask on doc-sig for your language to be added in the
language picker on docs.python.org.
pt-brorfr.
●Each translation is under CC0 and marked as so in the README (as in
the cookiecutter).
●Translations files are hosted on
https://github.com/python/python-docs-{LANGUAGE_TAG} (not
mandatory to start a translation, but mandatory to land on
docs.python.org).
●Translations having completed tutorial/, library/stdtypes
and library/functions are hosted on
https://docs.python.org/{LANGUAGE_TAG}/{VERSION_TAG}/.
#python-doc.
.po files
before committing, this helps keeping git diffs short.
●potodo to list what needs to be translated.
github.com/python organization we’ll all have the
exact same hierarchy so bots will be able to build all of our
translations. So you may have to convert from one hierarchy to another.
Ask for help on the doc-sig mailing list if you’re not sure on how to do
it.
po
files in the root of the repository using the gettext_compact=0
style.
●Python »
Python Developer's Guide »