jump to navigation

Lendo Euclides por Beppo Levi 2013/09/03

Posted by gsavix in ciência colaborativa, civilização, colaboração na aquisição conhecimento, Conhecimento, conhecimento física, Conhecimento para receber ou transferir tecnologia, construtores de documentação, gerador documentos, máxima matemática, Memorando, metodologia para receber ou transferir conhecimento, morfologia, notícias interesse público, publicação jornal internet, semântica, sintaxe, sistema hipotético dedutivo, sociologia do conhecimento.
add a comment

A matemática e a geometria sob um olhar renovador.

Editora Civilização Brasileira – Rio de Janeiro – 2008
(um selo da editora record ltda)

Tradução do espanhol (Leyendo a Euclides)

Ao publicar sua monumental obra Elementos, Euclides de Alexandria (360 a.C. a 295 a.C.), criador da geometria euclidiana, tornou-se o mais importante matemático da Antiguidade greco-romana e talvez de todos os tempos.

A obra abrange toda a aritmética, a álgebra e a geometria conhecidas até então no mundo grego, sistematiza o conhecimento geométrico dos antigos e intercala os teoremas já conhecidos com a demonstração de muitos outros, que completam lacunas e dão coerência e encadeamento lógico ao sistema que ele criou.

Em Elementos, Euclides introduziu o formato (ou método) axiomático, que é, em grande medida, o paradigma do modo de operar da razão matemática. Seus axiomas cristalizaram uma estética quase imperativa para essa razão: a estética do equilíbrio delicado entre simplicidade e alcance, entre o mínimo de pressupostos e o máximo de consequências deriváveis. A genialidade do modelo euclidiano reside em que a partir de noções elementares como ponto, reta, círculo e juntamente com apenas cinco axiomas, é possível desenvolver análises que abrangem toda a geometria clássica.

Beppo Levi escreveu “Lendo Euclides” em 1947, e já nesta época era reconhecido na comunidade científica como alguém que formulou as bases do ensino claro e do respeito pela investigação científica, na qual deve prevalecer o rigor lógico. Seu objetivo era atrair a atenção dos leitores não matemáticos para o estudo dos conceitos fundamentais da geometria e da filosofia por meio da reflexão e da análise cuidadosa de Elementos. Neste livro não é o matemático profissional quem escreve, mas o estudioso que transmite sua paixão pela matemática, pela história e pela filosofia. Ao fazer essa leitura e vem a tona a reflexão de um diálogo que atravessa mais de vinte e dois séculos e permite aprender Euclides com olhos modernos. Os leitores terão a oportunidade de reaprender a geometria pelas mãos de um célebre matemático.

Beppo Levi nasceu em Turim, na Itália, em 1875. Doutorou-se em 1896, com apenas 21 anos e a partir de 1906 foi professor nas universidades de Cagliari, Parma e Bolonha. em 1938, devido à perseguição anti-semita do regime fascista de Mussolini, teve de emigrar com sua família. estabeleceu-se na cidade de Rosario, na Argentina, onde viveu até sua morte em 1961. Lá fundou o Departamento de Matemática da Universidad Nacional del Litoral – que hoje leva seu nome – e influenciou na formação de grandes cientistas argentinos.

Euclides dois mil anos depois

Entre diversas coisas, conjecturou e demonstrou que existem infinitos números primos (indivisíveis). Ganhou a vida dando aulas de matemática a curiosos, desejosos de aprender para saber, não para fazer. Conta a tradição que quando um aluno novato lhe perguntou que proveito material poderia obter com o estudo da matemática, Euclides teria chamado seu escravo e lhe teria dito: “Dê uma moeda de ouro a esse infeliz, já que ele pensa que deve ganhar para aprender”.

É muito possível que Euclides tenha estado conectado com o Museu de Alexandria, visto que nesse instituto estatal de investigações científicas e humanísticas se havia congregado a flor e a nata da intelectualidade da época. Os pesquisadores do Museu recebiam salários do tesouro real para produzir conhecimentos que raras vezes tinham aplicação prática. Só formavam e proviam cérebros curiosos e engenhosos, a começar pelos próprios. Quantos estadistas do nosso século entendem que o conhecimento básico é o mais útil, por ser utilizável em múltiplos campos?

A principal obra de Euclides, intitulada Elementos, é o livro antigo mais estudado da História. Reúne e sistematiza os conhecimentos geométricos de seu Tempo. Por isso já se disse que Euclides não foi original: apenas compilou invenções alheias. Os que repetem essa tese desconhecem que Euclides construiu a primeira teoria propriamente dita registrada pela História, o sistema Hipotético-Dedutivo. Antes dele, a matemática era um amontoado de resultados soltos; a partir dele, foi se convertendo em um conjunto de sistemas relacionados entre si.

Euclides introduziu explicitamente o formato (também chamado método) axiomático, que consiste em começar listando os conceitos básicos e os postulados – ou seja, ideias não deriváveis de outras ideias no mesmo sistema – e derivar (definir ou deduzir) os demais a partir deles.

A axiomática serve de parâmetro para a organização racional e econômica de qualquer corpo de conhecimentos, sejam matemáticos, físicos, econômicos, filosóficos ou outros. Spinoza, por exemplo, a utilizou em sua grande obra “Ética”. Hoje, os filósofos a empregam para esclarecer, sistematizar e provar ideias em qualquer ramo da filosofia.

David Hilbert, no final do século XIX, exaltou e advertiu para as virtudes da axiomática. Utilizou-a em matemática e em física, e a tornou seu cânone (Hilbert, 1918). Entre estas virtudes figuram as seguintes:

– economia
– aceleração da dedução
– facilitação do exame de coerência lógica
– esclarecimento de suposições
– individualização dos conceitos básicos ou primitivos (definidores) e busca de fundamentos cada vez mais profundos.

Essas virtudes tornam quase plausível a anedota segundo a qual Blaise Pascal, aos 14 anos, teria reconstruído por sua própria conta a maior parte da geometria euclidiana a partir de seus postulados.

No entanto, o método axiomático pode enganar, ao sugerir que basta um sistema de axiomas para deduzir todos os teoremas em um campo definido. De fato, salvo nos casos das consequências imediatas (corolários), é preciso agregar suposições, tais como construções, exemplos ou lemas (proposições tomadas de campos fronteiriços). Por exemplo para provar que a soma dos ângulos internos de um triângulo é igual a dois ângulos retos, convém começar traçando uma reta paralela a um dos lados. Outros teoremas euclidianos requerem outras construções (ad hoc) mais ou menos engenhosas. Talvez por esse motivo Einstein, já famoso e sempre muito ocupado, tenha se dado ao trabalho de escrever uma carta ao psicólogo Wertheimer expondo duas provas diferentes do teorema geométrico do antigo Menelau. [minha anotação: também Einstein trabalhando por muitos anos no escritório de patentes na Suiça, deve ter visto, lido, analisado centenas de tratados, teoremas, ideias, roteiros, etc].

Isso, junto com sua sistemática e seu rigor lógico, faz com que o estudo da geometria euclidiana seja possivelmente mais formativo do que o da geometria analítica ou o do cálculo infinitesimal. Essas teorias possuem algoritmos (regras) que podem se aplicar uniformemente e, em muitos casos, mecanicamente. Esse, além da inércia secular, é um dos motivos que os Elementos se tornou um dos livros mais difundidos em todo mundo durante dois milênios. Seu estudo exige tanto engenho e empenho quanto rigor. Forma tanto matemáticos quanto advogados.

A lógica da geometria de Euclides, em particular sua sistemática e coerência, continua suscitando admiração. Não causa surpresa que um matemático moderno como Beppo Levi lhe tenha dedicado um estudo profundo ainda que sem a carga erudita habitual. Nem é de se estranhar, também, que este livro do matemático ítalo-argentino desperte a curiosidade de leitores contemporâneos.

Beppo Levi (1875-1961) foi um matemático tão versátil como distinto. Mesmo tendo trabalhado principalmente com geometria algébrica, fez importantes incursões em outros campos, tais como a análise matemática, a teoria dos números, a teoria dos conjuntos, a lógica e a dialética da matemática. Semelhante universalidade é inconcebível hoje em dia, em parte porque se sabe muitíssimo mais, em parte porque se superestimam a especialização, sem reparar que as fronteiras entre as disciplinas são, em grande medida, artificiais.

Afirma-se que, entre 1897 e 1909, Levi participou ativamente em todos os novos desenvolvimentos da matemática da época (Schappacher e Schoof, 1996). Seu nome aparece associado, direta ou indiretamente, aos nomes de quase todos os grandes matemáticos de seu tempo, entre outros, Hilbert, Lebesgue e Poincaré. Além disso suas contribuições pertencem à pré-história de vários ramos da matemática que emergiram depois de Levi.

Entre outras coisas, Levi talvez tenha sido o primeiro a formular explicitamente e a criticar o axioma da escolha, usualmente atribuído a Zermelo (Moore, 1982). Descobriu que estava sendo utilizado tacitamente em muitas demonstrações matemáticas (tal axioma continua sendo motivo de estudos). Mas Levi é bem mais conhecido pelo lema que leva seu nome, e que se refere a integrais de sucessões monótonas de funções. Também é conhecido por seu estudo, mais importante, de singularidades de superfícies algébricas.

Ironicamente, esse grande homem tem sido considerado o matemático mais baixinho do século. Era corcunda, tinha uma voz estridente e era casado com uma mulher linda, com quem teve três filhos, entre eles Laura, a física da família. Embora Levi não tenha passado no exame de pureza racial, viveu muito mais anos, comportou-se muitíssimo melhor, concebeu e criou mais filhos e mais ideias que seu perseguidor.

A legislação anti-semita promulgada pelo governo fascista italiano em 1938 privou Levi de sua cátedra em Bolonha e o obrigou a emigrar junto com a família. Aos 64 anos de idade, recomeçou a vida: veio parar no ramo de Rosario da Universidade Nacional do Litoral. Isso se deveu à gestão de seu ilustrado reitor, o engenheiro Cortés Plá, e do matemático Julio Rey pastor, grande incentivador da ciência na Argentina e na Espanha.

Em sua nova Pátria, Levi fez um pouco de tudo. Deu cursos para estrangeiros; em 1940, fundou e dirigiu o Instituto de Matemática e sua revista , Mathematicae Notae; estimulou os poucos jovens que se interessavam pela Matemática pura; participou de reuniões de físicos; continuou cultivando as humanidades e inclusive encontrou tempo para responder algumas questões matemáticas formuladas por alunos e colaboradores.

Aprenderão com este livro a ver Euclides e inclusive seu mestre Platão, através dos olhos modernos.

Mario Bunge
Foundations and Philosophy of Science Unit
MCGill University, Montreal

Referências bibliográficas:

– Hilbert, D. “Axiomatisches Denken”, in Gesammelte Abhandlungen, vol. 3. Berlim: Julius Springer, 1918.

– Moore, G. E. Zermelo’s Axioms of Choice. Nova York: Springer-Verlag, 1982.

– Schappacher, N. e Schoof, R. “Beppo Levi and the arithmetic of elliptic curves”, in The Mathematical Intelligencer 18: 57-69, 1996.

adaptado por Gilberto dos Santos Alves
com base em livros e artigos da Biblioteca de São Paulo – agosto de 2013.

Princípios de reStructuredText 2011/02/01

Posted by gsavix in ciência colaborativa, colaboração na aquisição conhecimento, como gerar documentos a partir dos programas fonte, como publicar na internet gratuitamente, Conhecimento, Conhecimento para receber ou transferir tecnologia, Doc, gerador documentos, Memorando, metodologia para receber ou transferir conhecimento, noticiário genérico, política, publicação jornal internet, publicador documentação, sociologia do conhecimento, Soft.
add a comment

reStructuredText Princípios

Esta seção é uma breve introdução aos conceitos e sintaxe de reStructuredText (reST), e pretende prover escritores com informação suficiente para criar documentos de maneira produtiva. Desde que reST foi desenhado para ser uma linguagem de marcação simples e não obstrutiva. .. seealso:

A documentação autorizada sobre Uso de Documentação está em
`reStructuredText <http://docutils.sourceforge.net/rst.html>`_.
Este endereço "ref" traz a descrição individual das construções em reST.

Parágrafos

O parágrafo (ref) é o bloco básico num documento reST. Parágrafos são simples conjuntos de textos, separados por uma ou mais linhas em branco. Como em Python, a indentação tem significado em reST, então todas as linhas do mesmo parágrafo precisam estar alinhadas à esquerda com o mesmo nível de indentação.

marcação Inline

Uma marcação padrão inline em reST é bem simples e usa:

  • um asterisco: *text* para ênfase (itálico),
  • dois asteriscos: **text** para ênfase (negrito),
  • backquotes: ``text`` para exemplos de código.

Se os asteriscos ou backquotes aparecerem em textos e forem confundidos com delimitadores de marcadores inline, eles deverão ser desviados com backslash (barra invertida).

Esteja alerta sobre algumas restrições das marcações:

  • não podem ser aninhadas,
  • o conteúdo não pode começar ou terminar por espaço em branco: * text* é errado,
  • precisam ser separadas e envolvidas por texto por caracteres especiais. Use backslash (barra invertida com espaço em branco) para lidar com: thisis\ *one*\ word.

Estas restrições podem deixar de existir nas futuras versões do docutils.

reST também permite configuração “role textos interpretados”, o que significa que texto delimitado, pode ser interpretado de maneira específica. Sphinx usa isso para providenciar marcação semântica e de referência cruzada dos identificadores, como descrito nas seções apropriadas. A sintaxe genérica :rolename:`content`.

reST padrão contém as seguintes roles:

Veja Inline markup para roles adicionadas pelo Sphinx.

Listas e Blocos

List markup (ref) is natural: just place an asterisk at the start of a paragraph and indent properly. The same goes for numbered lists; they can also be autonumbered using a # sign:

* This is a bulleted list.
* It has two items, the second
  item uses two lines.

1. This is a numbered list.
2. It has two items too.

#. This is a numbered list.
#. It has two items too.

Nested lists are possible, but be aware that they must be separated from the parent list items by blank lines:

* this is
* a list

  * with a nested list
  * and some subitems

* and here the parent list continues

Definition lists (ref) are created as follows:

term (up to a line of text)
   Definition of the term, which must be indented

   and can even consist of multiple paragraphs

next term
   Description.

Note that the term cannot have more than one line of text.

Quoted paragraphs (ref) are created by just indenting them more than the surrounding paragraphs.

Line blocks (ref) are a way of preserving line breaks:

| These lines are
| broken exactly like in
| the source file.

There are also several more special blocks available:

  • field lists (ref)
  • option lists (ref)
  • quoted literal blocks (ref)
  • doctest blocks (ref)

Código Fonte

Literal code blocks (ref) are introduced by ending a paragraph with the special marker ::. The literal block must be indented (and, like all paragraphs, separated from the surrounding ones by blank lines):

This is a normal text paragraph. The next paragraph is a code sample::

   It is not processed in any way, except
   that the indentation is removed.

   It can span multiple lines.

This is a normal text paragraph again.

The handling of the :: marker is smart:

  • If it occurs as a paragraph of its own, that paragraph is completely left out of the document.
  • If it is preceded by whitespace, the marker is removed.
  • If it is preceded by non-whitespace, the marker is replaced by a single colon.

That way, the second sentence in the above example’s first paragraph would be rendered as “The next paragraph is a code sample:”.

Tables

Two forms of tables are supported. For grid tables (ref), you have to “paint” the cell grid yourself. They look like this:

+------------------------+------------+----------+----------+
| Header row, column 1   | Header 2   | Header 3 | Header 4 |
| (header rows optional) |            |          |          |
+========================+============+==========+==========+
| body row 1, column 1   | column 2   | column 3 | column 4 |
+------------------------+------------+----------+----------+
| body row 2             | ...        | ...      |          |
+------------------------+------------+----------+----------+

Simple tables (ref) are easier to write, but limited: they must contain more than one row, and the first column cannot contain multiple lines. They look like this:

=====  =====  =======
A      B      A and B
=====  =====  =======
False  False  False
True   False  False
False  True   False
True   True   True
=====  =====  =======

Sections

Section headers (ref) are created by underlining (and optionally overlining) the section title with a punctuation character, at least as long as the text:

=================
This is a heading
=================

Normally, there are no heading levels assigned to certain characters as the structure is determined from the succession of headings. However, for the Python documentation, this convention is used which you may follow:

  • # with overline, for parts
  • * with overline, for chapters
  • =, for sections
  • -, for subsections
  • ^, for subsubsections
  • ", for paragraphs

Of course, you are free to use your own marker characters (see the reST documentation), and use a deeper nesting level, but keep in mind that most target formats (HTML, LaTeX) have a limited supported nesting depth.

Explicit Markup

“Explicit markup” (ref) is used in reST for most constructs that need special handling, such as footnotes, specially-highlighted paragraphs, comments, and generic directives.

An explicit markup block begins with a line starting with .. followed by whitespace and is terminated by the next paragraph at the same level of indentation. (There needs to be a blank line between explicit markup and normal paragraphs. This may all sound a bit complicated, but it is intuitive enough when you write it.)

Directives

A directive (ref) is a generic block of explicit markup. Besides roles, it is one of the extension mechanisms of reST, and Sphinx makes heavy use of it.

Docutils supports the following directives:

  • Admonitions: attention, caution, danger, error, hint, important, note, tip, warning and the generic admonition. (Most themes style only “note” and “warning” specially.)
  • Images:
  • Additional body elements:
    • contents (a local, i.e. for the current file only, table of contents)
    • container (a container with a custom class, useful to generate an outer <div> in HTML)
    • rubric (a heading without relation to the document sectioning)
    • topic, sidebar (special highlighted body elements)
    • parsed-literal (literal block that supports inline markup)
    • epigraph (a block quote with optional attribution line)
    • highlights, pull-quote (block quotes with their own class attribute)
    • compound (a compound paragraph)
  • Special tables:
    • table (a table with title)
    • csv-table (a table generated from comma-separated values)
    • list-table (a table generated from a list of lists)
  • Special directives:
    • raw (include raw target-format markup)
    • include (include reStructuredText from another file) – in Sphinx, when given an absolute include file path, this directive takes it as relative to the source directory
    • class (assign a class attribute to the next element) [1]
  • HTML specifics:
    • meta (generation of HTML <meta> tags)
    • title (override document title)
  • Influencing markup:

    Since these are only per-file, better use Sphinx’ facilities for setting the default_role.

Do not use the directives sectnum, header and footer.

Directives added by Sphinx are described in Sphinx Markup Constructs.

Basically, a directive consists of a name, arguments, options and content. (Keep this terminology in mind, it is used in the next chapter describing custom directives.) Looking at this example,

.. function:: foo(x)
              foo(y, z)
   :module: some.module.name

   Return a line of text input from the user.

function is the directive name. It is given two arguments here, the remainder of the first line and the second line, as well as one option module (as you can see, options are given in the lines immediately following the arguments and indicated by the colons). Options must be indented to the same level as the directive content.

The directive content follows after a blank line and is indented relative to the directive start.

Images

reST supports an image directive (ref), used like so:

.. image:: gnu.png
   (options)

When used within Sphinx, the file name given (here gnu.png) must either be relative to the source file, or absolute which means that they are relative to the top source directory. For example, the file sketch/spam.rst could refer to the image images/spam.png as ../images/spam.png or /images/spam.png.

Sphinx will automatically copy image files over to a subdirectory of the output directory on building (e.g. the _static directory for HTML output.)

Interpretation of image size options (width and height) is as follows: if the size has no unit or the unit is pixels, the given size will only be respected for output channels that support pixels (i.e. not in LaTeX output). Other units (like pt for points) will be used for HTML and LaTeX output.

Sphinx extends the standard docutils behavior by allowing an asterisk for the extension:

.. image:: gnu.*

Sphinx then searches for all images matching the provided pattern and determines their type. Each builder then chooses the best image out of these candidates. For instance, if the file name gnu.* was given and two files gnu.pdf and gnu.png existed in the source tree, the LaTeX builder would choose the former, while the HTML builder would prefer the latter.

Alterado na versão 0.4: Added the support for file names ending in an asterisk.

Alterado na versão 0.6: Image paths can now be absolute.

Footnotes

For footnotes (ref), use [#name]_ to mark the footnote location, and add the footnote body at the bottom of the document after a “Footnotes” rubric heading, like so:

Lorem ipsum [#f1]_ dolor sit amet ... [#f2]_

.. rubric:: Footnotes

.. [#f1] Text of the first footnote.
.. [#f2] Text of the second footnote.

You can also explicitly number the footnotes ([1]_) or use auto-numbered footnotes without names ([#]_).

Citations

Standard reST citations (ref) are supported, with the additional feature that they are “global”, i.e. all citations can be referenced from all files. Use them like so:

Lorem ipsum [Ref]_ dolor sit amet.

.. [Ref] Book or article reference, URL or whatever.

Citation usage is similar to footnote usage, but with a label that is not numeric or begins with #.

Substitutions

reST supports “substitutions” (ref), which are pieces of text and/or markup referred to in the text by |name|. They are defined like footnotes with explicit markup blocks, like this:

.. |name| replace:: replacement *text*

or this:

.. |caution| image:: warning.png
             :alt: Warning!

See the reST reference for substitutions for details.

If you want to use some substitutions for all documents, put them into rst_prolog or put them into a separate file and include it into all documents you want to use them in, using the include directive. (Be sure to give the include file a file name extension differing from that of other source files, to avoid Sphinx finding it as a standalone document.)

Sphinx defines some default substitutions, see Substitutions.

Comments

Every explicit markup block which isn’t a valid markup construct (like the footnotes above) is regarded as a comment (ref). For example:

.. This is a comment.

You can indent text after a comment start to form multiline comments:

..
   This whole indented block
   is a comment.

   Still in the comment.

Source encoding

Since the easiest way to include special characters like em dashes or copyright signs in reST is to directly write them as Unicode characters, one has to specify an encoding. Sphinx assumes source files to be encoded in UTF-8 by default; you can change this with the source_encoding config value.

Gotchas

There are some problems one commonly runs into while authoring reST documents:

  • Separation of inline markup: As said above, inline markup spans must be separated from the surrounding text by non-word characters, you have to use a backslash-escaped space to get around that. See the reference for the details.
  • No nested inline markup: Something like *see :func:`foo`* is not possible.

Footnotes

[1] When the default domain contains a class directive, this directive will be shadowed. Therefore, Sphinx re-exports it as rst-class.

Chamando sphinx-build 2011/02/01

Posted by gsavix in ciência colaborativa, civilização, colaboração na aquisição conhecimento, como gerar documentos a partir dos programas fonte, como publicar na internet gratuitamente, Conhecimento, Conhecimento para receber ou transferir tecnologia, Doc, gerador documentos, língua portuguesa, Memorando, metodologia para receber ou transferir conhecimento, publicação jornal internet, publicador documentação, sociologia do conhecimento, Soft.
add a comment

Chamando sphinx-build

O script sphinx-build constrói um conjunto Sphinx de documentação. É chamado assim:

$ sphinx-build [opções] diretório-fonte diretório-documentos [arquivos]

onde diretório-fonte é diretório fonte, e and diretório-documentos é o diretório ou pasta onde será construída a documentação. Na maioria das vezes você não precisa especificar arquivos.

O script sphinx-build tem várias opções:

-b nome_do_construtor
É a opção mais importante: pois seleciona o tipo de construção. Os tipos mais comuns são:

html
Páginas HTML. É o construtor padrão.
dirhtml
Páginas HTML, mas um diretório para cada documento. Gera simples URLs (sem .html usado em muitos webserver).
singlehtml
Um único arquivo HTML, com todo o conteúdo.
htmlhelp, qthelp, devhelp, epub
Arquivos HTML, com informações específicas e adicionais para construir coleção de documentação para estes formatos.
latex
Constrói fontes LaTeX, que se compilados podem gerar documento PDF. utiliza para isso o programa pdflatex.
man
Contrói páginas no formato groff (man em sistemas UNIX).
text
Constrói arquivos texto.
doctest
Executa todos os doctests na documentação, se a extensão doctest foi habilitada.
linkcheck
Verifica a integridade de todos links externos.

Veja construtores para uma lista de todos construtores enviados com o Sphinx. Extensões podem adicionar seus próprios construtores.

-a
Se informada, sempre irá gravar todos os tipos de arquivos. O padrão é só gerar saída para arquivos novos ou fontes modificados. (Isto pode não se aplicar a todos os construtores).

-E
Don’t use a saved environment (the structure caching all cross-references), but rebuild it completely. The default is to only read and parse source files that are new or have changed since the last run.

-t alvo
Define o alvo alvo. Isto é relevante para diretivas only que só incluem seu conteúdo se o alvo foi habilitado.

Novo na versão 0.6.

-d caminho
Since Sphinx has to read and parse all source files before it can write an output file, the parsed source files are cached as “doctree pickles”. Normally, these files are put in a directory called .doctrees under the build directory; with this option you can select a different cache directory (the doctrees can be shared between all builders).

-c path
Don’t look for the conf.py in the source directory, but use the given configuration directory instead. Note that various other files and paths given by configuration values are expected to be relative to the configuration directory, so they will have to be present at this location too.

Novo na versão 0.3.

-C
Don’t look for a configuration file; only take options via the -D option.

Novo na versão 0.5.

-D setting=value
Override a configuration value set in the conf.py file. The value must be a string or dictionary value. For the latter, supply the setting name and key like this: -D latex_elements.docclass=scrartcl. For boolean values, use 0 or 1 as the value.

Alterado na versão 0.6: The value can now be a dictionary value.

-A name=value
Make the name assigned to value in the HTML templates.

Novo na versão 0.5.

-n
Run in nit-picky mode. Currently, this generates warnings for all missing references.

-N
Do not emit colored output. (On Windows, colored output is disabled in any case.)

-q
Do not output anything on standard output, only write warnings and errors to standard error.

-Q
Do not output anything on standard output, also suppress warnings. Only errors are written to standard error.

-w arquivo
Grave avisos (warnings e errors) para cada arquivo, em adição ao padrão de erros.

-W
Trate avisos (warnings) como erros. Isto significa que o construtor irá parar ao primeiro erro e o sphinx-build termina com status de saída 1.

-P
(Useful for debugging only.) Run the Python debugger, pdb, if an unhandled exception occurs while building.

You can also give one or more filenames on the command line after the source and build directories. Sphinx will then try to build only these output files (and their dependencies).

Opções do Makefile

Os arquivos Makefile e make.bat são criados pelo programa sphinx-quickstart normalmente executado sphinx-build só com as opções -b e -d. Contudo, são suportadas as seguintes variáveis com suas descrições:

PAPER
O valor para latex_paper_size.

SPHINXBUILD
O comando para usar ao invés de sphinx-build.

BUILDDIR
O diretório onde será construído, ao invés do escolhido pelo sphinx-quickstart.

SPHINXOPTS
Opções adicionais para o programa sphinx-build.

 

© Copyright 2011, Biblioteca Nuto Santana e outros. Criado com Sphinx 1.0.7

Primeiros passos com o Sphinx 2011/02/01

Posted by gsavix in ciência colaborativa, colaboração na aquisição conhecimento, como gerar documentos a partir dos programas fonte, como publicar na internet gratuitamente, Computadores, Conhecimento para receber ou transferir tecnologia, Doc, Memorando, metodologia para receber ou transferir conhecimento, publicação jornal internet, publicador documentação, sociologia do conhecimento, Soft.
Tags: , , , , , ,
add a comment

Primeiros passos com Sphinx

Esse documento é para permitir uma visão como um tutorial, nas tarefas mais comuns no uso do Sphinx.

A seta verde designa “mais informações”, através de ligações para seções avançadas descrevendo a tarefa.

Configurando fontes da documentação

O diretório ou pasta raiz, da coleção tem o nome de source directory. Nele também está o arquivo de configuração Sphinx conf.py, onde você pode configurar todos os aspectos, sobre como o Sphinx faz a leitura dos seus fontes e constrói sua documentação. [1]

O Sphinx vem com um script chamado sphinx-quickstart que configura on diretório ou pasta fonte, além de criar um arquivo padrão chamado conf.py com as opções mais comuns, a partir de poucas perguntas feitas para você. Apenas execute:

$ sphinx-quickstart

e responda as perguntas. (Certifique-se de responder yes para a extensão “autodoc”.)

Definindo a estrutura do Documento

Vamos assumir que você já executou sphinx-quickstart. Foi criado um diretório ou pasta contendo o arquivo conf.py e um arquivo com documento mestre index.rst (se você aceitou os padrões). A função principal do master document é servir como página de boas vindas, e conter a raiz da TOC (tabela de Conteúdos) ou (toctree). Isto é uma das principais coisas que o Sphinx adiciona ao reStructuredText, (RST) uma maneira de conectar múltiplos arquivos em uma hierarquia única hierarquia de documentos.

Diretivas reStructuredText

toctree é uma directiva de reStructuredText, uma peça versátil de markup. Diretivas podem conter argumentos, opções e conteúdo.

Argumentos são fornecidos diretamento após (dois pontos) seguidos pelo name da diretiva. Cada diretiva decide quando e quantos argumentos pode ter.

Opções são fornecidas após os argumentos, na forma de “lista de campos”. O maxdepth é uma opção para a diretiva toctree.

Conteúdo seguindo Argumentos ou Opções após uma linha em branco. Cada diretiva decide quando pode haver conteúdo e o que fazer com ele.

Uma pegadinha com diretivas é que a primeira linha do conteúdo precisa estar “indentada” (ou alinhada) à mesma coluna onde a opção está.

A diretiva toctree inicialmente está vazia, e parece com:

.. toctree::
   :maxdepth: 2

Você adiciona documentos na lista, preenchendo o Conteúdo da diretiva:

.. toctree::
   :maxdepth: 2

   intro
   tutorial
   ...

É exatamente assim que toctree para documentação parece. Os documentos para incluir são colocados como nome do documento, os quais de maneira resumida, significa que você não quis informar as extensão do arquivo, e vai utilizar a barra como separador de diretórios ou pastas.

more Leia mais sobre Diretiva toctree.

Você pode criar os arquivos que você inseriu em toctree e adicionar conteúdo, e os títulos deles serão inseridos até o nível especificado por “maxdepth” da diretiva toctree. Agora, o Sphinx sabe a ordem e a hierarquia dos documentos, os quais podem conter diretivas toctree neles mesmos, o que significa que você pode especificar várias hierarquias subordinadas se necessário.

Adicionando conteúdo

Em arquivos fonte Sphinx, você pode usar muitas funcionalidades padrão de (RST) reStructuredText. Além destas, existem outros adicionadas pelo Sphinx. Por exemplo, você pode adicionar referências cruzadas entre arquivos, de uma maneira portável (pois funcionam para todos os tipos de saída), através de ref role.

Por exemplo, se você está vendo a versão HTML, você pode dar uma olhada na fonte do documento – usando o link “Exibir Código Fonte” na barra lateral.

more Veja reStructuredText Princípios para maiores detalhes ao reStructuredText e marcas_sphinx para uma lista completa de marcações adicionadas pelo Sphinx.

Rodando o build

Agora que você adicionou alguns arquivos e conteúdos, vamos fazer nosso primeiro “build” (construir) dos documentos. A construção é iniciada com o programa sphinx-build, o qual é chamado como:

$ sphinx-build -b html diretório_fonte diretório_construído

onde diretório-fonte é onde estão seus arquivos reStructuredText e o diretório_construído é o diretório ou pasta onde você deseja colocar a documentação construída. A opção -b seleciona o construtor; nesse exemplo Sphinx irá construir arquivos HTML.

mais informações Veja chamada para todas as opções que o programa sphinx-build permite.

Contudo, o script sphinx-quickstart cria um arquivo a Makefile e um arquivo make.bat que tornam a vida mais fácil para você, pois para criar a documentação você só precisa escrever:

$ make html

para construir docs HTML no diretório que você escolheu. Execute make sem argumento para ver quais possibilidades estão disponíveis.

Documentando objetos

Um dos principais objetivos do Sphinxs, é a documentação fácil de objetos objetos (em termos gerais) em qualquer domínio. Um domínio é uma coleção de tipos de objetos, que juntos com marcas, criam e referenciam descrições a estes objetos.

O domínio mais importante é o Python. Por ex.: a função interna enumerate(), você pode adicionar isto aos seus arquivos fonte:

.. py:function:: enumerate(sequence[, start=0])

   Retorna um iterator que aponta tuples de um índice e um item de
   *sequência*. (E assim sucessivamente.)

Isso é renderizado (deduzido) como:

enumerate(sequence[, start=0])
Retorna um iterator que aponta tuples de um índice e um item de
sequência. (E assim sucessivamente.)

O argumento da diretiva é a assinatura do objeto que você descreve, o conteúdo é a documentação dele. Múltiplas assinaturas podem ser dadas, cada uma em sua linha.

O domínio Python também ocorre como domínio padrão, portanto você não precisa colocar o prefixo de marcação no nome do domínio:

.. function:: enumerate(sequence[, start=0])

   ...

faz o mesmo se você manter a configuração padrão para domínio.

Existem muitos outras diretivas para documentar outros tipos de objetos Python, por exemplo: py:class or py:method. Existe também uma definição de referência cruzada role para cada um desses objetos. Essa marcação irá criar uma ligação em enumerate():

A função :py:func:`enumerate` pode ser usada para ...

E aqui a prova: Um link para enumerate().

Recapitulando, o prefixo py: pode ser omitido para o domínio Python pois é o padrão. Não importa qual arquivo contem a documentação para enumerate(); O Sphinx irá encontrar e criar um link para este arquivo.

Cada domínio terá regras especiais para como são as assinaturas e fazer a saída formatada aparecer bem formatada ou adicionar funcionalidades como ligação para tipos de parâmetros, ex. em domínios C/C++.

more Veja domínios para todas as diretivas e roles disponíveis.

Configurações básicas

Anteriormente mencionamos que o arquivo conf.py controla como o Sphinx processa seus documentos. Quando este arquivo, é executado como um fonte Python, você assinala cada um dos valores, nele existentes. Para usuários avançados: deste que executado pelo Sphinx, você pode executar tarefas não triviais, a partir deste arquivo, como extensão sys.path our importar um módulo para encontrar a versão que você está documentando. Os valores configurados que você provavelmente deseja modificar, já foram gravados no arquivo conf.py pelo sphinx-quickstart e inicialmente definidos como comentários com a sintaxe padrão Python # torna comentário o resto da linha. Para modificar o valor padrão, remova o # e modifique o conteúdo da variável para o valor desejado. Para personalizar um valor que não foi automaticamente adicionado pelo programa sphinx-quickstart, apenas faça um assinalamente adicional.

Tenha em mente que o arquivo utiliza sintaxe do Python para strings, números, listas e assim por diante. O arquivo é salvo em unicode UTF-8 por padrão como indicado pela declaração de codificação da primeira linha. Se você usar caracteres não ASCII em qualquer valor de string, você precisa utilizar Python Unicode (como project = u'Exposé').

mais informações Veja Arquivo de configuração do build para documentação de todos os valores disponíveis.

Autodoc

Quando documentar código Python, é comum colocar um monte de documentação nos arquivos fonte, em strings de documentação. Sphinx suporta a inclusão de docstrings a partir de seus módulos com uma extensão (uma extensão é um módulo Python que provê funcionalidades adicionais para os projetos Sphinx) chamada “autodoc”.

Para utilizar autodoc, você precisa ativar esta extensão no arquivo conf.py colocando a string 'sphinx.ext.autodoc' na lista assinalada contendo extensions. Então você terá mais diretivas à sua disposição.

Por exemplo, para documentar a função io.open(), lendo sua assinatura e a docstring do arquivo fonte, você escreverá:

.. autofunction:: io.open

Você também pode documentar todas as classes ou mesmo todos os módulos, automáticamente usando as opções de membros para diretivas auto, ficando assim:

.. automodule:: io
   :members:

autodoc precisa importar seus módulos para extrair as docstrings. Todavia, você precisar adicionar o caminho correto para sys.path no seu arquivo conf.py.

mais informações Veja sphinx.ext.autodoc para descrição completa para funcionalidades autodoc.

Mais tópicos serão cobertos

  • Outras extensões (math, intersphinx, viewcode, doctest)
  • Arquivos Státicos
  • Selecionando um tema
  • Modelos (Templating)
  • Usando extensions
  • Escrevendo extensões

Notas de Rodapé

[1] Essa é a formatação usual. Contudo, o arquivo conf.py pode também estar em outro diretório ou pasta, o diretório de configuração. Veja Chamando sphinx-build.