modal 1.0.6.dev58__py3-none-any.whl → 1.2.3.dev7__py3-none-any.whl

modal/__main__.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2022
 import sys
 
+from ._output import make_console
 from ._traceback import reduce_traceback_to_user_code
 from .cli._traceback import highlight_modal_warnings, setup_rich_traceback
 from .cli.entry_point import entrypoint_cli
@@ -35,9 +36,7 @@ def main():
             raise
 
         from grpclib import GRPCError, Status
-        from rich.console import Console
         from rich.panel import Panel
-        from rich.text import Text
 
         if isinstance(exc, GRPCError):
             status_map = {
@@ -68,8 +67,8 @@ def main():
             if notes := getattr(exc, "__notes__", []):
                 content = f"{content}\n\nNote: {' '.join(notes)}"
 
-        console = Console(stderr=True)
-        panel = Panel(Text(content), title=title, title_align="left", border_style="red")
+        console = make_console(stderr=True)
+        panel = Panel(content, title=title, title_align="left", border_style="red")
         console.print(panel, highlight=False)
         sys.exit(1)
 

modal/_billing.py

@@ -0,0 +1,80 @@
+# Copyright Modal Labs 2025
+from datetime import datetime, timezone
+from decimal import Decimal
+from typing import Any, Optional, TypedDict
+
+from modal_proto import api_pb2
+
+from .client import _Client
+from .exception import InvalidError
+
+
+class WorkspaceBillingReportItem(TypedDict):
+    object_id: str
+    description: str
+    environment_name: str
+    interval_start: datetime
+    cost: Decimal
+    tags: dict[str, str]
+
+
+async def _workspace_billing_report(
+    *,
+    start: datetime,  # Start of the report, inclusive
+    end: Optional[datetime] = None,  # End of the report, exclusive
+    resolution: str = "d",  # Resolution, e.g. "d" for daily or "h" for hourly
+    tag_names: Optional[list[str]] = None,  # Optional additional metadata to include
+    client: Optional[_Client] = None,
+) -> list[dict[str, Any]]:
+    """Generate a tabular report of workspace usage by object and time.
+
+    The result will be a list of dictionaries for each interval (determined by `resolution`)
+    between the `start` and `end` limits. The dictionary represents a single Modal object
+    that billing can be attributed to (e.g., an App) along with metadata (including user-defined
+    tags) for identifying that object.
+
+    The `start` and `end` parameters are required to either have a UTC timezone or to be
+    timezone-naive (which will be interpreted as UTC times). The timestamps in the result will
+    be in UTC. Cost will be reported for full intervals, even if the provided `start` or `end`
+    parameters are partial: `start` will be rounded to the beginning of its interval, while
+    partial `end` intervals will be excluded.
+
+    Additional user-provided metadata can be included in the report if the objects have tags
+    and `tag_names` (i.e., keys) are specified in the request. Note that tags will be attributed
+    to the entire interval even if they were added or removed at some point within it.
+
+    """
+    if client is None:
+        client = await _Client.from_env()
+
+    tag_names = tag_names or []
+
+    if end is None:
+        end = datetime.now(timezone.utc)
+
+    for dt in (start, end):
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        elif dt.tzinfo != timezone.utc:
+            raise InvalidError("Timezone-aware start/end limits must be in UTC.")
+
+    request = api_pb2.WorkspaceBillingReportRequest(
+        resolution=resolution,
+        tag_names=tag_names,
+    )
+    request.start_timestamp.FromDatetime(start)
+    request.end_timestamp.FromDatetime(end)
+
+    rows = []
+    async for pb_item in client.stub.WorkspaceBillingReport.unary_stream(request):
+        item = {
+            "object_id": pb_item.object_id,
+            "description": pb_item.description,
+            "environment_name": pb_item.environment_name,
+            "interval_start": pb_item.interval.ToDatetime().replace(tzinfo=timezone.utc),
+            "cost": Decimal(pb_item.cost),
+            "tags": dict(pb_item.tags),
+        }
+        rows.append(item)
+
+    return rows

modal/_clustered_functions.py

@@ -5,7 +5,6 @@ from dataclasses import dataclass
 from typing import Optional
 
 from modal._utils.async_utils import synchronize_api
-from modal._utils.grpc_utils import retry_transient_errors
 from modal.client import _Client
 from modal.exception import InvalidError
 from modal_proto import api_pb2
@@ -14,7 +13,9 @@ from modal_proto import api_pb2
 @dataclass
 class ClusterInfo:
     rank: int
+    cluster_id: str
     container_ips: list[str]
+    container_ipv4_ips: list[str]
 
 
 cluster_info: Optional[ClusterInfo] = None
@@ -59,8 +60,7 @@ async def _initialize_clustered_function(client: _Client, task_id: str, world_si
         os.environ["NCCL_NSOCKS_PERTHREAD"] = "1"
 
     if world_size > 1:
-        resp: api_pb2.TaskClusterHelloResponse = await retry_transient_errors(
-            client.stub.TaskClusterHello,
+        resp = await client.stub.TaskClusterHello(
             api_pb2.TaskClusterHelloRequest(
                 task_id=task_id,
                 container_ip=container_ip,
@@ -68,12 +68,16 @@ 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,
         )
     else:
         cluster_info = ClusterInfo(
             rank=0,
+            cluster_id="",  # No cluster ID for single-node  # TODO(irfansharif): Is this right?
             container_ips=[container_ip],
+            container_ipv4_ips=[],  # No IPv4 IPs for single-node
         )
 
 

modal/_clustered_functions.pyi

@@ -3,12 +3,14 @@ import typing
 import typing_extensions
 
 class ClusterInfo:
-    """ClusterInfo(rank: int, container_ips: list[str])"""
+    """ClusterInfo(rank: int, cluster_id: str, container_ips: list[str], container_ipv4_ips: list[str])"""
 
     rank: int
+    cluster_id: str
     container_ips: list[str]
+    container_ipv4_ips: list[str]
 
-    def __init__(self, rank: int, container_ips: list[str]) -> None:
+    def __init__(self, rank: int, cluster_id: str, container_ips: list[str], container_ipv4_ips: list[str]) -> None:
         """Initialize self.  See help(type(self)) for accurate signature."""
         ...
 

modal/_container_entrypoint.py

@@ -32,14 +32,14 @@ from modal._partial_function import (
     _PartialFunctionFlags,
 )
 from modal._serialization import deserialize, deserialize_params
-from modal._utils.async_utils import TaskContext, synchronizer
+from modal._utils.async_utils import TaskContext, aclosing, synchronizer
 from modal._utils.function_utils import (
     callable_has_non_self_params,
 )
 from modal.app import App, _App
 from modal.client import Client, _Client
 from modal.config import logger
-from modal.exception import ExecutionError, InputCancellation, InvalidError
+from modal.exception import ExecutionError, InputCancellation
 from modal.running_app import RunningApp, running_app_from_layout
 from modal_proto import api_pb2
 
@@ -184,86 +184,75 @@ def call_function(
     batch_wait_ms: int,
 ):
     async def run_input_async(io_context: IOContext) -> None:
+        reset_context = execution_context._set_current_context_ids(
+            io_context.input_ids, io_context.function_call_ids, io_context.attempt_tokens
+        )
         started_at = time.time()
-        input_ids, function_call_ids = io_context.input_ids, io_context.function_call_ids
-        reset_context = execution_context._set_current_context_ids(input_ids, function_call_ids)
         async with container_io_manager.handle_input_exception.aio(io_context, started_at):
-            res = io_context.call_finalized_function()
             # TODO(erikbern): any exception below shouldn't be considered a user exception
             if io_context.finalized_function.is_generator:
-                if not inspect.isasyncgen(res):
-                    raise InvalidError(f"Async generator function returned value of type {type(res)}")
-
                 # Send up to this many outputs at a time.
+                current_function_call_id = execution_context.current_function_call_id()
+                assert current_function_call_id is not None  # Set above.
+                current_attempt_token = execution_context.current_attempt_token()
+                assert current_attempt_token is not None  # Set above, but can be empty string.
                 generator_queue: asyncio.Queue[Any] = await container_io_manager._queue_create.aio(1024)
                 async with container_io_manager.generator_output_sender(
-                    function_call_ids[0],
-                    io_context.finalized_function.data_format,
+                    current_function_call_id,
+                    current_attempt_token,
+                    io_context._generator_output_format(),
                     generator_queue,
                 ):
                     item_count = 0
-                    async for value in res:
-                        await container_io_manager._queue_put.aio(generator_queue, value)
-                        item_count += 1
+                    async with aclosing(io_context.call_generator_async()) as gen:
+                        async for value in gen:
+                            await container_io_manager._queue_put.aio(generator_queue, value)
+                            item_count += 1
 
-                message = api_pb2.GeneratorDone(items_total=item_count)
-                await container_io_manager.push_outputs.aio(
-                    io_context,
-                    started_at,
-                    message,
-                    api_pb2.DATA_FORMAT_GENERATOR_DONE,
+                await container_io_manager._send_outputs.aio(
+                    started_at, io_context.output_items_generator_done(started_at, item_count)
                 )
             else:
-                if not inspect.iscoroutine(res) or inspect.isgenerator(res) or inspect.isasyncgen(res):
-                    raise InvalidError(
-                        f"Async (non-generator) function returned value of type {type(res)}"
-                        " You might need to use @app.function(..., is_generator=True)."
-                    )
-                value = await res
+                value = await io_context.call_function_async()
                 await container_io_manager.push_outputs.aio(
                     io_context,
                     started_at,
                     value,
-                    io_context.finalized_function.data_format,
                 )
         reset_context()
 
     def run_input_sync(io_context: IOContext) -> None:
         started_at = time.time()
-        input_ids, function_call_ids = io_context.input_ids, io_context.function_call_ids
-        reset_context = execution_context._set_current_context_ids(input_ids, function_call_ids)
+        reset_context = execution_context._set_current_context_ids(
+            io_context.input_ids, io_context.function_call_ids, io_context.attempt_tokens
+        )
         with container_io_manager.handle_input_exception(io_context, started_at):
-            res = io_context.call_finalized_function()
-
             # TODO(erikbern): any exception below shouldn't be considered a user exception
             if io_context.finalized_function.is_generator:
-                if not inspect.isgenerator(res):
-                    raise InvalidError(f"Generator function returned value of type {type(res)}")
-
+                gen = io_context.call_generator_sync()
                 # Send up to this many outputs at a time.
+                current_function_call_id = execution_context.current_function_call_id()
+                assert current_function_call_id is not None  # Set above.
+                current_attempt_token = execution_context.current_attempt_token()
+                assert current_attempt_token is not None  # Set above, but can be empty string.
                 generator_queue: asyncio.Queue[Any] = container_io_manager._queue_create(1024)
-
                 with container_io_manager.generator_output_sender(
-                    function_call_ids[0],
-                    io_context.finalized_function.data_format,
+                    current_function_call_id,
+                    current_attempt_token,
+                    io_context._generator_output_format(),
                     generator_queue,
                 ):
                     item_count = 0
-                    for value in res:
+                    for value in gen:
                         container_io_manager._queue_put(generator_queue, value)
                         item_count += 1
 
-                message = api_pb2.GeneratorDone(items_total=item_count)
-                container_io_manager.push_outputs(io_context, started_at, message, api_pb2.DATA_FORMAT_GENERATOR_DONE)
-            else:
-                if inspect.iscoroutine(res) or inspect.isgenerator(res) or inspect.isasyncgen(res):
-                    raise InvalidError(
-                        f"Sync (non-generator) function return value of type {type(res)}."
-                        " You might need to use @app.function(..., is_generator=True)."
-                    )
-                container_io_manager.push_outputs(
-                    io_context, started_at, res, io_context.finalized_function.data_format
+                container_io_manager._send_outputs(
+                    started_at, io_context.output_items_generator_done(started_at, item_count)
                 )
+            else:
+                values = io_context.call_function_sync()
+                container_io_manager.push_outputs(io_context, started_at, values)
         reset_context()
 
     if container_io_manager.input_concurrency_enabled:
@@ -426,9 +415,9 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                         param_kwargs,
                     )
                 else:
+                    assert ser_usr_cls is None
                     service = import_single_function_service(
                         function_def,
-                        ser_usr_cls,
                         ser_fun,
                     )
 
@@ -461,7 +450,10 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                     f"Function has {len(service.service_deps)} dependencies"
                     f" but container got {len(dep_object_ids)} object ids.\n"
                     f"Code deps: {service.service_deps}\n"
-                    f"Object ids: {dep_object_ids}"
+                    f"Object ids: {dep_object_ids}\n"
+                    "\n"
+                    "This can happen if you are defining Modal objects under a conditional statement "
+                    "that evaluates differently in the local and remote environments."
                 )
             for object_id, obj in zip(dep_object_ids, service.service_deps):
                 metadata: Message = container_app.object_handle_metadata[object_id]