modal 1.0.3.dev10__py3-none-any.whl → 1.2.3.dev7__py3-none-any.whl

modal/serving.py

@@ -4,13 +4,13 @@ import platform
 from collections.abc import AsyncGenerator
 from multiprocessing.context import SpawnProcess
 from multiprocessing.synchronize import Event
-from typing import TYPE_CHECKING, Optional, TypeVar
+from typing import TYPE_CHECKING, Optional
 
 from synchronicity.async_wrap import asynccontextmanager
 
 from modal._output import OutputManager
 
-from ._utils.async_utils import TaskContext, asyncify, synchronize_api, synchronizer
+from ._utils.async_utils import TaskContext, asyncify, synchronize_api
 from ._utils.logger import logger
 from ._watcher import watch
 from .cli.import_refs import ImportRef, import_app_from_ref
@@ -20,20 +20,16 @@ from .output import _get_output_manager, enable_output
 from .runner import _run_app, serve_update
 
 if TYPE_CHECKING:
-    from .app import _App
-else:
-    _App = TypeVar("_App")
+    import modal.app
 
 
 def _run_serve(
     import_ref: ImportRef, existing_app_id: str, is_ready: Event, environment_name: str, show_progress: bool
 ):
-    # subprocess entrypoint
-    _app = import_app_from_ref(import_ref, base_cmd="modal serve")
-    blocking_app = synchronizer._translate_out(_app)
+    app = import_app_from_ref(import_ref, base_cmd="modal serve")
 
     with enable_output(show_progress=show_progress):
-        serve_update(blocking_app, existing_app_id, is_ready, environment_name)
+        serve_update(app, existing_app_id, is_ready, environment_name)
 
 
 async def _restart_serve(
@@ -97,12 +93,12 @@ async def _run_watch_loop(
 
 @asynccontextmanager
 async def _serve_app(
-    app: "_App",
+    app: "modal.app._App",
     import_ref: ImportRef,
     *,
     _watcher: Optional[AsyncGenerator[set[str], None]] = None,  # for testing
     environment_name: Optional[str] = None,
-) -> AsyncGenerator["_App", None]:
+) -> AsyncGenerator["modal.app._App", None]:
     if environment_name is None:
         environment_name = config.get("environment")
 

modal/serving.pyi

@@ -1,4 +1,5 @@
 import collections.abc
+import modal.app
 import modal.cli.import_refs
 import multiprocessing.context
 import multiprocessing.synchronize
@@ -6,8 +7,6 @@ import synchronicity.combined_types
 import typing
 import typing_extensions
 
-_App = typing.TypeVar("_App")
-
 def _run_serve(
     import_ref: modal.cli.import_refs.ImportRef,
     existing_app_id: str,
@@ -27,31 +26,31 @@ async def _run_watch_loop(
     environment_name: str,
 ): ...
 def _serve_app(
-    app: _App,
+    app: modal.app._App,
     import_ref: modal.cli.import_refs.ImportRef,
     *,
     _watcher: typing.Optional[collections.abc.AsyncGenerator[set[str], None]] = None,
     environment_name: typing.Optional[str] = None,
-) -> typing.AsyncContextManager[_App]: ...
+) -> typing.AsyncContextManager[modal.app._App]: ...
 
 class __serve_app_spec(typing_extensions.Protocol):
     def __call__(
         self,
         /,
-        app: _App,
+        app: modal.app.App,
         import_ref: modal.cli.import_refs.ImportRef,
         *,
         _watcher: typing.Optional[typing.Generator[set[str], None, None]] = None,
         environment_name: typing.Optional[str] = None,
-    ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[_App]: ...
+    ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[modal.app.App]: ...
     def aio(
         self,
         /,
-        app: _App,
+        app: modal.app.App,
         import_ref: modal.cli.import_refs.ImportRef,
         *,
         _watcher: typing.Optional[collections.abc.AsyncGenerator[set[str], None]] = None,
         environment_name: typing.Optional[str] = None,
-    ) -> typing.AsyncContextManager[_App]: ...
+    ) -> typing.AsyncContextManager[modal.app.App]: ...
 
 serve_app: __serve_app_spec

modal/snapshot.py

@@ -3,10 +3,10 @@ from typing import Optional
 
 from modal_proto import api_pb2
 
+from ._load_context import LoadContext
 from ._object import _Object
 from ._resolver import Resolver
 from ._utils.async_utils import synchronize_api
-from ._utils.grpc_utils import retry_transient_errors
 from .client import _Client
 
 
@@ -24,16 +24,19 @@ class _SandboxSnapshot(_Object, type_prefix="sn"):
         """
         Construct a `SandboxSnapshot` object from a sandbox snapshot ID.
         """
-        if client is None:
-            client = await _Client.from_env()
-
-        async def _load(self: _SandboxSnapshot, resolver: Resolver, existing_object_id: Optional[str]):
-            await retry_transient_errors(
-                client.stub.SandboxSnapshotGet, api_pb2.SandboxSnapshotGetRequest(snapshot_id=sandbox_snapshot_id)
+        # TODO: remove this - from_id constructor should not do io:
+        client = client or await _Client.from_env()
+
+        async def _load(
+            self: _SandboxSnapshot, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
+            await load_context.client.stub.SandboxSnapshotGet(
+                api_pb2.SandboxSnapshotGetRequest(snapshot_id=sandbox_snapshot_id)
             )
 
         rep = "SandboxSnapshot()"
-        obj = _SandboxSnapshot._from_loader(_load, rep)
+        obj = _SandboxSnapshot._from_loader(_load, rep, load_context_overrides=LoadContext(client=client))
+        # TODO: should this be a _Object._new_hydrated instead?
         obj._hydrate(sandbox_snapshot_id, client, None)
 
         return obj

modal/snapshot.pyi

@@ -5,14 +5,35 @@ import typing
 import typing_extensions
 
 class _SandboxSnapshot(modal._object._Object):
+    """> Sandbox memory snapshots are in **early preview**.
+
+    A `SandboxSnapshot` object lets you interact with a stored Sandbox snapshot that was created by calling
+    `._experimental_snapshot()` on a Sandbox instance. This includes both the filesystem and memory state of
+    the original Sandbox at the time the snapshot was taken.
+    """
     @staticmethod
-    async def from_id(sandbox_snapshot_id: str, client: typing.Optional[modal.client._Client] = None): ...
+    async def from_id(sandbox_snapshot_id: str, client: typing.Optional[modal.client._Client] = None):
+        """Construct a `SandboxSnapshot` object from a sandbox snapshot ID."""
+        ...
 
 class SandboxSnapshot(modal.object.Object):
-    def __init__(self, *args, **kwargs): ...
+    """> Sandbox memory snapshots are in **early preview**.
+
+    A `SandboxSnapshot` object lets you interact with a stored Sandbox snapshot that was created by calling
+    `._experimental_snapshot()` on a Sandbox instance. This includes both the filesystem and memory state of
+    the original Sandbox at the time the snapshot was taken.
+    """
+    def __init__(self, *args, **kwargs):
+        """mdmd:hidden"""
+        ...
 
     class __from_id_spec(typing_extensions.Protocol):
-        def __call__(self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None): ...
-        async def aio(self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None): ...
+        def __call__(self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None):
+            """Construct a `SandboxSnapshot` object from a sandbox snapshot ID."""
+            ...
+
+        async def aio(self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None):
+            """Construct a `SandboxSnapshot` object from a sandbox snapshot ID."""
+            ...
 
     from_id: __from_id_spec

modal/token_flow.py

@@ -6,11 +6,11 @@ from collections.abc import AsyncGenerator
 from typing import Optional
 
 import aiohttp.web
-from rich.console import Console
 from synchronicity.async_wrap import asynccontextmanager
 
 from modal_proto import api_pb2
 
+from ._output import make_console
 from ._utils.async_utils import synchronize_api
 from ._utils.http_utils import run_temporary_http_server
 from .client import _Client
@@ -56,7 +56,7 @@ class _TokenFlow:
         req = api_pb2.TokenFlowWaitRequest(
             token_flow_id=self.token_flow_id, timeout=timeout, wait_secret=self.wait_secret
         )
-        resp = await self.stub.TokenFlowWait(req, timeout=(timeout + grpc_extra_timeout))
+        resp = await self.stub.TokenFlowWait(req, retry=None, timeout=timeout + grpc_extra_timeout)
         if not resp.timeout:
             return resp
         else:
@@ -76,7 +76,7 @@ async def _new_token(
 ):
     server_url = config.get("server_url", profile=profile)
 
-    console = Console()
+    console = make_console()
 
     result: Optional[api_pb2.TokenFlowWaitResponse] = None
     async with _Client.anonymous(server_url) as client:
@@ -133,7 +133,7 @@ async def _set_token(
 ):
     # TODO add server_url as a parameter for verification?
     server_url = config.get("server_url", profile=profile)
-    console = Console()
+    console = make_console()
     if verify:
         console.print(f"Verifying token against [blue]{server_url}[/blue]")
         await _Client.verify(server_url, (token_id, token_secret))

modal/token_flow.pyi

@@ -5,13 +5,21 @@ import typing
 import typing_extensions
 
 class _TokenFlow:
-    def __init__(self, client: modal.client._Client): ...
+    def __init__(self, client: modal.client._Client):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
     def start(
         self, utm_source: typing.Optional[str] = None, next_url: typing.Optional[str] = None
-    ) -> typing.AsyncContextManager[tuple[str, str, str]]: ...
+    ) -> typing.AsyncContextManager[tuple[str, str, str]]:
+        """mdmd:hidden"""
+        ...
+
     async def finish(
         self, timeout: float = 40.0, grpc_extra_timeout: float = 5.0
-    ) -> typing.Optional[modal_proto.api_pb2.TokenFlowWaitResponse]: ...
+    ) -> typing.Optional[modal_proto.api_pb2.TokenFlowWaitResponse]:
+        """mdmd:hidden"""
+        ...
 
 SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
 
@@ -21,20 +29,30 @@ class TokenFlow:
     class __start_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, /, utm_source: typing.Optional[str] = None, next_url: typing.Optional[str] = None
-        ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[tuple[str, str, str]]: ...
+        ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[tuple[str, str, str]]:
+            """mdmd:hidden"""
+            ...
+
         def aio(
             self, /, utm_source: typing.Optional[str] = None, next_url: typing.Optional[str] = None
-        ) -> typing.AsyncContextManager[tuple[str, str, str]]: ...
+        ) -> typing.AsyncContextManager[tuple[str, str, str]]:
+            """mdmd:hidden"""
+            ...
 
     start: __start_spec[typing_extensions.Self]
 
     class __finish_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, /, timeout: float = 40.0, grpc_extra_timeout: float = 5.0
-        ) -> typing.Optional[modal_proto.api_pb2.TokenFlowWaitResponse]: ...
+        ) -> typing.Optional[modal_proto.api_pb2.TokenFlowWaitResponse]:
+            """mdmd:hidden"""
+            ...
+
         async def aio(
             self, /, timeout: float = 40.0, grpc_extra_timeout: float = 5.0
-        ) -> typing.Optional[modal_proto.api_pb2.TokenFlowWaitResponse]: ...
+        ) -> typing.Optional[modal_proto.api_pb2.TokenFlowWaitResponse]:
+            """mdmd:hidden"""
+            ...
 
     finish: __finish_spec[typing_extensions.Self]
 
@@ -55,4 +73,6 @@ async def _set_token(
     verify: bool = True,
     server_url: typing.Optional[str] = None,
 ): ...
-def _open_url(url: str) -> bool: ...
+def _open_url(url: str) -> bool:
+    """Opens url in web browser, making sure we use a modern one (not Lynx etc)"""
+    ...