reflex 0.8.14.post1__py3-none-any.whl → 0.8.15a0__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

@@ -17,19 +17,15 @@ import typing
 import warnings
 from collections.abc import AsyncIterator, Callable, Sequence
 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 +90,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 +104,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."
@@ -259,10 +253,6 @@ class EventHandlerSetVar(EventHandler):
         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.
 
@@ -479,7 +469,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 +729,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
             )
@@ -1090,7 +1080,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 +1178,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 +1339,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 +1455,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:
@@ -1872,10 +1862,16 @@ 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 (
@@ -2142,7 +2138,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 +2622,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)
 

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
 
@@ -320,12 +321,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,9 @@
 """Compatibility hacks and helpers."""
 
-import contextlib
-import sys
-from typing import Any
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
 
 
 async def windows_hot_reload_lifespan_hack():
@@ -29,63 +30,17 @@ 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.
-
-    Yields:
-        None when the Pydantic module is patched.
-    """
-    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
-
-        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]
-
-
-with pydantic_v1_patch():
-    import sqlmodel as sqlmodel
-
-
-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/prerequisites.py

@@ -15,7 +15,6 @@ 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
@@ -639,6 +638,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/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