modAL 1.3.6.dev12__tar.gz → 1.3.6.dev14__tar.gz

{modal-1.3.6.dev12 → modal-1.3.6.dev14}/PKG-INFO

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

{modal-1.3.6.dev12 → modal-1.3.6.dev14}/modal/_functions.py

@@ -2,7 +2,6 @@
 import asyncio
 import dataclasses
 import inspect
-import textwrap
 import time
 import typing
 import warnings
@@ -44,7 +43,6 @@ from ._utils.async_utils import (
     warn_if_generator_is_not_consumed,
 )
 from ._utils.blob_utils import MAX_OBJECT_SIZE_BYTES
-from ._utils.deprecation import deprecation_warning, warn_if_passing_namespace
 from ._utils.function_utils import (
     ATTEMPT_TIMEOUT_GRACE_PERIOD,
     OUTPUTS_TIMEOUT,
@@ -54,9 +52,10 @@ from ._utils.function_utils import (
     _stream_function_call_data,
     get_function_type,
     is_async,
+    parse_gpu_config,
 )
 from ._utils.grpc_utils import Retry, RetryWarningMessage
-from ._utils.mount_utils import validate_network_file_systems, validate_volumes
+from ._utils.mount_utils import validate_network_file_systems, validate_volumes, validate_volumes_by_object_id
 from .call_graph import InputInfo, _reconstruct_call_graph
 from .client import _Client
 from .cloud_bucket_mount import _CloudBucketMount, cloud_bucket_mounts_to_proto
@@ -67,7 +66,6 @@ from .exception import (
     NotFoundError,
     OutputExpiredError,
 )
-from .gpu import GPU_T, parse_gpu_config
 from .image import _Image
 from .mount import _get_client_mount, _Mount
 from .network_file_system import _NetworkFileSystem, network_file_system_mount_protos
@@ -587,7 +585,7 @@ class _FunctionSpec:
     network_file_systems: dict[Union[str, PurePosixPath], _NetworkFileSystem]
     volumes: dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]]
     # TODO(irfansharif): Somehow assert that it's the first kind, in sandboxes
-    gpus: Union[GPU_T, list[GPU_T]]
+    gpus: Optional[str | list[str]]
     cloud: Optional[str]
     cpu: Optional[Union[float, tuple[float, float]]]
     memory: Optional[Union[int, tuple[int, int]]]
@@ -666,7 +664,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         secrets: Optional[Collection[_Secret]] = None,
         schedule: Optional[Schedule] = None,
         is_generator: bool = False,
-        gpu: Union[GPU_T, list[GPU_T]] = None,
+        gpu: Optional[str | list[str]] = None,
         # TODO: maybe break this out into a separate decorator for notebooks.
         network_file_systems: dict[Union[str, PurePosixPath], _NetworkFileSystem] = {},
         volumes: dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]] = {},
@@ -703,7 +701,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         include_source: bool = True,
         experimental_options: Optional[dict[str, str]] = None,
         _experimental_proxy_ip: Optional[str] = None,
-        _experimental_custom_scaling_factor: Optional[float] = None,
         restrict_output: bool = False,
         http_config: Optional[api_pb2.HTTPConfig] = None,
     ) -> "_Function":
@@ -799,11 +796,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         f"for clustered Functions"
                     )
 
-        if _experimental_custom_scaling_factor is not None and (
-            _experimental_custom_scaling_factor < 0 or _experimental_custom_scaling_factor > 1
-        ):
-            raise InvalidError("`_experimental_custom_scaling_factor` must be between 0.0 and 1.0 inclusive.")
-
         if not cloud and not is_builder_function:
             cloud = config.get("default_cloud")
 
@@ -966,6 +958,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 if image._metadata is not None:
                     mount_client_dependencies = image._metadata.image_builder_version > "2024.10"
 
+                # Validate that the same volume (by object_id) isn't mounted at multiple paths
+                # This validation happens here (at load time) because volumes need to be hydrated
+                # to have their object_id set.
+                validate_volumes_by_object_id(validated_volumes_no_cloud_buckets)
+
                 # Relies on dicts being ordered (true as of Python 3.6).
                 volume_mounts = [
                     api_pb2.VolumeMount(
@@ -1045,7 +1042,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     _experimental_group_size=cluster_size or 0,  # Experimental: Clustered functions
                     _experimental_concurrent_cancellations=True,
                     _experimental_proxy_ip=_experimental_proxy_ip,
-                    _experimental_custom_scaling=_experimental_custom_scaling_factor is not None,
                     # --- These are deprecated in favor of autoscaler_settings
                     warm_pool_size=min_containers or 0,
                     concurrency_limit=max_containers or 0,
@@ -1117,8 +1113,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     function_data.ranked_functions.extend(ranked_functions)
                     function_definition = None  # function_definition is not used in this case
                 else:
-                    # TODO(irfansharif): Assert on this specific type once we get rid of python 3.9.
-                    # assert isinstance(gpu, GPU_T)  # includes the case where gpu==None case
                     function_definition.resources.CopyFrom(
                         convert_fn_config_to_resources_config(
                             cpu=cpu, memory=memory, gpu=gpu, ephemeral_disk=ephemeral_disk, rdma=rdma
@@ -1165,7 +1159,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         obj._webhook_config = webhook_config  # only set locally
 
         # Used to check whether we should rebuild a modal.Image which uses `run_function`.
-        gpus: list[GPU_T] = gpu if isinstance(gpu, list) else [gpu]
+        gpus: list[str] = gpu if isinstance(gpu, list) else [gpu] if gpu else []
         obj._build_args = dict(  # See get_build_def
             secrets=repr(secrets),
             gpu_config=repr([parse_gpu_config(_gpu) for _gpu in gpus]),
@@ -1235,6 +1229,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             assert parent is not None and parent.is_hydrated
 
             if options:
+                # Validate that the same volume (by object_id) isn't mounted at multiple paths
+                validate_volumes_by_object_id(options.validated_volumes)
+
                 volume_mounts = [
                     api_pb2.VolumeMount(
                         mount_path=path,
@@ -1350,43 +1347,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         # One idea would be for FunctionUpdateScheduleParams to return the current (coalesced) settings
         # and then we could return them here (would need some ad hoc dataclass, which I don't love)
 
-    @live_method
-    async def keep_warm(self, warm_pool_size: int) -> None:
-        """mdmd:hidden
-        Set the warm pool size for the Function.
-
-        DEPRECATED: Please adapt your code to use the more general `update_autoscaler` method instead:
-
-        ```python notest
-        f = modal.Function.from_name("my-app", "function")
-
-        # Old pattern (deprecated)
-        f.keep_warm(2)
-
-        # New pattern
-        f.update_autoscaler(min_containers=2)
-        ```
-        """
-        if self._is_method:
-            raise InvalidError(
-                textwrap.dedent(
-                    """
-                The `.keep_warm()` method can not be used on Modal class *methods*.
-
-                Call `.keep_warm()` on the class *instance* instead. All methods of a class are run by the same
-                container pool, and this method applies to the size of that container pool.
-            """
-                )
-            )
-
-        deprecation_warning(
-            (2025, 5, 5),
-            "The .keep_warm() method has been deprecated in favor of the more general "
-            ".update_autoscaler(min_containers=...) method.",
-            show_source=True,
-        )
-        await self.update_autoscaler(min_containers=warm_pool_size)
-
     @classmethod
     def _from_name(
         cls,
@@ -1436,7 +1396,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         app_name: str,
         name: str,
         *,
-        namespace=None,  # mdmd:line-hidden
         environment_name: Optional[str] = None,
         client: Optional[_Client] = None,
     ) -> "_Function":
@@ -1451,17 +1410,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         ```
         """
         if "." in name:
-            class_name, method_name = name.split(".", 1)
-            deprecation_warning(
-                (2025, 2, 11),
-                "Looking up class methods using Function.from_name will be deprecated"
-                " in a future version of Modal.\nUse modal.Cls.from_name instead, e.g.\n\n"
-                f'{class_name} = modal.Cls.from_name("{app_name}", "{class_name}")\n'
-                f"instance = {class_name}(...)\n"
-                f"instance.{method_name}.remote(...)\n",
+            raise InvalidError(
+                f"Invalid Function name: {name!r}. "
+                "If you are trying to look up a class method, use `modal.Cls.from_name` instead."
             )
 
-        warn_if_passing_namespace(namespace, "modal.Function.from_name")
         return cls._from_name(
             app_name, name, load_context_overrides=LoadContext(environment_name=environment_name, client=client)
         )
@@ -1579,21 +1532,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 + f"or call it locally: {self._function_name}.local()"
             )
 
-    # TODO (live_method on properties is not great, since it could be blocking the event loop from async contexts)
-    @property
-    @live_method
-    async def web_url(self) -> Optional[str]:
-        """mdmd:hidden
-        Deprecated. Use the `Function.get_web_url()` method instead.
-
-        URL of a Function running as a web endpoint.
-        """
-        deprecation_msg = """The Function.web_url property will be removed in a future version of Modal.
-Use the `Function.get_web_url()` method instead.
-"""
-        deprecation_warning((2025, 5, 6), deprecation_msg, pending=True)
-        return self._web_url
-
     @live_method
     async def get_web_url(self) -> Optional[str]:
         """URL of a Function running as a web endpoint."""
@@ -2102,13 +2040,3 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         except Exception as exc:
             # TODO: kill all running function calls
             raise exc
-
-
-async def _gather(*function_calls: _FunctionCall[T]) -> typing.Sequence[T]:
-    """mdmd:hidden
-    Deprecated: Please use `modal.FunctionCall.gather()` instead."""
-    deprecation_warning(
-        (2025, 2, 24),
-        "`modal.functions.gather()` is deprecated; please use `modal.FunctionCall.gather()` instead.",
-    )
-    return await _FunctionCall.gather(*function_calls)

{modal-1.3.6.dev12 → modal-1.3.6.dev14}/modal/_partial_function.py

@@ -17,7 +17,7 @@ from modal_proto import api_pb2
 
 from ._functions import _Function
 from ._utils.async_utils import synchronizer
-from ._utils.deprecation import deprecation_warning
+from ._utils.deprecation import deprecation_error
 from ._utils.function_utils import callable_has_non_self_params
 from .config import config
 from .exception import InvalidError
@@ -310,7 +310,7 @@ def _method(
     def wrapper(obj: Union[Callable[..., Any], _PartialFunction]) -> _PartialFunction:
         flags = _PartialFunctionFlags.CALLABLE_INTERFACE
 
-        nonlocal is_generator  # TODO(michael): we are likely to deprecate the explicit is_generator param
+        nonlocal is_generator
         if is_generator is None:
             callable = obj.raw_f if isinstance(obj, _PartialFunction) else obj
             is_generator = inspect.isgeneratorfunction(callable) or inspect.isasyncgenfunction(callable)
@@ -403,72 +403,16 @@ def _fastapi_endpoint(
 
 def _web_endpoint(
     _warn_parentheses_missing=None,  # mdmd:line-hidden
-    *,
-    method: str = "GET",  # REST method for the created endpoint.
-    label: Optional[str] = None,  # Label for created endpoint. Final subdomain will be <workspace>--<label>.modal.run.
-    docs: bool = False,  # Whether to enable interactive documentation for this endpoint at /docs.
-    custom_domains: Optional[
-        Iterable[str]
-    ] = None,  # Create an endpoint using a custom domain fully-qualified domain name (FQDN).
-    requires_proxy_auth: bool = False,  # Require Modal-Key and Modal-Secret HTTP Headers on requests.
-) -> Callable[
-    [Union[_PartialFunction[P, ReturnType, ReturnType], Callable[P, ReturnType]]],
-    _PartialFunction[P, ReturnType, ReturnType],
-]:
-    """Register a basic web endpoint with this application.
-
+    *args,
+    **kwargs,
+) -> None:
+    """mdmd:hidden
     DEPRECATED: This decorator has been renamed to `@modal.fastapi_endpoint`.
-
-    This is the simple way to create a web endpoint on Modal. The function
-    behaves as a [FastAPI](https://fastapi.tiangolo.com/) handler and should
-    return a response object to the caller.
-
-    Endpoints created with `@modal.web_endpoint` are meant to be simple, single
-    request handlers and automatically have
-    [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) enabled.
-    For more flexibility, use `@modal.asgi_app`.
-
-    To learn how to use Modal with popular web frameworks, see the
-    [guide on web endpoints](https://modal.com/docs/guide/webhooks).
     """
-    if isinstance(_warn_parentheses_missing, str):
-        # Probably passing the method string as a positional argument.
-        raise InvalidError('Positional arguments are not allowed. Suggestion: `@modal.web_endpoint(method="GET")`.')
-    elif _warn_parentheses_missing is not None:
-        raise InvalidError(
-            "Positional arguments are not allowed. Did you forget parentheses? Suggestion: `@modal.web_endpoint()`."
-        )
-
-    deprecation_warning(
+    deprecation_error(
         (2025, 3, 5), "The `@modal.web_endpoint` decorator has been renamed to `@modal.fastapi_endpoint`."
     )
 
-    webhook_config = api_pb2.WebhookConfig(
-        type=api_pb2.WEBHOOK_TYPE_FUNCTION,
-        method=method,
-        web_endpoint_docs=docs,
-        requested_suffix=label or "",
-        ephemeral_suffix=config.get("dev_suffix"),
-        async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
-        custom_domains=_parse_custom_domains(custom_domains),
-        requires_proxy_auth=requires_proxy_auth,
-    )
-
-    flags = _PartialFunctionFlags.WEB_INTERFACE
-    params = _PartialFunctionParams(webhook_config=webhook_config)
-
-    def wrapper(
-        obj: Union[_PartialFunction[P, ReturnType, ReturnType], Callable[P, ReturnType]],
-    ) -> _PartialFunction[P, ReturnType, ReturnType]:
-        if isinstance(obj, _PartialFunction):
-            pf = obj.stack(flags, params)
-        else:
-            pf = _PartialFunction(obj, flags, params)
-        pf.validate_obj_compatibility("web_endpoint")
-        return pf
-
-    return wrapper
-
 
 def _asgi_app(
     _warn_parentheses_missing=None,  # mdmd:line-hidden

{modal-1.3.6.dev12 → modal-1.3.6.dev14}/modal/_resources.py

@@ -3,19 +3,18 @@ from typing import Optional, Union
 
 from modal_proto import api_pb2
 
+from ._utils.function_utils import parse_gpu_config
 from .exception import InvalidError
-from .gpu import GPU_T, parse_gpu_config
 
 
 def convert_fn_config_to_resources_config(
     *,
     cpu: Optional[Union[float, tuple[float, float]]],
     memory: Optional[Union[int, tuple[int, int]]],
-    gpu: GPU_T,
+    gpu: Optional[str],
     ephemeral_disk: Optional[int],
     rdma: Optional[bool] = None,
 ) -> api_pb2.Resources:
-    gpu_config = parse_gpu_config(gpu)
     if cpu and isinstance(cpu, tuple):
         if not cpu[0]:
             raise InvalidError("CPU request must be a positive number")
@@ -45,7 +44,7 @@ def convert_fn_config_to_resources_config(
     return api_pb2.Resources(
         milli_cpu=milli_cpu,
         milli_cpu_max=milli_cpu_max,
-        gpu_config=gpu_config,
+        gpu_config=parse_gpu_config(gpu),
         memory_mb=memory_mb,
         memory_mb_max=memory_mb_max,
         ephemeral_disk_mb=ephemeral_disk,

{modal-1.3.6.dev12 → modal-1.3.6.dev14}/modal/_utils/deprecation.py

@@ -89,55 +89,34 @@ def renamed_parameter(
     return decorator
 
 
-def warn_on_renamed_autoscaler_settings(func: Callable[P, R]) -> Callable[P, R]:
-    name_map = {
-        "keep_warm": "min_containers",
-        "concurrency_limit": "max_containers",
-        "_experimental_buffer_containers": "buffer_containers",
-        "container_idle_timeout": "scaledown_window",
-    }
+def handle_deprecated_parameters(func: Callable[P, R]) -> Callable[P, R]:
+    """Meta-decorator for modal.Function decorators that errors when deprecated parameters are passed.
+
+    We use this for a select parameters that might still be suggested by LLMs.
+    """
 
     @functools.wraps(func)
     def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-        mut_kwargs: dict[str, Any] = locals()["kwargs"]  # Avoid referencing kwargs directly due to bug in sigtools
-
-        substitutions = []
-        old_params_used = name_map.keys() & mut_kwargs.keys()
-        for old_param, new_param in name_map.items():
-            if old_param in old_params_used:
-                new_param = name_map[old_param]
-                mut_kwargs[new_param] = mut_kwargs.pop(old_param)
-                substitutions.append(f"- {old_param} -> {new_param}")
-
-        if substitutions:
-            substitution_string = "\n".join(substitutions)
-            message = (
-                "We have renamed several parameters related to autoscaling."
-                " Please update your code to use the following new names:"
-                f"\n\n{substitution_string}"
-                "\n\nSee https://modal.com/docs/guide/modal-1-0-migration for more details."
+        _kwargs: dict[str, Any] = locals()["kwargs"]  # Avoid referencing kwargs directly due to bug in sigtools
+
+        # Basic autoscaler parameters
+        autoscaler_settings = {
+            "keep_warm": "min_containers",
+            "concurrency_limit": "max_containers",
+            "container_idle_timeout": "scaledown_window",
+        }
+
+        for old_name, new_name in autoscaler_settings.items():
+            if old_name in _kwargs:
+                deprecation_error((2025, 2, 24), f"The '{old_name}' parameter has been renamed to '{new_name}'.")
+
+        # Input concurrency
+        if "allow_concurrent_inputs" in _kwargs:
+            deprecation_error(
+                (2025, 4, 9),
+                "The 'allow_concurrent_inputs' parameter is deprecated. Use the '@modal.concurrent' decorator instead.",
             )
-            deprecation_warning((2025, 2, 24), message, show_source=True)
 
         return func(*args, **kwargs)
 
     return wrapper
-
-
-def warn_if_passing_namespace(
-    namespace: Any,
-    resource_name: str,
-) -> None:
-    """Issue deprecation warning for namespace parameter if non-None value is passed.
-
-    Args:
-        namespace: The namespace parameter value (may be None or actual value)
-        resource_name: Name of the resource type for the warning message
-    """
-    if namespace is not None:
-        deprecation_warning(
-            (2025, 6, 30),
-            f"The `namespace` parameter for `{resource_name}` is deprecated and will be"
-            " removed in a future release. It is no longer needed, so can be removed"
-            " from your code.",
-        )

{modal-1.3.6.dev12 → modal-1.3.6.dev14}/modal/_utils/function_utils.py

@@ -602,3 +602,20 @@ async def _create_input(
             ),
             idx=idx,
         )
+
+
+def parse_gpu_config(value: Optional[str]) -> api_pb2.GPUConfig:
+    if value is None:
+        return api_pb2.GPUConfig()
+    elif isinstance(value, str):
+        count = 1
+        if ":" in value:
+            value, count_str = value.split(":", 1)
+            try:
+                count = int(count_str)
+            except ValueError:
+                raise InvalidError(f"Invalid GPU count: {count_str}. Value must be an integer.")
+        gpu_type = value.upper()
+        return api_pb2.GPUConfig(gpu_type=gpu_type, count=count)
+    else:
+        raise InvalidError(f"Invalid GPU config: {value!r}. Value must be a string or `None`")

{modal-1.3.6.dev12 → modal-1.3.6.dev14}/modal/_utils/mount_utils.py

@@ -101,3 +101,23 @@ def validate_only_modal_volumes(
         raise InvalidError(f"{caller_name} only supports volumes that are modal.Volume")
 
     return validated_volumes
+
+
+def validate_volumes_by_object_id(validated_volumes: Sequence[tuple[str, _Volume]]) -> None:
+    """Validate that the same volume (by object_id) is not mounted at multiple paths.
+
+    This validation happens at load time after volumes are hydrated and have object_ids.
+    """
+    object_id_to_paths: dict[str, list[str]] = {}
+    for path, volume in validated_volumes:
+        if not volume.is_hydrated:
+            # This should never happen since this function is only called at load time
+            raise RuntimeError(f"Internal error: Volume at '{path}' is not hydrated when validating mounts")
+        object_id_to_paths.setdefault(volume.object_id, []).append(path)
+
+    for object_id, paths in object_id_to_paths.items():
+        if len(paths) > 1:
+            conflicting = ", ".join(sorted(paths))
+            raise InvalidError(
+                f"The same Volume cannot be mounted in multiple locations for the same function: {conflicting}"
+            )