reflex 0.8.12a1__py3-none-any.whl → 0.8.13a1__py3-none-any.whl

reflex/components/recharts/recharts.py

@@ -8,7 +8,7 @@ from reflex.components.component import Component, MemoizationLeaf, NoSSRCompone
 class Recharts(Component):
     """A component that wraps a recharts lib."""
 
-    library = "recharts@3.2.0"
+    library = "recharts@3.2.1"
 
     def _get_style(self) -> dict:
         return {"wrapperStyle": self.style}
@@ -17,7 +17,7 @@ class Recharts(Component):
 class RechartsCharts(NoSSRComponent, MemoizationLeaf):
     """A component that wraps a recharts lib."""
 
-    library = "recharts@3.2.0"
+    library = "recharts@3.2.1"
 
 
 LiteralAnimationEasing = Literal["ease", "ease-in", "ease-out", "ease-in-out", "linear"]

reflex/constants/colors.py

@@ -96,4 +96,6 @@ class Color:
         Returns:
             The formatted color.
         """
-        return format_color(self.color, self.shade, self.alpha)
+        from reflex.vars import LiteralColorVar
+
+        return LiteralColorVar.create(self).__format__(format_spec)

reflex/constants/installer.py

@@ -143,11 +143,11 @@ class PackageJson(SimpleNamespace):
         "postcss-import": "16.1.1",
         "@react-router/dev": _react_router_version,
         "@react-router/fs-routes": _react_router_version,
-        "vite": "npm:rolldown-vite@7.1.9",
+        "vite": "npm:rolldown-vite@7.1.12",
     }
     OVERRIDES = {
         # This should always match the `react` version in DEPENDENCIES for recharts compatibility.
         "react-is": _react_version,
         "cookie": "1.0.2",
-        "vite": "npm:rolldown-vite@7.1.9",
+        "vite": "npm:rolldown-vite@7.1.12",
     }

reflex/environment.py

@@ -657,6 +657,9 @@ class EnvironmentVariables:
     # Whether to force a full reload on changes.
     VITE_FORCE_FULL_RELOAD: EnvVar[bool] = env_var(False)
 
+    # Whether to enable SSR for the frontend.
+    REFLEX_SSR: EnvVar[bool] = env_var(True)
+
 
 environment = EnvironmentVariables()
 

reflex/istate/proxy.py

@@ -71,10 +71,15 @@ class StateProxy(wrapt.ObjectProxy):
             state_instance: The state instance to proxy.
             parent_state_proxy: The parent state proxy, for linked mutability and context tracking.
         """
+        from reflex.state import _substate_key
+
         super().__init__(state_instance)
-        # compile is not relevant to backend logic
         self._self_app = prerequisites.get_and_validate_app().app
         self._self_substate_path = tuple(state_instance.get_full_name().split("."))
+        self._self_substate_token = _substate_key(
+            state_instance.router.session.client_token,
+            self._self_substate_path,
+        )
         self._self_actx = None
         self._self_mutable = False
         self._self_actx_lock = asyncio.Lock()
@@ -127,16 +132,9 @@ class StateProxy(wrapt.ObjectProxy):
             msg = "The state is already mutable. Do not nest `async with self` blocks."
             raise ImmutableStateError(msg)
 
-        from reflex.state import _substate_key
-
         await self._self_actx_lock.acquire()
         self._self_actx_lock_holder = current_task
-        self._self_actx = self._self_app.modify_state(
-            token=_substate_key(
-                self.__wrapped__.router.session.client_token,
-                self._self_substate_path,
-            )
-        )
+        self._self_actx = self._self_app.modify_state(token=self._self_substate_token)
         mutable_state = await self._self_actx.__aenter__()
         super().__setattr__(
             "__wrapped__", mutable_state.get_substate(self._self_substate_path)
@@ -378,17 +376,6 @@ class MutableProxy(wrapt.ObjectProxy):
         pydantic.BaseModel.__dict__
     )
 
-    # These types will be wrapped in MutableProxy
-    __mutable_types__ = (
-        list,
-        dict,
-        set,
-        Base,
-        DeclarativeBase,
-        BaseModelV2,
-        BaseModelV1,
-    )
-
     # Dynamically generated classes for tracking dataclass mutations.
     __dataclass_proxies__: dict[type, type] = {}
 
@@ -469,20 +456,6 @@ class MutableProxy(wrapt.ObjectProxy):
             return wrapped(*args, **(kwargs or {}))
         return None
 
-    @classmethod
-    def _is_mutable_type(cls, value: Any) -> bool:
-        """Check if a value is of a mutable type and should be wrapped.
-
-        Args:
-            value: The value to check.
-
-        Returns:
-            Whether the value is of a mutable type.
-        """
-        return isinstance(value, cls.__mutable_types__) or (
-            dataclasses.is_dataclass(value) and not isinstance(value, Var)
-        )
-
     @staticmethod
     def _is_called_from_dataclasses_internal() -> bool:
         """Check if the current function is called from dataclasses helper.
@@ -514,7 +487,7 @@ class MutableProxy(wrapt.ObjectProxy):
         if self._is_called_from_dataclasses_internal():
             return value
         # Recursively wrap mutable types, but do not re-wrap MutableProxy instances.
-        if self._is_mutable_type(value) and not isinstance(value, MutableProxy):
+        if is_mutable_type(type(value)) and not isinstance(value, MutableProxy):
             base_cls = globals()[self.__base_proxy__]
             return base_cls(
                 wrapped=value,
@@ -575,7 +548,7 @@ class MutableProxy(wrapt.ObjectProxy):
                     self._wrap_recursive_decorator,
                 )
 
-        if self._is_mutable_type(value) and __name not in (
+        if is_mutable_type(type(value)) and __name not in (
             "__wrapped__",
             "_self_state",
             "__dict__",
@@ -764,3 +737,30 @@ class ImmutableMutableProxy(MutableProxy):
         return super()._mark_dirty(
             wrapped=wrapped, instance=instance, args=args, kwargs=kwargs
         )
+
+
+# These types will be wrapped in MutableProxy
+MUTABLE_TYPES = (
+    list,
+    dict,
+    set,
+    Base,
+    DeclarativeBase,
+    BaseModelV2,
+    BaseModelV1,
+)
+
+
+@functools.lru_cache(maxsize=1024)
+def is_mutable_type(type_: type) -> bool:
+    """Check if a type is mutable and should be wrapped.
+
+    Args:
+        type_: The type to check.
+
+    Returns:
+        Whether the type is mutable and should be wrapped.
+    """
+    return issubclass(type_, MUTABLE_TYPES) or (
+        dataclasses.is_dataclass(type_) and not issubclass(type_, Var)
+    )

reflex/plugins/shared_tailwind.py

@@ -179,7 +179,7 @@ class TailwindPlugin(PluginBase):
     config: TailwindConfig = dataclasses.field(
         default_factory=lambda: TailwindConfig(
             plugins=[
-                "@tailwindcss/typography@0.5.16",
+                "@tailwindcss/typography@0.5.18",
             ],
         )
     )

reflex/reflex.py

@@ -204,7 +204,7 @@ def _run(
     args = (frontend,)
     kwargs = {
         "check_if_schema_up_to_date": True,
-        "prerender_routes": env == constants.Env.PROD,
+        "prerender_routes": exec.should_prerender_routes(),
     }
 
     # Granian fails if the app is already imported.
@@ -216,9 +216,12 @@ def _run(
             *args,
             **kwargs,
         )
-        compile_future.result()
+        return_result = compile_future.result()
     else:
-        app_task(*args, **kwargs)
+        return_result = app_task(*args, **kwargs)
+
+    if not return_result:
+        raise SystemExit(1)
 
     # Get the frontend and backend commands, based on the environment.
     setup_frontend = frontend_cmd = backend_cmd = None
@@ -422,6 +425,21 @@ def compile(dry: bool, rich: bool):
     default=constants.Env.PROD.value,
     help="The environment to export the app in.",
 )
+@click.option(
+    "--exclude-from-backend",
+    "backend_excluded_dirs",
+    multiple=True,
+    type=click.Path(exists=True, path_type=Path, resolve_path=True),
+    help="Files or directories to exclude from the backend zip. Can be used multiple times.",
+)
+@click.option(
+    "--server-side-rendering/--no-server-side-rendering",
+    "--ssr/--no-ssr",
+    "ssr",
+    default=True,
+    is_flag=True,
+    help="Whether to enable server side rendering for the frontend.",
+)
 def export(
     zip: bool,
     frontend_only: bool,
@@ -429,11 +447,18 @@ def export(
     zip_dest_dir: str,
     upload_db_file: bool,
     env: LITERAL_ENV,
+    backend_excluded_dirs: tuple[Path, ...] = (),
+    ssr: bool = True,
 ):
     """Export the app to a zip file."""
     from reflex.utils import export as export_utils
     from reflex.utils import prerequisites
 
+    if not environment.REFLEX_SSR.is_set():
+        environment.REFLEX_SSR.set(ssr)
+    elif environment.REFLEX_SSR.get() != ssr:
+        ssr = environment.REFLEX_SSR.get()
+
     environment.REFLEX_COMPILE_CONTEXT.set(constants.CompileContext.EXPORT)
 
     should_frontend_run, should_backend_run = prerequisites.check_running_mode(
@@ -455,6 +480,8 @@ def export(
         upload_db_file=upload_db_file,
         env=constants.Env.DEV if env == constants.Env.DEV else constants.Env.PROD,
         loglevel=config.loglevel.subprocess_level(),
+        backend_excluded_dirs=backend_excluded_dirs,
+        prerender_routes=ssr,
     )
 
 
@@ -660,6 +687,21 @@ def makemigrations(message: str | None):
     "--config",
     help="path to the config file",
 )
+@click.option(
+    "--exclude-from-backend",
+    "backend_excluded_dirs",
+    multiple=True,
+    type=click.Path(exists=True, path_type=Path, resolve_path=True),
+    help="Files or directories to exclude from the backend zip. Can be used multiple times.",
+)
+@click.option(
+    "--server-side-rendering/--no-server-side-rendering",
+    "--ssr/--no-ssr",
+    "ssr",
+    default=True,
+    is_flag=True,
+    help="Whether to enable server side rendering for the frontend.",
+)
 def deploy(
     app_name: str | None,
     app_id: str | None,
@@ -673,6 +715,8 @@ def deploy(
     project_name: str | None,
     token: str | None,
     config_path: str | None,
+    backend_excluded_dirs: tuple[Path, ...] = (),
+    ssr: bool = True,
 ):
     """Deploy the app to the Reflex hosting service."""
     from reflex_cli.utils import dependency
@@ -690,6 +734,11 @@ def deploy(
 
     environment.REFLEX_COMPILE_CONTEXT.set(constants.CompileContext.DEPLOY)
 
+    if not environment.REFLEX_SSR.is_set():
+        environment.REFLEX_SSR.set(ssr)
+    elif environment.REFLEX_SSR.get() != ssr:
+        ssr = environment.REFLEX_SSR.get()
+
     # Only check requirements if interactive.
     # There is user interaction for requirements update.
     if interactive:
@@ -721,6 +770,8 @@ def deploy(
                 zipping=zipping,
                 loglevel=config.loglevel.subprocess_level(),
                 upload_db_file=upload_db,
+                backend_excluded_dirs=backend_excluded_dirs,
+                prerender_routes=ssr,
             )
         ),
         regions=list(region),

reflex/state.py

@@ -7,6 +7,7 @@ import builtins
 import contextlib
 import copy
 import dataclasses
+import datetime
 import functools
 import inspect
 import pickle
@@ -41,7 +42,7 @@ from reflex.event import (
 from reflex.istate import HANDLED_PICKLE_ERRORS, debug_failed_pickles
 from reflex.istate.data import RouterData
 from reflex.istate.proxy import ImmutableMutableProxy as ImmutableMutableProxy
-from reflex.istate.proxy import MutableProxy, StateProxy
+from reflex.istate.proxy import MutableProxy, StateProxy, is_mutable_type
 from reflex.istate.storage import ClientStorageBase
 from reflex.model import Model
 from reflex.utils import console, format, prerequisites, types
@@ -306,6 +307,14 @@ async def _resolve_delta(delta: Delta) -> Delta:
     return delta
 
 
+_deserializers = {
+    int: int,
+    float: float,
+    datetime.datetime: datetime.datetime.fromisoformat,
+    datetime.date: datetime.date.fromisoformat,
+    datetime.time: datetime.time.fromisoformat,
+}
+
 all_base_state_classes: dict[str, None] = {}
 
 
@@ -1359,7 +1368,7 @@ class BaseState(EvenMoreBasicBaseState):
             if parent_state is not None:
                 return getattr(parent_state, name)
 
-        if MutableProxy._is_mutable_type(value) and (
+        if is_mutable_type(type(value)) and (
             name in super().__getattribute__("base_vars") or name in backend_vars
         ):
             # track changes in mutable containers (list, dict, set, etc)
@@ -1872,11 +1881,12 @@ class BaseState(EvenMoreBasicBaseState):
                 hinted_args is tuple or hinted_args is tuple
             ):
                 payload[arg] = tuple(value)
-            elif isinstance(value, str) and (
-                hinted_args is int or hinted_args is float
+            elif (
+                isinstance(value, str)
+                and (deserializer := _deserializers.get(hinted_args)) is not None
             ):
                 try:
-                    payload[arg] = hinted_args(value)
+                    payload[arg] = deserializer(value)
                 except ValueError:
                     msg = f"Received a string value ({value}) for {arg} but expected a {hinted_args}"
                     raise ValueError(msg) from None

reflex/testing.py

@@ -47,6 +47,7 @@ from reflex.state import (
 )
 from reflex.utils import console, js_runtimes
 from reflex.utils.export import export
+from reflex.utils.token_manager import TokenManager
 from reflex.utils.types import ASGIApp
 
 try:
@@ -774,6 +775,19 @@ class AppHarness:
                 self.app_instance._state_manager = app_state_manager
                 await self.state_manager.close()
 
+    def token_manager(self) -> TokenManager:
+        """Get the token manager for the app instance.
+
+        Returns:
+            The current token_manager attached to the app's EventNamespace.
+        """
+        assert self.app_instance is not None
+        app_event_namespace = self.app_instance.event_namespace
+        assert app_event_namespace is not None
+        app_token_manager = app_event_namespace._token_manager
+        assert app_token_manager is not None
+        return app_token_manager
+
     def poll_for_content(
         self,
         element: WebElement,

reflex/utils/build.py

@@ -26,14 +26,14 @@ def set_env_json():
 
 
 def _zip(
+    *,
     component_name: constants.ComponentName,
-    target: str | Path,
-    root_dir: str | Path,
-    exclude_venv_dirs: bool,
-    upload_db_file: bool = False,
-    dirs_to_exclude: set[str] | None = None,
-    files_to_exclude: set[str] | None = None,
-    top_level_dirs_to_exclude: set[str] | None = None,
+    target: Path,
+    root_directory: Path,
+    exclude_venv_directories: bool,
+    include_db_file: bool = False,
+    directory_names_to_exclude: set[str] | None = None,
+    files_to_exclude: set[Path] | None = None,
     globs_to_include: list[str] | None = None,
 ) -> None:
     """Zip utility function.
@@ -41,49 +41,62 @@ def _zip(
     Args:
         component_name: The name of the component: backend or frontend.
         target: The target zip file.
-        root_dir: The root directory to zip.
-        exclude_venv_dirs: Whether to exclude venv directories.
-        upload_db_file: Whether to include local sqlite db files.
-        dirs_to_exclude: The directories to exclude.
+        root_directory: The root directory to zip.
+        exclude_venv_directories: Whether to exclude venv directories.
+        include_db_file: Whether to include local sqlite db files.
+        directory_names_to_exclude: The directory names to exclude.
         files_to_exclude: The files to exclude.
-        top_level_dirs_to_exclude: The top level directory names immediately under root_dir to exclude. Do not exclude folders by these names further in the sub-directories.
-        globs_to_include: Apply these globs from the root_dir and always include them in the zip.
+        globs_to_include: Apply these globs from the root_directory and always include them in the zip.
 
     """
     target = Path(target)
-    root_dir = Path(root_dir)
-    dirs_to_exclude = dirs_to_exclude or set()
+    root_directory = Path(root_directory).resolve()
+    directory_names_to_exclude = directory_names_to_exclude or set()
     files_to_exclude = files_to_exclude or set()
-    files_to_zip: list[str] = []
+    files_to_zip: list[Path] = []
     # Traverse the root directory in a top-down manner. In this traversal order,
     # we can modify the dirs list in-place to remove directories we don't want to include.
-    for root, dirs, files in os.walk(root_dir, topdown=True, followlinks=True):
-        root = Path(root)
+    for directory_path, subdirectories_names, subfiles_names in os.walk(
+        root_directory, topdown=True, followlinks=True
+    ):
+        directory_path = Path(directory_path).resolve()
         # Modify the dirs in-place so excluded and hidden directories are skipped in next traversal.
-        dirs[:] = [
-            d
-            for d in dirs
-            if (basename := Path(d).resolve().name) not in dirs_to_exclude
-            and not basename.startswith(".")
-            and (not exclude_venv_dirs or not _looks_like_venv_dir(root / d))
+        subdirectories_names[:] = [
+            subdirectory_name
+            for subdirectory_name in subdirectories_names
+            if subdirectory_name not in directory_names_to_exclude
+            and not any(
+                (directory_path / subdirectory_name).samefile(exclude)
+                for exclude in files_to_exclude
+                if exclude.exists()
+            )
+            and not subdirectory_name.startswith(".")
+            and (
+                not exclude_venv_directories
+                or not _looks_like_venv_directory(directory_path / subdirectory_name)
+            )
         ]
-        # If we are at the top level with root_dir, exclude the top level dirs.
-        if top_level_dirs_to_exclude and root == root_dir:
-            dirs[:] = [d for d in dirs if d not in top_level_dirs_to_exclude]
         # Modify the files in-place so the hidden files and db files are excluded.
-        files[:] = [
-            f
-            for f in files
-            if not f.startswith(".") and (upload_db_file or not f.endswith(".db"))
+        subfiles_names[:] = [
+            subfile_name
+            for subfile_name in subfiles_names
+            if not subfile_name.startswith(".")
+            and (include_db_file or not subfile_name.endswith(".db"))
         ]
         files_to_zip += [
-            str(root / file) for file in files if file not in files_to_exclude
+            directory_path / subfile_name
+            for subfile_name in subfiles_names
+            if not any(
+                (directory_path / subfile_name).samefile(excluded_file)
+                for excluded_file in files_to_exclude
+                if excluded_file.exists()
+            )
         ]
     if globs_to_include:
         for glob in globs_to_include:
             files_to_zip += [
-                str(file)
-                for file in root_dir.glob(glob)
+                file
+                for file in root_directory.glob(glob)
                 if file.name not in files_to_exclude
             ]
     # Create a progress bar for zipping the component.
@@ -100,14 +113,15 @@ def _zip(
         for file in files_to_zip:
             console.debug(f"{target}: {file}", progress=progress)
             progress.advance(task)
-            zipf.write(file, Path(file).relative_to(root_dir))
+            zipf.write(file, Path(file).relative_to(root_directory))
 
 
 def zip_app(
     frontend: bool = True,
     backend: bool = True,
     zip_dest_dir: str | Path | None = None,
-    upload_db_file: bool = False,
+    include_db_file: bool = False,
+    backend_excluded_dirs: tuple[Path, ...] = (),
 ):
     """Zip up the app.
 
@@ -115,41 +129,41 @@ def zip_app(
         frontend: Whether to zip up the frontend app.
         backend: Whether to zip up the backend app.
         zip_dest_dir: The directory to export the zip file to.
-        upload_db_file: Whether to upload the database file.
+        include_db_file: Whether to include the database file.
+        backend_excluded_dirs: A tuple of files or directories to exclude from the backend zip.  Defaults to ().
     """
     zip_dest_dir = zip_dest_dir or Path.cwd()
     zip_dest_dir = Path(zip_dest_dir)
     files_to_exclude = {
-        constants.ComponentName.FRONTEND.zip(),
-        constants.ComponentName.BACKEND.zip(),
+        Path(constants.ComponentName.FRONTEND.zip()).resolve(),
+        Path(constants.ComponentName.BACKEND.zip()).resolve(),
     }
 
     if frontend:
         _zip(
             component_name=constants.ComponentName.FRONTEND,
             target=zip_dest_dir / constants.ComponentName.FRONTEND.zip(),
-            root_dir=prerequisites.get_web_dir() / constants.Dirs.STATIC,
+            root_directory=prerequisites.get_web_dir() / constants.Dirs.STATIC,
             files_to_exclude=files_to_exclude,
-            exclude_venv_dirs=False,
+            exclude_venv_directories=False,
         )
 
     if backend:
         _zip(
             component_name=constants.ComponentName.BACKEND,
             target=zip_dest_dir / constants.ComponentName.BACKEND.zip(),
-            root_dir=Path.cwd(),
-            dirs_to_exclude={"__pycache__"},
-            files_to_exclude=files_to_exclude,
-            top_level_dirs_to_exclude={"assets"},
-            exclude_venv_dirs=True,
-            upload_db_file=upload_db_file,
+            root_directory=Path.cwd(),
+            directory_names_to_exclude={"__pycache__"},
+            files_to_exclude=files_to_exclude | set(backend_excluded_dirs),
+            exclude_venv_directories=True,
+            include_db_file=include_db_file,
             globs_to_include=[
                 str(Path(constants.Dirs.WEB) / constants.Dirs.BACKEND / "*")
             ],
         )
 
 
-def _duplicate_index_html_to_parent_dir(directory: Path):
+def _duplicate_index_html_to_parent_directory(directory: Path):
     """Duplicate index.html in the child directories to the given directory.
 
     This makes accessing /route and /route/ work in production.
@@ -169,7 +183,7 @@ def _duplicate_index_html_to_parent_dir(directory: Path):
                 else:
                     console.debug(f"Skipping {index_html}, already exists at {target}")
             # Recursively call this function for the child directory.
-            _duplicate_index_html_to_parent_dir(child)
+            _duplicate_index_html_to_parent_directory(child)
 
 
 def build():
@@ -200,11 +214,17 @@ def build():
         },
     )
     processes.show_progress("Creating Production Build", process, checkpoints)
-    _duplicate_index_html_to_parent_dir(wdir / constants.Dirs.STATIC)
-    path_ops.cp(
-        wdir / constants.Dirs.STATIC / constants.ReactRouter.SPA_FALLBACK,
-        wdir / constants.Dirs.STATIC / "404.html",
-    )
+    _duplicate_index_html_to_parent_directory(wdir / constants.Dirs.STATIC)
+
+    spa_fallback = wdir / constants.Dirs.STATIC / constants.ReactRouter.SPA_FALLBACK
+    if not spa_fallback.exists():
+        spa_fallback = wdir / constants.Dirs.STATIC / "index.html"
+
+    if spa_fallback.exists():
+        path_ops.cp(
+            spa_fallback,
+            wdir / constants.Dirs.STATIC / "404.html",
+        )
 
     config = get_config()
 
@@ -247,6 +267,6 @@ def setup_frontend_prod(
     build()
 
 
-def _looks_like_venv_dir(dir_to_check: str | Path) -> bool:
-    dir_to_check = Path(dir_to_check)
-    return (dir_to_check / "pyvenv.cfg").exists()
+def _looks_like_venv_directory(directory_to_check: str | Path) -> bool:
+    directory_to_check = Path(directory_to_check)
+    return (directory_to_check / "pyvenv.cfg").exists()

reflex/utils/exec.py

@@ -497,6 +497,7 @@ HOTRELOAD_IGNORE_EXTENSIONS = (
     "sh",
     "bash",
     "log",
+    "db",
 )
 
 HOTRELOAD_IGNORE_PATTERNS = (
@@ -742,6 +743,17 @@ def is_prod_mode() -> bool:
     return current_mode == constants.Env.PROD
 
 
+def should_prerender_routes() -> bool:
+    """Check if the app should prerender routes.
+
+    Returns:
+        True if the app should prerender routes.
+    """
+    if not environment.REFLEX_SSR.is_set():
+        return is_prod_mode()
+    return environment.REFLEX_SSR.get()
+
+
 def get_compile_context() -> constants.CompileContext:
     """Check if the app is compiled for deploy.
 

reflex/utils/export.py

@@ -18,6 +18,8 @@ def export(
     deploy_url: str | None = None,
     env: constants.Env = constants.Env.PROD,
     loglevel: constants.LogLevel = console._LOG_LEVEL,
+    backend_excluded_dirs: tuple[Path, ...] = (),
+    prerender_routes: bool = True,
 ):
     """Export the app to a zip file.
 
@@ -31,6 +33,8 @@ def export(
         deploy_url: The deploy URL to use. Defaults to None.
         env: The environment to use. Defaults to constants.Env.PROD.
         loglevel: The log level to use. Defaults to console._LOG_LEVEL.
+        backend_excluded_dirs: A tuple of files or directories to exclude from the backend zip.  Defaults to ().
+        prerender_routes: Whether to prerender the routes. Defaults to True.
     """
     config = get_config()
 
@@ -56,7 +60,7 @@ def export(
 
     if frontend:
         # Ensure module can be imported and app.compile() is called.
-        prerequisites.get_compiled_app(prerender_routes=True)
+        prerequisites.get_compiled_app(prerender_routes=prerender_routes)
         # Set up .web directory and install frontend dependencies.
         build.setup_frontend(Path.cwd())
 
@@ -70,7 +74,8 @@ def export(
             frontend=frontend,
             backend=backend,
             zip_dest_dir=zip_dest_dir,
-            upload_db_file=upload_db_file,
+            include_db_file=upload_db_file,
+            backend_excluded_dirs=backend_excluded_dirs,
         )
 
     # Post a telemetry event.