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.

boletim nuto santana – machado de assis 2011/04/11

Posted by gsavix in biblioteca pública wireless, civilização, classes de documentação web html, colaboração na aquisição conhecimento, como gerar documentos a partir dos programas fonte, como publicar na internet gratuitamente, Conhecimento para receber ou transferir tecnologia, construtores de classe do documentos web, construtores de documentação, gerador documentos, língua portuguesa, machado de assis, notícias interesse público, publicação jornal internet, publicador documentação.
add a comment

A finalidade deste artigo é apresentar quais são os livros que estão na biblioteca pública nuto santana, que fica aqui em são paulo – brasil – e possui muitos dos livros desse importante autor brasileiro.

Se você deseja fazer seu trabalho escolar ou pesquisa e usar alguns dos livros saiba que é só fazer sua carteirinha gratuitamente na biblioteca e retirar o livro para sua pesquisa ou trabaho sem nenhum custo. de graça. gratuito.

veja a lista das obras que estão do sistema da biblioteca e só aqui você tem a lista que pode ser encontrada facilmente pelos buscadores google, yahoo, bing, ask etc.

 

baixe o arquivo contendo o pdf para melhorar sua pesquisa:

 

MachadodeAssisNutoSanabril2011

 

você também pode acessar esta versão para seu dispositivo móvel independente de versão de sistema operacional.

Protótipo Boletim Novos Títulos 2011/02/23

Posted by gsavix in biblioteca pública wireless, classes de documentação web html, colaboração na aquisição conhecimento, como gerar documentos a partir dos programas fonte, como publicar na internet gratuitamente, Conhecimento para receber ou transferir tecnologia, construtores de classe do documentos web, construtores de documentação, gerador documentos, língua portuguesa, Memorando, metodologia para receber ou transferir conhecimento, publicação jornal internet, publicador documentação, www.auvix.com.br.
1 comment so far

Boletim Biblioteca Pública Nuto Santana – São Paulo – SP — Boletim Nuto Santana fev/2011 – Sphinx




Suporte a Temas em HTML (CSS) 2011/02/01

Posted by gsavix in biblioteca pública wireless, classes de documentação web html, 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, construtores de documentação, Doc, língua portuguesa, Memorando, metodologia para receber ou transferir conhecimento, notícias interesse público, publicação jornal internet, publicador documentação, Sistemas Computacionais, sociologia do conhecimento, Soft.
add a comment

Suporte a Temas em HTML

Novo na versão 0.6.

Sphinx suporta a mudança na aparência dos HTML gerados, através da funcionalidade chamada tema. Tema é uma coleção de modelos de folhas de estilo (CSS) além de outros tipos de arquivos estáticos. Adicionalmente, pode haver a configuração de arquivos que podem ter seu tema herdado de outro tema, permitindo utilizar várias opções de aparência e comportamento.

Temas podem ser desvinculados de projetos, podendo ser utilizados de maneira diferente em cada um deles, sem sofrer mudanças.

Usando um tema

Usar um tema existente é fácil. Se o tema já veio com o Sphinx, você só precisa configurar html_theme para o valor desejado.Com valor de html_theme_options você escolhe opções de aparência e comportamento. Por exemplo, você pode ter o seguinte em seu arquivo conf.py:

html_theme = "default"
html_theme_options = {
    "rightsidebar": "true",
    "relbarbgcolor": "black"
}

Isto irá dar a você o tema padrão, mas com uma barra lateral à direita e uma barra de relação ( a barra de navegação das ligações no topo e no rodapé) na cor preta.

Se o tema não veio com o Sphinx, ele pode ser em duas formas: um diretório contendo o arquivo theme.conf e outros arquivos necessários, ou um arquivo zip com os mesmos conteúdos. Qualquer um deles pode ser colocado onde o Sphinx pode encontrá-los; para isso pode ser usado o valor de configuração html_theme_path. Ele dá uma lista de diretórios, relativos ao diretório contendo o arquivo conf.py, os quais podem conter temas ou arquivos zip. Por exemplo, se você tem um tema em um arquivo blue.zip, você pode colocá-lo no arquivo conf.py e usar esta configuração:

html_theme = "blue"
html_theme_path = ["."]

Temas Internos

Visão Temas
default 

default

sphinxdoc 

sphinxdoc

scrolls 

scrolls

agogo 

agogo

traditional 

traditional

nature 

nature

haiku 

haiku

O Sphinx vem com uma seleção de temas que você pode usar.

Estes temas são:

  • basic – Essa é a formatação sem estilo usada como base para outros temas, e utilizável como base para outros temas configuráveis também. O HTML contém todos os elementos importantes como barras laterais e barras de relação. Tem uma opção (a qual é herdada por outros temas):
    • nosidebar (verdadeiro ou falso): Não inclui a barra lateral. Padrão é falso.
  • default – Este é o tema padrão,o qual parece com Documentação Python em <http://docs.python.org/>`_. Pode ser personalizado através destas opções:
    • rightsidebar (verdadeiro ou falso): Barra lateral do lado direito. Padrão é Falso.
    • stickysidebar (verdadeiro ou falso): Barra lateral ser fixa, ela não rola para fora da visão para conteúdos longos. Isto pode não funcionar bem para todos os navegadores. Padrão é falso.
    • collapsiblesidebar (true or false): Add an experimental JavaScript snippet that makes the sidebar collapsible via a button on its side. Doesn’t work together with “rightsidebar” or “stickysidebar”. Defaults to false.
    • externalrefs (true or false): Display external links differently from internal links. Defaults to false.

    There are also various color and font options that can change the color scheme without having to write a custom stylesheet:

    • footerbgcolor (CSS color): Background color for the footer line.
    • footertextcolor (CSS color): Text color for the footer line.
    • sidebarbgcolor (CSS color): Background color for the sidebar.
    • sidebarbtncolor (CSS color): Background color for the sidebar collapse button (used when collapsiblesidebar is true).
    • sidebartextcolor (CSS color): Text color for the sidebar.
    • sidebarlinkcolor (CSS color): Link color for the sidebar.
    • relbarbgcolor (CSS color): Background color for the relation bar.
    • relbartextcolor (CSS color): Text color for the relation bar.
    • relbarlinkcolor (CSS color): Link color for the relation bar.
    • bgcolor (CSS color): Body background color.
    • textcolor (CSS color): Body text color.
    • linkcolor (CSS color): Body link color.
    • visitedlinkcolor (CSS color): Body color for visited links.
    • headbgcolor (CSS color): Background color for headings.
    • headtextcolor (CSS color): Text color for headings.
    • headlinkcolor (CSS color): Link color for headings.
    • codebgcolor (CSS color): Background color for code blocks.
    • codetextcolor (CSS color): Default text color for code blocks, if not set differently by the highlighting style.
    • bodyfont (CSS font-family): Font for normal text.
    • headfont (CSS font-family): Font for headings.
  • sphinxdoc – The theme used for this documentation. It features a sidebar on the right side. There are currently no options beyond nosidebar.
  • scrolls – A more lightweight theme, based on the Jinja documentation. The following color options are available:
    • headerbordercolor
    • subheadlinecolor
    • linkcolor
    • visitedlinkcolor
    • admonitioncolor
  • agogo – A theme created by Andi Albrecht. The following options are supported:
    • bodyfont (CSS font family): Font for normal text.
    • headerfont (CSS font family): Font for headings.
    • pagewidth (CSS length): Width of the page content, default 70em.
    • documentwidth (CSS length): Width of the document (without sidebar), default 50em.
    • sidebarwidth (CSS length): Width of the sidebar, default 20em.
    • bgcolor (CSS color): Background color.
    • headerbg (CSS value for “background”): background for the header area, default a grayish gradient.
    • footerbg (CSS value for “background”): background for the footer area, default a light gray gradient.
    • linkcolor (CSS color): Body link color.
    • headercolor1, headercolor2 (CSS color): colors for <h1> and <h2> headings.
    • headerlinkcolor (CSS color): Color for the backreference link in headings.
    • textalign (CSS text-align value): Text alignment for the body, default is justify.
  • nature – A greenish theme. There are currently no options beyond nosidebar.
  • haiku – A theme without sidebar inspired by the Haiku OS user guide. The following options are supported:
    • full_logo (true or false, default false): If this is true, the header will only show the html_logo. Use this for large logos. If this is false, the logo (if present) will be shown floating right, and the documentation title will be put in the header.
    • textcolor, headingcolor, linkcolor, visitedlinkcolor, hoverlinkcolor (CSS colors): Colors for various body elements.
  • traditional – A theme resembling the old Python documentation. There are currently no options beyond nosidebar.
  • epub – A theme for the epub builder. There are currently no options. This theme tries to save visual space which is a sparse resource on ebook readers.

Criando temas

Como foi dito, temas podem ser diretórios ou arquivos zip (cujo nome é o nome tema), contendo o seguinte:

  • Um arquivo theme.conf veja abaixo,
  • Modelos HTML, se necessário.
  • Um diretório static/ contento qualquer arquivos estáticos, que serão copiados para o diretório estático de saída (diretório de build). Podem ser imagens, folhas de estilo, scripts, etc.

O arquivo theme.conf tem formato de INI [1] (legível inclusive pelo módulo Python ConfigParser) e tem a seguinte estrutura:

[theme]
inherit = base theme
stylesheet = main CSS name
pygments_style = stylename

[options]
variable = default value
  • inherit fornece o nome do tema básico “base theme”, ou none. O tema básico irá ser usado para localizar modelos inexistentes ( muitos temas não conseguem suprir outros modelos se eles usam basic como tema básico), estas opções serão herdadas e todos seus arquivos estáticos também.
  • stylesheet fornece o nome do arquivo CSS que será referenciado no header do HTML gerado. Se você preceisa mais de um CSS, inclua o segundo a partir do primeiro usando CSS’ @import, ou utilize um modelo de HTML que adiciona a ligação <link rel="stylesheet"> e as tags necessárias. Configurando o valor html_style irá sobrepor esta configuração.
  • pygments_style fornece o nome do estilo de “Pygments” que deverá ser usado para enfatizar as cores. Configurando o valor pygments_style irá sobrepor esta configuração.
  • A seção options contém pares de nome de variáveis e valores. Estas opções podem ser sobrepostas pelo usuário através de html_theme_options e são acessíveis a partir de todos os modelos como theme_<name>.

Modelos

O guia para modelos css guide to templating ajuda se você deseja escrever seu próprio modelo. O que é importante ter em mente é a ordem na qual o Sphinx procura por modelos (templates):

  • Primeiro, nos diretórios modelos do usuário templates_path.
  • Depois, no tema selecionado.
  • Após, em seus temas internos, Sphinx tema básico, etc.

Quando estender um modelo de tema, com o mesmo nome, use o nome do tema como um nome de diretório explícito: {% extends "basic/layout.html" %}. A partir de um modelo de usuário templates_path, você pode usar o “ponto de exclamação” como na sintaxe descrita no documento de modelo.

Modelos Estáticos

Temas foram criados para facilitar, o usuário em configurar aparência da documentação sem precisar escrever uma folha de estilos. É necessário um tema modelo bem como arquivos HTML. Entretanto o Sphinx suporta o que é chamado de “modelos estáticos” como segue:

Se o nome do arquivo está em um diretório de temas static/ ou em um caminho estático (terminado por _t), irá ser processado pelo motor de modelos. O _t irá ser deixado no final do nome do arquivo. Por ex: o tema padrão default é um arquivo static/default.css_t o qual usa um modelo para colocar cores em uma folha de estilo (css). Quando a documentação for construída com o tema padrão, o diretório de saída irá conter um arquivo _static/default.css onde os alvos (tags) já foram tratadas.

[1] Ele não é um arquivo Python executável, em oposição ao arquivo conf.py, pois pode expor a risco de segurança desnecessário já que é compartilhado.

Contrutores disponíveis¶ 2011/02/01

Posted by gsavix in biblioteca pública wireless, classes de documentação web html, 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, construtores de classe do documentos web, construtores de documentação, Doc, gerador documentos, Memorando, metodologia para receber ou transferir conhecimento, publicação jornal internet, publicador documentação, Sistemas Computacionais, sociologia do conhecimento.
add a comment

Contrutores disponíveis

Estas são as classes de construtores internas do Sphinx. Mais construtores (Builders) podem ser adicionadas através extensões.

O nome do construtor precisa ser dado para a opção -b da linha de comando do sphinx-build para o construtor selecionado.

class sphinx.builders.html.StandaloneHTMLBuilder
Este é o construtor padrão de HTML. Sua saida é um diretório ou pasta com arquivos HTML, completados com folhas de estilos (CSS) e opcionalmente fontes de arquivos (reST). Existem poucos valores para escolher as opções desejadas neste construtor, veja o capítulo Opções para Saída HTML para detalhes.

Seu nome é html.

class sphinx.builders.html.DirectoryHTMLBuilder
Esta é uma subclasse do construtor HTML. Sua saida é um diretório contendo arquivos HTML, onde cada arquivo é chamado index.html e colocado em um subdiretório ou subpasta com nome igual ao do nome da página. Por exemplo: O documento markup/rest.rst não irá resultar em um arquivo markup/rest.html, mas markup/rest/index.html. Quando gerando ligações entre as páginas, o index.html é omitido, então aquela URL parecerá com markup/rest/.

Seu nome é dirhtml.

Novo na versão 0.6.

class sphinx.builders.html.SingleFileHTMLBuilder
Esse é um construtor HTML que combina todo o projeto em um único arquivo. (Obviamente isso só funciona para pequenos projetos.) O arquivo é nomeado como documento mestre. Não é gerado índice.

Seu nome é singlehtml.

Novo na versão 1.0.

class sphinx.builders.htmlhelp.HTMLHelpBuilder
Esse construtor produz a mesma saída que o construtor HTML, mas também cria arquivos de suporte Help HTML, que permitem que o Microsoft HTML Help Workshop, compile-os em um arquivo (CHM).

Seu nome é htmlhelp.

class sphinx.builders.qthelp.QtHelpBuilder
Esse construtor produz a mesma saída que o construtor HTML, mas também cria uma coleção de arquivos de suporte Qt help que permitem ao gerador de coleção Qt compilá-los.

Seu nome é qthelp.

class sphinx.builders.devhelp.DevhelpBuilder
Esse construtor produz a mesma saída padrão HTML, mas também cria GNOME Devhelp suporte arquivo que permite ao leitor GNOME Devhelp enxergá-los.

Seu nome é devhelp.

class sphinx.builders.epub.EpubBuilder
Esse construtor produz a mesma saída que o construtor HTML, mas também cria um arquivo epub para leitores de ebook. Veja Epub info para detalhes sobre ele. Para o formato das definições de epub olhe em http://www.idpf.org/specs.htm ou http://en.wikipedia.org/wiki/EPUB.

Alguns leitoros ebook não exibem os alvos das ligações de referência, entretanto este construtor adiciona os alvos, após as ligações quando necessário. A exibição de URLs pode ser personalizada através de regras CSS para a classe link-target.

Seu nome é epub.

class sphinx.builders.latex.LaTeXBuilder
Esse construtor produz um conjunto de arquivos LaTeX em um diretório de saída. Você deve especificar quais documentos serão incluídos nos arquivos LaTeX através do valor latex_documents. Existem alguns valores que podem ser personalizados para esse construtor, veja o capítulo Options for LaTeX output para mais detalhes.

Nota

A produção de arquivo LaTeX utiliza vários pacotes LaTeX que podem não estarem presentes em uma distribuição “mínima”. Para TeXLive, os seguintes pacotes precisam estar instalados:

  • latex-recommended
  • latex-extra
  • fonts-recommended

Seu nome é latex.

Note que um construtor direto PDF usando ReportLab está disponível em rst2pdf versão 0.12 ou maior. Pode ser necessário adicionar 'rst2pdf.pdfbuilder' para seu extensions para habilitá-lo, seu nome é pdf. Veja o manual rst2pdf manual para detalhes.

class sphinx.builders.text.TextBuilder
Esse construtor produz um arquivo de texto para cada arquivo reST – isto é o mesmo que a fonte reST, porém com várias marcações eliminadas para melhor legibilidade.

Seu nome é text.

Novo na versão 0.4.

class sphinx.builders.manpage.ManualPageBuilder
Esse construtor produz páginas de manual no formato groff. Você precisa especificar quais documentos serão incluídos nas páginas do manual através do valor de configuração man_pages.

Seu nome é man.

Nota

Esse construtor requer o gerador de páginas man docutils, e está disponível na versão 0.6 do docutils.

Novo na versão 1.0.

class sphinx.builders.html.SerializingHTMLBuilder
Esse construtor usa um módulo que implementa a API de serialização Python (pickle, simplejson, phpserialize e outras) para dar saída a documanetação gerada. O construtor pickle é uma subclasse dele.

Uma subclasse concreta desse construtor de serialização é a PHP serialization cujo formato é esse:

import phpserialize

class PHPSerializedBuilder(SerializingHTMLBuilder):
    name = 'phpserialized'
    implementation = phpserialize
    out_suffix = '.file.phpdump'
    globalcontext_filename = 'globalcontext.phpdump'
    searchindex_filename = 'searchindex.phpdump'
implementation
Um módulo que implementa funções dump(), load(), dumps() e loads() que tem os mesmos nomes conforme o módulo pickle. Módulos conhecidos na implementação desse interface são`simplejson` (ou json em Python 2.6), phpserialize, plistlib e outros.

out_suffix
O sufixo para arquivos normais.

globalcontext_filename
O nome de arquivo que contém “contexto global”. Esse é um dict (dicionário) contendo valores das configurações gerais, como por exemplo o nome do projeto.

searchindex_filename
O nome do arquivo para pesquisa do índice, que será gerado pelo Sphinx.

Veja Detalhes sobre Construtores de Serialização para detalhes sobre o formato da saída.

Novo na versão 0.5.

class sphinx.builders.html.PickleHTMLBuilder
Esse construtor produz um diretório ou pasta contendo arquivos pickle contendo fragmentos de HTML e informação sobre (TOC tabela de conteúdo), para uso com uma aplicação web ou ferramento para pós-processamento, a qual não usa os modelos de HTML padrão. Veja Detalhes sobre Construtores de Serialização para detalhes sobre o formato da saída.

Seu nome é pickle. (O nome antigo web também funciona.)

O sufixo de arquivo é .fpickle. O contexto global é chamado globalcontext.pickle, e o índice de pesquisa searchindex.pickle.

class sphinx.builders.html.JSONHTMLBuilder
Esse construtor produz um diretório com arquivos JSON, contendo fragmentos HTML e informações TOC, para uso em aplicação web (ou configurado para ferramentas de pósprocessamento) que não utiliza templates padrões HTML.

Veja Detalhes sobre Construtores de Serialização para detalhes sobre o formato da saída.

Seu nome é json.

O sufixo do arquivo é .fjson. O contexto global é chamado globalcontext.json, o índice searchindex.json.

Novo na versão 0.5.

class sphinx.builders.changes.ChangesBuilder
Esse construtor produz HTML com visão de todas as diretivas novidades da versão, versionadded e com as tornadas obsoletas deprecated na versão corrente version. Isto é utilizado para atualizar um arquivo registro de modificações “ChangeLog”, por exemplo.

Seu nome é: changes.

class sphinx.builders.linkcheck.CheckExternalLinksBuilder
Esse construtor procura em todos os documentos para ligações externas e tenta abrir, utilizando o módulo urllib2, e grava informações sobre quais estão quebradas para a saída padrão e para um arquivo chamado output.txt no diretório de saída.

Seu nome é linkcheck.

Extensões nativas (Built-in) do Sphinx que oferencem mais construtores são:

Detalhes sobre Construtores de Serialização

Todos os construtores de serialização gravam um arquivo para cada arquivo fonte e alguns arquivos especiais. Eles também copiam os arquivos fonte reST para o diretório ou pasta _sources sob o diretório ou pasta de saída.

A PickleHTMLBuilder é uma subclasse que implementa o interface de serialização.

Os arquivos do arquivo fonte têm a extensão out_suffix e são organizados em diretórios ou pastas assim como os arquivos fontes estão. Eles são revertidos para um dicionário (estrutura como um dicionário) com estas chaves:

body
O HTML “body” (isto é, o HTML deduzido do arquivo fonte), é renderizado pelo tradutor HTML.
title
O título do documento, como HTML (pode conter markup).
toc
A tabela de conteúdos do arquivo, é renderizada como um HTML <ul>.
display_toc
Um booleano que é True se o toc contém mais de uma entrada.
current_page_name
O nome do documento do arquivo corrente.
parents, prev and next
Informação sobre capítulos relacionados à árvore TOC. Cada relação é um dicionário com as chaves link (HREF para a relação) e title (título do documento relacionado, como HTML). parents é a lista das relações, enquanto prev e next são relações simples.
sourcename
O nome do arquivo fonte sob _sources.

Os arquivos especiais estão localizados no diretório ou pasta de saída. São:

SerializingHTMLBuilder.globalcontext_filename
Um dicionário pickled com as chaves:

project, copyright, release, version
Os mesmos valores informados no arquivo de configuração.
style
html_style.
last_updated
Data da última geração.
builder
Nome do construtor utilizado, no caso de pickles será sempre 'pickle'.
titles
Um dicionário de todos os documentos títulos como strings HTML.
SerializingHTMLBuilder.searchindex_filename
Um índice que pode ser usado para pesquisar na documentação. É uma lista pickled com as seguintes entradas:

  • Uma lista indexada de nomes de documentos.
  • Uma lista de títulos de documentos, como strings HTML, na mesma ordem da primeira lista.
  • Um dicionário mapeando palavras raízes (processadas por um stemmer em inglês) para uma lista de inteiros, os quais são índices para a primeira.
environment.pickle
O ambiente do construtor. Sempre é um arquivo pickle, independente do construtor e uma cópia do ambiente no qual o construtor foi iniciado.

Por fazer

Documentar os membros comuns.

Diferentemente de outros arquivos pickle, esse arquivo requer que o pacote sphinx esteja disponível para desfazer o pickle.

Domínios Sphinx¶ 2011/02/01

Posted by gsavix in 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, gerador documentos, língua portuguesa, Memorando, metodologia para receber ou transferir conhecimento, publicação jornal internet, publicador documentação, sociologia do conhecimento.
add a comment

Domínios Sphinx

Novo na versão 1.0.

O que é um Domínio?

Originalmente o Sphinx foi concebido para um objetivo simples, documentação da Linguagem Python. Ele foi disponibilizado para todos como uma ferramenta de documentação, mas a documentação de módulos Python permanecia inerentemente arraigada – as mais fundamentais diretivas, como function, foram desenhadas para lidar objetos Python. Desde que Sphinx tornou-se mais popular, aumentou o interesse para diferentes propósitos como: projetos C/C++ projetos JavaScript, ou mesmo como marcação reStructuredText (como nesta documentação por exemplo).

Isto era possível, porém agora ficou mais fácil utilizá-lo em projetos de documentação usando diferentes linguagens de programação ou mesmo em uma que não seja suportada pela distribuição Sphinx, pois foi criado a diretiva domínio (domain) para esta finalidade.

O domínio (domain) é uma coleção de marcações (reStructuredText diretiva e role) para descrever e ligar o object juntos. Ex. elementos de uma linguagem de programação. Os nomes e diretivas num domínio são parecidos com: domain:name, ex. py:function. Domínios também podem prover índices personalizados (como Python Module Index).

Usando domínios significa que não haverá problemas quando alguém quiser fazer referência a classes C++ e Python. Isto também significa que estensões que suportam novas linguagens são muito mais faceis de serem escritas.

Esta seção descreve quais domínios vem com o Sphinx. O domínio API é bem documentado, na seção Domain API.

Marcação Básica

Muitos domínios trazem um número de diretivas descrição de objetos, usadas para prover descrição específica para objetos dos módulos. Cada diretiva requer uma ou mais assinaturas par prover informação básica sobre o que está sendo descrito e o conteúdo pode ser a descrição. A versão básica cria entradas no índice geral; Se nenhuma entrada no índice é desejada, você pode usar a opção de diretiva :noindex:. Um exemplo usando diretiva domínio Python:

.. py:function:: spam(eggs)
                 ham(eggs)

   Spam or ham the foo.

Isto descreve as duas funções Python spam e ham. (Note que quando as assinaturas se tornam longas, você pode quebrá-las se você adicionar uma barra invertida em linhas que deverão ser continuadas na próxima linha. Ex:

.. py:function:: filterwarnings(action, message='', category=Warning, \
                                module='', lineno=0, append=False)
   :noindex:

(Este exemplo também mostra o uso de :noindex:)

Domínios também permitem o uso de “roles” que façam ligações com estas descrições de objetos. Por exemplo, para criar ligação para uma das funções descritas acima você pode usar

A função :py:func:`spam` faz a mesma coisa.

Como você pode ver, ambos nomes de diretiva e role contêm o nome do domínio e o nome da diretiva.

Domínio Padrão

Para evitar escrever o domínio toda vez que você descreve Objetos Python, um domínio padrão pode ser selecionado com o valor config primary_domain ou com esta diretiva:

.. default-domain:: nome
Selecione um novo domínio. Enquanto o primary_domain seleciona um padrão global, este tem efeito só dentro do mesmo arquivo.

Se nenhum outro padrão é selecionado, o domínio Python (chamado py) é o padrão, mais por compatibilidade com antigas versões do Sphinx.

Diretivas e roles que pertencem ao mesmo dominio padrão, podem ser referenciadas sem explicitar o domínio, por exemplo

.. function:: pyfunc()

   Descreve uma função Python.

Referência a :func:`pyfunc`.

Sintaxe Referência-Cruzada

Para roles de referência-cruzada provida por domínios, as mesmas facilidades existem como referências-cruzadas gerais. Veja Cross-referencing syntax.

Resumidamente:

  • Voce pode explicitar um título e uma referência alvo: :role:`title <target>` irá referenciar a target, mas a ligação texto será title.
  • Se prefixar o conteúdo com !, nenhuma referência ou hiperligação será criada.
  • Se você prefixar o conteúdo com ~, o texto de ligação será só o último componente do alvo. Por exemplo: :py:meth:`~Queue.Queue.get` irá referenciar a Queue.Queue.get mas só irá exibir get com texto da ligação.

O Domínio Python

The Python domain (name py) provides the following directives for module declarations:

.. py:module:: name
This directive marks the beginning of the description of a module (or package submodule, in which case the name should be fully qualified, including the package name). It does not create content (like e.g. py:class does).

This directive will also cause an entry in the global module index.

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.

.. py:currentmodule:: name
This directive tells Sphinx that the classes, functions etc. documented from here are in the given module (like py:module), but it will not create index entries, an entry in the Global Module Index, or a link target for py:mod. This is helpful in situations where documentation for things in a module is spread over multiple files or sections – one location has the py:module directive, the others only py:currentmodule.

The following directives are provided for module and class contents:

.. py:data:: name
Describes global data in a module, including both variables and values used as “defined constants.” Class and object attributes are not documented using this environment.

.. py:exception:: name
Describes an exception class. The signature can, but need not include parentheses with constructor arguments.

.. py:function:: name(signature)
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; see Python Signatures. For example:

.. py:function:: Timer.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.

.. py:class:: name[(signature)]
Describes a class. The signature can include parentheses with parameters which will be shown as the constructor arguments. See also Python Signatures.

Methods and attributes belonging to the class should be placed in this directive’s body. If they are placed outside, the supplied name should contain the class name so that cross-references still work. Example:

.. py:class:: Foo
   .. py:method:: quux()

-- or --

.. py:class:: Bar

.. py:method:: Bar.quux()

The first way is the preferred one.

.. py:attribute:: name
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.

.. py:method:: name(signature)
Describes an object method. The parameters should not include the self parameter. The description should include similar information to that described for function. See also Python Signatures.

.. py:staticmethod:: name(signature)
Like py:method, but indicates that the method is a static method.

Novo na versão 0.4.

.. py:classmethod:: name(signature)
Like py:method, but indicates that the method is a class method.

Novo na versão 0.6.

Python Signatures

Signatures of functions, methods and class constructors can be given like they would be written in Python, with the exception that optional parameters can be indicated by brackets:

.. py:function:: compile(source[, filename[, symbol]])

It is customary to put the opening bracket before the comma. In addition to this “nested” bracket style, a “flat” style can also be used, due to the fact that most optional parameters can be given independently:

.. py:function:: compile(source[, filename, symbol])

Default values for optional arguments can be given (but if they contain commas, they will confuse the signature parser). Python 3-style argument annotations can also be given as well as return type annotations:

.. py:function:: compile(source : string[, filename, symbol]) -> ast object

Info field lists

Novo na versão 0.4.

Inside Python object description directives, reST field lists with these fields are recognized and formatted nicely:

  • param, parameter, arg, argument, key, keyword: Description of a parameter.
  • type: Type of a parameter.
  • raises, raise, except, exception: That (and when) a specific exception is raised.
  • var, ivar, cvar: Description of a variable.
  • returns, return: Description of the return value.
  • rtype: Return type.

The field names must consist of one of these keywords and an argument (except for returns and rtype, which do not need an argument). This is best explained by an example:

.. py:function:: format_exception(etype, value, tb[, limit=None])

   Format the exception with a traceback.

   :param etype: exception type
   :param value: exception value
   :param tb: traceback object
   :param limit: maximum number of stack frames to show
   :type limit: integer or None
   :rtype: list of strings

This will render like this:

format_exception(etype, value, tb[, limit=None])
Format the exception with a traceback.

Parâmetros:
  • etype – exception type
  • value – exception value
  • tb – traceback object
  • limit (integer or None) – maximum number of stack frames to show
Tipo de retorno:
list of strings

It is also possible to combine parameter type and description, if the type is a single word, like this:

:param integer limit: maximum number of stack frames to show

Cross-referencing Python objects

The following roles refer to objects in modules and are possibly hyperlinked if a matching identifier is found:

:py:mod:
Reference a module; a dotted name may be used. This should also be used for package names.

:py:func:
Reference a Python function; dotted names may be used. The role text needs not include trailing parentheses to enhance readability; they will be added automatically by Sphinx if the add_function_parentheses config value is true (the default).

:py:data:
Reference a module-level variable.

:py:const:
Reference a “defined” constant. This may be a C-language #define or a Python variable that is not intended to be changed.

:py:class:
Reference a class; a dotted name may be used.

:py:meth:
Reference a method of an object. The role text can include the type name and the method name; if it occurs within the description of a type, the type name can be omitted. A dotted name may be used.

:py:attr:
Reference a data attribute of an object.

:py:exc:
Reference an exception. A dotted name may be used.

:py:obj:
Reference an object of unspecified type. Useful e.g. as the default_role.

Novo na versão 0.4.

The name enclosed in this markup can include a module name and/or a class name. For example, :py:func:`filter` could refer to a function named filter in the current module, or the built-in function of that name. In contrast, :py: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 Python’s codecs module, :py:func:`open` always refers to the built-in function, while :py:func:`.open` refers to codecs.open().

A similar heuristic is used to determine whether the name is an attribute of the currently documented class.

Also, if the name is prefixed with a dot, and no exact match is found, the target is taken as a suffix and all object names with that suffix are searched. For example, :py:meth:`.TarFile.close` references the tarfile.TarFile.close() function, even if the current module is not tarfile. Since this can get ambiguous, if there is more than one possible match, you will get a warning from Sphinx.

Note that you can combine the ~ and . prefixes: :py:meth:`~.TarFile.close` will reference the tarfile.TarFile.close() method, but the visible link caption will only be close().

The C Domain

The C domain (name c) is suited for documentation of C API.

.. c:function:: type name(signature)
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:: type name
Describes a C struct member. Example signature:

.. c:member:: PyObject* PyTypeObject.tp_bases

The 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:: name
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:: name
Describes a C type (whether defined by a typedef or struct). The signature should just be the type name.

.. c:var:: type name
Describes a global C variable. The signature should include the type, such as:

.. c:var:: PyObject* PyClass_Type

Cross-referencing C constructs

The following roles create cross-references to C-language constructs if they are defined in the documentation:

:c:data:
Reference a C-language variable.

:c:func:
Reference a C-language function. Should include trailing parentheses.

:c:macro:
Reference a “simple” C macro, as defined above.

:c:type:
Reference a C-language type.

The C++ Domain

The C++ domain (name cpp) supports documenting C++ projects.

The following directives are available:

.. cpp:class:: signatures
.. cpp:function:: signatures
.. cpp:member:: signatures
.. cpp:type:: signatures
Describe a C++ object. Full signature specification is supported – give the signature as you would in the declaration. Here some examples:

.. cpp:function:: bool namespaced::theclass::method(int arg1, std::string arg2)

   Describes a method with parameters and types.

.. cpp:function:: bool namespaced::theclass::method(arg1, arg2)

   Describes a method without types.

.. cpp:function:: const T &array<T>::operator[]() const

   Describes the constant indexing operator of a templated array.

.. cpp:function:: operator bool() const

   Describe a casting operator here.

.. cpp:member:: std::string theclass::name

.. cpp:type:: theclass::const_iterator

Will be rendered like this:

bool namespaced::theclass::method(int arg1, std::string arg2)
Describes a method with parameters and types.

bool namespaced::theclass::method(arg1 None, arg2 None)
Describes a method without types.

const T& array<T>::operator[]() const
Describes the constant indexing operator of a templated array.

operator bool() const
Describe a casting operator here.

std::string theclass::name
type theclass::const_iterator
.. cpp:namespace:: namespace
Select the current C++ namespace for the following objects.

These roles link to the given object types:

:cpp:class:
:cpp:func:
:cpp:member:
:cpp:type:
Reference a C++ object. You can give the full signature (and need to, for overloaded functions.)

Nota

Sphinx’ syntax to give references a custom title can interfere with linking to template classes, if nothing follows the closing angle bracket, i.e. if the link looks like this: :cpp:class:`MyClass<T>`. This is interpreted as a link to T with a title of MyClass. In this case, please escape the opening angle bracket with a backslash, like this: :cpp:class:`MyClass\<T>`.

Note on References

It is currently impossible to link to a specific version of an overloaded method. Currently the C++ domain is the first domain that has basic support for overloaded methods and until there is more data for comparison we don’t want to select a bad syntax to reference a specific overload. Currently Sphinx will link to the first overloaded version of the method / function.

The Standard Domain

The so-called “standard” domain collects all markup that doesn’t warrant a domain of its own. Its directives and roles are not prefixed with a domain name.

The standard domain is also where custom object descriptions, added using the add_object_type() API, are placed.

There is a set of directives allowing documenting command-line programs:

.. option:: name args, name args, ...
Describes a command line option or switch. Option argument names should be enclosed in angle brackets. Example:

.. option:: -m <module>, --module <module>

   Run a module as a script.

The directive will create a cross-reference target named after the first option, referencable by option (in the example case, you’d use something like :option:`-m`).

.. envvar:: name
Describes an environment variable that the documented code or program uses or defines. Referencable by envvar.

.. program:: name
Like py:currentmodule, this directive produces no output. Instead, it serves to notify Sphinx that all following option directives document options for the program called name.

If you use program, you have to qualify the references in your option roles by the program name, so if you have the following situation

.. program:: rm

.. option:: -r

   Work recursively.

.. program:: svn

.. option:: -r revision

   Specify the revision to work upon.

then :option:`rm -r` would refer to the first option, while :option:`svn -r` would refer to the second one.

The program name may contain spaces (in case you want to document subcommands like svn add and svn commit separately).

Novo na versão 0.5.

There is also a very generic object description directive, which is not tied to any domain:

.. describe:: text
.. object:: text
This directive produces the same formatting as the specific ones provided by domains, but does not create index entries or cross-referencing targets. Example:

.. describe:: PAPER

   You can set this variable to select a paper size.

The JavaScript Domain

The JavaScript domain (name js) provides the following directives:

.. js:function:: name(signature)
Describes a JavaScript function or method. If you want to describe arguments as optional use square brackets as documented for Python signatures.

You can use fields to give more details about arguments and their expected types, errors which may be thrown by the function, and the value being returned:

.. js:function:: $.getJSON(href, callback[, errback])

   :param string href: An URI to the location of the resource.
   :param callback: Get's called with the object.
   :param errback:
       Get's called in case the request fails. And a lot of other
       text so we need multiple lines
   :throws SomeError: For whatever reason in that case.
   :returns: Something

This is rendered as:

$.getJSON(href, callback[, errback])
Parâmetros:
  • href (string) – An URI to the location of the resource.
  • callback – Get’s called with the object.
  • errback – Get’s called in case the request fails. And a lot of other text so we need multiple lines.
Gera SomeError: For whatever reason in that case.
Retorna: Something
.. js:class:: name
Describes a constructor that creates an object. This is basically like a function but will show up with a class prefix:

.. js:class:: MyAnimal(name[, age])

   :param string name: The name of the animal
   :param number age: an optional age for the animal

This is rendered as:

class MyAnimal(name[, age])
Parâmetros:
  • name (string) – The name of the animal
  • age (number) – an optional age for the animal
.. js:data:: name
Describes a global variable or constant.

.. js:attribute:: object.name
Describes the attribute name of object.

These roles are provided to refer to the described objects:

:js:func:
:js:class:
:js:data:
:js:attr:

The reStructuredText domain

The reStructuredText domain (name rst) provides the following directives:

.. rst:directive:: name
Describes a reST directive. The name can be a single directive name or actual directive syntax (.. prefix and :: suffix) with arguments that will be rendered differently. For example:

.. rst:directive:: foo

   Foo description.

.. rst:directive:: .. bar:: baz

   Bar description.

will be rendered as:

.. foo::
Foo description.

.. bar:: baz
Bar description.

.. rst:role:: name
Describes a reST role. For example:

.. rst:role:: foo

   Foo description.

will be rendered as:

:foo:
Foo description.

These roles are provided to refer to the described objects:

:rst:dir:
:rst:role:

More domains

The sphinx-contrib repository contains more domains available as extensions; currently a Ruby and an Erlang domain.

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.

Você conhece o Gtranslator? 2010/12/27

Posted by gsavix in colaboração na aquisição conhecimento, Conhecimento para receber ou transferir tecnologia, língua portuguesa, metodologia para receber ou transferir conhecimento, Sistemas Computacionais, Sistemas de Gestão da Produção, Soft.
add a comment

Gtranslator

Gtranslator é um editor expandido de arquivos “gettext po”  para o ambiente desktop do GNOME. Ele pode manipular todas as formas de arquivos gettext po, incluindo muitas funcionalidades de Localizar/Substituir, Memória de Tradução, Vários Perfis Tradução, Tabela de Mensagens, Navegação Fácil e edição de mensagens e comentários, para que a tradução seja mais acurada.

Gtranslator inclui também um sistema de plugin com vários plugins como Língua Alternada, Etiquetas, Integração com Controle de Versão (SVN, etc) .

Além de tudo isso é livre para você copiar, modificar, contribuir, interagir não dexiando você na mão de nenhum fabricante ou fornecedor com direitos autorais exclusivos.

 

para mais informações acesse: http://live.gnome.org/gtranslator