reflex 0.6.2a2__py3-none-any.whl → 0.6.3__py3-none-any.whl

reflex/utils/pyi_generator.py

@@ -70,7 +70,7 @@ DEFAULT_TYPING_IMPORTS = {
 DEFAULT_IMPORTS = {
     "typing": sorted(DEFAULT_TYPING_IMPORTS),
     "reflex.components.core.breakpoints": ["Breakpoints"],
-    "reflex.event": ["EventChain", "EventHandler", "EventSpec"],
+    "reflex.event": ["EventChain", "EventHandler", "EventSpec", "EventType"],
     "reflex.style": ["Style"],
     "reflex.vars.base": ["Var"],
 }
@@ -427,18 +427,58 @@ def _generate_component_create_functiondef(
     all_props = [arg[0].arg for arg in prop_kwargs]
     kwargs.extend(prop_kwargs)
 
+    def figure_out_return_type(annotation: Any):
+        if inspect.isclass(annotation) and issubclass(annotation, inspect._empty):
+            return ast.Name(id="Optional[EventType]")
+        if isinstance(annotation, str) and annotation.startswith("Tuple["):
+            inside_of_tuple = annotation.removeprefix("Tuple[").removesuffix("]")
+
+            if inside_of_tuple == "()":
+                return ast.Name(id="Optional[EventType[[]]]")
+
+            arguments: list[str] = [""]
+
+            bracket_count = 0
+
+            for char in inside_of_tuple:
+                if char == "[":
+                    bracket_count += 1
+                elif char == "]":
+                    bracket_count -= 1
+
+                if char == "," and bracket_count == 0:
+                    arguments.append("")
+                else:
+                    arguments[-1] += char
+
+            arguments = [argument.strip() for argument in arguments]
+
+            arguments_without_var = [
+                argument.removeprefix("Var[").removesuffix("]")
+                if argument.startswith("Var[")
+                else argument
+                for argument in arguments
+            ]
+
+            return ast.Name(
+                id=f"Optional[EventType[{', '.join(arguments_without_var)}]]"
+            )
+        return ast.Name(id="Optional[EventType]")
+
+    event_triggers = clz().get_event_triggers()
+
     # event handler kwargs
     kwargs.extend(
         (
             ast.arg(
                 arg=trigger,
-                annotation=ast.Name(
-                    id="Optional[Union[EventHandler, EventSpec, list, Callable, Var]]"
+                annotation=figure_out_return_type(
+                    inspect.signature(event_triggers[trigger]).return_annotation
                 ),
             ),
             ast.Constant(value=None),
         )
-        for trigger in sorted(clz().get_event_triggers())
+        for trigger in sorted(event_triggers)
     )
     logger.debug(f"Generated {clz.__name__}.create method with {len(kwargs)} kwargs")
     create_args = ast.arguments(

reflex/utils/registry.py

@@ -1,8 +1,10 @@
 """Utilities for working with registries."""
 
+import os
+
 import httpx
 
-from reflex.utils import console
+from reflex.utils import console, net
 
 
 def latency(registry: str) -> int:
@@ -15,7 +17,7 @@ def latency(registry: str) -> int:
         int: The latency of the registry in microseconds.
     """
     try:
-        return httpx.get(registry).elapsed.microseconds
+        return net.get(registry).elapsed.microseconds
     except httpx.HTTPError:
         console.info(f"Failed to connect to {registry}.")
         return 10_000_000
@@ -34,7 +36,7 @@ def average_latency(registry, attempts: int = 3) -> int:
     return sum(latency(registry) for _ in range(attempts)) // attempts
 
 
-def _get_best_registry() -> str:
+def get_best_registry() -> str:
     """Get the best registry based on latency.
 
     Returns:
@@ -46,3 +48,15 @@ def _get_best_registry() -> str:
     ]
 
     return min(registries, key=average_latency)
+
+
+def _get_npm_registry() -> str:
+    """Get npm registry. If environment variable is set, use it first.
+
+    Returns:
+        str:
+    """
+    if npm_registry := os.environ.get("NPM_CONFIG_REGISTRY", ""):
+        return npm_registry
+    else:
+        return get_best_registry()

reflex/utils/telemetry.py

@@ -94,9 +94,7 @@ def _raise_on_missing_project_hash() -> bool:
         False when compilation should be skipped (i.e. no .web directory is required).
         Otherwise return True.
     """
-    if should_skip_compile():
-        return False
-    return True
+    return not should_skip_compile()
 
 
 def _prepare_event(event: str, **kwargs) -> dict:

reflex/utils/types.py

@@ -18,6 +18,7 @@ from typing import (
     List,
     Literal,
     Optional,
+    Sequence,
     Tuple,
     Type,
     Union,
@@ -102,14 +103,14 @@ if TYPE_CHECKING:
 
     # ArgsSpec = Callable[[Var], list[Var]]
     ArgsSpec = (
-        Callable[[], List[Var]]
-        | Callable[[Var], List[Var]]
-        | Callable[[Var, Var], List[Var]]
-        | Callable[[Var, Var, Var], List[Var]]
-        | Callable[[Var, Var, Var, Var], List[Var]]
-        | Callable[[Var, Var, Var, Var, Var], List[Var]]
-        | Callable[[Var, Var, Var, Var, Var, Var], List[Var]]
-        | Callable[[Var, Var, Var, Var, Var, Var, Var], List[Var]]
+        Callable[[], Sequence[Var]]
+        | Callable[[Var], Sequence[Var]]
+        | Callable[[Var, Var], Sequence[Var]]
+        | Callable[[Var, Var, Var], Sequence[Var]]
+        | Callable[[Var, Var, Var, Var], Sequence[Var]]
+        | Callable[[Var, Var, Var, Var, Var], Sequence[Var]]
+        | Callable[[Var, Var, Var, Var, Var, Var], Sequence[Var]]
+        | Callable[[Var, Var, Var, Var, Var, Var, Var], Sequence[Var]]
     )
 else:
     ArgsSpec = Callable[..., List[Any]]
@@ -182,6 +183,26 @@ def is_generic_alias(cls: GenericType) -> bool:
     return isinstance(cls, GenericAliasTypes)
 
 
+def unionize(*args: GenericType) -> Type:
+    """Unionize the types.
+
+    Args:
+        args: The types to unionize.
+
+    Returns:
+        The unionized types.
+    """
+    if not args:
+        return Any
+    if len(args) == 1:
+        return args[0]
+    # We are bisecting the args list here to avoid hitting the recursion limit
+    # In Python versions >= 3.11, we can simply do `return Union[*args]`
+    midpoint = len(args) // 2
+    first_half, second_half = args[:midpoint], args[midpoint:]
+    return Union[unionize(*first_half), unionize(*second_half)]
+
+
 def is_none(cls: GenericType) -> bool:
     """Check if a class is None.
 
@@ -220,6 +241,27 @@ def is_literal(cls: GenericType) -> bool:
     return get_origin(cls) is Literal
 
 
+def has_args(cls) -> bool:
+    """Check if the class has generic parameters.
+
+    Args:
+        cls: The class to check.
+
+    Returns:
+        Whether the class has generic
+    """
+    if get_args(cls):
+        return True
+
+    # Check if the class inherits from a generic class (using __orig_bases__)
+    if hasattr(cls, "__orig_bases__"):
+        for base in cls.__orig_bases__:
+            if get_args(base):
+                return True
+
+    return False
+
+
 def is_optional(cls: GenericType) -> bool:
     """Check if a class is an Optional.
 
@@ -337,11 +379,9 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
             return type_
     elif is_union(cls):
         # Check in each arg of the annotation.
-        for arg in get_args(cls):
-            type_ = get_attribute_access_type(arg, name)
-            if type_ is not None:
-                # Return the first attribute type that is accessible.
-                return type_
+        return unionize(
+            *(get_attribute_access_type(arg, name) for arg in get_args(cls))
+        )
     elif isinstance(cls, type):
         # Bare class
         if sys.version_info >= (3, 10):
@@ -374,7 +414,7 @@ def get_base_class(cls: GenericType) -> Type:
     if is_literal(cls):
         # only literals of the same type are supported.
         arg_type = type(get_args(cls)[0])
-        if not all(type(arg) == arg_type for arg in get_args(cls)):
+        if not all(type(arg) is arg_type for arg in get_args(cls)):
             raise TypeError("only literals of the same type are supported")
         return type(get_args(cls)[0])
 
@@ -525,7 +565,11 @@ def is_backend_base_variable(name: str, cls: Type) -> bool:
     if name.startswith(f"_{cls.__name__}__"):
         return False
 
-    hints = get_type_hints(cls)
+    # Extract the namespace of the original module if defined (dynamic substates).
+    if callable(getattr(cls, "_get_type_hints", None)):
+        hints = cls._get_type_hints()
+    else:
+        hints = get_type_hints(cls)
     if name in hints:
         hint = get_origin(hints[name])
         if hint == ClassVar:
@@ -538,7 +582,7 @@ def is_backend_base_variable(name: str, cls: Type) -> bool:
 
     if name in cls.__dict__:
         value = cls.__dict__[name]
-        if type(value) == classmethod:
+        if type(value) is classmethod:
             return False
         if callable(value):
             return False

reflex/vars/__init__.py

@@ -1,8 +1,10 @@
 """Immutable-Based Var System."""
 
+from .base import Field as Field
 from .base import LiteralVar as LiteralVar
 from .base import Var as Var
 from .base import VarData as VarData
+from .base import field as field
 from .base import get_unique_variable_name as get_unique_variable_name
 from .base import get_uuid_string_var as get_uuid_string_var
 from .base import var_operation as var_operation

reflex/vars/base.py

@@ -56,7 +56,7 @@ from reflex.utils.imports import (
     ParsedImportDict,
     parse_imports,
 )
-from reflex.utils.types import GenericType, Self, get_origin
+from reflex.utils.types import GenericType, Self, get_origin, has_args, unionize
 
 if TYPE_CHECKING:
     from reflex.state import BaseState
@@ -239,7 +239,7 @@ class Var(Generic[VAR_TYPE]):
             **kwargs,
         )
 
-        if (js_expr := kwargs.get("_js_expr", None)) is not None:
+        if (js_expr := kwargs.get("_js_expr")) is not None:
             object.__setattr__(value_with_replaced, "_js_expr", js_expr)
 
         return value_with_replaced
@@ -429,71 +429,75 @@ class Var(Generic[VAR_TYPE]):
             return self.to(EventVar, output)
         if fixed_output_type is EventChain:
             return self.to(EventChainVar, output)
-        if issubclass(fixed_output_type, Base):
-            return self.to(ObjectVar, output)
+        try:
+            if issubclass(fixed_output_type, Base):
+                return self.to(ObjectVar, output)
+        except TypeError:
+            pass
         if dataclasses.is_dataclass(fixed_output_type) and not issubclass(
             fixed_output_type, Var
         ):
             return self.to(ObjectVar, output)
 
-        if issubclass(output, BooleanVar):
-            return ToBooleanVarOperation.create(self)
+        if inspect.isclass(output):
+            if issubclass(output, BooleanVar):
+                return ToBooleanVarOperation.create(self)
+
+            if issubclass(output, NumberVar):
+                if fixed_type is not None:
+                    if fixed_type in types.UnionTypes:
+                        inner_types = get_args(base_type)
+                        if not all(issubclass(t, (int, float)) for t in inner_types):
+                            raise TypeError(
+                                f"Unsupported type {var_type} for NumberVar. Must be int or float."
+                            )
 
-        if issubclass(output, NumberVar):
-            if fixed_type is not None:
-                if fixed_type is Union:
-                    inner_types = get_args(base_type)
-                    if not all(issubclass(t, (int, float)) for t in inner_types):
+                    elif not issubclass(fixed_type, (int, float)):
                         raise TypeError(
                             f"Unsupported type {var_type} for NumberVar. Must be int or float."
                         )
+                return ToNumberVarOperation.create(self, var_type or float)
 
-                elif not issubclass(fixed_type, (int, float)):
+            if issubclass(output, ArrayVar):
+                if fixed_type is not None and not issubclass(
+                    fixed_type, (list, tuple, set)
+                ):
                     raise TypeError(
-                        f"Unsupported type {var_type} for NumberVar. Must be int or float."
+                        f"Unsupported type {var_type} for ArrayVar. Must be list, tuple, or set."
                     )
-            return ToNumberVarOperation.create(self, var_type or float)
+                return ToArrayOperation.create(self, var_type or list)
 
-        if issubclass(output, ArrayVar):
-            if fixed_type is not None and not issubclass(
-                fixed_type, (list, tuple, set)
-            ):
-                raise TypeError(
-                    f"Unsupported type {var_type} for ArrayVar. Must be list, tuple, or set."
-                )
-            return ToArrayOperation.create(self, var_type or list)
+            if issubclass(output, StringVar):
+                return ToStringOperation.create(self, var_type or str)
 
-        if issubclass(output, StringVar):
-            return ToStringOperation.create(self, var_type or str)
+            if issubclass(output, EventVar):
+                return ToEventVarOperation.create(self, var_type or EventSpec)
 
-        if issubclass(output, EventVar):
-            return ToEventVarOperation.create(self, var_type or EventSpec)
+            if issubclass(output, EventChainVar):
+                return ToEventChainVarOperation.create(self, var_type or EventChain)
 
-        if issubclass(output, EventChainVar):
-            return ToEventChainVarOperation.create(self, var_type or EventChain)
+            if issubclass(output, (ObjectVar, Base)):
+                return ToObjectOperation.create(self, var_type or dict)
 
-        if issubclass(output, (ObjectVar, Base)):
-            return ToObjectOperation.create(self, var_type or dict)
+            if issubclass(output, FunctionVar):
+                # if fixed_type is not None and not issubclass(fixed_type, Callable):
+                #     raise TypeError(
+                #         f"Unsupported type {var_type} for FunctionVar. Must be Callable."
+                #     )
+                return ToFunctionOperation.create(self, var_type or Callable)
 
-        if issubclass(output, FunctionVar):
-            # if fixed_type is not None and not issubclass(fixed_type, Callable):
-            #     raise TypeError(
-            #         f"Unsupported type {var_type} for FunctionVar. Must be Callable."
-            #     )
-            return ToFunctionOperation.create(self, var_type or Callable)
-
-        if issubclass(output, NoneVar):
-            return ToNoneOperation.create(self)
+            if issubclass(output, NoneVar):
+                return ToNoneOperation.create(self)
 
-        if dataclasses.is_dataclass(output):
-            return ToObjectOperation.create(self, var_type or dict)
+            if dataclasses.is_dataclass(output):
+                return ToObjectOperation.create(self, var_type or dict)
 
-        # If we can't determine the first argument, we just replace the _var_type.
-        if not issubclass(output, Var) or var_type is None:
-            return dataclasses.replace(
-                self,
-                _var_type=output,
-            )
+            # If we can't determine the first argument, we just replace the _var_type.
+            if not issubclass(output, Var) or var_type is None:
+                return dataclasses.replace(
+                    self,
+                    _var_type=output,
+                )
 
         # We couldn't determine the output type to be any other Var type, so we replace the _var_type.
         if var_type is not None:
@@ -530,7 +534,7 @@ class Var(Generic[VAR_TYPE]):
 
         fixed_type = get_origin(var_type) or var_type
 
-        if fixed_type is Union:
+        if fixed_type in types.UnionTypes:
             inner_types = get_args(var_type)
 
             if all(
@@ -568,8 +572,11 @@ class Var(Generic[VAR_TYPE]):
             return self.to(EventVar, self._var_type)
         if issubclass(fixed_type, EventChain):
             return self.to(EventChainVar, self._var_type)
-        if issubclass(fixed_type, Base):
-            return self.to(ObjectVar, self._var_type)
+        try:
+            if issubclass(fixed_type, Base):
+                return self.to(ObjectVar, self._var_type)
+        except TypeError:
+            pass
         if dataclasses.is_dataclass(fixed_type):
             return self.to(ObjectVar, self._var_type)
         return self
@@ -1237,26 +1244,6 @@ def var_operation(
     return wrapper
 
 
-def unionize(*args: Type) -> Type:
-    """Unionize the types.
-
-    Args:
-        args: The types to unionize.
-
-    Returns:
-        The unionized types.
-    """
-    if not args:
-        return Any
-    if len(args) == 1:
-        return args[0]
-    # We are bisecting the args list here to avoid hitting the recursion limit
-    # In Python versions >= 3.11, we can simply do `return Union[*args]`
-    midpoint = len(args) // 2
-    first_half, second_half = args[:midpoint], args[midpoint:]
-    return Union[unionize(*first_half), unionize(*second_half)]
-
-
 def figure_out_type(value: Any) -> types.GenericType:
     """Figure out the type of the value.
 
@@ -1266,6 +1253,11 @@ def figure_out_type(value: Any) -> types.GenericType:
     Returns:
         The type of the value.
     """
+    if isinstance(value, Var):
+        return value._var_type
+    type_ = type(value)
+    if has_args(type_):
+        return type_
     if isinstance(value, list):
         return List[unionize(*(figure_out_type(v) for v in value))]
     if isinstance(value, set):
@@ -1277,8 +1269,6 @@ def figure_out_type(value: Any) -> types.GenericType:
             unionize(*(figure_out_type(k) for k in value)),
             unionize(*(figure_out_type(v) for v in value.values())),
         ]
-    if isinstance(value, Var):
-        return value._var_type
     return type(value)
 
 
@@ -2832,3 +2822,68 @@ def dispatch(
         _var_data=var_data,
         _var_type=result_var_type,
     ).guess_type()
+
+
+V = TypeVar("V")
+
+
+class Field(Generic[T]):
+    """Shadow class for Var to allow for type hinting in the IDE."""
+
+    def __set__(self, instance, value: T):
+        """Set the Var.
+
+        Args:
+            instance: The instance of the class setting the Var.
+            value: The value to set the Var to.
+        """
+
+    @overload
+    def __get__(self: Field[bool], instance: None, owner) -> BooleanVar: ...
+
+    @overload
+    def __get__(self: Field[int], instance: None, owner) -> NumberVar: ...
+
+    @overload
+    def __get__(self: Field[str], instance: None, owner) -> StringVar: ...
+
+    @overload
+    def __get__(self: Field[None], instance: None, owner) -> NoneVar: ...
+
+    @overload
+    def __get__(
+        self: Field[List[V]] | Field[Set[V]] | Field[Tuple[V, ...]],
+        instance: None,
+        owner,
+    ) -> ArrayVar[List[V]]: ...
+
+    @overload
+    def __get__(
+        self: Field[Dict[str, V]], instance: None, owner
+    ) -> ObjectVar[Dict[str, V]]: ...
+
+    @overload
+    def __get__(self, instance: None, owner) -> Var[T]: ...
+
+    @overload
+    def __get__(self, instance, owner) -> T: ...
+
+    def __get__(self, instance, owner):  # type: ignore
+        """Get the Var.
+
+        Args:
+            instance: The instance of the class accessing the Var.
+            owner: The class that the Var is attached to.
+        """
+
+
+def field(value: T) -> Field[T]:
+    """Create a Field with a value.
+
+    Args:
+        value: The value of the Field.
+
+    Returns:
+        The Field.
+    """
+    return value  # type: ignore

reflex/vars/object.py

@@ -119,6 +119,8 @@ class ObjectVar(Var[OBJECT_TYPE]):
         """
         return object_entries_operation(self)
 
+    items = entries
+
     def merge(self, other: ObjectVar):
         """Merge two objects.
 
@@ -260,7 +262,9 @@ class ObjectVar(Var[OBJECT_TYPE]):
             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):
+        if (isclass(fixed_type) and not issubclass(fixed_type, dict)) or (
+            fixed_type in types.UnionTypes
+        ):
             attribute_type = get_attribute_access_type(var_type, name)
             if attribute_type is None:
                 raise VarAttributeError(

reflex/vars/sequence.py

@@ -545,7 +545,7 @@ class LiteralStringVar(LiteralVar, StringVar):
     def create(
         cls,
         value: str,
-        _var_type: GenericType | None = str,
+        _var_type: GenericType | None = None,
         _var_data: VarData | None = None,
     ) -> StringVar:
         """Create a var from a string value.
@@ -558,6 +558,9 @@ class LiteralStringVar(LiteralVar, StringVar):
         Returns:
             The var.
         """
+        # Determine var type in case the value is inherited from str.
+        _var_type = _var_type or type(value) or str
+
         if REFLEX_VAR_OPENING_TAG in value:
             strings_and_vals: list[Var | str] = []
             offset = 0
@@ -884,6 +887,12 @@ class ArrayVar(Var[ARRAY_VAR_TYPE]):
         i: int | NumberVar,
     ) -> ArrayVar[Set[INNER_ARRAY_VAR]]: ...
 
+    @overload
+    def __getitem__(
+        self: ARRAY_VAR_OF_LIST_ELEMENT[Tuple[KEY_TYPE, VALUE_TYPE]],
+        i: int | NumberVar,
+    ) -> ArrayVar[Tuple[KEY_TYPE, VALUE_TYPE]]: ...
+
     @overload
     def __getitem__(
         self: ARRAY_VAR_OF_LIST_ELEMENT[Tuple[INNER_ARRAY_VAR, ...]],
@@ -1146,7 +1155,7 @@ class ArrayVar(Var[ARRAY_VAR_TYPE]):
             function_var = ArgsFunctionOperation.create(tuple(), return_value)
         else:
             # generic number var
-            number_var = Var("").to(NumberVar)
+            number_var = Var("").to(NumberVar, int)
 
             first_arg_type = self[number_var]._var_type
 
@@ -1158,7 +1167,10 @@ class ArrayVar(Var[ARRAY_VAR_TYPE]):
                 _var_type=first_arg_type,
             ).guess_type()
 
-            function_var = ArgsFunctionOperation.create((arg_name,), fn(first_arg))
+            function_var = ArgsFunctionOperation.create(
+                (arg_name,),
+                Var.create(fn(first_arg)),
+            )
 
         return map_array_operation(self, function_var)
 

{reflex-0.6.2a2.dist-info → reflex-0.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reflex
-Version: 0.6.2a2
+Version: 0.6.3
 Summary: Web apps in pure Python.
 Home-page: https://reflex.dev
 License: Apache-2.0
@@ -35,7 +35,7 @@ Requires-Dist: redis (>=4.3.5,<6.0)
 Requires-Dist: reflex-chakra (>=0.6.0)
 Requires-Dist: reflex-hosting-cli (>=0.1.2,<2.0)
 Requires-Dist: rich (>=13.0.0,<14.0)
-Requires-Dist: setuptools (>=69.1.1,<70.2)
+Requires-Dist: setuptools (>=75.0)
 Requires-Dist: sqlmodel (>=0.0.14,<0.1)
 Requires-Dist: starlette-admin (>=0.11.0,<1.0)
 Requires-Dist: tomlkit (>=0.12.4,<1.0)
@@ -68,7 +68,7 @@ Description-Content-Type: text/markdown
 
 ---
 
-[English](https://github.com/reflex-dev/reflex/blob/main/README.md) | [简体中文](https://github.com/reflex-dev/reflex/blob/main/docs/zh/zh_cn/README.md) | [繁體中文](https://github.com/reflex-dev/reflex/blob/main/docs/zh/zh_tw/README.md) | [Türkçe](https://github.com/reflex-dev/reflex/blob/main/docs/tr/README.md) | [हिंदी](https://github.com/reflex-dev/reflex/blob/main/docs/in/README.md) | [Português (Brasil)](https://github.com/reflex-dev/reflex/blob/main/docs/pt/pt_br/README.md) | [Italiano](https://github.com/reflex-dev/reflex/blob/main/docs/it/README.md) | [Español](https://github.com/reflex-dev/reflex/blob/main/docs/es/README.md) | [한국어](https://github.com/reflex-dev/reflex/blob/main/docs/kr/README.md) | [日本語](https://github.com/reflex-dev/reflex/blob/main/docs/ja/README.md) | [Deutsch](https://github.com/reflex-dev/reflex/blob/main/docs/de/README.md) | [Persian (پارسی)](https://github.com/reflex-dev/reflex/blob/main/docs/pe/README.md)
+[English](https://github.com/reflex-dev/reflex/blob/main/README.md) | [简体中文](https://github.com/reflex-dev/reflex/blob/main/docs/zh/zh_cn/README.md) | [繁體中文](https://github.com/reflex-dev/reflex/blob/main/docs/zh/zh_tw/README.md) | [Türkçe](https://github.com/reflex-dev/reflex/blob/main/docs/tr/README.md) | [हिंदी](https://github.com/reflex-dev/reflex/blob/main/docs/in/README.md) | [Português (Brasil)](https://github.com/reflex-dev/reflex/blob/main/docs/pt/pt_br/README.md) | [Italiano](https://github.com/reflex-dev/reflex/blob/main/docs/it/README.md) | [Español](https://github.com/reflex-dev/reflex/blob/main/docs/es/README.md) | [한국어](https://github.com/reflex-dev/reflex/blob/main/docs/kr/README.md) | [日本語](https://github.com/reflex-dev/reflex/blob/main/docs/ja/README.md) | [Deutsch](https://github.com/reflex-dev/reflex/blob/main/docs/de/README.md) | [Persian (پارسی)](https://github.com/reflex-dev/reflex/blob/main/docs/pe/README.md) | [Tiếng Việt](https://github.com/reflex-dev/reflex/blob/main/docs/vi/README.md)
 
 ---