From 81d3b35b813bf2144e5f4f174cef20d1721c0465 Mon Sep 17 00:00:00 2001 From: Farhan Date: Sun, 22 Nov 2026 02:08:37 +0000 Subject: [PATCH 1/3] Pass a trigger's arguments only to a callable's positional parameters A callable given to an event trigger, such as `lambda key, **kw: ...` or `lambda key, *, flag=1: ...`, raised TypeError because every parameter, keyword-only and `**kwargs` included, was counted as a slot for the trigger's arguments. `*args` now takes all of them, even none. Claude-Session: https://claude.ai/code/session_01LwJUCVxPh3ihrnaFn6CWnf --- .../news/+varargs-event-callable.bugfix.md | 1 + .../src/reflex_base/event/__init__.py | 56 ++++++++++++++++--- tests/units/reflex_base/event/test_init.py | 38 +++++++++++++ 3 files changed, 87 insertions(+), 8 deletions(-) create mode 100644 packages/reflex-base/news/+varargs-event-callable.bugfix.md diff --git a/packages/reflex-base/news/+varargs-event-callable.bugfix.md b/packages/reflex-base/news/+varargs-event-callable.bugfix.md new file mode 100644 index 00000000000..70565a37e42 --- /dev/null +++ b/packages/reflex-base/news/+varargs-event-callable.bugfix.md @@ -0,0 +1 @@ +A callable passed to an event trigger gets the trigger's arguments only through its positional parameters: `lambda *args: ...` gets all of them, even none, and `lambda key, **kwargs: ...` or a keyword-only parameter no longer raises `TypeError`. diff --git a/packages/reflex-base/src/reflex_base/event/__init__.py b/packages/reflex-base/src/reflex_base/event/__init__.py index 63844816912..21bd6a42c7f 100644 --- a/packages/reflex-base/src/reflex_base/event/__init__.py +++ b/packages/reflex-base/src/reflex_base/event/__init__.py @@ -2624,6 +2624,50 @@ def args_specs_from_fields( } +# The parameters a trigger's arguments are passed to, in order. `*args` takes +# any number of them, none included; keyword-only parameters and `**kwargs` +# take none. +_POSITIONAL_PARAMETER_KINDS = ( + inspect.Parameter.POSITIONAL_ONLY, + inspect.Parameter.POSITIONAL_OR_KEYWORD, +) + + +def _positional_parameters( + parameters: Mapping[str, inspect.Parameter], +) -> list[inspect.Parameter]: + """Get the parameters a trigger's arguments are passed to. + + Args: + parameters: The parameters of the function. + + Returns: + Its positional parameters, in order. + """ + return [ + parameter + for parameter in parameters.values() + if parameter.kind in _POSITIONAL_PARAMETER_KINDS + ] + + +def _max_positional_args(parameters: Mapping[str, inspect.Parameter]) -> int | None: + """Get how many of a trigger's arguments a function takes. + + Args: + parameters: The parameters of the function. + + Returns: + The number of its positional parameters, or None when it takes ``*args``. + """ + if any( + parameter.kind is inspect.Parameter.VAR_POSITIONAL + for parameter in parameters.values() + ): + return None + return len(_positional_parameters(parameters)) + + def check_fn_match_arg_spec( user_func: Callable, user_func_parameters: Mapping[str, inspect.Parameter], @@ -2646,15 +2690,13 @@ def check_fn_match_arg_spec( Raises: EventFnArgMismatchError: Raised if the number of mandatory arguments do not match """ - user_args = list(user_func_parameters) + user_args = _positional_parameters(user_func_parameters) # Drop the first argument if it's a bound method if inspect.ismethod(user_func) and user_func.__self__ is not None: user_args = user_args[1:] user_default_args = [ - p.default - for p in user_func_parameters.values() - if p.default is not inspect.Parameter.empty + p.default for p in user_args if p.default is not inspect.Parameter.empty ] number_of_user_args = len(user_args) - number_of_bound_args number_of_user_default_args = len(user_default_args) if user_default_args else 0 @@ -2748,10 +2790,8 @@ def call_event_fn( # Check that fn signature matches arg_spec check_fn_match_arg_spec(fn, parameters, parsed_args, key=key) - number_of_fn_args = len(parameters) - - # Call the function with the parsed args. - out = fn(*[*parsed_args][:number_of_fn_args]) + # Call the function with as many of the parsed args as it takes. + out = fn(*parsed_args[: _max_positional_args(parameters)]) def _dispatch_mixed_event_var(event_like_var: Var) -> FunctionVar: """Wrap a mixed event-like Var into a callable frontend dispatcher. diff --git a/tests/units/reflex_base/event/test_init.py b/tests/units/reflex_base/event/test_init.py index fc4869d245b..d70f7a6cea3 100644 --- a/tests/units/reflex_base/event/test_init.py +++ b/tests/units/reflex_base/event/test_init.py @@ -6,7 +6,9 @@ from reflex_base.event import ( EventArgVar, EventChain, + EventSpec, LambdaEventCallback, + call_event_fn, event_arg_placeholder, event_args_signature, no_args_event_spec, @@ -98,3 +100,39 @@ def test_cond_between_function_and_none_inside_lambda_is_a_no_op_when_false() -> str(chain) == '((_ev_0) => (((_ev_0?.valueOf?.() === "go"?.valueOf?.()) ? ((_ev_0) => (flagRxClientStateSet(_ev_0))) : null)?.(_ev_0)))' ) + + +def test_call_event_fn_passes_every_trigger_argument_to_varargs() -> None: + """A callable taking ``*args`` gets all of a trigger's arguments, however many. + + ``*args`` is not a required argument, so a trigger with none is valid too. + """ + received: list[tuple[str, ...]] = [] + + def record(*args: Var) -> EventSpec: + received.append(tuple(str(arg) for arg in args)) + return rx.noop() + + def no_args() -> list[Var]: + return [] + + call_event_fn(record, no_args, key="on_mount") + call_event_fn(record, lambda a, b: [a, b], key="on_resize") + assert received == [(), ("_a", "_b")] + + +def test_call_event_fn_passes_only_positional_arguments() -> None: + """Keyword-only and ``**kwargs`` parameters take none of the trigger's arguments.""" + received: list[tuple[str, ...]] = [] + + def record_kwargs(key: Var, **kwargs: Any) -> EventSpec: + received.append((str(key), *kwargs)) + return rx.noop() + + def record_keyword_only(key: Var, *, flag: int = 1) -> EventSpec: + received.append((str(key), str(flag))) + return rx.noop() + + call_event_fn(record_kwargs, lambda a, b: [a, b], key="on_key_down") + call_event_fn(record_keyword_only, lambda a, b: [a, b], key="on_key_down") + assert received == [("_a",), ("_a", "1")] From a6c57f4901f3fc608cd450035c1002ab3ab2f084 Mon Sep 17 00:00:00 2001 From: Farhan Date: Sun, 22 Nov 2026 02:12:53 +0000 Subject: [PATCH 2/3] Keep a required keyword-only parameter required in the argument check Counting only positional parameters let `def handle(self, value, *, required)` bind to a one-argument trigger and fail later in the backend. Only `*args` and `**kwargs` are left out of the count now. Claude-Session: https://claude.ai/code/session_01LwJUCVxPh3ihrnaFn6CWnf --- .../news/+varargs-event-callable.bugfix.md | 2 +- .../src/reflex_base/event/__init__.py | 54 ++++++++----------- tests/units/reflex_base/event/test_init.py | 47 ++++++++++++++++ 3 files changed, 70 insertions(+), 33 deletions(-) diff --git a/packages/reflex-base/news/+varargs-event-callable.bugfix.md b/packages/reflex-base/news/+varargs-event-callable.bugfix.md index 70565a37e42..c57b5eece1c 100644 --- a/packages/reflex-base/news/+varargs-event-callable.bugfix.md +++ b/packages/reflex-base/news/+varargs-event-callable.bugfix.md @@ -1 +1 @@ -A callable passed to an event trigger gets the trigger's arguments only through its positional parameters: `lambda *args: ...` gets all of them, even none, and `lambda key, **kwargs: ...` or a keyword-only parameter no longer raises `TypeError`. +A callable passed to an event trigger gets the trigger's arguments only through its positional parameters: `lambda *args: ...` gets all of them, even none, and `lambda key, **kwargs: ...` or `lambda key, *, flag=1: ...` no longer raises `TypeError`. diff --git a/packages/reflex-base/src/reflex_base/event/__init__.py b/packages/reflex-base/src/reflex_base/event/__init__.py index 21bd6a42c7f..320c47cd399 100644 --- a/packages/reflex-base/src/reflex_base/event/__init__.py +++ b/packages/reflex-base/src/reflex_base/event/__init__.py @@ -2624,35 +2624,15 @@ def args_specs_from_fields( } -# The parameters a trigger's arguments are passed to, in order. `*args` takes -# any number of them, none included; keyword-only parameters and `**kwargs` -# take none. -_POSITIONAL_PARAMETER_KINDS = ( - inspect.Parameter.POSITIONAL_ONLY, - inspect.Parameter.POSITIONAL_OR_KEYWORD, +# The parameter kinds that take any number of arguments, none included. +_VARIADIC_PARAMETER_KINDS = ( + inspect.Parameter.VAR_POSITIONAL, + inspect.Parameter.VAR_KEYWORD, ) -def _positional_parameters( - parameters: Mapping[str, inspect.Parameter], -) -> list[inspect.Parameter]: - """Get the parameters a trigger's arguments are passed to. - - Args: - parameters: The parameters of the function. - - Returns: - Its positional parameters, in order. - """ - return [ - parameter - for parameter in parameters.values() - if parameter.kind in _POSITIONAL_PARAMETER_KINDS - ] - - def _max_positional_args(parameters: Mapping[str, inspect.Parameter]) -> int | None: - """Get how many of a trigger's arguments a function takes. + """Get how many of a trigger's arguments a function takes by position. Args: parameters: The parameters of the function. @@ -2660,12 +2640,16 @@ def _max_positional_args(parameters: Mapping[str, inspect.Parameter]) -> int | N Returns: The number of its positional parameters, or None when it takes ``*args``. """ - if any( - parameter.kind is inspect.Parameter.VAR_POSITIONAL - for parameter in parameters.values() - ): - return None - return len(_positional_parameters(parameters)) + count = 0 + for parameter in parameters.values(): + if parameter.kind is inspect.Parameter.VAR_POSITIONAL: + return None + if parameter.kind in ( + inspect.Parameter.POSITIONAL_ONLY, + inspect.Parameter.POSITIONAL_OR_KEYWORD, + ): + count += 1 + return count def check_fn_match_arg_spec( @@ -2690,7 +2674,13 @@ def check_fn_match_arg_spec( Raises: EventFnArgMismatchError: Raised if the number of mandatory arguments do not match """ - user_args = _positional_parameters(user_func_parameters) + # `*args` and `**kwargs` take no argument of their own; a keyword-only + # parameter without a default is as required as a positional one. + user_args = [ + p + for p in user_func_parameters.values() + if p.kind not in _VARIADIC_PARAMETER_KINDS + ] # Drop the first argument if it's a bound method if inspect.ismethod(user_func) and user_func.__self__ is not None: user_args = user_args[1:] diff --git a/tests/units/reflex_base/event/test_init.py b/tests/units/reflex_base/event/test_init.py index d70f7a6cea3..c2c0c8ab4e6 100644 --- a/tests/units/reflex_base/event/test_init.py +++ b/tests/units/reflex_base/event/test_init.py @@ -2,19 +2,23 @@ from typing import Any, cast +import pytest from reflex_base.client_state import client_state from reflex_base.event import ( EventArgVar, EventChain, + EventHandler, EventSpec, LambdaEventCallback, call_event_fn, + call_event_handler, event_arg_placeholder, event_args_signature, no_args_event_spec, parse_args_spec, passthrough_event_spec, ) +from reflex_base.utils.exceptions import EventFnArgMismatchError from reflex_base.vars.base import Var from reflex_base.vars.number import NumberVar @@ -136,3 +140,46 @@ def record_keyword_only(key: Var, *, flag: int = 1) -> EventSpec: call_event_fn(record_kwargs, lambda a, b: [a, b], key="on_key_down") call_event_fn(record_keyword_only, lambda a, b: [a, b], key="on_key_down") assert received == [("_a",), ("_a", "1")] + + +class KeywordOnlyState(rx.State): + """A state whose handler takes a keyword-only argument no trigger passes.""" + + def handle(self, value: str, *, required: str): + """Take the trigger's value and an argument it never sends. + + Args: + value: The trigger's value. + required: An argument no trigger passes. + """ + + +def test_a_required_keyword_only_parameter_still_counts_as_required() -> None: + """A required keyword-only parameter fails the check, as a required positional one does. + + Neither an event handler, whose arguments are sent by name, nor a callable, + called with the trigger's arguments by position, ever gets it. + """ + + def record(value: Var, *, required: str) -> EventSpec: + return rx.noop() + + with pytest.raises(EventFnArgMismatchError) as handler_error: + call_event_handler( + cast(EventHandler, KeywordOnlyState.handle), + lambda value: [value], + key="on_change", + ) + with pytest.raises(EventFnArgMismatchError) as callable_error: + call_event_fn(record, lambda value: [value], key="on_change") + + assert str(handler_error.value) == ( + "Event on_change only provides 1 arguments, but " + "KeywordOnlyState.handle requires at least 2 arguments to be passed to " + "the event handler.\nSee https://reflex.dev/docs/events/event-arguments/" + ) + assert str(callable_error.value) == ( + "Event on_change only provides 1 arguments, but " + f"{record} requires at least 2 arguments to be passed to " + "the event handler.\nSee https://reflex.dev/docs/events/event-arguments/" + ) From f475bf255d1eff3a9cd9240ca7db8f3afff32e05 Mon Sep 17 00:00:00 2001 From: Farhan Date: Sun, 22 Nov 2026 02:18:28 +0000 Subject: [PATCH 3/3] Reject a callable whose keyword-only parameter has no default A function given to an event trigger gets the trigger's arguments by position, so a required keyword-only parameter can never be filled. It failed with a TypeError when the event fired; it now fails when the page is built, with an error that names the parameter and the fix. Claude-Session: https://claude.ai/code/session_01LwJUCVxPh3ihrnaFn6CWnf --- .../news/+varargs-event-callable.bugfix.md | 2 +- .../src/reflex_base/event/__init__.py | 32 ++++++++++++++ tests/units/reflex_base/event/test_init.py | 44 +++++++++++-------- 3 files changed, 59 insertions(+), 19 deletions(-) diff --git a/packages/reflex-base/news/+varargs-event-callable.bugfix.md b/packages/reflex-base/news/+varargs-event-callable.bugfix.md index c57b5eece1c..84d6e923587 100644 --- a/packages/reflex-base/news/+varargs-event-callable.bugfix.md +++ b/packages/reflex-base/news/+varargs-event-callable.bugfix.md @@ -1 +1 @@ -A callable passed to an event trigger gets the trigger's arguments only through its positional parameters: `lambda *args: ...` gets all of them, even none, and `lambda key, **kwargs: ...` or `lambda key, *, flag=1: ...` no longer raises `TypeError`. +A callable passed to an event trigger gets the trigger's arguments only through its positional parameters: `lambda *args: ...` gets all of them, even none, and `lambda key, **kwargs: ...` or `lambda key, *, flag=1: ...` no longer raises `TypeError`. A callable with a keyword-only parameter that has no default now fails when the page is built, with an error saying how to fix it. diff --git a/packages/reflex-base/src/reflex_base/event/__init__.py b/packages/reflex-base/src/reflex_base/event/__init__.py index 320c47cd399..b1597a981cd 100644 --- a/packages/reflex-base/src/reflex_base/event/__init__.py +++ b/packages/reflex-base/src/reflex_base/event/__init__.py @@ -2652,6 +2652,37 @@ def _max_positional_args(parameters: Mapping[str, inspect.Parameter]) -> int | N return count +def _check_no_required_keyword_only( + fn: Callable, parameters: Mapping[str, inspect.Parameter], key: str | None +) -> None: + """Reject a callable with a keyword-only parameter that has no default. + + A callable gets the trigger's arguments by position, so it never gets one. + + Args: + fn: The callable given to the event trigger. + parameters: Its parameters. + key: The name of the event trigger. + + Raises: + EventFnArgMismatchError: If it has a required keyword-only parameter. + """ + for parameter in parameters.values(): + if ( + parameter.kind is inspect.Parameter.KEYWORD_ONLY + and parameter.default is inspect.Parameter.empty + ): + msg = ( + f"Event {key} cannot pass the keyword-only argument " + f"{parameter.name!r} of {fn}: a function given to an event " + "trigger gets the trigger's arguments by position only. Give " + f"{parameter.name!r} a default value, or move it before the `*` " + "so it takes one of the trigger's arguments.\n" + "See https://reflex.dev/docs/events/event-arguments/" + ) + raise EventFnArgMismatchError(msg) + + def check_fn_match_arg_spec( user_func: Callable, user_func_parameters: Mapping[str, inspect.Parameter], @@ -2778,6 +2809,7 @@ def call_event_fn( parameters = inspect.signature(fn).parameters # Check that fn signature matches arg_spec + _check_no_required_keyword_only(fn, parameters, key) check_fn_match_arg_spec(fn, parameters, parsed_args, key=key) # Call the function with as many of the parsed args as it takes. diff --git a/tests/units/reflex_base/event/test_init.py b/tests/units/reflex_base/event/test_init.py index c2c0c8ab4e6..2e051eb132a 100644 --- a/tests/units/reflex_base/event/test_init.py +++ b/tests/units/reflex_base/event/test_init.py @@ -154,32 +154,40 @@ def handle(self, value: str, *, required: str): """ -def test_a_required_keyword_only_parameter_still_counts_as_required() -> None: - """A required keyword-only parameter fails the check, as a required positional one does. - - Neither an event handler, whose arguments are sent by name, nor a callable, - called with the trigger's arguments by position, ever gets it. - """ - - def record(value: Var, *, required: str) -> EventSpec: - return rx.noop() - - with pytest.raises(EventFnArgMismatchError) as handler_error: +def test_a_required_keyword_only_parameter_of_a_handler_still_counts_as_required() -> ( + None +): + """An event handler's arguments are sent by name, so the trigger must supply it.""" + with pytest.raises(EventFnArgMismatchError) as error: call_event_handler( cast(EventHandler, KeywordOnlyState.handle), lambda value: [value], key="on_change", ) - with pytest.raises(EventFnArgMismatchError) as callable_error: - call_event_fn(record, lambda value: [value], key="on_change") - assert str(handler_error.value) == ( + assert str(error.value) == ( "Event on_change only provides 1 arguments, but " "KeywordOnlyState.handle requires at least 2 arguments to be passed to " "the event handler.\nSee https://reflex.dev/docs/events/event-arguments/" ) - assert str(callable_error.value) == ( - "Event on_change only provides 1 arguments, but " - f"{record} requires at least 2 arguments to be passed to " - "the event handler.\nSee https://reflex.dev/docs/events/event-arguments/" + + +def test_a_callable_with_a_required_keyword_only_parameter_is_rejected() -> None: + """A callable gets the trigger's arguments by position, so it never gets one. + + It is rejected however many arguments the trigger provides. + """ + + def record(value: Var, *, required: str) -> EventSpec: + return rx.noop() + + with pytest.raises(EventFnArgMismatchError) as error: + call_event_fn(record, lambda a, b: [a, b], key="on_change") + + assert str(error.value) == ( + f"Event on_change cannot pass the keyword-only argument 'required' of " + f"{record}: a function given to an event trigger gets the trigger's " + "arguments by position only. Give 'required' a default value, or move it " + "before the `*` so it takes one of the trigger's arguments.\n" + "See https://reflex.dev/docs/events/event-arguments/" )