Fix #225: Add submodule shims for backward compatibility.

src/cachetools/cache.py

@@ -0,0 +1,8 @@
+import warnings
+
+from . import Cache
+
+warnings.warn(
+    "cachetools.cache is deprecated, please use cachetools.Cache",
+    DeprecationWarning
+)

src/cachetools/fifo.py

@@ -0,0 +1,8 @@
+import warnings
+
+from . import FIFOCache
+
+warnings.warn(
+    "cachetools.fifo is deprecated, please use cachetools.FIFOCache",
+    DeprecationWarning
+)

src/cachetools/lfu.py

@@ -0,0 +1,8 @@
+import warnings
+
+from . import LFUCache
+
+warnings.warn(
+    "cachetools.lfu is deprecated, please use cachetools.LFUCache",
+    DeprecationWarning
+)

src/cachetools/lru.py

@@ -0,0 +1,8 @@
+import warnings
+
+from . import LRUCache
+
+warnings.warn(
+    "cachetools.lru is deprecated, please use cachetools.LRUCache",
+    DeprecationWarning
+)

src/cachetools/mru.py

@@ -0,0 +1,8 @@
+import warnings
+
+from . import MRUCache
+
+warnings.warn(
+    "cachetools.mru is deprecated, please use cachetools.MRUCache",
+    DeprecationWarning
+)

src/cachetools/rr.py

@@ -0,0 +1,8 @@
+import warnings
+
+from . import RRCache
+
+warnings.warn(
+    "cachetools.rr is deprecated, please use cachetools.RRCache",
+    DeprecationWarning
+)

src/cachetools/ttl.py

@@ -0,0 +1,8 @@
+import warnings
+
+from . import TTLCache
+
+warnings.warn(
+    "cachetools.ttl is deprecated, please use cachetools.TTLCache",
+    DeprecationWarning
+)

tests/test_deprecated.py

@@ -0,0 +1,59 @@
+import unittest
+import warnings
+
+class DeprecatedTest(unittest.TestCase):
+    def test_cache(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            from cachetools.cache import Cache
+            assert len(w) == 1
+            assert issubclass(w[-1].category, DeprecationWarning)
+            assert "cachetools.cache" in str(w[-1].message)
+
+    def test_fifo(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            from cachetools.fifo import FIFOCache
+            assert len(w) == 1
+            assert issubclass(w[-1].category, DeprecationWarning)
+            assert "cachetools.fifo" in str(w[-1].message)
+
+    def test_lfu(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            from cachetools.lfu import LFUCache
+            assert len(w) == 1
+            assert issubclass(w[-1].category, DeprecationWarning)
+            assert "cachetools.lfu" in str(w[-1].message)
+
+    def test_lru(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            from cachetools.lru import LRUCache
+            assert len(w) == 1
+            assert issubclass(w[-1].category, DeprecationWarning)
+            assert "cachetools.lru" in str(w[-1].message)
+
+    def test_mru(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            from cachetools.mru import MRUCache
+            assert len(w) == 1
+            assert issubclass(w[-1].category, DeprecationWarning)
+            assert "cachetools.mru" in str(w[-1].message)
+
+    def test_rr(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            from cachetools.rr import RRCache
+            assert len(w) == 1
+            assert issubclass(w[-1].category, DeprecationWarning)
+            assert "cachetools.rr" in str(w[-1].message)
+
+    def test_ttl(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            from cachetools.ttl import TTLCache
+            assert len(w) == 1
+            assert issubclass(w[-1].category, DeprecationWarning)
+            assert "cachetools.ttl" in str(w[-1].message)