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 {
GridCellKind,
GridColumnIcon,
type GridSelection,
} from "@glideapps/glide-data-grid";
import type { DataType } from "@/core/kernel/messages";
import { logNever } from "@/utils/assertNever";
import { Logger } from "@/utils/Logger";
import type {
ColumnEdit,
EditorRow,
Edits,
ModifiedGridColumn,
PositionalEdit,
RemoveRowEdit,
} from "./types";
export function getColumnKind(fieldType: DataType): GridCellKind {
switch (fieldType) {
case "string":
return GridCellKind.Text;
case "number":
return GridCellKind.Number;
case "boolean":
return GridCellKind.Boolean;
case "integer":
case "date":
case "datetime":
case "time":
case "geometry":
case "unknown":
return GridCellKind.Text;
default:
logNever(fieldType);
return GridCellKind.Text;
}
}
export function getColumnHeaderIcon(fieldType: DataType): GridColumnIcon {
switch (fieldType) {
case "string":
return GridColumnIcon.HeaderString;
case "number":
case "integer":
return GridColumnIcon.HeaderNumber;
case "boolean":
return GridColumnIcon.HeaderBoolean;
case "date":
case "datetime":
return GridColumnIcon.HeaderDate;
case "time":
return GridColumnIcon.HeaderTime;
case "geometry":
case "unknown":
return GridColumnIcon.HeaderString;
default:
logNever(fieldType);
return GridColumnIcon.HeaderString;
}
}
export function isValidCellValue(
dataType: DataType | undefined,
value: unknown,
): boolean {
switch (dataType) {
case "number":
return Number.isFinite(Number(value));
case "integer":
if (typeof value === "bigint") {
return true;
}
if (typeof value === "number") {
return Number.isFinite(value) && Number.isInteger(value);
}
if (typeof value === "string") {
const normalized = value.trim();
return /^[+-]?[0-9]+(?:\.0+)?$/u.test(normalized);
}
return false;
case "boolean":
return typeof value === "boolean";
case undefined:
case "string":
case "date":
case "datetime":
case "time":
case "geometry":
case "unknown":
return true;
default:
logNever(dataType);
return false;
}
}
export function isPositionalEdit(
edit: Edits["edits"][number],
): edit is PositionalEdit {
return "rowIdx" in edit && "columnId" in edit && "value" in edit;
}
export function isRowEdit(edit: Edits["edits"][number]): edit is RemoveRowEdit {
return "rowIdx" in edit && "type" in edit;
}
export function isColumnEdit(edit: Edits["edits"][number]): edit is ColumnEdit {
return "columnIdx" in edit && "type" in edit;
}
export function pasteCells(options: {
selection: GridSelection;
data: EditorRow[];
columns: ModifiedGridColumn[];
editableColumns: string[] | "all";
onAddEdits: (edits: Edits["edits"]) => void;
}) {
const { selection, data, onAddEdits, columns, editableColumns } = options;
if (!selection.current) {
return;
}
const { range } = selection.current;
const { x: startCol, y: startRow } = range;
// Read clipboard data
navigator.clipboard
.readText()
.then((clipboardText) => {
if (!clipboardText.trim()) {
return;
}
// Parse tab-separated values
const rows = clipboardText.split("\n").filter((row) => row.trim());
const parsedData: string[][] = [];
for (const row of rows) {
const cells = row.split("\t");
parsedData.push(cells);
}
if (parsedData.length === 0) {
return;
}
const edits: Edits["edits"] = [];
const editableColumnSet =
editableColumns === "all" ? null : new Set(editableColumns);
for (const [rowIndex, dataRow] of parsedData.entries()) {
if (!dataRow) {
continue;
}
const targetRowIdx = startRow + rowIndex;
// Check if we've exceeded the data bounds
if (targetRowIdx >= data.length) {
break;
}
for (const [colIndex, cellValue] of dataRow.entries()) {
if (cellValue === undefined) {
continue;
}
const targetColIdx = startCol + colIndex;
// Check if we've exceeded the column bounds
if (targetColIdx >= columns.length) {
break;
}
const column = columns[targetColIdx];
const columnType = column.dataType;
const editable =
editableColumnSet === null || editableColumnSet.has(column.title);
if (!editable) {
continue;
}
// Convert the value based on the cell type
let convertedValue: unknown = cellValue;
switch (columnType) {
case "integer": {
const numValue = Number(cellValue);
if (!isValidCellValue(columnType, cellValue)) {
continue;
}
convertedValue = Number.isSafeInteger(numValue)
? numValue
: cellValue.trim();
break;
}
case "number": {
const numValue = Number(cellValue);
if (!isValidCellValue(columnType, numValue)) {
continue;
}
convertedValue = numValue;
break;
}
case "boolean": {
const boolValue = cellValue.toLowerCase();
convertedValue = boolValue === "true" || boolValue === "1";
break;
}
case "string":
case "date":
case "datetime":
case "time":
case "geometry":
case "unknown":
break;
default:
logNever(columnType);
continue;
}
// Get the column ID from the columns array using the title
const columnId = columns[targetColIdx].title;
edits.push({
rowIdx: targetRowIdx,
columnId,
value: convertedValue,
});
}
}
if (edits.length > 0) {
onAddEdits(edits);
}
})
.catch((error) => {
Logger.error("Failed to read clipboard data", error);
});
}