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

modal/__init__.py

@@ -27,7 +27,6 @@ try:
         asgi_app,
         batched,
         build,
-        concurrent,
         enter,
         exit,
         fastapi_endpoint,
@@ -83,7 +82,6 @@ __all__ = [
     "asgi_app",
     "batched",
     "build",
-    "concurrent",
     "current_function_call_id",
     "current_input_id",
     "enable_output",

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,
@@ -435,8 +440,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         max_containers: Optional[int] = None,
         buffer_containers: Optional[int] = None,
         scaledown_window: Optional[int] = None,
-        max_concurrent_inputs: Optional[int] = None,
-        target_concurrent_inputs: Optional[int] = None,
+        allow_concurrent_inputs: Optional[int] = None,
         batch_max_size: Optional[int] = None,
         batch_wait_ms: Optional[int] = None,
         cloud: Optional[str] = None,
@@ -787,8 +791,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     runtime_perf_record=config.get("runtime_perf_record"),
                     app_name=app_name,
                     is_builder_function=is_builder_function,
-                    max_concurrent_inputs=max_concurrent_inputs or 0,
-                    target_concurrent_inputs=target_concurrent_inputs or 0,
+                    target_concurrent_inputs=allow_concurrent_inputs or 0,
                     batch_max_size=batch_max_size or 0,
                     batch_linger_ms=batch_wait_ms or 0,
                     worker_id=config.get("worker_id"),
@@ -977,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:
@@ -1314,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/_partial_function.py

@@ -59,8 +59,6 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
     force_build: bool
     cluster_size: Optional[int]  # Experimental: Clustered functions
     build_timeout: Optional[int]
-    max_concurrent_inputs: Optional[int]
-    target_concurrent_inputs: Optional[int]
 
     def __init__(
         self,
@@ -74,8 +72,6 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
         cluster_size: Optional[int] = None,  # Experimental: Clustered functions
         force_build: bool = False,
         build_timeout: Optional[int] = None,
-        max_concurrent_inputs: Optional[int] = None,
-        target_concurrent_inputs: Optional[int] = None,
     ):
         self.raw_f = raw_f
         self.flags = flags
@@ -93,8 +89,6 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
         self.cluster_size = cluster_size  # Experimental: Clustered functions
         self.force_build = force_build
         self.build_timeout = build_timeout
-        self.max_concurrent_inputs = max_concurrent_inputs
-        self.target_concurrent_inputs = target_concurrent_inputs
 
     def _get_raw_f(self) -> Callable[P, ReturnType]:
         return self.raw_f
@@ -149,8 +143,6 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
             batch_wait_ms=self.batch_wait_ms,
             force_build=self.force_build,
             build_timeout=self.build_timeout,
-            max_concurrent_inputs=self.max_concurrent_inputs,
-            target_concurrent_inputs=self.target_concurrent_inputs,
         )
 
 
@@ -730,49 +722,3 @@ def _batched(
         )
 
     return wrapper
-
-
-def _concurrent(
-    _warn_parentheses_missing=None,
-    *,
-    max_inputs: int,  # Hard limit on each container's input concurrency
-    target_inputs: Optional[int] = None,  # Input concurrency that Modal's autoscaler should target
-) -> Callable[[Union[Callable[..., Any], _PartialFunction]], _PartialFunction]:
-    """Decorator that allows individual containers to handle multiple inputs concurrently.
-
-    The concurrency mechanism depends on whether the function is async or not:
-    - Async functions will run inputs on a single thread as asyncio tasks.
-    - Synchronous functions will use multi-threading. The code must be thread-safe.
-
-    Input concurrency will be most useful for workflows that are IO-bound
-    (e.g., making network requests) or when running an inference server that supports
-    dynamic batching.
-
-    When `target_inputs` is set, Modal's autoscaler will try to provision resources such
-    that each container is running that many inputs concurrently. Containers may burst up to
-    up to `max_inputs` if resources are insufficient to remain at the target concurrency.
-    """
-    if _warn_parentheses_missing is not None:
-        raise InvalidError(
-            "Positional arguments are not allowed. Did you forget parentheses? Suggestion: `@modal.concurrent()`."
-        )
-
-    if target_inputs and target_inputs > max_inputs:
-        raise InvalidError("`target_inputs` parameter cannot be greater than `max_inputs`.")
-
-    def wrapper(obj: Union[Callable[..., Any], _PartialFunction]) -> _PartialFunction:
-        if isinstance(obj, _PartialFunction):
-            # Risky that we need to mutate the parameters here; should make this safer
-            obj.max_concurrent_inputs = max_inputs
-            obj.target_concurrent_inputs = target_inputs
-            obj.add_flags(_PartialFunctionFlags.FUNCTION)
-            return obj
-
-        return _PartialFunction(
-            obj,
-            _PartialFunctionFlags.FUNCTION,
-            max_concurrent_inputs=max_inputs,
-            target_concurrent_inputs=target_inputs,
-        )
-
-    return wrapper

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],
+    )