Refactor.

Author: efkon-tkem

src/cachetools/__init__.py

@@ -201,9 +201,18 @@ def __getitem__(self, key, cache_getitem=Cache.__getitem__):
 
     def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
         cache_setitem(self, key, value)
-        self.__touch(key)
+        if key in self.__nodes:
+            self.__touch(key)
+        else:
+            head = self.__head
+            node = head.next
+            if not node:
+                node = head.next = LFUCache._Node(freq=1, next=None, prev=head)
+            node.items.add(key)
+            self.__nodes[key] = node
 
     def __delitem__(self, key, cache_delitem=Cache.__delitem__):
+        # FIXME: delete empty nodes?
         cache_delitem(self, key)
         node = self.__nodes.pop(key)
         node.items.remove(key)
@@ -213,33 +222,24 @@ def popitem(self):
         curr = self.__head.next
         while curr:
             if curr.items:
-                key = curr.items.pop()  # we remove an arbitrary element
-                del self.__nodes[key]
+                key = next(iter(curr.items))  # remove an arbitrary element
                 return (key, self.pop(key))
             curr = curr.next
         raise KeyError("%s is empty" % type(self).__name__) from None
 
     def __touch(self, key):
         """Increase use count"""
         node = self.__nodes.get(key, None)
-        if node is None:
-            head = self.__head
-            node = head.next
-            if not node:
-                node = head.next = LFUCache._Node(freq=1, next=None, prev=head)
-            node.items.add(key)
-            self.__nodes[key] = node
-        else:
-            # FIXME: remove empty nodes, otherwise this may grow without bounds?
-            # FIXME: LFUDecoratorTest::test_decorator_needs_rlock fails here?
-            assert key in node.items
-            node.items.remove(key)
-            nf = node.freq + 1
-            nn = node.next
-            if not nn or nn.freq != nf:
-                nn = node.next = LFUCache._Node(freq=nf, next=node.next, prev=node)
-            nn.items.add(key)
-            self.__nodes[key] = nn
+        # FIXME: remove empty nodes, otherwise this may grow without bounds?
+        # FIXME: LFUDecoratorTest::test_decorator_needs_rlock fails here
+        assert key in node.items
+        node.items.remove(key)
+        nf = node.freq + 1
+        nn = node.next
+        if not nn or nn.freq != nf:
+            nn = node.next = LFUCache._Node(freq=nf, next=node.next, prev=node)
+        nn.items.add(key)
+        self.__nodes[key] = nn
 
 
 class LRUCache(Cache):