Add Cache factory

README.rst

@@ -62,8 +62,8 @@ Using a cache is as simple as
 
     >>> import asyncio
     >>> loop = asyncio.get_event_loop()
-    >>> from aiocache import SimpleMemoryCache  # Here you can also use RedisCache and MemcachedCache
-    >>> cache = SimpleMemoryCache()
+    >>> from aiocache import Cache
+    >>> cache = Cache(Cache.MEMORY) # Here you can also use Cache.REDIS and Cache.MEMCACHED, default is Cache.MEMORY
     >>> loop.run_until_complete(cache.set('key', 'value'))
     True
     >>> loop.run_until_complete(cache.get('key'))
@@ -77,15 +77,15 @@ Or as a decorator
 
     from collections import namedtuple
 
-    from aiocache import cached, RedisCache
+    from aiocache import cached, Cache
     from aiocache.serializers import PickleSerializer
     # With this we can store python objects in backends like Redis!
 
     Result = namedtuple('Result', "content, status")
 
 
     @cached(
-        ttl=10, cache=RedisCache, key="key", serializer=PickleSerializer(), port=6379, namespace="main")
+        ttl=10, cache=Cache.REDIS, key="key", serializer=PickleSerializer(), port=6379, namespace="main")
     async def cached_call():
         print("Sleeping for three seconds zzzz.....")
         await asyncio.sleep(3)
@@ -97,21 +97,22 @@ Or as a decorator
         loop.run_until_complete(cached_call())
         loop.run_until_complete(cached_call())
         loop.run_until_complete(cached_call())
-        cache = RedisCache(endpoint="127.0.0.1", port=6379, namespace="main")
+        cache = Cache(Cache.REDIS, endpoint="127.0.0.1", port=6379, namespace="main")
         loop.run_until_complete(cache.delete("key"))
 
     if __name__ == "__main__":
         run()
 
+The recommended approach to instantiate a new cache is using the `Cache` constructor. However you can also instantiate directly using `aiocache.RedisCache`, `aiocache.SimpleMemoryCache` or `aiocache.MemcachedCache`.
+
 
 You can also setup cache aliases so its easy to reuse configurations
 
 .. code-block:: python
 
   import asyncio
 
-  from aiocache import caches, SimpleMemoryCache, RedisCache
-  from aiocache.serializers import StringSerializer, PickleSerializer
+  from aiocache import caches
 
   # You can use either classes or strings for referencing classes
   caches.set_config({

aiocache/__init__.py

@@ -1,8 +1,6 @@
 import logging
 
 from .backends.memory import SimpleMemoryCache
-from .factory import caches
-from .decorators import cached, cached_stampede, multi_cached
 from ._version import __version__
 
 
@@ -30,4 +28,16 @@
     del aiomcache
 
 
-__all__ = ("caches", "cached", "cached_stampede", "multi_cached", *__cache_types, "__version__")
+from .factory import caches, Cache  # noqa: E402
+from .decorators import cached, cached_stampede, multi_cached  # noqa: E402
+
+
+__all__ = (
+    "caches",
+    "Cache",
+    "cached",
+    "cached_stampede",
+    "multi_cached",
+    *__cache_types,
+    "__version__",
+)

aiocache/exceptions.py

@@ -0,0 +1,2 @@
+class InvalidCacheType(Exception):
+    pass

aiocache/factory.py

@@ -1,4 +1,12 @@
 from copy import deepcopy
+import logging
+
+
+from aiocache import SimpleMemoryCache, RedisCache, MemcachedCache
+from aiocache.exceptions import InvalidCacheType
+
+
+logger = logging.getLogger(__name__)
 
 
 def _class_from_string(class_path):
@@ -26,6 +34,35 @@ def _create_cache(cache, serializer=None, plugins=None, **kwargs):
     return instance
 
 
+class Cache:
+
+    MEMORY = "memory"
+    REDIS = "redis"
+    MEMCACHED = "memcached"
+
+    _PROTOCOL_MAPPING = {
+        "memory": SimpleMemoryCache,
+        "redis": RedisCache,
+        "memcached": MemcachedCache,
+    }
+
+    def __new__(cls, cache_type=MEMORY, **kwargs):
+        try:
+            cache_class = cls.get_protocol_class(cache_type)
+        except KeyError as e:
+            raise InvalidCacheType(
+                "Invalid cache type, you can only use {}".format(list(cls._PROTOCOL_MAPPING.keys()))
+            ) from e
+
+        instance = cache_class.__new__(cache_class, **kwargs)
+        instance.__init__(**kwargs)
+        return instance
+
+    @classmethod
+    def get_protocol_class(cls, protocol):
+        return cls._PROTOCOL_MAPPING[protocol]
+
+
 class CacheHandler:
 
     _config = {

aiocache/lock.py

@@ -44,10 +44,10 @@ class RedLock:
 
     Example usage::
 
-        from aiocache import RedisCache
+        from aiocache import Cache
         from aiocache.lock import RedLock
 
-        cache = RedisCache()
+        cache = Cache(Cache.REDIS)
         async with RedLock(cache, 'key', lease=1):  # Calls will wait here
             result = await cache.get('key')
             if result is not None:
@@ -112,7 +112,7 @@ class OptimisticLock:
 
     Example usage::
 
-        cache = RedisCache()
+        cache = Cache(Cache.REDIS)
 
         # The value stored in 'key' will be checked here
         async with OptimisticLock(cache, 'key') as lock:
@@ -123,7 +123,7 @@ class OptimisticLock:
     an :class:`aiocache.lock.OptimisticLockError` will be raised. A way to make
     the same call crash would be to change the value inside the lock like::
 
-        cache = RedisCache()
+        cache = Cache(Cache.REDIS)
 
         # The value stored in 'key' will be checked here
         async with OptimisticLock(cache, 'key') as lock:

aiocache/serializers.py

@@ -42,7 +42,7 @@ class NullSerializer(BaseSerializer):
     DISCLAIMER: Be careful with mutable types and memory storage. The following
     behavior is considered normal (same as ``functools.lru_cache``)::
 
-        cache = SimpleMemoryCache()
+        cache = Cache()
         my_list = [1]
         await cache.set("key", my_list)
         my_list.append(2)

docs/index.rst

@@ -25,8 +25,8 @@ Using a cache is as simple as
 
     >>> import asyncio
     >>> loop = asyncio.get_event_loop()
-    >>> from aiocache import SimpleMemoryCache
-    >>> cache = SimpleMemoryCache()
+    >>> from aiocache import Cache
+    >>> cache = Cache()
     >>> loop.run_until_complete(cache.set('key', 'value'))
     True
     >>> loop.run_until_complete(cache.get('key'))

docs/plugins.rst

@@ -5,9 +5,9 @@ Plugins
 
 Plugins can be used to enrich the behavior of the cache. By default all caches are configured without any plugin but can add new ones in the constructor or after initializing the cache class::
 
-    >>> from aiocache import SimpleMemoryCache
+    >>> from aiocache import Cache
     >>> from aiocache.plugins import TimingPlugin
-    cache = SimpleMemoryCache(plugins=[HitMissRatioPlugin()])
+    cache = Cache(plugins=[HitMissRatioPlugin()])
     cache.plugins += [TimingPlugin()]
 
 You can define your custom plugin by inheriting from `BasePlugin`_ and overriding the needed methods (the overrides NEED to be async). All commands have ``pre_<command_name>`` and ``post_<command_name>`` hooks.

examples/cached_decorator.py

@@ -9,7 +9,8 @@
 
 
 @cached(
-    ttl=10, cache=RedisCache, key="key", serializer=PickleSerializer(), port=6379, namespace="main")
+    ttl=10, cache=RedisCache, key="key", serializer=PickleSerializer(),
+    port=6379, namespace="main")
 async def cached_call():
     return Result("content", 200)
 

examples/frameworks/sanic_example.py

@@ -10,7 +10,7 @@
 from sanic import Sanic
 from sanic.response import json
 from sanic.log import log
-from aiocache import cached, SimpleMemoryCache
+from aiocache import cached, Cache
 from aiocache.serializers import JsonSerializer
 
 app = Sanic(__name__)
@@ -24,7 +24,7 @@ async def expensive_call():
 
 
 async def reuse_data():
-    cache = SimpleMemoryCache(serializer=JsonSerializer())  # Not ideal to define here
+    cache = Cache(serializer=JsonSerializer())  # Not ideal to define here
     data = await cache.get("my_custom_key")  # Note the key is defined in `cached` decorator
     return data
 

examples/marshmallow_serializer_class.py

@@ -4,7 +4,7 @@
 
 from marshmallow import fields, Schema, post_load
 
-from aiocache import SimpleMemoryCache
+from aiocache import Cache
 from aiocache.serializers import BaseSerializer
 
 
@@ -47,7 +47,7 @@ class Meta:
         strict = True
 
 
-cache = SimpleMemoryCache(serializer=MarshmallowSerializer(), namespace="main")
+cache = Cache(serializer=MarshmallowSerializer(), namespace="main")
 
 
 async def serializer():

examples/optimistic_lock.py

@@ -2,12 +2,12 @@
 import logging
 import random
 
-from aiocache import RedisCache
+from aiocache import Cache
 from aiocache.lock import OptimisticLock, OptimisticLockError
 
 
 logger = logging.getLogger(__name__)
-cache = RedisCache(endpoint='127.0.0.1', port=6379, namespace='main')
+cache = Cache(Cache.REDIS, endpoint='127.0.0.1', port=6379, namespace='main')
 
 
 async def expensive_function():

examples/plugins.py

@@ -2,7 +2,7 @@
 import random
 import logging
 
-from aiocache import SimpleMemoryCache
+from aiocache import Cache
 from aiocache.plugins import HitMissRatioPlugin, TimingPlugin, BasePlugin
 
 
@@ -18,7 +18,7 @@ async def post_set(self, *args, **kwargs):
         logger.info("I'm the post_set hook being called with %s %s" % (args, kwargs))
 
 
-cache = SimpleMemoryCache(
+cache = Cache(
     plugins=[HitMissRatioPlugin(), TimingPlugin(), MyCustomPlugin()],
     namespace="main")
 

examples/python_object.py

@@ -1,12 +1,12 @@
 import asyncio
 
 from collections import namedtuple
-from aiocache import RedisCache
+from aiocache import Cache
 from aiocache.serializers import PickleSerializer
 
 
 MyObject = namedtuple("MyObject", ["x", "y"])
-cache = RedisCache(serializer=PickleSerializer(), namespace="main")
+cache = Cache(Cache.REDIS, serializer=PickleSerializer(), namespace="main")
 
 
 async def complex_object():

examples/redlock.py

@@ -1,12 +1,12 @@
 import asyncio
 import logging
 
-from aiocache import RedisCache
+from aiocache import Cache
 from aiocache.lock import RedLock
 
 
 logger = logging.getLogger(__name__)
-cache = RedisCache(endpoint='127.0.0.1', port=6379, namespace='main')
+cache = Cache(Cache.REDIS, endpoint='127.0.0.1', port=6379, namespace='main')
 
 
 async def expensive_function():

examples/serializer_class.py

@@ -1,7 +1,7 @@
 import asyncio
 import zlib
 
-from aiocache import RedisCache
+from aiocache import Cache
 from aiocache.serializers import BaseSerializer
 
 
@@ -25,7 +25,7 @@ def loads(self, value):
         return decompressed
 
 
-cache = RedisCache(serializer=CompressionSerializer(), namespace="main")
+cache = Cache(Cache.REDIS, serializer=CompressionSerializer(), namespace="main")
 
 
 async def serializer():

examples/serializer_function.py

@@ -2,7 +2,7 @@
 import json
 
 from marshmallow import Schema, fields, post_load
-from aiocache import RedisCache
+from aiocache import Cache
 
 
 class MyType:
@@ -28,7 +28,7 @@ def loads(value):
     return MyTypeSchema().loads(value).data
 
 
-cache = RedisCache(namespace="main")
+cache = Cache(Cache.REDIS, namespace="main")
 
 
 async def serializer_function():

examples/simple_redis.py

@@ -1,9 +1,9 @@
 import asyncio
 
-from aiocache import RedisCache
+from aiocache import Cache
 
 
-cache = RedisCache(endpoint="127.0.0.1", port=6379, namespace="main")
+cache = Cache(Cache.REDIS, endpoint="127.0.0.1", port=6379, namespace="main")
 
 
 async def redis():

tests/acceptance/conftest.py

@@ -1,6 +1,6 @@
 import pytest
 
-from aiocache import SimpleMemoryCache, RedisCache, MemcachedCache, caches
+from aiocache import Cache, caches
 from aiocache.backends.redis import RedisBackend
 
 
@@ -28,7 +28,7 @@ def reset_redis_pools():
 
 @pytest.fixture
 def redis_cache(event_loop):
-    cache = RedisCache(namespace="test")
+    cache = Cache(Cache.REDIS, namespace="test")
     yield cache
 
     event_loop.run_until_complete(cache.delete(pytest.KEY))
@@ -39,7 +39,7 @@ def redis_cache(event_loop):
 
 @pytest.fixture
 def memory_cache(event_loop):
-    cache = SimpleMemoryCache(namespace="test")
+    cache = Cache(namespace="test")
     yield cache
 
     event_loop.run_until_complete(cache.delete(pytest.KEY))
@@ -50,7 +50,7 @@ def memory_cache(event_loop):
 
 @pytest.fixture
 def memcached_cache(event_loop):
-    cache = MemcachedCache(namespace="test")
+    cache = Cache(Cache.MEMCACHED, namespace="test")
     yield cache
 
     event_loop.run_until_complete(cache.delete(pytest.KEY))