reflex 0.7.0a5__py3-none-any.whl → 0.7.1__py3-none-any.whl

reflex/reflex.py

@@ -20,13 +20,8 @@ from reflex.utils import console, telemetry
 typer.core.rich = None  # pyright: ignore [reportPrivateImportUsage]
 
 # Create the app.
-try:
-    cli = typer.Typer(add_completion=False, pretty_exceptions_enable=False)
-except TypeError:
-    # Fallback for older typer versions.
-    cli = typer.Typer(add_completion=False)
+cli = typer.Typer(add_completion=False, pretty_exceptions_enable=False)
 
-SHOW_BUILT_WITH_REFLEX_INFO = "https://reflex.dev/docs/hosting/reflex-branding/"
 
 # Get the config.
 config = get_config()
@@ -127,8 +122,8 @@ def _run(
     env: constants.Env = constants.Env.DEV,
     frontend: bool = True,
     backend: bool = True,
-    frontend_port: int = config.frontend_port,
-    backend_port: int = config.backend_port,
+    frontend_port: int | None = None,
+    backend_port: int | None = None,
     backend_host: str = config.backend_host,
     loglevel: constants.LogLevel = config.loglevel,
 ):
@@ -158,17 +153,28 @@ def _run(
 
     # Find the next available open port if applicable.
     if frontend:
+        auto_increment_frontend = not bool(frontend_port or config.frontend_port)
         frontend_port = processes.handle_port(
             "frontend",
-            frontend_port,
-            constants.DefaultPorts.FRONTEND_PORT,
+            (
+                frontend_port
+                or config.frontend_port
+                or constants.DefaultPorts.FRONTEND_PORT
+            ),
+            auto_increment=auto_increment_frontend,
         )
 
     if backend:
+        auto_increment_backend = not bool(backend_port or config.backend_port)
+
         backend_port = processes.handle_port(
             "backend",
-            backend_port,
-            constants.DefaultPorts.BACKEND_PORT,
+            (
+                backend_port
+                or config.backend_port
+                or constants.DefaultPorts.BACKEND_PORT
+            ),
+            auto_increment=auto_increment_backend,
         )
 
     # Apply the new ports to the config.
@@ -185,15 +191,6 @@ def _run(
     prerequisites.check_latest_package_version(constants.Reflex.MODULE_NAME)
 
     if frontend:
-        if not config.show_built_with_reflex:
-            # The sticky badge may be disabled at runtime for team/enterprise tiers.
-            prerequisites.check_config_option_in_tier(
-                option_name="show_built_with_reflex",
-                allowed_tiers=["team", "enterprise"],
-                fallback_value=True,
-                help_link=SHOW_BUILT_WITH_REFLEX_INFO,
-            )
-
         # Get the app module.
         prerequisites.get_compiled_app()
 
@@ -246,7 +243,7 @@ def _run(
     # Start the frontend and backend.
     with processes.run_concurrently_context(*commands):
         # In dev mode, run the backend on the main thread.
-        if backend and env == constants.Env.DEV:
+        if backend and backend_port and env == constants.Env.DEV:
             backend_cmd(
                 backend_host, int(backend_port), loglevel.subprocess_level(), frontend
             )
@@ -275,10 +272,14 @@ def run(
         envvar=environment.REFLEX_BACKEND_ONLY.name,
     ),
     frontend_port: int = typer.Option(
-        config.frontend_port, help="Specify a different frontend port."
+        config.frontend_port,
+        help="Specify a different frontend port.",
+        envvar=environment.REFLEX_FRONTEND_PORT.name,
     ),
     backend_port: int = typer.Option(
-        config.backend_port, help="Specify a different backend port."
+        config.backend_port,
+        help="Specify a different backend port.",
+        envvar=environment.REFLEX_BACKEND_PORT.name,
     ),
     backend_host: str = typer.Option(
         config.backend_host, help="Specify the backend host."
@@ -291,6 +292,8 @@ def run(
     if frontend and backend:
         console.error("Cannot use both --frontend-only and --backend-only options.")
         raise typer.Exit(1)
+
+    environment.REFLEX_COMPILE_CONTEXT.set(constants.CompileContext.RUN)
     environment.REFLEX_BACKEND_ONLY.set(backend)
     environment.REFLEX_FRONTEND_ONLY.set(frontend)
 
@@ -337,20 +340,13 @@ def export(
     from reflex.utils import export as export_utils
     from reflex.utils import prerequisites
 
+    environment.REFLEX_COMPILE_CONTEXT.set(constants.CompileContext.EXPORT)
+
     frontend, backend = prerequisites.check_running_mode(frontend, backend)
 
     if prerequisites.needs_reinit(frontend=frontend or not backend):
         _init(name=config.app_name, loglevel=loglevel)
 
-    if frontend and not config.show_built_with_reflex:
-        # The sticky badge may be disabled on export for team/enterprise tiers.
-        prerequisites.check_config_option_in_tier(
-            option_name="show_built_with_reflex",
-            allowed_tiers=["team", "enterprise"],
-            fallback_value=False,
-            help_link=SHOW_BUILT_WITH_REFLEX_INFO,
-        )
-
     export_utils.export(
         zipping=zipping,
         frontend=frontend,
@@ -545,14 +541,7 @@ def deploy(
 
     check_version()
 
-    if not config.show_built_with_reflex:
-        # The sticky badge may be disabled on deploy for pro/team/enterprise tiers.
-        prerequisites.check_config_option_in_tier(
-            option_name="show_built_with_reflex",
-            allowed_tiers=["pro", "team", "enterprise"],
-            fallback_value=True,
-            help_link=SHOW_BUILT_WITH_REFLEX_INFO,
-        )
+    environment.REFLEX_COMPILE_CONTEXT.set(constants.CompileContext.DEPLOY)
 
     # Set the log level.
     console.set_log_level(loglevel)

reflex/state.py

@@ -40,50 +40,22 @@ from typing import (
     get_type_hints,
 )
 
-from redis.asyncio.client import PubSub
-from sqlalchemy.orm import DeclarativeBase
-from typing_extensions import Self
-
-from reflex import event
-from reflex.config import PerformanceMode, get_config
-from reflex.istate.data import RouterData
-from reflex.istate.storage import ClientStorageBase
-from reflex.model import Model
-from reflex.vars.base import (
-    ComputedVar,
-    DynamicRouteVar,
-    Var,
-    computed_var,
-    dispatch,
-    get_unique_variable_name,
-    is_computed_var,
-)
-
-try:
-    import pydantic.v1 as pydantic
-except ModuleNotFoundError:
-    import pydantic
-
-from pydantic import BaseModel as BaseModelV2
-
-try:
-    from pydantic.v1 import BaseModel as BaseModelV1
-except ModuleNotFoundError:
-    BaseModelV1 = BaseModelV2
-
-try:
-    from pydantic.v1 import validator
-except ModuleNotFoundError:
-    from pydantic import validator
-
+import pydantic.v1 as pydantic
 import wrapt
+from pydantic import BaseModel as BaseModelV2
+from pydantic.v1 import BaseModel as BaseModelV1
+from pydantic.v1 import validator
+from pydantic.v1.fields import ModelField
 from redis.asyncio import Redis
+from redis.asyncio.client import PubSub
 from redis.exceptions import ResponseError
+from sqlalchemy.orm import DeclarativeBase
+from typing_extensions import Self
 
 import reflex.istate.dynamic
-from reflex import constants
+from reflex import constants, event
 from reflex.base import Base
-from reflex.config import environment
+from reflex.config import PerformanceMode, environment, get_config
 from reflex.event import (
     BACKGROUND_TASK_MARKER,
     Event,
@@ -91,6 +63,9 @@ from reflex.event import (
     EventSpec,
     fix_events,
 )
+from reflex.istate.data import RouterData
+from reflex.istate.storage import ClientStorageBase
+from reflex.model import Model
 from reflex.utils import console, format, path_ops, prerequisites, types
 from reflex.utils.exceptions import (
     ComputedVarShadowsBaseVarsError,
@@ -121,6 +96,15 @@ from reflex.utils.types import (
     value_inside_optional,
 )
 from reflex.vars import VarData
+from reflex.vars.base import (
+    ComputedVar,
+    DynamicRouteVar,
+    Var,
+    computed_var,
+    dispatch,
+    get_unique_variable_name,
+    is_computed_var,
+)
 
 if TYPE_CHECKING:
     from reflex.components.component import Component
@@ -289,10 +273,6 @@ class EventHandlerSetVar(EventHandler):
         return super().__call__(*args)
 
 
-if TYPE_CHECKING:
-    from pydantic.v1.fields import ModelField
-
-
 def _unwrap_field_type(type_: Type) -> Type:
     """Unwrap rx.Field type annotations.
 
@@ -347,6 +327,9 @@ async def _resolve_delta(delta: Delta) -> Delta:
     return delta
 
 
+all_base_state_classes: dict[str, None] = {}
+
+
 class BaseState(Base, ABC, extra=pydantic.Extra.allow):
     """The state of the app."""
 
@@ -644,6 +627,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         cls._var_dependencies = {}
         cls._init_var_dependency_dicts()
 
+        all_base_state_classes[cls.get_full_name()] = None
+
     @staticmethod
     def _copy_fn(fn: Callable) -> Callable:
         """Copy a function. Used to copy ComputedVars and EventHandlers from mixins.
@@ -1742,6 +1727,9 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
 
         Yields:
             StateUpdate object
+
+        Raises:
+            ValueError: If a string value is received for an int or float type and cannot be converted.
         """
         from reflex.utils import telemetry
 
@@ -1779,12 +1767,25 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                     hinted_args, (Base, BaseModelV1, BaseModelV2)
                 ):
                     payload[arg] = hinted_args(**value)
-            if isinstance(value, list) and (hinted_args is set or hinted_args is Set):
+            elif isinstance(value, list) and (hinted_args is set or hinted_args is Set):
                 payload[arg] = set(value)
-            if isinstance(value, list) and (
+            elif isinstance(value, list) and (
                 hinted_args is tuple or hinted_args is Tuple
             ):
                 payload[arg] = tuple(value)
+            elif isinstance(value, str) and (
+                hinted_args is int or hinted_args is float
+            ):
+                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
+                else:
+                    console.warn(
+                        f"Received a string value ({value}) for {arg} but expected a {hinted_args}. A simple conversion was successful."
+                    )
 
         # Wrap the function in a try/except block.
         try:
@@ -2459,6 +2460,8 @@ class ComponentState(State, mixin=True):
         Returns:
             A new instance of the Component with an independent copy of the State.
         """
+        from reflex.compiler.compiler import into_component
+
         cls._per_component_state_instance_count += 1
         state_cls_name = f"{cls.__name__}_n{cls._per_component_state_instance_count}"
         component_state = type(
@@ -2470,6 +2473,7 @@ class ComponentState(State, mixin=True):
         # Save a reference to the dynamic state for pickle/unpickle.
         setattr(reflex.istate.dynamic, state_cls_name, component_state)
         component = component_state.get_component(*children, **props)
+        component = into_component(component)
         component.State = component_state
         return component
 
@@ -4088,6 +4092,7 @@ def reload_state_module(
     for subclass in tuple(state.class_subclasses):
         reload_state_module(module=module, state=subclass)
         if subclass.__module__ == module and module is not None:
+            all_base_state_classes.pop(subclass.get_full_name(), None)
             state.class_subclasses.remove(subclass)
             state._always_dirty_substates.discard(subclass.get_name())
             state._var_dependencies = {}

reflex/style.py

@@ -6,13 +6,13 @@ from typing import Any, Literal, Tuple, Type
 
 from reflex import constants
 from reflex.components.core.breakpoints import Breakpoints, breakpoints_values
-from reflex.event import EventChain, EventHandler
+from reflex.event import EventChain, EventHandler, EventSpec, run_script
 from reflex.utils import format
 from reflex.utils.exceptions import ReflexError
 from reflex.utils.imports import ImportVar
 from reflex.utils.types import get_origin
 from reflex.vars import VarData
-from reflex.vars.base import CallableVar, LiteralVar, Var
+from reflex.vars.base import LiteralVar, Var
 from reflex.vars.function import FunctionVar
 from reflex.vars.object import ObjectVar
 
@@ -48,11 +48,10 @@ def _color_mode_var(_js_expr: str, _var_type: Type = str) -> Var:
     ).guess_type()
 
 
-@CallableVar
 def set_color_mode(
-    new_color_mode: LiteralColorMode | Var[LiteralColorMode] | None = None,
-) -> Var[EventChain]:
-    """Create an EventChain Var that sets the color mode to a specific value.
+    new_color_mode: LiteralColorMode | Var[LiteralColorMode],
+) -> EventSpec:
+    """Create an EventSpec Var that sets the color mode to a specific value.
 
     Note: `set_color_mode` is not a real event and cannot be triggered from a
     backend event handler.
@@ -61,24 +60,15 @@ def set_color_mode(
         new_color_mode: The color mode to set.
 
     Returns:
-        The EventChain Var that can be passed to an event trigger.
+        The EventSpec Var that can be passed to an event trigger.
     """
     base_setter = _color_mode_var(
         _js_expr=constants.ColorMode.SET,
-        _var_type=EventChain,
-    )
-    if new_color_mode is None:
-        return base_setter
-
-    if not isinstance(new_color_mode, Var):
-        new_color_mode = LiteralVar.create(new_color_mode)
+    ).to(FunctionVar)
 
-    return Var(
-        f"() => {base_setter!s}({new_color_mode!s})",
-        _var_data=VarData.merge(
-            base_setter._get_all_var_data(), new_color_mode._get_all_var_data()
-        ),
-    ).to(FunctionVar, EventChain)
+    return run_script(
+        base_setter.call(new_color_mode),
+    )
 
 
 # Var resolves to the current color mode for the app ("light", "dark" or "system")
@@ -191,11 +181,12 @@ def convert(
     for key, value in style_dict.items():
         keys = (
             format_style_key(key)
-            if not isinstance(value, (dict, ObjectVar))
+            if not isinstance(value, (dict, ObjectVar, list))
             or (
                 isinstance(value, Breakpoints)
                 and all(not isinstance(v, dict) for v in value.values())
             )
+            or (isinstance(value, list) and all(not isinstance(v, dict) for v in value))
             or (
                 isinstance(value, ObjectVar)
                 and not issubclass(get_origin(value._var_type) or value._var_type, dict)
@@ -237,7 +228,9 @@ def format_style_key(key: str) -> Tuple[str, ...]:
     Returns:
         Tuple of css style names corresponding to the key provided.
     """
-    key = format.to_camel_case(key, allow_hyphens=True)
+    if key.startswith("--"):
+        return (key,)
+    key = format.to_camel_case(key)
     return STYLE_PROP_SHORTHAND_MAPPING.get(key, (key,))
 
 

reflex/testing.py

@@ -43,6 +43,7 @@ import reflex.utils.exec
 import reflex.utils.format
 import reflex.utils.prerequisites
 import reflex.utils.processes
+from reflex.components.component import CustomComponent
 from reflex.config import environment
 from reflex.state import (
     BaseState,
@@ -254,6 +255,7 @@ class AppHarness:
         # disable telemetry reporting for tests
 
         os.environ["TELEMETRY_ENABLED"] = "false"
+        CustomComponent.create().get_component.cache_clear()
         self.app_path.mkdir(parents=True, exist_ok=True)
         if self.app_source is not None:
             app_globals = self._get_globals_from_signature(self.app_source)

reflex/utils/build.py

@@ -60,6 +60,7 @@ def _zip(
     dirs_to_exclude: set[str] | None = None,
     files_to_exclude: set[str] | None = None,
     top_level_dirs_to_exclude: set[str] | None = None,
+    globs_to_include: list[str] | None = None,
 ) -> None:
     """Zip utility function.
 
@@ -72,6 +73,7 @@ def _zip(
         dirs_to_exclude: The directories to exclude.
         files_to_exclude: The files to exclude.
         top_level_dirs_to_exclude: The top level directory names immediately under root_dir to exclude. Do not exclude folders by these names further in the sub-directories.
+        globs_to_include: Apply these globs from the root_dir and always include them in the zip.
 
     """
     target = Path(target)
@@ -103,6 +105,13 @@ def _zip(
         files_to_zip += [
             str(root / file) for file in files if file not in files_to_exclude
         ]
+    if globs_to_include:
+        for glob in globs_to_include:
+            files_to_zip += [
+                str(file)
+                for file in root_dir.glob(glob)
+                if file.name not in files_to_exclude
+            ]
 
     # Create a progress bar for zipping the component.
     progress = Progress(
@@ -160,6 +169,9 @@ def zip_app(
             top_level_dirs_to_exclude={"assets"},
             exclude_venv_dirs=True,
             upload_db_file=upload_db_file,
+            globs_to_include=[
+                str(Path(constants.Dirs.WEB) / constants.Dirs.BACKEND / "*")
+            ],
         )
 
 

reflex/utils/console.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import contextlib
 import inspect
+import os
 import shutil
 import time
 from pathlib import Path
@@ -60,6 +61,9 @@ def set_log_level(log_level: LogLevel):
             f"log_level must be a LogLevel enum value, got {log_level} of type {type(log_level)} instead."
         )
     global _LOG_LEVEL
+    if log_level != _LOG_LEVEL:
+        # Set the loglevel persistenly for subprocesses.
+        os.environ["LOGLEVEL"] = log_level.value
     _LOG_LEVEL = log_level
 
 

reflex/utils/decorator.py

@@ -0,0 +1,25 @@
+"""Decorator utilities."""
+
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+
+def once(f: Callable[[], T]) -> Callable[[], T]:
+    """A decorator that calls the function once and caches the result.
+
+    Args:
+        f: The function to call.
+
+    Returns:
+        A function that calls the function once and caches the result.
+    """
+    unset = object()
+    value: object | T = unset
+
+    def wrapper() -> T:
+        nonlocal value
+        value = f() if value is unset else value
+        return value  # pyright: ignore[reportReturnType]
+
+    return wrapper