A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
refactor: typesafe app-state (#7627)
Myles Scolnickb02a3fddb4c5
diff --git a/marimo/_server/api/deps.py b/marimo/_server/api/deps.pyindex af66c3cba2..d0d9c75b56 100644--- a/marimo/_server/api/deps.py+++ b/marimo/_server/api/deps.py@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Optional, Union, castfrom marimo import _loggers as loggersfrom marimo._config.manager import MarimoConfigManager, ScriptConfigManager+from marimo._server.config import StarletteServerStatefrom marimo._server.session_manager import SessionManagerfrom marimo._server.tokens import SkewProtectionTokenfrom marimo._session.model import SessionMode@@ -14,7 +15,6 @@ if TYPE_CHECKING:from starlette.applications import Starlettefrom starlette.datastructures import Statefrom starlette.requests import Request- from starlette.types import ASGIAppfrom starlette.websockets import WebSocketfrom uvicorn import Server@@ -38,11 +38,11 @@ class AppStateBase:def __init__(self, state: State) -> None:"""Initialize the app state."""- self.state = state+ self.state = cast(StarletteServerState, state)@propertydef session_manager(self) -> SessionManager:- return cast(SessionManager, self.state.session_manager)+ return self.state.session_manager@propertydef mode(self) -> SessionMode:@@ -50,52 +50,39 @@ class AppStateBase:@propertydef quiet(self) -> bool:- return self.session_manager.quiet+ return self.state.quiet@propertydef host(self) -> str:- host: str = self.state.host- return host+ return self.state.host@propertydef port(self) -> int:- post: int = self.state.port- return post+ return self.state.port@propertydef maybe_port(self) -> Optional[int]:- return self.state._state.get("port")+ return getattr(self.state, "port", None)@propertydef base_url(self) -> str:- base_url: str = self.state.base_url- return base_url+ return self.state.base_url@propertydef server(self) -> Server:- server: Server = self.state.server- return server+ return self.state.server@propertydef config_manager(self) -> MarimoConfigManager:- cm = self.state.config_manager- assert isinstance(cm, MarimoConfigManager)- return cm-- @property- def watch(self) -> bool:- watch: bool = self.state.watch- return watch+ return self.state.config_manager@propertydef headless(self) -> bool:- headless: bool = self.state.headless- return headless+ return self.state.headless@propertydef skew_protection(self) -> bool:- skew_protection: bool = self.state.skew_protection- return skew_protection+ return self.state.skew_protection@propertydef skew_protection_token(self) -> SkewProtectionToken:@@ -103,24 +90,25 @@ class AppStateBase:@propertydef remote_url(self) -> Optional[str]:- return getattr(self.state, "remote_url", None)+ if hasattr(self.state, "remote_url"):+ return self.state.remote_url+ return None@propertydef mcp_server_enabled(self) -> bool:- mcp_server_enabled: bool = self.state.mcp_server_enabled- return mcp_server_enabled-- @property- def mcp_handler(self) -> Optional[ASGIApp]:- return getattr(self.state, "mcp_handler", None)+ return self.state.mcp_server_enabled@propertydef asset_url(self) -> Optional[str]:- return getattr(self.state, "asset_url", None)+ if hasattr(self.state, "asset_url"):+ return self.state.asset_url+ return None@propertydef enable_auth(self) -> bool:- return getattr(self.state, "enable_auth", True)+ if hasattr(self.state, "enable_auth"):+ return self.state.enable_auth+ return Trueclass AppState(AppStateBase):diff --git a/marimo/_server/config.py b/marimo/_server/config.pynew file mode 100644index 0000000000..5c4c347600--- /dev/null+++ b/marimo/_server/config.py@@ -0,0 +1,42 @@+from __future__ import annotations++from dataclasses import dataclass+from typing import TYPE_CHECKING++if TYPE_CHECKING:+ from starlette.datastructures import State+ from uvicorn import Server++ from marimo._config.manager import MarimoConfigManager+ from marimo._server.session_manager import SessionManager+++@dataclass(frozen=True)+class StarletteServerStateInit:+ """State for the Starlette server.++ This enforces that we always supply all the required state to the app.state object.+ """++ port: int+ host: str+ base_url: str+ asset_url: str | None+ headless: bool+ quiet: bool+ session_manager: SessionManager+ config_manager: MarimoConfigManager+ remote_url: str | None+ mcp_server_enabled: bool+ skew_protection: bool+ enable_auth: bool++ def apply(self, state: State) -> None:+ for field, value in self.__dict__.items():+ setattr(state, field, value)+++class StarletteServerState(StarletteServerStateInit):+ """Typed state for the Starlette server."""++ server: Serverdiff --git a/marimo/_session/resume_strategies.py b/marimo/_server/resume_strategies.pysimilarity index 100%rename from marimo/_session/resume_strategies.pyrename to marimo/_server/resume_strategies.pydiff --git a/marimo/_server/session_manager.py b/marimo/_server/session_manager.pyindex 6f378e6395..5b8915335d 100644--- a/marimo/_server/session_manager.py+++ b/marimo/_server/session_manager.py@@ -21,6 +21,7 @@ from marimo._runtime.commands import (from marimo._server.file_router import AppFileRouter, MarimoFileKeyfrom marimo._server.lsp import LspServerfrom marimo._server.recents import RecentFilesManager+from marimo._server.resume_strategies import create_resume_strategyfrom marimo._server.session.listeners import RecentsTrackerListenerfrom marimo._server.token_manager import TokenManagerfrom marimo._server.tokens import AuthToken, SkewProtectionToken@@ -35,7 +36,6 @@ from marimo._session.file_watcher_integration import (SessionFileWatcherExtension,)from marimo._session.model import ConnectionState, SessionMode-from marimo._session.resume_strategies import create_resume_strategyfrom marimo._session.session import Session, SessionImplfrom marimo._session.session_repository import SessionRepositoryfrom marimo._session.types import KernelStatediff --git a/marimo/_server/start.py b/marimo/_server/start.pyindex ee6b68d699..7ab27f6b38 100644--- a/marimo/_server/start.py+++ b/marimo/_server/start.py@@ -16,6 +16,9 @@ from marimo._config.settings import GLOBAL_SETTINGSfrom marimo._mcp.server.main import setup_mcp_serverfrom marimo._messaging.notification import StartupLogsNotificationfrom marimo._runtime.commands import SerializedCLIArgs+from marimo._server.config import (+ StarletteServerStateInit,+)from marimo._server.file_router import AppFileRouterfrom marimo._server.lsp import CompositeLspServer, NoopLspServerfrom marimo._server.main import create_starlette_app@@ -282,19 +285,21 @@ def start(if mcp_enabled:setup_mcp_server(app)- app.state.port = external_port- app.state.host = external_host-- app.state.headless = headless- app.state.watch = watch- app.state.session_manager = session_manager- app.state.base_url = base_url- app.state.asset_url = asset_url- app.state.config_manager = config_reader- app.state.remote_url = remote_url- app.state.mcp_server_enabled = mcp- app.state.skew_protection = skew_protection- app.state.enable_auth = enable_auth+ init_state = StarletteServerStateInit(+ port=external_port,+ host=external_host,+ base_url=base_url,+ asset_url=asset_url,+ headless=headless,+ quiet=quiet,+ session_manager=session_manager,+ config_manager=config_reader,+ remote_url=remote_url,+ mcp_server_enabled=mcp,+ skew_protection=skew_protection,+ enable_auth=enable_auth,+ )+ init_state.apply(app.state)# Resource initialization# Increase the limit on open file descriptors to prevent resourcediff --git a/tests/_server/ai/tools/test_tool_manager.py b/tests/_server/ai/tools/test_tool_manager.pyindex 9bca5bee14..2ec246a580 100644--- a/tests/_server/ai/tools/test_tool_manager.py+++ b/tests/_server/ai/tools/test_tool_manager.py@@ -4,17 +4,15 @@ import pytestfrom starlette.applications import Starlettefrom marimo._ai._tools.tools_registry import SUPPORTED_BACKEND_AND_MCP_TOOLS-from marimo._config.manager import get_default_config_managerfrom marimo._server.ai.tools.tool_manager import ToolManagerfrom marimo._server.ai.tools.types import ToolCallResult-from tests._server.mocks import get_mock_session_manager+from tests._server.mocks import get_starlette_server_state_init@pytest.fixturedef manager():app = Starlette()- app.state.config_manager = get_default_config_manager(current_path=None)- app.state.session_manager = get_mock_session_manager()+ get_starlette_server_state_init().apply(app.state)manager = ToolManager(app)assert len(manager._tools) == 0 # lazy initreturn managerdiff --git a/tests/_server/api/endpoints/test_login.py b/tests/_server/api/endpoints/test_login.pyindex 1fe0ab1740..ba24f437d6 100644--- a/tests/_server/api/endpoints/test_login.py+++ b/tests/_server/api/endpoints/test_login.py@@ -18,7 +18,7 @@ from marimo._server.api.endpoints.login import router as auth_routerfrom marimo._server.api.middleware import AuthBackendfrom marimo._server.router import APIRouterfrom marimo._server.tokens import AuthToken-from tests._server.mocks import get_mock_session_manager+from tests._server.mocks import get_starlette_server_state_initAUTH_TOKEN = AuthToken("test_password")@@ -40,9 +40,8 @@ def create_app(base_url: str = "") -> Starlette:),],)- app.state.session_manager = get_mock_session_manager()+ get_starlette_server_state_init(base_url=base_url).apply(app.state)app.state.session_manager._token_manager.auth_token = AUTH_TOKEN- app.state.base_url = base_urlreturn appdiff --git a/tests/_server/api/test_auth.py b/tests/_server/api/test_auth.pyindex a33cfa2702..99d30fe59d 100644--- a/tests/_server/api/test_auth.py+++ b/tests/_server/api/test_auth.py@@ -9,7 +9,7 @@ from starlette.authentication import SimpleUserfrom starlette.datastructures import Headers, QueryParamsfrom starlette.requests import HTTPConnection-from marimo._config.manager import UserConfigManager+from marimo._config.manager import MarimoConfigManager, UserConfigManagerfrom marimo._server.api.auth import (CustomAuthenticationMiddleware,CustomSessionMiddleware,@@ -17,8 +17,12 @@ from marimo._server.api.auth import ()from marimo._server.api.deps import AppStatefrom marimo._server.api.middleware import AuthBackend+from marimo._server.config import StarletteServerStateInitfrom marimo._server.main import create_starlette_app-from tests._server.mocks import get_mock_session_manager+from tests._server.mocks import (+ get_mock_session_manager,+ get_starlette_server_state_init,+)async def mock_receive() -> Any:@@ -52,12 +56,20 @@ async def test_custom_session_middleware_call_with_port():@pytest.fixturedef app() -> Starlette:app = create_starlette_app(base_url="", enable_auth=True)- app.state.session_manager = get_mock_session_manager()- app.state.config_manager = UserConfigManager()- app.state.host = "localhost"- app.state.port = 1234- app.state.base_url = ""- app.state.enable_auth = True+ StarletteServerStateInit(+ port=1234,+ host="localhost",+ base_url="",+ asset_url=None,+ headless=False,+ quiet=False,+ session_manager=get_mock_session_manager(),+ config_manager=MarimoConfigManager(UserConfigManager()),+ remote_url=None,+ mcp_server_enabled=False,+ skew_protection=False,+ enable_auth=True,+ ).apply(app.state)return app@@ -148,7 +160,7 @@ async def test_validate_auth_with_no_auth(app: Starlette):async def test_custom_auth_middleware_preserves_user():app = Starlette()- app.state.session_manager = get_mock_session_manager()+ get_starlette_server_state_init().apply(app.state)async def test_app(scope: Any, receive: Any, send: Any) -> None:del receive, send@@ -176,7 +188,7 @@ async def test_custom_auth_middleware_preserves_user():async def test_custom_auth_middleware_without_user():app = Starlette()- app.state.session_manager = get_mock_session_manager()+ get_starlette_server_state_init().apply(app.state)async def test_app(scope: Any, receive: Any, send: Any) -> None:del receive, senddiff --git a/tests/_server/api/test_middleware.py b/tests/_server/api/test_middleware.pyindex 2e316abfbd..d3b83268e1 100644--- a/tests/_server/api/test_middleware.py+++ b/tests/_server/api/test_middleware.py@@ -23,9 +23,11 @@ from marimo._server.api.middleware import (_AsyncHTTPClient,_URLRequest,)+from marimo._server.config import StarletteServerStateInitfrom marimo._server.main import (create_starlette_app,)+from marimo._server.session_manager import SessionManagerfrom marimo._server.tokens import AuthTokenfrom marimo._server.utils import find_free_portfrom marimo._session.model import SessionMode@@ -38,20 +40,36 @@ if TYPE_CHECKING:from starlette.types import ASGIApp, Receive, Scope, Send-def test_base_url() -> None:- app = create_starlette_app(base_url="/foo")- app.state.session_manager = get_mock_session_manager()- app.state.config_manager = MarimoConfigManager(UserConfigManager())- client = TestClient(app)+def init_state(+ *,+ session_manager: SessionManager,+ enable_auth: bool = True,+ skew_protection: bool = False,+ base_url: str = "",+) -> StarletteServerStateInit:+ return StarletteServerStateInit(+ port=1234,+ host="localhost",+ base_url=base_url,+ asset_url=None,+ headless=False,+ quiet=False,+ session_manager=session_manager,+ config_manager=MarimoConfigManager(UserConfigManager()),+ remote_url=None,+ mcp_server_enabled=False,+ skew_protection=skew_protection,+ enable_auth=enable_auth,+ )- # Mock out the server- uvicorn_server = uvicorn.Server(uvicorn.Config(app))- uvicorn_server.servers = []- app.state.server = uvicorn_server- app.state.host = "localhost"- app.state.port = 1234- app.state.base_url = "/foo"+def test_base_url() -> None:+ app = create_starlette_app(base_url="/foo")+ init_state(+ session_manager=get_mock_session_manager(mode=SessionMode.EDIT),+ base_url="/foo",+ ).apply(app.state)+ with_server(app)client = TestClient(app)@@ -111,19 +129,22 @@ def test_skew_protection(edit_app: Starlette) -> None:assert response.status_code == 401, response.text+def with_server(app: Starlette) -> Starlette:+ uvicorn_server = uvicorn.Server(uvicorn.Config(app))+ uvicorn_server.servers = []+ app.state.server = uvicorn_server+ return app++def test_skew_protection_disabled() -> None:"""Test that skew protection can be disabled via CLI flag"""app = create_starlette_app(base_url="", skew_protection=False)- app.state.session_manager = get_mock_session_manager()- app.state.session_manager.mode = SessionMode.EDIT- app.state.config_manager = MarimoConfigManager(UserConfigManager())+ init_state(+ session_manager=get_mock_session_manager(mode=SessionMode.EDIT),+ skew_protection=False,+ ).apply(app.state)# Mock out the server- uvicorn_server = uvicorn.Server(uvicorn.Config(app))- uvicorn_server.servers = []- app.state.server = uvicorn_server- app.state.host = "localhost"- app.state.port = 1234- app.state.base_url = ""+ with_server(app)client = TestClient(app)@@ -138,32 +159,20 @@ def test_skew_protection_disabled() -> None:@pytest.fixturedef edit_app() -> Starlette:app = create_starlette_app(base_url="")- app.state.session_manager = get_mock_session_manager()- app.state.session_manager.mode = SessionMode.EDIT- app.state.config_manager = MarimoConfigManager(UserConfigManager())- # Mock out the server- uvicorn_server = uvicorn.Server(uvicorn.Config(app))- uvicorn_server.servers = []- app.state.server = uvicorn_server- app.state.host = "localhost"- app.state.port = 1234- app.state.base_url = ""+ session_manager = get_mock_session_manager()+ with_server(app)+ init_state(session_manager=session_manager).apply(app.state)return app@pytest.fixturedef read_app() -> Starlette:app = create_starlette_app(base_url="")- app.state.session_manager = get_mock_session_manager()- app.state.session_manager.mode = SessionMode.RUN- app.state.config_manager = MarimoConfigManager(UserConfigManager())# Mock out the server- uvicorn_server = uvicorn.Server(uvicorn.Config(app))- uvicorn_server.servers = []- app.state.server = uvicorn_server- app.state.host = "localhost"- app.state.port = 1234- app.state.base_url = ""+ with_server(app)+ init_state(+ session_manager=get_mock_session_manager(mode=SessionMode.RUN),+ ).apply(app.state)return app@@ -175,36 +184,26 @@ def app(request: Any) -> Starlette:@pytest.fixturedef no_auth_edit_app() -> Starlette:app = create_starlette_app(base_url="", enable_auth=False)- app.state.session_manager = get_mock_session_manager()- app.state.session_manager.mode = SessionMode.EDIT- # no auth- app.state.session_manager._token_manager.auth_token = AuthToken("")- app.state.config_manager = MarimoConfigManager(UserConfigManager())- # Mock out the server- uvicorn_server = uvicorn.Server(uvicorn.Config(app))- uvicorn_server.servers = []- app.state.server = uvicorn_server- app.state.host = "localhost"- app.state.port = 1234- app.state.base_url = ""+ session_manager = get_mock_session_manager()+ session_manager.mode = SessionMode.EDIT+ session_manager._token_manager.auth_token = AuthToken("")+ with_server(app)+ init_state(session_manager=session_manager, enable_auth=False).apply(+ app.state+ )return app@pytest.fixturedef no_auth_read_app() -> Starlette:app = create_starlette_app(base_url="", enable_auth=False)- app.state.session_manager = get_mock_session_manager()- app.state.session_manager.mode = SessionMode.RUN+ session_manager = get_mock_session_manager(mode=SessionMode.RUN)# no auth- app.state.session_manager._token_manager.auth_token = AuthToken("")- app.state.config_manager = MarimoConfigManager(UserConfigManager())- # Mock out the server- uvicorn_server = uvicorn.Server(uvicorn.Config(app))- uvicorn_server.servers = []- app.state.server = uvicorn_server- app.state.host = "localhost"- app.state.port = 1234- app.state.base_url = ""+ session_manager._token_manager.auth_token = AuthToken("")+ with_server(app)+ init_state(session_manager=session_manager, enable_auth=False).apply(+ app.state+ )return appdiff --git a/tests/_server/conftest.py b/tests/_server/conftest.pyindex 7187697b90..026a62c816 100644--- a/tests/_server/conftest.py+++ b/tests/_server/conftest.py@@ -13,6 +13,7 @@ from starlette.testclient import TestClientfrom marimo._config.manager import MarimoConfigManager, UserConfigManagerfrom marimo._config.utils import CONFIG_FILENAMEfrom marimo._server.api.deps import AppState+from marimo._server.config import StarletteServerStateInitfrom marimo._server.main import create_starlette_appfrom marimo._server.session_manager import SessionManagerfrom marimo._server.utils import initialize_asyncio@@ -59,18 +60,27 @@ def user_config_manager() -> Iterator[UserConfigManager]:@pytest.fixturedef client(user_config_manager: UserConfigManager) -> Iterator[TestClient]:main = sys.modules["__main__"]- app.state.session_manager = get_mock_session_manager()- app.state.config_manager = MarimoConfigManager(user_config_manager)client = TestClient(app)+ StarletteServerStateInit(+ port=1234,+ host="localhost",+ base_url="",+ asset_url=None,+ headless=False,+ quiet=False,+ session_manager=get_mock_session_manager(),+ config_manager=MarimoConfigManager(user_config_manager),+ remote_url=None,+ mcp_server_enabled=False,+ skew_protection=False,+ enable_auth=True,+ ).apply(app.state)# Mock out the serveruvicorn_server = uvicorn.Server(uvicorn.Config(app))uvicorn_server.servers = []-app.state.server = uvicorn_server- app.state.host = "localhost"- app.state.port = 1234- app.state.base_url = ""+yield clientsys.modules["__main__"] = maindiff --git a/tests/_server/mocks.py b/tests/_server/mocks.pyindex 18d92a6f47..9b362e5dda 100644--- a/tests/_server/mocks.py+++ b/tests/_server/mocks.py@@ -5,7 +5,12 @@ import base64import tempfilefrom typing import TYPE_CHECKING, Any, Callable, Optional, cast-from marimo._config.manager import get_default_config_manager+from marimo._config.manager import (+ MarimoConfigManager,+ UserConfigManager,+ get_default_config_manager,+)+from marimo._server.config import StarletteServerStateInitfrom marimo._server.file_router import AppFileRouterfrom marimo._server.lsp import NoopLspServerfrom marimo._server.session_manager import SessionManager@@ -21,7 +26,30 @@ def get_session_manager(client: TestClient) -> SessionManager:return client.app.state.session_manager # type: ignore-def get_mock_session_manager() -> SessionManager:+def get_starlette_server_state_init(+ *,+ session_manager: Optional[SessionManager] = None,+ base_url: str = "",+) -> StarletteServerStateInit:+ return StarletteServerStateInit(+ port=1234,+ host="localhost",+ base_url=base_url,+ asset_url=None,+ headless=False,+ quiet=False,+ session_manager=session_manager or get_mock_session_manager(),+ config_manager=MarimoConfigManager(UserConfigManager()),+ remote_url=None,+ mcp_server_enabled=False,+ skew_protection=False,+ enable_auth=True,+ )+++def get_mock_session_manager(+ mode: SessionMode = SessionMode.EDIT,+) -> SessionManager:temp_file = tempfile.NamedTemporaryFile(suffix=".py", delete=False)temp_file.write(@@ -49,7 +77,7 @@ if __name__ == "__main__":sm = SessionManager(file_router=AppFileRouter.from_filename(MarimoPath(temp_file.name)),- mode=SessionMode.EDIT,+ mode=mode,quiet=False,include_code=True,lsp_server=lsp_server,diff --git a/tests/_session/test_file_watcher_integration.py b/tests/_session/test_file_watcher_integration.pyindex 75f294d494..92ed94846f 100644--- a/tests/_session/test_file_watcher_integration.py+++ b/tests/_session/test_file_watcher_integration.py@@ -71,7 +71,6 @@ def test_attach_session_without_path() -> None:"""Test attaching a file watcher to a session without a file path."""session = create_mock_session(None)- session_id = SessionId("test-session")event_bus = SessionEventBus()lifecycle.on_attach(session, event_bus)diff --git a/tests/_session/test_resume_strategies.py b/tests/_session/test_resume_strategies.pyindex e3045bbbbf..9220259618 100644--- a/tests/_session/test_resume_strategies.py+++ b/tests/_session/test_resume_strategies.py@@ -9,11 +9,11 @@ from unittest.mock import MagicMockimport pytestfrom marimo._server.exceptions import InvalidSessionException-from marimo._session.model import ConnectionState-from marimo._session.resume_strategies import (+from marimo._server.resume_strategies import (EditModeResumeStrategy,RunModeResumeStrategy,)+from marimo._session.model import ConnectionStatefrom marimo._session.session_repository import SessionRepositoryfrom marimo._types.ids import SessionId