modal 1.5.6.dev23__tar.gz → 1.5.6.dev24__tar.gz

{modal-1.5.6.dev23 → modal-1.5.6.dev24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.6.dev23
+Version: 1.5.6.dev24
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.5.6.dev23 → modal-1.5.6.dev24}/modal/_functions.py

@@ -10,7 +10,7 @@ from collections.abc import AsyncGenerator, AsyncIterator, Callable, Collection,
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from pathlib import PurePosixPath
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 
 import typing_extensions
 from google.protobuf.message import Message
@@ -945,7 +945,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             self._hydrate(response.function_id, load_context.client, response.handle_metadata)
 
         async def _load(self: _Function, resolver: Resolver, load_context: LoadContext, existing_object_id: str | None):
-            with FunctionCreationStatus(tag) as function_creation_status:
+            with FunctionCreationStatus("Server" if is_server else "Function", tag) as function_creation_status:
                 timeout_secs = timeout
 
                 if app and app._is_interactive_ and not is_builder_function:
@@ -1388,6 +1388,72 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             _load_remote, rep, skip_reload=True, hydrate_lazily=True, load_context_overrides=load_context_overrides
         )
 
+    @classmethod
+    def _from_id(
+        cls,
+        function_id: str,
+        *,
+        load_context_overrides: LoadContext,
+        called_from: Literal["Function", "Server"] = "Function",
+    ):
+        # internal function lookup implementation that allows lookup of class "service functions"
+        # in addition to non-class functions
+        async def _load_remote(
+            self: _Function, resolver: Resolver, load_context: LoadContext, existing_object_id: str | None
+        ):
+            request = api_pb2.FunctionGetByIdRequest(function_id=function_id)
+            try:
+                response = await load_context.client.stub.FunctionGetById(request)
+            except NotFoundError as exc:
+                # refine the error message
+                msg = f"Lookup failed for {called_from} '{function_id}': {exc}."
+                raise NotFoundError(msg) from None
+            if called_from == "Function" and (response.function.is_server or response.function.is_class):
+                if response.function.is_server:
+                    raise InvalidError(f"{function_id} is a Server. Use \n ``modal.Server.from_id('{function_id}')``")
+                raise InvalidError(f"{function_id} is a Cls and cannot be loaded with Function.from_id().")
+            if called_from == "Server" and not response.function.is_server:
+                if response.function.is_class:
+                    raise InvalidError(f"{function_id} is a Cls and cannot be loaded with Server.from_id().")
+                raise InvalidError(f"{function_id} is a Function. Use \n ``modal.Function.from_id('{function_id}')``")
+            self._hydrate(function_id, load_context.client, response.handle_metadata)
+            self._function_info = FunctionInfo._from_function_proto(response.function)
+
+        rep = f"modal.Function.from_id('{function_id}')"
+        return cls._from_loader(
+            _load_remote, rep, skip_reload=True, hydrate_lazily=True, load_context_overrides=load_context_overrides
+        )
+
+    @classmethod
+    def from_id(
+        cls: type["_Function"],
+        function_id: str,
+        *,
+        client: _Client | None = None,
+    ):
+        """Reference a Function from a deployed or running App by its ID.
+
+        This is a lazy method that defers hydrating the local
+        object with metadata from Modal servers until the first
+        time it is actually used.
+
+        Args:
+            function_id: ID of the function.
+            client: Modal client to use; defaults to `Client.from_env()` when omitted.
+
+        Returns:
+            A lazy `Function` handle.
+
+        Examples:
+            ```python
+            f = modal.Function.from_id("fu-123")
+            ```
+        """
+        return cls._from_id(
+            function_id,
+            load_context_overrides=LoadContext(client=client),
+        )
+
     @classmethod
     def from_name(
         cls: type["_Function"],

{modal-1.5.6.dev23 → modal-1.5.6.dev24}/modal/_output/manager.py

@@ -58,6 +58,11 @@ class StatusRow(ABC):
         """Append a warning message associated with this row."""
         ...
 
+    @abstractmethod
+    def details(self, message: str) -> None:
+        """Append additional details to the row."""
+        ...
+
     @abstractmethod
     def finish(self, message: str) -> None:
         """Mark the row as finished with the given message."""
@@ -73,6 +78,9 @@ class DisabledStatusRow(StatusRow):
     def warn(self, warning: "api_pb2.Warning") -> None:
         pass
 
+    def details(self, message: str) -> None:
+        pass
+
     def finish(self, message: str) -> None:
         pass
 

{modal-1.5.6.dev23 → modal-1.5.6.dev24}/modal/_output/rich.py

@@ -194,6 +194,10 @@ class RichStatusRow(StatusRow):
         if self._spinner is not None:
             self._spinner.update(text=message)
 
+    def details(self, message: str) -> None:
+        if self._step_node is not None:
+            self._step_node.add(f"{message}")
+
     def warn(self, warning: api_pb2.Warning) -> None:
         if self._step_node is not None:
             self._step_node.add(f"[yellow]:warning:[/yellow] {warning.message}")
@@ -201,7 +205,7 @@ class RichStatusRow(StatusRow):
     def finish(self, message: str) -> None:
         if self._step_node is not None and self._spinner is not None:
             self._spinner.update(text=message)
-            self._step_node.label = f"🔨 {message}"
+            self._step_node.label = f"[green]✓[/green] {message}"
 
 
 _LOG_FLUSH_THRESHOLD = 32768  # 32KB — flush batched log output roughly every ~400 lines

modal-1.5.6.dev24/modal/_output/status.py

@@ -0,0 +1,92 @@
+# Copyright Modal Labs 2022
+"""Function creation status tracking for Modal CLI.
+
+This module contains the FunctionCreationStatus context manager used to
+track and display function creation progress.
+"""
+
+from __future__ import annotations
+
+from modal_proto import api_pb2
+
+from .manager import OutputManager
+
+
+def _get_annotation_for_web_url(url_info: api_pb2.WebUrlInfo) -> str:
+    if url_info.truncated:
+        suffix = " [grey70](label truncated)[/grey70]"
+    elif url_info.label_stolen:
+        suffix = " [grey70](label stolen)[/grey70]"
+    else:
+        suffix = ""
+    return suffix
+
+
+class FunctionCreationStatus:
+    """Context manager for tracking and displaying function creation progress."""
+
+    type: str
+    name: str
+    response: api_pb2.FunctionCreateResponse | None = None
+
+    def __init__(self, type: str, name: str):
+        self.type = type
+        self.name = name
+        self._output_mgr = OutputManager.get()
+
+    def __enter__(self):
+        self.status_row = self._output_mgr.add_status_row()
+        self.status_row.message(f"Creating {self.type} {self.name}...")
+        return self
+
+    def set_response(self, resp: api_pb2.FunctionCreateResponse):
+        self.response = resp
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type:
+            raise exc_val
+
+        if not self.response:
+            self.status_row.finish(f"Unknown error when creating {self.type} {self.name}")
+            return
+
+        for warning in self.response.server_warnings:
+            self.status_row.warn(warning)
+
+        if web_url := self.response.handle_metadata.web_url:
+            url_info = self.response.function.web_url_info
+            authenticated = self.response.function.webhook_config.requires_proxy_auth
+            auth_suffix = " 🔑" if authenticated else " [yellow](unauthenticated)[/yellow]"
+            suffix = _get_annotation_for_web_url(url_info)
+
+            self.status_row.finish(f"Created {self.type} [green]{self.name}[/green]")
+            self.status_row.details(f"[dim underline]{web_url}[/dim underline]{auth_suffix}{suffix}")
+            for custom_domain in self.response.function.custom_domain_info:
+                self.status_row.details(f"Custom domain: [dim underline]{custom_domain.url}[/dim underline]")
+
+        elif self.response.function.flash_service_urls:
+            # Despite the gRPC API types, Servers only have one URL
+            authenticated = self.response.function.is_server and not self.response.function.http_config.unauthenticated
+            auth_suffix = " 🔑" if authenticated else " [yellow](unauthenticated)[/yellow]"
+            self.status_row.finish(f"Created {self.type} [green]{self.name}[/green]")
+            url = self.response.function.flash_service_urls[0]
+            self.status_row.details(f"[dim underline]{url}[/dim underline]{auth_suffix}")
+
+        else:
+            self.status_row.finish(f"Created {self.type} [green]{self.name}[/green].")
+            if self.response.function.method_definitions_set:
+                for method_definition in self.response.function.method_definitions.values():
+                    if method_definition.web_url:
+                        url_info = method_definition.web_url_info
+                        suffix = _get_annotation_for_web_url(url_info)
+                        authenticated = method_definition.webhook_config.requires_proxy_auth
+                        auth_suffix = " 🔑" if authenticated else " [yellow](unauthenticated)[/yellow]"
+                        self.status_row.details(
+                            f"{method_definition.function_name} -> "
+                            f"[dim underline]{method_definition.web_url}[/dim underline]{auth_suffix}{suffix}"
+                        )
+                        for custom_domain in method_definition.custom_domain_info:
+                            indent = len(method_definition.function_name) * " "
+                            self.status_row.details(
+                                f"{indent} -> [dim underline]{custom_domain.url}[/dim underline]{auth_suffix}"
+                            )

{modal-1.5.6.dev23 → modal-1.5.6.dev24}/modal/_server.py

@@ -273,6 +273,38 @@ class _Server:
         )
         return server
 
+    @classmethod
+    def from_id(
+        cls: type["_Server"],
+        server_id: str,
+        *,
+        client: _Client | None = None,
+    ):
+        """Reference a Server from a deployed or running App by its ID.
+
+        This is a lazy method that defers hydrating the local
+        object with metadata from Modal servers until the first
+        time it is actually used.
+
+        Args:
+            server_id: The ID of the server.
+            client: Modal client instance for this session.
+
+        Examples:
+            ```python notest
+            server = modal.Server.from_id("fu-456")
+            ```
+        """
+        load_context_overrides = LoadContext(client=client)
+
+        server = _Server()
+        server._service_function = _Function._from_id(
+            server_id,
+            load_context_overrides=load_context_overrides,
+            called_from="Server",
+        )
+        return server
+
     def _is_local(self) -> bool:
         """Returns True if this Server has local source code available."""
         return self._user_cls is not None

{modal-1.5.6.dev23 → modal-1.5.6.dev24}/modal/cli/config.py

@@ -1,5 +1,5 @@
 # Copyright Modal Labs 2022
-import json
+from json import dumps
 
 import click
 
@@ -21,11 +21,12 @@ config_cli = ModalGroup(
 )
 
 
-@config_cli.command("show", help="Show current configuration values (debugging command).")
+@config_cli.command("show", help="Show current configuration values.")
 @click.option("--redact/--no-redact", default=True, help="Redact secret credential values.")
-def show(redact: bool):
-    # This is just a test command
-    config_dict = config.to_dict()
+@click.option("--include-internal", is_flag=True, help="Include internal feature flags.", hidden=True)
+@click.option("--json", is_flag=True, default=False)
+def show(redact: bool, include_internal: bool, json: bool):
+    config_dict = config.to_dict(include_internal=include_internal)
     if redact and config_dict.get("token_secret"):
         config_dict["token_secret"] = "***"
     if redact and config_dict.get("oauth_refresh_token"):
@@ -33,7 +34,8 @@ def show(redact: bool):
     if redact and config_dict.get("oauth_client_secret"):
         config_dict["oauth_client_secret"] = "***"
 
-    OutputManager.get().print_json(json.dumps(config_dict))
+    # Accept --json as a no-op for consistency; we may change the default formatting later
+    OutputManager.get().print_json(dumps(config_dict))
 
 
 SET_DEFAULT_ENV_HELP = """Set the default Modal environment for the active profile

{modal-1.5.6.dev23 → modal-1.5.6.dev24}/modal/cli/function.py

@@ -37,7 +37,14 @@ from ._stats import (
     stats_style,
     success_style,
 )
-from .utils import _resolve_function_id, display_table, env_option, humanize_filesize
+from .utils import (
+    HEADER_ONLY,
+    _resolve_function_id,
+    display_table,
+    env_option,
+    grouped_utc_timestamp,
+    humanize_filesize,
+)
 
 function_cli = ModalGroup(name="function", help="Inspect Modal Functions.")
 
@@ -48,6 +55,46 @@ _CONTAINER_METRIC_ORDER = (
     "Memory Usage (GiB)",
     "GPU Utilization (%)",
 )
+_DEFAULT_CALL_TAIL = 100
+_MAX_CALL_TAIL = 1000
+_FAILURE_STATUSES = {
+    api_pb2.FUNCTION_CALL_INPUT_STATUS_FAILURE: "Failure",
+    api_pb2.FUNCTION_CALL_INPUT_STATUS_TIMEOUT: "Timeout",
+    api_pb2.FUNCTION_CALL_INPUT_STATUS_TERMINATED: "Terminated",
+    api_pb2.FUNCTION_CALL_INPUT_STATUS_INIT_FAILURE: "Failure",
+    api_pb2.FUNCTION_CALL_INPUT_STATUS_INTERNAL_FAILURE: "Failure",
+    api_pb2.FUNCTION_CALL_INPUT_STATUS_IDLE_TIMEOUT: "Timeout (idle)",
+    api_pb2.FUNCTION_CALL_INPUT_STATUS_MEMORY_MANAGER_EVICTION: "Evicted (over memory request)",
+}
+
+
+def _optional_duration(value: float, present: bool) -> str:
+    if not present:
+        return "—"
+    return f"{value:.2f}"
+
+
+def _function_call_status(status: api_pb2.FunctionCallInputStatus.ValueType, json_output: bool = False) -> str | int:
+    try:
+        name = api_pb2.FunctionCallInputStatus.Name(status)
+    except ValueError:
+        return status
+    label = name.removeprefix("FUNCTION_CALL_INPUT_STATUS_").replace("_", " ")
+    if json_output:
+        return label.lower()
+    return _FAILURE_STATUSES.get(status, label.title())
+
+
+def _function_call_status_cell(status: api_pb2.FunctionCallInputStatus.ValueType, no_color: bool = False) -> Text:
+    style = None
+    if status == api_pb2.FUNCTION_CALL_INPUT_STATUS_PENDING:
+        style = "yellow"
+    elif status == api_pb2.FUNCTION_CALL_INPUT_STATUS_RUNNING:
+        style = "green"
+    elif status in _FAILURE_STATUSES:
+        style = "red"
+    label = str(_function_call_status(status))
+    return Text(label, style=style) if style and not no_color else Text(label)
 
 
 def _time_range_stats_json(response: api_pb2.FunctionGetTimeRangeStatsResponse) -> dict[str, object]:
@@ -307,6 +354,183 @@ async def stats(
         output.print(_percentile_table(container_rows, use_color))
 
 
+@function_cli.command("calls", no_args_is_help=True)
+@click.argument("function_identifier", metavar="FUNCTION")
+@click.option(
+    "-n",
+    "--tail",
+    type=click.IntRange(min=1, max=_MAX_CALL_TAIL),
+    default=_DEFAULT_CALL_TAIL,
+    show_default=True,
+    help="Show up to the last N Function inputs.",
+)
+@click.option(
+    "--all-variants",
+    is_flag=True,
+    default=False,
+    help="Include inputs from the base Function and all its variants.",
+)
+@click.option(
+    "--show-function-call-id",
+    is_flag=True,
+    default=False,
+    help="Include the Function Call ID in table output.",
+)
+@click.option("--json", "json_output", is_flag=True, default=False, help="Output calls as JSON.")
+@click.option("--no-color", "no_color", is_flag=True, default=False, help="Disable colors in the output.")
+@env_option
+@synchronizer.create_blocking
+async def calls(
+    function_identifier: str,
+    tail: int = _DEFAULT_CALL_TAIL,
+    all_variants: bool = False,
+    show_function_call_id: bool = False,
+    json_output: bool = False,
+    no_color: bool = False,
+    *,
+    env: str | None = None,
+) -> None:
+    """Show recent inputs for a Modal Function.
+
+    FUNCTION may be a Function ID or a deployed Function name in the form
+    ``APP_NAME/FUNCTION_NAME``. Each unique input corresponds to one entry
+    in the output.
+
+    Examples:
+
+    ```
+    modal function calls my-app/my-function
+    ```
+
+    Show recent calls across all variants of a Cls:
+
+    ```
+    modal function calls 'my-app/MyClass.*' --all-variants --tail 500
+    ```
+
+    Disable color in the output:
+
+    ```
+    modal function calls my-app/my-function --no-color
+    ```
+    """
+    environment_name = _get_environment_name(ensure_env(env))
+    client = await _Client.from_env()
+    function_id, _ = await _resolve_function_id(
+        client,
+        function_identifier,
+        environment_name,
+        command="calls",
+    )
+    response = await client.stub.FunctionCallFetch(
+        api_pb2.FunctionCallFetchRequest(
+            function_id=function_id,
+            tail=api_pb2.FunctionCallFetchRequest.Tail(count=tail),
+            all_variants=all_variants,
+        )
+    )
+
+    if json_output:
+        OutputManager.get().print_json(
+            json_lib.dumps(
+                [
+                    {
+                        "function_call_id": call.function_call_id,
+                        "service_method_name": (
+                            call.service_method_name if call.HasField("service_method_name") else None
+                        ),
+                        "enqueued_at": (call.enqueued_at.ToJsonString() if call.HasField("enqueued_at") else None),
+                        "started_at": (call.started_at.ToJsonString() if call.HasField("started_at") else None),
+                        "container_id": call.container_id if call.HasField("container_id") else None,
+                        "startup_time_seconds": (
+                            call.startup_time_seconds if call.HasField("startup_time_seconds") else None
+                        ),
+                        "execution_time_seconds": (
+                            call.execution_time_seconds if call.HasField("execution_time_seconds") else None
+                        ),
+                        "status": _function_call_status(call.status, True),
+                    }
+                    for call in response.function_call_inputs
+                ]
+            )
+        )
+        return
+
+    show_service_method_name = bool(response.function_call_inputs) and all(
+        call.HasField("service_method_name") for call in response.function_call_inputs
+    )
+    rows: list[list[Text | str]] = []
+    previous_enqueued_date = None
+    for call in response.function_call_inputs:
+        if call.HasField("enqueued_at"):
+            enqueued_at, enqueued_date = grouped_utc_timestamp(call.enqueued_at, previous_enqueued_date)
+            previous_enqueued_date = enqueued_date
+        else:
+            enqueued_at = "—"
+            enqueued_date = None
+
+        if call.HasField("started_at") and enqueued_date:
+            started_secs = (
+                call.started_at.ToDatetime(tzinfo=timezone.utc) - call.enqueued_at.ToDatetime(tzinfo=timezone.utc)
+            ).total_seconds()
+            started_at = f"{started_secs:.2f}"
+        else:
+            started_at = "—"
+
+        row: list[Text | str] = [Text(enqueued_at), Text(started_at)]
+        if show_function_call_id:
+            row.append(Text(call.function_call_id or "—"))
+        if show_service_method_name:
+            row.append(Text(call.service_method_name))
+        row.extend(
+            [
+                Text(
+                    call.container_id if call.HasField("container_id") else "—",
+                ),
+                Text(
+                    _optional_duration(call.execution_time_seconds, call.HasField("execution_time_seconds")),
+                ),
+                _function_call_status_cell(call.status, no_color=no_color),
+            ]
+        )
+        rows.append(row)
+
+    title = f"Function calls for {function_id}"
+    if all_variants:
+        title += " · all variants"
+    output = OutputManager.get()
+    output.print("")
+    output.print(Text(title))
+    output.print(
+        Text(
+            f"Displaying {len(rows):,} {'row' if len(rows) == 1 else 'rows'}",
+            style=STATS_METADATA_STYLE if not no_color else "",
+        )
+    )
+    output.print("")
+    columns: list[str | Column] = [
+        Column("Enqueued (UTC)", no_wrap=True, justify="right"),
+        Column("Queue Time (s)", justify="right"),
+    ]
+    if show_function_call_id:
+        columns.append("Function Call ID")
+    if show_service_method_name:
+        columns.append("Method")
+    columns.extend(
+        [
+            Column("Container", width=29),
+            Column("Execution (s)", justify="right"),
+            "Status",
+        ]
+    )
+    display_table(
+        columns,
+        rows,
+        table_box=HEADER_ONLY,
+        border_style=STATS_METADATA_STYLE if not no_color else "",
+    )
+
+
 @function_cli.command("logs", no_args_is_help=True)
 @click.argument("function_ref")
 @click.option("-f", "--follow", is_flag=True, default=False, help="Stream log output until interrupted")