Creating a REST API in Python using Bottle and MongoDB

A simple example how to implement a REST API with bottle.py

My Adventures in Coding

I have been using Bottle and MongoDB for a REST API project for almost a year now. I frequently get asked the question “Bottle, what is Bottle, I have never heard of it” and “Ok, I have read the Bottle tutorial, it is simple, but how do I use Bottle with MongoDB?”. So I decided to write up a simple “Getting Started” tutorial for my friends curious about these technologies.

Prerequisites: Python 2.7 or higher

Setup MongoDB

MongoDB is a document store, a schema less database. What makes MongoDB unique (and why we decided to use it) is that MongoDB is a hybrid document store. What this means is that MongoDB offers the freedom of storing data in a schema less fashion, while still providing a flexible query syntax that will make anyone familiar with SQL feel comfortable.

You will need to download the latest version of MongoDB from the

View original post 420 more words

Advertisements

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