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 { type FilePath, Paths, PathBuilder } from "./paths";
/**
* Get the protocol and parent directories of a path.
*/
export function getProtocolAndParentDirectories({
path,
delimiter,
initialPath,
restrictNavigation,
}: {
path: string;
delimiter: string;
initialPath: string;
restrictNavigation: boolean;
}) {
// Determine protocol (http://, gs://, C:\, s3://, or /)
const protocolMatch = path.match(/^[\dA-Za-z]+:\/\//);
const isWindowsPath = /^[A-Za-z]:\\/.test(path);
const protocol = protocolMatch
? protocolMatch[0]
: isWindowsPath
? path.slice(0, 3)
: "/";
// Remove protocol from path
const pathWithoutProtocol = isWindowsPath
? path.slice(protocol.length)
: protocolMatch
? path.slice(protocol.length)
: path;
// Split path into segments
const segments = pathWithoutProtocol.split(delimiter).filter(Boolean);
// Build parent directories from segments
let parentDirectories: string[] = [];
if (isWindowsPath) {
// Handle Windows paths differently
for (let i = segments.length; i >= 0; i--) {
const dirPath = protocol + segments.slice(0, i).join(delimiter);
parentDirectories.push(dirPath);
}
} else {
// Handle non-Windows paths
let currentPath = protocol;
for (let i = 0; i <= segments.length; i++) {
const dirPath = currentPath + segments.slice(0, i).join(delimiter);
parentDirectories.push(dirPath);
// Add delimiter if not already present
if (i < segments.length && !currentPath.endsWith(delimiter)) {
currentPath += delimiter;
}
}
// Reverse to get parent directories in descending order
parentDirectories.reverse();
}
// Filter to paths within initial path if navigation is restricted
if (restrictNavigation) {
parentDirectories = parentDirectories.filter((dir) =>
dir.startsWith(initialPath),
);
}
return { protocol, parentDirectories };
}
export function fileSplit(path: string): [name: string, extension: string] {
const lastDotIndex = path.lastIndexOf(".");
const name = lastDotIndex > 0 ? path.slice(0, lastDotIndex) : path;
const extension = lastDotIndex > 0 ? path.slice(lastDotIndex) : "";
return [name, extension];
}
/**
* Build the "_copy" filename used for duplicate operations.
* e.g. `foo.py` → `foo_copy.py`, `README` → `README_copy`.
*/
export function makeDuplicateName(name: string): string {
const [base, extension] = fileSplit(name);
return `${base}_copy${extension}`;
}
/**
* Return `path` as an absolute path, joining against `root` when it's
* workspace-relative. `root`'s delimiter determines the join style so
* Windows and POSIX paths both behave correctly.
*/
export function toAbsolutePath(path: string, root: string): FilePath {
if (Paths.isAbsolute(path)) {
return path as FilePath;
}
return PathBuilder.guessDeliminator(root).join(root, path as FilePath);
}
/**
* Resolve absolute current/new paths for a rename- or copy-style operation.
* Given a node's current `path` (absolute or workspace-relative) and a
* desired new `name` (basename only), returns the absolute source and the
* absolute destination, keeping the file in the same parent directory.
*/
export function resolvePaths({
path,
name,
root,
}: {
path: string;
name: string;
root: string;
}): { path: FilePath; newPath: FilePath } {
const absPath = toAbsolutePath(path, root);
// When `root` is empty (callers with already-absolute paths), fall back to
// the resolved absolute path so we don't default to the Windows delimiter.
const pathBuilder = PathBuilder.guessDeliminator(root || absPath);
const newPath = pathBuilder.join(pathBuilder.dirname(absPath), name);
return { path: absPath, newPath };
}