modal 1.5.5.dev14__tar.gz → 1.5.5.dev16__tar.gz

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.5.dev14
+Version: 1.5.5.dev16
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/_environments.py

@@ -478,7 +478,7 @@ class _EnvironmentBillingManager:
         elif end.tzinfo != timezone.utc:
             raise InvalidError("Timezone-aware 'end' parameter must be in UTC.")
 
-        if not self._environment.is_hydrated:
+        if not self._environment._is_hydrated:
             await self._environment.hydrate()
 
         request = api_pb2.WorkspaceBillingReportRequest(
@@ -549,7 +549,7 @@ class _EnvironmentBillingManager:
         if cycle > datetime.now(timezone.utc):
             raise InvalidError("Provided 'cycle' parameter cannot be in the future.")
 
-        if not self._environment.is_hydrated:
+        if not self._environment._is_hydrated:
             await self._environment.hydrate()
 
         request = api_pb2.EnvironmentBillingSummaryRequest(environment_id=self._environment.object_id)

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/_function_variants.py

@@ -157,7 +157,7 @@ class _FunctionOptions:
             + list(self.secrets)
             + [mount.secret for _, mount in self.cloud_bucket_mounts if mount.secret]
         )
-        return [dep for dep in all_deps if not dep.is_hydrated]
+        return [dep for dep in all_deps if not dep._is_hydrated]
 
     def to_proto(self) -> api_pb2.FunctionOptions:
         """Convert the dataclass to a FunctionOptions protobuf message."""
@@ -246,7 +246,7 @@ def _make_function_variant(
         load_context: "LoadContext",
         existing_object_id: str | None,
     ):
-        if not base_function.is_hydrated:
+        if not base_function._is_hydrated:
             await base_function.hydrate(load_context.client)
         assert base_function._client and base_function._client.stub
 

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/_functions.py

@@ -663,7 +663,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return _FunctionLogsManager(self)
 
     @staticmethod
-    def from_local(
+    def _from_local(
         info: FunctionInfo,
         app: "modal.app._App | None",  # App here should only be None in case of Image.run_function
         image: _Image,
@@ -937,7 +937,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             with FunctionCreationStatus(tag) as function_creation_status:
                 timeout_secs = timeout
 
-                if app and app.is_interactive and not is_builder_function:
+                if app and app._is_interactive_ and not is_builder_function:
                     pty_info = get_pty_info(shell=False)
                 else:
                     pty_info = None
@@ -1164,7 +1164,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         # the only way to infer a LoadContext for an `@app.function`, and the App doesn't
         # get its client until *after* the Function is created.
         load_context = app._root_load_context if app else LoadContext.empty()
-        obj = _Function._from_loader(_load, rep, preload=_preload, deps=_deps, load_context_overrides=load_context)
+        obj: _Function = _Function._from_loader(
+            _load, rep, preload=_preload, deps=_deps, load_context_overrides=load_context
+        )
 
         obj._raw_f = info.raw_f
         obj._info = info
@@ -1192,6 +1194,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
         return obj
 
+    from_local = _from_local
+    """mdmd:hidden"""
+
     async def _update_autoscaler(
         self,
         *,
@@ -1386,6 +1391,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     @property
     def tag(self) -> str:
         """mdmd:hidden"""
+        return self._tag_
+
+    @property
+    def _tag_(self) -> str:
         assert self._tag
         return self._tag
 
@@ -1406,12 +1415,20 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     @property
     def info(self) -> FunctionInfo:
         """mdmd:hidden"""
+        return self._info_
+
+    @property
+    def _info_(self) -> FunctionInfo:
         assert self._info
         return self._info
 
     @property
     def spec(self) -> _FunctionSpec:
         """mdmd:hidden"""
+        return self._spec_
+
+    @property
+    def _spec_(self) -> _FunctionSpec:
         assert self._spec
         return self._spec
 
@@ -1419,13 +1436,16 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         # 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:
+    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") and self._raw_f is not None
         return f"{inspect.getsource(self._raw_f)}\n{repr(self._build_args)}"
 
+    get_build_def = _get_build_def
+    """mdmd:hidden"""
+
     # Live handle methods
 
     def _initialize_from_empty(self):
@@ -1675,6 +1695,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     @property
     async def is_generator(self) -> bool:
         """mdmd:hidden"""
+        return await self._is_generator_
+
+    @property
+    async def _is_generator_(self) -> bool:
         # 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:
@@ -1910,7 +1934,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             # TODO: check if we end up here in a container for a serialized function?
             raise ExecutionError("Can't call .local on service function")
 
-        if is_local() and self.spec.volumes or self.spec.network_file_systems:
+        if is_local() and self._spec_.volumes or self._spec_.network_file_systems:
             warnings.warn(
                 f"The {info.function_name} function is executing locally "
                 + "and will not have access to the mounted Volume or NetworkFileSystem data"
@@ -2014,6 +2038,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         Returns:
             The original function object registered with Modal.
         """
+        return self._raw_f_
+
+    @property
+    def _raw_f_(self) -> Callable[..., Any]:
         assert self._raw_f is not None
         return self._raw_f
 

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/_image.py

@@ -704,7 +704,7 @@ class _Image(_Object, type_prefix="im"):
                 # TODO: better way to filter out types that don't have a stable hash?
                 build_function_globals = serialize(filtered_globals) if filtered_globals else b""
                 _build_function = api_pb2.BuildFunction(
-                    definition=build_function.get_build_def(),
+                    definition=build_function._get_build_def(),
                     globals=build_function_globals,
                     input=build_function_input,
                 )
@@ -2756,7 +2756,7 @@ class _Image(_Object, type_prefix="im"):
 
         info = FunctionInfo(raw_f)
 
-        function = _Function.from_local(
+        function = _Function._from_local(
             info,
             app=None,
             image=self,
@@ -2938,7 +2938,7 @@ class _Image(_Object, type_prefix="im"):
         try:
             yield
         except Exception as exc:
-            if not self.is_hydrated:
+            if not self._is_hydrated:
                 # Might be hydrated later (if it's the container's used image)
                 self.inside_exceptions.append(exc)
             elif env_image_id == self.object_id:
@@ -3051,7 +3051,7 @@ class _Image(_Object, type_prefix="im"):
         """mdmd:hidden"""
         # Image inherits hydrate() from Object but can't be hydrated on demand
         # Overriding the method lets us hide it from the docs and raise a better error message
-        if not self.is_hydrated:
+        if not self._is_hydrated:
             raise ExecutionError(
                 "Images cannot currently be hydrated on demand; you can build an Image by running an App that uses it."
             )

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/_object.py

@@ -209,7 +209,7 @@ class _Object:
         name: str | None = None,
         *,
         load_context_overrides: LoadContext,
-    ):
+    ) -> Self:
         # TODO(erikbern): flip the order of the two first arguments
         obj = _Object.__new__(cls)
         obj._init(
@@ -313,7 +313,10 @@ class _Object:
     @property
     def deps(self) -> Callable[..., Sequence["_Object"]]:
         """mdmd:hidden"""
+        return self._deps_
 
+    @property
+    def _deps_(self) -> Callable[..., Sequence["_Object"]]:
         def default_deps(*args, **kwargs) -> Sequence["_Object"]:
             return []
 

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/_resolver.py

@@ -44,19 +44,19 @@ class Resolver:
         existing_object_id: str | None = None,
     ):
         if obj._is_hydrated and obj._skip_reload:
-            if obj.local_uuid not in self._local_uuid_to_future:
+            if obj._local_uuid not in self._local_uuid_to_future:
                 # a bit dumb - but we still need to store a reference to the object here
                 # to be able to include all referenced objects when setting up the app
                 fut: Future = Future()
                 fut.set_result(obj)
-                self._local_uuid_to_future[obj.local_uuid] = fut
+                self._local_uuid_to_future[obj._local_uuid] = fut
             return obj
 
         deduplication_key: Hashable | None = None
         if obj._deduplication_key:
             deduplication_key = await obj._deduplication_key()
 
-        cached_future = self._local_uuid_to_future.get(obj.local_uuid)
+        cached_future = self._local_uuid_to_future.get(obj._local_uuid)
 
         if not cached_future and deduplication_key is not None:
             # deduplication cache makes sure duplicate mounts are resolved only
@@ -78,7 +78,7 @@ class Resolver:
                     # 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()])
+                    await asyncio.gather(*[self.load(dep, load_context) for dep in obj._deps_()])
 
                     # Load the object itself
                     if not obj._load:
@@ -102,7 +102,7 @@ class Resolver:
 
             # use task_context from load_context to make sure tasks are cleaned up eventually
             cached_future = parent_load_context.task_context.create_task(loader())
-            self._local_uuid_to_future[obj.local_uuid] = cached_future
+            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():

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/_runtime/user_code_imports.py

@@ -522,8 +522,8 @@ def import_single_function_service(
         f = getattr(module, qual_name)
         if isinstance(f, Function):
             _function: modal._functions._Function[Any, Any, Any] = synchronizer._translate_in(f)  # type: ignore
-            service_deps = _function.deps(only_explicit_mounts=True)
-            user_defined_callable = _function.get_raw_f()
+            service_deps = _function._deps_(only_explicit_mounts=True)
+            user_defined_callable = _function._raw_f_
             assert _function._app  # app should always be set on a decorated function
             active_app = _function._app
         else:
@@ -594,7 +594,7 @@ def import_class_service(
     if isinstance(cls_or_user_cls, modal.cls.Cls):
         _cls = typing.cast(modal.cls._Cls, synchronizer._translate_in(cls_or_user_cls))
         class_service_function: _Function = _cls._get_class_service_function()
-        service_deps = class_service_function.deps(only_explicit_mounts=True)
+        service_deps = class_service_function._deps_(only_explicit_mounts=True)
         active_app = class_service_function.app
     else:
         # Undecorated user class (serialized or local scope-decoration).
@@ -606,7 +606,7 @@ def import_class_service(
             service_function_hydration_data.function_handle_metadata,
             skip_reload=True,  # this skips re-loading the function, which is required since it doesn't have a loader
         )
-        _cls = modal.cls._Cls.from_local(cls_or_user_cls, active_app, _service_function)
+        _cls = modal.cls._Cls._from_local(cls_or_user_cls, active_app, _service_function)
         # hydration of the class itself - just sets the id and triggers some side effects
         # that transfers metadata from the service function to the class. TODO: cleanup!
         _cls._hydrate(class_id, _client, api_pb2.ClassHandleMetadata())
@@ -647,7 +647,7 @@ def import_server_service(
     if isinstance(cls_or_user_cls, modal.server.Server):
         _server = typing.cast(modal._server._Server, synchronizer._translate_in(cls_or_user_cls))
         server_service_function: _Function = _server._get_service_function()
-        service_deps = server_service_function.deps(only_explicit_mounts=True)
+        service_deps = server_service_function._deps_(only_explicit_mounts=True)
         active_app = _server._get_app()
 
     else:

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/_serialization.py

@@ -4,7 +4,7 @@ import io
 import pickle
 import typing
 from inspect import Parameter
-from typing import Any
+from typing import Any, cast
 
 from modal._traceback import extract_traceback
 from modal.config import config
@@ -43,8 +43,11 @@ class Pickler(cloudpickle.Pickler):
 
         if isinstance(obj, _Object):
             flag = "_o"
+            is_hydrated = obj._is_hydrated
         elif isinstance(obj, Object):
             flag = "o"
+            inner = cast(_Object, synchronizer._translate_in(obj))
+            is_hydrated = inner._is_hydrated
         elif isinstance(obj, PartialFunction):
             # Special case for PartialObject since it's a synchronicity wrapped object
             # that's set on serialized classes.
@@ -66,8 +69,10 @@ class Pickler(cloudpickle.Pickler):
             return ("sync", (impl_object.__class__, attributes))
         else:
             return
-        if not obj.is_hydrated:
+
+        if not is_hydrated:
             raise InvalidError(f"Can't serialize object {obj} which hasn't been hydrated.")
+
         return (obj.object_id, flag, obj._get_metadata())
 
 

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/_utils/mount_utils.py

@@ -108,7 +108,7 @@ def validate_volumes_by_object_id(validated_volumes: Sequence[tuple[str, _Volume
     """
     object_id_to_paths: dict[str, list[str]] = {}
     for path, volume in validated_volumes:
-        if not volume.is_hydrated:
+        if not volume._is_hydrated:
             # This should never happen since this function is only called at load time
             raise RuntimeError(f"Internal error: Volume at '{path}' is not hydrated when validating mounts")
         object_id_to_paths.setdefault(volume.object_id, []).append(path)

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/_workspace.py

@@ -321,7 +321,7 @@ class _WorkspaceBillingManager:
             A single mapping containing cost values. All values are reported as `decimal.Decimal`s.
         """
 
-        if not self._workspace.is_hydrated:
+        if not self._workspace._is_hydrated:
             await self._workspace.hydrate()
 
         response = await self._workspace.client.stub.WorkspaceBillingRates(
@@ -386,7 +386,7 @@ class _WorkspaceBillingManager:
         elif end.tzinfo != timezone.utc:
             raise InvalidError("Timezone-aware 'end' parameter must be in UTC.")
 
-        if not self._workspace.is_hydrated:
+        if not self._workspace._is_hydrated:
             await self._workspace.hydrate()
 
         request = api_pb2.WorkspaceBillingReportRequest(
@@ -457,7 +457,7 @@ class _WorkspaceBillingManager:
         if cycle > datetime.now(timezone.utc):
             raise InvalidError("Provided 'cycle' parameter cannot be in the future.")
 
-        if not self._workspace.is_hydrated:
+        if not self._workspace._is_hydrated:
             await self._workspace.hydrate()
 
         request = api_pb2.WorkspaceBillingSummaryRequest()
@@ -483,7 +483,7 @@ class _WorkspaceSettingsManager:
         Returns:
             A `WorkspaceSettings` dataclass.
         """
-        if not self._workspace.is_hydrated:
+        if not self._workspace._is_hydrated:
             await self._workspace.hydrate()
         resp = await self._workspace.client.stub.WorkspaceSettings(Empty())
         return WorkspaceSettings(
@@ -494,14 +494,14 @@ class _WorkspaceSettingsManager:
         """mdmd:hidden
         Set the image builder version for the Workspace.
         """
-        if not self._workspace.is_hydrated:
+        if not self._workspace._is_hydrated:
             await self._workspace.hydrate()
         req = api_pb2.WorkspaceSetImageBuilderVersionRequest(new_image_builder_version=version)
         await self._workspace.client.stub.WorkspaceSetImageBuilderVersion(req)
 
     async def _set_default_environment(self, name: str) -> None:
         """Set the default environment for the Workspace."""
-        if not self._workspace.is_hydrated:
+        if not self._workspace._is_hydrated:
             await self._workspace.hydrate()
         req = api_pb2.WorkspaceSetDefaultEnvironmentRequest(environment_name=name)
         await self._workspace.client.stub.WorkspaceSetDefaultEnvironment(req)

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/app.py

@@ -275,6 +275,11 @@ class _App:
 
     @property
     def is_interactive(self) -> bool:
+        """mdmd:hidden"""
+        return self._is_interactive_
+
+    @property
+    def _is_interactive_(self) -> bool:
         """mdmd:hidden
         Whether the current app for the app is running in interactive mode.
 
@@ -305,6 +310,11 @@ class _App:
         """
         return self._description
 
+    @description.setter
+    def description(self, value):
+        """mdmd:hidden"""
+        self._description = value
+
     @staticmethod
     async def lookup(
         name: str,
@@ -379,7 +389,7 @@ class _App:
 
         Note: we don't recommend using the method and may deprecate it in the future.
         """
-        self._description = description
+        self.description = description
 
     def _validate_blueprint_value(self, key: str, value: Any):
         if not isinstance(value, _Object):
@@ -589,14 +599,14 @@ class _App:
             raise ExecutionError("`_get_watch_mounts` requires a running app.")
 
         all_mounts = []
-        for function in self.registered_functions.values():
+        for function in self._local_state.functions.values():
             all_mounts.extend(function._serve_mounts)
 
         return [m for m in all_mounts if m.is_local()]
 
     def _add_function(self, function: _Function, is_web_endpoint: bool):
         local_state = self._local_state
-        if old_function := local_state.functions.get(function.tag, None):
+        if old_function := local_state.functions.get(function._tag_, None):
             if old_function is function:
                 return  # already added the same exact instance, ignore
 
@@ -605,25 +615,25 @@ class _App:
             # and we don't want to warn about a collision in that case.
             if not is_interactive_ipython():
                 logger.warning(
-                    f"Warning: function name '{function.tag}' collision!"
+                    f"Warning: function name '{function._tag_}' collision!"
                     " Overriding existing function "
                     f"[{old_function._info.module_name}].{old_function._info.function_name}"
                     f" with new function [{function._info.module_name}].{function._info.function_name}"
                 )
-        if function.tag in local_state.classes:
-            logger.warning(f"Warning: tag {function.tag} exists but is overridden by function")
+        if function._tag_ in local_state.classes:
+            logger.warning(f"Warning: tag {function._tag_} exists but is overridden by function")
 
         if self._running_app:
             # If this is inside a container, then objects can be defined after app initialization.
             # So we may have to initialize objects once they get bound to the app.
-            if function.tag in self._running_app.function_ids:
-                object_id: str = self._running_app.function_ids[function.tag]
+            if function._tag_ in self._running_app.function_ids:
+                object_id: str = self._running_app.function_ids[function._tag_]
                 metadata: Message = self._running_app.object_handle_metadata[object_id]
                 function._hydrate(object_id, self._client, metadata)
 
-        local_state.functions[function.tag] = function
+        local_state.functions[function._tag_] = function
         if is_web_endpoint:
-            local_state.web_endpoints.append(function.tag)
+            local_state.web_endpoints.append(function._tag_)
 
     def _add_class(self, tag: str, cls: _Cls):
         if self._running_app:
@@ -985,7 +995,7 @@ class _App:
             if is_generator is None:
                 is_generator = inspect.isgeneratorfunction(raw_f) or inspect.isasyncgenfunction(raw_f)
 
-            function = _Function.from_local(
+            function = _Function._from_local(
                 info,
                 app=self,
                 image=image,
@@ -1221,7 +1231,7 @@ class _App:
             info = FunctionInfo(None, serialized=serialized, user_cls=user_cls)
 
             i6pn_enabled = i6pn or cluster_size is not None
-            cls_func = _Function.from_local(
+            cls_func = _Function._from_local(
                 info,
                 app=self,
                 image=image or self._get_default_image(),
@@ -1264,7 +1274,7 @@ class _App:
 
             self._add_function(cls_func, is_web_endpoint=False)
 
-            cls: _Cls = _Cls.from_local(user_cls, self, cls_func)
+            cls: _Cls = _Cls._from_local(user_cls, self, cls_func)
 
             for method_name, partial_function in cls._method_partials.items():
                 if partial_function.params.webhook_config is not None:
@@ -1432,7 +1442,7 @@ class _App:
             # Create the FunctionInfo for the server, note we treat FunctionInfo as a class for servers
             info = FunctionInfo(None, serialized=serialized, user_cls=user_cls, name_override=name or user_cls.__name__)
             # Create the service function
-            service_function = _Function.from_local(
+            service_function = _Function._from_local(
                 info,
                 app=self,
                 image=image or self._get_default_image(),

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/app.pyi

@@ -205,6 +205,11 @@ class _App:
 
     @property
     def is_interactive(self) -> bool:
+        """mdmd:hidden"""
+        ...
+
+    @property
+    def _is_interactive_(self) -> bool:
         """mdmd:hidden
         Whether the current app for the app is running in interactive mode.
 
@@ -230,6 +235,11 @@ class _App:
         """
         ...
 
+    @description.setter
+    def description(self, value):
+        """mdmd:hidden"""
+        ...
+
     @staticmethod
     async def lookup(
         name: str,
@@ -1023,6 +1033,11 @@ class App:
 
     @property
     def is_interactive(self) -> bool:
+        """mdmd:hidden"""
+        ...
+
+    @property
+    def _is_interactive_(self) -> bool:
         """mdmd:hidden
         Whether the current app for the app is running in interactive mode.
 
@@ -1048,6 +1063,11 @@ class App:
         """
         ...
 
+    @description.setter
+    def description(self, value):
+        """mdmd:hidden"""
+        ...
+
     class __lookup_spec(typing_extensions.Protocol):
         def __call__(
             self,

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/cli/config.py

@@ -22,12 +22,16 @@ config_cli = ModalGroup(
 
 
 @config_cli.command("show", help="Show current configuration values (debugging command).")
-@click.option("--redact/--no-redact", default=True, help="Redact the `token_secret` value.")
+@click.option("--redact/--no-redact", default=True, help="Redact secret credential values.")
 def show(redact: bool):
     # This is just a test command
     config_dict = config.to_dict()
     if redact and config_dict.get("token_secret"):
         config_dict["token_secret"] = "***"
+    if redact and config_dict.get("oauth_refresh_token"):
+        config_dict["oauth_refresh_token"] = "***"
+    if redact and config_dict.get("oauth_client_secret"):
+        config_dict["oauth_client_secret"] = "***"
 
     OutputManager.get().print_json(json.dumps(config_dict))
 

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/cli/import_refs.py

@@ -27,6 +27,8 @@ from modal.exception import InvalidError, _CliUserExecutionError
 from modal.functions import Function
 from modal.output import OutputManager
 
+from .._utils.async_utils import synchronizer
+
 
 @dataclasses.dataclass
 class ImportRef:
@@ -165,15 +167,18 @@ def list_cli_commands(
     all_runnables: dict[Runnable, list[str]] = defaultdict(list)
     priorities: dict[Runnable, int] = defaultdict(lambda: AutoRunPriority.APP_FUNCTION)
     for app_name, app in apps:
-        for name, local_entrypoint in app.registered_entrypoints.items():
+        for name, inner_entrypoint in app._local_state.local_entrypoints.items():
+            local_entrypoint = cast(LocalEntrypoint, synchronizer._translate_out(inner_entrypoint))
             all_runnables[local_entrypoint].append(f"{app_name}.{name}")
             priorities[local_entrypoint] = AutoRunPriority.APP_LOCAL_ENTRYPOINT
-        for name, function in app.registered_functions.items():
-            if function.info.is_service_class() and not include_service_functions:
+        for name, inner_function in app._local_state.functions.items():
+            function = cast(Function, synchronizer._translate_out(inner_function))
+            if function._info_.is_service_class() and not include_service_functions:
                 continue  # Skip class and server service functions for all commands except `modal shell`.
             all_runnables[function].append(f"{app_name}.{name}")
             priorities[function] = AutoRunPriority.APP_FUNCTION
-        for cls_name, cls in app.registered_classes.items():
+        for cls_name, inner_cls in app._local_state.classes.items():
+            cls = cast(Cls, synchronizer._translate_out(inner_cls))
             for method_name in cls._get_method_names():
                 method_ref = MethodReference(cls, method_name)
                 all_runnables[method_ref].append(f"{app_name}.{cls_name}.{method_name}")

{modal-1.5.5.dev14 → modal-1.5.5.dev16}/modal/cli/launch.py

@@ -4,12 +4,15 @@ import inspect
 import json
 import os
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 import click
 import rich.panel
 from rich.markdown import Markdown
 
+from modal.app import _App
+
+from .._utils.async_utils import synchronizer
 from ..exception import _CliUserExecutionError
 from ..output import OutputManager
 from ..runner import run_app
@@ -40,7 +43,8 @@ def _launch_program(
     entrypoint = module.main
 
     app = _get_runnable_app(entrypoint)
-    app.set_description(description if description else base_cmd)
+    inner = cast(_App, synchronizer._translate_in(app))
+    inner._description = description if description else base_cmd
 
     # `launch/` scripts must have a `local_entrypoint()` with no args, for simplicity here.
     func = entrypoint.info.raw_f