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

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.
 

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]:

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,
         )
 

reflex/vars/datetime.py

@@ -174,10 +174,14 @@ def date_compare_operation(
 class LiteralDatetimeVar(LiteralVar, DateTimeVar):
     """Base class for immutable datetime and date vars."""
 
-    _var_value: datetime | date = dataclasses.field(default=datetime.now())
+    _var_value: date = dataclasses.field(default=datetime.now())
 
     @classmethod
-    def create(cls, value: datetime | date, _var_data: VarData | None = None):
+    def _get_all_var_data_without_creating_var(cls, value: date) -> VarData | None:
+        return None
+
+    @classmethod
+    def create(cls, value: date, _var_data: VarData | None = None):
         """Create a new instance of the class.
 
         Args:

reflex/vars/dep_tracking.py

@@ -192,7 +192,7 @@ class DependencyTracker:
         """
         from reflex.state import BaseState
 
-        if instruction.opname == "LOAD_FAST":
+        if instruction.opname in ("LOAD_FAST", "LOAD_FAST_BORROW"):
             msg = f"Dependency detection cannot identify get_state class from local var {instruction.argval}."
             raise VarValueError(msg)
         if isinstance(self.func, CodeType):
@@ -305,7 +305,7 @@ class DependencyTracker:
             elif self.scan_status == ScanStatus.GETTING_VAR:
                 self.handle_getting_var(instruction)
             elif (
-                instruction.opname in ("LOAD_FAST", "LOAD_DEREF")
+                instruction.opname in ("LOAD_FAST", "LOAD_DEREF", "LOAD_FAST_BORROW")
                 and instruction.argval in self.tracked_locals
             ):
                 # bytecode loaded the class instance to the top of stack, next load instruction

reflex/vars/number.py

@@ -973,6 +973,20 @@ class LiteralNumberVar(LiteralVar, NumberVar[NUMBER_T]):
         """
         return hash((type(self).__name__, self._var_value))
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(
+        cls, value: float | int | decimal.Decimal
+    ) -> VarData | None:
+        """Get all the var data without creating the var.
+
+        Args:
+            value: The value of the var.
+
+        Returns:
+            The var data.
+        """
+        return None
+
     @classmethod
     def create(
         cls, value: float | int | decimal.Decimal, _var_data: VarData | None = None
@@ -1027,6 +1041,18 @@ class LiteralBooleanVar(LiteralVar, BooleanVar):
         """
         return hash((type(self).__name__, self._var_value))
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(cls, value: bool) -> VarData | None:
+        """Get all the var data without creating the var.
+
+        Args:
+            value: The value of the var.
+
+        Returns:
+            The var data.
+        """
+        return None
+
     @classmethod
     def create(cls, value: bool, _var_data: VarData | None = None):
         """Create the boolean var.

reflex/vars/object.py

@@ -40,7 +40,7 @@ from .base import (
     var_operation_return,
 )
 from .number import BooleanVar, NumberVar, raise_unsupported_operand_types
-from .sequence import ArrayVar, StringVar
+from .sequence import ArrayVar, LiteralArrayVar, StringVar
 
 OBJECT_TYPE = TypeVar("OBJECT_TYPE", covariant=True)
 
@@ -437,6 +437,24 @@ class LiteralObjectVar(CachedVarOperation, ObjectVar[OBJECT_TYPE], LiteralVar):
         """
         return hash((type(self).__name__, self._js_expr))
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(
+        cls,
+        value: Mapping,
+    ) -> 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.
+        """
+        return VarData.merge(
+            LiteralArrayVar._get_all_var_data_without_creating_var(value),
+            LiteralArrayVar._get_all_var_data_without_creating_var(value.values()),
+        )
+
     @cached_property_no_lock
     def _cached_get_all_var_data(self) -> VarData | None:
         """Get all the var data.
@@ -445,11 +463,10 @@ class LiteralObjectVar(CachedVarOperation, ObjectVar[OBJECT_TYPE], LiteralVar):
             The var data.
         """
         return VarData.merge(
-            *[LiteralVar.create(var)._get_all_var_data() for var in self._var_value],
-            *[
-                LiteralVar.create(var)._get_all_var_data()
-                for var in self._var_value.values()
-            ],
+            LiteralArrayVar._get_all_var_data_without_creating_var(self._var_value),
+            LiteralArrayVar._get_all_var_data_without_creating_var(
+                self._var_value.values()
+            ),
             self._var_data,
         )
 

reflex/vars/sequence.py

@@ -495,6 +495,23 @@ class LiteralArrayVar(CachedVarOperation, LiteralVar, ArrayVar[ARRAY_VAR_TYPE]):
             + "]"
         )
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(cls, value: Iterable) -> VarData | None:
+        """Get all the VarData associated with the Var without creating a Var.
+
+        Args:
+            value: The value to get the VarData for.
+
+        Returns:
+            The VarData associated with the Var.
+        """
+        return VarData.merge(
+            *[
+                LiteralVar._get_all_var_data_without_creating_var_dispatch(element)
+                for element in value
+            ]
+        )
+
     @cached_property_no_lock
     def _cached_get_all_var_data(self) -> VarData | None:
         """Get all the VarData associated with the Var.
@@ -504,7 +521,7 @@ class LiteralArrayVar(CachedVarOperation, LiteralVar, ArrayVar[ARRAY_VAR_TYPE]):
         """
         return VarData.merge(
             *[
-                LiteralVar.create(element)._get_all_var_data()
+                LiteralVar._get_all_var_data_without_creating_var_dispatch(element)
                 for element in self._var_value
             ],
             self._var_data,
@@ -1147,6 +1164,20 @@ class LiteralStringVar(LiteralVar, StringVar[str]):
 
     _var_value: str = dataclasses.field(default="")
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(cls, value: str) -> VarData | None:
+        """Get all the VarData associated with the Var without creating a Var.
+
+        Args:
+            value: The value to get the VarData for.
+
+        Returns:
+            The VarData associated with the Var.
+        """
+        if REFLEX_VAR_OPENING_TAG not in value:
+            return None
+        return cls.create(value)._get_all_var_data()
+
     @classmethod
     def create(
         cls,

{reflex-0.8.15a0.dist-info → reflex-0.8.15a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflex
-Version: 0.8.15a0
+Version: 0.8.15a1
 Summary: Web apps in pure Python.
 Project-URL: homepage, https://reflex.dev
 Project-URL: repository, https://github.com/reflex-dev/reflex
@@ -18,10 +18,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: <4.0,>=3.10
 Requires-Dist: alembic<2.0,>=1.15.2
 Requires-Dist: click>=8.2
-Requires-Dist: granian[reload]>=2.4.0
+Requires-Dist: granian[reload]>=2.5.5
 Requires-Dist: httpx<1.0,>=0.23.3
 Requires-Dist: packaging<26,>=24.2
 Requires-Dist: platformdirs<5.0,>=4.3.7
@@ -32,7 +33,7 @@ Requires-Dist: python-socketio<6.0,>=5.12.0
 Requires-Dist: redis<7.0,>=5.2.1
 Requires-Dist: reflex-hosting-cli>=0.1.55
 Requires-Dist: rich<15,>=13
-Requires-Dist: sqlmodel<0.1,>=0.0.24
+Requires-Dist: sqlmodel<0.1,>=0.0.27
 Requires-Dist: starlette>=0.47.0
 Requires-Dist: typing-extensions>=4.13.0
 Requires-Dist: wrapt<2.0,>=1.17.0