out

11

Mini-curso TurboGears - Básico - Aula 1

Filed Under programação | 1 Comment

Antes de começar a codificar um sistema em TurboGears, é importante entender as partes deste framework e como elas funcionam. Neste artigo vamos entender quais são essas partes, onde elas se localizam e como cada uma destas partes se integram para o funcionamento do todo do TurboGears.

A grosso modo, quais são as partes do TurboGears?

O TurboGears é composto de 3 partes principais, o gerenciador do banco de dados (SQLObject), o servidor web (CherryPy) e o gerenciador de templates (Kid), se você ainda não instalou o TurboGears veja como instalar em um artigo postado anteriormente neste blog.

O papel principal do SQLObject é fazer todos os SELECTS, INSERTS, CREATES e etc de uma forma que eu não precise escrever os comandos do SQL, em resumo, ele lê um arquivo de modelo que criamos, o “model.py”, e cria automaticamente o banco de dados e possibilita que realizemos operações sobre ele usando apenas objetos do Python.

A função do CherryPy é levar os dados do banco de dados para uma interface comum que conhecemos, a web, ele faz isso dando respostas em HTTP para aos pedidos que fazemos usando métodos, seu arquivo principal é o “controllers.py”.

Já o Kid trabalha com em conjunto com os anteriores dando uma “cara” bonitinha para as respostas do CherryPy, usando os templates do Kid podemos desenhar nossa página como ela deve ser mostrada e o CherryPy entenderá isso e preencherá os locais apropriados com as respostas do banco de dados. Os arquivos de templates se localizam dentro do diretório “templates/”.

Resumindo, o TurboGears funciona lendo dados do banco de dados, manipulando esses dados de alguma forma e mostrando os resultados na forma desejada.

Colocando em prática a teoria

Depois do TurboGears instalado executar o comando

$ tg-admin quickstart

Responder conforme queira as perguntas, após o processo o TurboGears deverá ter criado um diretório com o nome do projeto dado, acesse este diretório e execute

$ ./start-nome_do_projeto

Em seguida acesse o endereço no seu navegador “http://localhost:8080″ e verifique seu projeto iniciado, uma característica do TurboGears é a facilidade com que se coloca um projeto no ar em questão de segundos.

Verifique as partes do TurboGears mencionadas anteriomente, edite os arquivos “model.py” e veja que não tem nenhum modelo criado, o arquivo “controllers.py” e os arquivos de templates.

Neste meio tempo procure estudar sobre a api do Kid, do CherryPy e do SQLObject, todos os links poderão ser encontrados neste blog na seção lateral em “Recomendados”, fique a vontade para fazer perguntas por e-mail ou pelo blog.

Veremos no próximo artigo desta série como criar um pequeno modelo e executar as operações básicas de adição, edição e deleção sobre ele, aguarde, veremos do básico ao avançado e ao longo do mini-curso várias dicas usadas por profissionais.

Até breve!

out

1

Como usar vários arquivos de controle no TurboGears inteligentemente?

Filed Under programação | Leave a Comment

Uma coisa que as vezes não nos damos conta quando programamos em TurboGears é que ele nada mais é do que Python, e sendo assim pode utilizar todos os recursos disponíveis na linguagem. Parece óbvio, mas eu tenho visto em várias listas de discursões perguntas como:

  • Como faço para criar um instalador para meu projeto TurboGears?
  • Como faço para usar projeto X que tem em TAL framework?
  • Ou pior, vou usar o framework Y porque ele é “compatível” com tal e tal tecnologia.

Todas essas perguntas são simples de responder, pois todos esses projetos são feitos em Python e podem ser importados de um framework para outro sem problema nenhum. Instalador? Arquivos .egg, que é padrão do Python! Veremos respostas mais detalhadas para essas perguntas em artigos futuros.

Outra pergunta que vejo em listas com igual freqüência é: “Como faço para criar vários arquivos de controle no TurboGears? Pois com apenas um arquivo (controllers.py) meu código fica bagunçado e para projetos grandes isso não é o ideial por N motivos”. Realmente um projeto com vários arquivos de controle pode ser muito melhor estruturado e organizado!

Existem várias formas de usar vários arquivos de controle, sendo que normalmente a orientação data em listas é: 1. Cria uma pasta, tipo “modules”, 2. Cria teus arquivos lá dentro, 3. Tem que criar um arquivo “__init__.py” dentro do diretório para funcionar, sem dar nenhuma explicação do porquê disto! e 4. importa as classes para o “controllers.py” conforme tua necessidade e pronto! Funcionar até que funciona, mas não é a forma mais “Pythonista” de resolver este problema.

Entendendo Python Packages

Só esse assunto daria um artigo sozinho, mas vou tentar resumir sem falar difícil. Para o Python a estrutura de diretórios do seu S.O. não existe (pelo menos não da forma que você entende), um diretório é só mais uma forma de se agrupar classes, assim como podemos agrupar usando arquivos. O arquivo “__init__.py”, é o equivalente ao método “def __init__(self):” definido dentro de uma classe, ou seja, ao instanciarmos uma classe qualquer

class foo:
… def __init__(self):
… … print “executei!”

>> objeto = foo()
executei!

Automaticamente o método __init__(self): dentro desta classe será chamado e irá imprimir a string “executei!”. De forma análoga o arquivo “__init__.py” dentro de um diretório funciona, todavia ele é executado no momento que o diretório é importado! Colocando os pingos nos i’s agora, este diretório para o Python é chamado de “Python Package” e pode ser importado da mesma forma que um arquivo. Ex. “controllers.py”.

Começaram a imaginar? Se o TurboGears em um determinado momento importa o arquivo “controllers.py” para anunciar no CherryPy os métodos que estarão disponíveis no projeto, da mesma forma ele fará, se agora, ao invés de um arquivo, tivermos um diretório.

A mágica começa!

Como tudo em Python é falado como magia (e parece mesmo!) vejamos como “sumir” com o arquivo “controllers.py” e ainda assim seu projeto continuar funcionando!

Crie um diretório chamado “controllers” no mesmo diretório do arquivo “controllers.py”

$ mkdir controllers

Mova o arquivo “controllers.py” para dentro do diretório que você acabou de criar, apenas trocando o nome para “__init__.py”.

$ mv controllers.py controllers/__init__.py

Inicie seu projeto! Ele estará funcionando perfeitamente. Isso ocorre porque no momento que o diretório “controllers” foi importado o arquivo “__init__.py” foi executado como se ainda existisse um arquivo “controllers.py”.

Criando outros controles!

Agora é só criar os arquivos de controles desejados dentro desta nova pasta (controllers), como por exemplo um arquivo “cliente.py” para guardar classes relacionadas de formulários, testes, e a classe que herda “controllers.Controllers” do CherryPy.
No arquivo “__init__.py” importe uma classe de dentro deste novo arquivo criado, usando:

>>> from cliente import ClienteControle

E dentro da classe “Root(controllers.RootController):” instancie sua classe usando:

>>> cliente = ClienteControle()

Esta classe estará disponível no endereço “/cliente” do seu projeto.

Pronto! Agora você pode organizar seu projeto com muito mais simplicidade e usar a mesma técnica para outros arquivos, caso entenda necessário. Ex. “model.py”.

set

29

Como instalar o Turbogears… Explicado!

Filed Under programação | Leave a Comment

Instalar o TurboGears é uma tarefa muito simples, resume-se em uma linha, primeiro você vai no site do TurboGears http://www.turbogears.org/, baixa o arquivo “tgsetup.py” e aí é só executar

$ sudo python tgsetup.py

Pronto? Não exatamente! Neste período de incerteza sobre o desenvolvimento do TurboGears eu não gosto que manter minha versão no top, porque? Meus projetos são todos desenvolvidos usando o SQLObject e o TurboGears está caminhando para migrar seu ORM padrão para o SQLAlchemy, que é superior, mas que ainda está na versão 0.4! Enquanto o SQLObject, com toda a limitação técnica, já está na versão 1.0-final! Traduzindo… por uma questão que estabilidade e segurança no desenvolvimento, prefiro usar a vesão 1.0.2.2 do TurboGears, que é a última versão que testei e comprovei sua estabilidade. Então a solução seria:

$ sudo easy_install TurboGears==1.0.2.2

Errado novamente! Isso só garante que o TurboGears seja instalado na versão exata 1.0.2.2, mas todas as dependências como: Kid, Cheetah, PyProtocols, etc., são instalados nas suas últimas versões disponíveis, isso pode até ser bom, mas pode ocorrer que versões mais novas deste módulos podem gerar uma certa incompatibilidade com uma versão antiga do TurboGears, principalmente devido a DeprecatedWarnings. Então como fazer?

  1. O ideal é ter sempre o arquivo de todos os Eggs usados para instalar na época que a versão 1.0.2.2 era a atual e guardar esses Eggs junto do repositório do projeto que você está desenvolvendo, então quando você for atualizar a versão do TurboGears utilizada no projeto, atualizará também a versão dos Eggs no repositório para o atual, neste caso, quando precisar (re)instalar o projeto no seu cliente você já possuirá todos os Eggs de instalação disponíveis no seu repositório.PS: Lembre-se que o Egg é diferente para diferentes plataformas, caso possua clientes Windows e Linux mantenha versões separadas destes pacotes, o mesmo vale para clientes usando Python 2.4 e Python 2.5.2.
  2. Outra opção, para o caso de você não ter acesso ao conhecimento de quais pacotes eram atuais na época, é acessar a pasta “tags” do Subversion do Turbogears na versão que você deseja instalar e consultar o arquivo “setup.py” para ver quais são as dependências para a instalação do TurboGears, neste arquivo estará listado os pacotes requeridos com as versões mínimas para a instalação do TurboGears. Lembre-se que você poderá ter que consultar as “dependências das dependências” para conseguir uma lista completa dos módulos necessários, o Exemplo disso é que o TurboGears depende do TurboKid e o TurboKid depende do Kid, então terá que consultar o TurboKid para saber qual a versão mínima do Kid. Para este cenário mantenha as versões mínimas instaladas, atualizando apenas os módulos que apresentarem mudanças significativas de segurança ou que tenham funcionalidades desejadas.
  3. Eu já tive um certo trabalho de consolidar isso que mencionei no ponto 2, e neste arquivo irei colocar mastigado como instalar a versão 1.0.2.2 usando minha lista de dependências que considero estável, minha lista é:
  • Cheetah-2.0rc8
  • CherryPy-2.2.1
  • ConfigObj-4.4.0
  • DecoratorTools-1.4
  • ElementTree-1.2.6_20050316
  • FormEncode-0.7.1
  • Kid-0.9.5
  • Paste-1.3
  • PasteDeploy-1.3
  • PasteScript-1.3.4
  • PyProtocols-1.0a0
  • RuleDispatch-0.5a0.dev_r2306
  • SimpleJson-1.7.1
  • SqlObject-0.9.0b2
  • TurboCheetah-0.9.5
  • TurboJson-1.0
  • TurboKid-1.0.1
  • TurboGears-1.0.2.2

Agora como instalar esses pacotes? Usando o Cheeseshop encontrei uma grande dificuldade de achar pacotes antigos, imaginei que seria possível instalar usando o Setuptools com o comando “easy_install Cheetah==2.0rc8″, mas também sem sucesso, o jeito foi acessar o repositório Subversion de cada módulo e compilar o arquivo Egg apartir do código fonte

$ svn co http://+projeto_url_svn+/tags/+versão desejada+
$ python setup.py bdist_egg

Após ter construido todos os Eggs para sua plataforma crie uma pasta do seu Subversion e armazene conforme mencionei anteriormente no passo 1.
Agora sim, dentro da pasta contendo todos os módulos listados acima instale o TurboGears 1.0.2.2 usando o comando

$ sudo easy_install -f . TurboGears==1.0.2.2

O -f indica que o Setuptools não irá consultar a internet para buscar pacotes, se quiser se certificar tire o cabo da Internet.

Pronto, agora você terá a versão 1.0.2.2 do TurboGears estável instalada em seu computador.