modal 0.62.16__py3-none-any.whl → 0.72.11__py3-none-any.whl

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,19 +1,20 @@
 # 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()
 
 
-class StubFilesFilter(DefaultFilter):
+class AppFilesFilter(DefaultFilter):
     def __init__(
         self,
         *,
@@ -21,7 +22,7 @@ class StubFilesFilter(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 StubFilesFilter(DefaultFilter):
         return super().__call__(change, path)
 
 
-async def _watch_paths(paths: Set[Path], watch_filter: StubFilesFilter) -> 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: StubFilesFilter) -> Async
         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], StubFilesFilter]:
+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:
@@ -89,14 +91,14 @@ def _watch_args_from_mounts(mounts: List[_Mount]) -> Tuple[Set[Path], StubFilesF
             elif dir_filters[path] is not None:
                 dir_filters[path].add(filter_file.absolute().resolve())
 
-    watch_filter = StubFilesFilter(dir_filters=dict(dir_filters))
+    watch_filter = AppFilesFilter(dir_filters=dict(dir_filters))
     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