def set_og_image(image):
if isinstance(image, list):
for count in range(len(image)):
dict = OrderedDict()
dict['property'] = "og:image"
dict['content'] = image[count]
current.response.meta['og_image_'+str(count)] = dict
else:
dict = OrderedDict()
dict['property'] = "og:image"
dict['content'] = image
current.response.meta.og_image = dict
def set_tc_image(image):
dict = OrderedDict()
dict['name'] = "twitter:image"
if isinstance(image, list):
dict['content'] = image[0]
else:
dict['content'] = image
current.response.meta.tc_image = dict
def set_twitter_card(card="summary", title=None,
creator=None, site=None, label1=None,
data1=None, label2=None, data2=None,
image=None, description=None):
if not title:
title = current.request.application.replace('_', ' ').title()
data = locals()
for name in ['card', 'title', 'description', 'creator', 'site', 'label1', 'data1', 'label2', 'data2']:
dict = OrderedDict()
if data[name]:
dict['property'] = "twitter:"+name
dict['content'] = data[name]
current.response.meta['tc_'+name] = dict
if image:
set_tc_image(image)
def set_open_graph(type="website", title=None,
url=None, image=None, description=None,
site_name=None, locale=None, locale_alternate={}):
if not title:
title = current.request.application.replace('_', ' ').title()
if not url:
url = URL(args=current.request.args, host=True)
data = locals()
for name in ['type', 'title', 'url', 'description', 'site_name', 'locale']:
dict = OrderedDict()
if data[name]:
dict['name'] = "og:"+name
dict['content'] = data[name]
current.response.meta['og_'+name] = dict
if image:
set_og_image(image)
def __init__(self, request=None):
self.initialized = False
self.request = request
self.storage = OrderedDict() if HAVE_PSUTIL else {}
self.app = request.application if request else ''
class CacheInRam(CacheAbstract):
"""
Ram based caching
This is implemented as global (per process, shared by all threads)
dictionary.
A mutex-lock mechanism avoid conflicts.
"""
locker = thread.allocate_lock()
meta_storage = {}
stats = {}
def __init__(self, request=None):
self.initialized = False
self.request = request
self.storage = OrderedDict() if HAVE_PSUTIL else {}
self.app = request.application if request else ''
def initialize(self):
if self.initialized:
return
else:
self.initialized = True
self.locker.acquire()
if not self.app in self.meta_storage:
self.storage = self.meta_storage[self.app] = \
OrderedDict() if HAVE_PSUTIL else {}
self.stats[self.app] = {'hit_total': 0, 'misses': 0}
else:
self.storage = self.meta_storage[self.app]
self.locker.release()
def clear(self, regex=None):
self.initialize()
self.locker.acquire()
storage = self.storage
if regex is None:
storage.clear()
else:
self._clear(storage, regex)
if not self.app in self.stats:
self.stats[self.app] = {'hit_total': 0, 'misses': 0}
self.locker.release()
def __call__(self, key, f,
time_expire=DEFAULT_TIME_EXPIRE,
destroyer=None):
"""
Attention! cache.ram does not copy the cached object.
It just stores a reference to it. Turns out the deepcopying the object
has some problems:
- would break backward compatibility
- would be limiting because people may want to cache live objects
- would work unless we deepcopy no storage and retrival which would make
things slow.
Anyway. You can deepcopy explicitly in the function generating the value
to be cached.
"""
self.initialize()
dt = time_expire
now = time.time()
self.locker.acquire()
item = self.storage.get(key, None)
if item and f is None:
del self.storage[key]
if destroyer:
destroyer(item[1])
self.stats[self.app]['hit_total'] += 1
self.locker.release()
if f is None:
return None
if item and (dt is None or item[0] > now - dt):
return item[1]
elif item and (item[0] < now - dt) and destroyer:
destroyer(item[1])
value = f()
self.locker.acquire()
self.storage[key] = (now, value)
self.stats[self.app]['misses'] += 1
if HAVE_PSUTIL:
remove_oldest_entries(self.storage, percentage = self.max_ram_utilization)
self.locker.release()
return value
def increment(self, key, value=1):
self.initialize()
self.locker.acquire()
try:
if key in self.storage:
value = self.storage[key][1] + value
self.storage[key] = (time.time(), value)
except BaseException, e:
self.locker.release()
raise e
self.locker.release()
return value
