modAL 1.4.3__tar.gz → 1.4.3.dev0__tar.gz

{modal-1.4.3 → modal-1.4.3.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.4.3
+Version: 1.4.3.dev0
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0
@@ -25,6 +25,7 @@ Requires-Dist: protobuf!=4.24.0,<7.0,>=3.19
 Requires-Dist: rich>=12.0.0
 Requires-Dist: synchronicity~=0.12.1
 Requires-Dist: toml
+Requires-Dist: typer>=0.9
 Requires-Dist: types-certifi
 Requires-Dist: types-toml
 Requires-Dist: watchfiles

{modal-1.4.3 → modal-1.4.3.dev0}/modal/__init__.py

@@ -17,7 +17,6 @@ try:
     from .cloud_bucket_mount import CloudBucketMount
     from .cls import Cls, parameter
     from .dict import Dict
-    from .environments import Environment
     from .exception import Error
     from .file_pattern_matcher import FilePatternMatcher
     from .functions import Function, FunctionCall
@@ -62,7 +61,6 @@ __all__ = [
     "Cls",
     "Cron",
     "Dict",
-    "Environment",
     "Error",
     "FilePatternMatcher",
     "Function",

{modal-1.4.3 → modal-1.4.3.dev0}/modal/_container_entrypoint.py

@@ -94,23 +94,6 @@ class DaemonizedThreadPool:
         self.inputs.put((func, args))
 
 
-def call_server(user_code_event_loop: UserCodeEventLoop):
-    async def run():
-        exit_event = asyncio.Event()
-
-        def _on_sigterm():
-            logger.info("server_received_sigterm")
-            exit_event.set()
-
-        user_code_event_loop.loop.add_signal_handler(signal.SIGTERM, _on_sigterm)
-        try:
-            await exit_event.wait()
-        finally:
-            user_code_event_loop.loop.remove_signal_handler(signal.SIGTERM)
-
-    user_code_event_loop.run(run())
-
-
 def call_function(
     user_code_event_loop: UserCodeEventLoop,
     container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
@@ -402,10 +385,7 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
             )
 
         with service.execution_context(event_loop, container_io_manager) as finalized_functions:
-            if function_def.is_server:
-                call_server(event_loop)
-            else:
-                call_function(event_loop, container_io_manager, finalized_functions, batch_max_size, batch_wait_ms)
+            call_function(event_loop, container_io_manager, finalized_functions, batch_max_size, batch_wait_ms)
 
 
 if __name__ == "__main__":

{modal-1.4.3 → modal-1.4.3.dev0}/modal/_functions.py

@@ -5,7 +5,7 @@ import inspect
 import time
 import typing
 import warnings
-from collections.abc import AsyncGenerator, Collection, Sequence
+from collections.abc import AsyncGenerator, Collection, Sequence, Sized
 from dataclasses import dataclass
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING, Any, AsyncIterator, Callable, Optional, Union
@@ -18,7 +18,6 @@ from synchronicity.combined_types import MethodWithAio
 from modal_proto import api_pb2
 from modal_proto.modal_api_grpc import ModalClientModal
 
-from ._function_variants import _FunctionOptions, _make_function_variant
 from ._load_context import LoadContext
 from ._object import _Object, live_method, live_method_gen
 from ._output.pty import get_pty_info
@@ -27,8 +26,11 @@ from ._resolver import Resolver
 from ._resources import convert_fn_config_to_resources_config
 from ._runtime.execution_context import current_input_id, is_local
 from ._serialization import (
+    apply_defaults,
     get_callable_schema,
     serialize,
+    serialize_proto_params,
+    validate_parameter_values,
 )
 from ._traceback import print_server_warnings
 from ._utils.async_utils import (
@@ -46,7 +48,6 @@ from ._utils.function_utils import (
     OUTPUTS_TIMEOUT,
     FunctionInfo,
     _create_input,
-    _parse_retries,
     _process_result,
     _stream_function_call_data,
     get_function_type,
@@ -89,7 +90,7 @@ from .proxy import _Proxy
 from .retries import Retries, RetryManager
 from .schedule import Schedule
 from .secret import _Secret
-from .volume import _Volume, _volume_to_mount_proto
+from .volume import _Volume
 
 if TYPE_CHECKING:
     import modal.app
@@ -548,7 +549,26 @@ class FunctionStats:
     backlog: int
     num_total_runners: int
     num_running_inputs: int
-    input_headroom: int
+
+
+def _parse_retries(
+    retries: Optional[Union[int, Retries]],
+    source: str = "",
+) -> Optional[api_pb2.FunctionRetryPolicy]:
+    if isinstance(retries, int):
+        return Retries(
+            max_retries=retries,
+            initial_delay=1.0,
+            backoff_coefficient=1.0,
+        )._to_proto()
+    elif isinstance(retries, Retries):
+        return retries._to_proto()
+    elif retries is None:
+        return None
+    else:
+        extra = f" on {source}" if source else ""
+        msg = f"Retries parameter must be an integer or instance of modal.Retries. Found: {type(retries)}{extra}."
+        raise InvalidError(msg)
 
 
 @dataclass
@@ -634,8 +654,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         None  # set for 0.67+ class service functions
     )
     _metadata: Optional[api_pb2.FunctionHandleMetadata] = None
-    _options: _FunctionOptions
-    _base_function: Optional["_Function"] = None
 
     @staticmethod
     def from_local(
@@ -667,7 +685,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         batch_wait_ms: Optional[int] = None,
         cloud: Optional[str] = None,
         region: Optional[Union[str, Sequence[str]]] = None,
-        routing_region: Optional[str] = None,
         nonpreemptible: bool = False,
         is_builder_function: bool = False,
         is_auto_snapshot: bool = False,
@@ -720,9 +737,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
         if retry_policy is not None:
             if webhook_config is not None:
-                raise InvalidError("Web Functions do not support retries.")
+                raise InvalidError("Web endpoints do not support retries.")
             if is_generator:
-                raise InvalidError("Generator Functions do not support retries.")
+                raise InvalidError("Generator functions do not support retries.")
 
         if timeout is None:  # type: ignore[unreachable]  # Help users who aren't using type checkers
             raise InvalidError("The `timeout` parameter cannot be set to None: https://modal.com/docs/guide/timeouts")
@@ -947,7 +964,13 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
                 # Relies on dicts being ordered (true as of Python 3.6).
                 volume_mounts = [
-                    _volume_to_mount_proto(path, volume) for path, volume in validated_volumes_no_cloud_buckets
+                    api_pb2.VolumeMount(
+                        mount_path=path,
+                        volume_id=volume.object_id,
+                        allow_background_commits=True,
+                        read_only=volume._read_only,
+                    )
+                    for path, volume in validated_volumes_no_cloud_buckets
                 ]
                 loaded_mount_ids = {m.object_id for m in all_mounts} | {m.object_id for m in image._mount_layers}
 
@@ -1028,7 +1051,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     supported_output_formats=supported_output_formats,
                     http_config=http_config,
                     is_server=is_server,
-                    routing_region=routing_region or "",
                 )
 
                 if isinstance(gpu, list):
@@ -1068,7 +1090,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         supported_output_formats=supported_output_formats,
                         http_config=http_config,
                         is_server=function_definition.is_server,
-                        routing_region=function_definition.routing_region,
                     )
 
                     ranked_functions = []
@@ -1150,6 +1171,130 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
         return obj
 
+    def _bind_parameters(
+        self,
+        obj: "modal.cls._Obj",
+        options: Optional["modal.cls._ServiceOptions"],
+        args: Sized,
+        kwargs: dict[str, Any],
+    ) -> "_Function":
+        """mdmd:hidden
+
+        Binds a class-function to a specific instance of (init params, options) or a new workspace
+        """
+
+        parent = self
+
+        async def _load(
+            param_bound_func: _Function,
+            resolver: Resolver,
+            load_context: LoadContext,
+            existing_object_id: Optional[str],
+        ):
+            if not parent.is_hydrated:
+                # While the base Object.hydrate() method appears to be idempotent, it's not always safe
+                await parent.hydrate()
+
+            assert parent._client and parent._client.stub
+
+            if (
+                parent._class_parameter_info
+                and parent._class_parameter_info.format == api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PROTO
+            ):
+                if args:
+                    # TODO(elias) - We could potentially support positional args as well, if we want to?
+                    raise InvalidError(
+                        "Can't use positional arguments with modal.parameter-based synthetic constructors.\n"
+                        "Use (<parameter_name>=value) keyword arguments when constructing classes instead."
+                    )
+                schema = parent._class_parameter_info.schema
+                kwargs_with_defaults = apply_defaults(kwargs, schema)
+                validate_parameter_values(kwargs_with_defaults, schema)
+                serialized_params = serialize_proto_params(kwargs_with_defaults)
+                can_use_parent = len(parent._class_parameter_info.schema) == 0  # no parameters
+            else:
+                from modal.cls import _ServiceOptions  # Should probably define this dataclass here?
+
+                can_use_parent = len(args) + len(kwargs) == 0 and (options == _ServiceOptions())
+                serialized_params = serialize((args, kwargs))
+
+            if can_use_parent:
+                # We can end up here if parent wasn't hydrated when class was instantiated, but has been since.
+                param_bound_func._hydrate_from_other(parent)
+                return
+
+            assert parent is not None and parent.is_hydrated
+
+            if options:
+                # Validate that the same volume (by object_id) isn't mounted at multiple paths
+                validate_volumes_by_object_id(options.validated_volumes)
+
+                volume_mounts = [
+                    api_pb2.VolumeMount(
+                        mount_path=path,
+                        volume_id=volume.object_id,
+                        allow_background_commits=True,
+                        read_only=volume._read_only,
+                    )
+                    for path, volume in options.validated_volumes
+                ]
+                options_pb = api_pb2.FunctionOptions(
+                    secret_ids=[s.object_id for s in options.secrets],
+                    replace_secret_ids=bool(options.secrets),
+                    replace_volume_mounts=len(volume_mounts) > 0,
+                    volume_mounts=volume_mounts,
+                    cloud_bucket_mounts=cloud_bucket_mounts_to_proto(options.cloud_bucket_mounts),
+                    replace_cloud_bucket_mounts=bool(options.cloud_bucket_mounts),
+                    resources=options.resources,
+                    retry_policy=options.retry_policy,
+                    concurrency_limit=options.max_containers,
+                    buffer_containers=options.buffer_containers,
+                    task_idle_timeout_secs=options.scaledown_window,
+                    timeout_secs=options.timeout_secs,
+                    max_concurrent_inputs=options.max_concurrent_inputs,
+                    target_concurrent_inputs=options.target_concurrent_inputs,
+                    batch_max_size=options.batch_max_size,
+                    batch_linger_ms=options.batch_wait_ms,
+                    scheduler_placement=options.scheduler_placement,
+                    cloud_provider_str=options.cloud,
+                )
+            else:
+                options_pb = None
+
+            req = api_pb2.FunctionBindParamsRequest(
+                function_id=parent.object_id,
+                serialized_params=serialized_params,
+                function_options=options_pb,
+                environment_name=load_context.environment_name
+                or "",  # TODO: investigate shouldn't environment name always be specified here?
+            )
+
+            response = await parent._client.stub.FunctionBindParams(req)
+            param_bound_func._hydrate(response.bound_function_id, parent._client, response.handle_metadata)
+
+        def _deps():
+            if options:
+                all_deps = (
+                    [v for _, v in options.validated_volumes]
+                    + list(options.secrets)
+                    + [mount.secret for _, mount in options.cloud_bucket_mounts if mount.secret]
+                )
+                return [dep for dep in all_deps if not dep.is_hydrated]
+            return []
+
+        fun: _Function = _Function._from_loader(
+            _load,
+            "Function(parametrized)",
+            hydrate_lazily=True,
+            deps=_deps,
+            load_context_overrides=self._load_context_overrides,
+        )
+
+        fun._info = self._info
+        fun._obj = obj
+        fun._spec = self._spec  # TODO (elias): fix - this is incorrect when using with_options
+        return fun
+
     @live_method
     async def update_autoscaler(
         self,
@@ -1239,7 +1384,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         )
         rep = f"modal.Function.from_name('{app_name}', '{name}'{environment_rep})"
         return cls._from_loader(
-            _load_remote, rep, skip_reload=True, hydrate_lazily=True, load_context_overrides=load_context_overrides
+            _load_remote, rep, is_another_app=True, hydrate_lazily=True, load_context_overrides=load_context_overrides
         )
 
     @classmethod
@@ -1326,8 +1471,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._serve_mounts = frozenset()
         self._metadata = None
         self._experimental_flash_urls = None
-        self._options = _FunctionOptions()
-        self._base_function = None
 
     def _hydrate_metadata(self, metadata: Optional[Message]):
         # Overridden concrete implementation of base class method
@@ -1388,10 +1531,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
     @live_method
     async def get_web_url(self) -> Optional[str]:
-        """URL for addressing a Web Function via HTTP.
-
-        Returns None when this is not a Web Function.
-        """
+        """URL of a Function running as a web endpoint."""
         return self._web_url
 
     @live_method
@@ -1399,143 +1539,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         """URL of the flash service for the function."""
         return list(self._experimental_flash_urls) if self._experimental_flash_urls else None
 
-    def _apply_dynamic_config(
-        self,
-        new_options: _FunctionOptions,
-        config_method_name: str,
-    ) -> "_Function[P, ReturnType, OriginalReturnType]":
-        base_function = self._base_function or self
-        combined_options = self._options.merge_options(new_options)
-
-        # For "True Functions" (i.e. not the Function inside a Cls), we will use
-        # `parameter_schema=[]` when the Function is un-parameterized. Note that
-        # `parameter_schema=Null` has different semantics that preserve Cls backwards compatibility.
-        parameter_schema: Sequence[api_pb2.ClassParameterSpec] = []
-        args = ()
-        kwargs: dict[str, Any] = {}
-
-        # The main reason to have two layers here (_apply_dynamic_config -> _make_function_variant)
-        # is because the _make_function_variant logic is shared between a true Function and a
-        # "class service function", but we need to propagate different instance metadata to the
-        # new object in each case. There's likely a cleaner way to do this, and then we could just
-        # collapse the dynamic configuration into a single layer.
-        new_function = _make_function_variant(base_function, combined_options, parameter_schema, args, kwargs)
-
-        new_function._options = combined_options
-        new_function._base_function = base_function
-        new_function._rep = f"{self._rep}.{config_method_name}(...)"
-
-        new_function._app = self._app
-        new_function._obj = self._obj
-
-        new_function._is_generator = self._is_generator
-        new_function._webhook_config = self._webhook_config
-
-        # Other fields not necessarily initialized
-        if self._info is not None:
-            new_function._build_args = self._build_args
-            new_function._is_method = self._is_method
-            new_function._raw_f = self._raw_f
-            new_function._tag = self._tag
-
-        return new_function
-
-    def with_options(
-        self,
-        *,
-        cpu: Optional[Union[float, tuple[float, float]]] = None,
-        memory: Optional[Union[int, tuple[int, int]]] = None,
-        gpu: Optional[str] = None,
-        env: Optional[dict[str, Optional[str]]] = None,
-        secrets: Optional[Collection[_Secret]] = None,
-        volumes: dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]] = {},
-        retries: Optional[Union[int, Retries]] = None,
-        max_containers: Optional[int] = None,
-        buffer_containers: Optional[int] = None,
-        scaledown_window: Optional[int] = None,
-        timeout: Optional[int] = None,
-        region: Optional[Union[str, Sequence[str]]] = None,
-        cloud: Optional[str] = None,
-    ) -> "_Function[P, ReturnType, OriginalReturnType]":
-        """Dynamically override the static Function configuration with invocation-specific values.
-
-        This method returns a new Function instance with the dynamic configuration. Invocations of
-        the new Function will run in a distinct container pool and autoscale independently from the
-        base Function (and from other dynamic configurations).
-
-        Note that options cannot be "unset" with this method (i.e., if a GPU is configured in the
-        `@app.cls()` decorator, passing `gpu=None` here will not create a CPU-only instance).
-        Additionally, container arguments like `volumes` and `secrets` will _replace_ the base
-        configuration or any previous use of this method rather than extending it.
-
-        **Usage:**
-
-        You can use this method after looking up a deployed Function:
-
-        ```python notest
-        fn = modal.Function.from_name("my_app", "fn").with_options(gpu="H100")
-        fn.remote()  # will run on a H100 GPU
-        ```
-
-        Or by referencing another Function defined in the same App:
-
-        ```python notest
-        @app.function()
-        def fn():
-            ...
-
-        # From a local entrypoint or another Function
-        fn.with_options(gpu="H100").remote()  # Uses an H100 GPU
-        fn.remote()  # Uses the static configuration with no GPU
-        ```
-
-        """
-        options = _FunctionOptions.new(
-            cpu=cpu,
-            memory=memory,
-            gpu=gpu,
-            env=env,
-            secrets=secrets,
-            volumes=volumes,
-            retries=retries,
-            max_containers=max_containers,
-            buffer_containers=buffer_containers,
-            scaledown_window=scaledown_window,
-            timeout=timeout,
-            region=region,
-            cloud=cloud,
-        )
-
-        return self._apply_dynamic_config(options, "with_options")
-
-    def with_concurrency(
-        self,
-        *,
-        max_inputs: int,
-        target_inputs: Optional[int] = None,
-    ) -> "_Function[P, ReturnType, OriginalReturnType]":
-        """Override the static Function configuration with invocation-specific input concurrency.
-
-        Returns a new Function instance that is dynamically configured to behave like a Function using
-        the `@modal.concurrent` decorator. This instance will autoscale independently from the base Function.
-        """
-        options = _FunctionOptions.new(max_concurrent_inputs=max_inputs, target_concurrent_inputs=target_inputs)
-        return self._apply_dynamic_config(options, "with_concurrency")
-
-    def with_batching(
-        self,
-        *,
-        max_batch_size: int,
-        wait_ms: int,
-    ) -> "_Function[P, ReturnType, OriginalReturnType]":
-        """Override the static Function configuration with invocation-specific dynamic batching.
-
-        Returns a new Function instance that is dynamically configured to behave like a Function using
-        the `@modal.batched` decorator. This instance will autoscale independently from the base Function.
-        """
-        options = _FunctionOptions.new(batch_max_size=max_batch_size, batch_wait_ms=wait_ms)
-        return self._apply_dynamic_config(options, "with_batching")
-
     @property
     async def is_generator(self) -> bool:
         """mdmd:hidden"""
@@ -1848,10 +1851,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             retry=Retry(total_timeout=10.0),
         )
         return FunctionStats(
-            backlog=resp.backlog,
-            num_total_runners=resp.num_total_tasks,
-            num_running_inputs=resp.num_running_inputs,
-            input_headroom=resp.input_headroom,
+            backlog=resp.backlog, num_total_runners=resp.num_total_tasks, num_running_inputs=resp.num_running_inputs
         )
 
     @live_method

{modal-1.4.3 → modal-1.4.3.dev0}/modal/_object.py

@@ -82,7 +82,7 @@ class _Object:
     _load: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]] = None
     _preload: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]]
     _rep: str
-    _skip_reload: bool
+    _is_another_app: bool
     _hydrate_lazily: bool
     _deps: Optional[Callable[..., Sequence["_Object"]]]
     _deduplication_key: Optional[Callable[[], Awaitable[Hashable]]] = None
@@ -113,9 +113,9 @@ class _Object:
         self,
         rep: str,
         load: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]] = None,
+        is_another_app: bool = False,
         preload: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]] = None,
         hydrate_lazily: bool = False,
-        skip_reload: bool = False,
         deps: Optional[Callable[..., Sequence["_Object"]]] = None,
         deduplication_key: Optional[Callable[[], Awaitable[Hashable]]] = None,
         name: Optional[str] = None,
@@ -123,10 +123,10 @@ class _Object:
         load_context_overrides: Optional[LoadContext] = None,
     ):
         self._local_uuid = str(uuid.uuid4())
-        self._rep = rep
         self._load = load
         self._preload = preload
-        self._skip_reload = skip_reload
+        self._rep = rep
+        self._is_another_app = is_another_app
         self._hydrate_lazily = hydrate_lazily
         self._deps = deps
         self._deduplication_key = deduplication_key
@@ -218,7 +218,7 @@ class _Object:
         cls,
         load: Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]],
         rep: str,
-        skip_reload: bool = False,
+        is_another_app: bool = False,
         preload: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]] = None,
         hydrate_lazily: bool = False,
         deps: Optional[Callable[..., Sequence["_Object"]]] = None,
@@ -232,12 +232,12 @@ class _Object:
         obj._init(
             rep,
             load,
-            skip_reload=skip_reload,
-            preload=preload,
-            hydrate_lazily=hydrate_lazily,
-            deps=deps,
-            deduplication_key=deduplication_key,
-            name=name,
+            is_another_app,
+            preload,
+            hydrate_lazily,
+            deps,
+            deduplication_key,
+            name,
             load_context_overrides=load_context_overrides,
         )
         return obj
@@ -268,7 +268,7 @@ class _Object:
         object_id: str,
         client: _Client,
         handle_metadata: Optional[Message],
-        skip_reload: bool = False,
+        is_another_app: bool = False,
         rep: Optional[str] = None,
     ) -> Self:
         obj_cls: type[Self]
@@ -287,7 +287,7 @@ class _Object:
         # Instantiate provider
         obj = _Object.__new__(obj_cls)
         rep = rep or f"modal.{obj_cls.__name__.strip('_')}.from_id({object_id!r})"
-        obj._init(rep, skip_reload=skip_reload)
+        obj._init(rep, is_another_app=is_another_app)
         obj._hydrate(object_id, client, handle_metadata)
 
         return obj

{modal-1.4.3 → modal-1.4.3.dev0}/modal/_output/rich.py

@@ -49,7 +49,7 @@ from modal._output.manager import (
 )
 from modal._utils.time_utils import timestamp_to_localized_str
 from modal.config import logger
-from modal.exception import DeprecationError, ServerWarning
+from modal.exception import DeprecationError, PendingDeprecationError, ServerWarning
 from modal_proto import api_pb2
 
 if platform.system() == "Windows":
@@ -359,14 +359,14 @@ class RichOutputManager(OutputManager):
     ) -> None:
         """Display a warning, using rich formatting for Modal-specific warnings.
 
-        Modal warnings (DeprecationError, ServerWarning) are shown
+        Modal warnings (DeprecationError, PendingDeprecationError, ServerWarning) are shown
         in a yellow-bordered panel with source context. Other warnings fall back to the
         default Python warning display.
         """
         # For non-Modal warnings, fall back to the default display
         import modal
 
-        is_modal_warning = issubclass(category, (DeprecationError, ServerWarning))
+        is_modal_warning = issubclass(category, (DeprecationError, PendingDeprecationError, ServerWarning))
         filename_in_modal = modal.__path__ and Path(filename).is_relative_to(modal.__path__[0])
         if not is_modal_warning and not filename_in_modal:
             base_showwarning(warning, category, filename, lineno, file=None, line=None)
@@ -392,7 +392,7 @@ class RichOutputManager(OutputManager):
                 pass
 
         # Build title
-        if issubclass(category, DeprecationError):
+        if issubclass(category, (DeprecationError, PendingDeprecationError)):
             title = "Modal Deprecation Warning"
         else:
             title = "Modal Warning"

{modal-1.4.3 → modal-1.4.3.dev0}/modal/_output/status.py

@@ -90,7 +90,7 @@ class FunctionCreationStatus:
                         suffix = _get_suffix_from_web_url_info(url_info)
                         class_web_endpoint_method_status_row = self._output_mgr.add_status_row()
                         class_web_endpoint_method_status_row.finish(
-                            f"Created Web Function URL for {method_definition.function_name} => [magenta underline]"
+                            f"Created web endpoint for {method_definition.function_name} => [magenta underline]"
                             f"{method_definition.web_url}[/magenta underline]{suffix}"
                         )
                         for custom_domain in method_definition.custom_domain_info: