Archive

Archive for the ‘Django’ Category

Aplicações Plugáveis com Django.

Olá pessoas,

Como prometido no último post Projetos vs. Apps  vou lhes mostrar como tornar suas aplicações de um projeto plugáveis, e assim obedecer aquele conceito de DRY (Don’t repeat yourself) . 
Sem muita enrolação, até por que não é preciso pois o processo é bem simples.

1º Organização das URLs 

antes de mais nada eu aconselho que você organize seu arquivo urls.py da seguinte maneira:

separe as urls de acordo com a aplicação
ex:     galeria de imagens e noticias

# galeria
(r’^/galeria/‘,’views.all_albuns’),

(r’^/galeria/imagens’,’views.all_pics’),

#noticias

(r’^/noticias/‘, ‘noticias.views.all_news’),

(r’^/noticias/(?P<slug>[\w_-]+)’,’noticias.views.news’)

Com o código organizado fica mais fácil de vizualizar e mover nossas urls.

Percebam que minha url de noticias é antecedida de “noticia/”, assim como a de galeria é de “galeria/

2º includes

logo abaixo de #galeira adicione o seguinte código:

 (r’^galeria/’, include(‘galeria.urls’)),

abaixo de #noticias adicione o seguinte código:

 (r’^noticias/’, include(‘noticias.urls’)),

E por último mas não menos importante

3º criando o Urls.py de noticias e galeria

Não se esqueça dos imports tradicionais de quando se constrói um arquivo de urls. Crie um arquivo de url (urls.py) dentro da pasta da sua aplicação

noticias/urls.py

urlpatterns = patterns(‘noticias.views’,

# localhost/noticias

(r’^noticias/$’,all_news’),
#localhost/noticias/slug
(r’^noticias/(?P<slug>[\w_-]+)/$’, ‘noticia’),
)

Perceba que as urls deste arquivo são as mesmas do arquivo de urls do projeto, logo volte ao arquivo de urls do projeto e remova as urls de lá deixando somente  “(r’^noticias/’, include(‘noticias.urls’)),” , ou seja copie do arquivo (urls.py) do projeto para o arquiv (urls.py) da aplicação, lembrando de deixar somente o include. Faça o mesmo com a galeria.

Assim o arquivo de url deve ficar da seguinte forma:

(r’^galeria/’, include(‘galeria.urls’)),

(r’^noticias/’, include(‘noticias.urls’)),

para adicionar suas aplicações a outros projetos, basta adicionar estes “includes” no urls.py do projeto.

No github existe vários repositórios com algumas aplicações plugáveis e úteis, pronto para serem usadas, faça o mesmo com as suas divide-as com o mundo, assim todos crescemos juntos e sem ficar reescrevendo linhas e linhas de código, sem falar que fica muito simples de fazer manutenção de apps desacopladas de projetos.

Por hoje é só, e até a próxima,

Gil.

Categorias:Django Tags:, ,

Projetos vs Apps.

Estava pensando acoplamento de aplicações, e “passando o olho” rapidamente pela documentação Django me deparei com os seguintes comentários:

Qual a diferença entre um projeto e uma app? Uma app é uma aplicação web que faz algo -e.g., um sistema Weblog, um banco de dados de registros públicos ou uma simples app de enquete. Um projeto é uma coleção de configurações e app para um web site em particular. Um projeto pode conter várias apps, Uma app pode estar em vários projetos.

Suas apps podem “viver” em qualquer lugar do seu Path Python.

Filosofia

Um modelo é único, definitivo fonte de dados de seus dados. Ele contém contém os campos essenciais e suas características de dados que você esta armazenando. Django segue o principio de DRY. O objetivo é definir seus dados em um lugar e automaticamente derivar coisas dele.

Apps Django são “plugáveis”: Você pode usar uma app em múltiplos projetos, e você pode distribuir apps, pois elas não tem que estar a uma determinada instalação Django.

Logo Ter um projeto com pequenas aplicações se torna muito mais vantajoso do que ter um projeto com aplicações muito grandes. Não me recordo onde li uma certa vez que se a descrição da sua aplicação ocupa mais de uma linha, ela deve ser quebrada em pequenas aplicações. Pode parecer não ter importância mas com o passar do tempo você possuirá varias apps que automatizaram seu trabalho.

No próximo post mostrarei como tornar sua aplicação plugável, mas por hoje é só.

Abraço e até a próxima,
Gil.

Categorias:Django Tags:, ,

Formalidades

Boa Tarde, venho por meio desta informar ao(s) senhor(es) que a partir da presente data vinte e seis(26) dias do mês de Janeiro(01) do ano de dois mil e doze(2012)…

Opa opa, calma ai né! Entendo que formalidades são necessariedades da comunicação em um ambiente de trabalho, principalmente quando se vai falar com superiores.
Mas tamanha formalidade em um ambiente de trabalho pode diminuir a produtividade e comodidade de funcionários, que são a principal ferramenta de uma empresa.
Alguns dias atrás estava num escritório de advocacia, e pude perceber que até mesmo lá um ambiente onde a linguagem formal é usada a cada documento redigido a cada ligação, as pessoas se tratavam de forma mais informal, o dono do escritório fazendo brincadeiras com seu estagiário e falando seriamente quando necessário.

Com certeza os empregados daquele escritório desempenham seu trabalho com mais tranquilidade, o que não significa com menos seriedade. É irrefutável que um ambiente descontraído anima o funcionário a desempenhar seu papel mas tranquilamente, sem medo de arriscar e expor idéias.

Não quero que ninguém saia por ai falando: “E ai boss, tranquilo meu camarada?”, obviamente não é esse o ponto em que quero chegar, hierarquias existem e devem ser respeitadas é claro. Sou a favor da humanização do ambiente de trabalho, não da bagunça!

O que é mais confortável, expor suas idéias a um chefe que você nunca viu dando um sorriso ou expor essas mesmas idéias a uma pessoa que esta sorrindo conversando com seus funcionários de igual para igual? Até mesmo um companheiro de equipe a quem você apresentaria um projeto? Qual a possibilidade daquele companheiro de equipe que nunca sorri, não conversa com todos, olhar para seu projeto e sorrir falar que gostou e te chamar para discuti-lo mas afundo?

Agora coloque isso num ambiente de funcionários de TI, que tem prazos curtos, grande exigência do cliente que ás vezes deseja que o computador leia sua mente e realize todas as tarefas que deveriam ser feitas por ele com um simples clique no mouse. Ou aquela plataforma, que não funciona, o erro de sintaxe que ninguém encontra, etc.

Trabalhar com TI em geral é muito prazeroso, programar então nem se fale :-), desde que estas tarefas sejam desempenhadas num ambiente propício para isso.

Nunca passei por essa situação de ter um ambiente carregado, afinal estou buscando um emprego, e ficaria muito contente de passar longe de um ambiente desses.

Então fica combinado, aqui no blog nada de linguagem muito formal ok? Nada “vc”, “ngm” e outros vícios de msn é claro, mas vou tentar transpor a linguagem que uso no meu dia a dia, afinal o objetivo do blog não é me expor?!

___

E para não passar em branco sem programação  no post de hoje de uma olhada numa siege que estou preparando, para a minha volta as aulas na faculdade.
Introduction to Django in 15 minutes or less.

Por hoje é só, abraço

Gil.

Django humanize & Dojo Python

Olá, estava vendo a documentação do Django, conhecendo as ferramentas que ele me oferce, quando me deparei com o Django.contrib.humanize clique aqui para ver a documentação original (inglês), segundo a documentação do Django o django.contrib.humanize é: Um conjunto de úteis template filters  para adicinoar um “toque humano” aos dados (tradução própia).

Exemplo retirado da docs.djangoproject :

apnumber

For numbers 1-9, returns the number spelled out. Otherwise, returns the number. This follows Associated Press style.

Examples:

  • 1 becomes one.
  • 2 becomes two.
  • 10 becomes 10.

Lendo isto lembrei de um dojo que fiz há um tempo com meu amigo Uriel (@urieljuliatti), bom não finalizamos no tempo desejado e me decepcionou o fato de não saber coisas simples com o Python. Apesar de ter ficado decepcionado com os resultados, percebi que tinha que estudar mais, e que dojos são um ótimo termômetro para saber como você esta se saindo, além de serem divertidos pelo simples fato de serem desafiadores.

Algumas coisas que pude tirar proveito daquele dia foram que dificuldades e dúvidas irão aparecer, se preparar para elas é essencial (ter uma lista com fontes de pesquisa ajuda muito) e nem sempre a tua solução é a melhor, admitir isto pode ser difícil mas não adianta, trabalhar em equipe é isso, agregar  experiências e idéias.

Dojo

O objetivo do Dojo era contar quantas letras existem nos números de um a mil.
ex: um => duas letras
dois => quatro letras
total = 6 letras.

Resolução:
Após a frustração com o Python, o Uriel começou a rabiscar algo em Ruby, e eu em python, chegamos no fim do dia sem uma resolução. O Uriel me mostrou a linha de raciocínio dele, confesso que no momento não entendi – respondi assim: Sim, sim ah tá – nunca respondam assim, nunca fique com dúvidas.

Chegando em casa, começei a pensar na solução do Uriel e percebi que ele estava certo, dei uma “rabiscada” em python e saiu algo mais ou menos assim:

-*- coding: utf-8 -*-
#! /usr/Python/Python2.7
# gilgomesp@gmail.com

# sys para usar o argv
import sys

# numeros por extenso

numeros = [{0:””, 1:”um”, 2:”dois”, 3:”três”, 4:”quatro”, 5:”cinco”,
6:”seis”, 7:”sete”, 8:”oito”, 9:”nove”, 10:”dez”,
11:”onze”, 12:”doze”, 13:”treze”, 14:”quatorze”, 15:”quinze”,
16:”dezesseis”, 17:”dezessete”, 18:”dezoito”, 19:”dezenove”},
{2:”vinte”, 3:”trinta”,
4:”quarenta”, 5:”cinquenta”, 6:”sessenta”, 7:”setenta”, 8:”oitenta”,
9:”noventa”},
{1:”cento”, 2:”duzentos”, 3:”trezentos”,
4:”quatrocentos”, 5:”quinhentos”, 6:”seissentos”, 7:”setessentos”,
8:”oitocentos”, 9:”novecentos”}]
def unidades(numero):
n = str(int(numero)) # converte para string
numeroString = ‘0’ * (3 – len(n)) + n # gera uma string numeroString = 83
u = int(numeroString[-1:])
if numeros[0].has_key(u):
unidade = numeros[0][u]
return unidade

def dezenas(numero):
n = str(int(numero))
numeroString = ‘0’ * len(n) + n
d = int(numeroString[2:-1])
dez = int(numeroString[2:])
if numeros[1].has_key(dez):
dezena = numeros[0][dez]
return dezena
else:
dezena = numeros[1][d]
return dezena

#def centenas(numero):
#n = str(int(numero)) #converte para str
#numeroString = ‘0’ * (3 – len(n)) + n
#c = int(numeroString[-2:])
#if numeros[2].has_key(c):
#centena = numeros[2][c]
#return centena
#else: print ‘invalido’

def extenso(numero):
if numero >= 20:
return dezenas(numero)+ ‘ e ‘+ unidades(numero)
elif numero < 20:
return unidades(numero)
elif numero >99:
return centenas(numero)
def main():
numero = 99 # OU sys.argv[1]
print extenso(numero)

if __name__ == ‘__main__’:
main()

Não ficou pronto, não por incapacidade, mas sim por ter perdido o objetivo para mim que era a conclusão em dupla do Dojo, o prazer de resolver meu primeiro desafio fora da faculdade com meu amigo Uriel.
Para finalizar gostaria de deixar claro que não vejo essa experiência como frustante, mas sim como uma grande oportunidade de aprender, e acredito ter evoluído mais um pouquinho nessa caminha rumo ao infinito que é o aprendizado e evolução pessoal.

Abraços deste que vos fala, até a próxima.

Categorias:Diversos, Django Tags:, ,

Trabalhando com FlatPages no Django

Flatpages ou páginas planas são sensacionais e o Django torna a experiência com elas muito satisfatória e ágil.

Páginas planas são páginas estáticas e o melhor exemplo disto são aquelas famosas páginas /sobre/, /about/, /sobre-mim/ etc.

Chega de enrolação e “mãos a obra”.

Usarei aqui um projeto bem rápido com configurações padrões, nada de mais:

Vamos criar o projeto ->

No windows:

abra o prompt de comando (DOS) vá para o diretório onde ficara seus projetos ex:

cd D:\projetos

c:\Python27\Scripts\django-admin.py startproject exemplo

No linux

$ cd /projetos

$ django-admin.py startproject exemplo

No diretório do projeto adicione as seguintes linhas no teu arquivo urls.py

(r”,include(‘django.contrib.flatpages.urls’)),

Não vou falar de configurações do settings e banco de dados, pois não é o objetivo do post, agora vamos as paginas planas.

Insira ‘django.contrib.flatpages’, em suas apps (INSTALLED_APPS ) no seu arquivo setings.py em sua pasta de templates no meu caso “exemplo/teste/templates” e adicione o seguinte diretório flatpages/default.html a nossa pagina default deve ficar da seguinte maneira

{{ flatpage.title }}

{{ flatpage.content }}

use o syncdb e reinicie o servidor e pronto agora é só acessar o admin e adicionar a flatpage /sobre/

Obs: lembre-se de trocar o valor de site (example.com) pelo servidor local no meu aqui localhost:8000 adicione a flatpage e acesse localhost:8000/sobre pronto ja temos nossa flatpage.

O único problema que encontrei adicionando flatpages desta maneira, foi o de conciliar paginas planas com o sistema de feed que o Django possui. Encontrei a solução no manual do Marinho. Remova a linha

(r”,include(‘django.contrib.flatpages.urls’)),

do seu arquivo urls.py e no settings.py adicione a seguinte linha as MIDDLEWARE_CLASSES

‘django.contrib.flatpages.middleware.FlatpageFallbackMiddleware’,

e pronto ja temos nossas flatpages funcionando perfeitamente, usando um editor rich text, o trabalho de estilização do conteudo fica mais agradavel ainda #fikdik.

Categorias:Django Tags: