本文整理汇总了Python中repoze.lru.LRUCache类的典型用法代码示例。如果您正苦于以下问题:Python LRUCache类的具体用法?Python LRUCache怎么用?Python LRUCache使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了LRUCache类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: AdapterRegistry
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: LRUCache
class LRUCache(StorageInterface):
"""In memory LRU cache"""
def __init__(self, max_size=1024):
if max_size < 1:
raise ValueError("max_size must be a positive integer greater than 0")
self.max_size = max_size
self.engine = LRUCacheEngine(max_size)
def __getitem__(self, key):
value = self.engine.get(key)
if value is None:
raise KeyError
return value
def __setitem__(self, key, value):
self.engine.put(key, value)
def __contains__(self, key):
value = self.engine.get(key)
if value is not None:
return True
else:
return False
def __len__(self):
return self.max_size
示例3: StaticsMiddleware
class StaticsMiddleware(object):
def _adapt_path(self, path):
return normcase(normpath(path))
def __init__(self, app, root_dir, cache_max_age=3600):
self.app = app
self.cache_max_age = cache_max_age
self.doc_root = self._adapt_path(root_dir)
self.paths_cache = LRUCache(1024)
def __call__(self, environ, start_response):
full_path = environ['PATH_INFO']
filepath = self.paths_cache.get(full_path)
if filepath is None:
path = full_path.split('/')
if INVALID_PATH_PARTS(path):
return HTTPNotFound('Out of bounds: %s' % environ['PATH_INFO'])(environ, start_response)
filepath = self._adapt_path(join(self.doc_root, *path))
self.paths_cache.put(full_path, filepath)
if isfile(filepath):
return FileServeApp(filepath, self.cache_max_age)(environ, start_response)
return self.app(environ, start_response)
示例4: __init__
def __init__(self, key_lookup, component_cache_size, all_cache_size,
fallback_cache_size):
self.key_lookup = key_lookup
self.predicate_key = key_lookup.predicate_key
self.key_dict_to_predicate_key = key_lookup.key_dict_to_predicate_key
self.component_cache = LRUCache(component_cache_size)
self.all_cache = LRUCache(all_cache_size)
self.fallback_cache = LRUCache(fallback_cache_size)
示例5: __init__
def __init__(
self, namespace=BASE_NAMESPACE, base_url=None,
long_timeout=600):
self.namespace = namespace
self._client = TimeoutClient(
version="1.15", base_url=base_url, long_timeout=long_timeout)
self._image_cache = LRUCache(100)
示例6: __init__
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
示例7: __init__
def __init__(
self, namespace=BASE_NAMESPACE, base_url=None,
long_timeout=600):
self.namespace = namespace
self._client = dockerpy_client(
version="1.15", base_url=base_url,
long_timeout=timedelta(seconds=long_timeout),
)
self._image_cache = LRUCache(100)
示例8: ClusterCache
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()
示例9: __init__
def __init__(self, wiki, page_urls, registry_size=None):
self.wiki = wiki
self.page_urls = page_urls
self._cache = LRUCache(registry_size or self.PAGE_REGISTRY_SIZE)
self._pages_meta = None
self._queue = None
self._results = None
self._pool = None
self._done = False
示例10: __init__
def __init__(self, basedir, notify_on_commit):
self.basedir = basedir
self._notify_on_commit = notify_on_commit
self._changelog_cache = LRUCache(1000) # is thread safe
with self.get_sqlconn() as conn:
row = conn.execute("select max(serial) from changelog").fetchone()
serial = row[0]
if serial is None:
self.next_serial = 0
else:
self.next_serial = serial + 1
# perform some crash recovery
data = self.get_raw_changelog_entry(serial)
changes, rel_renames = loads(data)
check_pending_renames(str(self.basedir), rel_renames)
示例11: partly_distinct
def partly_distinct(iterable):
"""
Filters items from iterable and **tries to return only distincts**.
Keeps order.
:param Iterable iterable: Something iterable we have to filter.
>>> list(partly_distinct([1, 2, 3, 2, 1, 2, 3, 4]))
... [1, 2, 3, 4]
.. note::
Unlike :py:func:`distinct` it won't guarantee that all elements would
be distinct. But if you have rather small cardinality of the stream,
this would work.
.. note::
Current implementation guarantees support for 10000 distinct values.
If your cardinality is bigger, there might be some duplicates.
"""
cache = LRUCache(10000)
for item in iterable:
if not cache.get(item):
cache.put(item, True)
yield item
示例12: __init__
def __init__(self, name, server=None, create=False):
self.server = server or Server()
self.session = server.session
self.name = name
self.database = server.host + "/" + name
self.cache = LRUCache(100)
if create:
self.create()
else:
response = self.session.head(self.database)
if not response.ok:
if response.status_code == 404:
raise excepts.DBNotExists
raise Exception(response.status_code)
示例13: __init__
def __init__(self):
self.cli = False
self.args = {}
self.debug = False
self.debug2 = False
self.quiet = False
self.profile = False
self.components = OrderedDict()
self.start_item = OrderedDict()
self.start_nodes = []
self.config_files = []
self.included_files = []
self.props = {}
self.properties = self.props
self.var = {}
self.working_dir = os.getcwd()
self.library_path = os.path.dirname(os.path.realpath(__file__)) + "/../../library"
self.comp = Components(self)
self._functions = {"text": functions,
"xml": xmlfunctions,
"datetime": datetime,
"dt": datetime,
"re": re,
"sys": sys,
"urllib": urllib,
"random": random.Random()}
self._globals = self._functions
class Functions():
pass
self.f = Functions()
for k, v in self._functions.items():
setattr(self.f, k, v)
self._compiled = LRUCache(512) # TODO: Configurable
示例14: EDBag
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)
示例15: __init__
def __init__(self):
self.args = {}
self.debug = False
self.debug2 = False
self.quiet = False
self.config_files = []
self.start_node = None
self.start_message = {}
self.props = {}
self._globals = {"text": text, "cubetl": cubetl}
self._compiled = LRUCache(512) # TODO: Configurable
self.comp = Components(self)