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

Co-authored-by: Borda <6035284+Borda@users.noreply.github.com>

Author: Copilot

src/cachier/core.py

@@ -79,20 +79,74 @@ def _convert_args_kwargs(
         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
+
+    sig = inspect.signature(func)
+    func_params = list(sig.parameters)
+
+    # Separate regular parameters from VAR_POSITIONAL and VAR_KEYWORD
+    regular_params = []
+    var_positional_name = None
+    var_keyword_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 == inspect.Parameter.VAR_KEYWORD:
+            var_keyword_name = param_name
+        else:
+            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 inspect.signature(func).parameters.items()
+        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(dict(**args_as_kw, **kwds))
+
+    # Merge args expanded as kwargs and the original kwds
+    kwargs.update(args_as_kw)
+
+    # Handle variadic keyword arguments
+    if var_keyword_name:
+        # Separate kwds that match known parameters from those that don't
+        known_param_kwds = {}
+        extra_kwds = {}
+        for k, v in kwds.items():
+            if k in sig.parameters:
+                param = sig.parameters[k]
+                if param.kind != inspect.Parameter.VAR_KEYWORD:
+                    known_param_kwds[k] = v
+                else:
+                    extra_kwds[k] = v
+            else:
+                extra_kwds[k] = v
+        kwargs.update(known_param_kwds)
+        # Store extra kwargs with their original keys
+        kwargs.update(extra_kwds)
+    else:
+        kwargs.update(kwds)
+
     return OrderedDict(sorted(kwargs.items()))
 
 

tests/test_varargs.py

@@ -0,0 +1,205 @@
+"""Test for variadic arguments (*args) handling in cachier."""
+
+from datetime import timedelta
+
+import pytest
+
+from cachier import cachier
+
+
+@pytest.mark.pickle
+def test_varargs_different_cache_keys():
+    """Test that functions with *args get unique cache keys for different arguments."""
+    call_count = 0
+
+    @cachier(stale_after=timedelta(seconds=500))
+    def get_data(*args):
+        """Test function that accepts variadic arguments."""
+        nonlocal call_count
+        call_count += 1
+        return f"Result for args: {args}, call #{call_count}"
+
+    # Clear any existing cache
+    get_data.clear_cache()
+    call_count = 0
+
+    # Test 1: Call with different arguments should produce different cache entries
+    result1 = get_data("print", "domains")
+    assert call_count == 1
+    assert "('print', 'domains')" in result1
+
+    result2 = get_data("print", "users", "allfields")
+    assert call_count == 2, "Function should be called again with different args"
+    assert "('print', 'users', 'allfields')" in result2
+    assert result1 != result2, "Different args should produce different results"
+
+    # Test 2: Calling with the same arguments should use cache
+    result3 = get_data("print", "domains")
+    assert call_count == 2, "Function should not be called again (cache hit)"
+    assert result3 == result1
+
+    result4 = get_data("print", "users", "allfields")
+    assert call_count == 2, "Function should not be called again (cache hit)"
+    assert result4 == result2
+
+    get_data.clear_cache()
+
+
+@pytest.mark.pickle
+def test_varargs_empty():
+    """Test that functions with *args work with no arguments."""
+    call_count = 0
+
+    @cachier(stale_after=timedelta(seconds=500))
+    def get_data(*args):
+        """Test function that accepts variadic arguments."""
+        nonlocal call_count
+        call_count += 1
+        return f"Result for args: {args}, call #{call_count}"
+
+    get_data.clear_cache()
+    call_count = 0
+
+    # Call with no arguments
+    result1 = get_data()
+    assert call_count == 1
+    assert "()" in result1
+
+    # Second call should use cache
+    result2 = get_data()
+    assert call_count == 1
+    assert result2 == result1
+
+    get_data.clear_cache()
+
+
+@pytest.mark.pickle
+def test_varargs_with_regular_args():
+    """Test that functions with both regular and variadic arguments work correctly."""
+    call_count = 0
+
+    @cachier(stale_after=timedelta(seconds=500))
+    def get_data(command, *args):
+        """Test function with regular and variadic arguments."""
+        nonlocal call_count
+        call_count += 1
+        return f"Command: {command}, args: {args}, call #{call_count}"
+
+    get_data.clear_cache()
+    call_count = 0
+
+    # Test different calls
+    result1 = get_data("print", "domains")
+    assert call_count == 1
+
+    result2 = get_data("print", "users", "allfields")
+    assert call_count == 2
+    assert result1 != result2
+
+    result3 = get_data("list")
+    assert call_count == 3
+    assert result3 != result1
+    assert result3 != result2
+
+    # Test cache hits
+    result4 = get_data("print", "domains")
+    assert call_count == 3
+    assert result4 == result1
+
+    get_data.clear_cache()
+
+
+@pytest.mark.pickle
+def test_varkwargs_different_cache_keys():
+    """Test that functions with **kwargs get unique cache keys for different arguments."""
+    call_count = 0
+
+    @cachier(stale_after=timedelta(seconds=500))
+    def get_data(**kwargs):
+        """Test function that accepts keyword variadic arguments."""
+        nonlocal call_count
+        call_count += 1
+        return f"Result for kwargs: {kwargs}, call #{call_count}"
+
+    get_data.clear_cache()
+    call_count = 0
+
+    # Test with different kwargs
+    result1 = get_data(type="domains", action="print")
+    assert call_count == 1
+
+    result2 = get_data(type="users", action="print", fields="allfields")
+    assert call_count == 2
+    assert result1 != result2
+
+    # Test cache hits
+    result3 = get_data(type="domains", action="print")
+    assert call_count == 2
+    assert result3 == result1
+
+    get_data.clear_cache()
+
+
+@pytest.mark.pickle
+def test_varargs_and_varkwargs():
+    """Test that functions with both *args and **kwargs work correctly."""
+    call_count = 0
+
+    @cachier(stale_after=timedelta(seconds=500))
+    def get_data(*args, **kwargs):
+        """Test function with both variadic arguments."""
+        nonlocal call_count
+        call_count += 1
+        return f"args: {args}, kwargs: {kwargs}, call #{call_count}"
+
+    get_data.clear_cache()
+    call_count = 0
+
+    # Test different combinations
+    result1 = get_data("print", "domains")
+    assert call_count == 1
+
+    result2 = get_data("print", "users", action="list")
+    assert call_count == 2
+    assert result1 != result2
+
+    result3 = get_data(action="list", resource="domains")
+    assert call_count == 3
+    assert result3 != result1
+    assert result3 != result2
+
+    # Test cache hits
+    result4 = get_data("print", "domains")
+    assert call_count == 3
+    assert result4 == result1
+
+    get_data.clear_cache()
+
+
+@pytest.mark.memory
+def test_varargs_memory_backend():
+    """Test that variadic arguments work with memory backend."""
+    call_count = 0
+
+    @cachier(backend="memory", stale_after=timedelta(seconds=500))
+    def get_data(*args):
+        """Test function that accepts variadic arguments."""
+        nonlocal call_count
+        call_count += 1
+        return f"Result: {args}, call #{call_count}"
+
+    get_data.clear_cache()
+    call_count = 0
+
+    result1 = get_data("a", "b")
+    assert call_count == 1
+
+    result2 = get_data("a", "b", "c")
+    assert call_count == 2
+    assert result1 != result2
+
+    result3 = get_data("a", "b")
+    assert call_count == 2
+    assert result3 == result1
+
+    get_data.clear_cache()