artigo

Convertendo centenas de imagens em alguns PDFs com Python

Se você não tem nada a ver com programação, nem tem interesse no assunto, simplesmente ignore este artigo.


Mike Driscoll tem um blog dedicado a Python chamado The Mouse vs. the Python e eventualmente há excelentes artigos por lá.

Esta é uma tradução livre do artigo Reportlab: Converting Hundreds of Images Into PDFs e modifiquei sutilmente algumas coisas, incluindo os exemplos. Agradeço ao Mike pelos excelentes artigos e me desculpo pelas liberdades que tomei na tradução (incluindo a mudança no nome do artigo). Vamos a ele!


Recentemente me pediram para converter algumas centenas de imagens em páginas de um PDF. Um amigo meu desenha comics e meu irmão queria poder lê-lo em um tablet. Acontece que se você tem um monte de arquivos nomeados assim:

'Jia_01.Jpg', 'Jia_02.Jpg', 'Jia_09.Jpg', 'Jia_10.Jpg', 'Jia_11.Jpg', 'Jia_101.Jpg'

o tablet Android vai reordená-los mais ou menos assim:

'Jia_01.Jpg', 'Jia_02.Jpg', 'Jia_09.Jpg', 'Jia_10.Jpg', 'Jia_101.Jpg', 'Jia_11.Jpg'

E se torna muito confuso ler com os arquivos fora de ordem desse jeito. Infelizmente, até mesmo o Python ordena os arquivos desse modo. Tentei usar o módulo glob diretamente e então ordenar o resultado e resultou no mesmo problema. Assim a primeira coisa que eu tinha que fazer era achar algum tipo de ordenação que organizasse os arquivos corretamente. Deve ser notado que o Windows 7 pode ordenar os arquivos corretamente no sistema de arquivos, mas o Python não.

Depois de uma pequena busca no Google, encontrei o seguinte script no StackOverflow:

import re
 
#----------------------------------------------------------------------
def sorted_nicely( l ):
    """
    Sort the given iterable in the way that humans expect.
    """
    convert = lambda text: int(text) if text.isdigit() else text
    alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ]
    return sorted(l, key = alphanum_key)

Funcionou perfeitamente! Agora eu só tinha que arrumar um jeito de colocar cada página da HQ em sua própria página dentro do arquivo PDF. Felizmente, a biblioteca reportlab torna essa tarefa muito fácil de realizar. Você só precisa percorrer as imagens e inserí-las uma a uma em uma página. É mais fácil dar uma olhada no código, assim vejamos:

import glob
import os
import re
 
from reportlab.lib.pagesizes import letter
from reportlab.platypus import SimpleDocTemplate, Paragraph, Image, PageBreak
from reportlab.lib.units import inch
 
#----------------------------------------------------------------------
def sorted_nicely( l ):
    """
    # http://stackoverflow.com/questions/2669059/how-to-sort-alpha-numeric-set-in-python
 
    Sort the given iterable in the way that humans expect.
    """
    convert = lambda text: int(text) if text.isdigit() else text
    alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ]
    return sorted(l, key = alphanum_key)
 
#----------------------------------------------------------------------
def create_comic(fname, front_cover, back_cover, path):
    """"""
    filename = os.path.join(path, fname + ".pdf")
    doc = SimpleDocTemplate(filename,pagesize=letter,
                            rightMargin=72,leftMargin=72,
                            topMargin=72,bottomMargin=18)
    Story=[]
    width = 7.5*inch
    height = 9.5*inch
 
    pictures = sorted_nicely(glob.glob(path + "\\%s*" % fname))
 
    Story.append(Image(front_cover, width, height))
    Story.append(PageBreak())
 
    x = 0
    page_nums = {100:'%s_101-200.pdf', 200:'%s_201-300.pdf',
                 300:'%s_301-400.pdf', 400:'%s_401-500.pdf',
                 500:'%s_end.pdf'}
    for pic in pictures:
        parts = pic.split("\\")
        p = parts[-1].split("%s" % fname)
        page_num = int(p[-1].split(".")[0])
        print "page_num => ", page_num
 
        im = Image(pic, width, height)
        Story.append(im)
        Story.append(PageBreak())
 
        if page_num in page_nums.keys():
            print "%s created" % filename
            doc.build(Story)
            filename = os.path.join(path, page_nums[page_num] % fname)
            doc = SimpleDocTemplate(filename,
                                    pagesize=letter,
                                    rightMargin=72,leftMargin=72,
                                    topMargin=72,bottomMargin=18)
            Story=[]
        print pic
        x += 1
 
    Story.append(Image(back_cover, width, height))
    doc.build(Story)
    print "%s created" % filename
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    path = r"C:\Users\Mike\Desktop\Sam's Comics"
    front_cover = os.path.join(path, "FrontCover.jpg")
    back_cover = os.path.join(path, "BackCover2.jpg")
    create_comic("Jia_", front_cover, back_cover, path)

Vamos detalhar isso um pouco. Como sempre ocorre, você tem alguns imports necessários que são exigidos para que o código funcione. Você vai notar que nós também temos dentro do código a função sorted_nicely de que falamos anteriormente. A função principal se chama create_comic e recebe quatro parâmetros: fname, front_cover, back_cover, path. Se você já usou o reportlab antes, deve ter reconhecido o SimpleDocTemplate e o Story, que são mostrados no referido tutorial

De qualquer forma, você faz um laço (loop) nas imagens ordenadas e vai adicionando as imagens ao Story, sempre com um objeto PageBreak. A razão de haver um condicional dentro do laço é que eu descobri que se eu tentar construir o PDF com todas as 400+ imagens, termina ocorrendo um erro de memória. Assim eu quebrei o trabalho em uma série de documentos onde cada um tem 100 páginas ou menos. Ao final do documento, você tem que chamar o método build do objeto doc para criar o documento PDF propriamente.

Agora você sabe como eu converti um monte de imagens em alguns documentos PDF. Teoricamente, você pode usar o PyPdf para juntar todos os PDFs resultantes em um PDF único, mas eu não tentei fazer isso. Pode ser que apareça um outro erro de memória. Deixo esse teste como um exercício para o leitor.

P. S.: A foto deste post é de NobMouse.

Special: 

FreeDroid RPG: um Action RPG livre

FreeDroid RPG

Arthur HuilletEm 2002 Arthur Huillet (que parece, como eu, também gostar de usar um fedora preto) começou um projeto de um jogo de RPG eletrônico, a ser feito como um software livre. E assim foi que nasceu o FreeDroid RPG, um jogo que vem evoluindo cada vez mais (recendo até mesmo contribuições via projeto Google Summer of Code).

No estilo Diablo, FreeDroid RPG mostra um mundo pós-apocaliptico dominado por uma megacorporação, que espalhou seus robôs por todo lugar, subjugando a humanidade. O personagem principal é ninguém menos que o Tux, que tem como missão descobrir como pará-los.

O jogo está bem avançado e é estruturalmente bacana. O que me causou estranheza e fez com que eu não me interessasse tanto por ele de início foi justamente o fato de a história girar em torno do Tux. Apesar de eu defender Sofware Livre, o Tux não me atrai. Preferências à parte, o fato de o RPG ainda servir como conscientizador para a causa do Software Livre é muito bacana e vou jogar de novo quando tiver um tempinho livre.

Segundo a apresentação mais recente no FOSDEM, o FreeDroid RPG rende 12 horas de jogo, tem 60 personagens para interagir, uma trilha sonora composta por 14 músicas originais e traz diálogos somando mais de 60.000 palavras. Pena não ter em português ainda (tradutores são bem-vindos).

O jogo está disponível para Windows, MacOS e GNU/Linux (inclusive já tem pacotes nos repositórios oficiais do Trisquel). Então, recomendo que teste o FreeDroid RPG! Jogue e tire suas conclusões (comentando aqui no Bardo WS, se desejar, o que seria também bem-vindo).

FreeDroid RPG talvez seja o mais perto que temos de "um open Diablo", pena que não seja multiplayer. Seria bom também termos um "open Castlevania", "Open Zelda" e, por que não, um "open Pokémon". E mais importante ainda: com enredos, personagens e mundo próprios e não apenas réplicas genéricas.

Tela do jogo FreeDroid RPG

Se quiser conhecer mais sobre o FreeDroid RPG, inclusive sobre como ele foi feito, dá uma olhada na apresentação do Arthur no FOSDEM (estão liberados os slides, além de video e audio da palestra).

Emuladores e ROMs

 

Emulador é um enganador. É um tipo de programa que "faz-de-conta" que você está usando um outro ambiente (que não o ambiente que realmente está usando). Está confuso?

Se você usa algum Unix (como o GNU/Linux), certamente já viu atalho para um programa chamado Terminal, xterm, gnome-terminal ou algo do tipo. O terminal propriamente dito é aquele modo de uso do computador onde vemos só letras monoespaçadas, a famosa tela preta. Esses programinhas que tem no modo gráfico na verdade são emuladores de terminal, pois permitem que programas feitos para executar apenas em terminal executem neles como se eles próprios fossem terminais, mas eles não são.

Ainda está confuso? Tá bem, tá bem, então vamos ao ponto onde eu quero chegar hoje: videogames. Um emulador de videogame é um programa que faze de conta que você está em um videogame. E aí? Como se joga? Você precisa de imagens dos jogos. Não falo de imagens gráficas como JPEG ou PNG, estou falando de cópias exatas do conteúdo de um cartucho ou CD de jogo. Quando você transforma um CD-ROM em um arquivo (sem conversões e compressões), o arquivo ISO é a imagem do CD. Quando estamos falando de videogames e cartuchos, essa imagem é o que a gente costuma chamar de ROM.

Vamos a um exemplo mais específico: você quer jogar Super Mario Bros no computador, aquele jogo para Nintendinho (também chamado de NES ou Famicom; ou, no Brasil, de Turbo Game, Dynavision, Phantom System...). Você precisa de um emulador de NES e de um ROM do Super Mario Bros.

Ao executar o emulador com o ROM, o emulador utilizará os recursos do seu computador e criará um comportamento similar ao do NES, imitando o do NES. Assim, ele pega o ROM e consegue executá-lo para você poder jogar. O jogo, que não passa de um software feito especificamente para a arquitetura do NES, encontrará todos os recursos de que precisa e funcionará na boa, achando que ele próprio está dentro de um cartuxo e que está sendo executado verdadeiramente por um videogame NES.

Legal, não é? Esta técnica permite imitar vários ambientes e videogames. Claro que para uma arquitetura de videogames diferente (entenda como um "console" diferente), você precisará de um emulador diferente. Claro, há casos de emuladores muito bem projetados, capazes de emular vários hardwares diferentes sozinho, mas estes funcionam na prática como vários emuladores fundidos em um.

Aí você que não conhece emuladores vai perguntar: E isso funciona direitinho? A resposta é: depende! A arquitetura dos videogames não é publicada, nem emuladores são necessariamente desejados ou autorizados pelos fabricantes de videogames. Então, o que temos são equipes que de boa vontade tentam fazer o melhor que podem para que o emulador engane adequadamente os jogos para esse ou aquele console. Às vezes conseguem resultados maravilhosos, às vezes nem tanto.

Curioso é que a Nintendo tem abusado do uso de emuladores. O Nintendo Wii é capaz de emular todos os consoles anteriores dela (exceto pelo GameCube, mas o Wii roda jogos do GameCube em mídia) e mais outros (como os da Sega, por exemplo). Os jogos são comprados em sua loja virtual e instalados no videogame. O Nintendo 3DS também oferece funcionalidade semelhante, mas aplicável aos videogames portáteis antigos.

Falando-se de computadores, o mundo dos softwares livres tem vários emuladores, para as mais variadas arquiteturas. Aqui listo alguns:

  • ZSNES - Emulador de Super-Nintendo
  • FCEUX - Emulador de Nintendo 8 bits
  • Gens - Emulador de Mega Drive
  • Yabause - Emulador de Sega Saturn
  • DeSmuME - Emulador de Nintendo DS
  • Mupen64plus - Emulador de Nintendo 64
  • Stella - Emulador de Atari

Todos estes são softwares livres para emular consoles de videogame, inclusive estão no repositório do Trisquel (Sistema Operacional baseado em GNU e Linux, distribuído também no CyanPack). Lembrando que emulação de videogames é um assunto controverso. Recomenda-se emular apenas jogos pelos quais você tenha pago.

P. S.: Foto original do post é de barité.

Special: 

Klavaro - curso de Digitação

Há algumas décadas era fundamental para qualquer sujeito cursar datilografia. O tempo foi passando e a datilografia foi sendo substituída pouco a pouco pelos cursos de digitação. O princípio prevalecia: o usuário praticava para ter familiaridade com o teclado, tornando-se capaz de atingir alto desempenho com um teclado alfabético na frente.

O tempo foi passando mais um pouco e os cursos de informática foram ofuscando os de digitação. Hoje não se faz mais cursos de digitação. Resultado é que é comum leigos se admirarem quando veem alguém da outra geração digitando mais do que três caracteres por segundo ou digitando sem olhar para o monitor. Foi uma das perícias que se perderam com a evolução.

Mas se você perdeu o bonde e não teve oportunidade de fazer um curso de digitação, não tem problema! Existem softwares que viabilizam um curso autodidata de digitação. Um deles é o Klavaro.

Você pode obter o Klavaro a partir do site do projeto. Ele tem suporte a português (além de vários outros idiomas) e tem versão para GNU/Linux, MacOS X e Windows, além de vir junto no CyanPack, caso você o tenha baixado.

O Klavaro (cujo nome significa teclado, em Esperanto) apresenta cinco modos:

  1. Introdução: explicando como dispor os dedos no teclado e boas práticas na digitação.
  2. Curso Básico - treinamento inicial
  3. Adaptabilidade - prática com teclas aleatórias
  4. Rapidez - prática com palavras aleatórias
  5. Fluidez - prática com textos inteiros

Quem não tinha acesso a um curso de digitação agora não tem mais desculpa: basta instalar esse excelente software e mandar ver!

Curiosidade: o Klavaro também oferece curso e práticas com o teclado Dvorak ao invés do QUERTY-ABNT2.

Special: 

Dynasty Warriors

Dynasty Warriors DS

Hoje mais uma grande franquia de jogos faz aniversário. Trata-se da Dynasty Warriors, uma franquia de jogos de estratégia tática criada pela Tecmo Koei, inspirada no Romance dos Três Reinos, que completa 15 anos hoje.

Nos jogos da série, você escolhe um entre três reinos (Wu, Shu ou Wei) e segue china afora derrotando rivais menores e, por fim, derrotando os genearais dos outros dois reinos. Para isso, usa-se estratégia do avanço através do mapa, combinado com ação nos momentos de confronto, contra os soldados e arqueiros do oponente. O objetivo final é conseguir a unificação da China.

O título mais recente da série é o Dynasty Warriors 7, para Playstation 3, Xbox 360 e Windows. O curioso é que apenas a partir do segundo, o jogo passou a ter esse formato hoje conhecido. O primeiro título era um jogo de luta tipo Tekken, tanto que a série de estratégia no Japão se chama Shin Sangokumusou e tem uma contagem diferente da ocidental: por exemplo, Dynasty Warriors 3 lá é Shin Sangokumusou 2.

  1. Dynasty Warriors (1997) - Playstation
  2. Dynasty Warriors 2 (2000) - Playstation 2
  3. Dynasty Warriors 3 (2001) - Playstation 2 e Xbox
  4. Dynasty Warriors 4 (2003) - Playstation 2, Xbox e Microsoft Windows
  5. Dynasty Warriors (2004) - Playstation Portable
  6. Dynasty Warriors Advance (2005) - GameBoy Advance
  7. Dynasty Warriors 5 (2005) - Playstation 2, Xbox e Microsoft Windows
  8. Dynasty Warriors Vol. 2 (2006) - Playstation Portable
  9. Dynasty Warriors DS: Fighter's Battle (2007) - Nintendo DS
  10. Dynasty Warriors 6 (2007) - Playstation 3, Playstation 2, Playstation Portable, Xbox 360 e Microsoft Windows
  11. Dynasty Warriors: Strikeforce (2009) - Playtation 3, Playstation Portable, Xbox 360
  12. Dynasty Warriors Next (2011) - Playstation Vita
  13. Dynasty Warriors 7 (2011) - Playstation 3, X-Box 360 e Microsoft Windows

A série se estende por vários títulos mais, inclusive com uma variante (com vários títulos também) onde se joga com mechas (aqueles robôs gigantes controláveis dos animes e mangás): Dynasty Warriors Gundam.

Aqui está o trailler do Dynasty Warriors 7:

Detalhe que no Japão eles não devem comemorar esses 15 anos, já que a série Shin Sangokumusou só começou no ano 2000, no que há dois anos eles comemoraram 10 anos da série.

Special: 

Como funciona um blog, para leigos

Antes de mais nada, este artigo foi escrito para leigos, que não sabem o que é isso de CMS ou sistema de Blog. Se você sabe o que é CMS, pode ignorar este artigo sem peso na consciência.

Anos 1990

Para entendermos como tudo isso funciona, precisamos voltar no tempo para a década de 1990. Com o início da popularização da Internet, veio a ideia de que qualquer pessoa pode compartilhar algo com o mundo inteiro. Isso era feito, naquele tempo, através de homepages, que eram parecidos com blogs e sites atuais no sentido de que a gente os acessava através de um endereço. Se você pagasse o necessário e tivesse conhecimento de HTML (ou pagasse alguém que tivesse esse conhecimento) poderia ter o endereço minhapagina.com. Parecido com os blogs de hoje, mas com algumas diferenças muito importantes.

1) Você não poderia alterar facilmente o conteúdo das páginas. Tudo era feito diretamente nessa linguagem HTML. Precisaríamos de um programa para acessar o servidor remotamente (geralmente um gerenciador de arquivos remotos via FTP), editar a página em um programa específico (Netscape Composer?), salvar e reenviar para o servidor. Claro que não é tão simples e alguns preferiam pagar pra alguém fazer isso. Claro que se você pagasse pra alguém pra que fizesse isso por você, você ficava preso e teria que recorrer a essa pessoa sempre que precisasse atualizar a sua homepage.

2) Não tinha como ter interação com visitantes. Ao invés de comentários, o que geralmente tínhamos eram livros de visitas, que eram como tópicos em um outro site, mas linkados a partir do nosso, e nesse sim as pessoas poderiam comentar.

Resumindo: não havia interatividade.

O que é HTML?

Agora vamos dar uma pausa para explicar melhor o que é isso de HTML afinal.

Quando você digita google.com e dá ENTER, ou bardo.ws, ou fsf.org, ou trezentos.blog.br e dá ENTER, o navegador vai procurar o servidor correspondente a esse endereço. O servidor então enviará ao navegador um código estranho: o HTML. Estranho para nós, não para o navegador, pois esse código diz exatamente como a página deve ser montada. Ele diz que textos estão na página, que estilo cada porção de texto segue, que imagens estão e onde devem aparecer, quais os links e para onde apontam... Enfim, o conteúdo da página é passado para o navegador nesse formato HTML. O navegador lê esse código, coça o queixo e diz: "Ah, entendi!". Então ele reproduz na tela, para você ver, todo o texto e imagens, tudo devidamente diagramado e formatado.

Na Era das Homepages, o que fazíamos era criar páginas em HTML mesmo e deixar lá no servidor. Quando um navegador chegasse procurando por uma página chamada "sobremim.html", existia um arquivo lá no servidor com esse nome exato e que tinha mesmo um código HTML dentro. Todo o trabalho que o servidor tinha era mandar esse arquivo pro navegador, e todos os demais arquivos que fossem sendo pedidos: as fotos que constavam na página, a outra página quando a gente clicasse num link, etc.

Peraí! E se...

Lembra aquele lance de Livro de Visitas de que falei? Pois bem, ele era bem diferente das homepages. Não era uma página salva em HTML que estava nos servidor, mas sim um programa. Um software que era capaz de ler a partir de um arquivo informações organizadas, como uma tabela contendo informações como: nome, email, homepage e comentário. Assim, sempre que o navegador apontava para aquele servidor, esse programa era acionado. O programa lia o arquivo e criava um código HTML, mandando para o navegador, como se fosse uma página estática antiga. Além disso, esse programa era capaz de gravar novos comentários no final na sua tabelinha. O visitante que chegasse depois veria esse novo comentário acrescentado.

Então alguém deve ter pensado: se um programa pode funcionar em um servidor e guardar comentários... E se a homepage todinha fosse na verdade um programa? Um programa mas que o visitante nunca desconfia que é um programa: ele só vê as páginas normais, como era antigamente. Mas poderia ter um banco de dados com as informações das páginas armazenadas e o programa montaria a homepage de maneira dinâmica! E se a gente pudesse editar essas páginas no próprio navegador sem precisar de editor de HTML nem de FTP?

Foi assim que começaram a aparecer gerenciadores de conteúdo. Aí alguém pensou: e se eu fizesse um diário, com os artigos sendo publicados em ordem de defasagem: os mais novos empurrando os mais antigos para baixo? E se cada artigo desses permitisse que os visitantes comentassem, complementando, discordando ou ratificando cada artigo?

Assim foi que a Internet de blogs e sites como conhecemos hoje foi se desenhando. Hoje são raros os endereços que guardam páginas com código HTML. A grande maioria dos endereços hoje encontram programas capazes de gerar esse código dinamicamente. Blogs são programas, wikis são programas. As redes sociais são programas que rodam no servidor. O sistema de busca é um programa

Sistemas de Blog e CMS

Existem sistemas prontos para atender os usuários sem que eles saibam nada sobre programação ou administração de sistemas. E há alguns gratuitos que são assim. O próprio Google oferece o Blogger, nesses moldes.

Para quem tem seu próprio endereço e prefere gerenciar seu site com minúcia, existem bons softwares livres que fazem as vezes de blogs (e wikis, e CMSs...). Os softwares para gerenciar blog mais famosos de hoje em dia creio que sejam o Wordpress, Joomla, Plone e Drupal.

O Wordpress nasceu como um sistema para gerenciar blog, mas hoje suporta diversos outros recursos além desse. O legal é que há um serviço de blog gratuito usando o Wordpress para quem quer usar a feramenta e não quer ter que instalar e gerenciar num servidor próprio: wordpress.com.

Joomla é o grupo dissidente do Mambo. É um gerenciador de conteúdo bem completo, o que quer dizer que oferece recursos de forum, envio de arquivos, dentre vários outros.

Plone é outro bastante completo e muito utilizado aqui em Alagoas, em especial pelo Governo e pela UFAL. Um lado negativo para usuários menores é que a estrutura necessária para fazê-lo funcionar não é exatamente trivial: exige alguns programas mais difíceis de instalar do que os outros que apresentei.

E o Drupal, claro! O Drupal é o CMS que utilizo no Bardo WS. Ele oferece diversos recursos também e tem me atendido desde que comecei a utilizá-lo.

Bom, deu pra entender um pouco como funcionam blogs por dentro? Algumas dúvidas mais? Pode mandar ver!

Special: 

CyanPack - 5 anos e 50 releases!

O CyanPack é um conjunto de softwares livres para Windows similar ao projeto OpenDisc, mas com características bem próprias.

Disponível em dois formatos: CD e DVD. O CD traz softwares livres para Windows apenas em formato executável, enquando a versão em DVD acrescenta o código-fonte de todos esses softwares, além de uma versão sutilmente remasterizada do sistema operacional livre Trisquel.

Tanto o CD como o DVD trazem além de software, material diverso para leitura, incluindo a edição mais recente de revistas digitais como a Revista Espírito Livre, a Revista Programar e a Revista Nintendo Blast. Trazem também alguns livros digitais, dentre eles muitos de Cárlisson Galdino (incluindo cordéis).

A edição mais recente, a 12.0 - Mitromorpha Azorensis - marca o projeto como o quinquagésimo release. Por isso, aqui você verá uma breve história do projeto CyanPack, algumas curiosidades sobre o projeto e a lista de todas as versões já liberadas. Espero que você goste! (E se você estiver na rede social SoftwareLivre.org, não deixe de participar também da comunidade CyanPack)

História

Criado em 2006 para facilitar a instalação de softwares no Campus Arapiraca da UFAL, o projeto NTI-CD reunia softwares gratuitos cujas licenças permitissem redistribuição. Em 2007, passou a ter lançamentos mensais de novas versões. Na versão 7.2 (primeira a ser tornada pública), passou a funcionar também como utilitário, ao incorporar a distribuição GNU/Linux DSL, funcionando como um LiveCD.

Em janeiro de 2008, em sua versão 8.1, o nome do projeto mudou para CyanCD, continuando com edições mensais.

Em janeiro de 2010, o projeto passou a ser bimestral, mas em 2011 sua periodicidade ficou indefinida, tendo versões publicadas com diferença de um ou de dois meses para suas antecessoras.

Em janeiro de 2011, o projeto deixou de trazer softwares gratuitos para Windows para trazer exclusivamente softwares livres. Na versão 11.5 (julho de 2011), ocorreu nova mudança de nome. O projeto, para oferecer ainda mais a seus usuários, mudou de CyanCD para CyanPack.

Curiosidades

Cada edição do CyanPack, desde a época em que se chamava NTI-CD, traz um papel de parede temático. Posteriormente, o pacote passou a trazer duas versões do papel de parede: uma normal e outra sob aplicação de algum efeito. A finalidade do papel de parede de cada edição é para servir de informação visual.

Quando atualizamos os softwares em um computador a partir do CyanPack, nós mudamos o papel de parede do Administrador para o que veio naquela edição do CyanPack. Assim, quando nos depararmos com aquele mesmo computador no futuro saberemos quais softwares precisamos atualizar (considerando que o CyanPack traz memória da última atualização de cada programa, até 3 releases do CyanPack de distância).

O papel de parede com aplicação de efeito vem do uso do Firefox para atualizar um computador. Primeiro, fazemos download a partir do CyanPack de todos os programas que precisamos atualizar. Ao terminarmos esse passo, nós mudamos o papel de parede para o temático-alterado. Assim, se precisarmos interromper as atualizações por uma razão qualquer, ao nos depararmos com o computador saberemos: primeiro, que ele não está atualizado, pois parou no meio de uma atualização; segundo, qual a versão que estava sendo atualizada no momento. Se a versão era a mais recente, então basta abrir o Firefox e continuar a execução dos programas salvos. Apagando cada instalador da lista de download tão logo sua execução seja concluída.

Outra curiosidade é sobre os nomes de versão. Muitas vezes vinham estudantes ao NTI pedindo para modificar a senha. O Sistema Acadêmico da época nos permitia criar novas senhas provisórias (daquelas que, ao primeiro login, obrigam o usuário a definir uma nova senha). Era prática comum naquele tempo se colocar senhas provisórias como “12345”. A ideia de usar codinomes para o CyanPack na época foi para aproveitar esse nome como “senha provisória”. Quem mudou a senha em setembro de 2007 tinha como senha provisória “pedras”.

Com o tempo essa estratégia passou a ser não apenas desnecessária, como impraticável. Já pensou tentar explicar ao usuário como escrever uma senha provisória “kraepelini” ou “sophiae”?

Nomes de versão

Nomear projetos e dar codinome de versão é um tipo de atividade muitas vezes necessária. Para isso terminei criando até mesmo um projeto próprio: o Multiverso.

Falando especificamente de CyanCD/CyanPack, a nomeação das versões não existia a princípio, depois passou por uma fase solta até 2008, quando passou a ter temas anuais. Cada ano o CyanCD/CyanPack tem um macrotema, um universo de nomes, e as versões daquele ano seguirão esse universo como guia.

Em 2008 tivemos a família vegetal Monardela; em 2009 foi a série Invent, homenageando inventores diversos; em 2010 foi a vez dos pilotos brasileiros de Fórmula 1; enquanto este ano de 2011 os nomes seguiram a série da família de formigas Technomyrmex. O universo de 2012 é dos moluscos Mitromorpha

Release

Versão

Mês de Lançamento

Codinome

Distibuição incluída

1

07/02/11

Fevereiro de 2007

Não tinha

DSL

2

07/04/11

Abril de 2007

Não tinha

?

3

07/05/11

Maio de 2007

Não tinha

?

4

07/06/11

Junho de 2007

Não tinha

Puppy Linux

5

07/07/11

Julho de 2007

Disco

Puppy Linux

6

07/08/11

Agosto de 2007

NTI

Puppy Linux

7

07/09/11

Setembro de 2007

Pedras

Puppy Linux

8

07/10/11

Outubro de 2007

Cogumelo

Puppy Linux

9

07/11/11

Novembro de 2007

Ilha

Puppy Linux

10

07/12/11

Dezembro de 2007

Natal

Puppy Linux

11

08/01/11

Janeiro de 2008

Monardela Antonina

Puppy Linux

12

08/02/11

Fevereiro de 2008

Monardela Cinerea

Puppy Linux

13

08/03/11

Março de 2008

Monardela Crispa

Puppy Linux

14

08/04/11

Abril de 2008

Monardela Glauca

Puppy Linux

15

08/05/11

Maio de 2008

Monardela Lanceolata

Puppy Linux

16

08/06/11

Junho de 2008

Monardela Linoides

Puppy Linux

17

08/07/11

Julho de 2008

Monardela Macrantha

Puppy Linux

18

08/08/11

Agosto de 2008

Monardela Nana

Puppy Linux

19

08/09/11

Setembro de 2008

Monardela Odoratissima

Puppy Linux

20

08/10/11

Outubro de 2008

Monardela Subglabra

Puppy Linux

21

08/11/11

Novembro de 2008

Monardela Undulata

Puppy Linux

22

08/12/11

Dezembro de 2008

Monardela Villosa

Puppy Linux

23

09/01/11

Janeiro de 2009

Adolph Rickenbacker

Puppy Linux

24

09/02/11

Fevereiro de 2009

Alberto Santos Dumont

Puppy Linux

25

09/03/11

Março de 2009

Alexander Grahan Bell

Puppy Linux

26

09/04/11

Abril de 2009

Bartolomeo Cristofori

Puppy Linux

27

9.4i (flisol)

Abril de 2009

Carlos Morimoto

Puppy Linux

28

09/05/11

Maio de 2009

Cornelius Drebbel

Puppy Linux

09/06/11

Junho de 2009

Não houve

 

29

09/07/11

Julho de 2009

Hans Lippershey

Puppy Linux

30

09/08/11

Agosto de 2009

Igor Sikorsky

Puppy Linux

31

09/09/11

Setembro de 2009

Louis e Auguste Lumière

Puppy Linux

32

09/10/11

Outubro de 2009

Martin Cooper

Puppy Linux

33

09/11/11

Novembro de 2009

Otto Wichterle

Puppy Linux

34

09/12/11

Dezembro de 2009

Robert Adler

Puppy Linux

35

10/01/11

Janeiro de 2010

Ayrton Senna

Puppy Linux

36

10/03/11

Março de 2010

Emerson Fittipaldi

Puppy Linux

37

10.4i (flisol)

Abril de 2010

Supertux Kart

Puppy Linux

38

10/05/11

Maio de 2010

Felipe Massa

Puppy Linux

39

10/07/11

Julho de 2010

Nelson Piquet

Puppy Linux

40

10/09/11

Setembro de 2010

José Carlos Pace

Puppy Linux

41

10/11/11

Novembro de 2010

Rubens Barrichello

Puppy Linux

42

11/01/11

Janeiro de 2011

Technomyrmex Albipes

Puppy Linux

43

11/02/11

Fevereiro de 2011

Technomyrmex Fulvus

Puppy Linux

44

11/03/11

Abril de 2011

Technomyrmex Ilgi

MacPup

45

11/04/11

Maio de 2011

Technomyrmex Jocosus

MacPup

46

11/05/11

Julho de 2011

Technomyrmex Kraepelini

Trisquel

47

11/06/11

Setembro de 2011

Technomyrmex Madecassus

Trisquel

48

11/07/11

Outubro de 2011

Technomyrmex Pallipes

Trisquel

49

11/08/11

Dezembro de 2011

Technomyrmex Sophiae

Trisquel

5031/01/12Fevereiro de 2012Mitromorpha AzorensisTrisquel
Special: 

As pessoas não querem produtos

Ano passado participei do I ESLAPE, Encontro de Software Livre do Agreste Pernambucano. Organizado por Marcelo Santana, o evento foi muito bom, apesar de alguns contratempos.

É comum haver contratempos. Nós planejamos o evento com atenção a todos os detalhes e no dia simplesmente algumas coisas terminam dando errado. É gente da equipe que adoece, são parceiros que não cumprem acordos (por esquecimento ou desleixo). Nós que já organizamos eventos (apesar de menores) sabemos bem como é. O que importa é que no final o evento foi muito bom e pretendo ir para uma eventual edição 2012.

Mas o que quero comentar aqui é sobre parte da palestra do Maddog Hall, diretor executivo da Linux International, o braço direito de Linus Torvalds.

Tive de voltar para casa logo depois da palestra por conta de um compromisso no dia seguinte, durante o dia. Por conta disso terminei não podendo acompanhar a palestra inteira, só um pedaço mesmo.

Uma parte que me lembro claramente e achei muito interessante, entretanto, diz respeito ao mundo atual, ao capitalismo, à indústria e o consumo, não estando preso ao "Linux" ou ao Software Livre. Ele disse que as pessoas não querem produtos, elas querem serviços.

Pode parecer estranho, mas se analisar bem isso é verdade. Há produtos que marcam e há pessoas que são fãs de certos produtos ou de certas tecnologias. Esses querem realmente os produtos. A maioria da população, porém, não é assim.

As pessoas não compram um carro porque querem ter o produto. O que elas querem ter é transporte de qualidade no momento em que for preciso. Isso se estende a muitas outras áreas e serve como base para justificar a importância cada vez maior da Computação nas Nuvens.

Pense bem: qual a vantagem de pensarmos em produtos, especialmente hoje num dia a dia de obsolecência programada e extrema? Claro: o fator econômico. Por isso faz mais sentido comprar um carro do que contratar serviço de uma empresa.

Outra coisa interessante que ele falou foi sobre commodities. Ele disse que a indústria tem usado o termo commodity de maneira inapropriada. Arroz é commodity, mas carro não é. Quando se vai comprar arroz, você não sabe dizer com clareza a diferença entre um produto e outro. Na prática, você termina levando em conta fatores como preço e afinidade com fabricante. Quando vai comprar um automóvel, você tem muitas características para avaliar: conforto, consumo, manutenbilidade, além do preço. Em sua visão, pra resumir, um commodity não é só um tipo de produto muito popular, mas um produto que não sabemos tanto a diferença entre os modelos no mercado. Você pode dizer para alguém "compre arroz para mim" e não se importar com a marca, mas dificilmente vai dizer para alguém "eu preciso de um carro: compre um pra mim".

É isso. Só umas ideias interessantes que vi na palestra e gostaria de compartilhar aqui com vocês. Apesar de ter levado um bom tempo para isso, finalmente aqui estão.

Special: 

Criando PDFs em Python com Reportlab

Se você não tem nada a ver com programação, nem tem interesse no assunto, simplesmente ignore este artigo.


Mike Driscoll tem um blog dedicado a Python chamado The Mouse vs. the Python e eventualmente há excelentes artigos por lá. Artigos estilo receita de bolo. Já traduzi um deles em outros tempos, falando sobre edição de registros do Windows: Editando o Registro do Windows em Python com o _winreg.

No final do ano passado, o Mike publicou um Top 10 de seus artigos. Aproveitei a lista e traduzi o artigo mais visitado de seu blog em 2011. Não é somente questão de popularidade, o artigo é muito bom e fala sobre como gerar arquivos PDF em Python: A Simple Step-by-Step Reportlab Tutorial.

Esta é uma tradução livre e modifiquei sutilmente algumas coisas, incluindo os exemplos. Agradeço ao Mike pelos excelentes artigos e me desculpo pelas liberdades que tomei na tradução (incluindo a mudança no nome do artigo). Vamos a ele!


O subtítulo deste artigo poderia facilmente ser "Como criar PDFs com Python", mas o Wordpress não suporta isso. De qualquer forma, a melhor biblioteca é a Reportlab.. Ela não é distribuída junto com a biblioteca padrão, de modo que você precisará baixá-la para poder executar com sucesso os exemplos deste tutorial. Você vai se deparar com pelo menos um exemplo de como colocar uma imagem no PDF, que quer dizer que você também precisará da Python Imaging Library (PIL). Pelo que entendi, Reportlab é compatível com Python 2.x, IronPython e Jython. Eles Eles estão trabalhando em um port para Python 3.x (ou estarão muito em breve)

Instalação

Reportlab suporta a maioria dos métodos de instalação em Python. Você tem a opção de baixar o código-fonte e rodar “python setup.py install” ou rodar um instalador de binário (em Windows). Havia uma discussão recente na lista de email que indicava que eles adicionariam suporte a pip também. A discussão que eu li sobre suporte do Reportlab ao easy_install é confusa, de modo que eu não estou certo se eles já dão suporte àquele método ou não. (Nota do Tradutor: em Trisquel ou outra distribuição GNU/Linux baseada em Debian, você pode instalar facilmente o Reportlab e o PIL com o comando "apt-get install python-reportlab python-imaging")

Criando um PDF simples

Reportlab tem uma documentação decente. O que eu quero dizer com isso é que a documentação nos dá aquilo de que precisamos para começar, mas quando você acha alguma coisa um tanto mais complexa para fazer, você tem correr com suas próprias pernas. Só recentemente eles adicionaram uma sessão Code Snippets ao site, que espero que venha a agrupar receitas, dicas e truques, de modo que melhore essa questão. Mas basta disso. Vamos ver como se cria alguma coisa.

No Reportlab, o componente de nível mais baixo que é usado regularmente é o objeto canvas do pacote pdfgen. As funções nesse pacote lhe permitem "pintar" um documento com seu texto, suas imagens, linhas ou o que você quiser. Eu

In Reportlab, the lowest-level component that’s used regularly is the canvas object from the pdfgen package. The functions in this package allow you to “paint” a document with your text, images, lines or whatever. Já ouvi algumas pessoas descreverem isso como escrever em Postscript. Eu tenho minhas dúvidas se isso é realmente tão ruim assim. Pela minha experiência, é bem parecido com você usar um toolkit para fazer interface gráfica em regiões específicas, com posicionamentos absolutos. Vejamos como o objeto canvas funciona:

from reportlab.pdfgen import canvas
 
c = canvas.Canvas("ola.pdf")
c.drawString(100,750,"Bem-vindo ao Reportlab!")
c.save()

Você terminará com um arquivo PDF parecido com isso:

PDF do exemplo, de Olá Mundo

A primeira coisa a se notar sobre esse código é que se quisermos salvar o PDF, precisamos fornecer um nome de arquivo ao objeto Canvas. O endereço para o arquivo pode ser um caminho tanto absoluto como relativo. Nesse exemplo, o PDF será criado no mesmo lugar onde você está quando chamar o script. A próxima peça do quebra-cabeças é o método drawString. Ele desenhará o texto do jeito que você mandar. Quando usamos o objeto canvas, ele começa no canto inferior esquerdo da página. Assim, para este exemplo, pedimos para desenhar o texto a 100 pontos da margem esquerda e a 750 pontos do canto inferior da página (1 ponto equivale a 1/72 polegada). Você pode mudar esse padrão no construtor do Canvas passando um zero ao parâmetro bottomup. Entretanto, eu não tenho muita certeza do que acontecerá se você fizer isso, já que o guia de usuário do Reportlab não é muito claro a esse respeito. A peça final do código que foi apresentado é a que salva o seu PDF.

Isso foi fácil! Você já criou um PDF simples! Note que o tamanho por padrão do Canvas já é A4, de modo que se você for estadunidense provavelmente desejará mudá-lo para o formato letter. É fácil fazer isso no Reportlab. Tudo o que você precisa fazer é o seguinte:

from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
 
canvas = canvas.Canvas('arquivo.pdf', pagesize=letter)
width, height = letter

A principal razão para pegar a largura e altura da página é que você pode definir margens, além de poder usá-las para fazer cálculos e decidir quando adicionar uma quebra de página. Vamos dar uma olhada por alto no construtor da classe Canvas para ver que opções nós temos mais:

def __init__(self,filename,
    pagesize=letter,
    bottomup = 1,
    pageCompression=0,
    encoding=rl_config.defaultEncoding,
    verbosity=0
    encrypt=None):

Esse código foi tirado diretamente do Guia de Usuário do Reportlab, página 11. Você pode ler sobre outras opções nesse guia se você quiser os detalhes completos.

Agora vamos fazer algo um pouco mais difícil e útil.

Um Pequeno Formulário, uma Pequena Função

Formulário em PDF

Neste exemplo, criaremos um formulário imprimível parcial. Até onde eu sei, o Reportlab não suporta aqueles formulários preenchíveis na tela, os que foram adicionados aos produtos Adobe no decorrer dos anos. De qualquer modo, vamos ao código!

from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
 
canvas = canvas.Canvas("form.pdf", pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
 
canvas.drawString(30,750,'COMUNICADO OFICIAL')
canvas.drawString(30,735,'EMPRESAS ACME')
canvas.drawString(500,750,"12/12/2011")
canvas.line(480,747,580,747)
 
canvas.drawString(275,725,'SALDO DEVEDOR:')
canvas.drawString(500,725,"R$ 1.000,00")
canvas.line(378,723,580,723)
 
canvas.drawString(30,703,'RECEBIDO POR:')
canvas.line(130,700,580,700)
canvas.drawString(130,703,"JOHN DOE")
 
canvas.save()

Isso é baseado no recibo atual que eu criei no trabalho. A principal diferença entre este e o exemplo anterior é o uso do método canvas.line. Você pode usá-lo para desenhar linhas no seu documento passando pares X-Y. Eu usei esta funcionalidade para criar grades, embora isso seja um saco. Outros pontos interessantes nesse código incluem o comando setLineWidth(.3), que diz ao Reportlab quão grossas devem ser as linhas; e o comando setFont('Helvetica', 12), que nos permite especificar a fonte e tamanho.

Nosso próximo exemplo vai envolver o que aprendemos até agora e nos introduzirá nos fluidos.

Indo com o Fluxo

Se você é um publicitário ou faz algum tipo de trabalho com cartas, então Reportlab será um excelente acréscimo ao seu arsenal. Nós o usamos para criar cartas de formulário para pessoas com bilhetes de estacionamento vencidos. O exemplo a seguir é baseado em algum código que eu escrevi para essa aplicação, embora a carta seja um tanto diferente. (Note que o código abaixo não rodará se você não tiver a Python Imaging Library instalada).

# -*- coding: UTF-8 -*-
import time
from reportlab.lib.enums import TA_JUSTIFY
from reportlab.lib.pagesizes import letter
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.units import inch
 
doc = SimpleDocTemplate("form_letter.pdf",pagesize=letter,
                        rightMargin=72,leftMargin=72,
                        topMargin=72,bottomMargin=18)
Story=[]
logo = "python-logo.png"
magName = "Pythonista"
issueNum = 12
subPrice = "99.00"
limitedDate = "03/05/2010"
freeGift = "Bisão de pelúcia"
 
formatted_time = time.ctime()
full_name = "Mike Driscoll"
address_parts = ["411 State St.", "Marshalltown, IA 50158"]
 
im = Image(logo, 2*inch, 2*inch)
Story.append(im)
 
styles=getSampleStyleSheet()
styles.add(ParagraphStyle(name='Justify', alignment=TA_JUSTIFY))
ptext = '<font size=12>%s</font>' % formatted_time
 
Story.append(Paragraph(ptext, styles["Normal"]))
Story.append(Spacer(1, 12))
 
# Create return address
ptext = '<font size=12>%s</font>' % full_name
Story.append(Paragraph(ptext, styles["Normal"]))
for part in address_parts:
    ptext = '<font size=12>%s</font>' % part.strip()
    Story.append(Paragraph(ptext, styles["Normal"]))
 
Story.append(Spacer(1, 12))
ptext = '<font size=12>Caro(a) %s:</font>' % full_name.split()[0].strip()
Story.append(Paragraph(ptext, styles["Normal"]))
Story.append(Spacer(1, 12))
 
ptext = '<font size=12>Gostaríamos de recebê-lo na nossa base de assinantes da Revista %s! \
        Você receberá %s edições pelo excelente preço inicial de $%s. Por favor responda até\
        %s para começar a receber nossa publicação e ainda levar esse maravilhoso presente: %s.</font>' % (magName,
                                                                                                issueNum,
                                                                                                subPrice,
                                                                                                limitedDate,
                                                                                                freeGift)
Story.append(Paragraph(ptext, styles["Justify"]))
Story.append(Spacer(1, 12))
 
 
ptext = '<font size=12>Agradecemos muito e esperamos seu retorno para lhe servir.</font>'
Story.append(Paragraph(ptext, styles["Justify"]))
Story.append(Spacer(1, 12))
ptext = '<font size=12>Atenciosamente,</font>'
Story.append(Paragraph(ptext, styles["Normal"]))
Story.append(Spacer(1, 48))
ptext = '<font size=12>Ima Sucker</font>'
Story.append(Paragraph(ptext, styles["Normal"]))
Story.append(Spacer(1, 12))
doc.build(Story)

Bem, aqui teve muito mais código do que nos nossos exemplos anteriores. Precisaremos olhá-lo com calma para entendermos tudo o que está sendo feito. Quando você estiver pronto, simplesmente continue lendo. (N. T. Como traduzi o código do exemplo e o adaptei sutilmente, fez-se necessário o uso daquela primeira linha de comentário no código, que diz ao Python que o código a seguir está em Unicode. Se você salva seus arquivos em ISO-8859-1, basta colocar esse código no lugar de UTF-8 que está tudo bem).

A primeira parte que precisamos olhar são as novas linhas de importação:

from reportlab.lib.enums import TA_JUSTIFY
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.units import inch

De enums, importamos “TA_JUSTIFY”, que permite que nossas strings tenham formatação justified. Há várias outras constantes que podemos usar: alinhamento à direita, à esquerda e algumas outras coisas divertidas. Em seguida temos o módulo platypus (que vem de Page LAyout and TYPography Using Scripts. N. T.: platypus também significa "ornitorrinco"). Ele contem um monte de módulos, mas provavelmente os mais importantes deles são os fluidos, como o Paragraph. Um fluido tem tipicamente os seguintes atributos: wrap, draw e algumas vezes split. Eles são usados para escrever com facilidade parágrafos, tabelas e outras construções de múltiplas páginas.

A classe SimpleDocTemplate nos permite definir em só lugar margens, tamanho da página, nome do arquivo e uma pá de outras configurações para o nosso documento. Um "Spacer" é bom para adicionar uma linha em branco, como uma quebra de parágrafo. A classe Image utiliza a Python Image Library para nos permitir inserir e manipular facilmente uma imagem no nosso PDF.

O getSampleStyleSheet pega um conjunto de estilos padrão que podemos usar no nosso PDF.  ParagraphStyle é usado para definir o alinhamento do nosso parágrafo nesse exemplo, mas pode fazer muito mais do que isso (veja a página 67 do guia de usuário). Pra terminar, inch (polegada) é uma unidade de medida para ajudar no posicionamento de itens no seu PDF. Você pode vê-lo em ação quando nós posicionamos o logo: Image(logo, 2*inch, 2*inch). Isso quer dizer que o logotipo estará a duas polegadas do topo e a duas polegadas da esquerda.

Não recordo a razão para que os exemplos do Reportlab usem uma lista Story, mas é como nós faremos aqui também. Basicamente você cria uma linha de texto, uma tabela e imagem ou o que você quiser e as anexa à Story list. Você verá isso por todo o nosso exemplo. A primeira vez que fizemos isso foi quando adicionamos a imagem. Antes de prosseguir, precisamos olhar como adicionamos um estilo ao nosso objeto de estilos.

styles.add(ParagraphStyle(name='Justify', alignment=TA_JUSTIFY))

A razão para isso é importante e é para que você possa utilizar a lista de estilo para vários parágrafos de texto do seu documento. No código anterior, criamos um estilo de parágrafo chamado "Justify". Tudo o que ele faz é justificar nosso texto. Você verá um exemplo disso depois no texto. Por ora, vamos ver um exemplo rápido

ptext = '<font size=12>%s</font>' % formatted_time
Story.append(Paragraph(ptext, styles["Normal"]))

Para a nossa primeira linha de texto, usamos a classe Paragraph. Como você pode ver, a classe Paragraph aceita algumas tags estilo HTML. Aqui nós definimos o tamanho da fonte para 12 e usamos o estilo normal (que é alinhado à esquerda, entre outras coisas). O resto do exemplo é basicamente a mesma coisa, só que com espaçadores (Spacers) colocados aqui e ali. No fim, nós chamamos doc.build para criar o documento.

Resumindo

Agora você sabe o básico sobre criação de PDFs em Python usando Reportlab. Nós nem sequer arranhamos a superfície daquilo tudo que podemos fazer com Reportlab. Alguns exemplos incluem tabelas, gráficos, paginação, sobreposição de cores, links, gráficos e muito mais. Eu recomendo bastante que você baixe o módulo junto com o guia de usuário e mande ver!

Páginas