modAL 1.3.0__tar.gz → 1.3.1__tar.gz

{modal-1.3.0 → modal-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.3.0
+Version: 1.3.1
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0
@@ -20,7 +20,8 @@ Requires-Dist: aiohttp
 Requires-Dist: cbor2
 Requires-Dist: certifi
 Requires-Dist: click~=8.1
-Requires-Dist: grpclib<0.4.10,>=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.11.1

{modal-1.3.0 → modal-1.3.1}/modal/__init__.py

@@ -41,6 +41,7 @@ try:
     from .schedule import Cron, Period
     from .scheduler_placement import SchedulerPlacement
     from .secret import Secret
+    from .server import Server
     from .snapshot import SandboxSnapshot
     from .volume import Volume
 except Exception:
@@ -75,6 +76,7 @@ __all__ = [
     "SandboxSnapshot",
     "SchedulerPlacement",
     "Secret",
+    "Server",
     "Tunnel",
     "Volume",
     "asgi_app",

{modal-1.3.0 → modal-1.3.1}/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.0 → modal-1.3.1}/modal/_billing.py

@@ -52,11 +52,15 @@ async def _workspace_billing_report(
     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.")
+    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,

{modal-1.3.0 → modal-1.3.1}/modal/_container_entrypoint.py

@@ -5,6 +5,7 @@ import os
 from modal._runtime.user_code_imports import (
     Service,
     import_class_service,
+    import_server_service,
     import_single_function_service,
 )
 
@@ -300,7 +301,18 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                 param_kwargs = {}
 
             with execution_context._import_context():
-                if function_def.is_class:
+                if function_def.is_server:
+                    service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
+                    service_function_hydration_data = [
+                        o for o in container_args.app_layout.objects if o.object_id == service_base_function_id
+                    ][0]
+                    service = import_server_service(
+                        function_def,
+                        service_function_hydration_data,
+                        client,
+                        ser_usr_cls,
+                    )
+                elif function_def.is_class:
                     # this is a bit ugly - match the function and class based on function name to get metadata
                     # This metadata is required in order to hydrate the class in case it's not globally
                     # decorated (or serialized)

{modal-1.3.0 → modal-1.3.1}/modal/_functions.py

@@ -689,6 +689,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         nonpreemptible: bool = False,
         is_builder_function: bool = False,
         is_auto_snapshot: bool = False,
+        is_server: bool = False,
         enable_memory_snapshot: bool = False,
         block_network: bool = False,
         restrict_modal_access: bool = False,
@@ -722,7 +723,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     f"Function {raw_f} has a schedule, so it needs to support being called with no arguments"
                 )
         else:
-            # must be a "class service function"
             assert info.user_cls
             assert not webhook_config
             assert not schedule
@@ -734,7 +734,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         ]
 
         retry_policy = _parse_retries(
-            retries, f"Function '{info.get_tag()}'" if info.raw_f else f"Class '{info.get_tag()}'"
+            retries,
+            f"Function '{info.get_tag()}'" if info.raw_f else f"Class '{info.get_tag()}'",
         )
 
         if retry_policy is not None:
@@ -1054,6 +1055,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     supported_input_formats=supported_input_formats,
                     supported_output_formats=supported_output_formats,
                     http_config=http_config,
+                    is_server=is_server,
                 )
 
                 if isinstance(gpu, list):
@@ -1093,6 +1095,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         supported_input_formats=supported_input_formats,
                         supported_output_formats=supported_output_formats,
                         http_config=http_config,
+                        is_server=function_definition.is_server,
                     )
 
                     ranked_functions = []

{modal-1.3.0 → modal-1.3.1}/modal/_grpc_client.py

@@ -6,7 +6,7 @@ from google.protobuf.message import Message
 from grpclib import GRPCError, Status
 
 from . import exception
-from ._traceback import suppress_tb_frames
+from ._traceback import suppress_tb_frame
 from ._utils.grpc_utils import Retry, _retry_transient_errors
 from .config import config, logger
 
@@ -50,7 +50,7 @@ class grpc_error_converter:
     def __exit__(self, exc_type, exc, traceback) -> Literal[False]:
         # skip all internal frames from grpclib
         use_full_traceback = config.get("traceback")
-        with suppress_tb_frames(1):
+        with suppress_tb_frame():
             if isinstance(exc, GRPCError):
                 modal_exc = _STATUS_TO_EXCEPTION[exc.status](exc.message)
                 modal_exc._grpc_message = exc.message
@@ -115,7 +115,7 @@ class UnaryUnaryWrapper(Generic[RequestType, ResponseType]):
         timeout: Optional[float] = None,
         metadata: Optional[list[tuple[str, str]]] = None,
     ) -> ResponseType:
-        with suppress_tb_frames(1):
+        with suppress_tb_frame():
             if timeout is not None and retry is not None:
                 raise exception.InvalidError("Retry must be None when timeout is set")
 

{modal-1.3.0 → modal-1.3.1}/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.0 → modal-1.3.1}/modal/_object.py

@@ -9,11 +9,11 @@ from typing import Callable, ClassVar, Optional
 from google.protobuf.message import Message
 from typing_extensions import Self
 
-from modal._traceback import suppress_tb_frames
+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
@@ -127,9 +127,11 @@ class _Object:
         assert isinstance(object_id, str) and self._type_prefix is not None
         if not object_id.startswith(self._type_prefix):
             raise ExecutionError(
-                f"Can not hydrate {type(self)}:"
+                f"Can not hydrate {type(self)}: "
                 f" it has type prefix {self._type_prefix}"
-                f" but the object_id starts with {object_id[:3]}"
+                f" but the object_id starts with {object_id[:3]}. "
+                "This usually means the object name was previously used for a different type. "
+                "Rename the object/app or stop the previous deployment and redeploy."
             )
         self._object_id = object_id
         self._client = client
@@ -137,7 +139,7 @@ class _Object:
         self._is_hydrated = True
 
     def _hydrate_metadata(self, metadata: Optional[Message]):
-        # override this is subclasses that need additional data (other than an object_id) for a functioning Handle
+        # override this if it's a subclass that needs additional data (other than an object_id) for a functioning Handle
         pass
 
     def _get_metadata(self) -> Optional[Message]:
@@ -314,9 +316,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 +328,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_frames(1):  # 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.0 → modal-1.3.1}/modal/_output.py

@@ -169,9 +169,9 @@ class OutputManager:
 
     @classmethod
     @contextlib.contextmanager
-    def enable_output(cls, show_progress: bool = True) -> Generator[None]:
+    def enable_output(cls, show_progress: bool = True, show_timestamps: bool = False) -> Generator[None]:
         if show_progress:
-            cls._instance = OutputManager()
+            cls._instance = OutputManager(show_timestamps=show_timestamps)
         try:
             yield
         finally:

{modal-1.3.0 → modal-1.3.1}/modal/_partial_function.py

@@ -19,7 +19,7 @@ from ._functions import _Function
 from ._utils.async_utils import synchronizer
 from ._utils.deprecation import deprecation_warning
 from ._utils.function_utils import callable_has_non_self_params
-from .config import config, logger
+from .config import config
 from .exception import InvalidError
 
 MAX_MAX_BATCH_SIZE = 1000
@@ -125,7 +125,6 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
     user_cls: Optional[type] = None  # class
     flags: _PartialFunctionFlags
     params: _PartialFunctionParams
-    registered: bool
 
     def __init__(
         self,
@@ -141,7 +140,6 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
             self.user_cls = None
         self.flags = flags
         self.params = params
-        self.registered = False
         self.validate_flag_composition()
 
     def stack(self, flags: _PartialFunctionFlags, params: _PartialFunctionParams) -> typing_extensions.Self:
@@ -156,13 +154,11 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
         uses_interface_flags = self.flags & _PartialFunctionFlags.interface_flags()
         uses_lifecycle_flags = self.flags & _PartialFunctionFlags.lifecycle_flags()
         if uses_interface_flags and uses_lifecycle_flags:
-            self.registered = True  # Hacky, avoid false-positive warning
             raise InvalidError("Interface decorators cannot be combined with lifecycle decorators.")
 
         has_web_interface = self.flags & _PartialFunctionFlags.WEB_INTERFACE
         has_callable_interface = self.flags & _PartialFunctionFlags.CALLABLE_INTERFACE
         if has_web_interface and has_callable_interface:
-            self.registered = True  # Hacky, avoid false-positive warning
             raise InvalidError("Callable decorators cannot be combined with web interface decorators.")
 
     def validate_obj_compatibility(
@@ -174,20 +170,17 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
         uses_lifecycle_flags = self.flags & _PartialFunctionFlags.lifecycle_flags()
         uses_interface_flags = self.flags & _PartialFunctionFlags.interface_flags()
         if self.user_cls is not None and (uses_lifecycle_flags or uses_interface_flags):
-            self.registered = True  # Hacky, avoid false-positive warning
             raise InvalidError(
                 f"Cannot apply `@modal.{decorator_name}` to a class. Hint: consider applying to a method instead."
             )
 
         wrapped_object = self.raw_f or self.user_cls
         if isinstance(wrapped_object, _Function):
-            self.registered = True  # Hacky, avoid false-positive warning
             raise InvalidError(
                 f"Cannot stack `@modal.{decorator_name}` on top of `@app.function`."
                 " Hint: swap the order of the decorators."
             )
         elif isinstance(wrapped_object, _Cls):
-            self.registered = True  # Hacky, avoid false-positive warning
             raise InvalidError(
                 f"Cannot stack `@modal.{decorator_name}` on top of `@app.cls()`."
                 " Hint: swap the order of the decorators."
@@ -196,15 +189,12 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
         # Run some assertions about a callable wrappee defined by the specific decorator used
         if self.raw_f is not None:
             if not callable(self.raw_f):
-                self.registered = True  # Hacky, avoid false-positive warning
                 raise InvalidError(f"The object wrapped by `@modal.{decorator_name}` must be callable.")
 
             if require_sync and inspect.iscoroutinefunction(self.raw_f):
-                self.registered = True  # Hacky, avoid false-positive warning
                 raise InvalidError(f"The `@modal.{decorator_name}` decorator can't be applied to an async function.")
 
             if require_nullary and callable_has_non_self_params(self.raw_f):
-                self.registered = True  # Hacky, avoid false-positive warning
                 raise InvalidError(f"Functions decorated by `@modal.{decorator_name}` can't have parameters.")
 
     def _get_raw_f(self) -> Callable[P, ReturnType]:
@@ -244,17 +234,6 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
             # to let it be bound to a variable and become a Function later on
             return self  # type: ignore  # this returns a PartialFunction in a special internal case
 
-    def __del__(self):
-        if self.registered is False:
-            if self.raw_f is not None:
-                name, object_type, suggestion = self.raw_f.__name__, "function", "@app.function or @app.cls"
-            elif self.user_cls is not None:
-                name, object_type, suggestion = self.user_cls.__name__, "class", "@app.cls"
-            logger.warning(
-                f"The `{name}` {object_type} was never registered with the App."
-                f" Did you forget an {suggestion} decorator?"
-            )
-
 
 def _find_partial_methods_for_user_cls(user_cls: type[Any], flags: int) -> dict[str, _PartialFunction]:
     """Grabs all method on a user class, and returns partials. Includes legacy methods."""

{modal-1.3.0 → modal-1.3.1}/modal/_resolver.py

@@ -9,11 +9,10 @@ from collections.abc import Hashable
 from typing import TYPE_CHECKING, Optional
 
 import modal._object
-from modal._traceback import suppress_tb_frames
+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
@@ -35,7 +34,7 @@ class StatusRow:
 
     def warning(self, warning: api_pb2.Warning):
         if self._step_node is not None:
-            self._step_node.add(f"[yellow]:warning:[/yellow] {warning.message}")
+            self._step_node.add(f"⚠️ {warning.message}")
 
     def finish(self, message):
         if self._step_node is not None and self._spinner is not None:
@@ -120,37 +119,41 @@ class Resolver:
         if not cached_future:
             # don't run any awaits within this if-block to prevent race conditions
             async def loader():
-                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()])
-
-                # Load the object itself
-                if not obj._load:
-                    raise Exception(f"Object {obj} has no loader function")
-
-                await obj._load(obj, self, load_context, existing_object_id)
-
-                # Check that the id of functions didn't change
-                # Persisted refs are ignored because their life cycle is managed independently.
-                if (
-                    not obj._is_another_app
-                    and existing_object_id is not None
-                    and existing_object_id.startswith("fu-")
-                    and obj.object_id != existing_object_id
-                ):
-                    raise Exception(
-                        f"Tried creating an object using existing id {existing_object_id} but it has id {obj.object_id}"
-                    )
-
-                return obj
-
-            cached_future = asyncio.create_task(loader())
+                with suppress_tb_frame():
+                    load_context = await obj._load_context_overrides.merged_with(parent_load_context).apply_defaults()
+
+                    # 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:
+                        raise Exception(f"Object {obj} has no loader function")
+
+                    await obj._load(obj, self, load_context, existing_object_id)
+
+                    # Check that the id of functions didn't change
+                    # Persisted refs are ignored because their life cycle is managed independently.
+                    if (
+                        not obj._is_another_app
+                        and existing_object_id is not None
+                        and existing_object_id.startswith("fu-")
+                        and obj.object_id != existing_object_id
+                    ):
+                        raise Exception(
+                            f"Tried creating an object using existing id {existing_object_id} "
+                            f"but it has id {obj.object_id}"
+                        )
+
+                    return obj
+
+            # 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
-        with suppress_tb_frames(2):
-            # skip current frame + `loader()` closure frame from above
+        with suppress_tb_frame():
             return await cached_future
 
     def objects(self) -> list["modal._object._Object"]: