modAL 1.0.5__tar.gz → 1.0.5.dev1__tar.gz

{modal-1.0.5 → modal-1.0.5.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.0.5
+Version: 1.0.5.dev1
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0
@@ -19,7 +19,7 @@ License-File: LICENSE
 Requires-Dist: aiohttp
 Requires-Dist: certifi
 Requires-Dist: click~=8.1.0
-Requires-Dist: grpclib<0.4.9,>=0.4.7
+Requires-Dist: grpclib==0.4.7
 Requires-Dist: protobuf!=4.24.0,<7.0,>=3.19
 Requires-Dist: rich>=12.0.0
 Requires-Dist: synchronicity~=0.9.15

{modal-1.0.5 → modal-1.0.5.dev1}/modal/_clustered_functions.pyi

@@ -3,22 +3,12 @@ import typing
 import typing_extensions
 
 class ClusterInfo:
-    """ClusterInfo(rank: int, container_ips: list[str])"""
-
     rank: int
     container_ips: list[str]
 
-    def __init__(self, rank: int, container_ips: list[str]) -> None:
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    def __repr__(self):
-        """Return repr(self)."""
-        ...
-
-    def __eq__(self, other):
-        """Return self==value."""
-        ...
+    def __init__(self, rank: int, container_ips: list[str]) -> None: ...
+    def __repr__(self): ...
+    def __eq__(self, other): ...
 
 def get_cluster_info() -> ClusterInfo: ...
 async def _initialize_clustered_function(client: modal.client._Client, task_id: str, world_size: int): ...

{modal-1.0.5 → modal-1.0.5.dev1}/modal/_functions.py

@@ -15,6 +15,7 @@ import typing_extensions
 from google.protobuf.message import Message
 from grpclib import GRPCError, Status
 from synchronicity.combined_types import MethodWithAio
+from synchronicity.exceptions import UserCodeException
 
 from modal_proto import api_pb2
 from modal_proto.modal_api_grpc import ModalClientModal
@@ -62,6 +63,8 @@ from .cloud_bucket_mount import _CloudBucketMount, cloud_bucket_mounts_to_proto
 from .config import config
 from .exception import (
     ExecutionError,
+    FunctionTimeoutError,
+    InternalFailure,
     InvalidError,
     NotFoundError,
     OutputExpiredError,
@@ -141,13 +144,7 @@ class _Invocation:
         stub = client.stub
 
         function_id = function.object_id
-        item = await _create_input(
-            args,
-            kwargs,
-            stub,
-            method_name=function._use_method_name,
-            function_call_invocation_type=function_call_invocation_type,
-        )
+        item = await _create_input(args, kwargs, stub, method_name=function._use_method_name)
 
         request = api_pb2.FunctionMapRequest(
             function_id=function_id,
@@ -260,7 +257,7 @@ class _Invocation:
             request,
         )
 
-    async def _get_single_output(self, expected_jwt: Optional[str] = None) -> api_pb2.FunctionGetOutputsItem:
+    async def _get_single_output(self, expected_jwt: Optional[str] = None) -> Any:
         # waits indefinitely for a single result for the function, and clear the outputs buffer after
         item: api_pb2.FunctionGetOutputsItem = (
             await self.pop_function_call_outputs(
@@ -269,7 +266,7 @@ class _Invocation:
                 input_jwts=[expected_jwt] if expected_jwt else None,
             )
         ).outputs[0]
-        return item
+        return await _process_result(item.result, item.data_format, self.stub, self.client)
 
     async def run_function(self) -> Any:
         # Use retry logic only if retry policy is specified and
@@ -281,30 +278,23 @@ class _Invocation:
             or ctx.function_call_invocation_type != api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC
             or not ctx.sync_client_retries_enabled
         ):
-            item = await self._get_single_output()
-            return await _process_result(item.result, item.data_format, self.stub, self.client)
+            return await self._get_single_output()
 
         # User errors including timeouts are managed by the user specified retry policy.
         user_retry_manager = RetryManager(ctx.retry_policy)
 
         while True:
-            item = await self._get_single_output(ctx.input_jwt)
-            if item.result.status in (
-                api_pb2.GenericResult.GENERIC_STATUS_SUCCESS,
-                api_pb2.GenericResult.GENERIC_STATUS_TERMINATED,
-            ):
-                # success or cancellations are "final" results
-                return await _process_result(item.result, item.data_format, self.stub, self.client)
-
-            if item.result.status != api_pb2.GenericResult.GENERIC_STATUS_INTERNAL_FAILURE:
-                # non-internal failures get a delay before retrying
+            try:
+                return await self._get_single_output(ctx.input_jwt)
+            except (UserCodeException, FunctionTimeoutError) as exc:
                 delay_ms = user_retry_manager.get_delay_ms()
                 if delay_ms is None:
-                    # no more retries, this should raise an error when the non-success status is converted
-                    # to an exception:
-                    return await _process_result(item.result, item.data_format, self.stub, self.client)
+                    raise exc
                 await asyncio.sleep(delay_ms / 1000)
-
+            except InternalFailure:
+                # For system failures on the server, we retry immediately,
+                # and the failure does not count towards the retry policy.
+                pass
             await self._retry_input()
 
     async def poll_function(self, timeout: Optional[float] = None):
@@ -362,14 +352,12 @@ class _InputPlaneInvocation:
         client: _Client,
         input_item: api_pb2.FunctionPutInputsItem,
         function_id: str,
-        input_plane_region: str,
     ):
         self.stub = stub
         self.client = client  # Used by the deserializer.
         self.attempt_token = attempt_token
         self.input_item = input_item
         self.function_id = function_id
-        self.input_plane_region = input_plane_region
 
     @staticmethod
     async def create(
@@ -379,27 +367,21 @@ class _InputPlaneInvocation:
         *,
         client: _Client,
         input_plane_url: str,
-        input_plane_region: str,
     ) -> "_InputPlaneInvocation":
         stub = await client.get_stub(input_plane_url)
 
         function_id = function.object_id
-        control_plane_stub = client.stub
-        # Note: Blob upload is done on the control plane stub, not the input plane stub!
-        input_item = await _create_input(args, kwargs, control_plane_stub, method_name=function._use_method_name)
+        input_item = await _create_input(args, kwargs, stub, method_name=function._use_method_name)
 
         request = api_pb2.AttemptStartRequest(
             function_id=function_id,
             parent_input_id=current_input_id() or "",
             input=input_item,
         )
-        metadata: list[tuple[str, str]] = []
-        if input_plane_region and input_plane_region != "":
-            metadata.append(("x-modal-input-plane-region", input_plane_region))
-        response = await retry_transient_errors(stub.AttemptStart, request, metadata=metadata)
+        response = await retry_transient_errors(stub.AttemptStart, request)
         attempt_token = response.attempt_token
 
-        return _InputPlaneInvocation(stub, attempt_token, client, input_item, function_id, input_plane_region)
+        return _InputPlaneInvocation(stub, attempt_token, client, input_item, function_id)
 
     async def run_function(self) -> Any:
         # This will retry when the server returns GENERIC_STATUS_INTERNAL_FAILURE, i.e. lost inputs or worker preemption
@@ -411,41 +393,33 @@ class _InputPlaneInvocation:
                 timeout_secs=OUTPUTS_TIMEOUT,
                 requested_at=time.time(),
             )
-            metadata: list[tuple[str, str]] = []
-            if self.input_plane_region and self.input_plane_region != "":
-                metadata.append(("x-modal-input-plane-region", self.input_plane_region))
             await_response: api_pb2.AttemptAwaitResponse = await retry_transient_errors(
                 self.stub.AttemptAwait,
                 await_request,
                 attempt_timeout=OUTPUTS_TIMEOUT + ATTEMPT_TIMEOUT_GRACE_PERIOD,
-                metadata=metadata,
             )
 
-            if await_response.HasField("output"):
-                if await_response.output.result.status == api_pb2.GenericResult.GENERIC_STATUS_INTERNAL_FAILURE:
-                    internal_failure_count += 1
-                    # Limit the number of times we retry
-                    if internal_failure_count < MAX_INTERNAL_FAILURE_COUNT:
-                        # For system failures on the server, we retry immediately,
-                        # and the failure does not count towards the retry policy.
-                        retry_request = api_pb2.AttemptRetryRequest(
-                            function_id=self.function_id,
-                            parent_input_id=current_input_id() or "",
-                            input=self.input_item,
-                            attempt_token=self.attempt_token,
-                        )
-                        # TODO(ryan): Add exponential backoff?
-                        retry_response = await retry_transient_errors(
-                            self.stub.AttemptRetry,
-                            retry_request,
-                            metadata=metadata,
-                        )
-                        self.attempt_token = retry_response.attempt_token
-                        continue
-
-                return await _process_result(
-                    await_response.output.result, await_response.output.data_format, self.stub, self.client
+            try:
+                if await_response.HasField("output"):
+                    return await _process_result(
+                        await_response.output.result, await_response.output.data_format, self.stub, self.client
+                    )
+            except InternalFailure as e:
+                internal_failure_count += 1
+                # Limit the number of times we retry
+                if internal_failure_count >= MAX_INTERNAL_FAILURE_COUNT:
+                    raise e
+                # For system failures on the server, we retry immediately,
+                # and the failure does not count towards the retry policy.
+                retry_request = api_pb2.AttemptRetryRequest(
+                    function_id=self.function_id,
+                    parent_input_id=current_input_id() or "",
+                    input=self.input_item,
+                    attempt_token=self.attempt_token,
                 )
+                # TODO(ryan): Add exponential backoff?
+                retry_response = await retry_transient_errors(self.stub.AttemptRetry, retry_request)
+                self.attempt_token = retry_response.attempt_token
 
 
 # Wrapper type for api_pb2.FunctionStats
@@ -799,7 +773,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     req.method_definitions[method_name].CopyFrom(method_definition)
             elif webhook_config:
                 req.webhook_config.CopyFrom(webhook_config)
-
             response = await retry_transient_errors(resolver.client.stub.FunctionPrecreate, req)
             self._hydrate(response.function_id, resolver.client, response.handle_metadata)
 
@@ -854,7 +827,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         mount_path=path,
                         volume_id=volume.object_id,
                         allow_background_commits=True,
-                        read_only=volume._read_only,
                     )
                     for path, volume in validated_volumes_no_cloud_buckets
                 ]
@@ -1108,7 +1080,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         mount_path=path,
                         volume_id=volume.object_id,
                         allow_background_commits=True,
-                        read_only=volume._read_only,
                     )
                     for path, volume in options.validated_volumes
                 ]
@@ -1281,9 +1252,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     ) -> "_Function":
         """Reference a Function from a deployed App by its name.
 
-        This is a lazy method that defers hydrating the local
-        object with metadata from Modal servers until the first
-        time it is actually used.
+        In contrast to `modal.Function.lookup`, this is a lazy method
+        that defers hydrating the local object with metadata from
+        Modal servers until the first time it is actually used.
 
         ```python
         f = modal.Function.from_name("other-app", "function")
@@ -1406,7 +1377,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._method_handle_metadata = dict(metadata.method_handle_metadata)
         self._definition_id = metadata.definition_id
         self._input_plane_url = metadata.input_plane_url
-        self._input_plane_region = metadata.input_plane_region
 
     def _get_metadata(self):
         # Overridden concrete implementation of base class method
@@ -1422,7 +1392,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             method_handle_metadata=self._method_handle_metadata,
             function_schema=self._metadata.function_schema if self._metadata else None,
             input_plane_url=self._input_plane_url,
-            input_plane_region=self._input_plane_region,
         )
 
     def _check_no_web_url(self, fn_name: str):
@@ -1469,11 +1438,7 @@ Use the `Function.get_web_url()` method instead.
 
     @live_method_gen
     async def _map(
-        self,
-        input_queue: _SynchronizedQueue,
-        order_outputs: bool,
-        return_exceptions: bool,
-        wrap_returned_exceptions: bool,
+        self, input_queue: _SynchronizedQueue, order_outputs: bool, return_exceptions: bool
     ) -> AsyncGenerator[Any, None]:
         """mdmd:hidden
 
@@ -1501,7 +1466,6 @@ Use the `Function.get_web_url()` method instead.
                 self.client,
                 order_outputs,
                 return_exceptions,
-                wrap_returned_exceptions,
                 count_update_callback,
                 api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC,
             )
@@ -1518,7 +1482,6 @@ Use the `Function.get_web_url()` method instead.
                 kwargs,
                 client=self.client,
                 input_plane_url=self._input_plane_url,
-                input_plane_region=self._input_plane_region,
             )
         else:
             invocation = await _Invocation.create(
@@ -1699,9 +1662,8 @@ Use the `Function.get_web_url()` method instead.
     async def spawn(self, *args: P.args, **kwargs: P.kwargs) -> "_FunctionCall[ReturnType]":
         """Calls the function with the given arguments, without waiting for the results.
 
-        Returns a [`modal.FunctionCall`](https://modal.com/docs/reference/modal.FunctionCall) object
-        that can later be polled or waited for using
-        [`.get(timeout=...)`](https://modal.com/docs/reference/modal.FunctionCall#get).
+        Returns a [`modal.FunctionCall`](/docs/reference/modal.FunctionCall) object, that can later be polled or
+        waited for using [`.get(timeout=...)`](/docs/reference/modal.FunctionCall#get).
         Conceptually similar to `multiprocessing.pool.apply_async`, or a Future/Promise in other contexts.
         """
         self._check_no_web_url("spawn")
@@ -1777,7 +1739,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         """Returns a structure representing the call graph from a given root
         call ID, along with the status of execution for each node.
 
-        See [`modal.call_graph`](https://modal.com/docs/reference/modal.call_graph) reference page
+        See [`modal.call_graph`](/docs/reference/modal.call_graph) reference page
         for documentation on the structure of the returned `InputInfo` items.
         """
         assert self._client and self._client.stub
@@ -1791,7 +1753,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         terminate_containers: bool = False,
     ):
         """Cancels the function call, which will stop its execution and mark its inputs as
-        [`TERMINATED`](https://modal.com/docs/reference/modal.call_graph#modalcall_graphinputstatus).
+        [`TERMINATED`](/docs/reference/modal.call_graph#modalcall_graphinputstatus).
 
         If `terminate_containers=True` - the containers running the cancelled inputs are all terminated
         causing any non-cancelled inputs on those containers to be rescheduled in new containers.

{modal-1.0.5 → modal-1.0.5.dev1}/modal/_partial_function.py

@@ -538,7 +538,7 @@ def _wsgi_app(
     Web Server Gateway Interface (WSGI) is a standard for synchronous Python web apps.
     It has been [succeeded by the ASGI interface](https://asgi.readthedocs.io/en/latest/introduction.html#wsgi-compatibility)
     which is compatible with ASGI and supports additional functionality such as web sockets.
-    Modal supports ASGI via [`asgi_app`](https://modal.com/docs/reference/modal.asgi_app).
+    Modal supports ASGI via [`asgi_app`](/docs/reference/modal.asgi_app).
 
     **Usage:**