modal 0.68.42__py3-none-any.whl → 0.70.2__py3-none-any.whl

modal/_container_entrypoint.py

@@ -464,7 +464,7 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                 batch_wait_ms = function_def.batch_linger_ms or 0
 
         # Get ids and metadata for objects (primarily functions and classes) on the app
-        container_app: RunningApp = container_io_manager.get_app_objects()
+        container_app: RunningApp = container_io_manager.get_app_objects(container_args.app_layout)
 
         # Initialize objects on the app.
         # This is basically only functions and classes - anything else is deprecated and will be unsupported soon

modal/_runtime/asgi.py

@@ -26,6 +26,7 @@ class LifespanManager:
     shutdown: asyncio.Future
     queue: asyncio.Queue
     has_run_init: bool = False
+    lifespan_supported: bool = False
 
     def __init__(self, asgi_app, state):
         self.asgi_app = asgi_app
@@ -46,6 +47,7 @@ class LifespanManager:
         await self.ensure_init()
 
         async def receive():
+            self.lifespan_supported = True
             return await self.queue.get()
 
         async def send(message):
@@ -63,16 +65,21 @@ class LifespanManager:
         try:
             await self.asgi_app({"type": "lifespan", "state": self.state}, receive, send)
         except Exception as e:
+            if not self.lifespan_supported:
+                logger.info(f"ASGI lifespan task exited before receiving any messages with exception:\n{e}")
+                self.startup.set_result(None)
+                self.shutdown.set_result(None)
+                return
+
             logger.error(f"Error in ASGI lifespan task: {e}")
             if not self.startup.done():
                 self.startup.set_exception(ExecutionError("ASGI lifespan task exited startup"))
             if not self.shutdown.done():
                 self.shutdown.set_exception(ExecutionError("ASGI lifespan task exited shutdown"))
         else:
-            if not self.startup.done():
-                self.startup.set_result("ASGI Lifespan protocol is probably not supported by this library")
-            if not self.shutdown.done():
-                self.shutdown.set_result("ASGI Lifespan protocol is probably not supported by this library")
+            logger.info("ASGI Lifespan protocol is probably not supported by this library")
+            self.startup.set_result(None)
+            self.shutdown.set_result(None)
 
     async def lifespan_startup(self):
         await self.ensure_init()

modal/_runtime/container_io_manager.py

@@ -21,7 +21,6 @@ from typing import (
 )
 
 from google.protobuf.empty_pb2 import Empty
-from google.protobuf.message import Message
 from grpclib import Status
 from synchronicity.async_wrap import asynccontextmanager
 
@@ -31,12 +30,12 @@ from modal._traceback import extract_traceback, print_exception
 from modal._utils.async_utils import TaskContext, asyncify, synchronize_api, synchronizer
 from modal._utils.blob_utils import MAX_OBJECT_SIZE_BYTES, blob_download, blob_upload
 from modal._utils.function_utils import _stream_function_call_data
-from modal._utils.grpc_utils import get_proto_oneof, retry_transient_errors
+from modal._utils.grpc_utils import retry_transient_errors
 from modal._utils.package_utils import parse_major_minor_version
 from modal.client import HEARTBEAT_INTERVAL, HEARTBEAT_TIMEOUT, _Client
 from modal.config import config, logger
 from modal.exception import ClientClosed, InputCancellation, InvalidError, SerializationError
-from modal.running_app import RunningApp
+from modal.running_app import RunningApp, running_app_from_layout
 from modal_proto import api_pb2
 
 if TYPE_CHECKING:
@@ -450,25 +449,19 @@ class _ContainerIOManager:
 
             await asyncio.sleep(DYNAMIC_CONCURRENCY_INTERVAL_SECS)
 
-    async def get_app_objects(self) -> RunningApp:
-        req = api_pb2.AppGetObjectsRequest(app_id=self.app_id, include_unindexed=True, only_class_function=True)
-        resp = await retry_transient_errors(self._client.stub.AppGetObjects, req)
-        logger.debug(f"AppGetObjects received {len(resp.items)} objects for app {self.app_id}")
+    async def get_app_objects(self, app_layout: api_pb2.AppLayout) -> RunningApp:
+        if len(app_layout.objects) == 0:
+            # TODO(erikbern): this should never happen! let's keep it in here for a short second
+            # until we've sanity checked that this is, in fact, dead code.
+            req = api_pb2.AppGetLayoutRequest(app_id=self.app_id)
+            resp = await retry_transient_errors(self._client.stub.AppGetLayout, req)
+            app_layout = resp.app_layout
 
-        tag_to_object_id = {}
-        object_handle_metadata = {}
-        for item in resp.items:
-            handle_metadata: Optional[Message] = get_proto_oneof(item.object, "handle_metadata_oneof")
-            object_handle_metadata[item.object.object_id] = handle_metadata
-            if item.tag:
-                tag_to_object_id[item.tag] = item.object.object_id
-
-        return RunningApp(
+        return running_app_from_layout(
             self.app_id,
+            app_layout,
+            self._client,
             environment_name=self._environment_name,
-            tag_to_object_id=tag_to_object_id,
-            object_handle_metadata=object_handle_metadata,
-            client=self._client,
         )
 
     async def get_serialized_function(self) -> tuple[Optional[Any], Optional[Callable[..., Any]]]:

modal/_utils/docker_utils.py

@@ -0,0 +1,64 @@
+# Copyright Modal Labs 2024
+import re
+import shlex
+from typing import Sequence
+
+from ..exception import InvalidError
+
+
+def extract_copy_command_patterns(dockerfile_lines: Sequence[str]) -> list[str]:
+    """
+    Extract all COPY command sources from a Dockerfile.
+    Combines multiline COPY commands into a single line.
+    """
+    copy_source_patterns: set[str] = set()
+    current_command = ""
+    copy_pattern = re.compile(r"^\s*COPY\s+(.+)$", re.IGNORECASE)
+
+    # First pass: handle line continuations and collect full commands
+    for line in dockerfile_lines:
+        line = line.strip()
+        if not line or line.startswith("#"):
+            # ignore comments and empty lines
+            continue
+
+        if current_command:
+            # Continue previous line
+            current_command += " " + line.rstrip("\\").strip()
+        else:
+            # Start new command
+            current_command = line.rstrip("\\").strip()
+
+        if not line.endswith("\\"):
+            # Command is complete
+
+            match = copy_pattern.match(current_command)
+            if match:
+                args = match.group(1)
+                parts = shlex.split(args)
+
+                # COPY --from=... commands reference external sources and do not need a context mount.
+                # https://docs.docker.com/reference/dockerfile/#copy---from
+                if parts[0].startswith("--from="):
+                    current_command = ""
+                    continue
+
+                if len(parts) >= 2:
+                    # Last part is destination, everything else is a mount source
+                    sources = parts[:-1]
+
+                    for source in sources:
+                        special_pattern = re.compile(r"^\s*--|\$\s*")
+                        if special_pattern.match(source):
+                            raise InvalidError(
+                                f"COPY command: {source} using special flags/arguments/variables are not supported"
+                            )
+
+                        if source == ".":
+                            copy_source_patterns.add("./**")
+                        else:
+                            copy_source_patterns.add(source)
+
+            current_command = ""
+
+    return list(copy_source_patterns)

modal/_utils/function_utils.py

@@ -99,16 +99,18 @@ def get_function_type(is_generator: Optional[bool]) -> "api_pb2.Function.Functio
 
 
 class FunctionInfo:
-    """Class that helps us extract a bunch of information about a locally defined function.
+    """Utility that determines serialization/deserialization mechanisms for functions
 
-    Used for populating the definition of a remote function, and for making .local() calls
-    on a host with the local definition available.
+    * Stored as file vs serialized
+    * If serialized: how to serialize the function
+    * If file: which module/function name should be used to retrieve
+
+    Used for populating the definition of a remote function
     """
 
     raw_f: Optional[Callable[..., Any]]  # if None - this is a "class service function"
     function_name: str
     user_cls: Optional[type[Any]]
-    definition_type: "modal_proto.api_pb2.Function.DefinitionType.ValueType"
     module_name: Optional[str]
 
     _type: FunctionInfoType
@@ -116,6 +118,12 @@ class FunctionInfo:
     _base_dir: str
     _remote_dir: Optional[PurePosixPath] = None
 
+    def get_definition_type(self) -> "modal_proto.api_pb2.Function.DefinitionType.ValueType":
+        if self.is_serialized():
+            return modal_proto.api_pb2.Function.DEFINITION_TYPE_SERIALIZED
+        else:
+            return modal_proto.api_pb2.Function.DEFINITION_TYPE_FILE
+
     def is_service_class(self):
         if self.raw_f is None:
             assert self.user_cls
@@ -172,7 +180,7 @@ class FunctionInfo:
             self._base_dir = base_dirs[0]
             self.module_name = module.__spec__.name
             self._remote_dir = ROOT_DIR / PurePosixPath(module.__package__.split(".")[0])
-            self.definition_type = api_pb2.Function.DEFINITION_TYPE_FILE
+            self._is_serialized = False
             self._type = FunctionInfoType.PACKAGE
         elif hasattr(module, "__file__") and not serialized:
             # This generally covers the case where it's invoked with
@@ -182,18 +190,18 @@ class FunctionInfo:
             self._file = os.path.abspath(inspect.getfile(module))
             self.module_name = inspect.getmodulename(self._file)
             self._base_dir = os.path.dirname(self._file)
-            self.definition_type = api_pb2.Function.DEFINITION_TYPE_FILE
+            self._is_serialized = False
             self._type = FunctionInfoType.FILE
         else:
             self.module_name = None
             self._base_dir = os.path.abspath("")  # get current dir
-            self.definition_type = api_pb2.Function.DEFINITION_TYPE_SERIALIZED
-            if serialized:
+            self._is_serialized = True  # either explicitly, or by being in a notebook
+            if serialized:  # if explicit
                 self._type = FunctionInfoType.SERIALIZED
             else:
                 self._type = FunctionInfoType.NOTEBOOK
 
-        if self.definition_type == api_pb2.Function.DEFINITION_TYPE_FILE:
+        if not self.is_serialized():
             # Sanity check that this function is defined in global scope
             # Unfortunately, there's no "clean" way to do this in Python
             qualname = f.__qualname__ if f else user_cls.__qualname__
@@ -203,7 +211,7 @@ class FunctionInfo:
                 )
 
     def is_serialized(self) -> bool:
-        return self.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED
+        return self._is_serialized
 
     def serialized_function(self) -> bytes:
         # Note: this should only be called from .load() and not at function decoration time
@@ -312,7 +320,7 @@ class FunctionInfo:
         if self._type == FunctionInfoType.PACKAGE:
             if config.get("automount"):
                 return [_Mount.from_local_python_packages(self.module_name)]
-            elif self.definition_type == api_pb2.Function.DEFINITION_TYPE_FILE:
+            elif not self.is_serialized():
                 # mount only relevant file and __init__.py:s
                 return [
                     _Mount.from_local_dir(
@@ -322,7 +330,7 @@ class FunctionInfo:
                         condition=entrypoint_only_package_mount_condition(self._file),
                     )
                 ]
-        elif self.definition_type == api_pb2.Function.DEFINITION_TYPE_FILE:
+        elif not self.is_serialized():
             remote_path = ROOT_DIR / Path(self._file).name
             if not _is_modal_path(remote_path):
                 return [
@@ -570,12 +578,15 @@ class FunctionCreationStatus:
 
         elif self.response.function.web_url:
             url_info = self.response.function.web_url_info
+            requires_proxy_auth = self.response.function.webhook_config.requires_proxy_auth
+            proxy_auth_suffix = " 🔑" if requires_proxy_auth else ""
             # Ensure terms used here match terms used in modal.com/docs/guide/webhook-urls doc.
             suffix = _get_suffix_from_web_url_info(url_info)
             # TODO: this is only printed when we're showing progress. Maybe move this somewhere else.
             web_url = self.response.handle_metadata.web_url
             self.status_row.finish(
-                f"Created web function {self.tag} => [magenta underline]{web_url}[/magenta underline]{suffix}"
+                f"Created web function {self.tag} => [magenta underline]{web_url}[/magenta underline]"
+                f"{proxy_auth_suffix}{suffix}"
             )
 
             # Print custom domain in terminal

modal/cli/launch.py

@@ -77,6 +77,7 @@ def vscode(
     cpu: int = 8,
     memory: int = 32768,
     gpu: Optional[str] = None,
+    image: str = "debian:12",
     timeout: int = 3600,
     mount: Optional[str] = None,  # Create a `modal.Mount` from a local directory.
     volume: Optional[str] = None,  # Attach a persisted `modal.Volume` by name (creating if missing).
@@ -86,6 +87,7 @@ def vscode(
         "cpu": cpu,
         "memory": memory,
         "gpu": gpu,
+        "image": image,
         "timeout": timeout,
         "mount": mount,
         "volume": volume,

modal/cli/programs/vscode.py

@@ -15,9 +15,34 @@ from modal import App, Image, Mount, Queue, Secret, Volume, forward
 # Passed by `modal launch` locally via CLI, plumbed to remote runner through secrets.
 args: dict[str, Any] = json.loads(os.environ.get("MODAL_LAUNCH_ARGS", "{}"))
 
+CODE_SERVER_INSTALLER = "https://code-server.dev/install.sh"
+CODE_SERVER_ENTRYPOINT = (
+    "https://raw.githubusercontent.com/coder/code-server/refs/tags/v4.96.1/ci/release-image/entrypoint.sh"
+)
+FIXUD_INSTALLER = "https://github.com/boxboat/fixuid/releases/download/v0.6.0/fixuid-0.6.0-linux-$ARCH.tar.gz"
+
 
 app = App()
-app.image = Image.from_registry("codercom/code-server", add_python="3.11").dockerfile_commands("ENTRYPOINT []")
+app.image = (
+    Image.from_registry(args.get("image"), add_python="3.11")
+    .apt_install("curl", "dumb-init", "git", "git-lfs")
+    .run_commands(
+        f"curl -fsSL {CODE_SERVER_INSTALLER} | sh",
+        f"curl -fsSL {CODE_SERVER_ENTRYPOINT}  > /code-server.sh",
+        "chmod u+x /code-server.sh",
+    )
+    .run_commands(
+        'ARCH="$(dpkg --print-architecture)"'
+        f' && curl -fsSL "{FIXUD_INSTALLER}" | tar -C /usr/local/bin -xzf - '
+        " && chown root:root /usr/local/bin/fixuid"
+        " && chmod 4755 /usr/local/bin/fixuid"
+        " && mkdir -p /etc/fixuid"
+        ' && echo "user: root" >> /etc/fixuid/config.yml'
+        ' && echo "group: root" >> /etc/fixuid/config.yml'
+    )
+    .run_commands("mkdir /home/coder")
+    .env({"ENTRYPOINTD": ""})
+)
 
 
 mount = (
@@ -71,7 +96,7 @@ def run_vscode(q: Queue):
         url = tunnel.url
         threading.Thread(target=wait_for_port, args=((url, token), q)).start()
         subprocess.run(
-            ["/usr/bin/entrypoint.sh", "--bind-addr", "0.0.0.0:8080", "."],
+            ["/code-server.sh", "--bind-addr", "0.0.0.0:8080", "."],
             env={**os.environ, "SHELL": "/bin/bash", "PASSWORD": token},
         )
     q.put("done")

modal/client.pyi

@@ -26,7 +26,7 @@ class _Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.42"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.70.2"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -81,7 +81,7 @@ class Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.42"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.70.2"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/file_io.py

@@ -18,7 +18,8 @@ from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES
 from .client import _Client
 from .exception import FilesystemExecutionError, InvalidError
 
-LARGE_FILE_SIZE_LIMIT = 16 * 1024 * 1024  # 16 MiB
+WRITE_CHUNK_SIZE = 16 * 1024 * 1024  # 16 MiB
+WRITE_FILE_SIZE_LIMIT = 1024 * 1024 * 1024  # 1 GiB
 READ_FILE_SIZE_LIMIT = 100 * 1024 * 1024  # 100 MiB
 
 ERROR_MAPPING = {
@@ -77,7 +78,7 @@ async def _replace_bytes(file: "_FileIO", data: bytes, start: Optional[int] = No
     if start is not None and end is not None:
         if start >= end:
             raise InvalidError("start must be less than end")
-    if len(data) > LARGE_FILE_SIZE_LIMIT:
+    if len(data) > WRITE_CHUNK_SIZE:
         raise InvalidError("Write request payload exceeds 16 MiB limit")
     resp = await file._make_request(
         api_pb2.ContainerFilesystemExecRequest(
@@ -288,15 +289,20 @@ class _FileIO(Generic[T]):
         self._validate_type(data)
         if isinstance(data, str):
             data = data.encode("utf-8")
-        if len(data) > LARGE_FILE_SIZE_LIMIT:
-            raise ValueError("Write request payload exceeds 16 MiB limit")
-        resp = await self._make_request(
-            api_pb2.ContainerFilesystemExecRequest(
-                file_write_request=api_pb2.ContainerFileWriteRequest(file_descriptor=self._file_descriptor, data=data),
-                task_id=self._task_id,
+        if len(data) > WRITE_FILE_SIZE_LIMIT:
+            raise ValueError("Write request payload exceeds 1 GiB limit")
+        for i in range(0, len(data), WRITE_CHUNK_SIZE):
+            chunk = data[i : i + WRITE_CHUNK_SIZE]
+            resp = await self._make_request(
+                api_pb2.ContainerFilesystemExecRequest(
+                    file_write_request=api_pb2.ContainerFileWriteRequest(
+                        file_descriptor=self._file_descriptor,
+                        data=chunk,
+                    ),
+                    task_id=self._task_id,
+                )
             )
-        )
-        await self._wait(resp.exec_id)
+            await self._wait(resp.exec_id)
 
     async def flush(self) -> None:
         """Flush the buffer to disk."""

modal/file_pattern_matcher.py

@@ -12,7 +12,7 @@ then asking it whether file paths match any of its patterns.
 import os
 from abc import abstractmethod
 from pathlib import Path
-from typing import Callable, Optional
+from typing import Callable, Optional, Sequence, Union
 
 from ._utils.pattern_utils import Pattern
 
@@ -152,3 +152,13 @@ class FilePatternMatcher(_AbstractPatternMatcher):
 # with_repr allows us to use this matcher as a default value in a function signature
 #  and get a nice repr in the docs and auto-generated type stubs:
 NON_PYTHON_FILES = (~FilePatternMatcher("**/*.py")).with_repr(f"{__name__}.NON_PYTHON_FILES")
+_NOTHING = (~FilePatternMatcher()).with_repr(f"{__name__}._NOTHING")  # match everything = ignore nothing
+
+
+def _ignore_fn(ignore: Union[Sequence[str], Callable[[Path], bool]]) -> Callable[[Path], bool]:
+    # if a callable is passed, return it
+    # otherwise, treat input as a sequence of patterns and return a callable pattern matcher for those
+    if callable(ignore):
+        return ignore
+
+    return FilePatternMatcher(*ignore)

modal/functions.py

@@ -753,7 +753,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     mount_ids=loaded_mount_ids,
                     secret_ids=[secret.object_id for secret in secrets],
                     image_id=(image.object_id if image else ""),
-                    definition_type=info.definition_type,
+                    definition_type=info.get_definition_type(),
                     function_serialized=function_serialized or b"",
                     class_serialized=class_serialized or b"",
                     function_type=function_type,

modal/functions.pyi

@@ -462,11 +462,11 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
 
     _call_generator_nowait: ___call_generator_nowait_spec
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
 
-    remote: __remote_spec[P, ReturnType]
+    remote: __remote_spec[ReturnType, P]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, *args, **kwargs) -> typing.Generator[typing.Any, None, None]: ...
@@ -479,17 +479,17 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
     def _get_obj(self) -> typing.Optional[modal.cls.Obj]: ...
     def local(self, *args: P.args, **kwargs: P.kwargs) -> OriginalReturnType: ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
-    _experimental_spawn: ___experimental_spawn_spec[P, ReturnType]
+    _experimental_spawn: ___experimental_spawn_spec[ReturnType, P]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
-    spawn: __spawn_spec[P, ReturnType]
+    spawn: __spawn_spec[ReturnType, P]
 
     def get_raw_f(self) -> typing.Callable[..., typing.Any]: ...
 

modal/gpu.py

@@ -137,6 +137,27 @@ class H100(_GPUConfig):
         return f"GPU(H100, count={self.count})"
 
 
+class L40S(_GPUConfig):
+    """
+    [NVIDIA L40S](https://www.nvidia.com/en-us/data-center/l40s/) GPU class.
+
+    The L40S is a data center GPU for the Ada Lovelace architecture. It has 48 GB of on-chip
+    GDDR6 RAM and enhanced support for FP8 precision.
+    """
+
+    def __init__(
+        self,
+        *,
+        # Number of GPUs per container. Defaults to 1.
+        # Useful if you have very large models that don't fit on a single GPU.
+        count: int = 1,
+    ):
+        super().__init__(api_pb2.GPU_TYPE_L40S, count)
+
+    def __repr__(self):
+        return f"GPU(L40S, count={self.count})"
+
+
 class Any(_GPUConfig):
     """Selects any one of the GPU classes available within Modal, according to availability."""
 
@@ -154,6 +175,7 @@ STRING_TO_GPU_CONFIG: dict[str, Callable] = {
     "a100-80gb": lambda: A100(size="80GB"),
     "h100": H100,
     "a10g": A10G,
+    "l40s": L40S,
     "any": Any,
 }
 display_string_to_config = "\n".join(f'- "{key}" → `{c()}`' for key, c in STRING_TO_GPU_CONFIG.items() if key != "inf2")