Class CompileContext

packages/reflex-base/src/reflex_base/plugins/compiler.py:754–864

Mutable compilation state for an entire compile run.

@dataclasses.dataclass(slots=True, kw_only=True)
class CompileContext(BaseContext):
    """Mutable compilation state for an entire compile run."""

    app: App | None = None
    pages: Sequence[PageDefinition]
    hooks: CompilerHooks = dataclasses.field(default_factory=CompilerHooks)
    compiled_pages: dict[str, PageContext] = dataclasses.field(default_factory=dict)
    all_imports: ParsedImportDict = dataclasses.field(default_factory=dict)
    app_wrap_components: dict[tuple[int, str], Component] = dataclasses.field(
        default_factory=dict
    )
    stateful_routes: dict[str, None] = dataclasses.field(default_factory=dict)
    # Auto-memoize wrapper tags seen during the tree walk (populated by
    # ``MemoizeStatefulPlugin``).
    memoize_wrappers: dict[str, None] = dataclasses.field(default_factory=dict)
    # Compiler-generated memo definitions for auto-memoized stateful wrappers.
    # Keyed by ``(tag, source_module)`` so identical-rendering subtrees from
    # different user modules each get their own entry and emit into the right
    # mirrored memo file. Stored as ``Any`` to avoid an import cycle with
    # ``reflex_base.components.memo``.
    auto_memo_components: dict[tuple[str, str | None], Any] = dataclasses.field(
        default_factory=dict
    )

    def compile(
        self,
        *,
        evaluate_progress: Callable[[], None] | None = None,
        render_progress: Callable[[], None] | None = None,
        **kwargs: Any,
    ) -> dict[str, PageContext]:
        """Compile all configured pages through the plugin pipeline.

        Args:
            evaluate_progress: Callback invoked after each page evaluation.
            render_progress: Callback invoked after each page render.
            kwargs: Additional compiler-specific context.

        Returns:
            The compiled page contexts keyed by route.
        """
        from reflex.compiler import compiler
        from reflex.state import all_base_state_classes

        self.ensure_context_attached()
        self.compiled_pages.clear()
        self.all_imports.clear()
        self.app_wrap_components.clear()
        self.stateful_routes.clear()
        self.memoize_wrappers.clear()
        self.auto_memo_components.clear()

        for page in self.pages:
            page_fn = page.component
            n_states_before = len(all_base_state_classes)
            page_ctx = self.hooks.eval_page(
                page_fn,
                page=page,