reflex 0.7.13a2__py3-none-any.whl → 0.7.14a2__py3-none-any.whl

reflex/state.py

@@ -148,7 +148,8 @@ def _no_chain_background_task(
 
         return _no_chain_background_task_gen
 
-    raise TypeError(f"{fn} is marked as a background task, but is not async.")
+    msg = f"{fn} is marked as a background task, but is not async."
+    raise TypeError(msg)
 
 
 def _substate_key(
@@ -233,22 +234,19 @@ class EventHandlerSetVar(EventHandler):
 
         if args:
             if not isinstance(args[0], str):
-                raise EventHandlerValueError(
-                    f"Var name must be passed as a string, got {args[0]!r}"
-                )
+                msg = f"Var name must be passed as a string, got {args[0]!r}"
+                raise EventHandlerValueError(msg)
 
             handler = getattr(self.state_cls, constants.SETTER_PREFIX + args[0], None)
 
             # Check that the requested Var setter exists on the State at compile time.
             if handler is None:
-                raise AttributeError(
-                    f"Variable `{args[0]}` cannot be set on `{self.state_cls.get_full_name()}`"
-                )
+                msg = f"Variable `{args[0]}` cannot be set on `{self.state_cls.get_full_name()}`"
+                raise AttributeError(msg)
 
             if asyncio.iscoroutinefunction(handler.fn):
-                raise NotImplementedError(
-                    f"Setter for {args[0]} is async, which is not supported."
-                )
+                msg = f"Setter for {args[0]} is async, which is not supported."
+                raise NotImplementedError(msg)
 
         return super().__call__(*args)
 
@@ -406,14 +404,14 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         from reflex.utils.exceptions import ReflexRuntimeError
 
         if not _reflex_internal_init and not is_testing_env():
-            raise ReflexRuntimeError(
+            msg = (
                 "State classes should not be instantiated directly in a Reflex app. "
                 "See https://reflex.dev/docs/state/ for further information."
             )
+            raise ReflexRuntimeError(msg)
         if type(self)._mixin:
-            raise ReflexRuntimeError(
-                f"{type(self).__name__} is a state mixin and cannot be instantiated directly."
-            )
+            msg = f"{type(self).__name__} is a state mixin and cannot be instantiated directly."
+            raise ReflexRuntimeError(msg)
         kwargs["parent_state"] = parent_state
         super().__init__()
         for name, value in kwargs.items():
@@ -462,10 +460,11 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             NameError: If the module name is invalid.
         """
         if "___" in cls.__module__:
-            raise NameError(
+            msg = (
                 "The module name of a State class cannot contain '___'. "
                 "Please rename the module."
             )
+            raise NameError(msg)
 
     @classmethod
     def __init_subclass__(cls, mixin: bool = False, **kwargs):
@@ -515,10 +514,11 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             # Check if another substate class with the same name has already been defined.
             if cls.get_name() in {c.get_name() for c in parent_state.class_subclasses}:
                 # This should not happen, since we have added module prefix to state names in #3214
-                raise StateValueError(
+                msg = (
                     f"The substate class '{cls.get_name()}' has been defined multiple times. "
                     "Shadowing substate classes is not allowed."
                 )
+                raise StateValueError(msg)
             # Track this new subclass in the parent state's subclasses set.
             parent_state.class_subclasses.add(cls)
 
@@ -832,9 +832,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 overridden_methods.add(method.__name__)
 
         for method_name in overridden_methods:
-            raise EventHandlerShadowsBuiltInStateMethodError(
-                f"The event handler name `{method_name}` shadows a builtin State method; use a different name instead"
-            )
+            msg = f"The event handler name `{method_name}` shadows a builtin State method; use a different name instead"
+            raise EventHandlerShadowsBuiltInStateMethodError(msg)
 
     @classmethod
     def _check_overridden_basevars(cls):
@@ -845,9 +844,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         """
         for computed_var_ in cls._get_computed_vars():
             if computed_var_._js_expr in cls.__annotations__:
-                raise ComputedVarShadowsBaseVarsError(
-                    f"The computed var name `{computed_var_._js_expr}` shadows a base var in {cls.__module__}.{cls.__name__}; use a different name instead"
-                )
+                msg = f"The computed var name `{computed_var_._js_expr}` shadows a base var in {cls.__module__}.{cls.__name__}; use a different name instead"
+                raise ComputedVarShadowsBaseVarsError(msg)
 
     @classmethod
     def _check_overridden_computed_vars(cls) -> None:
@@ -861,9 +859,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 continue
             name = cv._js_expr
             if name in cls.inherited_vars or name in cls.inherited_backend_vars:
-                raise ComputedVarShadowsStateVarError(
-                    f"The computed var name `{cv._js_expr}` shadows a var in {cls.__module__}.{cls.__name__}; use a different name instead"
-                )
+                msg = f"The computed var name `{cv._js_expr}` shadows a var in {cls.__module__}.{cls.__name__}; use a different name instead"
+                raise ComputedVarShadowsStateVarError(msg)
 
     @classmethod
     def get_skip_vars(cls) -> set[str]:
@@ -901,7 +898,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             if issubclass(base, BaseState) and base is not BaseState and not base._mixin
         ]
         if len(parent_states) >= 2:
-            raise ValueError(f"Only one parent state is allowed {parent_states}.")
+            msg = f"Only one parent state is allowed {parent_states}."
+            raise ValueError(msg)
         # The first non-mixin state in the mro is our parent.
         for base in cls.mro()[1:]:
             if not issubclass(base, BaseState) or base._mixin:
@@ -953,7 +951,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         name = cls.get_name()
         parent_state = cls.get_parent_state()
         if parent_state is not None:
-            name = ".".join((parent_state.get_full_name(), name))
+            name = parent_state.get_full_name() + "." + name
         return name
 
     @classmethod
@@ -982,7 +980,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         for substate in cls.get_substates():
             if path[0] == substate.get_name():
                 return substate.get_class_substate(path[1:])
-        raise ValueError(f"Invalid path: {path}")
+        msg = f"Invalid path: {path}"
+        raise ValueError(msg)
 
     @classmethod
     def get_class_var(cls, path: Sequence[str]) -> Any:
@@ -1000,7 +999,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         path, name = path[:-1], path[-1]
         substate = cls.get_class_substate(tuple(path))
         if not hasattr(substate, name):
-            raise ValueError(f"Invalid path: {path}")
+            msg = f"Invalid path: {path}"
+            raise ValueError(msg)
         return getattr(substate, name)
 
     @classmethod
@@ -1029,12 +1029,13 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         from reflex.utils.exceptions import VarTypeError
 
         if not types.is_valid_var_type(prop._var_type):
-            raise VarTypeError(
+            msg = (
                 "State vars must be of a serializable type. "
                 "Valid types include strings, numbers, booleans, lists, "
                 "dictionaries, dataclasses, datetime objects, and pydantic models. "
                 f'Found var "{prop._js_expr}" with type {prop._var_type}.'
             )
+            raise VarTypeError(msg)
         cls._set_var(prop)
         if cls.is_user_defined() and get_config().state_auto_setters:
             cls._create_setter(prop)
@@ -1056,9 +1057,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             NameError: if a variable of this name already exists
         """
         if name in cls.__fields__:
-            raise NameError(
-                f"The variable '{name}' already exist. Use a different name"
-            )
+            msg = f"The variable '{name}' already exist. Use a different name"
+            raise NameError(msg)
 
         # create the variable based on name and type
         var = Var(
@@ -1260,9 +1260,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 arg in cls.computed_vars
                 and not isinstance(cls.computed_vars[arg], DynamicRouteVar)
             ) or arg in cls.base_vars:
-                raise DynamicRouteArgShadowsStateVarError(
-                    f"Dynamic route arg '{arg}' is shadowing an existing var in {cls.__module__}.{cls.__name__}"
-                )
+                msg = f"Dynamic route arg '{arg}' is shadowing an existing var in {cls.__module__}.{cls.__name__}"
+                raise DynamicRouteArgShadowsStateVarError(msg)
         for substate in cls.get_substates():
             substate._check_overwritten_dynamic_args(args)
 
@@ -1363,10 +1362,11 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 f"_{getattr(type(self), '__original_name__', type(self).__name__)}__"
             )
         ):
-            raise SetUndefinedStateVarError(
+            msg = (
                 f"The state variable '{name}' has not been defined in '{type(self).__name__}'. "
                 f"All state variables must be declared before they can be set."
             )
+            raise SetUndefinedStateVarError(msg)
 
         fields = self.get_fields()
 
@@ -1470,7 +1470,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 return self
             path = path[1:]
         if path[0] not in self.substates:
-            raise ValueError(f"Invalid path: {path}")
+            msg = f"Invalid path: {path}"
+            raise ValueError(msg)
         return self.substates[path[0]].get_substate(path[1:])
 
     @classmethod
@@ -1517,10 +1518,11 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         # Then get the target state and all its substates.
         state_manager = get_state_manager()
         if not isinstance(state_manager, StateManagerRedis):
-            raise RuntimeError(
+            msg = (
                 f"Requested state {state_cls.get_full_name()} is not cached and cannot be accessed without redis. "
-                "(All states should already be available -- this is likely a bug).",
+                "(All states should already be available -- this is likely a bug)."
             )
+            raise RuntimeError(msg)
         state_in_redis = await state_manager.get_state(
             token=_substate_key(self.router.session.client_token, state_cls),
             top_level=False,
@@ -1528,9 +1530,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         )
 
         if not isinstance(state_in_redis, state_cls):
-            raise StateMismatchError(
-                f"Searched for state {state_cls.get_full_name()} but found {state_in_redis}."
-            )
+            msg = f"Searched for state {state_cls.get_full_name()} but found {state_in_redis}."
+            raise StateMismatchError(msg)
 
         return state_in_redis
 
@@ -1549,9 +1550,10 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         root_state = self._get_root_state()
         substate = root_state.get_substate(state_cls.get_full_name().split("."))
         if not isinstance(substate, state_cls):
-            raise StateMismatchError(
+            msg = (
                 f"Searched for state {state_cls.get_full_name()} but found {substate}."
             )
+            raise StateMismatchError(msg)
         return substate
 
     async def get_state(self, state_cls: type[T_STATE]) -> T_STATE:
@@ -1601,9 +1603,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
 
         var_data = var._get_all_var_data()
         if var_data is None or not var_data.state:
-            raise UnretrievableVarValueError(
-                f"Unable to retrieve value for {var._js_expr}: not associated with any state."
-            )
+            msg = f"Unable to retrieve value for {var._js_expr}: not associated with any state."
+            raise UnretrievableVarValueError(msg)
         # Fastish case: this var belongs to this state
         if var_data.state == self.get_full_name():
             return getattr(self, var_data.field_name)
@@ -1634,9 +1635,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         path, name = path[:-1], path[-1]
         substate = self.get_substate(path)
         if not substate:
-            raise ValueError(
-                "The value of state cannot be None when processing an event."
-            )
+            msg = "The value of state cannot be None when processing an event."
+            raise ValueError(msg)
         handler = substate.event_handlers[name]
 
         # For background tasks, proxy the state
@@ -1702,10 +1702,11 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 "ignore", message=f"coroutine '{coroutine_name}' was never awaited"
             )
 
-        raise TypeError(
+        msg = (
             f"Your handler {handler.fn.__qualname__} must only return/yield: None, Events or other EventHandlers referenced by their class (i.e. using `type(self)` or other class references)."
             f" Returned events of types {', '.join(map(str, map(type, events)))!s}."
         )
+        raise TypeError(msg)
 
     async def _as_state_update(
         self,
@@ -1834,9 +1835,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 try:
                     payload[arg] = hinted_args(value)
                 except ValueError:
-                    raise ValueError(
-                        f"Received a string value ({value}) for {arg} but expected a {hinted_args}"
-                    ) from None
+                    msg = f"Received a string value ({value}) for {arg} but expected a {hinted_args}"
+                    raise ValueError(msg) from None
                 else:
                     console.warn(
                         f"Received a string value ({value}) for {arg} but expected a {hinted_args}. A simple conversion was successful."
@@ -2123,9 +2123,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         Raises:
             TypeError: always, because async contextmanager protocol is only supported for background task.
         """
-        raise TypeError(
-            "Only background task should use `async with self` to modify state."
-        )
+        msg = "Only background task should use `async with self` to modify state."
+        raise TypeError(msg)
 
     async def __aexit__(self, *exc_info: Any) -> None:
         """Exit the async context manager protocol.
@@ -2136,7 +2135,6 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         Args:
             exc_info: The exception info tuple.
         """
-        pass
 
     def __getstate__(self):
         """Get the state for redis serialization.
@@ -2298,9 +2296,10 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         elif fp is not None and data is None:
             (substate_schema, state) = pickle.load(fp)
         else:
-            raise ValueError("Only one of `data` or `fp` must be provided")
+            msg = "Only one of `data` or `fp` must be provided"
+            raise ValueError(msg)
         if substate_schema != state._to_schema():
-            raise StateSchemaMismatchError()
+            raise StateSchemaMismatchError
         return state
 
 
@@ -2377,14 +2376,12 @@ def dynamic(func: Callable[[T], Component]):
     values = list(func_signature.values())
 
     if number_of_parameters != 1:
-        raise DynamicComponentInvalidSignatureError(
-            "The function must have exactly one parameter, which is the state class."
-        )
+        msg = "The function must have exactly one parameter, which is the state class."
+        raise DynamicComponentInvalidSignatureError(msg)
 
     if len(values) != 1:
-        raise DynamicComponentInvalidSignatureError(
-            "You must provide a type hint for the state class in the function."
-        )
+        msg = "You must provide a type hint for the state class in the function."
+        raise DynamicComponentInvalidSignatureError(msg)
 
     state_class: type[T] = values[0]
 
@@ -2457,7 +2454,7 @@ class OnLoadInternalState(State):
         )
         if not load_events:
             self.is_hydrated = True
-            return  # Fast path for navigation with no on_load events defined.
+            return None  # Fast path for navigation with no on_load events defined.
         self.is_hydrated = False
         return [
             *fix_events(
@@ -2549,9 +2546,8 @@ class ComponentState(State, mixin=True):
         Raises:
             NotImplementedError: if the subclass does not override this method.
         """
-        raise NotImplementedError(
-            f"{cls.__name__} must implement get_component to return the component instance."
-        )
+        msg = f"{cls.__name__} must implement get_component to return the component instance."
+        raise NotImplementedError(msg)
 
     @classmethod
     def create(cls, *children, **props) -> Component:

reflex/style.py

@@ -121,10 +121,11 @@ def convert_item(
         ReflexError: If an EventHandler is used as a style value
     """
     if isinstance(style_item, EventHandler):
-        raise ReflexError(
+        msg = (
             "EventHandlers cannot be used as style values. "
             "Please use a Var or a literal value."
         )
+        raise ReflexError(msg)
 
     if isinstance(style_item, Var):
         return style_item, style_item._get_all_var_data()
@@ -381,6 +382,7 @@ def format_as_emotion(style_dict: dict[str, Any]) -> Style | None:
         if _var_data is not None:
             emotion_style._var_data = VarData.merge(emotion_style._var_data, _var_data)
         return emotion_style
+    return None
 
 
 def convert_dict_to_style_and_format_emotion(

reflex/testing.py

@@ -155,9 +155,8 @@ class AppHarness:
                 app_name = f"{func_name}_{slug_suffix}"
                 app_name = re.sub(r"[^a-zA-Z0-9_]", "_", app_name)
             elif isinstance(app_source, str):
-                raise ValueError(
-                    "app_name must be provided when app_source is a string."
-                )
+                msg = "app_name must be provided when app_source is a string."
+                raise ValueError(msg)
             else:
                 app_name = app_source.__name__
 
@@ -285,7 +284,8 @@ class AppHarness:
             self.app_instance._state_manager, StateManagerRedis
         ):
             if self.app_instance._state is None:
-                raise RuntimeError("State is not set.")
+                msg = "State is not set."
+                raise RuntimeError(msg)
             # Create our own redis connection for testing.
             self.state_manager = StateManagerRedis.create(self.app_instance._state)
         else:
@@ -299,7 +299,8 @@ class AppHarness:
 
     def _get_backend_shutdown_handler(self):
         if self.backend is None:
-            raise RuntimeError("Backend was not initialized.")
+            msg = "Backend was not initialized."
+            raise RuntimeError(msg)
 
         original_shutdown = self.backend.shutdown
 
@@ -330,7 +331,8 @@ class AppHarness:
 
     def _start_backend(self, port: int = 0):
         if self.app_asgi is None:
-            raise RuntimeError("App was not initialized.")
+            msg = "App was not initialized."
+            raise RuntimeError(msg)
         self.backend = uvicorn.Server(
             uvicorn.Config(
                 app=self.app_asgi,
@@ -366,7 +368,8 @@ class AppHarness:
                 state=self.app_instance._state,
             )
             if not isinstance(self.app_instance.state_manager, StateManagerRedis):
-                raise RuntimeError("Failed to reset state manager.")
+                msg = "Failed to reset state manager."
+                raise RuntimeError(msg)
 
     def _start_frontend(self):
         # Set up the frontend.
@@ -406,7 +409,8 @@ class AppHarness:
                 config.deploy_url = self.frontend_url
                 break
         if self.frontend_url is None:
-            raise RuntimeError("Frontend did not start")
+            msg = "Frontend did not start"
+            raise RuntimeError(msg)
 
         def consume_frontend_output():
             while True:
@@ -578,20 +582,23 @@ class AppHarness:
             TimeoutError: when server or sockets are not ready
         """
         if self.backend is None:
-            raise RuntimeError("Backend is not running.")
+            msg = "Backend is not running."
+            raise RuntimeError(msg)
         backend = self.backend
         # check for servers to be initialized
         if not self._poll_for(
             target=lambda: getattr(backend, "servers", False),
             timeout=timeout,
         ):
-            raise TimeoutError("Backend servers are not initialized.")
+            msg = "Backend servers are not initialized."
+            raise TimeoutError(msg)
         # check for sockets to be listening
         if not self._poll_for(
             target=lambda: getattr(backend.servers[0], "sockets", False),
             timeout=timeout,
         ):
-            raise TimeoutError("Backend is not listening.")
+            msg = "Backend is not listening."
+            raise TimeoutError(msg)
         return backend.servers[0].sockets[0]
 
     def frontend(
@@ -619,12 +626,14 @@ class AppHarness:
             RuntimeError: when selenium is not importable or frontend is not running
         """
         if not has_selenium:
-            raise RuntimeError(
+            msg = (
                 "Frontend functionality requires `selenium` to be installed, "
                 "and it could not be imported."
             )
+            raise RuntimeError(msg)
         if self.frontend_url is None:
-            raise RuntimeError("Frontend is not running.")
+            msg = "Frontend is not running."
+            raise RuntimeError(msg)
         want_headless = False
         if environment.APP_HARNESS_HEADLESS.get():
             want_headless = True
@@ -650,7 +659,8 @@ class AppHarness:
             if want_headless:
                 driver_options.add_argument("headless")
         if driver_options is None:
-            raise RuntimeError(f"Could not determine options for {driver_clz}")
+            msg = f"Could not determine options for {driver_clz}"
+            raise RuntimeError(msg)
         if args := environment.APP_HARNESS_DRIVER_ARGS.get():
             for arg in args.split(","):
                 driver_options.add_argument(arg)
@@ -680,7 +690,8 @@ class AppHarness:
             RuntimeError: when the app hasn't started running
         """
         if self.state_manager is None:
-            raise RuntimeError("state_manager is not set.")
+            msg = "state_manager is not set."
+            raise RuntimeError(msg)
         try:
             return await self.state_manager.get_state(token)
         finally:
@@ -698,7 +709,8 @@ class AppHarness:
             RuntimeError: when the app hasn't started running
         """
         if self.state_manager is None:
-            raise RuntimeError("state_manager is not set.")
+            msg = "state_manager is not set."
+            raise RuntimeError(msg)
         state = await self.get_state(token)
         for key, value in kwargs.items():
             setattr(state, key, value)
@@ -722,9 +734,11 @@ class AppHarness:
             RuntimeError: when the app hasn't started running
         """
         if self.state_manager is None:
-            raise RuntimeError("state_manager is not set.")
+            msg = "state_manager is not set."
+            raise RuntimeError(msg)
         if self.app_instance is None:
-            raise RuntimeError("App is not running.")
+            msg = "App is not running."
+            raise RuntimeError(msg)
         app_state_manager = self.app_instance.state_manager
         if isinstance(self.state_manager, StateManagerRedis):
             # Temporarily replace the app's state manager with our own, since
@@ -761,9 +775,8 @@ class AppHarness:
             target=lambda: element.text != exp_not_equal,
             timeout=timeout,
         ):
-            raise TimeoutError(
-                f"{element} content remains {exp_not_equal!r} while polling.",
-            )
+            msg = f"{element} content remains {exp_not_equal!r} while polling."
+            raise TimeoutError(msg)
         return element.text
 
     def poll_for_value(
@@ -792,9 +805,8 @@ class AppHarness:
             target=lambda: element.get_attribute("value") not in exp_not_equal,
             timeout=timeout,
         ):
-            raise TimeoutError(
-                f"{element} content remains {exp_not_equal!r} while polling.",
-            )
+            msg = f"{element} content remains {exp_not_equal!r} while polling."
+            raise TimeoutError(msg)
         return element.get_attribute("value")
 
     def poll_for_clients(self, timeout: TimeoutType = None) -> dict[str, BaseState]:
@@ -812,15 +824,18 @@ class AppHarness:
             ValueError: when the state_manager is not a memory state manager
         """
         if self.app_instance is None:
-            raise RuntimeError("App is not running.")
+            msg = "App is not running."
+            raise RuntimeError(msg)
         state_manager = self.app_instance.state_manager
         if not isinstance(state_manager, (StateManagerMemory, StateManagerDisk)):
-            raise ValueError("Only works with memory or disk state manager")
+            msg = "Only works with memory or disk state manager"
+            raise ValueError(msg)
         if not self._poll_for(
             target=lambda: state_manager.states,
             timeout=timeout,
         ):
-            raise TimeoutError("No states were observed while polling.")
+            msg = "No states were observed while polling."
+            raise TimeoutError(msg)
         return state_manager.states
 
 
@@ -962,11 +977,13 @@ class AppHarnessProd(AppHarness):
     def _wait_frontend(self):
         self._poll_for(lambda: self.frontend_server is not None)
         if self.frontend_server is None or not self.frontend_server.socket.fileno():
-            raise RuntimeError("Frontend did not start")
+            msg = "Frontend did not start"
+            raise RuntimeError(msg)
 
     def _start_backend(self):
         if self.app_asgi is None:
-            raise RuntimeError("App was not initialized.")
+            msg = "App was not initialized."
+            raise RuntimeError(msg)
         environment.REFLEX_SKIP_COMPILE.set(True)
         self.backend = uvicorn.Server(
             uvicorn.Config(

reflex/utils/build.py

@@ -132,7 +132,7 @@ def _zip(
 def zip_app(
     frontend: bool = True,
     backend: bool = True,
-    zip_dest_dir: str | Path = Path.cwd(),
+    zip_dest_dir: str | Path | None = None,
     upload_db_file: bool = False,
 ):
     """Zip up the app.
@@ -143,6 +143,7 @@ def zip_app(
         zip_dest_dir: The directory to export the zip file to.
         upload_db_file: Whether to upload the database file.
     """
+    zip_dest_dir = zip_dest_dir or Path.cwd()
     zip_dest_dir = Path(zip_dest_dir)
     files_to_exclude = {
         constants.ComponentName.FRONTEND.zip(),