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.

improvement: unfold code in traceback errors (#7321)

Myles Scolnicka0bc7bd93e3c
diff --git a/frontend/src/core/codemirror/cells/__tests__/traceback-decorations.test.ts b/frontend/src/core/codemirror/cells/__tests__/traceback-decorations.test.ts
new file mode 100644
index 0000000000..a38a82f32a
--- /dev/null
+++ b/frontend/src/core/codemirror/cells/__tests__/traceback-decorations.test.ts
@@ -0,0 +1,617 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+
+import { python } from "@codemirror/lang-python";
+import { foldCode, foldedRanges, foldGutter } from "@codemirror/language";
+import { EditorState } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { afterEach, describe, expect, it } from "vitest";
+import type { CellId } from "@/core/cells/ids";
+import { createMockObservable } from "@/core/state/__mocks__/mocks";
+import type { Observable } from "@/core/state/observable";
+import type { TracebackInfo } from "@/utils/traceback";
+import { cellIdState } from "../state";
+import { errorLineHighlighter } from "../traceback-decorations";
+
+function createEditor(
+ content: string,
+ cellId: CellId,
+ errorsObservable: Observable<TracebackInfo[] | undefined>,
+) {
+ const state = EditorState.create({
+ doc: content,
+ extensions: [
+ python(),
+ foldGutter(),
+ cellIdState.of(cellId),
+ errorLineHighlighter(errorsObservable),
+ ],
+ });
+
+ const view = new EditorView({
+ state,
+ parent: document.body,
+ });
+
+ return view;
+}
+
+describe("traceback-decorations", () => {
+ let view: EditorView | null = null;
+
+ afterEach(() => {
+ if (view) {
+ view.destroy();
+ view = null;
+ }
+ document.body.innerHTML = "";
+ });
+
+ describe("unfoldErrorLines", () => {
+ it("should unfold folded regions containing error lines", () => {
+ const cellId = "cell1" as CellId;
+ const code = `def my_function():
+ x = 1
+ y = 2
+ z = x + y
+ return z
+
+result = my_function()`;
+
+ const errorsObservable = createMockObservable<
+ TracebackInfo[] | undefined
+ >(undefined);
+ view = createEditor(code, cellId, errorsObservable);
+
+ // Fold the function body (lines 2-5)
+ // @ts-expect-error - foldCode accepts position as second arg at runtime
+ const foldResult = foldCode(view, view.state.doc.line(1).from);
+ expect(foldResult).toBe(true);
+
+ // Verify it's folded
+ const foldedBefore = foldedRanges(view.state);
+ let hasFoldedRegion = false;
+ foldedBefore.between(0, view.state.doc.length, () => {
+ hasFoldedRegion = true;
+ });
+ expect(hasFoldedRegion).toBe(true);
+
+ // Add an error on line 3 (inside the folded region)
+ const mockObservable = errorsObservable as Observable<
+ TracebackInfo[] | undefined
+ > & { set: (value: TracebackInfo[] | undefined) => void };
+ mockObservable.set([
+ {
+ kind: "cell",
+ cellId,
+ lineNumber: 3,
+ },
+ ]);
+
+ // Wait for the update to process
+ view.dispatch({});
+
+ // Verify the region is now unfolded
+ const foldedAfter = foldedRanges(view.state);
+ let stillFolded = false;
+ foldedAfter.between(0, view.state.doc.length, () => {
+ stillFolded = true;
+ });
+ expect(stillFolded).toBe(false);
+ });
+
+ it("should not unfold folded regions when error is outside the region", () => {
+ const cellId = "cell1" as CellId;
+ const code = `def my_function():
+ x = 1
+ y = 2
+ return x + y
+
+result = my_function()`;
+
+ const errorsObservable = createMockObservable<
+ TracebackInfo[] | undefined
+ >(undefined);
+ view = createEditor(code, cellId, errorsObservable);
+
+ // Fold the function body (lines 2-4)
+ // @ts-expect-error - foldCode accepts position as second arg at runtime
+ const foldResult = foldCode(view, view.state.doc.line(1).from);
+ expect(foldResult).toBe(true);
+
+ // Verify it's folded
+ const foldedBefore = foldedRanges(view.state);
+ let hasFoldedRegion = false;
+ foldedBefore.between(0, view.state.doc.length, () => {
+ hasFoldedRegion = true;
+ });
+ expect(hasFoldedRegion).toBe(true);
+
+ // Add an error on line 6 (outside the folded region)
+ const mockObservable = errorsObservable as Observable<
+ TracebackInfo[] | undefined
+ > & { set: (value: TracebackInfo[] | undefined) => void };
+ mockObservable.set([
+ {
+ kind: "cell",
+ cellId,
+ lineNumber: 6,
+ },
+ ]);
+
+ // Wait for the update to process
+ view.dispatch({});
+
+ // Verify the region is still folded
+ const foldedAfter = foldedRanges(view.state);
+ let stillFolded = false;
+ foldedAfter.between(0, view.state.doc.length, () => {
+ stillFolded = true;
+ });
+ expect(stillFolded).toBe(true);
+ });
+
+ it("should not unfold regions for errors in different cells", () => {
+ const cellId1 = "cell1" as CellId;
+ const cellId2 = "cell2" as CellId;
+ const code = `def my_function():
+ x = 1
+ y = 2
+ return x + y`;
+
+ const errorsObservable = createMockObservable<
+ TracebackInfo[] | undefined
+ >(undefined);
+ view = createEditor(code, cellId1, errorsObservable);
+
+ // Fold the function body
+ // @ts-expect-error - foldCode accepts position as second arg at runtime
+ const foldResult = foldCode(view, view.state.doc.line(1).from);
+ expect(foldResult).toBe(true);
+
+ // Verify it's folded
+ const foldedBefore = foldedRanges(view.state);
+ let hasFoldedRegion = false;
+ foldedBefore.between(0, view.state.doc.length, () => {
+ hasFoldedRegion = true;
+ });
+ expect(hasFoldedRegion).toBe(true);
+
+ // Add an error for a different cell
+ const mockObservable = errorsObservable as Observable<
+ TracebackInfo[] | undefined
+ > & { set: (value: TracebackInfo[] | undefined) => void };
+ mockObservable.set([
+ {
+ kind: "cell",
+ cellId: cellId2,
+ lineNumber: 2,
+ },
+ ]);
+
+ // Wait for the update to process
+ view.dispatch({});
+
+ // Verify the region is still folded (error is for different cell)
+ const foldedAfter = foldedRanges(view.state);
+ let stillFolded = false;
+ foldedAfter.between(0, view.state.doc.length, () => {
+ stillFolded = true;
+ });
+ expect(stillFolded).toBe(true);
+ });
+
+ it("should handle multiple errors in the same folded region", () => {
+ const cellId = "cell1" as CellId;
+ const code = `def my_function():
+ x = 1
+ y = 2
+ z = 3
+ return x + y + z
+
+result = my_function()`;
+
+ const errorsObservable = createMockObservable<
+ TracebackInfo[] | undefined
+ >(undefined);
+ view = createEditor(code, cellId, errorsObservable);
+
+ // Fold the function body
+ // @ts-expect-error - foldCode accepts position as second arg at runtime
+ const foldResult = foldCode(view, view.state.doc.line(1).from);
+ expect(foldResult).toBe(true);
+
+ // Verify it's folded
+ const foldedBefore = foldedRanges(view.state);
+ let hasFoldedRegion = false;
+ foldedBefore.between(0, view.state.doc.length, () => {
+ hasFoldedRegion = true;
+ });
+ expect(hasFoldedRegion).toBe(true);
+
+ // Add multiple errors on different lines inside the folded region
+ const mockObservable = errorsObservable as Observable<
+ TracebackInfo[] | undefined
+ > & { set: (value: TracebackInfo[] | undefined) => void };
+ mockObservable.set([
+ {
+ kind: "cell",
+ cellId,
+ lineNumber: 2, // Inside folded region
+ },
+ {
+ kind: "cell",
+ cellId,
+ lineNumber: 4, // Also inside folded region
+ },
+ ]);
+
+ // Wait for the update to process
+ view.dispatch({});
+
+ // Verify the region is unfolded
+ const foldedAfter = foldedRanges(view.state);
+ let stillFolded = false;
+ foldedAfter.between(0, view.state.doc.length, () => {
+ stillFolded = true;
+ });
+ expect(stillFolded).toBe(false);
+ });
+
+ it("should handle invalid line numbers gracefully in unfoldErrorLines", () => {
+ const cellId = "cell1" as CellId;
+ const code = `def my_function():
+ x = 1
+ return x`;
+
+ const errorsObservable = createMockObservable<
+ TracebackInfo[] | undefined
+ >(undefined);
+ view = createEditor(code, cellId, errorsObservable);
+
+ // Fold the function
+ // @ts-expect-error - foldCode accepts position as second arg at runtime
+ const foldResult = foldCode(view, view.state.doc.line(1).from);
+ expect(foldResult).toBe(true);
+
+ // Add an error with a mix of valid and invalid line numbers
+ // The invalid one should be handled gracefully by unfoldErrorLines (which has try-catch)
+ // Note: createErrorDecorations will throw for invalid line numbers, but unfoldErrorLines
+ // has error handling. Since we're testing folding, we'll test with a valid line number
+ // that's inside the folded region, and verify the folding still works
+ const mockObservable = errorsObservable as Observable<
+ TracebackInfo[] | undefined
+ > & { set: (value: TracebackInfo[] | undefined) => void };
+ mockObservable.set([
+ {
+ kind: "cell",
+ cellId,
+ lineNumber: 2, // Valid line number inside folded region
+ },
+ ]);
+
+ // Should not throw an error and should unfold the region
+ expect(() => {
+ if (!view) {
+ throw new Error("view is null");
+ }
+ view.dispatch({});
+ }).not.toThrow();
+
+ // Verify the region is unfolded
+ if (!view) {
+ throw new Error("view is null");
+ }
+ const foldedAfter = foldedRanges(view.state);
+ let stillFolded = false;
+ foldedAfter.between(0, view.state.doc.length, () => {
+ stillFolded = true;
+ });
+ expect(stillFolded).toBe(false);
+ });
+
+ it("should handle file errors (not cell errors)", () => {
+ const cellId = "cell1" as CellId;
+ const code = `def my_function():
+ x = 1
+ return x`;
+
+ const errorsObservable = createMockObservable<
+ TracebackInfo[] | undefined
+ >(undefined);
+ view = createEditor(code, cellId, errorsObservable);
+
+ // Fold the function
+ // @ts-expect-error - foldCode accepts position as second arg at runtime
+ const foldResult = foldCode(view, view.state.doc.line(1).from);
+ expect(foldResult).toBe(true);
+
+ // Add a file error (not a cell error)
+ const mockObservable = errorsObservable as Observable<
+ TracebackInfo[] | undefined
+ > & { set: (value: TracebackInfo[] | undefined) => void };
+ mockObservable.set([
+ {
+ kind: "file",
+ filePath: "/some/path.py",
+ lineNumber: 2,
+ },
+ ]);
+
+ // Wait for the update to process
+ view.dispatch({});
+
+ // Verify the region is still folded (file errors don't trigger unfolding)
+ const foldedAfter = foldedRanges(view.state);
+ let stillFolded = false;
+ foldedAfter.between(0, view.state.doc.length, () => {
+ stillFolded = true;
+ });
+ expect(stillFolded).toBe(true);
+ });
+
+ it("should handle empty or undefined errors", () => {
+ const cellId = "cell1" as CellId;
+ const code = `def my_function():
+ x = 1
+ return x`;
+
+ const errorsObservable = createMockObservable<
+ TracebackInfo[] | undefined
+ >(undefined);
+ view = createEditor(code, cellId, errorsObservable);
+
+ // Fold the function
+ // @ts-expect-error - foldCode accepts position as second arg at runtime
+ const foldResult = foldCode(view, view.state.doc.line(1).from);
+ expect(foldResult).toBe(true);
+
+ // Set errors to empty array
+ const mockObservable = errorsObservable as Observable<
+ TracebackInfo[] | undefined
+ > & { set: (value: TracebackInfo[] | undefined) => void };
+ mockObservable.set([]);
+
+ // Should not throw
+ expect(() => {
+ if (!view) {
+ throw new Error("view is null");
+ }
+ view.dispatch({});
+ }).not.toThrow();
+
+ // Set errors to undefined
+ mockObservable.set(undefined);
+
+ // Should not throw
+ expect(() => {
+ if (!view) {
+ throw new Error("view is null");
+ }
+ view.dispatch({});
+ }).not.toThrow();
+ });
+
+ it("should handle invalid line numbers gracefully", () => {
+ const cellId = "cell1" as CellId;
+ const code = `def my_function():
+ x = 1
+ return x`;
+
+ const errorsObservable = createMockObservable<
+ TracebackInfo[] | undefined
+ >(undefined);
+ view = createEditor(code, cellId, errorsObservable);
+
+ // Fold the function
+ // @ts-expect-error - foldCode accepts position as second arg at runtime
+ const foldResult = foldCode(view, view.state.doc.line(1).from);
+ expect(foldResult).toBe(true);
+
+ // Add an error with an invalid line number (beyond document length)
+ const mockObservable = errorsObservable as Observable<
+ TracebackInfo[] | undefined
+ > & { set: (value: TracebackInfo[] | undefined) => void };
+ const maxLine = view.state.doc.lines;
+ mockObservable.set([
+ {
+ kind: "cell",
+ cellId,
+ lineNumber: maxLine + 100, // Invalid line number
+ },
+ ]);
+
+ // Should not throw an error
+ expect(() => {
+ if (!view) {
+ throw new Error("view is null");
+ }
+ view.dispatch({});
+ }).not.toThrow();
+
+ // Verify the region is still folded (invalid line numbers don't trigger unfolding)
+ const foldedAfter = foldedRanges(view.state);
+ let stillFolded = false;
+ foldedAfter.between(0, view.state.doc.length, () => {
+ stillFolded = true;
+ });
+ expect(stillFolded).toBe(true);
+ });
+
+ it("should unfold nested structures when error is inside", () => {
+ const cellId = "cell1" as CellId;
+ const code = `def outer_function():
+ def inner_function():
+ x = 1
+ y = 2
+ return x + y
+ result = inner_function()
+ return result
+
+final = outer_function()`;
+
+ const errorsObservable = createMockObservable<
+ TracebackInfo[] | undefined
+ >(undefined);
+ view = createEditor(code, cellId, errorsObservable);
+
+ // Fold the outer function (which contains the inner function)
+ // @ts-expect-error - foldCode accepts position as second arg at runtime
+ const outerFoldResult = foldCode(view, view.state.doc.line(1).from);
+ expect(outerFoldResult).toBe(true);
+
+ // Verify it's folded
+ const foldedBefore = foldedRanges(view.state);
+ let hasFoldedRegion = false;
+ foldedBefore.between(0, view.state.doc.length, () => {
+ hasFoldedRegion = true;
+ });
+ expect(hasFoldedRegion).toBe(true);
+
+ // Add an error on line 4 (inside the folded outer function, in the inner function)
+ const mockObservable = errorsObservable as Observable<
+ TracebackInfo[] | undefined
+ > & { set: (value: TracebackInfo[] | undefined) => void };
+ mockObservable.set([
+ {
+ kind: "cell",
+ cellId,
+ lineNumber: 4,
+ },
+ ]);
+
+ // Wait for the update to process
+ view.dispatch({});
+
+ // Verify the region is unfolded (the error line should be visible)
+ const foldedAfter = foldedRanges(view.state);
+ let stillFolded = false;
+ foldedAfter.between(0, view.state.doc.length, () => {
+ stillFolded = true;
+ });
+ expect(stillFolded).toBe(false);
+ });
+
+ it("should handle errors being cleared and then re-added", () => {
+ const cellId = "cell1" as CellId;
+ const code = `def my_function():
+ x = 1
+ y = 2
+ return x + y
+
+result = my_function()`;
+
+ const errorsObservable = createMockObservable<
+ TracebackInfo[] | undefined
+ >(undefined);
+ view = createEditor(code, cellId, errorsObservable);
+
+ // Fold the function
+ // @ts-expect-error - foldCode accepts position as second arg at runtime
+ const foldResult = foldCode(view, view.state.doc.line(1).from);
+ expect(foldResult).toBe(true);
+
+ // Add an error
+ const mockObservable = errorsObservable as Observable<
+ TracebackInfo[] | undefined
+ > & { set: (value: TracebackInfo[] | undefined) => void };
+ mockObservable.set([
+ {
+ kind: "cell",
+ cellId,
+ lineNumber: 2,
+ },
+ ]);
+
+ view.dispatch({});
+
+ // Verify it's unfolded
+ let foldedAfter = foldedRanges(view.state);
+ let stillFolded = false;
+ foldedAfter.between(0, view.state.doc.length, () => {
+ stillFolded = true;
+ });
+ expect(stillFolded).toBe(false);
+
+ // Clear errors
+ mockObservable.set(undefined);
+ view.dispatch({});
+
+ // Fold again
+ // @ts-expect-error - foldCode accepts position as second arg at runtime
+ const foldResult2 = foldCode(view, view.state.doc.line(1).from);
+ expect(foldResult2).toBe(true);
+
+ // Add error again
+ mockObservable.set([
+ {
+ kind: "cell",
+ cellId,
+ lineNumber: 3,
+ },
+ ]);
+
+ view.dispatch({});
+
+ // Verify it's unfolded again
+ foldedAfter = foldedRanges(view.state);
+ stillFolded = false;
+ foldedAfter.between(0, view.state.doc.length, () => {
+ stillFolded = true;
+ });
+ expect(stillFolded).toBe(false);
+ });
+
+ it("should unfold immediately when errors are set", () => {
+ const cellId = "cell1" as CellId;
+ const code = `def my_function():
+ x = 1
+ y = 2
+ return x + y
+
+result = my_function()`;
+
+ const errorsObservable = createMockObservable<
+ TracebackInfo[] | undefined
+ >(undefined);
+ view = createEditor(code, cellId, errorsObservable);
+
+ // Fold the function
+ // @ts-expect-error - foldCode accepts position as second arg at runtime
+ const foldResult = foldCode(view, view.state.doc.line(1).from);
+ expect(foldResult).toBe(true);
+
+ // Verify it's folded
+ const foldedBefore = foldedRanges(view.state);
+ let hasFoldedRegion = false;
+ foldedBefore.between(0, view.state.doc.length, () => {
+ hasFoldedRegion = true;
+ });
+ expect(hasFoldedRegion).toBe(true);
+
+ // Add an error - the observable subscription should trigger immediately
+ const mockObservable = errorsObservable as Observable<
+ TracebackInfo[] | undefined
+ > & { set: (value: TracebackInfo[] | undefined) => void };
+ mockObservable.set([
+ {
+ kind: "cell",
+ cellId,
+ lineNumber: 2,
+ },
+ ]);
+
+ // The unfolding should happen synchronously when set() is called
+ // (the subscription callback runs immediately)
+ // We still need to dispatch to apply the state changes
+ view.dispatch({});
+
+ // Verify the region is now unfolded
+ const foldedAfter = foldedRanges(view.state);
+ let stillFolded = false;
+ foldedAfter.between(0, view.state.doc.length, () => {
+ stillFolded = true;
+ });
+ expect(stillFolded).toBe(false);
+ });
+ });
+});
diff --git a/frontend/src/core/codemirror/cells/traceback-decorations.ts b/frontend/src/core/codemirror/cells/traceback-decorations.ts
index ebaf2f841e..14cb77a440 100644
--- a/frontend/src/core/codemirror/cells/traceback-decorations.ts
+++ b/frontend/src/core/codemirror/cells/traceback-decorations.ts
@@ -1,6 +1,7 @@
/* Copyright 2024 Marimo. All rights reserved. */
-import type { EditorState, Extension } from "@codemirror/state";
+import { foldedRanges, unfoldEffect } from "@codemirror/language";
+import type { EditorState, Extension, StateEffect } from "@codemirror/state";
import { RangeSetBuilder } from "@codemirror/state";
import {
Decoration,
@@ -11,6 +12,7 @@ import {
type ViewUpdate,
} from "@codemirror/view";
import type { Observable } from "@/core/state/observable";
+import { Logger } from "@/utils/Logger";
import type { TracebackInfo } from "@/utils/traceback";
import { cellIdState } from "./state";
@@ -33,16 +35,57 @@ function createErrorDecorations(state: EditorState, errors: TracebackInfos) {
.sort((a, b) => a.lineNumber - b.lineNumber);
for (const error of relevantErrors) {
- const line = state.doc.line(error.lineNumber);
- const deco = Decoration.line({
- class: "cm-error-line",
- });
- builder.add(line.from, line.from, deco);
+ try {
+ const line = state.doc.line(error.lineNumber);
+ const deco = Decoration.line({
+ class: "cm-error-line",
+ });
+ builder.add(line.from, line.from, deco);
+ } catch (error) {
+ Logger.debug("Invalid line number in error decoration", { error });
+ }
}
return builder.finish();
}
+/**
+ * Unfolds any folded regions that contain error lines.
+ */
+function unfoldErrorLines(view: EditorView, errors: TracebackInfos) {
+ if (!errors?.length) {
+ return;
+ }
+
+ const cellId = view.state.facet(cellIdState);
+ const relevantErrors = errors.filter(
+ (error) => error.kind === "cell" && error.cellId === cellId,
+ );
+
+ if (relevantErrors.length === 0) {
+ return;
+ }
+
+ const folded = foldedRanges(view.state);
+ const effects: StateEffect<unknown>[] = [];
+
+ for (const error of relevantErrors) {
+ try {
+ const line = view.state.doc.line(error.lineNumber);
+ // Check if this line is inside a folded region
+ folded.between(line.from, line.to, (from, to) => {
+ effects.push(unfoldEffect.of({ from, to }));
+ });
+ } catch (error) {
+ Logger.debug("Invalid line numbers", { error });
+ }
+ }
+
+ if (effects.length > 0) {
+ view.dispatch({ effects });
+ }
+}
+
/**
* A view plugin that highlights error lines in the editor.
*/
@@ -51,15 +94,15 @@ class ErrorHighlighter implements PluginValue {
decorations: DecorationSet;
constructor(view: EditorView, errorsObservable: Observable<TracebackInfos>) {
- this.decorations = createErrorDecorations(
- view.state,
- errorsObservable.get(),
- );
+ const errors = errorsObservable.get();
+ this.decorations = createErrorDecorations(view.state, errors);
+ unfoldErrorLines(view, errors);
this.unsubscribe = errorsObservable.sub((errors) => {
// Prev length
const prevLength = this.decorations.size;
this.decorations = createErrorDecorations(view.state, errors);
+ unfoldErrorLines(view, errors);
if (prevLength !== this.decorations.size) {
// Force a re-render
diff --git a/frontend/src/core/state/__mocks__/mocks.ts b/frontend/src/core/state/__mocks__/mocks.ts
new file mode 100644
index 0000000000..43c8b8f223
--- /dev/null
+++ b/frontend/src/core/state/__mocks__/mocks.ts
@@ -0,0 +1,22 @@
+import type { Observable } from "../observable";
+
+export function createMockObservable<T>(
+ initialValue: T,
+): Observable<T> & { set: (value: T) => void } {
+ let value = initialValue;
+ const subscribers = new Set<(value: T) => void>();
+
+ return {
+ get: () => value,
+ sub: (callback) => {
+ subscribers.add(callback);
+ return () => {
+ subscribers.delete(callback);
+ };
+ },
+ set: (newValue: T) => {
+ value = newValue;
+ subscribers.forEach((callback) => callback(newValue));
+ },
+ };
+}