A convite do Marcel da PyCursos, no dia 13/05/2013 eu estive representando a MixinCode na apresentação da palestra Deploy completo de uma aplicação Django.
Desde já, agradeço pelo convite e também ao pessoal que ficou firme e forte até o final da palestra que durou um pouco mais de duas horas.
Abaixo os vídeos e slides.
Vídeo oficial do Hangout:
Vídeo gravado pelo screenflow (alta qualidade):
Slides no slideshare:
Vejamos um pequeno exemplo de uso do class based views no Django:
# views.py
from django.views.generic import ListView
from books.models import Publisher
class PublisherList(ListView):
model = Publisher
# urls.py
from django.conf.urls import patterns, url
from books.views import PublisherList
urlpatterns = patterns('',
url(r'^publishers/$', PublisherList.as_view()),
)
O problema desse código é que você precisa importar o PublisherList no urls.py, para pequenos projetos isso não é problema, mas se o projeto for muito grande o tempo de carregamento do urls.py será comprometido.
Usando o paradigma tradicional de views (uma função que recebe request e retorna um HttpResponse) podemos carregar essa view apenas quando necessário, isso é chamado de lazy loading, muito melhor para grandes projetos, pois a importação de todas as views no urls.py é desnecessária.
Podemos resolver isso de uma maneira muito fácil:
# views.py
from django.views.generic import ListView
from books.models import Publisher
class PublisherList(ListView):
model = Publisher
publisher_list = PublisherList.as_view()
# urls.py
from django.conf.urls import patterns, url
urlpatterns = patterns('',
url(r'^publishers/$', 'myapp.views.publisher_list'),
)
Acabei de gravar um screencast que deve servir para o pessoal que tem dúvidas sobre o deploy de uma aplicação django com nginx e gunicorn.
Todos que trabalham com desenvolvimento de sistemas já se depararam com o seguinte problema: Como faço para buscar um endereço pelo cep ou vice-versa?
Existe um banco de ceps que pode ser encontrado facilmente usando algum sistema de buscas pela web, o problema é que esse banco é de 2009 e provavelmente desatualizado. Para vergonha dos brasileiros, o site dos correios não provê um webservice oficial para busca de ceps, o máximo que oferece é um form em que os resultados são devolvidos em html mesmo, nada de retorno em json/xml, inclusive os correios te vendem uma base de cep com 900 mil ceps pela pechincha de R$ 1.100,00.
Uma solução viável (até que os correios não botem um captcha na busca) é fazer um screen-scraping em python do resultado html devolvido, para isso já existe uma ótima biblioteca chamada cep que resolve esse problema.
Então eu tive a seguinte ideia, porque não usar o tornado para servir como um webservice do resultado que a biblioteca cep devolve? Eu posso usar o async http cliente do tornado e assim conseguir retornar esses resultados sem bloquear outras requisições que chegam ao meu servidor.
Fazendo um projetinho de 15 minutos eu cheguei no seguinte código (claro, ainda dá pra refatorar muita coisa ainda):
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tornado.ioloop
import tornado.web
import tornado.httpclient
import tornado.escape
from urllib import urlencode
# http://pypi.python.org/pypi/cep
from cep import Correios
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write(
'<html><body><form action="/search" method="get">'
'<input type="text" name="query">'
'<input type="submit" value="Pesquisar">'
'</form></body></html>'
)
class SearchHandler(tornado.web.RequestHandler):
@tornado.web.asynchronous
def get(self):
# get search argument
query = self.get_argument('query', None)
# write error for empty argument
if not query or query == '':
self.write("Por favor preencha o formulário de busca")
self.finish()
# create data for request body
data = dict(
EndRow='10',
Metodo='listaLogradouro',
StartRow='1',
TipoConsulta='relaxation',
relaxation=query.encode('cp1252'),
)
# create http request
request = tornado.httpclient.HTTPRequest(
'http://www.buscacep.correios.com.br/servicos/dnec/consultaLogradouroAction.do',
method='POST',
body=urlencode(data, True)
)
# create async http client
http = tornado.httpclient.AsyncHTTPClient()
# load page
http.fetch(request, callback=self.process_response)
def process_response(self, response):
# if error raise status code 500
if response.error:
raise tornado.web.HTTPError(500)
# cep parsing
c = Correios()
resultados = c._parse_tabela(response.body)
# create json
json = tornado.escape.json_encode(resultados)
# output json
self.set_header('Content-Type', 'application/json')
self.write(json)
self.finish()
application = tornado.web.Application([
tornado.web.url(r'/', MainHandler, name='main'),
tornado.web.url(r'/search', SearchHandler, name='search'),
])
if __name__ == '__main__':
application.listen(8888)
tornado.ioloop.IOLoop.instance().start()
Basicamente temos apenas dois handlers, o primeiro é um form com o campo query e o segundo é um handler assíncrono que recebe a query e processa uma request para o site dos correios, ao receber o html eu passo o processamento para a biblioteca cep e finalmente devolvo o resultado em json.
Pronto, agora você pode rodar um webservice local para buscar os ceps diretamente dos correios, lógico que esse projeto pode melhorar bastante, podemos guardar os resultados em um banco de dados evitando que sempre seja feita uma requisição ao site dos correios.
É muito comum o uso de slugs na construção de urls elegantes, o Django já vem com uma função chamada slugify que transforma um string no formato de slug.
Utilizando o signals, podemos criar uma função que faz o processamento do slug após o registro ser criado no banco, ficando transparente para o usuário final.
Eu vou criar um model chamado category com name e slug
# models.py
# -*- coding: utf-8 -*-
from django.db import models
class Category(models.Model):
# category name
name = models.CharField(u'nome', max_length=100)
# category slug
slug = models.SlugField(max_length=150, editable=False)
def __unicode__(self):
return self.name
class Meta:
verbose_name = u'categoria'
verbose_name_plural = u'categorias'
Note que é interessante usar mais caracteres no max_length do slug, aqui temos o name com max_length=100 e o slug com max_length=150.
Agora para um melhor controle, vamos adicionar outros dois atributos:
slug_field_name: informa qual é o atributo slug
slug_from: informa o atributo de onde o slug vai ser gerado
# models.py
# -*- coding: utf-8 -*-
from django.db import models
class Category(models.Model):
# category name
name = models.CharField(u'nome', max_length=100)
# category slug
slug = models.SlugField(max_length=150, editable=False)
# Field to slug
slug_field_name = 'slug'
slug_from = 'name'
def __unicode__(self):
return self.name
class Meta:
verbose_name = u'categoria'
verbose_name_plural = u'categorias'
Agora vamos escrever a função que vai tratar o signal
# signals.py
# -*- coding: utf-8 -*-
from django.template.defaultfilters import slugify
def create_slug(sender, instance, signal, *args, **kwargs):
# check for id and attributes
if instance.id and hasattr(instance, 'slug_field_name') and hasattr(instance, 'slug_from'):
# get slug information
slug_name = instance.slug_field_name
slug_from = instance.slug_from
# save slug if empty
if not getattr(instance, slug_name, None):
# create slug
slug = '%s-' % instance.id + slugify(getattr(instance, slug_from))
# set slug
setattr(instance, slug_name, slug)
# save instance
instance.save()
A função create_slug checa se a instância em questão possui id, slug_field_name e slug_from, caso o slug não esteja preenchido um novo slug é gerado e gravado.
Para geração de slugs eu utilizei a concatenação do id do objeto e o slug, por isso que é sempre interessante deixar o max_length do slug maior do que a origem dele. Dessa forma nunca vai existir slugs em duplicidade, porque o id da instância sempre é diferente.
Para finalizar, basta adicionar o signal no models.py
# models.py
# -*- coding: utf-8 -*-
from django.db import models
from django.db.models import signals
from signals import create_slug
class Category(models.Model):
# category name
name = models.CharField(u'nome', max_length=100)
# category slug
slug = models.SlugField(max_length=150, editable=False)
# Field to slug
slug_field_name = 'slug'
slug_from = 'name'
def __unicode__(self):
return self.name
class Meta:
verbose_name = u'categoria'
verbose_name_plural = u'categorias'
# Signals
signals.post_save.connect(create_slug, sender=Category)
Como essa função é genérica, você pode usar ela em qualquer model, basta informar o slug_field_name e slug_from.
As dicas desse post foram tiradas da apresentação Advanced Django Forms Usage da DjangoCon, recomendo que todos vejam o vídeo e os slides.
Vídeo:
Slides: http://speakerdeck.com/u/maraujop/p/advanced-django-forms-usage
Esse primeiro exemplo mostra o uso tradicional de um form dentro de uma view do Django:
def my_view(request, template_name='myapp/my_form.html'):
if request.method == 'POST':
form = MyForm(request.POST) # Form #1!
if form.is_valid(): # nested if!
do_x()
return redirect('/')
else:
form = MyForm() # Form #2!
return render(request, template_name, {'form': form})
O principal problema desse código é que você tem o form declarado duas vezes quando é possível declarar uma única vez. Podemos reescrever esse código dessa forma:
def my_view(request, template_name='myapp/my_form.html'):
# sticks in a POST or renders empty form
form = MyForm(request.POST or None)
if form.is_valid():
do_x()
return redirect('home')
return render(request, template_name, {'form': form})
Agora temos menos linhas de código, o form declarado uma única vez e um if a menos.
No caso de um form com upload de arquivos, podemos fazer assim:
def my_view(request, template_name='myapp/my_form.html'):
form = MyForm(request.POST or None, request.FILES or None)
if form.is_valid():
do_x()
return redirect('home')
return render(request, template_name, {'form': form})
Em todo projeto Django é comum que se use bastante os modelforms, nesse caso o uso tradicional é dessa forma:
def my_model_edit(request, slug=slug, template_name='myapp/my_model_form.html'):
# I wouldn't call the variable model, because it's an instance of a model, it's confusing
mymodel = get_object_or_404(MyModel, slug=slug)
if request.method == 'POST':
form = MyForm(request, instance=mymodel)
if form.is_valid():
mymodel = form.save()
mymodel.day_shown = datetime.datetime.now() # Do any extra model stuff here
mymodel.save()
return redirect('home')
else:
form = MyForm(instance=mymodel)
return render(request, template_name, {'form': form, 'model': mymodel})
Aqui temos o mesmo problema do form simples, o form é declarado duas vezes, podemos reescrever dessa forma:
def my_model_edit(request, slug=slug, template_name='myapp/my_model_form.html'):
mymodel = get_object_or_404(MyModel, slug=slug)
form = MyModelForm(request.POST or None, instance=mymodel)
if form.is_valid():
mymodel = form.save()
mymodel.edited_at_djangocon = True
mymodel.save()
return redirect('home')
return render(request, template_name, {'form': form, 'mymodel': mymodel})
Novamente temos menos linhas de código, o form declarado uma única vez e apenas um if.
Para um modelform de adição o código ficaria o seguinte:
def my_model_add(request, template_name='myapp/my_model_form.html'):
form = MyModelForm(request.POST or None)
if form.is_valid():
mymodel = form.save()
mymodel.added_at_djangocon = True
mymodel.save()
return redirect('home')
return render(request,template_name,{'form': form})
Além dessas dicas existem várias outras na apresentação, recomendo mais uma vez a todos que assistam e baixem os slides.
WSGI (Web Server Gateway Interface) é uma especificação de interface que permite a comunicação entre o servidor e sua aplicação python, o PEP 333 descreve em detalhes toda especificação do WSGI 1.0 (existe o PEP 3333 que descreve o WSGI 1.0.1, mas o padrão utilizado atualmente ainda é o 1.0).
O Gunicorn é projeto de maior destaque quando se fala de servidor WSGI nativo, com ele não é preciso de nenhum adaptador WSGI para outro servidor web, apesar disso é bem comum que se utilize um servidor web para servir conteúdo estático e passar o conteúdo dinâmico para o servidor WSGI usando o esquema de proxy reverso.
O mod_wsgi e uwsgi são os maiores projetos em termos de adaptadores WSGI, o mod_wsgi roda em conjunto com o Apache, já o uwsgi roda em conjunto com NGINX.
O grande benefício do WSGI é que já existem servidores/adaptadores bastante eficientes, então você só precisa se preocupar com a parte da aplicação em si, além disso, praticamente todos os frameworks web fazem uso do WSGI o que torna ele o padrão para deploy de aplicações.
Um exemplo de hello world com wsgi
# -*- coding: utf-8 -*-
def hello_world_wsgi(environ, start_response):
'''
Uma função simples que demonstra como fazer um hello world com WSGI.
Essa função deve receber dois argumentos environ e start_response.
O environ contém um dicionário em python com valores preenchidos pelo
servidor em cada requisição recebida.
Para saber mais sobre as variáveis que vem no environ visite:
http://www.python.org/dev/peps/pep-0333/#environ-variables
O start_response é um callback enviado pelo servidor para que sua aplicação
responda a requisição.
'''
# o status segue o padrão do w3:
# http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
status = '200 OK'
# response body é o conteúdo que deve ser retornado
response_body = 'Hello World!'
# response_headers é o cabeçalho de resposta, geralmente contém o tipo
# de conteúdo retornado e o tamanho.
response_headers = [
('Content-Type', 'text/plain'),
('Content-Length', str(len(response_body)))
]
# a resposta deve ser iniciada utilizando o start_response
start_response(status, response_headers)
# por fim o conteúdo deve ser retornado utilizando alguma estrutura python
# iterável, nesse caso uma lista foi usada.
return [response_body]
# iniciando um servidor wsgi na porta 8080
if __name__ == '__main__':
from wsgiref.simple_server import make_server
srv = make_server('localhost', 8080, hello_world_wsgi)
srv.serve_forever()
Claro que esse exemplo pode ser melhorado, vejamos outro exemplo mais elaborado
# -*- coding: utf-8 -*-
def application_handler(environ, start_response):
'''
Função responsável por gerenciar as requisições WSGI.
Caso a requisição seja para a raíz do site '/' o index_handler vai ser
carregado, caso contrário o not_found_handler é carregado.
'''
# recebendo o valor do PATH
path = environ.get('PATH_INFO', '')
# verificando se o path é a raíz do site
if path == '/':
return index_handler(environ, start_response)
else:
return not_found_handler(environ, start_response)
def index_handler(environ, start_response):
'''
Retorna a página index do site.
'''
status = '200 OK'
response_body = '<h1>Welcome!</h1>'
response_headers = [
('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))
]
start_response(status, response_headers)
return [response_body]
def not_found_handler(environ, start_response):
'''
Retorna a página 404 de um site.
'''
status = '404 NOT FOUND'
response_body = '<h1>Not found!</h1>'
response_headers = [
('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))
]
start_response(status, response_headers)
return [response_body]
# iniciando um servidor wsgi na porta 8080
if __name__ == '__main__':
from wsgiref.simple_server import make_server
srv = make_server('localhost', 8080, application_handler)
srv.serve_forever()
Podemos melhorar a maneira que as urls são chamadas
# -*- coding: utf-8 -*-
import re
def index_handler(environ, start_response):
'''
Retorna a página index do site.
'''
status = '200 OK'
response_body = '<h1>Welcome!</h1>'
response_headers = [
('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))
]
start_response(status, response_headers)
return [response_body]
def hello_handler(environ, start_response):
'''
Retorna a página hello world do site.
'''
status = '200 OK'
response_body = '<h1>Hello World!</h1>'
response_headers = [
('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))
]
start_response(status, response_headers)
return [response_body]
def not_found_handler(environ, start_response):
'''
Retorna a página 404 de um site.
'''
status = '404 NOT FOUND'
response_body = '<h1>Not found!</h1>'
response_headers = [
('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))
]
start_response(status, response_headers)
return [response_body]
# Lista de urls, cada elemento é uma tupla com dois valores: uma expressão
# regular da url e a função que vai processar a requisição, muito parecido com
# o esquema do django.
urls = [
(r'^$', index_handler),
(r'^hello/$', hello_handler),
]
def application_handler(environ, start_response, urls=urls):
'''
Função responsável por gerenciar as requisições WSGI.
As requisições são despachadas de acordo com a url da lista de urls.
'''
# recebendo o valor do PATH
path = environ.get('PATH_INFO', '').lstrip('/')
# verificando se o path tem algum handler correspondente, caso contrário
# retorne 404
for regex, callback in urls:
match = re.search(regex, path)
if match is not None:
return callback(environ, start_response)
return not_found_handler(environ, start_response)
# iniciando um servidor wsgi na porta 8080
if __name__ == '__main__':
from wsgiref.simple_server import make_server
srv = make_server('localhost', 8080, application_handler)
srv.serve_forever()
O código acima tem um pequeno problema, ao acessar o /hello e /hello/ você recebe resultados diferentes, o primeiro retorna 404 enquanto o segundo retorna a página do hello world. Isso acontece por causa do ‘/’ no final da url, seria interessante escrever um middleware que adicionasse essa barra de forma automática se necessário.
# -*- coding: utf-8 -*-
import re
def index_handler(environ, start_response):
'''
Retorna a página index do site.
'''
status = '200 OK'
response_body = '<h1>Welcome!</h1>'
response_headers = [
('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))
]
start_response(status, response_headers)
return [response_body]
def hello_handler(environ, start_response):
'''
Retorna a página hello world do site.
'''
status = '200 OK'
response_body = '<h1>Hello World!</h1>'
response_headers = [
('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))
]
start_response(status, response_headers)
return [response_body]
def not_found_handler(environ, start_response):
'''
Retorna a página 404 de um site.
'''
status = '404 NOT FOUND'
response_body = '<h1>Not found!</h1>'
response_headers = [
('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))
]
start_response(status, response_headers)
return [response_body]
# Lista de urls, cada elemento é uma tupla com dois valores: uma expressão
# regular da url e a função que vai processar a requisição, muito parecido com
# o esquema do django.
urls = [
(r'^$', index_handler),
(r'^hello/$', hello_handler),
]
def fetch_url(url, urls=urls):
'''
Função para checar se uma url está listada na lista de urls.
Retorna o callback em caso positivo e None em caso negativo.
'''
url = url.lstrip('/')
for regex, callback in urls:
match = re.search(regex, url)
if match:
return callback
return None
def application_handler(environ, start_response):
'''
Função responsável por gerenciar as requisições WSGI.
As requisições são despachadas de acordo com a url da lista de urls.
'''
# recebendo o valor do PATH
path = environ.get('PATH_INFO', '')
# verificando se o path tem algum handler correspondente, caso contrário
# retorne 404
callback = fetch_url(path)
if callback:
return callback(environ, start_response)
return not_found_handler(environ, start_response)
class AddSlashMiddleware(object):
'''
Middleware que verifica se a url requisitada em combinação com o '/' no
final é válida, em caso afirmativo deve ocorrer um redirecionamento.
'''
def __init__(self, application):
self.application = application
def __call__(self, environ, start_response):
# Recebe o path
path = environ.get('PATH_INFO', '')
if not path.endswith('/'):
# Se o path não termina com '/', verificar se esse path
# combinado com o '/' existe na lista de urls
callback = fetch_url(path + '/')
if callback:
# Redireciona para url
uri = path + '/'
start_response('302 FOUND', [('Location', uri)])
return []
# Passa o controle para aplicação
return self.application(environ, start_response)
# cria um application que passa pelo middleware
application = AddSlashMiddleware(application_handler)
# iniciando um servidor wsgi na porta 8080
if __name__ == '__main__':
from wsgiref.simple_server import make_server
srv = make_server('localhost', 8080, application)
srv.serve_forever()
Para finalizar, vamos escrever outro middleware, desta vez eu quero que o html retornado fique todo em letra minúscula.
# -*- coding: utf-8 -*-
import re
def index_handler(environ, start_response):
'''
Retorna a página index do site.
'''
status = '200 OK'
response_body = '<h1>Welcome!</h1>'
response_headers = [
('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))
]
start_response(status, response_headers)
return [response_body]
def hello_handler(environ, start_response):
'''
Retorna a página hello world do site.
'''
status = '200 OK'
response_body = '<h1>Hello World!</h1>'
response_headers = [
('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))
]
start_response(status, response_headers)
return [response_body]
def not_found_handler(environ, start_response):
'''
Retorna a página 404 de um site.
'''
status = '404 NOT FOUND'
response_body = '<h1>Not found!</h1>'
response_headers = [
('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))
]
start_response(status, response_headers)
return [response_body]
# Lista de urls, cada elemento é uma tupla com dois valores: uma expressão
# regular da url e a função que vai processar a requisição, muito parecido com
# o esquema do django.
urls = [
(r'^$', index_handler),
(r'^hello/$', hello_handler),
]
def fetch_url(url, urls=urls):
'''
Função para checar se uma url está listada na lista de urls.
Retorna o callback em caso positivo e None em caso negativo.
'''
url = url.lstrip('/')
for regex, callback in urls:
match = re.search(regex, url)
if match:
return callback
return None
def application_handler(environ, start_response):
'''
Função responsável por gerenciar as requisições WSGI.
As requisições são despachadas de acordo com a url da lista de urls.
'''
# recebendo o valor do PATH
path = environ.get('PATH_INFO', '')
# verificando se o path tem algum handler correspondente, caso contrário
# retorne 404
callback = fetch_url(path)
if callback:
return callback(environ, start_response)
return not_found_handler(environ, start_response)
class AddSlashMiddleware(object):
'''
Middleware que verifica se a url requisitada em combinação com o '/' no
final é válida, em caso afirmativo deve ocorrer um redirecionamento.
'''
def __init__(self, application):
self.application = application
def __call__(self, environ, start_response):
# Recebe o path
path = environ.get('PATH_INFO', '')
if not path.endswith('/'):
# Se o path não termina com '/', verificar se esse path
# combinado com o '/' existe na lista de urls
callback = fetch_url(path + '/')
if callback:
# Redireciona para url
uri = path + '/'
start_response('302 FOUND', [('Location', uri)])
return []
# Passa o controle para aplicação
return self.application(environ, start_response)
class LowercaseMiddleware(object):
'''
Middleware que converte o html todo em letras minúsculas.
'''
def __init__(self, application):
self.application = application
def __call__(self, environ, start_response):
# Faço uma iteração convertendo o valor obtido para minúsculas
for chunk in self.application(environ, start_response):
yield chunk.lower()
# Aplicando o AddSlashMiddleware
application = AddSlashMiddleware(application_handler)
# Aplicando o LowercaseMiddleware
application = LowercaseMiddleware(application)
# iniciando um servidor wsgi na porta 8080
if __name__ == '__main__':
from wsgiref.simple_server import make_server
srv = make_server('localhost', 8080, application)
srv.serve_forever()
Agora temos dois middlewares que são aplicados ao nosso aplicativo, lembrando que a ordem que os middlewares são aplicados é importante.
Como foi visto, o WSGI permite que se criem aplicações de forma bastante simples, recomendo a leitura do Learn WSGI que foi a referência para esse post.
Esse primeiro screencast é uma introdução sobre o Redis, o próximo vai ser apenas sobre casos de uso em sistemas web.
Redis – Introdução from Allisson Azevedo on Vimeo.
Atualização:
Eu não gostei da qualidade de conversão do vídeo no vimeo, então eu fiz o upload para o youtube em qualidade HD (720p), o único problema é que cada vídeo pode ter no máximo 15min, então eu tive que quebrar o screencast em três partes.
Gostei bastante de participar mais uma vez do Ensol, nessa quinta edição eu apresentei a palestra Otimizando sites com o nosql redis
O Django já conta com um aplicativo no contrib para gerar sitemaps, recentemente eu tive alguns problemas com o padrão de objetos por arquivo xml gerado que é de 50 mil por página. Como o sistema tinha certa de 120 mil objetos ficaria muito pesado essa consulta para o banco e também o tempo de renderização do template.
Investigando no código fonte do Django eu percebi como é montado o GenericSitemap :
# trechos do arquivo django/contrib/sitemaps/__init__.py
class Sitemap(object):
# This limit is defined by Google. See the index documentation at
# http://sitemaps.org/protocol.php#index.
limit = 50000
def __get(self, name, obj, default=None):
try:
attr = getattr(self, name)
except AttributeError:
return default
if callable(attr):
return attr(obj)
return attr
def items(self):
return []
def location(self, obj):
return obj.get_absolute_url()
def _get_paginator(self):
if not hasattr(self, "_paginator"):
self._paginator = paginator.Paginator(self.items(), self.limit)
return self._paginator
paginator = property(_get_paginator)
def get_urls(self, page=1, site=None):
if site is None:
if Site._meta.installed:
try:
site = Site.objects.get_current()
except Site.DoesNotExist:
pass
if site is None:
raise ImproperlyConfigured("In order to use Sitemaps you must either use the sites framework or pass in a Site or RequestSite object in your view code.")
urls = []
for item in self.paginator.page(page).object_list:
loc = "http://%s%s" % (site.domain, self.__get('location', item))
priority = self.__get('priority', item, None)
url_info = {
'location': loc,
'lastmod': self.__get('lastmod', item, None),
'changefreq': self.__get('changefreq', item, None),
'priority': str(priority is not None and priority or '')
}
urls.append(url_info)
return urls
class FlatPageSitemap(Sitemap):
def items(self):
current_site = Site.objects.get_current()
return current_site.flatpage_set.filter(registration_required=False)
class GenericSitemap(Sitemap):
priority = None
changefreq = None
def __init__(self, info_dict, priority=None, changefreq=None):
self.queryset = info_dict['queryset']
self.date_field = info_dict.get('date_field', None)
self.priority = priority
self.changefreq = changefreq
def items(self):
# Make sure to return a clone; we don't want premature evaluation.
return self.queryset.filter()
def lastmod(self, item):
if self.date_field is not None:
return getattr(item, self.date_field)
return None
A solução é bastante simples:
from django.contrib.sitemaps import GenericSitemap
from django.conf import settings
SITEMAP_LIMIT = getattr(settings, 'SITEMAP_LIMIT', 2000)
class LimitedSitemap(GenericSitemap):
limit = SITEMAP_LIMIT
Em primeiro lugar eu faço uso da variável SITEMAP_LIMIT que deve ser setada no settings.py, caso ela não esteja setada o valor 2000 é usado.
Depois crio uma classe chamada LimitedSitemap que herda de GenericSitemap e faço uso do limite para paginação. Com um limite de 2000 objetos a consulta ao banco ficou e a renderização do template ficaram bem mais leves.
