PySide e aplicações web

Recentemente eu me vi obrigado a mudar a linha de desenvolvimento de um projeto meu, e pra isso eu resolvi abandonar muita coisa e me dedicar de fato ao Python. Eu sempre soube que a comunidade do Python era muito grande e bem entusiasmada, mas me surpreendi com o quanto eu consegui progredir em tão pouco tempo, tá dando tempo até de postar no blog e adiantar tempo no cronograma

Enfim, minha situação é a seguinte: pretendo fazer um sistema web, com a interface inteira em HTML e um back-end qualquer (tá, eu vou escolher o Django, mas você que está lendo é livre para escolher qualquer outro), mas que o usuário final veja esse sistema como um software comum, com atalho na área de trabalho, janelinha dedicada e tudo mais. Até ai eu poderia usar um Adobe AIR da vida, mas o problema é que eu preciso me comunicar com alguns recursos do PC, tipo comandos no terminal, janela de autenticação, ou até mesmo um “visual” mais desktop. Então me surgiram diversas opções pra Mono, Python, e até o C++… Mas quem me agradou de verdade foi o PySide, uma binding oficial do Qt em Python.

O que me convenceu a gostar do PySide foi a facilidade de implementar instâncias derivadas de QObject dentro de um QWebView, essas instâncias ficam acessíveis no objeto window do JavaScript. Suponhamos que eu tenha uma classe mais ou menos assim:

from PySide import QtCore

class MyJSObject(QtCore.QObject):
    @QtCore.Slot()
    def teste(self):
        print "Hello from JavaScript"

Com essa classe criada, eu posso adicioná-la ao frame principal de um determinado QWebView da seguinte maneira:

meuBrowser = QtWebKit.QWebView()
meuBrowser.load(QtCore.QUrl('http://localhost/minhapagina.htm'))
meuBrowser.page().mainFrame().addToJavaScriptWindowObject('myjs', MyJSObject())

Experimente fazer uma chamada no JavaScript ao objeto window["myjs"].teste(), ou se você preferir injetar um código JavaScript para esse fim, também é possível através do evaluateJavaScript():

meuBrowser.page().mainFrame().evaluateJavaScript('window["myjs"].teste()')

Agora é só conferir o terminal do Python pra você ver o print do método teste() funcionando. A partir desse conceito você tem uma gama de opções para desenvolver aplicações ricas usando todo potencial do Python e do que há de melhor na web ao mesmo tempo.

Não se esqueça de os métodos declarados dentro da sua classe derivada de QObject precisam do decorator Slot para ficarem visíveis no JavaScript. Para tirar mais dúvidas quanto as slots e aos signals, leia esse trecho da documentação oficial.

Dedico esse artigo ao pessoal do canal #python na rede vIRCio, em especial ao Rafaelzinhu por ter me indicado esse servidor IRC e ao vitorlobo com o blog Pythonando, que serviu de ótima referência pra que eu pudesse destrinchar bastante coisa sobre o PySide.

 

Python e Cygwin – primeiras impressões

De volta à minha rotina de programador, depois de algumas semanas de supostas “férias” (lê-se falta do que fazer)… Estou com algumas idéias novas no ar, e uma delas diz respeito a passar um bom tempo usando apenas Windows. Como bom adepto de Linux que eu sou, no mínimo um terminal com os poderes do pinguim fazem falta pra mim, mas eu nunca tinha encontrado um motivo bem convincente para usar Cygwin… Agora eu encontrei: Python.

Há um bom tempo atrás eu tive experiências com Python nativo no Windows 7 (inclusive o artigo que eu escrevi sobre PyDev, Django e virtualenv foi escrito nessa época), mas eu sempre odiei o fato de não ter um compilador dedicado ao Python caso eu precisasse compilar pacotes com o pip, ou mesmo instalar coisas legais no meu virtualenv. Com o Cygwin a história muda, já que é possível eu instalar gcc e uma série de pacotes básicos do Linux que facilitam a minha vida, além de me deixar mais em casa já que boa parte dos meus trabalhos de front-end para Django foram na época que eu usava Ubuntu 10.04 e eu usava muito o terminal para rodar o servidor de desenvolvimento e as outras funções do Django. Enfim, vamos ao que interessa:

Instalando o Cygwin

A instalação do Cygwin não tem muito segredo, o melhor que você faz é deixar o diretório padrão de instalação (C:\cygwin) e escolher um diretório de cache dos pacotes à seu gosto (você pode guardar esse cache para futuras instalações, por exemplo). Lembre-se de marcar para a instalação pacotes como o gcc, gcc-core, gcc-mingw, gcc-mingw-core, python… Você também pode instalar pacotes como o make, autoconf, automake, gcc-g++, gcc-mingw-g++, gdb, vim, mc, e outros pacotes que podem ser úteis no futuro (caso você queira fazer mais coisas além de só usar o Python). Caso você queira instalar mais coisas, é só recorrer ao setup novamente e ele vai reconhecer suas preferências (diretório do seu ambiente cygwin, diretório do cache, e até mesmo o repositório que vc baixou os pacotes), dai é só instalar o que você quer, é parecido com sistemas tipo apt-get ou yum.

Hello Python

Na primeira execução do Cygwin, ele gera um perfil no ambiente dele e já te dá acesso aos comandos. Mas antes disso, vou dar uma dicazinha legal: edite o arquivo .bashrc que se encontra no seu diretório home (tipo C:\cygwin\home\usuario, dentro do Cygwin ele é visto como /home/usuario), procure uma área de Aliases que contém aliases comentados, e tire os comentários dos aliases que você achar útil (eu pessoalmente descomentei todos). Algumas coisas legais que esses aliases fazem é imitar o dir do Windows, deixar o ls com as cores por padrão, adicionar o parâmetro de leitura amigável para o df e o du, entre outras coisinhas que vocês podem ler no meio dos comentários. Depois de mexer no .bashrc, recomendo que você saia do Cygwin e abra ele novamente pra atualizar o seu terminal.

Com o seu terminal aberto, você pode testar o Python, é só digitar python no console e ver o ambiente que todo desenvolvedor Python conhece. Até ai não tem muita diferença do Python nativo do Windows, a diferença vem na hora de instalar os pacotes. Inicialmente o Python do Cygwin vem “seco”, nem setuptools tem nele, mas é possível instalar os pacotes oficiais do PyPI como se fossem os pacotes próprios pro Linux (basicamente é essa a vantagem do Cygwin). Recomendo a instalação dos seguintes pacotes:

• setuptools
• pip
• virtualenv

É importante lembrar que o setuptools tem que ser instalado primeiro, já que sem ele os outros não vão nem conseguir rodar o setup.py, mas com o setuptools no jeito é fácil lidar com o resto. Caso você fique meio perdido tentando acessar os drives do Windows, o Cygwin tem um diretório especial chamado cygdrive na pasta raiz, as subpastas do cygdrive representam as letras das unidades do Windows (você pode acessar o C:\ entrando em /cygdrive/c/ por exemplo).

Windows é Windows, mesmo com Cygwin

Provavelmente se você usa Windows Vista ou Windows 7, você vai se deparar com um bug MUITO estranho na hora de instalar qualquer pacote pelo pip. Felizmente eu encontrei um cara no Super User que teve o mesmo problema que eu (nessa thread aqui), e resolveram o problema pra ele. Se aparecer uma mensagem mais ou menos assim:

    0 [main] python 6140 C:\cygwin\bin\python.exe: *** fatal error – unable to remap \\?\C:\cygwin\lib\python2.6\lib-dynload\time.dll to same address as parent: 0x2B0000 != 0×360000
Stack trace:
Frame     Function  Args
00288E68  6102749B  (00288E68, 00000000, 00000000, 00000000)
00289158  6102749B  (61177B80, 00008000, 00000000, 61179977)
0028A188  61004AFB  (611A136C, 6124112C, 002B0000, 00360000)
End of stack trace
0 [main] python 9048 fork: child 6140 – died waiting for dll loading, errno 11
abort: Resource temporarily unavailable

A solução não é muito amigável, mas se resume basicamente nisso:

1. Feche todos os programas que fazem uso do cygwin1.dll (terminais Cygwin e programas relacionados)
2. Encontre o diretório bin do Cygwin (por padrão é C:\cygwin\bin)
3. Execute o ash.exe (ou dash.exe, também serve)
4. Digite /bin/rebaseall -v e espere um tempo até que a execução seja concluída com sucesso
5. Se ainda assim você receber uma mensagem de erro (rebaseall:’/cygdrive/c/Users/usuario/AppData/Local/Temp’ is not writable), abra um terminal do Cygwin, digite chmod 777 ~/AppData/Local/Temp e volte para o passo 1

Feito isso, você não terá mais problemas com essa mensagem, e você poderá seguir instalando seus pacotes com o pip, compilando pacotes próprios para o Linux e afins. Agora é só você se divertir instalando seus pacotes, montando seus virtualenvs e desenvolvendo bastante.

 

Zen of IE6

Faz tempo que eu não posto aqui, hein? Passei longos meses me ocupando com tanta coisa que nem sequer me preocupei em postar conteudo aqui, mas vamos lá, vou tentar voltar a postar com mais frequência aqui.

Hoje eu trago uma matéria que resume basicamente meu 1 ano e meio trabalhando como desenvolvedor front-end na INGG, em especial todas as dores de cabeça que eu já tive com IE6.

1. Quem usa IE6 nos dias de hoje não preza por qualidade, quer apenas ver o site funcionando (by Fernando Ralfer).
2. Nem todo float precisa de clear, o IE6 empurra tudo mesmo que você não queira.
3. Todo float precisa de um display:inline para evitar o bug da margem duplicada.
4. Todo position:absolute precisa de z-index; No position:relative não é obrigatório mas é ideal.
5. PNG com PNGFix é melhor que GIF, GIF é melhor que PNG com gambiarra filtro alpha (recomendação pessoal: DD_belatedPNG).
6. Behavior é um mal necessário (use apenas em último caso).
7. Sempre deixe 3px de sobra nos seus blocos (mesmo que isso implique em enganar todos os outros browsers com margin-right:-3px – leia mais aqui).

E de brinde, duas dicas para quem usa DD_belatedPNG: para quem trabalha com sprites em PNG transparentes, evite offsets ímpares, eles sempre vão retornar coisas esquisitas; para todos os casos, o belated só simula hover na tag <a>, significa que mesmo que hajam tags dentro do <a>, nenhuma dessas tags vai atualizar o background no momento que o mouse passar em cima do elemento (no hover, mais especificamente).

 

PyDev, Django e virtualenv

Ainda não sou muito especialista em Python, mas recentemente eu me deparei com uma situação curiosa: na empresa em que eu trabalho, precisamos manter uma versão específica do Django porque a maioria dos sites que a gente desenvolveu há um bom tempo rodam nessa versão; Mas sempre nós sentimos a necessidade de evoluir e usar os novos recursos do Django (já estou sonhando com as novas templatetags condicionais que vão facilitar demais a minha vida ). Ai vem a grande pergunta: como é que faz pra rodar mais de uma versão do Django sem comprometer a versão padrão instalada no sistema?

Já ouço da boca dos “djangueiros” da empresa que a melhor solução seria o virtualenv. Ele cria ambientes virtuais para Python, permitindo que você instale livremente suas bibliotecas, assim como também é possível ter vários ambientes virtuais com versões específicas, formando seus “kits” de desenvolvimento (tipo se você desenvolve pra 3 ou 4 versões diferentes do Django, é possível fazer um virtualenv para cada versão e alternar facilmente entre elas). Mais legal ainda é a facilidade que o PyDev oferece para usar o virtualenv, com alguns cliques você troca de ambiente.

Mas enfim, vamos ao que interessa:

Instalando os pacotes básicos

Fiz uma pesquisa tanto para Windows quanto para Ubuntu acerca desse passo. No Ubuntu, você pode usar o apt-get para instalar os pacotes necessários:

$ sudo apt-get install python-setuptools python-dev build-essential

$ sudo easy_install -U pip

Searching for pip

Reading http://pypi.python.org/simple/pip/

Reading http://pip.openplans.org

Best match: pip 0.7.1

Downloading http://pypi.python.org/packages/source/p/pip/pip-0.7.1.tar.gz#md5=420c83ad67bdcb542f772eb64392cce6

Processing pip-0.7.1.tar.gz

Running pip-0.7.1/setup.py -q bdist_egg –dist-dir /tmp/easy_install-lEQ9xp/pip-0.7.1/egg-dist-tmp-KOpPI1

warning: no previously-included files matching ‘*.txt’ found under directory ‘docs/_build’

no previously-included directories found matching ‘docs/_build/_sources’

zip_safe flag not set; analyzing archive contents…

pip.basecommand: module references __file__

pip.runner: module references __file__

pip.venv: module references __file__

pip.vcs.__init__: module references __file__

Adding pip 0.7.1 to easy-install.pth file

Installing pip script to /usr/local/bin

Installed /usr/local/lib/python2.6/dist-packages/pip-0.7.1-py2.6.egg

Processing dependencies for pip

Finished processing dependencies for pip

No caso do Windows, basta baixar os pacotes setuptools e pip, exatamente nessa ordem, diretamente do Python Package Index. Dê preferência aos pacotes que já tem instalador para Windows (no nosso caso, apenas o setuptools), mas mesmo que não haja instalador não tem problema. Nos pacotes sem instalador, apenas descompacte o pacote e execute o setup.py da seguinte maneira:

python setup.py install

Os passos a seguir podem ser aplicados tanto para o Windows quanto para o Ubuntu (no caso do Windows, obviamente não é necessário o sudo):

$ sudo pip install -U virtualenv

Downloading/unpacking virtualenv

Downloading virtualenv-1.4.8.tar.gz (1.5Mb): 1.5Mb downloaded

Running setup.py egg_info for package virtualenv

warning: no previously-included files matching ‘*.*’ found under directory ‘docs/_templates’

Installing collected packages: virtualenv

Running setup.py install for virtualenv

warning: no previously-included files matching ‘*.*’ found under directory ‘docs/_templates’

Installing virtualenv script to /usr/local/bin

Successfully installed virtualenv

Cleaning up…

Criando o ambiente virtual

O comando a seguir cria o ambiente virtual propriamente dito. O parâmetro --no-site-packages diz para o virtualenv não herdar nenhuma biblioteca instalada na pasta site-packages da instalação existente do Python. Para mais informações, consulte a documentação do virtualenv sobre o parâmetro –no-site-packages.

$ virtualenv --no-site-packages --distribute meuvirtualenv

New python executable in meuvirtualenv/bin/python

A globally installed setuptools was found (in /usr/lib/python2.6/dist-packages)

Use the –no-site-packages option to use distribute in the virtualenv.

Installing distribute…………………………………………………………………………………..done.

Instalando pacotes no seu ambiente virtual

Use a opção -E do pip para instalar pacotes num ambiente específico (no exemplo abaixo eu sugeri a instalção do yolk, uma ferramenta para listar pacotes instalados):

$ pip install -E meuvirtualenv yolk

Downloading/unpacking yolk

Downloading yolk-0.4.1.tar.gz (80Kb): 80Kb downloaded

Running setup.py egg_info for package yolk

Requirement already satisfied (use –upgrade to upgrade): distribute in ./meuvirtualenv/lib/python2.6/site-packages/distribute-0.6.10-py2.6.egg (from yolk)

Installing collected packages: yolk

Running setup.py install for yolk

Installing yolk script to /home/timoteoramos/meuvirtualenv/bin

Successfully installed yolk

Cleaning up…

Ativando um ambiente virtual e usando-o

• Ative o ambiente virtual criado (no meu exemplo, o ambiente está em /home/timoteoramos):
  $ source meuvirtualenv/bin/activate
  Ou no Windows:
  meuvirtualenv\Scripts\activate.bat
• Execute o yolk para listar os pacotes instalados:
  $ yolk -l 

  Python – 2.6.4 – active development (/usr/lib/python2.6/lib-dynload)

  distribute – 0.6.10 – active

  pip – 0.7.1 – active

  wsgiref – 0.1.2 – active development (/usr/lib/python2.6)

  yolk – 0.4.1 – active

• Desative o ambiente:
  $ deactivate
• Tente executar o yolk:
  $ yolk -l 

  yolk: command not found

Assim como o yolk, é possível instalar qualquer pacote disponível no pip, inclusive o Django, basta especificar o nome do pacote. No caso do Django mesmo não tem nenhum segredo, é só mandar um pip install -E meuvirtualenv Django.

Rodando o seu virtualenv no PyDev

Jurava que isso ia dar trabalho, mas foi tão fácil que me deixou até intrigado, num merece nem screenshot hehehe

• Com a IDE aberta, vá em Window / Preferences. Na janela que irá abrir, siga para PyDev / Interpreter – Python
• Adicione um novo interpretador clicando em New; encontre o executável do Python dentro do seu virtualenv (no Windows fica em Scripts, no Linux em geral fica em bin)
• Assim que você adicionar o interpretador e der o devido nome para ele (geralmente descrevendo o virtualenv, tipo “virtualenv – Django 1.x.x”), o PyDev logo vai perguntar pelas pastas que ele irá incluir, e “surpresa”: todos os includes corretos vem marcados! É só clicar em OK e pronto
• Para alternar de virtualenv (ou mesmo voltar para o interpretador do sistema), basta alterar as propriedades do seu projeto e escolher o interpretador que você deseja.

Espero que isso facilite mais um pouco os desenvolvedores de Django que curtem o Aptana Studio e o PyDev.

Referência: SaltyCrane Blog – Notes on using pip and virtualenv with Django

 

bzr+ssh: Criando usuários restritos para um servidor Bazaar

Há um bom tempo eu venho pesquisando sobre formas de facilitar os métodos de trabalho em equipe com Bazaar aqui na empresa que eu trabalho. Em relação ao compartilhamento das árvores de trabalho, a solução é bem simples e usa apenas o comando “bzr serve” para uma pasta específica, mas esse modo é apenas para leitura (funciona para os comandos pull, merge e até update, esse último usado com checkouts leves em branches remotos). Para autenticar usuários a documentação do Bazaar sempre me sugere o uso de outras tecnologias populares, tais como FTP, SFTP ou WebDAV (dizem que WebDAV não é uma boa opção, ainda vou pesquisar mais a respeito). O problema se dá em relação ao bzr+ssh, que é mais ou menos usar o mesmo “bzr serve” com autenticação SSH, mas nunca encontrei nada detalhado na documentação do Bazaar.

Felizmente, encontrei nesse blog uma solução não muito prática mas bem eficiente:

• Tenha em mãos uma par de chaves pública e privada para SSH (caso não tenha, talvez a documentação do Bazaar ajude)
• Na configuração das chaves autorizadas (fica em ~/.ssh/authorized_keys), altere a linha de permissão da sua chave pública para isso:
  command="bzr serve --inet --directory=/home/bzr --allow-writes",no-port-forwarding,no-pty,no-agent-forwarding,no-X11-forwarding ssh-rsa AAAA[... resto da sua chave + comentário ...]
• Altere o diretório /home/bzr para qualquer diretório de sua preferência, esse será o path relativo de todos os seus projetos versionados com Bazaar

Feito isso, o usuário poderá upar seus trabalhos usando o endereço “bzr+ssh://<usuario@servidor>/<nomedoprojeto>” ao invés de “sftp://<usuario@servidor>/home/bzr/<nomedoprojeto>”, mas lembre-se de que essa facilidade só vai funcionar através da autenticação pela chave SSH, não irá funcionar pela autenticação normal do servidor. Em outras palavras, você pode até bloquear a autenticação do servidor para que o usuário se autentique apenas pela chave SSH, basta alterar o seu /etc/shadow (caso use o método convencional de autenticação no Linux) e colocar um asterisco onde deveria ficar a chave criptografada com a senha do usuário. O usuário precisa de uma shell para executar o bzr serve via SSH, portanto se você setar o shell do usuário para /bin/false, a dica acima não vai funcionar, assim o método ideal para bloquear um usuário apenas para trabalhar com Bazaar é retirar a autenticação padrão dele, como foi comentado antes.

 

Symfony e campos não-escapados (raw fields)

Há um bom tempo venho dando umas bisbilotadas na documentação oficial do Symfony, testando alguns recursos e por fim estou estudando o guia de introdução com suas 397 páginas. Meu desafio esses dias foi escrever um módulo bem básico, um clássico módulo de notícias com listagem, detalhe da notícia e comentários dos usuários. E como todos devem imaginar, a parte principal da notícia é a notícia em si, que pode vir acompanhada de tags HTML em geral (essencial para todo sistema de CMS, claro).

Mas ai surge um problema: o Symfony por padrão filtra todo o conteúdo pra que sejam evitados ataques de injeção de código malicioso, e assim também filtra tudo que vem do ORM ou mesmo de uma simples string que você passa do controller pra view. Alguns frameworks de desenvolvimento web com padrão MVC tipo o Django também fazem isso, mas esses já vem munidos de um tratamento especial para o caso de campos com HTML (ou campos WYSIWYG, como preferir), no caso do Django existe um filtro chamado “safe”, que permite que um determinado campo passe para a renderização sem ser filtrado, ou seja, ele vai “cru” para a renderização e pode ser exibido como HTML ou qualquer outra coisa. Mas no Symfony eu não achei uma alternativa tão prática assim, e ai começa mais uma peregrinação pelo Google e pela documentação do Symfony.

Felizmente encontrei duas alternativas:

Alternativa 1: Pegar o objeto puro e percorre-lo

Em casos simples como uma string ou uma array estática, talvez esse método ajude (visto que você não vai precisar percorre-lo ou pode usar estratégias menos complexas), mas eu não achei nada bonito no caso de lidar com o ORM:

<ul>
<?php foreach($sf_data->get('objectList', ESC_RAW) as $obj) { ?>
<li>
<?php echo link_to('<strong>' . esc_specialchars($obj->title) . '</strong>', 'news/detail?slug=' . esc_specialchars($obj->slug), array('absolute' => true)); ?>
<div class="content"><?php echo $obj->content; ?></div>
</li>
<?php } ?>
</ul>

Nem preciso comentar muito, né? Isso ai é HORRÍVEL demais hahaha

Tirar toda a filtragem do objeto pra ter apenas um único campo raw? E depois filtrar os outros de volta? É justamente caminhar na direção inversa à praticidade! Isso ai é pior do que reinventar a roda, imagine percorrer um objeto com 20 ou 30 propriedades, ai eu vou filtrar todas menos o campo raw? Por que eu não posso usar um {% obj.content|safe %} como no Django?

Alternativa 2: Pegar o raw field de um campo específico

Certamente o cara que escreveu o Symfony pensou em muitas situações (inclusive na minha hehehe), e com um pouco de pesquisa eu encontrei o método que retorna o campo sem escapamento:


<ul>
<?php foreach($objectList as $obj) { ?>
<li>
<?php echo link_to('<strong>' . $obj->title . '</strong>', 'news/detail?slug=' . $obj->slug, array('absolute' => true)); ?>
<div class="content"><?php echo $obj->getRawValue()->getContent(); ?></div>
</li>
<?php } ?>
</ul>

Amém irmãos, existe solução pra tudo nesse mundo. O caso acima é muito mais conveniente pra trabalhos com o uso do ORM, visto que eu nem mexi no $objectList, peguei ele original da action referente à view, e imprimi apenas o campo content como raw field. Agora sim eu posso escrever meu módulo de notícias sem muita dor de cabeça (tirando o fato de que ainda acho feio escrever esses templates no PHP puro, mas até que não é tão ruim assim hehehe)

 

Aptana: PyDev para trabalhos com Django

Mesmo sendo um fã de tecnologias como PHP e .NET/Mono, lido com desenvolvimento web para Django na empresa em que trabalho. E tenho que admitir: Django é um ótimo framework para desenvolvimento rápido, com qualidade e boas práticas de código. Através do Aptana eu conheci o PyDev, um plugin para desenvolvimento Python no Eclipse, que dá um suporte especial para Django (também existe suporte para Google App Engine, mas isso é tema pra outro post). Com esse suporte é possível ter:

• Shell interativa (console python para interagir com o seu ambiente de trabalho)
• Servidor de desenvolvimento dentro da IDE (runserver do manage.py)
• Trabalhar com o recurso auto-completar usando tudo que o Python e o Django podem oferecer
• Depuração detalhada e dicas para desempenho no seu projeto

Claro que existem muitos outros recursos, e muitos deles eu desconheço por não ser muito especialista em Python (na verdade eu trabalho só com front-end na minha empresa, tem outros colegas que lidam com o Python diretamente ), mas organizar os projetos e automatizá-los dentro do Aptana é algo bem confortável para o desenvolvimento em equipe.
Mas enfim, indo direto ao assunto, certifique-se de que você tem o PyDev instalado (no Aptana você encontra ele em Help / Install Aptana Features, na perspectiva do Aptana Web, em qualquer outra perspectiva do Eclipse você precisa instalar manualmente).

Parte 1: Configure o ambiente PyDev

1. Com o seu PyDev devidamente instalado, vá em Window / Preferences. Entre em PyDev e escolha o interpretador que você deseja configurar. Geralmente para o Django o ideal é usar Python, mas caso você deseje configurar o Jython (Java) ou IronPython (.NET) também é possível seguir os passos abaixo (não testei pessoalmente, mas percebi que as telas são idênticas).
   
2. Na janela mostrada acima, clique em New (na área de cima – Python interpreters) e uma janela irá aparecer, pedindo o nome do interpretador e o path do executável. Eu uso Python 2.6 aqui, então coloquei o nome do interpretador de Python 2.6 e defini o path onde ele está instalado (no Windows geralmente é C:\Python26\python.exe, no Linux costuma ser /usr/bin/python caso ele venha instalado por padrão ou instalável via gerenciador de pacotes).
   
3. Após adicionar o interpretador, o PyDev irá checar todas as bibliotecas oferecidas por esse interpretador (na janela que aparecer, apenas clique em OK para deixar marcadas as bibliotecas padrões, mexa apenas se souber o que está fazendo). Caso deseje, ainda é possível alterar variáveis de ambiente nessa janela de configurações, assim como substituições de string e outras opções listadas nas abas abaixo dos interpretadores.

Parte 2: Configure o seu projeto Django

1. Com o seu projeto devidamente criado e registrado (sugiro que crie como um PyDev Django Project, mas é possível adaptar a partir de outros tipos de projetos), clique com o botão direito e escolha a opção Properties:
   
2. Nas propriedades do seu projeto, vá em PyDev – PYTHONPATH. Nessa área é possível alterar o path das pastas que contém o seu código-fonte Python, assim como bibliotecas específicas do projeto e substituições de string também específicas do projeto.
   
3. Caso você esteja criando um projeto do zero (mesmo que usando um projeto Django existente de outro editor), a opção de criar um PyDev Django Project adiciona uma pasta “src” contendo um esqueleto básico de um projeto Django e adiciona o respectivo path nessa janela. Mas caso você esteja adaptando seu projeto no Eclipse de outro tipo (um Web Project do Aptana, ou mesmo um Project vazio), a janela virá vazia como mostrada no passo anterior. Seja qual for o caso, você pode deixar a pasta src se quiser ou pode definir outra pasta (na minha empresa, a gente separa os materiais de layout e outras referências na pasta “material” e separa o projeto Django em uma pasta django_site).
   
4. Após configurar o path do seu projeto, você precisa dizer onde se encontra o arquivo manage.py do seu projeto Django. Siga para a aba String Substitution Variables.
   
5. Caso não exista, adicione uma variável chamada DJANGO_MANAGE_LOCATION e como valor defina um path relativo à raiz do projeto. No meu caso ficou “django_site/<nomedoprojeto>/manage.py”.
   
6. Para trabalhar com SQLite, o PyDev precisa que seu banco de dados seja definido com um path absoluto (vindo direto da raiz, no Windows seria algo como C:\ ou no Linux começando com /). Se você precisa manter esse projeto Django portável entre vários PCs (um ambiente de trabalho, ou um projeto open-source), sugiro que você use uma configuração específica no seu settings.py:
   import os
DATABASE_NAME = os.path.join(os.path.dirname(__file__), 'django_site.db').replace('\\','/')
7. Com as devidas variáveis configuradas, é possível executar o projeto. Mas antes, verifique se o banco de dados está pronto. Feche a janela de propriedades e clique com o botão direito na pasta do projeto, escolha Django / Sync DB. A janela de console irá pedir pra que você preencha alguns dados para adicionar um novo administrador caso o banco de dados esteja sendo criado (caso você altere alguns models ou instale apps novos, ele apenas irá incluir as tabelas necessárias no banco de dados).
8. Agora com o banco de dados pronto, clique em Run para executar o projeto. Ele vai perguntar como você deseja rodar o projeto, escolha “PyDev: Django” e clique em OK. O console irá mostrar a tela do runserver padrão do Django, que monitora as requisições feitas pra ele.
   
9. Se você precisa alterar argumentos do runserver, você pode ir no menu Run / Run Configurations. Procure a configuração de Run do Django referente ao seu projeto (listado em PyDev Django). Por padrão o argumento é “runserver –noreload”, mas pode ser alterado como você preferir. É ideal deixar o –noreload para evitar problemas com a execução do Python dentro do Eclipse (apesar de que é chato você ficar dando stop no console e reiniciando o processo à cada alteração que você faz nos arquivos do Python). Experimente definir o argumento como “runserver 0.0.0.0:8000 –noreload” para que qualquer pessoa de qualquer IP veja o seu projeto Django quando ele estiver rodando na sua máquina

Mais uma dica pra encerrar: você pode usar a shell interativa para fazer testes com o seu projeto. Clique com o botão direito na pasta do projeto e escolha Django / Shell with django environment. Na primeira vez que você usar essa opção, ele irá perguntar qual módulo de settings deve ser usado. Se o seu projeto estiver configurado corretamente, esse valor já vai vir preenchido corretamente também, você só irá precisar clicar em OK e logo você verá a shell disponível na sua janela de console do Eclipse.

 

Pequeno problema com Eclipse e Ubuntu

Recentemente ando fazendo testes com o Aptana Studio 2 que é uma ótima plataforma de desenvolvimento web, usando o Eclipse que já é uma IDE de grande tradição no mundo Java. Atualmente me deparei com um problema com o meu Ubuntu 10.04, as dicas de código aparecem todas em branco e com muita dificuldade consigo ler alguma coisa.

Nas minhas pesquisas pelo Google, acabei encontrando um ticket postado no Launchpad: https://bugs.launchpad.net/ubuntu/+source/eclipse/+bug/540332

Nesse ticket, algumas pessoas sugeriram correções de diversas formas, mas a mais eficiente que eu considero foi essa:

Wim Symons wrote on 2010-04-20:

You can also do:

System > Preferences > Appearance
Click Customize …
Select the Colors tab
Set the background color for Tooltips to #F6F88B
Set the foreground color for Tooltips to #000000

And restart Eclipse after that.

A idéia é fazer um ajuste no tema atual do Ubuntu, mudando as cores das dicas (hints) do sistema.

Nas Preferências de Aparência, vá em Tema e clique em Personalizar. Em seguida, vá em Cores e ajuste as cores das Dicas de Ferramenta:

• Mude a cor do plano de fundo para #F6F88B
• Mude a cor do texto para #000000

Reinicie o Eclipse (e de preferência os outros programas abertos).

 

Plugins favoritos do Firefox

Existem inúmeros plugins disponíveis para extender a funcionalidade do Firefox, todos os dias estão sempre aparecendo atualizações ou plugins novos. Hoje resolvi listar os plugins que eu considero indispensáveis no meu dia-a-dia, tanto como desenvolvedor como usuário.

Já usei muitos plugins bons, outros só me deram dor de cabeça e atualmente mantenho só aqueles que servem mesmo pra mim. Espero que minha lista seja útil para os leitores do meu blog

Plugins para desenvolvimento

• ColorZilla
  Utilitário para extrair cores de qualquer área possível dentro do Firefox, um colorpicker para o Firefox
• Web Developer
  Um ótimo conjunto de ferramentas para desenvolvimento web (linhas-guia, validação de páginas, checagem de cabeçalhos HTTP, desabilitar JavaScript/CSS, entre outros)
• Toggle Web Developer Toolbar
  Botão “mais bonitinho” para exibir/ocultar o Web Developer
• Firebug
  O canivete suiço do desenvolvimento web no Firefox: inspecionar o DOM, console JavaScript, monitor de rede, testes de desempenho para JavaScript… sem contar os plugins que extendem o Firebug (listados abaixo)
• FireQuery
  Extensão para o Firebug especial para jQuery: visualiza os objetos criados com jQuery.data nos elementos, permite injetar jQuery em qualquer site, adiciona o jquery.lint para fazer testes de desempenho específicos para jQuery
• Firepicker
  Colorpicker básico para propriedades color e background-color no Firebug
• YSlow
  Extensão do Firebug para testar a qualidade dos sites
• SEO Doctor
  Um dos muitos utilitários de Search Engine Optimization, para quem quer ter boas colocações nas pesquisas do Google e outros sites de pesquisa
• Page Speed
  Plugin para testar o desempenho do seu site e obter sugestões para melhoria do mesmo
• Firefox Throttle (disponível apenas em FTP)
  Limita a velocidade de conexão no Firefox, específico para testar seu site em velocidades lentas (especialmente pra quem quer saber se seu site roda bem numa net abaixo de 1Mbps, até mesmo discada de 56Kbps)

Plugins de uso geral

• Delicious Bookmarks
  Integra uma conta do Delicious ao Firefox, simulando a barra de favoritos e incluindo uma barra lateral que pode ser exibida/ocultada com o atalho CTRL + B
• FlashGot
  Permite baixar conteúdo extra de muitos sites (YouTube, Vimeo e outros) e integra o Firefox aos mais conhecidos gerenciadores de download
• Download Statusbar
  Extensão para mostrar o status do download como uma statusbar, sem a necessidade de uma nova janela para ver os downloads
• DownThemAll!
  Gerenciador de download interno do Firefox, muito útil e roda em qualquer sistema operacional
• Fission (para Firefox 3, Firefox 4 já vai vir com esse tipo de funcionalidade)
  Imita a barra de progresso do Safari, mostrando o progresso na caixa de endereço web do Firefox
• Organize Status Bar
  Utilitário para ordenar os ícones da barra de status
• Moonlight (apenas Linux e Mac)
  Plugin específico para rodar o Silverlight no Linux e Mac
• Cooliris (apenas Windows)
  Slideshow muito bom e elegante, o melhor que já vi… Mas infelizmente só roda no Windows (por enquanto, já ouvi falar que eles vão portar pra outros sistemas)