modal 1.5.6.dev11__tar.gz → 1.5.6.dev12__tar.gz

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.6.dev11
+Version: 1.5.6.dev12
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/_functions.py

@@ -16,6 +16,7 @@ from google.protobuf.message import Message
 from grpclib import Status
 from synchronicity.combined_types import MethodWithAio
 
+from modal._utils.logger import logger
 from modal.types import CloudBucketMountInfo, FunctionInfo, HttpInfo, VolumeMountInfo
 from modal_proto import api_pb2
 from modal_proto.modal_api_grpc import ModalClientModal
@@ -2306,7 +2307,8 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         """Fetch information about the graph of Inputs this FunctionCall is part of.
 
         Note: the call graph data is not populated in real-time, and its capture is best-effort.
-        We do not recommend relying on this method for critical use cases.
+        Large call graphs may be truncated. We do not recommend relying on this method
+        for critical use cases.
 
         See the [`modal.types`](/docs/sdk/py/latest/types) reference for information
         on the return values.
@@ -2317,6 +2319,11 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         assert self._client and self._client.stub
         request = api_pb2.FunctionGetCallGraphRequest(function_call_id=self.object_id)
         response = await self._client.stub.FunctionGetCallGraph(request)
+        if response.truncated:
+            logger.warning(
+                f"Call graph for {self.object_id} was truncated; "
+                f"returning the first {len(response.inputs)} inputs. The graph may be incomplete."
+            )
         return _reconstruct_call_graph(response)
 
     @live_method

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/_runtime/execution_context.py

@@ -109,7 +109,7 @@ _current_input_id: ContextVar = ContextVar("_current_input_id")
 _current_function_call_id: ContextVar = ContextVar("_current_function_call_id")
 _current_attempt_token: ContextVar = ContextVar("_current_attempt_token")
 
-_is_currently_importing = False  # we set this to True while a container is importing user code
+_is_currently_importing = False
 
 
 @contextmanager

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/cli/image.py

@@ -58,7 +58,7 @@ async def logs(image_id: str, layers: int | None, all_layers: bool) -> None:
     effective_layers = None if all_layers else layers or 1
     image = Image.from_id(image_id)
     output_mgr = OutputManager.get()
-    last_message = ""
+    last_message: str | None = None
     async for entry in image.logs.fetch.aio(layers=effective_layers):
         last_message = entry.message
         await output_mgr.put_fetched_log(
@@ -69,7 +69,9 @@ async def logs(image_id: str, layers: int | None, all_layers: bool) -> None:
             )
         )
     output_mgr.flush_lines()
-    if last_message and not last_message.endswith("\n"):
+    if last_message is None:
+        output_mgr.print(f"No build logs found for Image {image_id}.")
+    elif not last_message.endswith("\n"):
         output_mgr.print("")
 
 

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/cli/import_refs.py

@@ -27,6 +27,7 @@ from modal.exception import InvalidError, _CliUserExecutionError
 from modal.functions import Function
 from modal.output import OutputManager
 
+from .._runtime import execution_context
 from .._utils.async_utils import synchronizer
 
 
@@ -74,7 +75,8 @@ def import_file_or_module(import_ref: ImportRef, base_cmd: str = ""):
                 f"Use `{base_cmd} -m {import_ref.file_or_module}` instead.",
             )
         try:
-            module = importlib.import_module(import_ref.file_or_module)
+            with execution_context._import_context():
+                module = importlib.import_module(import_ref.file_or_module)
         except Exception as exc:
             raise _CliUserExecutionError(import_ref.file_or_module) from exc
     else:
@@ -97,7 +99,8 @@ def import_file_or_module(import_ref: ImportRef, base_cmd: str = ""):
         sys.modules[module_name] = module
         try:
             assert spec.loader
-            spec.loader.exec_module(module)
+            with execution_context._import_context():
+                spec.loader.exec_module(module)
         except Exception as exc:
             if isinstance(exc, ImportError) and "attempted relative import with no known parent package" in str(exc):
                 if import_ref.file_or_module and import_ref.command and not import_ref.use_module_mode:

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/cli/profile.py

@@ -17,7 +17,7 @@ from modal.config import (
     config_set_active_profile,
 )
 from modal.environments import Environment
-from modal.exception import AuthError
+from modal.exception import AuthError, InvalidError
 from modal.output import OutputManager
 
 from ._help import ModalGroup
@@ -53,8 +53,11 @@ async def list_(json: bool | None = False):
     lookup_coros = [
         _lookup_workspace(
             config.get("server_url", profile=profile),
-            config.get("token_id", profile=profile, use_env=False),
-            config.get("token_secret", profile=profile, use_env=False),
+            token_id=config.get("token_id", profile=profile, use_env=False),
+            token_secret=config.get("token_secret", profile=profile, use_env=False),
+            oauth_refresh_token=config.get("oauth_refresh_token", profile=profile, use_env=False),
+            oauth_client_id=config.get("oauth_client_id", profile=profile, use_env=False),
+            oauth_client_secret=config.get("oauth_client_secret", profile=profile, use_env=False),
         )
         for profile in profiles
     ]
@@ -77,16 +80,28 @@ async def list_(json: bool | None = False):
         rows.append((active, content))
 
     env_based_workspace: str | None = None
-    if "MODAL_TOKEN_ID" in os.environ:
+    credential_env_vars = (
+        "MODAL_TOKEN_ID",
+        "MODAL_TOKEN_SECRET",
+        "MODAL_OAUTH_REFRESH_TOKEN",
+        "MODAL_OAUTH_CLIENT_ID",
+        "MODAL_OAUTH_CLIENT_SECRET",
+    )
+    if any(env_var in os.environ for env_var in credential_env_vars):
         try:
             env_based_resp = await _lookup_workspace(
                 config.get("server_url", profile=config_module._profile),
-                os.environ["MODAL_TOKEN_ID"],
-                os.environ.get("MODAL_TOKEN_SECRET", ""),
+                token_id=config.get("token_id", profile=config_module._profile),
+                token_secret=config.get("token_secret", profile=config_module._profile),
+                oauth_refresh_token=config.get("oauth_refresh_token", profile=config_module._profile),
+                oauth_client_id=config.get("oauth_client_id", profile=config_module._profile),
+                oauth_client_secret=config.get("oauth_client_secret", profile=config_module._profile),
             )
             env_based_workspace = env_based_resp.username
         except AuthError:
             env_based_workspace = "Unknown (authentication failure)"
+        except InvalidError:
+            env_based_workspace = "Unknown (invalid credential configuration)"
 
     output = OutputManager.get()
     highlight = "bold green" if env_based_workspace is None else "yellow"

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/cli/token.py

@@ -62,10 +62,15 @@ async def info():
 
     output = OutputManager.get()
     env_vars = []
-    if os.environ.get("MODAL_TOKEN_ID"):
-        env_vars.append("MODAL_TOKEN_ID")
-    if os.environ.get("MODAL_TOKEN_SECRET"):
-        env_vars.append("MODAL_TOKEN_SECRET")
+    for env_var in (
+        "MODAL_TOKEN_ID",
+        "MODAL_TOKEN_SECRET",
+        "MODAL_OAUTH_REFRESH_TOKEN",
+        "MODAL_OAUTH_CLIENT_ID",
+        "MODAL_OAUTH_CLIENT_SECRET",
+    ):
+        if os.environ.get(env_var):
+            env_vars.append(env_var)
 
     if env_vars:
         env_vars_str = " and ".join(env_vars)

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/client.pyi

@@ -77,7 +77,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.6.dev11",
+        version: str = "1.5.6.dev12",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):
@@ -277,7 +277,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.6.dev11",
+        version: str = "1.5.6.dev12",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/config.py

@@ -109,7 +109,7 @@ from google.protobuf.empty_pb2 import Empty
 from modal_proto import api_pb2
 
 from ._utils.logger import configure_logger
-from .exception import InvalidError, NotFoundError
+from .exception import AuthError, InvalidError, NotFoundError
 
 # By default, try api.modal.com and fail over to api.modal2.com
 DEFAULT_SERVER_URL = "https://api.modal.com,https://api.modal2.com"
@@ -184,11 +184,51 @@ def _read_user_config():
 _user_config = _read_user_config()
 
 
-async def _lookup_workspace(server_url: str, token_id: str, token_secret: str) -> api_pb2.WorkspaceNameLookupResponse:
-    from .client import _Client
-
-    credentials = (token_id, token_secret)
-    async with _Client(server_url, api_pb2.CLIENT_TYPE_CLIENT, credentials) as client:
+async def _lookup_workspace(
+    server_url: str,
+    token_id: str | None = None,
+    token_secret: str | None = None,
+    *,
+    oauth_refresh_token: str | None = None,
+    oauth_client_id: str | None = None,
+    oauth_client_secret: str | None = None,
+) -> api_pb2.WorkspaceNameLookupResponse:
+    from .client import _Client, _OAuthCredentials
+
+    has_token_config = bool(token_id or token_secret)
+    has_oauth_config = bool(oauth_refresh_token or oauth_client_id or oauth_client_secret)
+    if has_token_config and has_oauth_config:
+        raise InvalidError("Modal token credentials and OAuth credentials cannot both be configured.")
+    if has_oauth_config:
+        missing_oauth_credentials = [
+            name
+            for name, value in (
+                ("refresh token", oauth_refresh_token),
+                ("client ID", oauth_client_id),
+                ("client secret", oauth_client_secret),
+            )
+            if not value
+        ]
+        if missing_oauth_credentials:
+            raise InvalidError(f"OAuth credentials are incomplete; missing {', '.join(missing_oauth_credentials)}.")
+        assert oauth_refresh_token and oauth_client_id and oauth_client_secret
+        credentials = None
+        oauth_credentials = _OAuthCredentials(
+            refresh_token=oauth_refresh_token,
+            client_id=oauth_client_id,
+            client_secret=oauth_client_secret,
+        )
+    else:
+        if not token_id or not token_secret:
+            raise AuthError("Token ID and secret must both be configured.")
+        credentials = (token_id, token_secret)
+        oauth_credentials = None
+    async with _Client(
+        server_url,
+        api_pb2.CLIENT_TYPE_CLIENT,
+        credentials,
+        oauth_credentials=oauth_credentials,
+    ) as client:
         return await client.stub.WorkspaceNameLookup(Empty(), retry=None, timeout=3)
 
 

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/functions.pyi

@@ -1231,7 +1231,8 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
             """Fetch information about the graph of Inputs this FunctionCall is part of.
 
             Note: the call graph data is not populated in real-time, and its capture is best-effort.
-            We do not recommend relying on this method for critical use cases.
+            Large call graphs may be truncated. We do not recommend relying on this method
+            for critical use cases.
 
             See the [`modal.types`](/docs/sdk/py/latest/types) reference for information
             on the return values.
@@ -1245,7 +1246,8 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
             """Fetch information about the graph of Inputs this FunctionCall is part of.
 
             Note: the call graph data is not populated in real-time, and its capture is best-effort.
-            We do not recommend relying on this method for critical use cases.
+            Large call graphs may be truncated. We do not recommend relying on this method
+            for critical use cases.
 
             See the [`modal.types`](/docs/sdk/py/latest/types) reference for information
             on the return values.

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/runner.py

@@ -377,13 +377,17 @@ async def _run_app(
     deployment_strategy: str = "rolling",
 ) -> AsyncGenerator["modal.app._App", None]:
     """mdmd:hidden"""
+    if modal._runtime.execution_context._in_import_context():
+        raise InvalidError(
+            "`App.run()` cannot be called in global scope. "
+            'Use `if __name__ == "__main__"` to run Apps in a script, '
+            "or convert the block to a local entrypoint and use the `modal run` CLI."
+        )
+
     load_context = await app._root_load_context.reset().in_place_upgrade(
         client=client, environment_name=environment_name
     )
 
-    if modal._runtime.execution_context._in_import_context():
-        raise InvalidError("Can not run an app in global scope within a container")
-
     if app._running_app:
         raise InvalidError(
             "App is already running and can't be started again.\n"
@@ -601,6 +605,12 @@ async def _deploy_app(
 
     Users should prefer the `modal deploy` CLI or the `App.deploy` method.
     """
+    if modal._runtime.execution_context._in_import_context():
+        raise InvalidError(
+            "`App.deploy()` should not be called in global scope. "
+            'Use `if __name__ == "__main__"` to deploy Apps in a script, '
+            "or use the `modal deploy` CLI."
+        )
 
     name = name or app.name or ""
     if not name:

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/token_flow.py

@@ -166,7 +166,14 @@ async def _set_token(
     )
 
     # Warn the user if their token will be ignored
-    env_vars = [var if os.environ.get(var) else None for var in ["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"]]
+    credential_env_vars = [
+        "MODAL_TOKEN_ID",
+        "MODAL_TOKEN_SECRET",
+        "MODAL_OAUTH_REFRESH_TOKEN",
+        "MODAL_OAUTH_CLIENT_ID",
+        "MODAL_OAUTH_CLIENT_SECRET",
+    ]
+    env_vars = [var if os.environ.get(var) else None for var in credential_env_vars]
     env_vars_used = [var for var in env_vars if var is not None]
     env_vars_str = " / ".join(env_vars_used)
     if env_vars_used:

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/volume.py

@@ -1,8 +1,10 @@
 # Copyright Modal Labs 2023
 import asyncio
+import base64
 import builtins
 import concurrent.futures
 import functools
+import hashlib
 import multiprocessing
 import os
 import platform
@@ -79,6 +81,21 @@ from .types import FileEntry, FileEntryType as FileEntryType, VolumeCreateOption
 VOLUME_PUT_FILE_CLIENT_TIMEOUT = 60 * 60
 
 
+def _expected_block_lengths(start: int, length: int, num_blocks: int) -> list[int]:
+    """Number of bytes of a byte range that fall into each of its `BLOCK_SIZE`-aligned blocks.
+
+    A downloaded block may be shorter than this (trailing zero bytes are left out),
+    so the caller extends it with zeros to the expected length.
+    """
+    lengths = []
+    pos = start
+    for idx in range(num_blocks):
+        block_end = min(start + length, (start // BLOCK_SIZE + idx + 1) * BLOCK_SIZE)
+        lengths.append(max(0, block_end - pos))
+        pos = block_end
+    return lengths
+
+
 async def _raise_on_block_response_error(response) -> None:
     """Raise a picklable Modal exception on error.
 
@@ -99,6 +116,91 @@ async def _raise_on_block_response_error(response) -> None:
     raise ExecutionError(f"Request failed with status {response.status} {response.reason}: {body}")
 
 
+# A block download may carry an RFC 9530 `Repr-Digest`. Only the `sha-256`
+# member is understood, and it covers the whole body; every other algorithm
+# key is ignored, as the RFC prescribes, and a body carrying only unknown keys
+# is left unverified. The field is a Structured Fields Dictionary (RFC 8941):
+# parameters on a member carry no meaning here and are dropped, and when a key
+# repeats the last occurrence wins.
+_REPR_DIGEST_MEMBER_RE = re.compile(r"^sha-256=:([A-Za-z0-9+/]+={0,2}):(;.*)?$")
+
+
+def _split_sf_members(header: str) -> list[str]:
+    # Splits a Structured Fields List/Dictionary on commas, except commas inside
+    # quoted (possibly backslash-escaped) parameter strings.
+    members: list[str] = []
+    start = 0
+    in_quote = False
+    escaped = False
+    for i, ch in enumerate(header):
+        if escaped:
+            escaped = False
+        elif in_quote:
+            if ch == "\\":
+                escaped = True
+            elif ch == '"':
+                in_quote = False
+        elif ch == '"':
+            in_quote = True
+        elif ch == ",":
+            members.append(header[start:i])
+            start = i + 1
+    members.append(header[start:])
+    return members
+
+
+def _parse_repr_digest(header: str | None) -> bytes | None:
+    if not header:
+        return None
+    sha256: bytes | None = None
+    for member in _split_sf_members(header):
+        match = _REPR_DIGEST_MEMBER_RE.match(member.strip())
+        if match is None:
+            continue
+        try:
+            decoded = base64.b64decode(match.group(1), validate=True)
+        except ValueError:
+            continue
+        if len(decoded) != 32:
+            continue
+        sha256 = decoded
+    if sha256 is None:
+        logger.debug(f"ignoring unrecognized Repr-Digest: {header!r}")
+    return sha256
+
+
+class _BlockDigestVerifier:
+    """Checks a streamed block body against the digest its response advertised.
+
+    Feed the body through `update` in order, then call `finish`. Without a
+    digest both are no-ops, so callers can use one unconditionally.
+    """
+
+    def __init__(self, sha256: bytes | None):
+        self._sha256 = sha256
+        self._hasher = hashlib.sha256() if sha256 is not None else None
+
+    def update(self, chunk: bytes) -> None:
+        if self._hasher is not None:
+            self._hasher.update(chunk)
+
+    def finish(self) -> None:
+        if self._sha256 is None or self._hasher is None:
+            return
+        actual = self._hasher.digest()
+        if actual != self._sha256:
+            raise ExecutionError(f"Block download corrupted: expected sha256 {self._sha256.hex()}, got {actual.hex()}")
+
+
+async def _read_block_body(response) -> bytes:
+    """Read a block response body in full, verifying any digest it advertises."""
+    verifier = _BlockDigestVerifier(_parse_repr_digest(response.headers.get("Repr-Digest")))
+    body = await response.content.read()
+    verifier.update(body)
+    verifier.finish()
+    return body
+
+
 def _validate_volume_version(
     requested_version: int,
     actual_version: int,
@@ -854,7 +956,7 @@ class _Volume(_Object, type_prefix="vo"):
             print(len(data))  # == 1024 * 1024
             ```
         """
-        req = api_pb2.VolumeGetFile2Request(volume_id=self.object_id, path=path)
+        req = api_pb2.VolumeGetFile2Request(volume_id=self.object_id, path=path, client_pads_blocks=True)
 
         try:
             response = await self.client.stub.VolumeGetFile2(req)
@@ -862,14 +964,20 @@ class _Volume(_Object, type_prefix="vo"):
             raise FileNotFoundError(exc.args[0])
 
         @retry(n_attempts=5, base_delay=0.1, attempt_timeout=None)
-        async def read_block(block_url: str) -> bytes:
+        async def read_block(block: tuple[str, int]) -> bytes:
+            block_url, expected_len = block
             async with ClientSessionRegistry.get_session().get(block_url) as get_response:
                 await _raise_on_block_response_error(get_response)
-                return await get_response.content.read()
+                body = await _read_block_body(get_response)
+            if len(body) > expected_len:
+                raise ExecutionError(f"Block body is {len(body)} bytes, expected at most {expected_len}")
+            return body.ljust(expected_len, b"\0")
 
-        async def iter_urls() -> AsyncGenerator[str]:
-            for url in response.get_urls:
-                yield url
+        block_lengths = _expected_block_lengths(response.start, response.len, len(response.get_urls))
+
+        async def iter_urls() -> AsyncGenerator[tuple[str, int]]:
+            for url, expected_len in zip(response.get_urls, block_lengths):
+                yield url, expected_len
 
         # TODO(dflemstr): Reasonable default? Make configurable?
         prefetch_num_blocks = multiprocessing.cpu_count()
@@ -910,7 +1018,7 @@ class _Volume(_Object, type_prefix="vo"):
         if concurrency is None:
             concurrency = multiprocessing.cpu_count()
 
-        req = api_pb2.VolumeGetFile2Request(volume_id=self.object_id, path=path)
+        req = api_pb2.VolumeGetFile2Request(volume_id=self.object_id, path=path, client_pads_blocks=True)
 
         # Acquire RPC semaphore if provided to limit concurrent VolumeGetFile2 RPCs.
         # This is used by CLI downloads to prevent overwhelming the server.
@@ -929,14 +1037,23 @@ class _Volume(_Object, type_prefix="vo"):
         write_lock = asyncio.Lock()
         start_pos = fileobj.tell()
 
+        block_lengths = _expected_block_lengths(response.start, response.len, len(response.get_urls))
+
         @retry(n_attempts=5, base_delay=0.1, attempt_timeout=None)
         async def download_block(idx, url) -> int:
             block_start_pos = start_pos + idx * BLOCK_SIZE
+            # Every attempt writes into exactly this slice, so a retry after a rejected
+            # response overwrites everything the rejected attempt wrote.
+            expected_len = block_lengths[idx]
             num_bytes_written = 0
 
             async with download_semaphore, ClientSessionRegistry.get_session().get(url) as get_response:
                 await _raise_on_block_response_error(get_response)
+                verifier = _BlockDigestVerifier(_parse_repr_digest(get_response.headers.get("Repr-Digest")))
                 async for chunk in get_response.content.iter_any():
+                    if num_bytes_written + len(chunk) > expected_len:
+                        raise ExecutionError(f"Block {idx} response is longer than the expected {expected_len} bytes")
+                    verifier.update(chunk)
                     num_chunk_bytes_written = 0
 
                     while num_chunk_bytes_written < len(chunk):
@@ -944,13 +1061,26 @@ class _Volume(_Object, type_prefix="vo"):
                             fileobj.seek(block_start_pos + num_bytes_written + num_chunk_bytes_written)
                             # TODO(dflemstr): this is a small write, but nonetheless might block the event loop for some
                             #  time:
-                            n = fileobj.write(chunk)
+                            n = fileobj.write(chunk[num_chunk_bytes_written:])
+                            if not n:
+                                raise OSError("File object write made no progress")
 
                         num_chunk_bytes_written += n
                         progress_cb(advance=n)
 
                     num_bytes_written += len(chunk)
 
+                # Trailing zero bytes may be omitted from the body; restore them.
+                while num_bytes_written < expected_len:
+                    padding = b"\0" * min(expected_len - num_bytes_written, 1024 * 1024)
+                    async with write_lock:
+                        fileobj.seek(block_start_pos + num_bytes_written)
+                        n = fileobj.write(padding)
+                    num_bytes_written += n
+                    progress_cb(advance=n)
+
+                verifier.finish()
+
             return num_bytes_written
 
         coros = [download_block(idx, url) for idx, url in enumerate(response.get_urls)]

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal/volume.pyi

@@ -15,6 +15,14 @@ import synchronicity.combined_types
 import typing
 import typing_extensions
 
+def _expected_block_lengths(start: int, length: int, num_blocks: int) -> list[int]:
+    """Number of bytes of a byte range that fall into each of its `BLOCK_SIZE`-aligned blocks.
+
+    A downloaded block may be shorter than this (trailing zero bytes are left out),
+    so the caller extends it with zeros to the expected length.
+    """
+    ...
+
 async def _raise_on_block_response_error(response) -> None:
     """Raise a picklable Modal exception on error.
 
@@ -24,6 +32,26 @@ async def _raise_on_block_response_error(response) -> None:
     """
     ...
 
+def _split_sf_members(header: str) -> list[str]: ...
+def _parse_repr_digest(header: typing.Optional[str]) -> typing.Optional[bytes]: ...
+
+class _BlockDigestVerifier:
+    """Checks a streamed block body against the digest its response advertised.
+
+    Feed the body through `update` in order, then call `finish`. Without a
+    digest both are no-ops, so callers can use one unconditionally.
+    """
+    def __init__(self, sha256: typing.Optional[bytes]):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def update(self, chunk: bytes) -> None: ...
+    def finish(self) -> None: ...
+
+async def _read_block_body(response) -> bytes:
+    """Read a block response body in full, verifying any digest it advertises."""
+    ...
+
 def _validate_volume_version(requested_version: int, actual_version: int, volume_name: str) -> None:
     """Validate that the returned volume version matches the requested version."""
     ...

{modal-1.5.6.dev11 → modal-1.5.6.dev12}/modal.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.6.dev11
+Version: 1.5.6.dev12
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0