Python: Why Are the Big Dealers Making Big Bets?

Python: Why Are the Big Dealers Making Big Bets?.

Executando expressões lógicas dinâmicas em java

Esses dias me deparei com o seguinte problema: como gerar expressões lógicas a partir de atributos anotados de um objeto como no exemplo abaixo, que são construídas pelo usuário através de uma interface gráfica?

public class Contact {

  @MyAnnotion
  private String name;

  @MyAnnotation(operators={Operator.Equal, Operator.GreaterThan....})
  private Date birthday;

  @MyAnnotion 
  private String address;
 
  @MyAnnotation(operators={Operator.Equal, Operator.GreaterThan....})
  private Integer age;

}

Digamos que queremos construir regras como “nome contains ‘Joao’ AND birthday <= '10/12/2013' OR age < 18", ou seja queremos criar regras para serem aplicadas nos objetos Contacts e selecionar os objetos de acordo com aqueles que atendem a regra ou não. Construir a regra em si não é um grande problema. O desafio está em executar a regra construída obedecendo a precedência dos operadores lógicos, e havendo parênteses, aumenta a complexidade, pois temos que executar os mais internos primeiro.

Uma das soluções, apontada por um amigo meu, é gerar um programa java script e utilizar a engine de script para avaliar a expressão lógica gerada. Por exemplo a expressão “nome igual ‘Eduardo’ and idade > 10” seria traduzido para algo assim:

if('Eduardo' == 'Eduardo' && 30 > 10){ return true; } else { return false; }

Basicamente geramos uma string contendo um código semelhante ao mostrado acima substituindo o campos (nome,idade no exemplo) pelos seus respectivos valores e os operadores pelos seus correspondentes na linguagem javascript.

Abaixo segue o código completo do programa em java, mostrando a solução que adotamos e que funcionou muito bem, muito superior ao que tínhamos antes que gerava um SQL, mas tinha um problema grave, pois quando estamos criando ou editando um objeto ainda não colocamos o objeto (Contact no caso desse artigo) no banco, logo as regras que estão lá não conseguirão ser aplicadas sobre os novos dados. Mas salvar o objeto no banco para poder aplicar as regras e apagá-lo caso, o usuário desista da edição ou criação do novo contato, é um convite para erros de inconsistência no banco. O jeito foi executar as regras sem precisar do banco e essa solução de usar a script engine da JVM caiu como uma luva.

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class ExecutaRegra {
	
	public static void main(String[] args){
		try {
			String expressaoJavascript = "if('Teste'=='Teste1' || 1==0){r=true} else {r=false}";

			ScriptEngineManager mgr = new ScriptEngineManager();
			ScriptEngine jsEngine = mgr.getEngineByName("JavaScript");
			boolean result = (Boolean) jsEngine.eval(expressaoJavascript);
			
			System.out.println("Resultado: " + result);
			
		} catch (ScriptException ex) {
			ex.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} 
	}
}

Micro web frameworks em Python: experimentando o Bottle.py

Estamos geralmente acostumados a trabalhar com frameworks web complicados, principalmente os desenvolvedores java/JEE, cheios de funcionalidades e opções que muitas vezes, para fazer um aplicativo pequeno, como um blog ou uma lista de tarefas, provocam um desânimo só de pensar em ter que configurar maven, xml’s, properties e por aí vai.

Em outras linguagens como ruby ou python temos frameworks muito fáceis de aprender  como o Ruby on Rails, Django e Web2py (esse último tem conceitos bem interessantes que vou explorar em um post futuro). Mesmo assim, se você ainda quiser uma coisa mais simples por que acha que não precisa de tantas funcionalidades, como aquelas disponíveis no Rails ou o Django, ou ainda, você não quer instalar nada, ter que gerenciar pacotes de pendências e esse tipo de coisa, talvez seja interessante olhar para os micro-frameworks, que oferecem apenas o mínimo necessário para se implementar um aplicativo web.

Nesse post eu descrevo apenas minha experiência com o bottle.py, embora o mesmo valha para outros microframeworks semelhantes, como o flask, tido por alguns como o mais completo e com mais suporte da comunidade.

O framework bottle pode ser usado como um módulo python sem dependências adicionais. Inclusive, você pode baixá-lo do site e incluir no seu projeto facilmente por que ele é constituído de apenas um arquivo. Ele implementa o padrão WSGI e suporta roteamento, templates de views, upload de arquivos, cookies e inclusive websockets. Também conta com a possibilidade do uso de plugins de terceiros.

O famoso hello world é mostrado no código abaixo:


from bottle import route, run, template

@route('/hello/')
def index(name='World'):
  return template('Hello {{name}}!', name=name)

run(host='localhost', port=8080, debug=True)

e reparem na semelhança com o flask:

from flask import Flask
app = Flask(__name__)

@app.route('/';)
def hello():
 return 'Hello World!;

if __name__ == '__main__&quot':
 app.run()

De acordo com o código acima, os decorators do python são utilizados para realizar o mapeando das url’s. Os parâmetros das url’s correspondem aos parâmetros dos métodos decorados, cujo retorno pode apontar para uma template a ser renderizada, um redirecionamento ou um código HTTP. É possível também responder em formato JSON e XML, caso a intenção seja implementar uma API REST.

O bottle possui uma template engine embutida (embora suporte outras mais conhecidas como a jinja2) chamada Simple Template ou stpl muito fácil de aprender. Os parâmetros paras as views são passadas via dicionários como no exemplo abaixo, que retorna uma lista de posts:

@route('/posts')
def posts():
  posts = find_all()
  return template('index', dict(posts=posts))

Nas linhas abaixo, segui o mesmo exemplo de primeiro projeto quando somos apresentados ao rails, a implementação de um blog. O código completo está disponível no github nesse link.

Começamos pelo modelo de Post, bem simples, que terá um título, uma data e um conteúdo. Aproveitando que estava aprendendo um pouco de python e bottle, inclui mais um framework, de ORM, na brincadeira, para mapear o objeto Post para a camada de persistência. Resolvi utilizar o SQLAlchemy que parece ser o mais recomendado de acordo com o site stackoverflow. Abaixo temos o nosso modelo de Post:


from sqlalchemy.engine import create_engine
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.schema import Column, Sequence
from sqlalchemy.types import Integer, String, DateTime

#definicao do banco de dados
DATABASE='sqlite:///blog.db';
engine = create_engine(DATABASE, echo=True)
BASE = declarative_base(engine)

class Post(BASE):
   '''modelo de post'''
   __tablename__ = 'posts'
   id = Column(Integer, Sequence('post_id_seq'), primary_key=True)
   title = Column(String(250))
   content = Column(String())
   date=Column(DateTime())

def __init__(self, title, content, date):
   self.title = title
   self.content = content
   self.date = date

def __repr__(self):
   return '%s, %s, %s', (self.id, self.title, self.date)

BASE.metadata.create_all(engine)

Em seguida, precisamos implementar um controlador para realizar as operações de criação, edição e exclusão dos posts. Abaixo segue o código:

from model.post import Post, DATABASE
from sqlalchemy.engine import create_engine
from sqlalchemy.orm.session import sessionmaker
from sqlalchemy.sql.expression import desc

def get_connection():
  """
  Connect to our SQLite database and return a Session object
  """
  engine = create_engine(DATABASE, echo=True)
  Session = sessionmaker(bind=engine)
  session = Session()
  return session

def save(post):
  if post.title != '' and post.title != None:
   session = get_connection()
   session.add(post)
   session.commit()
   session.close()
  else:
   raise Exception(u'Title cannot be empty')

def update_post(post):
  if post:
    session = get_connection()
    session.query(Post).filter(Post.id == post.id).update({'title':post.title, \
    'date':post.date, 'content':post.content})
    session.commit()
    session.close()

def delete_post(post):
  if post:
   session = get_connection()
   session.delete(post)
   session.commit()
   session.close()

def find_by_id(id):
  session = get_connection()
  post = session.query(Post).filter(Post.id==id).first()
  session.close()
  return post

def find_all():
  session = get_connection()
  posts = session.query(Post).order_by(desc(Post.date))
  session.close()
  return posts

Agora que temos nossa camada de persistência e um controlador, vamos a parte que interessa, a implementação da camada web. Praticamente, essa fase corresponde a mapear as url’s que desejamos expôr e fazer as respectivas chamadas para o nosso controlador persistir as mudanças e os posts criados.

No código abaixo temos algumas linhas destacadas que vale a pena explicar. As linhas 8 até 14 definem um método auxiliar para renderizar as views passando seus argumentos, incluindo uma mensagem de erro, pois o bottle não apresenta o flash do rails ou algo parecido (pelo menos não achei nada na documentação).

Também faltam mensagens automáticas de validação em forms tal como ocorre no Rails ou web2py. Mas é uma boa oportunidade para vc aprender a fazer o seu lendo os códigos-fontes de outros frameworks.

Nas linhas 16 a 18 o método send_static é utilizado para servir arquivos estáticos como figuras, css e javascripts, etc. Qualquer link apontando para ‘/assests/js/hello.js’, por exemplo, será mapeado por este método para, o arquivo localizado em views/js/hello.js. Esses paths dependem de onde o programa principal está sendo executado. Maiores detalhes você encontra na documentação do bottle.

Finalmente, nas linhas 79 a 81 definimos um método que será executado sempre que ocorrer o erro 404 do HTTP, de forma a exibir a uma página padrão de erro.

# -*- coding: utf-8 -*-
from bottle import get, post, request, route, run, template, view, redirect, \
static_file, error
from controller.postcontroller import *
from model.post import Post
import datetime

def render_template(args, kwargs=None, error=None, msg_success=None):
 if kwargs == None:
  kwargs = dict()

 kwargs['error']=error
 kwargs['msg_success']=msg_success
 return template(args, kwargs)

@route('/assets/')
def send_static(filename):
 return static_file(filename, root='views')

@route('/posts')
def posts():
  '''Listing of posts'''
  posts = find_all()
  return render_template('index', dict(posts=posts))

@route('/post/')
def get_post(id):
  '''Get post given the id'''
  return 'Not Implemented Yet';

@get('/posts/new')
def new():
  '''create a empty post to fill the new form'''
  today = datetime.date.today()
  return render_template('new', dict(post=Post(None, None, today)))

@post('/post/create')
def create():
  '''Get the attributes from request and create a new post'''
  post = build(request)
  try:
   save(post)
  except Exception as e:
   return render_template('new', dict(post=post), \
   error='Title cannot be empty')
 redirect('/posts')

@get('/posts/edit')
def edit(id):
 if id:
  post = find_by_id(id)
  if post:
    return render_template('edit', dict(post=post))

 posts=find_all()
 return render_template('index', dict(posts=posts), error='Post not found')

@route('/post/update/:id', method='POST')
def update(id):
  if id:
    post = find_by_id(id)

  if post:
    post_from_request = build(request)
    post.title = post_from_request.title
    post.date = post_from_request.date
    post.content = post_from_request.content
    update_post(post)

 posts = find_all()
 return render_template('index', dict(posts=posts), \
                        msg_success='Post edited with success')

@route('/posts/delete/:id', method='POST')
def delete(id):
 post = find_by_id(id)
 delete_post(post)

@error(404)
def error404(error):
  return 'Nothing here, sorry'

def build(request):
 '''
 Extract from the request the parameters to create the new post
 '''
 title = request.forms.get('title')
 content = request.forms.get('content')
 day,month,year = request.forms.get('date').split('/')
 return Post(title, content,  datetime.date(int(year),int(month),int(day)))

if __name__ == '__main__':
 run(host='localhost', port=9090)

Agora, faltam as views, que como dito anteriormente são implementadas com uma engine de template própria do framework. O código abaixo dá uma idéia dessas views. Não listaremos todas elas por questão de espaço. Mas o código completo você pode pegar no github e ver como o código está organizado.

%rebase layout title="New Post"

%if error:
    <div class="alert alert-error">
        {{error}}
    </div>
%end

<form action="/post/create" method="post">
   <fieldset>
     <input id="date" type="text" name="date" 
            value="{{post.date.strftime('%d/%m/%Y')}}" />
     <label for="title">Title</label>
     <input id="title" type="text" name="title" />
     <textarea id="content" cols="400" name="content" rows="10">
        {{post.content or ''}}
     </textarea>
     <button class="btn" type="submit">Submit</button>
   </fieldset>
</form>
<script type="text/javascript">
// <![CDATA[
$(function(){   
  $( "#date" ).datepicker({dateFormat:'dd/mm/yy'});   
});
// ]]>
</script>

No código acima, na linha 1 indica um layout padrão a ser renderizado junto com a view evitando repetição de código entre várias páginas. E, nas linhas 3 a 7 temos o exemplo de como exibir uma mensagem de erro quando esta ocorre. Nota-se que o  código da view é bem simples, usa-se código python sem maiores traumas, nada muito diferente de outras templates como a ERB do Rails.

No código do controlador as linhas 92-93 são responsáveis por inicializar o servidor http. Basta digitar a seguinte linha no terminal e acessar http://localhost:9090/posts:

 python blog.py

Apesar do Bottle não possuir features muito avançadas para desenvolvimento web ele me pareceu bem interessante para implementar coisas pequenas e rápidas, inclusive uma API REST. A implementação desse exemplo foi bem rápida e não faz muito tempo que aprendi o básico da linguagem python.

Na minha opinião é um ótimo framework para implementar aplicativos com poucas funcionalidades e principalmente se você deseja executá-lo em várias máquinas sem precisar instalar vários pacotes, ou se você não tem a senha de administrador da máquina, por exemplo. Basta ter python instalado, o que acontece na maiorias das distribuições linux e no OSX. Por outro lado, se temos que implementar um aplicativo mais complexo, com vários objetos na camada de modelo, com diversas validações e relacionamentos entre os mesmos, talvez não seja a melhor opção por nos obrigar a implementar vários códigos adjacentes, como por exemplo a validação de objetos antes de persistir e exibição de mensagens de erros ou sucesso, o que no Rails, é feito de maneira bem intuitiva e com poucas linhas de código.

Como o código é aberto você pode baixá-lo da internet e ler o código-fonte caso queria entender como funciona um framework web, sendo essa, a sua principal vantagem. É uma ótima fonte de estudo para quem deseja entender como funciona a internet e um pouco do protocolo HTTP. E no caso de se sentir confortável o bastante, desenvolver seu próprio framework web adicionando opções mais avançadas de acordo com a necessidade.

Referências:
Bottle.py: http://bottlepy.org/docs/dev/index.html

PyBlog, código-fonte de exemplo:
https://github.com/eduardocl/pyblog

Outros frameworks minimalistas:
werkzeug: http://werkzeug.pocoo.org/

Flask: http://flask.pocoo.org