modal 0.62.115__py3-none-any.whl → 0.72.13__py3-none-any.whl

modal/queue.pyi

@@ -1,3 +1,4 @@
+import collections.abc
 import modal.client
 import modal.object
 import synchronicity.combined_types
@@ -5,196 +6,270 @@ import typing
 import typing_extensions
 
 class _Queue(modal.object._Object):
+    def __init__(self): ...
     @staticmethod
-    def new():
-        ...
-
-    def __init__(self):
-        ...
-
-    @staticmethod
-    def validate_partition_key(partition: typing.Union[str, None]) -> bytes:
-        ...
-
+    def validate_partition_key(partition: typing.Optional[str]) -> bytes: ...
     @classmethod
-    def ephemeral(cls: typing.Type[_Queue], client: typing.Union[modal.client._Client, None] = None, environment_name: typing.Union[str, None] = None, _heartbeat_sleep: float = 300) -> typing.AsyncContextManager[_Queue]:
-        ...
-
+    def ephemeral(
+        cls: type[_Queue],
+        client: typing.Optional[modal.client._Client] = None,
+        environment_name: typing.Optional[str] = None,
+        _heartbeat_sleep: float = 300,
+    ) -> typing.AsyncContextManager[_Queue]: ...
     @staticmethod
-    def from_name(label: str, namespace=1, environment_name: typing.Union[str, None] = None, create_if_missing: bool = False) -> _Queue:
-        ...
-
+    def from_name(
+        name: str, namespace=1, environment_name: typing.Optional[str] = None, create_if_missing: bool = False
+    ) -> _Queue: ...
     @staticmethod
-    def persisted(label: str, namespace=1, environment_name: typing.Union[str, None] = None) -> _Queue:
-        ...
-
-    @staticmethod
-    async def lookup(label: str, namespace=1, client: typing.Union[modal.client._Client, None] = None, environment_name: typing.Union[str, None] = None, create_if_missing: bool = False) -> _Queue:
-        ...
-
+    async def lookup(
+        name: str,
+        namespace=1,
+        client: typing.Optional[modal.client._Client] = None,
+        environment_name: typing.Optional[str] = None,
+        create_if_missing: bool = False,
+    ) -> _Queue: ...
     @staticmethod
-    async def delete(label: str, *, client: typing.Union[modal.client._Client, None] = None, environment_name: typing.Union[str, None] = None):
-        ...
-
-    async def _get_nonblocking(self, partition: typing.Union[str, None], n_values: int) -> typing.List[typing.Any]:
-        ...
-
-    async def _get_blocking(self, partition: typing.Union[str, None], timeout: typing.Union[float, None], n_values: int) -> typing.List[typing.Any]:
-        ...
-
-    async def get(self, block: bool = True, timeout: typing.Union[float, None] = None, *, partition: typing.Union[str, None] = None) -> typing.Union[typing.Any, None]:
-        ...
-
-    async def get_many(self, n_values: int, block: bool = True, timeout: typing.Union[float, None] = None, *, partition: typing.Union[str, None] = None) -> typing.List[typing.Any]:
-        ...
-
-    async def put(self, v: typing.Any, block: bool = True, timeout: typing.Union[float, None] = None, *, partition: typing.Union[str, None] = None, partition_ttl: int = 86400) -> None:
-        ...
-
-    async def put_many(self, vs: typing.List[typing.Any], block: bool = True, timeout: typing.Union[float, None] = None, *, partition: typing.Union[str, None] = None, partition_ttl: int = 86400) -> None:
-        ...
-
-    async def _put_many_blocking(self, partition: typing.Union[str, None], partition_ttl: int, vs: typing.List[typing.Any], timeout: typing.Union[float, None] = None):
-        ...
-
-    async def _put_many_nonblocking(self, partition: typing.Union[str, None], partition_ttl: int, vs: typing.List[typing.Any]):
-        ...
-
-    async def len(self, *, partition: typing.Union[str, None] = None) -> int:
-        ...
-
-    def iterate(self, *, partition: typing.Union[str, None] = None, item_poll_timeout: float = 0.0) -> typing.AsyncGenerator[typing.Any, None]:
-        ...
-
+    async def delete(
+        name: str,
+        *,
+        client: typing.Optional[modal.client._Client] = None,
+        environment_name: typing.Optional[str] = None,
+    ): ...
+    async def _get_nonblocking(self, partition: typing.Optional[str], n_values: int) -> list[typing.Any]: ...
+    async def _get_blocking(
+        self, partition: typing.Optional[str], timeout: typing.Optional[float], n_values: int
+    ) -> list[typing.Any]: ...
+    async def clear(self, *, partition: typing.Optional[str] = None, all: bool = False) -> None: ...
+    async def get(
+        self, block: bool = True, timeout: typing.Optional[float] = None, *, partition: typing.Optional[str] = None
+    ) -> typing.Optional[typing.Any]: ...
+    async def get_many(
+        self,
+        n_values: int,
+        block: bool = True,
+        timeout: typing.Optional[float] = None,
+        *,
+        partition: typing.Optional[str] = None,
+    ) -> list[typing.Any]: ...
+    async def put(
+        self,
+        v: typing.Any,
+        block: bool = True,
+        timeout: typing.Optional[float] = None,
+        *,
+        partition: typing.Optional[str] = None,
+        partition_ttl: int = 86400,
+    ) -> None: ...
+    async def put_many(
+        self,
+        vs: list[typing.Any],
+        block: bool = True,
+        timeout: typing.Optional[float] = None,
+        *,
+        partition: typing.Optional[str] = None,
+        partition_ttl: int = 86400,
+    ) -> None: ...
+    async def _put_many_blocking(
+        self,
+        partition: typing.Optional[str],
+        partition_ttl: int,
+        vs: list[typing.Any],
+        timeout: typing.Optional[float] = None,
+    ): ...
+    async def _put_many_nonblocking(
+        self, partition: typing.Optional[str], partition_ttl: int, vs: list[typing.Any]
+    ): ...
+    async def len(self, *, partition: typing.Optional[str] = None, total: bool = False) -> int: ...
+    def iterate(
+        self, *, partition: typing.Optional[str] = None, item_poll_timeout: float = 0.0
+    ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
 
 class Queue(modal.object.Object):
-    def __init__(self):
-        ...
-
+    def __init__(self): ...
     @staticmethod
-    def new():
-        ...
-
-    @staticmethod
-    def validate_partition_key(partition: typing.Union[str, None]) -> bytes:
-        ...
-
+    def validate_partition_key(partition: typing.Optional[str]) -> bytes: ...
     @classmethod
-    def ephemeral(cls: typing.Type[Queue], client: typing.Union[modal.client.Client, None] = None, environment_name: typing.Union[str, None] = None, _heartbeat_sleep: float = 300) -> synchronicity.combined_types.AsyncAndBlockingContextManager[Queue]:
-        ...
-
-    @staticmethod
-    def from_name(label: str, namespace=1, environment_name: typing.Union[str, None] = None, create_if_missing: bool = False) -> Queue:
-        ...
-
+    def ephemeral(
+        cls: type[Queue],
+        client: typing.Optional[modal.client.Client] = None,
+        environment_name: typing.Optional[str] = None,
+        _heartbeat_sleep: float = 300,
+    ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[Queue]: ...
     @staticmethod
-    def persisted(label: str, namespace=1, environment_name: typing.Union[str, None] = None) -> Queue:
-        ...
+    def from_name(
+        name: str, namespace=1, environment_name: typing.Optional[str] = None, create_if_missing: bool = False
+    ) -> Queue: ...
 
     class __lookup_spec(typing_extensions.Protocol):
-        def __call__(self, label: str, namespace=1, client: typing.Union[modal.client.Client, None] = None, environment_name: typing.Union[str, None] = None, create_if_missing: bool = False) -> Queue:
-            ...
-
-        async def aio(self, *args, **kwargs) -> Queue:
-            ...
+        def __call__(
+            self,
+            name: str,
+            namespace=1,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+            create_if_missing: bool = False,
+        ) -> Queue: ...
+        async def aio(
+            self,
+            name: str,
+            namespace=1,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+            create_if_missing: bool = False,
+        ) -> Queue: ...
 
     lookup: __lookup_spec
 
     class __delete_spec(typing_extensions.Protocol):
-        def __call__(self, label: str, *, client: typing.Union[modal.client.Client, None] = None, environment_name: typing.Union[str, None] = None):
-            ...
-
-        async def aio(self, *args, **kwargs):
-            ...
+        def __call__(
+            self,
+            name: str,
+            *,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+        ): ...
+        async def aio(
+            self,
+            name: str,
+            *,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+        ): ...
 
     delete: __delete_spec
 
     class ___get_nonblocking_spec(typing_extensions.Protocol):
-        def __call__(self, partition: typing.Union[str, None], n_values: int) -> typing.List[typing.Any]:
-            ...
-
-        async def aio(self, *args, **kwargs) -> typing.List[typing.Any]:
-            ...
+        def __call__(self, partition: typing.Optional[str], n_values: int) -> list[typing.Any]: ...
+        async def aio(self, partition: typing.Optional[str], n_values: int) -> list[typing.Any]: ...
 
     _get_nonblocking: ___get_nonblocking_spec
 
     class ___get_blocking_spec(typing_extensions.Protocol):
-        def __call__(self, partition: typing.Union[str, None], timeout: typing.Union[float, None], n_values: int) -> typing.List[typing.Any]:
-            ...
-
-        async def aio(self, *args, **kwargs) -> typing.List[typing.Any]:
-            ...
+        def __call__(
+            self, partition: typing.Optional[str], timeout: typing.Optional[float], n_values: int
+        ) -> list[typing.Any]: ...
+        async def aio(
+            self, partition: typing.Optional[str], timeout: typing.Optional[float], n_values: int
+        ) -> list[typing.Any]: ...
 
     _get_blocking: ___get_blocking_spec
 
-    class __get_spec(typing_extensions.Protocol):
-        def __call__(self, block: bool = True, timeout: typing.Union[float, None] = None, *, partition: typing.Union[str, None] = None) -> typing.Union[typing.Any, None]:
-            ...
+    class __clear_spec(typing_extensions.Protocol):
+        def __call__(self, *, partition: typing.Optional[str] = None, all: bool = False) -> None: ...
+        async def aio(self, *, partition: typing.Optional[str] = None, all: bool = False) -> None: ...
+
+    clear: __clear_spec
 
-        async def aio(self, *args, **kwargs) -> typing.Union[typing.Any, None]:
-            ...
+    class __get_spec(typing_extensions.Protocol):
+        def __call__(
+            self, block: bool = True, timeout: typing.Optional[float] = None, *, partition: typing.Optional[str] = None
+        ) -> typing.Optional[typing.Any]: ...
+        async def aio(
+            self, block: bool = True, timeout: typing.Optional[float] = None, *, partition: typing.Optional[str] = None
+        ) -> typing.Optional[typing.Any]: ...
 
     get: __get_spec
 
     class __get_many_spec(typing_extensions.Protocol):
-        def __call__(self, n_values: int, block: bool = True, timeout: typing.Union[float, None] = None, *, partition: typing.Union[str, None] = None) -> typing.List[typing.Any]:
-            ...
-
-        async def aio(self, *args, **kwargs) -> typing.List[typing.Any]:
-            ...
+        def __call__(
+            self,
+            n_values: int,
+            block: bool = True,
+            timeout: typing.Optional[float] = None,
+            *,
+            partition: typing.Optional[str] = None,
+        ) -> list[typing.Any]: ...
+        async def aio(
+            self,
+            n_values: int,
+            block: bool = True,
+            timeout: typing.Optional[float] = None,
+            *,
+            partition: typing.Optional[str] = None,
+        ) -> list[typing.Any]: ...
 
     get_many: __get_many_spec
 
     class __put_spec(typing_extensions.Protocol):
-        def __call__(self, v: typing.Any, block: bool = True, timeout: typing.Union[float, None] = None, *, partition: typing.Union[str, None] = None, partition_ttl: int = 86400) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
+        def __call__(
+            self,
+            v: typing.Any,
+            block: bool = True,
+            timeout: typing.Optional[float] = None,
+            *,
+            partition: typing.Optional[str] = None,
+            partition_ttl: int = 86400,
+        ) -> None: ...
+        async def aio(
+            self,
+            v: typing.Any,
+            block: bool = True,
+            timeout: typing.Optional[float] = None,
+            *,
+            partition: typing.Optional[str] = None,
+            partition_ttl: int = 86400,
+        ) -> None: ...
 
     put: __put_spec
 
     class __put_many_spec(typing_extensions.Protocol):
-        def __call__(self, vs: typing.List[typing.Any], block: bool = True, timeout: typing.Union[float, None] = None, *, partition: typing.Union[str, None] = None, partition_ttl: int = 86400) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
+        def __call__(
+            self,
+            vs: list[typing.Any],
+            block: bool = True,
+            timeout: typing.Optional[float] = None,
+            *,
+            partition: typing.Optional[str] = None,
+            partition_ttl: int = 86400,
+        ) -> None: ...
+        async def aio(
+            self,
+            vs: list[typing.Any],
+            block: bool = True,
+            timeout: typing.Optional[float] = None,
+            *,
+            partition: typing.Optional[str] = None,
+            partition_ttl: int = 86400,
+        ) -> None: ...
 
     put_many: __put_many_spec
 
     class ___put_many_blocking_spec(typing_extensions.Protocol):
-        def __call__(self, partition: typing.Union[str, None], partition_ttl: int, vs: typing.List[typing.Any], timeout: typing.Union[float, None] = None):
-            ...
-
-        async def aio(self, *args, **kwargs):
-            ...
+        def __call__(
+            self,
+            partition: typing.Optional[str],
+            partition_ttl: int,
+            vs: list[typing.Any],
+            timeout: typing.Optional[float] = None,
+        ): ...
+        async def aio(
+            self,
+            partition: typing.Optional[str],
+            partition_ttl: int,
+            vs: list[typing.Any],
+            timeout: typing.Optional[float] = None,
+        ): ...
 
     _put_many_blocking: ___put_many_blocking_spec
 
     class ___put_many_nonblocking_spec(typing_extensions.Protocol):
-        def __call__(self, partition: typing.Union[str, None], partition_ttl: int, vs: typing.List[typing.Any]):
-            ...
-
-        async def aio(self, *args, **kwargs):
-            ...
+        def __call__(self, partition: typing.Optional[str], partition_ttl: int, vs: list[typing.Any]): ...
+        async def aio(self, partition: typing.Optional[str], partition_ttl: int, vs: list[typing.Any]): ...
 
     _put_many_nonblocking: ___put_many_nonblocking_spec
 
     class __len_spec(typing_extensions.Protocol):
-        def __call__(self, *, partition: typing.Union[str, None] = None) -> int:
-            ...
-
-        async def aio(self, *args, **kwargs) -> int:
-            ...
+        def __call__(self, *, partition: typing.Optional[str] = None, total: bool = False) -> int: ...
+        async def aio(self, *, partition: typing.Optional[str] = None, total: bool = False) -> int: ...
 
     len: __len_spec
 
     class __iterate_spec(typing_extensions.Protocol):
-        def __call__(self, *, partition: typing.Union[str, None] = None, item_poll_timeout: float = 0.0) -> typing.Generator[typing.Any, None, None]:
-            ...
-
-        def aio(self, *, partition: typing.Union[str, None] = None, item_poll_timeout: float = 0.0) -> typing.AsyncGenerator[typing.Any, None]:
-            ...
+        def __call__(
+            self, *, partition: typing.Optional[str] = None, item_poll_timeout: float = 0.0
+        ) -> typing.Generator[typing.Any, None, None]: ...
+        def aio(
+            self, *, partition: typing.Optional[str] = None, item_poll_timeout: float = 0.0
+        ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
 
     iterate: __iterate_spec

modal/requirements/2024.04.txt

@@ -17,10 +17,11 @@ idna==3.6
 markdown-it-py==3.0.0
 mdurl==0.1.2
 multidict==6.0.5
-protobuf==5.26.1
+protobuf==4.25.3
 pydantic==2.6.4
 pydantic_core==2.16.3
 Pygments==2.17.2
+python-multipart==0.0.9
 rich==13.7.1
 sniffio==1.3.1
 starlette==0.36.3

modal/requirements/2024.10.txt

@@ -0,0 +1,16 @@
+aiohappyeyeballs==2.4.3
+aiohttp==3.10.8
+aiosignal==1.3.1
+async-timeout==4.0.3 ; python_version < "3.11"
+attrs==24.2.0
+certifi==2024.8.30
+frozenlist==1.4.1
+grpclib==0.4.7
+h2==4.1.0
+hpack==4.0.0
+hyperframe==6.0.1
+idna==3.10
+multidict==6.1.0
+protobuf>=3.20,<6
+typing_extensions==4.12.2
+yarl==1.13.1

modal/requirements/README.md

@@ -0,0 +1,21 @@
+# Modal Image builder configuration
+
+This directory contains `modal.Image` specifications that vary across
+"image builder" versions.
+
+The `base-images.json` file specifies the versions used for Modal's
+various `Image` constructor methods.
+
+The versioned requirements files enumerate the dependencies needed by
+the Modal client library when it is running inside a Modal container.
+
+The container requirements are a subset of the dependencies required by the
+client for local operation (i.e., to run or deploy Modal apps). Additionally,
+we aim to pin specific versions rather than allowing a range as we do for the
+installation dependencies.
+
+From version `2024.04`, the requirements specify the entire dependency tree,
+and not just the first-order dependencies.
+
+Note that for `2023.12`, there is a separate requirements file that is used for
+Python 3.12.

modal/requirements/base-images.json

@@ -0,0 +1,22 @@
+{
+    "debian": {
+        "2024.10": "bookworm",
+        "2024.04": "bookworm",
+        "2023.12": "bullseye"
+    },
+    "python": {
+        "2024.10": ["3.9.20", "3.10.15", "3.11.10", "3.12.6", "3.13.0"],
+        "2024.04": ["3.9.19", "3.10.14", "3.11.8", "3.12.2"],
+        "2023.12": ["3.9.15", "3.10.8", "3.11.0", "3.12.1"]
+    },
+    "micromamba": {
+        "2024.10": "1.5.10",
+        "2024.04": "1.5.8",
+        "2023.12": "1.3.1"
+    },
+    "package_tools": {
+        "2024.10": "pip wheel uv",
+        "2024.04": "pip wheel uv",
+        "2023.12": "pip"
+    }
+}

modal/retries.py

@@ -1,10 +1,14 @@
 # Copyright Modal Labs 2022
+import asyncio
 from datetime import timedelta
 
 from modal_proto import api_pb2
 
 from .exception import InvalidError
 
+MIN_INPUT_RETRY_DELAY_MS = 1000
+MAX_INPUT_RETRY_DELAY_MS = 24 * 60 * 60 * 1000
+
 
 class Retries:
     """Adds a retry policy to a Modal function.
@@ -13,7 +17,7 @@ class Retries:
 
     ```python
     import modal
-    app = modal.App()  # Note: called "stub" up until April 2024
+    app = modal.App()
 
     # Basic configuration.
     # This sets a policy of max 4 retries with 1-second delay between failures.
@@ -53,14 +57,16 @@ class Retries:
         # The maximum number of retries that can be made in the presence of failures.
         max_retries: int,
         # Coefficent controlling how much the retry delay increases each retry attempt.
-        # A backoff coefficient of 1.0 creates fixed-delay retries where the delay period will always equal the initial delay.
+        # A backoff coefficient of 1.0 creates fixed-delay where the delay period always equals the initial delay.
         backoff_coefficient: float = 2.0,
         # Number of seconds that must elapse before the first retry occurs.
         initial_delay: float = 1.0,
         # Maximum length of retry delay in seconds, preventing the delay from growing infinitely.
         max_delay: float = 60.0,
     ):
-        """Construct a new retries policy, supporting exponential and fixed-interval delays via a backoff coefficient."""
+        """
+        Construct a new retries policy, supporting exponential and fixed-interval delays via a backoff coefficient.
+        """
         if max_retries < 0:
             raise InvalidError(f"Invalid retries number: {max_retries}. Function retries must be non-negative.")
 
@@ -84,7 +90,8 @@ class Retries:
 
         if not 1.0 <= backoff_coefficient <= 10.0:
             raise InvalidError(
-                f"Invalid backoff_coefficient: {backoff_coefficient}. Coefficient must be between 1.0 (fixed-interval backoff) and 10.0"
+                f"Invalid backoff_coefficient: {backoff_coefficient}. "
+                "Coefficient must be between 1.0 (fixed-interval backoff) and 10.0"
             )
 
         self.max_retries = max_retries
@@ -100,3 +107,37 @@ class Retries:
             initial_delay_ms=self.initial_delay // timedelta(milliseconds=1),
             max_delay_ms=self.max_delay // timedelta(milliseconds=1),
         )
+
+
+class RetryManager:
+    """
+    Helper class to apply the specified retry policy.
+    """
+
+    def __init__(self, retry_policy: api_pb2.FunctionRetryPolicy):
+        self.retry_policy = retry_policy
+        self.attempt_count = 0
+
+    async def raise_or_sleep(self, exc: Exception):
+        """
+        Raises an exception if the maximum retry count has been reached, otherwise sleeps for calculated delay.
+        """
+        self.attempt_count += 1
+        if self.attempt_count > self.retry_policy.retries:
+            raise exc
+        delay_ms = self._retry_delay_ms(self.attempt_count, self.retry_policy)
+        await asyncio.sleep(delay_ms / 1000)
+
+    @staticmethod
+    def _retry_delay_ms(attempt_count: int, retry_policy: api_pb2.FunctionRetryPolicy) -> float:
+        """
+        Computes the amount of time to sleep before retrying based on the backend_coefficient and initial_delay_ms args.
+        """
+        if attempt_count < 1:
+            raise ValueError(f"Cannot compute retry delay. attempt_count must be at least 1, but was {attempt_count}")
+        delay_ms = retry_policy.initial_delay_ms * (retry_policy.backoff_coefficient ** (attempt_count - 1))
+        if delay_ms < MIN_INPUT_RETRY_DELAY_MS:
+            return MIN_INPUT_RETRY_DELAY_MS
+        if delay_ms > MAX_INPUT_RETRY_DELAY_MS:
+            return MAX_INPUT_RETRY_DELAY_MS
+        return delay_ms