Test Parametrization Id Function Receives Arg Tuple

I've seen requests similar to this, but I don't believe the exact same. Forgive me if this is a duplicate.

Proposal

For multi-argument parametrized test functions, pass the arguments as the original tuple to ids when ids` is a callable.

@pytest.mark.parametrize(
    "input_val, expected_output_val",
    [
        (0, 1),
        ("hello", "world")
    ],
    ids=lambda vals: f"Input val: {vals[0]}, expected output val: {vals[1]}"
)
def test_some_function(input_val, expected_ouput_val):
   ...

would output:

test_something.py::test_some_function[Input val: 0, expected output val: 1]
test_something.py::test_some_function[Input val: hello, expected output val: world]

Current Workarounds

If each arg in a given arg set is a different type, the above output could be achieved by using conditional statements based on arg type. e.g. ids=lambda val: f"Input val: {val} if type(val) == str else f"expected output val: {val}".

However, this is only sometimes the case. Exceptions could be found if a function accepts multiple types, or the likelihood of unique types for each parameter decreases with increasing number of parameters for a given function.

The other workaround I have is to declare the argument sets as a list, pass the list to argvals, and then pass a list comprehension to ids:

some_function_parametrize_args = [
        (0, 1),
        ("hello", "world")
]

@pytest.mark.parametrize(
    "input_val, expected_output_val",
    some_function_parametrize_args,
    ids=[f"Input val: {vals[0]}, expected output val: {vals[1]}" for vals in some_function_parametrize_args]
)
def test_some_function(input_val, expected_ouput_val):
   ...

This workaround works just fine, but I think it makes the code messier by exposing the args passed into argvals as a variable in the module when the intended scope would be just for that test function.

Thank you in advanced for reading this and discussing with me!

The issue centers on pytest.mark.parametrize and callable ids handling, but names no implementation files or tests. Start by tracing how ids receives values for multi-argument parametrization and reviewing related tests; done means a callable receives each original argument tuple and the documented example and regression coverage pass.