k3cacheable 0.1.2__tar.gz → 0.1.4__tar.gz

{k3cacheable-0.1.2/k3cacheable.egg-info → k3cacheable-0.1.4}/PKG-INFO

@@ -1,22 +1,22 @@
 Metadata-Version: 2.4
 Name: k3cacheable
-Version: 0.1.2
+Version: 0.1.4
 Summary: Cache data which access frequently
 Author-email: Zhang Yanpo <drdr.xp@gmail.com>
-License: MIT
+License-Expression: 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
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: msgpack
@@ -59,57 +59,57 @@ pip install k3cacheable
 # Synopsis
 
 ```python
+import time
 
 import k3cacheable
-import time
 
 # create a `LRU`, capacity:10 timeout:60
 c = k3cacheable.LRU(10, 60)
 
 # set value like the `dict`
-c['key'] = 'val'
+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']
+    val = c["key"]
 except KeyError:
-    print('key error')
+    print("key error")
 
 cache_data = {
-    'key1': 'val_1',
-    'key2': 'val_2',
+    "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)
+@k3cacheable.cache("cache_name", capacity=100, timeout=60, is_deepcopy=False, mutex_update=False)
 def get_data(param):
-    return cache_data.get(param, '')
+    return cache_data.get(param, "")
+
 
 # call `get_data`, if item has not been cached, cache the return value
-data = get_data('key1')
+data = get_data("key1")
 
 # call `get_data` use the same param, data will be got from cache
 time.sleep(1)
-data = get_data('key1')
+data = get_data("key1")
 
 # if item timeout, when call `get_data`, cache again
 time.sleep(1)
-data = get_data('key1')
+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)
+# define a method with a decorator
+class MethodCache:
+    @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, '')
+        return cache_data.get(param, "")
 
-mm = MethodCache()
-data = mm.get_data('key2')
 
+mm = MethodCache()
+data = mm.get_data("key2")
 ```
 
 #   Author

{k3cacheable-0.1.2 → k3cacheable-0.1.4}/README.md

@@ -23,57 +23,57 @@ pip install k3cacheable
 # Synopsis
 
 ```python
+import time
 
 import k3cacheable
-import time
 
 # create a `LRU`, capacity:10 timeout:60
 c = k3cacheable.LRU(10, 60)
 
 # set value like the `dict`
-c['key'] = 'val'
+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']
+    val = c["key"]
 except KeyError:
-    print('key error')
+    print("key error")
 
 cache_data = {
-    'key1': 'val_1',
-    'key2': 'val_2',
+    "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)
+@k3cacheable.cache("cache_name", capacity=100, timeout=60, is_deepcopy=False, mutex_update=False)
 def get_data(param):
-    return cache_data.get(param, '')
+    return cache_data.get(param, "")
+
 
 # call `get_data`, if item has not been cached, cache the return value
-data = get_data('key1')
+data = get_data("key1")
 
 # call `get_data` use the same param, data will be got from cache
 time.sleep(1)
-data = get_data('key1')
+data = get_data("key1")
 
 # if item timeout, when call `get_data`, cache again
 time.sleep(1)
-data = get_data('key1')
+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)
+# define a method with a decorator
+class MethodCache:
+    @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, '')
+        return cache_data.get(param, "")
 
-mm = MethodCache()
-data = mm.get_data('key2')
 
+mm = MethodCache()
+data = mm.get_data("key2")
 ```
 
 #   Author

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

@@ -1,17 +1,15 @@
-#!/usr/bin/env python
-# coding: utf-8
-
 import copy
 import logging
 import threading
 import time
+
 import msgpack
 
 logger = logging.getLogger(__name__)
 _lock_mutex_update = threading.RLock()
 
 
-class LRU(object):
+class LRU:
     """
     `LRU` contain `__getitem__` and `__setitem__`,
     so can get value and set value like `dict`
@@ -75,7 +73,7 @@ class LRU(object):
 
             if now > item["tm"] + self.timeout:
                 self._del_item(item)
-                raise KeyError("{k} is timeout".format(k=key))
+                raise KeyError(f"{key} is timeout")
 
             self._move_to_tail(item)
 
@@ -127,7 +125,7 @@ class LRU(object):
             self._del_item(item)
 
 
-class Cacheable(object):
+class Cacheable:
     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.
@@ -163,7 +161,8 @@ class Cacheable(object):
     def _cache_wrapper(self, fun):
         def func_wrapper(*args, **argkv):
             val = None
-            generate_key = self._arg_str(args, argkv)
+            # Functions that use the same cache name share one LRU, so the key includes the function.
+            generate_key = (fun, self._arg_str(args, argkv))
 
             try:
                 val = self.lru[generate_key]
@@ -229,7 +228,9 @@ def cache(name, capacity=1024 * 4, timeout=60, is_deepcopy=True, is_pack=False,
     """
     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, is_pack=is_pack, mutex_update=mutex_update
+        )
         caches[name] = c
 
     return c._cache_wrapper

{k3cacheable-0.1.2 → k3cacheable-0.1.4/k3cacheable.egg-info}/PKG-INFO

@@ -1,22 +1,22 @@
 Metadata-Version: 2.4
 Name: k3cacheable
-Version: 0.1.2
+Version: 0.1.4
 Summary: Cache data which access frequently
 Author-email: Zhang Yanpo <drdr.xp@gmail.com>
-License: MIT
+License-Expression: 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
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: msgpack
@@ -59,57 +59,57 @@ pip install k3cacheable
 # Synopsis
 
 ```python
+import time
 
 import k3cacheable
-import time
 
 # create a `LRU`, capacity:10 timeout:60
 c = k3cacheable.LRU(10, 60)
 
 # set value like the `dict`
-c['key'] = 'val'
+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']
+    val = c["key"]
 except KeyError:
-    print('key error')
+    print("key error")
 
 cache_data = {
-    'key1': 'val_1',
-    'key2': 'val_2',
+    "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)
+@k3cacheable.cache("cache_name", capacity=100, timeout=60, is_deepcopy=False, mutex_update=False)
 def get_data(param):
-    return cache_data.get(param, '')
+    return cache_data.get(param, "")
+
 
 # call `get_data`, if item has not been cached, cache the return value
-data = get_data('key1')
+data = get_data("key1")
 
 # call `get_data` use the same param, data will be got from cache
 time.sleep(1)
-data = get_data('key1')
+data = get_data("key1")
 
 # if item timeout, when call `get_data`, cache again
 time.sleep(1)
-data = get_data('key1')
+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)
+# define a method with a decorator
+class MethodCache:
+    @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, '')
+        return cache_data.get(param, "")
 
-mm = MethodCache()
-data = mm.get_data('key2')
 
+mm = MethodCache()
+data = mm.get_data("key2")
 ```
 
 #   Author

{k3cacheable-0.1.2 → k3cacheable-0.1.4}/pyproject.toml

@@ -1,14 +1,14 @@
 [build-system]
-requires = ["setuptools>=61.0"]
+requires = ["setuptools>=77.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "k3cacheable"
-version = "0.1.2"
+version = "0.1.4"
 description = "Cache data which access frequently"
 readme = "README.md"
-license = {text = "MIT"}
-requires-python = ">=3.9"
+license = "MIT"
+requires-python = ">=3.10"
 authors = [
     { name = "Zhang Yanpo", email = "drdr.xp@gmail.com" }
 ]
@@ -17,12 +17,12 @@ 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",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
     "msgpack",

{k3cacheable-0.1.2 → k3cacheable-0.1.4}/synopsis.py

@@ -1,6 +1,7 @@
-import k3cacheable
 import time
 
+import k3cacheable
+
 # create a `LRU`, capacity:10 timeout:60
 c = k3cacheable.LRU(10, 60)
 
@@ -40,7 +41,7 @@ data = get_data("key1")
 
 
 # define a method with a decorator
-class MethodCache(object):
+class MethodCache:
     @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, "")

{k3cacheable-0.1.2 → k3cacheable-0.1.4}/test/test_k3cacheable.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python
-# coding: utf-8
-
 import _thread
 import time
 import unittest
@@ -61,12 +58,12 @@ class TestLRU(unittest.TestCase):
         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)
+                lru[i] = f"val{i}"
 
             for i in range(insert_count):
                 try:
                     val = lru[i]
-                    self.assertEqual(val, "val%d" % (i))
+                    self.assertEqual(val, f"val{i}")
                     self.assertEqual(lru.tail["key"], i)
                     self.assertIn(i, exist_items)
 
@@ -118,20 +115,20 @@ class TestCacheable(unittest.TestCase):
 
     def test_get_items_from_cache(self):
         cache_items = {}
-        for key in need_cache_data.keys():
+        for key in need_cache_data:
             cache_items[key] = get_cache_data(key)
 
         time.sleep(0.1)
-        for key in need_cache_data.keys():
+        for key in need_cache_data:
             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():
+        for key in need_cache_data:
             cache_items[key] = self._method_cache_data(key)
 
         time.sleep(0.1)
-        for key in need_cache_data.keys():
+        for key in need_cache_data:
             self.assertEqual(self._method_cache_data(key), cache_items[key])
 
     def test_cache_item_timeout_and_cache_again(self):
@@ -151,6 +148,13 @@ class TestCacheable(unittest.TestCase):
     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_pack_item_from_cache(self):
+        # With `is_deepcopy=False`, only unpacking the cached msgpack bytes gives a new object on each call.
+        first = get_pack_of_cache_data("key1")
+        second = get_pack_of_cache_data("key1")
+        self.assertEqual({"key": "key1"}, first)
+        self.assertIsNot(first, second)
+
     def test_get_concurrent_update_cache_data(self):
         result = {}
 
@@ -198,12 +202,29 @@ class TestCacheable(unittest.TestCase):
         for args, argkv, expect_str in cases:
             self.assertEqual(k3cacheable.Cacheable()._arg_str(args, argkv), expect_str)
 
+    def test_functions_sharing_cache_name(self):
+        @k3cacheable.cache("shared_by_two_functions", capacity=10, timeout=60, is_deepcopy=False)
+        def get_aa(key):
+            return "aa-" + key
+
+        @k3cacheable.cache("shared_by_two_functions", capacity=10, timeout=60, is_deepcopy=False)
+        def get_bb(key):
+            return "bb-" + key
+
+        self.assertEqual("aa-k", get_aa("k"))
+        self.assertEqual("bb-k", get_bb("k"))
+
 
 @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("pack_of_cache_data", capacity=100, timeout=60, is_deepcopy=False, is_pack=True)
+def get_pack_of_cache_data(key):
+    return {"key": key}
+
+
 @k3cacheable.cache("cache_data", capacity=100, timeout=4, is_deepcopy=False)
 def get_cache_data(key):
     cache_data = need_cache_data.get(key, {})