modal 0.67.1__py3-none-any.whl → 0.67.33__py3-none-any.whl

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:

modal/_tunnel.py

@@ -1,8 +1,9 @@
 # Copyright Modal Labs 2023
 """Client for Modal relay servers, allowing users to expose TLS."""
 
+from collections.abc import AsyncIterator
 from dataclasses import dataclass
-from typing import AsyncIterator, Optional, Tuple
+from typing import Optional
 
 from grpclib import GRPCError, Status
 from synchronicity.async_wrap import asynccontextmanager
@@ -35,12 +36,12 @@ class Tunnel:
         return value
 
     @property
-    def tls_socket(self) -> Tuple[str, int]:
+    def tls_socket(self) -> tuple[str, int]:
         """Get the public TLS socket as a (host, port) tuple."""
         return (self.host, self.port)
 
     @property
-    def tcp_socket(self) -> Tuple[str, int]:
+    def tcp_socket(self) -> tuple[str, int]:
         """Get the public TCP socket as a (host, port) tuple."""
         if not self.unencrypted_host:
             raise InvalidError(
@@ -61,7 +62,7 @@ async def _forward(port: int, *, unencrypted: bool = False, client: Optional[_Cl
 
     **Usage:**
 
-    ```python
+    ```python notest
     import modal
     from flask import Flask
 

modal/_tunnel.pyi

@@ -12,9 +12,9 @@ class Tunnel:
     @property
     def url(self) -> str: ...
     @property
-    def tls_socket(self) -> typing.Tuple[str, int]: ...
+    def tls_socket(self) -> tuple[str, int]: ...
     @property
-    def tcp_socket(self) -> typing.Tuple[str, int]: ...
+    def tcp_socket(self) -> tuple[str, int]: ...
     def __init__(self, host: str, port: int, unencrypted_host: str, unencrypted_port: int) -> None: ...
     def __repr__(self): ...
     def __eq__(self, other): ...

modal/_utils/async_utils.py

@@ -6,19 +6,13 @@ import inspect
 import itertools
 import time
 import typing
+from collections.abc import AsyncGenerator, AsyncIterable, Awaitable, Iterable, Iterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from typing import (
     Any,
-    AsyncGenerator,
-    Awaitable,
     Callable,
-    Iterable,
-    Iterator,
-    List,
     Optional,
-    Set,
-    Tuple,
     TypeVar,
     Union,
     cast,
@@ -118,7 +112,7 @@ class TaskContext:
     ```
     """
 
-    _loops: Set[asyncio.Task]
+    _loops: set[asyncio.Task]
 
     def __init__(self, grace: Optional[float] = None):
         self._grace = grace
@@ -272,7 +266,7 @@ async def queue_batch_iterator(q: asyncio.Queue, max_batch_size=100, debounce_ti
 
     Treats a None value as end of queue items
     """
-    item_list: List[Any] = []
+    item_list: list[Any] = []
 
     while True:
         if q.empty() and len(item_list) > 0:
@@ -387,8 +381,7 @@ class AsyncOrSyncIterable:
     def __iter__(self):
         try:
             with Runner() as runner:
-                for output in run_async_gen(runner, self._async_iterable):
-                    yield output  # type: ignore
+                yield from run_async_gen(runner, self._async_iterable)
         except NestedEventLoops:
             raise InvalidError(self.nested_async_message)
 
@@ -491,14 +484,17 @@ class aclosing(typing.Generic[T]):  # noqa
         await self.agen.aclose()
 
 
-async def sync_or_async_iter(iter: Union[Iterable[T], AsyncGenerator[T, None]]) -> AsyncGenerator[T, None]:
+async def sync_or_async_iter(iter: Union[Iterable[T], AsyncIterable[T]]) -> AsyncGenerator[T, None]:
     if hasattr(iter, "__aiter__"):
         agen = typing.cast(AsyncGenerator[T, None], iter)
         try:
             async for item in agen:
                 yield item
         finally:
-            await agen.aclose()
+            if hasattr(agen, "aclose"):
+                # All AsyncGenerator's have an aclose method
+                # but some AsyncIterable's don't necessarily
+                await agen.aclose()
     else:
         assert hasattr(iter, "__iter__"), "sync_or_async_iter requires an Iterable or AsyncGenerator"
         # This intentionally could block the event loop for the duration of calling __iter__ and __next__,
@@ -509,12 +505,12 @@ async def sync_or_async_iter(iter: Union[Iterable[T], AsyncGenerator[T, None]])
 
 
 @typing.overload
-def async_zip(g1: AsyncGenerator[T, None], g2: AsyncGenerator[V, None], /) -> AsyncGenerator[Tuple[T, V], None]:
+def async_zip(g1: AsyncGenerator[T, None], g2: AsyncGenerator[V, None], /) -> AsyncGenerator[tuple[T, V], None]:
     ...
 
 
 @typing.overload
-def async_zip(*generators: AsyncGenerator[T, None]) -> AsyncGenerator[Tuple[T, ...], None]:
+def async_zip(*generators: AsyncGenerator[T, None]) -> AsyncGenerator[tuple[T, ...], None]:
     ...
 
 
@@ -573,6 +569,46 @@ STOP_SENTINEL = StopSentinelType()
 
 
 async def async_merge(*generators: AsyncGenerator[T, None]) -> AsyncGenerator[T, None]:
+    """
+    Asynchronously merges multiple async generators into a single async generator.
+
+    This function takes multiple async generators and yields their values in the order
+    they are produced. If any generator raises an exception, the exception is propagated.
+
+    Args:
+        *generators: One or more async generators to be merged.
+
+    Yields:
+        The values produced by the input async generators.
+
+    Raises:
+        Exception: If any of the input generators raises an exception, it is propagated.
+
+    Usage:
+    ```python
+    import asyncio
+    from modal._utils.async_utils import async_merge
+
+    async def gen1():
+        yield 1
+        yield 2
+
+    async def gen2():
+        yield "a"
+        yield "b"
+
+    async def example():
+        values = set()
+        async for value in async_merge(gen1(), gen2()):
+            values.add(value)
+
+        return values
+
+    # Output could be: {1, "a", 2, "b"} (order may vary)
+    values = asyncio.run(example())
+    assert values == {1, "a", 2, "b"}
+    ```
+    """
     queue: asyncio.Queue[Union[ValueWrapper[T], ExceptionWrapper]] = asyncio.Queue(maxsize=len(generators) * 10)
 
     async def producer(generator: AsyncGenerator[T, None]):
@@ -582,7 +618,7 @@ async def async_merge(*generators: AsyncGenerator[T, None]) -> AsyncGenerator[T,
         except Exception as e:
             await queue.put(ExceptionWrapper(e))
 
-    tasks = set([asyncio.create_task(producer(gen)) for gen in generators])
+    tasks = {asyncio.create_task(producer(gen)) for gen in generators}
     new_output_task = asyncio.create_task(queue.get())
 
     try:
@@ -689,7 +725,7 @@ async def async_map_ordered(
 ) -> AsyncGenerator[V, None]:
     semaphore = asyncio.Semaphore(buffer_size or concurrency)
 
-    async def mapper_func_wrapper(tup: Tuple[int, T]) -> Tuple[int, V]:
+    async def mapper_func_wrapper(tup: tuple[int, T]) -> tuple[int, V]:
         return (tup[0], await async_mapper_func(tup[1]))
 
     async def counter() -> AsyncGenerator[int, None]:

modal/_utils/blob_utils.py

@@ -5,9 +5,11 @@ import hashlib
 import io
 import os
 import platform
+import time
+from collections.abc import AsyncIterator
 from contextlib import AbstractContextManager, contextmanager
 from pathlib import Path, PurePosixPath
-from typing import Any, AsyncIterator, BinaryIO, Callable, List, Optional, Union
+from typing import Any, BinaryIO, Callable, Optional, Union
 from urllib.parse import urlparse
 
 from aiohttp import BytesIOPayload
@@ -173,7 +175,7 @@ async def perform_multipart_upload(
     *,
     content_length: int,
     max_part_size: int,
-    part_urls: List[str],
+    part_urls: list[str],
     completion_url: str,
     upload_chunk_size: int = DEFAULT_SEGMENT_CHUNK_SIZE,
     progress_report_cb: Optional[Callable] = None,
@@ -184,7 +186,7 @@ async def perform_multipart_upload(
 
     # Give each part its own IO reader object to avoid needing to
     # lock access to the reader's position pointer.
-    data_file_readers: List[BinaryIO]
+    data_file_readers: list[BinaryIO]
     if isinstance(data_file, io.BytesIO):
         view = data_file.getbuffer()  # does not copy data
         data_file_readers = [io.BytesIO(view) for _ in range(len(part_urls))]
@@ -288,11 +290,18 @@ async def _blob_upload(
 
 
 async def blob_upload(payload: bytes, stub: ModalClientModal) -> str:
+    size_mib = len(payload) / 1024 / 1024
+    logger.debug(f"Uploading large blob of size {size_mib:.2f} MiB")
+    t0 = time.time()
     if isinstance(payload, str):
         logger.warning("Blob uploading string, not bytes - auto-encoding as utf8")
         payload = payload.encode("utf8")
     upload_hashes = get_upload_hashes(payload)
-    return await _blob_upload(upload_hashes, payload, stub)
+    blob_id = await _blob_upload(upload_hashes, payload, stub)
+    dur_s = max(time.time() - t0, 0.001)  # avoid division by zero
+    throughput_mib_s = (size_mib) / dur_s
+    logger.debug(f"Uploaded large blob of size {size_mib:.2f} MiB ({throughput_mib_s:.2f} MiB/s)." f" {blob_id}")
+    return blob_id
 
 
 async def blob_upload_file(
@@ -317,11 +326,17 @@ async def _download_from_url(download_url: str) -> bytes:
 
 
 async def blob_download(blob_id: str, stub: ModalClientModal) -> bytes:
-    # convenience function reading all of the downloaded file into memory
+    """Convenience function for reading all of the downloaded file into memory."""
+    logger.debug(f"Downloading large blob {blob_id}")
+    t0 = time.time()
     req = api_pb2.BlobGetRequest(blob_id=blob_id)
     resp = await retry_transient_errors(stub.BlobGet, req)
-
-    return await _download_from_url(resp.download_url)
+    data = await _download_from_url(resp.download_url)
+    size_mib = len(data) / 1024 / 1024
+    dur_s = max(time.time() - t0, 0.001)  # avoid division by zero
+    throughput_mib_s = size_mib / dur_s
+    logger.debug(f"Downloaded large blob {blob_id} of size {size_mib:.2f} MiB ({throughput_mib_s:.2f} MiB/s)")
+    return data
 
 
 async def blob_iter(blob_id: str, stub: ModalClientModal) -> AsyncIterator[bytes]:

modal/_utils/function_utils.py

@@ -2,9 +2,10 @@
 import asyncio
 import inspect
 import os
+from collections.abc import AsyncGenerator
 from enum import Enum
 from pathlib import Path, PurePosixPath
-from typing import Any, AsyncGenerator, Callable, Dict, List, Literal, Optional, Tuple, Type
+from typing import Any, Callable, Literal, Optional
 
 from grpclib import GRPCError
 from grpclib.exceptions import StreamTerminatedError
@@ -30,7 +31,7 @@ class FunctionInfoType(Enum):
 
 
 # TODO(elias): Add support for quoted/str annotations
-CLASS_PARAM_TYPE_MAP: Dict[Type, Tuple["api_pb2.ParameterType.ValueType", str]] = {
+CLASS_PARAM_TYPE_MAP: dict[type, tuple["api_pb2.ParameterType.ValueType", str]] = {
     str: (api_pb2.PARAM_TYPE_STRING, "string_default"),
     int: (api_pb2.PARAM_TYPE_INT, "int_default"),
 }
@@ -102,7 +103,7 @@ class FunctionInfo:
 
     raw_f: Optional[Callable[..., Any]]  # if None - this is a "class service function"
     function_name: str
-    user_cls: Optional[Type[Any]]
+    user_cls: Optional[type[Any]]
     definition_type: "modal_proto.api_pb2.Function.DefinitionType.ValueType"
     module_name: Optional[str]
 
@@ -123,7 +124,7 @@ class FunctionInfo:
         f: Optional[Callable[..., Any]],
         serialized=False,
         name_override: Optional[str] = None,
-        user_cls: Optional[Type] = None,
+        user_cls: Optional[type] = None,
     ):
         self.raw_f = f
         self.user_cls = user_cls
@@ -133,6 +134,9 @@ class FunctionInfo:
         elif f is None and user_cls:
             # "service function" for running all methods of a class
             self.function_name = f"{user_cls.__name__}.*"
+        elif f and user_cls:
+            # Method may be defined on superclass of the wrapped class
+            self.function_name = f"{user_cls.__name__}.{f.__name__}"
         else:
             self.function_name = f.__qualname__
 
@@ -147,7 +151,7 @@ class FunctionInfo:
             # Get the package path
             # Note: __import__ always returns the top-level package.
             self._file = os.path.abspath(module.__file__)
-            package_paths = set([os.path.abspath(p) for p in __import__(module.__package__).__path__])
+            package_paths = {os.path.abspath(p) for p in __import__(module.__package__).__path__}
             # There might be multiple package paths in some weird cases
             base_dirs = [
                 base_dir for base_dir in package_paths if os.path.commonpath((base_dir, self._file)) == base_dir
@@ -210,7 +214,7 @@ class FunctionInfo:
             logger.debug(f"Serializing function for class service function {self.user_cls.__qualname__} as empty")
             return b""
 
-    def get_cls_vars(self) -> Dict[str, Any]:
+    def get_cls_vars(self) -> dict[str, Any]:
         if self.user_cls is not None:
             cls_vars = {
                 attr: getattr(self.user_cls, attr)
@@ -220,7 +224,7 @@ class FunctionInfo:
             return cls_vars
         return {}
 
-    def get_cls_var_attrs(self) -> Dict[str, Any]:
+    def get_cls_var_attrs(self) -> dict[str, Any]:
         import dis
 
         import opcode
@@ -241,10 +245,16 @@ class FunctionInfo:
         f_attrs = {k: cls_vars[k] for k in cls_vars if k in f_attr_ops}
         return f_attrs
 
-    def get_globals(self) -> Dict[str, Any]:
+    def get_globals(self) -> dict[str, Any]:
         from .._vendor.cloudpickle import _extract_code_globals
 
+        if self.raw_f is None:
+            return {}
+
         func = self.raw_f
+        while hasattr(func, "__wrapped__") and func is not func.__wrapped__:
+            # Unwrap functions decorated using functools.wrapped (potentially multiple times)
+            func = func.__wrapped__
         f_globals_ref = _extract_code_globals(func.__code__)
         f_globals = {k: func.__globals__[k] for k in f_globals_ref if k in func.__globals__}
         return f_globals
@@ -262,7 +272,7 @@ class FunctionInfo:
         # annotation parameters trigger strictly typed parameterization
         # which enables web endpoint for parameterized classes
 
-        modal_parameters: List[api_pb2.ClassParameterSpec] = []
+        modal_parameters: list[api_pb2.ClassParameterSpec] = []
         signature = _get_class_constructor_signature(self.user_cls)
         for param in signature.parameters.values():
             has_default = param.default is not param.empty
@@ -278,7 +288,7 @@ class FunctionInfo:
             format=api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PROTO, schema=modal_parameters
         )
 
-    def get_entrypoint_mount(self) -> List[_Mount]:
+    def get_entrypoint_mount(self) -> list[_Mount]:
         """
         Includes:
         * Implicit mount of the function itself (the module or package that the function is part of)

modal/_utils/grpc_testing.py

@@ -4,7 +4,8 @@ import inspect
 import logging
 import typing
 from collections import Counter, defaultdict
-from typing import Any, Awaitable, Callable, Dict, List, Tuple
+from collections.abc import Awaitable
+from typing import Any, Callable
 
 import grpclib.server
 from grpclib import GRPCError, Status
@@ -93,7 +94,7 @@ def patch_mock_servicer(cls):
 
 
 class ResponseNotConsumed(Exception):
-    def __init__(self, unconsumed_requests: List[str]):
+    def __init__(self, unconsumed_requests: list[str]):
         self.unconsumed_requests = unconsumed_requests
         request_count = Counter(unconsumed_requests)
         super().__init__(f"Expected but did not receive the following requests: {request_count}")
@@ -101,9 +102,9 @@ class ResponseNotConsumed(Exception):
 
 class InterceptionContext:
     def __init__(self):
-        self.calls: List[Tuple[str, Any]] = []  # List[Tuple[method_name, message]]
-        self.custom_responses: Dict[str, List[Tuple[Callable[[Any], bool], List[Any]]]] = defaultdict(list)
-        self.custom_defaults: Dict[str, Callable[["MockClientServicer", grpclib.server.Stream], Awaitable[None]]] = {}
+        self.calls: list[tuple[str, Any]] = []  # List[Tuple[method_name, message]]
+        self.custom_responses: dict[str, list[tuple[Callable[[Any], bool], list[Any]]]] = defaultdict(list)
+        self.custom_defaults: dict[str, Callable[["MockClientServicer", grpclib.server.Stream], Awaitable[None]]] = {}
 
     def add_response(
         self, method_name: str, first_payload, *, request_filter: Callable[[Any], bool] = lambda req: True
@@ -147,7 +148,7 @@ class InterceptionContext:
 
         raise KeyError(f"No message of that type in call list: {self.calls}")
 
-    def get_requests(self, method_name: str) -> List[Any]:
+    def get_requests(self, method_name: str) -> list[Any]:
         return [msg for _method_name, msg in self.calls if _method_name == method_name]
 
     def _add_recv(self, method_name: str, msg):

modal/_utils/grpc_utils.py

@@ -7,10 +7,9 @@ import time
 import typing
 import urllib.parse
 import uuid
+from collections.abc import AsyncIterator
 from typing import (
     Any,
-    AsyncIterator,
-    Dict,
     Optional,
     TypeVar,
 )
@@ -72,7 +71,7 @@ RETRYABLE_GRPC_STATUS_CODES = [
 
 def create_channel(
     server_url: str,
-    metadata: Dict[str, str] = {},
+    metadata: dict[str, str] = {},
 ) -> grpclib.client.Channel:
     """Creates a grpclib.Channel.
 

modal/_utils/hash_utils.py

@@ -2,12 +2,12 @@
 import base64
 import dataclasses
 import hashlib
-from typing import BinaryIO, Callable, List, Union
+from typing import BinaryIO, Callable, Union
 
 HASH_CHUNK_SIZE = 4096
 
 
-def _update(hashers: List[Callable[[bytes], None]], data: Union[bytes, BinaryIO]) -> None:
+def _update(hashers: list[Callable[[bytes], None]], data: Union[bytes, BinaryIO]) -> None:
     if isinstance(data, bytes):
         for hasher in hashers:
             hasher(data)

modal/_utils/mount_utils.py

@@ -1,8 +1,9 @@
 # Copyright Modal Labs 2022
 import posixpath
 import typing
+from collections.abc import Mapping, Sequence
 from pathlib import PurePath, PurePosixPath
-from typing import Dict, List, Mapping, Sequence, Tuple, Union
+from typing import Union
 
 from ..cloud_bucket_mount import _CloudBucketMount
 from ..exception import InvalidError
@@ -15,7 +16,7 @@ T = typing.TypeVar("T", bound=Union[_Volume, _NetworkFileSystem, _CloudBucketMou
 def validate_mount_points(
     display_name: str,
     volume_likes: Mapping[Union[str, PurePosixPath], T],
-) -> List[Tuple[str, T]]:
+) -> list[tuple[str, T]]:
     """Mount point path validation for volumes and network file systems."""
 
     if not isinstance(volume_likes, dict):
@@ -57,11 +58,11 @@ def validate_network_file_systems(
 
 def validate_volumes(
     volumes: Mapping[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]],
-) -> Sequence[Tuple[str, Union[_Volume, _CloudBucketMount]]]:
+) -> Sequence[tuple[str, Union[_Volume, _CloudBucketMount]]]:
     validated_volumes = validate_mount_points("Volume", volumes)
     # We don't support mounting a modal.Volume in more than one location,
     # but the same CloudBucketMount object can be used in more than one location.
-    volume_to_paths: Dict[_Volume, List[str]] = {}
+    volume_to_paths: dict[_Volume, list[str]] = {}
     for path, volume in validated_volumes:
         if not isinstance(volume, (_Volume, _CloudBucketMount)):
             raise InvalidError(f"Object of type {type(volume)} mounted at '{path}' is not useable as a volume.")

modal/_utils/package_utils.py

@@ -4,7 +4,6 @@ import importlib.util
 import typing
 from importlib.metadata import PackageNotFoundError, files
 from pathlib import Path
-from typing import Tuple
 
 from ..exception import ModuleNotMountable
 
@@ -24,7 +23,7 @@ def get_file_formats(module):
 BINARY_FORMATS = ["so", "S", "s", "asm"]  # TODO
 
 
-def get_module_mount_info(module_name: str) -> typing.Sequence[typing.Tuple[bool, Path]]:
+def get_module_mount_info(module_name: str) -> typing.Sequence[tuple[bool, Path]]:
     """Returns a list of tuples [(is_dir, path)] describing how to mount a given module."""
     file_formats = get_file_formats(module_name)
     if set(BINARY_FORMATS) & set(file_formats):
@@ -49,7 +48,7 @@ def get_module_mount_info(module_name: str) -> typing.Sequence[typing.Tuple[bool
     return entries
 
 
-def parse_major_minor_version(version_string: str) -> Tuple[int, int]:
+def parse_major_minor_version(version_string: str) -> tuple[int, int]:
     parts = version_string.split(".")
     if len(parts) < 2:
         raise ValueError("version_string must have at least an 'X.Y' format")

modal/_utils/pattern_matcher.py

@@ -12,7 +12,7 @@ then asking it whether file paths match any of its patterns.
 import enum
 import os
 import re
-from typing import List, Optional, TextIO
+from typing import Optional, TextIO
 
 escape_chars = frozenset(".+()|{}$")
 
@@ -32,7 +32,7 @@ class Pattern:
         """Initialize a new Pattern instance."""
         self.match_type = MatchType.UNKNOWN
         self.cleaned_pattern = ""
-        self.dirs: List[str] = []
+        self.dirs: list[str] = []
         self.regexp: Optional[re.Pattern] = None
         self.exclusion = False
 
@@ -151,7 +151,7 @@ class Pattern:
 class PatternMatcher:
     """Allows checking paths against a list of patterns."""
 
-    def __init__(self, patterns: List[str]) -> None:
+    def __init__(self, patterns: list[str]) -> None:
         """Initialize a new PatternMatcher instance.
 
         Args:
@@ -160,7 +160,7 @@ class PatternMatcher:
         Raises:
             ValueError: If an illegal exclusion pattern is provided.
         """
-        self.patterns: List[Pattern] = []
+        self.patterns: list[Pattern] = []
         self.exclusions = False
         for pattern in patterns:
             pattern = pattern.strip()
@@ -217,7 +217,7 @@ class PatternMatcher:
         return matched
 
 
-def read_ignorefile(reader: TextIO) -> List[str]:
+def read_ignorefile(reader: TextIO) -> list[str]:
     """Read an ignore file from a reader and return the list of file patterns to
     ignore, applying the following rules:
 
@@ -241,7 +241,7 @@ def read_ignorefile(reader: TextIO) -> List[str]:
     if reader is None:
         return []
 
-    excludes: List[str] = []
+    excludes: list[str] = []
 
     for line in reader:
         pattern = line.rstrip("\n\r")

modal/_utils/rand_pb_testing.py

@@ -7,13 +7,13 @@ Modal, with random seeds, and it supports oneofs, and Protobuf v4.
 
 import string
 from random import Random
-from typing import Any, Callable, Dict, Optional, Type, TypeVar
+from typing import Any, Callable, Optional, TypeVar
 
 from google.protobuf.descriptor import Descriptor, FieldDescriptor
 
 T = TypeVar("T")
 
-_FIELD_RANDOM_GENERATOR: Dict[int, Callable[[Random], Any]] = {
+_FIELD_RANDOM_GENERATOR: dict[int, Callable[[Random], Any]] = {
     FieldDescriptor.TYPE_DOUBLE: lambda rand: rand.normalvariate(0, 1),
     FieldDescriptor.TYPE_FLOAT: lambda rand: rand.normalvariate(0, 1),
     FieldDescriptor.TYPE_INT32: lambda rand: int.from_bytes(rand.randbytes(4), "little", signed=True),
@@ -71,7 +71,7 @@ def _fill(msg, desc: Descriptor, rand: Random) -> None:
                 setattr(msg, field.name, generator(rand))
 
 
-def rand_pb(proto: Type[T], rand: Optional[Random] = None) -> T:
+def rand_pb(proto: type[T], rand: Optional[Random] = None) -> T:
     """Generate a pseudorandom protobuf message.
 
     ```python notest

modal/_utils/shell_utils.py

@@ -6,7 +6,8 @@ import errno
 import os
 import select
 import sys
-from typing import Callable, Coroutine, Optional
+from collections.abc import Coroutine
+from typing import Callable, Optional
 
 from modal._pty import raw_terminal, set_nonblocking