[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

examples/redis_example.py

@@ -113,9 +113,7 @@ def demo_callable_client():
 
     def get_redis_client():
         """Get a Redis client."""
-        return redis.Redis(
-            host="localhost", port=6379, db=0, decode_responses=False
-        )
+        return redis.Redis(host="localhost", port=6379, db=0, decode_responses=False)
 
     @cachier(backend="redis", redis_client=get_redis_client)
     def cached_with_callable(n):

src/cachier/config.py

@@ -83,9 +83,7 @@ class CacheEntry:
     _completed: bool = False
 
 
-def _update_with_defaults(
-    param, name: str, func_kwargs: Optional[dict] = None
-):
+def _update_with_defaults(param, name: str, func_kwargs: Optional[dict] = None):
     import cachier
 
     if func_kwargs:
@@ -107,8 +105,7 @@ def set_default_params(**params: Any) -> None:
     import warnings
 
     warnings.warn(
-        "Called `set_default_params` is deprecated and will be removed."
-        " Please use `set_global_params` instead.",
+        "Called `set_default_params` is deprecated and will be removed. Please use `set_global_params` instead.",
         DeprecationWarning,
         stacklevel=2,
     )
@@ -138,11 +135,7 @@ def set_global_params(**params: Any) -> None:
     """
     import cachier
 
-    valid_params = {
-        k: v
-        for k, v in params.items()
-        if hasattr(cachier.config._global_params, k)
-    }
+    valid_params = {k: v for k, v in params.items() if hasattr(cachier.config._global_params, k)}
     cachier.config._global_params = replace(
         cachier.config._global_params,
         **valid_params,
@@ -159,8 +152,7 @@ def get_default_params() -> Params:
     import warnings
 
     warnings.warn(
-        "Called `get_default_params` is deprecated and will be removed."
-        " Please use `get_global_params` instead.",
+        "Called `get_default_params` is deprecated and will be removed. Please use `get_global_params` instead.",
         DeprecationWarning,
         stacklevel=2,
     )

src/cachier/core.py

@@ -56,9 +56,7 @@ def _function_thread(core, key, func, args, kwds):
         print(f"Function call failed with the following exception:\n{exc}")
 
 
-def _calc_entry(
-    core, key, func, args, kwds, printer=lambda *_: None
-) -> Optional[Any]:
+def _calc_entry(core, key, func, args, kwds, printer=lambda *_: None) -> Optional[Any]:
     core.mark_entry_being_calculated(key)
     try:
         func_res = func(*args, **kwds)
@@ -70,26 +68,18 @@ def _calc_entry(
         core.mark_entry_not_calculated(key)
 
 
-def _convert_args_kwargs(
-    func, _is_method: bool, args: tuple, kwds: dict
-) -> dict:
+def _convert_args_kwargs(func, _is_method: bool, args: tuple, kwds: dict) -> dict:
     """Convert mix of positional and keyword arguments to aggregated kwargs."""
     # unwrap if the function is functools.partial
     if hasattr(func, "func"):
         args = func.args + args
         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(
-        zip(func_params[1:], args[1:])
-        if _is_method
-        else zip(func_params, args)
-    )
+    args_as_kw = dict(zip(func_params[1:], args[1:]) if _is_method else zip(func_params, args))
     # init with default values
     kwargs = {
-        k: v.default
-        for k, v in inspect.signature(func).parameters.items()
-        if v.default is not inspect.Parameter.empty
+        k: v.default for k, v in inspect.signature(func).parameters.items() if v.default is not inspect.Parameter.empty
     }
     # merge args expanded as kwargs and the original kwds
     kwargs.update(dict(**args_as_kw, **kwds))
@@ -99,8 +89,7 @@ def _convert_args_kwargs(
 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.",
+            f"`{name}` is deprecated and will be removed in a future release, use `cachier__` alternative instead.",
             DeprecationWarning,
             stacklevel=2,
         )
@@ -201,18 +190,13 @@ def cachier(
     """
     # Check for deprecated parameters
     if hash_params is not None:
-        message = (
-            "hash_params will be removed in a future release, "
-            "please use hash_func instead"
-        )
+        message = "hash_params will be removed in a future release, please use hash_func instead"
         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")
-    size_limit_bytes = parse_bytes(
-        _update_with_defaults(entry_size_limit, "entry_size_limit")
-    )
+    size_limit_bytes = parse_bytes(_update_with_defaults(entry_size_limit, "entry_size_limit"))
     # Override the backend parameter if a mongetter is provided.
     if callable(mongetter):
         backend = "mongo"
@@ -290,59 +274,37 @@ def _call(*args, max_age: Optional[timedelta] = None, **kwds):
             nonlocal allow_none, last_cleanup
             _allow_none = _update_with_defaults(allow_none, "allow_none", kwds)
             # print('Inside general wrapper for {}.'.format(func.__name__))
-            ignore_cache = _pop_kwds_with_deprecation(
-                kwds, "ignore_cache", False
-            )
-            overwrite_cache = _pop_kwds_with_deprecation(
-                kwds, "overwrite_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
-            )
+            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
-            )
+            _stale_after = _update_with_defaults(stale_after, "stale_after", kwds)
             _next_time = _update_with_defaults(next_time, "next_time", kwds)
-            _cleanup_flag = _update_with_defaults(
-                cleanup_stale, "cleanup_stale", kwds
-            )
-            _cleanup_interval_val = _update_with_defaults(
-                cleanup_interval, "cleanup_interval", kwds
-            )
+            _cleanup_flag = _update_with_defaults(cleanup_stale, "cleanup_stale", kwds)
+            _cleanup_interval_val = _update_with_defaults(cleanup_interval, "cleanup_interval", 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
-            )
+            kwargs = _convert_args_kwargs(func, _is_method=core.func_is_method, args=args, kwds=kwds)
 
             if _cleanup_flag:
                 now = datetime.now()
                 with cleanup_lock:
                     if now - last_cleanup >= _cleanup_interval_val:
                         last_cleanup = now
-                        _get_executor().submit(
-                            core.delete_stale_entries, _stale_after
-                        )
+                        _get_executor().submit(core.delete_stale_entries, _stale_after)
 
             _print = print if verbose else lambda x: None
 
             # Check current global caching state dynamically
             from .config import _global_params
 
             if ignore_cache or not _global_params.caching_enabled:
-                return (
-                    func(args[0], **kwargs)
-                    if core.func_is_method
-                    else func(**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, _print)
-            if entry is None or (
-                not entry._completed and not entry._processing
-            ):
+            if entry is None or (not entry._completed and not entry._processing):
                 _print("No entry found. No current calc. Calling like a boss.")
                 return _calc_entry(core, key, func, args, kwds, _print)
             _print("Entry found.")
@@ -353,10 +315,7 @@ def _call(*args, max_age: Optional[timedelta] = None, **kwds):
                 nonneg_max_age = True
                 if max_age is not None:
                     if max_age < ZERO_TIMEDELTA:
-                        _print(
-                            "max_age is negative. "
-                            "Cached result considered stale."
-                        )
+                        _print("max_age is negative. Cached result considered stale.")
                         nonneg_max_age = False
                     else:
                         assert max_age is not None  # noqa: S101
@@ -379,9 +338,7 @@ def _call(*args, max_age: Optional[timedelta] = None, **kwds):
                     _print("Async calc and return stale")
                     core.mark_entry_being_calculated(key)
                     try:
-                        _get_executor().submit(
-                            _function_thread, core, key, func, args, kwds
-                        )
+                        _get_executor().submit(_function_thread, core, key, func, args, kwds)
                     finally:
                         core.mark_entry_not_calculated(key)
                     return entry.value
@@ -426,9 +383,7 @@ def _precache_value(*args, value_to_cache, **kwds):  # noqa: D417
 
             """
             # merge args expanded as kwargs and the original kwds
-            kwargs = _convert_args_kwargs(
-                func, _is_method=core.func_is_method, args=args, kwds=kwds
-            )
+            kwargs = _convert_args_kwargs(func, _is_method=core.func_is_method, args=args, kwds=kwds)
             return core.precache_value((), kwargs, value_to_cache)
 
         func_wrapper.clear_cache = _clear_cache

src/cachier/cores/base.py

@@ -85,9 +85,7 @@ def precache_value(self, args, kwds, value_to_cache):
 
     def check_calc_timeout(self, time_spent):
         """Raise an exception if a recalculation is needed."""
-        calc_timeout = _update_with_defaults(
-            self.wait_for_calc_timeout, "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()
 

src/cachier/cores/memory.py

@@ -24,9 +24,7 @@ def __init__(
     def _hash_func_key(self, key: str) -> str:
         return f"{_get_func_str(self.func)}:{key}"
 
-    def get_entry_by_key(
-        self, key: str, reload=False
-    ) -> Tuple[str, Optional[CacheEntry]]:
+    def get_entry_by_key(self, key: str, reload=False) -> Tuple[str, Optional[CacheEntry]]:
         with self.lock:
             return key, self.cache.get(self._hash_func_key(key), None)
 
@@ -112,8 +110,6 @@ def delete_stale_entries(self, stale_after: timedelta) -> None:
         """Remove stale entries from the in-memory cache."""
         now = datetime.now()
         with self.lock:
-            keys_to_delete = [
-                k for k, v in self.cache.items() if now - v.time > stale_after
-            ]
+            keys_to_delete = [k for k, v in self.cache.items() if now - v.time > stale_after]
             for key in keys_to_delete:
                 del self.cache[key]

src/cachier/cores/mongo.py

@@ -55,9 +55,7 @@ def __init__(
             entry_size_limit=entry_size_limit,
         )
         if mongetter is None:
-            raise MissingMongetter(
-                "must specify ``mongetter`` when using the mongo core"
-            )
+            raise MissingMongetter("must specify ``mongetter`` when using the mongo core")
         self.mongetter = mongetter
         self.mongo_collection = self.mongetter()
         index_inf = self.mongo_collection.index_information()
@@ -73,9 +71,7 @@ def _func_str(self) -> str:
         return _get_func_str(self.func)
 
     def get_entry_by_key(self, key: str) -> Tuple[str, Optional[CacheEntry]]:
-        res = self.mongo_collection.find_one(
-            {"func": self._func_str, "key": key}
-        )
+        res = self.mongo_collection.find_one({"func": self._func_str, "key": key})
         if not res:
             return key, None
         val = None
@@ -156,6 +152,4 @@ def clear_being_calculated(self) -> None:
     def delete_stale_entries(self, stale_after: timedelta) -> None:
         """Delete stale entries from the MongoDB cache."""
         threshold = datetime.now() - stale_after
-        self.mongo_collection.delete_many(
-            filter={"func": self._func_str, "time": {"$lt": threshold}}
-        )
+        self.mongo_collection.delete_many(filter={"func": self._func_str, "time": {"$lt": threshold}})