Fix cache key generation for variadic arguments (*args, **kwargs) (#322)

* Initial plan

* Fix: Handle variadic arguments (*args, **kwargs) in cache key generation

- Modified _convert_args_kwargs() to properly handle VAR_POSITIONAL and VAR_KEYWORD parameters
- Variadic positional args are now expanded as individual entries with __varargs_N__ keys
- Variadic keyword args are stored with their original keys
- Added comprehensive test suite for variadic arguments
- All existing tests pass including custom hash function tests

* Address PR review feedback: keyword-only params, parametrize tests, simplify code

- Fixed incorrect handling of keyword-only parameters (KEYWORD_ONLY should not be in regular_params)
- Simplified VAR_KEYWORD handling by removing unreachable else branch
- Parametrized first test to run on both pickle and memory backends
- Added 3 new tests for keyword-only parameter edge cases
- Fixed line length issues in docstrings and comments

* Improve test assertions to explicitly verify cache hits

- Changed assertions to capture previous call_count before testing cache hits
- Makes tests more explicit: verify count didn't increase rather than re-asserting same value
- Applied to test_varargs_different_cache_keys, test_varargs_empty, test_varkwargs_different_cache_keys, and test_varargs_and_varkwargs

* Simplify parameter handling in `map_arguments`
* Fix test assertion in test_varargs_memory_backend

- Changed assertion to capture previous_call_count before cache hit test
- Makes test explicit about verifying the count didn't increase
- Consistent with other test improvements in previous commit

* Refactor and parametrize varargs/varkwargs test cases for enhanced readability and backend coverage
* Remove redundant `@pytest.mark.pickle` annotations from varargs/varkwargs test cases
* [pre-commit.ci] auto fixes from pre-commit.com hooks
* Add comprehensive edge case tests for variadic arguments

- Added TestFunctoolsPartial: tests for functools.partial wrapped functions
- Added TestMethodWithVarargs: tests for functions simulating method behavior
- Added TestPositionalOnlyParams: tests for positional-only parameters (/) with varargs
- Added TestComplexParameterMix: tests for functions with all parameter types combined
- Added TestEdgeCasesEmptyAndNone: tests for None, empty strings, and zero values in varargs
- Total test count increased from 42 to 68 tests (26 new tests)
- All tests parametrized across pickle and memory backends for comprehensive coverage

* Simplify redundant conditional in _convert_args_kwargs

- Removed redundant if-else where both branches performed the same action
- Simplified kwds handling to always use kwargs.update(kwds)
- Removed unused var_keyword_name variable
- All 68 tests still pass

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Borda <6035284+Borda@users.noreply.github.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: 3 people

src/cachier/core.py

@@ -75,14 +75,53 @@ def _convert_args_kwargs(func, _is_method: bool, args: tuple, kwds: dict) -> dic
         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()))