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
Resolve file keys through the workspace when matching sessions (#10474)
Trevor Manz2e0c21364aea
diff --git a/marimo/_server/resume_strategies.py b/marimo/_server/resume_strategies.pyindex 1996339cf6..f7c3c51332 100644--- a/marimo/_server/resume_strategies.py+++ b/marimo/_server/resume_strategies.py@@ -17,8 +17,14 @@ from marimo._types.ids import SessionIdLOGGER = _loggers.marimo_logger()if TYPE_CHECKING:+ from collections.abc import Callable+from marimo._server.workspace import MarimoFileKey+ # Resolves a file key to a canonical absolute path, or None when the key+ # has no backing file (untitled notebooks) or cannot be resolved.+ FileKeyResolver = Callable[[MarimoFileKey], str | None]+class SessionResumeStrategy(Protocol):"""Protocol for session resume strategies."""@@ -47,8 +53,13 @@ class EditModeResumeStrategy(SessionResumeStrategy):Only one session per file is allowed in edit mode."""- def __init__(self, repository: SessionRepository) -> None:+ def __init__(+ self,+ repository: SessionRepository,+ resolve_file_key: FileKeyResolver,+ ) -> None:self._repository = repository+ self._resolve_file_key = resolve_file_keydef try_resume(self,@@ -56,15 +67,15 @@ class EditModeResumeStrategy(SessionResumeStrategy):file_key: MarimoFileKey,) -> Session | None:"""Try to resume an orphaned session for the same file."""- import os-- # Find sessions with the same file+ # Find sessions with the same file. File keys can be+ # workspace-relative, so match through the workspace resolver rather+ # than a CWD-dependent abspath.sessions_with_file = []- for session in self._repository.get_all():+ for session in self._repository.get_all_by_file_key(+ file_key, resolved_path=self._resolve_file_key(file_key)+ ):session_id = self._repository.get_session_id(session)- if session_id and session.app_file_manager.path == os.path.abspath(- file_key- ):+ if session_id:sessions_with_file.append((session_id, session))if len(sessions_with_file) == 0:@@ -124,18 +135,21 @@ class RunModeResumeStrategy(SessionResumeStrategy):def create_resume_strategy(- mode: SessionMode, repository: SessionRepository+ mode: SessionMode,+ repository: SessionRepository,+ resolve_file_key: FileKeyResolver,) -> SessionResumeStrategy:"""Factory function to create the appropriate resume strategy.Args:mode: The session moderepository: The session repository+ resolve_file_key: Resolves a file key to a canonical absolute pathReturns:The appropriate resume strategy for the mode"""if mode == SessionMode.EDIT:- return EditModeResumeStrategy(repository)+ return EditModeResumeStrategy(repository, resolve_file_key)else:return RunModeResumeStrategy(repository)diff --git a/marimo/_server/session_manager.py b/marimo/_server/session_manager.pyindex c897b17113..70cb80b66c 100644--- a/marimo/_server/session_manager.py+++ b/marimo/_server/session_manager.py@@ -134,7 +134,9 @@ class SessionManager:)# Initialize resume strategy- self._resume_strategy = create_resume_strategy(mode, self._repository)+ self._resume_strategy = create_resume_strategy(+ mode, self._repository, self._resolve_file_key+ )# Add recents tracking listenerself.recents = RecentFilesManager()@@ -286,6 +288,10 @@ class SessionManager:except Exception as e:return False, str(e)+ renamed_path = session.app_file_manager.path+ if renamed_path is not None:+ self.workspace.register_allowed_path(renamed_path)+# Emit the session notebook renamed eventawait self._event_bus.emit_session_notebook_renamed(session, old_path)@@ -318,7 +324,25 @@ class SessionManager:self, file_key: MarimoFileKey) -> Session | None:"""Get a session by file key."""- return self._repository.get_by_file_key(file_key)+ return self._repository.get_by_file_key(+ file_key, resolved_path=self._resolve_file_key(file_key)+ )++ def _resolve_file_key(self, file_key: MarimoFileKey) -> str | None:+ """Best-effort canonical absolute path for a file key.++ File keys can be workspace-relative, so resolving against the server+ CWD is wrong; the workspace owns the resolution. Returns None when+ the key has no backing file (untitled notebooks) or cannot be+ resolved (deleted file, path outside the workspace); session lookups+ then fall back to matching the key a session was created under.+ """+ from marimo._utils.http import HTTPException++ try:+ return self.workspace.resolve(file_key)+ except HTTPException:+ return Nonedef maybe_resume_session(self, new_session_id: SessionId, file_key: MarimoFileKeydiff --git a/marimo/_server/workspace/_directory.py b/marimo/_server/workspace/_directory.pyindex 58f5bbd4b5..499ecdbe3d 100644--- a/marimo/_server/workspace/_directory.py+++ b/marimo/_server/workspace/_directory.py@@ -16,6 +16,7 @@ from marimo._server.workspace._base import (file_not_found,)from marimo._utils.http import HTTPException, HTTPStatus+from marimo._utils.paths import normalize_pathif TYPE_CHECKING:from marimo._server.models.files import FileInfo@@ -88,7 +89,7 @@ class DirectoryWorkspace(NotebookWorkspace):self._validator.validate_inside_directory(directory, filepath)if filepath.exists():- return str(filepath)+ return str(normalize_path(filepath))raise file_not_found(key)diff --git a/marimo/_session/session_repository.py b/marimo/_session/session_repository.pyindex 1490aef582..dd3236da72 100644--- a/marimo/_session/session_repository.py+++ b/marimo/_session/session_repository.py@@ -52,17 +52,33 @@ class SessionRepository:return sessionreturn None- def get_by_file_key(self, file_key: MarimoFileKey) -> Session | None:+ def get_by_file_key(+ self, file_key: MarimoFileKey, resolved_path: str | None = None+ ) -> Session | None:"""Get a session by file key."""- import os-- for session in self._sessions.values():+ sessions = self.get_all_by_file_key(file_key, resolved_path)+ return sessions[0] if sessions else None++ def get_all_by_file_key(+ self, file_key: MarimoFileKey, resolved_path: str | None = None+ ) -> list[Session]:+ """Get all sessions for a notebook file key.++ When `resolved_path` is provided, a session matches on its current+ filesystem path. Otherwise, it matches on the key it was created+ under (`initialization_id`). File keys can be workspace-relative, so+ callers must resolve them through the workspace (not against the+ server CWD) before comparing to session paths.+ """+ return [+ session+ for session in self._sessions.values()if (- session.initialization_id == file_key- or session.app_file_manager.path == os.path.abspath(file_key)- ):- return session- return None+ session.app_file_manager.path == resolved_path+ if resolved_path is not None+ else session.initialization_id == file_key+ )+ ]def get_by_file_path(self, file_path: str) -> list[Session]:"""Get all sessions associated with a file path."""diff --git a/tests/_server/api/endpoints/test_resume_session.py b/tests/_server/api/endpoints/test_resume_session.pyindex 9200553000..0a9e1e16d7 100644--- a/tests/_server/api/endpoints/test_resume_session.py+++ b/tests/_server/api/endpoints/test_resume_session.py@@ -11,6 +11,7 @@ from marimo._messaging.notification import (CellNotification,KernelReadyNotification,)+from marimo._server.workspace import DirectoryWorkspacefrom marimo._session import Sessionfrom marimo._types.ids import SessionIdfrom marimo._utils.parse_dataclass import parse_raw@@ -19,9 +20,11 @@ from tests._server.api.endpoints.ws_helpers import (create_response,headers,)-from tests._server.mocks import get_session_manager+from tests._server.mocks import get_session_manager, workspace_scopeif TYPE_CHECKING:+ from pathlib import Path+from starlette.testclient import TestClient@@ -111,6 +114,49 @@ def test_refresh_session(client: TestClient) -> None:assert get_session(client, "789")+def test_refresh_resumes_directory_workspace_session(+ client: TestClient, tmp_path: Path+) -> None:+ """Regression: directory workspaces serve workspace-relative file keys.++ Refreshing the browser (a new connection with a new session id and the+ same relative key) must resume the existing session; resolving the key+ against the server CWD instead created a new kernel per refresh.+ """+ notebook = tmp_path / "notebooks" / "example.py"+ notebook.parent.mkdir()+ notebook.write_text(+ "import marimo\n\napp = marimo.App()\n\n"+ "@app.cell\ndef _():\n x = 1\n return (x,)\n"+ )+ workspace = DirectoryWorkspace(+ str(notebook.parent), include_markdown=False+ )+ session_manager = get_session_manager(client)++ with workspace_scope(client, workspace):+ with client.websocket_connect(+ "/ws?session_id=dir1&file=example.py&access_token=fake-token"+ ) as websocket:+ data = websocket.receive_json()+ assert data["op"] == "kernel-ready"+ assert data["data"]["resumed"] is False++ # Simulated refresh: new session id, same workspace-relative key+ with client.websocket_connect(+ "/ws?session_id=dir2&file=example.py&access_token=fake-token"+ ) as websocket:+ data = websocket.receive_json()+ assert data == {"op": "reconnected", "data": {"op": "reconnected"}}+ data = websocket.receive_json()+ assert data["op"] == "kernel-ready"+ assert data["data"]["resumed"] is True++ assert len(session_manager.sessions) == 1+ assert get_session(client, SessionId("dir2"))+ session_manager.close_session(SessionId("dir2"))++def test_save_session(client: TestClient) -> None:filename = (get_session_manager(client)diff --git a/tests/_server/test_sessions.py b/tests/_server/test_sessions.pyindex 9caf664551..0c159171d0 100644--- a/tests/_server/test_sessions.py+++ b/tests/_server/test_sessions.py@@ -930,13 +930,15 @@ def __():# Rename to the second filesession = session_manager.get_session(session_id)assert session is not None- session.app_file_manager.rename(str(new_path))- assert new_path.exists()success, error = await session_manager.rename_session(session_id, str(new_path))assert successassert error is None+ assert new_path.exists()+ assert (+ session_manager.get_session_by_file_key(str(new_path)) is session+ )# Modify the new fileoperations.clear()diff --git a/tests/_server/test_workspace.py b/tests/_server/test_workspace.pyindex c8366c06e9..73d9401e0b 100644--- a/tests/_server/test_workspace.py+++ b/tests/_server/test_workspace.py@@ -282,6 +282,14 @@ class TestNotebookWorkspace(unittest.TestCase):# ----- security: DirectoryWorkspace -----+ def test_directory_workspace_resolve_normalizes_dotdot(self):+ workspace = DirectoryWorkspace(self.test_dir, include_markdown=False)+ key = os.path.join(+ "nested", "..", os.path.basename(self.test_file1.name)+ )++ assert workspace.resolve(key) == self.test_file1.name+def test_directory_workspace_new_file_prefix_does_not_leak(self):"""`__new__` prefix returns None — does not bypass containment.diff --git a/tests/_session/test_resume_strategies.py b/tests/_session/test_resume_strategies.pyindex 9220259618..fda8e4b049 100644--- a/tests/_session/test_resume_strategies.py+++ b/tests/_session/test_resume_strategies.py@@ -18,11 +18,16 @@ from marimo._session.session_repository import SessionRepositoryfrom marimo._types.ids import SessionId-def create_mock_session(file_path: str, connection_state: ConnectionState):+def create_mock_session(+ file_path: str,+ connection_state: ConnectionState,+ initialization_id: str | None = None,+):"""Create a mock session for testing."""session = MagicMock()session.app_file_manager = MagicMock()session.app_file_manager.path = os.path.abspath(file_path)+ session.initialization_id = initialization_idsession.connection_state.return_value = connection_statereturn session@@ -30,7 +35,7 @@ def create_mock_session(file_path: str, connection_state: ConnectionState):def test_edit_mode_resume_no_existing_sessions() -> None:"""Test that edit mode returns None when no sessions exist."""repository = SessionRepository()- strategy = EditModeResumeStrategy(repository)+ strategy = EditModeResumeStrategy(repository, os.path.abspath)result = strategy.try_resume(SessionId("new-session"), "test.py")assert result is None@@ -39,7 +44,7 @@ def test_edit_mode_resume_no_existing_sessions() -> None:def test_edit_mode_resume_orphaned_session() -> None:"""Test that edit mode resumes an orphaned session for the same file."""repository = SessionRepository()- strategy = EditModeResumeStrategy(repository)+ strategy = EditModeResumeStrategy(repository, os.path.abspath)# Create an orphaned sessionold_session_id = SessionId("old-session")@@ -58,10 +63,102 @@ def test_edit_mode_resume_orphaned_session() -> None:assert repository.get_sync(old_session_id) is None+def test_edit_mode_resume_workspace_relative_key() -> None:+ """Regression: directory workspaces serve workspace-relative file keys.++ The key must be resolved through the workspace, not against the server+ CWD; sessions never resumed when the workspace root was a subdirectory+ of the CWD (`marimo edit notebooks/`).+ """+ repository = SessionRepository()+ # The notebook lives outside the CWD, like `marimo edit notebooks/`+ # run from a project root.+ resolved = os.path.abspath(+ os.path.join(os.sep, "workspace", "notebooks", "example.py")+ )+ strategy = EditModeResumeStrategy(+ repository,+ lambda key: resolved if key == "example.py" else None,+ )++ old_session_id = SessionId("old-session")+ session = create_mock_session(+ resolved, ConnectionState.ORPHANED, initialization_id="example.py"+ )+ repository.add_sync(old_session_id, session)++ new_session_id = SessionId("new-session")+ result = strategy.try_resume(new_session_id, "example.py")++ assert result is session+ assert repository.get_sync(new_session_id) is session+++def test_edit_mode_resume_unresolvable_key_matches_initialization_id() -> None:+ """A key with no backing file (untitled or deleted notebook) still+ matches the session created under the same key."""+ repository = SessionRepository()+ strategy = EditModeResumeStrategy(repository, lambda _key: None)++ old_session_id = SessionId("old-session")+ session = create_mock_session(+ "test.py", ConnectionState.ORPHANED, initialization_id="__new__abc"+ )+ repository.add_sync(old_session_id, session)++ result = strategy.try_resume(SessionId("new-session"), "__new__abc")++ assert result is session+++def test_edit_mode_resume_after_rename_matches_resolved_path() -> None:+ """A session keeps its creation key after a rename; the resolved path+ of the new key must still find it."""+ repository = SessionRepository()+ resolved = os.path.abspath(os.path.join(os.sep, "workspace", "renamed.py"))+ strategy = EditModeResumeStrategy(+ repository,+ lambda key: resolved if key == "renamed.py" else None,+ )++ session = create_mock_session(+ resolved, ConnectionState.ORPHANED, initialization_id="original.py"+ )+ repository.add_sync(SessionId("old-session"), session)++ result = strategy.try_resume(SessionId("new-session"), "renamed.py")++ assert result is session+++def test_edit_mode_ignores_creation_key_when_file_resolves() -> None:+ """A recreated file must not match a session that moved away from it."""+ repository = SessionRepository()+ original = os.path.abspath(+ os.path.join(os.sep, "workspace", "original.py")+ )+ renamed = os.path.abspath(os.path.join(os.sep, "workspace", "renamed.py"))+ strategy = EditModeResumeStrategy(+ repository,+ lambda key: original if key == "original.py" else None,+ )++ session = create_mock_session(+ renamed, ConnectionState.ORPHANED, initialization_id="original.py"+ )+ old_session_id = SessionId("old-session")+ repository.add_sync(old_session_id, session)++ result = strategy.try_resume(SessionId("new-session"), "original.py")++ assert result is None+ assert repository.get_sync(old_session_id) is session++def test_edit_mode_resume_open_session_not_resumed() -> None:- """Test that edit mode doesn't resume a non-orphaned session."""+ """Test that edit mode doesn't resume a session with a live editor."""repository = SessionRepository()- strategy = EditModeResumeStrategy(repository)+ strategy = EditModeResumeStrategy(repository, os.path.abspath)# Create an open sessionold_session_id = SessionId("old-session")@@ -72,7 +169,7 @@ def test_edit_mode_resume_open_session_not_resumed() -> None:new_session_id = SessionId("new-session")result = strategy.try_resume(new_session_id, "test.py")- # Should return None because session is not orphaned+ # Should return None because session has a live editorassert result is None# Original session should remain unchanged@@ -82,7 +179,7 @@ def test_edit_mode_resume_open_session_not_resumed() -> None:def test_edit_mode_resume_different_file() -> None:"""Test that edit mode doesn't resume session for different file."""repository = SessionRepository()- strategy = EditModeResumeStrategy(repository)+ strategy = EditModeResumeStrategy(repository, os.path.abspath)# Create an orphaned session for a different fileold_session_id = SessionId("old-session")@@ -102,7 +199,7 @@ def test_edit_mode_resume_different_file() -> None:def test_edit_mode_resume_multiple_sessions_raises_error() -> None:"""Test that edit mode raises error if multiple sessions exist for same file."""repository = SessionRepository()- strategy = EditModeResumeStrategy(repository)+ strategy = EditModeResumeStrategy(repository, os.path.abspath)# Create two sessions for the same filesession1 = create_mock_session("test.py", ConnectionState.ORPHANED)