Django é o framework ideal para os que buscam agilidade e simplicidade. Um dos recursos que mais gosto é o Admin, uma poderosa interface para produzir conteúdo. Simples de usar, bastante customizável e com um visual agradável, bastante útil durante a fase de desenvolvimento e ideal para pequenos projetos com ausência de um designer na equipe. Outras caracteristicas interessantes são:

• API para autenticação de usuários com suporte à grupos e níveis de acesso, que permite a criação de permissões personalizadas para cada página, classe ou método;
• Sistema de cache que torna mais rápido o carregamento das páginas e o acesso ao banco de dados;
• Sistema de templates utilizando HTML, com suporte a herança e Template Tags – uma linguagem de templates para manipulação de conteúdo dinamicamente. É possível criar suas próprias com código Python e utiliza-las em qualquer parte do projeto;
• Trabalhar com formulários e extremamente simples e há diversos tipos de validações disponíveis como por exemplo e-mail, cpf e endereço IP;
• ORM compatível com os bancos de dados mais utilizados no mercado;
• Paginação é uma tarefa trivial;
• Incrível suporte à internacionalização;
• É multiplataforma;
• Documentação bem completa e de fácil entendimento;
• Comunidade altamente ativa.

Por utilizar Python, é compatível com uma grande variedade de bibliotecas para trabalhar com xml, json, webservices, restful, graficos, relatorios, imagens e etc. Sem dúvida uma ótima escolha para quem procura agilidade com produtividade.

Essa foi minha opinião expressada no debate Django vs. Ruby on Rails, matéria da revista TiDigital (edição 16 de junho/2010).

Compartilhe esse artigo

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

Um formulário dinâmico é aquele que o usuário pode definir quais campos vão existir. O programador não precisa criar código para cada formulário.
Imagine um sistema que necessite de diversos tipos de formulários. Tarefa no mínimo entediante para o responsável pela manutenção. E se o usuário puder criar e modificar um formulário por uma interface gráfica fácil de usar? Seria muito bom para o programador!
O segredo desse dinamismo é o uso de metaclasses, que são classes cujas instâncias também são classes.
O truque é criar em tempo de execução uma metaclasse da classe forms.Form. Atributos dos campos como label, tipo, max length etc, podem ficar armazenados no banco de dados. Os valores dos campos podem ficar em outra tabela com uma referência de chave estrangeira. Usando o ORM do Django é muito simples, e de quebra já ganha uma interface gráfica para administrar tudo (admin).
Sendo assim, o usuário poderia montar os campos do formulário definindo um label, tipo de campo, se é obrigatório ou não, valor padrão… e essas informações ficarão no armazenadas no BD. Fica fácil criar um código para pegar essas informações, criar uma nova classe Form em tempo de execução, instância-la e renderizar no template.

Exemplo:

# views.py
 
from django.views.generic.simple import direct_to_template
from django.forms import forms, fields
 
def montar_formulario_dinamico(request):
    campos_dinamicos = {
        'nome': fields.CharField(max_length=100, required=True, label='Nome', initial='Gustavo'),
        'idade': fields.IntegerField(label='Idade', min_value=0),
        'email': fields.EmailField(max_length=200, required=False, label='E-mail')
    }
 
    FormDinamico = type('', (forms.Form,), campos_dinamicos)
    form = FormDinamico()
 
    return direct_to_template(request, 'formulario.html', extra_context={'formulario': form})

Fica a dica!

Compartilhe esse artigo

Instalação

Há diversas maneiras de se instalar um sistema feito em django. Vou mostrar como fazer o deploy usando Apache2 com o módulo mod_wsgi.
O ambiente completo usa Apache2, sqlite3, python-2.6 e Django-1.1.

root@localhost# apt-get install apache2 libapache2-mod-wsgi sqlite3 python-pysqlite2 python-django

O diretório web padrão do Apache no Ubuntu é o /var/www. Vamos manter assim. Faça o download do Bandcontrol pelo site github.com (no site, clique no botão Download Source), descompacte no /var/www, renomeie o diretório para bandcontrol e altere o dono/grupo de acordo com o usuário do apache.

root@localhost: /var/www# tar zxvf gustavohenrique-bandcontrol-XXXXXX.tar.gz
root@localhost: /var/www# mv gustavohenrique-bandcontrol-XXXXXX bandcontrol
root@localhost: /var/www# chown www-data.www-data -Rf bandcontrol

Os shell scripts usam o Iptables para firewall e TC para controle de banda. É necessário permissão de super usuário para executar esses comandos. Vamos configurar o sudo para que o usuário do Apache possa executar tais comandos como root.

root@localhost: /var/www# chmod +w /etc/sudoers
root@localhost: /var/www# vim /etc/sudoers

Adicione essas linhas no arquivo /etc/sudoers:

# No Ubuntu o iptables e o tc estao dentro do /sbin
Cmd_Alias BANDCONTROL = /sbin/iptables, /sbin/tc
www-data  ALL = (ALL) NOPASSWD: BANDCONTROL

Configuracao do Apache

Configure um virtualhost no apache criando o arquivo /etc/apache2/sites-enabled/bandcontrol contendo:

WSGIRestrictStdout Off
NameVirtualHost bandcontrol
<VirtualHost bandcontrol>
        ServerAdmin webmaster@localhost
        LimitInternalRecursion 1000
        ServerName bandcontrol
 
        <Directory /var/www/bandcontrol>
                Options ExecCGI FollowSymLinks MultiViews
                AllowOverride FileInfo
                MultiviewsMatch Handlers
                Order deny,allow
                Allow from all
        </Directory>
 
        ErrorLog /var/log/apache2/bandcontrol_error.log
        CustomLog /var/log/apache2/bandcontrol_access.log combined
 
        WSGIScriptAlias /     "/var/www/bandcontrol/config.wsgi"
 
        Alias /admin_media/ "/usr/lib/pymodules/python2.6/django/contrib/admin/media/"
        Alias /media/           "/var/www/bandcontrol/media/"
</VirtualHost>

Edite o /etc/hosts e adicione:

127.0.0.2     bandcontrol

Configuracao do Bandcontrol

Altere o arquivo /var/www/bandcontrol/config.wsgi ajustando o diretório de instalação do Django. O padrão do Ubuntu é /usr/lib/pymodules/python2.6/django. Nesse arquivo também é configurado o diretório do bandcontrol:

import os, sys
PROJECT_ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, PROJECT_ROOT_PATH)
sys.path.append('/usr/lib/pymodules/python2.6/django/')
sys.path.append('/var/www')
os.environ['DJANGO_SETTINGS_MODULE']='settings'
import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()
 
import bandcontrol.monitor
bandcontrol.monitor.start(interval=1.0)

No arquivo /var/www/bandcontrol/settings.py é possível fazer mais alterações.
Para definir as interfaces de rede e classe IP utilizada na rede, edite os arquivos /var/www/bandcontrol/scripts/CONFIG e /var/www/bandcontrol/scripts/firewall.

Por padrão é utilizado o banco de dados sqlite3. Você pode escolher usar o MySQL ou PostgreSQL editando o arquivo /var/www/bandcontrol/settings.py.
Para criar o BD, entre no diretório do bandcontrol e execute o comando manage.py syncdb. Digite yes para confirmar a criação do super usuário. Forneça um login, e-mail e senha:

root@localhost: /var/www/bandcontrol# python manage.py syncdb
Creating table auth_permission
Creating table auth_group
Creating table auth_user
Creating table auth_message
Creating table django_content_type
Creating table django_session
Creating table django_site
Creating table django_admin_log
Creating table rede_plano
Creating table rede_pontorede
 
You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no): yes
Username (Leave blank to use 'root'): gustavo
E-mail address: eu@gustavohenrique.net
Password:
Password (again):
Superuser created successfully.
Installing index for auth.Permission model
Installing index for auth.Message model
Installing index for admin.LogEntry model
Installing index for rede.PontoRede model

Reinicie o Apache para que as alterações tenham efeito.

Utilização

Abra o browser e acesse http://bandcontrol/.
Reparem que no campo de endereço da URL e os nomes de usuário utilizados não condizem com o que foi exemplificado nesse artigo. Bom... estou com preguiça para alterar as imagens, então vamos desconsiderar esse "bug".

Entre com o login e senha criados no passo anterior.

Tela inicial do sistema.

Clique em Planos e vamos criar alguns.

Volte à tela inicial, clique em Pontos de Rede. No menu superior há opção para executar o firewall, parar o controle de banda e exibir os IPs conectados ao servidor. Sempre que fizer alguma alteração no sistema deve executar o firewall para ativar as mudanças.

Em exibir IPs conectados, para adicionar um IP no sistema forneça uma descrição única, escolha o plano e clique em [+].

O bandcontrol permite criar outros usuários com acesso ao sistema. Trabalha com permissões e grupos. Cortesia do Django \o/

Conclusão

Bandcontrol foi uma daquelas coisas "pra ontem". Foi feito em uma tarde de terça-feira. Tal velocidade se deve ao framework Django.
Esse artigo foi escrito um pouco de cada vez, por isso há grandes chances de algo sair errado. Há muito material disponível na web sobre deploy de projetos em Django. Em caso de dúvidas estarei disposto a ajudar.

Compartilhe esse artigo

Tela do jqDjangoGrid

jqDjangoGrid é um plugin para JQuery com uma aplicação plugável do Django para criar um datagrid.
Fácil de instalar e customizar, possui ordenação de resultados e pesquisa usando ajax.
Atualmente não suporta recurso de inserir ou alterar registros diretamente no datagrid, mas possui um método genérico para remoção de registros e outro que retorna a PK (Primary Key) do objeto selecionado.

INTRODUÇÃO

Neste artigo mostrarei como é fácil instalar e usar o jqDjangoGrid. Todos os códigos estão comentados para ajudar à quem precisar fazer alguma modificação, por isso eu aconselho a usar algum compactador de código javascript se for usar em ambiente de produção.
O tema padrão é o mesmo utilizado em um artigo anterior sobre datagrid com django, usando tons cinzas e azul. É fácil criar novos temas, bastar alterar o arquivo CSS e substituir as imagens.

Estou disponibilizando 2 arquivos para download, um contendo apenas o jqDjangoGrid e o outro contendo uma aplicação de exemplo (Um cadastro de bookmarks). É necessária a biblioteca JQuery para funcionar. Os pacotes estão com a versão 1.3.2 dessa biblioteca.

Download:

Baixe a última versão com um exemplo no site github.com.
Código no GitHub

INSTALAÇÃO E UTILIZAÇÃO

Instalação:

1. Descompacte o pacote jqdjangogrid.tar.gz;
2. copie o diretório jqdjangogrid, que é a app em django, para o diretório do seu projeto;
3. Copie os arquivos .js para o diretório de arquivos javascript do seu projeto (dento do MEDIA_ROOT);
4. Copie o diretório themes para o diretório de arquivos CSS do seu projeto (também dentro do MEDIA_ROOT)

Utilização:

Insira jqdjangogrid em INSTALLED_APPS localizada no settings.py e depois crie uma regra no urls.py.

INSTALLED_APPS = (
    # outras apps instaladas aqui
    'jqdjangogrid',
)

urlpatterns = patterns('',
    # suas outras regras aqui
    (r'^jqdjangogrid/', include('jqdjangogrid.urls')),
)

Inclua uma referência para os arquivos jqdjangogrid.css, jquery.js e jqdjangogrid.js dentro do template HTML principal. Ex.:

<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<link rel="StyleSheet" type="text/css" href="/path_to_your_css/css/themes/default/jqdjangogrid.css">
<script language="JavaScript" type="text/javascript" src="/path_to_your_js/jquery.js"></script>
<script language="JavaScript" type="text/javascript" src="/path_to_your_js/jqdjangogrid.js"></script>
...

Crie um div qualquer para servir como contâiner para o datagrid.

<div id="mydatagrid"></div>

Agora é só criar um objeto datagrid passando as configurações. Abaixo um exemplo com as configurações básicas criado no momento em que a página é carregada:

<!-- dentro da tag head -->
<script type="text/javascript">
$(document).ready(function() {
    $('#mydatagrid').datagrid({
        'appLabel': 'myapp',
        'modelName': 'MyClassName',
        'cols': {
            "pk": {"label": "", "width":"10px"},
            "field1": {"label": "Campo 1", "width": "100px"},
            "field2": {"label": "Campo 2", "width": "300px"},
        },
    });
});
</script>

Assim, ao carregar a página, será criado um datagrid contendo 3 colunas. Quando o nome da coluna for pk, vai aparecer um radio input cujo valor é a chave primária. Os outros atributos do campo são largura e label que vai aparecer no datagrid.

Conheça outros recursos na próxima página.

Compartilhe esse artigo

INTRODUÇÃO

O funcionamento da integração com o PagSeguro é simples:

1. Preenchimento do form com dados do pedido:
   Uma view do site renderiza um template contendo um form com campos ocultos (input type=”hidden”) preenchidos com dados sobre o pedido.
2. Envio dos dados à URL do pagseguro:
   O form é submetido via POST para a URL do PagSeguro que recebe os dados do pedido e exibe a tela de escolha da forma de pagamento.
3. Envio dos dados sobre a transação:
   Após o comprador escolher a forma de pagamento, o robô do PagSeguro envia em segundo plano um POST para a URL de retorno configurada pelo vendedor no site do PagSeguro. Em seguida redireciona o comprador para essa mesma URL de retorno.

A parte mais complicada é no passo 3, onde ocorre a comunicação em segundo plano (invisível ao usuário, não aparece no browser).
O robô do PagSeguro envia um POST para a URL de retorno definida pelo vendedor. Então é preciso verificar nessa URL se houve alguma requisição via POST. Então o método da view envia uma requisição ao PagSeguro, também em segundo plano, contendo os mesmos dados obtidos via POST e um código único (token) definido no painel de configuração da conta no site do PagSeguro. Após verificado a autenticidade da transação, os dados são armazenados no banco de dados para que o cliente possa acompanhar o status do pedido diretamente no seu site.

MÃO NA MASSA

Não será abordado quais campos e tipos de dados que devem ser enviados ao PagSeguro. Essas informações estão bem documentadas no site do mesmo.
No momento apenas será descrito como verificar a autenticidade da transação.

Vamos criar uma app chamada utils. Dentro do diretório dessa app, criamos o arquivo pagamentolib.py.

$ python manage.py startapp utils
$ vim utils/pagamentolib.py

Eis o código do pagamentolib.py:

# -*- coding: utf-8 -*-
 
import sys
import urllib2, urllib
from django.http import HttpResponse
 
 
class Pagamento(object):
 
    def _conectar(self, url, params):
        query_str = urllib.urlencode(params)
        req = urllib2.Request(url, query_str)
        f = urllib2.urlopen(req)
        conteudo = f.read()
        f.close()
        return conteudo
 
    def _enviar(self, url, params):
        retorno = self._conectar(url, params)
        if retorno.lower() == 'verificado':
            return True
        else:
            return False
 
 
class PagSeguro(Pagamento):
    def processar(self, token, params, url='https://pagseguro.uol.com.br/Security/NPI/Default.aspx'):
        if not params:
            return False
        else:
            lista = []
            for key in params.keys():
                lista.append((key,params[key]))
            lista.append(('Comando', 'validar'))
            lista.append(('Token', token))
 
            return self._enviar(url, lista)

Como exemplo, nossa URL de retorno é http://www.seusite.com/concluir/, que chama o método concluir contido na app carrinho

# -*- coding: utf-8 -*-
 
from django.views.generic.simple import direct_to_template
from meuprojeto.utils.pagamentolib import PagSeguro
 
def concluir(request):
    """
    Descricao:
    Armazena os dados do pedido e exibe a tela de pedido concluido.
    Verifica se o robo do PagSeguro enviou os dados do pedido via POST, e
    então armazena no banco de dados.
    Por fim, exibe a tela de pedido concluido com sucesso.
    """
 
    if request.method == 'POST':
        # token gerado no painel de controle do PagSeguro
        token = '12345699CA2AAAF4599EA697BB2F7FFF'
        p = PagSeguro()
        retorno = p.processar(token, request.POST)
 
        if retorno == True:
            try:
                # Cadastra os dados recebidos no banco de dados.
                # Utilize o request.POST.get('nomedocampo') para obter os valores
            except:
                pass
            return HttpResponse('Ok')
        else:
            return HttpResponse('Error')
 
    else:
        # Carrega tela contendo a mensagem de compra realizada
        return direct_to_template(request,'carrinho/concluir.html')

SERVIDOR DE TESTE

No site da Visie (empresa parceira do PagSeguro) está disponível para download uma aplicação feita em python que simula o servidor do PagSeguro. Com esse servidor de testes é possível verificar se a integração está enviando e recebendo os dados corretamente. É um servidor semelhante ao que acompanha o Django.

1. Faça o download em: http://visie.com.br/pagseguro/pagseguro_testserver_v0.21.zip e Descompacte em qualquer diretório.
2. Entre no diretório pagseguroMockup, edite o arquivo settings.py e altere o valor da variável retornourl para sua URL de retorno em ambiente de teste. Altere também dentro do arquivo pagseguro.py na linha 77 onde está ‘ProdId’ por ‘ProdID’.
3. Insira a linha 127.0.0.1 pagseguro.uol.com.br pagseguro no arquivo /etc/hosts. Agora basta executar o comando sudo python PagSeguroServer.py para iniciar o servidor de testes. Ctrl + C para sair.

CONCLUSÃO

O que foi mostrado nesse artigo também serve com base para comunicação com webservices de outros serviços de pagamento on-line. Eu aconselho a quem estiver pensando em desenvolver um e-commerce que utilize algum serviço desse tipo a não se prender em apenas um. Deixem pré-configurado uma segunda alternativa caso venha a ter problemas com a primeira.
Fiquei decepcionado quando não encontrei exemplos em Python no site do PagSeguro. Na minha opinião, se uma empresa disponibiliza um webservice e ganha sobre isso, deveria investir melhor na documentação e principalmente no suporte.

Compartilhe esse artigo

Abaixo está o código dentro do arquivo index.html responsável por exibir a lista de apps no admin.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

{% if app_list %}
  {% for app in app_list %}
        <div class="module">
        <table summary="{% blocktrans with app.name as name %}Models available in the {{ name }} application.{% endblocktrans %}">
        <caption><a href="{{ app.app_url }}" class="section">{% blocktrans with app.name as name %}{{ name }}{% endblocktrans %}</a></caption>
        {% for model in app.models %}
            <tr>
            {% if model.perms.change %}
                <th scope="row"><a href="{{ model.admin_url }}">{{ model.name }}</a></th>
            {% else %}
                <th scope="row">{{ model.name }}</th>
            {% endif %}
 
            {% if model.perms.add %}
                <td><a href="{{ model.admin_url }}add/" class="addlink">{% trans 'Add' %}</a></td>
            {% else %}
                <td>&nbsp;</td>
            {% endif %}
 
            {% if model.perms.change %}
                <td><a href="{{ model.admin_url }}" class="changelink">{% trans 'Change' %}</a></td>
            {% else %}
                <td>&nbsp;</td>
            {% endif %}
            </tr>
        {% endfor %}
        </table>
        </div>
  {% endfor %}
{% else %}
    <p>{% trans "You don't have permission to edit anything." %}</p>
{% endif %}

O que vamos fazer é inserir 2 "ifs" dentro da tag for de modo a não exibir as apps auth e sites. O primeiro if verifica se app_url = 'auth/' e o segundo se app_url = 'sites/'. Se app_url não for igual à nenhuma das 2 opções então a app será exibida na tela.

1
2

{% ifnotequal app.app_url 'auth/' %}
{% ifnotequal app.app_url 'sites/' %}

Abaixo o código com os "ifs" inseridos. Lembrando que é preciso fechar as tags. Reparem na terceira e quarta linha:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

{% if app_list %}
  {% for app in app_list %}
    {% ifnotequal app.app_url 'auth/' %}
      {% ifnotequal app.app_url 'sites/' %}
        <div class="module">
        <table summary="{% blocktrans with app.name as name %}Models available in the {{ name }} application.{% endblocktrans %}">
        <caption><a href="{{ app.app_url }}" class="section">{% blocktrans with app.name as name %}{{ name }}{% endblocktrans %}</a></caption>
        {% for model in app.models %}
            <tr>
            {% if model.perms.change %}
                <th scope="row"><a href="{{ model.admin_url }}">{{ model.name }}</a></th>
            {% else %}
                <th scope="row">{{ model.name }}</th>
            {% endif %}
 
            {% if model.perms.add %}
                <td><a href="{{ model.admin_url }}add/" class="addlink">{% trans 'Add' %}</a></td>
            {% else %}
                <td>&nbsp;</td>
            {% endif %}
 
            {% if model.perms.change %}
                <td><a href="{{ model.admin_url }}" class="changelink">{% trans 'Change' %}</a></td>
            {% else %}
                <td>&nbsp;</td>
            {% endif %}
            </tr>
        {% endfor %}
        </table>
        </div>
      {% endifnotequal %}
    {% endifnotequal %}
  {% endfor %}
{% else %}
    <p>{% trans "You don't have permission to edit anything." %}</p>
{% endif %}

Compartilhe esse artigo

Crie um arquivo chamado monitor.py e ponha-o no diretório do projeto. Abaixo o conteúdo do arquivo:

import os
import sys
import time
import signal
import threading
import atexit
import Queue
 
_interval = 1.0
_times = {}
_files = []
 
_running = False
_queue = Queue.Queue()
_lock = threading.Lock()
 
def _restart(path):
  _queue.put(True)
  prefix = 'monitor (pid=%d):' % os.getpid()
  print >> sys.stderr, '%s Change detected to \'%s\'.' % (prefix, path)
  print >> sys.stderr, '%s Triggering process restart.' % prefix
  os.kill(os.getpid(), signal.SIGINT)
 
def _modified(path):
  try:
    if not os.path.isfile(path):
      return path in _times
 
    mtime = os.stat(path).st_mtime
    if path not in _times:
      _times[path] = mtime
 
    if mtime != _times[path]:
      return True
  except:
    return True
 
  return False
 
def _monitor():
  while 1:
    for module in sys.modules.values():
      if not hasattr(module, '__file__'):
        continue
      path = getattr(module, '__file__')
      if not path:
        continue
      if os.path.splitext(path)[1] in ['.pyc', '.pyo', '.pyd']:
        path = path[:-1]
      if _modified(path):
        return _restart(path)
    for path in _files:
      if _modified(path):
        return _restart(path)
 
    try:
      return _queue.get(timeout=_interval)
    except:
      pass
 
_thread = threading.Thread(target=_monitor)
_thread.setDaemon(True)
 
def _exiting():
  try:
    _queue.put(True)
  except:
    pass
  _thread.join()
 
atexit.register(_exiting)
 
def track(path):
  if not path in _files:
    _files.append(path)
 
def start(interval=1.0):
  global _interval
  if interval < _interval:
    _interval = interval
 
  global _running
  _lock.acquire()
  if not _running:
    prefix = 'monitor (pid=%d):' % os.getpid()
    print >> sys.stderr, '%s Starting change monitor.' % prefix
    _running = True
    _thread.start()
  _lock.release()

Para finalizar a configuração, altere o arquivo de configuração do mod_wsgi de modo a conter as duas últimas linhas do código abaixo:

import os, sys
sys.path.append('/home/usuario/www/apps_wsgi')
os.environ['DJANGO_SETTINGS_MODULE']='meuprojeto.settings'
import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()
 
import meuprojeto.monitor
meuprojeto.monitor.start(interval=1.0)

Feito isso as alterações no código serão atualizadas no navegador em tempo real.
Lamento não inserir uma referência para o site do qual copiei o script, pois já faz algum tempo e não me lembro mais o nome nem a URL.

Links Relacionados

http://blog.dscpl.com.au/2009/02/source-code-reloading-with-modwsgi-on.html
http://blog.dscpl.com.au/2008/12/using-modwsgi-when-developing-django.html

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