modal 0.73.44__py3-none-any.whl → 0.73.46__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.44"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.46"
     ): ...
     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.44"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.46"
     ): ...
     def is_closed(self) -> bool: ...
     @property

{modal-0.73.44.dist-info → modal-0.73.46.dist-info}/METADATA

@@ -1,11 +1,13 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: modal
-Version: 0.73.44
+Version: 0.73.46
 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.44.dist-info → modal-0.73.46.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=Us7guqm-7JE3H9hipPxqhyOrFsJz2nbspDc03c4JmAA,7593
+modal/client.pyi,sha256=O1FkvafYE0HPYhNlOAfgFPBfi1-ZQ00hbjPGOtk2PAk,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
@@ -142,18 +144,6 @@ modal/requirements/2024.04.txt,sha256=6NnrbIE-mflwMyKyQ0tsWeY8XFE1kSW9oE8DVDoD8Q
 modal/requirements/2024.10.txt,sha256=qD-5cVIVM9wXesJ6JC89Ew-3m2KjEElUz3jaw_MddRo,296
 modal/requirements/README.md,sha256=9tK76KP0Uph7O0M5oUgsSwEZDj5y-dcUPsnpR0Sc-Ik,854
 modal/requirements/base-images.json,sha256=kLNo5Sqmnhp9H6Hr9IcaGJFrRaRg1yfuepUWkm-y8iQ,571
-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 +162,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=Z2EVtAHyRHPl9O8NnhkBr_IETVMlMSkE6X0LVKvJnCw,149
-modal-0.73.44.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
-modal-0.73.44.dist-info/METADATA,sha256=Li_yB2IQE6WhbqRbnksCXzgcHgninuSVyJXtRJ6Fxno,2330
-modal-0.73.44.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-modal-0.73.44.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-0.73.44.dist-info/top_level.txt,sha256=1nvYbOSIKcmU50fNrpnQnrrOpj269ei3LzgB6j9xGqg,64
-modal-0.73.44.dist-info/RECORD,,
+modal_version/_version_generated.py,sha256=8fsq1Mwk_oc-cRzDa1hVjelGQTPb2sWXcU1-oVbyluE,149
+modal-0.73.46.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-0.73.46.dist-info/METADATA,sha256=cRFzas4CsmfLqOAtoQuAAfiB1dKGnRUifH9e0hUWVwg,2452
+modal-0.73.46.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+modal-0.73.46.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-0.73.46.dist-info/top_level.txt,sha256=UkI9BtusWSFRKv6hePUkcXTROTUz7xo7rKGg_IHjuBM,32
+modal-0.73.46.dist-info/RECORD,,

{modal-0.73.44.dist-info → modal-0.73.46.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.44.dist-info → modal-0.73.46.dist-info}/top_level.txt

@@ -1,5 +1,3 @@
 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 = 44  # git: 65ca596
+build_number = 46  # git: 8736584

modal_docs/__init__.py

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

modal_docs/gen_cli_docs.py

@@ -1,117 +0,0 @@
-# Copyright Modal Labs 2023
-import inspect
-import sys
-from pathlib import Path
-from typing import Optional, cast
-
-from click import Command, Context, Group
-
-from modal.cli.entry_point import entrypoint_cli
-
-
-# Adapted from typer_cli, since it's incompatible with the latest version of typer
-# (see https://github.com/tiangolo/typer-cli/issues/50)
-def get_docs_for_click(
-    obj: Command,
-    ctx: Context,
-    *,
-    indent: int = 0,
-    name: str = "",
-    call_prefix: str = "",
-) -> str:
-    docs = "#" * (1 + indent)
-    command_name = name or obj.name
-    if call_prefix:
-        command_name = f"{call_prefix} {command_name}"
-    title = f"`{command_name}`" if command_name else "CLI"
-    docs += f" {title}\n\n"
-    if obj.help:
-        docs += f"{inspect.cleandoc(obj.help)}\n\n"
-    usage_pieces = obj.collect_usage_pieces(ctx)
-    if usage_pieces:
-        docs += "**Usage**:\n\n"
-        docs += "```shell\n"
-        if command_name:
-            docs += f"{command_name} "
-        docs += f"{' '.join(usage_pieces)}\n"
-        docs += "```\n\n"
-    args = []
-    opts = []
-    for param in obj.get_params(ctx):
-        rv = param.get_help_record(ctx)
-        if rv is not None:
-            if getattr(param, "hidden", False):
-                continue
-            if param.param_type_name == "argument":
-                args.append(rv)
-            elif param.param_type_name == "option":
-                opts.append(rv)
-    if args:
-        docs += "**Arguments**:\n\n"
-        for arg_name, arg_help in args:
-            docs += f"* `{arg_name}`"
-            if arg_help:
-                docs += f": {arg_help}"
-            docs += "\n"
-        docs += "\n"
-    if opts:
-        docs += "**Options**:\n\n"
-        for opt_name, opt_help in opts:
-            docs += f"* `{opt_name}`"
-            if opt_help:
-                docs += f": {opt_help}"
-            docs += "\n"
-        docs += "\n"
-    if obj.epilog:
-        docs += f"{obj.epilog}\n\n"
-    if isinstance(obj, Group):
-        group: Group = cast(Group, obj)
-        commands = group.list_commands(ctx)
-        if commands:
-            docs += "**Commands**:\n\n"
-            for command in commands:
-                command_obj = group.get_command(ctx, command)
-                assert command_obj
-                if command_obj.hidden:
-                    continue
-                docs += f"* `{command_obj.name}`"
-                command_help = command_obj.get_short_help_str(limit=250)
-                if command_help:
-                    docs += f": {command_help}"
-                docs += "\n"
-            docs += "\n"
-        for command in commands:
-            command_obj = group.get_command(ctx, command)
-            if command_obj.hidden:
-                continue
-            assert command_obj
-            use_prefix = ""
-            if command_name:
-                use_prefix += f"{command_name}"
-            docs += get_docs_for_click(obj=command_obj, ctx=ctx, indent=indent + 1, call_prefix=use_prefix)
-    return docs
-
-
-def run(output_dirname: Optional[str]) -> None:
-    entrypoint: Group = cast(Group, entrypoint_cli)
-    ctx = Context(entrypoint)
-    commands = entrypoint.list_commands(ctx)
-
-    for command in commands:
-        command_obj = entrypoint.get_command(ctx, command)
-        if command_obj.hidden:
-            continue
-        docs = get_docs_for_click(obj=command_obj, ctx=ctx, call_prefix="modal")
-
-        if output_dirname:
-            output_dir = Path(output_dirname)
-            output_dir.mkdir(parents=True, exist_ok=True)
-            output_file = output_dir / f"{command}.md"
-            print("Writing to", output_file)
-            output_file.write_text(docs)
-        else:
-            print(docs)
-
-
-if __name__ == "__main__":
-    run(None if len(sys.argv) <= 1 else sys.argv[1])

modal_docs/gen_reference_docs.py

@@ -1,193 +0,0 @@
-# Copyright Modal Labs 2023
-import importlib
-import inspect
-import json
-import os
-import sys
-import warnings
-from typing import NamedTuple
-
-from synchronicity.synchronizer import FunctionWithAio
-
-from .mdmd.mdmd import (
-    Category,
-    class_str,
-    default_filter,
-    function_str,
-    module_items,
-    module_str,
-    object_is_private,
-    package_filter,
-)
-
-
-class DocItem(NamedTuple):
-    label: str
-    category: Category
-    document: str
-    in_sidebar: bool = True
-
-
-def validate_doc_item(docitem: DocItem) -> DocItem:
-    # Check that unwanted strings aren't leaking into our docs.
-    bad_strings = [
-        # Presence of a to-do inside a `DocItem` usually indicates it's been
-        # placed inside a function signature definition or right underneath it, before the body.
-        # Fix by moving the to-do into the body or above the signature.
-        "TODO:"
-    ]
-    for line in docitem.document.splitlines():
-        for bad_str in bad_strings:
-            if bad_str in line:
-                msg = f"Found unwanted string '{bad_str}' in content for item '{docitem.label}'. Problem line: {line}"
-                raise ValueError(msg)
-    return docitem
-
-
-def run(output_dir: str = None):
-    """Generate Modal docs."""
-    import modal
-
-    ordered_doc_items: list[DocItem] = []
-    documented_items = set()
-
-    def filter_non_aio(module, name):
-        return not name.lower().startswith("aio")
-
-    def filter_already_documented(module, name):
-        item = getattr(module, name)
-        try:
-            if item in documented_items:
-                return False
-        except TypeError:  # unhashable stuff
-            print(f"Warning: could not document item {name}: {item}:")
-            return False
-        documented_items.add(item)
-        return True
-
-    def modal_default_filter(module, name):
-        return default_filter(module, name) and filter_non_aio(module, name) and filter_already_documented(module, name)
-
-    def top_level_filter(module, name):
-        item = getattr(module, name)
-        if object_is_private(name, item) or inspect.ismodule(item):
-            return False
-        return package_filter("modal") and filter_already_documented(module, name) and filter_non_aio(module, name)
-
-    base_title_level = "#"
-    forced_module_docs = [
-        ("modal.Function", "modal.functions"),
-        ("modal.Secret", "modal.secret"),
-        ("modal.Dict", "modal.dict"),
-        ("modal.Queue", "modal.queue"),
-        ("modal.call_graph", "modal.call_graph"),
-        ("modal.gpu", "modal.gpu"),
-        ("modal.runner", "modal.runner"),
-        ("modal.Sandbox", "modal.sandbox"),
-        ("modal.ContainerProcess", "modal.container_process"),
-        ("modal.io_streams", "modal.io_streams"),
-        ("modal.FileIO", "modal.file_io"),
-    ]
-    # These aren't defined in `modal`, but should still be documented as top-level entries.
-    forced_members = {"web_endpoint", "asgi_app", "method", "wsgi_app", "forward"}
-    # These are excluded from the sidebar, typically to 'soft release' some documentation.
-    sidebar_excluded: set[str] = set()
-
-    for title, modulepath in forced_module_docs:
-        module = importlib.import_module(modulepath)
-        document = module_str(modulepath, module, title_level=base_title_level, filter_items=modal_default_filter)
-        if document:
-            ordered_doc_items.append(
-                validate_doc_item(
-                    DocItem(
-                        label=title,
-                        category=Category.MODULE,
-                        document=document,
-                        in_sidebar=title not in sidebar_excluded,
-                    )
-                )
-            )
-
-    def f(module, member_name):
-        return top_level_filter(module, member_name) or (member_name in forced_members)
-
-    # now add all remaining top level modal.X entries
-    for qual_name, item_name, item in module_items(modal, filter_items=f):
-        if object_is_private(item_name, item):
-            continue  # skip stuff that's part of explicit `handle_objects` above
-
-        title = f"modal.{item_name}"
-        if inspect.isclass(item):
-            content = f"{base_title_level} {qual_name}\n\n" + class_str(item_name, item, base_title_level)
-            category = Category.CLASS
-        elif inspect.isroutine(item) or isinstance(item, FunctionWithAio):
-            content = f"{base_title_level} {qual_name}\n\n" + function_str(item_name, item)
-            category = Category.FUNCTION
-        elif inspect.ismodule(item):
-            continue  # skipping imported modules
-        else:
-            warnings.warn(f"Not sure how to document: {item_name} ({item})")
-            continue
-        ordered_doc_items.append(
-            validate_doc_item(
-                DocItem(
-                    label=title,
-                    category=category,
-                    document=content,
-                    in_sidebar=title not in sidebar_excluded,
-                )
-            )
-        )
-    ordered_doc_items.sort()
-
-    for modulepath in ["modal.exception", "modal.config"]:
-        module = importlib.import_module(modulepath)
-        document = module_str(modulepath, module, title_level=base_title_level, filter_items=modal_default_filter)
-        ordered_doc_items.append(
-            DocItem(
-                label=modulepath,
-                category=Category.MODULE,
-                document=document,
-            )
-        )
-
-    # TODO: add some way of documenting our .aio sub-methods
-
-    make_markdown_docs(
-        ordered_doc_items,
-        output_dir,
-    )
-
-
-def make_markdown_docs(items: list[DocItem], output_dir: str = None):
-    def _write_file(rel_path: str, data: str):
-        if output_dir is None:
-            print(f"<<< {rel_path}")
-            print(data)
-            print(f">>> {rel_path}")
-            return
-
-        filename = os.path.join(output_dir, rel_path)
-        print("Writing to", filename)
-        os.makedirs(os.path.dirname(filename), exist_ok=True)
-        with open(filename, "w") as fp:
-            fp.write(data)
-
-    sidebar_items = []
-    for item in items:
-        if item.in_sidebar:
-            sidebar_items.append(
-                {
-                    "label": item.label,
-                    "category": item.category.value,
-                }
-            )
-        _write_file(f"{item.label}.md", item.document)
-
-    sidebar_data = {"items": sidebar_items}
-    _write_file("sidebar.json", json.dumps(sidebar_data))
-
-
-if __name__ == "__main__":
-    # running this module outputs docs to stdout for inspection, useful for debugging
-    run(None if len(sys.argv) <= 1 else sys.argv[1])

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()