modal 1.0.6.dev58__py3-none-any.whl → 1.2.3.dev7__py3-none-any.whl

modal/secret.pyi

@@ -1,9 +1,367 @@
+import datetime
+import google.protobuf.message
+import modal._load_context
 import modal._object
 import modal.client
 import modal.object
+import modal_proto.api_pb2
+import synchronicity
 import typing
 import typing_extensions
 
+class SecretInfo:
+    """Information about the Secret object."""
+
+    name: typing.Optional[str]
+    created_at: datetime.datetime
+    created_by: typing.Optional[str]
+
+    def __init__(
+        self, name: typing.Optional[str], created_at: datetime.datetime, created_by: typing.Optional[str]
+    ) -> None:
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def __repr__(self):
+        """Return repr(self)."""
+        ...
+
+    def __eq__(self, other):
+        """Return self==value."""
+        ...
+
+class _SecretManager:
+    """Namespace with methods for managing named Secret objects."""
+    @staticmethod
+    async def create(
+        name: str,
+        env_dict: dict[str, str],
+        *,
+        allow_existing: bool = False,
+        environment_name: typing.Optional[str] = None,
+        client: typing.Optional[modal.client._Client] = None,
+    ) -> None:
+        """Create a new Secret object.
+
+        **Examples:**
+
+        ```python notest
+        contents = {"MY_KEY": "my-value", "MY_OTHER_KEY": "my-other-value"}
+        modal.Secret.objects.create("my-secret", contents)
+        ```
+
+        Secrets will be created in the active environment, or another one can be specified:
+
+        ```python notest
+        modal.Secret.objects.create("my-secret", contents, environment_name="dev")
+        ```
+
+        By default, an error will be raised if the Secret already exists, but passing
+        `allow_existing=True` will make the creation attempt a no-op in this case.
+        If the `env_dict` data differs from the existing Secret, it will be ignored.
+
+        ```python notest
+        modal.Secret.objects.create("my-secret", contents, allow_existing=True)
+        ```
+
+        Note that this method does not return a local instance of the Secret. You can use
+        `modal.Secret.from_name` to perform a lookup after creation.
+
+        Added in v1.1.2.
+        """
+        ...
+
+    @staticmethod
+    async def list(
+        *,
+        max_objects: typing.Optional[int] = None,
+        created_before: typing.Union[datetime.datetime, str, None] = None,
+        environment_name: str = "",
+        client: typing.Optional[modal.client._Client] = None,
+    ) -> list[_Secret]:
+        """Return a list of hydrated Secret objects.
+
+        **Examples:**
+
+        ```python
+        secrets = modal.Secret.objects.list()
+        print([s.name for s in secrets])
+        ```
+
+        Secrets will be retreived from the active environment, or another one can be specified:
+
+        ```python notest
+        dev_secrets = modal.Secret.objects.list(environment_name="dev")
+        ```
+
+        By default, all named Secrets are returned, newest to oldest. It's also possible to limit the
+        number of results and to filter by creation date:
+
+        ```python
+        secrets = modal.Secret.objects.list(max_objects=10, created_before="2025-01-01")
+        ```
+
+        Added in v1.1.2.
+        """
+        ...
+
+    @staticmethod
+    async def delete(
+        name: str,
+        *,
+        allow_missing: bool = False,
+        environment_name: typing.Optional[str] = None,
+        client: typing.Optional[modal.client._Client] = None,
+    ):
+        """Delete a named Secret.
+
+        Warning: Deletion is irreversible and will affect any Apps currently using the Secret.
+
+        **Examples:**
+
+        ```python notest
+        await modal.Secret.objects.delete("my-secret")
+        ```
+
+        Secrets will be deleted from the active environment, or another one can be specified:
+
+        ```python notest
+        await modal.Secret.objects.delete("my-secret", environment_name="dev")
+        ```
+
+        Added in v1.1.2.
+        """
+        ...
+
+class SecretManager:
+    """Namespace with methods for managing named Secret objects."""
+    def __init__(self, /, *args, **kwargs):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    class __create_spec(typing_extensions.Protocol):
+        def __call__(
+            self,
+            /,
+            name: str,
+            env_dict: dict[str, str],
+            *,
+            allow_existing: bool = False,
+            environment_name: typing.Optional[str] = None,
+            client: typing.Optional[modal.client.Client] = None,
+        ) -> None:
+            """Create a new Secret object.
+
+            **Examples:**
+
+            ```python notest
+            contents = {"MY_KEY": "my-value", "MY_OTHER_KEY": "my-other-value"}
+            modal.Secret.objects.create("my-secret", contents)
+            ```
+
+            Secrets will be created in the active environment, or another one can be specified:
+
+            ```python notest
+            modal.Secret.objects.create("my-secret", contents, environment_name="dev")
+            ```
+
+            By default, an error will be raised if the Secret already exists, but passing
+            `allow_existing=True` will make the creation attempt a no-op in this case.
+            If the `env_dict` data differs from the existing Secret, it will be ignored.
+
+            ```python notest
+            modal.Secret.objects.create("my-secret", contents, allow_existing=True)
+            ```
+
+            Note that this method does not return a local instance of the Secret. You can use
+            `modal.Secret.from_name` to perform a lookup after creation.
+
+            Added in v1.1.2.
+            """
+            ...
+
+        async def aio(
+            self,
+            /,
+            name: str,
+            env_dict: dict[str, str],
+            *,
+            allow_existing: bool = False,
+            environment_name: typing.Optional[str] = None,
+            client: typing.Optional[modal.client.Client] = None,
+        ) -> None:
+            """Create a new Secret object.
+
+            **Examples:**
+
+            ```python notest
+            contents = {"MY_KEY": "my-value", "MY_OTHER_KEY": "my-other-value"}
+            modal.Secret.objects.create("my-secret", contents)
+            ```
+
+            Secrets will be created in the active environment, or another one can be specified:
+
+            ```python notest
+            modal.Secret.objects.create("my-secret", contents, environment_name="dev")
+            ```
+
+            By default, an error will be raised if the Secret already exists, but passing
+            `allow_existing=True` will make the creation attempt a no-op in this case.
+            If the `env_dict` data differs from the existing Secret, it will be ignored.
+
+            ```python notest
+            modal.Secret.objects.create("my-secret", contents, allow_existing=True)
+            ```
+
+            Note that this method does not return a local instance of the Secret. You can use
+            `modal.Secret.from_name` to perform a lookup after creation.
+
+            Added in v1.1.2.
+            """
+            ...
+
+    create: __create_spec
+
+    class __list_spec(typing_extensions.Protocol):
+        def __call__(
+            self,
+            /,
+            *,
+            max_objects: typing.Optional[int] = None,
+            created_before: typing.Union[datetime.datetime, str, None] = None,
+            environment_name: str = "",
+            client: typing.Optional[modal.client.Client] = None,
+        ) -> list[Secret]:
+            """Return a list of hydrated Secret objects.
+
+            **Examples:**
+
+            ```python
+            secrets = modal.Secret.objects.list()
+            print([s.name for s in secrets])
+            ```
+
+            Secrets will be retreived from the active environment, or another one can be specified:
+
+            ```python notest
+            dev_secrets = modal.Secret.objects.list(environment_name="dev")
+            ```
+
+            By default, all named Secrets are returned, newest to oldest. It's also possible to limit the
+            number of results and to filter by creation date:
+
+            ```python
+            secrets = modal.Secret.objects.list(max_objects=10, created_before="2025-01-01")
+            ```
+
+            Added in v1.1.2.
+            """
+            ...
+
+        async def aio(
+            self,
+            /,
+            *,
+            max_objects: typing.Optional[int] = None,
+            created_before: typing.Union[datetime.datetime, str, None] = None,
+            environment_name: str = "",
+            client: typing.Optional[modal.client.Client] = None,
+        ) -> list[Secret]:
+            """Return a list of hydrated Secret objects.
+
+            **Examples:**
+
+            ```python
+            secrets = modal.Secret.objects.list()
+            print([s.name for s in secrets])
+            ```
+
+            Secrets will be retreived from the active environment, or another one can be specified:
+
+            ```python notest
+            dev_secrets = modal.Secret.objects.list(environment_name="dev")
+            ```
+
+            By default, all named Secrets are returned, newest to oldest. It's also possible to limit the
+            number of results and to filter by creation date:
+
+            ```python
+            secrets = modal.Secret.objects.list(max_objects=10, created_before="2025-01-01")
+            ```
+
+            Added in v1.1.2.
+            """
+            ...
+
+    list: __list_spec
+
+    class __delete_spec(typing_extensions.Protocol):
+        def __call__(
+            self,
+            /,
+            name: str,
+            *,
+            allow_missing: bool = False,
+            environment_name: typing.Optional[str] = None,
+            client: typing.Optional[modal.client.Client] = None,
+        ):
+            """Delete a named Secret.
+
+            Warning: Deletion is irreversible and will affect any Apps currently using the Secret.
+
+            **Examples:**
+
+            ```python notest
+            await modal.Secret.objects.delete("my-secret")
+            ```
+
+            Secrets will be deleted from the active environment, or another one can be specified:
+
+            ```python notest
+            await modal.Secret.objects.delete("my-secret", environment_name="dev")
+            ```
+
+            Added in v1.1.2.
+            """
+            ...
+
+        async def aio(
+            self,
+            /,
+            name: str,
+            *,
+            allow_missing: bool = False,
+            environment_name: typing.Optional[str] = None,
+            client: typing.Optional[modal.client.Client] = None,
+        ):
+            """Delete a named Secret.
+
+            Warning: Deletion is irreversible and will affect any Apps currently using the Secret.
+
+            **Examples:**
+
+            ```python notest
+            await modal.Secret.objects.delete("my-secret")
+            ```
+
+            Secrets will be deleted from the active environment, or another one can be specified:
+
+            ```python notest
+            await modal.Secret.objects.delete("my-secret", environment_name="dev")
+            ```
+
+            Added in v1.1.2.
+            """
+            ...
+
+    delete: __delete_spec
+
+async def _load_from_env_dict(
+    instance: _Secret, load_context: modal._load_context.LoadContext, env_dict: dict[str, str]
+):
+    """helper method for loaders .from_dict and .from_dotenv etc."""
+    ...
+
 class _Secret(modal._object._Object):
     """Secrets provide a dictionary of environment variables for images.
 
@@ -13,6 +371,15 @@ class _Secret(modal._object._Object):
 
     See [the secrets guide page](https://modal.com/docs/guide/secrets) for more information.
     """
+
+    _metadata: typing.Optional[modal_proto.api_pb2.SecretMetadata]
+
+    @synchronicity.classproperty
+    def objects(cls) -> _SecretManager: ...
+    @property
+    def name(self) -> typing.Optional[str]: ...
+    def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
+    def _get_metadata(self) -> modal_proto.api_pb2.SecretMetadata: ...
     @staticmethod
     def from_dict(env_dict: dict[str, typing.Optional[str]] = {}) -> _Secret:
         """Create a secret from a str-str dictionary. Values can also be `None`, which is ignored.
@@ -32,7 +399,7 @@ class _Secret(modal._object._Object):
         ...
 
     @staticmethod
-    def from_dotenv(path=None, *, filename=".env") -> _Secret:
+    def from_dotenv(path=None, *, filename=".env", client: typing.Optional[modal.client._Client] = None) -> _Secret:
         """Create secrets from a .env file automatically.
 
         If no argument is provided, it will use the current working directory as the starting
@@ -63,7 +430,12 @@ class _Secret(modal._object._Object):
 
     @staticmethod
     def from_name(
-        name: str, *, namespace=None, environment_name: typing.Optional[str] = None, required_keys: list[str] = []
+        name: str,
+        *,
+        namespace=None,
+        environment_name: typing.Optional[str] = None,
+        required_keys: list[str] = [],
+        client: typing.Optional[modal.client._Client] = None,
     ) -> _Secret:
         """Reference a Secret by its name.
 
@@ -82,18 +454,19 @@ class _Secret(modal._object._Object):
         ...
 
     @staticmethod
-    async def lookup(
-        name: str,
+    async def create_deployed(
+        deployment_name: str,
+        env_dict: dict[str, str],
         namespace=None,
         client: typing.Optional[modal.client._Client] = None,
         environment_name: typing.Optional[str] = None,
-        required_keys: list[str] = [],
-    ) -> _Secret:
+        overwrite: bool = False,
+    ) -> str:
         """mdmd:hidden"""
         ...
 
     @staticmethod
-    async def create_deployed(
+    async def _create_deployed(
         deployment_name: str,
         env_dict: dict[str, str],
         namespace=None,
@@ -104,6 +477,12 @@ class _Secret(modal._object._Object):
         """mdmd:hidden"""
         ...
 
+    async def info(self) -> SecretInfo:
+        """Return information about the Secret object."""
+        ...
+
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class Secret(modal.object.Object):
     """Secrets provide a dictionary of environment variables for images.
 
@@ -113,10 +492,19 @@ class Secret(modal.object.Object):
 
     See [the secrets guide page](https://modal.com/docs/guide/secrets) for more information.
     """
+
+    _metadata: typing.Optional[modal_proto.api_pb2.SecretMetadata]
+
     def __init__(self, *args, **kwargs):
         """mdmd:hidden"""
         ...
 
+    @synchronicity.classproperty
+    def objects(cls) -> SecretManager: ...
+    @property
+    def name(self) -> typing.Optional[str]: ...
+    def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
+    def _get_metadata(self) -> modal_proto.api_pb2.SecretMetadata: ...
     @staticmethod
     def from_dict(env_dict: dict[str, typing.Optional[str]] = {}) -> Secret:
         """Create a secret from a str-str dictionary. Values can also be `None`, which is ignored.
@@ -136,7 +524,7 @@ class Secret(modal.object.Object):
         ...
 
     @staticmethod
-    def from_dotenv(path=None, *, filename=".env") -> Secret:
+    def from_dotenv(path=None, *, filename=".env", client: typing.Optional[modal.client.Client] = None) -> Secret:
         """Create secrets from a .env file automatically.
 
         If no argument is provided, it will use the current working directory as the starting
@@ -167,7 +555,12 @@ class Secret(modal.object.Object):
 
     @staticmethod
     def from_name(
-        name: str, *, namespace=None, environment_name: typing.Optional[str] = None, required_keys: list[str] = []
+        name: str,
+        *,
+        namespace=None,
+        environment_name: typing.Optional[str] = None,
+        required_keys: list[str] = [],
+        client: typing.Optional[modal.client.Client] = None,
     ) -> Secret:
         """Reference a Secret by its name.
 
@@ -185,34 +578,36 @@ class Secret(modal.object.Object):
         """
         ...
 
-    class __lookup_spec(typing_extensions.Protocol):
+    class __create_deployed_spec(typing_extensions.Protocol):
         def __call__(
             self,
             /,
-            name: str,
+            deployment_name: str,
+            env_dict: dict[str, str],
             namespace=None,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
-            required_keys: list[str] = [],
-        ) -> Secret:
+            overwrite: bool = False,
+        ) -> str:
             """mdmd:hidden"""
             ...
 
         async def aio(
             self,
             /,
-            name: str,
+            deployment_name: str,
+            env_dict: dict[str, str],
             namespace=None,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
-            required_keys: list[str] = [],
-        ) -> Secret:
+            overwrite: bool = False,
+        ) -> str:
             """mdmd:hidden"""
             ...
 
-    lookup: __lookup_spec
+    create_deployed: __create_deployed_spec
 
-    class __create_deployed_spec(typing_extensions.Protocol):
+    class ___create_deployed_spec(typing_extensions.Protocol):
         def __call__(
             self,
             /,
@@ -239,4 +634,15 @@ class Secret(modal.object.Object):
             """mdmd:hidden"""
             ...
 
-    create_deployed: __create_deployed_spec
+    _create_deployed: ___create_deployed_spec
+
+    class __info_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /) -> SecretInfo:
+            """Return information about the Secret object."""
+            ...
+
+        async def aio(self, /) -> SecretInfo:
+            """Return information about the Secret object."""
+            ...
+
+    info: __info_spec[typing_extensions.Self]

modal/serving.py

@@ -4,13 +4,13 @@ import platform
 from collections.abc import AsyncGenerator
 from multiprocessing.context import SpawnProcess
 from multiprocessing.synchronize import Event
-from typing import TYPE_CHECKING, Optional, TypeVar
+from typing import TYPE_CHECKING, Optional
 
 from synchronicity.async_wrap import asynccontextmanager
 
 from modal._output import OutputManager
 
-from ._utils.async_utils import TaskContext, asyncify, synchronize_api, synchronizer
+from ._utils.async_utils import TaskContext, asyncify, synchronize_api
 from ._utils.logger import logger
 from ._watcher import watch
 from .cli.import_refs import ImportRef, import_app_from_ref
@@ -20,20 +20,16 @@ from .output import _get_output_manager, enable_output
 from .runner import _run_app, serve_update
 
 if TYPE_CHECKING:
-    from .app import _App
-else:
-    _App = TypeVar("_App")
+    import modal.app
 
 
 def _run_serve(
     import_ref: ImportRef, existing_app_id: str, is_ready: Event, environment_name: str, show_progress: bool
 ):
-    # subprocess entrypoint
-    _app = import_app_from_ref(import_ref, base_cmd="modal serve")
-    blocking_app = synchronizer._translate_out(_app)
+    app = import_app_from_ref(import_ref, base_cmd="modal serve")
 
     with enable_output(show_progress=show_progress):
-        serve_update(blocking_app, existing_app_id, is_ready, environment_name)
+        serve_update(app, existing_app_id, is_ready, environment_name)
 
 
 async def _restart_serve(
@@ -97,12 +93,12 @@ async def _run_watch_loop(
 
 @asynccontextmanager
 async def _serve_app(
-    app: "_App",
+    app: "modal.app._App",
     import_ref: ImportRef,
     *,
     _watcher: Optional[AsyncGenerator[set[str], None]] = None,  # for testing
     environment_name: Optional[str] = None,
-) -> AsyncGenerator["_App", None]:
+) -> AsyncGenerator["modal.app._App", None]:
     if environment_name is None:
         environment_name = config.get("environment")
 

modal/serving.pyi

@@ -1,4 +1,5 @@
 import collections.abc
+import modal.app
 import modal.cli.import_refs
 import multiprocessing.context
 import multiprocessing.synchronize
@@ -6,8 +7,6 @@ import synchronicity.combined_types
 import typing
 import typing_extensions
 
-_App = typing.TypeVar("_App")
-
 def _run_serve(
     import_ref: modal.cli.import_refs.ImportRef,
     existing_app_id: str,
@@ -27,31 +26,31 @@ async def _run_watch_loop(
     environment_name: str,
 ): ...
 def _serve_app(
-    app: _App,
+    app: modal.app._App,
     import_ref: modal.cli.import_refs.ImportRef,
     *,
     _watcher: typing.Optional[collections.abc.AsyncGenerator[set[str], None]] = None,
     environment_name: typing.Optional[str] = None,
-) -> typing.AsyncContextManager[_App]: ...
+) -> typing.AsyncContextManager[modal.app._App]: ...
 
 class __serve_app_spec(typing_extensions.Protocol):
     def __call__(
         self,
         /,
-        app: _App,
+        app: modal.app.App,
         import_ref: modal.cli.import_refs.ImportRef,
         *,
         _watcher: typing.Optional[typing.Generator[set[str], None, None]] = None,
         environment_name: typing.Optional[str] = None,
-    ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[_App]: ...
+    ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[modal.app.App]: ...
     def aio(
         self,
         /,
-        app: _App,
+        app: modal.app.App,
         import_ref: modal.cli.import_refs.ImportRef,
         *,
         _watcher: typing.Optional[collections.abc.AsyncGenerator[set[str], None]] = None,
         environment_name: typing.Optional[str] = None,
-    ) -> typing.AsyncContextManager[_App]: ...
+    ) -> typing.AsyncContextManager[modal.app.App]: ...
 
 serve_app: __serve_app_spec

modal/snapshot.py

@@ -3,10 +3,10 @@ from typing import Optional
 
 from modal_proto import api_pb2
 
+from ._load_context import LoadContext
 from ._object import _Object
 from ._resolver import Resolver
 from ._utils.async_utils import synchronize_api
-from ._utils.grpc_utils import retry_transient_errors
 from .client import _Client
 
 
@@ -24,16 +24,19 @@ class _SandboxSnapshot(_Object, type_prefix="sn"):
         """
         Construct a `SandboxSnapshot` object from a sandbox snapshot ID.
         """
-        if client is None:
-            client = await _Client.from_env()
-
-        async def _load(self: _SandboxSnapshot, resolver: Resolver, existing_object_id: Optional[str]):
-            await retry_transient_errors(
-                client.stub.SandboxSnapshotGet, api_pb2.SandboxSnapshotGetRequest(snapshot_id=sandbox_snapshot_id)
+        # TODO: remove this - from_id constructor should not do io:
+        client = client or await _Client.from_env()
+
+        async def _load(
+            self: _SandboxSnapshot, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
+            await load_context.client.stub.SandboxSnapshotGet(
+                api_pb2.SandboxSnapshotGetRequest(snapshot_id=sandbox_snapshot_id)
             )
 
         rep = "SandboxSnapshot()"
-        obj = _SandboxSnapshot._from_loader(_load, rep)
+        obj = _SandboxSnapshot._from_loader(_load, rep, load_context_overrides=LoadContext(client=client))
+        # TODO: should this be a _Object._new_hydrated instead?
         obj._hydrate(sandbox_snapshot_id, client, None)
 
         return obj