Wednesday, June 27, 2007

Desenvolvimento Web com Django

Django é um framework web para perfeccionistas com prazos, segundo seu próprio site (http://www.djangoproject.com/).

Ele é todo codificado em Python (python.org), ou seja, 100% multi-plataforma. E precisa de um dos principais bancos de dados SQL (MySQL, SQLite, PostgreSQL...) para manter persistência de dados. Para atender requisições da web, ele pode ser ligado ao mod_python sobre o Apache, fast-cgi ou outros. E claro, também conta com um servidor próprio para testes de desenvolvimento.

Seu projeto teve o código aberto por volta de 2005, ao meu ver, isso mostra o quão novo e desconhecido ele é para a comunidade. Sua versão atual é a 0.96 e ainda não há uma previsão para a 1.0. Porém 90% da API já está quase estável e não deverá sofrer muitas modificações.

Agora irei explicar o modo MTV; model - modelo, template - molde e view - visão.
No projeto da modelagem, o banco de dados é modelado em classes filhas da classe models do módulo django instalado no Python. Veja um exemplo abaixo:
class Reporter(models.Model):
full_name = models.CharField(maxlength=70)

def __str__(self):
return self.full_name

class Article(models.Model):
pub_date = models.DateTimeField()
headline = models.CharField(maxlength=200)
article = models.TextField()
reporter = models.ForeignKey(Reporter)

def __str__(self):
return self.headline

Cada classe será uma tabela no banco da dados, e a inclusão, remoção ou busca dos dados pode e deve ser feita através da API.
>>> from mysite.models import Reporter, Article

# No reporters are in the system yet.
>>> Reporter.objects.all()
[]

# Create a new Reporter.
>>> r = Reporter(full_name='John Smith')

# Save the object into the database. You have to call save() explicitly.
>>> r.save()

# Now it has an ID.
>>> r.id
1

# Now the new reporter is in the database.
>>> Reporter.objects.all()
[John Smith]

# Fields are represented as attributes on the Python object.
>>> r.full_name
'John Smith'

# Django provides a rich database lookup API.
>>> Reporter.objects.get(id=1)
John Smith
>>> Reporter.objects.get(full_name__startswith='John')
John Smith
>>> Reporter.objects.get(full_name__contains='mith')
John Smith
>>> Reporter.objects.get(id=2)
Traceback (most recent call last):
...
DoesNotExist: Reporter does not exist for {'id__exact': 2}

# Create an article.
>>> from datetime import datetime
>>> a = Article(pub_date=datetime.now(), headline='Django is cool',
... article='Yeah.', reporter=r)
>>> a.save()

# Now the article is in the database.
>>> Article.objects.all()
[Django is cool]

# Article objects get API access to related Reporter objects.
>>> r = a.reporter
>>> r.full_name
'John Smith'

# And vice versa: Reporter objects get API access to Article objects.
>>> r.article_set.all()
[Django is cool]

# The API follows relationships as far as you need, performing efficient
# JOINs for you behind the scenes.
# This finds all articles by a reporter whose name starts with "John".
>>> Article.objects.filter(reporter__full_name__startswith="John")
[Django is cool]

# Change an object by altering its attributes and calling save().
>>> r.full_name = 'Billy Goat'
>>> r.save()

# Delete an object with delete().
>>> r.delete()
No projeto da visão, é definido que informação deve aparecer em alguma página. Não confunda com como deve ser visto, essa função é do molde. Veja o exemplo abaixo:
def year_archive(request, year):
a_list = Article.objects.filter(pub_date__year=year)
return render_to_response('news/year_archive.html', {'year': year, 'article_list': a_list})
Finalmente, no molde, é definido como essa informação retornada pela busca na segunda linha do exemplo acima deverá ser apresentada. Veja abaixo:
{% extends "base.html" %}

{% block title %}Articles for {{ year }}{% endblock %}

{% block content %}
<h1>Articles for {{ year }}</h1>

{% for article in article_list %}
<p>{{ article.headline }}</p>
<p>By {{ article.reporter.full_name }}</p>
<p>Published {{ article.pub_date|date:"F j, Y" }}</p>

{% endfor %}
{% endblock %}
Olhando esse molde rapidamente, podemos perceber que sua linguagem é voltada aos designers. Onde quem predomina é o HTML/CSS/JavaScript e o código "estranho" é o mais simplificado possível e de rápido entendimento para possibilitar uma rica integração com a visão definida por um programador.

O Django também permite o mapeamento de URLs, onde em vez de um site dinâmico usar a URL /produto.py?id=5&view=detalhado, poderá fazer o mesmo com /Produto/5/detalhes ou até mesmo /Produtos/Carregador_AC_USB.

A quem interessar, sugiro uma boa lida na documentação presente no site do django e qualquer coisa, mandar um e-mail para mim: david (ponto) kwast (em) gmail.

Referências e links

http://www.djangoproject.com/

http://www.djangoproject.com/documentation/tutorial1/

http://www.djangobook.com/

Friday, June 1, 2007

Python no Nokia e61 (pyS60)

Acabei de adquirir um Nokia e61 e pretendo começar a desenvolver uns programas em Python.
Minha experiência nessa linguagem não é muita, mas já posso garantir que consigo fazer mais coisas que fazia com Java ou C++/QT.
Confesso que achei muito legal essa idéia da Nokia de olhar pra outra linguagem para portáteis, e fiquei muito feliz por ter sido Python. E o motivo vou mostrar a seguir.
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class HelloJ2ME extends MIDlet implements CommandListener{
private Display display;
private TextField caixaDeTextoHello;
private Command comandoDeSaida;
private Form formularioPrincipal;
public HelloJ2ME(){
display = Display.getDisplay(this);
formularioPrincipal = new Form("HelloJ2ME");
comandoDeSaida = new Command("Exit", Command.SCREEN,1);
caixaDeTextoHello = new TextField("Text","Hello World!",15,TextField.ANY);
formularioPrincipal.addCommand(comandoDeSaida);
formularioPrincipal.append(caixaDeTextoHello);
formularioPrincipal.setCommandListener(this);}
public void startApp(){
display.setCurrent(formularioPrincipal);}
public void pauseApp(){}
public void destroyApp(boolean incondicional){}
public void commandAction(Command comando, Displayable s){
if (comando == comandoDeSaida){
destroyApp(false);
notifyDestroyed();}}}

O resultado:


Referência

Tudo isso foi o primeiro exemplo de HelloWorld em J2ME que achei no Google, pelo tamanho acredito que existam outros menores.
Agora vou colocar um do Python para Symbian.
import appuifw
appuifw.app.title = u“Hello World”
appuifw.note(u“Hello World”, ‘info’)
Phyton_hello_world
Referência
Entendeu meu ponto de vista? E tem mais duas outras vantagens (sempre falando do meu ponto de vista), o python é a versão 2.2.2 completa (a atual é 2.5.1, mas acreditem, não tem muita coisa q faça falta) e é possível instalar o intepretador, que no caso de aparelhos com teclado QWERTY, pode ajudar a passar o tempo para pessoas que preferem programar em vez de jogar no celular.
Bom, por hoje é tudo, espero estar postando mais novidades e exemplos de código Python para celulares Nokia.

abraços

mais informações em
http://wiki.embeddedacademy.org/index.php/PyS60_Mini-course
e
http://wiki.opensource.nokia.com/projects/Python_for_S60