modal 1.6.0__tar.gz → 1.6.1.dev1__tar.gz

{modal-1.6.0 → modal-1.6.1.dev1}/PKG-INFO

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

{modal-1.6.0 → modal-1.6.1.dev1}/modal/_functions.py

@@ -7,7 +7,7 @@ import time
 import typing
 import warnings
 from collections import OrderedDict
-from collections.abc import AsyncGenerator, AsyncIterator, Callable, Collection, Sequence
+from collections.abc import AsyncGenerator, Callable, Collection, Sequence
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from pathlib import PurePosixPath
@@ -2405,7 +2405,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         return await self._invocation().poll_function(timeout=timeout, index=index)
 
     @live_method_gen
-    async def iter(self, *, start: int = 0, end: int | None = None) -> AsyncIterator[ReturnType]:
+    async def iter(self, *, start: int = 0, end: int | None = None) -> AsyncGenerator[ReturnType, None]:
         """Iterate in-order over the results of the function call.
 
         Optionally, specify a range [start, end) to iterate over.

{modal-1.6.0 → modal-1.6.1.dev1}/modal/_object.py

@@ -4,10 +4,10 @@ import typing
 import uuid
 from collections.abc import Awaitable, Callable, Hashable, Sequence
 from functools import wraps
-from typing import ClassVar
+from typing import Any, AsyncContextManager, AsyncGenerator, AsyncIterator, ClassVar, ParamSpec, TypeVar
 
 from google.protobuf.message import Message
-from typing_extensions import Self
+from typing_extensions import Concatenate, Self
 
 from ._load_context import LoadContext
 from ._resolver import Resolver
@@ -38,18 +38,24 @@ def _get_environment_name(
         return config.get("environment") or ""
 
 
-def live_method(method):
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def live_method(method: Callable[Concatenate[Any, P], Awaitable[T]]) -> Callable[Concatenate[Any, P], Awaitable[T]]:
     @wraps(method)
-    async def wrapped(self, *args, **kwargs):
+    async def wrapped(self, *args: P.args, **kwargs: P.kwargs) -> T:
         await self.hydrate()
         return await method(self, *args, **kwargs)
 
     return wrapped
 
 
-def live_method_gen(method):
+def live_method_gen(
+    method: Callable[Concatenate[Any, P], AsyncGenerator[T, None]],
+) -> Callable[Concatenate[Any, P], AsyncIterator[T]]:
     @wraps(method)
-    async def wrapped(self, *args, **kwargs):
+    async def wrapped(self, *args: P.args, **kwargs: P.kwargs) -> AsyncIterator[T]:
         await self.hydrate()
         async with aclosing(method(self, *args, **kwargs)) as stream:
             async for item in stream:
@@ -58,14 +64,16 @@ def live_method_gen(method):
     return wrapped
 
 
-def live_method_contextmanager(method):
+def live_method_contextmanager(
+    method: Callable[Concatenate[Any, P], AsyncContextManager[T]],
+) -> Callable[Concatenate[Any, P], AsyncContextManager[T]]:
     # make sure a wrapped function returning an async context manager
     # will not require both an `await func.aio()` and `async with`
     # which would have been the case if it was wrapped in live_method
 
     @wraps(method)
     @contextlib.asynccontextmanager
-    async def wrapped(self, *args, **kwargs):
+    async def wrapped(self, *args: P.args, **kwargs: P.kwargs):
         await self.hydrate()
         async with method(self, *args, **kwargs) as ctx:
             yield ctx
@@ -75,7 +83,7 @@ def live_method_contextmanager(method):
 
 class _Object:
     _type_prefix: ClassVar[str | None] = None
-    _prefix_to_type: ClassVar[dict[str, type]] = {}
+    _prefix_to_type: ClassVar[dict[str, type["_Object"]]] = {}
 
     # For constructors
     _load: Callable[[Self, Resolver, LoadContext, str | None], Awaitable[None]] | None = None

{modal-1.6.0 → modal-1.6.1.dev1}/modal/_utils/grpc_utils.py

@@ -307,20 +307,19 @@ def create_channel_config(*, sustained_keepalive: bool = False) -> grpclib.confi
     HTTP/2 keepalive probes keep idle transports warm through stateful
     middleboxes and surface dead connections before retries reuse them.
 
-    `sustained_keepalive` clears the two grpclib defaults such that a probe
-    actually goes out every `_keepalive_time`, for as long as the connection is
-    open.
+    A probe goes out every `_keepalive_time` while the connection keeps sending
+    requests. `sustained_keepalive` also keeps probing a connection that only
+    awaits responses, for as long as it is open.
     """
-    ping_throttle_overrides: dict[str, Any] = {}
+    ping_throttle_overrides: dict[str, Any] = {
+        # Default 300s floor between probes, applied regardless of data
+        # despite the name, so it has to stay under `_keepalive_time`.
+        "_http2_min_sent_ping_interval_without_data": GRPC_KEEPALIVE_TIME_SECS / 2,
+    }
     if sustained_keepalive:
-        ping_throttle_overrides = {
-            # Default 2: probing stops after two probes with no request sent in
-            # between. Requests reset the count, acks don't. 0 = no cap.
-            "_http2_max_pings_without_data": 0,
-            # Default 300s floor between probes, applied regardless of data
-            # despite the name, so it has to stay under `_keepalive_time`.
-            "_http2_min_sent_ping_interval_without_data": GRPC_KEEPALIVE_TIME_SECS / 2,
-        }
+        # Default 2: probing stops after two probes with no request sent in
+        # between. Requests reset the count, acks don't. 0 = no cap.
+        ping_throttle_overrides["_http2_max_pings_without_data"] = 0
 
     return grpclib.config.Configuration(
         _keepalive_time=GRPC_KEEPALIVE_TIME_SECS,