@deepnote/convert 1.4.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepnote/convert",
-  "version": "1.4.0",
+  "version": "2.0.0",
   "description": "",
   "keywords": [],
   "repository": {
@@ -33,7 +33,7 @@
     "ora": "^9.0.0",
     "uuid": "^13.0.0",
     "yaml": "^2.8.1",
-    "@deepnote/blocks": "1.4.0"
+    "@deepnote/blocks": "2.0.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/dist/src-DgOsAHcf.js

@@ -1,309 +0,0 @@
-import fs from "node:fs/promises";
-import { basename, dirname, extname, join } from "node:path";
-import { createMarkdown, createPythonCode, deserializeDeepnoteFile, environmentSchema, executionSchema } from "@deepnote/blocks";
-import { v4 } from "uuid";
-import { stringify } from "yaml";
-
-//#region src/deepnote-to-jupyter.ts
-/**
-* Converts an array of Deepnote blocks into a single Jupyter Notebook.
-* This is the lowest-level conversion function, suitable for use in Deepnote Cloud.
-*
-* @param blocks - Array of DeepnoteBlock objects to convert
-* @param options - Notebook metadata options
-* @returns A JupyterNotebook object
-*
-* @example
-* ```typescript
-* import { convertBlocksToJupyterNotebook } from '@deepnote/convert'
-*
-* const notebook = convertBlocksToJupyterNotebook(blocks, {
-*   notebookId: 'abc123',
-*   notebookName: 'My Notebook',
-*   executionMode: 'block'
-* })
-* ```
-*/
-function convertBlocksToJupyterNotebook(blocks, options) {
-	return {
-		cells: blocks.map((block) => convertBlockToCell(block)),
-		metadata: {
-			deepnote_notebook_id: options.notebookId,
-			deepnote_notebook_name: options.notebookName,
-			deepnote_execution_mode: options.executionMode,
-			deepnote_is_module: options.isModule,
-			deepnote_working_directory: options.workingDirectory,
-			deepnote_environment: options.environment,
-			deepnote_execution: options.execution
-		},
-		nbformat: 4,
-		nbformat_minor: 0
-	};
-}
-/**
-* Converts a Deepnote project into Jupyter Notebook objects.
-* This is a pure conversion function that doesn't perform any file I/O.
-* Each notebook in the Deepnote project is converted to a separate Jupyter notebook.
-*
-* @param deepnoteFile - The deserialized Deepnote project file
-* @returns Array of objects containing filename and corresponding Jupyter notebook
-*
-* @example
-* ```typescript
-* import { deserializeDeepnoteFile } from '@deepnote/blocks'
-* import { convertDeepnoteToJupyterNotebooks } from '@deepnote/convert'
-*
-* const yamlContent = await fs.readFile('project.deepnote', 'utf-8')
-* const deepnoteFile = deserializeDeepnoteFile(yamlContent)
-* const notebooks = convertDeepnoteToJupyterNotebooks(deepnoteFile)
-*
-* for (const { filename, notebook } of notebooks) {
-*   console.log(`${filename}: ${notebook.cells.length} cells`)
-* }
-* ```
-*/
-function convertDeepnoteToJupyterNotebooks(deepnoteFile) {
-	return deepnoteFile.project.notebooks.map((notebook) => {
-		const jupyterNotebook = convertNotebookToJupyter(deepnoteFile, notebook);
-		return {
-			filename: `${sanitizeFileName(notebook.name)}.ipynb`,
-			notebook: jupyterNotebook
-		};
-	});
-}
-/**
-* Converts a Deepnote project file into separate Jupyter Notebook (.ipynb) files.
-* Each notebook in the Deepnote project becomes a separate .ipynb file.
-*/
-async function convertDeepnoteFileToJupyterFiles(deepnoteFilePath, options) {
-	const notebooks = convertDeepnoteToJupyterNotebooks(deserializeDeepnoteFile(await fs.readFile(deepnoteFilePath, "utf-8")));
-	await fs.mkdir(options.outputDir, { recursive: true });
-	for (const { filename, notebook } of notebooks) {
-		const filePath = join(options.outputDir, filename);
-		await fs.writeFile(filePath, JSON.stringify(notebook, null, 2), "utf-8");
-	}
-}
-function convertBlockToCell(block) {
-	const content = block.content || "";
-	const jupyterCellType = convertBlockTypeToJupyter(block.type);
-	const metadata = {
-		cell_id: block.id,
-		deepnote_block_group: block.blockGroup,
-		deepnote_cell_type: block.type,
-		deepnote_sorting_key: block.sortingKey,
-		deepnote_content_hash: block.contentHash,
-		deepnote_execution_started_at: block.executionStartedAt,
-		deepnote_execution_finished_at: block.executionFinishedAt,
-		...block.metadata || {}
-	};
-	metadata.deepnote_source = content;
-	return {
-		block_group: block.blockGroup,
-		cell_type: jupyterCellType,
-		execution_count: block.executionCount ?? null,
-		metadata,
-		outputs: block.outputs,
-		source: getSourceForBlock(block, jupyterCellType, content)
-	};
-}
-function getSourceForBlock(block, jupyterCellType, content) {
-	if (jupyterCellType === "markdown") return createMarkdown(block);
-	if (block.type === "code") return content;
-	return createPythonCode(block);
-}
-function convertBlockTypeToJupyter(blockType) {
-	const codeTypes = [
-		"big-number",
-		"button",
-		"code",
-		"notebook-function",
-		"sql",
-		"visualization"
-	];
-	if (blockType.startsWith("input-")) return "code";
-	return codeTypes.includes(blockType) ? "code" : "markdown";
-}
-function convertNotebookToJupyter(deepnoteFile, notebook) {
-	return convertBlocksToJupyterNotebook(notebook.blocks, {
-		notebookId: notebook.id,
-		notebookName: notebook.name,
-		executionMode: notebook.executionMode,
-		isModule: notebook.isModule,
-		workingDirectory: notebook.workingDirectory,
-		environment: deepnoteFile.environment,
-		execution: deepnoteFile.execution
-	});
-}
-function sanitizeFileName(name) {
-	return name.replace(/[<>:"/\\|?*]/g, "_").replace(/\s+/g, "-");
-}
-
-//#endregion
-//#region src/jupyter-to-deepnote.ts
-/**
-* Converts a single Jupyter Notebook into an array of Deepnote blocks.
-* This is the lowest-level conversion function, suitable for use in Deepnote Cloud.
-*
-* @param notebook - The Jupyter notebook object to convert
-* @param options - Optional conversion options including custom ID generator
-* @returns Array of DeepnoteBlock objects
-*
-* @example
-* ```typescript
-* import { convertJupyterNotebookToBlocks } from '@deepnote/convert'
-*
-* const notebook = JSON.parse(ipynbContent)
-* const blocks = convertJupyterNotebookToBlocks(notebook, {
-*   idGenerator: () => myCustomIdGenerator()
-* })
-* ```
-*/
-function convertJupyterNotebookToBlocks(notebook, options) {
-	const idGenerator = options?.idGenerator ?? v4;
-	return notebook.cells.map((cell, index) => convertCellToBlock(cell, index, idGenerator));
-}
-/**
-* Converts Jupyter Notebook objects into a Deepnote project file.
-* This is a pure conversion function that doesn't perform any file I/O.
-*
-* @param notebooks - Array of Jupyter notebooks with filenames
-* @param options - Conversion options including project name
-* @returns A DeepnoteFile object
-*/
-function convertJupyterNotebooksToDeepnote(notebooks, options) {
-	let environment;
-	let execution;
-	for (const { notebook } of notebooks) {
-		if (!environment && notebook.metadata?.deepnote_environment) {
-			const parsed = environmentSchema.safeParse(notebook.metadata.deepnote_environment);
-			if (parsed.success) environment = parsed.data;
-		}
-		if (!execution && notebook.metadata?.deepnote_execution) {
-			const parsed = executionSchema.safeParse(notebook.metadata.deepnote_execution);
-			if (parsed.success) execution = parsed.data;
-		}
-	}
-	const deepnoteFile = {
-		environment,
-		execution,
-		metadata: { createdAt: (/* @__PURE__ */ new Date()).toISOString() },
-		project: {
-			id: v4(),
-			initNotebookId: void 0,
-			integrations: [],
-			name: options.projectName,
-			notebooks: [],
-			settings: {}
-		},
-		version: "1.0.0"
-	};
-	for (const { filename, notebook } of notebooks) {
-		const filenameWithoutExt = basename(filename, extname(filename)) || "Untitled notebook";
-		const blocks = convertJupyterNotebookToBlocks(notebook);
-		const notebookId = notebook.metadata?.deepnote_notebook_id;
-		const notebookName = notebook.metadata?.deepnote_notebook_name;
-		const executionMode = notebook.metadata?.deepnote_execution_mode;
-		const isModule = notebook.metadata?.deepnote_is_module;
-		const workingDirectory = notebook.metadata?.deepnote_working_directory;
-		deepnoteFile.project.notebooks.push({
-			blocks,
-			executionMode: executionMode ?? "block",
-			id: notebookId ?? v4(),
-			isModule: isModule ?? false,
-			name: notebookName ?? filenameWithoutExt,
-			workingDirectory
-		});
-	}
-	return deepnoteFile;
-}
-/**
-* Converts multiple Jupyter Notebook (.ipynb) files into a single Deepnote project file.
-*/
-async function convertIpynbFilesToDeepnoteFile(inputFilePaths, options) {
-	const notebooks = [];
-	for (const filePath of inputFilePaths) {
-		const notebook = await parseIpynbFile(filePath);
-		notebooks.push({
-			filename: basename(filePath),
-			notebook
-		});
-	}
-	const yamlContent = stringify(convertJupyterNotebooksToDeepnote(notebooks, { projectName: options.projectName }));
-	const parentDir = dirname(options.outputPath);
-	await fs.mkdir(parentDir, { recursive: true });
-	await fs.writeFile(options.outputPath, yamlContent, "utf-8");
-}
-async function parseIpynbFile(filePath) {
-	let ipynbJson;
-	try {
-		ipynbJson = await fs.readFile(filePath, "utf-8");
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Failed to read ${filePath}: ${message}`);
-	}
-	try {
-		return JSON.parse(ipynbJson);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Failed to parse ${filePath}: invalid JSON - ${message}`);
-	}
-}
-function convertCellToBlock(cell, index, idGenerator) {
-	let source = Array.isArray(cell.source) ? cell.source.join("") : cell.source;
-	const cellId = cell.metadata?.cell_id;
-	const deepnoteCellType = cell.metadata?.deepnote_cell_type;
-	const sortingKey = cell.metadata?.deepnote_sorting_key;
-	const contentHash = cell.metadata?.deepnote_content_hash;
-	const executionStartedAt = cell.metadata?.deepnote_execution_started_at;
-	const executionFinishedAt = cell.metadata?.deepnote_execution_finished_at;
-	const blockGroup = cell.metadata?.deepnote_block_group ?? cell.block_group ?? idGenerator();
-	const deepnoteSource = cell.metadata?.deepnote_source;
-	if (deepnoteSource !== void 0) source = deepnoteSource;
-	const blockType = deepnoteCellType ?? (cell.cell_type === "code" ? "code" : "markdown");
-	const originalMetadata = { ...cell.metadata };
-	delete originalMetadata.cell_id;
-	delete originalMetadata.deepnote_cell_type;
-	delete originalMetadata.deepnote_block_group;
-	delete originalMetadata.deepnote_sorting_key;
-	delete originalMetadata.deepnote_source;
-	delete originalMetadata.deepnote_content_hash;
-	delete originalMetadata.deepnote_execution_started_at;
-	delete originalMetadata.deepnote_execution_finished_at;
-	delete cell.block_group;
-	const executionCount = cell.execution_count ?? void 0;
-	const hasExecutionCount = executionCount !== void 0;
-	const hasOutputs = cell.cell_type === "code" && cell.outputs !== void 0;
-	return {
-		blockGroup,
-		content: source,
-		...contentHash ? { contentHash } : {},
-		...hasExecutionCount ? { executionCount } : {},
-		...executionFinishedAt ? { executionFinishedAt } : {},
-		...executionStartedAt ? { executionStartedAt } : {},
-		id: cellId ?? idGenerator(),
-		metadata: originalMetadata,
-		...hasOutputs ? { outputs: cell.outputs } : {},
-		sortingKey: sortingKey ?? createSortingKey(index),
-		type: blockType
-	};
-}
-function createSortingKey(index) {
-	const maxLength = 6;
-	const chars = "0123456789abcdefghijklmnopqrstuvwxyz";
-	const base = 36;
-	if (index < 0) throw new Error("Index must be non-negative");
-	let result = "";
-	let num = index + 1;
-	let iterations = 0;
-	while (num > 0 && iterations < maxLength) {
-		num--;
-		result = chars[num % base] + result;
-		num = Math.floor(num / base);
-		iterations++;
-	}
-	if (num > 0) throw new Error(`Index ${index} exceeds maximum key length of ${maxLength}`);
-	return result;
-}
-
-//#endregion
-export { convertDeepnoteFileToJupyterFiles as a, convertBlocksToJupyterNotebook as i, convertJupyterNotebookToBlocks as n, convertDeepnoteToJupyterNotebooks as o, convertJupyterNotebooksToDeepnote as r, convertIpynbFilesToDeepnoteFile as t };