modal 0.67.6__py3-none-any.whl → 0.67.8__py3-none-any.whl

modal/_clustered_functions.py

@@ -2,7 +2,7 @@
 import os
 import socket
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 
 from modal._utils.async_utils import synchronize_api
 from modal._utils.grpc_utils import retry_transient_errors
@@ -14,7 +14,7 @@ from modal_proto import api_pb2
 @dataclass
 class ClusterInfo:
     rank: int
-    container_ips: List[str]
+    container_ips: list[str]
 
 
 cluster_info: Optional[ClusterInfo] = None

modal/_clustered_functions.pyi

@@ -4,9 +4,9 @@ import typing_extensions
 
 class ClusterInfo:
     rank: int
-    container_ips: typing.List[str]
+    container_ips: list[str]
 
-    def __init__(self, rank: int, container_ips: typing.List[str]) -> None: ...
+    def __init__(self, rank: int, container_ips: list[str]) -> None: ...
     def __repr__(self): ...
     def __eq__(self, other): ...
 

modal/_container_entrypoint.py

@@ -19,7 +19,8 @@ import signal
 import sys
 import threading
 import time
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any, Callable, Optional
 
 from google.protobuf.message import Message
 
@@ -175,7 +176,7 @@ class UserCodeEventLoop:
 def call_function(
     user_code_event_loop: UserCodeEventLoop,
     container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
-    finalized_functions: Dict[str, "modal._runtime.user_code_imports.FinalizedFunction"],
+    finalized_functions: dict[str, "modal._runtime.user_code_imports.FinalizedFunction"],
     batch_max_size: int,
     batch_wait_ms: int,
 ):
@@ -473,7 +474,7 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
         # 1. Enable lazy hydration for all objects
         # 2. Fully deprecate .new() objects
         if service.code_deps is not None:  # this is not set for serialized or non-global scope functions
-            dep_object_ids: List[str] = [dep.object_id for dep in function_def.object_dependencies]
+            dep_object_ids: list[str] = [dep.object_id for dep in function_def.object_dependencies]
             if len(service.code_deps) != len(dep_object_ids):
                 raise ExecutionError(
                     f"Function has {len(service.code_deps)} dependencies"
@@ -595,7 +596,7 @@ if __name__ == "__main__":
     # from shutting down. The sleep(0) here is needed for finished ThreadPoolExecutor resources to
     # shut down without triggering this warning (e.g., `@wsgi_app()`).
     time.sleep(0)
-    lingering_threads: List[threading.Thread] = []
+    lingering_threads: list[threading.Thread] = []
     for thread in threading.enumerate():
         current_thread = threading.get_ident()
         if thread.ident is not None and thread.ident != current_thread and not thread.daemon and thread.is_alive():

modal/_output.py

@@ -9,8 +9,9 @@ import platform
 import re
 import socket
 import sys
+from collections.abc import Generator
 from datetime import timedelta
-from typing import Callable, ClassVar, Dict, Generator, Optional, Tuple
+from typing import Callable, ClassVar
 
 from grpclib.exceptions import GRPCError, StreamTerminatedError
 from rich.console import Console, Group, RenderableType
@@ -121,25 +122,25 @@ class LineBufferedOutput(io.StringIO):
 
 
 class OutputManager:
-    _instance: ClassVar[Optional["OutputManager"]] = None
+    _instance: ClassVar[OutputManager | None] = None
 
     _console: Console
-    _task_states: Dict[str, int]
-    _task_progress_items: Dict[Tuple[str, int], TaskID]
-    _current_render_group: Optional[Group]
-    _function_progress: Optional[Progress]
-    _function_queueing_progress: Optional[Progress]
-    _snapshot_progress: Optional[Progress]
-    _line_buffers: Dict[int, LineBufferedOutput]
+    _task_states: dict[str, int]
+    _task_progress_items: dict[tuple[str, int], TaskID]
+    _current_render_group: Group | None
+    _function_progress: Progress | None
+    _function_queueing_progress: Progress | None
+    _snapshot_progress: Progress | None
+    _line_buffers: dict[int, LineBufferedOutput]
     _status_spinner: Spinner
-    _app_page_url: Optional[str]
+    _app_page_url: str | None
     _show_image_logs: bool
-    _status_spinner_live: Optional[Live]
+    _status_spinner_live: Live | None
 
     def __init__(
         self,
         *,
-        stdout: Optional[io.TextIOWrapper] = None,
+        stdout: io.TextIOWrapper | None = None,
         status_spinner_text: str = "Running app...",
     ):
         self._stdout = stdout or sys.stdout
@@ -164,12 +165,12 @@ class OutputManager:
         cls._instance = None
 
     @classmethod
-    def get(cls) -> Optional["OutputManager"]:
+    def get(cls) -> OutputManager | None:
         return cls._instance
 
     @classmethod
     @contextlib.contextmanager
-    def enable_output(cls, show_progress: bool = True) -> Generator[None, None, None]:
+    def enable_output(cls, show_progress: bool = True) -> Generator[None]:
         if show_progress:
             cls._instance = OutputManager()
         try:
@@ -252,7 +253,7 @@ class OutputManager:
                 self._current_render_group.renderables.append(self._function_queueing_progress)
         return self._function_queueing_progress
 
-    def function_progress_callback(self, tag: str, total: Optional[int]) -> Callable[[int, int], None]:
+    def function_progress_callback(self, tag: str, total: int | None) -> Callable[[int, int], None]:
         """Adds a task to the current function_progress instance, and returns a callback
         to update task progress with new completed and total counts."""
 
@@ -330,7 +331,7 @@ class OutputManager:
             pass
 
     def update_queueing_progress(
-        self, *, function_id: str, completed: int, total: Optional[int], description: Optional[str]
+        self, *, function_id: str, completed: int, total: int | None, description: str | None
     ) -> None:
         """Handle queueing updates, ignoring completion updates for functions that have no queue progress bar."""
         task_key = (function_id, api_pb2.FUNCTION_QUEUED)
@@ -449,13 +450,13 @@ class ProgressHandler:
 
     def progress(
         self,
-        task_id: Optional[TaskID] = None,
-        advance: Optional[float] = None,
-        name: Optional[str] = None,
-        size: Optional[float] = None,
-        reset: Optional[bool] = False,
-        complete: Optional[bool] = False,
-    ) -> Optional[TaskID]:
+        task_id: TaskID | None = None,
+        advance: float | None = None,
+        name: str | None = None,
+        size: float | None = None,
+        reset: bool | None = False,
+        complete: bool | None = False,
+    ) -> TaskID | None:
         try:
             if task_id is not None:
                 if reset:
@@ -527,15 +528,15 @@ async def put_pty_content(log: api_pb2.TaskLogs, stdout):
 async def get_app_logs_loop(
     client: _Client,
     output_mgr: OutputManager,
-    app_id: Optional[str] = None,
-    task_id: Optional[str] = None,
-    app_logs_url: Optional[str] = None,
+    app_id: str | None = None,
+    task_id: str | None = None,
+    app_logs_url: str | None = None,
 ):
     last_log_batch_entry_id = ""
 
     pty_shell_stdout = None
-    pty_shell_finish_event: Optional[asyncio.Event] = None
-    pty_shell_task_id: Optional[str] = None
+    pty_shell_finish_event: asyncio.Event | None = None
+    pty_shell_task_id: str | None = None
 
     async def stop_pty_shell():
         nonlocal pty_shell_finish_event

modal/_pty.py

@@ -2,12 +2,12 @@
 import contextlib
 import os
 import sys
-from typing import Optional, Tuple
+from typing import Optional
 
 from modal_proto import api_pb2
 
 
-def get_winsz(fd) -> Tuple[Optional[int], Optional[int]]:
+def get_winsz(fd) -> tuple[Optional[int], Optional[int]]:
     try:
         import fcntl
         import struct

modal/_resolver.py

@@ -3,7 +3,8 @@ import asyncio
 import contextlib
 import typing
 from asyncio import Future
-from typing import TYPE_CHECKING, Dict, Hashable, List, Optional
+from collections.abc import Hashable
+from typing import TYPE_CHECKING, Optional
 
 from grpclib import GRPCError, Status
 
@@ -40,10 +41,10 @@ class StatusRow:
 
 
 class Resolver:
-    _local_uuid_to_future: Dict[str, Future]
+    _local_uuid_to_future: dict[str, Future]
     _environment_name: Optional[str]
     _app_id: Optional[str]
-    _deduplication_cache: Dict[Hashable, Future]
+    _deduplication_cache: dict[Hashable, Future]
     _client: _Client
 
     def __init__(
@@ -153,8 +154,8 @@ class Resolver:
         # TODO(elias): print original exception/trace rather than the Resolver-internal trace
         return await cached_future
 
-    def objects(self) -> List["_Object"]:
-        unique_objects: Dict[str, "_Object"] = {}
+    def objects(self) -> list["_Object"]:
+        unique_objects: dict[str, "_Object"] = {}
         for fut in self._local_uuid_to_future.values():
             if not fut.done():
                 # this will raise an exception if not all loads have been awaited, but that *should* never happen

modal/_resources.py

@@ -1,5 +1,5 @@
 # Copyright Modal Labs 2024
-from typing import Optional, Tuple, Union
+from typing import Optional, Union
 
 from modal_proto import api_pb2
 
@@ -9,8 +9,8 @@ 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]]],
+    cpu: Optional[Union[float, tuple[float, float]]],
+    memory: Optional[Union[int, tuple[int, int]]],
     gpu: GPU_T,
     ephemeral_disk: Optional[int],
 ) -> api_pb2.Resources:

modal/_runtime/asgi.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2022
 import asyncio
-from typing import Any, AsyncGenerator, Callable, Dict, NoReturn, Optional, Tuple, cast
+from collections.abc import AsyncGenerator
+from typing import Any, Callable, NoReturn, Optional, cast
 
 import aiohttp
 
@@ -80,8 +81,8 @@ class LifespanManager:
         await self.shutdown
 
 
-def asgi_app_wrapper(asgi_app, container_io_manager) -> Tuple[Callable[..., AsyncGenerator], LifespanManager]:
-    state: Dict[str, Any] = {}  # used for lifespan state
+def asgi_app_wrapper(asgi_app, container_io_manager) -> tuple[Callable[..., AsyncGenerator], LifespanManager]:
+    state: dict[str, Any] = {}  # used for lifespan state
 
     async def fn(scope):
         if "state" in scope:
@@ -92,8 +93,8 @@ def asgi_app_wrapper(asgi_app, container_io_manager) -> Tuple[Callable[..., Asyn
         function_call_id = current_function_call_id()
         assert function_call_id, "internal error: function_call_id not set in asgi_app() scope"
 
-        messages_from_app: asyncio.Queue[Dict[str, Any]] = asyncio.Queue(1)
-        messages_to_app: asyncio.Queue[Dict[str, Any]] = asyncio.Queue(1)
+        messages_from_app: asyncio.Queue[dict[str, Any]] = asyncio.Queue(1)
+        messages_to_app: asyncio.Queue[dict[str, Any]] = asyncio.Queue(1)
 
         async def disconnect_app():
             if scope["type"] == "http":
@@ -415,7 +416,7 @@ async def _proxy_websocket_request(session: aiohttp.ClientSession, scope, receiv
                     raise ExecutionError(f"Unexpected message type: {client_message['type']}")
 
         async def upstream_to_client():
-            msg: Dict[str, Any] = {
+            msg: dict[str, Any] = {
                 "type": "websocket.accept",
                 "subprotocol": upstream_ws.protocol,
             }

modal/_runtime/container_io_manager.py

@@ -9,19 +9,15 @@ import signal
 import sys
 import time
 import traceback
+from collections.abc import AsyncGenerator, AsyncIterator
 from contextlib import AsyncExitStack
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncGenerator,
-    AsyncIterator,
     Callable,
     ClassVar,
-    Dict,
-    List,
     Optional,
-    Tuple,
 )
 
 from google.protobuf.empty_pb2 import Empty
@@ -68,8 +64,8 @@ class IOContext:
     in a batched or single input context.
     """
 
-    input_ids: List[str]
-    function_call_ids: List[str]
+    input_ids: list[str]
+    function_call_ids: list[str]
     finalized_function: "modal._runtime.user_code_imports.FinalizedFunction"
 
     _cancel_issued: bool = False
@@ -77,10 +73,10 @@ class IOContext:
 
     def __init__(
         self,
-        input_ids: List[str],
-        function_call_ids: List[str],
+        input_ids: list[str],
+        function_call_ids: list[str],
         finalized_function: "modal._runtime.user_code_imports.FinalizedFunction",
-        function_inputs: List[api_pb2.FunctionInput],
+        function_inputs: list[api_pb2.FunctionInput],
         is_batched: bool,
         client: _Client,
     ):
@@ -95,8 +91,8 @@ class IOContext:
     async def create(
         cls,
         client: _Client,
-        finalized_functions: Dict[str, "modal._runtime.user_code_imports.FinalizedFunction"],
-        inputs: List[Tuple[str, str, api_pb2.FunctionInput]],
+        finalized_functions: dict[str, "modal._runtime.user_code_imports.FinalizedFunction"],
+        inputs: list[tuple[str, str, api_pb2.FunctionInput]],
         is_batched: bool,
     ) -> "IOContext":
         assert len(inputs) >= 1 if is_batched else len(inputs) == 1
@@ -136,7 +132,7 @@ class IOContext:
             #  between creating a new task for an input and attaching the cancellation callback
             logger.warning("Unexpected: Could not cancel input")
 
-    def _args_and_kwargs(self) -> Tuple[Tuple[Any, ...], Dict[str, List[Any]]]:
+    def _args_and_kwargs(self) -> tuple[tuple[Any, ...], dict[str, list[Any]]]:
         # deserializing here instead of the constructor
         # to make sure we handle user exceptions properly
         # and don't retry
@@ -153,7 +149,7 @@ class IOContext:
             param_names.append(param.name)
 
         # aggregate args and kwargs of all inputs into a kwarg dict
-        kwargs_by_inputs: List[Dict[str, Any]] = [{} for _ in range(len(self.input_ids))]
+        kwargs_by_inputs: list[dict[str, Any]] = [{} for _ in range(len(self.input_ids))]
 
         for i, (args, kwargs) in enumerate(deserialized_args):
             # check that all batched inputs should have the same number of args and kwargs
@@ -187,7 +183,7 @@ class IOContext:
         logger.debug(f"Finished input {self.input_ids}")
         return res
 
-    def validate_output_data(self, data: Any) -> List[Any]:
+    def validate_output_data(self, data: Any) -> list[Any]:
         if not self._is_batched:
             return [data]
 
@@ -263,7 +259,7 @@ class _ContainerIOManager:
     calls_completed: int
     total_user_time: float
     current_input_id: Optional[str]
-    current_inputs: Dict[str, IOContext]  # input_id -> IOContext
+    current_inputs: dict[str, IOContext]  # input_id -> IOContext
     current_input_started_at: Optional[float]
 
     _target_concurrency: int
@@ -472,7 +468,7 @@ class _ContainerIOManager:
             client=self._client,
         )
 
-    async def get_serialized_function(self) -> Tuple[Optional[Any], Optional[Callable[..., Any]]]:
+    async def get_serialized_function(self) -> tuple[Optional[Any], Optional[Callable[..., Any]]]:
         # Fetch the serialized function definition
         request = api_pb2.FunctionGetSerializedRequest(function_id=self.function_id)
         response = await self._client.stub.FunctionGetSerialized(request)
@@ -498,7 +494,7 @@ class _ContainerIOManager:
     def serialize_data_format(self, obj: Any, data_format: int) -> bytes:
         return serialize_data_format(obj, data_format)
 
-    async def format_blob_data(self, data: bytes) -> Dict[str, Any]:
+    async def format_blob_data(self, data: bytes) -> dict[str, Any]:
         return (
             {"data_blob_id": await blob_upload(data, self._client.stub)}
             if len(data) > MAX_OBJECT_SIZE_BYTES
@@ -515,7 +511,7 @@ class _ContainerIOManager:
         function_call_id: str,
         start_index: int,
         data_format: int,
-        messages_bytes: List[Any],
+        messages_bytes: list[Any],
     ) -> None:
         """Put data onto the `data_out` stream of a function call.
 
@@ -523,7 +519,7 @@ class _ContainerIOManager:
         was introduced as a performance optimization in client version 0.57, so older clients will
         still use the previous Postgres-backed system based on `FunctionPutOutputs()`.
         """
-        data_chunks: List[api_pb2.DataChunk] = []
+        data_chunks: list[api_pb2.DataChunk] = []
         for i, message_bytes in enumerate(messages_bytes):
             chunk = api_pb2.DataChunk(data_format=data_format, index=start_index + i)  # type: ignore
             if len(message_bytes) > MAX_OBJECT_SIZE_BYTES:
@@ -588,7 +584,7 @@ class _ContainerIOManager:
         self,
         batch_max_size: int,
         batch_wait_ms: int,
-    ) -> AsyncIterator[List[Tuple[str, str, api_pb2.FunctionInput]]]:
+    ) -> AsyncIterator[list[tuple[str, str, api_pb2.FunctionInput]]]:
         request = api_pb2.FunctionGetInputsRequest(function_id=self.function_id)
         iteration = 0
         while self._fetching_inputs:
@@ -645,7 +641,7 @@ class _ContainerIOManager:
     @synchronizer.no_io_translation
     async def run_inputs_outputs(
         self,
-        finalized_functions: Dict[str, "modal._runtime.user_code_imports.FinalizedFunction"],
+        finalized_functions: dict[str, "modal._runtime.user_code_imports.FinalizedFunction"],
         batch_max_size: int = 0,
         batch_wait_ms: int = 0,
     ) -> AsyncIterator[IOContext]:
@@ -675,7 +671,7 @@ class _ContainerIOManager:
         io_context: IOContext,
         started_at: float,
         data_format: "modal_proto.api_pb2.DataFormat.ValueType",
-        results: List[api_pb2.GenericResult],
+        results: list[api_pb2.GenericResult],
     ) -> None:
         output_created_at = time.time()
         outputs = [
@@ -704,7 +700,7 @@ class _ContainerIOManager:
             logger.info(err)
             return self.serialize(SerializationError(err))
 
-    def serialize_traceback(self, exc: BaseException) -> Tuple[Optional[bytes], Optional[bytes]]:
+    def serialize_traceback(self, exc: BaseException) -> tuple[Optional[bytes], Optional[bytes]]:
         serialized_tb, tb_line_cache = None, None
 
         try:
@@ -831,7 +827,7 @@ class _ContainerIOManager:
             )
             self.exit_context(started_at, io_context.input_ids)
 
-    def exit_context(self, started_at, input_ids: List[str]):
+    def exit_context(self, started_at, input_ids: list[str]):
         self.total_user_time += time.time() - started_at
         self.calls_completed += 1
 
@@ -934,7 +930,7 @@ class _ContainerIOManager:
             self._waiting_for_memory_snapshot = False
             self.heartbeat_condition.notify_all()
 
-    async def volume_commit(self, volume_ids: List[str]) -> None:
+    async def volume_commit(self, volume_ids: list[str]) -> None:
         """
         Perform volume commit for given `volume_ids`.
         Only used on container exit to persist uncommitted changes on behalf of user.

modal/_runtime/execution_context.py

@@ -1,6 +1,6 @@
 # Copyright Modal Labs 2024
 from contextvars import ContextVar
-from typing import Callable, List, Optional
+from typing import Callable, Optional
 
 from modal._utils.async_utils import synchronize_api
 from modal.exception import InvalidError
@@ -71,7 +71,7 @@ def current_function_call_id() -> Optional[str]:
         return None
 
 
-def _set_current_context_ids(input_ids: List[str], function_call_ids: List[str]) -> Callable[[], None]:
+def _set_current_context_ids(input_ids: list[str], function_call_ids: list[str]) -> Callable[[], None]:
     assert len(input_ids) == len(function_call_ids) and len(input_ids) > 0
     input_id = input_ids[0]
     function_call_id = function_call_ids[0]

modal/_runtime/telemetry.py

@@ -7,7 +7,6 @@ import socket
 import sys
 import threading
 import time
-import typing
 import uuid
 from importlib.util import find_spec, module_from_spec
 from struct import pack
@@ -65,7 +64,7 @@ class InterceptedModuleLoader(importlib.abc.Loader):
 
 
 class ImportInterceptor(importlib.abc.MetaPathFinder):
-    loading: typing.Dict[str, typing.Tuple[str, float]]
+    loading: dict[str, tuple[str, float]]
     tracing_socket: socket.socket
     events: queue.Queue
 

modal/_runtime/user_code_imports.py

@@ -3,7 +3,7 @@ import importlib
 import typing
 from abc import ABCMeta, abstractmethod
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Optional
 
 import modal._runtime.container_io_manager
 import modal.cls
@@ -49,12 +49,12 @@ class Service(metaclass=ABCMeta):
 
     user_cls_instance: Any
     app: Optional["modal.app._App"]
-    code_deps: Optional[List["modal.object._Object"]]
+    code_deps: Optional[list["modal.object._Object"]]
 
     @abstractmethod
     def get_finalized_functions(
         self, fun_def: api_pb2.Function, container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"
-    ) -> Dict[str, "FinalizedFunction"]:
+    ) -> dict[str, "FinalizedFunction"]:
         ...
 
 
@@ -99,13 +99,13 @@ def construct_webhook_callable(
 class ImportedFunction(Service):
     user_cls_instance: Any
     app: Optional["modal.app._App"]
-    code_deps: Optional[List["modal.object._Object"]]
+    code_deps: Optional[list["modal.object._Object"]]
 
     _user_defined_callable: Callable[..., Any]
 
     def get_finalized_functions(
         self, fun_def: api_pb2.Function, container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"
-    ) -> Dict[str, "FinalizedFunction"]:
+    ) -> dict[str, "FinalizedFunction"]:
         # Check this property before we turn it into a method (overriden by webhooks)
         is_async = get_is_async(self._user_defined_callable)
         # Use the function definition for whether this is a generator (overriden by webhooks)
@@ -142,13 +142,13 @@ class ImportedFunction(Service):
 class ImportedClass(Service):
     user_cls_instance: Any
     app: Optional["modal.app._App"]
-    code_deps: Optional[List["modal.object._Object"]]
+    code_deps: Optional[list["modal.object._Object"]]
 
-    _partial_functions: Dict[str, "modal.partial_function._PartialFunction"]
+    _partial_functions: dict[str, "modal.partial_function._PartialFunction"]
 
     def get_finalized_functions(
         self, fun_def: api_pb2.Function, container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"
-    ) -> Dict[str, "FinalizedFunction"]:
+    ) -> dict[str, "FinalizedFunction"]:
         finalized_functions = {}
         for method_name, partial in self._partial_functions.items():
             partial = synchronizer._translate_in(partial)  # ugly
@@ -184,9 +184,7 @@ class ImportedClass(Service):
         return finalized_functions
 
 
-def get_user_class_instance(
-    cls: typing.Union[type, modal.cls.Cls], args: typing.Tuple, kwargs: Dict[str, Any]
-) -> typing.Any:
+def get_user_class_instance(cls: typing.Union[type, modal.cls.Cls], args: tuple, kwargs: dict[str, Any]) -> typing.Any:
     """Returns instance of the underlying class to be used as the `self`
 
     The input `cls` can either be the raw Python class the user has declared ("user class"),
@@ -236,7 +234,7 @@ def import_single_function_service(
     """
     user_defined_callable: Callable
     function: Optional[_Function] = None
-    code_deps: Optional[List["modal.object._Object"]] = None
+    code_deps: Optional[list["modal.object._Object"]] = None
     active_app: Optional[modal.app._App] = None
 
     if ser_fun is not None:
@@ -311,7 +309,7 @@ def import_class_service(
     See import_function.
     """
     active_app: Optional["modal.app._App"]
-    code_deps: Optional[List["modal.object._Object"]]
+    code_deps: Optional[list["modal.object._Object"]]
     cls: typing.Union[type, modal.cls.Cls]
 
     if function_def.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED:

modal/_serialization.py

@@ -398,10 +398,8 @@ PARAM_TYPE_MAPPING = {
 }
 
 
-def serialize_proto_params(
-    python_params: typing.Dict[str, Any], schema: typing.Sequence[api_pb2.ClassParameterSpec]
-) -> bytes:
-    proto_params: typing.List[api_pb2.ClassParameterValue] = []
+def serialize_proto_params(python_params: dict[str, Any], schema: typing.Sequence[api_pb2.ClassParameterSpec]) -> bytes:
+    proto_params: list[api_pb2.ClassParameterValue] = []
     for schema_param in schema:
         type_info = PARAM_TYPE_MAPPING.get(schema_param.type)
         if not type_info:
@@ -426,9 +424,7 @@ def serialize_proto_params(
     return proto_bytes
 
 
-def deserialize_proto_params(
-    serialized_params: bytes, schema: typing.List[api_pb2.ClassParameterSpec]
-) -> typing.Dict[str, Any]:
+def deserialize_proto_params(serialized_params: bytes, schema: list[api_pb2.ClassParameterSpec]) -> dict[str, Any]:
     proto_struct = api_pb2.ClassParameterSet()
     proto_struct.ParseFromString(serialized_params)
     value_by_name = {p.name: p for p in proto_struct.parameters}

modal/_traceback.py

@@ -8,15 +8,15 @@ import re
 import sys
 import traceback
 from types import TracebackType
-from typing import Any, Dict, Optional, Tuple, Type
+from typing import Any, Optional
 
 from ._vendor.tblib import Traceback as TBLibTraceback
 
-TBDictType = Dict[str, Any]
-LineCacheType = Dict[Tuple[str, str], str]
+TBDictType = dict[str, Any]
+LineCacheType = dict[tuple[str, str], str]
 
 
-def extract_traceback(exc: BaseException, task_id: str) -> Tuple[TBDictType, LineCacheType]:
+def extract_traceback(exc: BaseException, task_id: str) -> tuple[TBDictType, LineCacheType]:
     """Given an exception, extract a serializable traceback (with task ID markers included),
     and a line cache that maps (filename, lineno) to line contents. The latter is used to show
     a helpful traceback to the user, even if they don't have packages installed locally that
@@ -103,7 +103,7 @@ def traceback_contains_remote_call(tb: Optional[TracebackType]) -> bool:
     return False
 
 
-def print_exception(exc: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[TracebackType]):
+def print_exception(exc: Optional[type[BaseException]], value: Optional[BaseException], tb: Optional[TracebackType]):
     """Add backwards compatibility for printing exceptions with "notes" for Python<3.11."""
     traceback.print_exception(exc, value, tb)
     if sys.version_info < (3, 11) and value is not None: