Skip to content

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.

refactor: typesafe app-state (#7627)

Myles Scolnickb02a3fddb4c5
diff --git a/marimo/_server/api/deps.py b/marimo/_server/api/deps.py
index 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, cast
from marimo import _loggers as loggers
from marimo._config.manager import MarimoConfigManager, ScriptConfigManager
+from marimo._server.config import StarletteServerState
from marimo._server.session_manager import SessionManager
from marimo._server.tokens import SkewProtectionToken
from marimo._session.model import SessionMode
@@ -14,7 +15,6 @@ if TYPE_CHECKING:
from starlette.applications import Starlette
from starlette.datastructures import State
from starlette.requests import Request
- from starlette.types import ASGIApp
from starlette.websockets import WebSocket
from 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)
@property
def session_manager(self) -> SessionManager:
- return cast(SessionManager, self.state.session_manager)
+ return self.state.session_manager
@property
def mode(self) -> SessionMode:
@@ -50,52 +50,39 @@ class AppStateBase:
@property
def quiet(self) -> bool:
- return self.session_manager.quiet
+ return self.state.quiet
@property
def host(self) -> str:
- host: str = self.state.host
- return host
+ return self.state.host
@property
def port(self) -> int:
- post: int = self.state.port
- return post
+ return self.state.port
@property
def maybe_port(self) -> Optional[int]:
- return self.state._state.get("port")
+ return getattr(self.state, "port", None)
@property
def base_url(self) -> str:
- base_url: str = self.state.base_url
- return base_url
+ return self.state.base_url
@property
def server(self) -> Server:
- server: Server = self.state.server
- return server
+ return self.state.server
@property
def 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
@property
def headless(self) -> bool:
- headless: bool = self.state.headless
- return headless
+ return self.state.headless
@property
def skew_protection(self) -> bool:
- skew_protection: bool = self.state.skew_protection
- return skew_protection
+ return self.state.skew_protection
@property
def skew_protection_token(self) -> SkewProtectionToken:
@@ -103,24 +90,25 @@ class AppStateBase:
@property
def 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
@property
def 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
@property
def 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
@property
def enable_auth(self) -> bool:
- return getattr(self.state, "enable_auth", True)
+ if hasattr(self.state, "enable_auth"):
+ return self.state.enable_auth
+ return True
class AppState(AppStateBase):
diff --git a/marimo/_server/config.py b/marimo/_server/config.py
new file mode 100644
index 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: Server
diff --git a/marimo/_session/resume_strategies.py b/marimo/_server/resume_strategies.py
similarity index 100%
rename from marimo/_session/resume_strategies.py
rename to marimo/_server/resume_strategies.py
diff --git a/marimo/_server/session_manager.py b/marimo/_server/session_manager.py
index 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, MarimoFileKey
from marimo._server.lsp import LspServer
from marimo._server.recents import RecentFilesManager
+from marimo._server.resume_strategies import create_resume_strategy
from marimo._server.session.listeners import RecentsTrackerListener
from marimo._server.token_manager import TokenManager
from 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_strategy
from marimo._session.session import Session, SessionImpl
from marimo._session.session_repository import SessionRepository
from marimo._session.types import KernelState
diff --git a/marimo/_server/start.py b/marimo/_server/start.py
index ee6b68d699..7ab27f6b38 100644
--- a/marimo/_server/start.py
+++ b/marimo/_server/start.py
@@ -16,6 +16,9 @@ from marimo._config.settings import GLOBAL_SETTINGS
from marimo._mcp.server.main import setup_mcp_server
from marimo._messaging.notification import StartupLogsNotification
from marimo._runtime.commands import SerializedCLIArgs
+from marimo._server.config import (
+ StarletteServerStateInit,
+)
from marimo._server.file_router import AppFileRouter
from marimo._server.lsp import CompositeLspServer, NoopLspServer
from 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 resource
diff --git a/tests/_server/ai/tools/test_tool_manager.py b/tests/_server/ai/tools/test_tool_manager.py
index 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 pytest
from starlette.applications import Starlette
from marimo._ai._tools.tools_registry import SUPPORTED_BACKEND_AND_MCP_TOOLS
-from marimo._config.manager import get_default_config_manager
from marimo._server.ai.tools.tool_manager import ToolManager
from 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.fixture
def 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 init
return manager
diff --git a/tests/_server/api/endpoints/test_login.py b/tests/_server/api/endpoints/test_login.py
index 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_router
from marimo._server.api.middleware import AuthBackend
from marimo._server.router import APIRouter
from marimo._server.tokens import AuthToken
-from tests._server.mocks import get_mock_session_manager
+from tests._server.mocks import get_starlette_server_state_init
AUTH_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_url
return app
diff --git a/tests/_server/api/test_auth.py b/tests/_server/api/test_auth.py
index 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 SimpleUser
from starlette.datastructures import Headers, QueryParams
from starlette.requests import HTTPConnection
-from marimo._config.manager import UserConfigManager
+from marimo._config.manager import MarimoConfigManager, UserConfigManager
from marimo._server.api.auth import (
CustomAuthenticationMiddleware,
CustomSessionMiddleware,
@@ -17,8 +17,12 @@ from marimo._server.api.auth import (
)
from marimo._server.api.deps import AppState
from marimo._server.api.middleware import AuthBackend
+from marimo._server.config import StarletteServerStateInit
from 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.fixture
def 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, send
diff --git a/tests/_server/api/test_middleware.py b/tests/_server/api/test_middleware.py
index 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 StarletteServerStateInit
from marimo._server.main import (
create_starlette_app,
)
+from marimo._server.session_manager import SessionManager
from marimo._server.tokens import AuthToken
from marimo._server.utils import find_free_port
from 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.fixture
def 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.fixture
def 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.fixture
def 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.fixture
def 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 app
diff --git a/tests/_server/conftest.py b/tests/_server/conftest.py
index 7187697b90..026a62c816 100644
--- a/tests/_server/conftest.py
+++ b/tests/_server/conftest.py
@@ -13,6 +13,7 @@ from starlette.testclient import TestClient
from marimo._config.manager import MarimoConfigManager, UserConfigManager
from marimo._config.utils import CONFIG_FILENAME
from marimo._server.api.deps import AppState
+from marimo._server.config import StarletteServerStateInit
from marimo._server.main import create_starlette_app
from marimo._server.session_manager import SessionManager
from marimo._server.utils import initialize_asyncio
@@ -59,18 +60,27 @@ def user_config_manager() -> Iterator[UserConfigManager]:
@pytest.fixture
def 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 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 = ""
+
yield client
sys.modules["__main__"] = main
diff --git a/tests/_server/mocks.py b/tests/_server/mocks.py
index 18d92a6f47..9b362e5dda 100644
--- a/tests/_server/mocks.py
+++ b/tests/_server/mocks.py
@@ -5,7 +5,12 @@ import base64
import tempfile
from 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 StarletteServerStateInit
from marimo._server.file_router import AppFileRouter
from marimo._server.lsp import NoopLspServer
from 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.py
index 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.py
index 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 MagicMock
import pytest
from 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 ConnectionState
from marimo._session.session_repository import SessionRepository
from marimo._types.ids import SessionId