reflex 0.8.8a2__py3-none-any.whl → 0.8.9a1__py3-none-any.whl

reflex/istate/data.py

@@ -83,6 +83,11 @@ class HeaderData(_HeaderData):
         )
 
 
+@serializer(to=dict)
+def _serialize_header_data(obj: HeaderData) -> dict:
+    return {k.name: getattr(obj, k.name) for k in dataclasses.fields(obj)}
+
+
 @serializer(to=dict)
 def serialize_frozen_dict_str_str(obj: _FrozenDictStrStr) -> dict:
     """Serialize a _FrozenDictStrStr object to a dict.
@@ -165,6 +170,11 @@ class PageData:
         )
 
 
+@serializer(to=dict)
+def _serialize_page_data(obj: PageData) -> dict:
+    return dataclasses.asdict(obj)
+
+
 @dataclasses.dataclass(frozen=True)
 class SessionData:
     """An object containing session data."""
@@ -190,6 +200,11 @@ class SessionData:
         )
 
 
+@serializer(to=dict)
+def _serialize_session_data(obj: SessionData) -> dict:
+    return dataclasses.asdict(obj)
+
+
 @dataclasses.dataclass(frozen=True)
 class RouterData:
     """An object containing RouterData."""

reflex/plugins/sitemap.py

@@ -5,8 +5,7 @@ from collections.abc import Sequence
 from pathlib import Path
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Literal, TypedDict
-from xml.dom import minidom
-from xml.etree.ElementTree import Element, SubElement, tostring
+from xml.etree.ElementTree import Element, SubElement, indent, tostring
 
 from typing_extensions import NotRequired
 
@@ -104,10 +103,8 @@ def generate_xml(links: Sequence[SitemapLink]) -> str:
         if (priority := link.get("priority")) is not None:
             priority_element = SubElement(url, "priority")
             priority_element.text = str(priority)
-
-    rough_string = tostring(urlset, "utf-8")
-    reparsed = minidom.parseString(rough_string)
-    return reparsed.toprettyxml(indent="  ")
+    indent(urlset, "  ")
+    return tostring(urlset, encoding="utf-8", xml_declaration=True).decode("utf-8")
 
 
 def is_route_dynamic(route: str) -> bool:

reflex/reflex.py

@@ -360,7 +360,13 @@ def run(
     default=False,
     help="Run the command without making any changes.",
 )
-def compile(dry: bool):
+@click.option(
+    "--rich/--no-rich",
+    default=True,
+    is_flag=True,
+    help="Whether to use rich progress bars.",
+)
+def compile(dry: bool, rich: bool):
     """Compile the app in the current directory."""
     import time
 
@@ -371,7 +377,7 @@ def compile(dry: bool):
         _init(name=get_config().app_name)
     get_config(reload=True)
     starting_time = time.monotonic()
-    prerequisites.get_compiled_app(dry_run=dry)
+    prerequisites.get_compiled_app(dry_run=dry, use_rich=rich)
     elapsed_time = time.monotonic() - starting_time
     console.success(f"App compiled successfully in {elapsed_time:.3f} seconds.")
 

reflex/state.py

@@ -225,8 +225,20 @@ class EventHandlerSetVar(EventHandler):
             EventHandlerValueError: If the given Var name is not a str
             NotImplementedError: If the setter for the given Var is async
         """
+        from reflex.config import get_config
         from reflex.utils.exceptions import EventHandlerValueError
 
+        config = get_config()
+        if config.state_auto_setters is None:
+            console.deprecate(
+                feature_name="state_auto_setters defaulting to True",
+                reason="The default value will be changed to False in a future release. Set state_auto_setters explicitly or define setters explicitly. "
+                f"Used {self.state_cls.__name__}.setvar without defining it.",
+                deprecation_version="0.8.9",
+                removal_version="0.9.0",
+                dedupe=True,
+            )
+
         if args:
             if not isinstance(args[0], str):
                 msg = f"Var name must be passed as a string, got {args[0]!r}"
@@ -1036,7 +1048,7 @@ class BaseState(EvenMoreBasicBaseState):
             )
             raise VarTypeError(msg)
         cls._set_var(name, prop)
-        if cls.is_user_defined() and get_config().state_auto_setters:
+        if cls.is_user_defined() and get_config().state_auto_setters is not False:
             cls._create_setter(name, prop)
         cls._set_default_value(name, prop)
 
@@ -1096,11 +1108,14 @@ class BaseState(EvenMoreBasicBaseState):
         setattr(cls, name, prop)
 
     @classmethod
-    def _create_event_handler(cls, fn: Any):
+    def _create_event_handler(
+        cls, fn: Any, event_handler_cls: type[EventHandler] = EventHandler
+    ):
         """Create an event handler for the given function.
 
         Args:
             fn: The function to create an event handler for.
+            event_handler_cls: The event handler class to use.
 
         Returns:
             The event handler.
@@ -1108,7 +1123,7 @@ class BaseState(EvenMoreBasicBaseState):
         # Check if function has stored event_actions from decorator
         event_actions = getattr(fn, "_rx_event_actions", {})
 
-        return EventHandler(
+        return event_handler_cls(
             fn=fn, state_full_name=cls.get_full_name(), event_actions=event_actions
         )
 
@@ -1125,9 +1140,34 @@ class BaseState(EvenMoreBasicBaseState):
             name: The name of the var.
             prop: The var to create a setter for.
         """
+        from reflex.config import get_config
+
+        config = get_config()
+        _create_event_handler_kwargs = {}
+
+        if config.state_auto_setters is None:
+
+            class EventHandlerDeprecatedSetter(EventHandler):
+                def __call__(self, *args, **kwargs):
+                    console.deprecate(
+                        feature_name="state_auto_setters defaulting to True",
+                        reason="The default value will be changed to False in a future release. Set state_auto_setters explicitly or define setters explicitly. "
+                        f"Used {setter_name} in {cls.__name__} without defining it.",
+                        deprecation_version="0.8.9",
+                        removal_version="0.9.0",
+                        dedupe=True,
+                    )
+                    return super().__call__(*args, **kwargs)
+
+            _create_event_handler_kwargs["event_handler_cls"] = (
+                EventHandlerDeprecatedSetter
+            )
+
         setter_name = Var._get_setter_name_for_name(name)
         if setter_name not in cls.__dict__:
-            event_handler = cls._create_event_handler(prop._get_setter(name))
+            event_handler = cls._create_event_handler(
+                prop._get_setter(name), **_create_event_handler_kwargs
+            )
             cls.event_handlers[setter_name] = event_handler
             setattr(cls, setter_name, event_handler)
 
@@ -1810,7 +1850,7 @@ class BaseState(EvenMoreBasicBaseState):
                 hinted_args = value_inside_optional(hinted_args)
             if (
                 isinstance(value, dict)
-                and inspect.isclass(hinted_args)
+                and isinstance(hinted_args, type)
                 and not types.is_generic_alias(hinted_args)  # py3.10
             ):
                 if issubclass(hinted_args, Model):
@@ -2341,7 +2381,7 @@ def _serialize_type(type_: Any) -> str:
     Returns:
         The serialized type.
     """
-    if not inspect.isclass(type_):
+    if not isinstance(type_, type):
         return f"{type_}"
     return f"{type_.__module__}.{type_.__qualname__}"
 

reflex/testing.py

@@ -472,7 +472,7 @@ class AppHarness:
         Returns:
             The rendered app global code.
         """
-        if not inspect.isclass(value) and not inspect.isfunction(value):
+        if not isinstance(value, type) and not inspect.isfunction(value):
             return f"{key} = {value!r}"
         return inspect.getsource(value)
 

reflex/utils/console.py

@@ -7,12 +7,13 @@ import datetime
 import inspect
 import os
 import shutil
+import sys
 import time
 from pathlib import Path
 from types import FrameType
 
 from rich.console import Console
-from rich.progress import MofNCompleteColumn, Progress, TimeElapsedColumn
+from rich.progress import MofNCompleteColumn, Progress, TaskID, TimeElapsedColumn
 from rich.prompt import Prompt
 
 from reflex.constants import LogLevel
@@ -244,23 +245,38 @@ def warn(msg: str, *, dedupe: bool = False, **kwargs):
         print_to_log_file(f"[orange1]Warning: {msg}[/orange1]", **kwargs)
 
 
-def _get_first_non_framework_frame() -> FrameType | None:
+@once
+def _exclude_paths_from_frame_info() -> list[Path]:
+    import importlib.util
+
     import click
+    import granian
+    import socketio
     import typing_extensions
 
     import reflex as rx
 
     # Exclude utility modules that should never be the source of deprecated reflex usage.
-    exclude_modules = [click, rx, typing_extensions]
+    exclude_modules = [click, rx, typing_extensions, socketio, granian]
+    modules_paths = [file for m in exclude_modules if (file := m.__file__)] + [
+        spec.origin
+        for m in [*sys.builtin_module_names, *sys.stdlib_module_names]
+        if (spec := importlib.util.find_spec(m)) and spec.origin
+    ]
     exclude_roots = [
         p.parent.resolve() if (p := Path(file)).name == "__init__.py" else p.resolve()
-        for m in exclude_modules
-        if (file := m.__file__)
+        for file in modules_paths
     ]
     # Specifically exclude the reflex cli module.
     if reflex_bin := shutil.which(b"reflex"):
         exclude_roots.append(Path(reflex_bin.decode()))
 
+    return exclude_roots
+
+
+def _get_first_non_framework_frame() -> FrameType | None:
+    exclude_roots = _exclude_paths_from_frame_info()
+
     frame = inspect.currentframe()
     while frame := frame and frame.f_back:
         frame_path = Path(inspect.getfile(frame)).resolve()
@@ -297,13 +313,13 @@ def deprecate(
         filename = Path(origin_frame.f_code.co_filename)
         if filename.is_relative_to(Path.cwd()):
             filename = filename.relative_to(Path.cwd())
-        loc = f"{filename}:{origin_frame.f_lineno}"
+        loc = f" ({filename}:{origin_frame.f_lineno})"
         dedupe_key = f"{dedupe_key} {loc}"
 
     if dedupe_key not in _EMITTED_DEPRECATION_WARNINGS:
         msg = (
             f"{feature_name} has been deprecated in version {deprecation_version}. {reason.rstrip('.').lstrip('. ')}. It will be completely "
-            f"removed in {removal_version}. ({loc})"
+            f"removed in {removal_version}.{loc}"
         )
         if _LOG_LEVEL <= LogLevel.WARNING:
             print(f"[yellow]DeprecationWarning: {msg}[/yellow]", **kwargs)
@@ -395,3 +411,47 @@ def timing(msg: str):
         yield
     finally:
         debug(f"[white]\\[timing] {msg}: {time.time() - start:.2f}s[/white]")
+
+
+class PoorProgress:
+    """A poor man's progress bar."""
+
+    def __init__(self):
+        """Initialize the progress bar."""
+        super().__init__()
+        self.tasks = {}
+        self.progress = 0
+        self.total = 0
+
+    def add_task(self, task: str, total: int):
+        """Add a task to the progress bar.
+
+        Args:
+            task: The task name.
+            total: The total number of steps for the task.
+
+        Returns:
+            The task ID.
+        """
+        self.total += total
+        task_id = TaskID(len(self.tasks))
+        self.tasks[task_id] = {"total": total, "current": 0}
+        return task_id
+
+    def advance(self, task: TaskID, advance: int = 1):
+        """Advance the progress of a task.
+
+        Args:
+            task: The task ID.
+            advance: The number of steps to advance.
+        """
+        if task in self.tasks:
+            self.tasks[task]["current"] += advance
+            self.progress += advance
+            _console.print(f"Progress: {self.progress}/{self.total}")
+
+    def start(self):
+        """Start the progress bar."""
+
+    def stop(self):
+        """Stop the progress bar."""

reflex/utils/frontend_skeleton.py

@@ -10,6 +10,7 @@ import click
 from reflex import constants
 from reflex.compiler import templates
 from reflex.config import Config, get_config
+from reflex.environment import environment
 from reflex.utils import console, path_ops
 from reflex.utils.prerequisites import get_project_hash, get_web_dir
 from reflex.utils.registry import get_npm_registry
@@ -192,7 +193,11 @@ def _compile_vite_config(config: Config):
     base = "/"
     if frontend_path := config.frontend_path.strip("/"):
         base += frontend_path + "/"
-    return templates.vite_config_template(base=base)
+    return templates.vite_config_template(
+        base=base,
+        hmr=environment.VITE_HMR.get(),
+        force_full_reload=environment.VITE_FORCE_FULL_RELOAD.get(),
+    )
 
 
 def initialize_vite_config():

reflex/utils/imports.py

@@ -135,7 +135,7 @@ class ImportVar:
         if self.alias:
             return (
                 self.alias
-                if self.is_default
+                if self.is_default and self.tag != "*"
                 else (self.tag + " as " + self.alias if self.tag else self.alias)
             )
         return self.tag or ""

reflex/utils/prerequisites.py

@@ -248,6 +248,7 @@ def get_compiled_app(
     prerender_routes: bool = False,
     dry_run: bool = False,
     check_if_schema_up_to_date: bool = False,
+    use_rich: bool = True,
 ) -> ModuleType:
     """Get the app module based on the default config after first compiling it.
 
@@ -256,6 +257,7 @@ def get_compiled_app(
         prerender_routes: Whether to prerender routes.
         dry_run: If True, do not write the compiled app to disk.
         check_if_schema_up_to_date: If True, check if the schema is up to date.
+        use_rich: Whether to use rich progress bars.
 
     Returns:
         The compiled app based on the default config.
@@ -263,7 +265,7 @@ def get_compiled_app(
     app, app_module = get_and_validate_app(
         reload=reload, check_if_schema_up_to_date=check_if_schema_up_to_date
     )
-    app._compile(prerender_routes=prerender_routes, dry_run=dry_run)
+    app._compile(prerender_routes=prerender_routes, dry_run=dry_run, use_rich=use_rich)
     return app_module
 
 

reflex/utils/pyi_generator.py

@@ -547,7 +547,7 @@ def _generate_component_create_functiondef(
     kwargs.extend(prop_kwargs)
 
     def figure_out_return_type(annotation: Any):
-        if inspect.isclass(annotation) and issubclass(annotation, inspect._empty):
+        if isinstance(annotation, type) and issubclass(annotation, inspect._empty):
             return ast.Name(id="EventType[Any]")
 
         if not isinstance(annotation, str) and get_origin(annotation) is tuple:
@@ -1181,7 +1181,7 @@ class PyiGenerator:
         class_names = {
             name: obj
             for name, obj in vars(module).items()
-            if inspect.isclass(obj)
+            if isinstance(obj, type)
             and (
                 rx_types.safe_issubclass(obj, Component)
                 or rx_types.safe_issubclass(obj, SimpleNamespace)

reflex/utils/serializers.py

@@ -187,7 +187,7 @@ def get_serializer(type_: type) -> Serializer | None:
 
     # If the type is not registered, check if it is a subclass of a registered type.
     for registered_type, serializer in reversed(SERIALIZERS.items()):
-        if types._issubclass(type_, registered_type):
+        if issubclass(type_, registered_type):
             return serializer
 
     # If there is no serializer, return None.
@@ -211,7 +211,7 @@ def get_serializer_type(type_: type) -> type | None:
 
     # If the type is not registered, check if it is a subclass of a registered type.
     for registered_type, serializer in reversed(SERIALIZER_TYPES.items()):
-        if types._issubclass(type_, registered_type):
+        if issubclass(type_, registered_type):
             return serializer
 
     # If there is no serializer, return None.
@@ -244,11 +244,11 @@ def can_serialize(type_: type, into_type: type | None = None) -> bool:
     Returns:
         Whether there is a serializer for the type.
     """
-    return has_serializer(type_, into_type) or (
+    return (
         isinstance(type_, type)
         and dataclasses.is_dataclass(type_)
         and (into_type is None or into_type is dict)
-    )
+    ) or has_serializer(type_, into_type)
 
 
 @serializer(to=str)

reflex/utils/types.py

@@ -52,11 +52,8 @@ UnionTypes = (Union, types.UnionType)
 GenericType = type | _GenericAlias
 
 # Valid state var types.
-JSONType = {str, int, float, bool}
-PrimitiveType = int | float | bool | str | list | dict | set | tuple
 PrimitiveTypes = (int, float, bool, str, list, dict, set, tuple)
-StateVar = PrimitiveType | Base | None
-StateIterVar = list | set | tuple
+StateVarTypes = (*PrimitiveTypes, Base, type(None))
 
 if TYPE_CHECKING:
     from reflex.vars.base import Var
@@ -401,6 +398,8 @@ def get_field_type(cls: GenericType, field_name: str) -> GenericType | None:
     Returns:
         The type of the field, if it exists, else None.
     """
+    if (fields := getattr(cls, "_fields", None)) is not None and field_name in fields:
+        return fields[field_name].annotated_type
     if (
         hasattr(cls, "__fields__")
         and field_name in cls.__fields__
@@ -857,8 +856,11 @@ def is_valid_var_type(type_: type) -> bool:
 
     if is_union(type_):
         return all(is_valid_var_type(arg) for arg in get_args(type_))
+
+    type_ = origin if (origin := get_origin(type_)) is not None else type_
+
     return (
-        _issubclass(type_, StateVar)
+        issubclass(type_, StateVarTypes)
         or serializers.has_serializer(type_)
         or dataclasses.is_dataclass(type_)
     )
@@ -993,11 +995,6 @@ def validate_literal(key: str, value: Any, expected_type: type, comp_name: str):
             raise ValueError(msg)
 
 
-# Store this here for performance.
-StateBases = get_base_class(StateVar)
-StateIterBases = get_base_class(StateIterVar)
-
-
 def safe_issubclass(cls: Any, cls_check: Any | tuple[Any, ...]):
     """Check if a class is a subclass of another class. Returns False if internal error occurs.
 

reflex/vars/base.py

@@ -366,7 +366,7 @@ def can_use_in_object_var(cls: GenericType) -> bool:
     if types.is_union(cls):
         return all(can_use_in_object_var(t) for t in types.get_args(cls))
     return (
-        inspect.isclass(cls)
+        isinstance(cls, type)
         and not safe_issubclass(cls, Var)
         and serializers.can_serialize(cls, dict)
     )
@@ -516,6 +516,17 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
         """
         return self._var_data
 
+    def __deepcopy__(self, memo: dict[int, Any]) -> Self:
+        """Deepcopy the var.
+
+        Args:
+            memo: The memo dictionary to use for the deepcopy.
+
+        Returns:
+            A deepcopy of the var.
+        """
+        return self
+
     def equals(self, other: Var) -> bool:
         """Check if two vars are equal.
 
@@ -795,7 +806,7 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
         if can_use_in_object_var(output):
             return self.to(ObjectVar, output)
 
-        if inspect.isclass(output):
+        if isinstance(output, type):
             for var_subclass in _var_subclasses[::-1]:
                 if safe_issubclass(output, var_subclass.var_subclass):
                     current_var_type = self._var_type
@@ -891,7 +902,7 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
             args = get_args(var_type)
             fixed_type = unionize(*(type(arg) for arg in args))
 
-        if not inspect.isclass(fixed_type):
+        if not isinstance(fixed_type, type):
             msg = f"Unsupported type {var_type} for guess_type."
             raise TypeError(msg)
 
@@ -930,6 +941,7 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
         Returns:
             A function that that creates a setter for the var.
         """
+        setter_name = Var._get_setter_name_for_name(name)
 
         def setter(state: Any, value: Any):
             """Get the setter for the var.
@@ -951,7 +963,7 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
 
         setter.__annotations__["value"] = self._var_type
 
-        setter.__qualname__ = Var._get_setter_name_for_name(name)
+        setter.__qualname__ = setter_name
 
         return setter
 
@@ -1153,18 +1165,6 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
         """
         return dataclasses.replace(self, _var_data=None)
 
-    def __get__(self, instance: Any, owner: Any):
-        """Get the var.
-
-        Args:
-            instance: The instance to get the var from.
-            owner: The owner of the var.
-
-        Returns:
-            The var.
-        """
-        return self
-
     def _decode(self) -> Any:
         """Decode Var as a python value.
 
@@ -1409,7 +1409,7 @@ class LiteralVar(Var):
         bases = cls.__bases__
 
         bases_normalized = [
-            base if inspect.isclass(base) else get_origin(base) for base in bases
+            base if isinstance(base, type) else get_origin(base) for base in bases
         ]
 
         possible_bases = [
@@ -1476,6 +1476,13 @@ class LiteralVar(Var):
             if isinstance(value, var_subclass.python_types):
                 return literal_subclass.create(value, _var_data=_var_data)
 
+        if (
+            (as_var_method := getattr(value, "_as_var", None)) is not None
+            and callable(as_var_method)
+            and isinstance((resulting_var := as_var_method()), Var)
+        ):
+            return resulting_var
+
         from reflex.event import EventHandler
         from reflex.utils.format import get_event_handler_parts
 

reflex/vars/object.py

@@ -6,7 +6,6 @@ import collections.abc
 import dataclasses
 import typing
 from collections.abc import Mapping
-from inspect import isclass
 from typing import (
     Any,
     NoReturn,
@@ -328,7 +327,10 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=Mapping):
 
         if (
             is_typeddict(fixed_type)
-            or (isclass(fixed_type) and not safe_issubclass(fixed_type, Mapping))
+            or (
+                isinstance(fixed_type, type)
+                and not safe_issubclass(fixed_type, Mapping)
+            )
             or (fixed_type in types.UnionTypes)
         ):
             attribute_type = get_attribute_access_type(var_type, name)

{reflex-0.8.8a2.dist-info → reflex-0.8.9a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflex
-Version: 0.8.8a2
+Version: 0.8.9a1
 Summary: Web apps in pure Python.
 Project-URL: homepage, https://reflex.dev
 Project-URL: repository, https://github.com/reflex-dev/reflex