modal 0.73.130__py3-none-any.whl → 0.73.131__py3-none-any.whl

modal/_functions.py

@@ -25,7 +25,12 @@ from ._pty import get_pty_info
 from ._resolver import Resolver
 from ._resources import convert_fn_config_to_resources_config
 from ._runtime.execution_context import current_input_id, is_local
-from ._serialization import apply_defaults, serialize, serialize_proto_params, validate_params
+from ._serialization import (
+    apply_defaults,
+    serialize,
+    serialize_proto_params,
+    validate_parameter_values,
+)
 from ._traceback import print_server_warnings
 from ._utils.async_utils import (
     TaskContext,
@@ -975,7 +980,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     )
                 schema = parent._class_parameter_info.schema
                 kwargs_with_defaults = apply_defaults(kwargs, schema)
-                validate_params(kwargs_with_defaults, schema)
+                validate_parameter_values(kwargs_with_defaults, schema)
                 serialized_params = serialize_proto_params(kwargs_with_defaults)
                 can_use_parent = len(parent._class_parameter_info.schema) == 0  # no parameters
             else:
@@ -1312,7 +1317,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 order_outputs,
                 return_exceptions,
                 count_update_callback,
-                api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC
+                api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC,
             )
         ) as stream:
             async for item in stream:

modal/_resolver.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2023
 import asyncio
 import contextlib
+import traceback
 import typing
 from asyncio import Future
 from collections.abc import Hashable
@@ -153,7 +154,11 @@ class Resolver:
                 self._deduplication_cache[deduplication_key] = cached_future
 
         # TODO(elias): print original exception/trace rather than the Resolver-internal trace
-        return await cached_future
+        try:
+            return await cached_future
+        except Exception:
+            traceback.print_exc()
+            raise
 
     def objects(self) -> list["modal._object._Object"]:
         unique_objects: dict[str, "modal._object._Object"] = {}

modal/_serialization.py

@@ -1,14 +1,16 @@
 # Copyright Modal Labs 2022
+import inspect
 import io
 import pickle
 import typing
-from dataclasses import dataclass
+from inspect import Parameter
 from typing import Any
 
 from modal._utils.async_utils import synchronizer
 from modal_proto import api_pb2
 
 from ._object import _Object
+from ._type_manager import parameter_serde_registry, schema_registry
 from ._vendor import cloudpickle
 from .config import logger
 from .exception import DeserializationError, ExecutionError, InvalidError
@@ -389,50 +391,6 @@ def check_valid_cls_constructor_arg(key, obj):
         )
 
 
-def assert_bytes(obj: Any):
-    if not isinstance(obj, bytes):
-        raise TypeError(f"Expected bytes, got {type(obj)}")
-    return obj
-
-
-@dataclass
-class ParamTypeInfo:
-    default_field: str
-    proto_field: str
-    converter: typing.Callable[[str], typing.Any]
-    type: type
-
-
-PYTHON_TO_PROTO_TYPE: dict[type, "api_pb2.ParameterType.ValueType"] = {
-    # python type -> protobuf type enum
-    str: api_pb2.PARAM_TYPE_STRING,
-    int: api_pb2.PARAM_TYPE_INT,
-    bytes: api_pb2.PARAM_TYPE_BYTES,
-}
-
-PROTO_TYPE_INFO = {
-    # Protobuf type enum -> encode/decode helper metadata
-    api_pb2.PARAM_TYPE_STRING: ParamTypeInfo(
-        default_field="string_default",
-        proto_field="string_value",
-        converter=str,
-        type=str,
-    ),
-    api_pb2.PARAM_TYPE_INT: ParamTypeInfo(
-        default_field="int_default",
-        proto_field="int_value",
-        converter=int,
-        type=int,
-    ),
-    api_pb2.PARAM_TYPE_BYTES: ParamTypeInfo(
-        default_field="bytes_default",
-        proto_field="bytes_value",
-        converter=assert_bytes,
-        type=bytes,
-    ),
-}
-
-
 def apply_defaults(
     python_params: typing.Mapping[str, Any], schema: typing.Sequence[api_pb2.ClassParameterSpec]
 ) -> dict[str, Any]:
@@ -453,68 +411,56 @@ def apply_defaults(
     return result
 
 
+def encode_parameter_value(name: str, python_value: Any) -> api_pb2.ClassParameterValue:
+    """Map to proto parameter representation using python runtime type information"""
+    struct = parameter_serde_registry.encode(python_value)
+    struct.name = name
+    return struct
+
+
 def serialize_proto_params(python_params: dict[str, Any]) -> bytes:
     proto_params: list[api_pb2.ClassParameterValue] = []
     for param_name, python_value in python_params.items():
-        python_type = type(python_value)
-        protobuf_type = get_proto_parameter_type(python_type)
-        type_info = PROTO_TYPE_INFO.get(protobuf_type)
-        proto_param = api_pb2.ClassParameterValue(
-            name=param_name,
-            type=protobuf_type,
-        )
-        try:
-            converted_value = type_info.converter(python_value)
-        except ValueError as exc:
-            raise ValueError(f"Invalid type for parameter {param_name}: {exc}")
-        setattr(proto_param, type_info.proto_field, converted_value)
-        proto_params.append(proto_param)
+        proto_params.append(encode_parameter_value(param_name, python_value))
     proto_bytes = api_pb2.ClassParameterSet(parameters=proto_params).SerializeToString(deterministic=True)
     return proto_bytes
 
 
 def deserialize_proto_params(serialized_params: bytes) -> dict[str, Any]:
-    proto_struct = api_pb2.ClassParameterSet()
-    proto_struct.ParseFromString(serialized_params)
+    proto_struct = api_pb2.ClassParameterSet.FromString(serialized_params)
     python_params = {}
     for param in proto_struct.parameters:
-        python_value: Any
-        if param.type == api_pb2.PARAM_TYPE_STRING:
-            python_value = param.string_value
-        elif param.type == api_pb2.PARAM_TYPE_INT:
-            python_value = param.int_value
-        elif param.type == api_pb2.PARAM_TYPE_BYTES:
-            python_value = param.bytes_value
-        else:
-            raise NotImplementedError(f"Unimplemented parameter type: {param.type}.")
-
-        python_params[param.name] = python_value
+        python_params[param.name] = parameter_serde_registry.decode(param)
 
     return python_params
 
 
-def validate_params(params: dict[str, Any], schema: typing.Sequence[api_pb2.ClassParameterSpec]):
-    # first check that all declared values are provided
-    for schema_param in schema:
-        if schema_param.name not in params:
-            # we expect all values to be present - even defaulted ones (defaults are applied on payload construction)
-            raise InvalidError(f"Missing required parameter: {schema_param.name}")
-        python_value = params[schema_param.name]
-        python_type = type(python_value)
-        param_protobuf_type = get_proto_parameter_type(python_type)
-        if schema_param.type != param_protobuf_type:
-            expected_python_type = PROTO_TYPE_INFO[schema_param.type].type
-            raise TypeError(
-                f"Parameter '{schema_param.name}' type error: expected {expected_python_type.__name__}, "
-                f"got {python_type.__name__}"
-            )
+def validate_parameter_values(payload: dict[str, Any], schema: typing.Sequence[api_pb2.ClassParameterSpec]):
+    """Ensure parameter payload conforms to the schema of a class
+
+    Checks that:
+    * All fields are specified (defaults are expected to already be applied on the payload)
+    * No extra fields are specified
+    * The type of each field is correct
+    """
+    for param_spec in schema:
+        if param_spec.name not in payload:
+            raise InvalidError(f"Missing required parameter: {param_spec.name}")
+        python_value = payload[param_spec.name]
+        if param_spec.HasField("full_type") and param_spec.full_type.base_type:
+            type_enum_value = param_spec.full_type.base_type
+        else:
+            type_enum_value = param_spec.type  # backwards compatibility pre-full_type
+
+        parameter_serde_registry.validate_value_for_enum_type(type_enum_value, python_value)
 
     schema_fields = {p.name for p in schema}
     # then check that no extra values are provided
-    non_declared_fields = params.keys() - schema_fields
+    non_declared_fields = payload.keys() - schema_fields
     if non_declared_fields:
         raise InvalidError(
-            f"The following parameter names were provided but are not present in the schema: {non_declared_fields}"
+            f"The following parameter names were provided but are not defined class modal.parameters for the class: "
+            f"{', '.join(non_declared_fields)}"
         )
 
 
@@ -528,8 +474,6 @@ def deserialize_params(serialized_params: bytes, function_def: api_pb2.Function,
     elif function_def.class_parameter_info.format == api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PROTO:
         param_args = ()  # we use kwargs only for our implicit constructors
         param_kwargs = deserialize_proto_params(serialized_params)
-        # TODO: We can probably remove the validation below since we do validation in the caller?
-        validate_params(param_kwargs, list(function_def.class_parameter_info.schema))
     else:
         raise ExecutionError(
             f"Unknown class parameter serialization format: {function_def.class_parameter_info.format}"
@@ -538,9 +482,47 @@ def deserialize_params(serialized_params: bytes, function_def: api_pb2.Function,
     return param_args, param_kwargs
 
 
-def get_proto_parameter_type(parameter_type: type) -> "api_pb2.ParameterType.ValueType":
-    if parameter_type not in PYTHON_TO_PROTO_TYPE:
-        type_name = getattr(parameter_type, "__name__", repr(parameter_type))
-        supported = ", ".join(parameter_type.__name__ for parameter_type in PYTHON_TO_PROTO_TYPE.keys())
-        raise InvalidError(f"{type_name} is not a supported parameter type. Use one of: {supported}")
-    return PYTHON_TO_PROTO_TYPE[parameter_type]
+def _signature_parameter_to_spec(
+    python_signature_parameter: inspect.Parameter, include_legacy_parameter_fields: bool = False
+) -> api_pb2.ClassParameterSpec:
+    """Returns proto representation of Parameter as returned by inspect.signature()
+
+    Setting include_legacy_parameter_fields makes the output backwards compatible with
+    pre v0.74 clients looking at class parameter specifications, and should not be used
+    when registering *function* schemas.
+    """
+    declared_type = python_signature_parameter.annotation
+    full_proto_type = schema_registry.get_proto_generic_type(declared_type)
+    has_default = python_signature_parameter.default is not Parameter.empty
+
+    field_spec = api_pb2.ClassParameterSpec(
+        name=python_signature_parameter.name,
+        full_type=full_proto_type,
+        has_default=has_default,
+    )
+    if include_legacy_parameter_fields:
+        # add the .{type}_default and `.type` values as required by legacy clients
+        # looking at class parameter specs
+        if full_proto_type.base_type == api_pb2.PARAM_TYPE_INT:
+            if has_default:
+                field_spec.int_default = python_signature_parameter.default
+            field_spec.type = api_pb2.PARAM_TYPE_INT
+        elif full_proto_type.base_type == api_pb2.PARAM_TYPE_STRING:
+            if has_default:
+                field_spec.string_default = python_signature_parameter.default
+            field_spec.type = api_pb2.PARAM_TYPE_STRING
+        elif full_proto_type.base_type == api_pb2.PARAM_TYPE_BYTES:
+            if has_default:
+                field_spec.bytes_default = python_signature_parameter.default
+            field_spec.type = api_pb2.PARAM_TYPE_BYTES
+
+    return field_spec
+
+
+def signature_to_parameter_specs(signature: inspect.Signature) -> list[api_pb2.ClassParameterSpec]:
+    # only used for modal.parameter() specs, uses backwards compatible fields and types
+    modal_parameters: list[api_pb2.ClassParameterSpec] = []
+    for param in signature.parameters.values():
+        field_spec = _signature_parameter_to_spec(param, include_legacy_parameter_fields=True)
+        modal_parameters.append(field_spec)
+    return modal_parameters

modal/_type_manager.py

@@ -0,0 +1,229 @@
+# Copyright Modal Labs 2025
+import typing
+from typing import Any
+
+import typing_extensions
+
+from modal.exception import InvalidError
+from modal_proto import api_pb2
+
+
+class ParameterProtoSerde(typing.Protocol):
+    def encode(self, value: Any) -> api_pb2.ClassParameterValue: ...
+
+    def decode(self, proto_value: api_pb2.ClassParameterValue) -> Any: ...
+
+    def validate(self, python_value: Any): ...
+
+
+class ProtoParameterSerdeRegistry:
+    _py_base_type_to_serde: dict[type, ParameterProtoSerde]
+    _proto_type_to_serde: dict["api_pb2.ParameterType.ValueType", ParameterProtoSerde]
+
+    def __init__(self):
+        self._py_base_type_to_serde = {}
+        self._proto_type_to_serde = {}
+
+    def register_encoder(self, python_base_type: type) -> typing.Callable[[ParameterProtoSerde], ParameterProtoSerde]:
+        def deco(ph: ParameterProtoSerde) -> ParameterProtoSerde:
+            if python_base_type in self._py_base_type_to_serde:
+                raise ValueError("Can't register the same encoder type twice")
+            self._py_base_type_to_serde[python_base_type] = ph
+            return ph
+
+        return deco
+
+    def register_decoder(
+        self, enum_type_value: "api_pb2.ParameterType.ValueType"
+    ) -> typing.Callable[[ParameterProtoSerde], ParameterProtoSerde]:
+        def deco(ph: ParameterProtoSerde) -> ParameterProtoSerde:
+            if enum_type_value in self._proto_type_to_serde:
+                raise ValueError("Can't register the same decoder type twice")
+            self._proto_type_to_serde[enum_type_value] = ph
+            return ph
+
+        return deco
+
+    def encode(self, python_value: Any) -> api_pb2.ClassParameterValue:
+        return self._get_encoder(type(python_value)).encode(python_value)
+
+    def supports_type(self, declared_type: type) -> bool:
+        try:
+            self._get_encoder(declared_type)
+            return True
+        except InvalidError:
+            return False
+
+    def decode(self, param_value: api_pb2.ClassParameterValue) -> Any:
+        return self._get_decoder(param_value.type).decode(param_value)
+
+    def validate_parameter_type(self, declared_type: type):
+        """Raises a helpful TypeError if the supplied type isn't supported by class parameters"""
+        if not parameter_serde_registry.supports_type(declared_type):
+            supported_types = self._py_base_type_to_serde.keys()
+            supported_str = ", ".join(t.__name__ for t in supported_types)
+
+            raise TypeError(
+                f"{declared_type.__name__} is not a supported modal.parameter() type. Use one of: {supported_str}"
+            )
+
+    def validate_value_for_enum_type(self, enum_value: "api_pb2.ParameterType.ValueType", python_value: Any):
+        serde = self._get_decoder(enum_value)  # use the schema's expected decoder
+        serde.validate(python_value)
+
+    def _get_encoder(self, python_base_type: type) -> ParameterProtoSerde:
+        try:
+            return self._py_base_type_to_serde[python_base_type]
+        except KeyError:
+            raise InvalidError(f"No class parameter encoder implemented for type `{python_base_type.__name__}`")
+
+    def _get_decoder(self, enum_value: "api_pb2.ParameterType.ValueType") -> ParameterProtoSerde:
+        try:
+            return self._proto_type_to_serde[enum_value]
+        except KeyError:
+            try:
+                enum_name = api_pb2.ParameterType.Name(enum_value)
+            except ValueError:
+                enum_name = str(enum_value)
+
+            raise InvalidError(f"No class parameter decoder implemented for type {enum_name}.")
+
+
+parameter_serde_registry = ProtoParameterSerdeRegistry()
+
+
+@parameter_serde_registry.register_encoder(int)
+@parameter_serde_registry.register_decoder(api_pb2.PARAM_TYPE_INT)
+class IntParameter:
+    @staticmethod
+    def encode(value: Any) -> api_pb2.ClassParameterValue:
+        return api_pb2.ClassParameterValue(type=api_pb2.PARAM_TYPE_INT, int_value=value)
+
+    @staticmethod
+    def decode(proto_value: api_pb2.ClassParameterValue) -> int:
+        return proto_value.int_value
+
+    @staticmethod
+    def validate(python_value: Any):
+        if not isinstance(python_value, int):
+            raise TypeError(f"Expected int, got {type(python_value).__name__}")
+
+
+@parameter_serde_registry.register_encoder(str)
+@parameter_serde_registry.register_decoder(api_pb2.PARAM_TYPE_STRING)
+class StringParameter:
+    @staticmethod
+    def encode(value: Any) -> api_pb2.ClassParameterValue:
+        return api_pb2.ClassParameterValue(type=api_pb2.PARAM_TYPE_STRING, string_value=value)
+
+    @staticmethod
+    def decode(proto_value: api_pb2.ClassParameterValue) -> str:
+        return proto_value.string_value
+
+    @staticmethod
+    def validate(python_value: Any):
+        if not isinstance(python_value, str):
+            raise TypeError(f"Expected str, got {type(python_value).__name__}")
+
+
+@parameter_serde_registry.register_encoder(bytes)
+@parameter_serde_registry.register_decoder(api_pb2.PARAM_TYPE_BYTES)
+class BytesParameter:
+    @staticmethod
+    def encode(value: Any) -> api_pb2.ClassParameterValue:
+        return api_pb2.ClassParameterValue(type=api_pb2.PARAM_TYPE_BYTES, bytes_value=value)
+
+    @staticmethod
+    def decode(proto_value: api_pb2.ClassParameterValue) -> bytes:
+        return proto_value.bytes_value
+
+    @staticmethod
+    def validate(python_value: Any):
+        if not isinstance(python_value, bytes):
+            raise TypeError(f"Expected bytes, got {type(python_value).__name__}")
+
+
+SCHEMA_FACTORY_TYPE = typing.Callable[[type], api_pb2.GenericPayloadType]
+
+
+class SchemaRegistry:
+    _schema_factories: dict[type, SCHEMA_FACTORY_TYPE]
+
+    def __init__(self):
+        self._schema_factories = {}
+
+    def add(self, python_base_type: type) -> typing.Callable[[SCHEMA_FACTORY_TYPE], SCHEMA_FACTORY_TYPE]:
+        # decorator for schema factory functions for a base type
+        def deco(factory_func: SCHEMA_FACTORY_TYPE) -> SCHEMA_FACTORY_TYPE:
+            assert python_base_type not in self._schema_factories
+            self._schema_factories[python_base_type] = factory_func
+            return factory_func
+
+        return deco
+
+    def get(self, python_base_type: type) -> SCHEMA_FACTORY_TYPE:
+        try:
+            return self._schema_factories[python_base_type]
+        except KeyError:
+            return unknown_type_schema
+
+    def get_proto_generic_type(self, declared_type: type):
+        if origin := typing_extensions.get_origin(declared_type):
+            base_type = origin
+        else:
+            base_type = declared_type
+
+        return self.get(base_type)(declared_type)
+
+
+schema_registry = SchemaRegistry()
+
+
+@schema_registry.add(int)
+def int_schema(full_python_type: type) -> api_pb2.GenericPayloadType:
+    return api_pb2.GenericPayloadType(
+        base_type=api_pb2.PARAM_TYPE_INT,
+    )
+
+
+@schema_registry.add(bytes)
+def proto_type_def(declared_python_type: type) -> api_pb2.GenericPayloadType:
+    return api_pb2.GenericPayloadType(
+        base_type=api_pb2.PARAM_TYPE_BYTES,
+    )
+
+
+def unknown_type_schema(declared_python_type: type) -> api_pb2.GenericPayloadType:
+    # TODO: add some metadata for unknown types to the type def?
+    return api_pb2.GenericPayloadType(base_type=api_pb2.PARAM_TYPE_UNKNOWN)
+
+
+@schema_registry.add(str)
+def str_schema(full_python_type: type) -> api_pb2.GenericPayloadType:
+    return api_pb2.GenericPayloadType(
+        base_type=api_pb2.PARAM_TYPE_STRING,
+    )
+
+
+@schema_registry.add(type(None))
+def none_type_schema(declared_python_type: type) -> api_pb2.GenericPayloadType:
+    return api_pb2.GenericPayloadType(base_type=api_pb2.PARAM_TYPE_NONE)
+
+
+@schema_registry.add(list)
+def list_schema(full_python_type: type) -> api_pb2.GenericPayloadType:
+    args = typing_extensions.get_args(full_python_type)
+
+    return api_pb2.GenericPayloadType(
+        base_type=api_pb2.PARAM_TYPE_LIST, sub_types=[schema_registry.get_proto_generic_type(arg) for arg in args]
+    )
+
+
+@schema_registry.add(dict)
+def dict_schema(full_python_type: type) -> api_pb2.GenericPayloadType:
+    args = typing_extensions.get_args(full_python_type)
+
+    return api_pb2.GenericPayloadType(
+        base_type=api_pb2.PARAM_TYPE_DICT,
+        sub_types=[schema_registry.get_proto_generic_type(arg_type) for arg_type in args],
+    )

modal/_utils/function_utils.py

@@ -16,12 +16,10 @@ import modal_proto
 from modal_proto import api_pb2
 
 from .._serialization import (
-    PROTO_TYPE_INFO,
-    PYTHON_TO_PROTO_TYPE,
     deserialize,
     deserialize_data_format,
-    get_proto_parameter_type,
     serialize,
+    signature_to_parameter_specs,
 )
 from .._traceback import append_modal_tb
 from ..config import config, logger
@@ -106,24 +104,6 @@ def get_function_type(is_generator: Optional[bool]) -> "api_pb2.Function.Functio
     return api_pb2.Function.FUNCTION_TYPE_GENERATOR if is_generator else api_pb2.Function.FUNCTION_TYPE_FUNCTION
 
 
-def signature_to_protobuf_schema(signature: inspect.Signature) -> list[api_pb2.ClassParameterSpec]:
-    modal_parameters: list[api_pb2.ClassParameterSpec] = []
-    for param in signature.parameters.values():
-        has_default = param.default is not param.empty
-        class_param_spec = api_pb2.ClassParameterSpec(name=param.name, has_default=has_default)
-        if param.annotation not in PYTHON_TO_PROTO_TYPE:
-            class_param_spec.type = api_pb2.PARAM_TYPE_UNKNOWN
-        else:
-            proto_type = PYTHON_TO_PROTO_TYPE[param.annotation]
-            class_param_spec.type = proto_type
-            proto_type_info = PROTO_TYPE_INFO[proto_type]
-            if has_default and proto_type is not api_pb2.PARAM_TYPE_UNKNOWN:
-                setattr(class_param_spec, proto_type_info.default_field, param.default)
-
-        modal_parameters.append(class_param_spec)
-    return modal_parameters
-
-
 class FunctionInfo:
     """Utility that determines serialization/deserialization mechanisms for functions
 
@@ -310,15 +290,12 @@ class FunctionInfo:
         # annotation parameters trigger strictly typed parametrization
         # which enables web endpoint for parametrized classes
         signature = _get_class_constructor_signature(self.user_cls)
-        # validate that the schema has no unspecified fields/unsupported class parameter types
-        for param in signature.parameters.values():
-            get_proto_parameter_type(param.annotation)
-
-        protobuf_schema = signature_to_protobuf_schema(signature)
+        # at this point, the types in the signature should already have been validated (see Cls.from_local())
+        parameter_specs = signature_to_parameter_specs(signature)
 
         return api_pb2.ClassParameterInfo(
             format=api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PROTO,
-            schema=protobuf_schema,
+            schema=parameter_specs,
         )
 
     def get_entrypoint_mount(self) -> dict[str, _Mount]:

modal/client.pyi

@@ -31,7 +31,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "0.73.130",
+        version: str = "0.73.131",
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -93,7 +93,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "0.73.130",
+        version: str = "0.73.131",
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/cls.py

@@ -21,8 +21,9 @@ from ._partial_function import (
 )
 from ._resolver import Resolver
 from ._resources import convert_fn_config_to_resources_config
-from ._serialization import check_valid_cls_constructor_arg, get_proto_parameter_type
+from ._serialization import check_valid_cls_constructor_arg
 from ._traceback import print_server_warnings
+from ._type_manager import parameter_serde_registry
 from ._utils.async_utils import synchronize_api, synchronizer
 from ._utils.deprecation import deprecation_warning, renamed_parameter, warn_on_renamed_autoscaler_settings
 from ._utils.grpc_utils import retry_transient_errors
@@ -462,7 +463,10 @@ class _Cls(_Object, type_prefix="cs"):
 
         annotated_params = {k: t for k, t in annotations.items() if k in params}
         for k, t in annotated_params.items():
-            get_proto_parameter_type(t)
+            try:
+                parameter_serde_registry.validate_parameter_type(t)
+            except TypeError as exc:
+                raise InvalidError(f"Class parameter '{k}': {exc}")
 
     @staticmethod
     def from_local(user_cls, app: "modal.app._App", class_service_function: _Function) -> "_Cls":

modal/functions.pyi

@@ -198,11 +198,11 @@ class Function(
 
     _call_generator_nowait: ___call_generator_nowait_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: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
 
-    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]: ...
@@ -217,19 +217,19 @@ class Function(
         self, *args: modal._functions.P.args, **kwargs: modal._functions.P.kwargs
     ) -> modal._functions.OriginalReturnType: ...
 
-    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]: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
     _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_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]: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
-    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]: ...
 

{modal-0.73.130.dist-info → modal-0.73.131.dist-info}/METADATA

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