modal 0.73.45__py3-none-any.whl → 0.73.47__py3-none-any.whl

modal/_runtime/container_io_manager.pyi

@@ -0,0 +1,395 @@
+import asyncio
+import asyncio.locks
+import asyncio.queues
+import collections.abc
+import modal._runtime.user_code_imports
+import modal.client
+import modal_proto.api_pb2
+import synchronicity.combined_types
+import typing
+import typing_extensions
+
+class UserException(Exception): ...
+class Sentinel: ...
+
+class IOContext:
+    input_ids: list[str]
+    function_call_ids: list[str]
+    finalized_function: modal._runtime.user_code_imports.FinalizedFunction
+    _cancel_issued: bool
+    _cancel_callback: typing.Optional[collections.abc.Callable[[], None]]
+
+    def __init__(
+        self,
+        input_ids: list[str],
+        function_call_ids: list[str],
+        finalized_function: modal._runtime.user_code_imports.FinalizedFunction,
+        function_inputs: list[modal_proto.api_pb2.FunctionInput],
+        is_batched: bool,
+        client: modal.client._Client,
+    ): ...
+    @classmethod
+    async def create(
+        cls,
+        client: modal.client._Client,
+        finalized_functions: dict[str, modal._runtime.user_code_imports.FinalizedFunction],
+        inputs: list[tuple[str, str, modal_proto.api_pb2.FunctionInput]],
+        is_batched: bool,
+    ) -> IOContext: ...
+    def set_cancel_callback(self, cb: collections.abc.Callable[[], None]): ...
+    def cancel(self): ...
+    def _args_and_kwargs(self) -> tuple[tuple[typing.Any, ...], dict[str, list[typing.Any]]]: ...
+    def call_finalized_function(self) -> typing.Any: ...
+    def validate_output_data(self, data: typing.Any) -> list[typing.Any]: ...
+
+class InputSlots:
+    active: int
+    value: int
+    waiter: typing.Optional[asyncio.Future]
+    closed: bool
+
+    def __init__(self, value: int) -> None: ...
+    async def acquire(self) -> None: ...
+    def _wake_waiter(self) -> None: ...
+    def release(self) -> None: ...
+    def set_value(self, value: int) -> None: ...
+    async def close(self) -> None: ...
+
+class _ContainerIOManager:
+    task_id: str
+    function_id: str
+    app_id: str
+    function_def: modal_proto.api_pb2.Function
+    checkpoint_id: typing.Optional[str]
+    calls_completed: int
+    total_user_time: float
+    current_input_id: typing.Optional[str]
+    current_inputs: dict[str, IOContext]
+    current_input_started_at: typing.Optional[float]
+    _target_concurrency: int
+    _max_concurrency: int
+    _concurrency_loop: typing.Optional[asyncio.Task]
+    _input_slots: InputSlots
+    _environment_name: str
+    _heartbeat_loop: typing.Optional[asyncio.Task]
+    _heartbeat_condition: typing.Optional[asyncio.locks.Condition]
+    _waiting_for_memory_snapshot: bool
+    _is_interactivity_enabled: bool
+    _fetching_inputs: bool
+    _client: modal.client._Client
+    _GENERATOR_STOP_SENTINEL: typing.ClassVar[Sentinel]
+    _singleton: typing.ClassVar[typing.Optional[_ContainerIOManager]]
+
+    def _init(self, container_args: modal_proto.api_pb2.ContainerArguments, client: modal.client._Client): ...
+    @property
+    def heartbeat_condition(self) -> asyncio.locks.Condition: ...
+    @staticmethod
+    def __new__(
+        cls, container_args: modal_proto.api_pb2.ContainerArguments, client: modal.client._Client
+    ) -> _ContainerIOManager: ...
+    @classmethod
+    def _reset_singleton(cls): ...
+    async def hello(self): ...
+    async def _run_heartbeat_loop(self): ...
+    async def _heartbeat_handle_cancellations(self) -> bool: ...
+    def heartbeats(self, wait_for_mem_snap: bool) -> typing.AsyncContextManager[None]: ...
+    def stop_heartbeat(self): ...
+    def dynamic_concurrency_manager(self) -> typing.AsyncContextManager[None]: ...
+    async def _dynamic_concurrency_loop(self): ...
+    async def get_serialized_function(
+        self,
+    ) -> tuple[typing.Optional[typing.Any], typing.Optional[collections.abc.Callable[..., typing.Any]]]: ...
+    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: ...
+    async def format_blob_data(self, data: bytes) -> dict[str, typing.Any]: ...
+    def get_data_in(self, function_call_id: str) -> collections.abc.AsyncIterator[typing.Any]: ...
+    async def put_data_out(
+        self, function_call_id: str, start_index: int, data_format: int, serialized_messages: 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: ...
+    def get_average_call_time(self) -> float: ...
+    def get_max_inputs_to_fetch(self): ...
+    def _generate_inputs(
+        self, batch_max_size: int, batch_wait_ms: int
+    ) -> collections.abc.AsyncIterator[list[tuple[str, str, modal_proto.api_pb2.FunctionInput]]]: ...
+    def run_inputs_outputs(
+        self,
+        finalized_functions: dict[str, modal._runtime.user_code_imports.FinalizedFunction],
+        batch_max_size: int = 0,
+        batch_wait_ms: int = 0,
+    ) -> collections.abc.AsyncIterator[IOContext]: ...
+    async def _push_outputs(
+        self,
+        io_context: IOContext,
+        started_at: float,
+        data_format: int,
+        results: list[modal_proto.api_pb2.GenericResult],
+    ) -> None: ...
+    def serialize_exception(self, exc: BaseException) -> bytes: ...
+    def serialize_traceback(self, exc: BaseException) -> tuple[typing.Optional[bytes], typing.Optional[bytes]]: ...
+    def handle_user_exception(self) -> typing.AsyncContextManager[None]: ...
+    def handle_input_exception(self, io_context: IOContext, started_at: float) -> typing.AsyncContextManager[None]: ...
+    def exit_context(self, started_at, input_ids: list[str]): ...
+    async def push_outputs(
+        self, io_context: IOContext, started_at: float, data: typing.Any, data_format: int
+    ) -> None: ...
+    async def memory_restore(self) -> None: ...
+    async def memory_snapshot(self) -> None: ...
+    async def volume_commit(self, volume_ids: list[str]) -> None: ...
+    async def interact(self, from_breakpoint: bool = False): ...
+    @property
+    def target_concurrency(self) -> int: ...
+    @property
+    def max_concurrency(self) -> int: ...
+    @classmethod
+    def get_input_concurrency(cls) -> int: ...
+    @classmethod
+    def set_input_concurrency(cls, concurrency: int): ...
+    @classmethod
+    def stop_fetching_inputs(cls): ...
+
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
+class ContainerIOManager:
+    task_id: str
+    function_id: str
+    app_id: str
+    function_def: modal_proto.api_pb2.Function
+    checkpoint_id: typing.Optional[str]
+    calls_completed: int
+    total_user_time: float
+    current_input_id: typing.Optional[str]
+    current_inputs: dict[str, IOContext]
+    current_input_started_at: typing.Optional[float]
+    _target_concurrency: int
+    _max_concurrency: int
+    _concurrency_loop: typing.Optional[asyncio.Task]
+    _input_slots: InputSlots
+    _environment_name: str
+    _heartbeat_loop: typing.Optional[asyncio.Task]
+    _heartbeat_condition: typing.Optional[asyncio.locks.Condition]
+    _waiting_for_memory_snapshot: bool
+    _is_interactivity_enabled: bool
+    _fetching_inputs: bool
+    _client: modal.client.Client
+    _GENERATOR_STOP_SENTINEL: typing.ClassVar[Sentinel]
+    _singleton: typing.ClassVar[typing.Optional[ContainerIOManager]]
+
+    def __init__(self, /, *args, **kwargs): ...
+    def _init(self, container_args: modal_proto.api_pb2.ContainerArguments, client: modal.client.Client): ...
+    @property
+    def heartbeat_condition(self) -> asyncio.locks.Condition: ...
+    @classmethod
+    def _reset_singleton(cls): ...
+
+    class __hello_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self): ...
+        async def aio(self): ...
+
+    hello: __hello_spec[typing_extensions.Self]
+
+    class ___run_heartbeat_loop_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self): ...
+        async def aio(self): ...
+
+    _run_heartbeat_loop: ___run_heartbeat_loop_spec[typing_extensions.Self]
+
+    class ___heartbeat_handle_cancellations_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self) -> bool: ...
+        async def aio(self) -> bool: ...
+
+    _heartbeat_handle_cancellations: ___heartbeat_handle_cancellations_spec[typing_extensions.Self]
+
+    class __heartbeats_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self, wait_for_mem_snap: bool
+        ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
+        def aio(self, wait_for_mem_snap: bool) -> typing.AsyncContextManager[None]: ...
+
+    heartbeats: __heartbeats_spec[typing_extensions.Self]
+
+    def stop_heartbeat(self): ...
+
+    class __dynamic_concurrency_manager_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
+        def aio(self) -> typing.AsyncContextManager[None]: ...
+
+    dynamic_concurrency_manager: __dynamic_concurrency_manager_spec[typing_extensions.Self]
+
+    class ___dynamic_concurrency_loop_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self): ...
+        async def aio(self): ...
+
+    _dynamic_concurrency_loop: ___dynamic_concurrency_loop_spec[typing_extensions.Self]
+
+    class __get_serialized_function_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self,
+        ) -> tuple[typing.Optional[typing.Any], typing.Optional[collections.abc.Callable[..., typing.Any]]]: ...
+        async def aio(
+            self,
+        ) -> tuple[typing.Optional[typing.Any], typing.Optional[collections.abc.Callable[..., typing.Any]]]: ...
+
+    get_serialized_function: __get_serialized_function_spec[typing_extensions.Self]
+
+    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: ...
+
+    class __format_blob_data_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, data: bytes) -> dict[str, typing.Any]: ...
+        async def aio(self, data: bytes) -> dict[str, typing.Any]: ...
+
+    format_blob_data: __format_blob_data_spec[typing_extensions.Self]
+
+    class __get_data_in_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, function_call_id: str) -> typing.Iterator[typing.Any]: ...
+        def aio(self, function_call_id: str) -> collections.abc.AsyncIterator[typing.Any]: ...
+
+    get_data_in: __get_data_in_spec[typing_extensions.Self]
+
+    class __put_data_out_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self, function_call_id: str, start_index: int, data_format: int, serialized_messages: list[typing.Any]
+        ) -> None: ...
+        async def aio(
+            self, function_call_id: str, start_index: int, data_format: int, serialized_messages: list[typing.Any]
+        ) -> None: ...
+
+    put_data_out: __put_data_out_spec[typing_extensions.Self]
+
+    class __generator_output_task_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, function_call_id: str, data_format: int, message_rx: asyncio.queues.Queue) -> None: ...
+        async def aio(self, function_call_id: str, data_format: int, message_rx: asyncio.queues.Queue) -> None: ...
+
+    generator_output_task: __generator_output_task_spec[typing_extensions.Self]
+
+    class ___queue_create_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, size: int) -> asyncio.queues.Queue: ...
+        async def aio(self, size: int) -> asyncio.queues.Queue: ...
+
+    _queue_create: ___queue_create_spec[typing_extensions.Self]
+
+    class ___queue_put_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, queue: asyncio.queues.Queue, value: typing.Any) -> None: ...
+        async def aio(self, queue: asyncio.queues.Queue, value: typing.Any) -> None: ...
+
+    _queue_put: ___queue_put_spec[typing_extensions.Self]
+
+    def get_average_call_time(self) -> float: ...
+    def get_max_inputs_to_fetch(self): ...
+
+    class ___generate_inputs_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self, batch_max_size: int, batch_wait_ms: int
+        ) -> typing.Iterator[list[tuple[str, str, modal_proto.api_pb2.FunctionInput]]]: ...
+        def aio(
+            self, batch_max_size: int, batch_wait_ms: int
+        ) -> collections.abc.AsyncIterator[list[tuple[str, str, modal_proto.api_pb2.FunctionInput]]]: ...
+
+    _generate_inputs: ___generate_inputs_spec[typing_extensions.Self]
+
+    class __run_inputs_outputs_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self,
+            finalized_functions: dict[str, modal._runtime.user_code_imports.FinalizedFunction],
+            batch_max_size: int = 0,
+            batch_wait_ms: int = 0,
+        ) -> typing.Iterator[IOContext]: ...
+        def aio(
+            self,
+            finalized_functions: dict[str, modal._runtime.user_code_imports.FinalizedFunction],
+            batch_max_size: int = 0,
+            batch_wait_ms: int = 0,
+        ) -> collections.abc.AsyncIterator[IOContext]: ...
+
+    run_inputs_outputs: __run_inputs_outputs_spec[typing_extensions.Self]
+
+    class ___push_outputs_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self,
+            io_context: IOContext,
+            started_at: float,
+            data_format: int,
+            results: list[modal_proto.api_pb2.GenericResult],
+        ) -> None: ...
+        async def aio(
+            self,
+            io_context: IOContext,
+            started_at: float,
+            data_format: int,
+            results: list[modal_proto.api_pb2.GenericResult],
+        ) -> None: ...
+
+    _push_outputs: ___push_outputs_spec[typing_extensions.Self]
+
+    def serialize_exception(self, exc: BaseException) -> bytes: ...
+    def serialize_traceback(self, exc: BaseException) -> tuple[typing.Optional[bytes], typing.Optional[bytes]]: ...
+
+    class __handle_user_exception_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
+        def aio(self) -> typing.AsyncContextManager[None]: ...
+
+    handle_user_exception: __handle_user_exception_spec[typing_extensions.Self]
+
+    class __handle_input_exception_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self, io_context: IOContext, started_at: float
+        ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
+        def aio(self, io_context: IOContext, started_at: float) -> typing.AsyncContextManager[None]: ...
+
+    handle_input_exception: __handle_input_exception_spec[typing_extensions.Self]
+
+    def exit_context(self, started_at, input_ids: list[str]): ...
+
+    class __push_outputs_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, io_context: IOContext, started_at: float, data: typing.Any, data_format: int) -> None: ...
+        async def aio(self, io_context: IOContext, started_at: float, data: typing.Any, data_format: int) -> None: ...
+
+    push_outputs: __push_outputs_spec[typing_extensions.Self]
+
+    class __memory_restore_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self) -> None: ...
+        async def aio(self) -> None: ...
+
+    memory_restore: __memory_restore_spec[typing_extensions.Self]
+
+    class __memory_snapshot_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self) -> None: ...
+        async def aio(self) -> None: ...
+
+    memory_snapshot: __memory_snapshot_spec[typing_extensions.Self]
+
+    class __volume_commit_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, volume_ids: list[str]) -> None: ...
+        async def aio(self, volume_ids: list[str]) -> None: ...
+
+    volume_commit: __volume_commit_spec[typing_extensions.Self]
+
+    class __interact_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, from_breakpoint: bool = False): ...
+        async def aio(self, from_breakpoint: bool = False): ...
+
+    interact: __interact_spec[typing_extensions.Self]
+
+    @property
+    def target_concurrency(self) -> int: ...
+    @property
+    def max_concurrency(self) -> int: ...
+    @classmethod
+    def get_input_concurrency(cls) -> int: ...
+    @classmethod
+    def set_input_concurrency(cls, concurrency: int): ...
+    @classmethod
+    def stop_fetching_inputs(cls): ...
+
+def check_fastapi_pydantic_compatibility(exc: ImportError) -> None: ...
+
+MAX_OUTPUT_BATCH_SIZE: int
+
+RTT_S: float

modal/_runtime/execution_context.pyi

@@ -0,0 +1,23 @@
+import collections.abc
+import contextvars
+import typing
+import typing_extensions
+
+def is_local() -> bool: ...
+async def _interact() -> None: ...
+
+class __interact_spec(typing_extensions.Protocol):
+    def __call__(self) -> None: ...
+    async def aio(self) -> None: ...
+
+interact: __interact_spec
+
+def current_input_id() -> typing.Optional[str]: ...
+def current_function_call_id() -> typing.Optional[str]: ...
+def _set_current_context_ids(
+    input_ids: list[str], function_call_ids: list[str]
+) -> collections.abc.Callable[[], None]: ...
+
+_current_input_id: contextvars.ContextVar
+
+_current_function_call_id: contextvars.ContextVar

modal/client.pyi

@@ -27,7 +27,7 @@ class _Client:
     _snapshotted: bool
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.45"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.47"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -85,7 +85,7 @@ class Client:
     _snapshotted: bool
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.45"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.47"
     ): ...
     def is_closed(self) -> bool: ...
     @property

{modal-0.73.45.dist-info → modal-0.73.47.dist-info}/METADATA

@@ -1,11 +1,13 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: modal
-Version: 0.73.45
+Version: 0.73.47
 Summary: Python client library for Modal
-Author: Modal Labs
-Author-email: support@modal.com
+Author-email: Modal Labs <support@modal.com>
+License: Apache-2.0
 Project-URL: Homepage, https://modal.com
 Project-URL: Source, https://github.com/modal-labs/modal-client
+Project-URL: Documentation, https://modal.com/docs
+Project-URL: Issue Tracker, https://github.com/modal-labs/modal-client/issues
 Keywords: modal,client,cloud,serverless,infrastructure
 Classifier: Topic :: System :: Distributed Computing
 Classifier: Operating System :: OS Independent
@@ -16,18 +18,18 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
 Requires-Dist: certifi
-Requires-Dist: click (>=8.1.0)
+Requires-Dist: click>=8.1.0
 Requires-Dist: fastapi
-Requires-Dist: grpclib (==0.4.7)
-Requires-Dist: protobuf (!=4.24.0,<6.0,>=3.19)
-Requires-Dist: rich (>=12.0.0)
-Requires-Dist: synchronicity (~=0.9.10)
+Requires-Dist: grpclib==0.4.7
+Requires-Dist: protobuf!=4.24.0,<6.0,>=3.19
+Requires-Dist: rich>=12.0.0
+Requires-Dist: synchronicity~=0.9.10
 Requires-Dist: toml
-Requires-Dist: typer (>=0.9)
+Requires-Dist: typer>=0.9
 Requires-Dist: types-certifi
 Requires-Dist: types-toml
 Requires-Dist: watchfiles
-Requires-Dist: typing-extensions (~=4.6)
+Requires-Dist: typing_extensions~=4.6
 
 # Modal Python Library
 

{modal-0.73.45.dist-info → modal-0.73.47.dist-info}/RECORD

@@ -22,7 +22,7 @@ modal/app.py,sha256=rCOPD51gVyow8muyaqMuV65qfTnAZKf_w1OCZdSF_6o,44636
 modal/app.pyi,sha256=0MMCgskIL4r3eq8oBcfm2lLyeao2gXjS3iXaIfmaJ-o,25959
 modal/call_graph.py,sha256=1g2DGcMIJvRy-xKicuf63IVE98gJSnQsr8R_NVMptNc,2581
 modal/client.py,sha256=8SQawr7P1PNUCq1UmJMUQXG2jIo4Nmdcs311XqrNLRE,15276
-modal/client.pyi,sha256=auqDL4NLiTWcJcrVMcKSQjtJyQ0CaDj0RXJOPjg_j_4,7593
+modal/client.pyi,sha256=5qG22FLFyDb4OjKfcnpVlfFwBYCVD6O_SzR9Rh2llaA,7593
 modal/cloud_bucket_mount.py,sha256=YOe9nnvSr4ZbeCn587d7_VhE9IioZYRvF9VYQTQux08,5914
 modal/cloud_bucket_mount.pyi,sha256=30T3K1a89l6wzmEJ_J9iWv9SknoGqaZDx59Xs-ZQcmk,1607
 modal/cls.py,sha256=nJhJr-YuttOmdNWxtMHcBV-q6iQmY5qXkEy9yO43clY,31130
@@ -85,7 +85,9 @@ modal/volume.pyi,sha256=kTsXarphjZILXci84LQy7EyC84eXUs5-7D62IM5q3eE,12491
 modal/_runtime/__init__.py,sha256=MIEP8jhXUeGq_eCjYFcqN5b1bxBM4fdk0VESpjWR0fc,28
 modal/_runtime/asgi.py,sha256=vIxpGrCZhdeThwazQckmrqoNKgDQYOyv8emzBHr8CiU,22154
 modal/_runtime/container_io_manager.py,sha256=3VPj0RWtSdvVZD96l5ZpO8MjhLRjAi_P_ZtpNK3nGn0,43593
+modal/_runtime/container_io_manager.pyi,sha256=sEGpOvlDOQCwUiJn4CAyE8TT2lCBKNBEqGWExfvVKsY,16661
 modal/_runtime/execution_context.py,sha256=E6ofm6j1POXGPxS841X3V7JU6NheVb8OkQc7JpLq4Kg,2712
+modal/_runtime/execution_context.pyi,sha256=wQZwMNADExkeNdB9yKX0PPojovxlFHbap3441wAsiMY,634
 modal/_runtime/gpu_memory_snapshot.py,sha256=tA3m1d1cwnmHpvpCeN_WijDd6n8byn7LWlpicbIxiOI,3144
 modal/_runtime/telemetry.py,sha256=T1RoAGyjBDr1swiM6pPsGRSITm7LI5FDK18oNXxY08U,5163
 modal/_runtime/user_code_imports.py,sha256=qDasIvffN3SJjUeT1DHcpN35lWNepnbomS0Z8yD65mA,14740
@@ -145,15 +147,6 @@ modal/requirements/base-images.json,sha256=kLNo5Sqmnhp9H6Hr9IcaGJFrRaRg1yfuepUWk
 modal_docs/__init__.py,sha256=svYKtV8HDwDCN86zbdWqyq5T8sMdGDj0PVlzc2tIxDM,28
 modal_docs/gen_cli_docs.py,sha256=c1yfBS_x--gL5bs0N4ihMwqwX8l3IBWSkBAKNNIi6bQ,3801
 modal_docs/gen_reference_docs.py,sha256=aDcUSSDtAAZ4eeFWyroeIg2TOzyRoYcic-d9Zh9TdLY,6656
-modal_docs/mdmd/__init__.py,sha256=svYKtV8HDwDCN86zbdWqyq5T8sMdGDj0PVlzc2tIxDM,28
-modal_docs/mdmd/mdmd.py,sha256=Irx49MCCTlBOP4FBdLR--JrpA3-WhsVeriq0LGgsRic,6232
-modal_docs/mdmd/signatures.py,sha256=XJaZrK7Mdepk5fdX51A8uENiLFNil85Ud0d4MH8H5f0,3218
-modal_global_objects/__init__.py,sha256=waLjl5c6IPDhSsdWAm9Bji4e2PVxamYABKAze6CHVXY,28
-modal_global_objects/images/__init__.py,sha256=MIEP8jhXUeGq_eCjYFcqN5b1bxBM4fdk0VESpjWR0fc,28
-modal_global_objects/images/base_images.py,sha256=tFc7tzQRJHtq23kURd6DTrnnO4Yp5ujr34WdJOM5ubI,775
-modal_global_objects/mounts/__init__.py,sha256=MIEP8jhXUeGq_eCjYFcqN5b1bxBM4fdk0VESpjWR0fc,28
-modal_global_objects/mounts/modal_client_package.py,sha256=W0E_yShsRojPzWm6LtIQqNVolapdnrZkm2hVEQuZK_4,767
-modal_global_objects/mounts/python_standalone.py,sha256=EsC-hdPtiAPOwgW9emHN6muNUkrJwR8dYxroVArxHxM,1841
 modal_proto/__init__.py,sha256=MIEP8jhXUeGq_eCjYFcqN5b1bxBM4fdk0VESpjWR0fc,28
 modal_proto/api.proto,sha256=hM-iLwpYycp-wGyvoAieAEM_km42yI0jZTigPQLGPC0,86712
 modal_proto/api_grpc.py,sha256=FYGqDegM_w_qxdtlxum8k31mDibKoMvmNxv_p9cKdKs,109056
@@ -172,10 +165,10 @@ modal_proto/options_pb2_grpc.pyi,sha256=CImmhxHsYnF09iENPoe8S4J-n93jtgUYD2JPAc0y
 modal_proto/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modal_version/__init__.py,sha256=wiJQ53c-OMs0Xf1UeXOxQ7FwlV1VzIjnX6o-pRYZ_Pk,470
 modal_version/__main__.py,sha256=2FO0yYQQwDTh6udt1h-cBnGd1c4ZyHnHSI4BksxzVac,105
-modal_version/_version_generated.py,sha256=KzBJR6EWPHfnPgT45aPYm-Hu5W_vWqPf0yWE9zA_9Eo,149
-modal-0.73.45.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
-modal-0.73.45.dist-info/METADATA,sha256=rJaXkmB-BGugmy1eUIL63_OjD0nC7LP6aPWOqYNAYK8,2330
-modal-0.73.45.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-modal-0.73.45.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-0.73.45.dist-info/top_level.txt,sha256=1nvYbOSIKcmU50fNrpnQnrrOpj269ei3LzgB6j9xGqg,64
-modal-0.73.45.dist-info/RECORD,,
+modal_version/_version_generated.py,sha256=5cj8cqKxfu-44XR4MQVL7vocSJ_677tLG2jtW72Zc7U,149
+modal-0.73.47.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-0.73.47.dist-info/METADATA,sha256=JSgSze5rgpMBFjrdIbIjQqqlzvFPjddyU-bPzU206I4,2452
+modal-0.73.47.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+modal-0.73.47.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-0.73.47.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
+modal-0.73.47.dist-info/RECORD,,

{modal-0.73.45.dist-info → modal-0.73.47.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{modal-0.73.45.dist-info → modal-0.73.47.dist-info}/top_level.txt

@@ -1,5 +1,4 @@
 modal
 modal_docs
-modal_global_objects
 modal_proto
 modal_version

modal_version/_version_generated.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2025
 
 # Note: Reset this value to -1 whenever you make a minor `0.X` release of the client.
-build_number = 45  # git: 9481268
+build_number = 47  # git: 985591d

modal_docs/mdmd/__init__.py

@@ -1 +0,0 @@
-# Copyright Modal Labs 2023

modal_docs/mdmd/mdmd.py

@@ -1,195 +0,0 @@
-# Copyright Modal Labs 2023
-"""mdmd - MoDal MarkDown"""
-
-import inspect
-import warnings
-from enum import Enum, EnumMeta
-from types import ModuleType
-from typing import Callable
-
-import synchronicity.synchronizer
-
-from .signatures import get_signature
-
-
-def format_docstring(docstring: str):
-    if docstring is None:
-        docstring = ""
-    else:
-        docstring = inspect.cleandoc(docstring)
-
-    if docstring and not docstring.endswith("\n"):
-        docstring += "\n"
-
-    return docstring
-
-
-def function_str(name: str, func):
-    signature = get_signature(name, func)
-    decl = f"""```python
-{signature}
-```\n\n"""
-    docstring = format_docstring(func.__doc__)
-    return decl + docstring
-
-
-def class_str(name, obj, title_level="##"):
-    def qual_name(cls):
-        if cls.__module__ == "builtins":
-            return cls.__name__
-        return f"{cls.__module__}.{cls.__name__}"
-
-    bases = [qual_name(b) for b in obj.__bases__]
-    bases_str = f"({', '.join(bases)})" if bases else ""
-    decl = f"""```python
-class {name}{bases_str}
-```\n\n"""
-    parts = [decl]
-    docstring = format_docstring(obj.__doc__)
-
-    if isinstance(obj, EnumMeta) and not docstring:
-        # Python 3.11 removed the docstring from enums
-        docstring = "An enumeration.\n"
-
-    if docstring:
-        parts.append(docstring + "\n")
-
-    if isinstance(obj, EnumMeta):
-        enum_vals = "\n".join(f"* `{k}`" for k in obj.__members__.keys())
-        parts.append(f"The possible values are:\n\n{enum_vals}\n")
-
-    else:
-        init = inspect.unwrap(obj.__init__)
-
-        if (inspect.isfunction(init) or inspect.ismethod(init)) and not object_is_private("constructor", init):
-            parts.append(function_str("__init__", init))
-
-    member_title_level = title_level + "#"
-
-    entries = {}
-
-    def rec_update_attributes(cls):
-        # first bases, then class itself
-        for base_cls in cls.__bases__:
-            rec_update_attributes(base_cls)
-        entries.update(cls.__dict__)
-
-    rec_update_attributes(obj)
-
-    for member_name, member in entries.items():
-        if isinstance(member, classmethod) or isinstance(member, staticmethod):
-            # get the original function definition instead of the descriptor object
-            member = getattr(obj, member_name)
-        elif isinstance(member, property):
-            member = member.fget
-        elif isinstance(member, (synchronicity.synchronizer.FunctionWithAio, synchronicity.synchronizer.MethodWithAio)):
-            member = member._func
-
-        if object_is_private(member_name, member):
-            continue
-
-        if callable(member):
-            parts.append(f"{member_title_level} {member_name}\n\n")
-            parts.append(function_str(member_name, member))
-
-    return "".join(parts)
-
-
-def module_str(header, module, title_level="#", filter_items: Callable[[ModuleType, str], bool] = None):
-    header = [f"{title_level} {header}\n\n"]
-    docstring = format_docstring(module.__doc__)
-    if docstring:
-        header.append(docstring + "\n")
-
-    object_docs = []
-    member_title_level = title_level + "#"
-    for qual_name, name, item in module_items(module, filter_items):
-        try:
-            if hasattr(item, "__wrapped__"):
-                item = item.__wrapped__
-        except KeyError:
-            pass
-        except:
-            print("failed on", qual_name, name, item)
-            raise
-        if inspect.isclass(item):
-            classdoc = class_str(name, item, title_level=member_title_level)
-            object_docs.append(f"{member_title_level} {qual_name}\n\n")
-            object_docs.append(classdoc)
-        elif callable(item):
-            funcdoc = function_str(name, item)
-            object_docs.append(f"{member_title_level} {qual_name}\n\n")
-            object_docs.append(funcdoc)
-        else:
-            item_doc = getattr(module, f"__doc__{name}", None)
-            if item_doc:
-                # variable documentation
-                object_docs.append(f"{member_title_level} {qual_name}\n\n")
-                object_docs.append(item_doc)
-            else:
-                warnings.warn(f"Not sure how to document: {name} ({item}")
-
-    if object_docs:
-        return "".join(header + object_docs)
-    return ""
-
-
-def object_is_private(name, obj):
-    docstring = inspect.getdoc(obj)
-    if docstring is None:
-        docstring = ""
-    module = getattr(obj, "__module__", None)  # obj is class
-    if not module:
-        cls = getattr(obj, "__class__", None)  # obj is instance
-        if cls:
-            module = getattr(cls, "__module__", None)
-    if module == "builtins":
-        return True
-
-    if docstring.lstrip().startswith("mdmd:hidden") or name.startswith("_"):
-        return True
-
-    return False
-
-
-def default_filter(module, item_name):
-    """Include non-private objects defined in the module itself"""
-    item = getattr(module, item_name)
-    if object_is_private(item_name, item) or inspect.ismodule(item):
-        return False
-    member_module = getattr(item, "__module__", type(item).__module__)
-    return member_module == module.__name__
-
-
-def package_filter(module_prefix: str):
-    """Include non-private objects defined in any module with the prefix `module_prefix`"""
-
-    def return_filter(module, item_name):
-        item = getattr(module, item_name)
-        if object_is_private(item_name, item) or inspect.ismodule(item):
-            return False
-        member_module = getattr(item, "__module__", type(item).__module__)
-        return member_module.startswith(module_prefix)
-
-    return return_filter
-
-
-def module_items(module, filter_items: Callable[[ModuleType, str], bool] = None):
-    """Returns filtered members of module"""
-    if filter_items is None:
-        # default filter is to only include classes and functions declared (or whose type is declared) in the file
-        filter_items = default_filter
-
-    for member_name, member in inspect.getmembers(module):
-        # only modal items
-        if not filter_items(module, member_name):
-            continue
-
-        qual_name = f"{module.__name__}.{member_name}"
-        yield qual_name, member_name, member
-
-
-class Category(Enum):
-    FUNCTION = "function"
-    CLASS = "class"
-    MODULE = "module"

modal_docs/mdmd/signatures.py

@@ -1,76 +0,0 @@
-# Copyright Modal Labs 2023
-import ast
-import inspect
-import re
-import textwrap
-import warnings
-
-from synchronicity.synchronizer import FunctionWithAio
-
-
-def _signature_from_ast(func) -> tuple[str, str]:
-    """Get function signature, including decorators and comments, from source code
-
-    Traverses functools.wraps-wrappings to get source of underlying function.
-
-    Has the advantage over inspect.signature that it can get decorators, default arguments and comments verbatim
-    from the function definition.
-    """
-    src = inspect.getsource(func)
-    src = textwrap.dedent(src)
-
-    def get_source_segment(src, fromline, fromcol, toline, tocol) -> str:
-        lines = src.split("\n")
-        lines = lines[fromline - 1 : toline]
-        lines[-1] = lines[-1][:tocol]
-        lines[0] = lines[0][fromcol:]
-        return "\n".join(lines)
-
-    tree = ast.parse(src)
-    func_def = list(ast.iter_child_nodes(tree))[0]
-    assert isinstance(func_def, (ast.FunctionDef, ast.AsyncFunctionDef))
-    decorator_starts = [(item.lineno, item.col_offset - 1) for item in func_def.decorator_list]
-    declaration_start = min([(func_def.lineno, func_def.col_offset)] + decorator_starts)
-    body_start = min((item.lineno, item.col_offset) for item in func_def.body)
-
-    return (
-        func_def.name,
-        get_source_segment(src, declaration_start[0], declaration_start[1], body_start[0], body_start[1] - 1).strip(),
-    )
-
-
-def get_signature(name, callable) -> str:
-    """A problem with using *only* this method is that the wrapping method signature will not be respected.
-    TODO: use source parsing *only* to extract default arguments, comments (and possibly decorators) and "merge"
-          that definition with the outer-most definition."""
-
-    if not (inspect.isfunction(callable) or inspect.ismethod(callable) or isinstance(callable, FunctionWithAio)):
-        assert hasattr(callable, "__call__")
-        callable = callable.__call__
-
-    try:
-        original_name, definition_source = _signature_from_ast(callable)
-    except Exception:
-        warnings.warn(f"Could not get source signature for {name}. Using fallback.")
-        original_name = name
-        definition_source = f"def {name}{inspect.signature(callable)}"
-
-    if original_name != name:
-        # ugly name and definition replacement hack when needed
-        definition_source = definition_source.replace(f"def {original_name}", f"def {name}")
-
-    if (
-        "async def" in definition_source
-        and not inspect.iscoroutinefunction(callable)
-        and not inspect.isasyncgenfunction(callable)
-    ):
-        # hack to "reset" signature to a blocking one if the underlying source definition is async
-        # but the wrapper function isn't (like when synchronicity wraps an async function as a blocking one)
-        definition_source = definition_source.replace("async def", "def")
-        definition_source = definition_source.replace("asynccontextmanager", "contextmanager")
-        definition_source = definition_source.replace("AsyncIterator", "Iterator")
-
-    # remove any synchronicity-internal decorators
-    definition_source, _ = re.subn(r"^\s*@synchronizer\..*\n", "", definition_source)
-
-    return definition_source

modal_global_objects/__init__.py

@@ -1 +0,0 @@
-# Copyright Modal Labs 2022

modal_global_objects/images/__init__.py

@@ -1 +0,0 @@
-# Copyright Modal Labs 2024

modal_global_objects/images/base_images.py

@@ -1,28 +0,0 @@
-# Copyright Modal Labs 2022
-import os
-import sys
-from typing import cast
-
-import modal
-from modal.image import SUPPORTED_PYTHON_SERIES, ImageBuilderVersion
-
-
-def dummy():
-    pass
-
-
-if __name__ == "__main__":
-    _, name = sys.argv
-    constructor = getattr(modal.Image, name)
-
-    builder_version = os.environ.get("MODAL_IMAGE_BUILDER_VERSION")
-    assert builder_version, "Script requires MODAL_IMAGE_BUILDER_VERSION environment variable"
-    python_versions = SUPPORTED_PYTHON_SERIES[cast(ImageBuilderVersion, builder_version)]
-
-    app = modal.App(f"build-{name.replace('_', '-')}-image")
-    for v in python_versions:
-        app.function(image=constructor(python_version=v), name=f"{v}")(dummy)
-
-    with modal.enable_output():
-        with app.run():
-            pass

modal_global_objects/mounts/__init__.py

@@ -1 +0,0 @@
-# Copyright Modal Labs 2024

modal_global_objects/mounts/modal_client_package.py

@@ -1,29 +0,0 @@
-# Copyright Modal Labs 2022
-from modal.config import config
-from modal.mount import (
-    client_mount_name,
-    create_client_mount,
-)
-from modal_proto import api_pb2
-
-
-def publish_client_mount(client):
-    mount = create_client_mount()
-    name = client_mount_name()
-    profile_environment = config.get("environment")
-    # TODO: change how namespaces work, so we don't have to use unrelated workspaces when deploying to global?.
-    mount._deploy(
-        client_mount_name(),
-        api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL,
-        client=client,
-        environment_name=profile_environment,
-    )
-    print(f"✅ Deployed client mount {name} to global namespace.")
-
-
-def main(client=None):
-    publish_client_mount(client)
-
-
-if __name__ == "__main__":
-    main()

modal_global_objects/mounts/python_standalone.py

@@ -1,53 +0,0 @@
-# Copyright Modal Labs 2022
-import shutil
-import tempfile
-import urllib.request
-
-from modal.config import config
-from modal.exception import NotFoundError
-from modal.mount import (
-    PYTHON_STANDALONE_VERSIONS,
-    Mount,
-    python_standalone_mount_name,
-)
-from modal_proto import api_pb2
-
-
-def publish_python_standalone_mount(client, version: str) -> None:
-    release, full_version = PYTHON_STANDALONE_VERSIONS[version]
-
-    libc = "gnu"
-    arch = "x86_64_v3"
-    url = (
-        "https://github.com/indygreg/python-build-standalone/releases/download"
-        + f"/{release}/cpython-{full_version}+{release}-{arch}-unknown-linux-gnu-install_only.tar.gz"
-    )
-
-    profile_environment = config.get("environment")
-    mount_name = python_standalone_mount_name(f"{version}-{libc}")
-    try:
-        Mount.from_name(mount_name, namespace=api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL).hydrate(client)
-        print(f"✅ Found existing mount {mount_name} in global namespace.")
-    except NotFoundError:
-        print(f"📦 Unpacking python-build-standalone for {version}-{libc}.")
-        with tempfile.TemporaryDirectory() as d:
-            urllib.request.urlretrieve(url, f"{d}/cpython.tar.gz")
-            shutil.unpack_archive(f"{d}/cpython.tar.gz", d)
-            print(f"🌐 Downloaded and unpacked archive to {d}.")
-            python_mount = Mount._from_local_dir(f"{d}/python")
-            python_mount._deploy(
-                mount_name,
-                api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL,
-                client=client,
-                environment_name=profile_environment,
-            )
-            print(f"✅ Deployed mount {mount_name} to global namespace.")
-
-
-def main(client=None):
-    for version in PYTHON_STANDALONE_VERSIONS:
-        publish_python_standalone_mount(client, version)
-
-
-if __name__ == "__main__":
-    main()