modAL 1.2.3__tar.gz → 1.2.3.dev0__tar.gz

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

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

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

@@ -90,6 +90,7 @@ 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
 
@@ -536,7 +537,6 @@ 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[api_pb2.SchedulerPlacement]
+    scheduler_placement: Optional[SchedulerPlacement]
     proxy: Optional[_Proxy]
 
 
@@ -683,8 +683,7 @@ 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,
-        region: Optional[Union[str, Sequence[str]]] = None,
-        nonpreemptible: bool = False,
+        scheduler_placement: Optional[SchedulerPlacement] = None,
         is_builder_function: bool = False,
         is_auto_snapshot: bool = False,
         enable_memory_snapshot: bool = False,
@@ -747,11 +746,6 @@ 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,
@@ -1024,7 +1018,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,
+                    scheduler_placement=scheduler_placement.proto if scheduler_placement else None,
                     is_class=info.is_service_class(),
                     class_parameter_info=info.class_parameter_info(),
                     i6pn_enabled=i6pn_enabled,

{modal-1.2.3 → modal-1.2.3.dev0}/modal/_load_context.py

@@ -66,9 +66,8 @@ 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=self.client if is_valid_client else await _Client.from_env(),
+            client=await _Client.from_env() if self._client is None else self.client,
             environment_name=self._environment_name or config.get("environment") or "",
             app_id=self._app_id,
         )

{modal-1.2.3 → modal-1.2.3.dev0}/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]]] = None
+    _load: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]]
     _preload: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]]
     _rep: str
     _is_another_app: bool
@@ -308,17 +308,11 @@ class _Object:
                 # memory snapshots capture references which must be rehydrated
                 # on restore to handle staleness.
                 logger.debug(f"rehydrating {self} after snapshot")
-                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_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)
                 self._is_rehydrated = True
                 logger.debug(f"rehydrated {self} with client {id(self.client)}")
         elif not self._hydrate_lazily:

{modal-1.2.3 → modal-1.2.3.dev0}/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 checking intersection types), so at runtime the Cls instance would
+        # due to Python's lack of type chekcing 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.3 → modal-1.2.3.dev0}/modal/_utils/async_utils.py

@@ -1,14 +1,12 @@
 # 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
@@ -136,8 +134,7 @@ class TaskContext:
     _loops: set[asyncio.Task]
 
     def __init__(self, grace: Optional[float] = None):
-        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._grace = grace
         self._loops = set()
 
     async def start(self):
@@ -169,29 +166,22 @@ class TaskContext:
             # still needs to be handled
             # (https://stackoverflow.com/a/63356323/2475114)
             if gather_future:
-                with contextlib.suppress(asyncio.CancelledError):
+                try:
                     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():
+                if task.done() or task in self._loops:  # Note: Legacy code, we can probably cancel loops.
                     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.3 → modal-1.2.3.dev0}/modal/_utils/grpc_utils.py

@@ -9,8 +9,7 @@ import urllib.parse
 import uuid
 from collections.abc import AsyncIterator
 from dataclasses import dataclass, field
-from functools import cache
-from typing import Any, Optional, Sequence, TypeVar
+from typing import Any, Optional, TypeVar
 
 import grpclib.client
 import grpclib.config
@@ -18,18 +17,14 @@ 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
 
@@ -73,7 +68,6 @@ RETRYABLE_GRPC_STATUS_CODES = [
     Status.INTERNAL,
     Status.UNKNOWN,
 ]
-SERVER_RETRY_WARNING_TIME_INTERVAL = 30.0
 
 
 @dataclass
@@ -113,56 +107,6 @@ 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] = {},
@@ -181,7 +125,7 @@ def create_channel(
     )
 
     if o.scheme == "unix":
-        channel = grpclib.client.Channel(path=o.path, config=config, status_details_codec=custom_detail_codec)
+        channel = grpclib.client.Channel(path=o.path, config=config)  # probably pointless to use a pool ever
     elif o.scheme in ("http", "https"):
         target = o.netloc
         parts = target.split(":")
@@ -189,7 +133,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, status_details_codec=custom_detail_codec)
+        channel = grpclib.client.Channel(host, port, ssl=ssl, config=config)
     else:
         raise Exception(f"Unknown scheme: {o.scheme}")
 
@@ -253,50 +197,6 @@ 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]",
@@ -319,15 +219,12 @@ 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:
@@ -339,77 +236,29 @@ 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 total_deadline is not None:
+        if retry.total_timeout is not None and 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:
@@ -418,7 +267,25 @@ async def _retry_transient_errors(
                 final_attempt = False
 
             with suppress_tb_frames(1):
-                process_exception_before_retry(exc, final_attempt, fn.name, n_retries, delay, idempotency_key)
+                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]})")
 
             n_retries += 1
 

{modal-1.2.3 → modal-1.2.3.dev0}/modal/app.py

@@ -719,7 +719,6 @@ 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
@@ -732,6 +731,9 @@ 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
@@ -741,8 +743,6 @@ 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,24 +762,6 @@ 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)]
@@ -789,7 +771,7 @@ class _App:
         def wrapped(
             f: Union[_PartialFunction, Callable[..., Any], None],
         ) -> _Function:
-            nonlocal is_generator, cloud, serialized, region, nonpreemptible
+            nonlocal is_generator, cloud, serialized
 
             # Check if the decorated object is a class
             if inspect.isclass(f):
@@ -878,6 +860,12 @@ 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,
@@ -904,13 +892,12 @@ 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,
@@ -963,7 +950,6 @@ 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
@@ -974,6 +960,9 @@ 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
@@ -983,8 +972,6 @@ 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.
@@ -992,6 +979,12 @@ 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),
@@ -1000,24 +993,6 @@ 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)]
@@ -1111,12 +1086,11 @@ 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,