mark var methods as private (#4319)

reflex/components/component.py

@@ -1450,7 +1450,7 @@ class Component(BaseComponent, ABC):
         """
         ref = self.get_ref()
         if ref is not None:
-            return f"const {ref} = useRef(null); {str(Var(_js_expr=ref).as_ref())} = {ref};"
+            return f"const {ref} = useRef(null); {str(Var(_js_expr=ref)._as_ref())} = {ref};"
 
     def _get_vars_hooks(self) -> dict[str, None]:
         """Get the hooks required by vars referenced in this component.

reflex/components/el/elements/forms.py

@@ -239,13 +239,13 @@ class Form(BaseHTML):
             # when ref start with refs_ it's an array of refs, so we need different method
             # to collect data
             if ref.startswith("refs_"):
-                ref_var = Var(_js_expr=ref[:-3]).as_ref()
+                ref_var = Var(_js_expr=ref[:-3])._as_ref()
                 form_refs[ref[len("refs_") : -3]] = Var(
                     _js_expr=f"getRefValues({str(ref_var)})",
                     _var_data=VarData.merge(ref_var._get_all_var_data()),
                 )
             else:
-                ref_var = Var(_js_expr=ref).as_ref()
+                ref_var = Var(_js_expr=ref)._as_ref()
                 form_refs[ref[4:]] = Var(
                     _js_expr=f"getRefValue({str(ref_var)})",
                     _var_data=VarData.merge(ref_var._get_all_var_data()),

reflex/components/plotly/plotly.py

@@ -265,7 +265,7 @@ const extractPoints = (points) => {
             merge_dicts.append(layout_dict)
         if self.template is not None:
             template_dict = LiteralVar.create({"layout": {"template": self.template}})
-            merge_dicts.append(template_dict.without_data())
+            merge_dicts.append(template_dict._without_data())
         if merge_dicts:
             tag.special_props.append(
                 # Merge all dictionaries and spread the result over props.

reflex/components/radix/themes/color_mode.py

@@ -203,5 +203,5 @@ class ColorModeNamespace(Var):
 color_mode = color_mode_var_and_namespace = ColorModeNamespace(
     _js_expr=color_mode._js_expr,
     _var_type=color_mode._var_type,
-    _var_data=color_mode.get_default_value(),
+    _var_data=color_mode._get_default_value(),
 )

reflex/components/radix/themes/color_mode.pyi

@@ -449,5 +449,5 @@ class ColorModeNamespace(Var):
 color_mode = color_mode_var_and_namespace = ColorModeNamespace(
     _js_expr=color_mode._js_expr,
     _var_type=color_mode._var_type,
-    _var_data=color_mode.get_default_value(),
+    _var_data=color_mode._get_default_value(),
 )

reflex/state.py

@@ -1036,9 +1036,9 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         Args:
             prop: The var to create a setter for.
         """
-        setter_name = prop.get_setter_name(include_state=False)
+        setter_name = prop._get_setter_name(include_state=False)
         if setter_name not in cls.__dict__:
-            event_handler = cls._create_event_handler(prop.get_setter())
+            event_handler = cls._create_event_handler(prop._get_setter())
             cls.event_handlers[setter_name] = event_handler
             setattr(cls, setter_name, event_handler)
 
@@ -1052,7 +1052,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         # Get the pydantic field for the var.
         field = cls.get_fields()[prop._var_field_name]
         if field.required:
-            default_value = prop.get_default_value()
+            default_value = prop._get_default_value()
             if default_value is not None:
                 field.required = False
                 field.default = default_value
@@ -1079,7 +1079,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             return getattr(cls, name)
         except AttributeError:
             try:
-                return Var("", _var_type=annotation_value).get_default_value()
+                return Var("", _var_type=annotation_value)._get_default_value()
             except TypeError:
                 pass
         return None

reflex/vars/base.py

@@ -734,7 +734,7 @@ class Var(Generic[VAR_TYPE]):
 
         return self
 
-    def get_default_value(self) -> Any:
+    def _get_default_value(self) -> Any:
         """Get the default value of the var.
 
         Returns:
@@ -777,7 +777,7 @@ class Var(Generic[VAR_TYPE]):
                 ) from e
         return set() if issubclass(type_, set) else None
 
-    def get_setter_name(self, include_state: bool = True) -> str:
+    def _get_setter_name(self, include_state: bool = True) -> str:
         """Get the name of the var's generated setter function.
 
         Args:
@@ -794,7 +794,7 @@ class Var(Generic[VAR_TYPE]):
             return setter
         return ".".join((var_data.state, setter))
 
-    def get_setter(self) -> Callable[[BaseState, Any], None]:
+    def _get_setter(self) -> Callable[[BaseState, Any], None]:
         """Get the var's setter function.
 
         Returns:
@@ -820,7 +820,7 @@ class Var(Generic[VAR_TYPE]):
             else:
                 setattr(state, actual_name, value)
 
-        setter.__qualname__ = self.get_setter_name()
+        setter.__qualname__ = self._get_setter_name()
 
         return setter
 
@@ -953,7 +953,7 @@ class Var(Generic[VAR_TYPE]):
             else PROTOTYPE_TO_STRING.call(self).to(StringVar)
         )
 
-    def as_ref(self) -> Var:
+    def _as_ref(self) -> Var:
         """Get a reference to the var.
 
         Returns:
@@ -998,7 +998,7 @@ class Var(Generic[VAR_TYPE]):
         type_of = FunctionStringVar("typeof")
         return type_of.call(self).to(StringVar)
 
-    def without_data(self):
+    def _without_data(self):
         """Create a copy of the var without the data.
 
         Returns:
@@ -1006,20 +1006,6 @@ class Var(Generic[VAR_TYPE]):
         """
         return dataclasses.replace(self, _var_data=None)
 
-    def contains(self, value: Any = None, field: Any = None):
-        """Get an attribute of the var.
-
-        Args:
-            value: The value to check for.
-            field: The field to check for.
-
-        Raises:
-            TypeError: If the var does not support contains check.
-        """
-        raise TypeError(
-            f"Var of type {self._var_type} does not support contains check."
-        )
-
     def __get__(self, instance: Any, owner: Any):
         """Get the var.
 
@@ -1032,14 +1018,6 @@ class Var(Generic[VAR_TYPE]):
         """
         return self
 
-    def reverse(self):
-        """Reverse the var.
-
-        Raises:
-            TypeError: If the var does not support reverse.
-        """
-        raise TypeError("Cannot reverse non-list var.")
-
     def __getattr__(self, name: str):
         """Get an attribute of the var.
 
@@ -1056,6 +1034,13 @@ class Var(Generic[VAR_TYPE]):
         if name.startswith("_"):
             return self.__getattribute__(name)
 
+        if name == "contains":
+            raise TypeError(
+                f"Var of type {self._var_type} does not support contains check."
+            )
+        if name == "reverse":
+            raise TypeError("Cannot reverse non-list var.")
+
         if self._var_type is Any:
             raise TypeError(
                 f"You must provide an annotation for the state var `{str(self)}`. Annotation cannot be `{self._var_type}`."
@@ -1084,10 +1069,7 @@ class Var(Generic[VAR_TYPE]):
         try:
             return json.loads(str(self))
         except ValueError:
-            try:
+            return str(self)
-                return json.loads(self.json())
-            except (ValueError, NotImplementedError):
-                return str(self)
 
     @property
     def _var_state(self) -> str:
@@ -1165,14 +1147,6 @@ class Var(Generic[VAR_TYPE]):
             "'in' operator not supported for Var types, use Var.contains() instead."
         )
 
-    def json(self) -> str:
-        """Serialize the var to a JSON string.
-
-        Raises:
-            NotImplementedError: If the method is not implemented.
-        """
-        raise NotImplementedError("Var subclasses must implement the json method.")
-
 
 OUTPUT = TypeVar("OUTPUT", bound=Var)
 

tests/units/test_var.py

@@ -211,7 +211,7 @@ def test_str(prop, expected):
 
 
 @pytest.mark.parametrize(
-    "prop,expected",
+    ("prop", "expected"),
     [
         (Var(_js_expr="p", _var_type=int), 0),
         (Var(_js_expr="p", _var_type=float), 0.0),
@@ -223,14 +223,14 @@ def test_str(prop, expected):
         (Var(_js_expr="p", _var_type=set), set()),
     ],
 )
-def test_default_value(prop, expected):
+def test_default_value(prop: Var, expected):
     """Test that the default value of a var is correct.
 
     Args:
         prop: The var to test.
         expected: The expected default value.
     """
-    assert prop.get_default_value() == expected
+    assert prop._get_default_value() == expected
 
 
 @pytest.mark.parametrize(
@@ -246,14 +246,14 @@ def test_default_value(prop, expected):
         ],
     ),
 )
-def test_get_setter(prop, expected):
+def test_get_setter(prop: Var, expected):
     """Test that the name of the setter function of a var is correct.
 
     Args:
         prop: The var to test.
         expected: The expected name of the setter function.
     """
-    assert prop.get_setter_name() == expected
+    assert prop._get_setter_name() == expected
 
 
 @pytest.mark.parametrize(
@@ -1302,7 +1302,6 @@ def test_fstring_roundtrip(value):
         Var(_js_expr="var", _var_type=float).guess_type(),
         Var(_js_expr="var", _var_type=str).guess_type(),
         Var(_js_expr="var", _var_type=bool).guess_type(),
-        Var(_js_expr="var", _var_type=dict).guess_type(),
         Var(_js_expr="var", _var_type=None).guess_type(),
     ],
 )
@@ -1323,10 +1322,10 @@ def test_unsupported_types_for_reverse(var):
         Var(_js_expr="var", _var_type=int).guess_type(),
         Var(_js_expr="var", _var_type=float).guess_type(),
         Var(_js_expr="var", _var_type=bool).guess_type(),
-        Var(_js_expr="var", _var_type=None).guess_type(),
+        Var(_js_expr="var", _var_type=type(None)).guess_type(),
     ],
 )
-def test_unsupported_types_for_contains(var):
+def test_unsupported_types_for_contains(var: Var):
     """Test that unsupported types for contains throw a type error.
 
     Args: