add progrss for imports and statefulizing

Author: adhami3310

reflex/app.py

@@ -1186,8 +1186,8 @@ def get_compilation_time() -> str:
         progress.start()
         task = progress.add_task(
             f"[{get_compilation_time()}] Compiling:",
-            total=len(self._pages)
-            + (len(self._unevaluated_pages) * 2)
+            total=len(self._unevaluated_pages)
+            + ((len(self._unevaluated_pages) + len(self._pages)) * 3)
             + fixed_pages_within_executor
             + adhoc_steps_without_executor
             + plugin_count,
@@ -1272,22 +1272,28 @@ def memoized_toast_provider():
         all_imports.update(custom_components_imports)
         progress.advance(task)
 
-        # This has to happen before compiling stateful components as that
-        # prevents recursive functions from reaching all components.
-        for component in self._pages.values():
-            # Add component._get_all_imports() to all_imports.
-            all_imports.update(component._get_all_imports())
+        with console.timing("Collect all imports and app wraps"):
+            # This has to happen before compiling stateful components as that
+            # prevents recursive functions from reaching all components.
+            for component in self._pages.values():
+                # Add component._get_all_imports() to all_imports.
+                all_imports.update(component._get_all_imports())
 
-            # Add the app wrappers from this component.
-            app_wrappers.update(component._get_all_app_wrap_components())
+                # Add the app wrappers from this component.
+                app_wrappers.update(component._get_all_app_wrap_components())
+
+                progress.advance(task)
 
         # Perform auto-memoization of stateful components.
         with console.timing("Auto-memoize StatefulComponents"):
             (
                 stateful_components_path,
                 stateful_components_code,
                 page_components,
-            ) = compiler.compile_stateful_components(self._pages.values())
+            ) = compiler.compile_stateful_components(
+                self._pages.values(),
+                progress_function=lambda task=task: progress.advance(task),
+            )
             progress.advance(task)
 
         # Catch "static" apps (that do not define a rx.State subclass) which are trying to access rx.State.

reflex/compiler/compiler.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import sys
-from collections.abc import Iterable, Sequence
+from collections.abc import Callable, Iterable, Sequence
 from inspect import getmodule
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -588,6 +588,7 @@ def compile_components(
 
 def compile_stateful_components(
     pages: Iterable[Component],
+    progress_function: Callable[[], None],
 ) -> tuple[str, str, list[BaseComponent]]:
     """Separately compile components that depend on State vars.
 
@@ -597,14 +598,20 @@ def compile_stateful_components(
 
     Args:
         pages: The pages to extract stateful components from.
+        progress_function: A function to call to indicate progress, called once per page.
 
     Returns:
         The path and code of the compiled stateful components.
     """
     output_path = utils.get_stateful_components_path()
 
-    # Compile the stateful components.
-    page_components = [StatefulComponent.compile_from(page) or page for page in pages]
+    page_components = []
+    for page in pages:
+        # Compile the stateful components
+        page_component = StatefulComponent.compile_from(page) or page
+        progress_function()
+        page_components.append(page_component)
+
     code = _compile_stateful_components(page_components)
     return output_path, code, page_components