modAL 1.0.0__tar.gz → 1.0.0.dev2__tar.gz

{modal-1.0.0 → modal-1.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.0.0
+Version: 1.0.0.dev2
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0

{modal-1.0.0 → modal-1.0.0.dev2}/modal/__init__.py

@@ -11,7 +11,7 @@ from modal_version import __version__
 try:
     from ._runtime.execution_context import current_function_call_id, current_input_id, interact, is_local
     from ._tunnel import Tunnel, forward
-    from .app import App
+    from .app import App, Stub
     from .client import Client
     from .cloud_bucket_mount import CloudBucketMount
     from .cls import Cls, parameter
@@ -20,6 +20,7 @@ try:
     from .file_pattern_matcher import FilePatternMatcher
     from .functions import Function, FunctionCall
     from .image import Image
+    from .mount import Mount
     from .network_file_system import NetworkFileSystem
     from .output import enable_output
     from .partial_function import (
@@ -53,7 +54,6 @@ except Exception:
     print()
     raise
 
-
 __all__ = [
     "__version__",
     "App",
@@ -66,6 +66,7 @@ __all__ = [
     "Function",
     "FunctionCall",
     "Image",
+    "Mount",
     "NetworkFileSystem",
     "Period",
     "Proxy",
@@ -76,6 +77,7 @@ __all__ = [
     "SandboxSnapshot",
     "SchedulerPlacement",
     "Secret",
+    "Stub",
     "Tunnel",
     "Volume",
     "asgi_app",
@@ -97,11 +99,3 @@ __all__ = [
     "web_server",
     "wsgi_app",
 ]
-
-
-def __getattr__(name):
-    if name == "Stub":
-        raise AttributeError(
-            "Module 'modal' has no attribute 'Stub'. Use `modal.App` instead. This is a simple name change."
-        )
-    raise AttributeError(f"module 'modal' has no attribute '{name}'")

{modal-1.0.0 → modal-1.0.0.dev2}/modal/_functions.py

@@ -6,7 +6,7 @@ import textwrap
 import time
 import typing
 import warnings
-from collections.abc import AsyncGenerator, Sequence, Sized
+from collections.abc import AsyncGenerator, Collection, Sequence, Sized
 from dataclasses import dataclass
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING, Any, Callable, Optional, Union
@@ -41,7 +41,7 @@ from ._utils.async_utils import (
     synchronizer,
     warn_if_generator_is_not_consumed,
 )
-from ._utils.deprecation import deprecation_warning
+from ._utils.deprecation import deprecation_error, deprecation_warning
 from ._utils.function_utils import (
     ATTEMPT_TIMEOUT_GRACE_PERIOD,
     OUTPUTS_TIMEOUT,
@@ -71,7 +71,7 @@ from .exception import (
 )
 from .gpu import GPU_T, parse_gpu_config
 from .image import _Image
-from .mount import _get_client_mount, _Mount
+from .mount import _get_client_mount, _Mount, get_sys_modules_mounts
 from .network_file_system import _NetworkFileSystem, network_file_system_mount_protos
 from .output import _get_output_manager
 from .parallel_map import (
@@ -405,6 +405,12 @@ class FunctionStats:
     backlog: int
     num_total_runners: int
 
+    def __getattr__(self, name):
+        if name == "num_active_runners":
+            msg = "'FunctionStats.num_active_runners' is no longer available."
+            deprecation_error((2024, 6, 14), msg)
+        raise AttributeError(f"'FunctionStats' object has no attribute '{name}'")
+
 
 def _parse_retries(
     retries: Optional[Union[int, Retries]],
@@ -505,6 +511,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         is_generator: bool = False,
         gpu: Union[GPU_T, list[GPU_T]] = None,
         # TODO: maybe break this out into a separate decorator for notebooks.
+        mounts: Collection[_Mount] = (),
         network_file_systems: dict[Union[str, PurePosixPath], _NetworkFileSystem] = {},
         volumes: dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]] = {},
         webhook_config: Optional[api_pb2.WebhookConfig] = None,
@@ -560,6 +567,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             assert not webhook_config
             assert not schedule
 
+        explicit_mounts = mounts
+
         include_source_mode = get_include_source_mode(include_source)
         if include_source_mode != IncludeSourceMode.INCLUDE_NOTHING:
             entrypoint_mounts = info.get_entrypoint_mount()
@@ -568,9 +577,34 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
         all_mounts = [
             _get_client_mount(),
+            *explicit_mounts,
             *entrypoint_mounts.values(),
         ]
 
+        if include_source_mode is IncludeSourceMode.INCLUDE_FIRST_PARTY and is_local():
+            auto_mounts = get_sys_modules_mounts()
+            # don't need to add entrypoint modules to automounts:
+            for entrypoint_module in entrypoint_mounts:
+                auto_mounts.pop(entrypoint_module, None)
+
+            warn_missing_modules = set(auto_mounts.keys()) - image._added_python_source_set
+
+            if warn_missing_modules:
+                python_stringified_modules = ", ".join(f'"{mod}"' for mod in sorted(warn_missing_modules))
+                deprecation_warning(
+                    (2025, 2, 3),
+                    (
+                        'Modal will stop implicitly adding local Python modules to the Image ("automounting") in a '
+                        "future update. The following modules need to be explicitly added for future "
+                        "compatibility:\n"
+                    )
+                    + "\n".join(sorted([f"* {m}" for m in warn_missing_modules]))
+                    + "\n\n"
+                    + (f"e.g.:\nimage_with_source = my_image.add_local_python_source({python_stringified_modules})\n\n")
+                    + "For more information, see https://modal.com/docs/guide/modal-1-0-migration",
+                )
+            all_mounts += auto_mounts.values()
+
         retry_policy = _parse_retries(
             retries, f"Function '{info.get_tag()}'" if info.raw_f else f"Class '{info.get_tag()}'"
         )
@@ -607,6 +641,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     image=image,
                     secrets=secrets,
                     gpu=gpu,
+                    mounts=mounts,
                     network_file_systems=network_file_systems,
                     volumes=volumes,
                     memory=memory,
@@ -714,7 +749,16 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
         def _deps(only_explicit_mounts=False) -> list[_Object]:
             deps: list[_Object] = list(secrets)
-            if not only_explicit_mounts:
+            if only_explicit_mounts:
+                # TODO: this is a bit hacky, but all_mounts may differ in the container vs locally
+                # We don't want the function dependencies to change, so we have this way to force it to
+                # only include its declared dependencies.
+                # Only objects that need interaction within a user's container actually need to be
+                # included when only_explicit_mounts=True, so omitting auto mounts here
+                # wouldn't be a problem as long as Mounts are "passive" and only loaded by the
+                # worker runtime
+                deps += list(explicit_mounts)
+            else:
                 deps += list(all_mounts)
             if proxy:
                 deps.append(proxy)
@@ -982,6 +1026,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         obj._build_args = dict(  # See get_build_def
             secrets=repr(secrets),
             gpu_config=repr([parse_gpu_config(_gpu) for _gpu in gpus]),
+            mounts=repr(mounts),
             network_file_systems=repr(network_file_systems),
         )
         # these key are excluded if empty to avoid rebuilds on client upgrade
@@ -1145,8 +1190,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
     @live_method
     async def keep_warm(self, warm_pool_size: int) -> None:
-        """mdmd:hidden
-        Set the warm pool size for the Function.
+        """Set the warm pool size for the Function.
 
         DEPRECATED: Please adapt your code to use the more general `update_autoscaler` method instead:
 
@@ -1250,8 +1294,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
     ) -> "_Function":
-        """mdmd:hidden
-        Lookup a Function from a deployed App by its name.
+        """Lookup a Function from a deployed App by its name.
 
         DEPRECATED: This method is deprecated in favor of `modal.Function.from_name`.
 
@@ -1375,8 +1418,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     @property
     @live_method
     async def web_url(self) -> Optional[str]:
-        """mdmd:hidden
-        Deprecated. Use the `Function.get_web_url()` method instead.
+        """Deprecated. Use the `Function.get_web_url()` method instead.
 
         URL of a Function running as a web endpoint.
         """
@@ -1493,6 +1535,20 @@ Use the `Function.get_web_url()` method instead.
         async for res in invocation.run_generator():
             yield res
 
+    @synchronizer.no_io_translation
+    async def _call_generator_nowait(self, args, kwargs):
+        deprecation_warning(
+            (2024, 12, 11),
+            "Calling spawn on a generator function is deprecated and will soon raise an exception.",
+        )
+        return await _Invocation.create(
+            self,
+            args,
+            kwargs,
+            client=self.client,
+            function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_ASYNC,
+        )
+
     @synchronizer.no_io_translation
     @live_method
     async def remote(self, *args: P.args, **kwargs: P.kwargs) -> ReturnType:
@@ -1605,7 +1661,7 @@ Use the `Function.get_web_url()` method instead.
         """
         self._check_no_web_url("_experimental_spawn")
         if self._is_generator:
-            raise InvalidError("Cannot `spawn` a generator function.")
+            invocation = await self._call_generator_nowait(args, kwargs)
         else:
             invocation = await self._call_function_nowait(
                 args, kwargs, function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_ASYNC
@@ -1637,13 +1693,14 @@ Use the `Function.get_web_url()` method instead.
         """
         self._check_no_web_url("spawn")
         if self._is_generator:
-            raise InvalidError("Cannot `spawn` a generator function.")
+            invocation = await self._call_generator_nowait(args, kwargs)
         else:
             invocation = await self._call_function_nowait(args, kwargs, api_pb2.FUNCTION_CALL_INVOCATION_TYPE_ASYNC)
 
         fc: _FunctionCall[ReturnType] = _FunctionCall._new_hydrated(
             invocation.function_call_id, invocation.client, None
         )
+        fc._is_generator = self._is_generator if self._is_generator else False
         return fc
 
     def get_raw_f(self) -> Callable[..., Any]:
@@ -1702,8 +1759,22 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
 
         The returned coroutine is not cancellation-safe.
         """
+
+        if self._is_generator:
+            raise Exception("Cannot get the result of a generator function call. Use `get_gen` instead.")
+
         return await self._invocation().poll_function(timeout=timeout)
 
+    async def get_gen(self) -> AsyncGenerator[Any, None]:
+        """
+        Calls the generator remotely, executing it with the given arguments and returning the execution's result.
+        """
+        if not self._is_generator:
+            raise Exception("Cannot iterate over a non-generator function call. Use `get` instead.")
+
+        async for res in self._invocation().run_generator():
+            yield res
+
     async def get_call_graph(self) -> list[InputInfo]:
         """Returns a structure representing the call graph from a given root
         call ID, along with the status of execution for each node.
@@ -1734,7 +1805,9 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         await retry_transient_errors(self._client.stub.FunctionCallCancel, request)
 
     @staticmethod
-    async def from_id(function_call_id: str, client: Optional[_Client] = None) -> "_FunctionCall[Any]":
+    async def from_id(
+        function_call_id: str, client: Optional[_Client] = None, is_generator: bool = False
+    ) -> "_FunctionCall[Any]":
         """Instantiate a FunctionCall object from an existing ID.
 
         Examples:
@@ -1757,6 +1830,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
             client = await _Client.from_env()
 
         fc: _FunctionCall[Any] = _FunctionCall._new_hydrated(function_call_id, client, None)
+        fc._is_generator = is_generator
         return fc
 
     @staticmethod
@@ -1787,8 +1861,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
 
 
 async def _gather(*function_calls: _FunctionCall[T]) -> typing.Sequence[T]:
-    """mdmd:hidden
-    Deprecated: Please use `modal.FunctionCall.gather()` instead."""
+    """Deprecated: Please use `modal.FunctionCall.gather()` instead."""
     deprecation_warning(
         (2025, 2, 24),
         "`modal.functions.gather()` is deprecated; please use `modal.FunctionCall.gather()` instead.",

{modal-1.0.0 → modal-1.0.0.dev2}/modal/_object.py

@@ -10,6 +10,7 @@ from typing_extensions import Self
 
 from ._resolver import Resolver
 from ._utils.async_utils import aclosing
+from ._utils.deprecation import deprecation_warning
 from .client import _Client
 from .config import config, logger
 from .exception import ExecutionError, InvalidError
@@ -236,6 +237,19 @@ class _Object:
 
         return self._deps if self._deps is not None else default_deps
 
+    async def resolve(self, client: Optional[_Client] = None):
+        """mdmd:hidden"""
+        obj = self.__class__.__name__.strip("_")
+        deprecation_warning(
+            (2025, 1, 16),
+            f"The `{obj}.resolve` method is deprecated and will be removed in a future release."
+            f" Please use `{obj}.hydrate()` or `await {obj}.hydrate.aio()` instead."
+            "\n\nNote that it is rarely necessary to explicitly hydrate objects, as most methods"
+            " will lazily hydrate when needed.",
+            show_source=False,  # synchronicity interferes with attributing source correctly
+        )
+        await self.hydrate(client)
+
     async def hydrate(self, client: Optional[_Client] = None) -> Self:
         """Synchronize the local object with its identity on the Modal server.
 

{modal-1.0.0 → modal-1.0.0.dev2}/modal/_partial_function.py

@@ -18,7 +18,7 @@ from modal_proto import api_pb2
 from ._functions import _Function
 from ._utils.async_utils import synchronizer
 from ._utils.deprecation import deprecation_warning
-from ._utils.function_utils import callable_has_non_self_params
+from ._utils.function_utils import callable_has_non_self_non_default_params, callable_has_non_self_params
 from .config import logger
 from .exception import InvalidError
 
@@ -181,11 +181,21 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
 
             if require_sync and inspect.iscoroutinefunction(self.raw_f):
                 self.registered = True  # Hacky, avoid false-positive warning
-                raise InvalidError(f"The `@modal.{decorator_name}` decorator can't be applied to an async function.")
+                raise InvalidError(f"`@modal.{decorator_name}` can't be applied to an async function.")
 
             if require_nullary and callable_has_non_self_params(self.raw_f):
                 self.registered = True  # Hacky, avoid false-positive warning
-                raise InvalidError(f"Functions decorated by `@modal.{decorator_name}` can't have parameters.")
+                if callable_has_non_self_non_default_params(self.raw_f):
+                    raise InvalidError(f"Functions obj by `@modal.{decorator_name}` can't have parameters.")
+                else:
+                    # TODO(michael): probably fine to just make this an error at this point
+                    # but best to do it in a separate PR
+                    deprecation_warning(
+                        (2024, 9, 4),
+                        f"The function obj by `@modal.{decorator_name}` has default parameters, "
+                        "but shouldn't have any parameters - Modal will drop support for "
+                        "default parameters in a future release.",
+                    )
 
     def _get_raw_f(self) -> Callable[P, ReturnType]:
         assert self.raw_f is not None
@@ -649,7 +659,7 @@ def _web_server(
 def _build(
     _warn_parentheses_missing=None, *, force: bool = False, timeout: int = 86400
 ) -> Callable[[Union[_PartialFunction, NullaryMethod]], _PartialFunction]:
-    """mdmd:hidden
+    """
     Decorator for methods that execute at _build time_ to create a new Image layer.
 
     **Deprecated**: This function is deprecated. We recommend using `modal.Volume`

{modal-1.0.0 → modal-1.0.0.dev2}/modal/_serialization.py

@@ -324,8 +324,8 @@ def _deserialize_asgi(asgi: api_pb2.Asgi) -> Any:
     elif msg_type == "websocket_send":
         return {
             "type": "websocket.send",
-            **({"bytes": asgi.websocket_send.bytes} if asgi.websocket_send.HasField("bytes") else {}),
-            **({"text": asgi.websocket_send.text} if asgi.websocket_send.HasField("text") else {}),
+            "bytes": asgi.websocket_send.bytes if asgi.websocket_send.HasField("bytes") else None,
+            "text": asgi.websocket_send.text if asgi.websocket_send.HasField("text") else None,
         }
     elif msg_type == "websocket_disconnect":
         return {

{modal-1.0.0 → modal-1.0.0.dev2}/modal/_utils/function_utils.py

@@ -23,7 +23,7 @@ from .._serialization import (
     signature_to_parameter_specs,
 )
 from .._traceback import append_modal_tb
-from ..config import logger
+from ..config import config, logger
 from ..exception import (
     DeserializationError,
     ExecutionError,
@@ -627,7 +627,8 @@ class FunctionCreationStatus:
 
 class IncludeSourceMode(enum.Enum):
     INCLUDE_NOTHING = False  # can only be set in source, can't be set in config
-    INCLUDE_MAIN_PACKAGE = True  # Default behavior
+    INCLUDE_MAIN_PACKAGE = True  # also represented by AUTOMOUNT=0 in config
+    INCLUDE_FIRST_PARTY = "legacy"  # mounts all "local" modules in sys.modules - represented by AUTOMOUNT=1 in config
 
 
 def get_include_source_mode(function_or_app_specific) -> IncludeSourceMode:
@@ -649,4 +650,6 @@ def get_include_source_mode(function_or_app_specific) -> IncludeSourceMode:
         # explicitly set in app/function
         return IncludeSourceMode(function_or_app_specific)
 
-    return IncludeSourceMode.INCLUDE_MAIN_PACKAGE
+    # note that the automount config boolean isn't a 1-1 mapping with include_source!
+    legacy_automount_mode: bool = config.get("automount")
+    return IncludeSourceMode.INCLUDE_FIRST_PARTY if legacy_automount_mode else IncludeSourceMode.INCLUDE_MAIN_PACKAGE

{modal-1.0.0 → modal-1.0.0.dev2}/modal/_utils/grpc_utils.py

@@ -148,20 +148,15 @@ def create_channel(
 
         logger.debug(f"Sending request to {event.method_name}")
 
-    async def recv_initial_metadata(initial_metadata: grpclib.events.RecvInitialMetadata) -> None:
+    async def recv_trailing_metadata(trailing_metadata: grpclib.events.RecvTrailingMetadata) -> None:
         # If we receive an auth token from the server, include it in all future requests.
         # TODO(nathan): This isn't perfect because the metadata isn't propagated when the
         # process is forked and a new channel is created. This is OK for now since this
         # token is only used by the experimental input plane
-        if token := initial_metadata.metadata.get("x-modal-auth-token"):
-            metadata["x-modal-auth-token"] = str(token)
-
-    async def recv_trailing_metadata(trailing_metadata: grpclib.events.RecvTrailingMetadata) -> None:
         if token := trailing_metadata.metadata.get("x-modal-auth-token"):
             metadata["x-modal-auth-token"] = str(token)
 
     grpclib.events.listen(channel, grpclib.events.SendRequest, send_request)
-    grpclib.events.listen(channel, grpclib.events.RecvInitialMetadata, recv_initial_metadata)
     grpclib.events.listen(channel, grpclib.events.RecvTrailingMetadata, recv_trailing_metadata)
 
     return channel

{modal-1.0.0 → modal-1.0.0.dev2}/modal/app.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2022
 import inspect
 import typing
+import warnings
 from collections.abc import AsyncGenerator, Coroutine, Sequence
 from pathlib import PurePosixPath
 from textwrap import dedent
@@ -29,6 +30,7 @@ from ._partial_function import (
 )
 from ._utils.async_utils import synchronize_api
 from ._utils.deprecation import (
+    deprecation_error,
     deprecation_warning,
     warn_on_renamed_autoscaler_settings,
 )
@@ -44,6 +46,7 @@ from .exception import ExecutionError, InvalidError
 from .functions import Function
 from .gpu import GPU_T
 from .image import _Image
+from .mount import _Mount
 from .network_file_system import _NetworkFileSystem
 from .partial_function import PartialFunction
 from .proxy import _Proxy
@@ -76,6 +79,11 @@ class _LocalEntrypoint:
     def app(self) -> "_App":
         return self._app
 
+    @property
+    def stub(self) -> "_App":
+        # Deprecated soon, only for backwards compatibility
+        return self._app
+
 
 LocalEntrypoint = synchronize_api(_LocalEntrypoint)
 
@@ -155,6 +163,7 @@ class _App:
     _classes: dict[str, _Cls]
 
     _image: Optional[_Image]
+    _mounts: Sequence[_Mount]
     _secrets: Sequence[_Secret]
     _volumes: dict[Union[str, PurePosixPath], _Volume]
     _web_endpoints: list[str]  # Used by the CLI
@@ -172,6 +181,7 @@ class _App:
         name: Optional[str] = None,
         *,
         image: Optional[_Image] = None,  # default image for all functions (default is `modal.Image.debian_slim()`)
+        mounts: Sequence[_Mount] = [],  # default mounts for all functions
         secrets: Sequence[_Secret] = [],  # default secrets for all functions
         volumes: dict[Union[str, PurePosixPath], _Volume] = {},  # default volumes for all functions
         include_source: Optional[bool] = None,
@@ -192,6 +202,7 @@ class _App:
         self._description = name
         self._include_source_default = include_source
 
+        check_sequence(mounts, _Mount, "`mounts=` has to be a list or tuple of `modal.Mount` objects")
         check_sequence(secrets, _Secret, "`secrets=` has to be a list or tuple of `modal.Secret` objects")
         validate_volumes(volumes)
 
@@ -201,6 +212,7 @@ class _App:
         self._functions = {}
         self._classes = {}
         self._image = image
+        self._mounts = mounts
         self._secrets = secrets
         self._volumes = volumes
         self._local_entrypoints = {}
@@ -316,6 +328,7 @@ class _App:
         self,
         *,
         client: Optional[_Client] = None,
+        show_progress: Optional[bool] = None,
         detach: bool = False,
         interactive: bool = False,
         environment_name: Optional[str] = None,
@@ -361,6 +374,16 @@ class _App:
         """
         from .runner import _run_app  # Defer import of runner.py, which imports a lot from Rich
 
+        # See Github discussion here: https://github.com/modal-labs/modal-client/pull/2030#issuecomment-2237266186
+
+        if show_progress is True:
+            deprecation_error(
+                (2024, 11, 20),
+                "`show_progress=True` is no longer supported. Use `with modal.enable_output():` instead.",
+            )
+        elif show_progress is False:
+            deprecation_warning((2024, 11, 20), "`show_progress=False` is deprecated (and has no effect)")
+
         async with _run_app(
             self, client=client, detach=detach, interactive=interactive, environment_name=environment_name
         ):
@@ -441,7 +464,9 @@ class _App:
         if not self._running_app:
             raise ExecutionError("`_get_watch_mounts` requires a running app.")
 
-        all_mounts = []
+        all_mounts = [
+            *self._mounts,
+        ]
         for function in self.registered_functions.values():
             all_mounts.extend(function._serve_mounts)
 
@@ -521,6 +546,14 @@ class _App:
         """All local CLI entrypoints registered on the app."""
         return self._local_entrypoints
 
+    @property
+    def indexed_objects(self) -> dict[str, _Object]:
+        deprecation_warning(
+            (2024, 11, 25),
+            "`app.indexed_objects` is deprecated! Use `app.registered_functions` or `app.registered_classes` instead.",
+        )
+        return dict(**self._functions, **self._classes)
+
     @property
     def registered_web_endpoints(self) -> list[str]:
         """Names of web endpoint (ie. webhook) functions registered on the app."""
@@ -605,6 +638,7 @@ class _App:
             GPU_T, list[GPU_T]
         ] = None,  # GPU request as string ("any", "T4", ...), object (`modal.GPU.A100()`, ...), or a list of either
         serialized: bool = False,  # Whether to send the function over using cloudpickle.
+        mounts: Sequence[_Mount] = (),  # Modal Mounts added to the container
         network_file_systems: dict[
             Union[str, PurePosixPath], _NetworkFileSystem
         ] = {},  # Mountpoints for Modal NetworkFileSystems
@@ -767,6 +801,12 @@ class _App:
                 rdma = None
                 i6pn_enabled = i6pn
 
+            if info.function_name.endswith(".app"):
+                warnings.warn(
+                    "Beware: the function name is `app`. Modal will soon rename `Stub` to `App`, "
+                    "so you might run into issues if you have code like `app = modal.App()` in the same scope"
+                )
+
             if is_generator is None:
                 is_generator = inspect.isgeneratorfunction(raw_f) or inspect.isasyncgenfunction(raw_f)
 
@@ -784,6 +824,7 @@ class _App:
                 schedule=schedule,
                 is_generator=is_generator,
                 gpu=gpu,
+                mounts=[*self._mounts, *mounts],
                 network_file_systems=network_file_systems,
                 volumes={**self._volumes, **volumes},
                 cpu=cpu,
@@ -834,6 +875,7 @@ class _App:
             GPU_T, list[GPU_T]
         ] = None,  # GPU request as string ("any", "T4", ...), object (`modal.GPU.A100()`, ...), or a list of either
         serialized: bool = False,  # Whether to send the function over using cloudpickle.
+        mounts: Sequence[_Mount] = (),
         network_file_systems: dict[
             Union[str, PurePosixPath], _NetworkFileSystem
         ] = {},  # Mountpoints for Modal NetworkFileSystems
@@ -955,6 +997,7 @@ class _App:
                 image=image or self._get_default_image(),
                 secrets=[*self._secrets, *secrets],
                 gpu=gpu,
+                mounts=[*self._mounts, *mounts],
                 network_file_systems=network_file_systems,
                 volumes={**self._volumes, **volumes},
                 cpu=cpu,
@@ -994,6 +1037,44 @@ class _App:
 
         return wrapper
 
+    async def spawn_sandbox(
+        self,
+        *entrypoint_args: str,
+        image: Optional[_Image] = None,  # The image to run as the container for the sandbox.
+        mounts: Sequence[_Mount] = (),  # Mounts to attach to the sandbox.
+        secrets: Sequence[_Secret] = (),  # Environment variables to inject into the sandbox.
+        network_file_systems: dict[Union[str, PurePosixPath], _NetworkFileSystem] = {},
+        timeout: Optional[int] = None,  # Maximum execution time of the sandbox in seconds.
+        workdir: Optional[str] = None,  # Working directory of the sandbox.
+        gpu: GPU_T = None,
+        cloud: Optional[str] = None,
+        region: Optional[Union[str, Sequence[str]]] = None,  # Region or regions to run the sandbox on.
+        # Specify, in fractional CPU cores, how many CPU cores to request.
+        # Or, pass (request, limit) to additionally specify a hard limit in fractional CPU cores.
+        # CPU throttling will prevent a container from exceeding its specified limit.
+        cpu: Optional[Union[float, tuple[float, float]]] = None,
+        # Specify, in MiB, a memory request which is the minimum memory required.
+        # Or, pass (request, limit) to additionally specify a hard limit in MiB.
+        memory: Optional[Union[int, tuple[int, int]]] = None,
+        block_network: bool = False,  # Whether to block network access
+        volumes: dict[
+            Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]
+        ] = {},  # Mount points for Modal Volumes and CloudBucketMounts
+        pty_info: Optional[api_pb2.PTYInfo] = None,
+        _experimental_scheduler_placement: Optional[
+            SchedulerPlacement
+        ] = None,  # Experimental controls over fine-grained scheduling (alpha).
+    ) -> None:
+        """mdmd:hidden"""
+        arglist = ", ".join(repr(s) for s in entrypoint_args)
+        message = (
+            "`App.spawn_sandbox` is deprecated.\n\n"
+            "Sandboxes can be created using the `Sandbox` object:\n\n"
+            f"```\nsb = Sandbox.create({arglist}, app=app)\n```\n\n"
+            "See https://modal.com/docs/guide/sandbox for more info on working with sandboxes."
+        )
+        deprecation_error((2024, 7, 5), message)
+
     def include(self, /, other_app: "_App") -> typing_extensions.Self:
         """Include another App's objects in this one.
 
@@ -1073,3 +1154,23 @@ class _App:
 
 
 App = synchronize_api(_App)
+
+
+class _Stub(_App):
+    """mdmd:hidden
+    This enables using a "Stub" class instead of "App".
+
+    For most of Modal's history, the app class was called "Stub", so this exists for
+    backwards compatibility, in order to facilitate moving from "Stub" to "App".
+    """
+
+    def __new__(cls, *args, **kwargs):
+        deprecation_warning(
+            (2024, 4, 29),
+            'The use of "Stub" has been deprecated in favor of "App".'
+            " This is a pure name change with no other implications.",
+        )
+        return _App(*args, **kwargs)
+
+
+Stub = synchronize_api(_Stub)