reflex 0.8.15a0__py3-none-any.whl → 0.8.15a2__py3-none-any.whl

reflex/model.py

@@ -71,6 +71,10 @@ if find_spec("sqlalchemy"):
             "echo": environment.SQLALCHEMY_ECHO.get(),
             # Check connections before returning them.
             "pool_pre_ping": environment.SQLALCHEMY_POOL_PRE_PING.get(),
+            "pool_size": environment.SQLALCHEMY_POOL_SIZE.get(),
+            "max_overflow": environment.SQLALCHEMY_MAX_OVERFLOW.get(),
+            "pool_recycle": environment.SQLALCHEMY_POOL_RECYCLE.get(),
+            "pool_timeout": environment.SQLALCHEMY_POOL_TIMEOUT.get(),
         }
         conf = get_config()
         url = url or conf.db_url
@@ -363,7 +367,7 @@ if find_spec("sqlmodel") and find_spec("sqlalchemy") and find_spec("pydantic"):
                     reason=(
                         "Register sqlmodel.SQLModel classes with `@rx.ModelRegistry.register`"
                     ),
-                    deprecation_version="0.8.0",
+                    deprecation_version="0.8.15",
                     removal_version="0.9.0",
                 )
             super().__pydantic_init_subclass__()

reflex/state.py

@@ -16,6 +16,7 @@ import time
 import typing
 import warnings
 from collections.abc import AsyncIterator, Callable, Sequence
+from enum import Enum
 from hashlib import md5
 from importlib.util import find_spec
 from types import FunctionType
@@ -246,7 +247,7 @@ class EventHandlerSetVar(EventHandler):
                 msg = f"Variable `{args[0]}` cannot be set on `{self.state_cls.get_full_name()}`"
                 raise AttributeError(msg)
 
-            if asyncio.iscoroutinefunction(handler.fn):
+            if inspect.iscoroutinefunction(handler.fn):
                 msg = f"Setter for {args[0]} is async, which is not supported."
                 raise NotImplementedError(msg)
 
@@ -287,7 +288,7 @@ async def _resolve_delta(delta: Delta) -> Delta:
     tasks = {}
     for state_name, state_delta in delta.items():
         for var_name, value in state_delta.items():
-            if asyncio.iscoroutine(value):
+            if inspect.iscoroutine(value):
                 tasks[state_name, var_name] = asyncio.create_task(
                     value,
                     name=f"reflex_resolve_delta|{state_name}|{var_name}|{time.time()}",
@@ -852,7 +853,7 @@ class BaseState(EvenMoreBasicBaseState):
             ComputedVarShadowsBaseVarsError: When a computed var shadows a base var.
         """
         for name, computed_var_ in cls._get_computed_vars():
-            if name in cls.__annotations__:
+            if name in get_type_hints(cls):
                 msg = f"The computed var name `{computed_var_._js_expr}` shadows a base var in {cls.__module__}.{cls.__name__}; use a different name instead"
                 raise ComputedVarShadowsBaseVarsError(msg)
 
@@ -1554,6 +1555,8 @@ class BaseState(EvenMoreBasicBaseState):
             RuntimeError: If redis is not used in this backend process.
             StateMismatchError: If the state instance is not of the expected type.
         """
+        from reflex.istate.manager.redis import StateManagerRedis
+
         # Then get the target state and all its substates.
         state_manager = get_state_manager()
         if not isinstance(state_manager, StateManagerRedis):
@@ -1733,7 +1736,7 @@ class BaseState(EvenMoreBasicBaseState):
         except TypeError:
             pass
 
-        coroutines = [e for e in events if asyncio.iscoroutine(e)]
+        coroutines = [e for e in events if inspect.iscoroutine(e)]
 
         for coroutine in coroutines:
             coroutine_name = coroutine.__qualname__
@@ -1878,6 +1881,12 @@ class BaseState(EvenMoreBasicBaseState):
                 hinted_args is tuple or hinted_args is tuple
             ):
                 payload[arg] = tuple(value)
+            elif isinstance(hinted_args, type) and issubclass(hinted_args, Enum):
+                try:
+                    payload[arg] = hinted_args(value)
+                except ValueError:
+                    msg = f"Received an invalid enum value ({value}) for {arg} of type {hinted_args}"
+                    raise ValueError(msg) from None
             elif (
                 isinstance(value, str)
                 and (deserializer := _deserializers.get(hinted_args)) is not None
@@ -1895,7 +1904,7 @@ class BaseState(EvenMoreBasicBaseState):
         # Wrap the function in a try/except block.
         try:
             # Handle async functions.
-            if asyncio.iscoroutinefunction(fn.func):
+            if inspect.iscoroutinefunction(fn.func):
                 events = await fn(**payload)
 
             # Handle regular functions.
@@ -2738,11 +2747,7 @@ def reload_state_module(
     state.get_class_substate.cache_clear()
 
 
-from reflex.istate.manager import LockExpiredError as LockExpiredError  # noqa: E402
 from reflex.istate.manager import StateManager as StateManager  # noqa: E402
-from reflex.istate.manager import StateManagerDisk as StateManagerDisk  # noqa: E402
-from reflex.istate.manager import StateManagerMemory as StateManagerMemory  # noqa: E402
-from reflex.istate.manager import StateManagerRedis as StateManagerRedis  # noqa: E402
 from reflex.istate.manager import get_state_manager as get_state_manager  # noqa: E402
 from reflex.istate.manager import (  # noqa: E402
     reset_disk_state_manager as reset_disk_state_manager,

reflex/testing.py

@@ -38,14 +38,10 @@ import reflex.utils.processes
 from reflex.components.component import CustomComponent
 from reflex.config import get_config
 from reflex.environment import environment
-from reflex.state import (
-    BaseState,
-    StateManager,
-    StateManagerDisk,
-    StateManagerMemory,
-    StateManagerRedis,
-    reload_state_module,
-)
+from reflex.istate.manager.disk import StateManagerDisk
+from reflex.istate.manager.memory import StateManagerMemory
+from reflex.istate.manager.redis import StateManagerRedis
+from reflex.state import BaseState, StateManager, reload_state_module
 from reflex.utils import console, js_runtimes
 from reflex.utils.export import export
 from reflex.utils.token_manager import TokenManager

reflex/utils/codespaces.py

@@ -26,11 +26,40 @@ def redirect_script() -> str:
 const thisUrl = new URL(window.location.href);
 const params = new URLSearchParams(thisUrl.search)
 
+function sameHostnameDifferentPort(one, two) {{
+    const hostnameOne = one.hostname;
+    const hostnameTwo = two.hostname;
+    const partsOne = hostnameOne.split(".");
+    const partsTwo = hostnameTwo.split(".");
+    if (partsOne.length !== partsTwo.length) {{ return false;  }}
+    for (let i = 1; i < partsOne.length; i++) {{
+        if (partsOne[i] !== partsTwo[i]) {{ return false; }}
+    }}
+    const uniqueNameOne = partsOne[0];
+    const uniqueNameTwo = partsTwo[0];
+    const uniqueNamePartsOne = uniqueNameOne.split("-");
+    const uniqueNamePartsTwo = uniqueNameTwo.split("-");
+    if (uniqueNamePartsOne.length !== uniqueNamePartsTwo.length) {{ return false;  }}
+    for (let i = 0; i < uniqueNamePartsOne.length - 1; i++) {{
+        if (uniqueNamePartsOne[i] !== uniqueNamePartsTwo[i]) {{ return false;  }}
+    }}
+    return true;
+}}
+
 function doRedirect(url) {{
     if (!window.sessionStorage.getItem("authenticated_github_codespaces")) {{
         const a = document.createElement("a");
         if (params.has("redirect_to")) {{
-            a.href = params.get("redirect_to")
+            const redirect_to = new URL(params.get("redirect_to"));
+            if (!sameHostnameDifferentPort(thisUrl, redirect_to)) {{
+                console.warn("Reflex: Not redirecting to different hostname");
+                return;
+            }}
+            if (!redirect_to.hostname.endsWith(".app.github.dev")) {{
+                console.warn("Reflex: Not redirecting to non .app.github.dev hostname");
+                return;
+            }}
+            a.href = redirect_to.href;
         }} else if (!window.location.href.startsWith(url)) {{
             a.href = url + `?redirect_to=${{window.location.href}}`
         }} else {{

reflex/utils/compat.py

@@ -1,6 +1,9 @@
 """Compatibility hacks and helpers."""
 
-from typing import TYPE_CHECKING
+import sys
+from collections.abc import Mapping
+from importlib.util import find_spec
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from pydantic.fields import FieldInfo
@@ -30,6 +33,51 @@ async def windows_hot_reload_lifespan_hack():
         pass
 
 
+def annotations_from_namespace(namespace: Mapping[str, Any]) -> dict[str, Any]:
+    """Get the annotations from a class namespace.
+
+    Args:
+        namespace: The class namespace.
+
+    Returns:
+        The (forward-ref) annotations from the class namespace.
+    """
+    if sys.version_info >= (3, 14) and "__annotations__" not in namespace:
+        from annotationlib import (
+            Format,
+            call_annotate_function,
+            get_annotate_from_class_namespace,
+        )
+
+        if annotate := get_annotate_from_class_namespace(namespace):
+            return call_annotate_function(annotate, format=Format.FORWARDREF)
+    return namespace.get("__annotations__", {})
+
+
+if find_spec("pydantic") and find_spec("pydantic.v1"):
+    from pydantic.v1.main import ModelMetaclass
+
+    class ModelMetaclassLazyAnnotations(ModelMetaclass):
+        """Compatibility metaclass to resolve python3.14 style lazy annotations."""
+
+        def __new__(mcs, name: str, bases: tuple, namespace: dict, **kwargs):
+            """Resolve python3.14 style lazy annotations before passing off to pydantic v1.
+
+            Args:
+                name: The class name.
+                bases: The base classes.
+                namespace: The class namespace.
+                **kwargs: Additional keyword arguments.
+
+            Returns:
+                The created class.
+            """
+            namespace["__annotations__"] = annotations_from_namespace(namespace)
+            return super().__new__(mcs, name, bases, namespace, **kwargs)
+else:
+    ModelMetaclassLazyAnnotations = type  # type: ignore[assignment]
+
+
 def sqlmodel_field_has_primary_key(field_info: "FieldInfo") -> bool:
     """Determines if a field is a primary.
 

reflex/utils/misc.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import contextlib
+import inspect
 import sys
 import threading
 from collections.abc import Callable
@@ -62,7 +63,7 @@ async def run_in_thread(func: Callable) -> Any:
     Returns:
         Any: The return value of the function.
     """
-    if asyncio.coroutines.iscoroutinefunction(func):
+    if inspect.iscoroutinefunction(func):
         msg = "func must be a non-async function"
         raise ValueError(msg)
     return await asyncio.get_event_loop().run_in_executor(None, func)

reflex/utils/monitoring.py

@@ -1,6 +1,5 @@
 """PyLeak integration for monitoring event loop blocking and resource leaks in Reflex applications."""
 
-import asyncio
 import contextlib
 import functools
 import inspect
@@ -154,7 +153,7 @@ def monitor_loopblocks(func: Callable) -> Callable:
 
         return async_gen_wrapper
 
-    if asyncio.iscoroutinefunction(func):
+    if inspect.iscoroutinefunction(func):
 
         @functools.wraps(func)
         async def async_wrapper(*args, **kwargs):

reflex/utils/prerequisites.py

@@ -16,9 +16,6 @@ from types import ModuleType
 from typing import NamedTuple
 
 from packaging import version
-from redis import Redis as RedisSync
-from redis.asyncio import Redis
-from redis.exceptions import RedisError
 
 from reflex import constants, model
 from reflex.config import Config, get_config
@@ -28,6 +25,9 @@ from reflex.utils.decorator import once
 from reflex.utils.misc import get_module_path
 
 if typing.TYPE_CHECKING:
+    from redis import Redis as RedisSync
+    from redis.asyncio import Redis
+
     from reflex.app import App
 
 
@@ -369,6 +369,12 @@ def get_redis() -> Redis | None:
     Returns:
         The asynchronous redis client.
     """
+    try:
+        from redis.asyncio import Redis
+        from redis.exceptions import RedisError
+    except ImportError:
+        console.debug("Redis package not installed.")
+        return None
     if (redis_url := parse_redis_url()) is not None:
         return Redis.from_url(
             redis_url,
@@ -383,6 +389,12 @@ def get_redis_sync() -> RedisSync | None:
     Returns:
         The synchronous redis client.
     """
+    try:
+        from redis import Redis as RedisSync
+        from redis.exceptions import RedisError
+    except ImportError:
+        console.debug("Redis package not installed.")
+        return None
     if (redis_url := parse_redis_url()) is not None:
         return RedisSync.from_url(
             redis_url,
@@ -417,6 +429,8 @@ async def get_redis_status() -> dict[str, bool | None]:
     Returns:
         The status of the Redis connection.
     """
+    from redis.exceptions import RedisError
+
     try:
         status = True
         redis_client = get_redis()

reflex/utils/processes.py

@@ -16,7 +16,6 @@ from pathlib import Path
 from typing import Any, Literal, overload
 
 import rich.markup
-from redis.exceptions import RedisError
 from rich.progress import Progress
 
 from reflex import constants
@@ -45,6 +44,9 @@ def get_num_workers() -> int:
     """
     if (redis_client := prerequisites.get_redis_sync()) is None:
         return 1
+
+    from redis.exceptions import RedisError
+
     try:
         redis_client.ping()
     except RedisError as re:

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/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

@@ -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.
 
@@ -442,6 +443,13 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
 
         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:
@@ -485,7 +493,7 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
         elif (
             isinstance(cls, type)
             and not is_generic_alias(cls)
-            and issubclass(cls, Model)
+            and issubclass(cls, sqlmodel_types)
         ):
             # Check in the annotations directly (for sqlmodel.Relationship)
             hints = get_type_hints(cls)  # pyright: ignore [reportArgumentType]

reflex/vars/base.py

@@ -43,6 +43,7 @@ from reflex import constants
 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,
@@ -1526,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."
@@ -1687,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)
 
 
@@ -2882,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,
@@ -3478,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]: