reflex 0.7.13a1__py3-none-any.whl → 0.7.14a1__py3-none-any.whl

reflex/plugins/tailwind_v3.py

@@ -253,3 +253,11 @@ class Plugin(PluginBase):
             str(Path(Dirs.STYLES) / (PageNames.STYLESHEET_ROOT + Ext.CSS)),
             add_tailwind_to_css_file,
         )
+
+    def __repr__(self):
+        """Return a string representation of the plugin.
+
+        Returns:
+            A string representation of the plugin.
+        """
+        return "TailwindV3Plugin()"

reflex/plugins/tailwind_v4.py

@@ -23,6 +23,7 @@ class Constants(SimpleNamespace):
 
     # Content of the style content.
     ROOT_STYLE_CONTENT = """@layer theme, base, components, utilities;
+@config "../tailwind.config.js";
 @import "tailwindcss/theme.css" layer(theme);
 @import "tailwindcss/preflight.css" layer(base);
 @import "{radix_url}" layer(components);
@@ -255,3 +256,11 @@ class Plugin(PluginBase):
             str(Path(Dirs.STYLES) / (PageNames.STYLESHEET_ROOT + Ext.CSS)),
             add_tailwind_to_css_file,
         )
+
+    def __repr__(self):
+        """Return a string representation of the plugin.
+
+        Returns:
+            A string representation of the plugin.
+        """
+        return "TailwindV4Plugin()"

reflex/reflex.py

@@ -36,7 +36,6 @@ def set_loglevel(ctx: click.Context, self: click.Parameter, value: str | None):
 @click.version_option(constants.Reflex.VERSION, message="%(version)s")
 def cli():
     """Reflex CLI to create, run, and deploy apps."""
-    pass
 
 
 loglevel_option = click.option(
@@ -202,6 +201,9 @@ def _run(
     # Get the app module.
     app_task = prerequisites.compile_or_validate_app
     args = (frontend,)
+    kwargs = {
+        "check_if_schema_up_to_date": True,
+    }
 
     # Granian fails if the app is already imported.
     if should_use_granian():
@@ -210,16 +212,15 @@ def _run(
         compile_future = concurrent.futures.ProcessPoolExecutor(max_workers=1).submit(
             app_task,
             *args,
+            **kwargs,
         )
         validation_result = compile_future.result()
     else:
-        validation_result = app_task(*args)
+        validation_result = app_task(*args, **kwargs)
+
     if not validation_result:
         raise click.exceptions.Exit(1)
 
-    # Warn if schema is not up to date.
-    prerequisites.check_schema_up_to_date()
-
     # Get the frontend and backend commands, based on the environment.
     setup_frontend = frontend_cmd = backend_cmd = None
     if env == constants.Env.DEV:
@@ -235,7 +236,8 @@ def _run(
             exec.run_backend_prod,
         )
     if not setup_frontend or not frontend_cmd or not backend_cmd:
-        raise ValueError(f"Invalid env: {env}. Must be DEV or PROD.")
+        msg = f"Invalid env: {env}. Must be DEV or PROD."
+        raise ValueError(msg)
 
     # Post a telemetry event.
     telemetry.send(f"run-{env.value}")
@@ -481,13 +483,11 @@ def logout():
 @click.group
 def db_cli():
     """Subcommands for managing the database schema."""
-    pass
 
 
 @click.group
 def script_cli():
     """Subcommands for running helper scripts."""
-    pass
 
 
 def _skip_compile():
@@ -531,9 +531,7 @@ def migrate():
     from reflex import model
     from reflex.utils import prerequisites
 
-    # TODO see if we can use `get_app()` instead (no compile).  Would _skip_compile still be needed then?
-    _skip_compile()
-    prerequisites.get_compiled_app()
+    prerequisites.get_app()
     if not prerequisites.check_db_initialized():
         return
     model.Model.migrate()

reflex/route.py

@@ -18,11 +18,13 @@ def verify_route_validity(route: str) -> None:
     """
     pattern = catchall_in_route(route)
     if pattern and not route.endswith(pattern):
-        raise ValueError(f"Catch-all must be the last part of the URL: {route}")
+        msg = f"Catch-all must be the last part of the URL: {route}"
+        raise ValueError(msg)
     if route == "api" or route.startswith("api/"):
-        raise ValueError(
+        msg = (
             f"Cannot have a route prefixed with 'api/': {route} (conflicts with NextJS)"
         )
+        raise ValueError(msg)
 
 
 def get_route_args(route: str) -> dict[str, str]:
@@ -48,9 +50,8 @@ def get_route_args(route: str) -> dict[str, str]:
         """
         arg_name = match.groups()[0]
         if arg_name in args:
-            raise ValueError(
-                f"Arg name [{arg_name}] is used more than once in this URL"
-            )
+            msg = f"Arg name [{arg_name}] is used more than once in this URL"
+            raise ValueError(msg)
         args[arg_name] = type_
 
     # Regex to check for route args.
@@ -136,7 +137,4 @@ def replace_brackets_with_keywords(input_string: str) -> str:
         r"\[\[.+?\]\]", constants.RouteRegex.DOUBLE_SEGMENT, output_string
     )
     # Replace [<slug>] with __SINGLE_SEGMENT__
-    output_string = re.sub(
-        r"\[.+?\]", constants.RouteRegex.SINGLE_SEGMENT, output_string
-    )
-    return output_string
+    return re.sub(r"\[.+?\]", constants.RouteRegex.SINGLE_SEGMENT, output_string)

reflex/state.py

@@ -148,7 +148,8 @@ def _no_chain_background_task(
 
         return _no_chain_background_task_gen
 
-    raise TypeError(f"{fn} is marked as a background task, but is not async.")
+    msg = f"{fn} is marked as a background task, but is not async."
+    raise TypeError(msg)
 
 
 def _substate_key(
@@ -233,22 +234,19 @@ class EventHandlerSetVar(EventHandler):
 
         if args:
             if not isinstance(args[0], str):
-                raise EventHandlerValueError(
-                    f"Var name must be passed as a string, got {args[0]!r}"
-                )
+                msg = f"Var name must be passed as a string, got {args[0]!r}"
+                raise EventHandlerValueError(msg)
 
             handler = getattr(self.state_cls, constants.SETTER_PREFIX + args[0], None)
 
             # Check that the requested Var setter exists on the State at compile time.
             if handler is None:
-                raise AttributeError(
-                    f"Variable `{args[0]}` cannot be set on `{self.state_cls.get_full_name()}`"
-                )
+                msg = f"Variable `{args[0]}` cannot be set on `{self.state_cls.get_full_name()}`"
+                raise AttributeError(msg)
 
             if asyncio.iscoroutinefunction(handler.fn):
-                raise NotImplementedError(
-                    f"Setter for {args[0]} is async, which is not supported."
-                )
+                msg = f"Setter for {args[0]} is async, which is not supported."
+                raise NotImplementedError(msg)
 
         return super().__call__(*args)
 
@@ -406,14 +404,14 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         from reflex.utils.exceptions import ReflexRuntimeError
 
         if not _reflex_internal_init and not is_testing_env():
-            raise ReflexRuntimeError(
+            msg = (
                 "State classes should not be instantiated directly in a Reflex app. "
                 "See https://reflex.dev/docs/state/ for further information."
             )
+            raise ReflexRuntimeError(msg)
         if type(self)._mixin:
-            raise ReflexRuntimeError(
-                f"{type(self).__name__} is a state mixin and cannot be instantiated directly."
-            )
+            msg = f"{type(self).__name__} is a state mixin and cannot be instantiated directly."
+            raise ReflexRuntimeError(msg)
         kwargs["parent_state"] = parent_state
         super().__init__()
         for name, value in kwargs.items():
@@ -462,10 +460,11 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             NameError: If the module name is invalid.
         """
         if "___" in cls.__module__:
-            raise NameError(
+            msg = (
                 "The module name of a State class cannot contain '___'. "
                 "Please rename the module."
             )
+            raise NameError(msg)
 
     @classmethod
     def __init_subclass__(cls, mixin: bool = False, **kwargs):
@@ -515,10 +514,11 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             # Check if another substate class with the same name has already been defined.
             if cls.get_name() in {c.get_name() for c in parent_state.class_subclasses}:
                 # This should not happen, since we have added module prefix to state names in #3214
-                raise StateValueError(
+                msg = (
                     f"The substate class '{cls.get_name()}' has been defined multiple times. "
                     "Shadowing substate classes is not allowed."
                 )
+                raise StateValueError(msg)
             # Track this new subclass in the parent state's subclasses set.
             parent_state.class_subclasses.add(cls)
 
@@ -832,9 +832,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 overridden_methods.add(method.__name__)
 
         for method_name in overridden_methods:
-            raise EventHandlerShadowsBuiltInStateMethodError(
-                f"The event handler name `{method_name}` shadows a builtin State method; use a different name instead"
-            )
+            msg = f"The event handler name `{method_name}` shadows a builtin State method; use a different name instead"
+            raise EventHandlerShadowsBuiltInStateMethodError(msg)
 
     @classmethod
     def _check_overridden_basevars(cls):
@@ -845,9 +844,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         """
         for computed_var_ in cls._get_computed_vars():
             if computed_var_._js_expr in cls.__annotations__:
-                raise ComputedVarShadowsBaseVarsError(
-                    f"The computed var name `{computed_var_._js_expr}` shadows a base var in {cls.__module__}.{cls.__name__}; use a different name instead"
-                )
+                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)
 
     @classmethod
     def _check_overridden_computed_vars(cls) -> None:
@@ -861,9 +859,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 continue
             name = cv._js_expr
             if name in cls.inherited_vars or name in cls.inherited_backend_vars:
-                raise ComputedVarShadowsStateVarError(
-                    f"The computed var name `{cv._js_expr}` shadows a var in {cls.__module__}.{cls.__name__}; use a different name instead"
-                )
+                msg = f"The computed var name `{cv._js_expr}` shadows a var in {cls.__module__}.{cls.__name__}; use a different name instead"
+                raise ComputedVarShadowsStateVarError(msg)
 
     @classmethod
     def get_skip_vars(cls) -> set[str]:
@@ -901,7 +898,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             if issubclass(base, BaseState) and base is not BaseState and not base._mixin
         ]
         if len(parent_states) >= 2:
-            raise ValueError(f"Only one parent state is allowed {parent_states}.")
+            msg = f"Only one parent state is allowed {parent_states}."
+            raise ValueError(msg)
         # The first non-mixin state in the mro is our parent.
         for base in cls.mro()[1:]:
             if not issubclass(base, BaseState) or base._mixin:
@@ -953,7 +951,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         name = cls.get_name()
         parent_state = cls.get_parent_state()
         if parent_state is not None:
-            name = ".".join((parent_state.get_full_name(), name))
+            name = parent_state.get_full_name() + "." + name
         return name
 
     @classmethod
@@ -982,7 +980,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         for substate in cls.get_substates():
             if path[0] == substate.get_name():
                 return substate.get_class_substate(path[1:])
-        raise ValueError(f"Invalid path: {path}")
+        msg = f"Invalid path: {path}"
+        raise ValueError(msg)
 
     @classmethod
     def get_class_var(cls, path: Sequence[str]) -> Any:
@@ -1000,7 +999,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         path, name = path[:-1], path[-1]
         substate = cls.get_class_substate(tuple(path))
         if not hasattr(substate, name):
-            raise ValueError(f"Invalid path: {path}")
+            msg = f"Invalid path: {path}"
+            raise ValueError(msg)
         return getattr(substate, name)
 
     @classmethod
@@ -1029,12 +1029,13 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         from reflex.utils.exceptions import VarTypeError
 
         if not types.is_valid_var_type(prop._var_type):
-            raise VarTypeError(
+            msg = (
                 "State vars must be of a serializable type. "
                 "Valid types include strings, numbers, booleans, lists, "
                 "dictionaries, dataclasses, datetime objects, and pydantic models. "
                 f'Found var "{prop._js_expr}" with type {prop._var_type}.'
             )
+            raise VarTypeError(msg)
         cls._set_var(prop)
         if cls.is_user_defined() and get_config().state_auto_setters:
             cls._create_setter(prop)
@@ -1056,9 +1057,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             NameError: if a variable of this name already exists
         """
         if name in cls.__fields__:
-            raise NameError(
-                f"The variable '{name}' already exist. Use a different name"
-            )
+            msg = f"The variable '{name}' already exist. Use a different name"
+            raise NameError(msg)
 
         # create the variable based on name and type
         var = Var(
@@ -1260,9 +1260,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 arg in cls.computed_vars
                 and not isinstance(cls.computed_vars[arg], DynamicRouteVar)
             ) or arg in cls.base_vars:
-                raise DynamicRouteArgShadowsStateVarError(
-                    f"Dynamic route arg '{arg}' is shadowing an existing var in {cls.__module__}.{cls.__name__}"
-                )
+                msg = f"Dynamic route arg '{arg}' is shadowing an existing var in {cls.__module__}.{cls.__name__}"
+                raise DynamicRouteArgShadowsStateVarError(msg)
         for substate in cls.get_substates():
             substate._check_overwritten_dynamic_args(args)
 
@@ -1363,10 +1362,11 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 f"_{getattr(type(self), '__original_name__', type(self).__name__)}__"
             )
         ):
-            raise SetUndefinedStateVarError(
+            msg = (
                 f"The state variable '{name}' has not been defined in '{type(self).__name__}'. "
                 f"All state variables must be declared before they can be set."
             )
+            raise SetUndefinedStateVarError(msg)
 
         fields = self.get_fields()
 
@@ -1470,7 +1470,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 return self
             path = path[1:]
         if path[0] not in self.substates:
-            raise ValueError(f"Invalid path: {path}")
+            msg = f"Invalid path: {path}"
+            raise ValueError(msg)
         return self.substates[path[0]].get_substate(path[1:])
 
     @classmethod
@@ -1517,10 +1518,11 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         # Then get the target state and all its substates.
         state_manager = get_state_manager()
         if not isinstance(state_manager, StateManagerRedis):
-            raise RuntimeError(
+            msg = (
                 f"Requested state {state_cls.get_full_name()} is not cached and cannot be accessed without redis. "
-                "(All states should already be available -- this is likely a bug).",
+                "(All states should already be available -- this is likely a bug)."
             )
+            raise RuntimeError(msg)
         state_in_redis = await state_manager.get_state(
             token=_substate_key(self.router.session.client_token, state_cls),
             top_level=False,
@@ -1528,9 +1530,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         )
 
         if not isinstance(state_in_redis, state_cls):
-            raise StateMismatchError(
-                f"Searched for state {state_cls.get_full_name()} but found {state_in_redis}."
-            )
+            msg = f"Searched for state {state_cls.get_full_name()} but found {state_in_redis}."
+            raise StateMismatchError(msg)
 
         return state_in_redis
 
@@ -1549,9 +1550,10 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         root_state = self._get_root_state()
         substate = root_state.get_substate(state_cls.get_full_name().split("."))
         if not isinstance(substate, state_cls):
-            raise StateMismatchError(
+            msg = (
                 f"Searched for state {state_cls.get_full_name()} but found {substate}."
             )
+            raise StateMismatchError(msg)
         return substate
 
     async def get_state(self, state_cls: type[T_STATE]) -> T_STATE:
@@ -1601,9 +1603,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
 
         var_data = var._get_all_var_data()
         if var_data is None or not var_data.state:
-            raise UnretrievableVarValueError(
-                f"Unable to retrieve value for {var._js_expr}: not associated with any state."
-            )
+            msg = f"Unable to retrieve value for {var._js_expr}: not associated with any state."
+            raise UnretrievableVarValueError(msg)
         # Fastish case: this var belongs to this state
         if var_data.state == self.get_full_name():
             return getattr(self, var_data.field_name)
@@ -1634,9 +1635,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         path, name = path[:-1], path[-1]
         substate = self.get_substate(path)
         if not substate:
-            raise ValueError(
-                "The value of state cannot be None when processing an event."
-            )
+            msg = "The value of state cannot be None when processing an event."
+            raise ValueError(msg)
         handler = substate.event_handlers[name]
 
         # For background tasks, proxy the state
@@ -1702,10 +1702,11 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 "ignore", message=f"coroutine '{coroutine_name}' was never awaited"
             )
 
-        raise TypeError(
+        msg = (
             f"Your handler {handler.fn.__qualname__} must only return/yield: None, Events or other EventHandlers referenced by their class (i.e. using `type(self)` or other class references)."
             f" Returned events of types {', '.join(map(str, map(type, events)))!s}."
         )
+        raise TypeError(msg)
 
     async def _as_state_update(
         self,
@@ -1834,9 +1835,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 try:
                     payload[arg] = hinted_args(value)
                 except ValueError:
-                    raise ValueError(
-                        f"Received a string value ({value}) for {arg} but expected a {hinted_args}"
-                    ) from None
+                    msg = f"Received a string value ({value}) for {arg} but expected a {hinted_args}"
+                    raise ValueError(msg) from None
                 else:
                     console.warn(
                         f"Received a string value ({value}) for {arg} but expected a {hinted_args}. A simple conversion was successful."
@@ -2123,9 +2123,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         Raises:
             TypeError: always, because async contextmanager protocol is only supported for background task.
         """
-        raise TypeError(
-            "Only background task should use `async with self` to modify state."
-        )
+        msg = "Only background task should use `async with self` to modify state."
+        raise TypeError(msg)
 
     async def __aexit__(self, *exc_info: Any) -> None:
         """Exit the async context manager protocol.
@@ -2136,7 +2135,6 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         Args:
             exc_info: The exception info tuple.
         """
-        pass
 
     def __getstate__(self):
         """Get the state for redis serialization.
@@ -2298,9 +2296,10 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         elif fp is not None and data is None:
             (substate_schema, state) = pickle.load(fp)
         else:
-            raise ValueError("Only one of `data` or `fp` must be provided")
+            msg = "Only one of `data` or `fp` must be provided"
+            raise ValueError(msg)
         if substate_schema != state._to_schema():
-            raise StateSchemaMismatchError()
+            raise StateSchemaMismatchError
         return state
 
 
@@ -2377,14 +2376,12 @@ def dynamic(func: Callable[[T], Component]):
     values = list(func_signature.values())
 
     if number_of_parameters != 1:
-        raise DynamicComponentInvalidSignatureError(
-            "The function must have exactly one parameter, which is the state class."
-        )
+        msg = "The function must have exactly one parameter, which is the state class."
+        raise DynamicComponentInvalidSignatureError(msg)
 
     if len(values) != 1:
-        raise DynamicComponentInvalidSignatureError(
-            "You must provide a type hint for the state class in the function."
-        )
+        msg = "You must provide a type hint for the state class in the function."
+        raise DynamicComponentInvalidSignatureError(msg)
 
     state_class: type[T] = values[0]
 
@@ -2457,7 +2454,7 @@ class OnLoadInternalState(State):
         )
         if not load_events:
             self.is_hydrated = True
-            return  # Fast path for navigation with no on_load events defined.
+            return None  # Fast path for navigation with no on_load events defined.
         self.is_hydrated = False
         return [
             *fix_events(
@@ -2549,9 +2546,8 @@ class ComponentState(State, mixin=True):
         Raises:
             NotImplementedError: if the subclass does not override this method.
         """
-        raise NotImplementedError(
-            f"{cls.__name__} must implement get_component to return the component instance."
-        )
+        msg = f"{cls.__name__} must implement get_component to return the component instance."
+        raise NotImplementedError(msg)
 
     @classmethod
     def create(cls, *children, **props) -> Component:

reflex/style.py

@@ -121,10 +121,11 @@ def convert_item(
         ReflexError: If an EventHandler is used as a style value
     """
     if isinstance(style_item, EventHandler):
-        raise ReflexError(
+        msg = (
             "EventHandlers cannot be used as style values. "
             "Please use a Var or a literal value."
         )
+        raise ReflexError(msg)
 
     if isinstance(style_item, Var):
         return style_item, style_item._get_all_var_data()
@@ -381,6 +382,7 @@ def format_as_emotion(style_dict: dict[str, Any]) -> Style | None:
         if _var_data is not None:
             emotion_style._var_data = VarData.merge(emotion_style._var_data, _var_data)
         return emotion_style
+    return None
 
 
 def convert_dict_to_style_and_format_emotion(