We place high importance on the consistency and readability of documentation.\nAfter all, Django was created in a journalism environment! So we treat our\ndocumentation like we treat our code: we aim to improve it as often as\npossible.
\nMudanças na documentação geralmente aparecem de duas formas:
\nMelhorias gerais: correção de ortografia, correções de erros e melhores explicações através de escrita clara e mais exemplos.
Novas funcionalidades: documentação de funcionalidades que foram adicionadas ao framework desde a última release.
Esta seção explica como os escritores podem construir suas mudanças na documentação de forma mais eficiente e menos suscetível a erros.
\nThough Django’s documentation is intended to be read as HTML at\nhttps://docs.djangoproject.com/, we edit it as a collection of plain text files\nwritten in the reStructuredText markup language for maximum flexibility.
\nWe work from the development version of the repository because it has the\nlatest-and-greatest documentation, just as it has the latest-and-greatest code.
\nWe also backport documentation fixes and improvements, at the discretion of the\nmerger, to the last release branch. This is because it’s advantageous to\nhave the docs for the last release be up-to-date and correct (see\nDiferenças entre versões).
\nA documentação do Django usa o sistema de documentação Sphinx, que por sua vez é baseado no docutils. A ideia básica é que uma documentação em texto plano com formatação simples é transformada em HTML, PDF, e muitos outros formatos.
\nSphinx includes a sphinx-build command for turning reStructuredText into\nother formats, e.g., HTML and PDF. This command is configurable, but the Django\ndocumentation includes a Makefile that provides a shorter make html\ncommand.
A documentação é organizada em vários categorias:
\nTutorials pega o leitor pelas mãos e o leva através de uma série de passos para criar algo.
\nO importante em um tutorial é ajudar o leitor a fazer algo útil, preferencialmente o mais rápido possível, para que ele passe a ganhar confiança.
\nExplain the nature of the problem we’re solving, so that the reader\nunderstands what we’re trying to achieve. Don’t feel that you need to begin\nwith explanations of how things work - what matters is what the reader does,\nnot what you explain. It can be helpful to refer back to what you’ve done and\nexplain afterward.
\nTopic guides buscam explicar um conceito ou um assunto de modo bem abrangente.
\nFaça links para referências ao invés de repeti-las. Utilize exemplos e não seja relutante em explicar coisas que pareçam muito básicas para você - essa pode ser a explicação que outra pessoa precisa.
\nContextualizar ajuda os novatos a ligar o assunto a coisas que eles já sabem.
\nReference guides contain technical references for APIs.\nThey describe the functioning of Django’s internal machinery and instruct in\nits use.
\nMantenha o material de referência focado estritamente no assunto. Assuma que o leitor já entende os conceitos básicos envolvidos mas precisa saber ou ser lembrado de como o Django faz isso.
\nGuias de referência não são o local para explicações genéricas. Se você se encontrar explicando conceitos básicos, você deve querer mover o material para um guia em um assunto em específico.
\nHow-to guides são receitas que levam o leitor através de uma série de passos em assuntos chave.
\nO que importa mais em um guia how-to é o que um usuário deseja alcançar. Um how-to deve sempre estar orientado a resultados ao invés de focado em detalhes internos de como o Django implementa o que quer que esteja sendo discutido.
\nEsses guias são mais avançados que tutoriais e assumem algum conhecimento sobre como o Django trabalha. Assuma que o leitor seguiu os tutoriais e não hesite em enviar o leitor de volta para o tutorial apropriado ao invés de repetir o mesmo material.
\nIf you’d like to start contributing to our docs, get the development version of\nDjango from the source code repository (see\nInstalando a versão de desenvolvimento.):
\nLinux / macOS
$ git clone https://github.com/django/django.git\nWindows
...\\> git clone https://github.com/django/django.git\nIf you’re planning to submit these changes, you might find it useful to make a\nfork of the Django repository and clone this fork instead.
\nCreate and activate a virtual environment, then install the dependencies:
\n$ python -m venv .venv\n$ source .venv/bin/activate\n$ python -m pip install -r docs/requirements.txt\nWe can build HTML output from the docs directory:
Linux / macOS
$ cd docs\n$ make html\nWindows
...\\> cd docs\n...\\> make.bat html\nYour locally-built documentation will be accessible at\n_build/html/index.html and it can be viewed in any web browser, though it\nwill be themed differently than the documentation at\ndocs.djangoproject.com. This is OK! If\nyour changes look good on your local machine, they’ll look good on the website.
The source files are .txt files located in the docs/ directory.
These files are written in the reStructuredText markup language. To learn the\nmarkup, see the reStructuredText reference.
\nTo edit this page, for example, we would edit the file\ndocs/internals/contributing/writing-documentation.txt and rebuild the\nHTML with make html.
Several checks help maintain Django’s documentation quality, including\nspelling and\ncode block formatting.
\nThese checks are run automatically in CI and must pass before documentation\nchanges can be merged. They can also be run locally with a single command:
\nLinux / macOS
$ make check\nWindows
...\\> make.bat check\nThis command runs all current checks and will include any new checks added in\nthe future.
\nBefore you commit your docs, it’s a good idea to run the spelling checker.\nYou’ll need to install sphinxcontrib-spelling first. Then from the\ndocs directory, run:
Linux / macOS
$ make spelling\nWindows
...\\> make.bat spelling\nWrong words (if any) along with the file and line number where they occur will\nbe saved to _build/spelling/output.txt.
Se você encontrar falso-positivos (erros que na verdade estão corretos), faça uma das coisas a seguir:
\nSurround inline code or brand/technology names with double grave accents\n(``).
Encontre um sinônimo que o verificador ortográfico reconheça.
Se, e somente se, você tiver certeza que a palavra que você está usando está correta - adicione ela em docs/spelling_wordlist (por favor mantenha a lista em ordem alfabética).
All Python code blocks should be formatted using the blacken-docs\nauto-formatter. This is automatically run by the pre-commit hook if configured.
\nThe check can also be run manually: provided that blacken-docs is installed,\nrun the following command from the docs directory:
Linux / macOS
$ make black\nWindows
...\\> make.bat black\nThe formatter will report any issues by printing them to the terminal and will\nreformat code blocks where possible.
\nLinks in documentation can become broken or changed such that they are no\nlonger the canonical link. Sphinx provides a builder that can check whether the\nlinks in the documentation are working. From the docs directory, run:
Linux / macOS
$ make linkcheck\nWindows
...\\> make.bat linkcheck\nOutput is printed to the terminal, but can also be found in\n_build/linkcheck/output.txt and _build/linkcheck/output.json.
Entries that have a status of “working” are fine, those that are “unchecked” or\n“ignored” have been skipped because they either cannot be checked or have\nmatched ignore rules in the configuration.
\nEntries that have a status of “broken” need to be fixed. Those that have a\nstatus of “redirected” may need to be updated to point to the canonical\nlocation, e.g. the scheme has changed http:// → https://. In certain\ncases, we do not want to update a “redirected” link, e.g. a rewrite to always\npoint to the latest or stable version of the documentation, e.g. /en/stable/ →\n/en/3.2/.
When using pronouns in reference to a hypothetical person, such as “a user with\na session cookie”, gender-neutral pronouns (they/their/them) should be used.\nInstead of:
\nele ou ela… utilize eles.
Dele ou dela… utilize deles.
Dele ou dela… utilize deles.
dele ou dela… use deles.
ele mesmo ou ela mesma… use eles mesmos.
Try to avoid using words that minimize the difficulty involved in a task or\noperation, such as “easily”, “simply”, “just”, “merely”, “straightforward”, and\nso on. People’s experience may not match your expectations, and they may become\nfrustrated when they do not find a step as “straightforward” or “simple” as it\nis implied to be.
\nAqui vão algumas orientações de estilo para termos usados comumente por toda a documentação:
\nDjango – quando estiver se referindo ao framework, deve começar com letra maiúscula. Ele só deve ser escrito em letras minúsculas no código Python e no logo de djangoproject.com.
email – sem hífen.
HTTP – the expected pronunciation is “Aitch Tee Tee Pee” and therefore\nshould be preceded by “an” and not “a”.
MySQL, PostgreSQL, SQLite
SQL – quando estiver se referindo ao SQL, a pronunciação esperada deve ser “Ess Queue Ell” e não “sequel”. Portanto, em uma frase como “Retorna uma expressão SQL”, “SQL” deve ser precedido por “um” e não por “a”.
Python – quando estiver se referindo a linguagem, use letra maiúscula.
realize, customize, initialize, etc. – use o padrão Americano “ize” suffix, não “ise”
subclass – É uma única palavra sem o hífen, tanto para o verbo (“subclassear o modelo”) quanto para o substântivo (“criar uma subclasse”).
the web, web framework – it’s not capitalized.
website – utilize uma palavra, tudo em minúsculas.
model – não tem maiúsculas.
template – não tem maiúsculas.
URLconf – utilize três as letras primeiras letras maiúsculas, sem espaço antes de “conf.”
view – não tem maiúsculas.
Estas regras regulam o formato de nossa documentação em reST (reStructuredText):
\nNa seção de títulos, só deixe em maiúsculas palavras iniciais e pronomes próprios.
Restrinja a documentação em até 80 caracteres de comprimento, a não ser que o código de exemplo seja significativamente mais difícil de ler quando quebrado em duas linhas, ou por outra boa razão.
The main thing to keep in mind as you write and edit docs is that the\nmore semantic markup you can add the better. So:
\nAdd ``django.contrib.auth`` to your ``INSTALLED_APPS``...\nIsn’t nearly as helpful as:
\nAdd :mod:`django.contrib.auth` to your :setting:`INSTALLED_APPS`...\nIsso porque o Sphinx irá gerar links apropriados para o mais recente, o que ajuda muito os leitores.
\nYou can prefix the target with a ~ (that’s a tilde) to get only the\n“last bit” of that path. So :mod:`~django.contrib.auth` will\ndisplay a link with the title “auth”.
Utilize intersphinx para referenciar a documentação do Python e do Sphinx.
Add .. code-block:: <lang> to literal blocks so that they get\nhighlighted. Prefer relying on automatic highlighting using ::\n(two colons). This has the benefit that if the code contains some invalid\nsyntax, it won’t be highlighted. Adding .. code-block:: python, for\nexample, will force highlighting despite invalid syntax.
To improve readability, use .. admonition:: Descriptive title rather than\n.. note::. Use these boxes sparingly.
Use these heading styles:
\n===\nOne\n===\n\nTwo\n===\n\nThree\n-----\n\nFour\n~~~~\n\nFive\n^^^^\nUse :rfc: to reference a Request for Comments (RFC) and\ntry to link to the relevant section if possible. For example, use\n:rfc:`2324#section-2.3.2` or\n:rfc:`Custom link text <2324#section-2.3.2>`.
Use :pep: to reference a Python Enhancement Proposal (PEP)\nand try to link to the relevant section if possible. For example, use\n:pep:`20#easter-egg` or :pep:`Easter Egg <20#easter-egg>`.
Use :mimetype: to refer to a MIME Type unless the value\nis quoted for a code example.
Use :envvar: to refer to an environment variable. You may\nalso need to define a reference to the documentation for that environment\nvariable using .. envvar::.
Use :cve: to reference a Common Vulnerabilities and\nExposures (CVE) identifier. For example, use :cve:`2019-14232`.
Besides Sphinx’s built-in markup, Django’s docs\ndefine some extra description units:
\nSettings:
\n.. setting:: INSTALLED_APPS\nPara redirecionar para uma configuração, utilize :setting:`INSTALLED_APPS`.
Template tags:
\n.. templatetag:: regroup\nPara redirecionar, utilize :ttag:`regroup`.
Template filters:
\n.. templatefilter:: linebreaksbr\nPara redirecionar, utilize :tfilter:`linebreaksbr`.
Field lookups (i.e. Foo.objects.filter(bar__exact=whatever)):
.. fieldlookup:: exact\nPara link, utilize :lookup:`exact`.
django-admin commands:
.. django-admin:: migrate\nPara linkar, utilize :djadmin:`migrate`.
django-admin command-line options:
.. django-admin-option:: --traceback\nPara redirecionar, utilize :option:`command_name --traceback` (ou omita command_name para as opções compartilhadas por todos os comandos como --verbosity).
Links to Trac tickets (typically reserved for patch release notes):
\n:ticket:`12345`\nDjango’s documentation uses a custom console directive for documenting\ncommand-line examples involving django-admin, manage.py, python,\netc.). In the HTML documentation, it renders a two-tab UI, with one tab showing\na Unix-style command prompt and a second tab showing a Windows prompt.
For example, you can replace this fragment:
\nuse this command:\n\n.. code-block:: console\n\n $ python manage.py shell\nwith this one:
\nuse this command:\n\n.. console::\n\n $ python manage.py shell\nNote duas coisas:
\nYou usually will replace occurrences of the .. code-block:: console\ndirective.
You don’t need to change the actual content of the code example. You still\nwrite it assuming a Unix-y environment (i.e. a '$' prompt symbol,\n'/' as filesystem path components separator, etc.)
The example above will render a code example block with two tabs. The first\none will show:
\n$ python manage.py shell\n(No changes from what .. code-block:: console would have rendered).
O segundo irá mostrar:
\n...\\> py manage.py shell\nNossa política para novas funcionalidades é:
\n\n\nAll documentation of new features should be written in a way that\nclearly designates the features that are only available in the Django\ndevelopment version. Assume documentation readers are using the latest\nrelease, not the development version.
\n
Nossa forma preferida de marcar novas funcionalidades é adicionando um prefixo na documentação de novas funcionalidades com “.. versionadded:: X.Y”, seguidas de uma linha em branco mandatória e uma descrição opcional (identada).
General improvements or other changes to the APIs that should be emphasized\nshould use the “.. versionchanged:: X.Y” directive (with the same format\nas the versionadded mentioned above.
These versionadded and versionchanged blocks should be “self-contained.”\nIn other words, since we only keep these annotations around for two releases,\nit’s nice to be able to remove the annotation and its contents without having\nto reflow, reindent, or edit the surrounding text. For example, instead of\nputting the entire description of a new or changed feature in a block, do\nsomething like this:
.. class:: Author(first_name, last_name, middle_name=None)\n\n A person who writes books.\n\n ``first_name`` is ...\n\n ...\n\n ``middle_name`` is ...\n\n .. versionchanged:: A.B\n\n The ``middle_name`` argument was added.\nColoque as considerações referentes as mudanças anotadas no final das seções, não no topo.
\nAlém disso, evite mencionar uma versão específica do Django fora dos blocos versionadded ou versionchanged. Mesmo dentro de um bloco, Ainda costuma ser redundantes fazer isso já que essas anotações irão renderizar como “Novo no Django A.B” e “Alterado no Django A.B”, respectivamente.
If a function, attribute, etc. is added, it’s also okay to use a\nversionadded annotation like this:
.. attribute:: Author.middle_name\n\n .. versionadded:: A.B\n\n An author's middle name.\nWe can remove the .. versionadded:: A.B annotation without any indentation\nchanges when the time comes.
Otimize a compressão das imagens quando possível. Para arquivos PNG, utilize OptiPNG e o “advpng” da AdvanceCOMP:
\nLinux / macOS
$ cd docs\n$ optipng -o7 -zm1-9 -i0 -strip all `find . -type f -not -path "./_build/*" -name "*.png"`\n$ advpng -z4 `find . -type f -not -path "./_build/*" -name "*.png"`\nWindows
...\\> cd docs\n...\\> optipng -o7 -zm1-9 -i0 -strip all `find . -type f -not -path ".\\_build\\*" -name "*.png"`\n...\\> advpng -z4 `find . -type f -not -path ".\\_build\\*" -name "*.png"`\nThis is based on OptiPNG version 0.7.5. Older versions may complain about the\n-strip all option being lossy.
Para um rápido exemplo de como tudo se encaixa, considere este exemplo hipotético:
\nPrimeiro, o documento ref/settings.txt pode ter um leiaute geral como esse:
========\nSettings\n========\n\n...\n\n.. _available-settings:\n\nAvailable settings\n==================\n\n...\n\n.. _deprecated-settings:\n\nDeprecated settings\n===================\n\n...\nDepois, o documento topics/settings.txt pode ser algo assim:
You can access a :ref:`listing of all available settings\n<available-settings>`. For a list of deprecated settings see\n:ref:`deprecated-settings`.\n\nYou can find both in the :doc:`settings reference document\n</ref/settings>`.\nWe use the Sphinx doc cross-reference element when we want to\nlink to another document as a whole and the ref element when\nwe want to link to an arbitrary location in a document.
Depois, repare em como os settings são anotados:
\n.. setting:: ADMINS\n\nADMINS\n======\n\nDefault: ``[]`` (Empty list)\n\nA list of all the people who get code error notifications. When\n``DEBUG=False`` and a view raises an exception, Django will email these people\nwith the full exception information. Each member of the list should be a tuple\nof (Full name, email address). Example::\n\n [("John", "john@example.com"), ("Mary", "mary@example.com")]\n\nNote that Django will email *all* of these people whenever an error happens.\nSee :doc:`/howto/error-reporting` for more information.\nIsso marca o próximo cabeçalho como o alvo “canônico” para o setting ADMINS. Isto significa que sempre que eu falar sobre ADMINS, eu posso redirecionar para ele usando :setting:`ADMINS`.
Isso é basicamente como tudo se encaixa.
\nVeja Localizing the Django documentation Se você quer ajudar a traduzir a documentação para outras linguagens.
\ndjango-adminLink para este cabeçalho#O Sphinx pode gerar uma página de manual para o comando django-admin. Isso é configurado em docs/conf.py. Diferentemente de outras documentações geradas, essa página man deve ser incluída no repositório do Django e de suas releases em docs/man/django-admin.1. Não existe a necessidade de atualizar esse arquivo quando estiver atualizando a documentação, já que ele é atualizado durante o processo de release.
To generate an updated version of the man page, in the docs directory, run:
Linux / macOS
$ make man\nWindows
...\\> make.bat man\nThe new man page will be written in docs/_build/man/django-admin.1.