ASCEE/pyqtgraph
5
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Style corrections

Browse Source
This commit is contained in:
Luke Campagnola 2014-03-05 09:12:23 -05:00
parent eb33970274
commit dad001b9d4
1 changed files with 35 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
pyqtgraph/lru_cache.py
View File

@ -10,33 +10,35 @@ class LRUCache(object):
This LRU cache should be reasonable for short collections (until around 100 items), as it does a 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 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 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 internal time to decide which items should be removed -- which should be Ok if the resizeTo
isn't too close to the max_size so that it becomes an operation that doesn't happen all the isn't too close to the maxSize so that it becomes an operation that doesn't happen all the
time). time).
''' '''
def __init__(self, max_size=100, resize_to=70): def __init__(self, maxSize=100, resizeTo=70):
''' '''
:param int max_size: ============== =========================================================
This is the maximum size of the cache. When some item is added and the cache would become **Arguments:**
bigger than this, it's resized to the value passed on resize_to. maxSize (int) This is the maximum size of the cache. When some
item is added and the cache would become bigger than
:param int resize_to: this, it's resized to the value passed on resizeTo.
When a resize operation happens, this is the size of the final cache. resizeTo (int) When a resize operation happens, this is the size
of the final cache.
============== =========================================================
''' '''
assert resize_to < max_size assert resizeTo < maxSize
self.max_size = max_size self.maxSize = maxSize
self.resize_to = resize_to self.resizeTo = resizeTo
self._counter = 0 self._counter = 0
self._dict = {} self._dict = {}
if _IS_PY3: if _IS_PY3:
self._next_time = itertools.count(0).__next__ self._nextTime = itertools.count(0).__next__
else: else:
self._next_time = itertools.count(0).next self._nextTime = itertools.count(0).next
def __getitem__(self, key): def __getitem__(self, key):
item = self._dict[key] item = self._dict[key]
item[2] = self._next_time() item[2] = self._nextTime()
return item[1] return item[1]
def __len__(self): def __len__(self):
@ -45,14 +47,14 @@ class LRUCache(object):
def __setitem__(self, key, value): def __setitem__(self, key, value):
item = self._dict.get(key) item = self._dict.get(key)
if item is None: if item is None:
if len(self._dict) + 1 > self.max_size: if len(self._dict) + 1 > self.maxSize:
self._resize_to() self._resizeTo()
item = [key, value, self._next_time()] item = [key, value, self._nextTime()]
self._dict[key] = item self._dict[key] = item
else: else:
item[1] = value item[1] = value
item[2] = self._next_time() item[2] = self._nextTime()
def __delitem__(self, key): def __delitem__(self, key):
del self._dict[key] del self._dict[key]
@ -73,17 +75,17 @@ class LRUCache(object):
def keys(self): def keys(self):
return [x[0] for x in self._dict.values()] return [x[0] for x in self._dict.values()]
def _resize_to(self): def _resizeTo(self):
ordered = sorted(self._dict.values(), key=operator.itemgetter(2))[:self.resize_to] ordered = sorted(self._dict.values(), key=operator.itemgetter(2))[:self.resizeTo]
for i in ordered: for i in ordered:
del self._dict[i[0]] del self._dict[i[0]]
def iteritems(self, access_time=False): def iteritems(self, accessTime=False):
''' '''
:param bool access_time: :param bool accessTime:
If True sorts the returned items by the internal access time. If True sorts the returned items by the internal access time.
''' '''
if access_time: if accessTime:
for x in sorted(self._dict.values(), key=operator.itemgetter(2)): for x in sorted(self._dict.values(), key=operator.itemgetter(2)):
yield x[0], x[1] yield x[0], x[1]
else: else:
@ -98,17 +100,20 @@ class LRUCache(object):
return [x[0] for x in self._dict.itervalues()] return [x[0] for x in self._dict.itervalues()]
def _resize_to(self): def _resizeTo(self):
ordered = sorted(self._dict.itervalues(), key=operator.itemgetter(2))[:self.resize_to] ordered = sorted(self._dict.itervalues(), key=operator.itemgetter(2))[:self.resizeTo]
for i in ordered: for i in ordered:
del self._dict[i[0]] del self._dict[i[0]]
def iteritems(self, access_time=False): def iteritems(self, accessTime=False):
''' '''
:param bool access_time: ============= ======================================================
If True sorts the returned items by the internal access time. **Arguments**
accessTime (bool) If True sorts the returned items by the
internal access time.
============= ======================================================
''' '''
if access_time: if accessTime:
for x in sorted(self._dict.itervalues(), key=operator.itemgetter(2)): for x in sorted(self._dict.itervalues(), key=operator.itemgetter(2)):
yield x[0], x[1] yield x[0], x[1]
else: else: