Merge branch 'master' into copilot/add-cache-analytics-framework

Author: Borda

.pre-commit-config.yaml

@@ -42,7 +42,7 @@ repos:
       - id: mdformat
         additional_dependencies:
           - mdformat-gfm
-          - mdformat-black
+          - mdformat-ruff
           - mdformat_frontmatter
         args: ["--number"]
 
@@ -61,7 +61,7 @@ repos:
       - id: ruff-format
         name: Black by Ruff
       # basic check
-      - id: ruff
+      - id: ruff-check
         name: Ruff check
         args: ["--fix"] #, "--unsafe-fixes"
 

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):

pyproject.toml

@@ -72,14 +72,11 @@ namespaces = false # to disable scanning PEP 420 namespaces (true by default)
 
 # === Linting & Formatting ===
 
-[tool.black]
-line-length = 79
-
 # --- ruff ---
 
 [tool.ruff]
 target-version = "py39"
-line-length = 79
+line-length = 120
 # Exclude a variety of commonly ignored directories.
 exclude = [
   ".eggs",

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

@@ -58,9 +58,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)
@@ -75,37 +73,67 @@ 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)
-    )
-    # 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
-    }
-    # merge args expanded as kwargs and the original kwds
-    kwargs.update(dict(**args_as_kw, **kwds))
+
+    sig = inspect.signature(func)
+    func_params = list(sig.parameters)
+
+    # Separate regular parameters from VAR_POSITIONAL
+    regular_params = []
+    var_positional_name = None
+
+    for param_name in func_params:
+        param = sig.parameters[param_name]
+        if param.kind == inspect.Parameter.VAR_POSITIONAL:
+            var_positional_name = param_name
+        elif param.kind in (
+            inspect.Parameter.POSITIONAL_ONLY,
+            inspect.Parameter.POSITIONAL_OR_KEYWORD
+        ):
+            regular_params.append(param_name)
+
+    # Map positional arguments to regular parameters
+    if _is_method:
+        # Skip 'self' for methods
+        args_to_map = args[1:]
+        params_to_use = regular_params[1:]
+    else:
+        args_to_map = args
+        params_to_use = regular_params
+
+    # Map as many args as possible to regular parameters
+    num_regular = len(params_to_use)
+    args_as_kw = dict(zip(params_to_use, args_to_map[:num_regular]))
+
+    # Handle variadic positional arguments
+    # Store them with indexed keys like __varargs_0__, __varargs_1__, etc.
+    if var_positional_name and len(args_to_map) > num_regular:
+        var_args = args_to_map[num_regular:]
+        for i, arg in enumerate(var_args):
+            args_as_kw[f"__varargs_{i}__"] = arg
+
+    # Init with default values
+    kwargs = {k: v.default for k, v in sig.parameters.items() if v.default is not inspect.Parameter.empty}
+
+    # Merge args expanded as kwargs and the original kwds
+    kwargs.update(args_as_kw)
+
+    # Handle keyword arguments (including variadic keyword arguments)
+    kwargs.update(kwds)
+
     return OrderedDict(sorted(kwargs.items()))
 
 
 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,
         )
@@ -216,10 +244,7 @@ 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
@@ -261,7 +286,7 @@ def cachier(
             hash_func=hash_func,
             wait_for_calc_timeout=wait_for_calc_timeout,
             entry_size_limit=size_limit_bytes,
-            metrics=cache_metrics,
+            metrics=cache_metrics
         )
     elif backend == "sql":
         core = _SQLCore(
@@ -316,41 +341,25 @@ 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
 
@@ -401,10 +410,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
@@ -459,9 +465,7 @@ def _call(*args, max_age: Optional[timedelta] = None, **kwds):
                         cache_metrics.record_recalculation()
                     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)
                     if cache_metrics:
@@ -542,9 +546,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

@@ -90,9 +90,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

@@ -30,9 +30,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)
 
@@ -122,9 +120,7 @@ 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]
             # Update size metrics after deletion

src/cachier/cores/mongo.py

@@ -60,9 +60,7 @@ def __init__(
             metrics=metrics,
         )
         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()
@@ -78,9 +76,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
@@ -151,16 +147,11 @@ def clear_cache(self) -> None:
 
     def clear_being_calculated(self) -> None:
         self.mongo_collection.update_many(
-            filter={
-                "func": self._func_str,
-                "processing": True,
-            },
+            filter={"func": self._func_str, "processing": True},
             update={"$set": {"processing": False}},
         )
 
     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}})