Pisa é um conversor de HTML/XHTML/CSS para PDF, escrito em Python e baseado nas bibliotecas Reportlab, PyPDF, TechGame Networks CSS e HTML5lib. Seu foco principal não é gerar páginas perfeitas para impressão, mas utilizar HTML e CSS para gerar PDFs dentro de aplicações.
A instalação pode ser feita através do código no site do projeto ou pelo comando easy_install pisa.

Crie um arquivo chamado report.py dentro do diretório do projeto contendo o código abaixo:

# -*- coding: utf-8 -*-
from django import http
from django.template.loader import get_template
from django.template import Context
import ho.pisa as pisa
import cStringIO as StringIO
import cgi, os
 
 
def fetch_resources(uri, rel):
    path = '/path/para/diretorio/contendo/imagens/a/serem/exibidas'
    return path
 
def write_to_pdf(template_src, context_dict, filename):
    template = get_template(template_src)
    context = Context(context_dict)
    html  = template.render(context)
    result = StringIO.StringIO()
    pdf = pisa.pisaDocument(StringIO.StringIO(html.encode("UTF-8")), result, link_callback=fetch_resources)
    if not pdf.err:
        response = http.HttpResponse(mimetype='application/pdf')
        response['Content-Disposition'] = 'attachment; filename=%s.pdf' % filename
        response.write(result.getvalue())
        return response
    return http.HttpResponse('Problema ao gerar PDF: %s' % cgi.escape(html))

E agora, dentro de uma view, é preciso importar o arquivo report.py e chamar a função write_to_pdf para fazer a conversão:

# views.py
from report import write_to_pdf
 
def listar_clientes_cadastrados(request):
    clientes = Cliente.objects.all()
    return write_to_pdf('relatorio.html', {'clientes': clientes}, 'nome_do_arquivo_pdf')

A função write_to_pdf recebe como parâmetro o nome do arquivo HTML que será convertido, as variáveis que serão tratadas dentro desse arquivo e o nome que o arquivo PDF sem a extensão. Retorna o download do arquivo PDF.

Conforme citado no início do post, a conversão não é perfeita. Por exemplo, às vezes uma tabela apresenta mínimas deformações, não fica igual como na versão HTML. Apesar disso Pisa é uma ótima solução que muitas vezes ajuda bastante e, como puderam ver, é muito fácil de usar.

Compartilhe esse artigo

KinterbasDB é uma biblioteca open source para Python que possibilita acessar banco de dados Firebird e algumas versões do Interbase.
O download pode ser feito na página do projeto.

Após o download, descompacte o pacote kinterbasdb-3.2.src.tar.gz.
Abra um terminal, entre no diretório onde o kinterbasdb foi descompactado e execute o comando python setup.py build. O script de instalação, setup.py, automaticamente vai detectar as informações necessárias pelo compilador C.
Se não ocorreu nenhum erro, execute o comando python setup.py install para instalar no diretório padrão de módulos do Python (varia de acordo com a distro).

root@localhost: ~# wget http://downloads.sourceforge.net/project/kinterbasdb/kinterbasdb/kinterbasdb-3.2/kinterbasdb-3.2.src.tar.gz?use_mirror=ufpr
root@localhost: ~# tar zxvf kinterbasdb-3.2.src.tar.gz
root@localhost: ~# python setup.py build
Succeeded:
  /usr/bin/python setup.py build
root@localhost: ~# python setup.py install

Para testar se foi instalado corretamente:

root@localhost: ~# python -c "import kinterbasdb as k; print k.__version__"
(3, 2, 0, 'final', 0)
root@localhost: ~#

É possível que apareça uma mensagem de erro em distros baseadas no Ubuntu:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
kinterbasdb.OperationalError: (-901, 'begin transaction: \n  invalid parameter in transaction parameter block')

Para corrigir esse problema é preciso usar uma outra versão do arquivo __init__.py.
Faça o download em https://firebird.svn.sourceforge.net/svnroot/firebird/qa/trunk/kinterbasdb/__init__.py e substitua o arquivo existente no diretório kinterbasdb.

root@localhost: ~# wget https://firebird.svn.sourceforge.net/svnroot/firebird/qa/trunk/kinterbasdb/__init__.py
root@localhost: ~# mv __init__.py /usr/lib/python2.5/site-packages/kinterbasdb/

Exemplo para Firebird-2.1 em servidor Windows:

import kinterbasdb
conn = kinterbasdb.connect(
    host='192.168.0.2',
    database='C:\\Dados\\meubanco.fdb',
    user='sysdba',
    password='masterkey'
)
cur = conn.cursor()
cur.execute('SELECT id, nome, telefone FROM tabela')
for (id, nome, telefone) in cur:
    print 'ID: %s, Nome: %s, Fone: %s' % (id, nome, telefone)

Compartilhe esse artigo

Utilizando as classes do projeto

Vamos supor nesse exemplo que o nome projeto em Django seja meuprojeto, a aplicação minhaapp e o script relatorio.py. Nomes nada criativos, eu sei, mas se você entendeu… é isso que importa.
Então vamos criar o arquivo /usr/bin/relatorio.py contendo as linhas abaixo:

#!/usr/bin/python
from django.core.management import setup_environ
import sys, datetime, settings
PROJECT_PATH = '/home/usuario/www/django/meuprojeto'
sys.path.insert(0, PROJECT_PATH)
setup_environ(settings)

O código acima é tudo que se precisa para usar o projeto dentro do script.
Como exemplo, vamos criar a classe Relatorio, importar a aplicação em Django e instanciar as classes que queremos usar:

# Importamos a classe Cliente
from minhaapp.models import Cliente
 
# Classe para trabalhar com o projeto em Django
class Relatorio(object):
    def teste_exibir_clientes_cadastrados(self):
        clientes = Cliente.objects.all()
        print clientes
 
# Instanciamos a classe Relatorio e executamos o método
rel = Relatorio()
rel.teste_exibir_clientes_cadastrados()

Agora no terminal:

$ sudo chmod +x /usr/bin/relatorio.py
$ relatorio.py

Viram como é fácil trabalhar com o projeto em Django em outro ambiente?!
Agora só falta renderizar um template e enviar o resultado por e-mail.

Renderizando um template

Temos o template relatorio.html localizado no diretório de templates do projeto:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html lang="pt-br">
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<title>Relatório de Clientes Cadastrados</title>
</head>
<body>
<h2>Clientes cadastrados</h2>
{% for cliente in clientes %}
    Nome: {{ cliente.nome }}<br>
{% endfor %}
</body>
</html>

Vamos obter os clientes cadastrados, passar o resultado ao template e enviar um e-mail no formato HTML contendo o template renderizado.
O script final deve ficar assim:

#!/usr/bin/python
 
"""Dependendo da distro o caminho para o python acima pode ser outro"""
 
from django.core.management import setup_environ
import sys, datetime, settings
PROJECT_PATH = '/home/gustavo/www/django/meuprojeto'
sys.path.insert(0, PROJECT_PATH)
setup_environ(settings)
 
from email.MIMEMultipart import MIMEMultipart
from email.MIMEText import MIMEText
from email.MIMEImage import MIMEImage
from smtplib import SMTP
import email.Charset
from unicodedata import normalize
 
 
class Relatorio(object):
    def __init__(self):
        """
        Construtor da classe
        """
 
        self.charset = 'utf-8'
        self.smtp_server = 'smtp.provedor.com.br'
        self.smtp_user = 'usuario'
        self.smtp_pass = 'senha'
        self.sender = 'meu@email.com.br'
        self.sender_name = 'Meu Nome Completo'
 
 
    def render(self, context, template):
        """
        Retorna o template renderizado
        """
 
        if template:
            t = loader.get_template(template)
            return t.render(Context(context))
 
 
    def enviar_relatorio(self):
        clientes = Cliente.objects.all()
 
        # Se nao houver clientes cadastrados...
        if not clientes.count() > 0:
            print u'Erro: Nenhum cliente cadastrado. O e-mail não foi enviado.'
        else:
            # Passa os clientes cadastrados para a variavel clientes no template
            context = {'clientes': clientes}
 
            # Obtem o template renderizado 
            html = self.render(context, 'relatorio.html')
 
            # A funcao normalize remove caracteres acentuados
            html = normalize('NFKD',html).encode('ASCII','ignore')
 
            # Mais detalhes sobre o módulo email, consulte a docuemtacao do python     
            msg_principal = MIMEMultipart('related')
            msg_principal['Subject'] = 'Relatorio de clientes'
            msg_principal['From'] = '%s <%s>' % (self.sender, self.sender_name)
            msg_principal['To'] =  '%s <%s>' % (recipient, recipient_name)
            msg_principal.preamble = 'This is a multi-part message in MIME format.'
 
            msg_alternativa = MIMEMultipart('alternative')
            msg_alternativa.attach(MIMEText(html, 'html', _charset=self.charset))
            msg_principal.attach(msg_alternativa)
            msg_alternativa.attach(MIMEText('Essa e uma mensagem alternativa', _charset=self.charset))
            msg_alternativa.attach(MIMEText(html, 'html', _charset=self.charset))
 
            # Tenta enviar o email
            try:
                smtp = SMTP()
                smtp.connect(self.smtp_server)
                smtp.login(self.smtp_user, self.smtp_pass)
                smtp.sendmail(self.sender, recipient, msg_principal.as_string())
                smtp.quit()
            except:
                print u'Erro: Não foi possível enviar o e-mail.'
 
 
# Instanciamos a classe Relatorio e executamos o método
rel = Relatorio()
rel.enviar_relatorio()

Conclusão

Acessar o ORM do Django por um script Python permite criar muitas coisas interessantes. Imagine criar um projeto no Django e usar suas classes e métodos em um projeto Python + QT por exemplo? E scripts produzindo logs em banco de dados em vez de jogar na tela ou no Syslog, tornando possível a visualização em ambiente web?
A imaginação é o limite.

Compartilhe esse artigo

Primeiro é necessário que você tenha instalado na sua máquina de desenvolvimento a PIL, rodando em ambiente Linux.
O processo de instalação consiste em copiar o diretório PIL e o arquivo PIL.pth para dentro do diretório do projeto criado com o Django. Após copiar, remova todos os arquivos .pyc do diretório PIL, deixando apenas os arquivos .py e .so.

Ex.:

[gu@notebook]$ ls
minhapp __init__.py manage.py PIL PIL.pth settings.py templates urls.py


No meu notebook com Ubuntu instalado, o diretório PIL e o arquivo PIL.pth encontram-se em /usr/lib/python2.5/site-packages. No servidor da KingHost a versão do Python é a 2.4 porém assim mesmo funcionou.
Caso alguém não consiga, estou disponibilizando a versão que utilizo com sucesso aqui: www.gustavohenrique.net/files/pil.tar.gz

Compartilhe esse artigo

Django é um framework MVC para desenvolvimento web escrito em python. Proporciona velocidade no desenvolvimento, código limpo e organizado e uma poderosa ferramenta de administração.
Essa é a primeira parte de uma série de artigos sobre como criar um sistema de gestão de provedor de internet utilizando Django, MySQL, Javascript (JQuery), Ajax com JSON, CSS e Linux. No momento abordaremos apenas a parte de cadastro de clientes.
Para melhor entendimento, é desejável conhecimento básico em desenvolvimento web, Python e Linux.
Instalação, características, manual e outras informações podem ser encontradas no site Django Brasil.

Sobre o Sistema

Como forma de estudo, resolvi portar as funcionalidades básicas de um sistema antigo que desenvolvi em PHP para Django. Trata-se de um sistema de gestão de provedor de internet, que possibilita o cadastro de clientes, controle de banda, regras de firewall, fluxo de caixa e relatórios gerenciais, interagindo com ferramentas em ambiente Linux. Chamaremos nosso sistema de Sigep – Sistema de Gestão de Provedor. Nome nada criativo, eu sei, mas vamos deixar assim mesmo.

Iniciando

O sistema completo será desenvolvido em Linux, utilizando softwares específicos para o mesmo. É possível desenvolver em Windows e MacOS X, porém o ambiente de produção necessariamente deve ser Linux. Abaixo a descrição do ambiente de desenvolvimento utilizado:

Sistema Operacional: Ubuntu 8.04
IDE/Editor: Komodo Edit para códigos do Django e Geany 0.13 para HTML e CSS
Banco de Dados: MySQL 5.0
Linguagem: Python: 2.5 e Django 1.0

Instalação

Não será abordado o processo de instalação nesse artigo. No site www.djangobrasil.com tem um ótimo tutorial de instalação em Windows e Linux.

Projeto Vs. Aplicação

Em Django, projeto é o sistema no todo e aplicação é um módulo desse sistema. No nosso projeto Sigep, teremos várias aplicações (módulos), que são: cliente, rede, relatório, etc. Você pode criar uma única aplicação contendo toda funcionalidade do sistema, porém isso deixaria o código mais extenso e de difícil manutenção.

Criando o Projeto

Abra um terminal, entre no diretorio onde deseja trabalhar e crie o projeto com o script django-admin.py.

gu@notebook:~$ mkdir projetos
gu@notebook:~$ cd projetos
gu@notebook:~$ django-admin.py startproject sigep
gu@notebook:~$ cd sigep
gu@notebook:~$ ls sigep
__init__.py manage.py settings.py urls.py


O django-admin.py criou um diretório com o nome do projeto contendo os seguintes arquivos:

__init__.py: Arquivo vazio. Serve apenas para identificar que é um pacote python
manage.py: Script para gerenciar o projeto no django
settings.py: Arquivo de configuração do projeto
urls.py: Onde é definido o mapeamento das URLs

Configurando o Projeto

Vamos editar o arquivo settings.py e incluir as linhas abaixo:

1
2

import os
LOCAL = lambda *args:os.path.join(os.path.dirname(__file__), *args)

As linhas acimas criam uma função para retornar o caminho absoluto do diretório do nosso projeto. Agora vamos alterar as seguintes variáveis:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

DATABASE_ENGINE = 'mysql'
DATABASE_NAME = 'sigepdjango'
DATABASE_USER = 'usuario_do_mysql_aki'
DATABASE_PASSWORD = 'senha_do_usuario_do_mysql_aki'
 
TIME_ZONE = 'America/Sao_Paulo'
 
LANGUAGE_CODE = 'pt-br'
 
MEDIA_ROOT = LOCAL('files')
 
TEMPLATE_DIRS = (
    LOCAL('templates')
)

O que fizemos acima foi configurar o projeto para acessar nosso banco de dados no MySQL, ajustar o timezone e idioma de acordo com o Brasil, setar o MEDIA_ROOT, que é o diretório onde nossos arquivos externos serão armazenados e definir o diretório templates onde nossos arquivos HTML ficarão.
Agora vamos criar nossa aplicação.

Compartilhe esse artigo