modal 0.67.22__py3-none-any.whl → 0.67.42__py3-none-any.whl

modal/_container_entrypoint.py

@@ -478,7 +478,9 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
             if len(service.code_deps) != len(dep_object_ids):
                 raise ExecutionError(
                     f"Function has {len(service.code_deps)} dependencies"
-                    f" but container got {len(dep_object_ids)} object ids."
+                    f" but container got {len(dep_object_ids)} object ids.\n"
+                    f"Code deps: {service.code_deps}\n"
+                    f"Object ids: {dep_object_ids}"
                 )
             for object_id, obj in zip(dep_object_ids, service.code_deps):
                 metadata: Message = container_app.object_handle_metadata[object_id]

modal/_runtime/container_io_manager.py

@@ -908,7 +908,7 @@ class _ContainerIOManager:
         if self.checkpoint_id:
             logger.debug(f"Checkpoint ID: {self.checkpoint_id} (Memory Snapshot ID)")
         else:
-            logger.debug("No checkpoint ID provided (Memory Snapshot ID)")
+            raise ValueError("No checkpoint ID provided for memory snapshot")
 
         # Pause heartbeats since they keep the client connection open which causes the snapshotter to crash
         async with self.heartbeat_condition:
@@ -918,7 +918,7 @@ class _ContainerIOManager:
             self.heartbeat_condition.notify_all()
 
             await self._client.stub.ContainerCheckpoint(
-                api_pb2.ContainerCheckpointRequest(checkpoint_id=self.checkpoint_id or "")
+                api_pb2.ContainerCheckpointRequest(checkpoint_id=self.checkpoint_id)
             )
 
             await self._client._close(prep_for_restore=True)

modal/_utils/function_utils.py

@@ -248,7 +248,13 @@ class FunctionInfo:
     def get_globals(self) -> dict[str, Any]:
         from .._vendor.cloudpickle import _extract_code_globals
 
+        if self.raw_f is None:
+            return {}
+
         func = self.raw_f
+        while hasattr(func, "__wrapped__") and func is not func.__wrapped__:
+            # Unwrap functions decorated using functools.wrapped (potentially multiple times)
+            func = func.__wrapped__
         f_globals_ref = _extract_code_globals(func.__code__)
         f_globals = {k: func.__globals__[k] for k in f_globals_ref if k in func.__globals__}
         return f_globals

modal/cli/_traceback.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2024
 """Helper functions related to displaying tracebacks in the CLI."""
 import functools
+import re
 import warnings
 from typing import Optional
 
@@ -166,8 +167,12 @@ def highlight_modal_deprecation_warnings() -> None:
     def showwarning(warning, category, filename, lineno, file=None, line=None):
         if issubclass(category, (DeprecationError, PendingDeprecationError)):
             content = str(warning)
-            date = content[:10]
-            message = content[11:].strip()
+            if re.match(r"^\d{4}-\d{2}-\d{2}", content):
+                date = content[:10]
+                message = content[11:].strip()
+            else:
+                date = ""
+                message = content
             try:
                 with open(filename, encoding="utf-8", errors="replace") as code_file:
                     source = code_file.readlines()[lineno - 1].strip()
@@ -178,7 +183,7 @@ def highlight_modal_deprecation_warnings() -> None:
             panel = Panel(
                 message,
                 style="yellow",
-                title=f"Modal Deprecation Warning ({date})",
+                title=f"Modal Deprecation Warning ({date})" if date else "Modal Deprecation Warning",
                 title_align="left",
             )
             Console().print(panel)

modal/cli/app.py

@@ -115,7 +115,7 @@ def logs(
     ```
 
     """
-    app_identifier = warn_on_name_option("stop", app_identifier, name)
+    app_identifier = warn_on_name_option("logs", app_identifier, name)
     app_id = get_app_id(app_identifier, env)
     stream_app_logs(app_id)
 

modal/cli/network_file_system.py

@@ -10,7 +10,7 @@ from grpclib import GRPCError, Status
 from rich.console import Console
 from rich.syntax import Syntax
 from rich.table import Table
-from typer import Typer
+from typer import Argument, Typer
 
 import modal
 from modal._location import display_location
@@ -18,7 +18,7 @@ from modal._output import OutputManager, ProgressHandler
 from modal._utils.async_utils import synchronizer
 from modal._utils.grpc_utils import retry_transient_errors
 from modal.cli._download import _volume_download
-from modal.cli.utils import ENV_OPTION, display_table, timestamp_to_local
+from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table, timestamp_to_local
 from modal.client import _Client
 from modal.environments import ensure_env
 from modal.network_file_system import _NetworkFileSystem
@@ -217,3 +217,24 @@ async def rm(
         if exc.status in (Status.NOT_FOUND, Status.INVALID_ARGUMENT):
             raise UsageError(exc.message)
         raise
+
+
+@nfs_cli.command(
+    name="delete",
+    help="Delete a named, persistent modal.NetworkFileSystem.",
+    rich_help_panel="Management",
+)
+@synchronizer.create_blocking
+async def delete(
+    nfs_name: str = Argument(help="Name of the modal.NetworkFileSystem to be deleted. Case sensitive"),
+    yes: bool = YES_OPTION,
+    env: Optional[str] = ENV_OPTION,
+):
+    if not yes:
+        typer.confirm(
+            f"Are you sure you want to irrevocably delete the modal.NetworkFileSystem '{nfs_name}'?",
+            default=False,
+            abort=True,
+        )
+
+    await _NetworkFileSystem.delete(label=nfs_name, environment_name=env)

modal/client.py

@@ -147,7 +147,7 @@ class _Client:
             )
             if resp.warning:
                 ALARM_EMOJI = chr(0x1F6A8)
-                warnings.warn(f"{ALARM_EMOJI} {resp.warning} {ALARM_EMOJI}", DeprecationError)
+                warnings.warn_explicit(f"{ALARM_EMOJI} {resp.warning} {ALARM_EMOJI}", DeprecationError, "<unknown>", 0)
         except GRPCError as exc:
             if exc.status == Status.FAILED_PRECONDITION:
                 raise VersionError(

modal/client.pyi

@@ -26,7 +26,7 @@ class _Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.67.22"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.67.42"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -81,7 +81,7 @@ class Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.67.22"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.67.42"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/cls.py

@@ -72,6 +72,68 @@ def _get_class_constructor_signature(user_cls: type) -> inspect.Signature:
         return inspect.Signature(constructor_parameters)
 
 
+def _bind_instance_method(service_function: _Function, class_bound_method: _Function):
+    """mdmd:hidden
+
+    Binds an "instance service function" to a specific method.
+    This "dummy" _Function gets no unique object_id and isn't backend-backed at the moment, since all
+    it does it forward invocations to the underlying instance_service_function with the specified method,
+    and we don't support web_config for parameterized methods at the moment.
+    """
+    # TODO(elias): refactor to not use `_from_loader()` as a crutch for lazy-loading the
+    #   underlying instance_service_function. It's currently used in order to take advantage
+    #   of resolver logic and get "chained" resolution of lazy loads, even though this thin
+    #   object itself doesn't need any "loading"
+    assert service_function._obj
+    method_name = class_bound_method._use_method_name
+    full_function_name = f"{class_bound_method._function_name}[parameterized]"
+
+    def hydrate_from_instance_service_function(method_placeholder_fun):
+        method_placeholder_fun._hydrate_from_other(service_function)
+        method_placeholder_fun._obj = service_function._obj
+        method_placeholder_fun._web_url = (
+            class_bound_method._web_url
+        )  # TODO: this shouldn't be set when actual parameters are used
+        method_placeholder_fun._function_name = full_function_name
+        method_placeholder_fun._is_generator = class_bound_method._is_generator
+        method_placeholder_fun._cluster_size = class_bound_method._cluster_size
+        method_placeholder_fun._use_method_name = method_name
+        method_placeholder_fun._is_method = True
+
+    async def _load(fun: "_Function", resolver: Resolver, existing_object_id: Optional[str]):
+        # there is currently no actual loading logic executed to create each method on
+        # the *parameterized* instance of a class - it uses the parameter-bound service-function
+        # for the instance. This load method just makes sure to set all attributes after the
+        # `service_function` has been loaded (it's in the `_deps`)
+        hydrate_from_instance_service_function(fun)
+
+    def _deps():
+        if service_function.is_hydrated:
+            # without this check, the common service_function will be reloaded by all methods
+            # TODO(elias): Investigate if we can fix this multi-loader in the resolver - feels like a bug?
+            return []
+        return [service_function]
+
+    rep = f"Method({full_function_name})"
+
+    fun = _Function._from_loader(
+        _load,
+        rep,
+        deps=_deps,
+        hydrate_lazily=True,
+    )
+    if service_function.is_hydrated:
+        # Eager hydration (skip load) if the instance service function is already loaded
+        hydrate_from_instance_service_function(fun)
+
+    fun._info = class_bound_method._info
+    fun._obj = service_function._obj
+    fun._is_method = True
+    fun._app = class_bound_method._app
+    fun._spec = class_bound_method._spec
+    return fun
+
+
 class _Obj:
     """An instance of a `Cls`, i.e. `Cls("foo", 42)` returns an `Obj`.
 
@@ -90,10 +152,9 @@ class _Obj:
 
     def __init__(
         self,
-        user_cls: type,
+        user_cls: Optional[type],  # this would be None in case of lookups
         class_service_function: Optional[_Function],  # only None for <v0.63 classes
         classbound_methods: dict[str, _Function],
-        from_other_workspace: bool,
         options: Optional[api_pb2.FunctionOptions],
         args,
         kwargs,
@@ -107,17 +168,15 @@ class _Obj:
         if class_service_function:
             # >= v0.63 classes
             # first create the singular object function used by all methods on this parameterization
-            self._instance_service_function = class_service_function._bind_parameters(
-                self, from_other_workspace, options, args, kwargs
-            )
+            self._instance_service_function = class_service_function._bind_parameters(self, options, args, kwargs)
             for method_name, class_bound_method in classbound_methods.items():
-                method = self._instance_service_function._bind_instance_method(class_bound_method)
+                method = _bind_instance_method(self._instance_service_function, class_bound_method)
                 self._method_functions[method_name] = method
         else:
             # looked up <v0.63 classes - bind each individual method to the new parameters
             self._instance_service_function = None
             for method_name, class_bound_method in classbound_methods.items():
-                method = class_bound_method._bind_parameters(self, from_other_workspace, options, args, kwargs)
+                method = class_bound_method._bind_parameters(self, options, args, kwargs)
                 self._method_functions[method_name] = method
 
         # Used for construction local object lazily
@@ -247,7 +306,6 @@ class _Cls(_Object, type_prefix="cs"):
     _method_functions: Optional[dict[str, _Function]] = None  # Placeholder _Functions for each method
     _options: Optional[api_pb2.FunctionOptions]
     _callables: dict[str, Callable[..., Any]]
-    _from_other_workspace: Optional[bool]  # Functions require FunctionBindParams before invocation.
     _app: Optional["modal.app._App"] = None  # not set for lookups
 
     def _initialize_from_empty(self):
@@ -255,7 +313,6 @@ class _Cls(_Object, type_prefix="cs"):
         self._class_service_function = None
         self._options = None
         self._callables = {}
-        self._from_other_workspace = None
 
     def _initialize_from_other(self, other: "_Cls"):
         self._user_cls = other._user_cls
@@ -263,7 +320,6 @@ class _Cls(_Object, type_prefix="cs"):
         self._method_functions = other._method_functions
         self._options = other._options
         self._callables = other._callables
-        self._from_other_workspace = other._from_other_workspace
 
     def _get_partial_functions(self) -> dict[str, _PartialFunction]:
         if not self._user_cls:
@@ -277,7 +333,7 @@ class _Cls(_Object, type_prefix="cs"):
             and self._class_service_function._method_handle_metadata
             and len(self._class_service_function._method_handle_metadata)
         ):
-            # The class only has a class service service function and no method placeholders (v0.67+)
+            # The class only has a class service function and no method placeholders (v0.67+)
             if self._method_functions:
                 # We're here when the Cls is loaded locally (e.g. _Cls.from_local) so the _method_functions mapping is
                 # populated with (un-hydrated) _Function objects
@@ -298,7 +354,7 @@ class _Cls(_Object, type_prefix="cs"):
                     self._method_functions[method_name] = _Function._new_hydrated(
                         self._class_service_function.object_id, self._client, method_handle_metadata
                     )
-        elif self._class_service_function:
+        elif self._class_service_function and self._class_service_function.object_id:
             # A class with a class service function and method placeholder functions
             self._method_functions = {}
             for method in metadata.methods:
@@ -382,7 +438,6 @@ class _Cls(_Object, type_prefix="cs"):
         cls._class_service_function = class_service_function
         cls._method_functions = method_functions
         cls._callables = callables
-        cls._from_other_workspace = False
         return cls
 
     def _uses_common_service_function(self):
@@ -449,7 +504,6 @@ class _Cls(_Object, type_prefix="cs"):
 
         rep = f"Ref({app_name})"
         cls = cls._from_loader(_load_remote, rep, is_another_app=True)
-        cls._from_other_workspace = bool(workspace is not None)
         return cls
 
     def with_options(
@@ -543,7 +597,6 @@ class _Cls(_Object, type_prefix="cs"):
             self._user_cls,
             self._class_service_function,
             self._method_functions,
-            self._from_other_workspace,
             self._options,
             args,
             kwargs,

modal/cls.pyi

@@ -19,6 +19,9 @@ T = typing.TypeVar("T")
 
 def _use_annotation_parameters(user_cls) -> bool: ...
 def _get_class_constructor_signature(user_cls: type) -> inspect.Signature: ...
+def _bind_instance_method(
+    service_function: modal.functions._Function, class_bound_method: modal.functions._Function
+): ...
 
 class _Obj:
     _functions: dict[str, modal.functions._Function]
@@ -30,10 +33,9 @@ class _Obj:
     def _uses_common_service_function(self): ...
     def __init__(
         self,
-        user_cls: type,
+        user_cls: typing.Optional[type],
         class_service_function: typing.Optional[modal.functions._Function],
         classbound_methods: dict[str, modal.functions._Function],
-        from_other_workspace: bool,
         options: typing.Optional[modal_proto.api_pb2.FunctionOptions],
         args,
         kwargs,
@@ -58,10 +60,9 @@ class Obj:
 
     def __init__(
         self,
-        user_cls: type,
+        user_cls: typing.Optional[type],
         class_service_function: typing.Optional[modal.functions.Function],
         classbound_methods: dict[str, modal.functions.Function],
-        from_other_workspace: bool,
         options: typing.Optional[modal_proto.api_pb2.FunctionOptions],
         args,
         kwargs,
@@ -90,7 +91,6 @@ class _Cls(modal.object._Object):
     _method_functions: typing.Optional[dict[str, modal.functions._Function]]
     _options: typing.Optional[modal_proto.api_pb2.FunctionOptions]
     _callables: dict[str, typing.Callable[..., typing.Any]]
-    _from_other_workspace: typing.Optional[bool]
     _app: typing.Optional[modal.app._App]
 
     def _initialize_from_empty(self): ...
@@ -142,7 +142,6 @@ class Cls(modal.object.Object):
     _method_functions: typing.Optional[dict[str, modal.functions.Function]]
     _options: typing.Optional[modal_proto.api_pb2.FunctionOptions]
     _callables: dict[str, typing.Callable[..., typing.Any]]
-    _from_other_workspace: typing.Optional[bool]
     _app: typing.Optional[modal.app.App]
 
     def __init__(self, *args, **kwargs): ...

modal/functions.py

@@ -347,7 +347,7 @@ class _FunctionSpec:
     volumes: dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]]
     gpus: Union[GPU_T, list[GPU_T]]  # TODO(irfansharif): Somehow assert that it's the first kind, in sandboxes
     cloud: Optional[str]
-    cpu: Optional[float]
+    cpu: Optional[Union[float, tuple[float, float]]]
     memory: Optional[Union[int, tuple[int, int]]]
     ephemeral_disk: Optional[int]
     scheduler_placement: Optional[SchedulerPlacement]
@@ -424,68 +424,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         fun._is_method = True
         return fun
 
-    def _bind_instance_method(self, class_bound_method: "_Function"):
-        """mdmd:hidden
-
-        Binds an "instance service function" to a specific method.
-        This "dummy" _Function gets no unique object_id and isn't backend-backed at the moment, since all
-        it does it forward invocations to the underlying instance_service_function with the specified method,
-        and we don't support web_config for parameterized methods at the moment.
-        """
-        # TODO(elias): refactor to not use `_from_loader()` as a crutch for lazy-loading the
-        #   underlying instance_service_function. It's currently used in order to take advantage
-        #   of resolver logic and get "chained" resolution of lazy loads, even though this thin
-        #   object itself doesn't need any "loading"
-        instance_service_function = self
-        assert instance_service_function._obj
-        method_name = class_bound_method._use_method_name
-        full_function_name = f"{class_bound_method._function_name}[parameterized]"
-
-        def hydrate_from_instance_service_function(method_placeholder_fun):
-            method_placeholder_fun._hydrate_from_other(instance_service_function)
-            method_placeholder_fun._obj = instance_service_function._obj
-            method_placeholder_fun._web_url = (
-                class_bound_method._web_url
-            )  # TODO: this shouldn't be set when actual parameters are used
-            method_placeholder_fun._function_name = full_function_name
-            method_placeholder_fun._is_generator = class_bound_method._is_generator
-            method_placeholder_fun._cluster_size = class_bound_method._cluster_size
-            method_placeholder_fun._use_method_name = method_name
-            method_placeholder_fun._is_method = True
-
-        async def _load(fun: "_Function", resolver: Resolver, existing_object_id: Optional[str]):
-            # there is currently no actual loading logic executed to create each method on
-            # the *parameterized* instance of a class - it uses the parameter-bound service-function
-            # for the instance. This load method just makes sure to set all attributes after the
-            # `instance_service_function` has been loaded (it's in the `_deps`)
-            hydrate_from_instance_service_function(fun)
-
-        def _deps():
-            if instance_service_function.is_hydrated:
-                # without this check, the common instance_service_function will be reloaded by all methods
-                # TODO(elias): Investigate if we can fix this multi-loader in the resolver - feels like a bug?
-                return []
-            return [instance_service_function]
-
-        rep = f"Method({full_function_name})"
-
-        fun = _Function._from_loader(
-            _load,
-            rep,
-            deps=_deps,
-            hydrate_lazily=True,
-        )
-        if instance_service_function.is_hydrated:
-            # Eager hydration (skip load) if the instance service function is already loaded
-            hydrate_from_instance_service_function(fun)
-
-        fun._info = class_bound_method._info
-        fun._obj = instance_service_function._obj
-        fun._is_method = True
-        fun._app = class_bound_method._app
-        fun._spec = class_bound_method._spec
-        return fun
-
     @staticmethod
     def from_args(
         info: FunctionInfo,
@@ -510,7 +448,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         batch_max_size: Optional[int] = None,
         batch_wait_ms: Optional[int] = None,
         container_idle_timeout: Optional[int] = None,
-        cpu: Optional[float] = None,
+        cpu: Optional[Union[float, tuple[float, float]]] = None,
         keep_warm: Optional[int] = None,  # keep_warm=True is equivalent to keep_warm=1
         cloud: Optional[str] = None,
         scheduler_placement: Optional[SchedulerPlacement] = None,
@@ -982,7 +920,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     def _bind_parameters(
         self,
         obj: "modal.cls._Obj",
-        from_other_workspace: bool,
         options: Optional[api_pb2.FunctionOptions],
         args: Sized,
         kwargs: dict[str, Any],
@@ -993,7 +930,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         """
 
         # In some cases, reuse the base function, i.e. not create new clones of each method or the "service function"
-        can_use_parent = len(args) + len(kwargs) == 0 and not from_other_workspace and options is None
+        can_use_parent = len(args) + len(kwargs) == 0 and options is None
         parent = self
 
         async def _load(param_bound_func: _Function, resolver: Resolver, existing_object_id: Optional[str]):

modal/functions.pyi

@@ -96,7 +96,7 @@ class _FunctionSpec:
     ]
     gpus: typing.Union[None, bool, str, modal.gpu._GPUConfig, list[typing.Union[None, bool, str, modal.gpu._GPUConfig]]]
     cloud: typing.Optional[str]
-    cpu: typing.Optional[float]
+    cpu: typing.Union[float, tuple[float, float], None]
     memory: typing.Union[int, tuple[int, int], None]
     ephemeral_disk: typing.Optional[int]
     scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement]
@@ -117,7 +117,7 @@ class _FunctionSpec:
             None, bool, str, modal.gpu._GPUConfig, list[typing.Union[None, bool, str, modal.gpu._GPUConfig]]
         ],
         cloud: typing.Optional[str],
-        cpu: typing.Optional[float],
+        cpu: typing.Union[float, tuple[float, float], None],
         memory: typing.Union[int, tuple[int, int], None],
         ephemeral_disk: typing.Optional[int],
         scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement],
@@ -150,7 +150,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     _method_handle_metadata: typing.Optional[dict[str, modal_proto.api_pb2.FunctionHandleMetadata]]
 
     def _bind_method(self, user_cls, method_name: str, partial_function: modal.partial_function._PartialFunction): ...
-    def _bind_instance_method(self, class_bound_method: _Function): ...
     @staticmethod
     def from_args(
         info: modal._utils.function_utils.FunctionInfo,
@@ -181,7 +180,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
         batch_max_size: typing.Optional[int] = None,
         batch_wait_ms: typing.Optional[int] = None,
         container_idle_timeout: typing.Optional[int] = None,
-        cpu: typing.Optional[float] = None,
+        cpu: typing.Union[float, tuple[float, float], None] = None,
         keep_warm: typing.Optional[int] = None,
         cloud: typing.Optional[str] = None,
         scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement] = None,
@@ -200,7 +199,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     def _bind_parameters(
         self,
         obj: modal.cls._Obj,
-        from_other_workspace: bool,
         options: typing.Optional[modal_proto.api_pb2.FunctionOptions],
         args: collections.abc.Sized,
         kwargs: dict[str, typing.Any],
@@ -320,7 +318,6 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
 
     def __init__(self, *args, **kwargs): ...
     def _bind_method(self, user_cls, method_name: str, partial_function: modal.partial_function.PartialFunction): ...
-    def _bind_instance_method(self, class_bound_method: Function): ...
     @staticmethod
     def from_args(
         info: modal._utils.function_utils.FunctionInfo,
@@ -351,7 +348,7 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
         batch_max_size: typing.Optional[int] = None,
         batch_wait_ms: typing.Optional[int] = None,
         container_idle_timeout: typing.Optional[int] = None,
-        cpu: typing.Optional[float] = None,
+        cpu: typing.Union[float, tuple[float, float], None] = None,
         keep_warm: typing.Optional[int] = None,
         cloud: typing.Optional[str] = None,
         scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement] = None,
@@ -370,7 +367,6 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
     def _bind_parameters(
         self,
         obj: modal.cls.Obj,
-        from_other_workspace: bool,
         options: typing.Optional[modal_proto.api_pb2.FunctionOptions],
         args: collections.abc.Sized,
         kwargs: dict[str, typing.Any],

modal/image.py

@@ -677,13 +677,13 @@ class _Image(_Object, type_prefix="im"):
             context_mount=mount,
         )
 
-    def _add_local_python_packages(self, *packages: str, copy: bool = False) -> "_Image":
-        """Adds Python package files to containers
+    def add_local_python_source(self, *modules: str, copy: bool = False) -> "_Image":
+        """Adds locally available Python packages/modules to containers
 
-        Adds all files from the specified Python packages to containers running the Image.
+        Adds all files from the specified Python package or module to containers running the Image.
 
         Packages are added to the `/root` directory of containers, which is on the `PYTHONPATH`
-        of any executed Modal Functions.
+        of any executed Modal Functions, enabling import of the module by that name.
 
         By default (`copy=False`), the files are added to containers on startup and are not built into the actual Image,
         which speeds up deployment.
@@ -693,9 +693,14 @@ class _Image(_Object, type_prefix="im"):
         required if you want to run additional build steps after this one.
 
         **Note:** This excludes all dot-prefixed subdirectories or files and all `.pyc`/`__pycache__` files.
-        To add full directories with finer control, use `.add_local_dir()` instead.
+        To add full directories with finer control, use `.add_local_dir()` instead and specify `/root` as
+        the destination directory.
         """
-        mount = _Mount.from_local_python_packages(*packages)
+
+        def only_py_files(filename):
+            return filename.endswith(".py")
+
+        mount = _Mount.from_local_python_packages(*modules, condition=only_py_files)
         return self._add_mount_layer_or_copy(mount, copy=copy)
 
     def copy_local_dir(self, local_path: Union[str, Path], remote_path: Union[str, Path] = ".") -> "_Image":
@@ -1005,8 +1010,8 @@ class _Image(_Object, type_prefix="im"):
         If not provided as argument the path to the lockfile is inferred. However, the
         file has to exist, unless `ignore_lockfile` is set to `True`.
 
-        Note that the root project of the poetry project is not installed,
-        only the dependencies. For including local packages see `modal.Mount.from_local_python_packages`
+        Note that the root project of the poetry project is not installed, only the dependencies.
+        For including local python source files see `add_local_python_source`
         """
 
         def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:

modal/image.pyi

@@ -115,7 +115,7 @@ class _Image(modal.object._Object):
     def copy_local_file(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "./"
     ) -> _Image: ...
-    def _add_local_python_packages(self, *module_names: str, copy: bool = False) -> _Image: ...
+    def add_local_python_source(self, *module_names: str, copy: bool = False) -> _Image: ...
     def copy_local_dir(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "."
     ) -> _Image: ...
@@ -372,7 +372,7 @@ class Image(modal.object.Object):
     def copy_local_file(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "./"
     ) -> Image: ...
-    def _add_local_python_packages(self, *module_names: str, copy: bool = False) -> Image: ...
+    def add_local_python_source(self, *module_names: str, copy: bool = False) -> Image: ...
     def copy_local_dir(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "."
     ) -> Image: ...

modal/io_streams.py

@@ -184,7 +184,7 @@ class _StreamReader(Generic[T]):
 
                 async for message in iterator:
                     if self._stream_type == StreamType.STDOUT and message:
-                        print(message, end="")
+                        print(message.decode("utf-8"), end="")
                     elif self._stream_type == StreamType.PIPE:
                         self._container_process_buffer.append(message)
                     if message is None:

modal/network_file_system.py

@@ -221,6 +221,12 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
         resp = await retry_transient_errors(client.stub.SharedVolumeGetOrCreate, request)
         return resp.shared_volume_id
 
+    @staticmethod
+    async def delete(label: str, client: Optional[_Client] = None, environment_name: Optional[str] = None):
+        obj = await _NetworkFileSystem.lookup(label, client=client, environment_name=environment_name)
+        req = api_pb2.SharedVolumeDeleteRequest(shared_volume_id=obj.object_id)
+        await retry_transient_errors(obj._client.stub.SharedVolumeDelete, req)
+
     @live_method
     async def write_file(self, remote_path: str, fp: BinaryIO, progress_cb: Optional[Callable[..., Any]] = None) -> int:
         """Write from a file object to a path on the network file system, atomically.