modAL 1.5.2__tar.gz → 1.5.2.dev0__tar.gz

{modal-1.5.2 → modal-1.5.2.dev0}/PKG-INFO

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

{modal-1.5.2 → modal-1.5.2.dev0}/modal/__init__.py

@@ -9,7 +9,7 @@ if sys.version_info[:2] >= (3, 15):
 from modal_version import __version__
 
 try:
-    from . import billing, types
+    from . import billing
     from ._runtime.execution_context import current_function_call_id, current_input_id, interact, is_local
     from ._tunnel import Tunnel, forward
     from .app import App
@@ -100,7 +100,6 @@ __all__ = [
     "interact",
     "method",
     "parameter",
-    "types",
     "web_endpoint",
     "web_server",
     "wsgi_app",

{modal-1.5.2 → modal-1.5.2.dev0}/modal/_billing.py

@@ -1,7 +1,10 @@
 # Copyright Modal Labs 2025
-from datetime import datetime
+from dataclasses import FrozenInstanceError, dataclass
+from datetime import datetime, timezone
 from decimal import Decimal
-from typing import TypedDict
+from typing import Any, Iterable, TypedDict
+
+from modal_proto import api_pb2
 
 from ._utils.deprecation import deprecation_warning
 from .client import _Client
@@ -16,6 +19,54 @@ class WorkspaceBillingReportItem(TypedDict):
     tags: dict[str, str]
 
 
+@dataclass(slots=True, frozen=True)
+class BillingReportItem:
+    object_id: str
+    description: str
+    environment_name: str
+    interval_start: datetime
+    cost: Decimal
+    cost_by_resource: dict[str, Decimal]
+    tags: dict[str, str]
+
+    def __getitem__(self, key: str) -> Any:
+        """mdmd:ignore"""
+        if key not in self.__slots__:
+            raise KeyError(key)
+
+        return getattr(self, key)
+
+    def __setitem__(self, key: str, _: Any):
+        """mdmd:ignore"""
+        raise FrozenInstanceError(f"cannot assign to field {key!r}")
+
+    def keys(self) -> Iterable[str]:
+        """mdmd:ignore"""
+        yield from self.__slots__
+
+    def values(self) -> Iterable[Any]:
+        """mdmd:ignore"""
+        for k in self.__slots__:
+            yield getattr(self, k)
+
+    def items(self) -> Iterable[tuple[str, Any]]:
+        """mdmd:ignore"""
+        for k in self.__slots__:
+            yield k, getattr(self, k)
+
+    @classmethod
+    def _from_proto(cls, pb_item: api_pb2.WorkspaceBillingReportItem) -> "BillingReportItem":
+        return cls(
+            object_id=pb_item.object_id,
+            description=pb_item.description,
+            environment_name=pb_item.environment_name,
+            interval_start=pb_item.interval.ToDatetime().replace(tzinfo=timezone.utc),
+            cost=Decimal(pb_item.cost),
+            cost_by_resource={k: Decimal(v) for k, v in pb_item.cost_by_resource.items()},
+            tags=dict(pb_item.tags),
+        )
+
+
 async def _workspace_billing_report(
     *,
     start: datetime,  # Start of the report, inclusive

{modal-1.5.2 → modal-1.5.2.dev0}/modal/_environments.py

@@ -13,6 +13,7 @@ from synchronicity import classproperty
 
 from modal_proto import api_pb2
 
+from ._billing import BillingReportItem
 from ._load_context import LoadContext
 from ._object import _Object
 from ._resolver import Resolver
@@ -20,7 +21,6 @@ from ._utils.name_utils import check_environment_name
 from .client import _Client
 from .config import config, logger
 from .exception import InvalidError, WorkspaceManagementError
-from .types import BillingReportItem
 
 
 @dataclass(frozen=True)
@@ -103,6 +103,9 @@ class _EnvironmentManager:
         await client.stub.EnvironmentDelete(api_pb2.EnvironmentDeleteRequest(name=name))
 
 
+MemberRole = Literal["viewer", "contributor"]
+
+
 def _role_to_proto(role: str) -> "api_pb2.EnvironmentRole.ValueType":
     match role:
         case "viewer":
@@ -113,7 +116,7 @@ def _role_to_proto(role: str) -> "api_pb2.EnvironmentRole.ValueType":
             raise InvalidError(f"Invalid Environment role: {role!r} (expected 'viewer' or 'contributor')")
 
 
-def _role_from_proto(proto_value: int) -> str:
+def _role_from_proto(proto_value: int) -> MemberRole:
     match proto_value:
         case api_pb2.ENVIRONMENT_ROLE_VIEWER:
             return "viewer"
@@ -134,7 +137,7 @@ class _EnvironmentMembersManager:
         """mdmd:hidden"""
         self._environment = environment
 
-    async def list(self) -> dict[Literal["users", "service_users"], dict[str, str]]:
+    async def list(self) -> dict[Literal["users", "service_users"], dict[str, MemberRole]]:
         """Return the members of a restricted Environment with their roles.
 
         **Examples:**
@@ -152,8 +155,8 @@ class _EnvironmentMembersManager:
         req = api_pb2.EnvironmentGetManagedRequest(environment_id=self._environment.object_id)
         resp = await self._environment.client.stub.EnvironmentGetManaged(req)
 
-        users: dict[str, str] = {}
-        service_users: dict[str, str] = {}
+        users: dict[str, MemberRole] = {}
+        service_users: dict[str, MemberRole] = {}
         for principal in resp.principal_roles:
             role = _role_from_proto(principal.role)
             if principal.user_id:
@@ -166,8 +169,8 @@ class _EnvironmentMembersManager:
     async def update(
         self,
         *,
-        users: Mapping[str, str] | None = None,
-        service_users: Mapping[str, str] | None = None,
+        users: Mapping[str, MemberRole] | None = None,
+        service_users: Mapping[str, MemberRole] | None = None,
     ) -> None:
         """Add or modify roles for members of a restricted Environment.
 

{modal-1.5.2 → modal-1.5.2.dev0}/modal/_function_variants.py

@@ -51,7 +51,6 @@ class _FunctionOptions:
     target_concurrent_inputs: int | None = None
     batch_max_size: int | None = None
     batch_wait_ms: int | None = None
-    routing_region: str | None = None
 
     @classmethod
     def new(
@@ -74,7 +73,6 @@ class _FunctionOptions:
         target_concurrent_inputs: int | None = None,
         batch_max_size: int | None = None,
         batch_wait_ms: int | None = None,
-        routing_region: str | None = None,
     ) -> "_FunctionOptions":
         """Internal constructor that validates and normalizes public parameters."""
         retry_policy = _parse_retries(retries)
@@ -121,7 +119,6 @@ class _FunctionOptions:
             target_concurrent_inputs=target_concurrent_inputs,
             batch_max_size=batch_max_size,
             batch_wait_ms=batch_wait_ms,
-            routing_region=routing_region,
         )
 
     def merge_options(self, new_options: "_FunctionOptions") -> "_FunctionOptions":
@@ -185,7 +182,6 @@ class _FunctionOptions:
             batch_linger_ms=self.batch_wait_ms,
             scheduler_placement=self.scheduler_placement,
             cloud_provider_str=self.cloud,
-            routing_region=self.routing_region,
         )
 
 

{modal-1.5.2 → modal-1.5.2.dev0}/modal/_functions.py

@@ -90,7 +90,6 @@ from .proxy import _Proxy
 from .retries import Retries, RetryManager
 from .schedule import Schedule
 from .secret import _Secret
-from .types import FunctionStats
 from .volume import _Volume, _volume_to_mount_proto
 
 if TYPE_CHECKING:
@@ -542,6 +541,17 @@ class _InputPlaneInvocation:
         return [("x-modal-input-plane-region", input_plane_region), ("x-modal-auth-token", token)]
 
 
+# Wrapper type for api_pb2.FunctionStats
+@dataclass(frozen=True)
+class FunctionStats:
+    """Simple data structure storing stats for a running function."""
+
+    backlog: int
+    num_total_runners: int
+    num_running_inputs: int
+    input_headroom: int
+
+
 @dataclass
 class _FunctionSpec:
     """
@@ -1509,7 +1519,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         timeout: int | None = None,
         region: str | Sequence[str] | None = None,
         cloud: str | None = None,
-        routing_region: str | None = None,
     ) -> "_Function[P, ReturnType, OriginalReturnType]":
         """Dynamically override the static Function configuration with invocation-specific values.
 
@@ -1558,7 +1567,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             timeout=timeout,
             region=region,
             cloud=cloud,
-            routing_region=routing_region,
         )
 
         return self._apply_dynamic_config(options, "with_options")

{modal-1.5.2 → modal-1.5.2.dev0}/modal/_image.py

@@ -117,34 +117,13 @@ def _validate_image_tag(tag: str) -> None:
     check_object_name(tag, "Image tag")
 
 
-def _parse_named_image_ref(name: str) -> tuple[str, str]:
-    """Parse an image reference, returning (namespace_prefix, name_tag).
-
-    If the name contains a '/', the part before the last '/' is extracted as
-    a namespace prefix (intended for environment/name or workspace/env/name
-    syntax). The actual image name (after the last '/') is validated as a
-    standard object name.
-
-    Returns a tuple of (prefix, "full_name:tag") where prefix is empty string
-    if no '/' is present.
-    """
+def _parse_named_image_ref(name: str) -> str:
     image_name, sep, tag = name.partition(":")
     if not sep:
         tag = "latest"
-
-    prefix = ""
-    if "/" in image_name:
-        prefix, image_name = image_name.rsplit("/", 1)
-        if not prefix:
-            raise InvalidError("Invalid Image name: '/' prefix must be non-empty.")
-        if not image_name:
-            raise InvalidError("Invalid Image name: name after '/' must be non-empty.")
-
     _validate_image_name(image_name)
     _validate_image_tag(tag)
-
-    full_name = f"{prefix}/{image_name}" if prefix else image_name
-    return prefix, f"{full_name}:{tag}"
+    return f"{image_name}:{tag}"
 
 
 def _validate_python_version(
@@ -1043,7 +1022,7 @@ class _Image(_Object, type_prefix="im"):
             ```
         """
         if app.app_id is None:
-            raise InvalidError("App has not been initialized yet. Use the context manager `app.run()` or `App.lookup`")
+            raise InvalidError("App has not been initialized yet. Use the content manager `app.run()` or `App.lookup`")
 
         resolver = Resolver()
         async with TaskContext() as tc:
@@ -2944,15 +2923,12 @@ class _Image(_Object, type_prefix="im"):
             ...
         ```
         """
-        namespace_prefix, tag = _parse_named_image_ref(name)
-
-        if namespace_prefix and environment_name:
-            raise InvalidError("Cannot specify 'environment_name' when the image name contains a '/'.")
+        tag = _parse_named_image_ref(name)
 
         async def _load(self: _Image, resolver: Resolver, load_context: LoadContext, existing_object_id: str | None):
             req = api_pb2.ImageGetByTagRequest(
                 tag=tag,
-                environment_name="" if namespace_prefix else load_context.environment_name,
+                environment_name=load_context.environment_name,
             )
             response = await load_context.client.stub.ImageGetByTag(req)
             self._hydrate(response.image_id, load_context.client, None)
@@ -2987,25 +2963,20 @@ class _Image(_Object, type_prefix="im"):
         image.publish("my-image-with-numpy:v1")
         ```
         """
-        namespace_prefix, tag = _parse_named_image_ref(name)
-
-        if namespace_prefix:
-            if environment_name:
-                raise InvalidError("Cannot specify 'environment_name' when the image name contains a '/'.")
-            resolved_env = ""
-        else:
-            resolved_env = environment_name or config.get("environment") or ""
+        tag = _parse_named_image_ref(name)
 
         if self._object_id is None:
             raise InvalidError("Cannot publish an image that has not been created yet. Call `.build()` first.")
 
         _client = client or await _Client.from_env()
 
+        resolved_env = environment_name or config.get("environment") or ""
+
         await _client.stub.ImagePublish(
             api_pb2.ImagePublishRequest(
                 image_id=self._object_id,
                 environment_name=resolved_env,
-                allow_public=False,
+                is_public=False,
                 tag=tag,
             )
         )

{modal-1.5.2 → modal-1.5.2.dev0}/modal/_runtime/container_io_manager.py

@@ -264,7 +264,7 @@ class IOContext:
         if not inspect.isasyncgen(expected_async_gen):
             raise InvalidError(f"Async generator function returned value of type {type(expected_async_gen)}")
 
-        async with aclosing(cast(AsyncGenerator[Any, None], expected_async_gen)) as gen:
+        async with aclosing(expected_async_gen) as gen:
             async for result in gen:
                 yield result
         logger.debug(f"Finished generator input {self.input_ids}")

{modal-1.5.2 → modal-1.5.2.dev0}/modal/_utils/blob_utils.py

@@ -138,13 +138,6 @@ async def _upload_to_s3_url(
                     text = await resp.text()
                 except Exception:
                     text = "<no body>"
-
-                if "The Content-MD5 you specified did not match what we received." in text:
-                    raise ExecutionError(
-                        "Hash mismatch during upload. This may be caused by files changing while an upload is in "
-                        "progress. Please try again."
-                    )
-
                 raise ExecutionError(f"Put to url {upload_url} failed with status {resp.status}: {text}")
 
             # client side ETag checksum verification

{modal-1.5.2 → modal-1.5.2.dev0}/modal/_utils/grpc_utils.py

@@ -31,7 +31,7 @@ from modal_version import __version__
 
 from .._traceback import suppress_tb_frame
 from ..config import config
-from .async_utils import TaskContext, retry
+from .async_utils import retry
 from .logger import logger
 
 RequestType = TypeVar("RequestType", bound=Message)
@@ -163,10 +163,8 @@ RETRYABLE_GRPC_STATUS_CODES = [
     Status.UNKNOWN,
 ]
 SERVER_RETRY_WARNING_TIME_INTERVAL = 30.0
+# Initial per-attempt timeout for TCP/TLS handshake in connect_channel.
 DEFAULT_MAX_RETRIES = 3
-GRPC_KEEPALIVE_TIME_SECS = 30.0
-GRPC_KEEPALIVE_TIMEOUT_SECS = 10.0
-GRPC_WINDOW_SIZE = 64 * 1024 * 1024  # 64 MiB
 
 
 @dataclass
@@ -192,7 +190,14 @@ class ConnectionManager:
 
     async def get_or_create_channel(self, server_url: str) -> grpclib.client.Channel:
         if server_url not in self._channels:
-            self._channels[server_url] = await create_channel_with_fallbacks(server_url, self._metadata)
+            self._channels[server_url] = create_channel(
+                server_url,
+                self._metadata,
+            )
+            try:
+                await connect_channel(self._channels[server_url])
+            except (OSError, asyncio.TimeoutError) as exc:
+                raise ConnectionError("Could not connect to the Modal server.") from exc
         return self._channels[server_url]
 
     def close(self):
@@ -254,21 +259,6 @@ class CustomProtoStatusDetailsCodec(StatusDetailsCodecBase):
 custom_detail_codec = CustomProtoStatusDetailsCodec()
 
 
-def create_channel_config() -> grpclib.config.Configuration:
-    """Shared grpclib channel settings for Modal client connections.
-
-    HTTP/2 keepalive probes keep idle transports warm through stateful
-    middleboxes and surface dead connections before retries reuse them.
-    """
-    return grpclib.config.Configuration(
-        _keepalive_time=GRPC_KEEPALIVE_TIME_SECS,
-        _keepalive_timeout=GRPC_KEEPALIVE_TIMEOUT_SECS,
-        _keepalive_permit_without_calls=True,
-        http2_connection_window_size=GRPC_WINDOW_SIZE,
-        http2_stream_window_size=GRPC_WINDOW_SIZE,
-    )
-
-
 def create_channel(
     server_url: str,
     metadata: dict[str, str] = {},
@@ -280,7 +270,10 @@ def create_channel(
     o = urllib.parse.urlparse(server_url)
 
     channel: grpclib.client.Channel
-    config = create_channel_config()
+    config = grpclib.config.Configuration(
+        http2_connection_window_size=64 * 1024 * 1024,  # 64 MiB
+        http2_stream_window_size=64 * 1024 * 1024,  # 64 MiB
+    )
 
     if o.scheme == "unix":
         channel = grpclib.client.Channel(path=o.path, config=config, status_details_codec=custom_detail_codec)
@@ -303,12 +296,6 @@ def create_channel(
         for k, v in metadata.items():
             event.metadata[k] = v
 
-        if o.hostname is not None:
-            # GRPC actually injects a :authority pseudo-header containing the hostname.
-            # But this gets stripped out by the C/C++ extension server-side and is hard to fix.
-            # So let's just add a separate header we can parse easily.
-            event.metadata["x-modal-host"] = o.hostname
-
         idempotency_key = typing.cast(Optional[str], event.metadata.get("x-idempotency-key"))
         if idempotency_key is None:
             logger.debug(f"Sending request to {event.method_name}")
@@ -322,59 +309,9 @@ def create_channel(
 
 # With 18 attempts, the max delays between calls is: 0.1 + 0.2 + 0.4 + 0.8 + 1.6 + 3.2 + 5*11 ~ 62
 @retry(n_attempts=18, base_delay=0.1, attempt_timeout=10.0, max_delay=5.0, total_timeout=63.0)
-async def create_channel_with_fallbacks(
-    server_url: str,
-    metadata: dict[str, str] = {},
-    stagger_delay: float = 1.0,
-) -> grpclib.client.Channel:
-    """Create a connected channel, supporting comma-separated fallback URLs.
-
-    `server_url` may be a single URL or a comma-separated list of URLs. The connection attempts
-    are raced against each other and the first one to connect wins, which lets the client fail
-    over to a secondary endpoint when the primary is unreachable (e.g. a DNS outage on the
-    primary's domain).
-
-    Attempts are staggered so earlier URLs (e.g. the primary) get a head start and are preferred
-    when reachable: the candidate at index `i` waits up to `i * stagger_delay` seconds before
-    starting. That wait is cut short as soon as the previous candidate *fails*, so a fast failure
-    falls over to the next URL immediately instead of waiting out the full stagger. Losing attempts
-    are cancelled and their channels closed.
-    """
-    urls = [url.strip() for url in server_url.split(",")]
-
-    # Set when a candidate's connection attempt fails, letting the next candidate start immediately
-    # instead of waiting out its stagger delay.
-    failed = [asyncio.Event() for _ in urls]
-
-    async def connect(index: int, url: str) -> grpclib.client.Channel:
-        if index > 0:
-            # Stagger the start so earlier URLs are preferred, but start early if the previous
-            # candidate has already failed.
-            try:
-                await asyncio.wait_for(failed[index - 1].wait(), timeout=index * stagger_delay)
-            except asyncio.TimeoutError:
-                pass
-        channel = create_channel(url, metadata)
-        try:
-            await channel.__connect__()
-        except BaseException:
-            # Close the channel of a losing/cancelled attempt so its socket doesn't leak.
-            channel.close()
-            failed[index].set()
-            raise
-        return channel
-
-    first_exc: BaseException | None = None
-    async with TaskContext() as tc:
-        tasks = [tc.create_task(connect(i, url)) for i, url in enumerate(urls)]
-        for attempt in asyncio.as_completed(tasks):
-            try:
-                return await attempt
-            except Exception as exc:
-                if first_exc is None:
-                    first_exc = exc
-
-    raise ConnectionError("Could not connect to the Modal server.") from first_exc
+async def connect_channel(channel: grpclib.client.Channel):
+    """Connect to socket and raise exceptions when there is a connection issue."""
+    await channel.__connect__()
 
 
 if typing.TYPE_CHECKING:

{modal-1.5.2 → modal-1.5.2.dev0}/modal/_utils/name_utils.py

@@ -29,13 +29,7 @@ def is_valid_object_name(name: str) -> bool:
 
 def is_valid_environment_name(name: str) -> bool:
     # first char is alnum, the rest allows other chars
-    # The "en-" prefix is reserved for environment IDs, so that references
-    # to environments can be resolved by either name or ID unambiguously.
-    return (
-        len(name) <= 64
-        and re.match(r"^[a-zA-Z0-9][a-zA-Z0-9-_.]+$", name) is not None
-        and not name.lower().startswith("en-")
-    )
+    return len(name) <= 64 and re.match(r"^[a-zA-Z0-9][a-zA-Z0-9-_.]+$", name) is not None
 
 
 def is_valid_tag(tag: str, max_length: int = 50) -> bool:
@@ -72,7 +66,7 @@ def check_environment_name(name: str) -> None:
         f"Invalid Environment name: '{name}'."
         "\n\nEnvironment names can only start with alphanumeric characters,"
         " may contain only alphanumeric characters, dashes, periods, and underscores,"
-        " must be shorter than 64 characters, and cannot start with 'en-'."
+        " and must be shorter than 64 characters."
     )
     if not is_valid_environment_name(name):
         raise InvalidError(message)

{modal-1.5.2 → modal-1.5.2.dev0}/modal/_utils/task_command_router_client.py

@@ -13,6 +13,7 @@ from contextlib import suppress
 from typing import TypeVar
 
 import grpclib.client
+import grpclib.config
 from grpclib import GRPCError, Status
 from grpclib.exceptions import StreamTerminatedError
 
@@ -22,7 +23,7 @@ from modal_proto import api_pb2, task_command_router_pb2 as sr_pb2
 from modal_proto.task_command_router_grpc import TaskCommandRouterStub
 
 from .._grpc_client import grpc_error_converter
-from .._utils.grpc_utils import ModalChannel, create_channel_config
+from .._utils.grpc_utils import ModalChannel
 from .async_utils import aclosing, retry
 from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES
 
@@ -31,8 +32,8 @@ from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES
 async def _connect_channel(channel: grpclib.client.Channel):
     """Connect to the command router channel.
 
-    Uses a longer retry budget than grpc_utils.create_channel_with_fallbacks. In rare cases the
-    sandbox may take a long time to start on the worker after scheduling.
+    Uses a longer retry budget than grpc_utils.connect_channel. In rare cases the sandbox
+    may take a long time to start on the worker after scheduling.
 
     Retries with exponential backoff (1, 2, 4, 8, 10, 10, ...) capped at 10s per delay.
     Total sleep between attempts: 1 + 2 + 4 + 8 + 10*29 = 305s (~5 min).
@@ -221,7 +222,10 @@ class TaskCommandRouterClient:
             host,
             port,
             ssl=ssl_context,
-            config=create_channel_config(),
+            config=grpclib.config.Configuration(
+                http2_connection_window_size=64 * 1024 * 1024,  # 64 MiB
+                http2_stream_window_size=64 * 1024 * 1024,  # 64 MiB
+            ),
             closed_error_message="Unable to perform operation on a detached sandbox",
         )
 
@@ -807,26 +811,6 @@ class TaskCommandRouterClient:
                 lambda: self._call_with_auth_retry(self._stub.TaskSetNetworkAccess, request)
             )
 
-    async def reload_volumes(self, task_id: str, timeout: float) -> sr_pb2.TaskReloadVolumesResponse:
-        """Reload all Volumes mounted in the task to reflect their latest committed state.
-
-        Args:
-            task_id: The task whose mounted Volumes should be reloaded.
-            timeout: Client-side deadline in seconds. If the reload does not complete within this
-                window, the call is cancelled and a `modal.exception.TimeoutError` is raised.
-        """
-        request = sr_pb2.TaskReloadVolumesRequest(task_id=task_id)
-        with grpc_error_converter():
-            try:
-                return await asyncio.wait_for(
-                    call_with_retries_on_transient_errors(
-                        lambda: self._call_with_auth_retry(self._stub.TaskReloadVolumes, request, timeout=timeout),
-                    ),
-                    timeout=timeout,
-                )
-            except asyncio.TimeoutError:
-                raise ModalTimeoutError("Timeout expired")
-
     async def _snapshot_with_deadline(self, rpc, request, *, timeout: float, **kwargs):
         # helper method for snapshot_directory and snapshot_filesystem to handle grpc
         # deadlines in a consistent way, converting any error to TimeoutError after passing