From eb33970274b6b2558b8911c6889e79571f21e555 Mon Sep 17 00:00:00 2001 From: Luke Campagnola Date: Wed, 5 Mar 2014 09:11:53 -0500 Subject: [PATCH] Correct to unix line endings --- pyqtgraph/lru_cache.py | 232 ++++++++++++++++++++--------------------- 1 file changed, 116 insertions(+), 116 deletions(-) diff --git a/pyqtgraph/lru_cache.py b/pyqtgraph/lru_cache.py index 862e956a..2ce2e372 100644 --- a/pyqtgraph/lru_cache.py +++ b/pyqtgraph/lru_cache.py @@ -1,116 +1,116 @@ -import operator -import sys -import itertools - - -_IS_PY3 = sys.version_info[0] == 3 - -class LRUCache(object): - ''' - This LRU cache should be reasonable for short collections (until around 100 items), as it does a - sort on the items if the collection would become too big (so, it is very fast for getting and - setting but when its size would become higher than the max size it does one sort based on the - internal time to decide which items should be removed -- which should be Ok if the resize_to - isn't too close to the max_size so that it becomes an operation that doesn't happen all the - time). - ''' - - def __init__(self, max_size=100, resize_to=70): - ''' - :param int max_size: - This is the maximum size of the cache. When some item is added and the cache would become - bigger than this, it's resized to the value passed on resize_to. - - :param int resize_to: - When a resize operation happens, this is the size of the final cache. - ''' - assert resize_to < max_size - self.max_size = max_size - self.resize_to = resize_to - self._counter = 0 - self._dict = {} - if _IS_PY3: - self._next_time = itertools.count(0).__next__ - else: - self._next_time = itertools.count(0).next - - def __getitem__(self, key): - item = self._dict[key] - item[2] = self._next_time() - return item[1] - - def __len__(self): - return len(self._dict) - - def __setitem__(self, key, value): - item = self._dict.get(key) - if item is None: - if len(self._dict) + 1 > self.max_size: - self._resize_to() - - item = [key, value, self._next_time()] - self._dict[key] = item - else: - item[1] = value - item[2] = self._next_time() - - def __delitem__(self, key): - del self._dict[key] - - def get(self, key, default=None): - try: - return self[key] - except KeyError: - return default - - def clear(self): - self._dict.clear() - - if _IS_PY3: - def values(self): - return [i[1] for i in self._dict.values()] - - def keys(self): - return [x[0] for x in self._dict.values()] - - def _resize_to(self): - ordered = sorted(self._dict.values(), key=operator.itemgetter(2))[:self.resize_to] - for i in ordered: - del self._dict[i[0]] - - def iteritems(self, access_time=False): - ''' - :param bool access_time: - If True sorts the returned items by the internal access time. - ''' - if access_time: - for x in sorted(self._dict.values(), key=operator.itemgetter(2)): - yield x[0], x[1] - else: - for x in self._dict.items(): - yield x[0], x[1] - - else: - def values(self): - return [i[1] for i in self._dict.itervalues()] - - def keys(self): - return [x[0] for x in self._dict.itervalues()] - - - def _resize_to(self): - ordered = sorted(self._dict.itervalues(), key=operator.itemgetter(2))[:self.resize_to] - for i in ordered: - del self._dict[i[0]] - - def iteritems(self, access_time=False): - ''' - :param bool access_time: - If True sorts the returned items by the internal access time. - ''' - if access_time: - for x in sorted(self._dict.itervalues(), key=operator.itemgetter(2)): - yield x[0], x[1] - else: - for x in self._dict.iteritems(): - yield x[0], x[1] +import operator +import sys +import itertools + + +_IS_PY3 = sys.version_info[0] == 3 + +class LRUCache(object): + ''' + This LRU cache should be reasonable for short collections (until around 100 items), as it does a + sort on the items if the collection would become too big (so, it is very fast for getting and + setting but when its size would become higher than the max size it does one sort based on the + internal time to decide which items should be removed -- which should be Ok if the resize_to + isn't too close to the max_size so that it becomes an operation that doesn't happen all the + time). + ''' + + def __init__(self, max_size=100, resize_to=70): + ''' + :param int max_size: + This is the maximum size of the cache. When some item is added and the cache would become + bigger than this, it's resized to the value passed on resize_to. + + :param int resize_to: + When a resize operation happens, this is the size of the final cache. + ''' + assert resize_to < max_size + self.max_size = max_size + self.resize_to = resize_to + self._counter = 0 + self._dict = {} + if _IS_PY3: + self._next_time = itertools.count(0).__next__ + else: + self._next_time = itertools.count(0).next + + def __getitem__(self, key): + item = self._dict[key] + item[2] = self._next_time() + return item[1] + + def __len__(self): + return len(self._dict) + + def __setitem__(self, key, value): + item = self._dict.get(key) + if item is None: + if len(self._dict) + 1 > self.max_size: + self._resize_to() + + item = [key, value, self._next_time()] + self._dict[key] = item + else: + item[1] = value + item[2] = self._next_time() + + def __delitem__(self, key): + del self._dict[key] + + def get(self, key, default=None): + try: + return self[key] + except KeyError: + return default + + def clear(self): + self._dict.clear() + + if _IS_PY3: + def values(self): + return [i[1] for i in self._dict.values()] + + def keys(self): + return [x[0] for x in self._dict.values()] + + def _resize_to(self): + ordered = sorted(self._dict.values(), key=operator.itemgetter(2))[:self.resize_to] + for i in ordered: + del self._dict[i[0]] + + def iteritems(self, access_time=False): + ''' + :param bool access_time: + If True sorts the returned items by the internal access time. + ''' + if access_time: + for x in sorted(self._dict.values(), key=operator.itemgetter(2)): + yield x[0], x[1] + else: + for x in self._dict.items(): + yield x[0], x[1] + + else: + def values(self): + return [i[1] for i in self._dict.itervalues()] + + def keys(self): + return [x[0] for x in self._dict.itervalues()] + + + def _resize_to(self): + ordered = sorted(self._dict.itervalues(), key=operator.itemgetter(2))[:self.resize_to] + for i in ordered: + del self._dict[i[0]] + + def iteritems(self, access_time=False): + ''' + :param bool access_time: + If True sorts the returned items by the internal access time. + ''' + if access_time: + for x in sorted(self._dict.itervalues(), key=operator.itemgetter(2)): + yield x[0], x[1] + else: + for x in self._dict.iteritems(): + yield x[0], x[1]