tuple_the_args: passing the tupled *args by keyword fails, and ch_func_to_all_pk can't handle a required keyword-only after *args

[thorwhalen]

Found while fixing #12 (PR #92). Neither is fixed there, because both need a design call.

1. tuple_the_args rejects its own signature. The wrapper advertises the tupled *args as a positional-or-keyword param, but giving it by keyword fails:

from i2.signatures import tuple_the_args, Sig

def foo(*pos, **kws):
    return pos, kws

f = tuple_the_args(foo)
Sig(f)               # <Sig (pos=(), **kws)>
f((1, 2), a=3)       # works
f(pos=(1, 2), a=3)   # FuncCallNotMatchingSignature: There should be only keyword arguments after the Variadic args

The cause is in ch_variadics_to_non_variadic_kind's inner function. It rebuilds positional args with mk_args_and_kwargs on the original signature, which unpacks the tuple, then indexes args[idx_of_vp] expecting the tuple. A fix has to fill any skipped defaults before *args, e.g. def g(a, b=1, *args) called as tupled(1, args=(2, 3)) must become g(1, 1, 2, 3). PR #92 adds a helper for exactly that (_args_and_kwargs_from_all_pk_arguments in signatures.py), which could be reused here.

2. ch_func_to_all_pk fails at decoration time for a required keyword-only param after *args:

from i2.signatures import ch_func_to_all_pk

def h(x, *y, z):
    ...

ch_func_to_all_pk(h)  # ValueError: non-default argument follows default argument

The all-PK signature would be (x, y=(), z), which isn't valid. The options are to drop y's default (making it required), to reorder, or to keep z keyword-only. Each changes what callers see, so this needs your decision.

[thorwhalen]

Decision, both parts

1. tuple_the_args: bind the call to the signature it advertises

This turned out not to be a design choice but a bug, and worse than the repro: on 0.1.74 the wrapper bound keyword input against the original variadic signature and then indexed the result as if it were the tupled one, so

def g(a, b=1, *args): ...
tg = tuple_the_args(g)         # (a, b=1, args=())
tg(1)                          # IndexError
tg(1, args=(2, 3))             # TypeError: Value after * must be an iterable, not int
tg(a=1, b=5, args=(2, 3))      # FuncCallNotMatchingSignature
tuple_the_args(lambda a, *args, **kw: ...)(1, (2,), kw={'x': 4})   # kw silently dropped
tuple_the_args(lambda a, *args: ...)(1, (2,), junk=3)             # junk silently dropped

Chosen: the inner function now binds (args, kwargs) to the new signature with Sig.map_arguments(..., ignore_kind=False) and rebuilds the call to the original function with _args_and_kwargs_from_all_pk_arguments, the helper #92 added (so the two functions share one rebuild path, as suggested here). Skipped defaults before the tupled param are filled (tg(1, args=(2, 3)) → g(1, 1, 2, 3)), the tupled param works by keyword, and a variadic keyword given by name as a dict is spread (the Sig.mk_args_and_kwargs convention). Whatever the advertised signature rejects now raises FuncCallNotMatchingSignature (a TypeError) with the signature and the call in the message. The dead try/except around the signature construction is gone.

Behaviour changes, deliberately: calls that raised or crashed now work; the two silent drops above now raise or are honoured. No dependent relied on the silent drops (see the use-site table below).

2. ch_func_to_all_pk on def h(x, *y, z): keep z keyword-only (option A)

Options considered

• A. Keep z keyword-only: (x, y=(), *, z).
• B. Make y required: (x, y, z).
• C. Reorder: (x, z, y=()).
• D. Raise a clear error at decoration time.

Chosen: A, as a rule in all_pk_signature rather than a special case: a parameter is made positional-or-keyword only while Python's ordering rules allow it. A required keyword-only param that follows a param with a default stays keyword-only, and so does everything after it (order is preserved, nothing is reordered). So all_pk_signature(Sig(lambda a=1, *, b, c=2: 0)) is (a=1, *, b, c=2) instead of a ValueError, and ch_func_to_all_pk(h) is (x, y=(), *, z) with hh(1, (2, 3), z=4) and hh(x=1, y=(2, 3), z=4) both working. #92's call path already handled a remaining keyword-only param, so ch_func_to_all_pk itself needed no change.

Why not the others. B changes what the tupled param means depending on a later param ((x, *y, z=0) gives y=(), (x, *y, z) would give a required y), and forces every caller to pass (). C makes positional calls bind differently from the original function. D leaves a perfectly usable function unusable. What every user of ch_func_to_all_pk in the fleet needs is keyword-callability of every param (meshed's hook_up and py2http's methodizer always call by keyword); A gives exactly that and loses nothing that worked before.

Use-site evidence

Site	Shape	Effect of the change
meshed handle_variadics (every FuncNode) → ch_variadics_to_non_variadic_kind	any user func	nodes shaped f(x, *y, z) no longer crash DAG construction; a tupled *args given by keyword is now correct
meshed hook_up → ch_func_to_all_pk, always called by keyword	tested with no *args	unchanged; f(x, *y, z) now works
py2http methodizer → ch_func_to_all_pk, always called by keyword	doctests without *args	unchanged; f(x, *y, z) now works
i2 FlexFuncFanout.normalize_func → ch_func_to_all_pk(tuple_the_args(f))	sum_of_args(*args, **kwargs)	the tupled-by-keyword doctest path now goes through a correct wrapper
lined normalize_func	dead code (sole caller commented out)	none
replace_kwargs_using sites in oa, aix	no source has *args	none

Test gate: i2 suite plus the dependents' suites, results on the PR.

Also found, out of scope: dol/signatures.py carries a vendored copy of these functions that does not import i2 and still has the 0.1.74 behaviour. Worth a separate sync issue on dol.

Review findings folded in. An independent adversarial review (≈430 calls compared against 0.1.74, plus meshed's and py2http's suites on both trees) found no worked-before/differs-now case any dependent hits. Two narrow worked-before/raises-now cases, both only for direct tuple_the_args users: an unknown keyword for a function without **kwargs (was dropped, now FuncCallNotMatchingSignature), and a by-name kwargs={...} dict whose key collides with a named param (the whole dict used to be dropped, now "multiple values for argument"). Also fixed from the review: all_pk_signature keeps everything after an untupled *args keyword-only too. The pre-existing excess-keyword asymmetry inside ch_func_to_all_pk is filed separately: #95.