cachier 3.1.0__py3-none-any.whl → 3.1.2__py3-none-any.whl

cachier/__init__.py

@@ -2,13 +2,17 @@ from ._version import *  # noqa: F403
 from .config import (
     disable_caching,
     enable_caching,
+    get_default_params,
     get_global_params,
+    set_default_params,
     set_global_params,
 )
 from .core import cachier
 
 __all__ = [
     "cachier",
+    "set_default_params",
+    "get_default_params",
     "set_global_params",
     "get_global_params",
     "enable_caching",

cachier/config.py

@@ -1,10 +1,10 @@
-import datetime
 import hashlib
 import os
 import pickle
 import threading
 from collections.abc import Mapping
 from dataclasses import dataclass, replace
+from datetime import datetime, timedelta
 from typing import Any, Optional, Union
 
 from ._types import Backend, HashFunc, Mongetter
@@ -27,7 +27,7 @@ class Params:
     hash_func: HashFunc = _default_hash_func
     backend: Backend = "pickle"
     mongetter: Optional[Mongetter] = None
-    stale_after: datetime.timedelta = datetime.timedelta.max
+    stale_after: timedelta = timedelta.max
     next_time: bool = False
     cache_dir: Union[str, os.PathLike] = "~/.cachier/"
     pickle_reload: bool = True
@@ -100,7 +100,8 @@ def set_global_params(**params: Mapping) -> None:
         if hasattr(cachier.config._global_params, k)
     }
     cachier.config._global_params = replace(
-        cachier.config._global_params, **valid_params
+        cachier.config._global_params,
+        **valid_params,  # type: ignore[arg-type]
     )
 
 

cachier/core.py

@@ -7,12 +7,12 @@
 # http://www.opensource.org/licenses/MIT-license
 # Copyright (c) 2016, Shay Palachy <shaypal5@gmail.com>
 
-import datetime
 import inspect
 import os
 import warnings
 from collections import OrderedDict
 from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timedelta
 from functools import wraps
 from typing import Any, Optional, Union
 from warnings import warn
@@ -107,7 +107,7 @@ def cachier(
     hash_params: Optional[HashFunc] = None,
     backend: Optional[Backend] = None,
     mongetter: Optional[Mongetter] = None,
-    stale_after: Optional[datetime.timedelta] = None,
+    stale_after: Optional[timedelta] = None,
     next_time: Optional[bool] = None,
     cache_dir: Optional[Union[str, os.PathLike]] = None,
     pickle_reload: Optional[bool] = None,
@@ -259,7 +259,7 @@ def cachier(
             _print("Entry found.")
             if _allow_none or entry.value is not None:
                 _print("Cached result found.")
-                now = datetime.datetime.now()
+                now = datetime.now()
                 if now - entry.time <= _stale_after:
                     _print("And it is fresh!")
                     return entry.value

cachier/cores/base.py

@@ -28,7 +28,11 @@ def _get_func_str(func: Callable) -> str:
 class _BaseCore:
     __metaclass__ = abc.ABCMeta
 
-    def __init__(self, hash_func: HashFunc, wait_for_calc_timeout: int):
+    def __init__(
+        self,
+        hash_func: Optional[HashFunc],
+        wait_for_calc_timeout: Optional[int],
+    ):
         self.hash_func = _update_with_defaults(hash_func, "hash_func")
         self.wait_for_calc_timeout = wait_for_calc_timeout
         self.lock = threading.RLock()

cachier/cores/memory.py

@@ -2,7 +2,7 @@
 
 import threading
 from datetime import datetime
-from typing import Any, Optional, Tuple
+from typing import Any, Dict, Optional, Tuple
 
 from .._types import HashFunc
 from ..config import CacheEntry
@@ -12,9 +12,13 @@ from .base import _BaseCore, _get_func_str
 class _MemoryCore(_BaseCore):
     """The memory core class for cachier."""
 
-    def __init__(self, hash_func: HashFunc, wait_for_calc_timeout: int):
+    def __init__(
+        self,
+        hash_func: Optional[HashFunc],
+        wait_for_calc_timeout: Optional[int],
+    ):
         super().__init__(hash_func, wait_for_calc_timeout)
-        self.cache = {}
+        self.cache: Dict[str, CacheEntry] = {}
 
     def _hash_func_key(self, key: str) -> str:
         return f"{_get_func_str(self.func)}:{key}"
@@ -79,8 +83,12 @@ class _MemoryCore(_BaseCore):
         hash_key = self._hash_func_key(key)
         with self.lock:  # pragma: no cover
             entry = self.cache[hash_key]
+            if entry is None:
+                return None
             if not entry._processing:
                 return entry.value
+        if entry._condition is None:
+            raise RuntimeError("No condition set for entry")
         entry._condition.acquire()
         entry._condition.wait()
         entry._condition.release()

cachier/cores/mongo.py

@@ -37,9 +37,9 @@ class _MongoCore(_BaseCore):
 
     def __init__(
         self,
-        hash_func: HashFunc,
-        mongetter: Mongetter,
-        wait_for_calc_timeout: int,
+        hash_func: Optional[HashFunc],
+        mongetter: Optional[Mongetter],
+        wait_for_calc_timeout: Optional[int],
     ):
         if "pymongo" not in sys.modules:
             warnings.warn(
@@ -48,7 +48,9 @@ class _MongoCore(_BaseCore):
                 stacklevel=2,
             )  # pragma: no cover
 
-        super().__init__(hash_func, wait_for_calc_timeout)
+        super().__init__(
+            hash_func=hash_func, wait_for_calc_timeout=wait_for_calc_timeout
+        )
         if mongetter is None:
             raise MissingMongetter(
                 "must specify ``mongetter`` when using the mongo core"

cachier/cores/pickle.py

@@ -9,7 +9,7 @@
 import os
 import pickle  # for local caching
 from datetime import datetime
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Optional, Tuple, Union
 
 import portalocker  # to lock on pickle cache IO
 from watchdog.events import PatternMatchingEventHandler
@@ -54,7 +54,7 @@ class _PickleCore(_BaseCore):
                     self.observer.stop()
                 # else:
                 #     print('NOT stopping observer... :(')
-            except TypeError:
+            except AttributeError:  # catching entry being None
                 self.value = None
                 self.observer.stop()
 
@@ -68,14 +68,14 @@ class _PickleCore(_BaseCore):
 
     def __init__(
         self,
-        hash_func: HashFunc,
-        pickle_reload: bool,
-        cache_dir: str,
-        separate_files: bool,
-        wait_for_calc_timeout: int,
+        hash_func: Optional[HashFunc],
+        pickle_reload: Optional[bool],
+        cache_dir: Optional[Union[str, os.PathLike]],
+        separate_files: Optional[bool],
+        wait_for_calc_timeout: Optional[int],
     ):
         super().__init__(hash_func, wait_for_calc_timeout)
-        self.cache = None
+        self._cache_dict: Dict[str, CacheEntry] = {}
         self.reload = _update_with_defaults(pickle_reload, "pickle_reload")
         self.cache_dir = os.path.expanduser(
             _update_with_defaults(cache_dir, "cache_dir")
@@ -83,6 +83,7 @@ class _PickleCore(_BaseCore):
         self.separate_files = _update_with_defaults(
             separate_files, "separate_files"
         )
+        self._cache_used_fpath = ""
 
     @property
     def cache_fname(self) -> str:
@@ -96,28 +97,52 @@ class _PickleCore(_BaseCore):
             os.path.join(os.path.realpath(self.cache_dir), self.cache_fname)
         )
 
-    def _reload_cache(self) -> None:
-        with self.lock:
-            try:
-                with portalocker.Lock(self.cache_fpath, mode="rb") as cf:
-                    self.cache = pickle.load(cf)  # noqa: S301
-            except (FileNotFoundError, EOFError):
-                self.cache = {}
+    @staticmethod
+    def _convert_legacy_cache_entry(
+        entry: Union[dict, CacheEntry],
+    ) -> CacheEntry:
+        if isinstance(entry, CacheEntry):
+            return entry
+        return CacheEntry(
+            value=entry["value"],
+            time=entry["time"],
+            stale=entry["stale"],
+            _processing=entry["being_calculated"],
+            _condition=entry.get("condition", None),
+        )
 
-    def _get_cache(self) -> Dict[str, CacheEntry]:
+    def _load_cache_dict(self) -> Dict[str, CacheEntry]:
+        try:
+            with portalocker.Lock(self.cache_fpath, mode="rb") as cf:
+                cache = pickle.load(cf)  # noqa: S301
+            self._cache_used_fpath = str(self.cache_fpath)
+        except (FileNotFoundError, EOFError):
+            cache = {}
+        return {
+            k: _PickleCore._convert_legacy_cache_entry(v)
+            for k, v in cache.items()
+        }
+
+    def get_cache_dict(self, reload: bool = False) -> Dict[str, CacheEntry]:
+        if self._cache_used_fpath != self.cache_fpath:
+            # force reload if the cache file has changed
+            # this change is dies to using different wrapped function
+            reload = True
+        if self._cache_dict and not (self.reload or reload):
+            return self._cache_dict
         with self.lock:
-            if not self.cache:
-                self._reload_cache()
-            return self.cache
+            self._cache_dict = self._load_cache_dict()
+        return self._cache_dict
 
-    def _get_cache_by_key(
+    def _load_cache_by_key(
         self, key=None, hash_str=None
-    ) -> Optional[Dict[str, CacheEntry]]:
+    ) -> Optional[CacheEntry]:
         fpath = self.cache_fpath
         fpath += f"_{hash_str or key}"
         try:
             with portalocker.Lock(fpath, mode="rb") as cache_file:
-                return pickle.load(cache_file)  # noqa: S301
+                entry = pickle.load(cache_file)  # noqa: S301
+            return _PickleCore._convert_legacy_cache_entry(entry)
         except (FileNotFoundError, EOFError):
             return None
 
@@ -131,35 +156,42 @@ class _PickleCore(_BaseCore):
         path, name = os.path.split(self.cache_fpath)
         for subpath in os.listdir(path):
             if subpath.startswith(name):
-                entry = self._get_cache_by_key(hash_str=subpath.split("_")[-1])
+                entry = self._load_cache_by_key(
+                    hash_str=subpath.split("_")[-1]
+                )
                 if entry is not None:
-                    entry.being_calculated = False
+                    entry._processing = False
                     self._save_cache(entry, hash_str=subpath.split("_")[-1])
 
     def _save_cache(
-        self, cache, key: str = None, hash_str: str = None
+        self,
+        cache: Union[Dict[str, CacheEntry], CacheEntry],
+        separate_file_key: Optional[str] = None,
+        hash_str: Optional[str] = None,
     ) -> None:
+        if separate_file_key and not isinstance(cache, CacheEntry):
+            raise ValueError(
+                "`separate_file_key` should only be used with a CacheEntry"
+            )
         fpath = self.cache_fpath
-        if key is not None:
-            fpath += f"_{key}"
+        if separate_file_key is not None:
+            fpath += f"_{separate_file_key}"
         elif hash_str is not None:
             fpath += f"_{hash_str}"
         with self.lock:
-            self.cache = cache
-            with portalocker.Lock(fpath, mode="wb") as cache_file:
-                pickle.dump(cache, cache_file, protocol=4)
-            if key is None:
-                self._reload_cache()
+            with portalocker.Lock(fpath, mode="wb") as cf:
+                pickle.dump(cache, cf, protocol=4)
+            # the same as check for separate_file, but changed for typing
+            if isinstance(cache, dict):
+                self._cache_dict = cache
+                self._cache_used_fpath = str(self.cache_fpath)
 
     def get_entry_by_key(
         self, key: str, reload: bool = False
-    ) -> Tuple[str, CacheEntry]:
-        with self.lock:
-            if self.separate_files:
-                return key, self._get_cache_by_key(key)
-            if self.reload or reload:
-                self._reload_cache()
-            return key, self._get_cache().get(key, None)
+    ) -> Tuple[str, Optional[CacheEntry]]:
+        if self.separate_files:
+            return key, self._load_cache_by_key(key)
+        return key, self.get_cache_dict(reload).get(key)
 
     def set_entry(self, key: str, func_res: Any) -> None:
         key_data = CacheEntry(
@@ -174,7 +206,7 @@ class _PickleCore(_BaseCore):
             return  # pragma: no cover
 
         with self.lock:
-            cache = self._get_cache()
+            cache = self.get_cache_dict()
             cache[key] = key_data
             self._save_cache(cache)
 
@@ -186,13 +218,15 @@ class _PickleCore(_BaseCore):
                 stale=False,
                 _processing=True,
             ),
-            key=key,
+            separate_file_key=key,
         )
 
-    def mark_entry_not_calculated_separate_files(self, key: str) -> None:
+    def _mark_entry_not_calculated_separate_files(self, key: str) -> None:
         _, entry = self.get_entry_by_key(key)
+        if entry is None:
+            return  # that's ok, we don't need an entry in that case
         entry._processing = False
-        self._save_cache(entry, key=key)
+        self._save_cache(entry, separate_file_key=key)
 
     def mark_entry_being_calculated(self, key: str) -> None:
         if self.separate_files:
@@ -200,7 +234,7 @@ class _PickleCore(_BaseCore):
             return  # pragma: no cover
 
         with self.lock:
-            cache = self._get_cache()
+            cache = self.get_cache_dict()
             if key in cache:
                 cache[key]._processing = True
             else:
@@ -214,9 +248,9 @@ class _PickleCore(_BaseCore):
 
     def mark_entry_not_calculated(self, key: str) -> None:
         if self.separate_files:
-            self.mark_entry_not_calculated_separate_files(key)
+            self._mark_entry_not_calculated_separate_files(key)
         with self.lock:
-            cache = self._get_cache()
+            cache = self.get_cache_dict()
             # that's ok, we don't need an entry in that case
             if isinstance(cache, dict) and key in cache:
                 cache[key]._processing = False
@@ -224,14 +258,13 @@ class _PickleCore(_BaseCore):
 
     def wait_on_entry_calc(self, key: str) -> Any:
         if self.separate_files:
-            entry = self._get_cache_by_key(key)
+            entry = self._load_cache_by_key(key)
             filename = f"{self.cache_fname}_{key}"
         else:
             with self.lock:
-                self._reload_cache()
-                entry = self._get_cache()[key]
+                entry = self.get_cache_dict()[key]
             filename = self.cache_fname
-        if not entry._processing:
+        if entry and not entry._processing:
             return entry.value
         event_handler = _PickleCore.CacheChangeHandler(
             filename=filename, core=self, key=key
@@ -259,7 +292,7 @@ class _PickleCore(_BaseCore):
             return  # pragma: no cover
 
         with self.lock:
-            cache = self._get_cache()
+            cache = self.get_cache_dict()
             for key in cache:
                 cache[key]._processing = False
             self._save_cache(cache)

cachier/version.info

@@ -1 +1 @@
-3.1.0
+3.1.2

{cachier-3.1.0.dist-info → cachier-3.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cachier
-Version: 3.1.0
+Version: 3.1.2
 Summary: Persistent, stale-free, local and cross-machine caching for Python functions.
 Author-email: Shay Palachy Affek <shay.palachy@gmail.com>
 License: MIT License
@@ -317,7 +317,7 @@ Cachier Cores
 Pickle Core
 -----------
 
-The default core for Cachier is pickle based, meaning each function will store its cache is a separate pickle file in the ``~/.cachier`` directory. Naturally, this kind of cache is both machine-specific and user-specific.
+The default core for Cachier is pickle based, meaning each function will store its cache in a separate pickle file in the ``~/.cachier`` directory. Naturally, this kind of cache is both machine-specific and user-specific.
 
 You can configure ``cachier`` to use another directory by providing the ``cache_dir`` parameter with the path to that directory:
 
@@ -394,7 +394,7 @@ Note, however, that ``cachier``'s in-memory core is simple, and has no monitorin
 Contributing
 ============
 
-Current maintainers are Shay Palachy Affek (`shay.palachy@gmail.com <mailto:shay.palachy@gmail.com>`_, `@shaypal5 <https://github.com/shaypal5>`_) and Judson Neer (`@lordjabez <https://github.com/lordjabez>`_); You are more than welcome to approach them for help. Contributions are very welcomed! :)
+Current maintainers are Shay Palachy Affek (`shay.palachy@gmail.com <mailto:shay.palachy@gmail.com>`_, `@shaypal5 <https://github.com/shaypal5>`_) and `Jirka Borovec <https://github.com/Borda>`_ (`@Borda <https://github.com/Borda>`_ on GitHub); You are more than welcome to approach them for help. Contributions are very welcomed! :)
 
 Installing for development
 --------------------------

cachier-3.1.2.dist-info/RECORD

@@ -0,0 +1,19 @@
+cachier/__init__.py,sha256=GZeDebG0EgWIYBmRgPhO19dMiiaam8f9Pu7cWLv3ywY,400
+cachier/__main__.py,sha256=upg-TlHs1vngKYvkjoPpl3Pvl6xOx4ut-M1mElMiAo0,443
+cachier/_types.py,sha256=EGJMiw-oCIC_cDLyzw7YC40lfo8jnD3zMmoJpA9Y8Iw,238
+cachier/_version.py,sha256=yE6UYwvdoIRpw3HmNifiGwV3fqVea5PwZj_EvyosiZ8,1079
+cachier/config.py,sha256=zp5AfhDIYsYmfQCrlQP-Jg-m6r_xIsk5tK3vPmQEhTA,3882
+cachier/core.py,sha256=x2uHH7twqNPpO09bUf5-Vfzx-G95qggmGTHPw1xkYo8,13156
+cachier/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cachier/version.info,sha256=kFNgkh5j9BnWoRHdMha_KEAvNnq5qmlETYDpdBlgDYA,6
+cachier/cores/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cachier/cores/base.py,sha256=q2QXw35UduQEFseNdwbBv1ZKPl1U25NKIX1NbC2i1U4,3682
+cachier/cores/memory.py,sha256=fsvqq9rwwmAaMBvYo-oUNAxB6UOyfBpuf8ACW_XTaU0,3572
+cachier/cores/mongo.py,sha256=tM1TJUA4UjknwOfcXF4l0DLDZb1ucUpL-dD75h7VgTA,4971
+cachier/cores/pickle.py,sha256=FgfvZWAFdWQPOo3G-L57iEV2ujEkIDH8TyGzbarsZeE,10678
+cachier-3.1.2.dist-info/LICENSE,sha256=-2WrMJkIa0gVP6YQHXXDT7ws-S3M2NEVEF4XF3K8qrY,1069
+cachier-3.1.2.dist-info/METADATA,sha256=blJgO_8gOHhLkjmMxcHyX84D_IXXCfUXPTzsZ2IScZU,20136
+cachier-3.1.2.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+cachier-3.1.2.dist-info/entry_points.txt,sha256=x4Y7t6Y0Qev_3fgG-Jv7TrsvVdJty3FnGAdkT8-_5mY,49
+cachier-3.1.2.dist-info/top_level.txt,sha256=_rW_HiJumDCch67YT-WAgzcyvKg5RiYDMZq9d-0ZpaE,8
+cachier-3.1.2.dist-info/RECORD,,

cachier-3.1.0.dist-info/RECORD

@@ -1,19 +0,0 @@
-cachier/__init__.py,sha256=ePVg3SxZQqCXDBSaNVziv5rK8ZjxWsUEAecjvP87-BY,300
-cachier/__main__.py,sha256=upg-TlHs1vngKYvkjoPpl3Pvl6xOx4ut-M1mElMiAo0,443
-cachier/_types.py,sha256=EGJMiw-oCIC_cDLyzw7YC40lfo8jnD3zMmoJpA9Y8Iw,238
-cachier/_version.py,sha256=yE6UYwvdoIRpw3HmNifiGwV3fqVea5PwZj_EvyosiZ8,1079
-cachier/config.py,sha256=KOGaXkBRgv66BexENrTMtrC_TYCeV1fA5v8l6Vj2CYI,3840
-cachier/core.py,sha256=qQa_GT8WQYD-VFcTS8a2v-Hys4_A1no-aM-d3lw1AFY,13149
-cachier/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cachier/version.info,sha256=svRNO24p-LG3PqRzXwBq_8TRmOH9nH1Q5zYVmx72NsY,6
-cachier/cores/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cachier/cores/base.py,sha256=jo69c2RMOXbTzDvqRV0UGa5UvyToipv3f62bICIII1k,3631
-cachier/cores/memory.py,sha256=SSa7qlSU_54YjNYEWrq9rxXozkMYXr5hadAZ3sz62l4,3336
-cachier/cores/mongo.py,sha256=eRG6XP55G4IcWnoMl5xtDufM1szf8FVbOIBbDH_r-Po,4887
-cachier/cores/pickle.py,sha256=20c5pg2CS6wAX1PdefCOjl-orec5w7tqEHVqNbZZv0s,9074
-cachier-3.1.0.dist-info/LICENSE,sha256=-2WrMJkIa0gVP6YQHXXDT7ws-S3M2NEVEF4XF3K8qrY,1069
-cachier-3.1.0.dist-info/METADATA,sha256=pDqPoWSFSkwdCHUQ-kvEzf517DippyuSaf9kDWkUtas,20102
-cachier-3.1.0.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-cachier-3.1.0.dist-info/entry_points.txt,sha256=x4Y7t6Y0Qev_3fgG-Jv7TrsvVdJty3FnGAdkT8-_5mY,49
-cachier-3.1.0.dist-info/top_level.txt,sha256=_rW_HiJumDCch67YT-WAgzcyvKg5RiYDMZq9d-0ZpaE,8
-cachier-3.1.0.dist-info/RECORD,,