ENG-9860 fix(vars): preserve custom Field attributes in state metaclass (#6726)

* fix(vars): preserve custom Field attributes in state metaclass

BaseStateMeta rebuilt Field instances for state annotations, discarding
any custom attributes callers had set. Copy over attrs the rebuilt field
did not recompute via Field._copy_custom_attrs_from so subclassed or
customized fields keep their extra state.

* fix(vars): deep-copy custom Field attrs and skip reserved annotation

Fold custom-attribute copying into Field.__init__ via a source_field
parameter instead of the post-hoc _copy_custom_attrs_from helper.
Copied attrs are now deep-copied so mutable values aren't shared
between the original and rebuilt fields, and the reserved `annotation`
attribute is never carried over — get_field_type duck-types pydantic
fields on `.annotation`, so copying it would shadow the real class
annotation.

Author: FarhanAliRaza

packages/reflex-base/news/6726.bugfix.md

@@ -0,0 +1 @@
+Custom attributes set on a `Field` are now preserved (deep-copied) when the state metaclass rebuilds fields, instead of being silently discarded. The reserved `annotation` attribute is never carried over so rebuilt fields are not misidentified as pydantic fields.

packages/reflex-base/src/reflex_base/vars/base.py

@@ -3470,6 +3470,11 @@ def dispatch(
 
 FIELD_TYPE = TypeVar("FIELD_TYPE")
 
+# Custom attrs never copied from a source field: get_field_type duck-types
+# pydantic fields on `.annotation`, so carrying it over would shadow the
+# real class annotation.
+_RESERVED_FIELD_ATTRS = frozenset({"annotation"})
+
 
 class Field(Generic[FIELD_TYPE]):
     """A field for a state."""
@@ -3486,6 +3491,7 @@ def __init__(
         is_var: bool = True,
         annotated_type: GenericType  # pyright: ignore [reportRedeclaration]
         | _MISSING_TYPE = MISSING,
+        source_field: Field | None = None,
     ) -> None:
         """Initialize the field.
 
@@ -3494,6 +3500,8 @@ def __init__(
             default_factory: The default factory for the field.
             is_var: Whether the field is a Var.
             annotated_type: The annotated type for the field.
+            source_field: If given, deep-copy custom (non-reserved) attributes
+                from this field that the new field did not compute itself.
         """
         self.default = default
         self.default_factory = default_factory
@@ -3524,6 +3532,10 @@ def __init__(
             self.type_ = self.type_origin = type_origin
         else:
             self.outer_type_ = self.annotated_type = self.type_ = self.type_origin = Any
+        if source_field is not None:
+            for key, value in source_field.__dict__.items():
+                if key not in self.__dict__ and key not in _RESERVED_FIELD_ATTRS:
+                    self.__dict__[key] = copy.deepcopy(value)
 
     def default_value(self) -> FIELD_TYPE:
         """Get the default value for the field.
@@ -3770,12 +3782,14 @@ def __new__(
                         default=value.default,
                         is_var=value.is_var,
                         annotated_type=figure_out_type(value.default),
+                        source_field=value,
                     )
                 else:
                     new_value = Field(
                         default_factory=value.default_factory,
                         is_var=value.is_var,
                         annotated_type=Any,
+                        source_field=value,
                     )
             elif (
                 not key.startswith("__")
@@ -3825,6 +3839,7 @@ def __new__(
                     default_factory=value.default_factory,
                     is_var=value.is_var,
                     annotated_type=annotation,
+                    source_field=value,
                 )
 
             own_fields[key] = value

tests/units/reflex_base/vars/__init__.py

@@ -0,0 +1,80 @@
+"""Tests for reflex_base.vars.base state metaclass field handling."""
+
+from typing import Any
+
+from reflex_base.utils.types import get_field_type
+from reflex_base.vars.base import EvenMoreBasicBaseState, field
+
+_MARKER_ATTR = "_marker"
+
+
+def test_custom_field_attr_survives_annotated_rebuild():
+    """A custom attribute on an annotated Field survives a rebuild."""
+    f = field("x")
+    setattr(f, _MARKER_ATTR, "tag")
+
+    class MyState(EvenMoreBasicBaseState):
+        name: str = f  # pyright: ignore[reportAssignmentType]
+
+    rebuilt = MyState.get_fields()["name"]
+    assert getattr(rebuilt, _MARKER_ATTR, None) == "tag"
+    assert rebuilt.annotated_type is str
+
+
+def test_custom_field_attr_survives_unannotated_rebuild():
+    """A custom attribute survives an inferred-type Field rebuild."""
+    f = field(0)
+    setattr(f, _MARKER_ATTR, "tag")
+
+    class MyState(EvenMoreBasicBaseState):
+        count = f
+
+    rebuilt = MyState.get_fields()["count"]
+    assert getattr(rebuilt, _MARKER_ATTR, None) == "tag"
+    assert rebuilt.annotated_type is int
+
+
+def test_custom_field_attr_survives_unannotated_factory_rebuild():
+    """A custom attribute survives a default-factory Field rebuild."""
+    f = field(default_factory=list)
+    setattr(f, _MARKER_ATTR, "tag")
+
+    class MyState(EvenMoreBasicBaseState):
+        items = f
+
+    rebuilt = MyState.get_fields()["items"]
+    assert getattr(rebuilt, _MARKER_ATTR, None) == "tag"
+    assert rebuilt.annotated_type is Any
+
+
+def test_reserved_annotation_attr_not_copied():
+    """A custom `annotation` attr must not make the rebuilt Field look pydantic.
+
+    get_field_type duck-types __fields__ entries on `.annotation`, so copying
+    it would shadow the real class annotation.
+    """
+    f = field("x")
+    f.annotation = int  # pyright: ignore[reportAttributeAccessIssue]
+
+    class MyState(EvenMoreBasicBaseState):
+        name: str = f  # pyright: ignore[reportAssignmentType]
+
+    rebuilt = MyState.get_fields()["name"]
+    assert "annotation" not in rebuilt.__dict__
+    assert get_field_type(MyState, "name") is str
+
+
+def test_custom_mutable_attr_is_deepcopied():
+    """Mutable custom attrs are deep-copied, not shared by reference."""
+    f = field("x")
+    opts = {"a": [1]}
+    f._opts = opts  # pyright: ignore[reportAttributeAccessIssue]
+
+    class MyState(EvenMoreBasicBaseState):
+        name: str = f  # pyright: ignore[reportAssignmentType]
+
+    rebuilt = MyState.get_fields()["name"]
+    assert rebuilt._opts == {"a": [1]}  # pyright: ignore[reportAttributeAccessIssue]
+    assert rebuilt._opts is not opts  # pyright: ignore[reportAttributeAccessIssue]
+    opts["a"].append(2)
+    assert rebuilt._opts == {"a": [1]}  # pyright: ignore[reportAttributeAccessIssue]