Only serialize used rx.Base fields

reflex/base.py

@@ -3,14 +3,35 @@
 from __future__ import annotations
 
 import os
-from typing import TYPE_CHECKING, Any, List, Type
+from typing import TYPE_CHECKING, Any, ClassVar, List, Optional, Type, Union
+
+if TYPE_CHECKING:
+    from reflex.utils.types import override
+else:
+
+    def override(fn):
+        """Decorator to indicate that a method is meant to override a parent method.
+
+        Args:
+            fn: The method to override.
+
+        Returns:
+            The unmodified method.
+        """
+        return fn
+
 
 try:
+    if TYPE_CHECKING:
+        from pydantic.v1.typing import AbstractSetIntStr, MappingIntStrAny
     import pydantic.v1.main as pydantic_main
     from pydantic.v1 import BaseModel
     from pydantic.v1.fields import ModelField
+
 except ModuleNotFoundError:
-    if not TYPE_CHECKING:
+    if TYPE_CHECKING:
+        from pydantic.typing import AbstractSetIntStr, MappingIntStrAny
+    else:
         import pydantic.main as pydantic_main
         from pydantic import BaseModel
         from pydantic.fields import ModelField  # type: ignore
@@ -48,6 +69,15 @@ def validate_field_name(bases: List[Type["BaseModel"]], field_name: str) -> None
 pydantic_main.validate_field_name = validate_field_name  # type: ignore
 
 
+class UsedSerialization:
+    """A mixin which allows tracking of fields used in the frontend.
+    You can subclass this and add a @rx.serializer which uses the __used_fields__ attribute to only serialize used fields.
+    Take a look at SlimBase for an example implementation.
+    """
+
+    __used_fields__: ClassVar[set[str]] = set()
+
+
 class Base(BaseModel):  # pyright: ignore [reportUnboundVariable]
     """The base class subclassed by all Reflex classes.
 
@@ -143,3 +173,49 @@ def get_value(self, key: str) -> Any:
             exclude_defaults=False,
             exclude_none=False,
         )
+
+
+class SlimBase(Base, UsedSerialization):
+    """A slimmed down version of the Base class.
+    Only used fields will be included in the dict for serialization.
+    """
+
+    @override
+    def dict(
+        self,
+        *,
+        include: Optional[Union[AbstractSetIntStr, MappingIntStrAny]] = None,
+        exclude: Optional[Union[AbstractSetIntStr, MappingIntStrAny]] = None,
+        by_alias: bool = False,
+        skip_defaults: Optional[bool] = None,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+    ) -> dict[str, Any]:
+        """Convert the object to a dict.
+
+        We override the default dict method to only include fields that are used.
+
+        Args:
+            include: The fields to include.
+            exclude: The fields to exclude.
+            by_alias: Whether to use the alias names.
+            skip_defaults: Whether to skip default values.
+            exclude_unset: Whether to exclude unset values.
+            exclude_defaults: Whether to exclude default values.
+            exclude_none: Whether to exclude None values.
+
+        Returns:
+            The object as a dict.
+        """
+        if not include and isinstance(self, UsedSerialization):
+            include = self.__used_fields__
+        return super().dict(
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            skip_defaults=skip_defaults,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )

reflex/ivars/object.py

@@ -20,6 +20,7 @@
     overload,
 )
 
+from reflex.base import UsedSerialization
 from reflex.utils import types
 from reflex.utils.exceptions import VarAttributeError
 from reflex.utils.types import GenericType, get_attribute_access_type, get_origin
@@ -267,6 +268,10 @@ def __getattr__(self, name) -> ImmutableVar:
                     f"The State var `{str(self)}` has no attribute '{name}' or may have been annotated "
                     f"wrongly."
                 )
+
+            if issubclass(fixed_type, UsedSerialization):
+                fixed_type.__used_fields__.add(name)
+
             return ObjectItemOperation.create(self, name, attribute_type).guess_type()
         else:
             return ObjectItemOperation.create(self, name).guess_type()

tests/utils/test_serializers.py

@@ -5,9 +5,10 @@
 
 import pytest
 
-from reflex.base import Base
+from reflex.base import Base, SlimBase
 from reflex.components.core.colors import Color
 from reflex.ivars.base import ImmutableVar, LiteralVar
+from reflex.state import State
 from reflex.utils import serializers
 
 
@@ -119,6 +120,33 @@ class BaseSubclass(Base):
     ts: datetime.timedelta = datetime.timedelta(1, 1, 1)
 
 
+class SlimBaseSubclass(SlimBase):
+    """A class inheriting from SlimBase for testing."""
+
+    ts: datetime.timedelta = datetime.timedelta(1, 1, 1)
+
+
+def test_slim_base_subclass():
+    """Test that a SlimBase subclass is serialized correctly."""
+
+    class SlimState(State):
+        """A test state."""
+
+        slim: SlimBaseSubclass = SlimBaseSubclass(ts=datetime.timedelta(1, 1, 1))
+
+    state = SlimState()
+    assert SlimBaseSubclass.__used_fields__ == set()
+    assert serializers.serialize(state.slim) == "({  })"
+
+    # Access the field
+    SlimState.slim.ts
+    assert SlimBaseSubclass.__used_fields__ == {"ts"}
+    assert serializers.serialize(state.slim) == '({ ["ts"] : "1 day, 0:00:01.000001" })'
+
+    # Reset the used fields tracking set.
+    SlimBaseSubclass.__used_fields__ = set()
+
+
 @pytest.mark.parametrize(
     "value,expected",
     [
@@ -153,6 +181,10 @@ class BaseSubclass(Base):
             BaseSubclass(ts=datetime.timedelta(1, 1, 1)),
             '({ ["ts"] : "1 day, 0:00:01.000001" })',
         ),
+        (
+            SlimBaseSubclass(ts=datetime.timedelta(1, 1, 1)),
+            "({  })",
+        ),
         (
             [1, LiteralVar.create("hi"), ImmutableVar.create("bye")],
             '[1, "hi", bye]',