modal 0.62.16__py3-none-any.whl → 0.72.11__py3-none-any.whl

modal/_container_entrypoint.pyi

@@ -1,378 +0,0 @@
-import asyncio.queues
-import collections.abc
-import modal.app
-import modal.client
-import modal.functions
-import modal.stub
-import modal_proto.api_pb2
-import typing
-import typing_extensions
-
-class UserException(Exception):
-    ...
-
-class UserCodeEventLoop:
-    def __enter__(self):
-        ...
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        ...
-
-    def run(self, coro):
-        ...
-
-
-class _FunctionIOManager:
-    def __init__(self, container_args: modal_proto.api_pb2.ContainerArguments, client: modal.client._Client):
-        ...
-
-    async def initialize_app(self) -> modal.app._ContainerApp:
-        ...
-
-    async def _run_heartbeat_loop(self):
-        ...
-
-    async def _heartbeat_handle_cancellations(self) -> bool:
-        ...
-
-    def heartbeats(self):
-        ...
-
-    def stop_heartbeat(self):
-        ...
-
-    async def get_serialized_function(self) -> typing.Tuple[typing.Union[typing.Any, None], typing.Callable]:
-        ...
-
-    def serialize(self, obj: typing.Any) -> bytes:
-        ...
-
-    def deserialize(self, data: bytes) -> typing.Any:
-        ...
-
-    def serialize_data_format(self, obj: typing.Any, data_format: int) -> bytes:
-        ...
-
-    def deserialize_data_format(self, data: bytes, data_format: int) -> typing.Any:
-        ...
-
-    def get_data_in(self, function_call_id: str) -> typing.AsyncIterator[typing.Any]:
-        ...
-
-    async def put_data_out(self, function_call_id: str, start_index: int, data_format: int, messages_bytes: typing.List[typing.Any]) -> None:
-        ...
-
-    async def generator_output_task(self, function_call_id: str, data_format: int, message_rx: asyncio.queues.Queue) -> None:
-        ...
-
-    async def _queue_create(self, size: int) -> asyncio.queues.Queue:
-        ...
-
-    async def _queue_put(self, queue: asyncio.queues.Queue, value: typing.Any) -> None:
-        ...
-
-    async def populate_input_blobs(self, item: modal_proto.api_pb2.FunctionInput):
-        ...
-
-    def get_average_call_time(self) -> float:
-        ...
-
-    def get_max_inputs_to_fetch(self):
-        ...
-
-    def _generate_inputs(self) -> typing.AsyncIterator[typing.Tuple[str, str, modal_proto.api_pb2.FunctionInput]]:
-        ...
-
-    def run_inputs_outputs(self, input_concurrency: int = 1) -> typing.AsyncIterator[typing.Tuple[str, str, typing.Any, typing.Any]]:
-        ...
-
-    async def _push_output(self, input_id, started_at: float, data_format=0, **kwargs):
-        ...
-
-    def serialize_exception(self, exc: BaseException) -> typing.Union[bytes, None]:
-        ...
-
-    def serialize_traceback(self, exc: BaseException) -> typing.Tuple[typing.Union[bytes, None], typing.Union[bytes, None]]:
-        ...
-
-    def handle_user_exception(self) -> typing.AsyncGenerator[None, None]:
-        ...
-
-    def handle_input_exception(self, input_id, started_at: float) -> typing.AsyncGenerator[None, None]:
-        ...
-
-    async def complete_call(self, started_at):
-        ...
-
-    async def push_output(self, input_id, started_at: float, data: typing.Any, data_format: int) -> None:
-        ...
-
-    async def restore(self) -> None:
-        ...
-
-    async def checkpoint(self) -> None:
-        ...
-
-    async def volume_commit(self, volume_ids: typing.List[str]) -> None:
-        ...
-
-
-class FunctionIOManager:
-    def __init__(self, container_args: modal_proto.api_pb2.ContainerArguments, client: modal.client.Client):
-        ...
-
-    class __initialize_app_spec(typing_extensions.Protocol):
-        def __call__(self) -> modal.app.ContainerApp:
-            ...
-
-        async def aio(self, *args, **kwargs) -> modal.app.ContainerApp:
-            ...
-
-    initialize_app: __initialize_app_spec
-
-    class ___run_heartbeat_loop_spec(typing_extensions.Protocol):
-        def __call__(self):
-            ...
-
-        async def aio(self, *args, **kwargs):
-            ...
-
-    _run_heartbeat_loop: ___run_heartbeat_loop_spec
-
-    class ___heartbeat_handle_cancellations_spec(typing_extensions.Protocol):
-        def __call__(self) -> bool:
-            ...
-
-        async def aio(self, *args, **kwargs) -> bool:
-            ...
-
-    _heartbeat_handle_cancellations: ___heartbeat_handle_cancellations_spec
-
-    def heartbeats(self):
-        ...
-
-    def stop_heartbeat(self):
-        ...
-
-    class __get_serialized_function_spec(typing_extensions.Protocol):
-        def __call__(self) -> typing.Tuple[typing.Union[typing.Any, None], typing.Callable]:
-            ...
-
-        async def aio(self, *args, **kwargs) -> typing.Tuple[typing.Union[typing.Any, None], typing.Callable]:
-            ...
-
-    get_serialized_function: __get_serialized_function_spec
-
-    def serialize(self, obj: typing.Any) -> bytes:
-        ...
-
-    def deserialize(self, data: bytes) -> typing.Any:
-        ...
-
-    def serialize_data_format(self, obj: typing.Any, data_format: int) -> bytes:
-        ...
-
-    def deserialize_data_format(self, data: bytes, data_format: int) -> typing.Any:
-        ...
-
-    class __get_data_in_spec(typing_extensions.Protocol):
-        def __call__(self, function_call_id: str) -> typing.Iterator[typing.Any]:
-            ...
-
-        def aio(self, function_call_id: str) -> typing.AsyncIterator[typing.Any]:
-            ...
-
-    get_data_in: __get_data_in_spec
-
-    class __put_data_out_spec(typing_extensions.Protocol):
-        def __call__(self, function_call_id: str, start_index: int, data_format: int, messages_bytes: typing.List[typing.Any]) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
-
-    put_data_out: __put_data_out_spec
-
-    class __generator_output_task_spec(typing_extensions.Protocol):
-        def __call__(self, function_call_id: str, data_format: int, message_rx: asyncio.queues.Queue) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
-
-    generator_output_task: __generator_output_task_spec
-
-    class ___queue_create_spec(typing_extensions.Protocol):
-        def __call__(self, size: int) -> asyncio.queues.Queue:
-            ...
-
-        async def aio(self, *args, **kwargs) -> asyncio.queues.Queue:
-            ...
-
-    _queue_create: ___queue_create_spec
-
-    class ___queue_put_spec(typing_extensions.Protocol):
-        def __call__(self, queue: asyncio.queues.Queue, value: typing.Any) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
-
-    _queue_put: ___queue_put_spec
-
-    class __populate_input_blobs_spec(typing_extensions.Protocol):
-        def __call__(self, item: modal_proto.api_pb2.FunctionInput):
-            ...
-
-        async def aio(self, *args, **kwargs):
-            ...
-
-    populate_input_blobs: __populate_input_blobs_spec
-
-    def get_average_call_time(self) -> float:
-        ...
-
-    def get_max_inputs_to_fetch(self):
-        ...
-
-    class ___generate_inputs_spec(typing_extensions.Protocol):
-        def __call__(self) -> typing.Iterator[typing.Tuple[str, str, modal_proto.api_pb2.FunctionInput]]:
-            ...
-
-        def aio(self) -> typing.AsyncIterator[typing.Tuple[str, str, modal_proto.api_pb2.FunctionInput]]:
-            ...
-
-    _generate_inputs: ___generate_inputs_spec
-
-    class __run_inputs_outputs_spec(typing_extensions.Protocol):
-        def __call__(self, input_concurrency: int = 1) -> typing.Iterator[typing.Tuple[str, str, typing.Any, typing.Any]]:
-            ...
-
-        def aio(self, input_concurrency: int = 1) -> typing.AsyncIterator[typing.Tuple[str, str, typing.Any, typing.Any]]:
-            ...
-
-    run_inputs_outputs: __run_inputs_outputs_spec
-
-    class ___push_output_spec(typing_extensions.Protocol):
-        def __call__(self, input_id, started_at: float, data_format=0, **kwargs):
-            ...
-
-        async def aio(self, *args, **kwargs):
-            ...
-
-    _push_output: ___push_output_spec
-
-    def serialize_exception(self, exc: BaseException) -> typing.Union[bytes, None]:
-        ...
-
-    def serialize_traceback(self, exc: BaseException) -> typing.Tuple[typing.Union[bytes, None], typing.Union[bytes, None]]:
-        ...
-
-    class __handle_user_exception_spec(typing_extensions.Protocol):
-        def __call__(self) -> typing.Generator[None, None, None]:
-            ...
-
-        def aio(self) -> typing.AsyncGenerator[None, None]:
-            ...
-
-    handle_user_exception: __handle_user_exception_spec
-
-    class __handle_input_exception_spec(typing_extensions.Protocol):
-        def __call__(self, input_id, started_at: float) -> typing.Generator[None, None, None]:
-            ...
-
-        def aio(self, input_id, started_at: float) -> typing.AsyncGenerator[None, None]:
-            ...
-
-    handle_input_exception: __handle_input_exception_spec
-
-    class __complete_call_spec(typing_extensions.Protocol):
-        def __call__(self, started_at):
-            ...
-
-        async def aio(self, *args, **kwargs):
-            ...
-
-    complete_call: __complete_call_spec
-
-    class __push_output_spec(typing_extensions.Protocol):
-        def __call__(self, input_id, started_at: float, data: typing.Any, data_format: int) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
-
-    push_output: __push_output_spec
-
-    class __restore_spec(typing_extensions.Protocol):
-        def __call__(self) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
-
-    restore: __restore_spec
-
-    class __checkpoint_spec(typing_extensions.Protocol):
-        def __call__(self) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
-
-    checkpoint: __checkpoint_spec
-
-    class __volume_commit_spec(typing_extensions.Protocol):
-        def __call__(self, volume_ids: typing.List[str]) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
-
-    volume_commit: __volume_commit_spec
-
-
-def call_function_sync(function_io_manager, imp_fun: ImportedFunction):
-    ...
-
-
-async def call_function_async(function_io_manager, imp_fun: ImportedFunction):
-    ...
-
-
-class ImportedFunction:
-    obj: typing.Any
-    fun: typing.Callable
-    stub: typing.Union[modal.stub._Stub, None]
-    is_async: bool
-    is_generator: bool
-    data_format: int
-    input_concurrency: int
-    is_auto_snapshot: bool
-    function: modal.functions._Function
-
-    def __init__(self, obj: typing.Any, fun: typing.Callable, stub: typing.Union[modal.stub._Stub, None], is_async: bool, is_generator: bool, data_format: int, input_concurrency: int, is_auto_snapshot: bool, function: modal.functions._Function) -> None:
-        ...
-
-    def __repr__(self):
-        ...
-
-    def __eq__(self, other):
-        ...
-
-
-def import_function(function_def: modal_proto.api_pb2.Function, ser_cls, ser_fun, ser_params: typing.Union[bytes, None], function_io_manager, client: modal.client.Client) -> ImportedFunction:
-    ...
-
-
-def call_lifecycle_functions(event_loop: UserCodeEventLoop, function_io_manager, funcs: collections.abc.Iterable[typing.Callable]) -> None:
-    ...
-
-
-def main(container_args: modal_proto.api_pb2.ContainerArguments, client: modal.client.Client):
-    ...
-
-
-MAX_OUTPUT_BATCH_SIZE: 'int'
-
-RTT_S: 'float'

modal/_container_exec.py

@@ -1,128 +0,0 @@
-# Copyright Modal Labs 2024
-import asyncio
-import platform
-from typing import List, Optional
-
-import rich
-import rich.status
-from grpclib import Status
-from grpclib.exceptions import GRPCError, StreamTerminatedError
-from rich.console import Console
-
-from modal_proto import api_pb2
-
-from ._pty import get_pty_info
-from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES, retry_transient_errors, unary_stream
-from ._utils.shell_utils import connect_to_terminal, write_to_fd
-from .client import _Client
-from .config import config
-from .exception import NotFoundError
-
-
-async def container_exec(task_id: str, command: List[str], *, pty: bool, client: _Client):
-    """Execute a command inside an active container"""
-    if platform.system() == "Windows":
-        print("container exec is not currently supported on Windows.")
-        return
-
-    client = await _Client.from_env()
-
-    console = Console()
-    connecting_status = console.status("Connecting...")
-    connecting_status.start()
-
-    try:
-        res: api_pb2.ContainerExecResponse = await client.stub.ContainerExec(
-            api_pb2.ContainerExecRequest(
-                task_id=task_id,
-                command=command,
-                pty_info=get_pty_info(shell=True) if pty else None,
-                runtime_debug=config.get("function_runtime_debug"),
-            )
-        )
-    except GRPCError as err:
-        connecting_status.stop()
-        if err.status == Status.NOT_FOUND:
-            raise NotFoundError(f"Container ID {task_id} not found")
-        raise
-
-    await connect_to_exec(res.exec_id, pty, connecting_status)
-
-
-async def connect_to_exec(exec_id: str, pty: bool = False, connecting_status: Optional[rich.status.Status] = None):
-    """
-    Connects the current terminal to the given exec id.
-
-    If connecting_status is given, this function will stop the status spinner upon connection or error.
-    """
-
-    client = await _Client.from_env()
-
-    async def _stream_to_stdout(on_connect: asyncio.Event) -> int:
-        return await _handle_exec_output(client, exec_id, on_connect)
-
-    async def _handle_input(data: bytes, message_index: int):
-        await retry_transient_errors(
-            client.stub.ContainerExecPutInput,
-            api_pb2.ContainerExecPutInputRequest(
-                exec_id=exec_id, input=api_pb2.RuntimeInputMessage(message=data, message_index=message_index)
-            ),
-            total_timeout=10,
-        )
-
-    await connect_to_terminal(_handle_input, _stream_to_stdout, pty, connecting_status)
-
-
-async def _handle_exec_output(client: _Client, exec_id: str, on_connect: Optional[asyncio.Event] = None) -> int:
-    """
-    Streams exec output to current terminal's stdout.
-
-    The on_connect event will be set when the client connects to the running process,
-    and the event loop will be released.
-
-    Returns the status code of the process.
-    """
-
-    last_batch_index = 0
-    exit_status = None
-
-    # we are connected if we received at least one message from the server
-    # (the server will send an empty message when the process spawns)
-    connected = False
-
-    async def _get_output():
-        nonlocal last_batch_index, exit_status, connected
-        req = api_pb2.ContainerExecGetOutputRequest(
-            exec_id=exec_id,
-            timeout=55,
-            last_batch_index=last_batch_index,
-        )
-        async for batch in unary_stream(client.stub.ContainerExecGetOutput, req):
-            for message in batch.items:
-                assert message.file_descriptor in [1, 2]
-
-                await write_to_fd(message.file_descriptor, str.encode(message.message))
-
-            if not connected:
-                connected = True
-                on_connect.set()
-                # give up the event loop
-                await asyncio.sleep(0)
-
-            if batch.HasField("exit_code"):
-                exit_status = batch.exit_code
-                break
-            last_batch_index = batch.batch_index
-
-    while exit_status is None:
-        try:
-            await _get_output()
-        except (GRPCError, StreamTerminatedError) as exc:
-            if isinstance(exc, GRPCError):
-                if exc.status in RETRYABLE_GRPC_STATUS_CODES:
-                    continue
-            elif isinstance(exc, StreamTerminatedError):
-                continue
-            raise
-
-    return exit_status

modal/_sandbox_shell.py

@@ -1,49 +0,0 @@
-# Copyright Modal Labs 2024
-import asyncio
-
-from ._utils.shell_utils import connect_to_terminal, write_to_fd
-from .sandbox import _Sandbox
-
-
-async def connect_to_sandbox(sandbox: _Sandbox):
-    """
-    Connects the current terminal to the Sandbox process.
-    """
-
-    async def _handle_input(data: bytes, _):
-        sandbox.stdin.write(data)
-        await sandbox.stdin.drain.aio()  # type: ignore
-
-    async def _stream_to_stdout(on_connect: asyncio.Event) -> int:
-        return await _stream_logs_to_stdout(sandbox, on_connect)
-
-    await connect_to_terminal(_handle_input, _stream_to_stdout, pty=True)
-
-
-async def _stream_logs_to_stdout(sandbox: _Sandbox, on_connect: asyncio.Event) -> int:
-    """
-    Streams sandbox output logs to the current terminal's stdout.
-
-    The on_connect event will be set when the client connects to the running process,
-    and the event loop will be released.
-    """
-
-    # we are connected if we received at least one message from the server
-    # (the server will send an empty message when the process spawns)
-    connected = False
-
-    # Since the sandbox process will run in a PTY, stderr will go to the PTY
-    # slave. The PTY shell will then relay data from PTY master to stdout.
-    # Therefore, we only need to stream from/to stdout here.
-    async for message in sandbox.stdout:
-        await write_to_fd(1, message.encode("utf-8"))
-
-        if not connected:
-            connected = True
-            on_connect.set()
-            # give up the event loop
-            await asyncio.sleep(0)
-
-    # Right now we don't propagate the exit_status to the TaskLogs, so setting
-    # exit status to 0.
-    return 0

modal/shared_volume.py

@@ -1,23 +0,0 @@
-# Copyright Modal Labs 2023
-
-from ._utils.async_utils import synchronize_api
-from .exception import deprecation_error
-
-
-class _SharedVolume:
-    def __init__(self, *args, **kwargs):
-        """`SharedVolume` is deprecated. We recommend `Volume` (https://modal.com/docs/guide/volumes) instead."""
-        deprecation_error((2023, 7, 5), _SharedVolume.__init__.__doc__)
-
-    @staticmethod
-    def new(*args, **kwargs):
-        """`SharedVolume` is deprecated. We recommend `Volume` (https://modal.com/docs/guide/volumes) instead."""
-        deprecation_error((2023, 7, 5), _SharedVolume.new.__doc__)
-
-    @staticmethod
-    def persisted(*args, **kwargs):
-        """`SharedVolume` is deprecated. We recommend `Volume` (https://modal.com/docs/guide/volumes) instead."""
-        deprecation_error((2023, 7, 5), _SharedVolume.persisted.__doc__)
-
-
-SharedVolume = synchronize_api(_SharedVolume)

modal/shared_volume.pyi

@@ -1,24 +0,0 @@
-class _SharedVolume:
-    def __init__(self, *args, **kwargs):
-        ...
-
-    @staticmethod
-    def new(*args, **kwargs):
-        ...
-
-    @staticmethod
-    def persisted(*args, **kwargs):
-        ...
-
-
-class SharedVolume:
-    def __init__(self, *args, **kwargs):
-        ...
-
-    @staticmethod
-    def new(*args, **kwargs):
-        ...
-
-    @staticmethod
-    def persisted(*args, **kwargs):
-        ...