modal 1.4.1.dev4__tar.gz → 1.4.2.dev0__tar.gz

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.4.1.dev4
+Version: 1.4.2.dev0
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0
@@ -23,7 +23,7 @@ Requires-Dist: grpclib<0.4.10,>=0.4.7; python_version < "3.14"
 Requires-Dist: grpclib<0.4.10,>=0.4.9; python_version >= "3.14"
 Requires-Dist: protobuf!=4.24.0,<7.0,>=3.19
 Requires-Dist: rich>=12.0.0
-Requires-Dist: synchronicity~=0.11.1
+Requires-Dist: synchronicity~=0.12.1
 Requires-Dist: toml
 Requires-Dist: typer>=0.9
 Requires-Dist: types-certifi

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/_utils/sandbox_fs_utils.py

@@ -12,6 +12,7 @@ from ..exception import (
     Error as ModalError,
     InvalidError,
     NotFoundError,
+    SandboxFilesystemDirectoryNotEmptyError,
     SandboxFilesystemError,
     SandboxFilesystemFileTooLargeError,
     SandboxFilesystemIsADirectoryError,
@@ -153,6 +154,40 @@ def make_read_file_command(remote_path: str) -> str:
     return json.dumps({"ReadFile": {"path": remote_path}})
 
 
+def make_remove_command(remote_path: str, recursive: bool) -> str:
+    """Build the JSON command string for a Remove operation.
+
+    The returned JSON must match the `Command` enum in the modal-sandbox-fs-tools
+    Rust crate (crates/modal-sandbox-fs-tools/src/lib.rs). Treat changes to
+    this schema like protobuf changes: fields must not be removed or renamed,
+    only added with backwards-compatible defaults.
+    """
+    return json.dumps({"Remove": {"path": remote_path, "recursive": recursive}})
+
+
+def raise_remove_error(returncode: int, stderr: Union[str, bytes], remote_path: str) -> NoReturn:
+    if payload := try_parse_error_payload(stderr):
+        logger.debug(
+            f"sandbox-fs-tools remove error: path={remote_path}, "
+            f"error_kind={payload.error_kind}, message={payload.message}, detail={payload.detail}"
+        )
+        if payload.error_kind == "NotFound":
+            raise SandboxFilesystemNotFoundError(f"{payload.message}: {remote_path}")
+        if payload.error_kind == "DirectoryNotEmpty":
+            raise SandboxFilesystemDirectoryNotEmptyError(f"{payload.message}: {remote_path}")
+        if payload.error_kind == "NotSupported":
+            raise InvalidError(
+                f"{payload.message}: {remote_path} - this operation is not supported for CloudBucketMounts"
+            )
+        if payload.error_kind == "PermissionDenied":
+            raise SandboxFilesystemPermissionError(f"{payload.message}: {remote_path}")
+        raise SandboxFilesystemError(payload.message)
+
+    if stderr_text := _stderr_to_text(stderr):
+        logger.debug(f"Unstructured modal-sandbox-fs-tools stderr: {stderr_text}")
+    raise SandboxFilesystemError(f"Operation on '{remote_path}' failed with exit code {returncode}")
+
+
 def validate_absolute_remote_path(remote_path: str, operation: str) -> None:
     if not PurePosixPath(remote_path).is_absolute():
         raise InvalidError(f"Sandbox.filesystem.{operation}() currently only supports absolute remote_path values")

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/_utils/task_command_router_client.py

@@ -2,6 +2,7 @@
 import asyncio
 import base64
 import json
+import socket
 import ssl
 import time
 import urllib.parse
@@ -181,7 +182,10 @@ class TaskCommandRouterClient:
             closed_error_message="Unable to perform operation on a detached sandbox",
         )
 
-        await _connect_channel(channel)
+        try:
+            await _connect_channel(channel)
+        except socket.gaierror as exc:
+            raise ConnectionError(f"Could not resolve hostname '{host}': {exc}") from exc
         loop = asyncio.get_running_loop()
         jwt_refresh_lock = asyncio.Lock()
 

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/_utils/time_utils.py

@@ -164,6 +164,61 @@ def parse_date_range(s: str, tz: Optional[tzinfo] = None) -> tuple[datetime, dat
     raise ValueError(f"Unrecognized range: '{s}'. Accepted values: {accepted}")
 
 
+def relative_timestamp(dt: datetime) -> str:
+    """Convert a tz-aware datetime to a human-readable relative time string.
+
+    Examples: "just now", "30 seconds ago", "5 minutes ago", "2 hours ago",
+    "yesterday", "3 days ago", "2 weeks ago", "3 months ago", "1 year ago".
+
+    Raises ValueError if the datetime is naive (no tzinfo).
+    """
+    if dt.tzinfo is None:
+        raise ValueError("datetime must be timezone-aware")
+
+    now = datetime.now(timezone.utc)
+    delta = now - dt
+    total_seconds = int(delta.total_seconds())
+
+    if total_seconds < 0:
+        return "just now"
+
+    if total_seconds < 10:
+        return "just now"
+    if total_seconds < 60:
+        return f"{total_seconds} seconds ago"
+    if total_seconds < 120:
+        return "1 minute ago"
+
+    minutes = total_seconds // 60
+    if minutes < 60:
+        return f"{minutes} minutes ago"
+    if minutes < 120:
+        return "1 hour ago"
+
+    hours = minutes // 60
+    if hours < 24:
+        return f"{hours} hours ago"
+    if hours < 48:
+        return "yesterday"
+
+    days = hours // 24
+    if days < 14:
+        return f"{days} days ago"
+
+    weeks = days // 7
+    if days < 60:
+        return f"{weeks} weeks ago"
+
+    months = days // 30
+    if days < 365:
+        return f"{months} months ago"
+
+    years = days // 365
+    if years == 1:
+        return "1 year ago"
+    return f"{years} years ago"
+
+
 def locale_tz() -> tzinfo:
     return datetime.now().astimezone().tzinfo
 

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/cli/import_refs.py

@@ -127,6 +127,7 @@ class AutoRunPriority:
 
 def list_cli_commands(
     module_members: dict[str, typing.Any],
+    include_service_functions: bool = False,
 ) -> list[CLICommand]:
     """
     Extracts all runnables found either directly in the input module, or in any of the Apps listed in that module
@@ -149,8 +150,8 @@ def list_cli_commands(
             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():
-                continue  # Skip class and server service functions since they don't have associated cli commands
+            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():
@@ -322,7 +323,12 @@ def _get_runnable_app(runnable: Runnable) -> App:
 
 
 def import_and_filter(
-    import_ref: ImportRef, *, base_cmd: str, accept_local_entrypoint=True, accept_webhook=False
+    import_ref: ImportRef,
+    *,
+    base_cmd: str,
+    accept_local_entrypoint=True,
+    accept_webhook=False,
+    accept_service_functions=False,
 ) -> tuple[Optional[Runnable], list[CLICommand]]:
     """Takes a function ref string and returns a single determined "runnable" to use, and a list of all available
     runnables.
@@ -339,7 +345,10 @@ def import_and_filter(
     """
     # all commands:
     module = import_file_or_module(import_ref, base_cmd)
-    cli_commands = list_cli_commands(dict(inspect.getmembers(module)))
+    cli_commands = list_cli_commands(
+        dict(inspect.getmembers(module)),
+        include_service_functions=accept_service_functions,
+    )
 
     # all commands that satisfy local entrypoint/accept webhook limitations AND object path prefix
 

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/cli/shell.py

@@ -142,7 +142,11 @@ def _start_shell_in_running_container(ref: str, cmd: str, pty: bool) -> None:
 def _function_spec_from_ref(ref: str, use_module_mode: bool) -> _FunctionSpec:
     import_ref = parse_import_ref(ref, use_module_mode=use_module_mode)
     runnable, all_usable_commands = import_and_filter(
-        import_ref, base_cmd="modal shell", accept_local_entrypoint=False, accept_webhook=True
+        import_ref,
+        base_cmd="modal shell",
+        accept_local_entrypoint=False,
+        accept_webhook=True,
+        accept_service_functions=True,
     )
     if not runnable:
         help_header = (

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/client.py

@@ -56,8 +56,7 @@ def _get_metadata(client_type: int, credentials: Optional[tuple[str, str]], vers
                 "x-modal-token-secret": token_secret,
             }
         )
-    agent_env = _agent_environment()
-    if agent_env:
+    if agent_env := _agent_environment():
         metadata["x-modal-agent-harness"] = urllib.parse.quote(agent_env)
     return metadata
 

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/client.pyi

@@ -35,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.4.1.dev4",
+        version: str = "1.4.2.dev0",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -171,7 +171,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.4.1.dev4",
+        version: str = "1.4.2.dev0",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/dict.py

@@ -298,7 +298,8 @@ class _Dict(_Object, type_prefix="di"):
         )
 
     @classproperty
-    def objects(cls) -> _DictManager:
+    @classmethod
+    def objects(cls) -> type[_DictManager]:
         return _DictManager
 
     @property

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/dict.pyi

@@ -412,7 +412,8 @@ class _Dict(modal._object._Object):
         ...
 
     @synchronicity.classproperty
-    def objects(cls) -> _DictManager: ...
+    @classmethod
+    def objects(cls) -> type[_DictManager]: ...
     @property
     def name(self) -> typing.Optional[str]: ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
@@ -653,7 +654,8 @@ class Dict(modal.object.Object):
         ...
 
     @synchronicity.classproperty
-    def objects(cls) -> DictManager: ...
+    @classmethod
+    def objects(cls) -> type[DictManager]: ...
     @property
     def name(self) -> typing.Optional[str]: ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/exception.py

@@ -351,6 +351,12 @@ class SandboxFilesystemNotFoundError(SandboxFilesystemError):
     pass
 
 
+class SandboxFilesystemDirectoryNotEmptyError(SandboxFilesystemError):
+    """Raised when a directory is not empty."""
+
+    pass
+
+
 class SandboxFilesystemIsADirectoryError(SandboxFilesystemError):
     """Raised when a file operation in the sandbox targets a directory when it should target a non-directory file."""
 

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/queue.py

@@ -291,7 +291,8 @@ class _Queue(_Object, type_prefix="qu"):
         raise RuntimeError("Queue() is not allowed. Please use `Queue.from_name(...)` or `Queue.ephemeral()` instead.")
 
     @classproperty
-    def objects(cls) -> _QueueManager:
+    @classmethod
+    def objects(cls) -> type[_QueueManager]:
         return _QueueManager
 
     @property

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/queue.pyi

@@ -431,7 +431,8 @@ class _Queue(modal._object._Object):
         ...
 
     @synchronicity.classproperty
-    def objects(cls) -> _QueueManager: ...
+    @classmethod
+    def objects(cls) -> type[_QueueManager]: ...
     @property
     def name(self) -> typing.Optional[str]: ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
@@ -726,7 +727,8 @@ class Queue(modal.object.Object):
         ...
 
     @synchronicity.classproperty
-    def objects(cls) -> QueueManager: ...
+    @classmethod
+    def objects(cls) -> type[QueueManager]: ...
     @property
     def name(self) -> typing.Optional[str]: ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/sandbox.py

@@ -123,24 +123,25 @@ class SandboxConnectCredentials:
 class Probe:
     """Probe configuration for the Sandbox Readiness Probe.
 
-    Usage:
-        ```py notest
-        # Wait until a file exists.
-        readiness_probe = modal.Probe.with_exec(
-            "sh", "-c", "test -f /tmp/ready",
-        )
-
-        # Wait until a TCP port is accepting connections.
-        readiness_probe = modal.Probe.with_tcp(8080)
-
-        app = modal.App.lookup('sandbox-readiness-probe', create_if_missing=True)
-        sandbox = modal.Sandbox.create(
-            "python3", "-m", "http.server", "8080",
-            readiness_probe=readiness_probe,
-            app=app,
-        )
-        sandbox.wait_until_ready()
-        ```
+    **Usage**
+
+    ```python notest
+    # Wait until a file exists.
+    readiness_probe = modal.Probe.with_exec(
+        "sh", "-c", "test -f /tmp/ready",
+    )
+
+    # Wait until a TCP port is accepting connections.
+    readiness_probe = modal.Probe.with_tcp(8080)
+
+    app = modal.App.lookup('sandbox-readiness-probe', create_if_missing=True)
+    sandbox = modal.Sandbox.create(
+        "python3", "-m", "http.server", "8080",
+        readiness_probe=readiness_probe,
+        app=app,
+    )
+    sandbox.wait_until_ready()
+    ```
     """
 
     tcp_port: Optional[int] = None

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/sandbox.pyi

@@ -74,24 +74,25 @@ class SandboxConnectCredentials:
 class Probe:
     """Probe configuration for the Sandbox Readiness Probe.
 
-    Usage:
-        ```py notest
-        # Wait until a file exists.
-        readiness_probe = modal.Probe.with_exec(
-            "sh", "-c", "test -f /tmp/ready",
-        )
-
-        # Wait until a TCP port is accepting connections.
-        readiness_probe = modal.Probe.with_tcp(8080)
-
-        app = modal.App.lookup('sandbox-readiness-probe', create_if_missing=True)
-        sandbox = modal.Sandbox.create(
-            "python3", "-m", "http.server", "8080",
-            readiness_probe=readiness_probe,
-            app=app,
-        )
-        sandbox.wait_until_ready()
-        ```
+    **Usage**
+
+    ```python notest
+    # Wait until a file exists.
+    readiness_probe = modal.Probe.with_exec(
+        "sh", "-c", "test -f /tmp/ready",
+    )
+
+    # Wait until a TCP port is accepting connections.
+    readiness_probe = modal.Probe.with_tcp(8080)
+
+    app = modal.App.lookup('sandbox-readiness-probe', create_if_missing=True)
+    sandbox = modal.Sandbox.create(
+        "python3", "-m", "http.server", "8080",
+        readiness_probe=readiness_probe,
+        app=app,
+    )
+    sandbox.wait_until_ready()
+    ```
     """
 
     tcp_port: typing.Optional[int]

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/sandbox_fs.py

@@ -12,8 +12,10 @@ from ._utils.async_utils import synchronize_api
 from ._utils.logger import logger
 from ._utils.sandbox_fs_utils import (
     make_read_file_command,
+    make_remove_command,
     make_write_file_command,
     raise_read_file_error,
+    raise_remove_error,
     raise_write_file_error,
     translate_exec_errors,
     validate_absolute_remote_path,
@@ -303,5 +305,51 @@ class _SandboxFilesystem:
         dur_s = max(time.monotonic() - t0, 0.001)
         _log_throughput(f"copy_from_local {local_path} -> {remote_path}", total_bytes, dur_s)
 
+    async def remove(self, remote_path: str, *, recursive: bool = False) -> None:
+        """Remove a file or directory in the Sandbox.
+
+        `remote_path` must be an absolute path in the Sandbox.
+
+        When `remote_path` is a directory and `recursive` is `False` (the
+        default), removes it only if it is empty. When `recursive` is `True`,
+        removes the directory and all its contents.
+
+        Recursive directory removal is not supported on all mounts.
+        In particular, `CloudBucketMount` does not support it. An
+        `InvalidError` is raised in that case.
+
+        **Raises**
+
+        - `SandboxFilesystemNotFoundError`: the path does not exist.
+        - `SandboxFilesystemDirectoryNotEmptyError`: `recursive` is `False` and the directory is not empty.
+        - `SandboxFilesystemPermissionError`: removal is not permitted.
+        - `InvalidError`: the operation is not supported by the mount.
+        - `SandboxFilesystemError`: the command fails for any other reason.
+
+        **Usage**
+
+        To remove a file:
+
+        ```python fixture:sandbox
+        sandbox.filesystem.write_bytes(b"Hello, world!\\n", "/tmp/hello.bin")
+        sandbox.filesystem.remove("/tmp/hello.bin")
+        ```
+
+        To remove a directory and all its contents:
+
+        ```python fixture:sandbox
+        sandbox.exec("mkdir", "-p", "/tmp/mydir/subdir").wait()
+        sandbox.filesystem.remove("/tmp/mydir", recursive=True)
+        ```
+        """
+        validate_absolute_remote_path(remote_path, "remove")
+
+        with translate_exec_errors("remove", remote_path):
+            process = await self._sandbox.exec(_SANDBOX_FS_TOOLS_PATH, make_remove_command(remote_path, recursive))
+            stderr, returncode = await asyncio.gather(process.stderr.read(), process.wait())
+
+        if returncode != 0:
+            raise_remove_error(returncode, stderr, remote_path)
+
 
 SandboxFilesystem = synchronize_api(_SandboxFilesystem)

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/sandbox_fs.pyi

@@ -168,6 +168,45 @@ class _SandboxFilesystem:
         """
         ...
 
+    async def remove(self, remote_path: str, *, recursive: bool = False) -> None:
+        """Remove a file or directory in the Sandbox.
+
+        `remote_path` must be an absolute path in the Sandbox.
+
+        When `remote_path` is a directory and `recursive` is `False` (the
+        default), removes it only if it is empty. When `recursive` is `True`,
+        removes the directory and all its contents.
+
+        Recursive directory removal is not supported on all mounts.
+        In particular, `CloudBucketMount` does not support it. An
+        `InvalidError` is raised in that case.
+
+        **Raises**
+
+        - `SandboxFilesystemNotFoundError`: the path does not exist.
+        - `SandboxFilesystemDirectoryNotEmptyError`: `recursive` is `False` and the directory is not empty.
+        - `SandboxFilesystemPermissionError`: removal is not permitted.
+        - `InvalidError`: the operation is not supported by the mount.
+        - `SandboxFilesystemError`: the command fails for any other reason.
+
+        **Usage**
+
+        To remove a file:
+
+        ```python fixture:sandbox
+        sandbox.filesystem.write_bytes(b"Hello, world!\n", "/tmp/hello.bin")
+        sandbox.filesystem.remove("/tmp/hello.bin")
+        ```
+
+        To remove a directory and all its contents:
+
+        ```python fixture:sandbox
+        sandbox.exec("mkdir", "-p", "/tmp/mydir/subdir").wait()
+        sandbox.filesystem.remove("/tmp/mydir", recursive=True)
+        ```
+        """
+        ...
+
 class SandboxFilesystem:
     """mdmd:namespace
     Namespace for Sandbox filesystem APIs.
@@ -505,3 +544,84 @@ class SandboxFilesystem:
             ...
 
     copy_from_local: __copy_from_local_spec
+
+    class __remove_spec(typing_extensions.Protocol):
+        def __call__(self, /, remote_path: str, *, recursive: bool = False) -> None:
+            """Remove a file or directory in the Sandbox.
+
+            `remote_path` must be an absolute path in the Sandbox.
+
+            When `remote_path` is a directory and `recursive` is `False` (the
+            default), removes it only if it is empty. When `recursive` is `True`,
+            removes the directory and all its contents.
+
+            Recursive directory removal is not supported on all mounts.
+            In particular, `CloudBucketMount` does not support it. An
+            `InvalidError` is raised in that case.
+
+            **Raises**
+
+            - `SandboxFilesystemNotFoundError`: the path does not exist.
+            - `SandboxFilesystemDirectoryNotEmptyError`: `recursive` is `False` and the directory is not empty.
+            - `SandboxFilesystemPermissionError`: removal is not permitted.
+            - `InvalidError`: the operation is not supported by the mount.
+            - `SandboxFilesystemError`: the command fails for any other reason.
+
+            **Usage**
+
+            To remove a file:
+
+            ```python fixture:sandbox
+            sandbox.filesystem.write_bytes(b"Hello, world!\n", "/tmp/hello.bin")
+            sandbox.filesystem.remove("/tmp/hello.bin")
+            ```
+
+            To remove a directory and all its contents:
+
+            ```python fixture:sandbox
+            sandbox.exec("mkdir", "-p", "/tmp/mydir/subdir").wait()
+            sandbox.filesystem.remove("/tmp/mydir", recursive=True)
+            ```
+            """
+            ...
+
+        async def aio(self, /, remote_path: str, *, recursive: bool = False) -> None:
+            """Remove a file or directory in the Sandbox.
+
+            `remote_path` must be an absolute path in the Sandbox.
+
+            When `remote_path` is a directory and `recursive` is `False` (the
+            default), removes it only if it is empty. When `recursive` is `True`,
+            removes the directory and all its contents.
+
+            Recursive directory removal is not supported on all mounts.
+            In particular, `CloudBucketMount` does not support it. An
+            `InvalidError` is raised in that case.
+
+            **Raises**
+
+            - `SandboxFilesystemNotFoundError`: the path does not exist.
+            - `SandboxFilesystemDirectoryNotEmptyError`: `recursive` is `False` and the directory is not empty.
+            - `SandboxFilesystemPermissionError`: removal is not permitted.
+            - `InvalidError`: the operation is not supported by the mount.
+            - `SandboxFilesystemError`: the command fails for any other reason.
+
+            **Usage**
+
+            To remove a file:
+
+            ```python fixture:sandbox
+            sandbox.filesystem.write_bytes(b"Hello, world!\n", "/tmp/hello.bin")
+            sandbox.filesystem.remove("/tmp/hello.bin")
+            ```
+
+            To remove a directory and all its contents:
+
+            ```python fixture:sandbox
+            sandbox.exec("mkdir", "-p", "/tmp/mydir/subdir").wait()
+            sandbox.filesystem.remove("/tmp/mydir", recursive=True)
+            ```
+            """
+            ...
+
+    remove: __remove_spec

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/secret.py

@@ -237,7 +237,8 @@ class _Secret(_Object, type_prefix="st"):
     _metadata: Optional[api_pb2.SecretMetadata] = None
 
     @classproperty
-    def objects(cls) -> _SecretManager:
+    @classmethod
+    def objects(cls) -> type[_SecretManager]:
         return _SecretManager
 
     @property

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/secret.pyi

@@ -375,7 +375,8 @@ class _Secret(modal._object._Object):
     _metadata: typing.Optional[modal_proto.api_pb2.SecretMetadata]
 
     @synchronicity.classproperty
-    def objects(cls) -> _SecretManager: ...
+    @classmethod
+    def objects(cls) -> type[_SecretManager]: ...
     @property
     def name(self) -> typing.Optional[str]: ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
@@ -500,7 +501,8 @@ class Secret(modal.object.Object):
         ...
 
     @synchronicity.classproperty
-    def objects(cls) -> SecretManager: ...
+    @classmethod
+    def objects(cls) -> type[SecretManager]: ...
     @property
     def name(self) -> typing.Optional[str]: ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/volume.py

@@ -358,7 +358,8 @@ class _Volume(_Object, type_prefix="vo"):
     _read_only: bool = False
 
     @classproperty
-    def objects(cls) -> _VolumeManager:
+    @classmethod
+    def objects(cls) -> type[_VolumeManager]:
         return _VolumeManager
 
     @property

{modal-1.4.1.dev4 → modal-1.4.2.dev0}/modal/volume.pyi

@@ -454,7 +454,8 @@ class _Volume(modal._object._Object):
     _read_only: bool
 
     @synchronicity.classproperty
-    def objects(cls) -> _VolumeManager: ...
+    @classmethod
+    def objects(cls) -> type[_VolumeManager]: ...
     @property
     def name(self) -> typing.Optional[str]: ...
     def read_only(self) -> _Volume:
@@ -789,7 +790,8 @@ class Volume(modal.object.Object):
         ...
 
     @synchronicity.classproperty
-    def objects(cls) -> VolumeManager: ...
+    @classmethod
+    def objects(cls) -> type[VolumeManager]: ...
     @property
     def name(self) -> typing.Optional[str]: ...
     def read_only(self) -> Volume: