Changed serializer functions

aiocache/backends/memory.py

@@ -15,59 +15,59 @@ def __init__(self, namespace=None, serializer=None):
         self.serializer = serializer or self.get_serializer()
         self.namespace = namespace or ""
 
-    async def get(self, key, default=None, deserialize_fn=None):
+    async def get(self, key, default=None, loads_fn=None):
         """
         Get a value from the cache. Returns default if not found.
 
         :param key: str
         :param default: obj to return when key is not found
-        :param deserializer_fn: callable alternative to use as deserialize function
-        :returns: obj deserialized
+        :param loads_fn: callable alternative to use as loads function
+        :returns: obj loadsd
         """
 
-        deserialize = deserialize_fn or self.serializer.deserialize
-        return deserialize(SimpleMemoryCache._cache.get(self._build_key(key), default))
+        loads = loads_fn or self.serializer.loads
+        return loads(SimpleMemoryCache._cache.get(self._build_key(key), default))
 
-    async def multi_get(self, keys, deserialize_fn=None):
+    async def multi_get(self, keys, loads_fn=None):
         """
         Get a value from the cache. Returns default if not found.
 
         :param key: str
-        :param deserializer_fn: callable alternative to use as deserialize function
-        :returns: obj deserialized
+        :param loads_fn: callable alternative to use as loads function
+        :returns: obj loadsd
         """
-        deserialize = deserialize_fn or self.serializer.deserialize
-        return [deserialize(SimpleMemoryCache._cache.get(self._build_key(key))) for key in keys]
+        loads = loads_fn or self.serializer.loads
+        return [loads(SimpleMemoryCache._cache.get(self._build_key(key))) for key in keys]
 
-    async def set(self, key, value, ttl=None, serialize_fn=None):
+    async def set(self, key, value, ttl=None, dumps_fn=None):
         """
         Stores the value in the given key with ttl if specified
 
         :param key: str
         :param value: obj
         :param ttl: int the expiration time in seconds
-        :param serialize_fn: callable alternative to use as serialize function
+        :param dumps_fn: callable alternative to use as dumps function
         :returns:
         """
-        serialize = serialize_fn or self.serializer.serialize
-        SimpleMemoryCache._cache[self._build_key(key)] = serialize(value)
+        dumps = dumps_fn or self.serializer.dumps
+        SimpleMemoryCache._cache[self._build_key(key)] = dumps(value)
         if ttl:
             loop = asyncio.get_event_loop()
             loop.call_later(ttl, self._delete, key)
         return True
 
-    async def multi_set(self, pairs, serialize_fn=None):
+    async def multi_set(self, pairs, dumps_fn=None):
         """
         Stores multiple values in the given keys.
 
         :param pairs: list of two element iterables. First is key and second is value
-        :param serialize_fn: callable alternative to use as serialize function
+        :param dumps_fn: callable alternative to use as dumps function
         :returns:
         """
-        serialize = serialize_fn or self.serializer.serialize
+        dumps = dumps_fn or self.serializer.dumps
 
         for key, value in pairs:
-            SimpleMemoryCache._cache[self._build_key(key)] = serialize(value)
+            SimpleMemoryCache._cache[self._build_key(key)] = dumps(value)
         return True
 
     async def delete(self, key):

aiocache/backends/redis.py

@@ -16,70 +16,70 @@ def __init__(self, endpoint=None, port=None, namespace=None, serializer=None, lo
         self._pool = None
         self._loop = loop or asyncio.get_event_loop()
 
-    async def get(self, key, default=None, deserialize_fn=None, encoding=None):
+    async def get(self, key, default=None, loads_fn=None, encoding=None):
         """
         Get a value from the cache. Returns default if not found.
 
         :param key: str
         :param default: obj to return when key is not found
-        :param deserializer_fn: callable alternative to use as deserialize function
+        :param loads_fn: callable alternative to use as loads function
         :param encoding: alternative encoding to use. Default is to use the self.serializer.encoding
         :returns: obj deserialized
         """
 
-        deserialize = deserialize_fn or self.serializer.deserialize
+        loads = loads_fn or self.serializer.loads
         encoding = encoding or getattr(self.serializer, "encoding", 'utf-8')
 
         with await self._connect() as redis:
-            return deserialize(
+            return loads(
                 await redis.get(self._build_key(key), encoding=encoding)) or default
 
-    async def multi_get(self, keys, deserialize_fn=None, encoding=None):
+    async def multi_get(self, keys, loads_fn=None, encoding=None):
         """
         Get a value from the cache. Returns default if not found.
 
         :param key: str
-        :param deserializer_fn: callable alternative to use as deserialize function
+        :param loads_fn: callable alternative to use as loads function
         :param encoding: alternative encoding to use. Default is to use the self.serializer.encoding
         :returns: obj deserialized
         """
-        deserialize = deserialize_fn or self.serializer.deserialize
+        loads = loads_fn or self.serializer.loads
         encoding = encoding or getattr(self.serializer, "encoding", 'utf-8')
 
         with await self._connect() as redis:
             keys = [self._build_key(key) for key in keys]
-            return [deserialize(obj) for obj in (await redis.mget(*keys, encoding=encoding))]
+            return [loads(obj) for obj in (await redis.mget(*keys, encoding=encoding))]
 
-    async def set(self, key, value, ttl=None, serialize_fn=None):
+    async def set(self, key, value, ttl=None, dumps_fn=None):
         """
         Stores the value in the given key with ttl if specified
 
         :param key: str
         :param value: obj
         :param ttl: int the expiration time in seconds
-        :param serialize_fn: callable alternative to use as serialize function
+        :param dumps_fn: callable alternative to use as dumps function
         :returns:
         """
-        serialize = serialize_fn or self.serializer.serialize
+        dumps = dumps_fn or self.serializer.dumps
         ttl = ttl or 0
 
         with await self._connect() as redis:
-            return await redis.set(self._build_key(key), serialize(value), expire=ttl)
+            return await redis.set(self._build_key(key), dumps(value), expire=ttl)
 
-    async def multi_set(self, pairs, serialize_fn=None):
+    async def multi_set(self, pairs, dumps_fn=None):
         """
         Stores multiple values in the given keys.
 
         :param pairs: list of two element iterables. First is key and second is value
-        :param serialize_fn: callable alternative to use as serialize function
+        :param dumps: callable alternative to use as dumps function
         :returns:
         """
-        serialize = serialize_fn or self.serializer.serialize
+        dumps = dumps_fn or self.serializer.dumps
 
         with await self._connect() as redis:
             serialized_pairs = list(
                 chain.from_iterable(
-                    (self._build_key(key), serialize(value)) for key, value in pairs))
+                    (self._build_key(key), dumps(value)) for key, value in pairs))
             return await redis.mset(*serialized_pairs)
 
     async def delete(self, key):

aiocache/serializers.py

@@ -20,11 +20,11 @@
 class BaseSerializer(metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
-    def serialize(self, value):
+    def dumps(self, value):
         pass
 
     @abc.abstractmethod
-    def deserialize(self, value):
+    def loads(self, value):
         pass
 
 
@@ -37,10 +37,10 @@ class DefaultSerializer(BaseSerializer):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-    def serialize(self, value):
+    def dumps(self, value):
         return value
 
-    def deserialize(self, value):
+    def loads(self, value):
         return value
 
 
@@ -51,7 +51,7 @@ class PickleSerializer(BaseSerializer):
 
     encoding = None
 
-    def serialize(self, value):
+    def dumps(self, value):
         """
         Serialize the received value using ``pickle.dumps``.
 
@@ -60,7 +60,7 @@ def serialize(self, value):
         """
         return pickle.dumps(value)
 
-    def deserialize(self, value):
+    def loads(self, value):
         """
         Deserialize value using ``pickle.loads``.
 
@@ -77,7 +77,7 @@ class JsonSerializer(BaseSerializer):
     Transform data to json string with json.dumps and json.loads to retrieve it back.
     """
 
-    def serialize(self, value):
+    def dumps(self, value):
         """
         Serialize the received value using ``json.dumps``.
 
@@ -86,7 +86,7 @@ def serialize(self, value):
         """
         return json.dumps(value)
 
-    def deserialize(self, value):
+    def loads(self, value):
         """
         Deserialize value using ``json.loads``.
 

tests/test_redis.py

@@ -128,9 +128,9 @@ async def test_get_complex_type(self, redis_cache, obj, serializer):
 
     @pytest.mark.asyncio
     async def test_get_set_alt_serializer(self, redis_cache):
-        await redis_cache.set(KEY, "value", serialize_fn=TestSerializer().serialize)
+        await redis_cache.set(KEY, "value", dumps_fn=TestSerializer().serialize)
         assert await redis_cache.get(KEY) == "v4lu3"
-        assert await redis_cache.get(KEY, deserialize_fn=TestSerializer().deserialize) == "value"
+        assert await redis_cache.get(KEY, loads_fn=TestSerializer().deserialize) == "value"
 
     @pytest.mark.asyncio
     async def test_ttl(self, redis_cache):