modal 0.72.5__py3-none-any.whl → 0.72.48__py3-none-any.whl

modal/dict.py

@@ -7,6 +7,7 @@ from synchronicity.async_wrap import asynccontextmanager
 
 from modal_proto import api_pb2
 
+from ._object import EPHEMERAL_OBJECT_HEARTBEAT_SLEEP, _get_environment_name, _Object, live_method, live_method_gen
 from ._resolver import Resolver
 from ._serialization import deserialize, serialize
 from ._utils.async_utils import TaskContext, synchronize_api
@@ -16,7 +17,6 @@ from ._utils.name_utils import check_object_name
 from .client import _Client
 from .config import logger
 from .exception import RequestSizeError
-from .object import EPHEMERAL_OBJECT_HEARTBEAT_SLEEP, _get_environment_name, _Object, live_method, live_method_gen
 
 
 def _serialize_dict(data):

modal/dict.pyi

@@ -1,4 +1,5 @@
 import collections.abc
+import modal._object
 import modal.client
 import modal.object
 import synchronicity.combined_types
@@ -7,7 +8,7 @@ import typing_extensions
 
 def _serialize_dict(data): ...
 
-class _Dict(modal.object._Object):
+class _Dict(modal._object._Object):
     def __init__(self, data={}): ...
     @classmethod
     def ephemeral(
@@ -56,6 +57,8 @@ class _Dict(modal.object._Object):
     def values(self) -> collections.abc.AsyncIterator[typing.Any]: ...
     def items(self) -> collections.abc.AsyncIterator[tuple[typing.Any, typing.Any]]: ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class Dict(modal.object.Object):
     def __init__(self, data={}): ...
     @classmethod
@@ -115,86 +118,86 @@ class Dict(modal.object.Object):
 
     delete: __delete_spec
 
-    class __clear_spec(typing_extensions.Protocol):
+    class __clear_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
 
-    clear: __clear_spec
+    clear: __clear_spec[typing_extensions.Self]
 
-    class __get_spec(typing_extensions.Protocol):
+    class __get_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any, default: typing.Optional[typing.Any] = None) -> typing.Any: ...
         async def aio(self, key: typing.Any, default: typing.Optional[typing.Any] = None) -> typing.Any: ...
 
-    get: __get_spec
+    get: __get_spec[typing_extensions.Self]
 
-    class __contains_spec(typing_extensions.Protocol):
+    class __contains_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> bool: ...
         async def aio(self, key: typing.Any) -> bool: ...
 
-    contains: __contains_spec
+    contains: __contains_spec[typing_extensions.Self]
 
-    class __len_spec(typing_extensions.Protocol):
+    class __len_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> int: ...
         async def aio(self) -> int: ...
 
-    len: __len_spec
+    len: __len_spec[typing_extensions.Self]
 
-    class ____getitem___spec(typing_extensions.Protocol):
+    class ____getitem___spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> typing.Any: ...
         async def aio(self, key: typing.Any) -> typing.Any: ...
 
-    __getitem__: ____getitem___spec
+    __getitem__: ____getitem___spec[typing_extensions.Self]
 
-    class __update_spec(typing_extensions.Protocol):
+    class __update_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, **kwargs) -> None: ...
         async def aio(self, **kwargs) -> None: ...
 
-    update: __update_spec
+    update: __update_spec[typing_extensions.Self]
 
-    class __put_spec(typing_extensions.Protocol):
+    class __put_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any, value: typing.Any) -> None: ...
         async def aio(self, key: typing.Any, value: typing.Any) -> None: ...
 
-    put: __put_spec
+    put: __put_spec[typing_extensions.Self]
 
-    class ____setitem___spec(typing_extensions.Protocol):
+    class ____setitem___spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any, value: typing.Any) -> None: ...
         async def aio(self, key: typing.Any, value: typing.Any) -> None: ...
 
-    __setitem__: ____setitem___spec
+    __setitem__: ____setitem___spec[typing_extensions.Self]
 
-    class __pop_spec(typing_extensions.Protocol):
+    class __pop_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> typing.Any: ...
         async def aio(self, key: typing.Any) -> typing.Any: ...
 
-    pop: __pop_spec
+    pop: __pop_spec[typing_extensions.Self]
 
-    class ____delitem___spec(typing_extensions.Protocol):
+    class ____delitem___spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> typing.Any: ...
         async def aio(self, key: typing.Any) -> typing.Any: ...
 
-    __delitem__: ____delitem___spec
+    __delitem__: ____delitem___spec[typing_extensions.Self]
 
-    class ____contains___spec(typing_extensions.Protocol):
+    class ____contains___spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> bool: ...
         async def aio(self, key: typing.Any) -> bool: ...
 
-    __contains__: ____contains___spec
+    __contains__: ____contains___spec[typing_extensions.Self]
 
-    class __keys_spec(typing_extensions.Protocol):
+    class __keys_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> typing.Iterator[typing.Any]: ...
         def aio(self) -> collections.abc.AsyncIterator[typing.Any]: ...
 
-    keys: __keys_spec
+    keys: __keys_spec[typing_extensions.Self]
 
-    class __values_spec(typing_extensions.Protocol):
+    class __values_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> typing.Iterator[typing.Any]: ...
         def aio(self) -> collections.abc.AsyncIterator[typing.Any]: ...
 
-    values: __values_spec
+    values: __values_spec[typing_extensions.Self]
 
-    class __items_spec(typing_extensions.Protocol):
+    class __items_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> typing.Iterator[tuple[typing.Any, typing.Any]]: ...
         def aio(self) -> collections.abc.AsyncIterator[tuple[typing.Any, typing.Any]]: ...
 
-    items: __items_spec
+    items: __items_spec[typing_extensions.Self]

modal/environments.py

@@ -8,6 +8,7 @@ from google.protobuf.wrappers_pb2 import StringValue
 
 from modal_proto import api_pb2
 
+from ._object import _Object
 from ._resolver import Resolver
 from ._utils.async_utils import synchronize_api, synchronizer
 from ._utils.deprecation import renamed_parameter
@@ -15,7 +16,6 @@ from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from .client import _Client
 from .config import config, logger
-from .object import _Object
 
 
 @dataclass(frozen=True)

modal/environments.pyi

@@ -1,4 +1,5 @@
 import google.protobuf.message
+import modal._object
 import modal.client
 import modal.object
 import modal_proto.api_pb2
@@ -16,7 +17,7 @@ class EnvironmentSettings:
     def __delattr__(self, name): ...
     def __hash__(self): ...
 
-class _Environment(modal.object._Object):
+class _Environment(modal._object._Object):
     _settings: EnvironmentSettings
 
     def __init__(self): ...

modal/experimental.py

@@ -1,16 +1,16 @@
 # Copyright Modal Labs 2022
-from typing import (
-    Any,
-    Callable,
-)
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
 
-import modal._clustered_functions
-from modal.functions import _Function
+from modal_proto import api_pb2
 
+from ._clustered_functions import ClusterInfo, get_cluster_info as _get_cluster_info
+from ._object import _get_environment_name
 from ._runtime.container_io_manager import _ContainerIOManager
-from .exception import (
-    InvalidError,
-)
+from ._utils.async_utils import synchronizer
+from .client import _Client
+from .exception import InvalidError
+from .functions import _Function
 from .partial_function import _PartialFunction, _PartialFunctionFlags
 
 
@@ -65,5 +65,41 @@ def clustered(size: int, broadcast: bool = True):
     return wrapper
 
 
-def get_cluster_info() -> modal._clustered_functions.ClusterInfo:
-    return modal._clustered_functions.get_cluster_info()
+def get_cluster_info() -> ClusterInfo:
+    return _get_cluster_info()
+
+
+@dataclass
+class AppInfo:
+    app_id: str
+    name: str
+    containers: int
+
+
+@synchronizer.create_blocking
+async def list_deployed_apps(environment_name: str = "", client: Optional[_Client] = None) -> list[AppInfo]:
+    """List deployed Apps along with the number of containers currently running."""
+    # This function exists to provide backwards compatibility for some users who had been
+    # calling into the private function that previously backed the `modal app list` CLI command.
+    # We plan to add more Python API for exposing this sort of information, but we haven't
+    # settled on a design we're happy with yet. In the meantime, this function will continue
+    # to support existing codebases. It's likely that the final API will be different
+    # (e.g. more oriented around the App object). This function should be gracefully deprecated
+    # one the new API is released.
+    client = client or await _Client.from_env()
+
+    resp: api_pb2.AppListResponse = await client.stub.AppList(
+        api_pb2.AppListRequest(environment_name=_get_environment_name(environment_name))
+    )
+
+    app_infos = []
+    for app_stats in resp.apps:
+        if app_stats.state == api_pb2.APP_STATE_DEPLOYED:
+            app_infos.append(
+                AppInfo(
+                    app_id=app_stats.app_id,
+                    name=app_stats.description,
+                    containers=app_stats.n_running_tasks,
+                )
+            )
+    return app_infos

modal/experimental.pyi

@@ -0,0 +1,29 @@
+import modal._clustered_functions
+import modal.client
+import typing
+import typing_extensions
+
+def stop_fetching_inputs(): ...
+def get_local_input_concurrency(): ...
+def set_local_input_concurrency(concurrency: int): ...
+def clustered(size: int, broadcast: bool = True): ...
+def get_cluster_info() -> modal._clustered_functions.ClusterInfo: ...
+
+class AppInfo:
+    app_id: str
+    name: str
+    containers: int
+
+    def __init__(self, app_id: str, name: str, containers: int) -> None: ...
+    def __repr__(self): ...
+    def __eq__(self, other): ...
+
+class __list_deployed_apps_spec(typing_extensions.Protocol):
+    def __call__(
+        self, environment_name: str = "", client: typing.Optional[modal.client.Client] = None
+    ) -> list[AppInfo]: ...
+    async def aio(
+        self, environment_name: str = "", client: typing.Optional[modal.client.Client] = None
+    ) -> list[AppInfo]: ...
+
+list_deployed_apps: __list_deployed_apps_spec

modal/file_io.pyi

@@ -100,6 +100,8 @@ class __replace_bytes_spec(typing_extensions.Protocol):
 
 replace_bytes: __replace_bytes_spec
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 T_INNER = typing.TypeVar("T_INNER", covariant=True)
 
 class FileIO(typing.Generic[T]):
@@ -112,37 +114,37 @@ class FileIO(typing.Generic[T]):
     def _validate_mode(self, mode: str) -> None: ...
     def _handle_error(self, error: modal_proto.api_pb2.SystemErrorMessage) -> None: ...
 
-    class ___consume_output_spec(typing_extensions.Protocol):
+    class ___consume_output_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, exec_id: str) -> typing.Iterator[typing.Optional[bytes]]: ...
         def aio(self, exec_id: str) -> typing.AsyncIterator[typing.Optional[bytes]]: ...
 
-    _consume_output: ___consume_output_spec
+    _consume_output: ___consume_output_spec[typing_extensions.Self]
 
-    class ___consume_watch_output_spec(typing_extensions.Protocol):
+    class ___consume_watch_output_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, exec_id: str) -> None: ...
         async def aio(self, exec_id: str) -> None: ...
 
-    _consume_watch_output: ___consume_watch_output_spec
+    _consume_watch_output: ___consume_watch_output_spec[typing_extensions.Self]
 
-    class ___parse_watch_output_spec(typing_extensions.Protocol):
+    class ___parse_watch_output_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, event: bytes) -> typing.Optional[FileWatchEvent]: ...
         async def aio(self, event: bytes) -> typing.Optional[FileWatchEvent]: ...
 
-    _parse_watch_output: ___parse_watch_output_spec
+    _parse_watch_output: ___parse_watch_output_spec[typing_extensions.Self]
 
-    class ___wait_spec(typing_extensions.Protocol):
+    class ___wait_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, exec_id: str) -> bytes: ...
         async def aio(self, exec_id: str) -> bytes: ...
 
-    _wait: ___wait_spec
+    _wait: ___wait_spec[typing_extensions.Self]
 
     def _validate_type(self, data: typing.Union[bytes, str]) -> None: ...
 
-    class ___open_file_spec(typing_extensions.Protocol):
+    class ___open_file_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str, mode: str) -> None: ...
         async def aio(self, path: str, mode: str) -> None: ...
 
-    _open_file: ___open_file_spec
+    _open_file: ___open_file_spec[typing_extensions.Self]
 
     @classmethod
     def create(
@@ -153,49 +155,49 @@ class FileIO(typing.Generic[T]):
         task_id: str,
     ) -> FileIO: ...
 
-    class ___make_read_request_spec(typing_extensions.Protocol):
+    class ___make_read_request_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, n: typing.Optional[int]) -> bytes: ...
         async def aio(self, n: typing.Optional[int]) -> bytes: ...
 
-    _make_read_request: ___make_read_request_spec
+    _make_read_request: ___make_read_request_spec[typing_extensions.Self]
 
-    class __read_spec(typing_extensions.Protocol[T_INNER]):
+    class __read_spec(typing_extensions.Protocol[T_INNER, SUPERSELF]):
         def __call__(self, n: typing.Optional[int] = None) -> T_INNER: ...
         async def aio(self, n: typing.Optional[int] = None) -> T_INNER: ...
 
-    read: __read_spec[T]
+    read: __read_spec[T, typing_extensions.Self]
 
-    class __readline_spec(typing_extensions.Protocol[T_INNER]):
+    class __readline_spec(typing_extensions.Protocol[T_INNER, SUPERSELF]):
         def __call__(self) -> T_INNER: ...
         async def aio(self) -> T_INNER: ...
 
-    readline: __readline_spec[T]
+    readline: __readline_spec[T, typing_extensions.Self]
 
-    class __readlines_spec(typing_extensions.Protocol[T_INNER]):
+    class __readlines_spec(typing_extensions.Protocol[T_INNER, SUPERSELF]):
         def __call__(self) -> typing.Sequence[T_INNER]: ...
         async def aio(self) -> typing.Sequence[T_INNER]: ...
 
-    readlines: __readlines_spec[T]
+    readlines: __readlines_spec[T, typing_extensions.Self]
 
-    class __write_spec(typing_extensions.Protocol):
+    class __write_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, data: typing.Union[bytes, str]) -> None: ...
         async def aio(self, data: typing.Union[bytes, str]) -> None: ...
 
-    write: __write_spec
+    write: __write_spec[typing_extensions.Self]
 
-    class __flush_spec(typing_extensions.Protocol):
+    class __flush_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
 
-    flush: __flush_spec
+    flush: __flush_spec[typing_extensions.Self]
 
     def _get_whence(self, whence: int): ...
 
-    class __seek_spec(typing_extensions.Protocol):
+    class __seek_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, offset: int, whence: int = 0) -> None: ...
         async def aio(self, offset: int, whence: int = 0) -> None: ...
 
-    seek: __seek_spec
+    seek: __seek_spec[typing_extensions.Self]
 
     @classmethod
     def ls(cls, path: str, client: modal.client.Client, task_id: str) -> list[str]: ...
@@ -214,17 +216,17 @@ class FileIO(typing.Generic[T]):
         timeout: typing.Optional[int] = None,
     ) -> typing.Iterator[FileWatchEvent]: ...
 
-    class ___close_spec(typing_extensions.Protocol):
+    class ___close_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
 
-    _close: ___close_spec
+    _close: ___close_spec[typing_extensions.Self]
 
-    class __close_spec(typing_extensions.Protocol):
+    class __close_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
 
-    close: __close_spec
+    close: __close_spec[typing_extensions.Self]
 
     def _check_writable(self) -> None: ...
     def _check_readable(self) -> None: ...

modal/file_pattern_matcher.py

@@ -112,7 +112,7 @@ class FilePatternMatcher(_AbstractPatternMatcher):
         self._set_patterns(pattern)
 
     @classmethod
-    def from_file(cls, file_path: Path) -> "FilePatternMatcher":
+    def from_file(cls, file_path: Union[str, Path]) -> "FilePatternMatcher":
         """Initialize a new FilePatternMatcher instance from a file.
 
         The patterns in the file will be read lazily when the matcher is first used.
@@ -122,17 +122,16 @@ class FilePatternMatcher(_AbstractPatternMatcher):
 
         **Usage:**
         ```python
-        from pathlib import Path
         from modal import FilePatternMatcher
 
-        matcher = FilePatternMatcher.from_file(Path("/path/to/ignorefile"))
+        matcher = FilePatternMatcher.from_file("/path/to/ignorefile")
         ```
 
         """
         uninitialized = cls.__new__(cls)
 
         def _delayed_init():
-            uninitialized._set_patterns(file_path.read_text("utf8").splitlines())
+            uninitialized._set_patterns(Path(file_path).read_text("utf8").splitlines())
             uninitialized._delayed_init = None
 
         uninitialized._delayed_init = _delayed_init

modal/functions.py

@@ -26,6 +26,7 @@ from modal_proto import api_pb2
 from modal_proto.modal_api_grpc import ModalClientModal
 
 from ._location import parse_cloud_provider
+from ._object import _get_environment_name, _Object, live_method, live_method_gen
 from ._pty import get_pty_info
 from ._resolver import Resolver
 from ._resources import convert_fn_config_to_resources_config
@@ -71,7 +72,6 @@ from .gpu import GPU_T, parse_gpu_config
 from .image import _Image
 from .mount import _get_client_mount, _Mount, get_auto_mounts
 from .network_file_system import _NetworkFileSystem, network_file_system_mount_protos
-from .object import _get_environment_name, _Object, live_method, live_method_gen
 from .output import _get_output_manager
 from .parallel_map import (
     _for_each_async,
@@ -383,12 +383,15 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     _serve_mounts: frozenset[_Mount]  # set at load time, only by loader
     _app: Optional["modal.app._App"] = None
     _obj: Optional["modal.cls._Obj"] = None  # only set for InstanceServiceFunctions and bound instance methods
-    _web_url: Optional[str]
+
+    _webhook_config: Optional[api_pb2.WebhookConfig] = None  # this is set in definition scope, only locally
+    _web_url: Optional[str]  # this is set on hydration
+
     _function_name: Optional[str]
     _is_method: bool
     _spec: Optional[_FunctionSpec] = None
     _tag: str
-    _raw_f: Callable[..., Any]
+    _raw_f: Optional[Callable[..., Any]]  # this is set to None for a "class service [function]"
     _build_args: dict
 
     _is_generator: Optional[bool] = None
@@ -474,7 +477,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         _experimental_buffer_containers: Optional[int] = None,
         _experimental_proxy_ip: Optional[str] = None,
         _experimental_custom_scaling_factor: Optional[float] = None,
-    ) -> None:
+    ) -> "_Function":
         """mdmd:hidden"""
         # Needed to avoid circular imports
         from .partial_function import _find_partial_methods_for_user_cls, _PartialFunctionFlags
@@ -573,7 +576,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 )
                 image = _Image._from_args(
                     base_images={"base": image},
-                    build_function=snapshot_function,
+                    build_function=snapshot_function,  # type: ignore   # TODO: separate functions.py and _functions.py
                     force_build=image.force_build or pf.force_build,
                 )
 
@@ -785,7 +788,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     task_idle_timeout_secs=container_idle_timeout or 0,
                     concurrency_limit=concurrency_limit or 0,
                     pty_info=pty_info,
-                    cloud_provider=cloud_provider,
+                    cloud_provider=cloud_provider,  # Deprecated at some point
+                    cloud_provider_str=cloud.upper() if cloud else "",  # Supersedes cloud_provider
                     warm_pool_size=keep_warm or 0,
                     runtime=config.get("function_runtime"),
                     runtime_debug=config.get("function_runtime_debug"),
@@ -911,6 +915,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         obj._cluster_size = cluster_size
         obj._is_method = False
         obj._spec = function_spec  # needed for modal shell
+        obj._webhook_config = webhook_config  # only set locally
 
         # Used to check whether we should rebuild a modal.Image which uses `run_function`.
         gpus: list[GPU_T] = gpu if isinstance(gpu, list) else [gpu]
@@ -962,7 +967,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     f"The {identity} has not been hydrated with the metadata it needs to run on Modal{reason}."
                 )
 
-            assert parent._client.stub
+            assert parent._client and parent._client.stub
 
             if can_use_parent:
                 # We can end up here if parent wasn't hydrated when class was instantiated, but has been since.
@@ -983,9 +988,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             else:
                 serialized_params = serialize((args, kwargs))
             environment_name = _get_environment_name(None, resolver)
-            assert parent is not None
+            assert parent is not None and parent.is_hydrated
             req = api_pb2.FunctionBindParamsRequest(
-                function_id=parent._object_id,
+                function_id=parent.object_id,
                 serialized_params=serialized_params,
                 function_options=options,
                 environment_name=environment_name
@@ -1032,11 +1037,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             """
                 )
             )
-        assert self._client and self._client.stub
         request = api_pb2.FunctionUpdateSchedulingParamsRequest(
-            function_id=self._object_id, warm_pool_size_override=warm_pool_size
+            function_id=self.object_id, warm_pool_size_override=warm_pool_size
         )
-        await retry_transient_errors(self._client.stub.FunctionUpdateSchedulingParams, request)
+        await retry_transient_errors(self.client.stub.FunctionUpdateSchedulingParams, request)
 
     @classmethod
     @renamed_parameter((2024, 12, 18), "tag", "name")
@@ -1138,11 +1142,15 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         assert self._spec
         return self._spec
 
+    def _is_web_endpoint(self) -> bool:
+        # only defined in definition scope/locally, and not for class methods at the moment
+        return bool(self._webhook_config and self._webhook_config.type != api_pb2.WEBHOOK_TYPE_UNSPECIFIED)
+
     def get_build_def(self) -> str:
         """mdmd:hidden"""
         # Plaintext source and arg definition for the function, so it's part of the image
         # hash. We can't use the cloudpickle hash because it's not very stable.
-        assert hasattr(self, "_raw_f") and hasattr(self, "_build_args")
+        assert hasattr(self, "_raw_f") and hasattr(self, "_build_args") and self._raw_f is not None
         return f"{inspect.getsource(self._raw_f)}\n{repr(self._build_args)}"
 
     # Live handle methods
@@ -1207,12 +1215,13 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     async def is_generator(self) -> bool:
         """mdmd:hidden"""
         # hacky: kind of like @live_method, but not hydrating if we have the value already from local source
+        # TODO(michael) use a common / lightweight method for handling unhydrated metadata properties
         if self._is_generator is not None:
             # this is set if the function or class is local
             return self._is_generator
 
         # not set - this is a from_name lookup - hydrate
-        await self.resolve()
+        await self.hydrate()
         assert self._is_generator is not None  # should be set now
         return self._is_generator
 
@@ -1248,7 +1257,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             _map_invocation(
                 self,  # type: ignore
                 input_queue,
-                self._client,
+                self.client,
                 order_outputs,
                 return_exceptions,
                 count_update_callback,
@@ -1266,7 +1275,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             self,
             args,
             kwargs,
-            client=self._client,
+            client=self.client,
             function_call_invocation_type=function_call_invocation_type,
         )
 
@@ -1276,7 +1285,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self, args, kwargs, function_call_invocation_type: "api_pb2.FunctionCallInvocationType.ValueType"
     ) -> _Invocation:
         return await _Invocation.create(
-            self, args, kwargs, client=self._client, function_call_invocation_type=function_call_invocation_type
+            self, args, kwargs, client=self.client, function_call_invocation_type=function_call_invocation_type
         )
 
     @warn_if_generator_is_not_consumed()
@@ -1287,7 +1296,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             self,
             args,
             kwargs,
-            client=self._client,
+            client=self.client,
             function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC_LEGACY,
         )
         async for res in invocation.run_generator():
@@ -1303,7 +1312,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             self,
             args,
             kwargs,
-            client=self._client,
+            client=self.client,
             function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_ASYNC_LEGACY,
         )
 
@@ -1452,14 +1461,14 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
     def get_raw_f(self) -> Callable[..., Any]:
         """Return the inner Python object wrapped by this Modal Function."""
+        assert self._raw_f is not None
         return self._raw_f
 
     @live_method
     async def get_current_stats(self) -> FunctionStats:
         """Return a `FunctionStats` object describing the current function's queue and runner counts."""
-        assert self._client.stub
         resp = await retry_transient_errors(
-            self._client.stub.FunctionGetCurrentStats,
+            self.client.stub.FunctionGetCurrentStats,
             api_pb2.FunctionGetCurrentStatsRequest(function_id=self.object_id),
             total_timeout=10.0,
         )
@@ -1491,8 +1500,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
     _is_generator: bool = False
 
     def _invocation(self):
-        assert self._client.stub
-        return _Invocation(self._client.stub, self.object_id, self._client)
+        return _Invocation(self.client.stub, self.object_id, self.client)
 
     async def get(self, timeout: Optional[float] = None) -> ReturnType:
         """Get the result of the function call.