modAL 1.2.7.dev10__tar.gz → 1.2.7.dev12__tar.gz

{modal-1.2.7.dev10 → modal-1.2.7.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.7.dev10
+Version: 1.2.7.dev12
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0
@@ -13,17 +13,17 @@ Classifier: Topic :: System :: Distributed Computing
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Requires-Python: <3.14,>=3.10
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
 Requires-Dist: cbor2
 Requires-Dist: certifi
 Requires-Dist: click~=8.1
-Requires-Dist: grpclib<0.4.9,>=0.4.7
+Requires-Dist: grpclib<0.4.10,>=0.4.7
 Requires-Dist: protobuf!=4.24.0,<7.0,>=3.19
 Requires-Dist: rich>=12.0.0
-Requires-Dist: synchronicity~=0.10.2
+Requires-Dist: synchronicity~=0.11.1
 Requires-Dist: toml
 Requires-Dist: typer>=0.9
 Requires-Dist: types-certifi
@@ -51,7 +51,7 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 ## Installation
 
-**This library requires Python 3.10 – 3.13.**
+**This library requires Python 3.10 – 3.14.**
 
 Install the package with `uv` or `pip`:
 

{modal-1.2.7.dev10 → modal-1.2.7.dev12}/README.md

@@ -17,7 +17,7 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 ## Installation
 
-**This library requires Python 3.10 – 3.13.**
+**This library requires Python 3.10 – 3.14.**
 
 Install the package with `uv` or `pip`:
 

{modal-1.2.7.dev10 → modal-1.2.7.dev12}/modal/__init__.py

@@ -3,8 +3,8 @@ import sys
 
 if sys.version_info[:2] < (3, 10):
     raise RuntimeError("This version of Modal requires at least Python 3.10")
-if sys.version_info[:2] >= (3, 14):
-    raise RuntimeError("This version of Modal does not support Python 3.14+")
+if sys.version_info[:2] >= (3, 15):
+    raise RuntimeError("This version of Modal does not support Python 3.15+")
 
 from modal_version import __version__
 

{modal-1.2.7.dev10 → modal-1.2.7.dev12}/modal/_grpc_client.py

@@ -38,7 +38,7 @@ _STATUS_TO_EXCEPTION: dict[Status, type[exception._GRPCErrorWrapper]] = {
     Status.UNIMPLEMENTED: exception.UnimplementedError,
     Status.INTERNAL: exception.InternalError,
     Status.UNAVAILABLE: exception.ServiceError,
-    Status.DATA_LOSS: exception.ServiceError,
+    Status.DATA_LOSS: exception.DataLossError,
     Status.UNAUTHENTICATED: exception.AuthError,
 }
 

{modal-1.2.7.dev10 → modal-1.2.7.dev12}/modal/_output.py

@@ -12,7 +12,7 @@ from collections.abc import Generator
 from datetime import timedelta
 from typing import Callable, ClassVar
 
-from grpclib.exceptions import GRPCError, StreamTerminatedError
+from grpclib.exceptions import StreamTerminatedError
 from rich.console import Console, Group, RenderableType
 from rich.live import Live
 from rich.panel import Panel
@@ -34,10 +34,11 @@ from rich.text import Text
 from modal._utils.time_utils import timestamp_to_localized_str
 from modal_proto import api_pb2
 
-from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES, Retry
+from ._utils.grpc_utils import Retry
 from ._utils.shell_utils import stream_from_stdin, write_to_fd
 from .client import _Client
 from .config import logger
+from .exception import InternalError, ServiceError
 
 if platform.system() == "Windows":
     default_spinner = "line"
@@ -644,13 +645,11 @@ async def get_app_logs_loop(
     while True:
         try:
             await _get_logs()
-        except (GRPCError, StreamTerminatedError, socket.gaierror, AttributeError) as exc:
-            if isinstance(exc, GRPCError):
-                if exc.status in RETRYABLE_GRPC_STATUS_CODES:
-                    # Try again if we had a temporary connection drop,
-                    # for example if computer went to sleep.
-                    logger.debug("Log fetching timed out. Retrying ...")
-                    continue
+        except (ServiceError, InternalError, StreamTerminatedError, socket.gaierror, AttributeError) as exc:
+            if isinstance(exc, (ServiceError, InternalError)):
+                # Try again if we had a temporary connection drop, for example if computer went to sleep.
+                logger.debug("Log fetching timed out. Retrying ...")
+                continue
             elif isinstance(exc, StreamTerminatedError):
                 logger.debug("Stream closed. Retrying ...")
                 continue

{modal-1.2.7.dev10 → modal-1.2.7.dev12}/modal/_runtime/container_io_manager.pyi

@@ -252,8 +252,6 @@ class _ContainerIOManager:
     @classmethod
     def stop_fetching_inputs(cls): ...
 
-SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
-
 class ContainerIOManager:
     """Synchronizes all RPC calls and network operations for a running container.
 
@@ -298,47 +296,47 @@ class ContainerIOManager:
         """Only used for tests."""
         ...
 
-    class __hello_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __hello_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    hello: __hello_spec[typing_extensions.Self]
+    hello: __hello_spec
 
-    class ___run_heartbeat_loop_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___run_heartbeat_loop_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    _run_heartbeat_loop: ___run_heartbeat_loop_spec[typing_extensions.Self]
+    _run_heartbeat_loop: ___run_heartbeat_loop_spec
 
-    class ___heartbeat_handle_cancellations_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___heartbeat_handle_cancellations_spec(typing_extensions.Protocol):
         def __call__(self, /) -> bool: ...
         async def aio(self, /) -> bool: ...
 
-    _heartbeat_handle_cancellations: ___heartbeat_handle_cancellations_spec[typing_extensions.Self]
+    _heartbeat_handle_cancellations: ___heartbeat_handle_cancellations_spec
 
-    class __heartbeats_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __heartbeats_spec(typing_extensions.Protocol):
         def __call__(
             self, /, wait_for_mem_snap: bool
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
         def aio(self, /, wait_for_mem_snap: bool) -> typing.AsyncContextManager[None]: ...
 
-    heartbeats: __heartbeats_spec[typing_extensions.Self]
+    heartbeats: __heartbeats_spec
 
     def stop_heartbeat(self): ...
 
-    class __dynamic_concurrency_manager_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __dynamic_concurrency_manager_spec(typing_extensions.Protocol):
         def __call__(self, /) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
         def aio(self, /) -> typing.AsyncContextManager[None]: ...
 
-    dynamic_concurrency_manager: __dynamic_concurrency_manager_spec[typing_extensions.Self]
+    dynamic_concurrency_manager: __dynamic_concurrency_manager_spec
 
-    class ___dynamic_concurrency_loop_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___dynamic_concurrency_loop_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    _dynamic_concurrency_loop: ___dynamic_concurrency_loop_spec[typing_extensions.Self]
+    _dynamic_concurrency_loop: ___dynamic_concurrency_loop_spec
 
-    class __get_data_in_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __get_data_in_spec(typing_extensions.Protocol):
         def __call__(
             self, /, function_call_id: str, attempt_token: typing.Optional[str]
         ) -> typing.Iterator[typing.Any]:
@@ -351,9 +349,9 @@ class ContainerIOManager:
             """Read from the `data_in` stream of a function call."""
             ...
 
-    get_data_in: __get_data_in_spec[typing_extensions.Self]
+    get_data_in: __get_data_in_spec
 
-    class __put_data_out_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __put_data_out_spec(typing_extensions.Protocol):
         def __call__(
             self,
             /,
@@ -388,9 +386,9 @@ class ContainerIOManager:
             """
             ...
 
-    put_data_out: __put_data_out_spec[typing_extensions.Self]
+    put_data_out: __put_data_out_spec
 
-    class __generator_output_sender_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __generator_output_sender_spec(typing_extensions.Protocol):
         def __call__(
             self, /, function_call_id: str, attempt_token: str, data_format: int, message_rx: asyncio.queues.Queue
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]:
@@ -403,9 +401,9 @@ class ContainerIOManager:
             """Runs background task that feeds generator outputs into a function call's `data_out` stream."""
             ...
 
-    generator_output_sender: __generator_output_sender_spec[typing_extensions.Self]
+    generator_output_sender: __generator_output_sender_spec
 
-    class ___queue_create_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___queue_create_spec(typing_extensions.Protocol):
         def __call__(self, /, size: int) -> asyncio.queues.Queue:
             """Create a queue, on the synchronicity event loop (needed on Python 3.8 and 3.9)."""
             ...
@@ -414,9 +412,9 @@ class ContainerIOManager:
             """Create a queue, on the synchronicity event loop (needed on Python 3.8 and 3.9)."""
             ...
 
-    _queue_create: ___queue_create_spec[typing_extensions.Self]
+    _queue_create: ___queue_create_spec
 
-    class ___queue_put_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___queue_put_spec(typing_extensions.Protocol):
         def __call__(self, /, queue: asyncio.queues.Queue, value: typing.Any) -> None:
             """Put a value onto a queue, using the synchronicity event loop."""
             ...
@@ -425,12 +423,12 @@ class ContainerIOManager:
             """Put a value onto a queue, using the synchronicity event loop."""
             ...
 
-    _queue_put: ___queue_put_spec[typing_extensions.Self]
+    _queue_put: ___queue_put_spec
 
     def get_average_call_time(self) -> float: ...
     def get_max_inputs_to_fetch(self): ...
 
-    class ___generate_inputs_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___generate_inputs_spec(typing_extensions.Protocol):
         def __call__(
             self, /, batch_max_size: int, batch_wait_ms: int
         ) -> typing.Iterator[list[tuple[str, int, str, str, modal_proto.api_pb2.FunctionInput]]]: ...
@@ -438,9 +436,9 @@ class ContainerIOManager:
             self, /, batch_max_size: int, batch_wait_ms: int
         ) -> collections.abc.AsyncIterator[list[tuple[str, int, str, str, modal_proto.api_pb2.FunctionInput]]]: ...
 
-    _generate_inputs: ___generate_inputs_spec[typing_extensions.Self]
+    _generate_inputs: ___generate_inputs_spec
 
-    class __run_inputs_outputs_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __run_inputs_outputs_spec(typing_extensions.Protocol):
         def __call__(
             self,
             /,
@@ -456,9 +454,9 @@ class ContainerIOManager:
             batch_wait_ms: int = 0,
         ) -> collections.abc.AsyncIterator[IOContext]: ...
 
-    run_inputs_outputs: __run_inputs_outputs_spec[typing_extensions.Self]
+    run_inputs_outputs: __run_inputs_outputs_spec
 
-    class ___send_outputs_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___send_outputs_spec(typing_extensions.Protocol):
         def __call__(self, /, started_at: float, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
             """Send pre-built output items with retry and chunking."""
             ...
@@ -467,9 +465,9 @@ class ContainerIOManager:
             """Send pre-built output items with retry and chunking."""
             ...
 
-    _send_outputs: ___send_outputs_spec[typing_extensions.Self]
+    _send_outputs: ___send_outputs_spec
 
-    class __handle_user_exception_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __handle_user_exception_spec(typing_extensions.Protocol):
         def __call__(self, /) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]:
             """Sets the task as failed in a way where it's not retried.
 
@@ -486,9 +484,9 @@ class ContainerIOManager:
             """
             ...
 
-    handle_user_exception: __handle_user_exception_spec[typing_extensions.Self]
+    handle_user_exception: __handle_user_exception_spec
 
-    class __handle_input_exception_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __handle_input_exception_spec(typing_extensions.Protocol):
         def __call__(
             self, /, io_context: IOContext, started_at: float
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]:
@@ -499,23 +497,23 @@ class ContainerIOManager:
             """Handle an exception while processing a function input."""
             ...
 
-    handle_input_exception: __handle_input_exception_spec[typing_extensions.Self]
+    handle_input_exception: __handle_input_exception_spec
 
     def exit_context(self, started_at, input_ids: list[str]): ...
 
-    class __push_outputs_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __push_outputs_spec(typing_extensions.Protocol):
         def __call__(self, /, io_context: IOContext, started_at: float, output_data: list[typing.Any]) -> None: ...
         async def aio(self, /, io_context: IOContext, started_at: float, output_data: list[typing.Any]) -> None: ...
 
-    push_outputs: __push_outputs_spec[typing_extensions.Self]
+    push_outputs: __push_outputs_spec
 
-    class __memory_restore_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __memory_restore_spec(typing_extensions.Protocol):
         def __call__(self, /) -> None: ...
         async def aio(self, /) -> None: ...
 
-    memory_restore: __memory_restore_spec[typing_extensions.Self]
+    memory_restore: __memory_restore_spec
 
-    class __memory_snapshot_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __memory_snapshot_spec(typing_extensions.Protocol):
         def __call__(self, /) -> None:
             """Message server indicating that function is ready to be checkpointed."""
             ...
@@ -524,9 +522,9 @@ class ContainerIOManager:
             """Message server indicating that function is ready to be checkpointed."""
             ...
 
-    memory_snapshot: __memory_snapshot_spec[typing_extensions.Self]
+    memory_snapshot: __memory_snapshot_spec
 
-    class __volume_commit_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __volume_commit_spec(typing_extensions.Protocol):
         def __call__(self, /, volume_ids: list[str]) -> None:
             """Perform volume commit for given `volume_ids`.
             Only used on container exit to persist uncommitted changes on behalf of user.
@@ -539,13 +537,13 @@ class ContainerIOManager:
             """
             ...
 
-    volume_commit: __volume_commit_spec[typing_extensions.Self]
+    volume_commit: __volume_commit_spec
 
-    class __interact_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __interact_spec(typing_extensions.Protocol):
         def __call__(self, /, from_breakpoint: bool = False): ...
         async def aio(self, /, from_breakpoint: bool = False): ...
 
-    interact: __interact_spec[typing_extensions.Self]
+    interact: __interact_spec
 
     @property
     def target_concurrency(self) -> int: ...

{modal-1.2.7.dev10 → modal-1.2.7.dev12}/modal/_serialization.py

@@ -420,7 +420,8 @@ def check_valid_cls_constructor_arg(key, obj):
     try:
         ClsConstructorPickler(buf).dump(obj)
         return True
-    except (AttributeError, ValueError):
+    except (AttributeError, ValueError, pickle.PicklingError):
+        # Python 3.14+ now raises an PicklingError for certain types of `dump` failures
         raise ValueError(
             f"Only pickle-able types are allowed in remote class constructors: argument {key} of type {type(obj)}."
         )

{modal-1.2.7.dev10 → modal-1.2.7.dev12}/modal/_utils/function_utils.py

@@ -8,7 +8,6 @@ from enum import Enum
 from pathlib import Path, PurePosixPath
 from typing import Any, Callable, Literal, Optional
 
-from grpclib import GRPCError
 from grpclib.exceptions import StreamTerminatedError
 
 import modal_proto
@@ -29,9 +28,11 @@ from ..exception import (
     DeserializationError,
     ExecutionError,
     FunctionTimeoutError,
+    InternalError,
     InternalFailure,
     InvalidError,
     RemoteError,
+    ServiceError,
 )
 from ..mount import ROOT_DIR, _is_modal_path, _Mount
 from .blob_utils import (
@@ -39,7 +40,6 @@ from .blob_utils import (
     blob_download,
     blob_upload_with_r2_failure_info,
 )
-from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES
 
 if typing.TYPE_CHECKING:
     import modal._functions
@@ -437,15 +437,14 @@ async def _stream_function_call_data(
 
                 last_index = chunk.index
                 yield message
-        except (GRPCError, StreamTerminatedError) as exc:
+        except (ServiceError, InternalError, StreamTerminatedError) as exc:
             if retries_remaining > 0:
                 retries_remaining -= 1
-                if isinstance(exc, GRPCError):
-                    if exc.status in RETRYABLE_GRPC_STATUS_CODES:
-                        logger.debug(f"{variant} stream retrying with delay {delay_ms}ms due to {exc}")
-                        await asyncio.sleep(delay_ms / 1000)
-                        delay_ms = min(1000, delay_ms * 10)
-                        continue
+                if isinstance(exc, (ServiceError, InternalError)):
+                    logger.debug(f"{variant} stream retrying with delay {delay_ms}ms due to {exc}")
+                    await asyncio.sleep(delay_ms / 1000)
+                    delay_ms = min(1000, delay_ms * 10)
+                    continue
                 elif isinstance(exc, StreamTerminatedError):
                     continue
             raise

{modal-1.2.7.dev10 → modal-1.2.7.dev12}/modal/_utils/rand_pb_testing.py

@@ -45,7 +45,14 @@ def _fill(msg, desc: Descriptor, rand: Random) -> None:
         if field.containing_oneof is not None and field.name not in oneof_fields:
             continue
         is_message = field.type == FieldDescriptor.TYPE_MESSAGE
-        is_repeated = field.label == FieldDescriptor.LABEL_REPEATED
+
+        # In the C implemenation of protobuf for Python 3.14, it raises a depreation
+        # warning when labels is accessed, but it does not clean up the exception state,
+        # causing an SystemError.
+        if hasattr(field, "is_repeated"):
+            is_repeated = field.is_repeated  # type: ignore
+        else:
+            is_repeated = field.label == FieldDescriptor.LABEL_REPEATED
         if is_message:
             msg_field = getattr(msg, field.name)
             if is_repeated: