reflex 0.8.14a2__py3-none-any.whl → 0.8.15__py3-none-any.whl

reflex/utils/redir.py

@@ -1,59 +1,43 @@
 """Utilities to handle redirection to browser UI."""
 
-import time
-import webbrowser
+from typing import TYPE_CHECKING
 
-from reflex import constants
-from reflex.utils import net
+if TYPE_CHECKING:
+    from urllib.parse import SplitResult
 
-from . import console
 
-
-def open_browser(target_url: str) -> None:
+def open_browser(target_url: "SplitResult") -> None:
     """Open a browser window to target_url.
 
     Args:
         target_url: The URL to open in the browser.
     """
-    if not webbrowser.open(target_url):
+    import webbrowser
+
+    from reflex.utils import console
+
+    if not webbrowser.open(target_url.geturl()):
         console.warn(
             f"Unable to automatically open the browser. Please navigate to {target_url} in your browser."
         )
     else:
-        console.info(f"Opening browser to {target_url}.")
-
-
-def open_browser_and_wait(target_url: str, poll_url: str, interval: int = 2):
-    """Open a browser window to target_url and request poll_url until it returns successfully.
-
-    Args:
-        target_url: The URL to open in the browser.
-        poll_url: The URL to poll for success.
-        interval: The interval in seconds to wait between polling.
-
-    Returns:
-        The response from the poll_url.
-    """
-    import httpx
-
-    open_browser(target_url)
-    console.info("[b]Complete the workflow in the browser to continue.[/b]")
-    while True:
-        try:
-            response = net.get(poll_url, follow_redirects=True)
-            if response.is_success:
-                break
-        except httpx.RequestError as err:
-            console.info(f"Will retry after error occurred while polling: {err}.")
-        time.sleep(interval)
-    return response
+        simplified_url = target_url._replace(path="", query="", fragment="").geturl()
+        console.info(f"Opened browser to {simplified_url}")
 
 
 def reflex_build_redirect() -> None:
     """Open the browser window to reflex.build."""
-    open_browser(constants.Templates.REFLEX_BUILD_FRONTEND)
+    from urllib.parse import urlsplit
+
+    from reflex import constants
+
+    open_browser(urlsplit(constants.Templates.REFLEX_BUILD_FRONTEND_WITH_REFERRER))
 
 
 def reflex_templates():
     """Open the browser window to reflex.build/templates."""
-    open_browser(constants.Templates.REFLEX_TEMPLATES_URL)
+    from urllib.parse import urlsplit
+
+    from reflex import constants
+
+    open_browser(urlsplit(constants.Templates.REFLEX_TEMPLATES_URL))

reflex/utils/serializers.py

@@ -12,13 +12,11 @@ import warnings
 from collections.abc import Callable, Mapping, Sequence
 from datetime import date, datetime, time, timedelta
 from enum import Enum
+from importlib.util import find_spec
 from pathlib import Path
 from typing import Any, Literal, TypeVar, get_type_hints, overload
 from uuid import UUID
 
-from pydantic import BaseModel as BaseModelV2
-from pydantic.v1 import BaseModel as BaseModelV1
-
 from reflex.base import Base
 from reflex.constants.colors import Color
 from reflex.utils import console, types
@@ -281,24 +279,13 @@ def serialize_base(value: Base) -> dict:
     }
 
 
-@serializer(to=dict)
-def serialize_base_model_v1(model: BaseModelV1) -> dict:
-    """Serialize a pydantic v1 BaseModel instance.
-
-    Args:
-        model: The BaseModel to serialize.
-
-    Returns:
-        The serialized BaseModel.
-    """
-    return model.dict()
-
-
-if BaseModelV1 is not BaseModelV2:
+if find_spec("pydantic"):
+    from pydantic import BaseModel as BaseModelV2
+    from pydantic.v1 import BaseModel as BaseModelV1
 
     @serializer(to=dict)
-    def serialize_base_model_v2(model: BaseModelV2) -> dict:
-        """Serialize a pydantic v2 BaseModel instance.
+    def serialize_base_model_v1(model: BaseModelV1) -> dict:
+        """Serialize a pydantic v1 BaseModel instance.
 
         Args:
             model: The BaseModel to serialize.
@@ -306,7 +293,21 @@ if BaseModelV1 is not BaseModelV2:
         Returns:
             The serialized BaseModel.
         """
-        return model.model_dump()
+        return model.dict()
+
+    if BaseModelV1 is not BaseModelV2:
+
+        @serializer(to=dict)
+        def serialize_base_model_v2(model: BaseModelV2) -> dict:
+            """Serialize a pydantic v2 BaseModel instance.
+
+            Args:
+                model: The BaseModel to serialize.
+
+            Returns:
+                The serialized BaseModel.
+            """
+            return model.model_dump()
 
 
 @serializer

reflex/utils/telemetry.py

@@ -1,7 +1,5 @@
 """Anonymous telemetry for Reflex."""
 
-from __future__ import annotations
-
 import asyncio
 import dataclasses
 import importlib.metadata

reflex/utils/templates.py

@@ -419,13 +419,13 @@ def get_init_cli_prompt_options() -> list[Template]:
     """
     return [
         Template(
-            name=constants.Templates.DEFAULT,
-            description="A blank Reflex app.",
+            name=constants.Templates.AI,
+            description="[bold]Try our free AI builder.",
             code_url="",
         ),
         Template(
-            name=constants.Templates.AI,
-            description="[bold]Try our free AI builder.",
+            name=constants.Templates.DEFAULT,
+            description="A blank Reflex app.",
             code_url="",
         ),
         Template(

reflex/utils/types.py

@@ -8,6 +8,7 @@ import types
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from enum import Enum
 from functools import cached_property, lru_cache
+from importlib.util import find_spec
 from types import GenericAlias
 from typing import (  # noqa: UP035
     TYPE_CHECKING,
@@ -33,7 +34,6 @@ from typing import (  # noqa: UP035
 from typing import get_origin as get_origin_og
 from typing import get_type_hints as get_type_hints_og
 
-from pydantic.v1.fields import ModelField
 from typing_extensions import Self as Self
 from typing_extensions import override as override
 
@@ -291,6 +291,7 @@ def is_literal(cls: GenericType) -> bool:
     return getattr(cls, "__origin__", None) is Literal
 
 
+@lru_cache
 def has_args(cls: type) -> bool:
     """Check if the class has generic parameters.
 
@@ -346,33 +347,6 @@ def is_classvar(a_type: Any) -> bool:
     )
 
 
-def true_type_for_pydantic_field(f: ModelField):
-    """Get the type for a pydantic field.
-
-    Args:
-        f: The field to get the type for.
-
-    Returns:
-        The type for the field.
-    """
-    if not isinstance(f.annotation, (str, ForwardRef)):
-        return f.annotation
-
-    type_ = f.outer_type_
-
-    if (
-        f.field_info.default is None
-        or (isinstance(f.annotation, str) and f.annotation.startswith("Optional"))
-        or (
-            isinstance(f.annotation, ForwardRef)
-            and f.annotation.__forward_arg__.startswith("Optional")
-        )
-    ) and not is_optional(type_):
-        return type_ | None
-
-    return type_
-
-
 def value_inside_optional(cls: GenericType) -> GenericType:
     """Get the value inside an Optional type or the original type.
 
@@ -412,6 +386,13 @@ def get_field_type(cls: GenericType, field_name: str) -> GenericType | None:
     return type_hints.get(field_name, None)
 
 
+PROPERTY_CLASSES = (property,)
+if find_spec("sqlalchemy") and find_spec("sqlalchemy.ext"):
+    from sqlalchemy.ext.hybrid import hybrid_property
+
+    PROPERTY_CLASSES += (hybrid_property,)
+
+
 def get_property_hint(attr: Any | None) -> GenericType | None:
     """Check if an attribute is a property and return its type hint.
 
@@ -421,9 +402,7 @@ def get_property_hint(attr: Any | None) -> GenericType | None:
     Returns:
         The type hint of the property, if it is a property, else None.
     """
-    from sqlalchemy.ext.hybrid import hybrid_property
-
-    if not isinstance(attr, (property, hybrid_property)):
+    if not isinstance(attr, PROPERTY_CLASSES):
         return None
     hints = get_type_hints(attr.fget)
     return hints.get("return", None)
@@ -441,12 +420,6 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
     Returns:
         The type of the attribute, if accessible, or None
     """
-    import sqlalchemy
-    from sqlalchemy.ext.associationproxy import AssociationProxyInstance
-    from sqlalchemy.orm import DeclarativeBase, Mapped, QueryableAttribute, Relationship
-
-    from reflex.model import Model
-
     try:
         attr = getattr(cls, name, None)
     except NotImplementedError:
@@ -458,67 +431,93 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
     if hasattr(cls, "__fields__") and name in cls.__fields__:
         # pydantic models
         return get_field_type(cls, name)
-    if isinstance(cls, type) and issubclass(cls, DeclarativeBase):
-        insp = sqlalchemy.inspect(cls)
-        if name in insp.columns:
-            # check for list types
-            column = insp.columns[name]
-            column_type = column.type
-            try:
-                type_ = insp.columns[name].type.python_type
-            except NotImplementedError:
-                type_ = None
-            if type_ is not None:
-                if hasattr(column_type, "item_type"):
-                    try:
-                        item_type = column_type.item_type.python_type  # pyright: ignore [reportAttributeAccessIssue]
-                    except NotImplementedError:
-                        item_type = None
-                    if item_type is not None:
-                        if type_ in PrimitiveToAnnotation:
-                            type_ = PrimitiveToAnnotation[type_]
-                        type_ = type_[item_type]  # pyright: ignore [reportIndexIssue]
-                if hasattr(column, "nullable") and column.nullable:
-                    type_ = type_ | None
+    if find_spec("sqlalchemy") and find_spec("sqlalchemy.orm"):
+        import sqlalchemy
+        from sqlalchemy.ext.associationproxy import AssociationProxyInstance
+        from sqlalchemy.orm import (
+            DeclarativeBase,
+            Mapped,
+            QueryableAttribute,
+            Relationship,
+        )
+
+        from reflex.model import Model
+
+        if find_spec("sqlmodel"):
+            from sqlmodel import SQLModel
+
+            sqlmodel_types = (Model, SQLModel)
+        else:
+            sqlmodel_types = (Model,)
+
+        if isinstance(cls, type) and issubclass(cls, DeclarativeBase):
+            insp = sqlalchemy.inspect(cls)
+            if name in insp.columns:
+                # check for list types
+                column = insp.columns[name]
+                column_type = column.type
+                try:
+                    type_ = insp.columns[name].type.python_type
+                except NotImplementedError:
+                    type_ = None
+                if type_ is not None:
+                    if hasattr(column_type, "item_type"):
+                        try:
+                            item_type = column_type.item_type.python_type  # pyright: ignore [reportAttributeAccessIssue]
+                        except NotImplementedError:
+                            item_type = None
+                        if item_type is not None:
+                            if type_ in PrimitiveToAnnotation:
+                                type_ = PrimitiveToAnnotation[type_]
+                            type_ = type_[item_type]  # pyright: ignore [reportIndexIssue]
+                    if hasattr(column, "nullable") and column.nullable:
+                        type_ = type_ | None
+                    return type_
+            if name in insp.all_orm_descriptors:
+                descriptor = insp.all_orm_descriptors[name]
+                if hint := get_property_hint(descriptor):
+                    return hint
+                if isinstance(descriptor, QueryableAttribute):
+                    prop = descriptor.property
+                    if isinstance(prop, Relationship):
+                        type_ = prop.mapper.class_
+                        # TODO: check for nullable?
+                        return list[type_] if prop.uselist else type_ | None
+                if isinstance(attr, AssociationProxyInstance):
+                    return list[
+                        get_attribute_access_type(
+                            attr.target_class,
+                            attr.remote_attr.key,  # pyright: ignore [reportAttributeAccessIssue]
+                        )
+                    ]
+        elif (
+            isinstance(cls, type)
+            and not is_generic_alias(cls)
+            and issubclass(cls, sqlmodel_types)
+        ):
+            # Check in the annotations directly (for sqlmodel.Relationship)
+            hints = get_type_hints(cls)  # pyright: ignore [reportArgumentType]
+            if name in hints:
+                type_ = hints[name]
+                type_origin = get_origin(type_)
+                if isinstance(type_origin, type) and issubclass(type_origin, Mapped):
+                    return get_args(type_)[0]  # SQLAlchemy v2
+                if find_spec("pydantic"):
+                    from pydantic.v1.fields import ModelField
+
+                    if isinstance(type_, ModelField):
+                        return type_.type_  # SQLAlchemy v1.4
                 return type_
-        if name in insp.all_orm_descriptors:
-            descriptor = insp.all_orm_descriptors[name]
-            if hint := get_property_hint(descriptor):
-                return hint
-            if isinstance(descriptor, QueryableAttribute):
-                prop = descriptor.property
-                if isinstance(prop, Relationship):
-                    type_ = prop.mapper.class_
-                    # TODO: check for nullable?
-                    return list[type_] if prop.uselist else type_ | None
-            if isinstance(attr, AssociationProxyInstance):
-                return list[
-                    get_attribute_access_type(
-                        attr.target_class,
-                        attr.remote_attr.key,  # pyright: ignore [reportAttributeAccessIssue]
-                    )
-                ]
-    elif isinstance(cls, type) and not is_generic_alias(cls) and issubclass(cls, Model):
-        # Check in the annotations directly (for sqlmodel.Relationship)
-        hints = get_type_hints(cls)
-        if name in hints:
-            type_ = hints[name]
-            type_origin = get_origin(type_)
-            if isinstance(type_origin, type) and issubclass(type_origin, Mapped):
-                return get_args(type_)[0]  # SQLAlchemy v2
-            if isinstance(type_, ModelField):
-                return type_.type_  # SQLAlchemy v1.4
-            return type_
-    elif is_union(cls):
+    if is_union(cls):
         # Check in each arg of the annotation.
         return unionize(
             *(get_attribute_access_type(arg, name) for arg in get_args(cls))
         )
-    elif isinstance(cls, type):
+    if isinstance(cls, type):
         # Bare class
         exceptions = NameError
         try:
-            hints = get_type_hints(cls)
+            hints = get_type_hints(cls)  # pyright: ignore [reportArgumentType]
             if name in hints:
                 return hints[name]
         except exceptions as e:

reflex/vars/base.py

@@ -40,10 +40,10 @@ from rich.markup import escape
 from typing_extensions import dataclass_transform, override
 
 from reflex import constants
-from reflex.base import Base
 from reflex.constants.compiler import Hooks
 from reflex.constants.state import FIELD_MARKER
 from reflex.utils import console, exceptions, imports, serializers, types
+from reflex.utils.compat import annotations_from_namespace
 from reflex.utils.decorator import once
 from reflex.utils.exceptions import (
     ComputedVarSignatureError,
@@ -1505,21 +1505,6 @@ class LiteralVar(Var):
                 )
             return LiteralVar.create(serialized_value, _var_data=_var_data)
 
-        if isinstance(value, Base):
-            # get the fields of the pydantic class
-            fields = value.__fields__.keys()
-            one_level_dict = {field: getattr(value, field) for field in fields}
-
-            return LiteralObjectVar.create(
-                {
-                    field: value
-                    for field, value in one_level_dict.items()
-                    if not callable(value)
-                },
-                _var_type=type(value),
-                _var_data=_var_data,
-            )
-
         if dataclasses.is_dataclass(value) and not isinstance(value, type):
             return LiteralObjectVar.create(
                 {
@@ -1542,6 +1527,82 @@ class LiteralVar(Var):
     def __post_init__(self):
         """Post-initialize the var."""
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(
+        cls,
+        value: Any,
+    ) -> VarData | None:
+        return cls.create(value)._get_all_var_data()
+
+    @classmethod
+    def _get_all_var_data_without_creating_var_dispatch(
+        cls,
+        value: Any,
+    ) -> VarData | None:
+        """Get all the var data without creating a var.
+
+        Args:
+            value: The value to get the var data from.
+
+        Returns:
+            The var data or None.
+
+        Raises:
+            TypeError: If the value is not a supported type for LiteralVar.
+        """
+        from .object import LiteralObjectVar
+        from .sequence import LiteralStringVar
+
+        if isinstance(value, Var):
+            return value._get_all_var_data()
+
+        for literal_subclass, var_subclass in _var_literal_subclasses[::-1]:
+            if isinstance(value, var_subclass.python_types):
+                return literal_subclass._get_all_var_data_without_creating_var(value)
+
+        if (
+            (as_var_method := getattr(value, "_as_var", None)) is not None
+            and callable(as_var_method)
+            and isinstance((resulting_var := as_var_method()), Var)
+        ):
+            return resulting_var._get_all_var_data()
+
+        from reflex.event import EventHandler
+        from reflex.utils.format import get_event_handler_parts
+
+        if isinstance(value, EventHandler):
+            return Var(
+                _js_expr=".".join(filter(None, get_event_handler_parts(value)))
+            )._get_all_var_data()
+
+        serialized_value = serializers.serialize(value)
+        if serialized_value is not None:
+            if isinstance(serialized_value, Mapping):
+                return LiteralObjectVar._get_all_var_data_without_creating_var(
+                    serialized_value
+                )
+            if isinstance(serialized_value, str):
+                return LiteralStringVar._get_all_var_data_without_creating_var(
+                    serialized_value
+                )
+            return LiteralVar._get_all_var_data_without_creating_var_dispatch(
+                serialized_value
+            )
+
+        if dataclasses.is_dataclass(value) and not isinstance(value, type):
+            return LiteralObjectVar._get_all_var_data_without_creating_var(
+                {
+                    k: (None if callable(v) else v)
+                    for k, v in dataclasses.asdict(value).items()
+                }
+            )
+
+        if isinstance(value, range):
+            return None
+
+        msg = f"Unsupported type {type(value)} for LiteralVar. Tried to create a LiteralVar from {value}."
+        raise TypeError(msg)
+
     @property
     def _var_value(self) -> Any:
         msg = "LiteralVar subclasses must implement the _var_value property."
@@ -1703,30 +1764,30 @@ 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):
-        if not value:
-            return Sequence[NoReturn]
-        return Sequence[unionize(*(figure_out_type(v) for v in value))]
-    if isinstance(value, set):
-        return set[unionize(*(figure_out_type(v) for v in value))]
-    if isinstance(value, tuple):
-        if not value:
-            return tuple[NoReturn, ...]
-        if len(value) <= 5:
-            return tuple[tuple(figure_out_type(v) for v in value)]
-        return tuple[unionize(*(figure_out_type(v) for v in value)), ...]
-    if isinstance(value, Mapping):
-        if not value:
-            return Mapping[NoReturn, NoReturn]
-        return Mapping[
-            unionize(*(figure_out_type(k) for k in value)),
-            unionize(*(figure_out_type(v) for v in value.values())),
-        ]
+    if isinstance(value, (list, set, tuple, Mapping, Var)):
+        if isinstance(value, Var):
+            return value._var_type
+        if has_args(value_type := type(value)):
+            return value_type
+        if isinstance(value, list):
+            if not value:
+                return Sequence[NoReturn]
+            return Sequence[unionize(*{figure_out_type(v) for v in value[:100]})]
+        if isinstance(value, set):
+            return set[unionize(*{figure_out_type(v) for v in value})]
+        if isinstance(value, tuple):
+            if not value:
+                return tuple[NoReturn, ...]
+            if len(value) <= 5:
+                return tuple[tuple(figure_out_type(v) for v in value)]
+            return tuple[unionize(*{figure_out_type(v) for v in value[:100]}), ...]
+        if isinstance(value, Mapping):
+            if not value:
+                return Mapping[NoReturn, NoReturn]
+            return Mapping[
+                unionize(*{figure_out_type(k) for k in list(value.keys())[:100]}),
+                unionize(*{figure_out_type(v) for v in list(value.values())[:100]}),
+            ]
     return type(value)
 
 
@@ -2898,6 +2959,10 @@ class LiteralNoneVar(LiteralVar, NoneVar):
         """
         return "null"
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(cls, value: None) -> VarData | None:
+        return None
+
     @classmethod
     def create(
         cls,
@@ -3201,6 +3266,8 @@ if TYPE_CHECKING:
     from _typeshed import DataclassInstance
     from sqlalchemy.orm import DeclarativeBase
 
+    from reflex.base import Base
+
     SQLA_TYPE = TypeVar("SQLA_TYPE", bound=DeclarativeBase | None)
     BASE_TYPE = TypeVar("BASE_TYPE", bound=Base | None)
     DATACLASS_TYPE = TypeVar("DATACLASS_TYPE", bound=DataclassInstance | None)
@@ -3492,7 +3559,7 @@ class BaseStateMeta(ABCMeta):
         inherited_fields: dict[str, Field] = {}
         own_fields: dict[str, Field] = {}
         resolved_annotations = types.resolve_annotations(
-            namespace.get("__annotations__", {}), namespace["__module__"]
+            annotations_from_namespace(namespace), namespace["__module__"]
         )
 
         for base in bases[::-1]:

reflex/vars/color.py

@@ -29,6 +29,23 @@ class LiteralColorVar(CachedVarOperation, LiteralVar, ColorVar):
 
     _var_value: Color = dataclasses.field(default_factory=lambda: Color(color="black"))
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(
+        cls,
+        value: Color,
+    ) -> VarData | None:
+        return VarData.merge(
+            LiteralStringVar._get_all_var_data_without_creating_var(value.color)
+            if isinstance(value.color, str)
+            else value.color._get_all_var_data(),
+            value.alpha._get_all_var_data()
+            if not isinstance(value.alpha, bool)
+            else None,
+            value.shade._get_all_var_data()
+            if not isinstance(value.shade, int)
+            else None,
+        )
+
     @classmethod
     def create(
         cls,
@@ -111,14 +128,17 @@ class LiteralColorVar(CachedVarOperation, LiteralVar, ColorVar):
             The var data.
         """
         return VarData.merge(
-            *[
-                LiteralVar.create(var)._get_all_var_data()
-                for var in (
-                    self._var_value.color,
-                    self._var_value.alpha,
-                    self._var_value.shade,
-                )
-            ],
+            LiteralStringVar._get_all_var_data_without_creating_var(
+                self._var_value.color
+            )
+            if isinstance(self._var_value.color, str)
+            else self._var_value.color._get_all_var_data(),
+            self._var_value.alpha._get_all_var_data()
+            if not isinstance(self._var_value.alpha, bool)
+            else None,
+            self._var_value.shade._get_all_var_data()
+            if not isinstance(self._var_value.shade, int)
+            else None,
             self._var_data,
         )