Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -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.
78 changes: 70 additions & 8 deletions packages/reflex-base/src/reflex_base/event/__init__.py
Original file line number Diff line number Diff line change
Expand Up @@ -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],
Expand All @@ -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
Comment thread
FarhanAliRaza marked this conversation as resolved.
Resolved
]
# 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
Expand Down Expand Up @@ -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.
Expand Down
93 changes: 93 additions & 0 deletions tests/units/reflex_base/event/test_init.py
Original file line number Diff line number Diff line change
Expand Up @@ -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

Expand Down Expand Up @@ -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/"
)
Loading