modal 1.1.2.dev27__tar.gz → 1.1.2.dev29__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.1.2.dev27
+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.dev27 → modal-1.1.2.dev29}/modal/_utils/blob_utils.py

@@ -444,14 +444,24 @@ def get_file_upload_spec_from_fileobj(fp: BinaryIO, mount_filename: PurePosixPat
 _FileUploadSource2 = Callable[[], ContextManager[BinaryIO]]
 
 
+@dataclasses.dataclass
+class FileUploadBlock:
+    # The start (byte offset, inclusive) of the block within the file
+    start: int
+    # The end (byte offset, exclusive) of the block, after having removed any trailing zeroes
+    end: int
+    # Raw (unencoded 32 byte) SHA256 sum of the block, not including trailing zeroes
+    contents_sha256: bytes
+
+
 @dataclasses.dataclass
 class FileUploadSpec2:
     source: _FileUploadSource2
     source_description: Union[str, Path]
 
     path: str
-    # Raw (unencoded 32 byte) SHA256 sum per 8MiB file block
-    blocks_sha256: list[bytes]
+    # 8MiB file blocks
+    blocks: list[FileUploadBlock]
     mode: int  # file permission bits (last 12 bits of st_mode)
     size: int
 
@@ -522,53 +532,102 @@ class FileUploadSpec2:
             source_fp.seek(0, os.SEEK_END)
             size = source_fp.tell()
 
-        blocks_sha256 = await hash_blocks_sha256(source, size, hash_semaphore)
+        blocks = await _gather_blocks(source, size, hash_semaphore)
 
         return FileUploadSpec2(
             source=source,
             source_description=source_description,
             path=mount_filename.as_posix(),
-            blocks_sha256=blocks_sha256,
+            blocks=blocks,
             mode=mode & 0o7777,
             size=size,
         )
 
 
-async def hash_blocks_sha256(
+async def _gather_blocks(
     source: _FileUploadSource2,
     size: int,
     hash_semaphore: asyncio.Semaphore,
-) -> list[bytes]:
+) -> list[FileUploadBlock]:
     def ceildiv(a: int, b: int) -> int:
         return -(a // -b)
 
     num_blocks = ceildiv(size, BLOCK_SIZE)
 
-    def blocking_hash_block_sha256(block_idx: int) -> bytes:
-        sha256_hash = hashlib.sha256()
-        block_start = block_idx * BLOCK_SIZE
+    async def gather_block(block_idx: int) -> FileUploadBlock:
+        async with hash_semaphore:
+            return await asyncio.to_thread(_gather_block, source, block_idx)
 
-        with source() as block_fp:
-            block_fp.seek(block_start)
+    tasks = (gather_block(idx) for idx in range(num_blocks))
+    return await asyncio.gather(*tasks)
 
-            num_bytes_read = 0
-            while num_bytes_read < BLOCK_SIZE:
-                chunk = block_fp.read(BLOCK_SIZE - num_bytes_read)
 
-                if not chunk:
-                    break
+def _gather_block(source: _FileUploadSource2, block_idx: int) -> FileUploadBlock:
+    start = block_idx * BLOCK_SIZE
+    end = _find_end_of_block(source, start, start + BLOCK_SIZE)
+    contents_sha256 = _hash_range_sha256(source, start, end)
+    return FileUploadBlock(start=start, end=end, contents_sha256=contents_sha256)
 
-                num_bytes_read += len(chunk)
-                sha256_hash.update(chunk)
 
-        return sha256_hash.digest()
+def _hash_range_sha256(source: _FileUploadSource2, start, end):
+    sha256_hash = hashlib.sha256()
+    range_size = end - start
 
-    async def hash_block_sha256(block_idx: int) -> bytes:
-        async with hash_semaphore:
-            return await asyncio.to_thread(blocking_hash_block_sha256, block_idx)
+    with source() as fp:
+        fp.seek(start)
+
+        num_bytes_read = 0
+        while num_bytes_read < range_size:
+            chunk = fp.read(range_size - num_bytes_read)
+
+            if not chunk:
+                break
+
+            num_bytes_read += len(chunk)
+            sha256_hash.update(chunk)
+
+    return sha256_hash.digest()
+
+
+def _find_end_of_block(source: _FileUploadSource2, start: int, end: int) -> Optional[int]:
+    """Finds the appropriate end of a block, which is the index of the byte just past the last non-zero byte in the
+    block.
+
+    >>> _find_end_of_block(lambda: BytesIO(b"abc123\0\0\0"), 0, 1024)
+    6
+    >>> _find_end_of_block(lambda: BytesIO(b"abc123\0\0\0"), 3, 1024)
+    6
+    >>> _find_end_of_block(lambda: BytesIO(b"abc123\0\0\0"), 0, 3)
+    4
+    >>> _find_end_of_block(lambda: BytesIO(b"abc123\0\0\0a"), 0, 9)
+    6
+    >>> _find_end_of_block(lambda: BytesIO(b"\0\0\0"), 0, 3)
+    0
+    >>> _find_end_of_block(lambda: BytesIO(b"\0\0\0\0\0\0"), 3, 6)
+    3
+    >>> _find_end_of_block(lambda: BytesIO(b""), 0, 1024)
+    0
+    """
+    size = end - start
+    new_end = start
 
-    tasks = (hash_block_sha256(idx) for idx in range(num_blocks))
-    return await asyncio.gather(*tasks)
+    with source() as block_fp:
+        block_fp.seek(start)
+
+        num_bytes_read = 0
+        while num_bytes_read < size:
+            chunk = block_fp.read(size - num_bytes_read)
+
+            if not chunk:
+                break
+
+            stripped_chunk = chunk.rstrip(b"\0")
+            if stripped_chunk:
+                new_end = start + num_bytes_read + len(stripped_chunk)
+
+            num_bytes_read += len(chunk)
+
+    return new_end
 
 
 def use_md5(url: str) -> bool:

{modal-1.1.2.dev27 → 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.dev27",
+        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.dev27",
+        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.dev27 → 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.dev27 → 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.dev27 → modal-1.1.2.dev29}/modal/functions.pyi

@@ -433,7 +433,7 @@ class Function(
 
     _call_generator: ___call_generator_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER:
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
@@ -442,7 +442,7 @@ class Function(
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -469,7 +469,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """[Experimental] Calls the function with the given arguments, without waiting for the results.
 
@@ -493,7 +493,7 @@ class Function(
             ...
 
     _experimental_spawn: ___experimental_spawn_spec[
-        modal._functions.ReturnType, modal._functions.P, typing_extensions.Self
+        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
     ]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER, SUPERSELF]):
@@ -502,7 +502,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P, typing_extensions.Self]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """Calls the function with the given arguments, without waiting for the results.
 
@@ -523,7 +523,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function."""

{modal-1.1.2.dev27 → 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.dev27 → 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,