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
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.tsnew file mode 100644index 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.tsindex 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 lengthconst prevLength = this.decorations.size;this.decorations = createErrorDecorations(view.state, errors);+ unfoldErrorLines(view, errors);if (prevLength !== this.decorations.size) {// Force a re-renderdiff --git a/frontend/src/core/state/__mocks__/mocks.ts b/frontend/src/core/state/__mocks__/mocks.tsnew file mode 100644index 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));+ },+ };+}