reflex 0.8.14.post1__py3-none-any.whl → 0.8.15a1__py3-none-any.whl

reflex/plugins/tailwind_v4.py

@@ -17,7 +17,7 @@ class Constants(SimpleNamespace):
     """Tailwind constants."""
 
     # The Tailwindcss version
-    VERSION = "tailwindcss@4.1.13"
+    VERSION = "tailwindcss@4.1.14"
     # The Tailwind config.
     CONFIG = "tailwind.config.js"
     # Default Tailwind content paths
@@ -156,7 +156,7 @@ class TailwindV4Plugin(TailwindPlugin):
         return [
             *super().get_frontend_development_dependencies(**context),
             Constants.VERSION,
-            "@tailwindcss/postcss@4.1.13",
+            "@tailwindcss/postcss@4.1.14",
         ]
 
     def pre_compile(self, **context):

reflex/reflex.py

@@ -11,12 +11,14 @@ from reflex_cli.v2.deployments import hosting_cli
 
 from reflex import constants
 from reflex.config import get_config
-from reflex.constants.base import LITERAL_ENV
 from reflex.custom_components.custom_components import custom_components_cli
 from reflex.environment import environment
-from reflex.state import reset_disk_state_manager
-from reflex.utils import console, redir, telemetry
-from reflex.utils.exec import should_use_granian
+from reflex.utils import console
+
+if TYPE_CHECKING:
+    from reflex_cli.constants.base import LogLevel as HostingLogLevel
+
+    from reflex.constants.base import LITERAL_ENV
 
 
 def set_loglevel(ctx: click.Context, self: click.Parameter, value: str | None):
@@ -40,6 +42,8 @@ def cli():
 
 loglevel_option = click.option(
     "--loglevel",
+    "--log-level",
+    "loglevel",
     type=click.Choice(
         [loglevel.value for loglevel in constants.LogLevel],
         case_sensitive=False,
@@ -63,7 +67,9 @@ def _init(
     exec.output_system_info()
 
     if ai:
-        redir.reflex_build_redirect()
+        from reflex.utils.redir import reflex_build_redirect
+
+        reflex_build_redirect()
         return
 
     # Validate the app name.
@@ -136,7 +142,9 @@ def _run(
     """Run the app in the given directory."""
     import atexit
 
-    from reflex.utils import build, exec, prerequisites, processes
+    from reflex.state import reset_disk_state_manager
+    from reflex.utils import build, exec, prerequisites, processes, telemetry
+    from reflex.utils.exec import should_use_granian
 
     config = get_config()
 
@@ -535,6 +543,8 @@ def login():
     validated_info = hosting_cli.login()
     if validated_info is not None:
         _skip_compile()  # Allow running outside of an app dir
+        from reflex.utils import telemetry
+
         telemetry.send("login", user_uuid=validated_info.get("user_id"))
 
 
@@ -838,10 +848,6 @@ def rename(new_name: str):
     rename_app(new_name, get_config().loglevel)
 
 
-if TYPE_CHECKING:
-    from reflex_cli.constants.base import LogLevel as HostingLogLevel
-
-
 def _convert_reflex_loglevel_to_reflex_cli_loglevel(
     loglevel: constants.LogLevel,
 ) -> HostingLogLevel:

reflex/state.py

@@ -16,20 +16,17 @@ 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
 from typing import TYPE_CHECKING, Any, BinaryIO, ClassVar, TypeVar, cast, get_type_hints
 
-import pydantic.v1 as pydantic
-from pydantic import BaseModel as BaseModelV2
-from pydantic.v1 import BaseModel as BaseModelV1
-from pydantic.v1.fields import ModelField
 from rich.markup import escape
 from typing_extensions import Self
 
 import reflex.istate.dynamic
 from reflex import constants, event
-from reflex.base import Base
 from reflex.constants.state import FIELD_MARKER
 from reflex.environment import PerformanceMode, environment
 from reflex.event import (
@@ -94,13 +91,11 @@ if environment.REFLEX_PERF_MODE.get() != PerformanceMode.OFF:
 VAR_TYPE = TypeVar("VAR_TYPE")
 
 
-def _no_chain_background_task(
-    state_cls: type[BaseState], name: str, fn: Callable
-) -> Callable:
+def _no_chain_background_task(state: BaseState, name: str, fn: Callable) -> Callable:
     """Protect against directly chaining a background task from another event handler.
 
     Args:
-        state_cls: The state class that the event handler is in.
+        state: The state instance the background task is bound to.
         name: The name of the background task.
         fn: The background task coroutine function / generator.
 
@@ -110,7 +105,7 @@ def _no_chain_background_task(
     Raises:
         TypeError: If the background task is not async.
     """
-    call = f"{state_cls.__name__}.{name}"
+    call = f"{type(state).__name__}.{name}"
     message = (
         f"Cannot directly call background task {name!r}, use "
         f"`yield {call}` or `return {call}` instead."
@@ -252,17 +247,13 @@ 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)
 
         return super().__call__(*args)
 
 
-if TYPE_CHECKING:
-    from pydantic.v1.fields import ModelField
-
-
 def get_var_for_field(cls: type[BaseState], name: str, f: Field) -> Var:
     """Get a Var instance for a state field.
 
@@ -297,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()}",
@@ -479,7 +470,7 @@ class BaseState(EvenMoreBasicBaseState):
 
         Args:
             mixin: Whether the subclass is a mixin and should not be initialized.
-            **kwargs: The kwargs to pass to the pydantic init_subclass method.
+            **kwargs: The kwargs to pass to the init_subclass method.
 
         Raises:
             StateValueError: If a substate class shadows another.
@@ -739,7 +730,7 @@ class BaseState(EvenMoreBasicBaseState):
             mixin
             for mixin in cls.__mro__
             if (
-                mixin not in [pydantic.BaseModel, Base, cls]
+                mixin is not cls
                 and issubclass(mixin, BaseState)
                 and mixin._mixin is True
             )
@@ -862,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)
 
@@ -1090,7 +1081,7 @@ class BaseState(EvenMoreBasicBaseState):
             _var_data=VarData.from_state(cls, name),
         ).guess_type()
 
-        # add the pydantic field dynamically (must be done before _init_var)
+        # add the field dynamically (must be done before _init_var)
         cls.add_field(name, var, default_value)
 
         cls._init_var(name, var)
@@ -1188,7 +1179,7 @@ class BaseState(EvenMoreBasicBaseState):
             name: The name of the var.
             prop: The var to set the default value for.
         """
-        # Get the pydantic field for the var.
+        # Get the field for the var.
         field = cls.get_fields()[name]
 
         if field.default is None and not types.is_optional(prop._var_type):
@@ -1349,7 +1340,7 @@ class BaseState(EvenMoreBasicBaseState):
         if name in event_handlers:
             handler = event_handlers[name]
             if handler.is_background:
-                fn = _no_chain_background_task(type(self), name, handler.fn)
+                fn = _no_chain_background_task(self, name, handler.fn)
             else:
                 fn = functools.partial(handler.fn, self)
             fn.__module__ = handler.fn.__module__
@@ -1465,7 +1456,7 @@ class BaseState(EvenMoreBasicBaseState):
 
     @classmethod
     @functools.lru_cache
-    def _is_client_storage(cls, prop_name_or_field: str | ModelField) -> bool:
+    def _is_client_storage(cls, prop_name_or_field: str | Field) -> bool:
         """Check if the var is a client storage var.
 
         Args:
@@ -1564,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):
@@ -1743,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__
@@ -1872,16 +1865,28 @@ class BaseState(EvenMoreBasicBaseState):
                             if key in hinted_args.__fields__
                         }
                     )
-                elif dataclasses.is_dataclass(hinted_args) or issubclass(
-                    hinted_args, (Base, BaseModelV1, BaseModelV2)
-                ):
+                elif dataclasses.is_dataclass(hinted_args):
                     payload[arg] = hinted_args(**value)
+                elif find_spec("pydantic"):
+                    from pydantic import BaseModel as BaseModelV2
+                    from pydantic.v1 import BaseModel as BaseModelV1
+
+                    if issubclass(hinted_args, BaseModelV1):
+                        payload[arg] = hinted_args.parse_obj(value)
+                    elif issubclass(hinted_args, BaseModelV2):
+                        payload[arg] = hinted_args.model_validate(value)
             elif isinstance(value, list) and (hinted_args is set or hinted_args is set):
                 payload[arg] = set(value)
             elif isinstance(value, list) and (
                 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
@@ -1899,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.
@@ -2142,7 +2147,7 @@ class BaseState(EvenMoreBasicBaseState):
         Args:
             include_computed: Whether to include computed vars.
             initial: Whether to get the initial value of computed vars.
-            **kwargs: Kwargs to pass to the pydantic dict method.
+            **kwargs: Kwargs to pass to the dict method.
 
         Returns:
             The object as a dictionary.
@@ -2626,7 +2631,7 @@ class ComponentState(State, mixin=True):
 
         Args:
             mixin: Whether the subclass is a mixin and should not be initialized.
-            **kwargs: The kwargs to pass to the pydantic init_subclass method.
+            **kwargs: The kwargs to pass to the init_subclass method.
         """
         super().__init_subclass__(mixin=mixin, **kwargs)
 
@@ -2742,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

@@ -21,6 +21,7 @@ import time
 import types
 from collections.abc import AsyncIterator, Callable, Coroutine, Sequence
 from http.server import SimpleHTTPRequestHandler
+from importlib.util import find_spec
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal, TypeVar
 
@@ -37,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
@@ -320,12 +317,13 @@ class AppHarness:
                     await self.app_instance.sio.shutdown()
 
             # sqlalchemy async engine shutdown handler
-            try:
-                async_engine = reflex.model.get_async_engine(None)
-            except ValueError:
-                pass
-            else:
-                await async_engine.dispose()
+            if find_spec("sqlmodel"):
+                try:
+                    async_engine = reflex.model.get_async_engine(None)
+                except ValueError:
+                    pass
+                else:
+                    await async_engine.dispose()
 
             await original_shutdown(*args, **kwargs)
 

reflex/utils/build.py

@@ -187,7 +187,11 @@ def _duplicate_index_html_to_parent_directory(directory: Path):
 
 
 def build():
-    """Build the app for deployment."""
+    """Build the app for deployment.
+
+    Raises:
+        SystemExit: If the build process fails.
+    """
     wdir = prerequisites.get_web_dir()
 
     # Clean the static directory if it exists.
@@ -214,6 +218,12 @@ def build():
         },
     )
     processes.show_progress("Creating Production Build", process, checkpoints)
+    process.wait()
+    if process.returncode != 0:
+        console.error(
+            "Failed to build the frontend. Please run with --loglevel debug for more information.",
+        )
+        raise SystemExit(1)
     _duplicate_index_html_to_parent_directory(wdir / constants.Dirs.STATIC)
 
     spa_fallback = wdir / constants.Dirs.STATIC / constants.ReactRouter.SPA_FALLBACK

reflex/utils/compat.py

@@ -1,8 +1,12 @@
 """Compatibility hacks and helpers."""
 
-import contextlib
 import sys
-from typing import Any
+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
 
 
 async def windows_hot_reload_lifespan_hack():
@@ -29,63 +33,62 @@ async def windows_hot_reload_lifespan_hack():
         pass
 
 
-@contextlib.contextmanager
-def pydantic_v1_patch():
-    """A context manager that patches the Pydantic module to mimic v1 behaviour.
+def annotations_from_namespace(namespace: Mapping[str, Any]) -> dict[str, Any]:
+    """Get the annotations from a class namespace.
+
+    Args:
+        namespace: The class namespace.
 
-    Yields:
-        None when the Pydantic module is patched.
+    Returns:
+        The (forward-ref) annotations from the class namespace.
     """
-    import pydantic
-
-    if pydantic.__version__.startswith("1."):
-        # pydantic v1 is already installed
-        yield
-        return
-
-    patched_modules = [
-        "pydantic",
-        "pydantic.fields",
-        "pydantic.errors",
-        "pydantic.main",
-    ]
-    originals = {module: sys.modules.get(module) for module in patched_modules}
-    try:
-        import pydantic.v1
+    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."""
 
-        sys.modules["pydantic.fields"] = pydantic.v1.fields  # pyright: ignore [reportAttributeAccessIssue]
-        sys.modules["pydantic.main"] = pydantic.v1.main  # pyright: ignore [reportAttributeAccessIssue]
-        sys.modules["pydantic.errors"] = pydantic.v1.errors  # pyright: ignore [reportAttributeAccessIssue]
-        sys.modules["pydantic"] = pydantic.v1
-        yield
-    except (ImportError, AttributeError):
-        # pydantic v1 is already installed
-        yield
-    finally:
-        # Restore the original Pydantic module
-        for k, original in originals.items():
-            if k in sys.modules:
-                if original:
-                    sys.modules[k] = original
-                else:
-                    del sys.modules[k]
+        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.
 
-with pydantic_v1_patch():
-    import sqlmodel as sqlmodel
+            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: Any) -> bool:
-    """Determines if a field is a priamary.
+def sqlmodel_field_has_primary_key(field_info: "FieldInfo") -> bool:
+    """Determines if a field is a primary.
 
     Args:
-        field: a rx.model field
+        field_info: a rx.model field
 
     Returns:
-        If field is a primary key (Bool)
+        If field_info is a primary key (Bool)
     """
-    if getattr(field.field_info, "primary_key", None) is True:
+    if getattr(field_info, "primary_key", None) is True:
         return True
-    if getattr(field.field_info, "sa_column", None) is None:
+    if getattr(field_info, "sa_column", None) is None:
         return False
-    return bool(getattr(field.field_info.sa_column, "primary_key", None))
+    return bool(getattr(field_info.sa_column, "primary_key", None))  # pyright: ignore[reportAttributeAccessIssue]

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

@@ -15,11 +15,7 @@ from pathlib import Path
 from types import ModuleType
 from typing import NamedTuple
 
-from alembic.util.exc import CommandError
 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
@@ -29,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
 
 
@@ -370,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,
@@ -384,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,
@@ -418,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()
@@ -639,6 +652,8 @@ def check_schema_up_to_date():
     if get_config().db_url is None or not environment.ALEMBIC_CONFIG.get().exists():
         return
     with model.Model.get_db_engine().connect() as connection:
+        from alembic.util.exc import CommandError
+
         try:
             if model.Model.alembic_autogenerate(
                 connection=connection,

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: