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
/* Copyright 2026 Marimo. All rights reserved. */
import {
EditorSelection,
type SelectionRange,
Text,
Transaction,
} from "@codemirror/state";
import type { EditorView } from "@codemirror/view";
import { toast } from "@/components/ui/use-toast";
import { getRequestClient } from "@/core/network/requests";
import { filenameAtom } from "@/core/saving/file-state";
import { store } from "@/core/state/jotai";
import { type FilePath, Paths } from "@/utils/paths";
const MAX_BASE64_SIZE_KB = 100;
function hasSelection(view: EditorView) {
return !view.state.selection.main.empty;
}
function toggleAllLines({
view,
selection,
markup,
}: {
view: EditorView;
selection: SelectionRange;
markup: string;
}) {
const changes = [];
let allLinesHaveMarkup = true;
for (let pos = selection.from; pos <= selection.to; pos++) {
const line = view.state.doc.lineAt(pos);
const lineText = line.text;
if (!lineText.startsWith(markup)) {
allLinesHaveMarkup = false;
break;
}
}
for (let pos = selection.from; pos <= selection.to;) {
const line = view.state.doc.lineAt(pos);
const lineText = line.text;
const hasMarkup = lineText.startsWith(markup);
if (allLinesHaveMarkup) {
changes.push({
from: line.from,
to: line.from + markup.length,
insert: Text.of([""]),
});
} else {
if (hasMarkup) {
changes.push({
from: line.from,
to: line.from + markup.length,
insert: Text.of([""]),
});
}
changes.push({
from: line.from,
insert: Text.of([markup]),
});
}
pos = line.to + 1; // Move to the start of the next line
}
return changes;
}
function wrapWithMarkup({
view,
range,
markupAfter,
markupBefore,
}: {
view: EditorView;
range: SelectionRange;
markupBefore: string;
markupAfter: string;
}) {
if (range.empty) {
const wordRange = view.state.wordAt(range.head);
if (wordRange) {
range = wordRange;
}
}
const isMarkupBefore =
view.state.sliceDoc(range.from - markupBefore.length, range.from) ===
markupBefore;
const isMarkupAfter =
view.state.sliceDoc(range.to, range.to + markupAfter.length) ===
markupAfter;
const changes = [];
changes.push(
isMarkupBefore
? {
from: range.from - markupBefore.length,
to: range.from,
insert: Text.of([""]),
}
: {
from: range.from,
insert: Text.of(markupBefore.split("\n")),
},
isMarkupAfter
? {
from: range.to,
to: range.to + markupAfter.length,
insert: Text.of([""]),
}
: {
from: range.to,
insert: Text.of(markupAfter.split("\n")),
},
);
const extendBefore = isMarkupBefore
? -markupBefore.length
: markupBefore.length;
const extendAfter = isMarkupAfter ? -markupAfter.length : markupAfter.length;
return {
changes,
range: EditorSelection.range(
range.from + extendBefore,
range.to + extendAfter,
),
};
}
export function insertBlockquote(view: EditorView) {
// Only apply on selection
if (!hasSelection(view)) {
return false;
}
const markup = "> ";
const changes = toggleAllLines({
view,
selection: view.state.selection.main,
markup,
});
if (changes.length > 0) {
view.dispatch(
view.state.update({ changes, scrollIntoView: true, userEvent: "input" }),
);
}
view.focus();
return true;
}
export function insertBoldMarker(view: EditorView) {
// Only apply on selection
if (!hasSelection(view)) {
return false;
}
const changes = view.state.changeByRange((range) => {
if (range.empty) {
const wordRange = view.state.wordAt(range.head);
if (wordRange) {
range = wordRange;
}
}
return wrapWithMarkup({
view,
range,
markupBefore: "**",
markupAfter: "**",
});
});
view.dispatch(
view.state.update(changes, {
scrollIntoView: true,
annotations: Transaction.userEvent.of("input"),
}),
);
view.focus();
return true;
}
export function insertCodeMarker(view: EditorView) {
// Only apply on selection
if (!hasSelection(view)) {
return false;
}
const changes = view.state.changeByRange((range) => {
if (range.empty) {
const wordRange = view.state.wordAt(range.head);
if (wordRange) {
range = wordRange;
}
}
const lineFrom = view.state.doc.lineAt(range.from).number;
const lineTo = view.state.doc.lineAt(range.to).number;
const isMultiline = lineFrom !== lineTo;
const fenceBefore = isMultiline ? "```\n" : "`";
const fenceAfter = isMultiline ? "\n```" : "`";
return wrapWithMarkup({
view,
range,
markupBefore: fenceBefore,
markupAfter: fenceAfter,
});
});
view.dispatch(
view.state.update(changes, {
scrollIntoView: true,
annotations: Transaction.userEvent.of("input"),
}),
);
view.focus();
return true;
}
export function insertItalicMarker(view: EditorView) {
// Apply with or without selection
const changes = view.state.changeByRange((range) => {
if (range.empty) {
const wordRange = view.state.wordAt(range.head);
if (wordRange) {
range = wordRange;
}
}
return wrapWithMarkup({ view, range, markupBefore: "_", markupAfter: "_" });
});
view.dispatch(
view.state.update(changes, {
scrollIntoView: true,
annotations: Transaction.userEvent.of("input"),
}),
);
view.focus();
return true;
}
export function insertLink(view: EditorView, url = "http://") {
// Only apply on selection
if (!hasSelection(view)) {
return false;
}
const changes = view.state.changeByRange((range) => {
const text = view.state.sliceDoc(range.from, range.to);
return {
changes: [
{ from: range.from, to: range.to, insert: `[${text}](${url})` },
],
range,
};
});
view.dispatch(
view.state.update(changes, {
scrollIntoView: true,
annotations: Transaction.userEvent.of("input"),
}),
);
const { to } = changes.selection.main;
// Can fail in tests
try {
view.dispatch({
selection: EditorSelection.create([
EditorSelection.range(to + 3, to + 3 + url.length),
EditorSelection.cursor(to + 3 + url.length),
]),
});
} catch {
// Do nothing
}
view.focus();
return true;
}
export async function insertImage(view: EditorView, file: File) {
const reader = new FileReader();
const dataUrl = await new Promise<string>((resolve) => {
reader.onload = () => resolve(reader.result as string);
reader.readAsDataURL(file);
});
let savedFilePath: string | undefined;
// If the file is base64 encoded, we can save it locally to prevent large file strings
try {
if (dataUrl.startsWith("data:")) {
let inputFilename = prompt(
"We can save your image as a file. Enter a filename.",
file.name,
);
const extension = file.type.split("/")[1];
// A cancelled prompt returns null
if (inputFilename === null) {
// Large strings do not make sense to write/save to the document
const base64SizeKB = Math.round(dataUrl.length / 1024);
if (base64SizeKB > MAX_BASE64_SIZE_KB) {
toast({
title: "Content too large",
description: `The content size is ${base64SizeKB} KB, which is too large to paste directly into the document.`,
});
return;
}
} else {
if (inputFilename.trim() === "") {
inputFilename = file.name;
} else if (!inputFilename.endsWith(`.${extension}`)) {
inputFilename = `${inputFilename}.${extension}`;
}
const filepath = store.get(filenameAtom);
const notebookDir = filepath ? Paths.dirname(filepath) : null;
const publicFolderPath = notebookDir
? `${notebookDir}/public`
: "public";
const createFileRes = await getRequestClient().sendCreateFileOrFolder({
path: publicFolderPath as FilePath,
type: "file",
name: inputFilename,
file,
});
if (createFileRes.success) {
savedFilePath = createFileRes.info?.path;
// We want the relative path to the public folder
if (
savedFilePath &&
notebookDir &&
savedFilePath.startsWith(notebookDir)
) {
savedFilePath = Paths.rest(savedFilePath, notebookDir).replaceAll(
"\\",
"/",
);
}
toast({
title: "Image uploaded successfully",
description: `We've uploaded your image at ${savedFilePath}`,
});
} else {
toast({
title: "Failed to upload image. Using raw base64 string.",
});
}
}
}
} catch {
toast({
title: "Failed to upload image. Using raw base64 string.",
});
}
const changes = view.state.changeByRange((range) => {
let text = view.state.sliceDoc(range.from, range.to);
if (text.trim() === "") {
text = "alt";
}
return {
changes: [
{
from: range.from,
to: range.to,
insert: ``,
},
],
range,
};
});
view.dispatch(
view.state.update(changes, {
scrollIntoView: true,
annotations: Transaction.userEvent.of("input"),
}),
);
const { to } = changes.selection.main;
try {
view.dispatch({
selection: EditorSelection.create([
EditorSelection.range(to + 4, to + 4 + dataUrl.length),
EditorSelection.cursor(to + 4 + dataUrl.length),
]),
});
} catch {
// Do nothing
}
view.focus();
return true;
}
export async function insertTextFile(view: EditorView, file: File) {
const text = await file.text();
// Just insert at the cursor
const changes = view.state.changeByRange((range) => {
return {
// Insert at the start of the range, don't replace any existing text
changes: [{ from: range.from, to: range.from, insert: text }],
range,
};
});
view.dispatch(
view.state.update(changes, {
scrollIntoView: true,
annotations: Transaction.userEvent.of("input"),
}),
);
view.focus();
return true;
}
export function insertUL(view: EditorView) {
// Only apply on selection
if (!hasSelection(view)) {
return false;
}
const { changes } = view.state.changeByRange((range) => {
const markupOne = "- ";
const markupTwo = "* ";
const rangeText = view.state
.sliceDoc(range.from, range.to + markupTwo.length)
.startsWith(markupTwo)
? markupTwo
: markupOne;
return {
range,
changes: toggleAllLines({ view, selection: range, markup: rangeText }),
};
});
if (changes.length > 0) {
view.dispatch(
view.state.update({ changes, scrollIntoView: true, userEvent: "input" }),
);
}
view.focus();
return true;
}
export function insertOL(view: EditorView) {
// Only apply on selection
if (!hasSelection(view)) {
return false;
}
const { changes } = view.state.changeByRange((range) => {
const markup = "1. ";
return {
range,
changes: toggleAllLines({ view, selection: range, markup }),
};
});
if (changes.length > 0) {
view.dispatch(
view.state.update({ changes, scrollIntoView: true, userEvent: "input" }),
);
}
view.focus();
return true;
}