modal 0.62.115__py3-none-any.whl → 0.72.13__py3-none-any.whl

modal/_utils/pattern_utils.py

@@ -0,0 +1,205 @@
+# Copyright Modal Labs 2024
+"""Pattern matching library ported from https://github.com/moby/patternmatcher.
+
+This is the same pattern-matching logic used by Docker, except it is written in
+Python rather than Go. Also, the original Go library has a couple deprecated
+functions that we don't implement in this port.
+
+The main way to use this library is by constructing a `FilePatternMatcher` object,
+then asking it whether file paths match any of its patterns.
+"""
+
+import enum
+import os
+import re
+from typing import Optional, TextIO
+
+escape_chars = frozenset(".+()|{}$")
+
+
+class MatchType(enum.IntEnum):
+    UNKNOWN = 0
+    EXACT = 1
+    PREFIX = 2
+    SUFFIX = 3
+    REGEXP = 4
+
+
+class Pattern:
+    """Defines a single regex pattern used to filter file paths."""
+
+    def __init__(self) -> None:
+        """Initialize a new Pattern instance."""
+        self.match_type = MatchType.UNKNOWN
+        self.cleaned_pattern = ""
+        self.dirs: list[str] = []
+        self.regexp: Optional[re.Pattern] = None
+        self.exclusion = False
+
+    def __str__(self) -> str:
+        """Return the cleaned pattern as the string representation."""
+        return self.cleaned_pattern
+
+    def compile(self, separator: str) -> None:
+        """Compile the pattern into a regular expression.
+
+        Args:
+            separator (str): The path separator (e.g., '/' or '\\').
+
+        Raises:
+            ValueError: If the pattern is invalid.
+        """
+        reg_str = "^"
+        pattern = self.cleaned_pattern
+
+        esc_separator = separator
+        if separator == "\\":
+            esc_separator = "\\\\"
+
+        self.match_type = MatchType.EXACT
+        i = 0
+        pattern_length = len(pattern)
+        while i < pattern_length:
+            ch = pattern[i]
+            if ch == "*":
+                if (i + 1) < pattern_length and pattern[i + 1] == "*":
+                    # Handle '**'
+                    i += 1  # Skip the second '*'
+                    # Treat '**/' as '**' so eat the '/'
+                    if (i + 1) < pattern_length and pattern[i + 1] == separator:
+                        i += 1  # Skip the '/'
+                    if i + 1 == pattern_length:
+                        # Pattern ends with '**'
+                        if self.match_type == MatchType.EXACT:
+                            self.match_type = MatchType.PREFIX
+                        else:
+                            reg_str += ".*"
+                            self.match_type = MatchType.REGEXP
+                    else:
+                        # '**' in the middle
+                        reg_str += f"(.*{esc_separator})?"
+                        self.match_type = MatchType.REGEXP
+
+                    if i == 1:
+                        self.match_type = MatchType.SUFFIX
+                else:
+                    # Single '*'
+                    reg_str += f"[^{esc_separator}]*"
+                    self.match_type = MatchType.REGEXP
+            elif ch == "?":
+                # Single '?'
+                reg_str += f"[^{esc_separator}]"
+                self.match_type = MatchType.REGEXP
+            elif ch in escape_chars:
+                reg_str += "\\" + ch
+            elif ch == "\\":
+                # Escape next character
+                if separator == "\\":
+                    reg_str += esc_separator
+                    i += 1
+                    continue
+                if (i + 1) < pattern_length:
+                    reg_str += "\\" + pattern[i + 1]
+                    i += 1  # Skip the escaped character
+                    self.match_type = MatchType.REGEXP
+                else:
+                    reg_str += "\\"
+            elif ch == "[" or ch == "]":
+                reg_str += ch
+                self.match_type = MatchType.REGEXP
+            else:
+                reg_str += ch
+            i += 1
+
+        if self.match_type != MatchType.REGEXP:
+            return
+
+        reg_str += "$"
+
+        try:
+            self.regexp = re.compile(reg_str)
+            self.match_type = MatchType.REGEXP
+        except re.error as e:
+            raise ValueError(f"Bad pattern: {pattern}") from e
+
+    def match(self, path: str) -> bool:
+        """Check if the path matches the pattern."""
+        if self.match_type == MatchType.UNKNOWN:
+            self.compile(os.path.sep)
+
+        if self.match_type == MatchType.EXACT:
+            return path == self.cleaned_pattern
+        elif self.match_type == MatchType.PREFIX:
+            # Strip trailing '**'
+            return path.startswith(self.cleaned_pattern[:-2])
+        elif self.match_type == MatchType.SUFFIX:
+            # Strip leading '**'
+            suffix = self.cleaned_pattern[2:]
+            if path.endswith(suffix):
+                return True
+            # '**/foo' matches 'foo'
+            if suffix[0] == os.path.sep and path == suffix[1:]:
+                return True
+            else:
+                return False
+        elif self.match_type == MatchType.REGEXP:
+            return self.regexp.match(path) is not None
+        else:
+            return False
+
+
+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:
+
+    - An UTF8 BOM header (if present) is stripped. (Python does this already)
+    - Lines starting with "#" are considered comments and are skipped.
+
+    For remaining lines:
+
+    - Leading and trailing whitespace is removed from each ignore pattern.
+    - It uses `os.path.normpath` to get the shortest/cleanest path for ignore
+      patterns.
+    - Leading forward-slashes ("/") are removed from ignore patterns, so
+      "/some/path" and "some/path" are considered equivalent.
+
+    Args:
+        reader (file-like object): The input stream to read from.
+
+    Returns:
+        list: A list of patterns to ignore.
+    """
+    if reader is None:
+        return []
+
+    excludes: list[str] = []
+
+    for line in reader:
+        pattern = line.rstrip("\n\r")
+
+        # Lines starting with "#" are ignored
+        if pattern.startswith("#"):
+            continue
+
+        pattern = pattern.strip()
+        if pattern == "":
+            continue
+
+        # Normalize absolute paths to paths relative to the context
+        # (taking care of '!' prefix)
+        invert = pattern[0] == "!"
+        if invert:
+            pattern = pattern[1:].strip()
+
+        if len(pattern) > 0:
+            pattern = os.path.normpath(pattern)
+            pattern = pattern.replace(os.sep, "/")
+            if len(pattern) > 1 and pattern[0] == "/":
+                pattern = pattern[1:]
+
+        if invert:
+            pattern = "!" + pattern
+
+        excludes.append(pattern)
+
+    return excludes

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

@@ -1,18 +1,17 @@
 # Copyright Modal Labs 2024
+
 import asyncio
 import contextlib
 import errno
 import os
 import select
 import sys
-from typing import Callable, Coroutine, Optional
-
-import rich.status
+from collections.abc import Coroutine
+from typing import Callable, Optional
 
 from modal._pty import raw_terminal, set_nonblocking
-from modal.exception import ExecutionError, InteractiveTimeoutError
 
-from .async_utils import TaskContext, asyncify
+from .async_utils import asyncify
 
 
 def write_to_fd(fd: int, data: bytes):
@@ -20,14 +19,20 @@ def write_to_fd(fd: int, data: bytes):
     future = loop.create_future()
 
     def try_write():
+        nonlocal data
         try:
             nbytes = os.write(fd, data)
-            loop.remove_writer(fd)
-            future.set_result(nbytes)
+            data = data[nbytes:]
+            if not data:
+                loop.remove_writer(fd)
+                future.set_result(None)
         except OSError as e:
-            if e.errno != errno.EAGAIN:
-                future.set_exception(e)
-                raise
+            if e.errno == errno.EAGAIN:
+                # Wait for the next write notification
+                return
+            # Fail if it's not EAGAIN
+            loop.remove_writer(fd)
+            future.set_exception(e)
 
     loop.add_writer(fd, try_write)
     return future
@@ -72,42 +77,3 @@ async def stream_from_stdin(handle_input: Callable[[bytes, int], Coroutine], use
         yield
     os.write(quit_pipe_write, b"\n")
     write_task.cancel()
-
-
-async def connect_to_terminal(
-    # Handles data read from stdin. Inputs are the stdin data and message index.
-    handle_stdin: Callable[[bytes, int], Coroutine],
-    # Creates a coroutine that streams data to stdout/stderr. Returns the exit status.
-    stream_to_stdio: Callable[[asyncio.Event], Coroutine[None, None, int]],
-    pty: bool = False,
-    connecting_status: Optional[rich.status.Status] = None,
-) -> None:
-    """
-    Connect to the current terminal by streaming data from terminal's stdin to the running process
-    and streaming output from running process into terminal's stdout.
-
-    If connecting_status is given, this function will stop the status spinner upon connection or error.
-    """
-
-    def stop_connecting_status():
-        if connecting_status:
-            connecting_status.stop()
-
-    on_connect = asyncio.Event()
-    async with TaskContext() as tc:
-        exec_output_task = tc.create_task(stream_to_stdio(on_connect))
-        try:
-            # time out if we can't connect to the server fast enough
-            await asyncio.wait_for(on_connect.wait(), timeout=15)
-            stop_connecting_status()
-
-            async with stream_from_stdin(handle_stdin, use_raw_terminal=pty):
-                exit_status = await exec_output_task
-
-            if exit_status != 0:
-                raise ExecutionError(f"Process exited with status code {exit_status}")
-
-        except (asyncio.TimeoutError, TimeoutError):
-            stop_connecting_status()
-            exec_output_task.cancel()
-            raise InteractiveTimeoutError("Failed to establish connection to container.")

modal/_vendor/a2wsgi_wsgi.py

@@ -35,10 +35,8 @@ from concurrent.futures import ThreadPoolExecutor
 from types import TracebackType
 from typing import (
     Any,
-    Awaitable,
     Callable,
     Dict,
-    Iterable,
     List,
     Literal,
     Optional,
@@ -48,6 +46,7 @@ from typing import (
     TypedDict,
     Union,
 )
+from collections.abc import Awaitable, Iterable
 
 
 ## BEGIN a2wsgi/asgi_typing.py
@@ -73,11 +72,11 @@ class HTTPScope(TypedDict):
     raw_path: NotRequired[bytes]
     query_string: bytes
     root_path: str
-    headers: Iterable[Tuple[bytes, bytes]]
-    client: NotRequired[Tuple[str, int]]
-    server: NotRequired[Tuple[str, Optional[int]]]
-    state: NotRequired[Dict[str, Any]]
-    extensions: NotRequired[Dict[str, Dict[object, object]]]
+    headers: Iterable[tuple[bytes, bytes]]
+    client: NotRequired[tuple[str, int]]
+    server: NotRequired[tuple[str, Optional[int]]]
+    state: NotRequired[dict[str, Any]]
+    extensions: NotRequired[dict[str, dict[object, object]]]
 
 
 class WebSocketScope(TypedDict):
@@ -89,18 +88,18 @@ class WebSocketScope(TypedDict):
     raw_path: bytes
     query_string: bytes
     root_path: str
-    headers: Iterable[Tuple[bytes, bytes]]
-    client: NotRequired[Tuple[str, int]]
-    server: NotRequired[Tuple[str, Optional[int]]]
+    headers: Iterable[tuple[bytes, bytes]]
+    client: NotRequired[tuple[str, int]]
+    server: NotRequired[tuple[str, Optional[int]]]
     subprotocols: Iterable[str]
-    state: NotRequired[Dict[str, Any]]
-    extensions: NotRequired[Dict[str, Dict[object, object]]]
+    state: NotRequired[dict[str, Any]]
+    extensions: NotRequired[dict[str, dict[object, object]]]
 
 
 class LifespanScope(TypedDict):
     type: Literal["lifespan"]
     asgi: ASGIVersions
-    state: NotRequired[Dict[str, Any]]
+    state: NotRequired[dict[str, Any]]
 
 
 WWWScope = Union[HTTPScope, WebSocketScope]
@@ -116,7 +115,7 @@ class HTTPRequestEvent(TypedDict):
 class HTTPResponseStartEvent(TypedDict):
     type: Literal["http.response.start"]
     status: int
-    headers: NotRequired[Iterable[Tuple[bytes, bytes]]]
+    headers: NotRequired[Iterable[tuple[bytes, bytes]]]
     trailers: NotRequired[bool]
 
 
@@ -137,7 +136,7 @@ class WebSocketConnectEvent(TypedDict):
 class WebSocketAcceptEvent(TypedDict):
     type: Literal["websocket.accept"]
     subprotocol: NotRequired[str]
-    headers: NotRequired[Iterable[Tuple[bytes, bytes]]]
+    headers: NotRequired[Iterable[tuple[bytes, bytes]]]
 
 
 class WebSocketReceiveEvent(TypedDict):
@@ -223,56 +222,47 @@ ASGIApp = Callable[[Scope, Receive, Send], Awaitable[None]]
 
 ## BEGIN a2wsgi/wsgi_typing.py
 
-CGIRequiredDefined = TypedDict(
-    "CGIRequiredDefined",
-    {
-        # The HTTP request method, such as GET or POST. This cannot ever be an
-        # empty string, and so is always required.
-        "REQUEST_METHOD": str,
-        # When HTTP_HOST is not set, these variables can be combined to determine
-        # a default.
-        # SERVER_NAME and SERVER_PORT are required strings and must never be empty.
-        "SERVER_NAME": str,
-        "SERVER_PORT": str,
-        # The version of the protocol the client used to send the request.
-        # Typically this will be something like "HTTP/1.0" or "HTTP/1.1" and
-        # may be used by the application to determine how to treat any HTTP
-        # request headers. (This variable should probably be called REQUEST_PROTOCOL,
-        # since it denotes the protocol used in the request, and is not necessarily
-        # the protocol that will be used in the server's response. However, for
-        # compatibility with CGI we have to keep the existing name.)
-        "SERVER_PROTOCOL": str,
-    },
-)
-
-CGIOptionalDefined = TypedDict(
-    "CGIOptionalDefined",
-    {
-        "REQUEST_URI": str,
-        "REMOTE_ADDR": str,
-        "REMOTE_PORT": str,
-        # The initial portion of the request URL’s “path” that corresponds to the
-        # application object, so that the application knows its virtual “location”.
-        # This may be an empty string, if the application corresponds to the “root”
-        # of the server.
-        "SCRIPT_NAME": str,
-        # The remainder of the request URL’s “path”, designating the virtual
-        # “location” of the request’s target within the application. This may be an
-        # empty string, if the request URL targets the application root and does
-        # not have a trailing slash.
-        "PATH_INFO": str,
-        # The portion of the request URL that follows the “?”, if any. May be empty
-        # or absent.
-        "QUERY_STRING": str,
-        # The contents of any Content-Type fields in the HTTP request. May be empty
-        # or absent.
-        "CONTENT_TYPE": str,
-        # The contents of any Content-Length fields in the HTTP request. May be empty
-        # or absent.
-        "CONTENT_LENGTH": str,
-    },
-    total=False,
-)
+class CGIRequiredDefined(TypedDict):
+    # The HTTP request method, such as GET or POST. This cannot ever be an
+    # empty string, and so is always required.
+    REQUEST_METHOD: str
+    # When HTTP_HOST is not set, these variables can be combined to determine
+    # a default.
+    # SERVER_NAME and SERVER_PORT are required strings and must never be empty.
+    SERVER_NAME: str
+    SERVER_PORT: str
+    # The version of the protocol the client used to send the request.
+    # Typically this will be something like "HTTP/1.0" or "HTTP/1.1" and
+    # may be used by the application to determine how to treat any HTTP
+    # request headers. (This variable should probably be called REQUEST_PROTOCOL,
+    # since it denotes the protocol used in the request, and is not necessarily
+    # the protocol that will be used in the server's response. However, for
+    # compatibility with CGI we have to keep the existing name.)
+    SERVER_PROTOCOL: str
+
+class CGIOptionalDefined(TypedDict, total=False):
+    REQUEST_URI: str
+    REMOTE_ADDR: str
+    REMOTE_PORT: str
+    # The initial portion of the request URL’s “path” that corresponds to the
+    # application object, so that the application knows its virtual “location”.
+    # This may be an empty string, if the application corresponds to the “root”
+    # of the server.
+    SCRIPT_NAME: str
+    # The remainder of the request URL’s “path”, designating the virtual
+    # “location” of the request’s target within the application. This may be an
+    # empty string, if the request URL targets the application root and does
+    # not have a trailing slash.
+    PATH_INFO: str
+    # The portion of the request URL that follows the “?”, if any. May be empty
+    # or absent.
+    QUERY_STRING: str
+    # The contents of any Content-Type fields in the HTTP request. May be empty
+    # or absent.
+    CONTENT_TYPE: str
+    # The contents of any Content-Length fields in the HTTP request. May be empty
+    # or absent.
+    CONTENT_LENGTH: str
 
 
 class InputStream(Protocol):
@@ -308,7 +298,7 @@ class InputStream(Protocol):
         """
         raise NotImplementedError
 
-    def readlines(self, hint: int = -1, /) -> List[bytes]:
+    def readlines(self, hint: int = -1, /) -> list[bytes]:
         """
         Note that the hint argument to readlines() is optional for both caller and
         implementer. The application is free not to supply it, and the server or gateway
@@ -349,14 +339,14 @@ class ErrorStream(Protocol):
     def write(self, s: str, /) -> Any:
         raise NotImplementedError
 
-    def writelines(self, seq: List[str], /) -> Any:
+    def writelines(self, seq: list[str], /) -> Any:
         raise NotImplementedError
 
 
 WSGIDefined = TypedDict(
     "WSGIDefined",
     {
-        "wsgi.version": Tuple[int, int],  # e.g. (1, 0)
+        "wsgi.version": tuple[int, int],  # e.g. (1, 0)
         "wsgi.url_scheme": str,  # e.g. "http" or "https"
         "wsgi.input": InputStream,
         "wsgi.errors": ErrorStream,
@@ -381,7 +371,7 @@ class Environ(CGIRequiredDefined, CGIOptionalDefined, WSGIDefined):
     """
 
 
-ExceptionInfo = Tuple[Type[BaseException], BaseException, Optional[TracebackType]]
+ExceptionInfo = tuple[type[BaseException], BaseException, Optional[TracebackType]]
 
 # https://peps.python.org/pep-3333/#the-write-callable
 WriteCallable = Callable[[bytes], None]
@@ -391,7 +381,7 @@ class StartResponse(Protocol):
     def __call__(
         self,
         status: str,
-        response_headers: List[Tuple[str, str]],
+        response_headers: list[tuple[str, str]],
         exc_info: Optional[ExceptionInfo] = None,
         /,
     ) -> WriteCallable:
@@ -460,7 +450,7 @@ class Body:
         self.buffer.clear()
         return result
 
-    def readlines(self, hint: int = -1) -> typing.List[bytes]:
+    def readlines(self, hint: int = -1) -> list[bytes]:
         if not self.has_more:
             return []
         if hint == -1:
@@ -626,7 +616,7 @@ class WSGIResponder:
     def start_response(
         self,
         status: str,
-        response_headers: typing.List[typing.Tuple[str, str]],
+        response_headers: list[tuple[str, str]],
         exc_info: typing.Optional[ExceptionInfo] = None,
     ) -> WriteCallable:
         self.exc_info = exc_info

modal/_vendor/cloudpickle.py

@@ -256,7 +256,7 @@ def _should_pickle_by_reference(obj, name=None):
             return False
         return obj.__name__ in sys.modules
     else:
-        raise TypeError("cannot check importability of {} instances".format(type(obj).__name__))
+        raise TypeError(f"cannot check importability of {type(obj).__name__} instances")
 
 
 def _lookup_module_and_qualname(obj, name=None):

modal/_watcher.py

@@ -1,14 +1,15 @@
 # Copyright Modal Labs 2022
 from collections import defaultdict
+from collections.abc import AsyncGenerator
 from pathlib import Path
-from typing import AsyncGenerator, Dict, List, Optional, Set, Tuple
+from typing import Optional
 
 from rich.tree import Tree
 from watchfiles import Change, DefaultFilter, awatch
 
 from modal.mount import _Mount
 
-from ._output import OutputManager
+from .output import _get_output_manager
 
 _TIMEOUT_SENTINEL = object()
 
@@ -21,7 +22,7 @@ class AppFilesFilter(DefaultFilter):
         # Watching specific files is discouraged on Linux, so to watch a file we watch its
         # containing directory and then filter that directory's changes for relevant files.
         # https://github.com/notify-rs/notify/issues/394
-        dir_filters: Dict[Path, Optional[Set[Path]]],
+        dir_filters: dict[Path, Optional[set[Path]]],
     ) -> None:
         self.dir_filters = dir_filters
         super().__init__()
@@ -54,7 +55,7 @@ class AppFilesFilter(DefaultFilter):
         return super().__call__(change, path)
 
 
-async def _watch_paths(paths: Set[Path], watch_filter: AppFilesFilter) -> AsyncGenerator[Set[str], None]:
+async def _watch_paths(paths: set[Path], watch_filter: AppFilesFilter) -> AsyncGenerator[set[str], None]:
     try:
         async for changes in awatch(*paths, step=500, watch_filter=watch_filter):
             changed_paths = {stringpath for _, stringpath in changes}
@@ -64,7 +65,7 @@ async def _watch_paths(paths: Set[Path], watch_filter: AppFilesFilter) -> AsyncG
         pass
 
 
-def _print_watched_paths(paths: Set[Path], output_mgr: OutputManager):
+def _print_watched_paths(paths: set[Path]):
     msg = "️️⚡️ Serving... hit Ctrl-C to stop!"
 
     output_tree = Tree(msg, guide_style="gray50")
@@ -72,12 +73,13 @@ def _print_watched_paths(paths: Set[Path], output_mgr: OutputManager):
     for path in paths:
         output_tree.add(f"Watching {path}.")
 
-    output_mgr.print_if_visible(output_tree)
+    if output_mgr := _get_output_manager():
+        output_mgr.print(output_tree)
 
 
-def _watch_args_from_mounts(mounts: List[_Mount]) -> Tuple[Set[Path], AppFilesFilter]:
+def _watch_args_from_mounts(mounts: list[_Mount]) -> tuple[set[Path], AppFilesFilter]:
     paths = set()
-    dir_filters: Dict[Path, Optional[Set[Path]]] = defaultdict(set)
+    dir_filters: dict[Path, Optional[set[Path]]] = defaultdict(set)
     for mount in mounts:
         # TODO(elias): Make this part of the mount class instead, since it uses so much internals
         for entry in mount._entries:
@@ -93,10 +95,10 @@ def _watch_args_from_mounts(mounts: List[_Mount]) -> Tuple[Set[Path], AppFilesFi
     return paths, watch_filter
 
 
-async def watch(mounts: List[_Mount], output_mgr: OutputManager) -> AsyncGenerator[Set[str], None]:
+async def watch(mounts: list[_Mount]) -> AsyncGenerator[set[str], None]:
     paths, watch_filter = _watch_args_from_mounts(mounts)
 
-    _print_watched_paths(paths, output_mgr)
+    _print_watched_paths(paths)
 
     async for updated_paths in _watch_paths(paths, watch_filter):
         yield updated_paths