cachier 2.3.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

cachier/__init__.py

@@ -1,11 +1,11 @@
 from ._version import *  # noqa: F403
-from .core import (
-    cachier,
+from .config import (
     disable_caching,
     enable_caching,
     get_default_params,
     set_default_params,
 )
+from .core import cachier
 
 __all__ = [
     "cachier",

cachier/__main__.py

@@ -7,7 +7,7 @@ from cachier.core import _set_max_workers
 
 @click.group()
 def cli():
-    """A command-line interface for cachier."""
+    """A command-line interface for cachier."""  # noqa: D401
 
 
 @cli.command("Limits the number of worker threads used by cachier.")

cachier/_types.py

@@ -0,0 +1,9 @@
+from typing import TYPE_CHECKING, Callable, Literal
+
+if TYPE_CHECKING:
+    import pymongo.collection
+
+
+HashFunc = Callable[..., str]
+Mongetter = Callable[[], "pymongo.collection.Collection"]
+Backend = Literal["pickle", "mongo", "memory"]

cachier/config.py

@@ -0,0 +1,103 @@
+import datetime
+import hashlib
+import os
+import pickle
+from typing import Optional, TypedDict, Union
+
+from ._types import Backend, HashFunc, Mongetter
+
+
+def _default_hash_func(args, kwds):
+    # Sort the kwargs to ensure consistent ordering
+    sorted_kwargs = sorted(kwds.items())
+    # Serialize args and sorted_kwargs using pickle or similar
+    serialized = pickle.dumps((args, sorted_kwargs))
+    # Create a hash of the serialized data
+    return hashlib.sha256(serialized).hexdigest()
+
+
+class Params(TypedDict):
+    """Type definition for cachier parameters."""
+
+    caching_enabled: bool
+    hash_func: HashFunc
+    backend: Backend
+    mongetter: Optional[Mongetter]
+    stale_after: datetime.timedelta
+    next_time: bool
+    cache_dir: Union[str, os.PathLike]
+    pickle_reload: bool
+    separate_files: bool
+    wait_for_calc_timeout: int
+    allow_none: bool
+
+
+_default_params: Params = {
+    "caching_enabled": True,
+    "hash_func": _default_hash_func,
+    "backend": "pickle",
+    "mongetter": None,
+    "stale_after": datetime.timedelta.max,
+    "next_time": False,
+    "cache_dir": "~/.cachier/",
+    "pickle_reload": True,
+    "separate_files": False,
+    "wait_for_calc_timeout": 0,
+    "allow_none": False,
+}
+
+
+def _update_with_defaults(
+    param, name: str, func_kwargs: Optional[dict] = None
+):
+    import cachier
+
+    if func_kwargs:
+        kw_name = f"cachier__{name}"
+        if kw_name in func_kwargs:
+            return func_kwargs.pop(kw_name)
+    if param is None:
+        return cachier.config._default_params[name]
+    return param
+
+
+def set_default_params(**params):
+    """Configure global parameters applicable to all memoized functions.
+
+    This function takes the same keyword parameters as the ones defined in the
+    decorator, which can be passed all at once or with multiple calls.
+    Parameters given directly to a decorator take precedence over any values
+    set by this function.
+
+    Only 'stale_after', 'next_time', and 'wait_for_calc_timeout' can be changed
+    after the memoization decorator has been applied. Other parameters will
+    only have an effect on decorators applied after this function is run.
+
+    """
+    import cachier
+
+    valid_params = (
+        p for p in params.items() if p[0] in cachier.config._default_params
+    )
+    _default_params.update(valid_params)
+
+
+def get_default_params():
+    """Get current set of default parameters."""
+    import cachier
+
+    return cachier.config._default_params
+
+
+def enable_caching():
+    """Enable caching globally."""
+    import cachier
+
+    cachier.config._default_params["caching_enabled"] = True
+
+
+def disable_caching():
+    """Disable caching globally."""
+    import cachier
+
+    cachier.config._default_params["caching_enabled"] = False

cachier/core.py

@@ -7,28 +7,28 @@
 # http://www.opensource.org/licenses/MIT-license
 # Copyright (c) 2016, Shay Palachy <shaypal5@gmail.com>
 
-# python 2 compatibility
-
 import datetime
-import hashlib
 import inspect
 import os
-import pickle
+import warnings
 from collections import OrderedDict
 from concurrent.futures import ThreadPoolExecutor
 from functools import wraps
-from typing import TYPE_CHECKING, Callable, Literal, Optional, TypedDict, Union
+from typing import Optional, Union
 from warnings import warn
 
+from .config import (
+    Backend,
+    HashFunc,
+    Mongetter,
+    _default_params,
+    _update_with_defaults,
+)
 from .cores.base import RecalculationNeeded, _BaseCore
 from .cores.memory import _MemoryCore
 from .cores.mongo import _MongoCore
 from .cores.pickle import _PickleCore
 
-if TYPE_CHECKING:
-    import pymongo.collection
-
-
 MAX_WORKERS_ENVAR_NAME = "CACHIER_MAX_WORKERS"
 DEFAULT_MAX_WORKERS = 8
 
@@ -68,15 +68,6 @@ def _calc_entry(core, key, func, args, kwds):
         core.mark_entry_not_calculated(key)
 
 
-def _default_hash_func(args, kwds):
-    # Sort the kwargs to ensure consistent ordering
-    sorted_kwargs = sorted(kwds.items())
-    # Serialize args and sorted_kwargs using pickle or similar
-    serialized = pickle.dumps((args, sorted_kwargs))
-    # Create a hash of the serialized data
-    return hashlib.sha256(serialized).hexdigest()
-
-
 def _convert_args_kwargs(
     func, _is_method: bool, args: tuple, kwds: dict
 ) -> dict:
@@ -84,7 +75,7 @@ def _convert_args_kwargs(
     # unwrap if the function is functools.partial
     if hasattr(func, "func"):
         args = func.args + args
-        kwds = dict(**func.keywords, **kwds)
+        kwds.update({k: v for k, v in func.keywords.items() if k not in kwds})
         func = func.func
     func_params = list(inspect.signature(func).parameters)
     args_as_kw = dict(
@@ -103,42 +94,15 @@ def _convert_args_kwargs(
     return OrderedDict(sorted(kwargs.items()))
 
 
-class MissingMongetter(ValueError):
-    """Thrown when the mongetter keyword argument is missing."""
-
-
-HashFunc = Callable[..., str]
-Mongetter = Callable[[], "pymongo.collection.Collection"]
-Backend = Literal["pickle", "mongo", "memory"]
-
-
-class Params(TypedDict):
-    caching_enabled: bool
-    hash_func: HashFunc
-    backend: Backend
-    mongetter: Optional[Mongetter]
-    stale_after: datetime.timedelta
-    next_time: bool
-    cache_dir: Union[str, os.PathLike]
-    pickle_reload: bool
-    separate_files: bool
-    wait_for_calc_timeout: int
-    allow_none: bool
-
-
-_default_params: Params = {
-    "caching_enabled": True,
-    "hash_func": _default_hash_func,
-    "backend": "pickle",
-    "mongetter": None,
-    "stale_after": datetime.timedelta.max,
-    "next_time": False,
-    "cache_dir": "~/.cachier/",
-    "pickle_reload": True,
-    "separate_files": False,
-    "wait_for_calc_timeout": 0,
-    "allow_none": False,
-}
+def _pop_kwds_with_deprecation(kwds, name: str, default_value: bool):
+    if name in kwds:
+        warnings.warn(
+            f"`{name}` is deprecated and will be removed in a future release,"
+            " use `cachier__` alternative instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+    return kwds.pop(name, default_value)
 
 
 def cachier(
@@ -154,7 +118,7 @@ def cachier(
     wait_for_calc_timeout: Optional[int] = None,
     allow_none: Optional[bool] = None,
 ):
-    """A persistent, stale-free memoization decorator.
+    """Wrap as a persistent, stale-free memoization decorator.
 
     The positional and keyword arguments to the wrapped function must be
     hashable (i.e. Python's immutable built-in objects, not mutable
@@ -163,13 +127,14 @@ def cachier(
     value is their id), equal objects across different sessions will not yield
     identical keys.
 
-    Arguments
+    Arguments:
     ---------
     hash_func : callable, optional
         A callable that gets the args and kwargs from the decorated function
         and returns a hash key for them. This parameter can be used to enable
         the use of cachier with functions that get arguments that are not
         automatically hashable by Python.
+    hash_params : callable, optional
     backend : str, optional
         The name of the backend to use. Valid options currently include
         'pickle', 'mongo' and 'memory'. If not provided, defaults to
@@ -219,13 +184,12 @@ def cachier(
         )
         warn(message, DeprecationWarning, stacklevel=2)
         hash_func = hash_params
+    # Update parameters with defaults if input is None
+    backend = _update_with_defaults(backend, "backend")
+    mongetter = _update_with_defaults(mongetter, "mongetter")
     # Override the backend parameter if a mongetter is provided.
-    if mongetter is None:
-        mongetter = _default_params["mongetter"]
     if callable(mongetter):
         backend = "mongo"
-    if backend is None:
-        backend = _default_params["backend"]
     core: _BaseCore
     if backend == "pickle":
         core = _PickleCore(
@@ -234,23 +198,16 @@ def cachier(
             cache_dir=cache_dir,
             separate_files=separate_files,
             wait_for_calc_timeout=wait_for_calc_timeout,
-            default_params=_default_params,
         )
     elif backend == "mongo":
-        if mongetter is None:
-            raise MissingMongetter(
-                "must specify ``mongetter`` when using the mongo core"
-            )
         core = _MongoCore(
-            mongetter=mongetter,
             hash_func=hash_func,
+            mongetter=mongetter,
             wait_for_calc_timeout=wait_for_calc_timeout,
-            default_params=_default_params,
         )
     elif backend == "memory":
         core = _MemoryCore(
-            hash_func=hash_func,
-            default_params=_default_params,
+            hash_func=hash_func, wait_for_calc_timeout=wait_for_calc_timeout
         )
     else:
         raise ValueError("specified an invalid core: %s" % backend)
@@ -261,26 +218,39 @@ def cachier(
         @wraps(func)
         def func_wrapper(*args, **kwds):
             nonlocal allow_none
-            _allow_none = (
-                allow_none
-                if allow_none is not None
-                else _default_params["allow_none"]
-            )
+            _allow_none = _update_with_defaults(allow_none, "allow_none", kwds)
             # print('Inside general wrapper for {}.'.format(func.__name__))
-            ignore_cache = kwds.pop("ignore_cache", False)
-            overwrite_cache = kwds.pop("overwrite_cache", False)
-            verbose_cache = kwds.pop("verbose_cache", False)
+            ignore_cache = _pop_kwds_with_deprecation(
+                kwds, "ignore_cache", False
+            )
+            overwrite_cache = _pop_kwds_with_deprecation(
+                kwds, "overwrite_cache", False
+            )
+            verbose = _pop_kwds_with_deprecation(kwds, "verbose_cache", False)
+            ignore_cache = kwds.pop("cachier__skip_cache", ignore_cache)
+            overwrite_cache = kwds.pop(
+                "cachier__overwrite_cache", overwrite_cache
+            )
+            verbose = kwds.pop("cachier__verbose", verbose)
+            _stale_after = _update_with_defaults(
+                stale_after, "stale_after", kwds
+            )
+            _next_time = _update_with_defaults(next_time, "next_time", kwds)
             # merge args expanded as kwargs and the original kwds
             kwargs = _convert_args_kwargs(
                 func, _is_method=core.func_is_method, args=args, kwds=kwds
             )
 
             _print = lambda x: None  # noqa: E731
-            if verbose_cache:
+            if verbose:
                 _print = print
             if ignore_cache or not _default_params["caching_enabled"]:
-                return func(**kwargs)
-            key, entry = core.get_entry(tuple(), kwargs)
+                return (
+                    func(args[0], **kwargs)
+                    if core.func_is_method
+                    else func(**kwargs)
+                )
+            key, entry = core.get_entry((), kwargs)
             if overwrite_cache:
                 return _calc_entry(core, key, func, args, kwds)
             if entry is None:
@@ -289,17 +259,13 @@ def cachier(
             _print("Entry found.")
             if _allow_none or entry.get("value", None) is not None:
                 _print("Cached result found.")
-                local_stale_after = (
-                    stale_after or _default_params["stale_after"]
-                )
-                local_next_time = next_time or _default_params["next_time"]  # noqa: E501
                 now = datetime.datetime.now()
-                if now - entry["time"] <= local_stale_after:
+                if now - entry["time"] <= _stale_after:
                     _print("And it is fresh!")
                     return entry["value"]
                 _print("But it is stale... :(")
                 if entry["being_calculated"]:
-                    if local_next_time:
+                    if _next_time:
                         _print("Returning stale.")
                         return entry["value"]  # return stale val
                     _print("Already calc. Waiting on change.")
@@ -307,7 +273,7 @@ def cachier(
                         return core.wait_on_entry_calc(key)
                     except RecalculationNeeded:
                         return _calc_entry(core, key, func, args, kwds)
-                if local_next_time:
+                if _next_time:
                     _print("Async calc and return stale")
                     try:
                         core.mark_entry_being_calculated(key)
@@ -328,22 +294,22 @@ def cachier(
             _print("No entry found. No current calc. Calling like a boss.")
             return _calc_entry(core, key, func, args, kwds)
 
-        def clear_cache():
+        def _clear_cache():
             """Clear the cache."""
             core.clear_cache()
 
-        def clear_being_calculated():
-            """Marks all entries in this cache as not being calculated."""
+        def _clear_being_calculated():
+            """Mark all entries in this cache as not being calculated."""
             core.clear_being_calculated()
 
-        def cache_dpath():
-            """Returns the path to the cache dir, if exists; None if not."""
+        def _cache_dpath():
+            """Return the path to the cache dir, if exists; None if not."""
             return getattr(core, "cache_dir", None)
 
-        def precache_value(*args, value_to_cache, **kwds):
+        def _precache_value(*args, value_to_cache, **kwds):  # noqa: D417
             """Add an initial value to the cache.
 
-            Arguments
+            Arguments:
             ---------
             value_to_cache : any
                 entry to be written into the cache
@@ -353,44 +319,12 @@ def cachier(
             kwargs = _convert_args_kwargs(
                 func, _is_method=core.func_is_method, args=args, kwds=kwds
             )
-            return core.precache_value(tuple(), kwargs, value_to_cache)
+            return core.precache_value((), kwargs, value_to_cache)
 
-        func_wrapper.clear_cache = clear_cache
-        func_wrapper.clear_being_calculated = clear_being_calculated
-        func_wrapper.cache_dpath = cache_dpath
-        func_wrapper.precache_value = precache_value
+        func_wrapper.clear_cache = _clear_cache
+        func_wrapper.clear_being_calculated = _clear_being_calculated
+        func_wrapper.cache_dpath = _cache_dpath
+        func_wrapper.precache_value = _precache_value
         return func_wrapper
 
     return _cachier_decorator
-
-
-def set_default_params(**params):
-    """Configure global parameters applicable to all memoized functions.
-
-    This function takes the same keyword parameters as the ones defined in the
-    decorator, which can be passed all at once or with multiple calls.
-    Parameters given directly to a decorator take precedence over any values
-    set by this function.
-
-    Only 'stale_after', 'next_time', and 'wait_for_calc_timeout' can be changed
-    after the memoization decorator has been applied. Other parameters will
-    only have an effect on decorators applied after this function is run.
-
-    """
-    valid_params = (p for p in params.items() if p[0] in _default_params)
-    _default_params.update(valid_params)
-
-
-def get_default_params():
-    """Get current set of default parameters."""
-    return _default_params
-
-
-def enable_caching():
-    """Enable caching globally."""
-    _default_params["caching_enabled"] = True
-
-
-def disable_caching():
-    """Disable caching globally."""
-    _default_params["caching_enabled"] = False

cachier/cores/base.py

@@ -8,21 +8,33 @@
 
 import abc  # for the _BaseCore abstract base class
 import inspect
+import threading
+from typing import Callable
+
+from .._types import HashFunc
+from ..config import _update_with_defaults
 
 
 class RecalculationNeeded(Exception):
+    """Exception raised when a recalculation is needed."""
+
     pass
 
 
+def _get_func_str(func: Callable) -> str:
+    return f".{func.__module__}.{func.__name__}"
+
+
 class _BaseCore:
     __metaclass__ = abc.ABCMeta
 
-    def __init__(self, hash_func, default_params):
-        self.default_params = default_params
-        self.hash_func = hash_func
+    def __init__(self, hash_func: HashFunc, wait_for_calc_timeout: int):
+        self.hash_func = _update_with_defaults(hash_func, "hash_func")
+        self.wait_for_calc_timeout = wait_for_calc_timeout
+        self.lock = threading.RLock()
 
     def set_func(self, func):
-        """Sets the function this core will use.
+        """Set the function this core will use.
 
         This has to be set before any method is called. Also determine if the
         function is an object method.
@@ -36,59 +48,62 @@ class _BaseCore:
         self.func = func
 
     def get_key(self, args, kwds):
-        """Returns a unique key based on the arguments provided."""
-        if self.hash_func is not None:
-            return self.hash_func(args, kwds)
-        else:
-            return self.default_params["hash_func"](args, kwds)
+        """Return a unique key based on the arguments provided."""
+        return self.hash_func(args, kwds)
 
     def get_entry(self, args, kwds):
-        """Returns the result mapped to the given arguments in this core's
-        cache, if such a mapping exists."""
+        """Get entry based on given arguments.
+
+        Return the result mapped to the given arguments in this core's cache,
+        if such a mapping exists.
+
+        """
         key = self.get_key(args, kwds)
         return self.get_entry_by_key(key)
 
     def precache_value(self, args, kwds, value_to_cache):
-        """Writes a precomputed value into the cache."""
+        """Write a precomputed value into the cache."""
         key = self.get_key(args, kwds)
         self.set_entry(key, value_to_cache)
         return value_to_cache
 
     def check_calc_timeout(self, time_spent):
         """Raise an exception if a recalculation is needed."""
-        if self.wait_for_calc_timeout is not None:
-            calc_timeout = self.wait_for_calc_timeout
-        else:
-            calc_timeout = self.default_params["wait_for_calc_timeout"]
+        calc_timeout = _update_with_defaults(
+            self.wait_for_calc_timeout, "wait_for_calc_timeout"
+        )
         if calc_timeout > 0 and (time_spent >= calc_timeout):
             raise RecalculationNeeded()
 
     @abc.abstractmethod
     def get_entry_by_key(self, key):
-        """Returns the result mapped to the given key in this core's cache, if
-        such a mapping exists."""
+        """Get entry based on given key.
+
+        Return the result mapped to the given key in this core's cache, if such
+        a mapping exists.
+
+        """
 
     @abc.abstractmethod
     def set_entry(self, key, func_res):
-        """Maps the given result to the given key in this core's cache."""
+        """Map the given result to the given key in this core's cache."""
 
     @abc.abstractmethod
     def mark_entry_being_calculated(self, key):
-        """Marks the entry mapped by the given key as being calculated."""
+        """Mark the entry mapped by the given key as being calculated."""
 
     @abc.abstractmethod
     def mark_entry_not_calculated(self, key):
-        """Marks the entry mapped by the given key as not being calculated."""
+        """Mark the entry mapped by the given key as not being calculated."""
 
     @abc.abstractmethod
     def wait_on_entry_calc(self, key):
-        """Waits on the entry mapped by key being calculated and returns
-        result."""
+        """Wait on the entry with keys being calculated and returns result."""
 
     @abc.abstractmethod
     def clear_cache(self):
-        """Clears the cache of this core."""
+        """Clear the cache of this core."""
 
     @abc.abstractmethod
     def clear_being_calculated(self):
-        """Marks all entries in this cache as not being calculated."""
+        """Mark all entries in this cache as not being calculated."""

cachier/cores/memory.py

@@ -3,20 +3,23 @@
 import threading
 from datetime import datetime
 
-from .base import _BaseCore
+from .._types import HashFunc
+from .base import _BaseCore, _get_func_str
 
 
 class _MemoryCore(_BaseCore):
     """The memory core class for cachier."""
 
-    def __init__(self, hash_func, default_params):
-        super().__init__(hash_func, default_params)
+    def __init__(self, hash_func: HashFunc, wait_for_calc_timeout: int):
+        super().__init__(hash_func, wait_for_calc_timeout)
         self.cache = {}
-        self.lock = threading.RLock()
+
+    def _hash_func_key(self, key):
+        return f"{_get_func_str(self.func)}:{key}"
 
     def get_entry_by_key(self, key, reload=False):
         with self.lock:
-            return key, self.cache.get(key, None)
+            return key, self.cache.get(self._hash_func_key(key), None)
 
     def set_entry(self, key, func_res):
         with self.lock:
@@ -24,10 +27,10 @@ class _MemoryCore(_BaseCore):
                 # we need to retain the existing condition so that
                 # mark_entry_not_calculated can notify all possibly-waiting
                 # threads about it
-                cond = self.cache[key]["condition"]
+                cond = self.cache[self._hash_func_key(key)]["condition"]
             except KeyError:  # pragma: no cover
                 cond = None
-            self.cache[key] = {
+            self.cache[self._hash_func_key(key)] = {
                 "value": func_res,
                 "time": datetime.now(),
                 "stale": False,
@@ -40,10 +43,10 @@ class _MemoryCore(_BaseCore):
             condition = threading.Condition()
             # condition.acquire()
             try:
-                self.cache[key]["being_calculated"] = True
-                self.cache[key]["condition"] = condition
+                self.cache[self._hash_func_key(key)]["being_calculated"] = True
+                self.cache[self._hash_func_key(key)]["condition"] = condition
             except KeyError:
-                self.cache[key] = {
+                self.cache[self._hash_func_key(key)] = {
                     "value": None,
                     "time": datetime.now(),
                     "stale": False,
@@ -54,7 +57,7 @@ class _MemoryCore(_BaseCore):
     def mark_entry_not_calculated(self, key):
         with self.lock:
             try:
-                entry = self.cache[key]
+                entry = self.cache[self._hash_func_key(key)]
             except KeyError:  # pragma: no cover
                 return  # that's ok, we don't need an entry in that case
             entry["being_calculated"] = False
@@ -67,13 +70,13 @@ class _MemoryCore(_BaseCore):
 
     def wait_on_entry_calc(self, key):
         with self.lock:  # pragma: no cover
-            entry = self.cache[key]
+            entry = self.cache[self._hash_func_key(key)]
             if not entry["being_calculated"]:
                 return entry["value"]
         entry["condition"].acquire()
         entry["condition"].wait()
         entry["condition"].release()
-        return self.cache[key]["value"]
+        return self.cache[self._hash_func_key(key)]["value"]
 
     def clear_cache(self):
         with self.lock:

cachier/cores/mongo.py

@@ -14,31 +14,45 @@ import warnings  # to warn if pymongo is missing
 from contextlib import suppress
 from datetime import datetime
 
+from .._types import HashFunc, Mongetter
+
 with suppress(ImportError):
     from bson.binary import Binary  # to save binary data to mongodb
     from pymongo import ASCENDING, IndexModel
     from pymongo.errors import OperationFailure
 
-from .base import RecalculationNeeded, _BaseCore
+from .base import RecalculationNeeded, _BaseCore, _get_func_str
 
 MONGO_SLEEP_DURATION_IN_SEC = 1
 
 
+class MissingMongetter(ValueError):
+    """Thrown when the mongetter keyword argument is missing."""
+
+
 class _MongoCore(_BaseCore):
     _INDEX_NAME = "func_1_key_1"
 
     def __init__(
-        self, mongetter, hash_func, wait_for_calc_timeout, default_params
+        self,
+        hash_func: HashFunc,
+        mongetter: Mongetter,
+        wait_for_calc_timeout: int,
     ):
         if "pymongo" not in sys.modules:
             warnings.warn(
-                "Cachier warning: pymongo was not found. "
-                "MongoDB cores will not function."
+                "`pymongo` was not found. MongoDB cores will not function.",
+                ImportWarning,
+                stacklevel=2,
             )  # pragma: no cover
-        super().__init__(hash_func, default_params)
+
+        super().__init__(hash_func, wait_for_calc_timeout)
+        if mongetter is None:
+            raise MissingMongetter(
+                "must specify ``mongetter`` when using the mongo core"
+            )
         self.mongetter = mongetter
         self.mongo_collection = self.mongetter()
-        self.wait_for_calc_timeout = wait_for_calc_timeout
         index_inf = self.mongo_collection.index_information()
         if _MongoCore._INDEX_NAME not in index_inf:
             func1key1 = IndexModel(
@@ -47,39 +61,39 @@ class _MongoCore(_BaseCore):
             )
             self.mongo_collection.create_indexes([func1key1])
 
-    @staticmethod
-    def _get_func_str(func):
-        return f".{func.__module__}.{func.__name__}"
+    @property
+    def _func_str(self) -> str:
+        return _get_func_str(self.func)
 
     def get_entry_by_key(self, key):
         res = self.mongo_collection.find_one(
-            {"func": _MongoCore._get_func_str(self.func), "key": key}
+            {"func": self._func_str, "key": key}
         )
-        if res:
-            try:
-                entry = {
-                    "value": pickle.loads(res["value"]),  # noqa: S301
-                    "time": res.get("time", None),
-                    "stale": res.get("stale", False),
-                    "being_calculated": res.get("being_calculated", False),
-                }
-            except KeyError:
-                entry = {
-                    "value": None,
-                    "time": res.get("time", None),
-                    "stale": res.get("stale", False),
-                    "being_calculated": res.get("being_calculated", False),
-                }
-            return key, entry
-        return key, None
+        if not res:
+            return key, None
+        try:
+            entry = {
+                "value": pickle.loads(res["value"]),  # noqa: S301
+                "time": res.get("time", None),
+                "stale": res.get("stale", False),
+                "being_calculated": res.get("being_calculated", False),
+            }
+        except KeyError:
+            entry = {
+                "value": None,
+                "time": res.get("time", None),
+                "stale": res.get("stale", False),
+                "being_calculated": res.get("being_calculated", False),
+            }
+        return key, entry
 
     def set_entry(self, key, func_res):
         thebytes = pickle.dumps(func_res)
         self.mongo_collection.update_one(
-            filter={"func": _MongoCore._get_func_str(self.func), "key": key},
+            filter={"func": self._func_str, "key": key},
             update={
                 "$set": {
-                    "func": _MongoCore._get_func_str(self.func),
+                    "func": self._func_str,
                     "key": key,
                     "value": Binary(thebytes),
                     "time": datetime.now(),
@@ -92,7 +106,7 @@ class _MongoCore(_BaseCore):
 
     def mark_entry_being_calculated(self, key):
         self.mongo_collection.update_one(
-            filter={"func": _MongoCore._get_func_str(self.func), "key": key},
+            filter={"func": self._func_str, "key": key},
             update={"$set": {"being_calculated": True}},
             upsert=True,
         )
@@ -101,7 +115,7 @@ class _MongoCore(_BaseCore):
         with suppress(OperationFailure):  # don't care in this case
             self.mongo_collection.update_one(
                 filter={
-                    "func": _MongoCore._get_func_str(self.func),
+                    "func": self._func_str,
                     "key": key,
                 },
                 update={"$set": {"being_calculated": False}},
@@ -121,14 +135,12 @@ class _MongoCore(_BaseCore):
             self.check_calc_timeout(time_spent)
 
     def clear_cache(self):
-        self.mongo_collection.delete_many(
-            filter={"func": _MongoCore._get_func_str(self.func)}
-        )
+        self.mongo_collection.delete_many(filter={"func": self._func_str})
 
     def clear_being_calculated(self):
         self.mongo_collection.update_many(
             filter={
-                "func": _MongoCore._get_func_str(self.func),
+                "func": self._func_str,
                 "being_calculated": True,
             },
             update={"$set": {"being_calculated": False}},

cachier/cores/pickle.py

@@ -8,7 +8,6 @@
 # Copyright (c) 2016, Shay Palachy <shaypal5@gmail.com>
 import os
 import pickle  # for local caching
-import threading
 from contextlib import suppress
 from datetime import datetime
 
@@ -16,21 +15,15 @@ import portalocker  # to lock on pickle cache IO
 from watchdog.events import PatternMatchingEventHandler
 from watchdog.observers import Observer
 
+from .._types import HashFunc
+from ..config import _update_with_defaults
+
 # Alternative:  https://github.com/WoLpH/portalocker
 from .base import _BaseCore
 
 
 class _PickleCore(_BaseCore):
-    """The pickle core class for cachier.
-
-    Parameters
-    ----------
-    pickle_reload : bool, optional
-        See core.cachier() documentation.
-    cache_dir : str, optional.
-        See core.cachier() documentation.
-
-    """
+    """The pickle core class for cachier."""
 
     class CacheChangeHandler(PatternMatchingEventHandler):
         """Handles cache-file modification events."""
@@ -69,75 +62,51 @@ class _PickleCore(_BaseCore):
                 self.observer.stop()
 
         def on_created(self, event):
-            """A Watchdog Event Handler method."""
+            """A Watchdog Event Handler method."""  # noqa: D401
             self._check_calculation()  # pragma: no cover
 
         def on_modified(self, event):
-            """A Watchdog Event Handler method."""
+            """A Watchdog Event Handler method."""  # noqa: D401
             self._check_calculation()
 
     def __init__(
         self,
-        hash_func,
-        pickle_reload,
-        cache_dir,
-        separate_files,
-        wait_for_calc_timeout,
-        default_params,
+        hash_func: HashFunc,
+        pickle_reload: bool,
+        cache_dir: str,
+        separate_files: bool,
+        wait_for_calc_timeout: int,
     ):
-        super().__init__(hash_func, default_params)
+        super().__init__(hash_func, wait_for_calc_timeout)
         self.cache = None
-        if pickle_reload is not None:
-            self.reload = pickle_reload
-        else:
-            self.reload = self.default_params["pickle_reload"]
-        if cache_dir is not None:
-            self.cache_dir = os.path.expanduser(cache_dir)
-        else:
-            self.cache_dir = os.path.expanduser(
-                self.default_params["cache_dir"]
-            )
-        if separate_files is not None:
-            self.separate_files = separate_files
-        else:
-            self.separate_files = self.default_params["separate_files"]
-        self.wait_for_calc_timeout = wait_for_calc_timeout
-        self.cache_fname = None
-        self.cache_fpath = None
-        self.lock = threading.RLock()
-
-    def _cache_fname(self):
-        if self.cache_fname is None:
-            self.cache_fname = (
-                f".{self.func.__module__}.{self.func.__qualname__}"
-            )
-            self.cache_fname = self.cache_fname.replace("<", "_").replace(
-                ">", "_"
-            )
-        return self.cache_fname
-
-    def _cache_fpath(self):
-        if self.cache_fpath is None:
-            if not os.path.exists(self.cache_dir):
-                os.makedirs(self.cache_dir)
-            self.cache_fpath = os.path.abspath(
-                os.path.join(
-                    os.path.realpath(self.cache_dir),
-                    self._cache_fname(),
-                )
-            )
-        return self.cache_fpath
+        self.reload = _update_with_defaults(pickle_reload, "pickle_reload")
+        self.cache_dir = os.path.expanduser(
+            _update_with_defaults(cache_dir, "cache_dir")
+        )
+        self.separate_files = _update_with_defaults(
+            separate_files, "separate_files"
+        )
+
+    @property
+    def cache_fname(self) -> str:
+        fname = f".{self.func.__module__}.{self.func.__qualname__}"
+        return fname.replace("<", "_").replace(">", "_")
+
+    @property
+    def cache_fpath(self) -> str:
+        os.makedirs(self.cache_dir, exist_ok=True)
+        return os.path.abspath(
+            os.path.join(os.path.realpath(self.cache_dir), self.cache_fname)
+        )
 
     def _reload_cache(self):
         with self.lock:
-            fpath = self._cache_fpath()
             try:
-                with portalocker.Lock(fpath, mode="rb") as cache_file:
-                    try:
-                        self.cache = pickle.load(cache_file)  # noqa: S301
-                    except EOFError:
-                        self.cache = {}
-            except FileNotFoundError:
+                with portalocker.Lock(
+                    self.cache_fpath, mode="rb"
+                ) as cache_file:
+                    self.cache = pickle.load(cache_file)  # noqa: S301
+            except (FileNotFoundError, EOFError):
                 self.cache = {}
 
     def _get_cache(self):
@@ -146,9 +115,9 @@ class _PickleCore(_BaseCore):
                 self._reload_cache()
             return self.cache
 
-    def _get_cache_by_key(self, key=None, hash=None):
-        fpath = self._cache_fpath()
-        fpath += f"_{key}" if hash is None else f"_{hash}"
+    def _get_cache_by_key(self, key=None, hash_str=None):
+        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
@@ -156,30 +125,28 @@ class _PickleCore(_BaseCore):
             return None
 
     def _clear_all_cache_files(self):
-        fpath = self._cache_fpath()
-        path, name = os.path.split(fpath)
+        path, name = os.path.split(self.cache_fpath)
         for subpath in os.listdir(path):
             if subpath.startswith(f"{name}_"):
                 os.remove(os.path.join(path, subpath))
 
     def _clear_being_calculated_all_cache_files(self):
-        fpath = self._cache_fpath()
-        path, name = os.path.split(fpath)
+        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=subpath.split("_")[-1])
+                entry = self._get_cache_by_key(hash_str=subpath.split("_")[-1])
                 if entry is not None:
                     entry["being_calculated"] = False
-                    self._save_cache(entry, hash=subpath.split("_")[-1])
-
-    def _save_cache(self, cache, key=None, hash=None):
+                    self._save_cache(entry, hash_str=subpath.split("_")[-1])
+
+    def _save_cache(self, cache, key=None, hash_str=None):
+        fpath = self.cache_fpath
+        if key is not None:
+            fpath += f"_{key}"
+        elif hash_str is not None:
+            fpath += f"_{hash_str}"
         with self.lock:
             self.cache = cache
-            fpath = self._cache_fpath()
-            if key is not None:
-                fpath += f"_{key}"
-            elif hash is not None:
-                fpath += f"_{hash}"
             with portalocker.Lock(fpath, mode="wb") as cache_file:
                 pickle.dump(cache, cache_file, protocol=4)
             if key is None:
@@ -202,11 +169,12 @@ class _PickleCore(_BaseCore):
         }
         if self.separate_files:
             self._save_cache(key_data, key)
-        else:
-            with self.lock:
-                cache = self._get_cache()
-                cache[key] = key_data
-                self._save_cache(cache)
+            return  # pragma: no cover
+
+        with self.lock:
+            cache = self._get_cache()
+            cache[key] = key_data
+            self._save_cache(cache)
 
     def mark_entry_being_calculated_separate_files(self, key):
         self._save_cache(
@@ -227,19 +195,20 @@ class _PickleCore(_BaseCore):
     def mark_entry_being_calculated(self, key):
         if self.separate_files:
             self.mark_entry_being_calculated_separate_files(key)
-        else:
-            with self.lock:
-                cache = self._get_cache()
-                try:
-                    cache[key]["being_calculated"] = True
-                except KeyError:
-                    cache[key] = {
-                        "value": None,
-                        "time": datetime.now(),
-                        "stale": False,
-                        "being_calculated": True,
-                    }
-                self._save_cache(cache)
+            return  # pragma: no cover
+
+        with self.lock:
+            cache = self._get_cache()
+            try:
+                cache[key]["being_calculated"] = True
+            except KeyError:
+                cache[key] = {
+                    "value": None,
+                    "time": datetime.now(),
+                    "stale": False,
+                    "being_calculated": True,
+                }
+            self._save_cache(cache)
 
     def mark_entry_not_calculated(self, key):
         if self.separate_files:
@@ -254,12 +223,12 @@ class _PickleCore(_BaseCore):
     def wait_on_entry_calc(self, key):
         if self.separate_files:
             entry = self._get_cache_by_key(key)
-            filename = f"{self._cache_fname()}_{key}"
+            filename = f"{self.cache_fname}_{key}"
         else:
             with self.lock:
                 self._reload_cache()
                 entry = self._get_cache()[key]
-            filename = self._cache_fname()
+            filename = self.cache_fname
         if not entry["being_calculated"]:
             return entry["value"]
         event_handler = _PickleCore.CacheChangeHandler(
@@ -285,9 +254,10 @@ class _PickleCore(_BaseCore):
     def clear_being_calculated(self):
         if self.separate_files:
             self._clear_being_calculated_all_cache_files()
-        else:
-            with self.lock:
-                cache = self._get_cache()
-                for key in cache:
-                    cache[key]["being_calculated"] = False
-                self._save_cache(cache)
+            return  # pragma: no cover
+
+        with self.lock:
+            cache = self._get_cache()
+            for key in cache:
+                cache[key]["being_calculated"] = False
+            self._save_cache(cache)

cachier/version.info

@@ -1 +1 @@
-v2.3.0
+3.0.1

{cachier-2.3.0.dist-info → cachier-3.0.1.dist-info}/METADATA

@@ -1,33 +1,50 @@
 Metadata-Version: 2.1
 Name: cachier
-Version: 2.3.0
+Version: 3.0.1
 Summary: Persistent, stale-free, local and cross-machine caching for Python functions.
-Home-page: https://github.com/python-cachier/cachier
-Author: Shay Palachy & al.
-Author-email: shay.palachy@gmail.com
-License: MIT
-Keywords: cache,persistence,mongo,memoization,decorator
-Platform: linux
-Platform: osx
-Platform: windows
+Author-email: Shay Palachy Affek <shay.palachy@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2016 Shay Palachy
+        
+        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.
+        
+Project-URL: Source, https://github.com/python-cachier/cachier
+Keywords: cache,caching,cross-machine,decorator,local,memoization,mongo,persistent
 Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Other/Nonlisted Topic
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
-Classifier: Topic :: Other/Nonlisted Topic
-Classifier: Intended Audience :: Developers
+Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: watchdog >=2.3.1
-Requires-Dist: portalocker >=2.3.2
-Requires-Dist: setuptools >=67.6.0
+Requires-Dist: portalocker>=2.3.2
+Requires-Dist: watchdog>=2.3.1
 
 Cachier
 #######
@@ -267,7 +284,7 @@ Cachier also accepts several keyword arguments in the calls of the function it w
 Ignore Cache
 ~~~~~~~~~~~~
 
-You can have ``cachier`` ignore any existing cache for a specific function call by passing ``ignore_cache=True`` to the function call. The cache will neither be checked nor updated with the new return value.
+You can have ``cachier`` ignore any existing cache for a specific function call by passing ``cachier__skip_cache=True`` to the function call. The cache will neither be checked nor updated with the new return value.
 
 .. code-block:: python
 
@@ -276,17 +293,17 @@ You can have ``cachier`` ignore any existing cache for a specific function call
     return first_num + second_num
 
   def main():
-    print(sum(5, 3, ignore_cache=True))
+    print(sum(5, 3, cachier__skip_cache=True))
 
 Overwrite Cache
 ~~~~~~~~~~~~~~~
 
-You can have ``cachier`` overwrite an existing cache entry - if one exists - for a specific function call by passing ``overwrite_cache=True`` to the function call. The cache will not be checked but will be updated with the new return value.
+You can have ``cachier`` overwrite an existing cache entry - if one exists - for a specific function call by passing ``cachier__overwrite_cache=True`` to the function call. The cache will not be checked but will be updated with the new return value.
 
 Verbose Cache Call
 ~~~~~~~~~~~~~~~~~~
 
-You can have ``cachier`` print out a detailed explanation of the logic of a specific call by passing ``verbose_cache=True`` to the function call. This can be useful if you are not sure why a certain function result is, or is not, returned.
+You can have ``cachier`` print out a detailed explanation of the logic of a specific call by passing ``cachier__verbose=True`` to the function call. This can be useful if you are not sure why a certain function result is, or is not, returned.
 
 Cache `None` Values
 ~~~~~~~~~~~~~~~~~~~
@@ -435,7 +452,7 @@ To run all tests EXCEPT memory core AND MongoDB core related tests, use:
 Running MongoDB tests against a live MongoDB instance
 -----------------------------------------------------
 
-**Note to developers:** By default, all MongoDB tests are run against a mocked MongoDB instance, provided by the ``pymongo_inmemory`` package. To run them against a live MongoDB instance, the ``CACHIER_TEST_VS_LIVE_MONGO`` environment variable is set to ``True`` in the ``test`` environment of this repository (and additional environment variables are populated with the appropriate credentials), used by the GitHub Action running tests on every commit and pull request.
+**Note to developers:** By default, all MongoDB tests are run against a mocked MongoDB instance, provided by the ``pymongo_inmemory`` package. To run them against a live MongoDB instance, the ``CACHIER_TEST_VS_DOCKERIZED_MONGO`` environment variable is set to ``True`` in the ``test`` environment of this repository (and additional environment variables are populated with the appropriate credentials), used by the GitHub Action running tests on every commit and pull request.
 
 Contributors are not expected to run these tests against a live MongoDB instance when developing, as credentials for the testing instance used will NOT be shared, but rather use the testing against the in-memory MongoDB instance as a good proxy.
 
@@ -492,8 +509,8 @@ Notable bugfixers:
 .. |PyPI-Versions| image:: https://img.shields.io/pypi/pyversions/cachier.svg
    :target: https://pypi.python.org/pypi/cachier
 
-.. |Build-Status| image:: https://github.com/python-cachier/cachier/actions/workflows/test.yml/badge.svg
-  :target: https://github.com/python-cachier/cachier/actions/workflows/test.yml
+.. |Build-Status| image:: https://github.com/python-cachier/cachier/actions/workflows/ci-test.yml/badge.svg
+  :target: https://github.com/python-cachier/cachier/actions/workflows/ci-test.yml
 
 .. |LICENCE| image:: https://img.shields.io/pypi/l/cachier.svg
   :target: https://pypi.python.org/pypi/cachier

cachier-3.0.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+cachier/__init__.py,sha256=6i43oFM_ZTp47b6R8Ws2vvf2JXLvbn-TKzWESwBDb-M,304
+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=JJutAeOlNjDobNWKteTvcvdj_Pfemk6_dMKIGFtW6UM,2754
+cachier/core.py,sha256=x0I-Ot2dt7wThu2j8iLXPYvv8exwp4xXMUQIQyImr64,13261
+cachier/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cachier/version.info,sha256=BuP-SnoYhNINgcxwZcqM_Uw5TsYCxNGA3cObvU99pSE,6
+cachier/cores/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cachier/cores/base.py,sha256=i6xlR3Em_s6rVER5Uyf1kK86KcaWtb84iKwS9bgDZGI,3465
+cachier/cores/memory.py,sha256=JFXnXBAeP0nOXOf_vNgpcEuRNjxre8WQjiUBa7yEYmY,3128
+cachier/cores/mongo.py,sha256=Ez3SNZzAzELO9c_SrGlOX855-5UEPBViabWPjkQnFc0,4917
+cachier/cores/pickle.py,sha256=fVajLzlhUkQ9ochLWAZnDQQZJPXj0lWl7mgalI-z2x0,8903
+cachier-3.0.1.dist-info/LICENSE,sha256=-2WrMJkIa0gVP6YQHXXDT7ws-S3M2NEVEF4XF3K8qrY,1069
+cachier-3.0.1.dist-info/METADATA,sha256=JZCfPStwVwwhYrdvT_Vkmm2FrfqYc2rUGtExGh86DGI,20102
+cachier-3.0.1.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+cachier-3.0.1.dist-info/entry_points.txt,sha256=x4Y7t6Y0Qev_3fgG-Jv7TrsvVdJty3FnGAdkT8-_5mY,49
+cachier-3.0.1.dist-info/top_level.txt,sha256=_rW_HiJumDCch67YT-WAgzcyvKg5RiYDMZq9d-0ZpaE,8
+cachier-3.0.1.dist-info/RECORD,,

{cachier-2.3.0.dist-info → cachier-3.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (72.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

cachier-3.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cachier = cachier.__main__:cli

cachier-2.3.0.dist-info/RECORD

@@ -1,17 +0,0 @@
-cachier/__init__.py,sha256=OvhjKkhTHuE9ESuBWLks0g6eGto9jKsJOr6FMFKQzXM,289
-cachier/__main__.py,sha256=g8dgovKdDgOMgNIpnmzVRuI5Dj5xODTav45TpZlH_iA,429
-cachier/_version.py,sha256=yE6UYwvdoIRpw3HmNifiGwV3fqVea5PwZj_EvyosiZ8,1079
-cachier/core.py,sha256=xB0kWRey5wL5XeTMTRe4lMpIukJmc2xWsOgUQGr8Q_c,14965
-cachier/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cachier/version.info,sha256=B-GHcA-4RPUOEZ4BIL3emPJuZ5J9E1aQPTmIXKecyHE,7
-cachier/cores/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cachier/cores/base.py,sha256=Sy0Tzi2We-op31bsickPiSM1U0neND1hvgjAkjKEUKg,3194
-cachier/cores/memory.py,sha256=sbit0EQNqZLqIZMKLJ7sNXfTkG63s68vKJpTl49E6Kc,2816
-cachier/cores/mongo.py,sha256=LMfLawErv7WJQVMwgca1jg6Qu7rK7tO7_9Zi1BHrodM,4829
-cachier/cores/pickle.py,sha256=tNrOQ61n2i6KC-xAw5K3Ewz_6Cegz4n3NtvRl_lqLnM,9903
-cachier-2.3.0.dist-info/LICENSE,sha256=-2WrMJkIa0gVP6YQHXXDT7ws-S3M2NEVEF4XF3K8qrY,1069
-cachier-2.3.0.dist-info/METADATA,sha256=06wPKvqCL4K1ujV0dFz6GLU4t75GFpVq8QMZHm2X2PQ,18839
-cachier-2.3.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-cachier-2.3.0.dist-info/entry_points.txt,sha256=16JU8wc6a62BLuOXVNjAiXJRp0AB5LtEwiKGYMjZjv0,49
-cachier-2.3.0.dist-info/top_level.txt,sha256=_rW_HiJumDCch67YT-WAgzcyvKg5RiYDMZq9d-0ZpaE,8
-cachier-2.3.0.dist-info/RECORD,,

cachier-2.3.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-cachier = cachier.__naim__:cli