modal 1.5.6.dev22__tar.gz → 1.5.6.dev24__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.6.dev22
+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.dev22 → modal-1.5.6.dev24}/modal/_function_variants.py

@@ -4,12 +4,15 @@ from collections.abc import Collection, Sequence, Sized
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING, Any
 
+import google.protobuf.message
+
 from modal.types import CloudBucketMountInfo, FunctionInfo, VolumeMountInfo
 from modal_proto import api_pb2
 
 from ._resources import convert_fn_config_to_resources_config
 from ._serialization import (
     apply_defaults,
+    deserialize_proto_params,
     serialize,
     serialize_proto_params,
     validate_parameter_values,
@@ -17,11 +20,14 @@ from ._serialization import (
 from ._utils.function_utils import _parse_retries
 from ._utils.mount_utils import validate_volumes, validate_volumes_by_object_id
 from .cloud_bucket_mount import _CloudBucketMount, cloud_bucket_mounts_to_proto
+from .exception import InvalidError
 from .retries import Retries
 from .secret import _Secret
 from .volume import _Volume, _volume_to_mount_proto
 
 if TYPE_CHECKING:
+    from modal.client import _Client
+
     from ._functions import _Function
     from ._load_context import LoadContext
     from ._object import _Object
@@ -190,6 +196,157 @@ class _FunctionOptions:
         )
 
 
+@dataclasses.dataclass(frozen=True)
+class _FunctionOptionsInfo:
+    """Configuration overrides applied to a Function variant.
+
+    Fields are named after the parameters of the builder methods that set them: `.with_options()`,
+    `.with_concurrency()` (`max_inputs`, `target_inputs`), and `.with_batching()` (`max_batch_size`,
+    `wait_ms`). Fields are None when the variant does not override that setting.
+    """
+
+    cpu: float | tuple[float, float] | None = None
+    memory: int | tuple[int, int] | None = None
+    gpu: str | None = None
+    secrets: list[str] | None = None
+    volumes: dict[str, VolumeMountInfo] | None = None  # mount path -> volume and its mount options
+    cloud_bucket_mounts: dict[str, CloudBucketMountInfo] | None = None  # mount path -> bucket mount
+    retries: Retries | None = None
+    max_containers: int | None = None
+    buffer_containers: int | None = None
+    scaledown_window: int | None = None
+    timeout: int | None = None
+    region: str | list[str] | None = None
+    cloud: str | None = None
+    routing_region: str | None = None
+    max_inputs: int | None = None
+    target_inputs: int | None = None
+    max_batch_size: int | None = None
+    wait_ms: int | None = None
+
+    @classmethod
+    def _from_proto(cls, proto: api_pb2.FunctionOptions) -> "_FunctionOptionsInfo":
+        cpu: float | tuple[float, float] | None = None
+        memory: int | tuple[int, int] | None = None
+        gpu: str | None = None
+        if proto.HasField("resources"):
+            resources = proto.resources
+            if resources.milli_cpu_max > 0:
+                cpu = (resources.milli_cpu / 1000, resources.milli_cpu_max / 1000)
+            elif resources.milli_cpu > 0:
+                cpu = resources.milli_cpu / 1000
+
+            if resources.memory_mb_max > 0:
+                memory = (resources.memory_mb, resources.memory_mb_max)
+            elif resources.memory_mb > 0:
+                memory = resources.memory_mb
+
+            if resources.gpu_config.count > 0:
+                gpu_config = resources.gpu_config
+                gpu = gpu_config.gpu_type if gpu_config.count == 1 else f"{gpu_config.gpu_type}:{gpu_config.count}"
+
+        retries: Retries | None = None
+        if proto.HasField("retry_policy"):
+            retry_policy = proto.retry_policy
+            retries = Retries(
+                max_retries=retry_policy.retries,
+                backoff_coefficient=retry_policy.backoff_coefficient or 2.0,
+                initial_delay=retry_policy.initial_delay_ms / 1000,
+                max_delay=retry_policy.max_delay_ms / 1000 or 60.0,
+            )
+
+        region: str | list[str] | None = None
+        if proto.HasField("scheduler_placement") and proto.scheduler_placement.regions:
+            region = list(proto.scheduler_placement.regions)
+
+        return cls(
+            cpu=cpu,
+            memory=memory,
+            gpu=gpu,
+            secrets=list(proto.secret_ids) or None,
+            volumes={
+                vm.mount_path: VolumeMountInfo(
+                    name=None,  # The mount records which Volume, not what it was called.
+                    volume_id=vm.volume_id,
+                    read_only=vm.read_only,
+                    sub_path=vm.sub_path if vm.HasField("sub_path") else None,
+                )
+                for vm in proto.volume_mounts
+            }
+            or None,
+            cloud_bucket_mounts={
+                cbm.mount_path: CloudBucketMountInfo._from_proto(cbm) for cbm in proto.cloud_bucket_mounts
+            }
+            or None,
+            retries=retries,
+            max_containers=proto.concurrency_limit if proto.HasField("concurrency_limit") else None,
+            buffer_containers=proto.buffer_containers if proto.HasField("buffer_containers") else None,
+            scaledown_window=proto.task_idle_timeout_secs if proto.HasField("task_idle_timeout_secs") else None,
+            timeout=proto.timeout_secs if proto.HasField("timeout_secs") else None,
+            region=region,
+            cloud=proto.cloud_provider_str if proto.HasField("cloud_provider_str") else None,
+            routing_region=proto.routing_region if proto.HasField("routing_region") else None,
+            max_inputs=proto.max_concurrent_inputs if proto.HasField("max_concurrent_inputs") else None,
+            target_inputs=proto.target_concurrent_inputs if proto.HasField("target_concurrent_inputs") else None,
+            max_batch_size=proto.batch_max_size if proto.HasField("batch_max_size") else None,
+            wait_ms=proto.batch_linger_ms if proto.HasField("batch_linger_ms") else None,
+        )
+
+
+@dataclasses.dataclass(frozen=True)
+class _FunctionVariantInfo:
+    """Information about a variant of a Function, created by parametrization or `.with_options()`."""
+
+    function_id: str
+    parameters: dict[str, str | int | bytes | bool] | None  # None when the parameters can't be decoded
+    options: _FunctionOptionsInfo | None
+
+    @classmethod
+    def _from_proto(cls, proto: api_pb2.FunctionVariantInfo) -> "_FunctionVariantInfo":
+        parameters: dict[str, str | int | bytes | bool] | None
+        try:
+            parameters = deserialize_proto_params(proto.serialized_params)
+        except (google.protobuf.message.DecodeError, InvalidError):
+            parameters = None
+
+        return cls(
+            function_id=proto.function_id,
+            parameters=parameters,
+            options=_FunctionOptionsInfo._from_proto(proto.function_options)
+            if proto.HasField("function_options")
+            else None,
+        )
+
+
+@dataclasses.dataclass(frozen=True)
+class _FunctionVariantListing:
+    """The variants of a Function, and how the server chose to order them."""
+
+    variants: list[_FunctionVariantInfo]
+    # True when the variants are ordered by how many tasks each is running, busiest first.
+    ordered_by_task_count: bool
+
+
+async def _list_function_variants(
+    client: "_Client", function_id: str, *, limit: int | None = None
+) -> _FunctionVariantListing:
+    variants: list[_FunctionVariantInfo] = []
+    ordered_by_task_count = False
+    cursor = None
+    while True:
+        request = api_pb2.FunctionListVariantsRequest(function_id=function_id, cursor=cursor, limit=limit or 0)
+        response = await client.stub.FunctionListVariants(request)
+        # An ordered listing arrives as a single response, so there is nothing to reconcile across
+        # pages: every response of a multi-page listing reports itself unordered.
+        ordered_by_task_count = response.ordered_by_task_count
+        variants.extend(_FunctionVariantInfo._from_proto(info) for info in response.infos)
+        if limit is not None and len(variants) >= limit:
+            return _FunctionVariantListing(variants[:limit], ordered_by_task_count)
+        if not response.HasField("next_cursor"):
+            return _FunctionVariantListing(variants, ordered_by_task_count)
+        cursor = response.next_cursor
+
+
 async def _function_bind_params_cached(
     base_function: "_Function",
     req: api_pb2.FunctionBindParamsRequest,

{modal-1.5.6.dev22 → 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.dev22 → 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.dev22 → 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.dev22 → 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.dev22 → 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