modAL 1.3.6.dev13__py3-none-any.whl → 1.3.6.dev14__py3-none-any.whl

modal/_functions.py

@@ -2,7 +2,6 @@
 import asyncio
 import dataclasses
 import inspect
-import textwrap
 import time
 import typing
 import warnings
@@ -44,7 +43,6 @@ from ._utils.async_utils import (
     warn_if_generator_is_not_consumed,
 )
 from ._utils.blob_utils import MAX_OBJECT_SIZE_BYTES
-from ._utils.deprecation import deprecation_warning, warn_if_passing_namespace
 from ._utils.function_utils import (
     ATTEMPT_TIMEOUT_GRACE_PERIOD,
     OUTPUTS_TIMEOUT,
@@ -54,6 +52,7 @@ from ._utils.function_utils import (
     _stream_function_call_data,
     get_function_type,
     is_async,
+    parse_gpu_config,
 )
 from ._utils.grpc_utils import Retry, RetryWarningMessage
 from ._utils.mount_utils import validate_network_file_systems, validate_volumes, validate_volumes_by_object_id
@@ -67,7 +66,6 @@ from .exception import (
     NotFoundError,
     OutputExpiredError,
 )
-from .gpu import GPU_T, parse_gpu_config
 from .image import _Image
 from .mount import _get_client_mount, _Mount
 from .network_file_system import _NetworkFileSystem, network_file_system_mount_protos
@@ -587,7 +585,7 @@ class _FunctionSpec:
     network_file_systems: dict[Union[str, PurePosixPath], _NetworkFileSystem]
     volumes: dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]]
     # TODO(irfansharif): Somehow assert that it's the first kind, in sandboxes
-    gpus: Union[GPU_T, list[GPU_T]]
+    gpus: Optional[str | list[str]]
     cloud: Optional[str]
     cpu: Optional[Union[float, tuple[float, float]]]
     memory: Optional[Union[int, tuple[int, int]]]
@@ -666,7 +664,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         secrets: Optional[Collection[_Secret]] = None,
         schedule: Optional[Schedule] = None,
         is_generator: bool = False,
-        gpu: Union[GPU_T, list[GPU_T]] = None,
+        gpu: Optional[str | list[str]] = None,
         # TODO: maybe break this out into a separate decorator for notebooks.
         network_file_systems: dict[Union[str, PurePosixPath], _NetworkFileSystem] = {},
         volumes: dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]] = {},
@@ -703,7 +701,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         include_source: bool = True,
         experimental_options: Optional[dict[str, str]] = None,
         _experimental_proxy_ip: Optional[str] = None,
-        _experimental_custom_scaling_factor: Optional[float] = None,
         restrict_output: bool = False,
         http_config: Optional[api_pb2.HTTPConfig] = None,
     ) -> "_Function":
@@ -799,11 +796,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         f"for clustered Functions"
                     )
 
-        if _experimental_custom_scaling_factor is not None and (
-            _experimental_custom_scaling_factor < 0 or _experimental_custom_scaling_factor > 1
-        ):
-            raise InvalidError("`_experimental_custom_scaling_factor` must be between 0.0 and 1.0 inclusive.")
-
         if not cloud and not is_builder_function:
             cloud = config.get("default_cloud")
 
@@ -1050,7 +1042,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     _experimental_group_size=cluster_size or 0,  # Experimental: Clustered functions
                     _experimental_concurrent_cancellations=True,
                     _experimental_proxy_ip=_experimental_proxy_ip,
-                    _experimental_custom_scaling=_experimental_custom_scaling_factor is not None,
                     # --- These are deprecated in favor of autoscaler_settings
                     warm_pool_size=min_containers or 0,
                     concurrency_limit=max_containers or 0,
@@ -1122,8 +1113,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     function_data.ranked_functions.extend(ranked_functions)
                     function_definition = None  # function_definition is not used in this case
                 else:
-                    # TODO(irfansharif): Assert on this specific type once we get rid of python 3.9.
-                    # assert isinstance(gpu, GPU_T)  # includes the case where gpu==None case
                     function_definition.resources.CopyFrom(
                         convert_fn_config_to_resources_config(
                             cpu=cpu, memory=memory, gpu=gpu, ephemeral_disk=ephemeral_disk, rdma=rdma
@@ -1170,7 +1159,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         obj._webhook_config = webhook_config  # only set locally
 
         # Used to check whether we should rebuild a modal.Image which uses `run_function`.
-        gpus: list[GPU_T] = gpu if isinstance(gpu, list) else [gpu]
+        gpus: list[str] = gpu if isinstance(gpu, list) else [gpu] if gpu else []
         obj._build_args = dict(  # See get_build_def
             secrets=repr(secrets),
             gpu_config=repr([parse_gpu_config(_gpu) for _gpu in gpus]),
@@ -1358,43 +1347,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         # One idea would be for FunctionUpdateScheduleParams to return the current (coalesced) settings
         # and then we could return them here (would need some ad hoc dataclass, which I don't love)
 
-    @live_method
-    async def keep_warm(self, warm_pool_size: int) -> None:
-        """mdmd:hidden
-        Set the warm pool size for the Function.
-
-        DEPRECATED: Please adapt your code to use the more general `update_autoscaler` method instead:
-
-        ```python notest
-        f = modal.Function.from_name("my-app", "function")
-
-        # Old pattern (deprecated)
-        f.keep_warm(2)
-
-        # New pattern
-        f.update_autoscaler(min_containers=2)
-        ```
-        """
-        if self._is_method:
-            raise InvalidError(
-                textwrap.dedent(
-                    """
-                The `.keep_warm()` method can not be used on Modal class *methods*.
-
-                Call `.keep_warm()` on the class *instance* instead. All methods of a class are run by the same
-                container pool, and this method applies to the size of that container pool.
-            """
-                )
-            )
-
-        deprecation_warning(
-            (2025, 5, 5),
-            "The .keep_warm() method has been deprecated in favor of the more general "
-            ".update_autoscaler(min_containers=...) method.",
-            show_source=True,
-        )
-        await self.update_autoscaler(min_containers=warm_pool_size)
-
     @classmethod
     def _from_name(
         cls,
@@ -1444,7 +1396,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         app_name: str,
         name: str,
         *,
-        namespace=None,  # mdmd:line-hidden
         environment_name: Optional[str] = None,
         client: Optional[_Client] = None,
     ) -> "_Function":
@@ -1459,17 +1410,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         ```
         """
         if "." in name:
-            class_name, method_name = name.split(".", 1)
-            deprecation_warning(
-                (2025, 2, 11),
-                "Looking up class methods using Function.from_name will be deprecated"
-                " in a future version of Modal.\nUse modal.Cls.from_name instead, e.g.\n\n"
-                f'{class_name} = modal.Cls.from_name("{app_name}", "{class_name}")\n'
-                f"instance = {class_name}(...)\n"
-                f"instance.{method_name}.remote(...)\n",
+            raise InvalidError(
+                f"Invalid Function name: {name!r}. "
+                "If you are trying to look up a class method, use `modal.Cls.from_name` instead."
             )
 
-        warn_if_passing_namespace(namespace, "modal.Function.from_name")
         return cls._from_name(
             app_name, name, load_context_overrides=LoadContext(environment_name=environment_name, client=client)
         )
@@ -1587,21 +1532,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 + f"or call it locally: {self._function_name}.local()"
             )
 
-    # TODO (live_method on properties is not great, since it could be blocking the event loop from async contexts)
-    @property
-    @live_method
-    async def web_url(self) -> Optional[str]:
-        """mdmd:hidden
-        Deprecated. Use the `Function.get_web_url()` method instead.
-
-        URL of a Function running as a web endpoint.
-        """
-        deprecation_msg = """The Function.web_url property will be removed in a future version of Modal.
-Use the `Function.get_web_url()` method instead.
-"""
-        deprecation_warning((2025, 5, 6), deprecation_msg, pending=True)
-        return self._web_url
-
     @live_method
     async def get_web_url(self) -> Optional[str]:
         """URL of a Function running as a web endpoint."""
@@ -2110,13 +2040,3 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         except Exception as exc:
             # TODO: kill all running function calls
             raise exc
-
-
-async def _gather(*function_calls: _FunctionCall[T]) -> typing.Sequence[T]:
-    """mdmd:hidden
-    Deprecated: Please use `modal.FunctionCall.gather()` instead."""
-    deprecation_warning(
-        (2025, 2, 24),
-        "`modal.functions.gather()` is deprecated; please use `modal.FunctionCall.gather()` instead.",
-    )
-    return await _FunctionCall.gather(*function_calls)

modal/_partial_function.py

@@ -17,7 +17,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.deprecation import deprecation_error
 from ._utils.function_utils import callable_has_non_self_params
 from .config import config
 from .exception import InvalidError
@@ -310,7 +310,7 @@ def _method(
     def wrapper(obj: Union[Callable[..., Any], _PartialFunction]) -> _PartialFunction:
         flags = _PartialFunctionFlags.CALLABLE_INTERFACE
 
-        nonlocal is_generator  # TODO(michael): we are likely to deprecate the explicit is_generator param
+        nonlocal is_generator
         if is_generator is None:
             callable = obj.raw_f if isinstance(obj, _PartialFunction) else obj
             is_generator = inspect.isgeneratorfunction(callable) or inspect.isasyncgenfunction(callable)
@@ -403,72 +403,16 @@ def _fastapi_endpoint(
 
 def _web_endpoint(
     _warn_parentheses_missing=None,  # mdmd:line-hidden
-    *,
-    method: str = "GET",  # REST method for the created endpoint.
-    label: Optional[str] = None,  # Label for created endpoint. Final subdomain will be <workspace>--<label>.modal.run.
-    docs: bool = False,  # Whether to enable interactive documentation for this endpoint at /docs.
-    custom_domains: Optional[
-        Iterable[str]
-    ] = None,  # Create an endpoint using a custom domain fully-qualified domain name (FQDN).
-    requires_proxy_auth: bool = False,  # Require Modal-Key and Modal-Secret HTTP Headers on requests.
-) -> Callable[
-    [Union[_PartialFunction[P, ReturnType, ReturnType], Callable[P, ReturnType]]],
-    _PartialFunction[P, ReturnType, ReturnType],
-]:
-    """Register a basic web endpoint with this application.
-
+    *args,
+    **kwargs,
+) -> None:
+    """mdmd:hidden
     DEPRECATED: This decorator has been renamed to `@modal.fastapi_endpoint`.
-
-    This is the simple way to create a web endpoint on Modal. The function
-    behaves as a [FastAPI](https://fastapi.tiangolo.com/) handler and should
-    return a response object to the caller.
-
-    Endpoints created with `@modal.web_endpoint` are meant to be simple, single
-    request handlers and automatically have
-    [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) enabled.
-    For more flexibility, use `@modal.asgi_app`.
-
-    To learn how to use Modal with popular web frameworks, see the
-    [guide on web endpoints](https://modal.com/docs/guide/webhooks).
     """
-    if isinstance(_warn_parentheses_missing, str):
-        # Probably passing the method string as a positional argument.
-        raise InvalidError('Positional arguments are not allowed. Suggestion: `@modal.web_endpoint(method="GET")`.')
-    elif _warn_parentheses_missing is not None:
-        raise InvalidError(
-            "Positional arguments are not allowed. Did you forget parentheses? Suggestion: `@modal.web_endpoint()`."
-        )
-
-    deprecation_warning(
+    deprecation_error(
         (2025, 3, 5), "The `@modal.web_endpoint` decorator has been renamed to `@modal.fastapi_endpoint`."
     )
 
-    webhook_config = api_pb2.WebhookConfig(
-        type=api_pb2.WEBHOOK_TYPE_FUNCTION,
-        method=method,
-        web_endpoint_docs=docs,
-        requested_suffix=label or "",
-        ephemeral_suffix=config.get("dev_suffix"),
-        async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
-        custom_domains=_parse_custom_domains(custom_domains),
-        requires_proxy_auth=requires_proxy_auth,
-    )
-
-    flags = _PartialFunctionFlags.WEB_INTERFACE
-    params = _PartialFunctionParams(webhook_config=webhook_config)
-
-    def wrapper(
-        obj: Union[_PartialFunction[P, ReturnType, ReturnType], Callable[P, ReturnType]],
-    ) -> _PartialFunction[P, ReturnType, ReturnType]:
-        if isinstance(obj, _PartialFunction):
-            pf = obj.stack(flags, params)
-        else:
-            pf = _PartialFunction(obj, flags, params)
-        pf.validate_obj_compatibility("web_endpoint")
-        return pf
-
-    return wrapper
-
 
 def _asgi_app(
     _warn_parentheses_missing=None,  # mdmd:line-hidden

modal/_resources.py

@@ -3,19 +3,18 @@ from typing import Optional, Union
 
 from modal_proto import api_pb2
 
+from ._utils.function_utils import parse_gpu_config
 from .exception import InvalidError
-from .gpu import GPU_T, parse_gpu_config
 
 
 def convert_fn_config_to_resources_config(
     *,
     cpu: Optional[Union[float, tuple[float, float]]],
     memory: Optional[Union[int, tuple[int, int]]],
-    gpu: GPU_T,
+    gpu: Optional[str],
     ephemeral_disk: Optional[int],
     rdma: Optional[bool] = None,
 ) -> api_pb2.Resources:
-    gpu_config = parse_gpu_config(gpu)
     if cpu and isinstance(cpu, tuple):
         if not cpu[0]:
             raise InvalidError("CPU request must be a positive number")
@@ -45,7 +44,7 @@ def convert_fn_config_to_resources_config(
     return api_pb2.Resources(
         milli_cpu=milli_cpu,
         milli_cpu_max=milli_cpu_max,
-        gpu_config=gpu_config,
+        gpu_config=parse_gpu_config(gpu),
         memory_mb=memory_mb,
         memory_mb_max=memory_mb_max,
         ephemeral_disk_mb=ephemeral_disk,

modal/_utils/deprecation.py

@@ -89,55 +89,34 @@ def renamed_parameter(
     return decorator
 
 
-def warn_on_renamed_autoscaler_settings(func: Callable[P, R]) -> Callable[P, R]:
-    name_map = {
-        "keep_warm": "min_containers",
-        "concurrency_limit": "max_containers",
-        "_experimental_buffer_containers": "buffer_containers",
-        "container_idle_timeout": "scaledown_window",
-    }
+def handle_deprecated_parameters(func: Callable[P, R]) -> Callable[P, R]:
+    """Meta-decorator for modal.Function decorators that errors when deprecated parameters are passed.
+
+    We use this for a select parameters that might still be suggested by LLMs.
+    """
 
     @functools.wraps(func)
     def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-        mut_kwargs: dict[str, Any] = locals()["kwargs"]  # Avoid referencing kwargs directly due to bug in sigtools
-
-        substitutions = []
-        old_params_used = name_map.keys() & mut_kwargs.keys()
-        for old_param, new_param in name_map.items():
-            if old_param in old_params_used:
-                new_param = name_map[old_param]
-                mut_kwargs[new_param] = mut_kwargs.pop(old_param)
-                substitutions.append(f"- {old_param} -> {new_param}")
-
-        if substitutions:
-            substitution_string = "\n".join(substitutions)
-            message = (
-                "We have renamed several parameters related to autoscaling."
-                " Please update your code to use the following new names:"
-                f"\n\n{substitution_string}"
-                "\n\nSee https://modal.com/docs/guide/modal-1-0-migration for more details."
+        _kwargs: dict[str, Any] = locals()["kwargs"]  # Avoid referencing kwargs directly due to bug in sigtools
+
+        # Basic autoscaler parameters
+        autoscaler_settings = {
+            "keep_warm": "min_containers",
+            "concurrency_limit": "max_containers",
+            "container_idle_timeout": "scaledown_window",
+        }
+
+        for old_name, new_name in autoscaler_settings.items():
+            if old_name in _kwargs:
+                deprecation_error((2025, 2, 24), f"The '{old_name}' parameter has been renamed to '{new_name}'.")
+
+        # Input concurrency
+        if "allow_concurrent_inputs" in _kwargs:
+            deprecation_error(
+                (2025, 4, 9),
+                "The 'allow_concurrent_inputs' parameter is deprecated. Use the '@modal.concurrent' decorator instead.",
             )
-            deprecation_warning((2025, 2, 24), message, show_source=True)
 
         return func(*args, **kwargs)
 
     return wrapper
-
-
-def warn_if_passing_namespace(
-    namespace: Any,
-    resource_name: str,
-) -> None:
-    """Issue deprecation warning for namespace parameter if non-None value is passed.
-
-    Args:
-        namespace: The namespace parameter value (may be None or actual value)
-        resource_name: Name of the resource type for the warning message
-    """
-    if namespace is not None:
-        deprecation_warning(
-            (2025, 6, 30),
-            f"The `namespace` parameter for `{resource_name}` is deprecated and will be"
-            " removed in a future release. It is no longer needed, so can be removed"
-            " from your code.",
-        )

modal/_utils/function_utils.py

@@ -602,3 +602,20 @@ async def _create_input(
             ),
             idx=idx,
         )
+
+
+def parse_gpu_config(value: Optional[str]) -> api_pb2.GPUConfig:
+    if value is None:
+        return api_pb2.GPUConfig()
+    elif isinstance(value, str):
+        count = 1
+        if ":" in value:
+            value, count_str = value.split(":", 1)
+            try:
+                count = int(count_str)
+            except ValueError:
+                raise InvalidError(f"Invalid GPU count: {count_str}. Value must be an integer.")
+        gpu_type = value.upper()
+        return api_pb2.GPUConfig(gpu_type=gpu_type, count=count)
+    else:
+        raise InvalidError(f"Invalid GPU config: {value!r}. Value must be a string or `None`")

modal/app.py

@@ -34,7 +34,7 @@ from ._server import _Server, validate_http_server_config
 from ._utils.async_utils import synchronize_api
 from ._utils.deprecation import (
     deprecation_warning,
-    warn_on_renamed_autoscaler_settings,
+    handle_deprecated_parameters,
 )
 from ._utils.function_utils import (
     FunctionInfo,
@@ -50,7 +50,6 @@ from .cls import _Cls, parameter
 from .config import logger
 from .exception import ExecutionError, InvalidError
 from .functions import Function
-from .gpu import GPU_T
 from .image import _Image
 from .network_file_system import _NetworkFileSystem
 from .partial_function import PartialFunction
@@ -58,7 +57,6 @@ from .proxy import _Proxy
 from .retries import Retries
 from .running_app import RunningApp
 from .schedule import Schedule
-from .scheduler_placement import SchedulerPlacement
 from .secret import _Secret
 from .volume import _Volume
 
@@ -443,7 +441,7 @@ class _App:
         # - 'rolling' (default): Traffic shifts to the new deployment by starting
         #   new containers gradually. Old containers will continue to process inputs while new
         #   containers start up.
-        # - 'restart': As part of the deployment, all running containers are terminated. New inputs
+        # - 'recreate': As part of the deployment, all running containers are terminated. New inputs
         #   will start new containers.
         strategy: str = "rolling",
     ) -> typing_extensions.Self:
@@ -705,7 +703,7 @@ class _App:
 
         return wrapped
 
-    @warn_on_renamed_autoscaler_settings
+    @handle_deprecated_parameters
     def function(
         self,
         _warn_parentheses_missing=None,  # mdmd:line-hidden
@@ -714,7 +712,7 @@ class _App:
         schedule: Optional[Schedule] = None,  # An optional Modal Schedule for the function
         env: Optional[dict[str, Optional[str]]] = None,  # Environment variables to set in the container
         secrets: Optional[Collection[_Secret]] = None,  # Secrets to inject into the container as environment variables
-        gpu: Union[GPU_T, list[GPU_T]] = None,  # GPU request; either a single GPU type or a list of types
+        gpu: Optional[str | list[str]] = None,  # GPU request; either a single GPU type or a list of types
         serialized: bool = False,  # Whether to send the function over using cloudpickle.
         network_file_systems: dict[
             Union[str, PurePosixPath], _NetworkFileSystem
@@ -756,17 +754,9 @@ class _App:
         experimental_options: Optional[dict[str, Any]] = None,
         # Parameters below here are experimental. Use with caution!
         _experimental_proxy_ip: Optional[str] = None,  # IP address of proxy
-        _experimental_custom_scaling_factor: Optional[float] = None,  # Custom scaling factor
         _experimental_restrict_output: bool = False,  # Don't use pickle for return values
         # Parameters below here are deprecated. Please update your code as suggested
-        keep_warm: Optional[int] = None,  # Replaced with `min_containers`
-        concurrency_limit: Optional[int] = None,  # Replaced with `max_containers`
-        container_idle_timeout: Optional[int] = None,  # Replaced with `scaledown_window`
-        allow_concurrent_inputs: Optional[int] = None,  # Replaced with the `@modal.concurrent` decorator
         max_inputs: Optional[int] = None,  # Replaced with `single_use_containers`
-        _experimental_buffer_containers: Optional[int] = None,  # Now stable API with `buffer_containers`
-        _experimental_scheduler_placement: Optional[SchedulerPlacement] = None,  # Replaced in favor of
-        # using `region` and `nonpreemptible`
     ) -> _FunctionDecoratorType:
         """Decorator to register a new Modal Function with this App."""
         if isinstance(_warn_parentheses_missing, _Image):
@@ -778,14 +768,6 @@ class _App:
         if image is None:
             image = self._get_default_image()
 
-        if allow_concurrent_inputs is not None:
-            deprecation_warning(
-                (2025, 4, 9),
-                "The `allow_concurrent_inputs` parameter is deprecated."
-                " Please use the `@modal.concurrent` decorator instead."
-                "\n\nSee https://modal.com/docs/guide/modal-1-0-migration for more information.",
-            )
-
         if max_inputs is not None:
             if not isinstance(max_inputs, int):
                 raise InvalidError(f"`max_inputs` must be an int, not {type(max_inputs).__name__}")
@@ -800,24 +782,6 @@ class _App:
             )
             single_use_containers = max_inputs == 1
 
-        if _experimental_scheduler_placement is not None:
-            deprecation_warning(
-                (2025, 11, 17),
-                "The `_experimental_scheduler_placement` parameter is deprecated."
-                " Please use the `region` and `nonpreemptible` parameters instead.",
-            )
-            if region is not None or nonpreemptible:
-                raise InvalidError(
-                    "Cannot use `_experimental_scheduler_placement` together with "
-                    "`region` or `nonpreemptible` parameters."
-                )
-            # Extract regions and lifecycle from scheduler placement
-            if _experimental_scheduler_placement.proto.regions:
-                region = list(_experimental_scheduler_placement.proto.regions)
-            if _experimental_scheduler_placement.proto._lifecycle:
-                # Convert lifecycle to nonpreemptible: "on-demand" -> True, "spot" -> False
-                nonpreemptible = _experimental_scheduler_placement.proto._lifecycle == "on-demand"
-
         secrets = secrets or []
         if env:
             secrets = [*secrets, _Secret.from_dict(env)]
@@ -836,9 +800,6 @@ class _App:
                 )
 
             if isinstance(f, _PartialFunction):
-                # typically for @function-wrapped @web_endpoint, @asgi_app, or @batched
-
-                # but we don't support @app.function wrapping a method.
                 if is_method_fn(f.raw_f.__qualname__):
                     raise InvalidError(
                         "The `@app.function` decorator cannot be used on class methods. "
@@ -868,7 +829,7 @@ class _App:
                     max_concurrent_inputs = f.params.max_concurrent_inputs
                     target_concurrent_inputs = f.params.target_concurrent_inputs
                 else:
-                    max_concurrent_inputs = allow_concurrent_inputs
+                    max_concurrent_inputs = None
                     target_concurrent_inputs = None
             else:
                 if not is_global_object(f.__qualname__) and not serialized:
@@ -905,7 +866,7 @@ class _App:
                 webhook_config = None
                 batch_max_size = None
                 batch_wait_ms = None
-                max_concurrent_inputs = allow_concurrent_inputs
+                max_concurrent_inputs = None
                 target_concurrent_inputs = None
 
                 cluster_size = None  # Experimental: Clustered functions
@@ -964,7 +925,7 @@ class _App:
         return wrapped
 
     @typing_extensions.dataclass_transform(field_specifiers=(parameter,), kw_only_default=True)
-    @warn_on_renamed_autoscaler_settings
+    @handle_deprecated_parameters
     def cls(
         self,
         _warn_parentheses_missing=None,  # mdmd:line-hidden
@@ -972,7 +933,7 @@ class _App:
         image: Optional[_Image] = None,  # The image to run as the container for the function
         env: Optional[dict[str, Optional[str]]] = None,  # Environment variables to set in the container
         secrets: Optional[Collection[_Secret]] = None,  # Secrets to inject into the container as environment variables
-        gpu: Union[GPU_T, list[GPU_T]] = None,  # GPU request; either a single GPU type or a list of types
+        gpu: Optional[str | list[str]] = None,  # GPU request; either a single GPU type or a list of types
         serialized: bool = False,  # Whether to send the function over using cloudpickle.
         network_file_systems: dict[
             Union[str, PurePosixPath], _NetworkFileSystem
@@ -1008,17 +969,9 @@ class _App:
         experimental_options: Optional[dict[str, Any]] = None,
         # Parameters below here are experimental. Use with caution!
         _experimental_proxy_ip: Optional[str] = None,  # IP address of proxy
-        _experimental_custom_scaling_factor: Optional[float] = None,  # Custom scaling factor
         _experimental_restrict_output: bool = False,  # Don't use pickle for return values
         # Parameters below here are deprecated. Please update your code as suggested
-        keep_warm: Optional[int] = None,  # Replaced with `min_containers`
-        concurrency_limit: Optional[int] = None,  # Replaced with `max_containers`
-        container_idle_timeout: Optional[int] = None,  # Replaced with `scaledown_window`
-        allow_concurrent_inputs: Optional[int] = None,  # Replaced with the `@modal.concurrent` decorator
         max_inputs: Optional[int] = None,  # Replaced with `single_use_containers`
-        _experimental_buffer_containers: Optional[int] = None,  # Now stable API with `buffer_containers`
-        _experimental_scheduler_placement: Optional[SchedulerPlacement] = None,  # Replaced in favor of
-        # using `region` and `nonpreemptible`
     ) -> Callable[[Union[CLS_T, _PartialFunction]], CLS_T]:
         """
         Decorator to register a new Modal [Cls](https://modal.com/docs/reference/modal.Cls) with this App.
@@ -1026,14 +979,6 @@ class _App:
         if _warn_parentheses_missing:
             raise InvalidError("Did you forget parentheses? Suggestion: `@app.cls()`.")
 
-        if allow_concurrent_inputs is not None:
-            deprecation_warning(
-                (2025, 4, 9),
-                "The `allow_concurrent_inputs` parameter is deprecated."
-                " Please use the `@modal.concurrent` decorator instead."
-                "\n\nSee https://modal.com/docs/guide/modal-1-0-migration for more information.",
-            )
-
         if max_inputs is not None:
             if not isinstance(max_inputs, int):
                 raise InvalidError(f"`max_inputs` must be an int, not {type(max_inputs).__name__}")
@@ -1048,24 +993,6 @@ class _App:
             )
             single_use_containers = max_inputs == 1
 
-        if _experimental_scheduler_placement is not None:
-            deprecation_warning(
-                (2025, 11, 17),
-                "The `_experimental_scheduler_placement` parameter is deprecated."
-                " Please use the `region` and `nonpreemptible` parameters instead.",
-            )
-            if region is not None or nonpreemptible:
-                raise InvalidError(
-                    "Cannot use `_experimental_scheduler_placement` together with "
-                    "`region` or `nonpreemptible` parameters."
-                )
-            # Extract regions and lifecycle from scheduler placement
-            if _experimental_scheduler_placement.proto.regions:
-                region = list(_experimental_scheduler_placement.proto.regions)
-            if _experimental_scheduler_placement.proto._lifecycle:
-                # Convert lifecycle to nonpreemptible: "on-demand" -> True, "spot" -> False
-                nonpreemptible = _experimental_scheduler_placement.proto._lifecycle == "on-demand"
-
         secrets = secrets or []
         if env:
             secrets = [*secrets, _Secret.from_dict(env)]
@@ -1086,7 +1013,7 @@ class _App:
                     max_concurrent_inputs = wrapped_cls.params.max_concurrent_inputs
                     target_concurrent_inputs = wrapped_cls.params.target_concurrent_inputs
                 else:
-                    max_concurrent_inputs = allow_concurrent_inputs
+                    max_concurrent_inputs = None
                     target_concurrent_inputs = None
 
                 if wrapped_cls.flags & _PartialFunctionFlags.CLUSTERED:
@@ -1098,7 +1025,7 @@ class _App:
                     rdma = None
             else:
                 user_cls = wrapped_cls
-                max_concurrent_inputs = allow_concurrent_inputs
+                max_concurrent_inputs = None
                 target_concurrent_inputs = None
                 cluster_size = None
                 rdma = None
@@ -1189,7 +1116,6 @@ class _App:
                 include_source=include_source if include_source is not None else local_state.include_source_default,
                 experimental_options={k: str(v) for k, v in (experimental_options or {}).items()},
                 _experimental_proxy_ip=_experimental_proxy_ip,
-                _experimental_custom_scaling_factor=_experimental_custom_scaling_factor,
                 restrict_output=_experimental_restrict_output,
             )
 
@@ -1215,7 +1141,7 @@ class _App:
         image: Optional[_Image] = None,  # The image to run as the container for the server
         env: Optional[dict[str, Optional[str]]] = None,  # Environment variables to set in the container
         secrets: Optional[Collection[_Secret]] = None,  # Secrets to inject into the container as environment variables
-        gpu: Union[GPU_T, list[GPU_T]] = None,  # GPU request; either a single GPU type or a list of types
+        gpu: Optional[str | list[str]] = None,  # GPU request; either a single GPU type or a list of types
         serialized: bool = False,  # Whether to send the server class over using cloudpickle.
         volumes: dict[
             Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]