modAL 1.5.4__tar.gz → 1.5.4.dev1__tar.gz

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

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

{modal-1.5.4 → modal-1.5.4.dev1}/modal/_clustered_functions.py

@@ -2,7 +2,6 @@
 import os
 import socket
 from dataclasses import dataclass
-from typing import cast
 
 from modal._utils.async_utils import synchronize_api
 from modal.client import _Client
@@ -42,11 +41,9 @@ def get_fabric_peers() -> list[int]:
 async def _initialize_clustered_function(client: _Client, task_id: str, world_size: int):
     global cluster_info
 
-    def get_i6pn() -> str:
+    def get_i6pn():
         """Returns the ipv6 address assigned to this container."""
-        # An AF_INET6 result always carries a (host, port, flowinfo, scope_id) sockaddr,
-        # but getaddrinfo is typed for every address family, some of which lead with an int
-        return cast(str, socket.getaddrinfo("i6pn.modal.local", None, socket.AF_INET6)[0][4][0])
+        return socket.getaddrinfo("i6pn.modal.local", None, socket.AF_INET6)[0][4][0]
 
     hostname = socket.gethostname()
     container_ip = get_i6pn()
@@ -80,9 +77,9 @@ async def _initialize_clustered_function(client: _Client, task_id: str, world_si
         cluster_info = ClusterInfo(
             rank=resp.cluster_rank,
             cluster_id=resp.cluster_id,
-            container_ips=list(resp.container_ips),
-            container_ipv4_ips=list(resp.container_ipv4_ips),
-            fabric_ids=list(resp.fabric_ids),
+            container_ips=resp.container_ips,
+            container_ipv4_ips=resp.container_ipv4_ips,
+            fabric_ids=resp.fabric_ids,
         )
     else:
         cluster_info = ClusterInfo(

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

@@ -45,7 +45,7 @@ from ._utils.async_utils import (
     synchronizer,
     warn_if_generator_is_not_consumed,
 )
-from ._utils.blob_utils import MAX_ASYNC_OBJECT_SIZE_BYTES, MAX_OBJECT_SIZE_BYTES
+from ._utils.blob_utils import MAX_OBJECT_SIZE_BYTES
 from ._utils.function_utils import (
     ATTEMPT_TIMEOUT_GRACE_PERIOD,
     OUTPUTS_TIMEOUT,
@@ -56,9 +56,7 @@ from ._utils.function_utils import (
     _stream_function_call_data,
     get_function_type,
     is_async,
-    normalize_fractional_target_concurrency,
     parse_gpu_config,
-    validate_target_concurrency,
 )
 from ._utils.grpc_utils import Retry, RetryWarningMessage
 from ._utils.mount_utils import validate_network_file_systems, validate_volumes, validate_volumes_by_object_id
@@ -95,7 +93,7 @@ from .proxy import _Proxy
 from .retries import Retries, RetryManager
 from .schedule import Schedule
 from .secret import _Secret
-from .types import FunctionAutoscalerSettings, FunctionStats, ServerAutoscalerSettings
+from .types import FunctionStats
 from .volume import _Volume, _volume_to_mount_proto
 
 if TYPE_CHECKING:
@@ -426,7 +424,6 @@ class _InputPlaneInvocation:
         client: _Client,
         input_plane_url: str,
         input_plane_region: str,
-        function_call_invocation_type: "api_pb2.FunctionCallInvocationType.ValueType",
     ) -> "_InputPlaneInvocation":
         stub = await client.get_stub(input_plane_url)
 
@@ -438,7 +435,6 @@ class _InputPlaneInvocation:
             kwargs,
             control_plane_stub,
             function=function,
-            function_call_invocation_type=function_call_invocation_type,
         )
 
         request = api_pb2.AttemptStartRequest(
@@ -640,12 +636,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         await self.hydrate()
         if not self._app_id:
             raise ExecutionError("app_id should have been set during function hydration")
-        return _LogQueryData(
-            self.client,
-            self._app_id,
-            LogsFilters(function_id=self.object_id),
-            source_object_id=self.object_id,
-        )
+        return _LogQueryData(self.client, self._app_id, LogsFilters(function_id=self.object_id))
 
     @property
     def logs(self) -> _FunctionLogsManager:
@@ -688,7 +679,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         scaleup_window: int | None = None,
         scaledown_window: int | None = None,
         max_concurrent_inputs: int | None = None,
-        target_concurrent_inputs: float | None = None,
+        target_concurrent_inputs: int | None = None,
         batch_max_size: int | None = None,
         batch_wait_ms: int | None = None,
         cloud: str | None = None,
@@ -796,17 +787,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             scaledown_window=scaledown_window,
         )
 
-        target_concurrent_inputs_int = 0
-        if target_concurrent_inputs is not None:
-            if is_server:
-                validate_target_concurrency(target_concurrent_inputs, "target_inputs", allow_fractional=True)
-                autoscaler_settings.target_concurrency_float = normalize_fractional_target_concurrency(
-                    target_concurrent_inputs
-                )
-            else:
-                validate_target_concurrency(target_concurrent_inputs, "target_inputs", allow_fractional=False)
-                target_concurrent_inputs_int = int(target_concurrent_inputs)
-
         # For clustered functions, container settings must be multiples of cluster_size
         if cluster_size is not None and cluster_size > 1:
             for field in ["min_containers", "max_containers", "buffer_containers"]:
@@ -1032,7 +1012,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     app_name=app_name,
                     is_builder_function=is_builder_function,
                     max_concurrent_inputs=max_concurrent_inputs or 0,
-                    target_concurrent_inputs=target_concurrent_inputs_int,
+                    target_concurrent_inputs=target_concurrent_inputs or 0,
                     batch_max_size=batch_max_size or 0,
                     batch_linger_ms=batch_wait_ms or 0,
                     worker_id=config.get("worker_id"),
@@ -1192,25 +1172,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return obj
 
     async def _update_autoscaler(
-        self,
-        *,
-        min_containers: int | None = None,
-        max_containers: int | None = None,
-        buffer_containers: int | None = None,
-        scaledown_window: int | None = None,
-    ) -> FunctionAutoscalerSettings:
-        settings = api_pb2.AutoscalerSettings(
-            min_containers=min_containers,
-            max_containers=max_containers,
-            buffer_containers=buffer_containers,
-            scaledown_window=scaledown_window,
-        )
-        request = api_pb2.FunctionUpdateSchedulingParamsRequest(function_id=self.object_id, settings=settings)
-        response = await self.client.stub.FunctionUpdateSchedulingParams(request)
-
-        return FunctionAutoscalerSettings._from_proto(response.current_settings)
-
-    async def _update_autoscaler_server(
         self,
         *,
         min_containers: int | None = None,
@@ -1218,22 +1179,21 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         buffer_containers: int | None = None,
         scaleup_window: int | None = None,
         scaledown_window: int | None = None,
-        target_concurrency: float | None = None,
-    ) -> ServerAutoscalerSettings:
+        target_concurrency: int | None = None,
+    ) -> None:
         settings = api_pb2.AutoscalerSettings(
             min_containers=min_containers,
             max_containers=max_containers,
             buffer_containers=buffer_containers,
             scaleup_window=scaleup_window,
             scaledown_window=scaledown_window,
+            target_concurrency=target_concurrency,
         )
-        if target_concurrency is not None:
-            validate_target_concurrency(target_concurrency, "target_concurrency", allow_fractional=True)
-            settings.target_concurrency_float = normalize_fractional_target_concurrency(target_concurrency)
         request = api_pb2.FunctionUpdateSchedulingParamsRequest(function_id=self.object_id, settings=settings)
-        response = await self.client.stub.FunctionUpdateSchedulingParams(request)
+        await self.client.stub.FunctionUpdateSchedulingParams(request)
 
-        return ServerAutoscalerSettings._from_proto(response.current_settings)
+        # One idea would be for FunctionUpdateScheduleParams to return the current (coalesced) settings
+        # and then we could return them here (would need some ad hoc dataclass, which I don't love)
 
     @live_method
     async def update_autoscaler(
@@ -1243,7 +1203,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         max_containers: int | None = None,
         buffer_containers: int | None = None,
         scaledown_window: int | None = None,
-    ) -> FunctionAutoscalerSettings:
+    ) -> None:
         """Override the current autoscaler behavior for this Function.
 
         Unspecified parameters will retain their current value, i.e. either the static value
@@ -1258,10 +1218,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             buffer_containers: Extra containers to keep warm beyond current demand.
             scaledown_window: Maximum duration (in seconds) idle containers wait before scaling down.
 
-        Returns:
-            A `FunctionAutoscalerSettings` dataclass which contains the current autoscaler settings
-            of this Function after the call.
-
         Examples:
             ```python notest
             f = modal.Function.from_name("my-app", "function")
@@ -1281,7 +1237,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         if self._is_method:
             raise InvalidError("Cannot call .update_autoscaler() on a method. Call it on the class instance instead.")
 
-        return await self._update_autoscaler(
+        await self._update_autoscaler(
             min_containers=min_containers,
             max_containers=max_containers,
             buffer_containers=buffer_containers,
@@ -1471,11 +1427,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._max_object_size_bytes = (
             metadata.max_object_size_bytes if metadata.HasField("max_object_size_bytes") else MAX_OBJECT_SIZE_BYTES
         )
-        self._max_async_object_size_bytes = (
-            metadata.max_async_object_size_bytes
-            if metadata.HasField("max_async_object_size_bytes")
-            else MAX_ASYNC_OBJECT_SIZE_BYTES
-        )
         self._experimental_flash_urls = metadata._experimental_flash_urls
         self._app_id = metadata.app_id or None
 
@@ -1500,7 +1451,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             input_plane_url=self._input_plane_url,
             input_plane_region=self._input_plane_region,
             max_object_size_bytes=self._max_object_size_bytes,
-            max_async_object_size_bytes=self._max_async_object_size_bytes,
             _experimental_flash_urls=self._experimental_flash_urls,
             supported_input_formats=self._metadata.supported_input_formats if self._metadata else [],
             supported_output_formats=self._metadata.supported_output_formats if self._metadata else [],
@@ -1764,7 +1714,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 client=self.client,
                 input_plane_url=self._input_plane_url,
                 input_plane_region=self._input_plane_region,
-                function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC,
             )
         else:
             invocation = await _Invocation.create(
@@ -1806,7 +1755,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 client=self.client,
                 input_plane_url=self._input_plane_url,
                 input_plane_region=self._input_plane_region,
-                function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC_LEGACY,
             )
         else:
             invocation = await _Invocation.create(
@@ -2082,12 +2030,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
             await self._hydrate_from_id_metadata()
         if not self._app_id:
             raise ExecutionError("app_id should have been set during function call hydration")
-        return _LogQueryData(
-            self.client,
-            self._app_id,
-            LogsFilters(function_call_id=self.object_id),
-            source_object_id=self.object_id,
-        )
+        return _LogQueryData(self.client, self._app_id, LogsFilters(function_call_id=self.object_id))
 
     @property
     def logs(self) -> _FunctionCallLogsManager:

{modal-1.5.4 → modal-1.5.4.dev1}/modal/_image.py

@@ -30,11 +30,9 @@ from modal_proto import api_pb2
 
 from ._environments import _get_environment_cached
 from ._load_context import LoadContext
-from ._logs_manager import _ImageLogsManager
 from ._object import _Object, live_method_gen
 from ._resolver import Resolver
 from ._serialization import get_preferred_payload_format, serialize
-from ._supports_logs import _ImageLogQueryData
 from ._utils.async_utils import TaskContext, deprecate_aio_usage, synchronizer
 from ._utils.blob_utils import MAX_OBJECT_SIZE_BYTES
 from ._utils.docker_utils import (
@@ -49,10 +47,10 @@ from .cloud_bucket_mount import _CloudBucketMount
 from .config import config, logger, user_config_path
 from .exception import (
     ExecutionError,
-    ImageBuildError,
     InternalError,
     InvalidError,
     NotFoundError,
+    RemoteError,
     ServiceError,
     VersionError,
 )
@@ -479,12 +477,6 @@ def _requires_image_instance(method):
     return wrapper
 
 
-@dataclass(frozen=True)
-class _FailedBuildAttempt:
-    image_id: str
-    client: _Client
-
-
 class _Image(_Object, type_prefix="im"):
     """Base class for container images to run functions in.
 
@@ -501,9 +493,6 @@ class _Image(_Object, type_prefix="im"):
     _added_python_source_set: frozenset[str]  # used to warn about missing mounts during auto-mount deprecation
     _metadata: api_pb2.ImageMetadata | None = None  # set on hydration, private for now
     _is_empty: bool
-    _build_steps: list[api_pb2.ImageBuildStep] | None = None
-    # A failed image ID is only queryable through the client that performed the build.
-    _failed_build_attempt: _FailedBuildAttempt | None = None
 
     def _initialize_from_empty(self):
         self.inside_exceptions = []
@@ -535,9 +524,6 @@ class _Image(_Object, type_prefix="im"):
         if metadata:
             assert isinstance(metadata, api_pb2.ImageMetadata)
             self._metadata = metadata
-        # Successful hydration supersedes diagnostic state retained from a failed build.
-        self._failed_build_attempt = None
-        self._build_steps = None
 
     def _add_mount_layer_or_copy(self, mount: _Mount, copy: bool = False):
         if copy:
@@ -766,12 +752,12 @@ class _Image(_Object, type_prefix="im"):
 
             if result.status == api_pb2.GenericResult.GENERIC_STATUS_FAILURE:
                 if result.exception:
-                    raise ImageBuildError(
-                        f"Image build for {image_id} failed with the exception:\n{result.exception}", image_id
-                    )
+                    raise RemoteError(f"Image build for {image_id} failed with the exception:\n{result.exception}")
                 else:
-                    msg = f"Image build for {image_id} failed.\nView the build logs:\n  modal image logs {image_id}"
-                    raise ImageBuildError(msg, image_id)
+                    msg = f"Image build for {image_id} failed. See build logs for more details."
+                    if not OutputManager.get().is_enabled:
+                        msg += " (Hint: Use `modal.enable_output()` to see logs from the process building the Image.)"
+                    raise RemoteError(msg)
             elif result.status == api_pb2.GenericResult.GENERIC_STATUS_TERMINATED:
                 msg = f"Image build for {image_id} terminated due to external shut-down. Please try again."
                 if result.exception:
@@ -779,16 +765,15 @@ class _Image(_Object, type_prefix="im"):
                         f"Image build for {image_id} terminated due to external shut-down with the exception:\n"
                         f"{result.exception}"
                     )
-                raise ImageBuildError(msg, image_id)
+                raise RemoteError(msg)
             elif result.status == api_pb2.GenericResult.GENERIC_STATUS_TIMEOUT:
-                raise ImageBuildError(
-                    f"Image build for {image_id} timed out. Please try again with a larger `timeout` parameter.",
-                    image_id,
+                raise RemoteError(
+                    f"Image build for {image_id} timed out. Please try again with a larger `timeout` parameter."
                 )
             elif result.status == api_pb2.GenericResult.GENERIC_STATUS_SUCCESS:
                 pass
             else:
-                raise ImageBuildError("Unknown status %s!" % result.status, image_id)
+                raise RemoteError("Unknown status %s!" % result.status)
 
             self._hydrate(image_id, load_context.client, metadata)
             local_mounts: set[_Mount] = set()
@@ -1079,18 +1064,8 @@ class _Image(_Object, type_prefix="im"):
 
         resolver = Resolver()
         async with TaskContext() as tc:
-            self._build_steps = None
-            self._failed_build_attempt = None
             load_context = LoadContext(task_context=tc).merged_with(app._root_load_context)
-            try:
-                await resolver.load(self, load_context)
-            except ImageBuildError as e:
-                self._failed_build_attempt = _FailedBuildAttempt(
-                    image_id=e.image_id,
-                    client=load_context.client,
-                )
-
-                raise
+            await resolver.load(self, load_context)
         return self
 
     @_requires_image_instance
@@ -3053,38 +3028,3 @@ class _Image(_Object, type_prefix="im"):
                 "Images cannot currently be hydrated on demand; you can build an Image by running an App that uses it."
             )
         return self
-
-    async def _resolve_image_id_client_for_logs(self) -> tuple[str, _Client]:
-        if self._failed_build_attempt is not None:
-            return self._failed_build_attempt.image_id, self._failed_build_attempt.client
-        if self._object_id is None:
-            raise InvalidError("Cannot fetch logs for an image that has not been built yet.")
-        if self._is_hydrated:
-            return self._object_id, self.client
-        # Use self._load_context_overrides to handle case of explicitly passed
-        # client in from_id
-        client = (await self._load_context_overrides.apply_defaults()).client
-        return self._object_id, client
-
-    async def _get_log_query_data(self) -> _ImageLogQueryData:
-        image_id, client = await self._resolve_image_id_client_for_logs()
-
-        if self._build_steps is None:
-            request = api_pb2.ImageBuildChainGetRequest(image_id=image_id)
-            response = await client.stub.ImageBuildChainGet(request)
-            self._build_steps = list(response.build_steps)
-        return _ImageLogQueryData(client, self._build_steps or [], image_id)
-
-    @property
-    def logs(self) -> _ImageLogsManager:
-        """Access logs for an `Image`.
-
-        Use [`fetch()`](#logsfetch)
-        to read logs for individual build layers and [`tail()`](#logstail)
-        to read the most recent logs.
-
-        See also:
-            - [`modal app logs`](https://modal.com/docs/cli/latest/app#modal-app-logs):
-              CLI access to logs for an App.
-        """
-        return _ImageLogsManager(self)

{modal-1.5.4 → modal-1.5.4.dev1}/modal/_logs.py

@@ -256,16 +256,13 @@ async def _refine_dense_ranges(
                 )
                 sub_resp = await client.stub.AppCountLogs(sub_req)
                 sub_ranges = _buckets_to_ranges(list(sub_resp.buckets), smaller_secs)
-                # Clamp the edge sub-ranges to the parent boundaries. Bucket
-                # alignment can make the first bucket begin before the parent
-                # (e.g. parent (6,12) with 4s buckets produces (4,8)) or make
-                # the last bucket end after it (e.g. parent (0,30) with 20s
-                # buckets produces (20,40)), causing overlaps with siblings.
+                # Clamp the last sub-range to the parent's end. When bucket_secs
+                # doesn't evenly divide the parent duration, the last bucket
+                # boundary overshoots (e.g. parent (0,30) with 20s buckets
+                # produces (20,40)), causing overlaps with sibling ranges.
                 if sub_ranges:
-                    first_start, first_end, first_count = sub_ranges[0]
-                    sub_ranges[0] = (max(first_start, start), first_end, first_count)
-                    last_start, last_end, last_count = sub_ranges[-1]
-                    sub_ranges[-1] = (last_start, min(last_end, end), last_count)
+                    s, _, c = sub_ranges[-1]
+                    sub_ranges[-1] = (s, min(s + smaller_secs, end), c)
                 return sub_ranges
 
         refine_set = {i for i, _ in to_refine}
@@ -413,6 +410,7 @@ async def fetch_logs(
 
     if until - since > _MAX_FETCH_RANGE:
         raise LogsFetchError(f"Time range cannot exceed {_MAX_FETCH_RANGE.days} days.")
+
     # Phase 1: Count logs per bucket
     bucket_secs = _pick_bucket_secs(since, until)
     count_req = api_pb2.AppCountLogsRequest(