modal 1.5.5.dev15__tar.gz → 1.5.5.dev16__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.5.dev15
+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.dev15 → 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.dev15 → 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.dev15 → modal-1.5.5.dev16}/modal/_functions.py

@@ -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
@@ -1934,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"

{modal-1.5.5.dev15 → 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.dev15 → 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.dev15 → 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.dev15 → 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.dev15 → 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.dev15 → 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.dev15 → modal-1.5.5.dev16}/modal/app.py

@@ -599,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
 
@@ -615,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:
@@ -995,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,
@@ -1231,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(),
@@ -1274,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:
@@ -1442,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.dev15 → 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.dev15 → 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.dev15 → 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

{modal-1.5.5.dev15 → modal-1.5.5.dev16}/modal/cli/run.py

@@ -8,14 +8,15 @@ import time
 import typing
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any, get_args
+from typing import Any, cast, get_args
 
 import click
 from click import ClickException
 from typing_extensions import TypedDict
 
 from .._environments import ensure_env
-from ..app import App, LocalEntrypoint
+from .._utils.async_utils import synchronizer
+from ..app import App, LocalEntrypoint, _App
 from ..cls import _get_class_constructor_signature
 from ..config import config
 from ..exception import ExecutionError, InvalidError, _CliUserExecutionError
@@ -466,9 +467,10 @@ class RunGroup(ModalGroup):
             raise ClickException(f"{help_header}\n\n{help_footer}")
 
         app = _get_runnable_app(runnable)
+        inner = cast(_App, synchronizer._translate_in(app))
 
-        if app.description is None:
-            app.set_description(_get_clean_app_description(func_ref))
+        if inner._description is None:
+            inner._description = _get_clean_app_description(func_ref)
 
         if isinstance(runnable, LocalEntrypoint):
             click_command = _get_click_command_for_local_entrypoint(app, runnable)
@@ -672,8 +674,10 @@ def serve(
 
     OutputManager.get().set_timestamps(timestamps)
     app = import_app_from_ref(import_ref, base_cmd="modal serve")
-    if app.description is None:
-        app.set_description(_get_clean_app_description(app_ref))
+    inner = cast(_App, synchronizer._translate_in(app))
+
+    if inner._description is None:
+        inner._description = _get_clean_app_description(app_ref)
     with serve_app(app, import_ref, name=name, environment_name=env):
         if timeout is None:
             timeout = config["serve_timeout"]