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

reflex/app.py

@@ -1100,12 +1100,18 @@ class App(MiddlewareMixin, LifespanMixin):
         for substate in state.class_subclasses:
             self._validate_var_dependencies(substate)
 
-    def _compile(self, prerender_routes: bool = False, dry_run: bool = False):
+    def _compile(
+        self,
+        prerender_routes: bool = False,
+        dry_run: bool = False,
+        use_rich: bool = True,
+    ):
         """Compile the app and output it to the pages folder.
 
         Args:
             prerender_routes: Whether to prerender the routes.
             dry_run: Whether to compile the app without saving it.
+            use_rich: Whether to use rich progress bars.
 
         Raises:
             ReflexRuntimeError: When any page uses state, but no rx.State subclass is defined.
@@ -1171,10 +1177,14 @@ class App(MiddlewareMixin, LifespanMixin):
             return
 
         # Create a progress bar.
-        progress = Progress(
-            *Progress.get_default_columns()[:-1],
-            MofNCompleteColumn(),
-            TimeElapsedColumn(),
+        progress = (
+            Progress(
+                *Progress.get_default_columns()[:-1],
+                MofNCompleteColumn(),
+                TimeElapsedColumn(),
+            )
+            if use_rich
+            else console.PoorProgress()
         )
 
         # try to be somewhat accurate - but still not 100%

reflex/compiler/templates.py

@@ -362,7 +362,7 @@ export const UploadFilesContext = createContext(null);
 export const DispatchContext = createContext(null);
 export const StateContexts = {{{state_contexts_str}}};
 export const EventLoopContext = createContext(null);
-export const clientStorage = {"{}" if client_storage is None else json_dumps(client_storage)}
+export const clientStorage = {"{}" if client_storage is None else json.dumps(client_storage)}
 
 {state_str}
 
@@ -502,11 +502,13 @@ def package_json_template(
     )
 
 
-def vite_config_template(base: str):
+def vite_config_template(base: str, hmr: bool, force_full_reload: bool):
     """Template for vite.config.js.
 
     Args:
         base: The base path for the Vite config.
+        hmr: Whether to enable hot module replacement.
+        force_full_reload: Whether to force a full reload on changes.
 
     Returns:
         Rendered vite.config.js content as string.
@@ -537,12 +539,25 @@ function alwaysUseReactDomServerNode() {{
   }};
 }}
 
+function fullReload() {{
+  return {{
+    name: "full-reload",
+    enforce: "pre",
+    handleHotUpdate({{ server }}) {{
+      server.ws.send({{
+        type: "full-reload",
+      }});
+      return [];
+    }}
+  }};
+}}
+
 export default defineConfig((config) => ({{
   plugins: [
     alwaysUseReactDomServerNode(),
     reactRouter(),
     safariCacheBustPlugin(),
-  ],
+  ].concat({"[fullReload()]" if force_full_reload else "[]"}),
   build: {{
     assetsDir: "{base}assets".slice(1),
     rollupOptions: {{
@@ -564,6 +579,7 @@ export default defineConfig((config) => ({{
   }},
   server: {{
     port: process.env.PORT,
+    hmr: {"true" if hmr else "false"},
     watch: {{
       ignored: [
         "**/.web/backend/**",

reflex/compiler/utils.py

@@ -220,10 +220,13 @@ def compile_state(state: type[BaseState]) -> dict:
 
 def _compile_client_storage_field(
     field: Field,
-) -> tuple[
-    type[Cookie] | type[LocalStorage] | type[SessionStorage] | None,
-    dict[str, Any] | None,
-]:
+) -> (
+    tuple[
+        type[Cookie] | type[LocalStorage] | type[SessionStorage],
+        dict[str, Any],
+    ]
+    | tuple[None, None]
+):
     """Compile the given cookie, local_storage or session_storage field.
 
     Args:

reflex/components/component.py

@@ -419,7 +419,6 @@ def evaluate_style_namespaces(style: ComponentStyle) -> dict:
 
 # Map from component to styling.
 ComponentStyle = dict[str | type[BaseComponent] | Callable | ComponentNamespace, Any]
-ComponentChild = types.PrimitiveType | Var | BaseComponent
 ComponentChildTypes = (*types.PrimitiveTypes, Var, BaseComponent, type(None))
 
 
@@ -480,7 +479,21 @@ def _components_from(
     return ()
 
 
-def _deterministic_hash(value: object) -> int:
+def _hash_str(value: str) -> str:
+    return md5(f'"{value}"'.encode(), usedforsecurity=False).hexdigest()
+
+
+def _hash_sequence(value: Sequence) -> str:
+    return _hash_str(str([_deterministic_hash(v) for v in value]))
+
+
+def _hash_dict(value: dict) -> str:
+    return _hash_sequence(
+        sorted([(k, _deterministic_hash(v)) for k, v in value.items()])
+    )
+
+
+def _deterministic_hash(value: object) -> str:
     """Hash a rendered dictionary.
 
     Args:
@@ -492,37 +505,28 @@ def _deterministic_hash(value: object) -> int:
     Raises:
         TypeError: If the value is not hashable.
     """
-    if isinstance(value, BaseComponent):
-        # If the value is a component, hash its rendered code.
-        rendered_code = value.render()
-        return _deterministic_hash(rendered_code)
-    if isinstance(value, Var):
-        return _deterministic_hash((value._js_expr, value._get_all_var_data()))
-    if isinstance(value, VarData):
-        return _deterministic_hash(dataclasses.asdict(value))
-    if isinstance(value, dict):
-        # Sort the dictionary to ensure consistent hashing.
-        return _deterministic_hash(
-            tuple(sorted((k, _deterministic_hash(v)) for k, v in value.items()))
-        )
-    if isinstance(value, int):
+    if value is None:
+        # Hash None as a special case.
+        return "None"
+    if isinstance(value, (int, float, enum.Enum)):
         # Hash numbers and booleans directly.
-        return int(value)
-    if isinstance(value, float):
-        return _deterministic_hash(str(value))
+        return str(value)
     if isinstance(value, str):
-        return int(md5(f'"{value}"'.encode()).hexdigest(), 16)
+        return _hash_str(value)
+    if isinstance(value, dict):
+        return _hash_dict(value)
     if isinstance(value, (tuple, list)):
         # Hash tuples by hashing each element.
-        return _deterministic_hash(
-            "[" + ",".join(map(str, map(_deterministic_hash, value))) + "]"
+        return _hash_sequence(value)
+    if isinstance(value, Var):
+        return _hash_str(
+            str((value._js_expr, _deterministic_hash(value._get_all_var_data())))
         )
-    if isinstance(value, enum.Enum):
-        # Hash enums by their name.
-        return _deterministic_hash(str(value))
-    if value is None:
-        # Hash None as a special case.
-        return _deterministic_hash("None")
+    if isinstance(value, VarData):
+        return _hash_dict(dataclasses.asdict(value))
+    if isinstance(value, BaseComponent):
+        # If the value is a component, hash its rendered code.
+        return _hash_dict(value.render())
 
     msg = (
         f"Cannot hash value `{value}` of type `{type(value).__name__}`. "
@@ -1038,9 +1042,13 @@ class Component(BaseComponent, ABC):
             name
             for name in cls.get_fields()
             if name in cls.get_props()
-            and types._issubclass(
-                types.value_inside_optional(types.get_field_type(cls, name)), Component
+            and isinstance(
+                field_type := types.value_inside_optional(
+                    types.get_field_type(cls, name)
+                ),
+                type,
             )
+            and issubclass(field_type, Component)
         }
 
     def _get_components_in_props(self) -> Sequence[BaseComponent]:
@@ -1508,8 +1516,9 @@ class Component(BaseComponent, ABC):
         Returns:
             A sequence of parent classes that define the method (differently than the base).
         """
+        current_class_method = getattr(Component, method, None)
         seen_methods = (
-            {getattr(Component, method)} if hasattr(Component, method) else set()
+            {current_class_method} if current_class_method is not None else set()
         )
         clzs: list[type[Component]] = []
         for clz in cls.mro():
@@ -1807,7 +1816,7 @@ class Component(BaseComponent, ABC):
 
         # Add the hook code from add_hooks for each parent class (this is reversed to preserve
         # the order of the hooks in the final output)
-        for clz in reversed(tuple(self._iter_parent_classes_with_method("add_hooks"))):
+        for clz in reversed(self._iter_parent_classes_with_method("add_hooks")):
             for hook in clz.add_hooks(self):
                 if isinstance(hook, Var):
                     extract_var_hooks(hook)
@@ -2190,6 +2199,9 @@ def _register_custom_component(
     Args:
         component_fn: The function that creates the component.
 
+    Returns:
+        The custom component.
+
     Raises:
         TypeError: If the tag name cannot be determined.
     """
@@ -2214,6 +2226,7 @@ def _register_custom_component(
         msg = f"Could not determine the tag name for {component_fn!r}"
         raise TypeError(msg)
     CUSTOM_COMPONENTS[dummy_component.tag] = dummy_component
+    return dummy_component
 
 
 def custom_component(
@@ -2237,7 +2250,24 @@ def custom_component(
         )
 
     # Register this component so it can be compiled.
-    _register_custom_component(component_fn)
+    dummy_component = _register_custom_component(component_fn)
+    if tag := dummy_component.tag:
+        object.__setattr__(
+            wrapper,
+            "_as_var",
+            lambda: Var(
+                tag,
+                _var_type=type[Component],
+                _var_data=VarData(
+                    imports={
+                        f"$/{constants.Dirs.UTILS}/components": [ImportVar(tag=tag)],
+                        "@emotion/react": [
+                            ImportVar(tag="jsx"),
+                        ],
+                    }
+                ),
+            ),
+        )
 
     return wrapper
 
@@ -2457,7 +2487,7 @@ class StatefulComponent(BaseComponent):
             return None
 
         # Compute the hash based on the rendered code.
-        code_hash = _deterministic_hash(rendered_code)
+        code_hash = _hash_str(_deterministic_hash(rendered_code))
 
         # Format the tag name including the hash.
         return format.format_state_name(