reflex 0.8.8a2__py3-none-any.whl → 0.8.9__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__}`. "
@@ -1017,44 +1021,8 @@ class Component(BaseComponent, ABC):
         """
         return set()
 
-    @classmethod
-    def _are_fields_known(cls) -> bool:
-        """Check if all fields are known at compile time. True for most components.
-
-        Returns:
-            Whether all fields are known at compile time.
-        """
-        return True
-
-    @classmethod
-    @functools.cache
-    def _get_component_prop_names(cls) -> set[str]:
-        """Get the names of the component props. NOTE: This assumes all fields are known.
-
-        Returns:
-            The names of the component props.
-        """
-        return {
-            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
-            )
-        }
-
-    def _get_components_in_props(self) -> Sequence[BaseComponent]:
-        """Get the components in the props.
-
-        Returns:
-            The components in the props
-        """
-        if self._are_fields_known():
-            return [
-                component
-                for name in self._get_component_prop_names()
-                for component in _components_from(getattr(self, name))
-            ]
+    @functools.cached_property
+    def _get_component_prop_property(self) -> Sequence[BaseComponent]:
         return [
             component
             for prop in self.get_props()
@@ -1063,6 +1031,14 @@ class Component(BaseComponent, ABC):
             for component in _components_from(value)
         ]
 
+    def _get_components_in_props(self) -> Sequence[BaseComponent]:
+        """Get the components in the props.
+
+        Returns:
+            The components in the props
+        """
+        return self._get_component_prop_property
+
     @classmethod
     def _validate_children(cls, children: tuple | list):
         from reflex.utils.exceptions import ChildrenTypeError
@@ -1508,8 +1484,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 +1784,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)
@@ -2051,15 +2028,6 @@ class CustomComponent(Component):
             self.props[camel_cased_key] = value
             setattr(self, camel_cased_key, value)
 
-    @classmethod
-    def _are_fields_known(cls) -> bool:
-        """Check if the fields are known.
-
-        Returns:
-            Whether the fields are known.
-        """
-        return False
-
     def __eq__(self, other: Any) -> bool:
         """Check if the component is equal to another.
 
@@ -2190,6 +2158,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 +2185,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 +2209,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 +2446,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(

reflex/components/core/sticky.pyi

@@ -22,6 +22,9 @@ class StickyLogo(Svg):
         width: Var[int | str] | int | str | None = None,
         height: Var[int | str] | int | str | None = None,
         xmlns: Var[str] | str | None = None,
+        view_box: Var[str] | str | None = None,
+        preserve_aspect_ratio: Var[str] | str | None = None,
+        transform: Var[str] | str | None = None,
         access_key: Var[str] | str | None = None,
         auto_capitalize: Literal[
             "characters", "none", "off", "on", "sentences", "words"