make requested changes

Author: Jakeway

cache_helper/decorators.py

@@ -24,7 +24,8 @@ def _cached(func):
 
         @wraps(func)
         def wrapper(*args, **kwargs):
-            cache_key = get_cache_key(*args, **kwargs)
+            function_cache_key = utils.get_function_cache_key(func_type, func_name, args, kwargs)
+            cache_key = utils.get_hashed_cache_key(function_cache_key)
 
             try:
                 value = cache.get(cache_key)
@@ -43,14 +44,5 @@ def wrapper(*args, **kwargs):
 
             return value
 
-        def get_cache_key(*args, **kwargs):
-            """
-            Gets the cache key that would be used if the given args and kwargs were supplied to decorated
-            function. For example, calling foo.get_cache_key('hello', 5) would not call foo - it would just
-            return the cache key that would be used if you were to call foo with the same args/kwargs.
-            """
-            function_cache_key = utils.get_function_cache_key(func_name, func_type, args, kwargs)
-            return utils.get_final_cache_key(function_cache_key)
-
         return wrapper
     return _cached

cache_helper/utils.py

@@ -6,7 +6,7 @@
 from cache_helper.interfaces import CacheHelperCacheable
 
 
-def get_function_cache_key(func_name, func_type, func_args, func_kwargs):
+def get_function_cache_key(func_type, func_name, func_args, func_kwargs):
     if func_type in ['method', 'function']:
         args_string = _sanitize_args(*func_args, **func_kwargs)
     elif func_type == 'class_method':
@@ -18,12 +18,12 @@ def get_function_cache_key(func_name, func_type, func_args, func_kwargs):
     return key
 
 
-def get_final_cache_key(key):
+def get_hashed_cache_key(key):
     """
     Given the intermediate key produced by a function call along with its args + kwargs,
     performs a sha256 hash on the utf-8 encoded version of the key, and returns the result
     """
-    key_hash = sha256(key.encode('utf-8')).hexdigest()
+    key_hash = sha256(key.encode('utf-8', errors='ignore')).hexdigest()
     return key_hash
 
 
@@ -42,15 +42,6 @@ def get_function_type(func):
     """
     Gets the type of the given function
     """
-    if inspect.ismethod(func):
-        # If the self attribute of the function is a class, it must be a class method
-        # Otherwise, it will be an instance method of some class, so just a regular method
-        if inspect.isclass(func.__self__):
-            return 'class_method'
-        else:
-            return 'method'
-
-    # Covers case when a method is decorated
     if 'self' in inspect.getargspec(func).args:
         return 'method'
     if 'cls' in inspect.getargspec(func).args:

test_project/tests.py

@@ -8,7 +8,7 @@
 from cache_helper import settings
 from cache_helper.decorators import cached
 from cache_helper.interfaces import CacheHelperCacheable
-from cache_helper.utils import get_function_type, get_final_cache_key, get_function_cache_key
+from cache_helper.utils import get_function_type, get_hashed_cache_key, get_function_cache_key
 from cache_helper.exceptions import CacheKeyCreationError, CacheHelperFunctionError
 
 
@@ -36,7 +36,6 @@ def fun_math(self, a, b):
     def take_then_give_back(self, a):
         return a
 
-    @cached(60*60)
     def instance_method(self):
         return self.name
 
@@ -142,7 +141,7 @@ def assertExpectedKeyInCache(self, key):
         """
         Tests given key is in cache, making sure to get the hashed version of key first
         """
-        finalized_key = get_final_cache_key(key)
+        finalized_key = get_hashed_cache_key(key)
         self.assertTrue(finalized_key in cache)
 
 
@@ -202,11 +201,11 @@ def tearDown(self):
 
     def test_unusual_character_key_creation(self):
         return_string('āęìøü')
-        expected_key_unusual_chars = get_function_cache_key('tests.return_string', 'function', ('āęìøü',), {})
+        expected_key_unusual_chars = get_function_cache_key('function', 'tests.return_string', ('āęìøü',), {})
         self.assertExpectedKeyInCache(expected_key_unusual_chars)
 
         return_string('aeiou')
-        expected_key = get_function_cache_key('tests.return_string', 'function', ('aeiou',), {})
+        expected_key = get_function_cache_key('function', 'tests.return_string', ('aeiou',), {})
         self.assertExpectedKeyInCache(expected_key)
 
         self.assertNotEqual(expected_key_unusual_chars, expected_key)
@@ -216,13 +215,13 @@ def test_same_method_name_different_class(self):
         Two different classes with the same method name should have different cache keys
         """
         self.apple.take_then_give_back(self.cherry)
-        apple_take_give_back_cherry_key = get_function_cache_key(
-            'tests.Fruit.take_then_give_back', 'method', (self.apple, self.cherry), {})
+        apple_take_give_back_cherry_key = get_function_cache_key('method', 'tests.Fruit.take_then_give_back',
+            (self.apple, self.cherry), {})
         self.assertExpectedKeyInCache(apple_take_give_back_cherry_key)
 
         self.celery.take_then_give_back(self.cherry)
-        celery_take_give_back_cherry_key = get_function_cache_key(
-            'tests.Vegetable.take_then_give_back', 'method', (self.celery, self.cherry), {})
+        celery_take_give_back_cherry_key = get_function_cache_key('method', 'tests.Vegetable.take_then_give_back',
+            (self.celery, self.cherry), {})
         self.assertExpectedKeyInCache(celery_take_give_back_cherry_key)
 
         self.assertNotEqual(apple_take_give_back_cherry_key, celery_take_give_back_cherry_key)
@@ -232,13 +231,13 @@ def test_same_class_method_name_different_class(self):
         Two different classes with the same class method name should have different cache keys
         """
         self.apple.add_sweet_letter(self.cherry)
-        apple_add_sweet_cherry_key = get_function_cache_key(
-            'tests.Fruit.add_sweet_letter', 'class_method', (self.apple, self.cherry), {})
+        apple_add_sweet_cherry_key = get_function_cache_key('class_method', 'tests.Fruit.add_sweet_letter',
+            (self.apple, self.cherry), {})
         self.assertExpectedKeyInCache(apple_add_sweet_cherry_key)
 
         self.celery.add_sweet_letter(self.cherry)
-        celery_add_sweet_cherry_key = get_function_cache_key(
-            'tests.Vegetable.add_sweet_letter', 'class_method', (self.celery, self.cherry), {})
+        celery_add_sweet_cherry_key = get_function_cache_key('class_method', 'tests.Vegetable.add_sweet_letter',
+            (self.celery, self.cherry), {})
         self.assertExpectedKeyInCache(celery_add_sweet_cherry_key)
 
         self.assertNotEqual(apple_add_sweet_cherry_key, celery_add_sweet_cherry_key)
@@ -248,11 +247,12 @@ def test_same_static_method_name_different_class_instance_reference(self):
         Two different classes with the same static method name should have different cache keys
         """
         self.apple.static_method(self.cherry)
-        apple_static_method_key = get_function_cache_key('tests.Fruit.static_method', 'function', (self.cherry,), {})
+        apple_static_method_key = get_function_cache_key('function', 'tests.Fruit.static_method', (self.cherry,), {})
         self.assertExpectedKeyInCache(apple_static_method_key)
 
         self.celery.static_method(self.cherry)
-        celery_static_method_key = get_function_cache_key('tests.Vegetable.static_method', 'function', (self.cherry,), {})
+        celery_static_method_key = get_function_cache_key('function', 'tests.Vegetable.static_method', (self.cherry,),
+            {})
         self.assertExpectedKeyInCache(celery_static_method_key)
 
         self.assertNotEqual(apple_static_method_key, celery_static_method_key)
@@ -262,25 +262,24 @@ def test_same_static_method_name_different_class_class_reference(self):
         Two different classes with the same static method name should have different cache keys
         """
         Fruit.static_method(self.cherry)
-        fruit_static_method_key = get_function_cache_key('tests.Fruit.static_method', 'function', (self.cherry,), {})
+        fruit_static_method_key = get_function_cache_key('function', 'tests.Fruit.static_method', (self.cherry,), {})
         self.assertExpectedKeyInCache(fruit_static_method_key)
 
         Vegetable.static_method(self.cherry)
-        vegetable_static_method_key = get_function_cache_key(
-            'tests.Vegetable.static_method', 'function', (self.cherry,), {})
+        vegetable_static_method_key = get_function_cache_key('function', 'tests.Vegetable.static_method',
+            (self.cherry,), {})
         self.assertExpectedKeyInCache(vegetable_static_method_key)
 
         self.assertNotEqual(fruit_static_method_key, vegetable_static_method_key)
 
     def test_same_function_name_from_module_level(self):
         """Two different functions with same name should have different cache keys"""
         Vegetable.foo(1, 2)
-        vegetable_static_method_key = get_function_cache_key(
-            'tests.Vegetable.foo', 'function', (1, 2), {})
+        vegetable_static_method_key = get_function_cache_key('function', 'tests.Vegetable.foo', (1, 2), {})
         self.assertExpectedKeyInCache(vegetable_static_method_key)
 
         foo(1, 2)
-        module_function_key = get_function_cache_key('tests.foo', 'function', (1, 2), {})
+        module_function_key = get_function_cache_key('function', 'tests.foo', (1, 2), {})
         self.assertExpectedKeyInCache(module_function_key)
 
         self.assertNotEqual(vegetable_static_method_key, module_function_key)