modal 1.5.4.dev20__tar.gz → 1.5.4.dev22__tar.gz

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/PKG-INFO

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

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/_clustered_functions.py

@@ -2,6 +2,7 @@
 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
@@ -41,9 +42,11 @@ 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():
+    def get_i6pn() -> str:
         """Returns the ipv6 address assigned to this container."""
-        return socket.getaddrinfo("i6pn.modal.local", None, socket.AF_INET6)[0][4][0]
+        # 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])
 
     hostname = socket.gethostname()
     container_ip = get_i6pn()
@@ -77,9 +80,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=resp.container_ips,
-            container_ipv4_ips=resp.container_ipv4_ips,
-            fabric_ids=resp.fabric_ids,
+            container_ips=list(resp.container_ips),
+            container_ipv4_ips=list(resp.container_ipv4_ips),
+            fabric_ids=list(resp.fabric_ids),
         )
     else:
         cluster_info = ClusterInfo(

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/_functions.py

@@ -56,7 +56,9 @@ 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
@@ -681,7 +683,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: int | None = None,
+        target_concurrent_inputs: float | None = None,
         batch_max_size: int | None = None,
         batch_wait_ms: int | None = None,
         cloud: str | None = None,
@@ -789,6 +791,17 @@ 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"]:
@@ -1014,7 +1027,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 or 0,
+                    target_concurrent_inputs=target_concurrent_inputs_int,
                     batch_max_size=batch_max_size or 0,
                     batch_linger_ms=batch_wait_ms or 0,
                     worker_id=config.get("worker_id"),
@@ -1200,7 +1213,7 @@ 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: int | None = None,
+        target_concurrency: float | None = None,
     ) -> ServerAutoscalerSettings:
         settings = api_pb2.AutoscalerSettings(
             min_containers=min_containers,
@@ -1208,8 +1221,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             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)
 

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/_runtime/execution_context.py

@@ -120,3 +120,9 @@ def _import_context():
         yield
     finally:
         _is_currently_importing = False
+
+
+def _in_import_context() -> bool:
+    # Accessor rather than direct attribute reads, since module-level variables
+    # are not exposed in the generated .pyi stub for this module
+    return _is_currently_importing

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/_runtime/execution_context.pyi

@@ -75,6 +75,7 @@ def _set_current_context_ids(
     input_ids: list[str], function_call_ids: list[str], attempt_tokens: list[str]
 ) -> collections.abc.Callable[[], None]: ...
 def _import_context(): ...
+def _in_import_context() -> bool: ...
 
 _current_input_id: contextvars.ContextVar
 

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/_server.py

@@ -124,7 +124,7 @@ class _Server:
     async def update_autoscaler(
         self,
         *,
-        target_concurrency: int | None = None,
+        target_concurrency: float | None = None,
         min_containers: int | None = None,
         max_containers: int | None = None,
         buffer_containers: int | None = None,
@@ -140,7 +140,9 @@ class _Server:
         its static configuration.
 
         Args:
-            target_concurrency: Target number of concurrent requests per container.
+            target_concurrency:
+                Target number of concurrent requests per container. May be fractional, e.g. 1.5 to
+                target three concurrent requests per two containers.
             min_containers: Minimum number of containers to keep running regardless of demand.
             max_containers: Limit on the number of containers that can be concurrently running.
             buffer_containers: Extra containers to scale up beyond current demand.
@@ -167,6 +169,9 @@ class _Server:
             # Adjust Server autoscaling to target 20 concurrent requests per replica
             server.update_autoscaler(target_concurrency=20)
 
+            # Target three concurrent requests for every two containers
+            server.update_autoscaler(target_concurrency=1.5)
+
             # Disable the Server autoscaling by setting target_concurrency to 0
             server.update_autoscaler(target_concurrency=0)
             ```

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/_utils/function_utils.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2022
 import asyncio
 import inspect
+import math
 import os
 import typing
 from collections.abc import AsyncGenerator, Callable
@@ -81,6 +82,28 @@ def is_flash_object(experimental_options: dict[str, Any] | None, http_config: ap
     return bool(experimental_options and experimental_options.get("flash", False)) or http_config is not None
 
 
+def validate_target_concurrency(value: float, param_name: str, allow_fractional: bool) -> None:
+    """Validate a user-supplied target concurrency.
+
+    Only `@app.server` may use a fractional Flash autoscaling target.
+    """
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise InvalidError(f"The `{param_name}` argument must be a number, not {type(value).__name__}.")
+    if not math.isfinite(value):
+        raise InvalidError(f"The `{param_name}` argument must be finite, not {value}.")
+    if value < 0:
+        raise InvalidError(f"The `{param_name}` argument must be non-negative.")
+    if not allow_fractional and not isinstance(value, int):
+        raise InvalidError(
+            f"The `{param_name}` argument must be an integer; fractional values are only supported for Servers."
+        )
+
+
+def normalize_fractional_target_concurrency(value: float) -> float:
+    """Clamp (0, 1) up to 1 and round to the nearest hundredth for Flash targets."""
+    return 1.0 if 0 < value < 1 else round(float(value), 2)
+
+
 def is_method_fn(object_qual_name: str):
     # methods have names like Cls.foo.
     if "<locals>" in object_qual_name:

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/_utils/task_command_router_client.py

@@ -14,6 +14,7 @@ from contextlib import suppress
 from typing import BinaryIO, TypeVar
 
 import grpclib.client
+import grpclib.events
 from grpclib import GRPCError, Status
 from grpclib.exceptions import StreamTerminatedError
 

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/_utils/time_utils.py

@@ -8,7 +8,7 @@ def is_leap(year: int):
     return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
 
 
-def month_length(month: int, year: int):
+def month_length(month: int, year: int) -> int:
     match month:
         # January, March, May, July, August, October, December
         case 1 | 3 | 5 | 7 | 8 | 10 | 12:
@@ -22,6 +22,9 @@ def month_length(month: int, year: int):
         case 2:
             return 29 if is_leap(year) else 28
 
+        case _:
+            raise ValueError(f"Invalid month: {month}")
+
 
 # also accepts negative inputs for n_months
 def add_months(s: datetime, n_months: int):

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/_workspace.py

@@ -1,11 +1,14 @@
 # Copyright Modal Labs 2025
 import builtins
+import warnings
+from collections.abc import Mapping
 from datetime import datetime, timezone
+from decimal import Decimal
 from typing import Optional
 
 from google.protobuf.empty_pb2 import Empty
 
-from modal.exception import InvalidError
+from modal.exception import DeprecationError, InvalidError
 from modal_proto import api_pb2
 
 from ._load_context import LoadContext
@@ -246,6 +249,64 @@ class _WorkspaceProxyTokenManager:
         return environment.object_id
 
 
+class _WorkspaceBillingRates(Mapping[str, Decimal]):
+    def __init__(
+        self, rates: Mapping[str, str], warnings: Mapping[str, str], errors: Mapping[str, str], formatted: str
+    ):
+        self._rates = {k: Decimal(v) for k, v in rates.items()}
+        self._warnings = warnings
+        self._errors = errors
+        self._formatted = formatted
+
+    def __getitem__(self, key: str) -> Decimal:
+        if key in self._errors:
+            raise DeprecationError(self._errors[key])
+        elif key in self._warnings:
+            warnings.warn(self._warnings[key], DeprecationError)
+
+        return self._rates[key]
+
+    def __iter__(self):
+        for k in self._rates:
+            # We don't want iteration over the dict to surface any deprecated keys
+            if k in self._warnings:
+                continue
+            if k in self._errors:
+                continue
+
+            yield k
+
+    def __len__(self):
+        return len(set(self._rates.keys()) - set(self._warnings.keys()) - set(self._errors.keys()))
+
+    # Ensures that `rates.get()` doesn't throw `DeprecationError`s
+    # fixme(ayush): pyright seems to assume that the return type of `.get` for a `Mapping[K, V]` is
+    # always `V` regardless of the type of `default`. Fix this somehow?
+    def get(self, key, default=None):  # pyright: ignore [reportIncompatibleMethodOverride]
+        try:
+            return self[key]
+        except KeyError:
+            return default
+        except DeprecationError as e:
+            warnings.warn(str(e), DeprecationError)
+            return default
+
+    # Ensures that `'k' in rates` doesn't throw `DeprecationError`s
+    def __contains__(self, key):
+        try:
+            self[key]
+        except (KeyError, DeprecationError):
+            return False
+        else:
+            return True
+
+    def __str__(self) -> str:
+        return self._formatted
+
+    def __repr__(self) -> str:
+        return repr({k: v for k, v in self.items()})
+
+
 class _WorkspaceBillingManager:
     """mdmd:namespace"""
 
@@ -253,6 +314,27 @@ class _WorkspaceBillingManager:
         """mdmd:hidden"""
         self._workspace = workspace
 
+    async def rates(self) -> _WorkspaceBillingRates:
+        """Return current pricing rates for the given workspace.
+
+        Returns:
+            A single mapping containing cost values. All values are reported as `decimal.Decimal`s.
+        """
+
+        if not self._workspace.is_hydrated:
+            await self._workspace.hydrate()
+
+        response = await self._workspace.client.stub.WorkspaceBillingRates(
+            api_pb2.WorkspaceBillingRatesRequest(),
+        )
+
+        return _WorkspaceBillingRates(
+            response.rates,
+            response.deprecation_warnings,
+            response.deprecation_errors,
+            response.formatted,
+        )
+
     async def report(
         self,
         *,

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/app.py

@@ -39,6 +39,7 @@ from ._utils.function_utils import (
     is_flash_object,
     is_global_object,
     is_method_fn,
+    validate_target_concurrency,
 )
 from ._utils.mount_utils import validate_volumes
 from ._utils.name_utils import check_object_name, check_tag_dict
@@ -1288,7 +1289,7 @@ class _App:
         cpu: float | tuple[float, float] | None = None,  # CPU cores to request
         memory: int | tuple[int, int] | None = None,  # Memory in MiB to request
         ephemeral_disk: int | None = None,  # Ephemeral disk size in MiB
-        target_concurrency: int | None = None,  # Target concurrency for the server; 0 disables autoscaling
+        target_concurrency: float | None = None,  # Target concurrency for the server; 0 disables autoscaling
         min_containers: int | None = None,  # Minimum number of containers to keep warm
         max_containers: int | None = None,  # Maximum number of containers
         buffer_containers: int | None = None,  # Additional idle containers under active load
@@ -1335,7 +1336,9 @@ class _App:
                 Specify, in MiB, a memory request which is the minimum memory required. Or, pass (request, limit) to
                 additionally specify a hard limit in MiB.
             ephemeral_disk: Specify, in MiB, the ephemeral disk size for the server.
-            target_concurrency: Target concurrency for the server; 0 disables autoscaling.
+            target_concurrency:
+                Target number of concurrent requests per container; 0 disables autoscaling. May be
+                fractional, e.g. 1.5 to target three concurrent requests per two containers.
             min_containers: Minimum number of containers to keep running regardless of demand.
             max_containers: Limit on the number of containers that can be concurrently running.
             buffer_containers: Extra containers to scale up beyond current demand.
@@ -1383,8 +1386,7 @@ class _App:
         )
 
         if target_concurrency is not None:
-            if not isinstance(target_concurrency, int) or target_concurrency < 0:
-                raise InvalidError("The `target_concurrency` argument must be a non-negative integer.")
+            validate_target_concurrency(target_concurrency, "target_concurrency", allow_fractional=True)
 
         if scaleup_window is not None and scaleup_window <= 0:
             raise InvalidError("`scaleup_window` must be > 0")

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/app.pyi

@@ -744,7 +744,7 @@ class _App:
         cpu: typing.Union[float, tuple[float, float], None] = None,
         memory: typing.Union[int, tuple[int, int], None] = None,
         ephemeral_disk: typing.Optional[int] = None,
-        target_concurrency: typing.Optional[int] = None,
+        target_concurrency: typing.Optional[float] = None,
         min_containers: typing.Optional[int] = None,
         max_containers: typing.Optional[int] = None,
         buffer_containers: typing.Optional[int] = None,
@@ -791,7 +791,9 @@ class _App:
                 Specify, in MiB, a memory request which is the minimum memory required. Or, pass (request, limit) to
                 additionally specify a hard limit in MiB.
             ephemeral_disk: Specify, in MiB, the ephemeral disk size for the server.
-            target_concurrency: Target concurrency for the server; 0 disables autoscaling.
+            target_concurrency:
+                Target number of concurrent requests per container; 0 disables autoscaling. May be
+                fractional, e.g. 1.5 to target three concurrent requests per two containers.
             min_containers: Minimum number of containers to keep running regardless of demand.
             max_containers: Limit on the number of containers that can be concurrently running.
             buffer_containers: Extra containers to scale up beyond current demand.
@@ -1750,7 +1752,7 @@ class App:
         cpu: typing.Union[float, tuple[float, float], None] = None,
         memory: typing.Union[int, tuple[int, int], None] = None,
         ephemeral_disk: typing.Optional[int] = None,
-        target_concurrency: typing.Optional[int] = None,
+        target_concurrency: typing.Optional[float] = None,
         min_containers: typing.Optional[int] = None,
         max_containers: typing.Optional[int] = None,
         buffer_containers: typing.Optional[int] = None,
@@ -1797,7 +1799,9 @@ class App:
                 Specify, in MiB, a memory request which is the minimum memory required. Or, pass (request, limit) to
                 additionally specify a hard limit in MiB.
             ephemeral_disk: Specify, in MiB, the ephemeral disk size for the server.
-            target_concurrency: Target concurrency for the server; 0 disables autoscaling.
+            target_concurrency:
+                Target number of concurrent requests per container; 0 disables autoscaling. May be
+                fractional, e.g. 1.5 to target three concurrent requests per two containers.
             min_containers: Minimum number of containers to keep running regardless of demand.
             max_containers: Limit on the number of containers that can be concurrently running.
             buffer_containers: Extra containers to scale up beyond current demand.

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/cli/billing.py

@@ -5,6 +5,7 @@ from json import dumps
 
 import click
 from rich.box import SIMPLE_HEAD
+from rich.padding import Padding
 from rich.table import Table
 from rich.text import Text
 
@@ -296,3 +297,32 @@ async def summary(for_: str | None, json: bool):
     )
 
     output.print(t)
+
+
+@billing_cli.command("rates")
+@click.option("--json", "json", is_flag=True, default=False, help="Output as JSON.")
+@synchronizer.create_blocking
+async def rates(json: bool = False):
+    """Return current pricing rates.
+
+    Examples:
+
+    ```bash
+    modal billing rates
+    ```
+    """
+
+    rates = await _Workspace.from_context().billing.rates()
+
+    output = OutputManager.get()
+
+    if json:
+        output.print_json(
+            dumps(
+                {k: str(v) for k, v in rates.items()},
+                sort_keys=True,
+            )
+        )
+        return
+
+    output.print(Padding(Text(rates._formatted), (1, 2)))

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/client.py

@@ -84,6 +84,7 @@ class _Client:
     _snapshotted: bool = False
     _connection_manager: ConnectionManager | None = None
     client_type: "api_pb2.ClientType.ValueType"
+    server_url: str
 
     def __init__(
         self,

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/client.pyi

@@ -31,13 +31,14 @@ class _Client:
     _snapshotted: bool
     _connection_manager: typing.Optional[modal._utils.grpc_utils.ConnectionManager]
     client_type: int
+    server_url: str
 
     def __init__(
         self,
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.4.dev20",
+        version: str = "1.5.4.dev22",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -201,13 +202,14 @@ class Client:
     _snapshotted: bool
     _connection_manager: typing.Optional[modal._utils.grpc_utils.ConnectionManager]
     client_type: int
+    server_url: str
 
     def __init__(
         self,
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.4.dev20",
+        version: str = "1.5.4.dev22",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/config.py

@@ -321,6 +321,7 @@ _SETTINGS = {
     "traceback": _Setting(False, transform=_to_boolean),
     "image_builder_version": _Setting(),
     "strict_parameters": _Setting(False, transform=_to_boolean),  # For internal/experimental use
+    "sandbox_v2": _Setting(None, transform=_to_boolean),
     "snapshot_debug": _Setting(False, transform=_to_boolean),
     "cuda_checkpoint_path": _Setting("/__modal/.bin/cuda-checkpoint"),  # Used for snapshotting GPU memory.
     "build_validation": _Setting("error", transform=_check_value(["error", "warn", "ignore"])),

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/experimental/flash.py

@@ -17,7 +17,7 @@ from modal.cls import _Cls
 from modal.dict import _Dict
 from modal_proto import api_pb2
 
-from .._runtime.container_io_manager import UserException
+from .._runtime.task_lifecycle_manager import UserException
 from .._server import validate_http_server_config
 from .._tunnel import _forward as _forward_tunnel
 from .._utils.async_utils import synchronize_api, synchronizer
@@ -86,6 +86,7 @@ class _FlashManager:
         self.tunnel = await self.tunnel_manager.__aenter__()
         parsed_url = urlparse(self.tunnel.url)
         host = parsed_url.hostname
+        assert host is not None, f"Tunnel URL has no host: {self.tunnel.url}"
         port = parsed_url.port or 443
 
         if self.is_server:
@@ -326,7 +327,7 @@ class _FlashPrometheusAutoscaler:
         self.autoscaling_interval_seconds = autoscaling_interval_seconds
 
         FlashClass = _Cls.from_name(app_name, cls_name)
-        self.fn = FlashClass._class_service_function
+        self.fn = FlashClass._get_class_service_function()
         self.cls = FlashClass()
 
         self.http_client = aiohttp.ClientSession()
@@ -335,7 +336,7 @@ class _FlashPrometheusAutoscaler:
             create_if_missing=True,
         )
 
-        self.autoscaler_thread = None
+        self.autoscaler_thread: asyncio.Task | None = None
 
     async def start(self):
         await self.fn.hydrate(client=self.client)
@@ -519,11 +520,13 @@ class _FlashPrometheusAutoscaler:
         return sum_metric, n_containers_with_metrics
 
     async def _get_metrics(self, url: str) -> dict[str, list[Any]] | None:  # technically any should be Sample
-        from prometheus_client.parser import Sample, text_string_to_metric_families
+        import aiohttp
+        from prometheus_client.parser import text_string_to_metric_families
+        from prometheus_client.samples import Sample
 
         # Fetch the metrics from the endpoint
         try:
-            response = await self.http_client.get(url, timeout=3)
+            response = await self.http_client.get(url, timeout=aiohttp.ClientTimeout(total=3))
             response.raise_for_status()
         except asyncio.TimeoutError:
             logger.warning(f"[Modal Flash] Timeout getting metrics from {url}")
@@ -627,6 +630,8 @@ class _FlashPrometheusAutoscaler:
         return new_replicas
 
     async def stop(self):
+        if self.autoscaler_thread is None:
+            return
         self.autoscaler_thread.cancel()
         await self.autoscaler_thread
 
@@ -696,20 +701,21 @@ async def flash_prometheus_autoscaler(
 
 
 @synchronizer.create_blocking
-async def flash_get_containers(app_name: str, cls_name: str) -> list[dict[str, Any]]:
+async def flash_get_containers(app_name: str, cls_name: str) -> list[Any]:
     """
     Return a list of flash containers for a deployed Flash service.
 
+    Each entry exposes `task_id`, `host`, and `port` attributes.
+
     This is a highly experimental method that can break or be removed at any time without warning.
     Do not use this method unless explicitly instructed to do so by Modal support.
     """
     client = await _Client.from_env()
-    fn = _Cls.from_name(app_name, cls_name)._class_service_function
-    assert fn is not None
+    fn = _Cls.from_name(app_name, cls_name)._get_class_service_function()
     await fn.hydrate(client=client)
     req = api_pb2.FlashContainerListRequest(function_id=fn.object_id)
     resp = await client.stub.FlashContainerList(req)
-    return resp.containers
+    return list(resp.containers)
 
 
 def _http_server(

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/experimental/flash.pyi

@@ -404,17 +404,21 @@ class __flash_prometheus_autoscaler_spec(typing_extensions.Protocol):
 flash_prometheus_autoscaler: __flash_prometheus_autoscaler_spec
 
 class __flash_get_containers_spec(typing_extensions.Protocol):
-    def __call__(self, /, app_name: str, cls_name: str) -> list[dict[str, typing.Any]]:
+    def __call__(self, /, app_name: str, cls_name: str) -> list[typing.Any]:
         """Return a list of flash containers for a deployed Flash service.
 
+        Each entry exposes `task_id`, `host`, and `port` attributes.
+
         This is a highly experimental method that can break or be removed at any time without warning.
         Do not use this method unless explicitly instructed to do so by Modal support.
         """
         ...
 
-    async def aio(self, /, app_name: str, cls_name: str) -> list[dict[str, typing.Any]]:
+    async def aio(self, /, app_name: str, cls_name: str) -> list[typing.Any]:
         """Return a list of flash containers for a deployed Flash service.
 
+        Each entry exposes `task_id`, `host`, and `port` attributes.
+
         This is a highly experimental method that can break or be removed at any time without warning.
         Do not use this method unless explicitly instructed to do so by Modal support.
         """

{modal-1.5.4.dev20 → modal-1.5.4.dev22}/modal/functions.pyi

@@ -117,7 +117,7 @@ class Function(
         scaleup_window: typing.Optional[int] = None,
         scaledown_window: typing.Optional[int] = None,
         max_concurrent_inputs: typing.Optional[int] = None,
-        target_concurrent_inputs: typing.Optional[int] = None,
+        target_concurrent_inputs: typing.Optional[float] = None,
         batch_max_size: typing.Optional[int] = None,
         batch_wait_ms: typing.Optional[int] = None,
         cloud: typing.Optional[str] = None,
@@ -179,7 +179,7 @@ class Function(
             buffer_containers: typing.Optional[int] = None,
             scaleup_window: typing.Optional[int] = None,
             scaledown_window: typing.Optional[int] = None,
-            target_concurrency: typing.Optional[int] = None,
+            target_concurrency: typing.Optional[float] = None,
         ) -> modal.types.ServerAutoscalerSettings: ...
         async def aio(
             self,
@@ -190,7 +190,7 @@ class Function(
             buffer_containers: typing.Optional[int] = None,
             scaleup_window: typing.Optional[int] = None,
             scaledown_window: typing.Optional[int] = None,
-            target_concurrency: typing.Optional[int] = None,
+            target_concurrency: typing.Optional[float] = None,
         ) -> modal.types.ServerAutoscalerSettings: ...
 
     _update_autoscaler_server: ___update_autoscaler_server_spec