modal 1.1.5.dev52__tar.gz → 1.3.1.dev20__tar.gz

{modal-1.1.5.dev52 → modal-1.3.1.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.1.5.dev52
+Version: 1.3.1.dev20
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0
@@ -13,17 +13,18 @@ Classifier: Topic :: System :: Distributed Computing
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.9
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
 Requires-Dist: cbor2
 Requires-Dist: certifi
 Requires-Dist: click~=8.1
-Requires-Dist: grpclib<0.4.9,>=0.4.7
+Requires-Dist: grpclib<0.4.10,>=0.4.7; python_version < "3.14"
+Requires-Dist: grpclib<0.4.10,>=0.4.9; python_version >= "3.14"
 Requires-Dist: protobuf!=4.24.0,<7.0,>=3.19
 Requires-Dist: rich>=12.0.0
-Requires-Dist: synchronicity~=0.10.2
+Requires-Dist: synchronicity~=0.11.1
 Requires-Dist: toml
 Requires-Dist: typer>=0.9
 Requires-Dist: types-certifi
@@ -32,14 +33,14 @@ Requires-Dist: watchfiles
 Requires-Dist: typing_extensions~=4.6
 Dynamic: license-file
 
-# Modal Python Library
+# Modal Python SDK
 
 [![PyPI Version](https://img.shields.io/pypi/v/modal.svg)](https://pypi.org/project/modal/)
 [![License](https://img.shields.io/badge/license-apache_2.0-darkviolet.svg)](https://github.com/modal-labs/modal-client/blob/master/LICENSE)
 [![Tests](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml)
 [![Slack](https://img.shields.io/badge/slack-join-blue.svg?logo=slack)](https://modal.com/slack)
 
-The [Modal](https://modal.com/) Python library provides convenient, on-demand
+The [Modal](https://modal.com/) Python SDK provides convenient, on-demand
 access to serverless cloud compute from Python scripts on your local computer.
 
 ## Documentation
@@ -51,12 +52,12 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 ## Installation
 
-**This library requires Python 3.9 – 3.13.**
+**This library requires Python 3.10 – 3.14.**
 
-Install the package with `pip`:
+Install the package with `uv` or `pip`:
 
 ```bash
-pip install modal
+uv pip install modal
 ```
 
 You can create a Modal account (or link your existing one) directly on the

{modal-1.1.5.dev52 → modal-1.3.1.dev20}/README.md

@@ -1,11 +1,11 @@
-# Modal Python Library
+# Modal Python SDK
 
 [![PyPI Version](https://img.shields.io/pypi/v/modal.svg)](https://pypi.org/project/modal/)
 [![License](https://img.shields.io/badge/license-apache_2.0-darkviolet.svg)](https://github.com/modal-labs/modal-client/blob/master/LICENSE)
 [![Tests](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml)
 [![Slack](https://img.shields.io/badge/slack-join-blue.svg?logo=slack)](https://modal.com/slack)
 
-The [Modal](https://modal.com/) Python library provides convenient, on-demand
+The [Modal](https://modal.com/) Python SDK provides convenient, on-demand
 access to serverless cloud compute from Python scripts on your local computer.
 
 ## Documentation
@@ -17,12 +17,12 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 ## Installation
 
-**This library requires Python 3.9 – 3.13.**
+**This library requires Python 3.10 – 3.14.**
 
-Install the package with `pip`:
+Install the package with `uv` or `pip`:
 
 ```bash
-pip install modal
+uv pip install modal
 ```
 
 You can create a Modal account (or link your existing one) directly on the

{modal-1.1.5.dev52 → modal-1.3.1.dev20}/modal/__init__.py

@@ -1,10 +1,10 @@
 # Copyright Modal Labs 2022
 import sys
 
-if sys.version_info[:2] < (3, 9):
-    raise RuntimeError("This version of Modal requires at least Python 3.9")
-if sys.version_info[:2] >= (3, 14):
-    raise RuntimeError("This version of Modal does not support Python 3.14+")
+if sys.version_info[:2] < (3, 10):
+    raise RuntimeError("This version of Modal requires at least Python 3.10")
+if sys.version_info[:2] >= (3, 15):
+    raise RuntimeError("This version of Modal does not support Python 3.15+")
 
 from modal_version import __version__
 

{modal-1.1.5.dev52 → modal-1.3.1.dev20}/modal/__main__.py

@@ -35,37 +35,12 @@ def main():
         ):
             raise
 
-        from grpclib import GRPCError, Status
         from rich.panel import Panel
 
-        if isinstance(exc, GRPCError):
-            status_map = {
-                Status.ABORTED: "Aborted",
-                Status.ALREADY_EXISTS: "Already exists",
-                Status.CANCELLED: "Cancelled",
-                Status.DATA_LOSS: "Data loss",
-                Status.DEADLINE_EXCEEDED: "Deadline exceeded",
-                Status.FAILED_PRECONDITION: "Failed precondition",
-                Status.INTERNAL: "Internal",
-                Status.INVALID_ARGUMENT: "Invalid",
-                Status.NOT_FOUND: "Not found",
-                Status.OUT_OF_RANGE: "Out of range",
-                Status.PERMISSION_DENIED: "Permission denied",
-                Status.RESOURCE_EXHAUSTED: "Resource exhausted",
-                Status.UNAUTHENTICATED: "Unauthenticaed",
-                Status.UNAVAILABLE: "Unavailable",
-                Status.UNIMPLEMENTED: "Unimplemented",
-                Status.UNKNOWN: "Unknown",
-            }
-            title = f"Error: {status_map.get(exc.status, 'Unknown')}"
-            content = str(exc.message)
-            if exc.details:
-                content += f"\n\nDetails: {exc.details}"
-        else:
-            title = "Error"
-            content = str(exc)
-            if notes := getattr(exc, "__notes__", []):
-                content = f"{content}\n\nNote: {' '.join(notes)}"
+        title = "Error"
+        content = str(exc)
+        if notes := getattr(exc, "__notes__", []):
+            content = f"{content}\n\nNote: {' '.join(notes)}"
 
         console = make_console(stderr=True)
         panel = Panel(content, title=title, title_align="left", border_style="red")

modal-1.3.1.dev20/modal/_billing.py

@@ -0,0 +1,84 @@
+# 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)
+
+    if start.tzinfo is None:
+        start = start.replace(tzinfo=timezone.utc)
+    elif start.tzinfo != timezone.utc:
+        raise InvalidError("Timezone-aware 'start' parameter must be in UTC.")
+
+    if end.tzinfo is None:
+        end = end.replace(tzinfo=timezone.utc)
+    elif end.tzinfo != timezone.utc:
+        raise InvalidError("Timezone-aware 'end' parameter 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-1.1.5.dev52 → modal-1.3.1.dev20}/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
@@ -61,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,

{modal-1.1.5.dev52 → modal-1.3.1.dev20}/modal/_container_entrypoint.py

@@ -15,27 +15,19 @@ if telemetry_socket:
     instrument_imports(telemetry_socket)
 
 import asyncio
-import inspect
 import queue
 import signal
-import sys
 import threading
 import time
-from collections.abc import Sequence
-from typing import TYPE_CHECKING, Any, Callable, Optional
+import types
+from typing import TYPE_CHECKING, Any, Optional, cast
 
 from google.protobuf.message import Message
 
 from modal._clustered_functions import initialize_clustered_function
-from modal._partial_function import (
-    _find_callables_for_obj,
-    _PartialFunctionFlags,
-)
+from modal._runtime.user_code_event_loop import UserCodeEventLoop
 from modal._serialization import deserialize, deserialize_params
 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
@@ -51,8 +43,8 @@ from ._runtime.container_io_manager import (
 )
 
 if TYPE_CHECKING:
-    import modal._object
     import modal._runtime.container_io_manager
+    import modal._runtime.user_code_imports
 
 
 class DaemonizedThreadPool:
@@ -101,81 +93,6 @@ class DaemonizedThreadPool:
         self.inputs.put((func, args))
 
 
-class UserCodeEventLoop:
-    """Run an async event loop as a context manager and handle signals.
-
-    This will run all *user supplied* async code, i.e. async functions, as well as async enter/exit managers
-
-    The following signals are handled while a coroutine is running on the event loop until
-    completion (and then handlers are deregistered):
-
-    - `SIGUSR1`: converted to an async task cancellation. Note that this only affects the event
-      loop, and the signal handler defined here doesn't run for sync functions.
-    - `SIGINT`: Unless the global signal handler has been set to SIGIGN, the loop's signal handler
-        is set to cancel the current task and raise KeyboardInterrupt to the caller.
-    """
-
-    def __enter__(self):
-        self.loop = asyncio.new_event_loop()
-        self.tasks = set()
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.loop.run_until_complete(self.loop.shutdown_asyncgens())
-        if sys.version_info[:2] >= (3, 9):
-            self.loop.run_until_complete(self.loop.shutdown_default_executor())  # Introduced in Python 3.9
-
-        for task in self.tasks:
-            task.cancel()
-
-        self.loop.close()
-
-    def create_task(self, coro):
-        task = self.loop.create_task(coro)
-        self.tasks.add(task)
-        task.add_done_callback(self.tasks.discard)
-        return task
-
-    def run(self, coro):
-        task = asyncio.ensure_future(coro, loop=self.loop)
-        self._sigints = 0
-
-        def _sigint_handler():
-            # cancel the task in order to have run_until_complete return soon and
-            # prevent a bunch of unwanted tracebacks when shutting down the
-            # event loop.
-
-            # this basically replicates the sigint handler installed by asyncio.run()
-            self._sigints += 1
-            if self._sigints == 1:
-                # first sigint is graceful
-                task.cancel()
-                return
-
-            # this should normally not happen, but the second sigint would "hard kill" the event loop!
-            raise KeyboardInterrupt()
-
-        ignore_sigint = signal.getsignal(signal.SIGINT) == signal.SIG_IGN
-        if not ignore_sigint:
-            self.loop.add_signal_handler(signal.SIGINT, _sigint_handler)
-
-        # Before Python 3.9 there is no argument to Task.cancel
-        if sys.version_info[:2] >= (3, 9):
-            self.loop.add_signal_handler(signal.SIGUSR1, task.cancel, "Input was cancelled by user")
-        else:
-            self.loop.add_signal_handler(signal.SIGUSR1, task.cancel)
-
-        try:
-            return self.loop.run_until_complete(task)
-        except asyncio.CancelledError:
-            if self._sigints > 0:
-                raise KeyboardInterrupt()
-        finally:
-            self.loop.remove_signal_handler(signal.SIGUSR1)
-            if not ignore_sigint:
-                self.loop.remove_signal_handler(signal.SIGINT)
-
-
 def call_function(
     user_code_event_loop: UserCodeEventLoop,
     container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
@@ -331,23 +248,25 @@ def call_function(
                     signal.signal(signal.SIGUSR1, usr1_handler)  # reset signal handler
 
 
-def call_lifecycle_functions(
-    event_loop: UserCodeEventLoop,
-    container_io_manager,  #: ContainerIOManager,  TODO: this type is generated at runtime
-    funcs: Sequence[Callable[..., Any]],
-) -> None:
-    """Call function(s), can be sync or async, but any return values are ignored."""
-    with container_io_manager.handle_user_exception():
-        for func in funcs:
-            # We are deprecating parametrized exit methods but want to gracefully handle old code.
-            # We can remove this once the deprecation in the actual @exit decorator is enforced.
-            args = (None, None, None) if callable_has_non_self_params(func) else ()
-            # in case func is non-async, it's executed here and sigint will by default
-            # interrupt it using a KeyboardInterrupt exception
-            res = func(*args)
-            if inspect.iscoroutine(res):
-                # if however func is async, we have to jump through some hoops
-                event_loop.run(res)
+def get_serialized_user_class_and_function(
+    function_def: api_pb2.Function, client: _Client
+) -> tuple[Optional[type], Optional[types.FunctionType]]:
+    if function_def.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED:
+        assert function_def.function_serialized or function_def.class_serialized
+
+        if function_def.function_serialized:
+            ser_fun = deserialize(function_def.function_serialized, client)
+        else:
+            ser_fun = None
+
+        if function_def.class_serialized:
+            ser_usr_cls = deserialize(function_def.class_serialized, client)
+        else:
+            ser_usr_cls = None
+    else:
+        ser_usr_cls, ser_fun = None, None
+
+    return ser_usr_cls, ser_fun
 
 
 def main(container_args: api_pb2.ContainerArguments, client: Client):
@@ -357,34 +276,20 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
     active_app: _App
     service: Service
     function_def = container_args.function_def
-    is_auto_snapshot: bool = function_def.is_auto_snapshot
     # The worker sets this flag to "1" for snapshot and restore tasks. Otherwise, this flag is unset,
     # in which case snapshots should be disabled.
     is_snapshotting_function = (
         function_def.is_checkpointing_function and os.environ.get("MODAL_ENABLE_SNAP_RESTORE") == "1"
     )
 
-    _client: _Client = synchronizer._translate_in(client)  # TODO(erikbern): ugly
+    _client: _Client = cast(_Client, synchronizer._translate_in(client))  # TODO(erikbern): ugly
 
     # Call ContainerHello - currently a noop but might be used later for things
     container_io_manager.hello()
 
     with container_io_manager.heartbeats(is_snapshotting_function), UserCodeEventLoop() as event_loop:
         # If this is a serialized function, fetch the definition from the server
-        if function_def.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED:
-            assert function_def.function_serialized or function_def.class_serialized
-
-            if function_def.function_serialized:
-                ser_fun = deserialize(function_def.function_serialized, _client)
-            else:
-                ser_fun = None
-
-            if function_def.class_serialized:
-                ser_usr_cls = deserialize(function_def.class_serialized, _client)
-            else:
-                ser_usr_cls = None
-        else:
-            ser_usr_cls, ser_fun = None, None
+        ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
 
         # Initialize the function, importing user code.
         with container_io_manager.handle_user_exception():
@@ -436,7 +341,7 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
 
         # Initialize objects on the app.
         # This is basically only functions and classes - anything else is deprecated and will be unsupported soon
-        app: App = synchronizer._translate_out(active_app)
+        app: App = cast(App, synchronizer._translate_out(active_app))
         app._init_container(client, container_app)
 
         # Hydrate all function dependencies.
@@ -450,10 +355,13 @@ 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]
+                metadata: Optional[Message] = container_app.object_handle_metadata[object_id]
                 obj._hydrate(object_id, _client, metadata)
 
         # Initialize clustered functions.
@@ -464,91 +372,8 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                 function_def._experimental_group_size,
             )
 
-        # Identify all "enter" methods that need to run before we snapshot.
-        if service.user_cls_instance is not None and not is_auto_snapshot:
-            pre_snapshot_methods = _find_callables_for_obj(
-                service.user_cls_instance, _PartialFunctionFlags.ENTER_PRE_SNAPSHOT
-            )
-            call_lifecycle_functions(event_loop, container_io_manager, list(pre_snapshot_methods.values()))
-
-        # If this container is being used to create a checkpoint, checkpoint the container after
-        # global imports and initialization. Checkpointed containers run from this point onwards.
-        if is_snapshotting_function:
-            container_io_manager.memory_snapshot()
-
-        # Install hooks for interactive functions.
-        def breakpoint_wrapper():
-            # note: it would be nice to not have breakpoint_wrapper() included in the backtrace
-            container_io_manager.interact(from_breakpoint=True)
-            import pdb
-
-            frame = inspect.currentframe().f_back
-
-            pdb.Pdb().set_trace(frame)
-
-        sys.breakpointhook = breakpoint_wrapper
-
-        # Identify the "enter" methods to run after resuming from a snapshot.
-        if service.user_cls_instance is not None and not is_auto_snapshot:
-            post_snapshot_methods = _find_callables_for_obj(
-                service.user_cls_instance, _PartialFunctionFlags.ENTER_POST_SNAPSHOT
-            )
-            call_lifecycle_functions(event_loop, container_io_manager, list(post_snapshot_methods.values()))
-
-        with container_io_manager.handle_user_exception():
-            finalized_functions = service.get_finalized_functions(function_def, container_io_manager)
-        # Execute the function.
-        lifespan_background_tasks = []
-        try:
-            for finalized_function in finalized_functions.values():
-                if finalized_function.lifespan_manager:
-                    lifespan_background_tasks.append(
-                        event_loop.create_task(finalized_function.lifespan_manager.background_task())
-                    )
-                    with container_io_manager.handle_user_exception():
-                        event_loop.run(finalized_function.lifespan_manager.lifespan_startup())
-            call_function(
-                event_loop,
-                container_io_manager,
-                finalized_functions,
-                batch_max_size,
-                batch_wait_ms,
-            )
-        finally:
-            # Run exit handlers. From this point onward, ignore all SIGINT signals that come from
-            # graceful shutdowns originating on the worker, as well as stray SIGUSR1 signals that
-            # may have been sent to cancel inputs.
-            int_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
-            usr1_handler = signal.signal(signal.SIGUSR1, signal.SIG_IGN)
-
-            try:
-                try:
-                    # run lifespan shutdown for asgi apps
-                    for finalized_function in finalized_functions.values():
-                        if finalized_function.lifespan_manager:
-                            with container_io_manager.handle_user_exception():
-                                event_loop.run(finalized_function.lifespan_manager.lifespan_shutdown())
-                finally:
-                    # no need to keep the lifespan asgi call around - we send it no more messages
-                    for lifespan_background_task in lifespan_background_tasks:
-                        lifespan_background_task.cancel()  # prevent dangling tasks
-
-                    # Identify "exit" methods and run them.
-                    # want to make sure this is called even if the lifespan manager fails
-                    if service.user_cls_instance is not None and not is_auto_snapshot:
-                        exit_methods = _find_callables_for_obj(service.user_cls_instance, _PartialFunctionFlags.EXIT)
-                        call_lifecycle_functions(event_loop, container_io_manager, list(exit_methods.values()))
-
-                # Finally, commit on exit to catch uncommitted volume changes and surface background
-                # commit errors.
-                container_io_manager.volume_commit(
-                    [v.volume_id for v in function_def.volume_mounts if v.allow_background_commits]
-                )
-            finally:
-                # Restore the original signal handler, needed for container_test hygiene since the
-                # test runs `main()` multiple times in the same process.
-                signal.signal(signal.SIGINT, int_handler)
-                signal.signal(signal.SIGUSR1, usr1_handler)
+        with service.execution_context(event_loop, container_io_manager) as finalized_functions:
+            call_function(event_loop, container_io_manager, finalized_functions, batch_max_size, batch_wait_ms)
 
 
 if __name__ == "__main__":