modAL 1.3.1__tar.gz → 1.3.1.dev1__tar.gz

{modal-1.3.1 → modal-1.3.1.dev1}/PKG-INFO

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

@@ -41,7 +41,6 @@ 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:
@@ -76,7 +75,6 @@ __all__ = [
     "SandboxSnapshot",
     "SchedulerPlacement",
     "Secret",
-    "Server",
     "Tunnel",
     "Volume",
     "asgi_app",

{modal-1.3.1 → modal-1.3.1.dev1}/modal/__main__.py

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

{modal-1.3.1 → modal-1.3.1.dev1}/modal/_billing.py

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

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

@@ -5,7 +5,6 @@ import os
 from modal._runtime.user_code_imports import (
     Service,
     import_class_service,
-    import_server_service,
     import_single_function_service,
 )
 
@@ -301,18 +300,7 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                 param_kwargs = {}
 
             with execution_context._import_context():
-                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:
+                if 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.1 → modal-1.3.1.dev1}/modal/_functions.py

@@ -689,7 +689,6 @@ 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,
@@ -723,6 +722,7 @@ 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,8 +734,7 @@ 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:
@@ -1055,7 +1054,6 @@ 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):
@@ -1095,7 +1093,6 @@ 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.1 → modal-1.3.1.dev1}/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_frame
+from ._traceback import suppress_tb_frames
 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_frame():
+        with suppress_tb_frames(1):
             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_frame():
+        with suppress_tb_frames(1):
             if timeout is not None and retry is not None:
                 raise exception.InvalidError("Retry must be None when timeout is set")
 

{modal-1.3.1 → modal-1.3.1.dev1}/modal/_load_context.py

@@ -1,12 +1,9 @@
 # Copyright Modal Labs 2025
-from typing import TYPE_CHECKING, Optional
+from typing import 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.
@@ -18,7 +15,6 @@ class LoadContext:
     _client: Optional[_Client] = None
     _environment_name: Optional[str] = None
     _app_id: Optional[str] = None
-    _task_context: Optional["TaskContext"] = None
 
     def __init__(
         self,
@@ -26,12 +22,10 @@ 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:
@@ -47,11 +41,6 @@ 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.
@@ -70,7 +59,6 @@ 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":
@@ -83,27 +71,16 @@ 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,
-        task_context: Optional["TaskContext"] = None,
+        self, client: Optional[_Client] = None, environment_name: Optional[str] = None, app_id: Optional[str] = None
     ) -> "LoadContext":
         """In-place set values if they aren't already set, or set default values
 
@@ -126,5 +103,4 @@ 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 → modal-1.3.1.dev1}/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_frame
+from modal._traceback import suppress_tb_frames
 
 from ._load_context import LoadContext
 from ._resolver import Resolver
-from ._utils.async_utils import TaskContext, aclosing
+from ._utils.async_utils import aclosing
 from ._utils.deprecation import deprecation_warning
 from .client import _Client
 from .config import config, logger
@@ -127,11 +127,9 @@ 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]}. "
-                "This usually means the object name was previously used for a different type. "
-                "Rename the object/app or stop the previous deployment and redeploy."
+                f" but the object_id starts with {object_id[:3]}"
             )
         self._object_id = object_id
         self._client = client
@@ -139,7 +137,7 @@ class _Object:
         self._is_hydrated = True
 
     def _hydrate_metadata(self, metadata: Optional[Message]):
-        # override this if it's a subclass that needs additional data (other than an object_id) for a functioning Handle
+        # override this is subclasses that need additional data (other than an object_id) for a functioning Handle
         pass
 
     def _get_metadata(self) -> Optional[Message]:
@@ -316,10 +314,9 @@ 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()
-                    async with TaskContext() as tc:
-                        root_load_context = LoadContext(task_context=tc)
-                        await resolver.load(typing.cast(_Object, self), root_load_context)
+                    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()
@@ -328,13 +325,11 @@ class _Object:
         elif not self._hydrate_lazily:
             self._validate_is_hydrated()
         else:
-            # Set the client on LoadContext before loading, with a TaskContext for proper
-            # exception handling when loading shared dependencies
+            # Set the client on LoadContext before loading
+            root_load_context = LoadContext(client=client)
             resolver = Resolver()
-            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)
+            with suppress_tb_frames(1):  # skip this frame by default
+                await resolver.load(self, root_load_context)
         return self
 
 

{modal-1.3.1 → modal-1.3.1.dev1}/modal/_output.py

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

{modal-1.3.1 → modal-1.3.1.dev1}/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
+from .config import config, logger
 from .exception import InvalidError
 
 MAX_MAX_BATCH_SIZE = 1000
@@ -125,6 +125,7 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
     user_cls: Optional[type] = None  # class
     flags: _PartialFunctionFlags
     params: _PartialFunctionParams
+    registered: bool
 
     def __init__(
         self,
@@ -140,6 +141,7 @@ 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:
@@ -154,11 +156,13 @@ 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(
@@ -170,17 +174,20 @@ 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."
@@ -189,12 +196,15 @@ 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]:
@@ -234,6 +244,17 @@ 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.1 → modal-1.3.1.dev1}/modal/_resolver.py

@@ -9,10 +9,11 @@ from collections.abc import Hashable
 from typing import TYPE_CHECKING, Optional
 
 import modal._object
-from modal._traceback import suppress_tb_frame
+from modal._traceback import suppress_tb_frames
 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
@@ -34,7 +35,7 @@ class StatusRow:
 
     def warning(self, warning: api_pb2.Warning):
         if self._step_node is not None:
-            self._step_node.add(f"⚠️ {warning.message}")
+            self._step_node.add(f"[yellow]:warning:[/yellow] {warning.message}")
 
     def finish(self, message):
         if self._step_node is not None and self._spinner is not None:
@@ -119,41 +120,37 @@ class Resolver:
         if not cached_future:
             # don't run any awaits within this if-block to prevent race conditions
             async def 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())
+                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())
             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_frame():
+        with suppress_tb_frames(2):
+            # skip current frame + `loader()` closure frame from above
             return await cached_future
 
     def objects(self) -> list["modal._object._Object"]: