modal 0.62.16__py3-none-any.whl → 0.72.11__py3-none-any.whl

modal/_resolver.py

@@ -1,13 +1,16 @@
 # Copyright Modal Labs 2023
 import asyncio
 import contextlib
+import typing
 from asyncio import Future
-from typing import TYPE_CHECKING, Dict, Hashable, List, Optional
+from collections.abc import Hashable
+from typing import TYPE_CHECKING, Optional
 
 from grpclib import GRPCError, Status
 
-from modal.exception import ExecutionError, NotFoundError
-from modal_proto import api_pb2
+from ._utils.async_utils import TaskContext
+from .client import _Client
+from .exception import NotFoundError
 
 if TYPE_CHECKING:
     from rich.tree import Tree
@@ -16,61 +19,62 @@ if TYPE_CHECKING:
 
 
 class StatusRow:
-    def __init__(self, progress: "Optional[Tree]"):
-        from ._output import (
-            step_progress,
-        )
-
+    def __init__(self, progress: "typing.Optional[Tree]"):
         self._spinner = None
         self._step_node = None
         if progress is not None:
-            self._spinner = step_progress()
+            from ._output import OutputManager
+
+            self._spinner = OutputManager.step_progress()
             self._step_node = progress.add(self._spinner)
 
     def message(self, message):
-        from ._output import step_progress_update
-
         if self._spinner is not None:
-            step_progress_update(self._spinner, message)
+            self._spinner.update(text=message)
 
     def finish(self, message):
-        from ._output import step_completed, step_progress_update
-
         if self._step_node is not None:
-            step_progress_update(self._spinner, message)
-            self._step_node.label = step_completed(message, is_substep=True)
+            from ._output import OutputManager
+
+            self._spinner.update(text=message)
+            self._step_node.label = OutputManager.substep_completed(message)
 
 
 class Resolver:
-    _local_uuid_to_future: Dict[str, Future]
+    _local_uuid_to_future: dict[str, Future]
     _environment_name: Optional[str]
     _app_id: Optional[str]
-    _deduplication_cache: Dict[Hashable, Future]
+    _deduplication_cache: dict[Hashable, Future]
+    _client: _Client
 
     def __init__(
         self,
-        client=None,
+        client: _Client,
         *,
-        output_mgr=None,
         environment_name: Optional[str] = None,
         app_id: Optional[str] = None,
     ):
-        from rich.tree import Tree
+        try:
+            # TODO(michael) If we don't clean this up more thoroughly, it would probably
+            # be good to have a single source of truth for "rich is installed" rather than
+            # doing a try/catch everywhere we want to use it.
+            from rich.tree import Tree
+
+            from ._output import OutputManager
 
-        from ._output import step_progress
+            tree = Tree(OutputManager.step_progress("Creating objects..."), guide_style="gray50")
+        except ImportError:
+            tree = None
 
-        self._output_mgr = output_mgr
         self._local_uuid_to_future = {}
-        self._tree = Tree(step_progress("Creating objects..."), guide_style="gray50")
+        self._tree = tree
         self._client = client
         self._app_id = app_id
         self._environment_name = environment_name
         self._deduplication_cache = {}
 
     @property
-    def app_id(self) -> str:
-        if self._app_id is None:
-            raise ExecutionError("Resolver has no app")
+    def app_id(self) -> Optional[str]:
         return self._app_id
 
     @property
@@ -117,7 +121,7 @@ class Resolver:
             async def loader():
                 # Wait for all its dependencies
                 # TODO(erikbern): do we need existing_object_id for those?
-                await asyncio.gather(*[self.load(dep) for dep in obj.deps()])
+                await TaskContext.gather(*[self.load(dep) for dep in obj.deps()])
 
                 # Load the object itself
                 try:
@@ -127,16 +131,18 @@ class Resolver:
                         raise NotFoundError(exc.message)
                     raise
 
-                # Check that the id of functions and classes didn't change
-                # TODO(erikbern): revisit this once stub assignments have been disallowed
-                if not obj._is_another_app and (obj.object_id.startswith("fu-") or obj.object_id.startswith("cs-")):
-                    # Persisted refs are ignored because their life cycle is managed independently.
-                    # The same tag on an app can be pointed at different objects.
-                    if existing_object_id is not None 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}"
-                        )
+                # 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
 
@@ -145,10 +151,11 @@ class Resolver:
             if deduplication_key is not None:
                 self._deduplication_cache[deduplication_key] = cached_future
 
+        # TODO(elias): print original exception/trace rather than the Resolver-internal trace
         return await cached_future
 
-    def objects(self) -> List["_Object"]:
-        unique_objects: Dict[str, "_Object"] = {}
+    def objects(self) -> list["_Object"]:
+        unique_objects: dict[str, "_Object"] = {}
         for fut in self._local_uuid_to_future.values():
             if not fut.done():
                 # this will raise an exception if not all loads have been awaited, but that *should* never happen
@@ -161,27 +168,16 @@ class Resolver:
 
     @contextlib.contextmanager
     def display(self):
-        from ._output import step_completed
+        # TODO(erikbern): get rid of this wrapper
+        from .output import _get_output_manager
 
-        if self._output_mgr is None:
-            yield
-        else:
-            with self._output_mgr.ctx_if_visible(self._output_mgr.make_live(self._tree)):
+        if self._tree and (output_mgr := _get_output_manager()):
+            with output_mgr.make_live(self._tree):
                 yield
-            self._tree.label = step_completed("Created objects.")
-            self._output_mgr.print_if_visible(self._tree)
+            self._tree.label = output_mgr.step_completed("Created objects.")
+            output_mgr.print(self._tree)
+        else:
+            yield
 
     def add_status_row(self) -> StatusRow:
         return StatusRow(self._tree)
-
-    async def console_write(self, log: api_pb2.TaskLogs):
-        if self._output_mgr is not None:
-            await self._output_mgr.put_log_content(log)
-
-    def console_flush(self):
-        if self._output_mgr is not None:
-            self._output_mgr.flush_lines()
-
-    def image_snapshot_update(self, image_id: str, task_progress: api_pb2.TaskProgress):
-        if self._output_mgr is not None:
-            self._output_mgr.update_snapshot_progress(image_id, task_progress)

modal/_resources.py

@@ -0,0 +1,51 @@
+# Copyright Modal Labs 2024
+from typing import Optional, Union
+
+from modal_proto import api_pb2
+
+from .exception import InvalidError
+from .gpu import GPU_T, parse_gpu_config
+
+
+def convert_fn_config_to_resources_config(
+    *,
+    cpu: Optional[Union[float, tuple[float, float]]],
+    memory: Optional[Union[int, tuple[int, int]]],
+    gpu: GPU_T,
+    ephemeral_disk: Optional[int],
+) -> api_pb2.Resources:
+    gpu_config = parse_gpu_config(gpu)
+    if cpu and isinstance(cpu, tuple):
+        if not cpu[0]:
+            raise InvalidError("CPU request must be a positive number")
+        elif not cpu[1]:
+            raise InvalidError("CPU limit must be a positive number")
+        milli_cpu = int(1000 * cpu[0])
+        milli_cpu_max = int(1000 * cpu[1])
+        if milli_cpu_max < milli_cpu:
+            raise InvalidError(f"Cannot specify a CPU limit lower than request: {milli_cpu_max} < {milli_cpu}")
+    elif cpu and isinstance(cpu, (float, int)):
+        milli_cpu = int(1000 * cpu)
+        milli_cpu_max = None
+    else:
+        milli_cpu = None
+        milli_cpu_max = None
+
+    if memory and isinstance(memory, int):
+        memory_mb = memory
+        memory_mb_max = 0  # no limit
+    elif memory and isinstance(memory, tuple):
+        memory_mb, memory_mb_max = memory
+        if memory_mb_max < memory_mb:
+            raise InvalidError(f"Cannot specify a memory limit lower than request: {memory_mb_max} < {memory_mb}")
+    else:
+        memory_mb = 0
+        memory_mb_max = 0
+    return api_pb2.Resources(
+        milli_cpu=milli_cpu,
+        milli_cpu_max=milli_cpu_max,
+        gpu_config=gpu_config,
+        memory_mb=memory_mb,
+        memory_mb_max=memory_mb_max,
+        ephemeral_disk_mb=ephemeral_disk,
+    )

modal/_runtime/__init__.py

@@ -0,0 +1 @@
+# Copyright Modal Labs 2024