Fix #334: Drop MRUCache.

Author: tkem

docs/index.rst

@@ -98,18 +98,6 @@ inserted into the cache.
    This class discards the least recently used items first to make
    space when necessary.
 
-.. autoclass:: MRUCache(maxsize, getsizeof=None)
-   :members: popitem
-
-   This class discards the most recently used items first to make
-   space when necessary.
-
-   .. deprecated:: 5.4
-
-   `MRUCache` has been deprecated due to lack of use, to reduce
-   maintenance.  Please choose another cache implementation that suits
-   your needs.
-
 .. autoclass:: RRCache(maxsize, choice=random.choice, getsizeof=None)
    :members: choice, popitem
 
@@ -174,7 +162,7 @@ inserted into the cache.
    value of `timer()`.
 
    .. testcode::
-   
+
       def my_ttu(_key, value, now):
           # assume value.ttu contains the item's time-to-use in seconds
           # note that the _key argument is ignored in this example
@@ -688,18 +676,6 @@ all the decorators in this module are thread-safe by default.
    saves up to `maxsize` results based on a Least Recently Used (LRU)
    algorithm.
 
-.. decorator:: mru_cache(user_function)
-               mru_cache(maxsize=128, typed=False)
-
-   Decorator that wraps a function with a memoizing callable that
-   saves up to `maxsize` results based on a Most Recently Used (MRU)
-   algorithm.
-
-   .. deprecated:: 5.4
-
-   The `mru_cache` decorator has been deprecated due to lack of use.
-   Please choose a decorator based on some other algorithm.
-
 .. decorator:: rr_cache(user_function)
                rr_cache(maxsize=128, choice=random.choice, typed=False)
 

src/cachetools/__init__.py

@@ -5,7 +5,6 @@
     "FIFOCache",
     "LFUCache",
     "LRUCache",
-    "MRUCache",
     "RRCache",
     "TLRUCache",
     "TTLCache",
@@ -237,47 +236,6 @@ def __update(self, key):
             self.__order[key] = None
 
 
-class MRUCache(Cache):
-    """Most Recently Used (MRU) cache implementation."""
-
-    def __init__(self, maxsize, getsizeof=None):
-        from warnings import warn
-
-        warn("MRUCache is deprecated", DeprecationWarning, stacklevel=2)
-
-        Cache.__init__(self, maxsize, getsizeof)
-        self.__order = collections.OrderedDict()
-
-    def __getitem__(self, key, cache_getitem=Cache.__getitem__):
-        value = cache_getitem(self, key)
-        if key in self:  # __missing__ may not store item
-            self.__update(key)
-        return value
-
-    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
-        cache_setitem(self, key, value)
-        self.__update(key)
-
-    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
-        cache_delitem(self, key)
-        del self.__order[key]
-
-    def popitem(self):
-        """Remove and return the `(key, value)` pair most recently used."""
-        try:
-            key = next(iter(self.__order))
-        except StopIteration:
-            raise KeyError("%s is empty" % type(self).__name__) from None
-        else:
-            return (key, self.pop(key))
-
-    def __update(self, key):
-        try:
-            self.__order.move_to_end(key, last=False)
-        except KeyError:
-            self.__order[key] = None
-
-
 class RRCache(Cache):
     """Random Replacement (RR) cache implementation."""
 

src/cachetools/func.py

@@ -1,6 +1,6 @@
 """`functools.lru_cache` compatible memoizing function decorators."""
 
-__all__ = ("fifo_cache", "lfu_cache", "lru_cache", "mru_cache", "rr_cache", "ttl_cache")
+__all__ = ("fifo_cache", "lfu_cache", "lru_cache", "rr_cache", "ttl_cache")
 
 import math
 import random
@@ -11,7 +11,7 @@
 except ImportError:  # pragma: no cover
     from dummy_threading import RLock
 
-from . import FIFOCache, LFUCache, LRUCache, MRUCache, RRCache, TTLCache
+from . import FIFOCache, LFUCache, LRUCache, RRCache, TTLCache
 from . import cached
 from . import keys
 
@@ -77,23 +77,6 @@ def lru_cache(maxsize=128, typed=False):
         return _cache(LRUCache(maxsize), maxsize, typed)
 
 
-def mru_cache(maxsize=128, typed=False):
-    """Decorator to wrap a function with a memoizing callable that saves
-    up to `maxsize` results based on a Most Recently Used (MRU)
-    algorithm.
-    """
-    from warnings import warn
-
-    warn("@mru_cache is deprecated", DeprecationWarning, stacklevel=2)
-
-    if maxsize is None:
-        return _cache({}, None, typed)
-    elif callable(maxsize):
-        return _cache(MRUCache(128), 128, typed)(maxsize)
-    else:
-        return _cache(MRUCache(maxsize), maxsize, typed)
-
-
 def rr_cache(maxsize=128, choice=random.choice, typed=False):
     """Decorator to wrap a function with a memoizing callable that saves
     up to `maxsize` results based on a Random Replacement (RR)

tests/test_func.py

@@ -111,18 +111,6 @@ class LRUDecoratorTest(unittest.TestCase, DecoratorTestMixin):
     DECORATOR = staticmethod(cachetools.func.lru_cache)
 
 
-class MRUDecoratorTest(unittest.TestCase, DecoratorTestMixin):
-    def decorator(self, maxsize, **kwargs):
-        import warnings
-
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            d = cachetools.func.mru_cache(maxsize, **kwargs)
-        self.assertNotEqual(len(w), 0)
-        self.assertIs(w[0].category, DeprecationWarning)
-        return d
-
-
 class RRDecoratorTest(unittest.TestCase, DecoratorTestMixin):
     DECORATOR = staticmethod(cachetools.func.rr_cache)