reflex 0.6.8a2__py3-none-any.whl → 0.7.0a1__py3-none-any.whl

reflex/vars/number.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import dataclasses
 import json
 import math
-import sys
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -18,9 +17,8 @@ from typing import (
 )
 
 from reflex.constants.base import Dirs
-from reflex.utils.exceptions import PrimitiveUnserializableToJSON, VarTypeError
+from reflex.utils.exceptions import PrimitiveUnserializableToJSONError, VarTypeError
 from reflex.utils.imports import ImportDict, ImportVar
-from reflex.utils.types import is_optional
 
 from .base import (
     CustomVarOperationReturn,
@@ -32,7 +30,7 @@ from .base import (
     var_operation_return,
 )
 
-NUMBER_T = TypeVar("NUMBER_T", int, float, Union[int, float], bool)
+NUMBER_T = TypeVar("NUMBER_T", int, float, bool)
 
 if TYPE_CHECKING:
     from .sequence import ArrayVar
@@ -62,7 +60,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __add__(self, other: number_types) -> NumberVar: ...
 
     @overload
-    def __add__(self, other: NoReturn) -> NoReturn: ...
+    def __add__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __add__(self, other: Any):
         """Add two numbers.
@@ -81,7 +79,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __radd__(self, other: number_types) -> NumberVar: ...
 
     @overload
-    def __radd__(self, other: NoReturn) -> NoReturn: ...
+    def __radd__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __radd__(self, other: Any):
         """Add two numbers.
@@ -100,7 +98,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __sub__(self, other: number_types) -> NumberVar: ...
 
     @overload
-    def __sub__(self, other: NoReturn) -> NoReturn: ...
+    def __sub__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __sub__(self, other: Any):
         """Subtract two numbers.
@@ -120,7 +118,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __rsub__(self, other: number_types) -> NumberVar: ...
 
     @overload
-    def __rsub__(self, other: NoReturn) -> NoReturn: ...
+    def __rsub__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __rsub__(self, other: Any):
         """Subtract two numbers.
@@ -161,7 +159,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
         """
         from .sequence import ArrayVar, LiteralArrayVar
 
-        if isinstance(other, (list, tuple, set, ArrayVar)):
+        if isinstance(other, (list, tuple, ArrayVar)):
             if isinstance(other, ArrayVar):
                 return other * self
             return LiteralArrayVar.create(other) * self
@@ -188,7 +186,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
         """
         from .sequence import ArrayVar, LiteralArrayVar
 
-        if isinstance(other, (list, tuple, set, ArrayVar)):
+        if isinstance(other, (list, tuple, ArrayVar)):
             if isinstance(other, ArrayVar):
                 return other * self
             return LiteralArrayVar.create(other) * self
@@ -202,7 +200,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __truediv__(self, other: number_types) -> NumberVar: ...
 
     @overload
-    def __truediv__(self, other: NoReturn) -> NoReturn: ...
+    def __truediv__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __truediv__(self, other: Any):
         """Divide two numbers.
@@ -222,7 +220,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __rtruediv__(self, other: number_types) -> NumberVar: ...
 
     @overload
-    def __rtruediv__(self, other: NoReturn) -> NoReturn: ...
+    def __rtruediv__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __rtruediv__(self, other: Any):
         """Divide two numbers.
@@ -242,7 +240,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __floordiv__(self, other: number_types) -> NumberVar: ...
 
     @overload
-    def __floordiv__(self, other: NoReturn) -> NoReturn: ...
+    def __floordiv__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __floordiv__(self, other: Any):
         """Floor divide two numbers.
@@ -262,7 +260,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __rfloordiv__(self, other: number_types) -> NumberVar: ...
 
     @overload
-    def __rfloordiv__(self, other: NoReturn) -> NoReturn: ...
+    def __rfloordiv__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __rfloordiv__(self, other: Any):
         """Floor divide two numbers.
@@ -282,7 +280,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __mod__(self, other: number_types) -> NumberVar: ...
 
     @overload
-    def __mod__(self, other: NoReturn) -> NoReturn: ...
+    def __mod__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __mod__(self, other: Any):
         """Modulo two numbers.
@@ -302,7 +300,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __rmod__(self, other: number_types) -> NumberVar: ...
 
     @overload
-    def __rmod__(self, other: NoReturn) -> NoReturn: ...
+    def __rmod__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __rmod__(self, other: Any):
         """Modulo two numbers.
@@ -322,7 +320,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __pow__(self, other: number_types) -> NumberVar: ...
 
     @overload
-    def __pow__(self, other: NoReturn) -> NoReturn: ...
+    def __pow__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __pow__(self, other: Any):
         """Exponentiate two numbers.
@@ -342,7 +340,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __rpow__(self, other: number_types) -> NumberVar: ...
 
     @overload
-    def __rpow__(self, other: NoReturn) -> NoReturn: ...
+    def __rpow__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __rpow__(self, other: Any):
         """Exponentiate two numbers.
@@ -418,7 +416,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     def __lt__(self, other: number_types) -> BooleanVar: ...
 
     @overload
-    def __lt__(self, other: NoReturn) -> NoReturn: ...
+    def __lt__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __lt__(self, other: Any):
         """Less than comparison.
@@ -431,13 +429,13 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
         """
         if not isinstance(other, NUMBER_TYPES):
             raise_unsupported_operand_types("<", (type(self), type(other)))
-        return less_than_operation(self, +other)
+        return less_than_operation(+self, +other)
 
     @overload
     def __le__(self, other: number_types) -> BooleanVar: ...
 
     @overload
-    def __le__(self, other: NoReturn) -> NoReturn: ...
+    def __le__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __le__(self, other: Any):
         """Less than or equal comparison.
@@ -450,7 +448,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
         """
         if not isinstance(other, NUMBER_TYPES):
             raise_unsupported_operand_types("<=", (type(self), type(other)))
-        return less_than_or_equal_operation(self, +other)
+        return less_than_or_equal_operation(+self, +other)
 
     def __eq__(self, other: Any):
         """Equal comparison.
@@ -462,7 +460,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
             The result of the comparison.
         """
         if isinstance(other, NUMBER_TYPES):
-            return equal_operation(self, +other)
+            return equal_operation(+self, +other)
         return equal_operation(self, other)
 
     def __ne__(self, other: Any):
@@ -475,14 +473,14 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
             The result of the comparison.
         """
         if isinstance(other, NUMBER_TYPES):
-            return not_equal_operation(self, +other)
+            return not_equal_operation(+self, +other)
         return not_equal_operation(self, other)
 
     @overload
     def __gt__(self, other: number_types) -> BooleanVar: ...
 
     @overload
-    def __gt__(self, other: NoReturn) -> NoReturn: ...
+    def __gt__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __gt__(self, other: Any):
         """Greater than comparison.
@@ -495,13 +493,13 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
         """
         if not isinstance(other, NUMBER_TYPES):
             raise_unsupported_operand_types(">", (type(self), type(other)))
-        return greater_than_operation(self, +other)
+        return greater_than_operation(+self, +other)
 
     @overload
     def __ge__(self, other: number_types) -> BooleanVar: ...
 
     @overload
-    def __ge__(self, other: NoReturn) -> NoReturn: ...
+    def __ge__(self, other: NoReturn) -> NoReturn: ...  # pyright: ignore [reportOverlappingOverload]
 
     def __ge__(self, other: Any):
         """Greater than or equal comparison.
@@ -514,17 +512,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
         """
         if not isinstance(other, NUMBER_TYPES):
             raise_unsupported_operand_types(">=", (type(self), type(other)))
-        return greater_than_or_equal_operation(self, +other)
-
-    def bool(self):
-        """Boolean conversion.
-
-        Returns:
-            The boolean value of the number.
-        """
-        if is_optional(self._var_type):
-            return boolify((self != None) & (self != 0))  # noqa: E711
-        return self != 0
+        return greater_than_or_equal_operation(+self, +other)
 
     def _is_strict_float(self) -> bool:
         """Check if the number is a float.
@@ -572,7 +560,7 @@ def binary_number_operation(
         Returns:
             The binary number operation.
         """
-        return operation(lhs, rhs)  # type: ignore
+        return operation(lhs, rhs)  # pyright: ignore [reportReturnType, reportArgumentType]
 
     return wrapper
 
@@ -984,7 +972,7 @@ def boolean_not_operation(value: BooleanVar):
 @dataclasses.dataclass(
     eq=False,
     frozen=True,
-    **{"slots": True} if sys.version_info >= (3, 10) else {},
+    slots=True,
 )
 class LiteralNumberVar(LiteralVar, NumberVar):
     """Base class for immutable literal number vars."""
@@ -998,10 +986,10 @@ class LiteralNumberVar(LiteralVar, NumberVar):
             The JSON representation of the var.
 
         Raises:
-            PrimitiveUnserializableToJSON: If the var is unserializable to JSON.
+            PrimitiveUnserializableToJSONError: If the var is unserializable to JSON.
         """
         if math.isinf(self._var_value) or math.isnan(self._var_value):
-            raise PrimitiveUnserializableToJSON(
+            raise PrimitiveUnserializableToJSONError(
                 f"No valid JSON representation for {self}"
             )
         return json.dumps(self._var_value)
@@ -1043,7 +1031,7 @@ class LiteralNumberVar(LiteralVar, NumberVar):
 @dataclasses.dataclass(
     eq=False,
     frozen=True,
-    **{"slots": True} if sys.version_info >= (3, 10) else {},
+    slots=True,
 )
 class LiteralBooleanVar(LiteralVar, BooleanVar):
     """Base class for immutable literal boolean vars."""

reflex/vars/object.py

@@ -3,13 +3,12 @@
 from __future__ import annotations
 
 import dataclasses
-import sys
 import typing
 from inspect import isclass
 from typing import (
     Any,
-    Dict,
     List,
+    Mapping,
     NoReturn,
     Tuple,
     Type,
@@ -19,6 +18,8 @@ from typing import (
     overload,
 )
 
+from typing_extensions import is_typeddict
+
 from reflex.utils import types
 from reflex.utils.exceptions import VarAttributeError
 from reflex.utils.types import GenericType, get_attribute_access_type, get_origin
@@ -36,7 +37,7 @@ from .base import (
 from .number import BooleanVar, NumberVar, raise_unsupported_operand_types
 from .sequence import ArrayVar, StringVar
 
-OBJECT_TYPE = TypeVar("OBJECT_TYPE")
+OBJECT_TYPE = TypeVar("OBJECT_TYPE", covariant=True)
 
 KEY_TYPE = TypeVar("KEY_TYPE")
 VALUE_TYPE = TypeVar("VALUE_TYPE")
@@ -46,7 +47,7 @@ ARRAY_INNER_TYPE = TypeVar("ARRAY_INNER_TYPE")
 OTHER_KEY_TYPE = TypeVar("OTHER_KEY_TYPE")
 
 
-class ObjectVar(Var[OBJECT_TYPE], python_types=dict):
+class ObjectVar(Var[OBJECT_TYPE], python_types=Mapping):
     """Base class for immutable object vars."""
 
     def _key_type(self) -> Type:
@@ -59,7 +60,7 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict):
 
     @overload
     def _value_type(
-        self: ObjectVar[Dict[Any, VALUE_TYPE]],
+        self: ObjectVar[Mapping[Any, VALUE_TYPE]],
     ) -> Type[VALUE_TYPE]: ...
 
     @overload
@@ -73,9 +74,9 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict):
         """
         fixed_type = get_origin(self._var_type) or self._var_type
         if not isclass(fixed_type):
-            return Any
-        args = get_args(self._var_type) if issubclass(fixed_type, dict) else ()
-        return args[1] if args else Any
+            return Any  # pyright: ignore [reportReturnType]
+        args = get_args(self._var_type) if issubclass(fixed_type, Mapping) else ()
+        return args[1] if args else Any  # pyright: ignore [reportReturnType]
 
     def keys(self) -> ArrayVar[List[str]]:
         """Get the keys of the object.
@@ -87,7 +88,7 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict):
 
     @overload
     def values(
-        self: ObjectVar[Dict[Any, VALUE_TYPE]],
+        self: ObjectVar[Mapping[Any, VALUE_TYPE]],
     ) -> ArrayVar[List[VALUE_TYPE]]: ...
 
     @overload
@@ -103,7 +104,7 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict):
 
     @overload
     def entries(
-        self: ObjectVar[Dict[Any, VALUE_TYPE]],
+        self: ObjectVar[Mapping[Any, VALUE_TYPE]],
     ) -> ArrayVar[List[Tuple[str, VALUE_TYPE]]]: ...
 
     @overload
@@ -132,50 +133,50 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict):
 
     # NoReturn is used here to catch when key value is Any
     @overload
-    def __getitem__(
-        self: ObjectVar[Dict[Any, NoReturn]],
+    def __getitem__(  # pyright: ignore [reportOverlappingOverload]
+        self: ObjectVar[Mapping[Any, NoReturn]],
         key: Var | Any,
     ) -> Var: ...
 
+    @overload
+    def __getitem__(
+        self: (ObjectVar[Mapping[Any, bool]]),
+        key: Var | Any,
+    ) -> BooleanVar: ...
+
     @overload
     def __getitem__(
         self: (
-            ObjectVar[Dict[Any, int]]
-            | ObjectVar[Dict[Any, float]]
-            | ObjectVar[Dict[Any, int | float]]
+            ObjectVar[Mapping[Any, int]]
+            | ObjectVar[Mapping[Any, float]]
+            | ObjectVar[Mapping[Any, int | float]]
         ),
         key: Var | Any,
     ) -> NumberVar: ...
 
     @overload
     def __getitem__(
-        self: ObjectVar[Dict[Any, str]],
+        self: ObjectVar[Mapping[Any, str]],
         key: Var | Any,
     ) -> StringVar: ...
 
     @overload
     def __getitem__(
-        self: ObjectVar[Dict[Any, list[ARRAY_INNER_TYPE]]],
+        self: ObjectVar[Mapping[Any, list[ARRAY_INNER_TYPE]]],
         key: Var | Any,
     ) -> ArrayVar[list[ARRAY_INNER_TYPE]]: ...
 
     @overload
     def __getitem__(
-        self: ObjectVar[Dict[Any, set[ARRAY_INNER_TYPE]]],
-        key: Var | Any,
-    ) -> ArrayVar[set[ARRAY_INNER_TYPE]]: ...
-
-    @overload
-    def __getitem__(
-        self: ObjectVar[Dict[Any, tuple[ARRAY_INNER_TYPE, ...]]],
+        self: ObjectVar[Mapping[Any, tuple[ARRAY_INNER_TYPE, ...]]],
         key: Var | Any,
     ) -> ArrayVar[tuple[ARRAY_INNER_TYPE, ...]]: ...
 
     @overload
     def __getitem__(
-        self: ObjectVar[Dict[Any, dict[OTHER_KEY_TYPE, VALUE_TYPE]]],
+        self: ObjectVar[Mapping[Any, Mapping[OTHER_KEY_TYPE, VALUE_TYPE]]],
         key: Var | Any,
-    ) -> ObjectVar[dict[OTHER_KEY_TYPE, VALUE_TYPE]]: ...
+    ) -> ObjectVar[Mapping[OTHER_KEY_TYPE, VALUE_TYPE]]: ...
 
     def __getitem__(self, key: Var | Any) -> Var:
         """Get an item from the object.
@@ -194,50 +195,44 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict):
 
     # NoReturn is used here to catch when key value is Any
     @overload
-    def __getattr__(
-        self: ObjectVar[Dict[Any, NoReturn]],
+    def __getattr__(  # pyright: ignore [reportOverlappingOverload]
+        self: ObjectVar[Mapping[Any, NoReturn]],
         name: str,
     ) -> Var: ...
 
     @overload
     def __getattr__(
         self: (
-            ObjectVar[Dict[Any, int]]
-            | ObjectVar[Dict[Any, float]]
-            | ObjectVar[Dict[Any, int | float]]
+            ObjectVar[Mapping[Any, int]]
+            | ObjectVar[Mapping[Any, float]]
+            | ObjectVar[Mapping[Any, int | float]]
         ),
         name: str,
     ) -> NumberVar: ...
 
     @overload
     def __getattr__(
-        self: ObjectVar[Dict[Any, str]],
+        self: ObjectVar[Mapping[Any, str]],
         name: str,
     ) -> StringVar: ...
 
     @overload
     def __getattr__(
-        self: ObjectVar[Dict[Any, list[ARRAY_INNER_TYPE]]],
+        self: ObjectVar[Mapping[Any, list[ARRAY_INNER_TYPE]]],
         name: str,
     ) -> ArrayVar[list[ARRAY_INNER_TYPE]]: ...
 
     @overload
     def __getattr__(
-        self: ObjectVar[Dict[Any, set[ARRAY_INNER_TYPE]]],
-        name: str,
-    ) -> ArrayVar[set[ARRAY_INNER_TYPE]]: ...
-
-    @overload
-    def __getattr__(
-        self: ObjectVar[Dict[Any, tuple[ARRAY_INNER_TYPE, ...]]],
+        self: ObjectVar[Mapping[Any, tuple[ARRAY_INNER_TYPE, ...]]],
         name: str,
     ) -> ArrayVar[tuple[ARRAY_INNER_TYPE, ...]]: ...
 
     @overload
     def __getattr__(
-        self: ObjectVar[Dict[Any, dict[OTHER_KEY_TYPE, VALUE_TYPE]]],
+        self: ObjectVar[Mapping[Any, Mapping[OTHER_KEY_TYPE, VALUE_TYPE]]],
         name: str,
-    ) -> ObjectVar[dict[OTHER_KEY_TYPE, VALUE_TYPE]]: ...
+    ) -> ObjectVar[Mapping[OTHER_KEY_TYPE, VALUE_TYPE]]: ...
 
     @overload
     def __getattr__(
@@ -245,7 +240,7 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict):
         name: str,
     ) -> ObjectItemOperation: ...
 
-    def __getattr__(self, name) -> Var:
+    def __getattr__(self, name: str) -> Var:
         """Get an attribute of the var.
 
         Args:
@@ -266,8 +261,11 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict):
             var_type = get_args(var_type)[0]
 
         fixed_type = var_type if isclass(var_type) else get_origin(var_type)
-        if (isclass(fixed_type) and not issubclass(fixed_type, dict)) or (
-            fixed_type in types.UnionTypes
+
+        if (
+            (isclass(fixed_type) and not issubclass(fixed_type, Mapping))
+            or (fixed_type in types.UnionTypes)
+            or is_typeddict(fixed_type)
         ):
             attribute_type = get_attribute_access_type(var_type, name)
             if attribute_type is None:
@@ -294,12 +292,12 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict):
 @dataclasses.dataclass(
     eq=False,
     frozen=True,
-    **{"slots": True} if sys.version_info >= (3, 10) else {},
+    slots=True,
 )
 class LiteralObjectVar(CachedVarOperation, ObjectVar[OBJECT_TYPE], LiteralVar):
     """Base class for immutable literal object vars."""
 
-    _var_value: Dict[Union[Var, Any], Union[Var, Any]] = dataclasses.field(
+    _var_value: Mapping[Union[Var, Any], Union[Var, Any]] = dataclasses.field(
         default_factory=dict
     )
 
@@ -310,7 +308,7 @@ class LiteralObjectVar(CachedVarOperation, ObjectVar[OBJECT_TYPE], LiteralVar):
             The type of the keys of the object.
         """
         args_list = typing.get_args(self._var_type)
-        return args_list[0] if args_list else Any
+        return args_list[0] if args_list else Any  # pyright: ignore [reportReturnType]
 
     def _value_type(self) -> Type:
         """Get the type of the values of the object.
@@ -319,7 +317,7 @@ class LiteralObjectVar(CachedVarOperation, ObjectVar[OBJECT_TYPE], LiteralVar):
             The type of the values of the object.
         """
         args_list = typing.get_args(self._var_type)
-        return args_list[1] if args_list else Any
+        return args_list[1] if args_list else Any  # pyright: ignore [reportReturnType]
 
     @cached_property_no_lock
     def _cached_var_name(self) -> str:
@@ -344,17 +342,20 @@ class LiteralObjectVar(CachedVarOperation, ObjectVar[OBJECT_TYPE], LiteralVar):
 
         Returns:
             The JSON representation of the object.
+
+        Raises:
+            TypeError: The keys and values of the object must be literal vars to get the JSON representation
         """
-        return (
-            "{"
-            + ", ".join(
-                [
-                    f"{LiteralVar.create(key).json()}:{LiteralVar.create(value).json()}"
-                    for key, value in self._var_value.items()
-                ]
-            )
-            + "}"
-        )
+        keys_and_values = []
+        for key, value in self._var_value.items():
+            key = LiteralVar.create(key)
+            value = LiteralVar.create(value)
+            if not isinstance(key, LiteralVar) or not isinstance(value, LiteralVar):
+                raise TypeError(
+                    "The keys and values of the object must be literal vars to get the JSON representation."
+                )
+            keys_and_values.append(f"{key.json()}:{value.json()}")
+        return "{" + ", ".join(keys_and_values) + "}"
 
     def __hash__(self) -> int:
         """Get the hash of the var.
@@ -383,7 +384,7 @@ class LiteralObjectVar(CachedVarOperation, ObjectVar[OBJECT_TYPE], LiteralVar):
     @classmethod
     def create(
         cls,
-        _var_value: dict,
+        _var_value: Mapping,
         _var_type: Type[OBJECT_TYPE] | None = None,
         _var_data: VarData | None = None,
     ) -> LiteralObjectVar[OBJECT_TYPE]:
@@ -466,7 +467,7 @@ def object_merge_operation(lhs: ObjectVar, rhs: ObjectVar):
     """
     return var_operation_return(
         js_expression=f"({{...{lhs}, ...{rhs}}})",
-        var_type=Dict[
+        var_type=Mapping[
             Union[lhs._key_type(), rhs._key_type()],
             Union[lhs._value_type(), rhs._value_type()],
         ],
@@ -476,7 +477,7 @@ def object_merge_operation(lhs: ObjectVar, rhs: ObjectVar):
 @dataclasses.dataclass(
     eq=False,
     frozen=True,
-    **{"slots": True} if sys.version_info >= (3, 10) else {},
+    slots=True,
 )
 class ObjectItemOperation(CachedVarOperation, Var):
     """Operation to get an item from an object."""