modal 0.73.26__py3-none-any.whl → 0.73.28__py3-none-any.whl

modal/_runtime/container_io_manager.py

@@ -5,7 +5,6 @@ import inspect
 import json
 import math
 import os
-import signal
 import sys
 import time
 import traceback
@@ -382,22 +381,9 @@ class _ContainerIOManager:
             # response.cancel_input_event.terminate_containers is never set, the server gets the worker to handle it.
             input_ids_to_cancel = response.cancel_input_event.input_ids
             if input_ids_to_cancel:
-                if self._max_concurrency > 1:
-                    for input_id in input_ids_to_cancel:
-                        if input_id in self.current_inputs:
-                            self.current_inputs[input_id].cancel()
-
-                elif self.current_input_id and self.current_input_id in input_ids_to_cancel:
-                    # This goes to a registered signal handler for sync Modal functions, or to the
-                    # `SignalHandlingEventLoop` for async functions.
-                    #
-                    # We only send this signal on functions that do not have concurrent inputs enabled.
-                    # This allows us to do fine-grained input cancellation. On sync functions, the
-                    # SIGUSR1 signal should interrupt the main thread where user code is running,
-                    # raising an InputCancellation() exception. On async functions, the signal should
-                    # reach a handler in SignalHandlingEventLoop, which cancels the task.
-                    logger.warning(f"Received a cancellation signal while processing input {self.current_input_id}")
-                    os.kill(os.getpid(), signal.SIGUSR1)
+                for input_id in input_ids_to_cancel:
+                    if input_id in self.current_inputs:
+                        self.current_inputs[input_id].cancel()
             return True
         return False
 

modal/_runtime/user_code_imports.py

@@ -10,10 +10,10 @@ import modal._runtime.container_io_manager
 import modal.cls
 from modal import Function
 from modal._functions import _Function
+from modal._partial_function import _find_partial_methods_for_user_cls, _PartialFunctionFlags
 from modal._utils.async_utils import synchronizer
 from modal._utils.function_utils import LocalFunctionError, is_async as get_is_async, is_global_object
 from modal.exception import ExecutionError, InvalidError
-from modal.partial_function import _find_partial_methods_for_user_cls, _PartialFunctionFlags
 from modal_proto import api_pb2
 
 if typing.TYPE_CHECKING:
@@ -139,7 +139,7 @@ class ImportedClass(Service):
     app: Optional["modal.app._App"]
     code_deps: Optional[Sequence["modal._object._Object"]]
 
-    _partial_functions: dict[str, "modal.partial_function._PartialFunction"]
+    _partial_functions: dict[str, "modal._partial_function._PartialFunction"]
 
     def get_finalized_functions(
         self, fun_def: api_pb2.Function, container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"

modal/app.py

@@ -23,6 +23,11 @@ from modal_proto import api_pb2
 from ._functions import _Function
 from ._ipython import is_notebook
 from ._object import _get_environment_name, _Object
+from ._partial_function import (
+    _find_partial_methods_for_user_cls,
+    _PartialFunction,
+    _PartialFunctionFlags,
+)
 from ._utils.async_utils import synchronize_api
 from ._utils.deprecation import deprecation_error, deprecation_warning, renamed_parameter
 from ._utils.function_utils import FunctionInfo, is_global_object, is_method_fn
@@ -38,12 +43,7 @@ from .gpu import GPU_T
 from .image import _Image
 from .mount import _Mount
 from .network_file_system import _NetworkFileSystem
-from .partial_function import (
-    PartialFunction,
-    _find_partial_methods_for_user_cls,
-    _PartialFunction,
-    _PartialFunctionFlags,
-)
+from .partial_function import PartialFunction
 from .proxy import _Proxy
 from .retries import Retries
 from .running_app import RunningApp

modal/client.pyi

@@ -27,7 +27,7 @@ class _Client:
     _snapshotted: bool
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.26"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.28"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -85,7 +85,7 @@ class Client:
     _snapshotted: bool
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.26"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.28"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/cls.py

@@ -13,6 +13,12 @@ from modal_proto import api_pb2
 
 from ._functions import _Function, _parse_retries
 from ._object import _Object
+from ._partial_function import (
+    _find_callables_for_obj,
+    _find_partial_methods_for_user_cls,
+    _PartialFunction,
+    _PartialFunctionFlags,
+)
 from ._resolver import Resolver
 from ._resources import convert_fn_config_to_resources_config
 from ._serialization import check_valid_cls_constructor_arg
@@ -25,12 +31,6 @@ from .client import _Client
 from .config import config
 from .exception import ExecutionError, InvalidError, NotFoundError
 from .gpu import GPU_T
-from .partial_function import (
-    _find_callables_for_obj,
-    _find_partial_methods_for_user_cls,
-    _PartialFunction,
-    _PartialFunctionFlags,
-)
 from .retries import Retries
 from .secret import _Secret
 from .volume import _Volume
@@ -674,8 +674,7 @@ class _Cls(_Object, type_prefix="cs"):
         )
 
     def __getattr__(self, k):
-        # Used by CLI and container entrypoint
-        # TODO: remove this method - access to attributes on classes should be discouraged
+        # TODO: remove this method - access to attributes on classes (not instances) should be discouraged
         if k in self._method_functions:
             deprecation_warning(
                 (2025, 1, 13),

modal/cls.pyi

@@ -3,6 +3,7 @@ import google.protobuf.message
 import inspect
 import modal._functions
 import modal._object
+import modal._partial_function
 import modal.app
 import modal.client
 import modal.functions
@@ -104,7 +105,7 @@ class _Cls(modal._object._Object):
 
     def _initialize_from_empty(self): ...
     def _initialize_from_other(self, other: _Cls): ...
-    def _get_partial_functions(self) -> dict[str, modal.partial_function._PartialFunction]: ...
+    def _get_partial_functions(self) -> dict[str, modal._partial_function._PartialFunction]: ...
     def _get_app(self) -> modal.app._App: ...
     def _get_user_cls(self) -> type: ...
     def _get_name(self) -> str: ...

modal/experimental.py

@@ -7,11 +7,11 @@ from modal_proto import api_pb2
 from ._clustered_functions import ClusterInfo, get_cluster_info as _get_cluster_info
 from ._functions import _Function
 from ._object import _get_environment_name
+from ._partial_function import _PartialFunction, _PartialFunctionFlags
 from ._runtime.container_io_manager import _ContainerIOManager
 from ._utils.async_utils import synchronizer
 from .client import _Client
 from .exception import InvalidError
-from .partial_function import _PartialFunction, _PartialFunctionFlags
 
 
 def stop_fetching_inputs():

modal/functions.pyi

@@ -200,11 +200,11 @@ class Function(
 
     _call_generator_nowait: ___call_generator_nowait_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
 
-    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, *args, **kwargs) -> typing.Generator[typing.Any, None, None]: ...
@@ -219,19 +219,19 @@ class Function(
         self, *args: modal._functions.P.args, **kwargs: modal._functions.P.kwargs
     ) -> modal._functions.OriginalReturnType: ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
     _experimental_spawn: ___experimental_spawn_spec[
-        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
+        modal._functions.ReturnType, modal._functions.P, typing_extensions.Self
     ]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
-    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]: ...