modal 1.3.1.dev28__tar.gz → 1.3.1.dev30__tar.gz

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/PKG-INFO

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

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/__main__.py

@@ -35,6 +35,7 @@ def main():
         ):
             raise
 
+        from rich.markup import escape
         from rich.panel import Panel
 
         title = "Error"
@@ -43,7 +44,7 @@ def main():
             content = f"{content}\n\nNote: {' '.join(notes)}"
 
         console = make_console(stderr=True)
-        panel = Panel(content, title=title, title_align="left", border_style="red")
+        panel = Panel(escape(content), title=title, title_align="left", border_style="red")
         console.print(panel, highlight=False)
         sys.exit(1)
 

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/_load_context.py

@@ -1,9 +1,12 @@
 # Copyright Modal Labs 2025
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from .client import _Client
 from .config import config
 
+if TYPE_CHECKING:
+    from ._utils.async_utils import TaskContext
+
 
 class LoadContext:
     """Encapsulates optional metadata values used during object loading.
@@ -15,6 +18,7 @@ class LoadContext:
     _client: Optional[_Client] = None
     _environment_name: Optional[str] = None
     _app_id: Optional[str] = None
+    _task_context: Optional["TaskContext"] = None
 
     def __init__(
         self,
@@ -22,10 +26,12 @@ class LoadContext:
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
         app_id: Optional[str] = None,
+        task_context: Optional["TaskContext"] = None,
     ):
         self._client = client
         self._environment_name = environment_name
         self._app_id = app_id
+        self._task_context = task_context
 
     @property
     def client(self) -> _Client:
@@ -41,6 +47,11 @@ class LoadContext:
     def app_id(self) -> Optional[str]:
         return self._app_id
 
+    @property
+    def task_context(self) -> "TaskContext":
+        assert self._task_context is not None, "LoadContext has no TaskContext"
+        return self._task_context
+
     @classmethod
     def empty(cls) -> "LoadContext":
         """Create an empty LoadContext with all fields set to None.
@@ -59,6 +70,7 @@ class LoadContext:
             client=self._client if self._client is not None else parent._client,
             environment_name=self._environment_name if self._environment_name is not None else parent._environment_name,
             app_id=self._app_id if self._app_id is not None else parent._app_id,
+            task_context=self._task_context if self._task_context is not None else parent._task_context,
         )  # TODO (elias):  apply_defaults?
 
     async def apply_defaults(self) -> "LoadContext":
@@ -71,16 +83,27 @@ class LoadContext:
             client=self.client if is_valid_client else await _Client.from_env(),
             environment_name=self._environment_name or config.get("environment") or "",
             app_id=self._app_id,
+            task_context=self._task_context,
         )
 
     def reset(self) -> "LoadContext":
+        """In-place replace all values with None, such that any inferred values/upgrades
+        will work. This is useful in cases where a load context reference may have leaked
+        into objects and used/upgraded but you want to make a fresh re-load, e.g. when doing
+        multiple `app.run()` calls in the same interpreter session.
+        """
         self._client = None
         self._environment_name = None
         self._app_id = None
+        self._task_context = None
         return self
 
     async def in_place_upgrade(
-        self, client: Optional[_Client] = None, environment_name: Optional[str] = None, app_id: Optional[str] = None
+        self,
+        client: Optional[_Client] = None,
+        environment_name: Optional[str] = None,
+        app_id: Optional[str] = None,
+        task_context: Optional["TaskContext"] = None,
     ) -> "LoadContext":
         """In-place set values if they aren't already set, or set default values
 
@@ -103,4 +126,5 @@ class LoadContext:
         self._client = self._client or client or await _Client.from_env()
         self._environment_name = self._environment_name or environment_name or config.get("environment") or ""
         self._app_id = self._app_id or app_id
+        self._task_context = self._task_context or task_context
         return self

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/_object.py

@@ -13,7 +13,7 @@ from modal._traceback import suppress_tb_frame
 
 from ._load_context import LoadContext
 from ._resolver import Resolver
-from ._utils.async_utils import aclosing
+from ._utils.async_utils import TaskContext, aclosing
 from ._utils.deprecation import deprecation_warning
 from .client import _Client
 from .config import config, logger
@@ -314,9 +314,10 @@ class _Object:
                     self._is_hydrated = False  # un-hydrate and re-resolve
                     # we don't set an explicit Client here, relying on the default
                     # env client to be applied by LoadContext.apply_default
-                    root_load_context = LoadContext.empty()
                     resolver = Resolver()
-                    await resolver.load(typing.cast(_Object, self), root_load_context)
+                    async with TaskContext() as tc:
+                        root_load_context = LoadContext(task_context=tc)
+                        await resolver.load(typing.cast(_Object, self), root_load_context)
                 else:
                     logger.debug(f"reloading non-lazy {self} by replacing client")
                     self._client = client or await _Client.from_env()
@@ -325,11 +326,13 @@ class _Object:
         elif not self._hydrate_lazily:
             self._validate_is_hydrated()
         else:
-            # Set the client on LoadContext before loading
-            root_load_context = LoadContext(client=client)
+            # Set the client on LoadContext before loading, with a TaskContext for proper
+            # exception handling when loading shared dependencies
             resolver = Resolver()
-            with suppress_tb_frame():  # skip this frame by default
-                await resolver.load(self, root_load_context)
+            async with TaskContext() as tc:
+                root_load_context = LoadContext(client=client, task_context=tc)
+                with suppress_tb_frame():  # skip this frame by default
+                    await resolver.load(self, root_load_context)
         return self
 
 

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/_resolver.py

@@ -13,7 +13,6 @@ from modal._traceback import suppress_tb_frame
 from modal_proto import api_pb2
 
 from ._load_context import LoadContext
-from ._utils.async_utils import TaskContext
 
 if TYPE_CHECKING:
     from rich.tree import Tree
@@ -123,8 +122,10 @@ class Resolver:
                 with suppress_tb_frame():
                     load_context = await obj._load_context_overrides.merged_with(parent_load_context).apply_defaults()
 
-                    # TODO(erikbern): do we need existing_object_id for those?
-                    await TaskContext.gather(*[self.load(dep, load_context) for dep in obj.deps()])
+                    # Use asyncio.gather here (not TaskContext.gather) - the shared TaskContext
+                    # in load_context handles cancellation at the top level, preventing premature
+                    # cancellation of shared dependencies when sibling tasks fail.
+                    await asyncio.gather(*[self.load(dep, load_context) for dep in obj.deps()])
 
                     # Load the object itself
                     if not obj._load:
@@ -147,7 +148,8 @@ class Resolver:
 
                     return obj
 
-            cached_future = asyncio.create_task(loader())
+            # use task_context from load_context to make sure tasks are cleaned up eventually
+            cached_future = parent_load_context.task_context.create_task(loader())
             self._local_uuid_to_future[obj.local_uuid] = cached_future
             if deduplication_key is not None:
                 self._deduplication_cache[deduplication_key] = cached_future

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/_utils/async_utils.py

@@ -402,26 +402,32 @@ def retry(direct_fn=None, *, n_attempts=3, base_delay=0, delay_factor=2, timeout
 class TaskContext:
     """A structured group that helps manage stray tasks.
 
-    This differs from the standard library `asyncio.TaskGroup` in that it cancels all tasks still
+    This differs from the standard library `asyncio.TaskGroup` in that it *cancels* tasks still
     running after exiting the context manager, rather than waiting for them to finish.
 
-    A `TaskContext` can have an optional `grace` period in seconds, which will wait for a certain
-    amount of time before cancelling all remaining tasks. This is useful for allowing tasks to
-    gracefully exit when they determine that the context is shutting down.
+    Arguments:
+    `grace: float`: period in seconds, which will wait for a certain amount of time before cancelling
+    all remaining tasks. This is useful for allowing tasks to finish after the context exits.
+
+    `cancellation_grace: float = 1.0`: period in seconds that cancelled tasks are allowed to stall before
+    they exit once they get cancelled (e.g. if they do async handling of the CancelledError). If tasks
+    take longer than this to exit the tasks are left dangling when the context exits.
 
     Usage:
 
     ```python notest
-    async with TaskContext() as task_context:
+    async with TaskContext(grace=1.0) as task_context:
         task = task_context.create_task(coro())
     ```
     """
 
     _loops: set[asyncio.Task]
 
-    def __init__(self, grace: Optional[float] = None):
+    def __init__(self, grace: Optional[float] = None, *, cancellation_grace: float = 1.0):
         self._grace = grace  # grace is the time we want for tasks to finish before cancelling them
-        self._cancellation_grace: float = 1.0  # extra graceperiod for the cancellation itself to "bubble up"
+        self._cancellation_grace: float = (
+            cancellation_grace  # extra graceperiod for the cancellation itself to "bubble up"
+        )
         self._loops = set()
 
     async def start(self):
@@ -438,10 +444,19 @@ class TaskContext:
         return self
 
     async def stop(self):
+        """This is called when exiting the TaskContext
+
+        Two important properties that we need to maintain here:
+        * Should never raise exceptions as a result
+        of exceptions (incl. cancellations) in the contained tasks
+        * Should not have an open-ended runtime, even if
+        the contained tasks are uncooperative with cancellations.
+        """
         self._exited.set()
         await asyncio.sleep(0)  # Causes any just-created tasks to get started
         unfinished_tasks = [t for t in self._tasks if not t.done()]
         gather_future = None
+
         try:
             if self._grace is not None and unfinished_tasks:
                 gather_future = asyncio.gather(*unfinished_tasks, return_exceptions=True)
@@ -458,17 +473,16 @@ class TaskContext:
 
             cancelled_tasks: list[asyncio.Task] = []
             for task in self._tasks:
-                if task.done() and not task.cancelled():
-                    # Raise any exceptions if they happened.
-                    # Only tasks without a done_callback will still be present in self._tasks
-                    task.result()
-
                 if task.done():
-                    continue
-
-                # Cancel any remaining unfinished tasks.
-                task.cancel()
-                cancelled_tasks.append(task)
+                    # consume potential exceptions so we don't get warnings
+                    # not that this is not supposed to reraise exceptions
+                    # since those are expected to be reraised by aexit anyway
+                    with contextlib.suppress(BaseException):
+                        task.result()
+                else:
+                    # Cancel any remaining unfinished tasks.
+                    task.cancel()
+                    cancelled_tasks.append(task)
 
             cancellation_gather = asyncio.gather(*cancelled_tasks, return_exceptions=True)
             try:
@@ -479,7 +493,22 @@ class TaskContext:
             await asyncio.sleep(0)  # wake up coroutines waiting for cancellations
 
     async def __aexit__(self, exc_type, value, tb):
-        await self.stop()
+        """
+        This is a bit involved:
+        * If there is an exception within the "context", we typically always want to reraise that
+        * If a cancellation comes in *during* aexit/stop execution itself, we don't actually cancel
+          the exit logic (it's already performing cancellation logic of sorts), but we do reraise
+          the CancelledError to prevent muting cancellation chains
+        """
+        stop_task = asyncio.ensure_future(self.stop())
+        try:
+            await asyncio.shield(stop_task)
+        except asyncio.CancelledError:
+            if not stop_task.done():
+                # External cancellation - wait for stop() to finish, then propagate
+                with contextlib.suppress(asyncio.CancelledError):
+                    await stop_task  # always run stop_task to completion
+            raise
 
     def create_task(self, coro_or_task) -> asyncio.Task:
         if isinstance(coro_or_task, asyncio.Task):
@@ -537,9 +566,9 @@ class TaskContext:
         For example, if you use `asyncio.gather(t1, t2, t3)` and t2 raises an exception, then t1 and
         t3 would continue running. With `TaskContext.gather(t1, t2, t3)`, they are cancelled.
 
-        (It's still acceptable to use `asyncio.gather()` if you don't need cancellation — for
+        It's still useful to use `asyncio.gather()` if you don't need cancellation — for
         example, if you're just gathering quick coroutines with no side-effects. Or if you're
-        gathering the tasks with `return_exceptions=True`.)
+        gathering the tasks with `return_exceptions=True`.
 
         Usage:
 
@@ -557,8 +586,8 @@ class TaskContext:
         ```
         """
         async with TaskContext() as tc:
-            results = await asyncio.gather(*(tc.create_task(coro) for coro in coros))
-        return results
+            tasks = [tc.create_task(coro) for coro in coros]
+            return await asyncio.gather(*tasks)
 
 
 def run_coro_blocking(coro):

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/cli/_traceback.py

@@ -7,6 +7,7 @@ import warnings
 from typing import Optional
 
 from rich.console import RenderResult, group
+from rich.markup import escape
 from rich.panel import Panel
 from rich.syntax import Syntax
 from rich.text import Text
@@ -189,7 +190,7 @@ def highlight_modal_warnings() -> None:
             if date:
                 title += f" ({date})"
             panel = Panel(
-                message,
+                escape(message),
                 border_style="yellow",
                 title=title,
                 title_align="left",

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/cli/dict.py

@@ -7,7 +7,7 @@ from typer import Argument, Option, Typer
 from modal._load_context import LoadContext
 from modal._output import make_console
 from modal._resolver import Resolver
-from modal._utils.async_utils import synchronizer
+from modal._utils.async_utils import TaskContext, synchronizer
 from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
 from modal.client import _Client
@@ -32,8 +32,9 @@ async def create(name: str, *, env: Optional[str] = ENV_OPTION):
     client = await _Client.from_env()
     resolver = Resolver()
 
-    load_context = LoadContext(client=client, environment_name=env)
-    await resolver.load(d, load_context)
+    async with TaskContext() as tc:
+        load_context = LoadContext(client=client, environment_name=env, task_context=tc)
+        await resolver.load(d, load_context)
 
 
 @dict_cli.command(name="list", rich_help_panel="Management")

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/cli/queues.py

@@ -8,7 +8,7 @@ from typer import Argument, Option, Typer
 from modal._load_context import LoadContext
 from modal._output import make_console
 from modal._resolver import Resolver
-from modal._utils.async_utils import synchronizer
+from modal._utils.async_utils import TaskContext, synchronizer
 from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
 from modal.client import _Client
@@ -40,8 +40,9 @@ async def create(name: str, *, env: Optional[str] = ENV_OPTION):
     q = _Queue.from_name(name, environment_name=env, create_if_missing=True)
     client = await _Client.from_env()
     resolver = Resolver()
-    load_context = LoadContext(client=client, environment_name=env)
-    await resolver.load(q, load_context)
+    async with TaskContext() as tc:
+        load_context = LoadContext(client=client, environment_name=env, task_context=tc)
+        await resolver.load(q, load_context)
 
 
 @queue_cli.command(name="delete", rich_help_panel="Management")

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/client.py

@@ -74,6 +74,7 @@ class _Client:
     _stub: Optional[modal_api_grpc.ModalClientModal] = None
     _auth_token_manager: Optional[_AuthTokenManager] = None
     _snapshotted: bool = False
+    _connection_manager: Optional[ConnectionManager] = None
     client_type: "api_pb2.ClientType.ValueType"
 
     def __init__(
@@ -315,6 +316,7 @@ class _Client:
         # Get a valid grpclib channel, reusing existing channels if possible.
         # This prevents usage of stale channels across forks of processes.
         await self._reset_on_pid_change()
+        assert self._connection_manager  # invariant: ._open() should always have been called before this
         return await self._connection_manager.get_or_create_channel(server_url)
 
     @synchronizer.nowrap

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/client.pyi

@@ -5,6 +5,7 @@ import google.protobuf.message
 import grpclib.client
 import modal._utils.async_utils
 import modal._utils.auth_token_manager
+import modal._utils.grpc_utils
 import modal_proto.modal_api_grpc
 import synchronicity.combined_types
 import typing
@@ -26,6 +27,7 @@ class _Client:
     _stub: typing.Optional[modal_proto.modal_api_grpc.ModalClientModal]
     _auth_token_manager: typing.Optional[modal._utils.auth_token_manager._AuthTokenManager]
     _snapshotted: bool
+    _connection_manager: typing.Optional[modal._utils.grpc_utils.ConnectionManager]
     client_type: int
 
     def __init__(
@@ -33,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.3.1.dev28",
+        version: str = "1.3.1.dev30",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -156,6 +158,7 @@ class Client:
     _stub: typing.Optional[modal_proto.modal_api_grpc.ModalClientModal]
     _auth_token_manager: typing.Optional[modal._utils.auth_token_manager._AuthTokenManager]
     _snapshotted: bool
+    _connection_manager: typing.Optional[modal._utils.grpc_utils.ConnectionManager]
     client_type: int
 
     def __init__(
@@ -163,7 +166,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.3.1.dev28",
+        version: str = "1.3.1.dev30",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/image.py

@@ -33,7 +33,7 @@ from ._load_context import LoadContext
 from ._object import _Object, live_method_gen
 from ._resolver import Resolver
 from ._serialization import get_preferred_payload_format, serialize
-from ._utils.async_utils import deprecate_aio_usage, synchronize_api, synchronizer
+from ._utils.async_utils import TaskContext, deprecate_aio_usage, synchronize_api, synchronizer
 from ._utils.blob_utils import MAX_OBJECT_SIZE_BYTES
 from ._utils.docker_utils import (
     extract_copy_command_patterns,
@@ -959,7 +959,9 @@ class _Image(_Object, type_prefix="im"):
             raise InvalidError("App has not been initialized yet. Use the content manager `app.run()` or `App.lookup`")
 
         resolver = Resolver()
-        await resolver.load(self, app._root_load_context)
+        async with TaskContext() as tc:
+            load_context = LoadContext(task_context=tc).merged_with(app._root_load_context)
+            await resolver.load(self, load_context)
         return self
 
     def pip_install(

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/mount.py

@@ -679,8 +679,9 @@ class _Mount(_Object, type_prefix="mo"):
         self._namespace = namespace
         self._allow_overwrite = allow_overwrite
         resolver = Resolver()
-        root_metadata = LoadContext(client=client, environment_name=environment_name)
-        await resolver.load(self, root_metadata)
+        async with TaskContext() as tc:
+            load_context = LoadContext(client=client, environment_name=environment_name, task_context=tc)
+            await resolver.load(self, load_context)
 
     def _get_metadata(self) -> api_pb2.MountHandleMetadata:
         if self._content_checksum_sha256_hex is None:

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/runner.py

@@ -128,8 +128,13 @@ async def _create_all_objects(
     local_app_state: "modal.app._LocalAppState",
     load_context: LoadContext,
 ) -> None:
-    """Create objects that have been defined but not created on the server."""
+    """Create objects that have been defined but not created on the server.
+
+    The load_context must have a task_context set for proper exception handling
+    when loading shared dependencies.
+    """
     indexed_objects: dict[str, _Object] = {**local_app_state.functions, **local_app_state.classes}
+    tc = load_context.task_context
 
     resolver = Resolver()
     with resolver.display():
@@ -158,8 +163,6 @@ async def _create_all_objects(
             if obj.is_hydrated:
                 tag_to_object_id[tag] = obj.object_id
 
-        await TaskContext.gather(*(_preload(tag, obj) for tag, obj in indexed_objects.items()))
-
         async def _load(tag, obj):
             existing_object_id = tag_to_object_id.get(tag)
             # Pass load_context so dependencies can inherit app_id, client, etc.
@@ -171,7 +174,8 @@ async def _create_all_objects(
             else:
                 raise RuntimeError(f"Unexpected object {obj.object_id}")
 
-        await TaskContext.gather(*(_load(tag, obj) for tag, obj in indexed_objects.items()))
+        await asyncio.gather(*[tc.create_task(_preload(tag, obj)) for tag, obj in indexed_objects.items()])
+        await asyncio.gather(*[tc.create_task(_load(tag, obj)) for tag, obj in indexed_objects.items()])
 
 
 async def _publish_app(
@@ -296,10 +300,12 @@ async def _run_app(
         app_state=app_state,
         interactive=interactive,
     )
-    await load_context.in_place_upgrade(app_id=running_app.app_id)
 
     logs_timeout = config["logs_timeout"]
     async with app._set_local_app(load_context.client, running_app), TaskContext(grace=logs_timeout) as tc:
+        # Inject TaskContext into load_context for proper exception handling when loading shared dependencies
+        await load_context.in_place_upgrade(task_context=tc, app_id=running_app.app_id)
+
         # Start heartbeats loop to keep the client alive
         # we don't log heartbeat exceptions in detached mode
         # as losing the local connection will not affect the running app
@@ -443,10 +449,12 @@ async def _serve_update(
     load_context = await app._root_load_context.reset().in_place_upgrade(environment_name=environment_name)
     try:
         running_app: RunningApp = await _init_local_app_existing(load_context.client, existing_app_id, environment_name)
-        await load_context.in_place_upgrade(app_id=running_app.app_id)
         local_app_state = app._local_state
-        # Create objects
-        await _create_all_objects(running_app, local_app_state, load_context)
+
+        # Create objects with a TaskContext for proper exception handling
+        async with TaskContext() as tc:
+            await load_context.in_place_upgrade(task_context=tc, app_id=running_app.app_id)
+            await _create_all_objects(running_app, local_app_state, load_context)
 
         # Publish the updated app
         await _publish_app(
@@ -526,11 +534,10 @@ async def _deploy_app(
         root_load_context.client, name, local_app_state.tags, environment_name=root_load_context.environment_name
     )
 
-    await root_load_context.in_place_upgrade(
-        app_id=running_app.app_id,
-    )
-
     async with TaskContext(0) as tc:
+        # Inject TaskContext into load_context for proper exception handling when loading shared dependencies
+        await root_load_context.in_place_upgrade(task_context=tc, app_id=running_app.app_id)
+
         # Start heartbeats loop to keep the client alive
         def heartbeat():
             return _heartbeat(client, running_app.app_id)

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/runner.pyi

@@ -30,7 +30,11 @@ async def _create_all_objects(
     local_app_state: modal.app._LocalAppState,
     load_context: modal._load_context.LoadContext,
 ) -> None:
-    """Create objects that have been defined but not created on the server."""
+    """Create objects that have been defined but not created on the server.
+
+    The load_context must have a task_context set for proper exception handling
+    when loading shared dependencies.
+    """
     ...
 
 async def _publish_app(

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal/sandbox.py

@@ -491,8 +491,9 @@ class _Sandbox(_Object, type_prefix="sb"):
         client = client or app_client
 
         resolver = Resolver()
-        load_context = LoadContext(client=client, app_id=app_id)
-        await resolver.load(obj, load_context)
+        async with TaskContext() as tc:
+            load_context = LoadContext(client=client, app_id=app_id, task_context=tc)
+            await resolver.load(obj, load_context)
         return obj
 
     def _hydrate_metadata(self, handle_metadata: Optional[Message]):

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal.egg-info/PKG-INFO

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

{modal-1.3.1.dev28 → modal-1.3.1.dev30}/modal_version/__init__.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2025
 """Supplies the current version of the modal client library."""
 
-__version__ = "1.3.1.dev28"
+__version__ = "1.3.1.dev30"