本文整理汇总了Python中repoze.lru.LRUCache.clear方法的典型用法代码示例。如果您正苦于以下问题:Python LRUCache.clear方法的具体用法?Python LRUCache.clear怎么用?Python LRUCache.clear使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类repoze.lru.LRUCache
的用法示例。
在下文中一共展示了LRUCache.clear方法的5个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: AdapterRegistry
# 需要导入模块: from repoze.lru import LRUCache [as 别名]
# 或者: from repoze.lru.LRUCache import clear [as 别名]
class AdapterRegistry(object):
""" Registry of adapters"""
_sentinel = object()
def __init__(self):
self.underlying = adapter.AdapterRegistry()
self.cache = LRUCache(500)
def lookup_adapter(self, typ):
""" Lookup adapter for ``typ``"""
adapter = self.cache.get(typ, self._sentinel)
if adapter is self._sentinel:
adapter = self.underlying.lookup([typ], IJSONSerializeable, "")
self.cache.put(typ, adapter)
return adapter
def register_adapter(self, typ, adapter=None):
""" Register ``adapter`` for type ``typ``
If no ``adapter`` supplied then this method returns decorator.
"""
if adapter is None:
def decorator(adapter):
self.register_adapter_impl(typ, adapter)
return adapter
return decorator
return self.register_adapter_impl(typ, adapter)
def register_adapter_impl(self, typ, adapter):
self.underlying.register(
[implementedBy(typ)], IJSONSerializeable, "", adapter)
self.cache.clear()
示例2: ClusterCache
# 需要导入模块: from repoze.lru import LRUCache [as 别名]
# 或者: from repoze.lru.LRUCache import clear [as 别名]
class ClusterCache(object):
def __init__(self, cache_size):
self.lru = LRUCache(cache_size)
self.hits = 0
self.misses = 0
def get(self, file_buffer, ptr):
v = self.lru.get((file_buffer, ptr))
if v is not None:
self.hits += 1
return v
v = ClusterData(file_buffer, ptr)
self.lru.put((file_buffer, ptr), v)
self.misses += 1
return v
def clear(self):
logger.debug("CACHE HITS " + str(self.hits) + " VS MISSES " + str(self.misses))
self.lru.clear()
示例3: EDBag
# 需要导入模块: from repoze.lru import LRUCache [as 别名]
# 或者: from repoze.lru.LRUCache import clear [as 别名]
class EDBag(Counter):
def __init__(self):
super(EDBag, self).__init__()
self.cache1 = LRUCache(256) # values where distance=1
self.cache2 = LRUCache(256) # values where distance>1
def add(self, x):
if not x in self:
self.cache2.clear()
self[x] += 1
def closest_by_edit_distance(self, x):
if x in self:
# Optimization: if x is in multiset, then closest
# edit dist = 0. Nothing can be any closer.
return (x, 0)
# Optimization: If we've looked up this value before,
# return previously computed answer.
cached_answer = self.cache1.get(x)
if cached_answer:
return cached_answer
cached_answer = self.cache2.get(x)
if cached_answer:
return cached_answer
closest = None
closest_dist = None
for y,_ in self.most_common():
d = editdistance.eval(x, y)
if not closest_dist or d < closest_dist:
closest = y
closest_dist = d
if d == 1:
# Optimization: nothing can be any closer, as
# we know there's nothing at edit distance 0 (x is not
# in the multiset).
self.cache1.put(x, (closest, closest_dist))
return (closest, closest_dist)
self.cache2.put(x, (closest, closest_dist))
return (closest, closest_dist)
示例4: LRUShelf
# 需要导入模块: from repoze.lru import LRUCache [as 别名]
# 或者: from repoze.lru.LRUCache import clear [as 别名]
class LRUShelf(Shelf):
"""An in-memory Least-Recently Used shelf up to `maxsize`.."""
def __init__(self, maxsize=1000):
self.store = LRUCache(int(maxsize))
def getitem(self, key):
value = self.store.get(key, UNSET)
if value is UNSET:
raise KeyError(key)
return value
def setitem(self, key, value):
self.store.put(key, value)
def delitem(self, key):
self.store.invalidate(key)
def clear(self):
self.store.clear()
示例5: Registry
# 需要导入模块: from repoze.lru import LRUCache [as 别名]
# 或者: from repoze.lru.LRUCache import clear [as 别名]
class Registry(object):
""" A component registry. The component registry supports the
Python mapping interface and can be used as you might a regular
dictionary. It also support more advanced registrations and
lookups that include a ``requires`` argument and a ``name`` via
its ``register`` and ``lookup`` methods. It may be treated as an
component registry by using its ``resolve`` method."""
def __init__(self, dict=None, **kwargs):
self.data = {}
self._lkpcache = LRUCache(1000)
if dict is not None:
self.update(dict)
if len(kwargs):
self.update(kwargs)
self.listener_registered = False # at least one listener registered
@property
def _dictmembers(self):
D = {}
norequires = self.data.get((), {})
for k, v in norequires.items():
provides, name = k
if name == '':
D[provides] = v
return D
def __cmp__(self, dict):
if isinstance(dict, Registry):
return cmp(self.data, dict.data)
else:
return cmp(self._dictmembers, dict)
def __len__(self):
return len(self._dictmembers)
def __getitem__(self, key):
notrequires = self.data.get((), {})
return notrequires[(key, '')]
def __setitem__(self, key, val):
self.register(key, val)
def __delitem__(self, key):
self._lkpcache.clear()
notrequires = self.data.get((), {})
try:
del notrequires[(key, '')]
except KeyError:
raise KeyError(key)
def clear(self, full=False):
if full:
self.data = {}
else:
notrequires = self.data.get((), {})
for k, v in notrequires.items():
provides, name = k
if name == '':
del notrequires[k]
self._lkpcache.clear()
def copy(self):
import copy
return copy.copy(self)
def items(self):
return self._dictmembers.items()
def keys(self):
return self._dictmembers.keys()
def values(self):
return self._dictmembers.values()
def iteritems(self):
return iter(self.items())
def iterkeys(self):
return iter(self.keys())
def itervalues(self):
return iter(self.values())
def __contains__(self, key):
return key in self._dictmembers
has_key = __contains__
def get(self, key, default=None):
try:
return self[key]
except KeyError:
return default
@classmethod
def fromkeys(cls, iterable, value=None):
d = cls()
for key in iterable:
d[key] = value
return d
#.........这里部分代码省略.........