modal 0.66.39__py3-none-any.whl → 0.66.46__py3-none-any.whl

modal/functions.py

@@ -314,7 +314,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     _tag: str
     _raw_f: Callable[..., Any]
     _build_args: dict
-    _can_use_base_function: bool = False  # whether we need to call FunctionBindParams
+
     _is_generator: Optional[bool] = None
     _cluster_size: Optional[int] = None
 
@@ -323,10 +323,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     _use_function_id: str  # The function to invoke
     _use_method_name: str = ""
 
-    # TODO (elias): remove _parent. In case of instance functions, and methods bound on those,
-    #  this references the parent class-function and is used to infer the client for lazy-loaded methods
-    _parent: Optional["_Function"] = None
-
     _class_parameter_info: Optional["api_pb2.ClassParameterInfo"] = None
     _method_handle_metadata: Optional[Dict[str, "api_pb2.FunctionHandleMetadata"]] = None
 
@@ -511,7 +507,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         fun._info = class_bound_method._info
         fun._obj = instance_service_function._obj
         fun._is_method = True
-        fun._parent = instance_service_function._parent
         fun._app = class_bound_method._app
         fun._spec = class_bound_method._spec
         return fun
@@ -1019,27 +1014,37 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         Binds a class-function to a specific instance of (init params, options) or a new workspace
         """
 
-        async def _load(self: _Function, resolver: Resolver, existing_object_id: Optional[str]):
-            if self._parent is None:
+        # 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
+        parent = self
+
+        async def _load(param_bound_func: _Function, resolver: Resolver, existing_object_id: Optional[str]):
+            if parent is None:
                 raise ExecutionError("Can't find the parent class' service function")
             try:
-                identity = f"{self._parent.info.function_name} class service function"
+                identity = f"{parent.info.function_name} class service function"
             except Exception:
                 # Can't always look up the function name that way, so fall back to generic message
                 identity = "class service function for a parameterized class"
-            if not self._parent.is_hydrated:
-                if self._parent.app._running_app is None:
+            if not parent.is_hydrated:
+                if parent.app._running_app is None:
                     reason = ", because the App it is defined on is not running"
                 else:
                     reason = ""
                 raise ExecutionError(
                     f"The {identity} has not been hydrated with the metadata it needs to run on Modal{reason}."
                 )
-            assert self._parent._client.stub
+
+            assert 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.
+                param_bound_func._hydrate_from_other(parent)
+                return
+
             if (
-                self._parent._class_parameter_info
-                and self._parent._class_parameter_info.format
-                == api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PROTO
+                parent._class_parameter_info
+                and parent._class_parameter_info.format == api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PROTO
             ):
                 if args:
                     # TODO(elias) - We could potentially support positional args as well, if we want to?
@@ -1047,34 +1052,30 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         "Can't use positional arguments with modal.parameter-based synthetic constructors.\n"
                         "Use (<parameter_name>=value) keyword arguments when constructing classes instead."
                     )
-                serialized_params = serialize_proto_params(kwargs, self._parent._class_parameter_info.schema)
+                serialized_params = serialize_proto_params(kwargs, parent._class_parameter_info.schema)
             else:
                 serialized_params = serialize((args, kwargs))
             environment_name = _get_environment_name(None, resolver)
-            assert self._parent is not None
+            assert parent is not None
             req = api_pb2.FunctionBindParamsRequest(
-                function_id=self._parent._object_id,
+                function_id=parent._object_id,
                 serialized_params=serialized_params,
                 function_options=options,
                 environment_name=environment_name
                 or "",  # TODO: investigate shouldn't environment name always be specified here?
             )
 
-            response = await retry_transient_errors(self._parent._client.stub.FunctionBindParams, req)
-            self._hydrate(response.bound_function_id, self._parent._client, response.handle_metadata)
+            response = await retry_transient_errors(parent._client.stub.FunctionBindParams, req)
+            param_bound_func._hydrate(response.bound_function_id, parent._client, response.handle_metadata)
 
         fun: _Function = _Function._from_loader(_load, "Function(parametrized)", hydrate_lazily=True)
 
-        # In some cases, reuse the base function, i.e. not create new clones of each method or the "service function"
-        fun._can_use_base_function = len(args) + len(kwargs) == 0 and not from_other_workspace and options is None
-        if fun._can_use_base_function and self.is_hydrated:
-            # Edge case that lets us hydrate all objects right away
-            # if the instance didn't use explicit constructor arguments
-            fun._hydrate_from_other(self)
+        if can_use_parent and parent.is_hydrated:
+            # skip the resolver altogether:
+            fun._hydrate_from_other(parent)
 
         fun._info = self._info
         fun._obj = obj
-        fun._parent = self
         return fun
 
     @live_method
@@ -1265,8 +1266,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 + f"or call it locally: {self._function_name}.local()"
             )
 
+    # TODO (live_method on properties is not great, since it could be blocking the event loop from async contexts)
     @property
-    def web_url(self) -> str:
+    @live_method
+    async def web_url(self) -> str:
         """URL of a Function running as a web endpoint."""
         if not self._web_url:
             raise ValueError(
@@ -1439,7 +1442,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             return fun(*args, **kwargs)
         else:
             # This is a method on a class, so bind the self to the function
-            user_cls_instance = obj._get_user_cls_instance()
+            user_cls_instance = obj._cached_user_cls_instance()
 
             fun = info.raw_f.__get__(user_cls_instance)
 

modal/functions.pyi

@@ -120,12 +120,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     _tag: str
     _raw_f: typing.Callable[..., typing.Any]
     _build_args: dict
-    _can_use_base_function: bool
     _is_generator: typing.Optional[bool]
     _cluster_size: typing.Optional[int]
     _use_function_id: str
     _use_method_name: str
-    _parent: typing.Optional[_Function]
     _class_parameter_info: typing.Optional[modal_proto.api_pb2.ClassParameterInfo]
     _method_handle_metadata: typing.Optional[typing.Dict[str, modal_proto.api_pb2.FunctionHandleMetadata]]
 
@@ -218,7 +216,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     def _get_metadata(self): ...
     def _check_no_web_url(self, fn_name: str): ...
     @property
-    def web_url(self) -> str: ...
+    async def web_url(self) -> str: ...
     @property
     def is_generator(self) -> bool: ...
     @property
@@ -296,12 +294,10 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
     _tag: str
     _raw_f: typing.Callable[..., typing.Any]
     _build_args: dict
-    _can_use_base_function: bool
     _is_generator: typing.Optional[bool]
     _cluster_size: typing.Optional[int]
     _use_function_id: str
     _use_method_name: str
-    _parent: typing.Optional[Function]
     _class_parameter_info: typing.Optional[modal_proto.api_pb2.ClassParameterInfo]
     _method_handle_metadata: typing.Optional[typing.Dict[str, modal_proto.api_pb2.FunctionHandleMetadata]]
 

modal/image.py

@@ -344,7 +344,7 @@ class _Image(_Object, type_prefix="im"):
                 "\n"
                 "my_image = (\n"
                 "    Image.debian_slim()\n"
-                '   .add_local_python_packages("mypak", copy=True)\n'
+                '    .add_local_file("data.json", copy=True)\n'
                 '    .run_commands("python -m mypak")  # this now works!\n'
                 ")\n"
             )
@@ -601,12 +601,59 @@ class _Image(_Object, type_prefix="im"):
             context_mount=mount,
         )
 
+    def add_local_file(self, local_path: Union[str, Path], remote_path: str, *, copy: bool = False) -> "_Image":
+        """Adds a local file to the image at `remote_path` within the container
+
+        By default (`copy=False`), the files are added to containers on startup and are not built into the actual Image,
+        which speeds up deployment.
+
+        Set `copy=True` to copy the files into an Image layer at build time instead, similar to how
+        [`COPY`](https://docs.docker.com/engine/reference/builder/#copy) works in a `Dockerfile`.
+
+        copy=True can slow down iteration since it requires a rebuild of the Image and any subsequent
+        build steps whenever the included files change, but it is required if you want to run additional
+        build steps after this one.
+        """
+        if not PurePosixPath(remote_path).is_absolute():
+            # TODO(elias): implement relative to absolute resolution using image workdir metadata
+            #  + make default remote_path="./"
+            #  This requires deferring the Mount creation until after "self" (the base image) has been resolved
+            #  so we know the workdir of the operation.
+            raise InvalidError("image.add_local_file() currently only supports absolute remote_path values")
+
+        if remote_path.endswith("/"):
+            remote_path = remote_path + Path(local_path).name
+
+        mount = _Mount.from_local_file(local_path, remote_path)
+        return self._add_mount_layer_or_copy(mount, copy=copy)
+
+    def add_local_dir(self, local_path: Union[str, Path], remote_path: str, *, copy: bool = False) -> "_Image":
+        """Adds a local directory's content to the image at `remote_path` within the container
+
+        By default (`copy=False`), the files are added to containers on startup and are not built into the actual Image,
+        which speeds up deployment.
+
+        Set `copy=True` to copy the files into an Image layer at build time instead, similar to how
+        [`COPY`](https://docs.docker.com/engine/reference/builder/#copy) works in a `Dockerfile`.
+
+        copy=True can slow down iteration since it requires a rebuild of the Image and any subsequent
+        build steps whenever the included files change, but it is required if you want to run additional
+        build steps after this one.
+        """
+        if not PurePosixPath(remote_path).is_absolute():
+            # TODO(elias): implement relative to absolute resolution using image workdir metadata
+            #  + make default remote_path="./"
+            raise InvalidError("image.add_local_dir() currently only supports absolute remote_path values")
+        mount = _Mount.from_local_dir(local_path, remote_path=remote_path)
+        return self._add_mount_layer_or_copy(mount, copy=copy)
+
     def copy_local_file(self, local_path: Union[str, Path], remote_path: Union[str, Path] = "./") -> "_Image":
         """Copy a file into the image as a part of building it.
 
         This works in a similar way to [`COPY`](https://docs.docker.com/engine/reference/builder/#copy)
         works in a `Dockerfile`.
         """
+        # TODO(elias): add pending deprecation with suggestion to use add_* instead
         basename = str(Path(local_path).name)
         mount = _Mount.from_local_file(local_path, remote_path=f"/{basename}")
 
@@ -1637,7 +1684,7 @@ class _Image(_Object, type_prefix="im"):
             dockerfile_function=build_dockerfile,
         )
 
-    def workdir(self, path: str) -> "_Image":
+    def workdir(self, path: Union[str, PurePosixPath]) -> "_Image":
         """Set the working directory for subsequent image build steps and function execution.
 
         **Example**

modal/image.pyi

@@ -100,6 +100,12 @@ class _Image(modal.object._Object):
         _do_assert_no_mount_layers: bool = True,
     ) -> _Image: ...
     def copy_mount(self, mount: modal.mount._Mount, remote_path: typing.Union[str, pathlib.Path] = ".") -> _Image: ...
+    def add_local_file(
+        self, local_path: typing.Union[str, pathlib.Path], remote_path: str, *, copy: bool = False
+    ) -> _Image: ...
+    def add_local_dir(
+        self, local_path: typing.Union[str, pathlib.Path], remote_path: str, *, copy: bool = False
+    ) -> _Image: ...
     def copy_local_file(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "./"
     ) -> _Image: ...
@@ -301,7 +307,7 @@ class _Image(modal.object._Object):
         kwargs: typing.Dict[str, typing.Any] = {},
     ) -> _Image: ...
     def env(self, vars: typing.Dict[str, str]) -> _Image: ...
-    def workdir(self, path: str) -> _Image: ...
+    def workdir(self, path: typing.Union[str, pathlib.PurePosixPath]) -> _Image: ...
     def imports(self): ...
     def _logs(self) -> typing.AsyncGenerator[str, None]: ...
 
@@ -351,6 +357,12 @@ class Image(modal.object.Object):
         _do_assert_no_mount_layers: bool = True,
     ) -> Image: ...
     def copy_mount(self, mount: modal.mount.Mount, remote_path: typing.Union[str, pathlib.Path] = ".") -> Image: ...
+    def add_local_file(
+        self, local_path: typing.Union[str, pathlib.Path], remote_path: str, *, copy: bool = False
+    ) -> Image: ...
+    def add_local_dir(
+        self, local_path: typing.Union[str, pathlib.Path], remote_path: str, *, copy: bool = False
+    ) -> Image: ...
     def copy_local_file(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "./"
     ) -> Image: ...
@@ -552,7 +564,7 @@ class Image(modal.object.Object):
         kwargs: typing.Dict[str, typing.Any] = {},
     ) -> Image: ...
     def env(self, vars: typing.Dict[str, str]) -> Image: ...
-    def workdir(self, path: str) -> Image: ...
+    def workdir(self, path: typing.Union[str, pathlib.PurePosixPath]) -> Image: ...
     def imports(self): ...
 
     class ___logs_spec(typing_extensions.Protocol):

modal/io_streams.py

@@ -66,9 +66,10 @@ T = TypeVar("T", str, bytes)
 
 
 class _StreamReader(Generic[T]):
-    """Provides an interface to buffer and fetch logs from a stream (`stdout` or `stderr`).
+    """Retrieve logs from a stream (`stdout` or `stderr`).
 
-    As an asynchronous iterable, the object supports the async for statement.
+    As an asynchronous iterable, the object supports the `for` and `async for`
+    statements. Just loop over the object to read in chunks.
 
     **Usage**
 
@@ -140,12 +141,12 @@ class _StreamReader(Generic[T]):
             self._consume_container_process_task = asyncio.create_task(self._consume_container_process_stream())
 
     @property
-    def file_descriptor(self):
+    def file_descriptor(self) -> int:
+        """Possible values are `1` for stdout and `2` for stderr."""
         return self._file_descriptor
 
     async def read(self) -> T:
-        """Fetch and return contents of the entire stream. If EOF was received,
-        return an empty string.
+        """Fetch the entire contents of the stream until EOF.
 
         **Usage**
 
@@ -157,7 +158,6 @@ class _StreamReader(Generic[T]):
 
         print(sandbox.stdout.read())
         ```
-
         """
         data_str = ""
         data_bytes = b""
@@ -175,9 +175,7 @@ class _StreamReader(Generic[T]):
             return cast(T, data_bytes)
 
     async def _consume_container_process_stream(self):
-        """
-        Consumes the container process stream and stores the messages in the buffer.
-        """
+        """Consume the container process stream and store messages in the buffer."""
         if self._stream_type == StreamType.DEVNULL:
             return
 
@@ -211,9 +209,7 @@ class _StreamReader(Generic[T]):
                 raise exc
 
     async def _stream_container_process(self) -> AsyncGenerator[Tuple[Optional[bytes], str], None]:
-        """mdmd:hidden
-        Streams the container process buffer to the reader.
-        """
+        """Streams the container process buffer to the reader."""
         entry_id = 0
         if self._last_entry_id:
             entry_id = int(self._last_entry_id) + 1
@@ -232,8 +228,7 @@ class _StreamReader(Generic[T]):
             entry_id += 1
 
     async def _get_logs(self) -> AsyncGenerator[Optional[bytes], None]:
-        """mdmd:hidden
-        Streams sandbox or process logs from the server to the reader.
+        """Streams sandbox or process logs from the server to the reader.
 
         Logs returned by this method may contain partial or multiple lines at a time.
 
@@ -278,9 +273,7 @@ class _StreamReader(Generic[T]):
                 raise
 
     async def _get_logs_by_line(self) -> AsyncGenerator[Optional[bytes], None]:
-        """mdmd:hidden
-        Processes logs from the server and yields complete lines only.
-        """
+        """Process logs from the server and yield complete lines only."""
         async for message in self._get_logs():
             if message is None:
                 if self._line_buffer:
@@ -325,7 +318,8 @@ MAX_BUFFER_SIZE = 2 * 1024 * 1024
 class _StreamWriter:
     """Provides an interface to buffer and write logs to a sandbox or container process stream (`stdin`)."""
 
-    def __init__(self, object_id: str, object_type: Literal["sandbox", "container_process"], client: _Client):
+    def __init__(self, object_id: str, object_type: Literal["sandbox", "container_process"], client: _Client) -> None:
+        """mdmd:hidden"""
         self._index = 1
         self._object_id = object_id
         self._object_type = object_type
@@ -333,17 +327,16 @@ class _StreamWriter:
         self._is_closed = False
         self._buffer = bytearray()
 
-    def get_next_index(self):
-        """mdmd:hidden"""
+    def _get_next_index(self) -> int:
         index = self._index
         self._index += 1
         return index
 
-    def write(self, data: Union[bytes, bytearray, memoryview, str]):
-        """
-        Writes data to stream's internal buffer, but does not drain/flush the write.
+    def write(self, data: Union[bytes, bytearray, memoryview, str]) -> None:
+        """Write data to the stream but does not send it immediately.
 
-        This method needs to be used along with the `drain()` method which flushes the buffer.
+        This is non-blocking and queues the data to an internal buffer. Must be
+        used along with the `drain()` method, which flushes the buffer.
 
         **Usage**
 
@@ -375,22 +368,36 @@ class _StreamWriter:
         else:
             raise TypeError(f"data argument must be a bytes-like object, not {type(data).__name__}")
 
-    def write_eof(self):
-        """
-        Closes the write end of the stream after the buffered write data is drained.
-        If the process was blocked on input, it will become unblocked after `write_eof()`.
+    def write_eof(self) -> None:
+        """Close the write end of the stream after the buffered data is drained.
 
-        This method needs to be used along with the `drain()` method which flushes the EOF to the process.
+        If the process was blocked on input, it will become unblocked after
+        `write_eof()`. This method needs to be used along with the `drain()`
+        method, which flushes the EOF to the process.
         """
         self._is_closed = True
 
-    async def drain(self):
-        """
-        Flushes the write buffer to the running process. Flushes the EOF if the writer is closed.
+    async def drain(self) -> None:
+        """Flush the write buffer and send data to the running process.
+
+        This is a flow control method that blocks until data is sent. It returns
+        when it is appropriate to continue writing data to the stream.
+
+        **Usage**
+
+        ```python
+        # Synchronous
+        writer.write(data)
+        writer.drain()
+
+        # Async
+        writer.write(data)
+        await writer.drain.aio()
+        ```
         """
         data = bytes(self._buffer)
         self._buffer.clear()
-        index = self.get_next_index()
+        index = self._get_next_index()
 
         try:
             if self._object_type == "sandbox":

modal/io_streams.pyi

@@ -26,7 +26,7 @@ class _StreamReader(typing.Generic[T]):
         by_line: bool = False,
     ) -> None: ...
     @property
-    def file_descriptor(self): ...
+    def file_descriptor(self) -> int: ...
     async def read(self) -> T: ...
     async def _consume_container_process_stream(self): ...
     def _stream_container_process(self) -> typing.AsyncGenerator[typing.Tuple[typing.Optional[bytes], str], None]: ...
@@ -38,11 +38,11 @@ class _StreamReader(typing.Generic[T]):
 class _StreamWriter:
     def __init__(
         self, object_id: str, object_type: typing.Literal["sandbox", "container_process"], client: modal.client._Client
-    ): ...
-    def get_next_index(self): ...
-    def write(self, data: typing.Union[bytes, bytearray, memoryview, str]): ...
-    def write_eof(self): ...
-    async def drain(self): ...
+    ) -> None: ...
+    def _get_next_index(self) -> int: ...
+    def write(self, data: typing.Union[bytes, bytearray, memoryview, str]) -> None: ...
+    def write_eof(self) -> None: ...
+    async def drain(self) -> None: ...
 
 T_INNER = typing.TypeVar("T_INNER", covariant=True)
 
@@ -60,7 +60,7 @@ class StreamReader(typing.Generic[T]):
         by_line: bool = False,
     ) -> None: ...
     @property
-    def file_descriptor(self): ...
+    def file_descriptor(self) -> int: ...
 
     class __read_spec(typing_extensions.Protocol[T_INNER]):
         def __call__(self) -> T_INNER: ...
@@ -100,13 +100,13 @@ class StreamReader(typing.Generic[T]):
 class StreamWriter:
     def __init__(
         self, object_id: str, object_type: typing.Literal["sandbox", "container_process"], client: modal.client.Client
-    ): ...
-    def get_next_index(self): ...
-    def write(self, data: typing.Union[bytes, bytearray, memoryview, str]): ...
-    def write_eof(self): ...
+    ) -> None: ...
+    def _get_next_index(self) -> int: ...
+    def write(self, data: typing.Union[bytes, bytearray, memoryview, str]) -> None: ...
+    def write_eof(self) -> None: ...
 
     class __drain_spec(typing_extensions.Protocol):
-        def __call__(self): ...
-        async def aio(self): ...
+        def __call__(self) -> None: ...
+        async def aio(self) -> None: ...
 
     drain: __drain_spec

modal/mount.py

@@ -377,7 +377,9 @@ class _Mount(_Object, type_prefix="mo"):
         )
 
     def add_local_file(
-        self, local_path: Union[str, Path], remote_path: Union[str, PurePosixPath, None] = None
+        self,
+        local_path: Union[str, Path],
+        remote_path: Union[str, PurePosixPath, None] = None,
     ) -> "_Mount":
         """
         Add a local file to the `Mount` object.

modal/partial_function.py

@@ -91,7 +91,7 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
         if obj:  # accessing the method on an instance of a class, e.g. `MyClass().fun``
             if hasattr(obj, "_modal_functions"):
                 # This happens inside "local" user methods when they refer to other methods,
-                # e.g. Foo().parent_method() doing self.local.other_method()
+                # e.g. Foo().parent_method.remote() calling self.other_method.remote()
                 return getattr(obj, "_modal_functions")[k]
             else:
                 # special edge case: referencing a method of an instance of an

modal/runner.py

@@ -327,11 +327,13 @@ async def _run_app(
             )
 
         try:
+            indexed_objects = dict(**app._functions, **app._classes)  # TODO(erikbern): remove
+
             # Create all members
-            await _create_all_objects(client, running_app, app._indexed_objects, environment_name)
+            await _create_all_objects(client, running_app, indexed_objects, environment_name)
 
             # Publish the app
-            await _publish_app(client, running_app, app_state, app._indexed_objects)
+            await _publish_app(client, running_app, app_state, indexed_objects)
         except asyncio.CancelledError as e:
             # this typically happens on sigint/ctrl-C during setup (the KeyboardInterrupt happens in the main thread)
             if output_mgr := _get_output_manager():
@@ -424,16 +426,18 @@ async def _serve_update(
     try:
         running_app: RunningApp = await _init_local_app_existing(client, existing_app_id, environment_name)
 
+        indexed_objects = dict(**app._functions, **app._classes)  # TODO(erikbern): remove
+
         # Create objects
         await _create_all_objects(
             client,
             running_app,
-            app._indexed_objects,
+            indexed_objects,
             environment_name,
         )
 
         # Publish the updated app
-        await _publish_app(client, running_app, api_pb2.APP_STATE_UNSPECIFIED, app._indexed_objects)
+        await _publish_app(client, running_app, api_pb2.APP_STATE_UNSPECIFIED, indexed_objects)
 
         # Communicate to the parent process
         is_ready.set()
@@ -521,17 +525,19 @@ async def _deploy_app(
 
         tc.infinite_loop(heartbeat, sleep=HEARTBEAT_INTERVAL)
 
+        indexed_objects = dict(**app._functions, **app._classes)  # TODO(erikbern): remove
+
         try:
             # Create all members
             await _create_all_objects(
                 client,
                 running_app,
-                app._indexed_objects,
+                indexed_objects,
                 environment_name=environment_name,
             )
 
             app_url, warnings = await _publish_app(
-                client, running_app, api_pb2.APP_STATE_DEPLOYED, app._indexed_objects, name, tag
+                client, running_app, api_pb2.APP_STATE_DEPLOYED, indexed_objects, name, tag
             )
         except Exception as e:
             # Note that AppClientDisconnect only stops the app if it's still initializing, and is a no-op otherwise.

{modal-0.66.39.dist-info → modal-0.66.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: modal
-Version: 0.66.39
+Version: 0.66.46
 Summary: Python client library for Modal
 Author: Modal Labs
 Author-email: support@modal.com