Refactor backends

Author: sh4nks

.gitignore

@@ -10,3 +10,4 @@ dist/
 .coverage
 .cache
 .xprocess
+.vscode

LICENSE

@@ -30,3 +30,40 @@ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+The "cache" module from werkzeug is licensed under a BSD-3 Clause license as is
+stated below:
+
+Copyright (c) 2017, Pallets Team
+
+All rights reserved.
+
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

MANIFEST.in

@@ -1,6 +1,16 @@
-include LICENSE CHANGES CONTRIBUTORS requirements.txt tox.ini
-include test_cache.py test_template.html
-graft docs *
-recursive-exclude docs *.pyc
-recursive-exclude docs *.pyo
+include LICENSE
+include CONTRIBUTORS
+include CHANGES
+include README.md
+include requirements.txt
+include tox.ini
+include setup.cfg
+
+graft docs
+graft tests
+
 prune docs/_build
+
+global-exclude __pycache__
+global-exclude *.py[co]
+global-exclude *.sw[a-z]

Makefile

@@ -1,4 +1,4 @@
-.PHONY: text tox clean wheel upload docs
+.PHONY: test tox clean wheel upload docs
 
 test:
 	pytest

README.md

@@ -12,6 +12,9 @@ Adds easy cache support to Flask.
 This is a fork of the [Flask-Cache](https://github.com/thadeusb/flask-cache)
 extension.
 
+Flask-Caching also includes the ``cache`` module from werkzeug licensed under a
+BSD-3 Clause License.
+
 
 Setup
 -----

docs/index.rst

@@ -7,7 +7,7 @@ Flask-Caching is an extension to `Flask`_ that adds caching support for
 various backends to any Flask application. Besides providing support for all
 `werkzeug`_'s original caching backends through a uniformed API,
 it is also possible to develop your own caching backend by subclassing
-:class:`flask_caching.backends.cache.BaseCache` class.
+:class:`flask_caching.backends.base.BaseCache` class.
 
 
 Installation
@@ -279,9 +279,9 @@ The following configuration values exist for Flask-Caching:
                                 * **simple**: SimpleCache
                                 * **filesystem**: FileSystemCache
                                 * **redis**: RedisCache (redis required)
+                                * **redissentinel**: RedisSentinelCache (redis required)
                                 * **uwsgi**: UWSGICache (uwsgi required)
                                 * **memcached**: MemcachedCache (pylibmc or memcache required)
-                                * **gaememcached**: GAEMemcachedCache
                                 * **saslmemcached**: SASLMemcachedCache (pylibmc required)
                                 * **spreadsaslmemcached**: SpreadSASLMemcachedCache (pylibmc required)
 
@@ -301,8 +301,7 @@ The following configuration values exist for Flask-Caching:
 ``CACHE_KEY_PREFIX``            A prefix that is added before all keys.
                                 This makes it possible to use the same
                                 memcached server for different apps.
-                                Used only for RedisCache, MemcachedCache and
-                                GAEMemcachedCache.
+                                Used only for RedisCache and MemcachedCache
 ``CACHE_UWSGI_NAME``            The name of the uwsgi caching instance to
                                 connect to, for example: mycache@localhost:3031,
                                 defaults to an empty string, which means uWSGI
@@ -389,11 +388,11 @@ Set ``CACHE_TYPE`` to ``redis`` to use this type.
 
 - CACHE_DEFAULT_TIMEOUT
 - CACHE_KEY_PREFIX
+- CACHE_OPTIONS
 - CACHE_REDIS_HOST
 - CACHE_REDIS_PORT
 - CACHE_REDIS_PASSWORD
 - CACHE_REDIS_DB
-- CACHE_OPTIONS
 - CACHE_REDIS_URL
 
 Entries in CACHE_OPTIONS are passed to the redis client as ``**kwargs``
@@ -403,10 +402,10 @@ RedisSentinelCache
 
 Set ``CACHE_TYPE`` to ``redissentinel`` to use this type.
 
+- CACHE_KEY_PREFIX
 - CACHE_REDIS_SENTINELS
 - CACHE_REDIS_SENTINEL_MASTER
 - CACHE_REDIS_PASSWORD
-- CACHE_KEY_PREFIX
 - CACHE_REDIS_DB
 
 Entries in CACHE_OPTIONS are passed to the redis client as ``**kwargs``
@@ -442,13 +441,6 @@ Relevant configuration values
 
    Alternatively, see `Custom Cache Backends`_.
 
-GAEMemcachedCache
-`````````````````
-
-Set ``CACHE_TYPE`` to ``gaememcached`` to use this type.
-
-Is MemcachedCache under a different name.
-
 SASLMemcachedCache
 ``````````````````
 
@@ -462,10 +454,10 @@ Relevant configuration values
 
 - CACHE_DEFAULT_TIMEOUT
 - CACHE_KEY_PREFIX
+- CACHE_OPTIONS
 - CACHE_MEMCACHED_SERVERS
 - CACHE_MEMCACHED_USERNAME
 - CACHE_MEMCACHED_PASSWORD
-- CACHE_OPTIONS
 
 .. note:: Since the SASL Memcached cache types do not use werkzeug's original built-in cache
    infrastructure, they can be configured with CACHE_OPTIONS.

flask_caching/__init__.py

@@ -21,7 +21,7 @@
 from flask import current_app, request, url_for
 from werkzeug.utils import import_string
 
-from ._compat import PY2, iteritems
+from flask_caching._compat import PY2, iteritems
 
 __version__ = "1.4.0"
 
@@ -198,7 +198,7 @@ def init_app(self, app, config=None):
             and not config["CACHE_NO_NULL_WARNING"]
         ):
             warnings.warn(
-                "Flask-Cache: CACHE_TYPE is set to null, "
+                "Flask-Caching: CACHE_TYPE is set to null, "
                 "caching is effectively disabled."
             )
 
@@ -219,7 +219,7 @@ def _set_cache(self, app, config):
                 cache_obj = getattr(backends, import_me)
             except AttributeError:
                 raise ImportError(
-                    "%s is not a valid FlaskCache backend" % (import_me)
+                    "%s is not a valid Flask-Caching backend" % (import_me)
                 )
         else:
             cache_obj = import_string(import_me)
@@ -411,8 +411,13 @@ def make_cache_key(*args, **kwargs):
                 # Convert non-keyword arguments (which is the way
                 # `make_cache_key` expects them) to keyword arguments
                 # (the way `url_for` expects them)
-                argspec = inspect.getargspec(f)
-                for arg_name, arg in zip(argspec.args, args):
+                try:
+                    # Python >= 3.0
+                    argspec_args = inspect.getfullargspec(f).args
+                except AttributeError:
+                    argspec_args = inspect.getargspec(f).args
+
+                for arg_name, arg in zip(argspec_args, args):
                     kwargs[arg_name] = arg
 
                 return _make_cache_key(args, kwargs, use_request=False)
@@ -619,7 +624,7 @@ def _memoize_kwargs_to_args(self, f, *args, **kwargs):
 
             new_args.append(arg)
 
-        new_args.extend(args[len(arg_names) :])
+        new_args.extend(args[len(arg_names):])
         return (
             tuple(new_args),
             OrderedDict(
@@ -639,7 +644,11 @@ def _bypass_cache(self, unless, f, *args, **kwargs):
         bypass_cache = False
 
         if callable(unless):
-            argspec = inspect.getargspec(unless)
+            try:
+                # Python >= 3.0
+                argspec = inspect.getfullargspec(unless)
+            except AttributeError:
+                argspec = inspect.getargspec(unless)
 
             # If unless() takes args, pass them in.
             if len(argspec.args) > 0 and argspec.varargs and argspec.keywords:
@@ -714,6 +723,7 @@ def big_foo(a, b):
                               renewal of cached functions.
         :param hash_method: Default hashlib.md5. The hash method used to
                             generate the keys for cached results.
+
         .. versionadded:: 0.5
             params ``make_name``, ``unless``
         """

flask_caching/_compat.py

@@ -21,8 +21,43 @@
     iterkeys = lambda d: iter(d.keys())
     itervalues = lambda d: iter(d.values())
     iteritems = lambda d: iter(d.items())
+
+    text_type = str
+    string_types = (str, )
+    integer_types = (int, )
+
+    def to_bytes(x, charset=sys.getdefaultencoding(), errors='strict'):
+        if x is None:
+            return None
+        if isinstance(x, (bytes, bytearray, memoryview)):  # noqa
+            return bytes(x)
+        if isinstance(x, str):
+            return x.encode(charset, errors)
+        raise TypeError('Expected bytes')
+
+    def to_native(x, charset=sys.getdefaultencoding(), errors='strict'):
+        if x is None or isinstance(x, str):
+            return x
+        return x.decode(charset, errors)
 else:
     range_type = xrange
     iterkeys = lambda d: d.iterkeys()
     itervalues = lambda d: d.itervalues()
     iteritems = lambda d: d.iteritems()
+    text_type = unicode
+    string_types = (str, unicode)
+    integer_types = (int, long)
+
+    def to_bytes(x, charset=sys.getdefaultencoding(), errors='strict'):
+        if x is None:
+            return None
+        if isinstance(x, (bytes, bytearray, buffer)):
+            return bytes(x)
+        if isinstance(x, unicode):
+            return x.encode(charset, errors)
+        raise TypeError('Expected bytes')
+
+    def to_native(x, charset=sys.getdefaultencoding(), errors='strict'):
+        if x is None or isinstance(x, str):
+            return x
+        return x.encode(charset, errors)