modAL 1.2.1__tar.gz → 1.2.1.dev0__tar.gz

{modal-1.2.1 → modal-1.2.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.1
+Version: 1.2.1.dev0
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0
@@ -32,14 +32,14 @@ Requires-Dist: watchfiles
 Requires-Dist: typing_extensions~=4.6
 Dynamic: license-file
 
-# Modal Python SDK
+# Modal Python Library
 
 [![PyPI Version](https://img.shields.io/pypi/v/modal.svg)](https://pypi.org/project/modal/)
 [![License](https://img.shields.io/badge/license-apache_2.0-darkviolet.svg)](https://github.com/modal-labs/modal-client/blob/master/LICENSE)
 [![Tests](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml)
 [![Slack](https://img.shields.io/badge/slack-join-blue.svg?logo=slack)](https://modal.com/slack)
 
-The [Modal](https://modal.com/) Python SDK provides convenient, on-demand
+The [Modal](https://modal.com/) Python library provides convenient, on-demand
 access to serverless cloud compute from Python scripts on your local computer.
 
 ## Documentation
@@ -53,10 +53,10 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 **This library requires Python 3.9 – 3.13.**
 
-Install the package with `uv` or `pip`:
+Install the package with `pip`:
 
 ```bash
-uv pip install modal
+pip install modal
 ```
 
 You can create a Modal account (or link your existing one) directly on the

{modal-1.2.1 → modal-1.2.1.dev0}/README.md

@@ -1,11 +1,11 @@
-# Modal Python SDK
+# Modal Python Library
 
 [![PyPI Version](https://img.shields.io/pypi/v/modal.svg)](https://pypi.org/project/modal/)
 [![License](https://img.shields.io/badge/license-apache_2.0-darkviolet.svg)](https://github.com/modal-labs/modal-client/blob/master/LICENSE)
 [![Tests](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml)
 [![Slack](https://img.shields.io/badge/slack-join-blue.svg?logo=slack)](https://modal.com/slack)
 
-The [Modal](https://modal.com/) Python SDK provides convenient, on-demand
+The [Modal](https://modal.com/) Python library provides convenient, on-demand
 access to serverless cloud compute from Python scripts on your local computer.
 
 ## Documentation
@@ -19,10 +19,10 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 **This library requires Python 3.9 – 3.13.**
 
-Install the package with `uv` or `pip`:
+Install the package with `pip`:
 
 ```bash
-uv pip install modal
+pip install modal
 ```
 
 You can create a Modal account (or link your existing one) directly on the

{modal-1.2.1 → modal-1.2.1.dev0}/modal/_container_entrypoint.py

@@ -450,10 +450,7 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                     f"Function has {len(service.service_deps)} dependencies"
                     f" but container got {len(dep_object_ids)} object ids.\n"
                     f"Code deps: {service.service_deps}\n"
-                    f"Object ids: {dep_object_ids}\n"
-                    "\n"
-                    "This can happen if you are defining Modal objects under a conditional statement "
-                    "that evaluates differently in the local and remote environments."
+                    f"Object ids: {dep_object_ids}"
                 )
             for object_id, obj in zip(dep_object_ids, service.service_deps):
                 metadata: Message = container_app.object_handle_metadata[object_id]

{modal-1.2.1 → modal-1.2.1.dev0}/modal/_partial_function.py

@@ -19,7 +19,7 @@ from ._functions import _Function
 from ._utils.async_utils import synchronizer
 from ._utils.deprecation import deprecation_warning
 from ._utils.function_utils import callable_has_non_self_params
-from .config import config, logger
+from .config import logger
 from .exception import InvalidError
 
 MAX_MAX_BATCH_SIZE = 1000
@@ -93,26 +93,6 @@ NullaryFuncOrMethod = Union[Callable[[], Any], Callable[[Any], Any]]
 NullaryMethod = Callable[[Any], Any]
 
 
-def verify_concurrent_params(params: _PartialFunctionParams, is_flash: bool = False) -> None:
-    def _verify_concurrent_params_with_flash_settings(params: _PartialFunctionParams) -> None:
-        if params.max_concurrent_inputs is not None:
-            raise TypeError(
-                "@modal.concurrent(max_inputs=...) is not yet supported for Flash functions. "
-                "Use `@modal.concurrent(target_inputs=...)` instead."
-            )
-        if params.target_concurrent_inputs is None:
-            raise TypeError("`@modal.concurrent()` missing required argument: `target_inputs`.")
-
-    def _verify_concurrent_params(params: _PartialFunctionParams) -> None:
-        if params.max_concurrent_inputs is None:
-            raise TypeError("`@modal.concurrent()` missing required argument: `max_inputs`.")
-
-    if is_flash:
-        _verify_concurrent_params_with_flash_settings(params)
-    else:
-        _verify_concurrent_params(params)
-
-
 class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
     """Object produced by a decorator in the `modal` namespace
 
@@ -398,7 +378,6 @@ def _fastapi_endpoint(
         method=method,
         web_endpoint_docs=docs,
         requested_suffix=label or "",
-        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         requires_proxy_auth=requires_proxy_auth,
@@ -467,7 +446,6 @@ def _web_endpoint(
         method=method,
         web_endpoint_docs=docs,
         requested_suffix=label or "",
-        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         requires_proxy_auth=requires_proxy_auth,
@@ -527,7 +505,6 @@ def _asgi_app(
     webhook_config = api_pb2.WebhookConfig(
         type=api_pb2.WEBHOOK_TYPE_ASGI_APP,
         requested_suffix=label or "",
-        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         requires_proxy_auth=requires_proxy_auth,
@@ -585,7 +562,6 @@ def _wsgi_app(
     webhook_config = api_pb2.WebhookConfig(
         type=api_pb2.WEBHOOK_TYPE_WSGI_APP,
         requested_suffix=label or "",
-        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         requires_proxy_auth=requires_proxy_auth,
@@ -647,7 +623,6 @@ def _web_server(
     webhook_config = api_pb2.WebhookConfig(
         type=api_pb2.WEBHOOK_TYPE_WEB_SERVER,
         requested_suffix=label or "",
-        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         web_server_port=port,
@@ -785,7 +760,7 @@ def _batched(
 def _concurrent(
     _warn_parentheses_missing=None,  # mdmd:line-hidden
     *,
-    max_inputs: Optional[int] = None,  # Hard limit on each container's input concurrency
+    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[P, ReturnType], _PartialFunction[P, ReturnType, ReturnType]]],
@@ -837,7 +812,7 @@ def _concurrent(
             "Positional arguments are not allowed. Did you forget parentheses? Suggestion: `@modal.concurrent()`."
         )
 
-    if max_inputs is not None and target_inputs is not None and target_inputs > max_inputs:
+    if target_inputs and target_inputs > max_inputs:
         raise InvalidError("`target_inputs` parameter cannot be greater than `max_inputs`.")
 
     flags = _PartialFunctionFlags.CONCURRENT

{modal-1.2.1 → modal-1.2.1.dev0}/modal/_utils/function_utils.py

@@ -75,10 +75,6 @@ def is_global_object(object_qual_name: str):
     return "<locals>" not in object_qual_name.split(".")
 
 
-def is_flash_object(experimental_options: Optional[dict[str, Any]]) -> bool:
-    return experimental_options.get("flash", False) if experimental_options else False
-
-
 def is_method_fn(object_qual_name: str):
     # methods have names like Cls.foo.
     if "<locals>" in object_qual_name:

{modal-1.2.1 → modal-1.2.1.dev0}/modal/app.py

@@ -2,7 +2,6 @@
 import inspect
 import typing
 from collections.abc import AsyncGenerator, Collection, Coroutine, Mapping, Sequence
-from dataclasses import dataclass
 from pathlib import PurePosixPath
 from textwrap import dedent
 from typing import (
@@ -27,14 +26,13 @@ from ._partial_function import (
     _find_partial_methods_for_user_cls,
     _PartialFunction,
     _PartialFunctionFlags,
-    verify_concurrent_params,
 )
 from ._utils.async_utils import synchronize_api
 from ._utils.deprecation import (
     deprecation_warning,
     warn_on_renamed_autoscaler_settings,
 )
-from ._utils.function_utils import FunctionInfo, is_flash_object, is_global_object, is_method_fn
+from ._utils.function_utils import FunctionInfo, is_global_object, is_method_fn
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_volumes
 from ._utils.name_utils import check_object_name, check_tag_dict
@@ -116,22 +114,6 @@ class _FunctionDecoratorType:
     def __call__(self, func): ...
 
 
-@dataclass()
-class _LocalAppState:
-    """All state for apps that's part of the local/definition state"""
-
-    functions: dict[str, _Function]
-    classes: dict[str, _Cls]
-    image_default: Optional[_Image]
-    web_endpoints: list[str]  # Used by the CLI
-    local_entrypoints: dict[str, _LocalEntrypoint]
-    tags: dict[str, str]
-
-    include_source_default: bool
-    secrets_default: Sequence[_Secret]
-    volumes_default: dict[Union[str, PurePosixPath], _Volume]
-
-
 class _App:
     """A Modal App is a group of functions and classes that are deployed together.
 
@@ -169,21 +151,23 @@ class _App:
 
     _name: Optional[str]
     _description: Optional[str]
+    _tags: dict[str, str]
+
+    _functions: dict[str, _Function]
+    _classes: dict[str, _Cls]
 
-    _local_state_attr: Optional[_LocalAppState] = None
+    _image: Optional[_Image]
+    _secrets: Sequence[_Secret]
+    _volumes: dict[Union[str, PurePosixPath], _Volume]
+    _web_endpoints: list[str]  # Used by the CLI
+    _local_entrypoints: dict[str, _LocalEntrypoint]
 
     # Running apps only (container apps or running local)
     _app_id: Optional[str]  # Kept after app finishes
     _running_app: Optional[RunningApp]  # Various app info
     _client: Optional[_Client]
 
-    @property
-    def _local_state(self) -> _LocalAppState:
-        """For internal use only. Do not use this property directly."""
-
-        if self._local_state_attr is None:
-            raise AttributeError("Local state is not initialized - app is not locally available")
-        return self._local_state_attr
+    _include_source_default: Optional[bool] = None
 
     def __init__(
         self,
@@ -212,6 +196,8 @@ class _App:
 
         self._name = name
         self._description = name
+        self._tags = tags or {}
+        self._include_source_default = include_source
 
         check_sequence(secrets, _Secret, "`secrets=` has to be a list or tuple of `modal.Secret` objects")
         validate_volumes(volumes)
@@ -219,24 +205,16 @@ class _App:
         if image is not None and not isinstance(image, _Image):
             raise InvalidError("`image=` has to be a `modal.Image` object")
 
-        self._local_state_attr = _LocalAppState(
-            functions={},
-            classes={},
-            image_default=image,
-            secrets_default=secrets,
-            volumes_default=volumes,
-            include_source_default=include_source,
-            web_endpoints=[],
-            local_entrypoints={},
-            tags=tags or {},
-        )
+        self._functions = {}
+        self._classes = {}
+        self._image = image
+        self._secrets = secrets
+        self._volumes = volumes
+        self._local_entrypoints = {}
+        self._web_endpoints = []
 
-        # Running apps only
         self._app_id = None
         self._running_app = None  # Set inside container, OR during the time an app is running locally
-
-        # Client is special - needed to be set just before the app is "hydrated" or running at the latest
-        # Guaranteed to be set for running apps, but also needed to actually *hydrate* the app and make it running
         self._client = None
 
         # Register this app. This is used to look up the app in the container, when we can't get it from the function
@@ -305,8 +283,7 @@ class _App:
 
         response = await retry_transient_errors(client.stub.AppGetOrCreate, request)
 
-        app = _App(name)  # TODO: this should probably be a distinct constructor, possibly even a distinct type
-        app._local_state_attr = None  # this is not a locally defined App, so no local state
+        app = _App(name)
         app._app_id = response.app_id
         app._client = client
         app._running_app = RunningApp(response.app_id, interactive=False)
@@ -333,19 +310,18 @@ class _App:
         App that is retrieved via `modal.App.lookup`. It is likely to be deprecated in the future.
 
         """
-        return self._local_state.image_default
+        return self._image
 
     @image.setter
     def image(self, value):
         """mdmd:hidden"""
-        self._local_state.image_default = value
+        self._image = value
 
     def _uncreate_all_objects(self):
         # TODO(erikbern): this doesn't unhydrate objects that aren't tagged
-        local_state = self._local_state
-        for obj in local_state.functions.values():
+        for obj in self._functions.values():
             obj._unhydrate()
-        for obj in local_state.classes.values():
+        for obj in self._classes.values():
             obj._unhydrate()
 
     @asynccontextmanager
@@ -481,9 +457,8 @@ class _App:
         return self
 
     def _get_default_image(self):
-        local_state = self._local_state
-        if local_state.image_default:
-            return local_state.image_default
+        if self._image:
+            return self._image
         else:
             return _default_image
 
@@ -498,8 +473,7 @@ class _App:
         return [m for m in all_mounts if m.is_local()]
 
     def _add_function(self, function: _Function, is_web_endpoint: bool):
-        local_state = self._local_state
-        if old_function := local_state.functions.get(function.tag, None):
+        if old_function := self._functions.get(function.tag, None):
             if old_function is function:
                 return  # already added the same exact instance, ignore
 
@@ -510,7 +484,7 @@ class _App:
                     f"[{old_function._info.module_name}].{old_function._info.function_name}"
                     f" with new function [{function._info.module_name}].{function._info.function_name}"
                 )
-        if function.tag in local_state.classes:
+        if function.tag in self._classes:
             logger.warning(f"Warning: tag {function.tag} exists but is overridden by function")
 
         if self._running_app:
@@ -521,9 +495,9 @@ class _App:
                 metadata: Message = self._running_app.object_handle_metadata[object_id]
                 function._hydrate(object_id, self._client, metadata)
 
-        local_state.functions[function.tag] = function
+        self._functions[function.tag] = function
         if is_web_endpoint:
-            local_state.web_endpoints.append(function.tag)
+            self._web_endpoints.append(function.tag)
 
     def _add_class(self, tag: str, cls: _Cls):
         if self._running_app:
@@ -534,7 +508,7 @@ class _App:
                 metadata: Message = self._running_app.object_handle_metadata[object_id]
                 cls._hydrate(object_id, self._client, metadata)
 
-        self._local_state.classes[tag] = cls
+        self._classes[tag] = cls
 
     def _init_container(self, client: _Client, running_app: RunningApp):
         self._app_id = running_app.app_id
@@ -542,18 +516,18 @@ class _App:
         self._client = client
 
         _App._container_app = self
-        local_state = self._local_state
+
         # Hydrate function objects
         for tag, object_id in running_app.function_ids.items():
-            if tag in local_state.functions:
-                obj = local_state.functions[tag]
+            if tag in self._functions:
+                obj = self._functions[tag]
                 handle_metadata = running_app.object_handle_metadata[object_id]
                 obj._hydrate(object_id, client, handle_metadata)
 
         # Hydrate class objects
         for tag, object_id in running_app.class_ids.items():
-            if tag in local_state.classes:
-                obj = local_state.classes[tag]
+            if tag in self._classes:
+                obj = self._classes[tag]
                 handle_metadata = running_app.object_handle_metadata[object_id]
                 obj._hydrate(object_id, client, handle_metadata)
 
@@ -567,7 +541,7 @@ class _App:
         This method is likely to be deprecated in the future in favor of a different
         approach for retrieving the layout of a deployed App.
         """
-        return self._local_state.functions
+        return self._functions
 
     @property
     def registered_classes(self) -> dict[str, _Cls]:
@@ -579,7 +553,7 @@ class _App:
         This method is likely to be deprecated in the future in favor of a different
         approach for retrieving the layout of a deployed App.
         """
-        return self._local_state.classes
+        return self._classes
 
     @property
     def registered_entrypoints(self) -> dict[str, _LocalEntrypoint]:
@@ -590,7 +564,7 @@ class _App:
         expected to work when a deplyoed App has been retrieved via `modal.App.lookup`.
         This method is likely to be deprecated in the future.
         """
-        return self._local_state.local_entrypoints
+        return self._local_entrypoints
 
     @property
     def registered_web_endpoints(self) -> list[str]:
@@ -602,7 +576,7 @@ class _App:
         This method is likely to be deprecated in the future in favor of a different
         approach for retrieving the layout of a deployed App.
         """
-        return self._local_state.web_endpoints
+        return self._web_endpoints
 
     def local_entrypoint(
         self, _warn_parentheses_missing: Any = None, *, name: Optional[str] = None
@@ -663,11 +637,10 @@ class _App:
         def wrapped(raw_f: Callable[..., Any]) -> _LocalEntrypoint:
             info = FunctionInfo(raw_f)
             tag = name if name is not None else raw_f.__qualname__
-            local_state = self._local_state
-            if tag in local_state.local_entrypoints:
+            if tag in self._local_entrypoints:
                 # TODO: get rid of this limitation.
                 raise InvalidError(f"Duplicate local entrypoint name: {tag}. Local entrypoint names must be unique.")
-            entrypoint = local_state.local_entrypoints[tag] = _LocalEntrypoint(info, self)
+            entrypoint = self._local_entrypoints[tag] = _LocalEntrypoint(info, self)
             return entrypoint
 
         return wrapped
@@ -759,8 +732,7 @@ class _App:
         secrets = secrets or []
         if env:
             secrets = [*secrets, _Secret.from_dict(env)]
-        local_state = self._local_state
-        secrets = [*local_state.secrets_default, *secrets]
+        secrets = [*self._secrets, *secrets]
 
         def wrapped(
             f: Union[_PartialFunction, Callable[..., Any], None],
@@ -803,7 +775,6 @@ class _App:
                 batch_max_size = f.params.batch_max_size
                 batch_wait_ms = f.params.batch_wait_ms
                 if f.flags & _PartialFunctionFlags.CONCURRENT:
-                    verify_concurrent_params(params=f.params, is_flash=is_flash_object(experimental_options))
                     max_concurrent_inputs = f.params.max_concurrent_inputs
                     target_concurrent_inputs = f.params.target_concurrent_inputs
                 else:
@@ -869,7 +840,7 @@ class _App:
                 is_generator=is_generator,
                 gpu=gpu,
                 network_file_systems=network_file_systems,
-                volumes={**local_state.volumes_default, **volumes},
+                volumes={**self._volumes, **volumes},
                 cpu=cpu,
                 memory=memory,
                 ephemeral_disk=ephemeral_disk,
@@ -895,7 +866,7 @@ class _App:
                 i6pn_enabled=i6pn_enabled,
                 cluster_size=cluster_size,  # Experimental: Clustered functions
                 rdma=rdma,
-                include_source=include_source if include_source is not None else local_state.include_source_default,
+                include_source=include_source if include_source is not None else self._include_source_default,
                 experimental_options={k: str(v) for k, v in (experimental_options or {}).items()},
                 _experimental_proxy_ip=_experimental_proxy_ip,
                 restrict_output=_experimental_restrict_output,
@@ -992,13 +963,11 @@ class _App:
             secrets = [*secrets, _Secret.from_dict(env)]
 
         def wrapper(wrapped_cls: Union[CLS_T, _PartialFunction]) -> CLS_T:
-            local_state = self._local_state
             # Check if the decorated object is a class
             if isinstance(wrapped_cls, _PartialFunction):
                 wrapped_cls.registered = True
                 user_cls = wrapped_cls.user_cls
                 if wrapped_cls.flags & _PartialFunctionFlags.CONCURRENT:
-                    verify_concurrent_params(params=wrapped_cls.params, is_flash=is_flash_object(experimental_options))
                     max_concurrent_inputs = wrapped_cls.params.max_concurrent_inputs
                     target_concurrent_inputs = wrapped_cls.params.target_concurrent_inputs
                 else:
@@ -1060,10 +1029,10 @@ class _App:
                 info,
                 app=self,
                 image=image or self._get_default_image(),
-                secrets=[*local_state.secrets_default, *secrets],
+                secrets=[*self._secrets, *secrets],
                 gpu=gpu,
                 network_file_systems=network_file_systems,
-                volumes={**local_state.volumes_default, **volumes},
+                volumes={**self._volumes, **volumes},
                 cpu=cpu,
                 memory=memory,
                 ephemeral_disk=ephemeral_disk,
@@ -1088,7 +1057,7 @@ class _App:
                 i6pn_enabled=i6pn_enabled,
                 cluster_size=cluster_size,
                 rdma=rdma,
-                include_source=include_source if include_source is not None else local_state.include_source_default,
+                include_source=include_source if include_source is not None else self._include_source_default,
                 experimental_options={k: str(v) for k, v in (experimental_options or {}).items()},
                 _experimental_proxy_ip=_experimental_proxy_ip,
                 _experimental_custom_scaling_factor=_experimental_custom_scaling_factor,
@@ -1098,11 +1067,6 @@ class _App:
             self._add_function(cls_func, is_web_endpoint=False)
 
             cls: _Cls = _Cls.from_local(user_cls, self, cls_func)
-            for method_name, partial_function in cls._method_partials.items():
-                if partial_function.params.webhook_config is not None:
-                    full_name = f"{user_cls.__name__}.{method_name}"
-                    local_state.web_endpoints.append(full_name)
-                partial_function.registered = True
 
             tag: str = user_cls.__name__
             self._add_class(tag, cls)
@@ -1138,14 +1102,11 @@ class _App:
         (with this App's tags taking precedence in the case of conflicts).
 
         """
-        other_app_local_state = other_app._local_state
-        this_local_state = self._local_state
-
-        for tag, function in other_app_local_state.functions.items():
+        for tag, function in other_app._functions.items():
             self._add_function(function, False)  # TODO(erikbern): webhook config?
 
-        for tag, cls in other_app_local_state.classes.items():
-            existing_cls = this_local_state.classes.get(tag)
+        for tag, cls in other_app._classes.items():
+            existing_cls = self._classes.get(tag)
             if existing_cls and existing_cls != cls:
                 logger.warning(
                     f"Named app class {tag} with existing value {existing_cls} is being "
@@ -1155,7 +1116,7 @@ class _App:
             self._add_class(tag, cls)
 
         if inherit_tags:
-            this_local_state.tags = {**other_app_local_state.tags, **this_local_state.tags}
+            self._tags = {**other_app._tags, **self._tags}
 
         return self
 
@@ -1171,7 +1132,7 @@ class _App:
 
         """
         # Note that we are requiring the App to be "running" before we set the tags.
-        # Alternatively, we could hold onto the tags (i.e. in `self._local_state.tags`) and then pass
+        # Alternatively, we could hold onto the tags (i.e. in `self._tags`) and then pass
         # then up when AppPublish gets called. I'm not certain we want to support it, though.
         # It might not be obvious to users that `.set_tags()` is eager and has immediate effect
         # when the App is running, but lazy (and potentially ignored) otherwise. There would be

{modal-1.2.1 → modal-1.2.1.dev0}/modal/app.pyi

@@ -74,42 +74,6 @@ class _FunctionDecoratorType:
         self, func: collections.abc.Callable[P, ReturnType]
     ) -> modal.functions.Function[P, ReturnType, ReturnType]: ...
 
-class _LocalAppState:
-    """All state for apps that's part of the local/definition state"""
-
-    functions: dict[str, modal._functions._Function]
-    classes: dict[str, modal.cls._Cls]
-    image_default: typing.Optional[modal.image._Image]
-    web_endpoints: list[str]
-    local_entrypoints: dict[str, _LocalEntrypoint]
-    tags: dict[str, str]
-    include_source_default: bool
-    secrets_default: collections.abc.Sequence[modal.secret._Secret]
-    volumes_default: dict[typing.Union[str, pathlib.PurePosixPath], modal.volume._Volume]
-
-    def __init__(
-        self,
-        functions: dict[str, modal._functions._Function],
-        classes: dict[str, modal.cls._Cls],
-        image_default: typing.Optional[modal.image._Image],
-        web_endpoints: list[str],
-        local_entrypoints: dict[str, _LocalEntrypoint],
-        tags: dict[str, str],
-        include_source_default: bool,
-        secrets_default: collections.abc.Sequence[modal.secret._Secret],
-        volumes_default: dict[typing.Union[str, pathlib.PurePosixPath], modal.volume._Volume],
-    ) -> None:
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    def __repr__(self):
-        """Return repr(self)."""
-        ...
-
-    def __eq__(self, other):
-        """Return self==value."""
-        ...
-
 class _App:
     """A Modal App is a group of functions and classes that are deployed together.
 
@@ -146,15 +110,18 @@ class _App:
     _container_app: typing.ClassVar[typing.Optional[_App]]
     _name: typing.Optional[str]
     _description: typing.Optional[str]
-    _local_state_attr: typing.Optional[_LocalAppState]
+    _tags: dict[str, str]
+    _functions: dict[str, modal._functions._Function]
+    _classes: dict[str, modal.cls._Cls]
+    _image: typing.Optional[modal.image._Image]
+    _secrets: collections.abc.Sequence[modal.secret._Secret]
+    _volumes: dict[typing.Union[str, pathlib.PurePosixPath], modal.volume._Volume]
+    _web_endpoints: list[str]
+    _local_entrypoints: dict[str, _LocalEntrypoint]
     _app_id: typing.Optional[str]
     _running_app: typing.Optional[modal.running_app.RunningApp]
     _client: typing.Optional[modal.client._Client]
-
-    @property
-    def _local_state(self) -> _LocalAppState:
-        """For internal use only. Do not use this property directly."""
-        ...
+    _include_source_default: typing.Optional[bool]
 
     def __init__(
         self,
@@ -663,10 +630,18 @@ class App:
     _container_app: typing.ClassVar[typing.Optional[App]]
     _name: typing.Optional[str]
     _description: typing.Optional[str]
-    _local_state_attr: typing.Optional[_LocalAppState]
+    _tags: dict[str, str]
+    _functions: dict[str, modal.functions.Function]
+    _classes: dict[str, modal.cls.Cls]
+    _image: typing.Optional[modal.image.Image]
+    _secrets: collections.abc.Sequence[modal.secret.Secret]
+    _volumes: dict[typing.Union[str, pathlib.PurePosixPath], modal.volume.Volume]
+    _web_endpoints: list[str]
+    _local_entrypoints: dict[str, LocalEntrypoint]
     _app_id: typing.Optional[str]
     _running_app: typing.Optional[modal.running_app.RunningApp]
     _client: typing.Optional[modal.client.Client]
+    _include_source_default: typing.Optional[bool]
 
     def __init__(
         self,
@@ -689,11 +664,6 @@ class App:
         """
         ...
 
-    @property
-    def _local_state(self) -> _LocalAppState:
-        """For internal use only. Do not use this property directly."""
-        ...
-
     @property
     def name(self) -> typing.Optional[str]:
         """The user-provided name of the App."""