From 3a2c76af313de9f01362eb35b7a396dd26212cc8 Mon Sep 17 00:00:00 2001 From: Masen Furer Date: Mon, 14 Oct 2024 14:12:23 -0700 Subject: [PATCH] LiteralEventChainVar becomes an ArgsFunctionOperation Instead of using the ArgsFunctionOperation to create the string representation of the _js_expr, make the identity of the var an ArgsFunctionOperation so the _args_names and _return_expr remain accessible. Rely on the default behavior of ArgsFunctionOperation to create the _cached_var_name / _js_expr value. This allows the compat shim in `format_event_chain` to remain functional, as it does special handling for ArgsFunctionOperation to retain the previous behavior of that function (this was a regression introduced in 0.6.2). --- reflex/event.py | 60 +++++++++++++++++++------------------------------ 1 file changed, 23 insertions(+), 37 deletions(-) diff --git a/reflex/event.py b/reflex/event.py index 04879add3..538ed9538 100644 --- a/reflex/event.py +++ b/reflex/event.py @@ -1332,7 +1332,7 @@ class EventChainVar(FunctionVar): frozen=True, **{"slots": True} if sys.version_info >= (3, 10) else {}, ) -class LiteralEventChainVar(CachedVarOperation, LiteralVar, EventChainVar): +class LiteralEventChainVar(ArgsFunctionOperation, EventChainVar, LiteralVar): """A literal event chain var.""" _var_value: EventChain = dataclasses.field(default=None) # type: ignore @@ -1345,41 +1345,6 @@ class LiteralEventChainVar(CachedVarOperation, LiteralVar, EventChainVar): """ return hash((self.__class__.__name__, self._js_expr)) - @cached_property_no_lock - def _cached_var_name(self) -> str: - """The name of the var. - - Returns: - The name of the var. - """ - sig = inspect.signature(self._var_value.args_spec) # type: ignore - if sig.parameters: - arg_def = tuple((f"_{p}" for p in sig.parameters)) - arg_def_expr = LiteralVar.create([Var(_js_expr=arg) for arg in arg_def]) - else: - # add a default argument for addEvents if none were specified in value.args_spec - # used to trigger the preventDefault() on the event. - arg_def = ("...args",) - arg_def_expr = Var(_js_expr="args") - - if self._var_value.invocation is None: - invocation = FunctionStringVar.create("addEvents") - else: - invocation = self._var_value.invocation - - return str( - ArgsFunctionOperation.create( - arg_def, - invocation.call( - LiteralVar.create( - [LiteralVar.create(event) for event in self._var_value.events] - ), - arg_def_expr, - self._var_value.event_actions, - ), - ) - ) - @classmethod def create( cls, @@ -1395,10 +1360,31 @@ class LiteralEventChainVar(CachedVarOperation, LiteralVar, EventChainVar): Returns: The created LiteralEventChainVar instance. """ + sig = inspect.signature(value.args_spec) # type: ignore + if sig.parameters: + arg_def = tuple((f"_{p}" for p in sig.parameters)) + arg_def_expr = LiteralVar.create([Var(_js_expr=arg) for arg in arg_def]) + else: + # add a default argument for addEvents if none were specified in value.args_spec + # used to trigger the preventDefault() on the event. + arg_def = ("...args",) + arg_def_expr = Var(_js_expr="args") + + if value.invocation is None: + invocation = FunctionStringVar.create("addEvents") + else: + invocation = value.invocation + return cls( _js_expr="", - _var_type=EventChain, + _var_type=Callable, _var_data=_var_data, + _args_names=arg_def, + _return_expr=invocation.call( + LiteralVar.create([LiteralVar.create(event) for event in value.events]), + arg_def_expr, + value.event_actions, + ), _var_value=value, )