perf: speed up component construction hot path

Pre-resolve each class's field defaults at metaclass time into immutable
defaults, factory defaults, and required-field buckets, so BaseComponent's
__init__ no longer dispatches through BaseField.default_value per instance.

In BaseComponent.__init__ and Component.__init__, write fields via
vars(self).update(...) instead of setattr to bypass the freeze guard in
__setattr__ — a brand-new instance can't be frozen, so the per-attribute
check is pure overhead during init.

Other tweaks in Component.__init__:
- Lazily allocate event_triggers only when a trigger is actually seen;
  most components have none, so the up-front dict copy was wasted work.
- Single-pass kwargs loop that handles event triggers, var props, and
  unknown on_* errors inline instead of double-iterating.
- Warn when field(default=...) is given a mutable default; nudge users
  toward default_factory.
- Defer the _validate_children imports until after the fast no-op exit.

Author: FarhanAliRaza

packages/reflex-base/src/reflex_base/components/component.py

@@ -129,6 +129,11 @@ def field(
     if default is not MISSING and default_factory is not None:
         msg = "cannot specify both default and default_factory"
         raise ValueError(msg)
+    if default is not MISSING and not types.is_immutable(default):
+        console.warn(
+            "Mutable default values are not recommended. "
+            "Use default_factory instead to avoid unexpected behavior."
+        )
     return ComponentField(  # pyright: ignore [reportReturnType]
         default=default,
         default_factory=default_factory,
@@ -146,6 +151,9 @@ class BaseComponentMeta(FieldBasedMeta, ABCMeta):
         _own_fields: Mapping[str, ComponentField]
         _fields: Mapping[str, ComponentField]
         _js_fields: Mapping[str, ComponentField]
+        _immutable_field_defaults: Mapping[str, Any]
+        _factory_field_defaults: Mapping[str, Callable[[], Any]]
+        _required_fields: tuple[str, ...]
 
     @classmethod
     def _process_annotated_fields(
@@ -306,11 +314,23 @@ def __init__(
         """
         if "children" in kwargs:
             kwargs["children"] = tuple(kwargs["children"])
-        for key, value in kwargs.items():
-            setattr(self, key, value)
-        for name, value in self.get_fields().items():
+        # Bypass ``__setattr__``'s freeze guard: a brand-new instance can't be
+        # frozen, so the per-attribute check is pure overhead during init.
+        d = vars(self)
+        d.update(kwargs)
+        cls = type(self)
+        # Defaults are pre-resolved by the metaclass into immutable/factory
+        # buckets, so we avoid the ``BaseField.default_value`` dispatch.
+        for name, default in cls._immutable_field_defaults.items():
             if name not in kwargs:
-                setattr(self, name, value.default_value())
+                d[name] = default
+        for name, factory in cls._factory_field_defaults.items():
+            if name not in kwargs:
+                d[name] = factory()
+        for name in cls._required_fields:
+            if name not in kwargs:
+                msg = f"Field `{name}` of `{cls.__name__}` requires a value."
+                raise ValueError(msg)
 
     def __setattr__(self, key: str, value: Any) -> None:
         """Block writes to frozen components, except for cache attributes.
@@ -946,76 +966,70 @@ def _post_init(self, *args, **kwargs):
         component_specific_triggers = self.get_event_triggers()
         props = self.get_props()
 
-        # Add any events triggers.
-        if "event_triggers" not in kwargs:
-            kwargs["event_triggers"] = {}
-        kwargs["event_triggers"] = kwargs["event_triggers"].copy()
+        # Lazily allocate the event_triggers dict only when a trigger is found.
+        # Most components have no events; allocating up-front is pure waste.
+        existing_triggers = kwargs.get("event_triggers")
+        event_triggers: dict[str, Any] | None = (
+            dict(existing_triggers) if existing_triggers else None
+        )
+        event_keys: list[str] = []
 
         # Iterate through the kwargs and set the props.
         for key, value in kwargs.items():
-            if (
-                key.startswith("on_")
-                and key not in component_specific_triggers
-                and key not in props
-            ):
-                valid_triggers = sorted(component_specific_triggers.keys())
-                msg = (
-                    f"The {(comp_name := type(self).__name__)} does not take in an `{key}` event trigger. "
-                    f"Valid triggers for {comp_name}: {valid_triggers}. "
-                    f"If {comp_name} is a third party component make sure to add `{key}` to the component's event triggers. "
-                    f"visit https://reflex.dev/docs/wrapping-react/guide/#event-triggers for more info."
-                )
-                raise ValueError(msg)
             if key in component_specific_triggers:
-                # Event triggers are bound to event chains.
-                is_var = False
-            elif key in props:
-                # Set the field type.
-                is_var = (
-                    field.type_origin is Var if (field := fields.get(key)) else False
+                if event_triggers is None:
+                    event_triggers = {}
+                event_triggers[key] = EventChain.create(
+                    value=value,
+                    args_spec=component_specific_triggers[key],
+                    key=key,
                 )
-            else:
+                event_keys.append(key)
                 continue
 
-            # Check whether the key is a component prop.
-            if is_var:
+            if key in props:
+                field = fields.get(key)
+                if field is None or field.type_origin is not Var:
+                    continue
                 try:
                     kwargs[key] = LiteralVar.create(value)
-
-                    # Get the passed type and the var type.
                     passed_type = kwargs[key]._var_type
                     expected_type = typing.get_args(
                         types.get_field_type(type(self), key)
                     )[0]
                 except TypeError:
-                    # If it is not a valid var, check the base types.
                     passed_type = type(value)
                     expected_type = types.get_field_type(type(self), key)
 
                 if not satisfies_type_hint(value, expected_type):
                     value_name = value._js_expr if isinstance(value, Var) else value
-
                     additional_info = (
                         " You can call `.bool()` on the value to convert it to a boolean."
                         if expected_type is bool and isinstance(value, Var)
                         else ""
                     )
-
                     raise TypeError(
                         f"Invalid var passed for prop {type(self).__name__}.{key}, expected type {expected_type}, got value {value_name} of type {passed_type}."
                         + additional_info
                     )
-            # Check if the key is an event trigger.
-            if key in component_specific_triggers:
-                kwargs["event_triggers"][key] = EventChain.create(
-                    value=value,
-                    args_spec=component_specific_triggers[key],
-                    key=key,
+                continue
+
+            if key.startswith("on_"):
+                valid_triggers = sorted(component_specific_triggers.keys())
+                comp_name = type(self).__name__
+                msg = (
+                    f"The {comp_name} does not take in an `{key}` event trigger. "
+                    f"Valid triggers for {comp_name}: {valid_triggers}. "
+                    f"If {comp_name} is a third party component make sure to add `{key}` to the component's event triggers. "
+                    f"visit https://reflex.dev/docs/wrapping-react/guide/#event-triggers for more info."
                 )
+                raise ValueError(msg)
 
-        # Remove any keys that were added as events.
-        for key in kwargs["event_triggers"]:
-            kwargs.pop(key, None)
+        # Promote any registered event triggers; drop the raw on_* keys.
+        if event_triggers is not None:
+            kwargs["event_triggers"] = event_triggers
+            for key in event_keys:
+                kwargs.pop(key, None)
 
         # Place data_ and aria_ attributes into custom_attrs
         special_attributes = [
@@ -1086,9 +1100,9 @@ def _post_init(self, *args, **kwargs):
         ):
             msg = f"Invalid class_name passed for prop {type(self).__name__}.class_name, expected type str, got value {class_name._js_expr} of type {class_name._var_type}."
             raise TypeError(msg)
-        # Construct the component.
-        for key, value in kwargs.items():
-            setattr(self, key, value)
+        # Construct the component. Bypass ``__setattr__``'s freeze guard: the
+        # instance is freshly created and not yet frozen.
+        vars(self).update(kwargs)
 
     @classmethod
     def get_event_triggers(cls) -> dict[str, types.ArgsSpec | Sequence[types.ArgsSpec]]:
@@ -1300,8 +1314,8 @@ def _unsafe_create(
         children_tuple = tuple(children)
         comp = cls.__new__(cls)
         super(Component, comp).__init__(id=props.get("id"), children=children_tuple)
-        for prop, value in props.items():
-            setattr(comp, prop, value)
+        # Bypass ``__setattr__``'s freeze guard: ``comp`` is not yet frozen.
+        vars(comp).update(props)
         comp._freeze()
         return comp
 
@@ -1533,19 +1547,18 @@ def _validate_component_children(self, children: list[Component]):
             children: The children of the component.
 
         """
-        from reflex_components_core.base.fragment import Fragment
-        from reflex_components_core.core.cond import Cond
-        from reflex_components_core.core.foreach import Foreach
-        from reflex_components_core.core.match import Match
-
-        no_valid_parents_defined = all(child._valid_parents == [] for child in children)
         if (
             not self._invalid_children
             and not self._valid_children
-            and no_valid_parents_defined
+            and all(child._valid_parents == [] for child in children)
         ):
             return
 
+        from reflex_components_core.base.fragment import Fragment
+        from reflex_components_core.core.cond import Cond
+        from reflex_components_core.core.foreach import Foreach
+        from reflex_components_core.core.match import Match
+
         comp_name = type(self).__name__
         allowed_components = [
             comp.__name__ for comp in (Fragment, Foreach, Cond, Match)

packages/reflex-base/src/reflex_base/components/field.py

@@ -181,3 +181,19 @@ def _finalize_fields(
         namespace["_own_fields"] = own_fields
         namespace["_inherited_fields"] = inherited_fields
         namespace["_fields"] = all_fields
+
+        # Pre-resolve defaults at class definition time so per-instance ``__init__``
+        # can skip the ``BaseField.default_value`` dispatch entirely.
+        immutable_defaults: dict[str, Any] = {}
+        factory_defaults: dict[str, Callable[[], Any]] = {}
+        required_fields: list[str] = []
+        for field_name, field in all_fields.items():
+            if field.default is not MISSING:
+                immutable_defaults[field_name] = field.default
+            elif field.default_factory is not None:
+                factory_defaults[field_name] = field.default_factory
+            else:
+                required_fields.append(field_name)
+        namespace["_immutable_field_defaults"] = immutable_defaults
+        namespace["_factory_field_defaults"] = factory_defaults
+        namespace["_required_fields"] = tuple(required_fields)