modAL 1.2.2.dev38__tar.gz → 1.2.3__tar.gz

{modal-1.2.2.dev38 → modal-1.2.3}/PKG-INFO

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

{modal-1.2.2.dev38 → modal-1.2.3}/modal/_functions.py

@@ -90,7 +90,6 @@ from .parallel_map import (
 from .proxy import _Proxy
 from .retries import Retries, RetryManager
 from .schedule import Schedule
-from .scheduler_placement import SchedulerPlacement
 from .secret import _Secret
 from .volume import _Volume
 
@@ -537,6 +536,7 @@ class _InputPlaneInvocation:
     async def _get_metadata(input_plane_region: str, client: _Client) -> list[tuple[str, str]]:
         if not input_plane_region:
             return []
+        assert client._auth_token_manager, "Client is not open"
         token = await client._auth_token_manager.get_token()
         return [("x-modal-input-plane-region", input_plane_region), ("x-modal-auth-token", token)]
 
@@ -589,7 +589,7 @@ class _FunctionSpec:
     cpu: Optional[Union[float, tuple[float, float]]]
     memory: Optional[Union[int, tuple[int, int]]]
     ephemeral_disk: Optional[int]
-    scheduler_placement: Optional[SchedulerPlacement]
+    scheduler_placement: Optional[api_pb2.SchedulerPlacement]
     proxy: Optional[_Proxy]
 
 
@@ -683,7 +683,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         batch_max_size: Optional[int] = None,
         batch_wait_ms: Optional[int] = None,
         cloud: Optional[str] = None,
-        scheduler_placement: Optional[SchedulerPlacement] = None,
+        region: Optional[Union[str, Sequence[str]]] = None,
+        nonpreemptible: bool = False,
         is_builder_function: bool = False,
         is_auto_snapshot: bool = False,
         enable_memory_snapshot: bool = False,
@@ -746,6 +747,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         if env:
             secrets = [*secrets, _Secret.from_dict(env)]
 
+        scheduler_placement: Optional[api_pb2.SchedulerPlacement] = None
+        if region or nonpreemptible:
+            regions = [region] if isinstance(region, str) else (list(region) if region else None)
+            scheduler_placement = api_pb2.SchedulerPlacement(regions=regions, nonpreemptible=nonpreemptible)
+
         function_spec = _FunctionSpec(
             mounts=all_mounts,
             secrets=secrets,
@@ -1018,7 +1024,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     untrusted=restrict_modal_access,
                     max_inputs=max_inputs or 0,
                     cloud_bucket_mounts=cloud_bucket_mounts_to_proto(cloud_bucket_mounts),
-                    scheduler_placement=scheduler_placement.proto if scheduler_placement else None,
+                    scheduler_placement=scheduler_placement,
                     is_class=info.is_service_class(),
                     class_parameter_info=info.class_parameter_info(),
                     i6pn_enabled=i6pn_enabled,

{modal-1.2.2.dev38 → modal-1.2.3}/modal/_load_context.py

@@ -66,8 +66,9 @@ class LoadContext:
 
         Returns a new instance (no in place mutation)"""
 
+        is_valid_client = self._client is not None and not self._client._snapshotted
         return LoadContext(
-            client=await _Client.from_env() if self._client is None else self.client,
+            client=self.client if is_valid_client else await _Client.from_env(),
             environment_name=self._environment_name or config.get("environment") or "",
             app_id=self._app_id,
         )

{modal-1.2.2.dev38 → modal-1.2.3}/modal/_object.py

@@ -43,7 +43,7 @@ class _Object:
     _prefix_to_type: ClassVar[dict[str, type]] = {}
 
     # For constructors
-    _load: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]]
+    _load: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]] = None
     _preload: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]]
     _rep: str
     _is_another_app: bool
@@ -308,11 +308,17 @@ class _Object:
                 # memory snapshots capture references which must be rehydrated
                 # on restore to handle staleness.
                 logger.debug(f"rehydrating {self} after snapshot")
-                self._is_hydrated = False  # un-hydrate and re-resolve
-                # Set the client on LoadContext before loading
-                root_load_context = LoadContext(client=client)
-                resolver = Resolver()
-                await resolver.load(typing.cast(_Object, self), root_load_context)
+                if self._hydrate_lazily:
+                    logger.debug(f"reloading lazy {self} from server")
+                    self._is_hydrated = False  # un-hydrate and re-resolve
+                    # we don't set an explicit Client here, relying on the default
+                    # env client to be applied by LoadContext.apply_default
+                    root_load_context = LoadContext.empty()
+                    resolver = Resolver()
+                    await resolver.load(typing.cast(_Object, self), root_load_context)
+                else:
+                    logger.debug(f"reloading non-lazy {self} by replacing client")
+                    self._client = client or await _Client.from_env()
                 self._is_rehydrated = True
                 logger.debug(f"rehydrated {self} with client {id(self.client)}")
         elif not self._hydrate_lazily:

{modal-1.2.2.dev38 → modal-1.2.3}/modal/_partial_function.py

@@ -219,7 +219,7 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
         # of the type PartialFunction and this descriptor would be triggered when accessing it,
         #
         # However, modal classes are *actually* Cls instances (which isn't reflected in type checkers
-        # due to Python's lack of type chekcing intersection types), so at runtime the Cls instance would
+        # due to Python's lack of type checking intersection types), so at runtime the Cls instance would
         # use its __getattr__ rather than this descriptor.
         assert self.raw_f is not None  # Should only be relevant in a method context
         k = self.raw_f.__name__

{modal-1.2.2.dev38 → modal-1.2.3}/modal/_utils/async_utils.py

@@ -1,12 +1,14 @@
 # Copyright Modal Labs 2022
 import asyncio
 import concurrent.futures
+import contextlib
 import functools
 import inspect
 import itertools
 import sys
 import time
 import typing
+import warnings
 from collections.abc import AsyncGenerator, AsyncIterable, Awaitable, Iterable, Iterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
@@ -134,7 +136,8 @@ class TaskContext:
     _loops: set[asyncio.Task]
 
     def __init__(self, grace: Optional[float] = None):
-        self._grace = grace
+        self._grace = grace  # grace is the time we want for tasks to finish before cancelling them
+        self._cancellation_grace: float = 1.0  # extra graceperiod for the cancellation itself to "bubble up"
         self._loops = set()
 
     async def start(self):
@@ -166,22 +169,29 @@ class TaskContext:
             # still needs to be handled
             # (https://stackoverflow.com/a/63356323/2475114)
             if gather_future:
-                try:
+                with contextlib.suppress(asyncio.CancelledError):
                     await gather_future
-                except asyncio.CancelledError:
-                    pass
 
+            cancelled_tasks: list[asyncio.Task] = []
             for task in self._tasks:
                 if task.done() and not task.cancelled():
                     # Raise any exceptions if they happened.
                     # Only tasks without a done_callback will still be present in self._tasks
                     task.result()
 
-                if task.done() or task in self._loops:  # Note: Legacy code, we can probably cancel loops.
+                if task.done():
                     continue
 
                 # Cancel any remaining unfinished tasks.
                 task.cancel()
+                cancelled_tasks.append(task)
+
+            cancellation_gather = asyncio.gather(*cancelled_tasks, return_exceptions=True)
+            try:
+                await asyncio.wait_for(cancellation_gather, timeout=self._cancellation_grace)
+            except asyncio.TimeoutError:
+                warnings.warn(f"Internal warning: Tasks did not cancel in a timely manner: {cancelled_tasks}")
+
             await asyncio.sleep(0)  # wake up coroutines waiting for cancellations
 
     async def __aexit__(self, exc_type, value, tb):

{modal-1.2.2.dev38 → modal-1.2.3}/modal/_utils/grpc_utils.py

@@ -9,7 +9,8 @@ import urllib.parse
 import uuid
 from collections.abc import AsyncIterator
 from dataclasses import dataclass, field
-from typing import Any, Optional, TypeVar
+from functools import cache
+from typing import Any, Optional, Sequence, TypeVar
 
 import grpclib.client
 import grpclib.config
@@ -17,14 +18,18 @@ import grpclib.events
 import grpclib.protocol
 import grpclib.stream
 from google.protobuf.message import Message
+from google.protobuf.symbol_database import SymbolDatabase
 from grpclib import GRPCError, Status
+from grpclib.encoding.base import StatusDetailsCodecBase
 from grpclib.exceptions import StreamTerminatedError
 from grpclib.protocol import H2Protocol
 
 from modal.exception import AuthError, ConnectionError
+from modal_proto import api_pb2
 from modal_version import __version__
 
 from .._traceback import suppress_tb_frames
+from ..config import config
 from .async_utils import retry
 from .logger import logger
 
@@ -68,6 +73,7 @@ RETRYABLE_GRPC_STATUS_CODES = [
     Status.INTERNAL,
     Status.UNKNOWN,
 ]
+SERVER_RETRY_WARNING_TIME_INTERVAL = 30.0
 
 
 @dataclass
@@ -107,6 +113,56 @@ class ConnectionManager:
         self._channels.clear()
 
 
+@cache
+def _sym_db() -> SymbolDatabase:
+    from google.protobuf.symbol_database import Default
+
+    return Default()
+
+
+class CustomProtoStatusDetailsCodec(StatusDetailsCodecBase):
+    """grpclib compatible details codec.
+
+    The server can encode the details using `google.rpc.Status` using grpclib's default codec and this custom codec
+    can decode it into a `api_pb2.RPCStatus`.
+    """
+
+    def encode(
+        self,
+        status: Status,
+        message: Optional[str],
+        details: Optional[Sequence[Message]],
+    ) -> bytes:
+        details_proto = api_pb2.RPCStatus(code=status.value, message=message or "")
+        if details is not None:
+            for detail in details:
+                detail_container = details_proto.details.add()
+                detail_container.Pack(detail)
+        return details_proto.SerializeToString()
+
+    def decode(
+        self,
+        status: Status,
+        message: Optional[str],
+        data: bytes,
+    ) -> Any:
+        sym_db = _sym_db()
+        details_proto = api_pb2.RPCStatus.FromString(data)
+
+        details = []
+        for detail_container in details_proto.details:
+            # If we do not know how to decode an emssage, we'll ignore it.
+            with contextlib.suppress(Exception):
+                msg_type = sym_db.GetSymbol(detail_container.TypeName())
+                detail = msg_type()
+                detail_container.Unpack(detail)
+                details.append(detail)
+        return details
+
+
+custom_detail_codec = CustomProtoStatusDetailsCodec()
+
+
 def create_channel(
     server_url: str,
     metadata: dict[str, str] = {},
@@ -125,7 +181,7 @@ def create_channel(
     )
 
     if o.scheme == "unix":
-        channel = grpclib.client.Channel(path=o.path, config=config)  # probably pointless to use a pool ever
+        channel = grpclib.client.Channel(path=o.path, config=config, status_details_codec=custom_detail_codec)
     elif o.scheme in ("http", "https"):
         target = o.netloc
         parts = target.split(":")
@@ -133,7 +189,7 @@ def create_channel(
         ssl = o.scheme.endswith("s")
         host = parts[0]
         port = int(parts[1]) if len(parts) == 2 else 443 if ssl else 80
-        channel = grpclib.client.Channel(host, port, ssl=ssl, config=config)
+        channel = grpclib.client.Channel(host, port, ssl=ssl, config=config, status_details_codec=custom_detail_codec)
     else:
         raise Exception(f"Unknown scheme: {o.scheme}")
 
@@ -197,6 +253,50 @@ async def retry_transient_errors(
     return await _retry_transient_errors(fn, req, retry=Retry(max_retries=max_retries))
 
 
+def get_server_retry_policy(exc: Exception) -> Optional[api_pb2.RPCRetryPolicy]:
+    """Get server retry policy."""
+    if not isinstance(exc, GRPCError) or not exc.details:
+        return None
+
+    # Server should not set multiple retry instructions, but if there is more than one, pick the first one
+    for entry in exc.details:
+        if isinstance(entry, api_pb2.RPCRetryPolicy):
+            return entry
+    return None
+
+
+def process_exception_before_retry(
+    exc: Exception,
+    final_attempt: bool,
+    fn_name: str,
+    n_retries: int,
+    delay: float,
+    idempotency_key: str,
+):
+    """Process exception before retry, used by `_retry_transient_errors`."""
+    with suppress_tb_frames(1):
+        if final_attempt:
+            logger.debug(
+                f"Final attempt failed with {repr(exc)} {n_retries=} {delay=} for {fn_name} ({idempotency_key[:8]})"
+            )
+            if isinstance(exc, OSError):
+                raise ConnectionError(str(exc))
+            elif isinstance(exc, asyncio.TimeoutError):
+                raise ConnectionError(str(exc))
+            else:
+                raise exc
+
+        if isinstance(exc, AttributeError) and "_write_appdata" not in str(exc):
+            # StreamTerminatedError are not properly raised in grpclib<=0.4.7
+            # fixed in https://github.com/vmagamedov/grpclib/issues/185
+            # TODO: update to newer version (>=0.4.8) once stable
+            # Also be sure to remove the AttributeError from the set of exceptions
+            # we handle in the retry logic once we drop this check!
+            raise exc
+
+    logger.debug(f"Retryable failure {repr(exc)} {n_retries=} {delay=} for {fn_name} ({idempotency_key[:8]})")
+
+
 async def _retry_transient_errors(
     fn: typing.Union[
         "modal._grpc_client.UnaryUnaryWrapper[RequestType, ResponseType]",
@@ -219,12 +319,15 @@ async def _retry_transient_errors(
 
     delay = retry.base_delay
     n_retries = 0
+    n_throttled_retries = 0
 
     status_codes = [*RETRYABLE_GRPC_STATUS_CODES, *retry.additional_status_codes]
 
     idempotency_key = str(uuid.uuid4())
 
     t0 = time.time()
+    last_server_retry_warning_time = None
+
     if retry.total_timeout is not None:
         total_deadline = t0 + retry.total_timeout
     else:
@@ -236,29 +339,77 @@ async def _retry_transient_errors(
         attempt_metadata = [
             ("x-idempotency-key", idempotency_key),
             ("x-retry-attempt", str(n_retries)),
+            ("x-throttle-retry-attempt", str(n_throttled_retries)),
             *metadata,
         ]
         if n_retries > 0:
             attempt_metadata.append(("x-retry-delay", str(time.time() - t0)))
+        if n_throttled_retries > 0:
+            attempt_metadata.append(("x-throttle-retry-delay", str(time.time() - t0)))
+
         timeouts = []
         if retry.attempt_timeout is not None:
             timeouts.append(retry.attempt_timeout)
-        if retry.total_timeout is not None and total_deadline is not None:
+        if total_deadline is not None:
             timeouts.append(max(total_deadline - time.time(), retry.attempt_timeout_floor))
         if timeouts:
             timeout = min(timeouts)  # In case the function provided both types of timeouts
         else:
             timeout = None
+
         try:
             with suppress_tb_frames(1):
                 return await fn_callable(req, metadata=attempt_metadata, timeout=timeout)
         except (StreamTerminatedError, GRPCError, OSError, asyncio.TimeoutError, AttributeError) as exc:
+            # Note that we only catch AttributeError to handle a specific case that works around a bug
+            # in grpclib<=0.4.7. See above (search for `write_appdata`).
+
+            # Server side instruction for retries
+            max_throttle_wait: Optional[int] = config.get("max_throttle_wait")
+            if (
+                max_throttle_wait != 0
+                and isinstance(exc, GRPCError)
+                and (server_retry_policy := get_server_retry_policy(exc))
+            ):
+                server_delay = server_retry_policy.retry_after_secs
+
+                now = time.time()
+
+                # We check if the timeout will be reached **after** the sleep, so we can raise an error early
+                # without needing to actually sleep.
+                total_timeout_will_be_reached = (
+                    retry.total_timeout is not None and (now + server_delay - t0) >= retry.total_timeout
+                )
+                max_throttle_will_be_reached = (
+                    max_throttle_wait is not None and (now + server_delay - t0) >= max_throttle_wait
+                )
+                final_attempt = total_timeout_will_be_reached or max_throttle_will_be_reached
+
+                with suppress_tb_frames(1):
+                    process_exception_before_retry(
+                        exc, final_attempt, fn.name, n_retries, server_delay, idempotency_key
+                    )
+
+                now = time.time()
+                if last_server_retry_warning_time is None or (
+                    now - last_server_retry_warning_time >= SERVER_RETRY_WARNING_TIME_INTERVAL
+                ):
+                    last_server_retry_warning_time = now
+                    logger.warning(
+                        f"Warning: Received {exc.status} status: {exc.message}. "
+                        f"Will retry in {server_delay:0.2f} seconds."
+                    )
+
+                n_throttled_retries += 1
+                await asyncio.sleep(server_delay)
+                continue
+
+            # Client handles retry
             if isinstance(exc, GRPCError) and exc.status not in status_codes:
                 if exc.status == Status.UNAUTHENTICATED:
                     raise AuthError(exc.message)
                 else:
                     raise exc
-
             if retry.max_retries is not None and n_retries >= retry.max_retries:
                 final_attempt = True
             elif total_deadline is not None and time.time() + delay + retry.attempt_timeout_floor >= total_deadline:
@@ -267,25 +418,7 @@ async def _retry_transient_errors(
                 final_attempt = False
 
             with suppress_tb_frames(1):
-                if final_attempt:
-                    logger.debug(
-                        f"Final attempt failed with {repr(exc)} {n_retries=} {delay=} "
-                        f"{total_deadline=} for {fn.name} ({idempotency_key[:8]})"
-                    )
-                    if isinstance(exc, OSError):
-                        raise ConnectionError(str(exc))
-                    elif isinstance(exc, asyncio.TimeoutError):
-                        raise ConnectionError(str(exc))
-                    else:
-                        raise exc
-
-                if isinstance(exc, AttributeError) and "_write_appdata" not in str(exc):
-                    # StreamTerminatedError are not properly raised in grpclib<=0.4.7
-                    # fixed in https://github.com/vmagamedov/grpclib/issues/185
-                    # TODO: update to newer version (>=0.4.8) once stable
-                    raise exc
-
-            logger.debug(f"Retryable failure {repr(exc)} {n_retries=} {delay=} for {fn.name} ({idempotency_key[:8]})")
+                process_exception_before_retry(exc, final_attempt, fn.name, n_retries, delay, idempotency_key)
 
             n_retries += 1
 

{modal-1.2.2.dev38 → modal-1.2.3}/modal/app.py

@@ -719,6 +719,7 @@ class _App:
         ] = None,  # Set this to True if it's a non-generator function returning a [sync/async] generator object
         cloud: Optional[str] = None,  # Cloud provider to run the function on. Possible values are aws, gcp, oci, auto.
         region: Optional[Union[str, Sequence[str]]] = None,  # Region or regions to run the function on.
+        nonpreemptible: bool = False,  # Whether to run the function on a nonpreemptible instance.
         enable_memory_snapshot: bool = False,  # Enable memory checkpointing for faster cold starts.
         block_network: bool = False,  # Whether to block network access
         restrict_modal_access: bool = False,  # Whether to allow this function access to other Modal resources
@@ -731,9 +732,6 @@ class _App:
         include_source: Optional[bool] = None,
         experimental_options: Optional[dict[str, Any]] = None,
         # Parameters below here are experimental. Use with caution!
-        _experimental_scheduler_placement: Optional[
-            SchedulerPlacement
-        ] = None,  # Experimental controls over fine-grained scheduling (alpha).
         _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
@@ -743,6 +741,8 @@ class _App:
         container_idle_timeout: Optional[int] = None,  # Replaced with `scaledown_window`
         allow_concurrent_inputs: Optional[int] = None,  # Replaced with the `@modal.concurrent` decorator
         _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):
@@ -762,6 +762,24 @@ class _App:
                 "\n\nSee https://modal.com/docs/guide/modal-1-0-migration for more information.",
             )
 
+        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)]
@@ -771,7 +789,7 @@ class _App:
         def wrapped(
             f: Union[_PartialFunction, Callable[..., Any], None],
         ) -> _Function:
-            nonlocal is_generator, cloud, serialized
+            nonlocal is_generator, cloud, serialized, region, nonpreemptible
 
             # Check if the decorated object is a class
             if inspect.isclass(f):
@@ -860,12 +878,6 @@ class _App:
             if is_generator is None:
                 is_generator = inspect.isgeneratorfunction(raw_f) or inspect.isasyncgenfunction(raw_f)
 
-            scheduler_placement: Optional[SchedulerPlacement] = _experimental_scheduler_placement
-            if region:
-                if scheduler_placement:
-                    raise InvalidError("`region` and `_experimental_scheduler_placement` cannot be used together")
-                scheduler_placement = SchedulerPlacement(region=region)
-
             function = _Function.from_local(
                 info,
                 app=self,
@@ -892,12 +904,13 @@ class _App:
                 timeout=timeout,
                 startup_timeout=startup_timeout or timeout,
                 cloud=cloud,
+                region=region,
+                nonpreemptible=nonpreemptible,
                 webhook_config=webhook_config,
                 enable_memory_snapshot=enable_memory_snapshot,
                 block_network=block_network,
                 restrict_modal_access=restrict_modal_access,
                 max_inputs=max_inputs,
-                scheduler_placement=scheduler_placement,
                 i6pn_enabled=i6pn_enabled,
                 cluster_size=cluster_size,  # Experimental: Clustered functions
                 rdma=rdma,
@@ -950,6 +963,7 @@ class _App:
         startup_timeout: Optional[int] = None,  # Maximum startup time in seconds with higher precedence than `timeout`.
         cloud: Optional[str] = None,  # Cloud provider to run the function on. Possible values are aws, gcp, oci, auto.
         region: Optional[Union[str, Sequence[str]]] = None,  # Region or regions to run the function on.
+        nonpreemptible: bool = False,  # Whether to run the function on a non-preemptible instance.
         enable_memory_snapshot: bool = False,  # Enable memory checkpointing for faster cold starts.
         block_network: bool = False,  # Whether to block network access
         restrict_modal_access: bool = False,  # Whether to allow this class access to other Modal resources
@@ -960,9 +974,6 @@ class _App:
         include_source: Optional[bool] = None,  # When `False`, don't automatically add the App source to the container.
         experimental_options: Optional[dict[str, Any]] = None,
         # Parameters below here are experimental. Use with caution!
-        _experimental_scheduler_placement: Optional[
-            SchedulerPlacement
-        ] = None,  # Experimental controls over fine-grained scheduling (alpha).
         _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
@@ -972,6 +983,8 @@ class _App:
         container_idle_timeout: Optional[int] = None,  # Replaced with `scaledown_window`
         allow_concurrent_inputs: Optional[int] = None,  # Replaced with the `@modal.concurrent` decorator
         _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.
@@ -979,12 +992,6 @@ class _App:
         if _warn_parentheses_missing:
             raise InvalidError("Did you forget parentheses? Suggestion: `@app.cls()`.")
 
-        scheduler_placement = _experimental_scheduler_placement
-        if region:
-            if scheduler_placement:
-                raise InvalidError("`region` and `_experimental_scheduler_placement` cannot be used together")
-            scheduler_placement = SchedulerPlacement(region=region)
-
         if allow_concurrent_inputs is not None:
             deprecation_warning(
                 (2025, 4, 9),
@@ -993,6 +1000,24 @@ class _App:
                 "\n\nSee https://modal.com/docs/guide/modal-1-0-migration for more information.",
             )
 
+        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,11 +1111,12 @@ class _App:
                 timeout=timeout,
                 startup_timeout=startup_timeout or timeout,
                 cloud=cloud,
+                region=region,
+                nonpreemptible=nonpreemptible,
                 enable_memory_snapshot=enable_memory_snapshot,
                 block_network=block_network,
                 restrict_modal_access=restrict_modal_access,
                 max_inputs=max_inputs,
-                scheduler_placement=scheduler_placement,
                 i6pn_enabled=i6pn_enabled,
                 cluster_size=cluster_size,
                 rdma=rdma,