Handle args_spec partial args for FunctionVar

When a FunctionVar is passed to an event trigger with a given args_spec,
transform it into a partial function that applies the transformed arguments
when called. This allows FunctionVar handlers to work with on_blur and
on_submit, which, by default, use the args_spec to transform the value before
passing it off to the handler.

Some escape hatches:
  * The behavior for EventChainVar is unchanged, so previous code that was
    explicitly casting functions to EventChain will continue to work without
    modification.
  * If the FunctionVar is returned through a lambda, no partial application is
    applied, because that happens at the point the lambda is called, so the
    return value of the lambda is responsible for mapping the arguments if
    desired.

This change also allows event handler lambda functions to return a
heterogeneous mix of EventSpec/EventHandler/FunctionVar (and EventChain
returned from lambda are treated as FunctionVar, allowing arbitrary nesting).

Update FunctionVar.partial such that passing no args does NOT create a new
useless function.

Author: masenf

reflex/event.py

@@ -520,21 +520,14 @@ def create(
                 if isinstance(v, (EventHandler, EventSpec)):
                     # Call the event handler to get the event.
                     events.append(call_event_handler(v, args_spec, key=key))
-                elif isinstance(v, (EventVar, FunctionVar)):
+                elif isinstance(v, (EventVar, EventChainVar)):
                     events.append(v)
+                elif isinstance(v, FunctionVar):
+                    # Apply the args_spec transformations as partial arguments to the function.
+                    events.append(v.partial(*parse_args_spec(args_spec)[0]))
                 elif isinstance(v, Callable):
                     # Call the lambda to get the event chain.
-                    result = call_event_fn(v, args_spec, key=key)
-                    if isinstance(result, Var):
-                        if isinstance(result, (EventVar, FunctionVar)):
-                            events.append(result)
-                            continue
-                        msg = (
-                            f"Invalid event chain: {v}. Cannot use a Var-returning "
-                            "lambda inside an EventChain list."
-                        )
-                        raise ValueError(msg)
-                    events.extend(result)
+                    events.extend(call_event_fn(v, args_spec, key=key))
                 else:
                     msg = f"Invalid event: {v}"
                     raise ValueError(msg)
@@ -1783,7 +1776,7 @@ def call_event_fn(
     fn: Callable,
     arg_spec: ArgsSpec | Sequence[ArgsSpec],
     key: str | None = None,
-) -> list[EventSpec] | Var:
+) -> list[EventSpec | FunctionVar]:
     """Call a function to a list of event specs.
 
     The function should return a single EventSpec, a list of EventSpecs, or a
@@ -1816,10 +1809,6 @@ def call_event_fn(
     # Call the function with the parsed args.
     out = fn(*[*parsed_args][:number_of_fn_args])
 
-    # If the function returns a Var, assume it's an EventChain and render it directly.
-    if isinstance(out, Var):
-        return out
-
     # Convert the output to a list.
     if not isinstance(out, list):
         out = [out]
@@ -1831,9 +1820,20 @@ def call_event_fn(
             # An un-called EventHandler gets all of the args of the event trigger.
             e = call_event_handler(e, arg_spec, key=key)
 
+        if isinstance(e, EventChain):
+            # Nested EventChain is treated like a FunctionVar.
+            e = Var.create(e)
+
         # Make sure the event spec is valid.
-        if not isinstance(e, EventSpec):
-            msg = f"Lambda {fn} returned an invalid event spec: {e}."
+        if not isinstance(e, (EventSpec, FunctionVar)):
+            hint = ""
+            if isinstance(e, VarOperationCall):
+                hint = " Hint: use `fn.partial(...)` instead of calling the FunctionVar directly."
+            msg = (
+                f"Invalid event chain for {key}: {fn} -> {e}: A lambda inside an EventChain "
+                "list must return `EventSpec | EventHandler | FunctionVar` or heterogeneous list of these types. "
+                f"Got: {type(e)}.{hint}"
+            )
             raise EventHandlerValueError(msg)
 
         # Add the event spec to the chain.

reflex/vars/function.py

@@ -186,7 +186,7 @@ def partial(self, *args: Var | Any) -> FunctionVar:  # pyright: ignore [reportIn
             The partially applied function.
         """
         if not args:
-            return ArgsFunctionOperation.create((), self)
+            return self
         return ArgsFunctionOperation.create(
             ("...args",),
             VarOperationCall.create(self, *args, Var(_js_expr="...args")),