k3cacheable 0.1.0__tar.gz → 0.1.2__tar.gz

k3cacheable-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 张炎泼
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

k3cacheable-0.1.2/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: k3cacheable
+Version: 0.1.2
+Summary: Cache data which access frequently
+Author-email: Zhang Yanpo <drdr.xp@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/pykit3/k3cacheable
+Project-URL: Documentation, https://k3cacheable.readthedocs.io
+Keywords: cache,cacheable,memoize,pykit3
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: msgpack
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Provides-Extra: publish
+Requires-Dist: build; extra == "publish"
+Requires-Dist: twine; extra == "publish"
+Requires-Dist: pk3; extra == "publish"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.5; extra == "docs"
+Requires-Dist: mkdocs-material>=9.0; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.24; extra == "docs"
+Dynamic: license-file
+
+# k3cacheable
+
+[![Action-CI](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml/badge.svg)](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml)
+[![Documentation Status](https://readthedocs.org/projects/k3cacheable/badge/?version=stable)](https://k3cacheable.readthedocs.io/en/stable/?badge=stable)
+[![Package](https://img.shields.io/pypi/pyversions/k3cacheable)](https://pypi.org/project/k3cacheable)
+
+Cache data which access frequently.
+
+k3cacheable is a component of [pykit3] project: a python3 toolkit set.
+
+
+Cache data which access frequently.
+
+
+
+
+# Install
+
+```
+pip install k3cacheable
+```
+
+# Synopsis
+
+```python
+
+import k3cacheable
+import time
+
+# create a `LRU`, capacity:10 timeout:60
+c = k3cacheable.LRU(10, 60)
+
+# set value like the `dict`
+c['key'] = 'val'
+
+# get value like the `dict`
+# if item timeout, delete it and raise `KeyError`
+# if item not exist, raise `KeyError`
+try:
+    val = c['key']
+except KeyError:
+    print('key error')
+
+cache_data = {
+    'key1': 'val_1',
+    'key2': 'val_2',
+}
+
+# define the function with a decorator
+@k3cacheable.cache('cache_name', capacity=100, timeout=60,
+                 is_deepcopy=False, mutex_update=False)
+def get_data(param):
+    return cache_data.get(param, '')
+
+# call `get_data`, if item has not been cached, cache the return value
+data = get_data('key1')
+
+# call `get_data` use the same param, data will be got from cache
+time.sleep(1)
+data = get_data('key1')
+
+# if item timeout, when call `get_data`, cache again
+time.sleep(1)
+data = get_data('key1')
+
+# define a method with a decorator
+class MethodCache(object):
+
+    @k3cacheable.cache('method_cache_name', capacity=100, timeout=60,
+                     is_deepcopy=False, mutex_update=False)
+    def get_data(self, param):
+        return cache_data.get(param, '')
+
+mm = MethodCache()
+data = mm.get_data('key2')
+
+```
+
+#   Author
+
+Zhang Yanpo (张炎泼) <drdr.xp@gmail.com>
+
+#   Copyright and License
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Zhang Yanpo (张炎泼) <drdr.xp@gmail.com>
+
+
+[pykit3]: https://github.com/pykit3

k3cacheable-0.1.0/k3cacheable/synopsis.py → k3cacheable-0.1.2/README.md

@@ -1,49 +1,90 @@
-import k3cacheable
-import time
-
-# create a `LRU`, capacity:10 timeout:60
-c = k3cacheable.LRU(10, 60)
-
-# set value like the `dict`
-c['key'] = 'val'
-
-# get value like the `dict`
-# if item timeout, delete it and raise `KeyError`
-# if item not exist, raise `KeyError`
-try:
-    val = c['key']
-except KeyError:
-    print('key error')
-
-cache_data = {
-    'key1': 'val_1',
-    'key2': 'val_2',
-}
-
-# define the function with a decorator
-@k3cacheable.cache('cache_name', capacity=100, timeout=60,
-                 is_deepcopy=False, mutex_update=False)
-def get_data(param):
-    return cache_data.get(param, '')
-
-# call `get_data`, if item has not been cached, cache the return value
-data = get_data('key1')
-
-# call `get_data` use the same param, data will be got from cache
-time.sleep(1)
-data = get_data('key1')
-
-# if item timeout, when call `get_data`, cache again
-time.sleep(1)
-data = get_data('key1')
-
-# define a method with a decorator
-class MethodCache(object):
-
-    @k3cacheable.cache('method_cache_name', capacity=100, timeout=60,
-                     is_deepcopy=False, mutex_update=False)
-    def get_data(self, param):
-        return cache_data.get(param, '')
-
-mm = MethodCache()
-data = mm.get_data('key2')
+# k3cacheable
+
+[![Action-CI](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml/badge.svg)](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml)
+[![Documentation Status](https://readthedocs.org/projects/k3cacheable/badge/?version=stable)](https://k3cacheable.readthedocs.io/en/stable/?badge=stable)
+[![Package](https://img.shields.io/pypi/pyversions/k3cacheable)](https://pypi.org/project/k3cacheable)
+
+Cache data which access frequently.
+
+k3cacheable is a component of [pykit3] project: a python3 toolkit set.
+
+
+Cache data which access frequently.
+
+
+
+
+# Install
+
+```
+pip install k3cacheable
+```
+
+# Synopsis
+
+```python
+
+import k3cacheable
+import time
+
+# create a `LRU`, capacity:10 timeout:60
+c = k3cacheable.LRU(10, 60)
+
+# set value like the `dict`
+c['key'] = 'val'
+
+# get value like the `dict`
+# if item timeout, delete it and raise `KeyError`
+# if item not exist, raise `KeyError`
+try:
+    val = c['key']
+except KeyError:
+    print('key error')
+
+cache_data = {
+    'key1': 'val_1',
+    'key2': 'val_2',
+}
+
+# define the function with a decorator
+@k3cacheable.cache('cache_name', capacity=100, timeout=60,
+                 is_deepcopy=False, mutex_update=False)
+def get_data(param):
+    return cache_data.get(param, '')
+
+# call `get_data`, if item has not been cached, cache the return value
+data = get_data('key1')
+
+# call `get_data` use the same param, data will be got from cache
+time.sleep(1)
+data = get_data('key1')
+
+# if item timeout, when call `get_data`, cache again
+time.sleep(1)
+data = get_data('key1')
+
+# define a method with a decorator
+class MethodCache(object):
+
+    @k3cacheable.cache('method_cache_name', capacity=100, timeout=60,
+                     is_deepcopy=False, mutex_update=False)
+    def get_data(self, param):
+        return cache_data.get(param, '')
+
+mm = MethodCache()
+data = mm.get_data('key2')
+
+```
+
+#   Author
+
+Zhang Yanpo (张炎泼) <drdr.xp@gmail.com>
+
+#   Copyright and License
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Zhang Yanpo (张炎泼) <drdr.xp@gmail.com>
+
+
+[pykit3]: https://github.com/pykit3

{k3cacheable-0.1.0/k3cacheable → k3cacheable-0.1.2}/__init__.py

@@ -6,8 +6,9 @@ Cache data which access frequently.
 # from .proc import CalledProcessError
 # from .proc import ProcError
 
-__version__ = "0.1.0"
-__name__ = "k3cacheable"
+from importlib.metadata import version
+
+__version__ = version("k3cacheable")
 
 from .cacheable import (
     LRU,
@@ -16,7 +17,7 @@ from .cacheable import (
 )
 
 __all__ = [
-    'LRU',
-    'Cacheable',
-    'cache',
+    "LRU",
+    "Cacheable",
+    "cache",
 ]

{k3cacheable-0.1.0/k3cacheable → k3cacheable-0.1.2}/cacheable.py

@@ -23,7 +23,7 @@ class LRU(object):
 
     If size of `LRU` is greater than `capacity` * 1.5,
     clean items from head until size is equal to `capacity`.
-    
+
     .. highlight:: python
     .. code-block:: python
 
@@ -51,6 +51,7 @@ class LRU(object):
             print('key not in lru')
         ...
     """
+
     def __init__(self, capacity, timeout=60):
         """
         Least Recently Used Cache.
@@ -64,39 +65,33 @@ class LRU(object):
         self.timeout = timeout
         self.size = 0
         self.items = {}
-        self.head = {'next': None, 'pre': None}
+        self.head = {"next": None, "pre": None}
         self.tail = self.head
 
     def __getitem__(self, key):
-
         with self.lock:
             now = int(time.time())
             item = self.items[key]
 
-            if now > item['tm'] + self.timeout:
+            if now > item["tm"] + self.timeout:
                 self._del_item(item)
-                raise KeyError('{k} is timeout'.format(k=key))
+                raise KeyError("{k} is timeout".format(k=key))
 
             self._move_to_tail(item)
 
-            return item['val']
+            return item["val"]
 
     def __setitem__(self, key, val):
-
         with self.lock:
             if key in self.items:
                 item = self.items[key]
-                item['val'] = val
-                item['tm'] = int(time.time())
+                item["val"] = val
+                item["tm"] = int(time.time())
 
                 self._move_to_tail(item)
 
             else:
-                self.items[key] = {'key': key,
-                                   'val': val,
-                                   'pre': None,
-                                   'next': None,
-                                   'tm': int(time.time())}
+                self.items[key] = {"key": key, "val": val, "pre": None, "next": None, "tm": int(time.time())}
 
                 self._move_to_tail(self.items[key])
 
@@ -106,40 +101,34 @@ class LRU(object):
                     self._cleanup()
 
     def _remove_item(self, item):
-
-        item['pre']['next'] = item['next']
-        if item['next'] is not None:
-            item['next']['pre'] = item['pre']
+        item["pre"]["next"] = item["next"]
+        if item["next"] is not None:
+            item["next"]["pre"] = item["pre"]
         else:
-            self.tail = item['pre']
+            self.tail = item["pre"]
 
     def _move_to_tail(self, item):
-
-        if item['pre'] is not None:
+        if item["pre"] is not None:
             self._remove_item(item)
 
-        self.tail['next'] = item
-        item['pre'] = self.tail
-        item['next'] = None
+        self.tail["next"] = item
+        item["pre"] = self.tail
+        item["next"] = None
         self.tail = item
 
     def _del_item(self, item):
-
-        del self.items[item['key']]
+        del self.items[item["key"]]
         self._remove_item(item)
         self.size -= 1
 
     def _cleanup(self):
-
         while self.size > self.capacity:
-            item = self.head['next']
+            item = self.head["next"]
             self._del_item(item)
 
 
 class Cacheable(object):
-
-    def __init__(self, capacity=1024 * 4, timeout=60,
-                    is_deepcopy=True, is_pack=False, mutex_update=False):
+    def __init__(self, capacity=1024 * 4, timeout=60, is_deepcopy=True, is_pack=False, mutex_update=False):
         """
         Create a `LRU` object, all items will be cached in it.
         :param capacity: for create `LRU` object, default is 1024 * 4
@@ -166,16 +155,13 @@ class Cacheable(object):
         self.mutex_update = mutex_update
 
     def _arg_str(self, args, argkv):
-
         argkv = [(k, v) for k, v in list(argkv.items())]
         argkv.sort()
 
         return str([args, argkv])
 
     def _cache_wrapper(self, fun):
-
         def func_wrapper(*args, **argkv):
-
             val = None
             generate_key = self._arg_str(args, argkv)
 
@@ -211,8 +197,7 @@ class Cacheable(object):
 caches = {}
 
 
-def cache(name, capacity=1024 * 4, timeout=60,
-        is_deepcopy=True, is_pack=False, mutex_update=False):
+def cache(name, capacity=1024 * 4, timeout=60, is_deepcopy=True, is_pack=False, mutex_update=False):
     """
     If not exist, create a `cacheable.Cacheable` and save it, else use exist one.
     :param name: for distinguishing different `cacheable.Cacheable`
@@ -244,8 +229,7 @@ def cache(name, capacity=1024 * 4, timeout=60,
     """
     c = caches.get(name)
     if c is None:
-        c = Cacheable(capacity=capacity, timeout=timeout,
-                      is_deepcopy=is_deepcopy, mutex_update=mutex_update)
+        c = Cacheable(capacity=capacity, timeout=timeout, is_deepcopy=is_deepcopy, mutex_update=mutex_update)
         caches[name] = c
 
     return c._cache_wrapper

k3cacheable-0.1.2/k3cacheable.egg-info/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: k3cacheable
+Version: 0.1.2
+Summary: Cache data which access frequently
+Author-email: Zhang Yanpo <drdr.xp@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/pykit3/k3cacheable
+Project-URL: Documentation, https://k3cacheable.readthedocs.io
+Keywords: cache,cacheable,memoize,pykit3
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: msgpack
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Provides-Extra: publish
+Requires-Dist: build; extra == "publish"
+Requires-Dist: twine; extra == "publish"
+Requires-Dist: pk3; extra == "publish"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.5; extra == "docs"
+Requires-Dist: mkdocs-material>=9.0; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.24; extra == "docs"
+Dynamic: license-file
+
+# k3cacheable
+
+[![Action-CI](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml/badge.svg)](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml)
+[![Documentation Status](https://readthedocs.org/projects/k3cacheable/badge/?version=stable)](https://k3cacheable.readthedocs.io/en/stable/?badge=stable)
+[![Package](https://img.shields.io/pypi/pyversions/k3cacheable)](https://pypi.org/project/k3cacheable)
+
+Cache data which access frequently.
+
+k3cacheable is a component of [pykit3] project: a python3 toolkit set.
+
+
+Cache data which access frequently.
+
+
+
+
+# Install
+
+```
+pip install k3cacheable
+```
+
+# Synopsis
+
+```python
+
+import k3cacheable
+import time
+
+# create a `LRU`, capacity:10 timeout:60
+c = k3cacheable.LRU(10, 60)
+
+# set value like the `dict`
+c['key'] = 'val'
+
+# get value like the `dict`
+# if item timeout, delete it and raise `KeyError`
+# if item not exist, raise `KeyError`
+try:
+    val = c['key']
+except KeyError:
+    print('key error')
+
+cache_data = {
+    'key1': 'val_1',
+    'key2': 'val_2',
+}
+
+# define the function with a decorator
+@k3cacheable.cache('cache_name', capacity=100, timeout=60,
+                 is_deepcopy=False, mutex_update=False)
+def get_data(param):
+    return cache_data.get(param, '')
+
+# call `get_data`, if item has not been cached, cache the return value
+data = get_data('key1')
+
+# call `get_data` use the same param, data will be got from cache
+time.sleep(1)
+data = get_data('key1')
+
+# if item timeout, when call `get_data`, cache again
+time.sleep(1)
+data = get_data('key1')
+
+# define a method with a decorator
+class MethodCache(object):
+
+    @k3cacheable.cache('method_cache_name', capacity=100, timeout=60,
+                     is_deepcopy=False, mutex_update=False)
+    def get_data(self, param):
+        return cache_data.get(param, '')
+
+mm = MethodCache()
+data = mm.get_data('key2')
+
+```
+
+#   Author
+
+Zhang Yanpo (张炎泼) <drdr.xp@gmail.com>
+
+#   Copyright and License
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Zhang Yanpo (张炎泼) <drdr.xp@gmail.com>
+
+
+[pykit3]: https://github.com/pykit3

k3cacheable-0.1.2/k3cacheable.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+__init__.py
+cacheable.py
+pyproject.toml
+synopsis.py
+./__init__.py
+./cacheable.py
+./synopsis.py
+k3cacheable.egg-info/PKG-INFO
+k3cacheable.egg-info/SOURCES.txt
+k3cacheable.egg-info/dependency_links.txt
+k3cacheable.egg-info/requires.txt
+k3cacheable.egg-info/top_level.txt
+test/test_doctest.py
+test/test_k3cacheable.py

k3cacheable-0.1.2/k3cacheable.egg-info/requires.txt

@@ -0,0 +1,16 @@
+msgpack
+
+[dev]
+pytest>=7.0
+ruff
+coverage
+
+[docs]
+mkdocs>=1.5
+mkdocs-material>=9.0
+mkdocstrings[python]>=0.24
+
+[publish]
+build
+twine
+pk3

k3cacheable-0.1.2/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "k3cacheable"
+version = "0.1.2"
+description = "Cache data which access frequently"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    { name = "Zhang Yanpo", email = "drdr.xp@gmail.com" }
+]
+keywords = ["cache", "cacheable", "memoize", "pykit3"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "msgpack",
+]
+
+[project.urls]
+Homepage = "https://github.com/pykit3/k3cacheable"
+Documentation = "https://k3cacheable.readthedocs.io"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "ruff",
+    "coverage",
+]
+publish = [
+    "build",
+    "twine",
+    "pk3",
+]
+docs = [
+    "mkdocs>=1.5",
+    "mkdocs-material>=9.0",
+    "mkdocstrings[python]>=0.24",
+]
+
+[tool.setuptools]
+packages = ["k3cacheable"]
+
+[tool.setuptools.package-dir]
+k3cacheable = "."
+
+[tool.ruff]
+line-length = 120

k3cacheable-0.1.2/synopsis.py

@@ -0,0 +1,50 @@
+import k3cacheable
+import time
+
+# create a `LRU`, capacity:10 timeout:60
+c = k3cacheable.LRU(10, 60)
+
+# set value like the `dict`
+c["key"] = "val"
+
+# get value like the `dict`
+# if item timeout, delete it and raise `KeyError`
+# if item not exist, raise `KeyError`
+try:
+    val = c["key"]
+except KeyError:
+    print("key error")
+
+cache_data = {
+    "key1": "val_1",
+    "key2": "val_2",
+}
+
+
+# define the function with a decorator
+@k3cacheable.cache("cache_name", capacity=100, timeout=60, is_deepcopy=False, mutex_update=False)
+def get_data(param):
+    return cache_data.get(param, "")
+
+
+# call `get_data`, if item has not been cached, cache the return value
+data = get_data("key1")
+
+# call `get_data` use the same param, data will be got from cache
+time.sleep(1)
+data = get_data("key1")
+
+# if item timeout, when call `get_data`, cache again
+time.sleep(1)
+data = get_data("key1")
+
+
+# define a method with a decorator
+class MethodCache(object):
+    @k3cacheable.cache("method_cache_name", capacity=100, timeout=60, is_deepcopy=False, mutex_update=False)
+    def get_data(self, param):
+        return cache_data.get(param, "")
+
+
+mm = MethodCache()
+data = mm.get_data("key2")

k3cacheable-0.1.2/test/test_doctest.py

@@ -0,0 +1,8 @@
+import doctest
+
+import k3cacheable
+
+
+def load_tests(loader, tests, ignore):
+    tests.addTests(doctest.DocTestSuite(k3cacheable))
+    return tests

k3cacheable-0.1.2/test/test_k3cacheable.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+import _thread
+import time
+import unittest
+
+import k3cacheable
+
+
+class TestLRU(unittest.TestCase):
+    def _assert_lru_list(self, lru):
+        size = lru.size
+        item_head = lru.head
+        item_tail = lru.tail
+        for i in range(size):
+            item_head = item_head["next"]
+            item_tail = item_tail["pre"]
+
+        self.assertIs(item_head, lru.tail)
+        self.assertIs(item_tail, lru.head)
+
+    def _assert_lru_items_order(self, lru, order_keys):
+        item = lru.head["next"]
+        lru_keys = []
+        while item is not None:
+            lru_keys.append(item["key"])
+            item = item["next"]
+
+        self.assertEqual(order_keys, lru_keys)
+
+    def test_lru_timeout(self):
+        cases = (
+            ("k1", "v1", 3, True),
+            ("k2", "v2", 1, False),
+        )
+
+        lru = k3cacheable.LRU(10, 2)
+        for key, val, sleep_time, is_timeout in cases:
+            lru[key] = val
+            time.sleep(sleep_time)
+
+            try:
+                lru[key]
+                self.assertFalse(is_timeout)
+
+            except KeyError:
+                self._assert_lru_list(lru)
+                self.assertTrue(is_timeout)
+
+    def test_lru_getitem(self):
+        capacity = 4
+        cases = (
+            (3, [0, 1, 2], []),
+            (4, [0, 1, 2, 3], []),
+            (5, [0, 1, 2, 3, 4], []),
+            (6, [0, 1, 2, 3, 4, 5], []),
+            (7, [3, 4, 5, 6], [0, 1, 2]),
+        )
+
+        for insert_count, exist_items, cleanup_items in cases:
+            lru = k3cacheable.LRU(capacity, 10)
+            for i in range(insert_count):
+                lru[i] = "val%d" % (i)
+
+            for i in range(insert_count):
+                try:
+                    val = lru[i]
+                    self.assertEqual(val, "val%d" % (i))
+                    self.assertEqual(lru.tail["key"], i)
+                    self.assertIn(i, exist_items)
+
+                except KeyError:
+                    self.assertIn(i, cleanup_items)
+
+    def test_lru_setitem(self):
+        capacity = 4
+        cases = (
+            (3, [0, 1, 2]),
+            (4, [0, 1, 2, 3]),
+            (5, [0, 1, 2, 3, 4]),
+            (6, [0, 1, 2, 3, 4, 5]),
+            # size of lru > capacity*1.5
+            # clean items from head, until size=capacity
+            (7, [3, 4, 5, 6]),
+        )
+
+        for insert_count, expect_order_keys in cases:
+            lru = k3cacheable.LRU(capacity, 10)
+            for i in range(insert_count):
+                lru[i] = "val"
+                self._assert_lru_list(lru)
+
+            self._assert_lru_items_order(lru, expect_order_keys)
+
+    def test_lru_capacity(self):
+        cases = (
+            (0, ((0, 0), (1, 0))),
+            (1, ((1, 1), (2, 1))),
+            (10, ((9, 9), (10, 10), (13, 13), (15, 15), (16, 10))),
+        )
+
+        for capacity, case in cases:
+            for insert_count, expect_size in case:
+                lru = k3cacheable.LRU(capacity, 60)
+                for i in range(insert_count):
+                    lru[i] = "val"
+
+                self.assertEqual(lru.size, expect_size)
+
+
+class TestCacheable(unittest.TestCase):
+    @k3cacheable.cache("method_cache_data", capacity=10, timeout=4, is_deepcopy=False)
+    def _method_cache_data(self, key):
+        data = need_cache_data.get(key, {})
+        data["tm"] = time.time()
+        return data
+
+    def test_get_items_from_cache(self):
+        cache_items = {}
+        for key in need_cache_data.keys():
+            cache_items[key] = get_cache_data(key)
+
+        time.sleep(0.1)
+        for key in need_cache_data.keys():
+            self.assertEqual(get_cache_data(key), cache_items[key])
+
+    def test_get_items_from_cache_use_method(self):
+        cache_items = {}
+        for key in need_cache_data.keys():
+            cache_items[key] = self._method_cache_data(key)
+
+        time.sleep(0.1)
+        for key in need_cache_data.keys():
+            self.assertEqual(self._method_cache_data(key), cache_items[key])
+
+    def test_cache_item_timeout_and_cache_again(self):
+        cases = (
+            (2, False),
+            (4, True),
+        )
+
+        tm = get_cache_data("key")["tm"]
+        for sleep_time, is_timeout in cases:
+            time.sleep(sleep_time)
+            if is_timeout:
+                self.assertNotEqual(tm, get_cache_data("key")["tm"])
+            else:
+                self.assertEqual(tm, get_cache_data("key")["tm"])
+
+    def test_get_deepcopy_item_from_cache(self):
+        self.assertIsNot(get_deepcopy_of_cache_data("key1"), get_deepcopy_of_cache_data("key1"))
+
+    def test_get_concurrent_update_cache_data(self):
+        result = {}
+
+        def _store_result(key):
+            result[key] = get_concurrent_update_cache_data()
+
+        _thread.start_new_thread(_store_result, ("key1",))
+        time.sleep(1)
+        _thread.start_new_thread(_store_result, ("key2",))
+
+        while True:
+            if "key2" in result:
+                break
+            time.sleep(0.1)
+
+        self.assertIsNot(result["key1"], result["key2"])
+
+    def test_get_mutext_update_cache_data(self):
+        result = {}
+
+        def _store_result(key):
+            result[key] = get_mutex_update_cache_data()
+
+        _thread.start_new_thread(_store_result, ("key1",))
+        time.sleep(1)
+        _thread.start_new_thread(_store_result, ("key2",))
+
+        while True:
+            if "key2" in result:
+                break
+            time.sleep(0.1)
+
+        self.assertIs(result["key1"], result["key2"])
+
+    def test_generate_lru_key(self):
+        cases = (
+            ((), {}, "[(), []]"),
+            ((1), {1: "val_1"}, "[1, [(1, 'val_1')]]"),
+            ((1), {"a": "val_a"}, "[1, [('a', 'val_a')]]"),
+            (("c"), {"b": "val_b"}, "['c', [('b', 'val_b')]]"),
+            ((1, "c"), {"a": "val_a", "b": "val_b"}, "[(1, 'c'), [('a', 'val_a'), ('b', 'val_b')]]"),
+            (("c", 1), {"b": "val_b", "a": "val_a"}, "[('c', 1), [('a', 'val_a'), ('b', 'val_b')]]"),
+        )
+
+        for args, argkv, expect_str in cases:
+            self.assertEqual(k3cacheable.Cacheable()._arg_str(args, argkv), expect_str)
+
+
+@k3cacheable.cache("deepcopy_of_cache_data", capacity=100, timeout=60, is_deepcopy=True)
+def get_deepcopy_of_cache_data(key):
+    return need_cache_data.get(key, {})
+
+
+@k3cacheable.cache("cache_data", capacity=100, timeout=4, is_deepcopy=False)
+def get_cache_data(key):
+    cache_data = need_cache_data.get(key, {})
+    cache_data["tm"] = time.time()
+    return cache_data
+
+
+@k3cacheable.cache("concurrent_update_cache_data", capacity=100, timeout=60, is_deepcopy=False, mutex_update=False)
+def get_concurrent_update_cache_data():
+    time.sleep(3)
+    return {}
+
+
+@k3cacheable.cache("mutex_update_cache_data", capacity=100, timeout=60, is_deepcopy=False, mutex_update=True)
+def get_mutex_update_cache_data():
+    time.sleep(3)
+    return {}
+
+
+need_cache_data = {
+    "key1": {"tm": 0},
+    "key2": {"tm": 0},
+    "key3": {"tm": 0},
+    "key4": {"tm": 0},
+}

k3cacheable-0.1.0/PKG-INFO

@@ -1,107 +0,0 @@
-Metadata-Version: 2.1
-Name: k3cacheable
-Version: 0.1.0
-Summary: Cache data which access frequently.
-Home-page: https://github.com/pykit3/k3cacheable
-Author: Zhang Yanpo
-Author-email: drdr.xp@gmail.com
-License: MIT
-Description: # k3cacheable
-        
-        [![Action-CI](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml/badge.svg)](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml)
-        [![Build Status](https://travis-ci.com/pykit3/k3cacheable.svg?branch=master)](https://travis-ci.com/pykit3/k3cacheable)
-        [![Documentation Status](https://readthedocs.org/projects/k3cacheable/badge/?version=stable)](https://k3cacheable.readthedocs.io/en/stable/?badge=stable)
-        [![Package](https://img.shields.io/pypi/pyversions/k3cacheable)](https://pypi.org/project/k3cacheable)
-        
-        Cache data which access frequently.
-        
-        k3cacheable is a component of [pykit3] project: a python3 toolkit set.
-        
-        
-        Cache data which access frequently.
-        
-        
-        
-        
-        # Install
-        
-        ```
-        pip install k3cacheable
-        ```
-        
-        # Synopsis
-        
-        ```python
-        
-        import k3cacheable
-        import time
-        
-        # create a `LRU`, capacity:10 timeout:60
-        c = k3cacheable.LRU(10, 60)
-        
-        # set value like the `dict`
-        c['key'] = 'val'
-        
-        # get value like the `dict`
-        # if item timeout, delete it and raise `KeyError`
-        # if item not exist, raise `KeyError`
-        try:
-            val = c['key']
-        except KeyError:
-            print('key error')
-        
-        cache_data = {
-            'key1': 'val_1',
-            'key2': 'val_2',
-        }
-        
-        # define the function with a decorator
-        @k3cacheable.cache('cache_name', capacity=100, timeout=60,
-                         is_deepcopy=False, mutex_update=False)
-        def get_data(param):
-            return cache_data.get(param, '')
-        
-        # call `get_data`, if item has not been cached, cache the return value
-        data = get_data('key1')
-        
-        # call `get_data` use the same param, data will be got from cache
-        time.sleep(1)
-        data = get_data('key1')
-        
-        # if item timeout, when call `get_data`, cache again
-        time.sleep(1)
-        data = get_data('key1')
-        
-        # define a method with a decorator
-        class MethodCache(object):
-        
-            @k3cacheable.cache('method_cache_name', capacity=100, timeout=60,
-                             is_deepcopy=False, mutex_update=False)
-            def get_data(self, param):
-                return cache_data.get(param, '')
-        
-        mm = MethodCache()
-        data = mm.get_data('key2')
-        
-        ```
-        
-        #   Author
-        
-        Zhang Yanpo (张炎泼) <drdr.xp@gmail.com>
-        
-        #   Copyright and License
-        
-        The MIT License (MIT)
-        
-        Copyright (c) 2015 Zhang Yanpo (张炎泼) <drdr.xp@gmail.com>
-        
-        
-        [pykit3]: https://github.com/pykit3
-Keywords: python,cache
-Platform: UNKNOWN
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.0
-Description-Content-Type: text/markdown

k3cacheable-0.1.0/k3cacheable/setup.py

@@ -1,23 +0,0 @@
-# DO NOT EDIT!!! built with `python _building/build_setup.py`
-import setuptools
-setuptools.setup(
-    name="k3cacheable",
-    packages=["k3cacheable"],
-    version="0.1.0",
-    license='MIT',
-    description='Cache data which access frequently.',
-    long_description="# k3cacheable\n\n[![Action-CI](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml/badge.svg)](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml)\n[![Build Status](https://travis-ci.com/pykit3/k3cacheable.svg?branch=master)](https://travis-ci.com/pykit3/k3cacheable)\n[![Documentation Status](https://readthedocs.org/projects/k3cacheable/badge/?version=stable)](https://k3cacheable.readthedocs.io/en/stable/?badge=stable)\n[![Package](https://img.shields.io/pypi/pyversions/k3cacheable)](https://pypi.org/project/k3cacheable)\n\nCache data which access frequently.\n\nk3cacheable is a component of [pykit3] project: a python3 toolkit set.\n\n\nCache data which access frequently.\n\n\n\n\n# Install\n\n```\npip install k3cacheable\n```\n\n# Synopsis\n\n```python\n\nimport k3cacheable\nimport time\n\n# create a `LRU`, capacity:10 timeout:60\nc = k3cacheable.LRU(10, 60)\n\n# set value like the `dict`\nc['key'] = 'val'\n\n# get value like the `dict`\n# if item timeout, delete it and raise `KeyError`\n# if item not exist, raise `KeyError`\ntry:\n    val = c['key']\nexcept KeyError:\n    print('key error')\n\ncache_data = {\n    'key1': 'val_1',\n    'key2': 'val_2',\n}\n\n# define the function with a decorator\n@k3cacheable.cache('cache_name', capacity=100, timeout=60,\n                 is_deepcopy=False, mutex_update=False)\ndef get_data(param):\n    return cache_data.get(param, '')\n\n# call `get_data`, if item has not been cached, cache the return value\ndata = get_data('key1')\n\n# call `get_data` use the same param, data will be got from cache\ntime.sleep(1)\ndata = get_data('key1')\n\n# if item timeout, when call `get_data`, cache again\ntime.sleep(1)\ndata = get_data('key1')\n\n# define a method with a decorator\nclass MethodCache(object):\n\n    @k3cacheable.cache('method_cache_name', capacity=100, timeout=60,\n                     is_deepcopy=False, mutex_update=False)\n    def get_data(self, param):\n        return cache_data.get(param, '')\n\nmm = MethodCache()\ndata = mm.get_data('key2')\n\n```\n\n#   Author\n\nZhang Yanpo (张炎泼) <drdr.xp@gmail.com>\n\n#   Copyright and License\n\nThe MIT License (MIT)\n\nCopyright (c) 2015 Zhang Yanpo (张炎泼) <drdr.xp@gmail.com>\n\n\n[pykit3]: https://github.com/pykit3",
-    long_description_content_type="text/markdown",
-    author='Zhang Yanpo',
-    author_email='drdr.xp@gmail.com',
-    url='https://github.com/pykit3/k3cacheable',
-    keywords=['python', 'cache'],
-    python_requires='>=3.0',
-
-    install_requires=['msgpack>=1.0.0'],
-    classifiers=[
-        'Development Status :: 4 - Beta',
-        'Intended Audience :: Developers',
-        'Topic :: Software Development :: Libraries',
-    ] + ['Programming Language :: Python :: 3'],
-)

k3cacheable-0.1.0/k3cacheable.egg-info/PKG-INFO

@@ -1,107 +0,0 @@
-Metadata-Version: 2.1
-Name: k3cacheable
-Version: 0.1.0
-Summary: Cache data which access frequently.
-Home-page: https://github.com/pykit3/k3cacheable
-Author: Zhang Yanpo
-Author-email: drdr.xp@gmail.com
-License: MIT
-Description: # k3cacheable
-        
-        [![Action-CI](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml/badge.svg)](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml)
-        [![Build Status](https://travis-ci.com/pykit3/k3cacheable.svg?branch=master)](https://travis-ci.com/pykit3/k3cacheable)
-        [![Documentation Status](https://readthedocs.org/projects/k3cacheable/badge/?version=stable)](https://k3cacheable.readthedocs.io/en/stable/?badge=stable)
-        [![Package](https://img.shields.io/pypi/pyversions/k3cacheable)](https://pypi.org/project/k3cacheable)
-        
-        Cache data which access frequently.
-        
-        k3cacheable is a component of [pykit3] project: a python3 toolkit set.
-        
-        
-        Cache data which access frequently.
-        
-        
-        
-        
-        # Install
-        
-        ```
-        pip install k3cacheable
-        ```
-        
-        # Synopsis
-        
-        ```python
-        
-        import k3cacheable
-        import time
-        
-        # create a `LRU`, capacity:10 timeout:60
-        c = k3cacheable.LRU(10, 60)
-        
-        # set value like the `dict`
-        c['key'] = 'val'
-        
-        # get value like the `dict`
-        # if item timeout, delete it and raise `KeyError`
-        # if item not exist, raise `KeyError`
-        try:
-            val = c['key']
-        except KeyError:
-            print('key error')
-        
-        cache_data = {
-            'key1': 'val_1',
-            'key2': 'val_2',
-        }
-        
-        # define the function with a decorator
-        @k3cacheable.cache('cache_name', capacity=100, timeout=60,
-                         is_deepcopy=False, mutex_update=False)
-        def get_data(param):
-            return cache_data.get(param, '')
-        
-        # call `get_data`, if item has not been cached, cache the return value
-        data = get_data('key1')
-        
-        # call `get_data` use the same param, data will be got from cache
-        time.sleep(1)
-        data = get_data('key1')
-        
-        # if item timeout, when call `get_data`, cache again
-        time.sleep(1)
-        data = get_data('key1')
-        
-        # define a method with a decorator
-        class MethodCache(object):
-        
-            @k3cacheable.cache('method_cache_name', capacity=100, timeout=60,
-                             is_deepcopy=False, mutex_update=False)
-            def get_data(self, param):
-                return cache_data.get(param, '')
-        
-        mm = MethodCache()
-        data = mm.get_data('key2')
-        
-        ```
-        
-        #   Author
-        
-        Zhang Yanpo (张炎泼) <drdr.xp@gmail.com>
-        
-        #   Copyright and License
-        
-        The MIT License (MIT)
-        
-        Copyright (c) 2015 Zhang Yanpo (张炎泼) <drdr.xp@gmail.com>
-        
-        
-        [pykit3]: https://github.com/pykit3
-Keywords: python,cache
-Platform: UNKNOWN
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.0
-Description-Content-Type: text/markdown

k3cacheable-0.1.0/k3cacheable.egg-info/SOURCES.txt

@@ -1,10 +0,0 @@
-setup.py
-k3cacheable/__init__.py
-k3cacheable/cacheable.py
-k3cacheable/setup.py
-k3cacheable/synopsis.py
-k3cacheable.egg-info/PKG-INFO
-k3cacheable.egg-info/SOURCES.txt
-k3cacheable.egg-info/dependency_links.txt
-k3cacheable.egg-info/requires.txt
-k3cacheable.egg-info/top_level.txt

k3cacheable-0.1.0/k3cacheable.egg-info/requires.txt

@@ -1 +0,0 @@
-msgpack>=1.0.0

k3cacheable-0.1.0/setup.py

@@ -1,23 +0,0 @@
-# DO NOT EDIT!!! built with `python _building/build_setup.py`
-import setuptools
-setuptools.setup(
-    name="k3cacheable",
-    packages=["k3cacheable"],
-    version="0.1.0",
-    license='MIT',
-    description='Cache data which access frequently.',
-    long_description="# k3cacheable\n\n[![Action-CI](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml/badge.svg)](https://github.com/pykit3/k3cacheable/actions/workflows/python-package.yml)\n[![Build Status](https://travis-ci.com/pykit3/k3cacheable.svg?branch=master)](https://travis-ci.com/pykit3/k3cacheable)\n[![Documentation Status](https://readthedocs.org/projects/k3cacheable/badge/?version=stable)](https://k3cacheable.readthedocs.io/en/stable/?badge=stable)\n[![Package](https://img.shields.io/pypi/pyversions/k3cacheable)](https://pypi.org/project/k3cacheable)\n\nCache data which access frequently.\n\nk3cacheable is a component of [pykit3] project: a python3 toolkit set.\n\n\nCache data which access frequently.\n\n\n\n\n# Install\n\n```\npip install k3cacheable\n```\n\n# Synopsis\n\n```python\n\nimport k3cacheable\nimport time\n\n# create a `LRU`, capacity:10 timeout:60\nc = k3cacheable.LRU(10, 60)\n\n# set value like the `dict`\nc['key'] = 'val'\n\n# get value like the `dict`\n# if item timeout, delete it and raise `KeyError`\n# if item not exist, raise `KeyError`\ntry:\n    val = c['key']\nexcept KeyError:\n    print('key error')\n\ncache_data = {\n    'key1': 'val_1',\n    'key2': 'val_2',\n}\n\n# define the function with a decorator\n@k3cacheable.cache('cache_name', capacity=100, timeout=60,\n                 is_deepcopy=False, mutex_update=False)\ndef get_data(param):\n    return cache_data.get(param, '')\n\n# call `get_data`, if item has not been cached, cache the return value\ndata = get_data('key1')\n\n# call `get_data` use the same param, data will be got from cache\ntime.sleep(1)\ndata = get_data('key1')\n\n# if item timeout, when call `get_data`, cache again\ntime.sleep(1)\ndata = get_data('key1')\n\n# define a method with a decorator\nclass MethodCache(object):\n\n    @k3cacheable.cache('method_cache_name', capacity=100, timeout=60,\n                     is_deepcopy=False, mutex_update=False)\n    def get_data(self, param):\n        return cache_data.get(param, '')\n\nmm = MethodCache()\ndata = mm.get_data('key2')\n\n```\n\n#   Author\n\nZhang Yanpo (张炎泼) <drdr.xp@gmail.com>\n\n#   Copyright and License\n\nThe MIT License (MIT)\n\nCopyright (c) 2015 Zhang Yanpo (张炎泼) <drdr.xp@gmail.com>\n\n\n[pykit3]: https://github.com/pykit3",
-    long_description_content_type="text/markdown",
-    author='Zhang Yanpo',
-    author_email='drdr.xp@gmail.com',
-    url='https://github.com/pykit3/k3cacheable',
-    keywords=['python', 'cache'],
-    python_requires='>=3.0',
-
-    install_requires=['msgpack>=1.0.0'],
-    classifiers=[
-        'Development Status :: 4 - Beta',
-        'Intended Audience :: Developers',
-        'Topic :: Software Development :: Libraries',
-    ] + ['Programming Language :: Python :: 3'],
-)