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..84d6e923587 --- /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 `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 63844816912..b1597a981cd 100644 --- a/packages/reflex-base/src/reflex_base/event/__init__.py +++ b/packages/reflex-base/src/reflex_base/event/__init__.py @@ -2624,6 +2624,65 @@ def args_specs_from_fields( } +# The parameter kinds that take any number of arguments, none included. +_VARIADIC_PARAMETER_KINDS = ( + inspect.Parameter.VAR_POSITIONAL, + inspect.Parameter.VAR_KEYWORD, +) + + +def _max_positional_args(parameters: Mapping[str, inspect.Parameter]) -> int | None: + """Get how many of a trigger's arguments a function takes by position. + + Args: + parameters: The parameters of the function. + + Returns: + The number of its positional parameters, or None when it takes ``*args``. + """ + 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_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], @@ -2646,15 +2705,19 @@ def check_fn_match_arg_spec( Raises: EventFnArgMismatchError: Raised if the number of mandatory arguments do not match """ - user_args = list(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:] 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 @@ -2746,12 +2809,11 @@ 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) - 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..2e051eb132a 100644 --- a/tests/units/reflex_base/event/test_init.py +++ b/tests/units/reflex_base/event/test_init.py @@ -2,17 +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 @@ -98,3 +104,90 @@ 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")] + + +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_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", + ) + + 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/" + ) + + +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/" + )