Whenever Jquery performs an ajax call and the response has a 302 HTTP Status (redirect), the redirection is not performed.

The response is handled by Jquery as it had a HTTP 200 status code, and that’s just not right !

I had this problem with an ajax login box:

• If username and password dont check, the server sends html, that goes to the login div.
• When login is performed, server sends a redirect response that points to a private page.

The usual solution is to send a reponse with a made up status code (usually 278), check it and handle the redirection yourself.

$(document).ready(function() {
    $('body').ajaxComplete(function(e, xhr, settings) {
        if (xhr.status == 278) {
            window.location.href = xhr.getResponseHeader("Location").replace(/\?.*$/, "?next="+window.location.pathname);
        }
    });
});

To solve this problem with django, you can create a middleware that changes the status code from redirects performed from ajax requests:

from django.http import HttpResponseRedirect
 
class AjaxRedirect(object):
    def process_response(self, request, response):
        if request.is_ajax():
            if type(response) == HttpResponseRedirect:
                response.status_code = 278
        return response

Assim como muitos outros usuários de Mac OSX o TextMate é meu editor de textos favorito. Ele é leve, confiável e torna a atividade de programar muito mais prazerosa. Na minha opinião ele só tem duas desvantagens: é pago (U$58) e funciona apenas no Mac OSX (sinto falta dele em outros OSs).

Nesse post vou mostrar como configurá-lo para trabalhar com Python e Django, em uma outra oportunidade, tentarei focar em dicas mais genéricas.

Antes de instalar qualquer tema ou bundle é necessário definir o encoding da sua máquina no seu arquivo ~/.bash_profile, basta adicionar essa linha:

export LC_CTYPE=pt_BR.UTF-8

Temas:

Primeiramente vamos configurar a aparência do TextMate, isso é feito através de temas. É necessário criar a pasta em que os temas do usuário são armazenados:

mkdir -p /Library/Application\ Support/TextMate/Bundles
cd /Library/Application\ Support/TextMate/Bundles

Com a pasta criada basta copiar os arquivos de temas e reiniciar o textmate com o comando:

osascript -e 'tell app "TextMate" to reload bundles'

Recomendo a criação de alguns alias para as tarefas mais comuns:

function tm-restart { osascript -e 'tell app "TextMate" to reload bundles'; };
alias tm-bundles="cd /Library/Application\ Support/TextMate/Bundles/"
alias tm-themes="cd /Library/Application\ Support/TextMate/Themes/"

Você pode achar temas legais aqui ou na wiki do textmate. O meu favorito é o Monokai

Bundles

Hightlight e outros

Basta instalar o bundle do Django e um melhorado do python.

Para não ficar perdido nos primeiros dias vale usar essa cheat sheet para python/django/rst

Auto complete com Rope

O bundle RopeMate utiliza a biblioteca Rope para adiconar recursos de autocomplete e refatoração. Os que mais uso são:

• Auto complete: <control> + <space>
• Organizar imports: <shift> + <cmd> + O
• Ir para a declaração (do método ou classe): <cmd> + F3
• Extrair linhas para método: <cmd> + <return>

Para instalar:

easy_install rope
cd ~/Library/Application\ Support/TextMate/Bundles/
git clone https://github.com/JulianEberius/RopeMate.tmbundle.git
tm-restart

Debug

O TextMate já possui um atalho para executar o script python com um terminal do pdb aberto: + + D. Porém, podemos melhorar essa integração, realçando a linha que está sendo debugada na janela do textmate.

sudo easy_install PdbTextMateSupport
mate ~/.pdbrc

Adicione as seguintes linhas:

from PdbTextMateSupport import preloop, precmd
pdb.Pdb.preloop = preloop
pdb.Pdb.precmd = precmd

Habilite o suporte marcando a opção “Highlight current line” no TextMate e executando o seguinte comando:

pdbtmsupport enable

Em 2008, ano que entrei na UNIRIO eu passava 4 horas diárias em um ônibus e felizmente foi ano em que descobri o Podcast, uma excelente maneira de se manter informado e entretido por áudio.

A definição que costumo dar a meus amigos é: “Se trata de uma espécie de programa de rádio, feito por blogueiros e distribuído em mp3″. É muito mais do que isso, mas a idéia é mais ou menos essa.

Existem temas para todos os gostos: humor, variedades, ensino de idiomas, notícias, discussões técnicas, etc.

Ao rechear seu dispositivo tocador de mp3 de podcasts, suas horas de atividade física/trânsito/trabalho/whatever passam a ser mais prazerosas, engraçadas e informativas.

Nesse post falarei sobre meus podcasts favoritos sobre tecnologia, nos próximos abordarei os de humor e variedades:

The Dev Show: Meu favorito quando o assunto é tecnologia, apesar dos hosts serem rubystas, abordam todos os assuntos relacionados a desenvolvimento e sempre aparecem com links para verdadeiras pérolas do github.

Grok Podcast: Excelente podcast, episódios de duração média, excelentes temas e convidados.

AndroidCast:Podcast nacional sobre android, o áudio ainda não está perfeito mas definitivamente vale pelo conteúdo.

Papo Tech: Um dos mais antigos no brasil, não se aprofunda muito e pode ser considerado um podcast feito por leigos, porém é bem engraçado e costuma trazer algumas dicas bem legais.

DatabaseCast: Podcast brasileiro sobre banco de dados, áudio bem legal e excelente conteúdo.

Guanacast: Trata de diversos assuntos, sempre com muito humor.

Simples Ideias: um podcast curto com notícias interessantes para desenvolvedores.

É comum que cada linguagem possua uma ou mais frameworks web que sejam encaradas como “balas de prata”, com excelente documentação, extensões, comunidade ativa, etc …

Em python possuímos Django, web2py e Zope. Cada um com suas vantagens e desvantagens, e o Django com a maior fatia de usuários, esse que vos fala incluso.
Apesar do Django ser excelente, ele possui suas desvantagens e sabemos que não existe bala de prata.

Recentemente tive algumas idéias para projetos bem pequenos, e resolvi procurar alguma framework que fosse mais simples, foi aí que encontrei o Flask.

Flask is a microframework for Python based on Werkzeug, Jinja 2 and good intentions. And before you ask: It’s BSD licensed!

O código fonte é pequeno, simples e bem escrito. Inclusive, Flask possui mais linhas de documentação do que código.

Não temos um ORM, e uma série de outras facilidades comuns em outras frameworks. Na verdade, não temos quase nada e issó é ótimo. Ao desenvolver como uma microframework, cresci como programador. Tive a oportunidade de desenvolver minhas próprias soluções para problemas comuns em desenvolvimento web, compreendendo melhor os conceitos e chegando em resultados mais adequados para meu projeto.

Não vou me alongar muito nem mostrar code snippets, como falei, a documentação é ótima. Com esse post quero apenas plantar essa idéia: Tente algo diferente, volte ao básico, e não mate formigas com uma bazuca.

Atualmente o meu sistema de controle de versão favorito é o git. Para projetos de código aberto não é necessário pensar duas vezes: hospede no github.

Na hora de trabalhar com código proprietário, o “segredo” do seu produto/empresa, você tem duas escolhas: pagar por uma conta no github ou hospedar em seu próprio servidor. Já experimentei os duas alternativas e posso afirmar que pago os U$12,00 mensais do github com muito prazer.

Porém, caso você goste de fortes emoções, esteja passando por tempos de vacas magras ou de paranóia, não custa nada relatar o que eu considero ser a melhor maneira de hospedar seu próprio repositório git: Gitosis

Para instalar:

git clone git://eagain.net/gitosis.git
cd gitosis
python setup.py install

Agora é a hora de adicionar o usuário que será dono dos repositórios, vamos chamá-lo de … git !

sudo adduser \
    --system \
    --shell /bin/sh \
    --gecos 'git version control' \
    --group \
    --disabled-password \
    --home /home/git \
    git

Copie sua chave pública ($HOME/.ssh/id_rsa.pub) para o servidor git. Para gerar a chave:

ssh-keygen -t rsa

No servidor git, vamos adicionar sua chave à lista de chaves autorizadas:

sudo -H -u git gitosis-init < /tmp/id_rsa.pub

Agora … a magia do gitosis, em sua máquina local:

git clone git@SEU_SERVIDOR:gitosis-admin.git
cd gitosis-admin

Voce terá um arquivo gitosis.conf e uma pasta keydir/
Esse repositório que você acabou de clonar contém os arquivos necessários para criar e administrar os repositórios git no servidor. Assim que você fizer push, o gitosis irá automaticamente fazer as mudanças necessárias no servidor.

Ou seja, você gerenciará seu servidor git com o git ! Além disso, a partir desse momento o login no servidor não será mais necessário, afinal basta fazer as atualizações localmente e o commit/push.

Para criar um repositório, basta editar o arquivo gitosis.conf:

 
[gitosis]                  
 
[group gitosis-admin]
writable = gitosis-admin
members = victor # nome do arquivo com a chave publica, sem o ".pub"             
 
#Para criar um novo repositório, bastar dar permissões de escrita nele:
 
[group minha_equipe]
members = victor
writable = top_secrect
 
git commit -a -m "Dando permissão a victor no repositorio top_secret"
git push

Agora, o usuário “victor” tem acesso ao respositório, porém este não foi criado ainda, isso precisa ser feito localmente, seguido de um push:

mkdir top_secrect
cd top_secrect
git init
git remote add origin git@SEU_SERVIDOR:top_secrect.git
touche README
git add .
git push origin master

Com esse push o repositório já foi criado e agora é só usar normalmente.

Para adiconar mais usuários basta colocar a chave deles em keydir/username.pub

Aproveite seu servidor de repositórios git, ou não :)

Se vale a pena migrar ? Como eu vou saber … você tem que conhecer as vantagens e as dificuldades de migração para ver se vale a pena no seu caso. E é sobre isso que vou falar aqui :)

As duas maiores novidades são as views baseadas em classes e o gerenciamento de arquivos estáticos. Os dois assuntos são bem extensos e cada um receberá seu próprio post em breve, vamos as outras novidades:

Novidades:

O python 2.7 melhorou muito a biblioteca unittest, para garantir que todos pudessem aproveita-las o pessoal do django fez um backport para python 2.4, chamado de unittest2.

A unittest2 está incluida no django e para aproveita-la em versões no python<2.7 basta usar o alias:
from django.utils import unittest

O nome de um template agora pode ser fornecido através de uma variável:

{% extends some_var %}


O módulo Logging do python é muito poderoso, e agora ele funciona integrado com o Django. Agora fica muito mais fácil configurar o comportamento e a versosidade dos seus logs. Além disso, segundo a equipe de desenvolvimento várias chamadas de log foram adicionadas no código da framework.

Delete-Cascade: os campos ForeignKey e OneToOneField agora aceitam o argumento on_delete para definir o comportamento quando o objeto referenciado é apagado.

Marcadores de contexto para tradução de strings: Para strings com tradução ambígua, dependente do contexto foi disponibilizada a função pgettext para especificar o contexto.

Agora é possível definir mais de uma váriavel com apenas um bloco with :)

A tag include agora aceita as opções with (para definir um contexto) e only (para excluir uma variavel do contexto atual) =D

A tag load aceita o argumento from, para carregar apenas um filtro ou tag.

Para ficar de olho:

Essa é a ultima versão do django com suporte a python2.4 , mas acho que pouca gente ainda está nessa versão. Mas fica o alerta: Se você usa python 2.5 a sua hora de migrar vai chegar.

A partir dessa versão a validação de segurança contra ataques CSRF também será obrigatória para requests AJAX.

Arquivos referênciados por um modelo através do FileField não serão mais apagados junto com o modelo e não há nenhuma maneira automática para que isso seja feito. O padrão sugerido é escrever um management command para apagar arquivos órfãos e colocar no cron.

A moderação automática de comentários não está mais sendo suportada, afinal é um problema de processamento de linguagem natural e foge do escopo da framework. Se você quiser restaurar o comportamento antigo basta colocar uma lista de palavras em PROFANITIES_LIST no settings.py

O uso de fixtures de teste no formato SQL não é mais suportado.

O suporte a mod_python foi removido, afinal um release não é feito desde 2007 e a fundação apache removeu esse módulo da lista de projetos ativos.

XMLField foi removido: nunca vi muita utilidade mesmo ...

Esses foram os pontos que considerei mais interessantes nessa release do django, espero que se você não foi convencido a migrar, mude de idéia nos próximos posts sobre class based views e static files.

Decidi fazer uma série de posts sobre as ferramentas que facilitam o desenvolvimento na linguagem Python. A idéia é ter um escopo bem aberto: começarei com gerenciamento de pacotes hoje, porém pretendo abordar bibliotecas, funcionalidades da biblioteca padrão, utilitários para teste, analisadores de sintaxe, etc.

Easy Install

Foi a primeira iniciativa de gerenciamento de pacotes com Python, e faz parte do pacote setuptools. O easy_install é bem simples: ele instala a ultima versão do pacote caso ele esteja disponível no PyPI (Python Package Index) e não dá suporte a desinstalação ou atualização. Sua utilização é bem simples:
sudo easy_install Django

Pip

O Pip revolucionou completamente o gerenciamento de pacotes no Python, suas principais características são:

• Suporte a desinstalação e atualização dos pacotes
• É possível especificar a versão desejada (desde que disponível no PyPI)
• Instala pacotes a partir de arquivos compactados (bz,gz,zip) que podem ser especificados através de uma url para download
• Suporte aos principais sistemas de controle de versão (svn, git, mercurial, bazaar). Basta especificar a url do projeto do github para instala-lo por exemplo
• Gerencia dependências de forma inteligente
• É possivel instalar vários pacotes de uma só vez, especificando um por linha em um arquivo de texto. Assim como é possivel exportar a lista de pacotes instalados para um arquivo

Uma visão rápida na sintaxe do pip:

# instalando do pypi (os operadores >,<,==,>=,<= são suportados para expressar a versão do pacote)
pip install django>=1.3

# desinstalando
pip uninstall web2py


Um outro recurso interessante do pip, é a criação de bundles. Um arquivo .pybundle contém todas as dependências de sua aplicação e é muito útil para deploy em ambientes offline ou com internet precária.

Um pybundle não contém binários, apenas fontes, portanto é necessário que o ambiente de deploy já possua um compilador no caso de dependências que não são python puro, como no caso da PIL.


pip bundle MinhaApp.pybundle MinhaApp

pip install MinhaApp.pybundle


No próximo post da série: virtualenv e virtualenvwrapper.

Volta e meia quando estou mac a mac com meu amigo Pedro Marins e ele dá uma espiada no meu Dock para ver se tem algum programa imperdível para Mac OSX.

Ontem, ele reparou que eu estava usando uma série de apps para acessar aplicativos/serviços web e redes sociais. Eu já tinha lhe recomendado o excelente Nambu (cliente twitter) e ele revolucionou minha experiência com feeds quando me recomendou o Reeder (cliente Google Reader).

Além desses dois aplicativos, já incorporados em nossas rotinas, ele questionou o Sparrow e o MarsEdit, ambos fixos em minha dock. Expliquei: Cliente do Gmail e do WordPress.

Era de se esperar sua expressão de surpresa, afinal a interface web tanto do gmail quanto do wordpress são excelentes, o gmail funciona offline e o wordpress possui uma série de otimizações através do google gears.

Antes de listar outros aplicativos que tenho usado do mesmo gênero, explico a minha incomum preferência. Mesmo após a série de melhorias que testemunhamos nos navegadores como, separação de processos por aba, motores JS e DOM cada vez mais rápidos, html5 (LocalStorage, Web Sql, Cache Manifest, IndexedDB, etc …), aplicativos dedicados tem algumas vantagens bem claras:

• A interface nativa de seu sistema operacional proporciona uma resposta mais rápida e é esteticamente mais agradável
• As possibilidades que o programador tem para conceber a UI são ilimitadas, muito diferente quando se está preso aos elementos do DOM
• A integração com o sistema operacional, traz muitas vantagens, como o acesso direto (e mudança do ícone para indicar estado pelo dock), notificações growl, início junto com OS e continua funcionando mesmo se o navegar travar (o que infelizmente ainda acontece, principalmente pra quem não abre mão dos betas)
• Se você precisa trabalhar offline ou com internet lenta/intermitente apps desktop sempre proporcionam uma experiência melhor
• Nas palavras do Pedro: “Fica tudo mais organizado”

As desvantagens ? Em alguns casos as apps que realmente valem a pena são pagas e o consumo de memória também pode ser um problema se seu notebook é fino que nem o do Pedro :)

Vou agora listar os aplicativos que uso:

• Sparrow: Cliente IMAP para o Gmail, interface excelente, limpa e funcional. Atalhos de teclados, e a possibilidade de usar CMD + setas e tab na edição do corpo do email fazem valer os U$ 9.90
• Reeder: Leitor de feeds, completamente integrado ao Google Reader, Read it Later, Instapaper e o que mais você imaginar
• Nambu: Twitter de maneira funcional e não invasiva, excelente ! (Não está mais sendo desenvolvido)
• MarsEdit: Editor de blogs, tenho usado nos meus últimos posts e melhorou muito a experiência de uso do WordPress
• iCalendar: Já vem no Mac OSX e se integra perfeitamente com o Google Calendar
• Facebox: Facebook não é muito a minha praia, mas pra quem gosta de seguir a timeline de perto é uma excelente opção.

AWS, ou Amazon Web Services é o conjunto de serviços de computação em nuvem que a Amazon oferece. Os produtos vão de Virtualização a Armazenamento, passando por monitoramento, bancos de dados, pagamentos, etc.

Atualmente a melhor interface Python para esses serviços se chama boto. Seu desenvolvimento é ativo, com commits frequentes, oferece suporte a maioria dos serviços da AWS, e até onde testei se mostrou estável .

Esse é o primeiro de uma série onde abordarei cada serviço da AWS e como usa-lo com Python e a lib boto

Começarei pelo mais comum:

Amazon Simple Storage Service (Amazon S3), um sistema de storage key-based, com uma excelente interface de acesso através de webservices e preços extremamente atrativos.
A cobrança é feita mensalmente de acordo com o tráfego realizado, espaço alocado e quantidade de requests realizados.

No plano mais barato, que nas palavras da amazon é “Designed for 99.99% Durability”, temos:

• U$0,093/mês por GB armazenado
• U$0,100/mês por GB enviado
• U$0,150/mês por GB baixado (cobrado somente a partir de um 1GB)
• U$0,01 por 1.000 requests PUT/COPY/POST/LIST
• U$0,01 por 10.000 requests GET/DELETE

Para instalar: pip install boto

Criando a conexão:

from boto.s3.connection import S3Connection
conn_s3 = S3Connection('AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY')
 
# ou de maneira mais direta ....
import boto
conn_s3 = boto.connect_s3('AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY')

No S3 os dados são armazenados em Bukets, que são containers para seus arquivos.

O nome dos buckets é compartilhado entre todos usuários do serviço, portanto é interessante adicionar um prefixo como ‘media.meusite.com’ aos identificadores de seus buckets.

Outro aspecto importante é que cada bucket possui uma determinada localização geográfica, que deve ser definida no momento em que ele é criado.

Utilizar seu subdomínio como prefixo é recomendado pois lhe permite mapear seus dominio/subdominios diretamente para seu dados do s3 adicionando entradas CNAME, por exemplo:

O bucket “media.meusite.com” corresponderá ao endereço:
http://media.xyz.com.s3.amazonaws.com/

Se você enviar o arquivo “imagem.jpg”, seu endereço será:
http://media.meusite.com.s3.amazonaws.com/imagem.jpg

Porém, ao mapear o domínio “media.meusite.com” para http://media.meusite.com.s3.amazonaws.com , o mesmo arquivo poderá ser acessado em:
http://media.meusite.com/imagem.jpg

from boto.s3.connection import Location
 
# listando as localizações disponíveis:
dir(Location)
['DEFAULT', 'EU', 'USWest', 'APSoutheast', '__doc__', '__module__']
 
# criando um novo bucket
balde = conn_s3.create_bucket('meu_balde', location=Location.DEFAULT)</code>
 
# listando todos os buckets de sua conta:
baldes = conn_s3.get_all_buckets()</code>
 
# instanciando um bucket existente
balde = conn_s3.get_bucket('meu_balde_velho')

O Bucket, é apenas um container de Keys que são os objetos que armazenam o conteúdo, suas características são:

• Uma Key é identificada por uma string que deve ser única dentro do Bucket
• Apesar do indenficador ser sempre um string, muitos visualizadores de dados (inclusive o da própria amazon), interpretam ‘/’ como separador de niveis em um path. E mostram as chaves organizadas em forma de pastas/subspastas
• Seu conteúdo pode ser uma string ou um arquivo
• É possível associar metadados a uma Key, assim como verificar seu tamanho em bytes, hash do conteúdo, etc

balde = conn_s3.get_bucket('meu_balde')
 
# criando uma chave que contém uma string
k = Key(balde, 'texto-1')
k.set_contents_from_string('qwerty!')</code>
 
# criando uma chave que contém um arquivo
k = Key(balde, '/fotos/imagem.jpg')  # vai ser exibido como um arquivo dentro da pasta fotos
k.set_contents_from_filename('/path/para/imagem.jpg')</code>
 
# Acessando o conteudo das chaves:
texto_1 = Key(balde, 'texto-1')
print texto_1.get_contents_as_string()</code>
 
img = Key(balde, '/fotos/imagem.jpg')
img.get_contents_to_filename('/onde/o/arquivo/sera/salvo.jpg')</code>

É possível definir o controle de acesso para todo o Bucket ou para keys específicas. Por padrão o acesso é feito somente através de sua conta da AWS, porém ele também pode ser:

• Público
• Para emails específicos (que possuem uma conta AWS associada)
• Através de uma url assinado por sua conta, que possui um tempo de expiração pré-determinado

# publico
bucket.set_acl('public-read')
key.set_acl('public-read')
# ou
key.make_public()
 
# para um email
key.add_email_grant('READ', 'fulano@bol.com.br')</code>
 
# gerando a url:
# esse método permite você controlar o acesso através de seu sistema, fazendo com que o s3 lide com todo o tráfego
key.generate_url(int(segundos para expirar))

Trabalhando com o objeto Key:

# apagando
k.delete()
 
# verificando se está armazenada na nuvem:
k.exists()
 
# copiando o conteudo para outra chave 
new_key = k.copy(balde_destino, chave_destino, metadata=None, preserve_acl=False)
 
# Metadados:
k.set_metadata('meta1', 'alguma string')
k.get_metadata('meta1')
 
# mime-type que será utilizado na resposta de um GET
k.content_type
 
# tamanho do arquivo em bytes
k.size
 
# hash md5 do arquivo armazenado
k.etag    # é igual a hashlib.md5( open('arquivo-enviado.jpg') ).hexdigest
 
k.last_modified # retorna uma string, não um datetime =(

Um servidor de FTP pode ser muito útil. Tem sido uma excelente solução quando prestadores de serviços querem fornercer arquivos para seus clientes de maneira bem simples e direta.

Segue o tutorial para implementação com o proftp. Testei no Ubuntu 10.04 mas deve funcionar em qualquer derivada do Debian

1
2

sudo apt-get install proftpd 
sudo vim /etc/proftpd/proftpd.conf

Agora é só modicar os seguintes atributos:

ServerName: Nome do servidor que será mostrado.
MaxClients = Numero máximo de clientes conectados.
DefaultRoot ~ = Para que cada usuário veja apenas a sua pasta.

1
2
3
4

sudo /etc/init.d/proftpd restart
mkdir /var/ww/ftp_clientes/usuario
adduser –home  /var/www/ftp_clientes/usuario –shell /bin/false –no-create-home usuario
chown -R usuario:usuario /var/www/ftp_clientes/usuario