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

modal/_utils/function_utils.py

@@ -15,7 +15,14 @@ from synchronicity.exceptions import UserCodeException
 import modal_proto
 from modal_proto import api_pb2
 
-from .._serialization import PROTO_TYPE_INFO, PYTHON_TO_PROTO_TYPE, deserialize, deserialize_data_format, serialize
+from .._serialization import (
+    PROTO_TYPE_INFO,
+    PYTHON_TO_PROTO_TYPE,
+    deserialize,
+    deserialize_data_format,
+    get_proto_parameter_type,
+    serialize,
+)
 from .._traceback import append_modal_tb
 from ..config import config, logger
 from ..exception import (
@@ -99,6 +106,24 @@ 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
 
@@ -277,28 +302,23 @@ class FunctionInfo:
             return api_pb2.ClassParameterInfo()
 
         # TODO(elias): Resolve circular dependencies... maybe we'll need some cls_utils module
-        from modal.cls import _get_class_constructor_signature, _use_annotation_parameters, _validate_parameter_type
+        from modal.cls import _get_class_constructor_signature, _use_annotation_parameters
 
         if not _use_annotation_parameters(self.user_cls):
             return api_pb2.ClassParameterInfo(format=api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PICKLE)
 
         # annotation parameters trigger strictly typed parametrization
         # which enables web endpoint for parametrized classes
-
-        modal_parameters: list[api_pb2.ClassParameterSpec] = []
         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():
-            has_default = param.default is not param.empty
-            _validate_parameter_type(self.user_cls.__name__, param.name, param.annotation)
-            proto_type = PYTHON_TO_PROTO_TYPE[param.annotation]
-            proto_type_info = PROTO_TYPE_INFO[proto_type]
-            class_param_spec = api_pb2.ClassParameterSpec(name=param.name, has_default=has_default, type=proto_type)
-            if has_default:
-                setattr(class_param_spec, proto_type_info.default_field, param.default)
-            modal_parameters.append(class_param_spec)
+            get_proto_parameter_type(param.annotation)
+
+        protobuf_schema = signature_to_protobuf_schema(signature)
 
         return api_pb2.ClassParameterInfo(
-            format=api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PROTO, schema=modal_parameters
+            format=api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PROTO,
+            schema=protobuf_schema,
         )
 
     def get_entrypoint_mount(self) -> dict[str, _Mount]:

modal/_utils/jwt_utils.py

@@ -0,0 +1,38 @@
+# Copyright Modal Labs 2025
+import base64
+import json
+from dataclasses import dataclass
+from typing import Any, Dict
+
+
+@dataclass
+class DecodedJwt:
+    header: Dict[str, Any]
+    payload: Dict[str, Any]
+
+    @staticmethod
+    def decode_without_verification(token: str) -> "DecodedJwt":
+        # Split the JWT into its three parts
+        header_b64, payload_b64, _ = token.split(".")
+
+        # Decode Base64 (with padding handling)
+        header_json = base64.urlsafe_b64decode(header_b64 + "==").decode("utf-8")
+        payload_json = base64.urlsafe_b64decode(payload_b64 + "==").decode("utf-8")
+
+        # Convert JSON strings to dictionaries
+        header = json.loads(header_json)
+        payload = json.loads(payload_json)
+
+        return DecodedJwt(header, payload)
+
+    @staticmethod
+    def _base64url_encode(data: str) -> str:
+        """Encodes data to Base64 URL-safe format without padding."""
+        return base64.urlsafe_b64encode(data.encode()).rstrip(b"=").decode()
+
+    @staticmethod
+    def encode_without_signature(fields: Dict[str, Any]) -> str:
+        """Encodes an Unsecured JWT (without a signature)."""
+        header_b64 = DecodedJwt._base64url_encode(json.dumps({"alg": "none", "typ": "JWT"}))
+        payload_b64 = DecodedJwt._base64url_encode(json.dumps(fields))
+        return f"{header_b64}.{payload_b64}."  # No signature

modal/app.py

@@ -678,6 +678,12 @@ class _App:
                 is_generator = f.is_generator
                 batch_max_size = f.batch_max_size
                 batch_wait_ms = f.batch_wait_ms
+                if f.max_concurrent_inputs:  # Using @modal.concurrent()
+                    max_concurrent_inputs = f.max_concurrent_inputs
+                    target_concurrent_inputs = f.target_concurrent_inputs
+                else:
+                    max_concurrent_inputs = allow_concurrent_inputs
+                    target_concurrent_inputs = None
             else:
                 if not is_global_object(f.__qualname__) and not serialized:
                     raise InvalidError(
@@ -709,10 +715,12 @@ class _App:
                     )
 
                 info = FunctionInfo(f, serialized=serialized, name_override=name)
+                raw_f = f
                 webhook_config = None
                 batch_max_size = None
                 batch_wait_ms = None
-                raw_f = f
+                max_concurrent_inputs = allow_concurrent_inputs
+                target_concurrent_inputs = None
 
                 cluster_size = None  # Experimental: Clustered functions
                 i6pn_enabled = i6pn
@@ -753,7 +761,8 @@ class _App:
                 max_containers=max_containers,
                 buffer_containers=buffer_containers,
                 scaledown_window=scaledown_window,
-                allow_concurrent_inputs=allow_concurrent_inputs,
+                max_concurrent_inputs=max_concurrent_inputs,
+                target_concurrent_inputs=target_concurrent_inputs,
                 batch_max_size=batch_max_size,
                 batch_wait_ms=batch_wait_ms,
                 timeout=timeout,
@@ -832,7 +841,7 @@ class _App:
         concurrency_limit: Optional[int] = None,  # Replaced with `max_containers`
         container_idle_timeout: Optional[int] = None,  # Replaced with `scaledown_window`
         _experimental_buffer_containers: Optional[int] = None,  # Now stable API with `buffer_containers`
-    ) -> Callable[[CLS_T], CLS_T]:
+    ) -> Callable[[Union[CLS_T, _PartialFunction]], CLS_T]:
         """
         Decorator to register a new Modal [Cls](/docs/reference/modal.Cls) with this App.
         """
@@ -845,8 +854,21 @@ class _App:
                 raise InvalidError("`region` and `_experimental_scheduler_placement` cannot be used together")
             scheduler_placement = SchedulerPlacement(region=region)
 
-        def wrapper(user_cls: CLS_T) -> CLS_T:
+        def wrapper(wrapped_cls: Union[CLS_T, _PartialFunction]) -> CLS_T:
             # Check if the decorated object is a class
+            if isinstance(wrapped_cls, _PartialFunction):
+                wrapped_cls.wrapped = True
+                user_cls = wrapped_cls.raw_f
+                if wrapped_cls.max_concurrent_inputs:  # Using @modal.concurrent()
+                    max_concurrent_inputs = wrapped_cls.max_concurrent_inputs
+                    target_concurrent_inputs = wrapped_cls.target_concurrent_inputs
+                else:
+                    max_concurrent_inputs = allow_concurrent_inputs
+                    target_concurrent_inputs = None
+            else:
+                user_cls = wrapped_cls
+                max_concurrent_inputs = allow_concurrent_inputs
+                target_concurrent_inputs = None
             if not inspect.isclass(user_cls):
                 raise TypeError("The @app.cls decorator must be used on a class.")
 
@@ -871,6 +893,12 @@ class _App:
             ):
                 raise InvalidError("A class must have `enable_memory_snapshot=True` to use `snap=True` on its methods.")
 
+            for method in _find_partial_methods_for_user_cls(user_cls, _PartialFunctionFlags.FUNCTION).values():
+                if method.max_concurrent_inputs:
+                    raise InvalidError(
+                        "The `@modal.concurrent` decorator cannot be used on methods; decorate the class instead."
+                    )
+
             info = FunctionInfo(None, serialized=serialized, user_cls=user_cls)
 
             cls_func = _Function.from_local(
@@ -892,7 +920,8 @@ class _App:
                 scaledown_window=scaledown_window,
                 proxy=proxy,
                 retries=retries,
-                allow_concurrent_inputs=allow_concurrent_inputs,
+                max_concurrent_inputs=max_concurrent_inputs,
+                target_concurrent_inputs=target_concurrent_inputs,
                 batch_max_size=batch_max_size,
                 batch_wait_ms=batch_wait_ms,
                 timeout=timeout,

modal/app.pyi

@@ -1,6 +1,7 @@
 import collections.abc
 import modal._functions
 import modal._object
+import modal._partial_function
 import modal._utils.function_utils
 import modal.client
 import modal.cloud_bucket_mount
@@ -247,7 +248,7 @@ class _App:
         concurrency_limit: typing.Optional[int] = None,
         container_idle_timeout: typing.Optional[int] = None,
         _experimental_buffer_containers: typing.Optional[int] = None,
-    ) -> collections.abc.Callable[[CLS_T], CLS_T]: ...
+    ) -> collections.abc.Callable[[typing.Union[CLS_T, modal._partial_function._PartialFunction]], CLS_T]: ...
     async def spawn_sandbox(
         self,
         *entrypoint_args: str,
@@ -487,7 +488,7 @@ class App:
         concurrency_limit: typing.Optional[int] = None,
         container_idle_timeout: typing.Optional[int] = None,
         _experimental_buffer_containers: typing.Optional[int] = None,
-    ) -> collections.abc.Callable[[CLS_T], CLS_T]: ...
+    ) -> collections.abc.Callable[[typing.Union[CLS_T, modal.partial_function.PartialFunction]], CLS_T]: ...
 
     class __spawn_sandbox_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(

modal/cli/app.py

@@ -227,6 +227,8 @@ async def history(
     ]
     rows = []
     deployments_with_tags = False
+    deployments_with_commit_info = False
+    deployments_with_dirty_commit = False
     for idx, app_stats in enumerate(resp.app_deployment_histories):
         style = "bold green" if idx == 0 else ""
 
@@ -241,10 +243,23 @@ async def history(
             deployments_with_tags = True
             row.append(Text(app_stats.tag, style=style))
 
+        if app_stats.commit_info.commit_hash:
+            deployments_with_commit_info = True
+            short_hash = app_stats.commit_info.commit_hash[:7]
+            if app_stats.commit_info.dirty:
+                deployments_with_dirty_commit = True
+                short_hash = f"{short_hash}*"
+            row.append(Text(short_hash, style=style))
+
         rows.append(row)
 
     if deployments_with_tags:
         columns.append("Tag")
+    if deployments_with_commit_info:
+        columns.append("Commit")
 
     rows = sorted(rows, key=lambda x: int(str(x[0])[1:]), reverse=True)
     display_table(columns, rows, json)
+
+    if deployments_with_dirty_commit and not json:
+        rich.print("* - repo had uncommitted changes")

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.116",
+        version: str = "0.73.128",
     ): ...
     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.116",
+        version: str = "0.73.128",
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/cls.py

@@ -21,7 +21,7 @@ from ._partial_function import (
 )
 from ._resolver import Resolver
 from ._resources import convert_fn_config_to_resources_config
-from ._serialization import PYTHON_TO_PROTO_TYPE, check_valid_cls_constructor_arg
+from ._serialization import check_valid_cls_constructor_arg, get_proto_parameter_type
 from ._traceback import print_server_warnings
 from ._utils.async_utils import synchronize_api, synchronizer
 from ._utils.deprecation import deprecation_warning, renamed_parameter, warn_on_renamed_autoscaler_settings
@@ -362,15 +362,6 @@ class _Obj:
 Obj = synchronize_api(_Obj)
 
 
-def _validate_parameter_type(cls_name: str, parameter_name: str, parameter_type: type):
-    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"{cls_name}.{parameter_name}: {type_name} is not a supported parameter type. Use one of: {supported}"
-        )
-
-
 class _Cls(_Object, type_prefix="cs"):
     """
     Cls adds method pooling and [lifecycle hook](/docs/guide/lifecycle-functions) behavior
@@ -467,12 +458,11 @@ class _Cls(_Object, type_prefix="cs"):
         annotations = user_cls.__dict__.get("__annotations__", {})  # compatible with older pythons
         missing_annotations = params.keys() - annotations.keys()
         if missing_annotations:
-            raise InvalidError("All modal.parameter() specifications need to be type annotated")
+            raise InvalidError("All modal.parameter() specifications need to be type-annotated")
 
         annotated_params = {k: t for k, t in annotations.items() if k in params}
         for k, t in annotated_params.items():
-            if t not in PYTHON_TO_PROTO_TYPE:
-                _validate_parameter_type(user_cls.__name__, k, t)
+            get_proto_parameter_type(t)
 
     @staticmethod
     def from_local(user_cls, app: "modal.app._App", class_service_function: _Function) -> "_Cls":

modal/cls.pyi

@@ -109,8 +109,6 @@ class Obj:
     async def _aenter(self): ...
     def __getattr__(self, k): ...
 
-def _validate_parameter_type(cls_name: str, parameter_name: str, parameter_type: type): ...
-
 class _Cls(modal._object._Object):
     _class_service_function: typing.Optional[modal._functions._Function]
     _options: typing.Optional[_ServiceOptions]

modal/functions.pyi

@@ -82,7 +82,8 @@ class Function(
         max_containers: typing.Optional[int] = None,
         buffer_containers: typing.Optional[int] = None,
         scaledown_window: typing.Optional[int] = None,
-        allow_concurrent_inputs: typing.Optional[int] = None,
+        max_concurrent_inputs: typing.Optional[int] = None,
+        target_concurrent_inputs: typing.Optional[int] = None,
         batch_max_size: typing.Optional[int] = None,
         batch_wait_ms: typing.Optional[int] = None,
         cloud: typing.Optional[str] = None,
@@ -198,11 +199,11 @@ class Function(
 
     _call_generator_nowait: ___call_generator_nowait_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_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.ReturnType, modal._functions.P, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, *args, **kwargs) -> typing.Generator[typing.Any, None, None]: ...
@@ -217,19 +218,19 @@ class Function(
         self, *args: modal._functions.P.args, **kwargs: modal._functions.P.kwargs
     ) -> modal._functions.OriginalReturnType: ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_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.ReturnType, modal._functions.P, typing_extensions.Self
+        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
     ]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_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.ReturnType, modal._functions.P, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]: ...