modAL 1.5.5__tar.gz → 1.5.5.dev1__tar.gz

{modal-1.5.5 → modal-1.5.5.dev1}/PKG-INFO

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

{modal-1.5.5 → modal-1.5.5.dev1}/modal/_container_entrypoint.py

@@ -145,7 +145,7 @@ def call_function(
                             item_count += 1
 
                 await container_io_manager._send_outputs.aio(
-                    io_context, io_context.output_items_generator_done(started_at, item_count)
+                    io_context.output_items_generator_done(started_at, item_count)
                 )
             else:
                 value = await io_context.call_function_async()
@@ -182,9 +182,7 @@ def call_function(
                         container_io_manager._queue_put(generator_queue, value)
                         item_count += 1
 
-                container_io_manager._send_outputs(
-                    io_context, io_context.output_items_generator_done(started_at, item_count)
-                )
+                container_io_manager._send_outputs(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.5 → modal-1.5.5.dev1}/modal/_environments.py

@@ -39,7 +39,6 @@ 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:
@@ -52,11 +51,8 @@ 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)
@@ -120,12 +116,9 @@ class _EnvironmentRolesManager:
         """mdmd:hidden"""
         self._environment = environment
 
-    async def list(self, *, exclude_default: bool = False) -> dict[Literal["users", "service_users"], dict[str, str]]:
+    async def list(self) -> 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
@@ -144,8 +137,6 @@ 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:
@@ -261,8 +252,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; assign a role (e.g. 'no-access') with "
-            "`Environment.roles.update()` instead.",
+            "`Environment.members.remove()` is deprecated. Environment Roles are now explicit; "
+            "set a role (e.g. 'no-access') with `Environment.roles.update()` instead.",
         )
         await self._environment.hydrate()
         users = users or []
@@ -478,7 +469,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(
@@ -549,7 +540,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.5 → modal-1.5.5.dev1}/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._source_info = base_function._source_info
+    fun._info = base_function._info
     fun._spec = base_function._spec  # TODO (elias): fix - this is incorrect when using with_options
     return fun

{modal-1.5.5 → modal-1.5.5.dev1}/modal/_functions.py

@@ -46,11 +46,10 @@ 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,
-    FunctionSourceInfo,
+    FunctionInfo,
     _create_input,
     _parse_retries,
     _process_result,
@@ -604,7 +603,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     """
 
     # TODO: more type annotations
-    _source_info: FunctionSourceInfo | None
+    _info: FunctionInfo | 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
@@ -664,8 +663,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return _FunctionLogsManager(self)
 
     @staticmethod
-    def _from_local(
-        info: FunctionSourceInfo,
+    def from_local(
+        info: FunctionInfo,
         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,
@@ -938,7 +937,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
@@ -1111,7 +1110,6 @@ 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 = []
@@ -1165,12 +1163,10 @@ 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 = _Function._from_loader(
-            _load, rep, preload=_preload, deps=_deps, load_context_overrides=load_context
-        )
+        obj = _Function._from_loader(_load, rep, preload=_preload, deps=_deps, load_context_overrides=load_context)
 
         obj._raw_f = info.raw_f
-        obj._source_info = info
+        obj._info = info
         obj._tag = tag
         obj._app = app  # needed for CLI right now
         obj._obj = None
@@ -1195,12 +1191,6 @@ 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,
         *,
@@ -1393,16 +1383,8 @@ 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
 
@@ -1415,40 +1397,20 @@ 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
-    @with_deprecation_warning(
-        (2026, 8, 26),
-        "`Function.info` is deprecated and will be removed in `modal` version 1.6.0",
-    )
-    def info(self) -> FunctionSourceInfo:
+    def info(self) -> FunctionInfo:
         """mdmd:hidden"""
-        return self._source_info_
+        assert self._info
+        return self._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
 
@@ -1456,19 +1418,13 @@ 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):
@@ -1477,7 +1433,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._is_generator = None
         self._web_url = None
         self._function_name = None
-        self._source_info = None
+        self._info = None
         self._serve_mounts = frozenset()
         self._metadata = None
         self._experimental_flash_urls = None
@@ -1609,7 +1565,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         new_function._webhook_config = self._webhook_config
 
         # Other fields not necessarily initialized
-        if self._source_info is not None:
+        if self._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
@@ -1716,16 +1672,8 @@ 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:
@@ -1915,12 +1863,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             yield item
 
     def _is_local(self):
-        return self._source_info is not None
+        return self._info is not None
 
-    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_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_obj(self) -> "modal.cls._Obj | None":
         if not self._is_method:
@@ -1955,13 +1903,13 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             )
             raise ExecutionError(msg)
 
-        info = self._get_source_info()
+        info = self._get_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"
@@ -2059,20 +2007,12 @@ 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
 

{modal-1.5.5 → modal-1.5.5.dev1}/modal/_image.py

@@ -41,7 +41,7 @@ from ._utils.docker_utils import (
     extract_copy_command_patterns,
     find_dockerignore_file,
 )
-from ._utils.function_utils import FunctionSourceInfo, parse_gpu_config
+from ._utils.function_utils import FunctionInfo, 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_source_info().get_globals()
-                attrs = build_function._get_source_info().get_cls_var_attrs()
+                globals = build_function._get_info().get_globals()
+                attrs = build_function._get_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_source_info().function_name}. "
+                            f"{build_function._get_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,
                 )
@@ -2754,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 = FunctionSourceInfo(raw_f)
+        info = FunctionInfo(raw_f)
 
-        function = _Function._from_local(
+        function = _Function.from_local(
             info,
             app=None,
             image=self,
@@ -2938,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:
@@ -3051,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."
             )

{modal-1.5.5 → modal-1.5.5.dev1}/modal/_logs_manager.py

@@ -93,8 +93,6 @@ def _entry_context_ids(object_id: str, item: api_pb2.TaskLogs, batch: api_pb2.Ta
             ]
         case "fc":
             context_ids = [item.input_id or batch.input_id, item.container_id or batch.task_id]
-        case "sb":
-            context_ids = [item.container_id or batch.task_id]
         case _:
             context_ids = []
     # filter for empty strings, can happen for Server which have function_ids but no input/container
@@ -804,71 +802,6 @@ class _ImageLogsManager:
 ImageLogsManager = synchronize_api(_ImageLogsManager, target_module=__name__)
 
 
-class _SandboxLogsManager:
-    """mdmd:namespace"""
-
-    def __init__(self, source: _SupportsLogs):
-        """mdmd:hidden"""
-        self._manager = _LogsManager(source)
-
-    async def fetch(
-        self,
-        *,
-        since: datetime,
-        until: datetime | None = None,
-        source: LogSource | None = None,
-        search_text: str = "",
-    ) -> AsyncGenerator[LogEntry, None]:
-        """Fetch Sandbox logs corresponding to the date range and filters.
-
-        Args:
-            since: Start date to fetch logs from. Must be in UTC or timezone-naive,
-                which is interpreted as local time.
-            until: Defaults to current date if None. Must be in UTC or timezone-naive, which is interpreted
-                as local time.
-            source: Filter by source: 'stdout', 'stderr', or 'system'.
-            search_text: Filter by search text.
-
-        Yields:
-            `LogEntry` objects in chronological order.
-
-        Examples:
-
-            ```python notest
-            sandbox = modal.Sandbox.from_name("my-app", "sandbox")
-
-            for entry in sandbox.logs.fetch(
-                since=datetime.now() - timedelta(minutes=25),
-                source="stdout",
-            ):
-                print(entry.message, end="")
-            ```
-        """
-        async for log_entry in self._manager.fetch(since=since, until=until, source=source, search_text=search_text):
-            yield log_entry
-
-    async def tail(
-        self,
-        entries: int = 100,
-        *,
-        source: LogSource | None = None,
-    ) -> AsyncGenerator[LogEntry, None]:
-        """Fetch the most recent Sandbox logs.
-
-        Args:
-            entries: The number of log entries to return.
-            source: Filter by source: 'stdout', 'stderr', or 'system'.
-
-        Yields:
-            `LogEntry` objects in chronological order.
-        """
-        async for log_entry in self._manager.tail(entries, source=source):
-            yield log_entry
-
-
-SandboxLogsManager = synchronize_api(_SandboxLogsManager, target_module=__name__)
-
-
 class _AppLogsManager:
     """mdmd:namespace"""