Pyramid - O Framework Web para Todos

Pyramid
O framework web para todos
Rudá Porto Filgueiras - rudazz@gmail.com
Twitter: rudaporto Github: rudaporto
02/10/2013 - PytthonBrasil[9] / PloneConf 2013

Tópicos
Introdução
História

Tópicos
Introdução
História
Princípios de Projeto

Tópicos
Introdução
História
Exemplos

Tópicos
Introdução
História
Exemplos
Perguntas

Tópicos
Introdução
História
Exemplos
Perguntas
Obrigado

About Me
1 >>> import this
2 The Zen of Python , by Tim Peters
3
4 Beautiful is better than ugly .
5 Explicit is better than implicit .
6 Simple is better than complex.
7 Complex is better than complicated .
8 ...
Usuário de Linux desde 1999
Usuário de Zope desde 2001
Usuário de Plone desde 2005
Não sou desenvolvedor "full time"
Membro Fundador da Associação Python Brasil
Primeira PythonBrasil == 2
Em busca de oportunidades e desaﬁos!

Por que Pyramid?
Simplicidade
Desempenho

Por que Pyramid?
Simplicidade
Desempenho
Ambiente familiar : from Zope/Plone World

Por que Pyramid?
Simplicidade
Desempenho
Identiﬁcação com o projeto

Por que Pyramid?
Simplicidade
Desempenho
Identiﬁcação com o projeto
Mais detalhes adiante ...

História
Projeto repoze.zope2: suporte WSGI Zope2 (reescrita
ZPublisher)

História
ZPublisher)
Problemas de compatibilidade com Zope2 motivaram a
criação de um novo framework

História
ZPublisher)
Zope3 foi avaliado, porém percebeu-se que ele levava a
mais indireções que o Zope2

História
ZPublisher)
Pylons e Django não possuíam recursos comuns do Zope:
traversal, declarative security e extensibilidade

História
ZPublisher)
Nasceu o repose.bfg que teve sua primeira versão em
julho 2008

História
ZPublisher)
julho 2008
No ﬁnal de 2010 o projeto repoze.bfg foi renomeado para
Pyramid e se integrou ao Pylons

História
ZPublisher)
julho 2008
No ﬁnal de 2010 o projeto repoze.bfg foi renomeado para
Pyramid e se integrou ao Pylons
Seu desenvolvimento foi inﬂuenciado pelo Zope2, Zope3,
Pylons 1.0 e Django

Princípios que nortearam o desenvolvimento do Pyramid:
Simplicidade
Minimalismo
Documentação
Desempenho / Velocidade
Conﬁabilidade
Aberto (Openess)

Simplicidade
"Pagar apenas por aquilo que se come"

Simplicidade
Permitir resultados práticos apenas com conhecimento
parcial do Pyramid

Simplicidade
parcial do Pyramid
Framework não deve forçar a utilização de uma
tecnologia especíﬁca

Simplicidade
parcial do Pyramid
Manutenção dos conceitos centrais ao mínimo necessário

Simplicidade
parcial do Pyramid
Manutenção dos conceitos centrais ao mínimo necessário
"Not build by aliens!"

Minimalismo
O escopo do framewok limita-se ao desenvolvimento de
aplicações Web

Minimalismo
aplicações Web
Mapear as URLs ao código

Minimalismo
aplicações Web
Renderização de templates e views

Minimalismo
aplicações Web
Segurança / Autenticação

Minimalismo
aplicações Web
Servir artefatos estáticos

Minimalismo
aplicações Web
Servir artefatos estáticos
Obs: não contém ORM especíﬁco ou deﬁnição de uma
tecnologia de banco de dados "padrão"

Documentação
Ser minimalista implica em maior facilidade para manter
a documentação atualizada e completa

Documentação
Ser minimalista implica em maior facilidade para manter
a documentação atualizada e completa
O objetivo é que nenhum aspecto do Pyramid ﬁque sem
documentação

Projetado para prover alta velocidade de execução para
as tarefas comuns, tais como:

E geração de respostas http para o browser: response
objects

Conﬁabilidade / Testes
Pyramid é desenvolvido de forma conservadora e testado
exaustivamente

Conﬁabilidade / Testes
Pyramid é desenvolvido de forma conservadora e testado
exaustivamente
Por deﬁnição: "Se não existe cobertura de testes o código
está quebrado"

Aberto (Openess)
Como Python, o código fonte do Pyramid é distribuído
sobre uma licença permissiva

Diferenciais Pyramid
Gerenciador de transações

Modelo de Conﬁguração

Traversal

Traversal
Flexibilidade das Views

Traversal
Tweens (plugins)

Traversal
Tweens (plugins)
Scaffolds

Hello World! - Aplicação em apenas um arquivo
1 from wsgiref . simple_server import make_server
2 from pyramid. config import Configurator
3 from pyramid. response import Response
4
5 def hello_world( request ) :
6 return Response( ' Hello %(name)s! ' % request . matchdict)
7
8 if __name__ == '__main__ ' :
9 config = Configurator ()
10 config . add_route( ' hello ' , ' / hello /{name} ' )
11 config . add_view( hello_world , route_name=' hello ' )
12 app = config .make_wsgi_app()
13 server = make_server( '0.0.0.0 ' , 8080, app)
14 server . serve_forever ()

Deploy
1 virtualenv −−no−site−packages deploy
2 cd deploy
3 source bin / activate
4 easy_install i n s ta l l pyramid==1.4.5

Criando um projeto com Scaffold : template alchemy
1 # criando um novo pacote usando scaffold
2 mkdir src
3 pcreate −s alchemy src / PyBR9Project
1 # visualizando a estrutura do pacote :
2 ls src / PyBR9Project / pybr9project
3
4 __init__ .py
5 models.py
6 scripts
7 static
8 templates
9 tests .py
10 views .py
11
12 # executando testes :
13 python src / PyBR9Project / setup .py test

Instalando o pacote e inicializando a aplicação
1 # instalando pacotes para desenvolvimento :
2 cd src / PyBR9Project
3 python setup .py develop
4
5 # i n i t database
6 initialize_PyBR9Project_db development. i n i
7
8 # i n i t web server
9 pserve development. i n i
Abrir: http://localhost:6543/

Conﬁguração utilizando Decorators
Os view decorators no Pyramid são inertes, apenas
detectados e ativados explicitamente.
No __init__.py da raiz do pacotes: conﬁg.scan()
1 from pyramid. view import view_config
3
4 @view_config(route_name=' turismo ' )
5 def turismo_view( request ) :
6 return Response( 'Pontos Turisticos ' )

Conﬁguração de rotas e API para URL / PATH
Deﬁnição da rota:
1 # "config" instance of pyramid. config . Configurator
2 config . add_route( ' turismo ' , ' / turismo ' , view=turismo_view)
Helpers para geração de URL ou PATH para um determinada
rota:
1 url = request . route_url ( ' foo ' , one='1 ' , two='2 ' )
2 # url : http : / / dominio / prefix /1/2
3 path = request . route_path ( ' foo ' , one='1 ' , two='2 ' )
4 # path : prefix /1/2
Referência: urldispatch

Arquivos estáticos (static ﬁles)
É possível servir mais de um conjunto de arquivos
estáticos: /static e /static2
Caminhos estáticos pode ser serrvidos diretamente de
um webserver e o Pyramid gera URLs para esses arquivos
Ambiente de desenvolvimento ou produção controlado
pelo arquivo .ini
1 # config is an instance of pyramid. config . Configurator
2 config . add_static_view (name=' static ' , path=' / var /www/ static ' )
3 # another way static directory relative from package root
4 config . add_static_view ( 'static_myapp ' , 'myapp: static ' )

Barra de Debug: recursos
Scaffolds em geral habilitam debug toolbar em
development.ini:
rotas conﬁguradas e ultimas renderizações executadas
visualizar o conjunto atual de pacotes instalados
acompanhar as consultas executadas no sqlalchemy
visualizar os logs e várias outras informações da
requisição
add-on pyramid_debugtoolbar_mongo para visualizar
informações do MongoDB

Barra de Debug: notfound, authorization
Em caso de exceção, debugger interativo permie analisar o
problema diretamente no navegador;
É possível habilitar um debug para exceções do tipo
NotFound "debug_notfound"
E também para debuggar a camada de autenticação
"debug_authorization"

Commnad line: pviews e proute
Comandos disponíveis para visualização da conﬁguração do
projeto:
1 pviews development. i n i /
2 URL = /
3 context : <pyramid. traversal . DefaultRootFactory instance . .
4 view name:
5 Route:
6 −−−−−−
7 route name: home
8 route pattern : /
9 route path : /
10 subpath:
11 View:
12 −−−−−
13 pybr9project . views .my_view

Add-ons
Alguns exemplos de add-ons disponíveis para o Pyramid:
Enviar email, autenticação LDAP
Gerador de formulários: FormAlchemy, Deform
Usar XML-RPC ou JSON-RPC
Integração com jQuery Mobile
Integração Beaker, Redis, MongoDB, etc.

Class based e Function based views
Pyramid tem o conceito uniﬁcado de view callable
Funções, métodos de classe e instâncias (__call__)
Exemplo de class view:
3
4 class AView(object ) :
5 def __init__ ( self , request ) :
6 self . request = request
7
8 @view_config(route_name='view_one ' )
9 def view_one( self ) :
10 return Response( 'one ' )
11
12 @view_config(route_name='view_two ' )
13 def view_two( self ) :
14 return Response( 'two ' )

Asset specifications
Asset specifications: são strings que contém o nome de um
pacote python e um arquivo ou diretório.
1 MyPackage: static / index . html
Extensível: não precisa depender de um global "static
directory"
Override: permite substituir a definição de um Asset
configurado em outro pacote
Para modificar um template específico basta sobrescrever
o asset specification com a versão customizada

Extensible templating
Pyramid possui uma API preparada para plugar novos
"renderers"
Cada sistema de template é tratado como um renderer,
tais como: Mako, Genshi, Chameleon e Jinja2
Você pode usar qualquer um desses templates da mesma
forma que você usaria os template padrão
É possível usar diferentes sistemas de template em um
mesmo projeto

Views com templates podem retornar dicionários
Se você usa um template "renderer", sua view não
precisa retornar um tipo especial de Response object
Basta retornar um dicionário e o Pyramid vai cuidar de
gerar um Response com o template escolhido
1 from pyramid. renderers import render_to_response
2
3 def myview( request ) :
4 return render_to_response ( 'myapp: templates /mytemplate. pt ' ,
5 { 'a ' :1} , request=request )
2
3 @view_config( renderer='myapp: templates /mytemplate. pt ' )
4 def myview( request ) :
5 return { 'a ' :1}

Sistema de Eventos
Pyramid emite determinados eventos durante o ciclo de
vida de cada Request
Você pode registrar a quantidade necessária de listeners
para caputurar esses eventos
Por exemplo, se registrar um listener para o evento do
tipo NewRequest, a cada novo request o listener será
invocado
O mesmo vale para o tipo de evento BeforeRender, que
informa quando um template será renderizado
A utilização de um sistema de eventos integrado ao
Pyramid minimiza o uso de "hardcoded hooks"
Você pode usar o sistema de eventos do Pyramid para
gerar seus próprios eventos, os quais outras aplicações
poderão capturar

HTTP caching
O Pyramid pode gerar os headers Cache-Control e Expires
automaticamente para fazer cache de qualquer view
facilmente.
Basta fornecer o parâmetro http_cache para o decorador
view_conﬁg, informando o tempo de cache em segundos
1 @view_config(http_cache=3600) # 60 minutes
2 def myview( request ) : ... .

Controle de sessão
Pyramid tem o recurso de sessão HTTP integrado
E ao mesmo tempo ele permite que você use seu próprio
sitema de sessão se você precisar
Já existe um pacote que permite integrar e substituir o
sitema de sessão padrão pelo Beaker
Você pode trocar os sitemas de sessão sem necessitar
qualquer modiﬁcação no seu código

Desempenho e Velocidade
O núcleo do Pyramid é marginalmente tão rápido quanto
qualquer outro framework web em Python
Ele foi desenvolvido desde seu princípio com foco em
desemepenho
Apenas o trabalho absolutamente necessário é realizado
para desempenhar uma dada tarefa
Chamda de funões desenecessárias e algoritimos sub
otimizados são evitados
É normal conseguir entre 3500 e 4000 requests por
segundo em uma aplicação Pyramid simples + mod_wsgi
ou gunicorn
Referência de comparação:
the-great-web-framework-shootout

Exception views
Pyramid permite que você registre uma ou mais
"exception view"
A view é invocadas quando ocorre uma exceção não
tratada pela aplicação
É possível registrar uma exception view para a execeção
do tipo Exception (log e generic message)
Ou para a Exception NotFound por exemplo, apenas para
logar recursos não existentes
2
3 @view_config( context=Exception)
4 def error_view(exc , request ) :
5 #log or do other stuff to exc ...
6 return Response( "Sorry there was an error " )

No Singletons
Não requer a construção de um “mutable globals”
import de uma aplicação Pyramid não deve gerar
qualquer “import-time side effects”
Diferencial em relação aos app Flask e Django

View predicates
O decorator view_conﬁg possui uma série de predicados que
podem ser usados para controlar a situação no qual a view
estará disponível.
No exemplo abaixo, tempo request_methos, context e name:
1 from resources import MyResource
4
5 @view_config(name='my_view ' , request_method='POST ' , context=MyResource
6 permission='read ' )
7 def my_view( request ) :
8 return Response( 'OK' )
Referência: viewconﬁg

Transaction Management
Pyramid scaffold conﬁgura o gerenciador de transações
baseado no Zope
Usando o gerenciador de transações não é preciso mais
controlar o commit
Ele cuida do committ: efetiva a transação no ﬁnal do
reguest ou aborta se uma exceção for levantada
Ter um local central de para controlar as transações
normalmente é muito útil
É possível também sincronizar o commit entre múltiplos
bancos de dados e realizar tarefas condicionalmente,
como enviar email apenas se houver commit

Outros recursos disponíveis
Segue outros recursos importante que não serão vistos em
detalhes:
Internationalization integrada
Detecção de conflitos de configuração
Extensibilidade da Configuração
Authentication and Authorization
Traversal
Tweens (plugins)
View response adapters
"Global"response object
Automatizar configuração repetitiva
Testes
Suporte
Documentação

Pyramid - O Framework Web para Todos

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Pyramid - O Framework Web para Todos

Pyramid - O Framework Web para Todos