first commit

Author: timurridjanovic

.gitignore

@@ -0,0 +1 @@
+*.pyc

README.md

@@ -0,0 +1,12 @@
+#LRU Cache
+
+**Description**:
+LRU Cache implementation with min heap instead of ordereddict.
+This was mainly an exercise in implementing a min heap, which is often used in priority queues.
+
+**Run tests**:
+To run the tests, you need to have nose installed. If you're on a UNIX-like system, you can run `easy_install nose`, `pip install nose` (you'll probably need to run these commands as root or using sudo).
+
+Once nose is installed, you can simply run `nosetests` in the root directory of the program.
+
+

lru_cache.py

@@ -0,0 +1,166 @@
+#LRU CACHE USING MIN HEAP INSTEAD OF ORDEREDDICT
+
+import time
+
+
+class MinHeap(object):
+    def __init__(self, l=[]):
+        self._heap = []
+        if len(l) > 0:
+            for e in l:
+                self.add(e[0], e[1])
+
+    def _parent(self, i):
+        return (i-1)/2
+
+    def _left_child(self, i):
+        return 2*i + 1
+
+    def _right_child(self, i):
+        return 2*i + 2
+
+    def _is_leaf(self, i):
+        return self._left_child(i) >= len(self._heap) and self._right_child(i) >= len(self._heap)
+
+    def _one_child(self, i):
+        return self._left_child(i) < len(self._heap) and self._right_child(i) >= len(self._heap)
+
+    def _down_heapify(self, i):
+        if self._is_leaf(i):
+            return self._heap
+
+        if self._one_child(i):
+            if self._heap[self._left_child(i)][1] < self._heap[i][1]:
+                self._heap[self._left_child(i)], self._heap[i] = self._heap[i], self._heap[self._left_child(i)]
+            return self._heap
+
+        if min(self._heap[self._left_child(i)][1], self._heap[self._right_child(i)][1]) >= self._heap[i][1]:
+            return self._heap
+
+        if self._heap[self._left_child(i)][1] < self._heap[self._right_child(i)][1]:
+            self._heap[self._left_child(i)], self._heap[i] = self._heap[i], self._heap[self._left_child(i)]
+            self._down_heapify(self._left_child(i))
+            return self._heap
+
+        self._heap[self._right_child(i)], self._heap[i] = self._heap[i], self._heap[self._right_child(i)]
+        self._down_heapify(self._right_child(i))
+        return self._heap
+
+    def _up_heapify(self, i):
+        if self._parent(i) >= 0:
+            if self._heap[self._parent(i)][1] > self._heap[i][1]:
+                self._heap[self._parent(i)], self._heap[i] = self._heap[i], self._heap[self._parent(i)]
+                self._up_heapify(self._parent(i))
+                return self._heap
+        return self._heap
+
+    def validate_heap(self):
+        for i, e in enumerate(self._heap):
+            if self._parent(i) >= 0:
+                if self._heap[self._parent(i)][1] > self._heap[i][1]:
+                    print self._heap[self._parent(i)], self._heap[i]
+                    return False
+        return True
+
+    def add(self, key, value):
+        self._heap.append((key, value))
+        self._up_heapify(len(self._heap) - 1)
+
+    def pop(self):
+        min_value = self._heap[0]
+        self._heap[0] = self._heap.pop()
+        self._down_heapify(0)
+        return min_value
+
+    def update(self, key, value):
+        for i, e in enumerate(self._heap):
+            if e[0] == key:
+                self._heap[i] = (key, value)
+                if value > e[1]:
+                    self._down_heapify(i)
+                else:
+                    self._up_heapify(i)
+                return self._heap
+        return self._heap
+
+    def delete(self, key):
+        for i, e in enumerate(self._heap):
+            if e[0] == key:
+                last_element = self._heap.pop()
+                self._heap[i] = last_element
+                self._down_heapify(i)
+                return self._heap
+        return self._heap
+
+
+class LRUCache(object):
+    def __init__(self, capacity):
+        self._cache_dict = {}
+        self._cache_heap = MinHeap()
+        self._capacity = capacity
+
+    def _is_in_cache(self, key):
+        if self._cache_dict.get(key):
+            return True
+        return False
+
+    def _is_over_capacity(self):
+        if len(self._cache_dict) >= self._capacity:
+            return True
+        return False
+
+    def set(self, key, value):
+        new_time = time.time()
+
+        if self._is_in_cache(key):
+            self._cache_heap.update(key, new_time)
+            self._cache_dict[key] = (value, new_time)
+            return self._cache_dict
+
+        if self._is_over_capacity():
+            min_value = self._cache_heap.pop()[0]
+            del self._cache_dict[min_value]
+
+        self._cache_heap.add(key, new_time)
+        self._cache_dict[key] = (value, new_time)
+        return self._cache_dict
+
+    def get(self, key):
+        if not self._is_in_cache(key): 
+            raise KeyError("this key is not in the cache")
+        
+        new_time = time.time()
+        self._cache_heap.update(key, new_time)
+        value = self._cache_dict[key][0]
+        self._cache_dict[key] = (value, new_time)
+        return value
+
+    def get_lru_el(self):
+        key = self._cache_heap._heap[0][0]
+        return self._cache_dict[key]
+
+    def get_dict(self):
+        return self._cache_dict
+
+
+lru_cache = LRUCache(3)
+
+lru_cache.set("user1", "teme")
+lru_cache.set("user2", "oge")
+lru_cache.set("user3", "dzenan")
+lru_cache.set("user4", "francis")
+lru_cache.set("user5", "baba")
+
+lru_cache.get("user3")
+lru_cache.get("user4")
+
+lru_cache.set("user2", "oge")
+lru_cache.set("user6", "tommy")
+
+print lru_cache.get_dict()
+print lru_cache.get_lru_el()
+
+        
+            
+
+

tests/__init__.py

@@ -0,0 +1,37 @@
+import unittest
+from nose.tools import raises
+
+from lru_cache import LRUCache
+
+class LRUCacheScaleTests(unittest.TestCase):
+    def setUp(self):
+        self.capacity = 500000
+        self.lru_cache = LRUCache(self.capacity)
+        
+        for i in xrange(1, self.capacity + 2):
+            self.lru_cache.set('user' + str(i), 'user_number_' + str(i))
+
+    def tearDown(self):
+        self.lru_cache = None
+
+    @raises(KeyError)
+    def test_set_and_get(self):
+        """
+        lru element should be user2 and user1 sould be removed.
+        """
+
+        self.assertEqual(self.lru_cache.get_lru_el(), self.lru_cache._cache_dict['user2'])
+        self.lru_cache.get('user1')
+
+    def test_update(self):
+        """
+        test update
+        """
+
+        self.lru_cache.set('user' + str(self.capacity/2), 'ANON_USER')
+        self.assertTrue(self.lru_cache.get('user' + str(self.capacity/2)) == 'ANON_USER')
+
+        self.lru_cache.set('user2', 'USER2')
+        self.assertEqual(self.lru_cache.get_lru_el(), self.lru_cache._cache_dict['user3'])
+
+

tests/lru_cache_scale_tests.py

@@ -0,0 +1,62 @@
+import unittest
+from nose.tools import raises
+
+from lru_cache import LRUCache
+
+class LRUCacheTests(unittest.TestCase):
+    def setUp(self):
+        self.lru_cache = LRUCache(3)
+        self.lru_cache.set('user1', 'timur')
+        self.lru_cache.set('user2', 'ogden')
+        self.lru_cache.set('user3', 'francis')
+        self.lru_cache.set('user4', 'amra')
+
+    def tearDown(self):
+        self.lru_cache = None
+
+    @raises(KeyError)
+    def test_key_error(self):
+        """
+        First element should be removed from cache
+        """
+        self.lru_cache.get('user1')
+
+
+    def test_get(self):
+        """
+        Checks to see if 3 most recent elements are in the cache
+        """
+        self.assertTrue(self.lru_cache.get('user2') == 'ogden')
+        self.assertTrue(self.lru_cache.get('user3') == 'francis')
+        self.assertTrue(self.lru_cache.get('user4') == 'amra')
+
+    @raises(KeyError)
+    def test_lru_get_and_set(self):
+        """
+        Performs a few get and set operations: user3 should be the least recently used element and should raise a key error. 
+        user2, user 4 and user5 should still be in the cache
+        """
+        self.lru_cache.get('user2')
+        self.lru_cache.set('user5', 'tom')
+        
+        self.assertTrue(self.lru_cache.get('user2') == 'ogden')
+        self.assertTrue(self.lru_cache.get('user4') == 'amra')
+        self.assertTrue(self.lru_cache.get('user5') == 'tom')
+
+        self.lru_cache.get('user3')
+
+    @raises(KeyError)
+    def test_update(self):
+        """
+        Updates user2 before adding new element. user4 should be the lru element and user3 should be removed from cache.
+        """
+        self.lru_cache.set('user2', 'Ogden')
+        self.lru_cache.set('user5', 'tom')
+
+        self.assertTrue(self.lru_cache.get('user2') == 'Ogden')
+        self.assertFalse(self.lru_cache.get('user2') == 'ogden')
+
+        self.assertTrue(self.lru_cache.get_lru_el() == self.lru_cache._cache_dict['user4'])
+        self.lru_cache.get('user3')
+
+