Pergunta
Existe uma maneira fácil de coisas de cache quando usando urllib2 que eu estou com vista sobre, ou eu tenho que fazer a minha própria?
Solução
Você pode usar uma função decorador tais como:
class cache(object):
def __init__(self, fun):
self.fun = fun
self.cache = {}
def __call__(self, *args, **kwargs):
key = str(args) + str(kwargs)
try:
return self.cache[key]
except KeyError:
self.cache[key] = rval = self.fun(*args, **kwargs)
return rval
except TypeError: # incase key isn't a valid key - don't cache
return self.fun(*args, **kwargs)
e definir uma função ao longo das linhas de:
@cache
def get_url_src(url):
return urllib.urlopen(url).read()
Isso supõe que você não está prestando atenção a controles de cache HTTP, mas só quero para armazenar em cache a página para a duração da aplicação
Outras dicas
Se você não me importo de trabalhar a um nível ligeiramente inferior, httplib2 ( https://github.com/ httplib2 / httplib2 ) é uma excelente biblioteca HTTP que inclui cache funcionalidade.
Esta receita ActiveState Python podem ser úteis: http://code.activestate.com/recipes/491261/
Eu sempre sido dividido entre usando httplib2, que faz um trabalho sólido de lidar com HTTP caching e autenticação, e urllib2, que está no stdlib, tem uma interface extensível e suportes HTTP Os servidores proxy.
O ActiveState receita começa a adicionar cache suporte para urllib2, mas apenas de uma forma muito primitiva moda. Ele falha para permitir extensibilidade em mecanismos de armazenamento, embutir o armazenamento de arquivos-system-backed. Ele também não honrar HTTP cache de cabeçalhos.
Em uma tentativa de reunir as melhores características de httplib2 caching e extensibilidade urllib2, eu adaptei a receita ActiveState para implementar a maior parte da mesma funcionalidade de cache como é encontrado em httplib2. O módulo é em jaraco.net como jaraco.net .http.caching . O link aponta para o módulo como ela existe no momento da redação deste texto. Enquanto que o módulo é atualmente parte do pacote jaraco.net maior, não tem dependências intra-pacote, então sinta-se livre para puxar o módulo para fora e usá-lo em seus próprios projetos.
Como alternativa, se você tiver Python 2.6 ou posterior, você pode easy_install jaraco.net>=1.3
e, em seguida, utilizar o CachingHandler com algo como o código no caching.quick_test()
.
"""Quick test/example of CacheHandler"""
import logging
import urllib2
from httplib2 import FileCache
from jaraco.net.http.caching import CacheHandler
logging.basicConfig(level=logging.DEBUG)
store = FileCache(".cache")
opener = urllib2.build_opener(CacheHandler(store))
urllib2.install_opener(opener)
response = opener.open("http://www.google.com/")
print response.headers
print "Response:", response.read()[:100], '...\n'
response.reload(store)
print response.headers
print "After reload:", response.read()[:100], '...\n'
Note que jaraco.util.http.caching não fornece uma especificação para o armazenamento de backup para o cache, mas ao contrário, segue a interface usada pelo httplib2. Por esta razão, o httplib2.FileCache pode ser usado diretamente com urllib2 eo CacheHandler. Além disso, outros caches de apoio projetadas para httplib2 deve ser utilizável pelo CacheHandler.
Eu estava procurando por algo semelhante, e me deparei com "Receita 491261: Caching e estrangulamento para urllib2" que danivo postou. O problema é que eu realmente não gostam do código caching (lotes de duplicação, os lotes de ingressar manualmente de caminhos de arquivo em vez de usar os.path.join, usos staticmethods, não muito PEP8'sih, e outras coisas que Eu tento evitar)
O código é um pouco melhor (na minha opinião de qualquer maneira) e é funcionalmente muito mesmo, com algumas adições - principalmente o método de "colocar novamente em cache" (exemplo de uso pode ser parecem aqui , ou na seção if __name__ == "__main__":
no final do código).
A versão mais recente pode ser encontrada em http://github.com/ DBR / tvdb_api / blob / master / cache.py , e eu vou colá-lo aqui para a posteridade (com meus cabeçalhos específicos do aplicativo removido):
#!/usr/bin/env python
"""
urllib2 caching handler
Modified from http://code.activestate.com/recipes/491261/ by dbr
"""
import os
import time
import httplib
import urllib2
import StringIO
from hashlib import md5
def calculate_cache_path(cache_location, url):
"""Checks if [cache_location]/[hash_of_url].headers and .body exist
"""
thumb = md5(url).hexdigest()
header = os.path.join(cache_location, thumb + ".headers")
body = os.path.join(cache_location, thumb + ".body")
return header, body
def check_cache_time(path, max_age):
"""Checks if a file has been created/modified in the [last max_age] seconds.
False means the file is too old (or doesn't exist), True means it is
up-to-date and valid"""
if not os.path.isfile(path):
return False
cache_modified_time = os.stat(path).st_mtime
time_now = time.time()
if cache_modified_time < time_now - max_age:
# Cache is old
return False
else:
return True
def exists_in_cache(cache_location, url, max_age):
"""Returns if header AND body cache file exist (and are up-to-date)"""
hpath, bpath = calculate_cache_path(cache_location, url)
if os.path.exists(hpath) and os.path.exists(bpath):
return(
check_cache_time(hpath, max_age)
and check_cache_time(bpath, max_age)
)
else:
# File does not exist
return False
def store_in_cache(cache_location, url, response):
"""Tries to store response in cache."""
hpath, bpath = calculate_cache_path(cache_location, url)
try:
outf = open(hpath, "w")
headers = str(response.info())
outf.write(headers)
outf.close()
outf = open(bpath, "w")
outf.write(response.read())
outf.close()
except IOError:
return True
else:
return False
class CacheHandler(urllib2.BaseHandler):
"""Stores responses in a persistant on-disk cache.
If a subsequent GET request is made for the same URL, the stored
response is returned, saving time, resources and bandwidth
"""
def __init__(self, cache_location, max_age = 21600):
"""The location of the cache directory"""
self.max_age = max_age
self.cache_location = cache_location
if not os.path.exists(self.cache_location):
os.mkdir(self.cache_location)
def default_open(self, request):
"""Handles GET requests, if the response is cached it returns it
"""
if request.get_method() is not "GET":
return None # let the next handler try to handle the request
if exists_in_cache(
self.cache_location, request.get_full_url(), self.max_age
):
return CachedResponse(
self.cache_location,
request.get_full_url(),
set_cache_header = True
)
else:
return None
def http_response(self, request, response):
"""Gets a HTTP response, if it was a GET request and the status code
starts with 2 (200 OK etc) it caches it and returns a CachedResponse
"""
if (request.get_method() == "GET"
and str(response.code).startswith("2")
):
if 'x-local-cache' not in response.info():
# Response is not cached
set_cache_header = store_in_cache(
self.cache_location,
request.get_full_url(),
response
)
else:
set_cache_header = True
#end if x-cache in response
return CachedResponse(
self.cache_location,
request.get_full_url(),
set_cache_header = set_cache_header
)
else:
return response
class CachedResponse(StringIO.StringIO):
"""An urllib2.response-like object for cached responses.
To determine if a response is cached or coming directly from
the network, check the x-local-cache header rather than the object type.
"""
def __init__(self, cache_location, url, set_cache_header=True):
self.cache_location = cache_location
hpath, bpath = calculate_cache_path(cache_location, url)
StringIO.StringIO.__init__(self, file(bpath).read())
self.url = url
self.code = 200
self.msg = "OK"
headerbuf = file(hpath).read()
if set_cache_header:
headerbuf += "x-local-cache: %s\r\n" % (bpath)
self.headers = httplib.HTTPMessage(StringIO.StringIO(headerbuf))
def info(self):
"""Returns headers
"""
return self.headers
def geturl(self):
"""Returns original URL
"""
return self.url
def recache(self):
new_request = urllib2.urlopen(self.url)
set_cache_header = store_in_cache(
self.cache_location,
new_request.url,
new_request
)
CachedResponse.__init__(self, self.cache_location, self.url, True)
if __name__ == "__main__":
def main():
"""Quick test/example of CacheHandler"""
opener = urllib2.build_opener(CacheHandler("/tmp/"))
response = opener.open("http://google.com")
print response.headers
print "Response:", response.read()
response.recache()
print response.headers
print "After recache:", response.read()
main()
Este artigo em Yahoo Developer Network - http://developer.yahoo.com/ python / python-caching.html -. descreve como cache de http chamadas feitas através urllib a memória ou disco
@dbr: você pode precisar adicionar também https respostas cache com:
def https_response(self, request, response):
return self.http_response(request,response)