modAL 1.2.4.dev2__tar.gz → 1.2.5.dev0__tar.gz

{modal-1.2.4.dev2 → modal-1.2.5.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.4.dev2
+Version: 1.2.5.dev0
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0

{modal-1.2.4.dev2 → modal-1.2.5.dev0}/modal/cli/entry_point.py

@@ -8,7 +8,7 @@ from rich.rule import Rule
 from modal._output import make_console
 from modal._utils.async_utils import synchronizer
 
-from . import run
+from . import run, shell as shell_module
 from .app import app_cli
 from .cluster import cluster_cli
 from .config import config_cli
@@ -94,7 +94,7 @@ async def setup(profile: Optional[str] = None):
 # Commands
 entrypoint_cli_typer.command("deploy", no_args_is_help=True)(run.deploy)
 entrypoint_cli_typer.command("serve", no_args_is_help=True)(run.serve)
-entrypoint_cli_typer.command("shell")(run.shell)
+entrypoint_cli_typer.command("shell")(shell_module.shell)
 entrypoint_cli_typer.add_typer(launch_cli)
 
 # Deployments

{modal-1.2.4.dev2 → modal-1.2.5.dev0}/modal/cli/run.py

@@ -2,15 +2,11 @@
 import asyncio
 import functools
 import inspect
-import platform
 import re
-import shlex
 import sys
 import time
 import typing
 from dataclasses import dataclass
-from functools import partial
-from pathlib import Path, PurePosixPath
 from typing import Any, Callable, Optional
 
 import click
@@ -18,20 +14,15 @@ import typer
 from click import ClickException
 from typing_extensions import TypedDict
 
-from .._functions import _FunctionSpec
 from ..app import App, LocalEntrypoint
 from ..cls import _get_class_constructor_signature
 from ..config import config
 from ..environments import ensure_env
-from ..exception import ExecutionError, InvalidError, NotFoundError, _CliUserExecutionError
+from ..exception import ExecutionError, InvalidError, _CliUserExecutionError
 from ..functions import Function
-from ..image import Image
-from ..mount import _Mount
 from ..output import enable_output
-from ..runner import deploy_app, interactive_shell, run_app
-from ..secret import Secret
+from ..runner import deploy_app, run_app
 from ..serving import serve_app
-from ..volume import Volume
 from .import_refs import (
     CLICommand,
     MethodReference,
@@ -40,7 +31,7 @@ from .import_refs import (
     import_app_from_ref,
     parse_import_ref,
 )
-from .utils import ENV_OPTION, ENV_OPTION_HELP, is_tty, stream_app_logs
+from .utils import ENV_OPTION, ENV_OPTION_HELP, stream_app_logs
 
 
 class ParameterMetadata(TypedDict):
@@ -521,213 +512,3 @@ def serve(
                 t = min(timeout, 3600)
                 time.sleep(t)
                 timeout -= t
-
-
-def shell(
-    ref: Optional[str] = typer.Argument(
-        default=None,
-        help=(
-            "ID of running container or Sandbox, or path to a Python file containing an App."
-            " Can also include a Function specifier, like `module.py::func`, if the file defines multiple Functions."
-        ),
-    ),
-    cmd: str = typer.Option("/bin/bash", "-c", "--cmd", help="Command to run inside the Modal image."),
-    env: str = ENV_OPTION,
-    image: Optional[str] = typer.Option(
-        default=None, help="Container image tag for inside the shell (if not using REF)."
-    ),
-    add_python: Optional[str] = typer.Option(default=None, help="Add Python to the image (if not using REF)."),
-    volume: Optional[list[str]] = typer.Option(
-        default=None,
-        help=(
-            "Name of a `modal.Volume` to mount inside the shell at `/mnt/{name}` (if not using REF)."
-            " Can be used multiple times."
-        ),
-    ),
-    add_local: Optional[list[str]] = typer.Option(
-        default=None,
-        help=(
-            "Local file or directory to mount inside the shell at `/mnt/{basename}` (if not using REF)."
-            " Can be used multiple times."
-        ),
-    ),
-    secret: Optional[list[str]] = typer.Option(
-        default=None,
-        help=("Name of a `modal.Secret` to mount inside the shell (if not using REF). Can be used multiple times."),
-    ),
-    cpu: Optional[int] = typer.Option(default=None, help="Number of CPUs to allocate to the shell (if not using REF)."),
-    memory: Optional[int] = typer.Option(
-        default=None, help="Memory to allocate for the shell, in MiB (if not using REF)."
-    ),
-    gpu: Optional[str] = typer.Option(
-        default=None,
-        help="GPUs to request for the shell, if any. Examples are `any`, `a10g`, `a100:4` (if not using REF).",
-    ),
-    cloud: Optional[str] = typer.Option(
-        default=None,
-        help=(
-            "Cloud provider to run the shell on. Possible values are `aws`, `gcp`, `oci`, `auto` (if not using REF)."
-        ),
-    ),
-    region: Optional[str] = typer.Option(
-        default=None,
-        help=(
-            "Region(s) to run the container on. "
-            "Can be a single region or a comma-separated list to choose from (if not using REF)."
-        ),
-    ),
-    pty: Optional[bool] = typer.Option(default=None, help="Run the command using a PTY."),
-    use_module_mode: bool = typer.Option(
-        False, "-m", help="Interpret argument as a Python module path instead of a file/script path"
-    ),
-):
-    """Run a command or interactive shell inside a Modal container.
-
-    **Examples:**
-
-    Start an interactive shell inside the default Debian-based image:
-
-    ```
-    modal shell
-    ```
-
-    Start an interactive shell with the spec for `my_function` in your App
-    (uses the same image, volumes, mounts, etc.):
-
-    ```
-    modal shell hello_world.py::my_function
-    ```
-
-    Or, if you're using a [modal.Cls](https://modal.com/docs/reference/modal.Cls)
-    you can refer to a `@modal.method` directly:
-
-    ```
-    modal shell hello_world.py::MyClass.my_method
-    ```
-
-    Start a `python` shell:
-
-    ```
-    modal shell hello_world.py --cmd=python
-    ```
-
-    Run a command with your function's spec and pipe the output to a file:
-
-    ```
-    modal shell hello_world.py -c 'uv pip list' > env.txt
-    ```
-
-    Connect to a running Sandbox by ID:
-
-    ```
-    modal shell sb-abc123xyz
-    ```
-    """
-    env = ensure_env(env)
-
-    if pty is None:
-        pty = is_tty()
-
-    if platform.system() == "Windows":
-        raise InvalidError("`modal shell` is currently not supported on Windows")
-
-    app = App("modal shell")
-
-    if ref is not None:
-        # `modal shell` with a sandbox ID gets the task_id, that's then handled by the `ta-*` flow below.
-        if ref.startswith("sb-") and len(ref[3:]) > 0 and ref[3:].isalnum():
-            from ..sandbox import Sandbox
-
-            try:
-                sandbox = Sandbox.from_id(ref)
-                task_id = sandbox._get_task_id()
-                ref = task_id
-            except NotFoundError as e:
-                raise ClickException(f"Sandbox '{ref}' not found")
-            except Exception as e:
-                raise ClickException(f"Error connecting to sandbox '{ref}': {str(e)}")
-
-        # `modal shell` with a container ID is a special case, alias for `modal container exec`.
-        if ref.startswith("ta-") and len(ref[3:]) > 0 and ref[3:].isalnum():
-            from .container import exec
-
-            exec(container_id=ref, command=shlex.split(cmd), pty=pty)
-            return
-
-        import_ref = parse_import_ref(ref, use_module_mode=use_module_mode)
-        runnable, all_usable_commands = import_and_filter(
-            import_ref, base_cmd="modal shell", accept_local_entrypoint=False, accept_webhook=True
-        )
-        if not runnable:
-            help_header = (
-                "Specify a Modal function to start a shell session for. E.g.\n"
-                f"> modal shell {import_ref.file_or_module}::my_function"
-            )
-
-            if all_usable_commands:
-                help_footer = f"The selected module '{import_ref.file_or_module}' has the following choices:\n\n"
-                help_footer += _get_runnable_list(all_usable_commands)
-            else:
-                help_footer = f"The selected module '{import_ref.file_or_module}' has no Modal functions or classes."
-
-            raise ClickException(f"{help_header}\n\n{help_footer}")
-
-        function_spec: _FunctionSpec
-        if isinstance(runnable, MethodReference):
-            # TODO: let users specify a class instead of a method, since they use the same environment
-            class_service_function = runnable.cls._get_class_service_function()
-            function_spec = class_service_function.spec
-        elif isinstance(runnable, Function):
-            function_spec = runnable.spec
-        else:
-            raise ValueError("Referenced entity is not a Modal function or class")
-
-        start_shell = partial(
-            interactive_shell,
-            image=function_spec.image,
-            mounts=function_spec.mounts,
-            secrets=function_spec.secrets,
-            network_file_systems=function_spec.network_file_systems,
-            gpu=function_spec.gpus,
-            cloud=function_spec.cloud,
-            cpu=function_spec.cpu,
-            memory=function_spec.memory,
-            volumes=function_spec.volumes,
-            region=function_spec.scheduler_placement.regions if function_spec.scheduler_placement else None,
-            pty=pty,
-            proxy=function_spec.proxy,
-        )
-    else:
-        modal_image = Image.from_registry(image, add_python=add_python) if image else None
-        volumes = {} if volume is None else {f"/mnt/{vol}": Volume.from_name(vol) for vol in volume}
-        secrets = [] if secret is None else [Secret.from_name(s) for s in secret]
-
-        mounts = []
-        if add_local:
-            for local_path_str in add_local:
-                local_path = Path(local_path_str).expanduser().resolve()
-                remote_path = PurePosixPath(f"/mnt/{local_path.name}")
-
-                if local_path.is_dir():
-                    m = _Mount._from_local_dir(local_path, remote_path=remote_path)
-                else:
-                    m = _Mount._from_local_file(local_path, remote_path=remote_path)
-                mounts.append(m)
-
-        start_shell = partial(
-            interactive_shell,
-            image=modal_image,
-            mounts=mounts,
-            cpu=cpu,
-            memory=memory,
-            gpu=gpu,
-            cloud=cloud,
-            volumes=volumes,
-            secrets=secrets,
-            region=region.split(",") if region else [],
-            pty=pty,
-        )
-
-    # NB: invoking under bash makes --cmd a lot more flexible.
-    cmds = shlex.split(f'/bin/bash -c "{cmd}"')
-    start_shell(app, cmds=cmds, environment_name=env, timeout=3600)

modal-1.2.5.dev0/modal/cli/shell.py

@@ -0,0 +1,237 @@
+# Copyright Modal Labs 2022
+import platform
+import shlex
+from functools import partial
+from pathlib import Path, PurePosixPath
+from typing import Optional
+
+import typer
+from click import ClickException
+
+from .._functions import _FunctionSpec
+from ..app import App
+from ..environments import ensure_env
+from ..exception import InvalidError, NotFoundError
+from ..functions import Function
+from ..image import Image
+from ..mount import _Mount
+from ..runner import interactive_shell
+from ..secret import Secret
+from ..volume import Volume
+from .import_refs import (
+    MethodReference,
+    import_and_filter,
+    parse_import_ref,
+)
+from .run import _get_runnable_list
+from .utils import ENV_OPTION, is_tty
+
+
+def shell(
+    ref: Optional[str] = typer.Argument(
+        default=None,
+        help=(
+            "ID of running container or Sandbox, or path to a Python file containing an App."
+            " Can also include a Function specifier, like `module.py::func`, if the file defines multiple Functions."
+        ),
+    ),
+    cmd: str = typer.Option("/bin/bash", "-c", "--cmd", help="Command to run inside the Modal image."),
+    env: str = ENV_OPTION,
+    image: Optional[str] = typer.Option(
+        default=None, help="Container image tag for inside the shell (if not using REF)."
+    ),
+    add_python: Optional[str] = typer.Option(default=None, help="Add Python to the image (if not using REF)."),
+    volume: Optional[list[str]] = typer.Option(
+        default=None,
+        help=(
+            "Name of a `modal.Volume` to mount inside the shell at `/mnt/{name}` (if not using REF)."
+            " Can be used multiple times."
+        ),
+    ),
+    add_local: Optional[list[str]] = typer.Option(
+        default=None,
+        help=(
+            "Local file or directory to mount inside the shell at `/mnt/{basename}` (if not using REF)."
+            " Can be used multiple times."
+        ),
+    ),
+    secret: Optional[list[str]] = typer.Option(
+        default=None,
+        help=("Name of a `modal.Secret` to mount inside the shell (if not using REF). Can be used multiple times."),
+    ),
+    cpu: Optional[int] = typer.Option(default=None, help="Number of CPUs to allocate to the shell (if not using REF)."),
+    memory: Optional[int] = typer.Option(
+        default=None, help="Memory to allocate for the shell, in MiB (if not using REF)."
+    ),
+    gpu: Optional[str] = typer.Option(
+        default=None,
+        help="GPUs to request for the shell, if any. Examples are `any`, `a10g`, `a100:4` (if not using REF).",
+    ),
+    cloud: Optional[str] = typer.Option(
+        default=None,
+        help=(
+            "Cloud provider to run the shell on. Possible values are `aws`, `gcp`, `oci`, `auto` (if not using REF)."
+        ),
+    ),
+    region: Optional[str] = typer.Option(
+        default=None,
+        help=(
+            "Region(s) to run the container on. "
+            "Can be a single region or a comma-separated list to choose from (if not using REF)."
+        ),
+    ),
+    pty: Optional[bool] = typer.Option(default=None, help="Run the command using a PTY."),
+    use_module_mode: bool = typer.Option(
+        False, "-m", help="Interpret argument as a Python module path instead of a file/script path"
+    ),
+):
+    """Run a command or interactive shell inside a Modal container.
+
+    **Examples:**
+
+    Start an interactive shell inside the default Debian-based image:
+
+    ```
+    modal shell
+    ```
+
+    Start an interactive shell with the spec for `my_function` in your App
+    (uses the same image, volumes, mounts, etc.):
+
+    ```
+    modal shell hello_world.py::my_function
+    ```
+
+    Or, if you're using a [modal.Cls](https://modal.com/docs/reference/modal.Cls)
+    you can refer to a `@modal.method` directly:
+
+    ```
+    modal shell hello_world.py::MyClass.my_method
+    ```
+
+    Start a `python` shell:
+
+    ```
+    modal shell hello_world.py --cmd=python
+    ```
+
+    Run a command with your function's spec and pipe the output to a file:
+
+    ```
+    modal shell hello_world.py -c 'uv pip list' > env.txt
+    ```
+
+    Connect to a running Sandbox by ID:
+
+    ```
+    modal shell sb-abc123xyz
+    ```
+    """
+    env = ensure_env(env)
+
+    if pty is None:
+        pty = is_tty()
+
+    if platform.system() == "Windows":
+        raise InvalidError("`modal shell` is currently not supported on Windows")
+
+    app = App("modal shell")
+
+    if ref is not None:
+        # `modal shell` with a sandbox ID gets the task_id, that's then handled by the `ta-*` flow below.
+        if ref.startswith("sb-") and len(ref[3:]) > 0 and ref[3:].isalnum():
+            from ..sandbox import Sandbox
+
+            try:
+                sandbox = Sandbox.from_id(ref)
+                task_id = sandbox._get_task_id()
+                ref = task_id
+            except NotFoundError as e:
+                raise ClickException(f"Sandbox '{ref}' not found")
+            except Exception as e:
+                raise ClickException(f"Error connecting to sandbox '{ref}': {str(e)}")
+
+        # `modal shell` with a container ID is a special case, alias for `modal container exec`.
+        if ref.startswith("ta-") and len(ref[3:]) > 0 and ref[3:].isalnum():
+            from .container import exec
+
+            exec(container_id=ref, command=shlex.split(cmd), pty=pty)
+            return
+
+        import_ref = parse_import_ref(ref, use_module_mode=use_module_mode)
+        runnable, all_usable_commands = import_and_filter(
+            import_ref, base_cmd="modal shell", accept_local_entrypoint=False, accept_webhook=True
+        )
+        if not runnable:
+            help_header = (
+                "Specify a Modal function to start a shell session for. E.g.\n"
+                f"> modal shell {import_ref.file_or_module}::my_function"
+            )
+
+            if all_usable_commands:
+                help_footer = f"The selected module '{import_ref.file_or_module}' has the following choices:\n\n"
+                help_footer += _get_runnable_list(all_usable_commands)
+            else:
+                help_footer = f"The selected module '{import_ref.file_or_module}' has no Modal functions or classes."
+
+            raise ClickException(f"{help_header}\n\n{help_footer}")
+
+        function_spec: _FunctionSpec
+        if isinstance(runnable, MethodReference):
+            # TODO: let users specify a class instead of a method, since they use the same environment
+            class_service_function = runnable.cls._get_class_service_function()
+            function_spec = class_service_function.spec
+        elif isinstance(runnable, Function):
+            function_spec = runnable.spec
+        else:
+            raise ValueError("Referenced entity is not a Modal function or class")
+
+        start_shell = partial(
+            interactive_shell,
+            image=function_spec.image,
+            mounts=function_spec.mounts,
+            secrets=function_spec.secrets,
+            network_file_systems=function_spec.network_file_systems,
+            gpu=function_spec.gpus,
+            cloud=function_spec.cloud,
+            cpu=function_spec.cpu,
+            memory=function_spec.memory,
+            volumes=function_spec.volumes,
+            region=function_spec.scheduler_placement.regions if function_spec.scheduler_placement else None,
+            pty=pty,
+            proxy=function_spec.proxy,
+        )
+    else:
+        modal_image = Image.from_registry(image, add_python=add_python) if image else None
+        volumes = {} if volume is None else {f"/mnt/{vol}": Volume.from_name(vol) for vol in volume}
+        secrets = [] if secret is None else [Secret.from_name(s) for s in secret]
+
+        mounts = []
+        if add_local:
+            for local_path_str in add_local:
+                local_path = Path(local_path_str).expanduser().resolve()
+                remote_path = PurePosixPath(f"/mnt/{local_path.name}")
+
+                if local_path.is_dir():
+                    m = _Mount._from_local_dir(local_path, remote_path=remote_path)
+                else:
+                    m = _Mount._from_local_file(local_path, remote_path=remote_path)
+                mounts.append(m)
+
+        start_shell = partial(
+            interactive_shell,
+            image=modal_image,
+            mounts=mounts,
+            cpu=cpu,
+            memory=memory,
+            gpu=gpu,
+            cloud=cloud,
+            volumes=volumes,
+            secrets=secrets,
+            region=region.split(",") if region else [],
+            pty=pty,
+        )
+
+    # NB: invoking under bash makes --cmd a lot more flexible.
+    cmds = shlex.split(f'/bin/bash -c "{cmd}"')
+    start_shell(app, cmds=cmds, environment_name=env, timeout=3600)

{modal-1.2.4.dev2 → modal-1.2.5.dev0}/modal/client.pyi

@@ -32,7 +32,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.4.dev2",
+        version: str = "1.2.5.dev0",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -163,7 +163,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.4.dev2",
+        version: str = "1.2.5.dev0",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.2.4.dev2 → modal-1.2.5.dev0}/modal/functions.pyi

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

{modal-1.2.4.dev2 → modal-1.2.5.dev0}/modal.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.4.dev2
+Version: 1.2.5.dev0
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0

{modal-1.2.4.dev2 → modal-1.2.5.dev0}/modal.egg-info/SOURCES.txt

@@ -155,6 +155,7 @@ modal/cli/profile.py
 modal/cli/queues.py
 modal/cli/run.py
 modal/cli/secret.py
+modal/cli/shell.py
 modal/cli/token.py
 modal/cli/utils.py
 modal/cli/volume.py

{modal-1.2.4.dev2 → modal-1.2.5.dev0}/modal_version/__init__.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2025
 """Supplies the current version of the modal client library."""
 
-__version__ = "1.2.4.dev2"
+__version__ = "1.2.5.dev0"