modal 1.1.5.dev66__py3-none-any.whl → 1.3.1.dev8__py3-none-any.whl

modal/cls.py

@@ -7,11 +7,11 @@ from pathlib import PurePosixPath
 from typing import Any, Callable, Optional, Sequence, TypeVar, Union
 
 from google.protobuf.message import Message
-from grpclib import GRPCError, Status
 
 from modal_proto import api_pb2
 
 from ._functions import _Function, _parse_retries
+from ._load_context import LoadContext
 from ._object import _Object, live_method
 from ._partial_function import (
     _find_callables_for_obj,
@@ -30,14 +30,12 @@ from ._utils.deprecation import (
     warn_if_passing_namespace,
     warn_on_renamed_autoscaler_settings,
 )
-from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_volumes
+from .client import _Client
 from .cloud_bucket_mount import _CloudBucketMount
-from .config import config
 from .exception import ExecutionError, InvalidError, NotFoundError
 from .gpu import GPU_T
 from .retries import Retries
-from .scheduler_placement import SchedulerPlacement
 from .secret import _Secret
 from .volume import _Volume
 
@@ -135,7 +133,7 @@ def _bind_instance_method(cls: "_Cls", service_function: _Function, method_name:
         method_metadata = cls._method_metadata[method_name]
         new_function._hydrate(service_function.object_id, service_function.client, method_metadata)
 
-    async def _load(fun: "_Function", resolver: Resolver, existing_object_id: Optional[str]):
+    async def _load(fun: "_Function", resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]):
         # there is currently no actual loading logic executed to create each method on
         # the *parametrized* instance of a class - it uses the parameter-bound service-function
         # for the instance. This load method just makes sure to set all attributes after the
@@ -154,11 +152,14 @@ def _bind_instance_method(cls: "_Cls", service_function: _Function, method_name:
 
     rep = f"Method({cls._name}.{method_name})"
 
+    # Bound methods should *reference* their parent Cls's LoadContext
+    # so that it can be modified in place on the parent and be reflected in the method
     fun = _Function._from_loader(
         _load,
         rep,
         deps=_deps,
         hydrate_lazily=True,
+        load_context_overrides=cls._load_context_overrides,
     )
     if service_function.is_hydrated:
         # Eager hydration (skip load) if the instance service function is already loaded
@@ -422,14 +423,13 @@ class _Obj:
 
         # Not hydrated Cls, and we don't have the class - typically a Cls.from_name that
         # has not yet been loaded. So use a special loader that loads it lazily:
-        async def method_loader(fun, resolver: Resolver, existing_object_id):
-            await resolver.load(self._cls)  # load class so we get info about methods
+        async def method_loader(fun, resolver: Resolver, load_context: LoadContext, existing_object_id):
             method_function = _get_maybe_method()
             if method_function is None:
                 raise NotFoundError(
                     f"Class has no method {k}, and attributes can't be accessed for `Cls.from_name` instances"
                 )
-            await resolver.load(method_function)  # get the appropriate method handle (lazy)
+            await resolver.load(method_function, load_context)  # get the appropriate method handle (lazy)
             fun._hydrate_from_other(method_function)
 
         # The reason we don't *always* use this lazy loader is because it precludes attribute access
@@ -437,8 +437,9 @@ class _Obj:
         return _Function._from_loader(
             method_loader,
             rep=f"Method({self._cls._name}.{k})",
-            deps=lambda: [],  # TODO: use cls as dep instead of loading inside method_loader?
+            deps=lambda: [self._cls],
             hydrate_lazily=True,
+            load_context_overrides=self._cls._load_context_overrides,
         )
 
 
@@ -485,6 +486,7 @@ class _Cls(_Object, type_prefix="cs"):
         self._callables = other._callables
         self._name = other._name
         self._method_metadata = other._method_metadata
+        self._load_context_overrides = other._load_context_overrides
 
     def _get_partial_functions(self) -> dict[str, _PartialFunction]:
         if not self._user_cls:
@@ -559,7 +561,7 @@ class {user_cls.__name__}:
 More information on class parameterization can be found here: https://modal.com/docs/guide/parametrized-functions
 """,
             )
-        annotations = user_cls.__dict__.get("__annotations__", {})  # compatible with older pythons
+        annotations = inspect.get_annotations(user_cls)
         missing_annotations = params.keys() - annotations.keys()
         if missing_annotations:
             raise InvalidError("All modal.parameter() specifications need to be type-annotated")
@@ -577,22 +579,15 @@ More information on class parameterization can be found here: https://modal.com/
         # validate signature
         _Cls.validate_construction_mechanism(user_cls)
 
-        method_partials: dict[str, _PartialFunction] = _find_partial_methods_for_user_cls(
-            user_cls, _PartialFunctionFlags.interface_flags()
-        )
-
-        for method_name, partial_function in method_partials.items():
-            if partial_function.params.webhook_config is not None:
-                full_name = f"{user_cls.__name__}.{method_name}"
-                app._web_endpoints.append(full_name)
-            partial_function.registered = True
-
         # Disable the warning that lifecycle methods are not wrapped
-        for partial_function in _find_partial_methods_for_user_cls(
+        lifecycle_method_partials = _find_partial_methods_for_user_cls(
             user_cls, ~_PartialFunctionFlags.interface_flags()
-        ).values():
+        )
+        for partial_function in lifecycle_method_partials.values():
             partial_function.registered = True
 
+        method_partials = _find_partial_methods_for_user_cls(user_cls, _PartialFunctionFlags.interface_flags())
+
         # Get all callables
         callables: dict[str, Callable] = {
             k: pf.raw_f
@@ -603,15 +598,18 @@ More information on class parameterization can be found here: https://modal.com/
         def _deps() -> list[_Function]:
             return [class_service_function]
 
-        async def _load(self: "_Cls", resolver: Resolver, existing_object_id: Optional[str]):
+        async def _load(self: "_Cls", resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]):
             req = api_pb2.ClassCreateRequest(
-                app_id=resolver.app_id, existing_class_id=existing_object_id, only_class_function=True
+                app_id=load_context.app_id, existing_class_id=existing_object_id, only_class_function=True
             )
-            resp = await resolver.client.stub.ClassCreate(req)
-            self._hydrate(resp.class_id, resolver.client, resp.handle_metadata)
+            resp = await load_context.client.stub.ClassCreate(req)
+            self._hydrate(resp.class_id, load_context.client, resp.handle_metadata)
 
         rep = f"Cls({user_cls.__name__})"
-        cls: _Cls = _Cls._from_loader(_load, rep, deps=_deps)
+        # Pass a *reference* to the App's LoadContext - this is important since the App is
+        # the only way to infer a LoadContext for an `@app.cls`, and the App doesn't
+        # get its client until *after* the Cls is created.
+        cls: _Cls = _Cls._from_loader(_load, rep, deps=_deps, load_context_overrides=app._root_load_context)
         cls._app = app
         cls._user_cls = user_cls
         cls._class_service_function = class_service_function
@@ -628,6 +626,7 @@ More information on class parameterization can be found here: https://modal.com/
         *,
         namespace: Any = None,  # mdmd:line-hidden
         environment_name: Optional[str] = None,
+        client: Optional["_Client"] = None,
     ) -> "_Cls":
         """Reference a Cls from a deployed App by its name.
 
@@ -640,42 +639,47 @@ More information on class parameterization can be found here: https://modal.com/
         ```
         """
         warn_if_passing_namespace(namespace, "modal.Cls.from_name")
-        _environment_name = environment_name or config.get("environment")
 
-        async def _load_remote(self: _Cls, resolver: Resolver, existing_object_id: Optional[str]):
+        async def _load_remote(
+            self: _Cls, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
             request = api_pb2.ClassGetRequest(
                 app_name=app_name,
                 object_tag=name,
-                environment_name=_environment_name,
+                environment_name=load_context.environment_name,
                 only_class_function=True,
             )
             try:
-                response = await retry_transient_errors(resolver.client.stub.ClassGet, request)
+                response = await load_context.client.stub.ClassGet(request)
             except NotFoundError as exc:
-                env_context = f" (in the '{environment_name}' environment)" if environment_name else ""
+                env_context = (
+                    f" (in the '{load_context.environment_name}' environment)" if load_context.environment_name else ""
+                )
                 raise NotFoundError(
                     f"Lookup failed for Cls '{name}' from the '{app_name}' app{env_context}: {exc}."
                 ) from None
-            except GRPCError as exc:
-                if exc.status == Status.FAILED_PRECONDITION:
-                    raise InvalidError(exc.message) from None
-                else:
-                    raise
 
             print_server_warnings(response.server_warnings)
-            await resolver.load(self._class_service_function)
-            self._hydrate(response.class_id, resolver.client, response.handle_metadata)
+            await resolver.load(self._class_service_function, load_context)
+            self._hydrate(response.class_id, load_context.client, response.handle_metadata)
 
         environment_rep = f", environment_name={environment_name!r}" if environment_name else ""
         rep = f"Cls.from_name({app_name!r}, {name!r}{environment_rep})"
-        cls = cls._from_loader(_load_remote, rep, is_another_app=True, hydrate_lazily=True)
+
+        load_context_overrides = LoadContext(client=client, environment_name=environment_name)
+        cls = cls._from_loader(
+            _load_remote,
+            rep,
+            is_another_app=True,
+            hydrate_lazily=True,
+            load_context_overrides=load_context_overrides,
+        )
 
         class_service_name = f"{name}.*"  # special name of the base service function for the class
         cls._class_service_function = _Function._from_name(
             app_name,
             class_service_name,
-            namespace=namespace,
-            environment_name=_environment_name,
+            load_context_overrides=load_context_overrides,
         )
         cls._name = name
         return cls
@@ -735,8 +739,6 @@ More information on class parameterization can be found here: https://modal.com/
         else:
             resources = None
 
-        scheduler_placement = SchedulerPlacement(region=region).proto if region else None
-
         if allow_concurrent_inputs is not None:
             deprecation_warning(
                 (2025, 5, 9),
@@ -744,7 +746,7 @@ More information on class parameterization can be found here: https://modal.com/
                 " please use the `.with_concurrency` method instead.",
             )
 
-        async def _load_from_base(new_cls, resolver, existing_object_id):
+        async def _load_from_base(new_cls, resolver, load_context, existing_object_id):
             # this is a bit confusing, the cls will always have the same metadata
             # since it has the same *class* service function (i.e. "template")
             # But the (instance) service function for each Obj will be different
@@ -753,14 +755,21 @@ More information on class parameterization can be found here: https://modal.com/
             if not self.is_hydrated:
                 # this should only happen for Cls.from_name instances
                 # other classes should already be hydrated!
-                await resolver.load(self)
+                await resolver.load(self, load_context)
 
             new_cls._initialize_from_other(self)
 
         def _deps():
             return []
 
-        cls = _Cls._from_loader(_load_from_base, rep=f"{self._name}.with_options(...)", is_another_app=True, deps=_deps)
+        cls = _Cls._from_loader(
+            _load_from_base,
+            rep=f"{self._name}.with_options(...)",
+            is_another_app=True,
+            deps=_deps,
+            load_context_overrides=self._load_context_overrides,
+            hydrate_lazily=True,
+        )
         cls._initialize_from_other(self)
 
         # Validate volumes
@@ -772,6 +781,11 @@ More information on class parameterization can be found here: https://modal.com/
         if env:
             secrets = [*secrets, _Secret.from_dict(env)]
 
+        scheduler_placement: Optional[api_pb2.SchedulerPlacement] = None
+        if region:
+            regions = [region] if isinstance(region, str) else list(region)
+            scheduler_placement = api_pb2.SchedulerPlacement(regions=regions)
+
         new_options = _ServiceOptions(
             secrets=secrets,
             validated_volumes=validated_volumes_no_cloud_buckets,
@@ -805,16 +819,21 @@ More information on class parameterization can be found here: https://modal.com/
         ```
         """
 
-        async def _load_from_base(new_cls, resolver, existing_object_id):
+        async def _load_from_base(new_cls, resolver, load_context, existing_object_id):
             if not self.is_hydrated:
-                await resolver.load(self)
+                await resolver.load(self, load_context)
             new_cls._initialize_from_other(self)
 
         def _deps():
             return []
 
         cls = _Cls._from_loader(
-            _load_from_base, rep=f"{self._name}.with_concurrency(...)", is_another_app=True, deps=_deps
+            _load_from_base,
+            rep=f"{self._name}.with_concurrency(...)",
+            is_another_app=True,
+            deps=_deps,
+            load_context_overrides=self._load_context_overrides,
+            hydrate_lazily=True,
         )
         cls._initialize_from_other(self)
 
@@ -834,16 +853,21 @@ More information on class parameterization can be found here: https://modal.com/
         ```
         """
 
-        async def _load_from_base(new_cls, resolver, existing_object_id):
+        async def _load_from_base(new_cls, resolver, load_context, existing_object_id):
             if not self.is_hydrated:
-                await resolver.load(self)
+                await resolver.load(self, load_context)
             new_cls._initialize_from_other(self)
 
         def _deps():
             return []
 
         cls = _Cls._from_loader(
-            _load_from_base, rep=f"{self._name}.with_concurrency(...)", is_another_app=True, deps=_deps
+            _load_from_base,
+            rep=f"{self._name}.with_batching(...)",
+            is_another_app=True,
+            deps=_deps,
+            load_context_overrides=self._load_context_overrides,
+            hydrate_lazily=True,
         )
         cls._initialize_from_other(self)
 
@@ -863,18 +887,31 @@ More information on class parameterization can be found here: https://modal.com/
         )
 
     def __getattr__(self, k):
-        # TODO: remove this method - access to attributes on classes (not instances) should be discouraged
-        if not self._is_local() or k in self._method_partials:
-            # if not local (== k *could* be a method) or it is local and we know k is a method
-            deprecation_warning(
-                (2025, 1, 13),
-                "Calling a method on an uninstantiated class will soon be deprecated; "
-                "update your code to instantiate the class first, i.e.:\n"
-                f"{self._name}().{k} instead of {self._name}.{k}",
+        if self._user_cls is not None:
+            # local class, we can check if there are static attributes and let the user access them
+            # except if they are PartialFunction (i.e. methods)
+            v = getattr(self._user_cls, k)
+            if not isinstance(v, modal.partial_function.PartialFunction):
+                return v
+
+        # We create a synthetic dummy Function that is guaranteed to raise an AttributeError when
+        # a user tries to use any of its "live methods" - this lets us raise exceptions for users
+        # only if they try to access methods on a Cls as if they were methods on the instance.
+        async def error_loader(
+            fun: _Function, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
+            raise AttributeError(
+                "You can't access methods on a Cls directly - Did you forget to instantiate the class first?\n"
+                "e.g. instead of MyClass.method.remote(), do MyClass().method.remote()"
             )
-            return getattr(self(), k)
-        # non-method attribute access on local class - arguably shouldn't be used either:
-        return getattr(self._user_cls, k)
+
+        return _Function._from_loader(
+            error_loader,
+            rep=f"UnboundMethod({self._name}.{k})",
+            deps=lambda: [],
+            hydrate_lazily=True,
+            load_context_overrides=self._load_context_overrides,
+        )
 
     def _is_local(self) -> bool:
         return self._user_cls is not None

modal/cls.pyi

@@ -5,6 +5,7 @@ import modal._functions
 import modal._object
 import modal._partial_function
 import modal.app
+import modal.client
 import modal.cloud_bucket_mount
 import modal.functions
 import modal.gpu
@@ -178,8 +179,6 @@ class _Obj:
     async def _aenter(self): ...
     def __getattr__(self, k): ...
 
-SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
-
 class Obj:
     """An instance of a `Cls`, i.e. `Cls("foo", 42)` returns an `Obj`.
 
@@ -202,7 +201,7 @@ class Obj:
     def _get_parameter_values(self) -> dict[str, typing.Any]: ...
     def _new_user_cls_instance(self): ...
 
-    class __update_autoscaler_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __update_autoscaler_spec(typing_extensions.Protocol):
         def __call__(
             self,
             /,
@@ -273,9 +272,9 @@ class Obj:
             """
             ...
 
-    update_autoscaler: __update_autoscaler_spec[typing_extensions.Self]
+    update_autoscaler: __update_autoscaler_spec
 
-    class __keep_warm_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __keep_warm_spec(typing_extensions.Protocol):
         def __call__(self, /, warm_pool_size: int) -> None:
             """mdmd:hidden
             Set the warm pool size for the class containers
@@ -314,7 +313,7 @@ class Obj:
             """
             ...
 
-    keep_warm: __keep_warm_spec[typing_extensions.Self]
+    keep_warm: __keep_warm_spec
 
     def _cached_user_cls_instance(self):
         """Get or construct the local object
@@ -379,6 +378,7 @@ class _Cls(modal._object._Object):
         *,
         namespace: typing.Any = None,
         environment_name: typing.Optional[str] = None,
+        client: typing.Optional[modal.client._Client] = None,
     ) -> _Cls:
         """Reference a Cls from a deployed App by its name.
 
@@ -507,7 +507,7 @@ class Cls(modal.object.Object):
     def _get_class_service_function(self) -> modal.functions.Function: ...
     def _get_method_names(self) -> collections.abc.Collection[str]: ...
 
-    class ___experimental_get_flash_urls_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___experimental_get_flash_urls_spec(typing_extensions.Protocol):
         def __call__(self, /) -> typing.Optional[list[str]]:
             """URL of the flash service for the class."""
             ...
@@ -516,7 +516,7 @@ class Cls(modal.object.Object):
             """URL of the flash service for the class."""
             ...
 
-    _experimental_get_flash_urls: ___experimental_get_flash_urls_spec[typing_extensions.Self]
+    _experimental_get_flash_urls: ___experimental_get_flash_urls_spec
 
     def _hydrate_metadata(self, metadata: google.protobuf.message.Message): ...
     @staticmethod
@@ -537,6 +537,7 @@ class Cls(modal.object.Object):
         *,
         namespace: typing.Any = None,
         environment_name: typing.Optional[str] = None,
+        client: typing.Optional[modal.client.Client] = None,
     ) -> Cls:
         """Reference a Cls from a deployed App by its name.
 

modal/config.py

@@ -51,6 +51,10 @@ Other possible configuration options are:
   Defaults to 10.
   Number of seconds to wait for logs to drain when closing the session,
   before giving up.
+* `max_throttle_wait` (in the .toml file) / `MODAL_MAX_THROTTLE_WAIT` (as an env var).
+  Defaults to None (no limit).
+  Maximum number of seconds to wait when requests are being throttled (i.e., due
+  to rate limiting or other cases that can normally be resolved through backoff).
 * `force_build` (in the .toml file) / `MODAL_FORCE_BUILD` (as an env var).
   Defaults to False.
   When set, ignores the Image cache and builds all Image layers. Note that this
@@ -71,6 +75,10 @@ Other possible configuration options are:
   The log formatting pattern that will be used by the modal client itself.
   See https://docs.python.org/3/library/logging.html#logrecord-attributes for available
   log attributes.
+* `dev_suffix` (in the .toml file) / `MODAL_DEV_SUFFIX` (as an env var).
+  Overrides the default `-dev` suffix added to URLs generated for web endpoints
+  when the App is ephemeral (i.e., created via `modal serve`). Must be a short
+  alphanumeric string.
 
 Meta-configuration
 ------------------
@@ -85,6 +93,7 @@ Some "meta-options" are set using environment variables only:
 
 import logging
 import os
+import re
 import typing
 import warnings
 from typing import Any, Callable, Optional
@@ -142,7 +151,7 @@ async def _lookup_workspace(server_url: str, token_id: str, token_secret: str) -
 
     credentials = (token_id, token_secret)
     async with _Client(server_url, api_pb2.CLIENT_TYPE_CLIENT, credentials) as client:
-        return await client.stub.WorkspaceNameLookup(Empty(), timeout=3)
+        return await client.stub.WorkspaceNameLookup(Empty(), retry=None, timeout=3)
 
 
 def config_profiles():
@@ -206,6 +215,12 @@ def _check_value(options: list[str]) -> Callable[[str], str]:
     return checker
 
 
+def _enforce_suffix_rules(x: str) -> str:
+    if x and not re.match(r"^[a-zA-Z0-9]{1,8}$", x):
+        raise ValueError("Suffix must be an alphanumeric string of no more than 8 characters.")
+    return x
+
+
 class _Setting(typing.NamedTuple):
     default: typing.Any = None
     transform: typing.Callable[[str], typing.Any] = lambda x: x  # noqa: E731
@@ -236,6 +251,8 @@ _SETTINGS = {
     "traceback": _Setting(False, transform=_to_boolean),
     "image_builder_version": _Setting(),
     "strict_parameters": _Setting(False, transform=_to_boolean),  # For internal/experimental use
+    # Allow insecure TLS for the task command router when running locally (testing/dev only)
+    "task_command_router_insecure": _Setting(False, transform=_to_boolean),
     "snapshot_debug": _Setting(False, transform=_to_boolean),
     "cuda_checkpoint_path": _Setting("/__modal/.bin/cuda-checkpoint"),  # Used for snapshotting GPU memory.
     "build_validation": _Setting("error", transform=_check_value(["error", "warn", "ignore"])),
@@ -244,6 +261,9 @@ _SETTINGS = {
         "pickle",
         transform=lambda s: _check_value(["pickle", "cbor"])(s.lower()),
     ),
+    "dev_suffix": _Setting("", transform=_enforce_suffix_rules),
+    "max_throttle_wait": _Setting(None, transform=lambda x: int(x) if x else None),
+    "async_warnings": _Setting(False, transform=_to_boolean),  # Feature flag for async API warnings
 }