reflex 0.7.2a2__py3-none-any.whl → 0.7.3a1__py3-none-any.whl

reflex/reflex.py

@@ -13,7 +13,7 @@ from reflex import constants
 from reflex.config import environment, get_config
 from reflex.custom_components.custom_components import custom_components_cli
 from reflex.state import reset_disk_state_manager
-from reflex.utils import console, telemetry
+from reflex.utils import console, redir, telemetry
 
 # Disable typer+rich integration for help panels
 typer.core.rich = None  # pyright: ignore [reportPrivateImportUsage]
@@ -22,10 +22,6 @@ typer.core.rich = None  # pyright: ignore [reportPrivateImportUsage]
 cli = typer.Typer(add_completion=False, pretty_exceptions_enable=False)
 
 
-# Get the config.
-config = get_config()
-
-
 def version(value: bool):
     """Get the Reflex version.
 
@@ -58,18 +54,28 @@ def main(
 def _init(
     name: str,
     template: str | None = None,
-    loglevel: constants.LogLevel = config.loglevel,
+    loglevel: constants.LogLevel | None = None,
     ai: bool = False,
 ):
     """Initialize a new Reflex app in the given directory."""
     from reflex.utils import exec, prerequisites
 
+    if loglevel is not None:
+        console.set_log_level(loglevel)
+
+    config = get_config()
+
     # Set the log level.
+    loglevel = loglevel or config.loglevel
     console.set_log_level(loglevel)
 
     # Show system info
     exec.output_system_info()
 
+    if ai:
+        redir.reflex_build_redirect()
+        return
+
     # Validate the app name.
     app_name = prerequisites.validate_app_name(name)
     console.rule(f"[bold]Initializing {app_name}")
@@ -83,7 +89,7 @@ def _init(
     prerequisites.initialize_frontend_dependencies()
 
     # Initialize the app.
-    template = prerequisites.initialize_app(app_name, template, ai)
+    template = prerequisites.initialize_app(app_name, template)
 
     # Initialize the .gitignore.
     prerequisites.initialize_gitignore()
@@ -105,8 +111,8 @@ def init(
         None,
         help="The template to initialize the app with.",
     ),
-    loglevel: constants.LogLevel = typer.Option(
-        config.loglevel, help="The log level to use."
+    loglevel: constants.LogLevel | None = typer.Option(
+        None, help="The log level to use."
     ),
     ai: bool = typer.Option(
         False,
@@ -123,12 +129,20 @@ def _run(
     backend: bool = True,
     frontend_port: int | None = None,
     backend_port: int | None = None,
-    backend_host: str = config.backend_host,
-    loglevel: constants.LogLevel = config.loglevel,
+    backend_host: str | None = None,
+    loglevel: constants.LogLevel | None = None,
 ):
     """Run the app in the given directory."""
     from reflex.utils import build, exec, prerequisites, processes
 
+    if loglevel is not None:
+        console.set_log_level(loglevel)
+
+    config = get_config()
+
+    loglevel = loglevel or config.loglevel
+    backend_host = backend_host or config.backend_host
+
     # Set the log level.
     console.set_log_level(loglevel)
 
@@ -270,21 +284,19 @@ def run(
         help="Execute only backend.",
         envvar=environment.REFLEX_BACKEND_ONLY.name,
     ),
-    frontend_port: int = typer.Option(
-        config.frontend_port,
+    frontend_port: int | None = typer.Option(
+        None,
         help="Specify a different frontend port.",
         envvar=environment.REFLEX_FRONTEND_PORT.name,
     ),
-    backend_port: int = typer.Option(
-        config.backend_port,
+    backend_port: int | None = typer.Option(
+        None,
         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."
-    ),
-    loglevel: constants.LogLevel = typer.Option(
-        config.loglevel, help="The log level to use."
+    backend_host: str | None = typer.Option(None, help="Specify the backend host."),
+    loglevel: constants.LogLevel | None = typer.Option(
+        None, help="The log level to use."
     ),
 ):
     """Run the app in the current directory."""
@@ -292,6 +304,16 @@ def run(
         console.error("Cannot use both --frontend-only and --backend-only options.")
         raise typer.Exit(1)
 
+    if loglevel is not None:
+        console.set_log_level(loglevel)
+
+    config = get_config()
+
+    frontend_port = frontend_port or config.frontend_port
+    backend_port = backend_port or config.backend_port
+    backend_host = backend_host or config.backend_host
+    loglevel = loglevel or config.loglevel
+
     environment.REFLEX_COMPILE_CONTEXT.set(constants.CompileContext.RUN)
     environment.REFLEX_BACKEND_ONLY.set(backend)
     environment.REFLEX_FRONTEND_ONLY.set(frontend)
@@ -331,8 +353,8 @@ def export(
     env: constants.Env = typer.Option(
         constants.Env.PROD, help="The environment to export the app in."
     ),
-    loglevel: constants.LogLevel = typer.Option(
-        config.loglevel, help="The log level to use."
+    loglevel: constants.LogLevel | None = typer.Option(
+        None, help="The log level to use."
     ),
 ):
     """Export the app to a zip file."""
@@ -343,8 +365,11 @@ def export(
 
     frontend, backend = prerequisites.check_running_mode(frontend, backend)
 
+    loglevel = loglevel or get_config().loglevel
+    console.set_log_level(loglevel)
+
     if prerequisites.needs_reinit(frontend=frontend or not backend):
-        _init(name=config.app_name, loglevel=loglevel)
+        _init(name=get_config().app_name, loglevel=loglevel)
 
     export_utils.export(
         zipping=zipping,
@@ -358,10 +383,14 @@ def export(
 
 
 @cli.command()
-def login(loglevel: constants.LogLevel = typer.Option(config.loglevel)):
+def login(loglevel: constants.LogLevel | None = typer.Option(None)):
     """Authenticate with experimental Reflex hosting service."""
     from reflex_cli.v2 import cli as hosting_cli
 
+    loglevel = loglevel or get_config().loglevel
+
+    console.set_log_level(loglevel)
+
     check_version()
 
     validated_info = hosting_cli.login()
@@ -372,8 +401,8 @@ def login(loglevel: constants.LogLevel = typer.Option(config.loglevel)):
 
 @cli.command()
 def logout(
-    loglevel: constants.LogLevel = typer.Option(
-        config.loglevel, help="The log level to use."
+    loglevel: constants.LogLevel | None = typer.Option(
+        None, help="The log level to use."
     ),
 ):
     """Log out of access to Reflex hosting service."""
@@ -381,6 +410,8 @@ def logout(
 
     check_version()
 
+    loglevel = loglevel or get_config().loglevel
+
     logout(loglevel)  # pyright: ignore [reportArgumentType]
 
 
@@ -399,6 +430,8 @@ def db_init():
     from reflex import model
     from reflex.utils import prerequisites
 
+    config = get_config()
+
     # Check the database url.
     if config.db_url is None:
         console.error("db_url is not configured, cannot initialize.")
@@ -466,8 +499,8 @@ def makemigrations(
 
 @cli.command()
 def deploy(
-    app_name: str = typer.Option(
-        config.app_name,
+    app_name: str | None = typer.Option(
+        None,
         "--app-name",
         help="The name of the App to deploy under.",
     ),
@@ -506,8 +539,8 @@ def deploy(
         "--envfile",
         help="The path to an env file to use. Will override any envs set manually.",
     ),
-    loglevel: constants.LogLevel = typer.Option(
-        config.loglevel, help="The log level to use."
+    loglevel: constants.LogLevel | None = typer.Option(
+        None, help="The log level to use."
     ),
     project: str | None = typer.Option(
         None,
@@ -538,6 +571,14 @@ def deploy(
     from reflex.utils import export as export_utils
     from reflex.utils import prerequisites
 
+    if loglevel is not None:
+        console.set_log_level(loglevel)
+
+    config = get_config()
+
+    loglevel = loglevel or config.loglevel
+    app_name = app_name or config.app_name
+
     check_version()
 
     environment.REFLEX_COMPILE_CONTEXT.set(constants.CompileContext.DEPLOY)
@@ -604,13 +645,15 @@ def deploy(
 @cli.command()
 def rename(
     new_name: str = typer.Argument(..., help="The new name for the app."),
-    loglevel: constants.LogLevel = typer.Option(
-        config.loglevel, help="The log level to use."
+    loglevel: constants.LogLevel | None = typer.Option(
+        None, help="The log level to use."
     ),
 ):
     """Rename the app in the current directory."""
     from reflex.utils import prerequisites
 
+    loglevel = loglevel or get_config().loglevel
+
     prerequisites.validate_app_name(new_name)
     prerequisites.rename_app(new_name, loglevel)
 

reflex/state.py

@@ -1013,9 +1013,9 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
 
         if not types.is_valid_var_type(prop._var_type):
             raise VarTypeError(
-                "State vars must be primitive Python types, "
-                "Plotly figures, Pandas dataframes, "
-                "or subclasses of rx.Base. "
+                "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}.'
             )
         cls._set_var(prop)

reflex/style.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Literal, Type
+from typing import Any, Literal, Mapping, Type
 
 from reflex import constants
 from reflex.components.core.breakpoints import Breakpoints, breakpoints_values
@@ -10,7 +10,7 @@ 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.utils.types import typehint_issubclass
 from reflex.vars import VarData
 from reflex.vars.base import LiteralVar, Var
 from reflex.vars.function import FunctionVar
@@ -189,7 +189,7 @@ def convert(
             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)
+                and not typehint_issubclass(value._var_type, Mapping)
             )
             else (key,)
         )

reflex/testing.py

@@ -54,18 +54,12 @@ from reflex.state import (
 from reflex.utils import console
 
 try:
-    from selenium import webdriver  # pyright: ignore [reportMissingImports]
-    from selenium.webdriver.remote.webdriver import (  # pyright: ignore [reportMissingImports]
-        WebDriver,
-    )
+    from selenium import webdriver
+    from selenium.webdriver.remote.webdriver import WebDriver
 
     if TYPE_CHECKING:
-        from selenium.webdriver.common.options import (
-            ArgOptions,  # pyright: ignore [reportMissingImports]
-        )
-        from selenium.webdriver.remote.webelement import (  # pyright: ignore [reportMissingImports]
-            WebElement,
-        )
+        from selenium.webdriver.common.options import ArgOptions
+        from selenium.webdriver.remote.webelement import WebElement
 
     has_selenium = True
 except ImportError:

reflex/utils/exceptions.py

@@ -1,6 +1,11 @@
 """Custom Exceptions."""
 
-from typing import Any
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from reflex.vars import Var
 
 
 class ReflexError(Exception):
@@ -78,6 +83,31 @@ class VarAttributeError(ReflexError, AttributeError):
 class UntypedVarError(ReflexError, TypeError):
     """Custom TypeError for untyped var errors."""
 
+    def __init__(self, var: Var, action: str, doc_link: str = ""):
+        """Create an UntypedVarError from a var.
+
+        Args:
+            var: The var.
+            action: The action that caused the error.
+            doc_link: The link to the documentation.
+        """
+        var_data = var._get_all_var_data()
+        is_state_var = (
+            var_data
+            and var_data.state
+            and var_data.field_name
+            and var_data.state + "." + var_data.field_name == str(var)
+        )
+        super().__init__(
+            f"Cannot {action} on untyped var '{var!s}' of type '{var._var_type!s}'."
+            + (
+                " Please add a type annotation to the var in the state class."
+                if is_state_var
+                else " You can call the var's .to(desired_type) method to convert it to the desired type."
+            )
+            + (f" See {doc_link}" if doc_link else "")
+        )
+
 
 class UntypedComputedVarError(ReflexError, TypeError):
     """Custom TypeError for untyped computed var errors."""

reflex/utils/exec.py

@@ -332,11 +332,9 @@ def run_granian_backend(host: str, port: int, loglevel: LogLevel):
     """
     console.debug("Using Granian for backend")
     try:
-        from granian import Granian  # pyright: ignore [reportMissingImports]
-        from granian.constants import (  # pyright: ignore [reportMissingImports]
-            Interfaces,
-        )
-        from granian.log import LogLevels  # pyright: ignore [reportMissingImports]
+        from granian.constants import Interfaces
+        from granian.log import LogLevels
+        from granian.server import Server as Granian
 
         Granian(
             target=get_granian_target(),
@@ -466,9 +464,7 @@ def run_granian_backend_prod(host: str, port: int, loglevel: LogLevel):
     from reflex.utils import processes
 
     try:
-        from granian.constants import (  # pyright: ignore [reportMissingImports]
-            Interfaces,
-        )
+        from granian.constants import Interfaces
 
         command = [
             "granian",

reflex/utils/export.py

@@ -6,8 +6,6 @@ from reflex import constants
 from reflex.config import environment, get_config
 from reflex.utils import build, console, exec, prerequisites, telemetry
 
-config = get_config()
-
 
 def export(
     zipping: bool = True,
@@ -33,6 +31,8 @@ def export(
         env: The environment to use. Defaults to constants.Env.PROD.
         loglevel: The log level to use. Defaults to console._LOG_LEVEL.
     """
+    config = get_config()
+
     # Set the log level.
     console.set_log_level(loglevel)
 

reflex/utils/prerequisites.py

@@ -37,7 +37,7 @@ from redis.exceptions import RedisError
 from reflex import constants, model
 from reflex.compiler import templates
 from reflex.config import Config, environment, get_config
-from reflex.utils import console, net, path_ops, processes, redir
+from reflex.utils import console, net, path_ops, processes
 from reflex.utils.exceptions import (
     GeneratedCodeHasNoFunctionDefsError,
     SystemPackageMissingError,
@@ -1695,31 +1695,6 @@ def validate_and_create_app_using_remote_template(
     )
 
 
-def generate_template_using_ai(template: str | None = None) -> str:
-    """Generate a template using AI(Flexgen).
-
-    Args:
-        template: The name of the template.
-
-    Returns:
-        The generation hash.
-
-    Raises:
-        Exit: If the template and ai flags are used.
-    """
-    if template is None:
-        # If AI is requested and no template specified, redirect the user to reflex.build.
-        return redir.reflex_build_redirect()
-    elif is_generation_hash(template):
-        # Otherwise treat the template as a generation hash.
-        return template
-    else:
-        console.error(
-            "Cannot use `--template` option with `--ai` option. Please remove `--template` option."
-        )
-        raise typer.Exit(2)
-
-
 def fetch_remote_templates(
     template: str,
 ) -> tuple[str, dict[str, Template]]:
@@ -1744,15 +1719,12 @@ def fetch_remote_templates(
     return template, available_templates
 
 
-def initialize_app(
-    app_name: str, template: str | None = None, ai: bool = False
-) -> str | None:
+def initialize_app(app_name: str, template: str | None = None) -> str | None:
     """Initialize the app either from a remote template or a blank app. If the config file exists, it is considered as reinit.
 
     Args:
         app_name: The name of the app.
         template: The name of the template to use.
-        ai: Whether to use AI to generate the template.
 
     Returns:
         The name of the template.
@@ -1768,11 +1740,6 @@ def initialize_app(
         telemetry.send("reinit")
         return
 
-    generation_hash = None
-    if ai:
-        generation_hash = generate_template_using_ai(template)
-        template = constants.Templates.DEFAULT
-
     templates: dict[str, Template] = {}
 
     # Don't fetch app templates if the user directly asked for DEFAULT.
@@ -1781,11 +1748,7 @@ def initialize_app(
 
     if template is None:
         template = prompt_for_template_options(get_init_cli_prompt_options())
-        if template == constants.Templates.AI:
-            generation_hash = generate_template_using_ai()
-            # change to the default to allow creation of default app
-            template = constants.Templates.DEFAULT
-        elif template == constants.Templates.CHOOSE_TEMPLATES:
+        if template == constants.Templates.CHOOSE_TEMPLATES:
             console.print(
                 f"Go to the templates page ({constants.Templates.REFLEX_TEMPLATES_URL}) and copy the command to init with a template."
             )
@@ -1800,11 +1763,6 @@ def initialize_app(
             app_name=app_name, template=template, templates=templates
         )
 
-    # If a reflex.build generation hash is available, download the code and apply it to the main module.
-    if generation_hash:
-        initialize_main_module_index_from_generation(
-            app_name, generation_hash=generation_hash
-        )
     telemetry.send("init", template=template)
 
     return template

reflex/utils/pyi_generator.py

@@ -348,7 +348,7 @@ def _extract_class_props_as_ast_nodes(
     all_props = []
     kwargs = []
     for target_class in clzs:
-        event_triggers = target_class().get_event_triggers()
+        event_triggers = target_class._create([]).get_event_triggers()
         # Import from the target class to ensure type hints are resolvable.
         exec(f"from {target_class.__module__} import *", type_hint_globals)
         for name, value in target_class.__annotations__.items():
@@ -575,7 +575,7 @@ def _generate_component_create_functiondef(
             return ast.Name(id=f"{' | '.join(map(ast.unparse, all_count_args_type))}")
         return ast.Name(id="EventType[Any]")
 
-    event_triggers = clz().get_event_triggers()
+    event_triggers = clz._create([]).get_event_triggers()
 
     # event handler kwargs
     kwargs.extend(

reflex/utils/redir.py

@@ -1,7 +1,6 @@
 """Utilities to handle redirection to browser UI."""
 
 import time
-import uuid
 import webbrowser
 
 import httpx
@@ -48,14 +47,6 @@ def open_browser_and_wait(
     return response
 
 
-def reflex_build_redirect() -> str:
-    """Open the browser window to reflex.build and wait for the user to select a generation.
-
-    Returns:
-        The selected generation hash.
-    """
-    token = str(uuid.uuid4())
-    target_url = constants.Templates.REFLEX_BUILD_URL.format(reflex_init_token=token)
-    poll_url = constants.Templates.REFLEX_BUILD_POLL_URL.format(reflex_init_token=token)
-    response = open_browser_and_wait(target_url, poll_url)
-    return response.json()["generation_hash"]
+def reflex_build_redirect() -> None:
+    """Open the browser window to reflex.build."""
+    open_browser(constants.Templates.REFLEX_BUILD_FRONTEND)

reflex/vars/base.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import contextlib
+import copy
 import dataclasses
 import datetime
 import functools
@@ -1255,6 +1256,27 @@ class Var(Generic[VAR_TYPE]):
 
     if not TYPE_CHECKING:
 
+        def __getitem__(self, key: Any) -> Var:
+            """Get the item from the var.
+
+            Args:
+                key: The key to get.
+
+            Raises:
+                UntypedVarError: If the var type is Any.
+                TypeError: If the var type is Any.
+
+            # noqa: DAR101 self
+            """
+            if self._var_type is Any:
+                raise exceptions.UntypedVarError(
+                    self,
+                    f"access the item '{key}'",
+                )
+            raise TypeError(
+                f"Var of type {self._var_type} does not support item access."
+            )
+
         def __getattr__(self, name: str):
             """Get an attribute of the var.
 
@@ -1280,7 +1302,8 @@ class Var(Generic[VAR_TYPE]):
 
             if self._var_type is Any:
                 raise exceptions.UntypedVarError(
-                    f"You must provide an annotation for the state var `{self!s}`. Annotation cannot be `{self._var_type}`."
+                    self,
+                    f"access the attribute '{name}'",
                 )
 
             raise VarAttributeError(
@@ -2146,7 +2169,7 @@ class ComputedVar(Var[RETURN_TYPE]):
             "fget": kwargs.pop("fget", self._fget),
             "initial_value": kwargs.pop("initial_value", self._initial_value),
             "cache": kwargs.pop("cache", self._cache),
-            "deps": kwargs.pop("deps", self._static_deps),
+            "deps": kwargs.pop("deps", copy.copy(self._static_deps)),
             "auto_deps": kwargs.pop("auto_deps", self._auto_deps),
             "interval": kwargs.pop("interval", self._update_interval),
             "backend": kwargs.pop("backend", self._backend),
@@ -2318,7 +2341,7 @@ class ComputedVar(Var[RETURN_TYPE]):
         if not _isinstance(value, self._var_type, nested=1, treat_var_as_type=False):
             console.error(
                 f"Computed var '{type(instance).__name__}.{self._js_expr}' must return"
-                f" type '{self._var_type}', got '{type(value)}'."
+                f" a value of type '{self._var_type}', got '{value}' of type {type(value)}."
             )
 
     def _deps(