modal 1.1.2.dev28__tar.gz → 1.1.2.dev29__tar.gz

{modal-1.1.2.dev28 → modal-1.1.2.dev29}/PKG-INFO

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

{modal-1.1.2.dev28 → modal-1.1.2.dev29}/modal/client.pyi

@@ -33,7 +33,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.1.2.dev28",
+        version: str = "1.1.2.dev29",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -164,7 +164,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.1.2.dev28",
+        version: str = "1.1.2.dev29",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.1.2.dev28 → modal-1.1.2.dev29}/modal/dict.py

@@ -5,7 +5,7 @@ from datetime import datetime
 from typing import Any, Optional, Union
 
 from google.protobuf.message import Message
-from grpclib import GRPCError
+from grpclib import GRPCError, Status
 from synchronicity import classproperty
 from synchronicity.async_wrap import asynccontextmanager
 
@@ -27,7 +27,7 @@ from ._utils.name_utils import check_object_name
 from ._utils.time_utils import as_timestamp, timestamp_to_localized_dt
 from .client import _Client
 from .config import logger
-from .exception import InvalidError, NotFoundError, RequestSizeError
+from .exception import AlreadyExistsError, InvalidError, NotFoundError, RequestSizeError
 
 
 def _serialize_dict(data):
@@ -49,6 +49,58 @@ class DictInfo:
 class _DictManager:
     """Namespace with methods for managing named Dict objects."""
 
+    @staticmethod
+    async def create(
+        name: str,  # Name to use for the new Dict
+        *,
+        allow_existing: bool = False,  # If True, no-op when the Dict already exists
+        environment_name: Optional[str] = None,  # Uses active environment if not specified
+        client: Optional[_Client] = None,  # Optional client with Modal credentials
+    ) -> None:
+        """Create a new Dict object.
+
+        **Examples:**
+
+        ```python notest
+        modal.Dict.objects.create("my-dict")
+        ```
+
+        Dicts will be created in the active environment, or another one can be specified:
+
+        ```python notest
+        modal.Dict.objects.create("my-dict", environment_name="dev")
+        ```
+
+        By default, an error will be raised if the Dict already exists, but passing
+        `allow_existing=True` will make the creation attempt a no-op in this case.
+
+        ```python notest
+        modal.Dict.objects.create("my-dict", allow_existing=True)
+        ```
+
+        Note that this method does not return a local instance of the Dict. You can use
+        `modal.Dict.from_name` to perform a lookup after creation.
+
+        """
+        client = await _Client.from_env() if client is None else client
+        object_creation_type = (
+            api_pb2.OBJECT_CREATION_TYPE_CREATE_IF_MISSING
+            if allow_existing
+            else api_pb2.OBJECT_CREATION_TYPE_CREATE_FAIL_IF_EXISTS
+        )
+        req = api_pb2.DictGetOrCreateRequest(
+            deployment_name=name,
+            environment_name=_get_environment_name(environment_name),
+            object_creation_type=object_creation_type,
+        )
+        try:
+            await retry_transient_errors(client.stub.DictGetOrCreate, req)
+        except GRPCError as exc:
+            if exc.status == Status.ALREADY_EXISTS and not allow_existing:
+                raise AlreadyExistsError(exc.message)
+            else:
+                raise
+
     @staticmethod
     async def list(
         *,
@@ -89,7 +141,9 @@ class _DictManager:
         async def retrieve_page(created_before: float) -> bool:
             max_page_size = 100 if max_objects is None else min(100, max_objects - len(items))
             pagination = api_pb2.ListPagination(max_objects=max_page_size, created_before=created_before)
-            req = api_pb2.DictListRequest(environment_name=environment_name, pagination=pagination)
+            req = api_pb2.DictListRequest(
+                environment_name=_get_environment_name(environment_name), pagination=pagination
+            )
             resp = await retry_transient_errors(client.stub.DictList, req)
             items.extend(resp.dicts)
             finished = (len(resp.dicts) < max_page_size) or (max_objects is not None and len(items) >= max_objects)

{modal-1.1.2.dev28 → modal-1.1.2.dev29}/modal/dict.pyi

@@ -35,6 +35,40 @@ class DictInfo:
 
 class _DictManager:
     """Namespace with methods for managing named Dict objects."""
+    @staticmethod
+    async def create(
+        name: str,
+        *,
+        allow_existing: bool = False,
+        environment_name: typing.Optional[str] = None,
+        client: typing.Optional[modal.client._Client] = None,
+    ) -> None:
+        """Create a new Dict object.
+
+        **Examples:**
+
+        ```python notest
+        modal.Dict.objects.create("my-dict")
+        ```
+
+        Dicts will be created in the active environment, or another one can be specified:
+
+        ```python notest
+        modal.Dict.objects.create("my-dict", environment_name="dev")
+        ```
+
+        By default, an error will be raised if the Dict already exists, but passing
+        `allow_existing=True` will make the creation attempt a no-op in this case.
+
+        ```python notest
+        modal.Dict.objects.create("my-dict", allow_existing=True)
+        ```
+
+        Note that this method does not return a local instance of the Dict. You can use
+        `modal.Dict.from_name` to perform a lookup after creation.
+        """
+        ...
+
     @staticmethod
     async def list(
         *,
@@ -100,6 +134,79 @@ class DictManager:
         """Initialize self.  See help(type(self)) for accurate signature."""
         ...
 
+    class __create_spec(typing_extensions.Protocol):
+        def __call__(
+            self,
+            /,
+            name: str,
+            *,
+            allow_existing: bool = False,
+            environment_name: typing.Optional[str] = None,
+            client: typing.Optional[modal.client.Client] = None,
+        ) -> None:
+            """Create a new Dict object.
+
+            **Examples:**
+
+            ```python notest
+            modal.Dict.objects.create("my-dict")
+            ```
+
+            Dicts will be created in the active environment, or another one can be specified:
+
+            ```python notest
+            modal.Dict.objects.create("my-dict", environment_name="dev")
+            ```
+
+            By default, an error will be raised if the Dict already exists, but passing
+            `allow_existing=True` will make the creation attempt a no-op in this case.
+
+            ```python notest
+            modal.Dict.objects.create("my-dict", allow_existing=True)
+            ```
+
+            Note that this method does not return a local instance of the Dict. You can use
+            `modal.Dict.from_name` to perform a lookup after creation.
+            """
+            ...
+
+        async def aio(
+            self,
+            /,
+            name: str,
+            *,
+            allow_existing: bool = False,
+            environment_name: typing.Optional[str] = None,
+            client: typing.Optional[modal.client.Client] = None,
+        ) -> None:
+            """Create a new Dict object.
+
+            **Examples:**
+
+            ```python notest
+            modal.Dict.objects.create("my-dict")
+            ```
+
+            Dicts will be created in the active environment, or another one can be specified:
+
+            ```python notest
+            modal.Dict.objects.create("my-dict", environment_name="dev")
+            ```
+
+            By default, an error will be raised if the Dict already exists, but passing
+            `allow_existing=True` will make the creation attempt a no-op in this case.
+
+            ```python notest
+            modal.Dict.objects.create("my-dict", allow_existing=True)
+            ```
+
+            Note that this method does not return a local instance of the Dict. You can use
+            `modal.Dict.from_name` to perform a lookup after creation.
+            """
+            ...
+
+    create: __create_spec
+
     class __list_spec(typing_extensions.Protocol):
         def __call__(
             self,

{modal-1.1.2.dev28 → modal-1.1.2.dev29}/modal/queue.py

@@ -29,7 +29,7 @@ from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from ._utils.time_utils import as_timestamp, timestamp_to_localized_dt
 from .client import _Client
-from .exception import InvalidError, NotFoundError, RequestSizeError
+from .exception import AlreadyExistsError, InvalidError, NotFoundError, RequestSizeError
 
 
 @dataclass
@@ -47,10 +47,62 @@ class QueueInfo:
 class _QueueManager:
     """Namespace with methods for managing named Queue objects."""
 
+    @staticmethod
+    async def create(
+        name: str,  # Name to use for the new Queue
+        *,
+        allow_existing: bool = False,  # If True, no-op when the Queue already exists
+        environment_name: Optional[str] = None,  # Uses active environment if not specified
+        client: Optional[_Client] = None,  # Optional client with Modal credentials
+    ) -> None:
+        """Create a new Queue object.
+
+        **Examples:**
+
+        ```python notest
+        modal.Queue.objects.create("my-queue")
+        ```
+
+        Queues will be created in the active environment, or another one can be specified:
+
+        ```python notest
+        modal.Queue.objects.create("my-queue", environment_name="dev")
+        ```
+
+        By default, an error will be raised if the Queue already exists, but passing
+        `allow_existing=True` will make the creation attempt a no-op in this case.
+
+        ```python notest
+        modal.Queue.objects.create("my-queue", allow_existing=True)
+        ```
+
+        Note that this method does not return a local instance of the Queue. You can use
+        `modal.Queue.from_name` to perform a lookup after creation.
+
+        """
+        client = await _Client.from_env() if client is None else client
+        object_creation_type = (
+            api_pb2.OBJECT_CREATION_TYPE_CREATE_IF_MISSING
+            if allow_existing
+            else api_pb2.OBJECT_CREATION_TYPE_CREATE_FAIL_IF_EXISTS
+        )
+        req = api_pb2.QueueGetOrCreateRequest(
+            deployment_name=name,
+            environment_name=_get_environment_name(environment_name),
+            object_creation_type=object_creation_type,
+        )
+        try:
+            await retry_transient_errors(client.stub.QueueGetOrCreate, req)
+        except GRPCError as exc:
+            if exc.status == Status.ALREADY_EXISTS and not allow_existing:
+                raise AlreadyExistsError(exc.message)
+            else:
+                raise
+
     @staticmethod
     async def list(
         *,
-        max_objects: Optional[int] = None,  # Limit requests to this size
+        max_objects: Optional[int] = None,  # Limit results to this size
         created_before: Optional[Union[datetime, str]] = None,  # Limit based on creation date
         environment_name: str = "",  # Uses active environment if not specified
         client: Optional[_Client] = None,  # Optional client with Modal credentials
@@ -87,7 +139,9 @@ class _QueueManager:
         async def retrieve_page(created_before: float) -> bool:
             max_page_size = 100 if max_objects is None else min(100, max_objects - len(items))
             pagination = api_pb2.ListPagination(max_objects=max_page_size, created_before=created_before)
-            req = api_pb2.QueueListRequest(environment_name=environment_name, pagination=pagination)
+            req = api_pb2.QueueListRequest(
+                environment_name=_get_environment_name(environment_name), pagination=pagination
+            )
             resp = await retry_transient_errors(client.stub.QueueList, req)
             items.extend(resp.queues)
             finished = (len(resp.queues) < max_page_size) or (max_objects is not None and len(items) >= max_objects)

{modal-1.1.2.dev28 → modal-1.1.2.dev29}/modal/queue.pyi

@@ -33,6 +33,40 @@ class QueueInfo:
 
 class _QueueManager:
     """Namespace with methods for managing named Queue objects."""
+    @staticmethod
+    async def create(
+        name: str,
+        *,
+        allow_existing: bool = False,
+        environment_name: typing.Optional[str] = None,
+        client: typing.Optional[modal.client._Client] = None,
+    ) -> None:
+        """Create a new Queue object.
+
+        **Examples:**
+
+        ```python notest
+        modal.Queue.objects.create("my-queue")
+        ```
+
+        Queues will be created in the active environment, or another one can be specified:
+
+        ```python notest
+        modal.Queue.objects.create("my-queue", environment_name="dev")
+        ```
+
+        By default, an error will be raised if the Queue already exists, but passing
+        `allow_existing=True` will make the creation attempt a no-op in this case.
+
+        ```python notest
+        modal.Queue.objects.create("my-queue", allow_existing=True)
+        ```
+
+        Note that this method does not return a local instance of the Queue. You can use
+        `modal.Queue.from_name` to perform a lookup after creation.
+        """
+        ...
+
     @staticmethod
     async def list(
         *,
@@ -98,6 +132,79 @@ class QueueManager:
         """Initialize self.  See help(type(self)) for accurate signature."""
         ...
 
+    class __create_spec(typing_extensions.Protocol):
+        def __call__(
+            self,
+            /,
+            name: str,
+            *,
+            allow_existing: bool = False,
+            environment_name: typing.Optional[str] = None,
+            client: typing.Optional[modal.client.Client] = None,
+        ) -> None:
+            """Create a new Queue object.
+
+            **Examples:**
+
+            ```python notest
+            modal.Queue.objects.create("my-queue")
+            ```
+
+            Queues will be created in the active environment, or another one can be specified:
+
+            ```python notest
+            modal.Queue.objects.create("my-queue", environment_name="dev")
+            ```
+
+            By default, an error will be raised if the Queue already exists, but passing
+            `allow_existing=True` will make the creation attempt a no-op in this case.
+
+            ```python notest
+            modal.Queue.objects.create("my-queue", allow_existing=True)
+            ```
+
+            Note that this method does not return a local instance of the Queue. You can use
+            `modal.Queue.from_name` to perform a lookup after creation.
+            """
+            ...
+
+        async def aio(
+            self,
+            /,
+            name: str,
+            *,
+            allow_existing: bool = False,
+            environment_name: typing.Optional[str] = None,
+            client: typing.Optional[modal.client.Client] = None,
+        ) -> None:
+            """Create a new Queue object.
+
+            **Examples:**
+
+            ```python notest
+            modal.Queue.objects.create("my-queue")
+            ```
+
+            Queues will be created in the active environment, or another one can be specified:
+
+            ```python notest
+            modal.Queue.objects.create("my-queue", environment_name="dev")
+            ```
+
+            By default, an error will be raised if the Queue already exists, but passing
+            `allow_existing=True` will make the creation attempt a no-op in this case.
+
+            ```python notest
+            modal.Queue.objects.create("my-queue", allow_existing=True)
+            ```
+
+            Note that this method does not return a local instance of the Queue. You can use
+            `modal.Queue.from_name` to perform a lookup after creation.
+            """
+            ...
+
+    create: __create_spec
+
     class __list_spec(typing_extensions.Protocol):
         def __call__(
             self,

{modal-1.1.2.dev28 → modal-1.1.2.dev29}/modal/secret.py

@@ -19,7 +19,7 @@ from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from ._utils.time_utils import as_timestamp, timestamp_to_localized_dt
 from .client import _Client
-from .exception import InvalidError, NotFoundError
+from .exception import AlreadyExistsError, InvalidError, NotFoundError
 
 ENV_DICT_WRONG_TYPE_ERR = "the env_dict argument to Secret has to be a dict[str, Union[str, None]]"
 
@@ -39,6 +39,62 @@ class SecretInfo:
 class _SecretManager:
     """Namespace with methods for managing named Secret objects."""
 
+    @staticmethod
+    async def create(
+        name: str,  # Name to use for the new Secret
+        env_dict: dict[str, str],  # Key-value pairs to set in the Secret
+        *,
+        allow_existing: bool = False,  # If True, no-op when the Secret already exists
+        environment_name: Optional[str] = None,  # Uses active environment if not specified
+        client: Optional[_Client] = None,  # Optional client with Modal credentials
+    ) -> 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.
+
+        """
+        client = await _Client.from_env() if client is None else client
+        object_creation_type = (
+            api_pb2.OBJECT_CREATION_TYPE_CREATE_IF_MISSING
+            if allow_existing
+            else api_pb2.OBJECT_CREATION_TYPE_CREATE_FAIL_IF_EXISTS
+        )
+        req = api_pb2.SecretGetOrCreateRequest(
+            deployment_name=name,
+            environment_name=_get_environment_name(environment_name),
+            object_creation_type=object_creation_type,
+            env_dict=env_dict,
+        )
+        try:
+            await retry_transient_errors(client.stub.SecretGetOrCreate, req)
+        except GRPCError as exc:
+            if exc.status == Status.ALREADY_EXISTS and not allow_existing:
+                raise AlreadyExistsError(exc.message)
+            else:
+                raise
+
     @staticmethod
     async def list(
         *,
@@ -79,7 +135,9 @@ class _SecretManager:
         async def retrieve_page(created_before: float) -> bool:
             max_page_size = 100 if max_objects is None else min(100, max_objects - len(items))
             pagination = api_pb2.ListPagination(max_objects=max_page_size, created_before=created_before)
-            req = api_pb2.SecretListRequest(environment_name=environment_name, pagination=pagination)
+            req = api_pb2.SecretListRequest(
+                environment_name=_get_environment_name(environment_name), pagination=pagination
+            )
             resp = await retry_transient_errors(client.stub.SecretList, req)
             items.extend(resp.items)
             finished = (len(resp.items) < max_page_size) or (max_objects is not None and len(items) >= max_objects)

{modal-1.1.2.dev28 → modal-1.1.2.dev29}/modal/secret.pyi

@@ -31,6 +31,43 @@ class SecretInfo:
 
 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.
+        """
+        ...
+
     @staticmethod
     async def list(
         *,
@@ -95,6 +132,85 @@ class SecretManager:
         """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.
+            """
+            ...
+
+        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.
+            """
+            ...
+
+    create: __create_spec
+
     class __list_spec(typing_extensions.Protocol):
         def __call__(
             self,