@deepnote/convert 2.1.0 → 2.1.2

package/dist/bin.cjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+const require_src = require('./src-DI6mrd_2.cjs');
+let cleye = require("cleye");
+cleye = require_src.__toESM(cleye);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_src.__toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = require_src.__toESM(node_path);
+let chalk = require("chalk");
+chalk = require_src.__toESM(chalk);
+let ora = require("ora");
+ora = require_src.__toESM(ora);
+
+//#region src/cli.ts
+async function convert(options) {
+	const { inputPath, projectName: customProjectName, outputPath: customOutputPath, cwd = process.cwd(), outputFormat = "jupyter" } = options;
+	const resolveProjectName = (possibleName) => {
+		if (customProjectName) return customProjectName;
+		if (possibleName) return possibleName;
+		return "Untitled project";
+	};
+	const resolveOutputPath = async (outputFilename) => {
+		if (customOutputPath) {
+			const absoluteOutputPath = (0, node_path.resolve)(cwd, customOutputPath);
+			if ((await node_fs_promises.default.stat(absoluteOutputPath).catch(() => null))?.isDirectory()) return (0, node_path.resolve)(absoluteOutputPath, outputFilename);
+			return absoluteOutputPath;
+		}
+		return (0, node_path.resolve)(cwd, outputFilename);
+	};
+	const absolutePath = (0, node_path.resolve)(cwd, inputPath);
+	if ((await node_fs_promises.default.stat(absolutePath)).isDirectory()) {
+		const entries = await node_fs_promises.default.readdir(absolutePath, { withFileTypes: true });
+		const ipynbFiles = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".ipynb")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+		const quartoFiles = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".qmd")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+		const pyFiles = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".py")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+		const classifyPyFile = async (pyFile) => {
+			const content = await node_fs_promises.default.readFile((0, node_path.resolve)(absolutePath, pyFile), "utf-8");
+			if (require_src.isMarimoContent(content)) return {
+				file: pyFile,
+				type: "marimo"
+			};
+			if (require_src.isPercentContent(content)) return {
+				file: pyFile,
+				type: "percent"
+			};
+			return {
+				file: pyFile,
+				type: "unknown"
+			};
+		};
+		const CONCURRENCY_LIMIT = 10;
+		const results = [];
+		for (let i = 0; i < pyFiles.length; i += CONCURRENCY_LIMIT) {
+			const batch = pyFiles.slice(i, i + CONCURRENCY_LIMIT);
+			const batchResults = await Promise.all(batch.map(classifyPyFile));
+			results.push(...batchResults);
+		}
+		const marimoFiles = results.filter((r) => r.type === "marimo").map((r) => r.file);
+		const percentFiles = results.filter((r) => r.type === "percent").map((r) => r.file);
+		if (ipynbFiles.length > 0) return convertDirectory(absolutePath, ipynbFiles, "jupyter", resolveProjectName, resolveOutputPath);
+		if (quartoFiles.length > 0) return convertDirectory(absolutePath, quartoFiles, "quarto", resolveProjectName, resolveOutputPath);
+		if (marimoFiles.length > 0) return convertDirectory(absolutePath, marimoFiles, "marimo", resolveProjectName, resolveOutputPath);
+		if (percentFiles.length > 0) return convertDirectory(absolutePath, percentFiles, "percent", resolveProjectName, resolveOutputPath);
+		throw new Error("No supported notebook files found in the specified directory (.ipynb, .qmd, .py)");
+	}
+	const ext = (0, node_path.extname)(absolutePath).toLowerCase();
+	if (ext === ".ipynb") return convertJupyterToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
+	if (ext === ".qmd") return convertQuartoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
+	if (ext === ".py") {
+		const content = await node_fs_promises.default.readFile(absolutePath, "utf-8");
+		if (require_src.isMarimoContent(content)) return convertMarimoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
+		if (require_src.isPercentContent(content)) return convertPercentToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
+		throw new Error("Unsupported Python file format. File must be a percent format (# %% markers) or Marimo notebook (@app.cell decorators).");
+	}
+	if (ext === ".deepnote") return convertDeepnoteToFormat(absolutePath, outputFormat, customOutputPath, cwd);
+	throw new Error("Unsupported file type. Please provide a .ipynb, .qmd, .py (percent/marimo), or .deepnote file.");
+}
+async function convertDirectory(dirPath, files, format, resolveProjectName, resolveOutputPath) {
+	const spinner = (0, ora.default)(`Converting ${{
+		jupyter: "Jupyter Notebooks",
+		quarto: "Quarto documents",
+		percent: "percent format notebooks",
+		marimo: "Marimo notebooks"
+	}[format]} to a Deepnote project...`).start();
+	try {
+		const filenameWithoutExtension = (0, node_path.basename)(dirPath);
+		const projectName = resolveProjectName(filenameWithoutExtension);
+		const outputPath = await resolveOutputPath(`${filenameWithoutExtension}.deepnote`);
+		const inputFilePaths = files.map((file) => (0, node_path.resolve)(dirPath, file));
+		switch (format) {
+			case "jupyter":
+				await require_src.convertIpynbFilesToDeepnoteFile(inputFilePaths, {
+					projectName,
+					outputPath
+				});
+				break;
+			case "quarto":
+				await require_src.convertQuartoFilesToDeepnoteFile(inputFilePaths, {
+					projectName,
+					outputPath
+				});
+				break;
+			case "percent":
+				await require_src.convertPercentFilesToDeepnoteFile(inputFilePaths, {
+					projectName,
+					outputPath
+				});
+				break;
+			case "marimo":
+				await require_src.convertMarimoFilesToDeepnoteFile(inputFilePaths, {
+					projectName,
+					outputPath
+				});
+				break;
+		}
+		spinner.succeed(`The Deepnote project has been saved to ${chalk.default.bold(outputPath)}`);
+		return outputPath;
+	} catch (error) {
+		spinner.fail("Conversion failed");
+		throw error;
+	}
+}
+async function convertSingleFileToDeepnote(absolutePath, formatName, converter, resolveProjectName, resolveOutputPath) {
+	const spinner = (0, ora.default)(`Converting the ${formatName} to a Deepnote project...`).start();
+	try {
+		const filenameWithoutExtension = (0, node_path.basename)(absolutePath, (0, node_path.extname)(absolutePath));
+		const projectName = resolveProjectName(filenameWithoutExtension);
+		const outputPath = await resolveOutputPath(`${filenameWithoutExtension}.deepnote`);
+		await converter([absolutePath], {
+			projectName,
+			outputPath
+		});
+		spinner.succeed(`The Deepnote project has been saved to ${chalk.default.bold(outputPath)}`);
+		return outputPath;
+	} catch (error) {
+		spinner.fail("Conversion failed");
+		throw error;
+	}
+}
+function convertJupyterToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
+	return convertSingleFileToDeepnote(absolutePath, "Jupyter Notebook", require_src.convertIpynbFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+}
+function convertQuartoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
+	return convertSingleFileToDeepnote(absolutePath, "Quarto document", require_src.convertQuartoFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+}
+function convertPercentToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
+	return convertSingleFileToDeepnote(absolutePath, "percent format notebook", require_src.convertPercentFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+}
+function convertMarimoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
+	return convertSingleFileToDeepnote(absolutePath, "Marimo notebook", require_src.convertMarimoFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+}
+async function convertDeepnoteToFormat(absolutePath, outputFormat, customOutputPath, cwd) {
+	const formatNames = {
+		jupyter: "Jupyter Notebooks",
+		percent: "percent format files",
+		quarto: "Quarto documents",
+		marimo: "Marimo notebooks"
+	};
+	const spinner = (0, ora.default)(`Converting Deepnote project to ${formatNames[outputFormat]}...`).start();
+	try {
+		const outputDirName = (0, node_path.basename)(absolutePath, (0, node_path.extname)(absolutePath));
+		const outputDir = customOutputPath ? (0, node_path.resolve)(cwd, customOutputPath) : (0, node_path.resolve)(cwd, outputDirName);
+		switch (outputFormat) {
+			case "jupyter":
+				await require_src.convertDeepnoteFileToJupyterFiles(absolutePath, { outputDir });
+				break;
+			case "percent":
+				await require_src.convertDeepnoteFileToPercentFiles(absolutePath, { outputDir });
+				break;
+			case "quarto":
+				await require_src.convertDeepnoteFileToQuartoFiles(absolutePath, { outputDir });
+				break;
+			case "marimo":
+				await require_src.convertDeepnoteFileToMarimoFiles(absolutePath, { outputDir });
+				break;
+		}
+		spinner.succeed(`${formatNames[outputFormat]} have been saved to ${chalk.default.bold(outputDir)}`);
+		return outputDir;
+	} catch (error) {
+		spinner.fail("Conversion failed");
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/bin.ts
+async function main() {
+	const argv = (0, cleye.cli)({
+		name: "deepnote-convert",
+		parameters: ["<path>"],
+		flags: {
+			projectName: {
+				description: "The name of the Deepnote project.",
+				type: String
+			},
+			outputPath: {
+				alias: "o",
+				description: "The path where the .deepnote file will be saved.",
+				type: String
+			},
+			cwd: {
+				description: "The working directory to resolve paths relative to.",
+				type: String
+			}
+		}
+	});
+	await convert({
+		inputPath: argv._.path,
+		projectName: argv.flags.projectName,
+		outputPath: argv.flags.outputPath,
+		cwd: argv.flags.cwd ?? process.cwd()
+	});
+}
+if (process.env.NODE_ENV !== "test" && process.env.VITEST !== "true") main().catch((error) => {
+	console.error(error);
+	process.exit(1);
+});
+
+//#endregion

package/dist/bin.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/index.cjs

@@ -0,0 +1,33 @@
+const require_src = require('./src-DI6mrd_2.cjs');
+
+exports.convertBlocksToJupyterNotebook = require_src.convertBlocksToJupyterNotebook;
+exports.convertBlocksToMarimoApp = require_src.convertBlocksToMarimoApp;
+exports.convertBlocksToPercentNotebook = require_src.convertBlocksToPercentNotebook;
+exports.convertBlocksToQuartoDocument = require_src.convertBlocksToQuartoDocument;
+exports.convertDeepnoteFileToJupyter = require_src.convertDeepnoteFileToJupyterFiles;
+exports.convertDeepnoteFileToMarimoFiles = require_src.convertDeepnoteFileToMarimoFiles;
+exports.convertDeepnoteFileToPercentFiles = require_src.convertDeepnoteFileToPercentFiles;
+exports.convertDeepnoteFileToQuartoFiles = require_src.convertDeepnoteFileToQuartoFiles;
+exports.convertDeepnoteToJupyterNotebooks = require_src.convertDeepnoteToJupyterNotebooks;
+exports.convertDeepnoteToMarimoApps = require_src.convertDeepnoteToMarimoApps;
+exports.convertDeepnoteToPercentNotebooks = require_src.convertDeepnoteToPercentNotebooks;
+exports.convertDeepnoteToQuartoDocuments = require_src.convertDeepnoteToQuartoDocuments;
+exports.convertIpynbFilesToDeepnoteFile = require_src.convertIpynbFilesToDeepnoteFile;
+exports.convertJupyterNotebookToBlocks = require_src.convertJupyterNotebookToBlocks;
+exports.convertJupyterNotebooksToDeepnote = require_src.convertJupyterNotebooksToDeepnote;
+exports.convertMarimoAppToBlocks = require_src.convertMarimoAppToBlocks;
+exports.convertMarimoAppsToDeepnote = require_src.convertMarimoAppsToDeepnote;
+exports.convertMarimoFilesToDeepnoteFile = require_src.convertMarimoFilesToDeepnoteFile;
+exports.convertPercentFilesToDeepnoteFile = require_src.convertPercentFilesToDeepnoteFile;
+exports.convertPercentNotebookToBlocks = require_src.convertPercentNotebookToBlocks;
+exports.convertPercentNotebooksToDeepnote = require_src.convertPercentNotebooksToDeepnote;
+exports.convertQuartoDocumentToBlocks = require_src.convertQuartoDocumentToBlocks;
+exports.convertQuartoDocumentsToDeepnote = require_src.convertQuartoDocumentsToDeepnote;
+exports.convertQuartoFilesToDeepnoteFile = require_src.convertQuartoFilesToDeepnoteFile;
+exports.detectFormat = require_src.detectFormat;
+exports.parseMarimoFormat = require_src.parseMarimoFormat;
+exports.parsePercentFormat = require_src.parsePercentFormat;
+exports.parseQuartoFormat = require_src.parseQuartoFormat;
+exports.serializeMarimoFormat = require_src.serializeMarimoFormat;
+exports.serializePercentFormat = require_src.serializePercentFormat;
+exports.serializeQuartoFormat = require_src.serializeQuartoFormat;