reflex 0.7.2.dev1__py3-none-any.whl → 0.7.3__py3-none-any.whl

reflex/reflex.py

@@ -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,13 +54,19 @@ 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
@@ -109,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,
@@ -127,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)
 
@@ -274,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."""
@@ -296,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)
@@ -335,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."""
@@ -347,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,
@@ -362,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()
@@ -376,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."""
@@ -385,6 +410,8 @@ def logout(
 
     check_version()
 
+    loglevel = loglevel or get_config().loglevel
+
     logout(loglevel)  # pyright: ignore [reportArgumentType]
 
 
@@ -403,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.")
@@ -470,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.",
     ),
@@ -510,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,
@@ -542,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)
@@ -608,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/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/vars/base.py

@@ -1256,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.
 
@@ -1281,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(

reflex/vars/number.py

@@ -23,6 +23,7 @@ from reflex.utils.exceptions import (
     VarValueError,
 )
 from reflex.utils.imports import ImportDict, ImportVar
+from reflex.utils.types import safe_issubclass
 
 from .base import (
     CustomVarOperationReturn,
@@ -524,7 +525,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
         Returns:
             bool: True if the number is a float.
         """
-        return issubclass(self._var_type, float)
+        return safe_issubclass(self._var_type, float)
 
     def _is_strict_int(self) -> bool:
         """Check if the number is an int.
@@ -532,7 +533,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
         Returns:
             bool: True if the number is an int.
         """
-        return issubclass(self._var_type, int)
+        return safe_issubclass(self._var_type, int)
 
     def __format__(self, format_spec: str) -> str:
         """Format the number.
@@ -546,6 +547,20 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
         Raises:
             VarValueError: If the format specifier is not supported.
         """
+        from .sequence import (
+            get_decimal_string_operation,
+            get_decimal_string_separator_operation,
+        )
+
+        separator = ""
+
+        if format_spec and format_spec[:1] == ",":
+            separator = ","
+            format_spec = format_spec[1:]
+        elif format_spec and format_spec[:1] == "_":
+            separator = "_"
+            format_spec = format_spec[1:]
+
         if (
             format_spec
             and format_spec[-1] == "f"
@@ -553,14 +568,17 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
             and format_spec[1:-1].isdigit()
         ):
             how_many_decimals = int(format_spec[1:-1])
+            return f"{get_decimal_string_operation(self, Var.create(how_many_decimals), Var.create(separator))}"
+
+        if not format_spec and separator:
             return (
-                f"{get_decimal_string_operation(self, Var.create(how_many_decimals))}"
+                f"{get_decimal_string_separator_operation(self, Var.create(separator))}"
             )
 
         if format_spec:
             raise VarValueError(
                 (
-                    "Unknown format code '{}' for object of type 'NumberVar'. It is only supported to use '.f' for float numbers."
+                    "Unknown format code '{}' for object of type 'NumberVar'. It is only supported to use ',', '_', and '.f' for float numbers."
                     "If possible, use computed variables instead: https://reflex.dev/docs/vars/computed-vars/"
                 ).format(format_spec)
             )
@@ -568,23 +586,6 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
         return super().__format__(format_spec)
 
 
-@var_operation
-def get_decimal_string_operation(value: NumberVar, decimals: NumberVar):
-    """Get the decimal string of the number.
-
-    Args:
-        value: The number.
-        decimals: The number of decimals.
-
-    Returns:
-        The decimal string of the number.
-    """
-    return var_operation_return(
-        js_expression=f"({value}.toFixed({decimals}))",
-        var_type=str,
-    )
-
-
 def binary_number_operation(
     func: Callable[[NumberVar, NumberVar], str],
 ) -> Callable[[number_types, number_types], NumberVar]:

reflex/vars/object.py

@@ -202,6 +202,12 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=Mapping):
         key: Var | Any,
     ) -> ObjectVar[Mapping[OTHER_KEY_TYPE, VALUE_TYPE]]: ...
 
+    @overload
+    def __getitem__(
+        self: ObjectVar[Mapping[Any, VALUE_TYPE]],
+        key: Var | Any,
+    ) -> Var[VALUE_TYPE]: ...
+
     def __getitem__(self, key: Var | Any) -> Var:
         """Get an item from the object.
 
@@ -221,6 +227,29 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=Mapping):
             return self.__getattr__(key)
         return ObjectItemOperation.create(self, key).guess_type()
 
+    def get(self, key: Var | Any, default: Var | Any | None = None) -> Var:
+        """Get an item from the object.
+
+        Args:
+            key: The key to get from the object.
+            default: The default value if the key is not found.
+
+        Returns:
+            The item from the object.
+        """
+        from reflex.components.core.cond import cond
+
+        if default is None:
+            default = Var.create(None)
+
+        value = self.__getitem__(key)  # pyright: ignore[reportUnknownVariableType,reportAttributeAccessIssue,reportUnknownMemberType]
+
+        return cond(  # pyright: ignore[reportUnknownVariableType]
+            value,
+            value,
+            default,
+        )
+
     # NoReturn is used here to catch when key value is Any
     @overload
     def __getattr__(  # pyright: ignore [reportOverlappingOverload]

reflex/vars/sequence.py

@@ -1202,6 +1202,43 @@ def string_replace_operation(
     )
 
 
+@var_operation
+def get_decimal_string_separator_operation(value: NumberVar, separator: StringVar):
+    """Get the decimal string separator.
+
+    Args:
+        value: The number.
+        separator: The separator.
+
+    Returns:
+        The decimal string separator.
+    """
+    return var_operation_return(
+        js_expression=f"({value}.toLocaleString('en-US').replaceAll(',', {separator}))",
+        var_type=str,
+    )
+
+
+@var_operation
+def get_decimal_string_operation(
+    value: NumberVar, decimals: NumberVar, separator: StringVar
+):
+    """Get the decimal string of the number.
+
+    Args:
+        value: The number.
+        decimals: The number of decimals.
+        separator: The separator.
+
+    Returns:
+        The decimal string of the number.
+    """
+    return var_operation_return(
+        js_expression=f"({value}.toLocaleString('en-US', ((decimals) => ({{minimumFractionDigits: decimals, maximumFractionDigits: decimals}}))({decimals})).replaceAll(',', {separator}))",
+        var_type=str,
+    )
+
+
 # Compile regex for finding reflex var tags.
 _decode_var_pattern_re = (
     rf"{constants.REFLEX_VAR_OPENING_TAG}(.*?){constants.REFLEX_VAR_CLOSING_TAG}"