modal 1.5.4.dev22__tar.gz → 1.5.5__tar.gz

{modal-1.5.4.dev22 → modal-1.5.5}/PKG-INFO

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

{modal-1.5.4.dev22 → modal-1.5.5}/modal/_container_entrypoint.py

@@ -145,7 +145,7 @@ def call_function(
                             item_count += 1
 
                 await container_io_manager._send_outputs.aio(
-                    io_context.output_items_generator_done(started_at, item_count)
+                    io_context, io_context.output_items_generator_done(started_at, item_count)
                 )
             else:
                 value = await io_context.call_function_async()
@@ -182,7 +182,9 @@ def call_function(
                         container_io_manager._queue_put(generator_queue, value)
                         item_count += 1
 
-                container_io_manager._send_outputs(io_context.output_items_generator_done(started_at, item_count))
+                container_io_manager._send_outputs(
+                    io_context, io_context.output_items_generator_done(started_at, item_count)
+                )
             else:
                 values = io_context.call_function_sync()
                 container_io_manager.push_outputs(io_context, started_at, values)

{modal-1.5.4.dev22 → modal-1.5.5}/modal/_environments.py

@@ -39,6 +39,7 @@ class _EnvironmentManager:
         name: str,  # Name to use for the new Environment
         *,
         restricted: bool = False,  # If True, enable RBAC restrictions on the Environment
+        default_role: str | None = None,  # Default member Role for the Restricted Environment
         experimental_options: dict[str, Any] | None = None,  # Experimental options for Environment creation
         client: _Client | None = None,  # Optional client with Modal credentials
     ) -> None:
@@ -51,8 +52,11 @@ class _EnvironmentManager:
         ```
         """
         check_environment_name(name)
+
         client = await _Client.from_env() if client is None else client
         request = api_pb2.EnvironmentCreateRequest(name=name, is_managed=restricted)
+        if default_role:
+            request.default_member_role_str = default_role
         if (experimental_options or {}).get("is_public", False):
             request.environment_type = api_pb2.ENVIRONMENT_TYPE_PUBLIC
         await client.stub.EnvironmentCreate(request)
@@ -116,9 +120,12 @@ class _EnvironmentRolesManager:
         """mdmd:hidden"""
         self._environment = environment
 
-    async def list(self) -> dict[Literal["users", "service_users"], dict[str, str]]:
+    async def list(self, *, exclude_default: bool = False) -> dict[Literal["users", "service_users"], dict[str, str]]:
         """Enumerate the Environment Role for each user and service user in the workspace.
 
+        Args:
+            exclude_default: If `True`, only include roles that are directly assigned.
+
         **Examples:**
 
         ```python notest
@@ -137,6 +144,8 @@ class _EnvironmentRolesManager:
         users: dict[str, str] = {}
         service_users: dict[str, str] = {}
         for principal in resp.principal_roles:
+            if exclude_default and not principal.has_role_assignment:
+                continue
             if principal.user_id:
                 users[principal.user_name] = principal.role_str
             elif principal.service_user_id:
@@ -252,8 +261,8 @@ class _EnvironmentMembersManager:
         """Remove the Environment Role of users and service users, reverting them to the default."""
         deprecation_warning(
             (2026, 7, 23),
-            "`Environment.members.remove()` is deprecated. Environment Roles are now explicit; "
-            "set a role (e.g. 'no-access') with `Environment.roles.update()` instead.",
+            "`Environment.members.remove()` is deprecated; assign a role (e.g. 'no-access') with "
+            "`Environment.roles.update()` instead.",
         )
         await self._environment.hydrate()
         users = users or []
@@ -469,7 +478,7 @@ class _EnvironmentBillingManager:
         elif end.tzinfo != timezone.utc:
             raise InvalidError("Timezone-aware 'end' parameter must be in UTC.")
 
-        if not self._environment.is_hydrated:
+        if not self._environment._is_hydrated:
             await self._environment.hydrate()
 
         request = api_pb2.WorkspaceBillingReportRequest(
@@ -540,7 +549,7 @@ class _EnvironmentBillingManager:
         if cycle > datetime.now(timezone.utc):
             raise InvalidError("Provided 'cycle' parameter cannot be in the future.")
 
-        if not self._environment.is_hydrated:
+        if not self._environment._is_hydrated:
             await self._environment.hydrate()
 
         request = api_pb2.EnvironmentBillingSummaryRequest(environment_id=self._environment.object_id)

{modal-1.5.4.dev22 → modal-1.5.5}/modal/_function_variants.py

@@ -157,7 +157,7 @@ class _FunctionOptions:
             + list(self.secrets)
             + [mount.secret for _, mount in self.cloud_bucket_mounts if mount.secret]
         )
-        return [dep for dep in all_deps if not dep.is_hydrated]
+        return [dep for dep in all_deps if not dep._is_hydrated]
 
     def to_proto(self) -> api_pb2.FunctionOptions:
         """Convert the dataclass to a FunctionOptions protobuf message."""
@@ -246,7 +246,7 @@ def _make_function_variant(
         load_context: "LoadContext",
         existing_object_id: str | None,
     ):
-        if not base_function.is_hydrated:
+        if not base_function._is_hydrated:
             await base_function.hydrate(load_context.client)
         assert base_function._client and base_function._client.stub
 
@@ -290,6 +290,6 @@ def _make_function_variant(
         deps=_deps,
         load_context_overrides=base_function._load_context_overrides,
     )
-    fun._info = base_function._info
+    fun._source_info = base_function._source_info
     fun._spec = base_function._spec  # TODO (elias): fix - this is incorrect when using with_options
     return fun

{modal-1.5.4.dev22 → modal-1.5.5}/modal/_functions.py

@@ -46,10 +46,11 @@ from ._utils.async_utils import (
     warn_if_generator_is_not_consumed,
 )
 from ._utils.blob_utils import MAX_ASYNC_OBJECT_SIZE_BYTES, MAX_OBJECT_SIZE_BYTES
+from ._utils.deprecation import with_deprecation_warning
 from ._utils.function_utils import (
     ATTEMPT_TIMEOUT_GRACE_PERIOD,
     OUTPUTS_TIMEOUT,
-    FunctionInfo,
+    FunctionSourceInfo,
     _create_input,
     _parse_retries,
     _process_result,
@@ -603,7 +604,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     """
 
     # TODO: more type annotations
-    _info: FunctionInfo | None
+    _source_info: FunctionSourceInfo | None
     _serve_mounts: frozenset[_Mount]  # set at load time, only by loader
     _app: "modal.app._App | None" = None
     # only set for InstanceServiceFunctions and bound instance methods
@@ -640,7 +641,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         await self.hydrate()
         if not self._app_id:
             raise ExecutionError("app_id should have been set during function hydration")
-        return _LogQueryData(self.client, self._app_id, LogsFilters(function_id=self.object_id))
+        return _LogQueryData(
+            self.client,
+            self._app_id,
+            LogsFilters(function_id=self.object_id),
+            source_object_id=self.object_id,
+        )
 
     @property
     def logs(self) -> _FunctionLogsManager:
@@ -658,8 +664,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return _FunctionLogsManager(self)
 
     @staticmethod
-    def from_local(
-        info: FunctionInfo,
+    def _from_local(
+        info: FunctionSourceInfo,
         app: "modal.app._App | None",  # App here should only be None in case of Image.run_function
         image: _Image,
         env: dict[str, str | None] | None = None,
@@ -932,7 +938,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             with FunctionCreationStatus(tag) as function_creation_status:
                 timeout_secs = timeout
 
-                if app and app.is_interactive and not is_builder_function:
+                if app and app._is_interactive_ and not is_builder_function:
                     pty_info = get_pty_info(shell=False)
                 else:
                     pty_info = None
@@ -1105,6 +1111,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         http_config=http_config,
                         is_server=function_definition.is_server,
                         routing_region=function_definition.routing_region,
+                        is_sessioned=function_definition.is_sessioned,
                     )
 
                     ranked_functions = []
@@ -1158,10 +1165,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         # the only way to infer a LoadContext for an `@app.function`, and the App doesn't
         # get its client until *after* the Function is created.
         load_context = app._root_load_context if app else LoadContext.empty()
-        obj = _Function._from_loader(_load, rep, preload=_preload, deps=_deps, load_context_overrides=load_context)
+        obj: _Function = _Function._from_loader(
+            _load, rep, preload=_preload, deps=_deps, load_context_overrides=load_context
+        )
 
         obj._raw_f = info.raw_f
-        obj._info = info
+        obj._source_info = info
         obj._tag = tag
         obj._app = app  # needed for CLI right now
         obj._obj = None
@@ -1186,6 +1195,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
         return obj
 
+    from_local = with_deprecation_warning(
+        (2026, 8, 26),
+        "`Function.from_local` is deprecated and will be removed in `modal` version 1.6.0",
+    )(_from_local)
+    """mdmd:hidden"""
+
     async def _update_autoscaler(
         self,
         *,
@@ -1378,8 +1393,16 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         )
 
     @property
+    @with_deprecation_warning(
+        (2026, 8, 26),
+        "`Function.tag` is deprecated and will be removed in `modal` version 1.6.0",
+    )
     def tag(self) -> str:
         """mdmd:hidden"""
+        return self._tag_
+
+    @property
+    def _tag_(self) -> str:
         assert self._tag
         return self._tag
 
@@ -1392,20 +1415,40 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return self._app
 
     @property
+    @with_deprecation_warning(
+        (2026, 8, 26),
+        "`Function.stub` is deprecated and will be removed in `modal` version 1.6.0",
+    )
     def stub(self) -> "modal.app._App":
         """mdmd:hidden"""
         # Deprecated soon, only for backwards compatibility
         return self.app
 
     @property
-    def info(self) -> FunctionInfo:
+    @with_deprecation_warning(
+        (2026, 8, 26),
+        "`Function.info` is deprecated and will be removed in `modal` version 1.6.0",
+    )
+    def info(self) -> FunctionSourceInfo:
         """mdmd:hidden"""
-        assert self._info
-        return self._info
+        return self._source_info_
 
     @property
+    def _source_info_(self) -> FunctionSourceInfo:
+        assert self._source_info
+        return self._source_info
+
+    @property
+    @with_deprecation_warning(
+        (2026, 8, 26),
+        "`Function.spec` is deprecated and will be removed in `modal` version 1.6.0",
+    )
     def spec(self) -> _FunctionSpec:
         """mdmd:hidden"""
+        return self._spec_
+
+    @property
+    def _spec_(self) -> _FunctionSpec:
         assert self._spec
         return self._spec
 
@@ -1413,13 +1456,19 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         # only defined in definition scope/locally, and not for class methods at the moment
         return bool(self._webhook_config and self._webhook_config.type != api_pb2.WEBHOOK_TYPE_UNSPECIFIED)
 
-    def get_build_def(self) -> str:
+    def _get_build_def(self) -> str:
         """mdmd:hidden"""
         # Plaintext source and arg definition for the function, so it's part of the image
         # hash. We can't use the cloudpickle hash because it's not very stable.
         assert hasattr(self, "_raw_f") and hasattr(self, "_build_args") and self._raw_f is not None
         return f"{inspect.getsource(self._raw_f)}\n{repr(self._build_args)}"
 
+    get_build_def = with_deprecation_warning(
+        (2026, 8, 26),
+        "`Function.get_build_def` is deprecated and will be removed in `modal` version 1.6.0",
+    )(_get_build_def)
+    """mdmd:hidden"""
+
     # Live handle methods
 
     def _initialize_from_empty(self):
@@ -1428,7 +1477,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._is_generator = None
         self._web_url = None
         self._function_name = None
-        self._info = None
+        self._source_info = None
         self._serve_mounts = frozenset()
         self._metadata = None
         self._experimental_flash_urls = None
@@ -1560,7 +1609,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         new_function._webhook_config = self._webhook_config
 
         # Other fields not necessarily initialized
-        if self._info is not None:
+        if self._source_info is not None:
             new_function._build_args = self._build_args
             new_function._is_method = self._is_method
             new_function._raw_f = self._raw_f
@@ -1667,8 +1716,16 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return self._apply_dynamic_config(options, "with_batching")
 
     @property
+    @with_deprecation_warning(
+        (2026, 8, 26),
+        "`Function.is_generator` is deprecated and will be removed in `modal` version 1.6.0",
+    )
     async def is_generator(self) -> bool:
         """mdmd:hidden"""
+        return await self._is_generator_
+
+    @property
+    async def _is_generator_(self) -> bool:
         # hacky: kind of like @live_method, but not hydrating if we have the value already from local source
         # TODO(michael) use a common / lightweight method for handling unhydrated metadata properties
         if self._is_generator is not None:
@@ -1858,12 +1915,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             yield item
 
     def _is_local(self):
-        return self._info is not None
+        return self._source_info is not None
 
-    def _get_info(self) -> FunctionInfo:
-        if not self._info:
-            raise ExecutionError("Can't get info for a function that isn't locally defined")
-        return self._info
+    def _get_source_info(self) -> FunctionSourceInfo:
+        if not self._source_info:
+            raise ExecutionError("Can't get source info for a function that isn't locally defined")
+        return self._source_info
 
     def _get_obj(self) -> "modal.cls._Obj | None":
         if not self._is_method:
@@ -1898,13 +1955,13 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             )
             raise ExecutionError(msg)
 
-        info = self._get_info()
+        info = self._get_source_info()
         if not info.raw_f:
             # Here if calling .local on a service function itself which should never happen
             # TODO: check if we end up here in a container for a serialized function?
             raise ExecutionError("Can't call .local on service function")
 
-        if is_local() and self.spec.volumes or self.spec.network_file_systems:
+        if is_local() and self._spec_.volumes or self._spec_.network_file_systems:
             warnings.warn(
                 f"The {info.function_name} function is executing locally "
                 + "and will not have access to the mounted Volume or NetworkFileSystem data"
@@ -2002,12 +2059,20 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         fc._function_id = self.object_id
         return fc
 
+    @with_deprecation_warning(
+        (2026, 8, 26),
+        "`Function.get_raw_f` is deprecated and will be removed in `modal` version 1.6.0",
+    )
     def get_raw_f(self) -> Callable[..., Any]:
         """Return the inner Python object wrapped by this Modal Function.
 
         Returns:
             The original function object registered with Modal.
         """
+        return self._raw_f_
+
+    @property
+    def _raw_f_(self) -> Callable[..., Any]:
         assert self._raw_f is not None
         return self._raw_f
 
@@ -2077,7 +2142,12 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
             await self._hydrate_from_id_metadata()
         if not self._app_id:
             raise ExecutionError("app_id should have been set during function call hydration")
-        return _LogQueryData(self.client, self._app_id, LogsFilters(function_call_id=self.object_id))
+        return _LogQueryData(
+            self.client,
+            self._app_id,
+            LogsFilters(function_call_id=self.object_id),
+            source_object_id=self.object_id,
+        )
 
     @property
     def logs(self) -> _FunctionCallLogsManager:

{modal-1.5.4.dev22 → modal-1.5.5}/modal/_image.py

@@ -41,7 +41,7 @@ from ._utils.docker_utils import (
     extract_copy_command_patterns,
     find_dockerignore_file,
 )
-from ._utils.function_utils import FunctionInfo, parse_gpu_config
+from ._utils.function_utils import FunctionSourceInfo, parse_gpu_config
 from ._utils.mount_utils import validate_only_modal_volumes, validate_volumes_by_object_id
 from ._utils.name_utils import check_object_name
 from .client import _Client
@@ -681,8 +681,8 @@ class _Image(_Object, type_prefix="im"):
 
             if build_function:
                 build_function_id = build_function.object_id
-                globals = build_function._get_info().get_globals()
-                attrs = build_function._get_info().get_cls_var_attrs()
+                globals = build_function._get_source_info().get_globals()
+                attrs = build_function._get_source_info().get_cls_var_attrs()
                 globals = {**globals, **attrs}
                 filtered_globals = {}
                 for k, v in globals.items():
@@ -694,7 +694,7 @@ class _Image(_Object, type_prefix="im"):
                         # Skip unserializable values for now.
                         logger.warning(
                             f"Skipping unserializable global variable {k} for "
-                            f"{build_function._get_info().function_name}. "
+                            f"{build_function._get_source_info().function_name}. "
                             "Changes to this variable won't invalidate the image."
                         )
                         continue
@@ -704,7 +704,7 @@ class _Image(_Object, type_prefix="im"):
                 # TODO: better way to filter out types that don't have a stable hash?
                 build_function_globals = serialize(filtered_globals) if filtered_globals else b""
                 _build_function = api_pb2.BuildFunction(
-                    definition=build_function.get_build_def(),
+                    definition=build_function._get_build_def(),
                     globals=build_function_globals,
                     input=build_function_input,
                 )
@@ -764,7 +764,10 @@ class _Image(_Object, type_prefix="im"):
                 if build_resp.HasField("metadata"):
                     metadata = build_resp.metadata
 
-            if result.status == api_pb2.GenericResult.GENERIC_STATUS_FAILURE:
+            if result.status in (
+                api_pb2.GenericResult.GENERIC_STATUS_FAILURE,
+                api_pb2.GenericResult.GENERIC_STATUS_MEMORY_MANAGER_EVICTION,
+            ):
                 if result.exception:
                     raise ImageBuildError(
                         f"Image build for {image_id} failed with the exception:\n{result.exception}", image_id
@@ -2751,9 +2754,9 @@ class _Image(_Object, type_prefix="im"):
             # It may be possible to support lambdas eventually, but for now we don't handle them well, so reject quickly
             raise InvalidError("Image.run_function does not support lambda functions.")
 
-        info = FunctionInfo(raw_f)
+        info = FunctionSourceInfo(raw_f)
 
-        function = _Function.from_local(
+        function = _Function._from_local(
             info,
             app=None,
             image=self,
@@ -2935,7 +2938,7 @@ class _Image(_Object, type_prefix="im"):
         try:
             yield
         except Exception as exc:
-            if not self.is_hydrated:
+            if not self._is_hydrated:
                 # Might be hydrated later (if it's the container's used image)
                 self.inside_exceptions.append(exc)
             elif env_image_id == self.object_id:
@@ -3048,7 +3051,7 @@ class _Image(_Object, type_prefix="im"):
         """mdmd:hidden"""
         # Image inherits hydrate() from Object but can't be hydrated on demand
         # Overriding the method lets us hide it from the docs and raise a better error message
-        if not self.is_hydrated:
+        if not self._is_hydrated:
             raise ExecutionError(
                 "Images cannot currently be hydrated on demand; you can build an Image by running an App that uses it."
             )