@deepnote/blocks 3.0.1 → 3.2.1

package/dist/index.cjs

@@ -28,6 +28,48 @@ yaml = __toESM(yaml);
 let ts_dedent = require("ts-dedent");
 ts_dedent = __toESM(ts_dedent);
 
+//#region src/blocks.ts
+var UnsupportedBlockTypeError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UnsupportedBlockTypeError";
+	}
+};
+
+//#endregion
+//#region src/blocks/executable-blocks.ts
+const executableBlockTypes = new Set([
+	"code",
+	"sql",
+	"notebook-function",
+	"visualization",
+	"button",
+	"big-number",
+	"input-text",
+	"input-textarea",
+	"input-checkbox",
+	"input-select",
+	"input-slider",
+	"input-date",
+	"input-date-range",
+	"input-file"
+]);
+/**
+* Type guard to check if a block is an executable block.
+* Executable blocks can have outputs and be executed by the runtime.
+*/
+function isExecutableBlock(block) {
+	return executableBlockTypes.has(block.type);
+}
+/**
+* Checks if a block type string represents an executable block.
+* Convenience function for when you only have the type string.
+*/
+function isExecutableBlockType(type) {
+	return executableBlockTypes.has(type);
+}
+
+//#endregion
 //#region src/deserialize-file/deepnote-file-schema.ts
 /** Preprocesses any content value to empty string for blocks that don't use content */
 const emptyContent = () => zod.z.preprocess(() => "", zod.z.literal("").optional());
@@ -420,6 +462,17 @@ const deepnoteFileSchema = zod.z.object({
 	}),
 	version: zod.z.string()
 });
+const deepnoteSnapshotSchema = deepnoteFileSchema.extend({
+	environment: environmentSchema.unwrap(),
+	execution: executionSchema.unwrap(),
+	metadata: zod.z.object({
+		checksum: zod.z.string().optional(),
+		createdAt: zod.z.string(),
+		exportedAt: zod.z.string().optional(),
+		modifiedAt: zod.z.string().optional(),
+		snapshotHash: zod.z.string()
+	})
+});
 
 //#endregion
 //#region src/deserialize-file/parse-yaml.ts
@@ -529,15 +582,6 @@ function deserializeDeepnoteFile(yamlContent) {
 	return result.data;
 }
 
-//#endregion
-//#region src/blocks.ts
-var UnsupportedBlockTypeError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "UnsupportedBlockTypeError";
-	}
-};
-
 //#endregion
 //#region src/blocks/image-blocks.ts
 function escapeHtmlAttribute(value) {
@@ -938,6 +982,53 @@ function isInputDateRangeBlock(block) {
 	return block.type === "input-date-range";
 }
 
+//#endregion
+//#region src/blocks/notebook-function-blocks.ts
+function isNotebookFunctionBlock(block) {
+	return block.type === "notebook-function";
+}
+function createPythonCodeForNotebookFunctionBlock(block) {
+	const notebookId = block.metadata?.function_notebook_id;
+	const inputs = block.metadata?.function_notebook_inputs ?? {};
+	const exportMappings = block.metadata?.function_notebook_export_mappings ?? {};
+	if (!notebookId) return ts_dedent.dedent`
+      # Notebook Function: Not configured
+      pass
+    `;
+	const enabledExports = Object.entries(exportMappings).filter(([, mapping]) => mapping.enabled);
+	const inputsAsString = JSON.stringify(inputs);
+	const exportMappingsDict = {};
+	for (const [exportName, mapping] of enabledExports) exportMappingsDict[exportName] = mapping.variable_name;
+	const exportMappingsAsString = JSON.stringify(exportMappingsDict);
+	const inputsComment = `Inputs: ${inputsAsString}`;
+	const exportsComment = enabledExports.length > 0 ? `Exports: ${enabledExports.map(([name, mapping]) => `${name} -> ${mapping.variable_name}`).join(", ")}` : "Exports: (none)";
+	const functionCall = ts_dedent.dedent`
+    _dntk.run_notebook_function(
+        ${escapePythonString(notebookId)},
+        inputs=${inputsAsString},
+        export_mappings=${exportMappingsAsString}
+    )
+  `;
+	if (enabledExports.length === 0) return ts_dedent.dedent`
+      # Notebook Function: ${notebookId}
+      # ${inputsComment}
+      # ${exportsComment}
+      ${functionCall}
+    `;
+	if (enabledExports.length === 1) return ts_dedent.dedent`
+      # Notebook Function: ${notebookId}
+      # ${inputsComment}
+      # ${exportsComment}
+      ${enabledExports[0][1]?.variable_name} = ${functionCall}
+    `;
+	return ts_dedent.dedent`
+    # Notebook Function: ${notebookId}
+    # ${inputsComment}
+    # ${exportsComment}
+    ${enabledExports.map(([, mapping]) => mapping.variable_name).join(", ")} = ${functionCall}
+  `;
+}
+
 //#endregion
 //#region src/blocks/sql-utils.ts
 function convertToEnvironmentVariableName(str) {
@@ -1013,18 +1104,24 @@ function createPythonCode(block, executionContext) {
 	if (isVisualizationBlock(block)) return createPythonCodeForVisualizationBlock(block);
 	if (isButtonBlock(block)) return createPythonCodeForButtonBlock(block, executionContext);
 	if (isBigNumberBlock(block)) return createPythonCodeForBigNumberBlock(block);
+	if (isNotebookFunctionBlock(block)) return createPythonCodeForNotebookFunctionBlock(block);
 	throw new UnsupportedBlockTypeError(`Creating python code from block type ${block.type} is not supported yet.`);
 }
 
 //#endregion
+exports.UnsupportedBlockTypeError = UnsupportedBlockTypeError;
 exports.createMarkdown = createMarkdown;
 exports.createPythonCode = createPythonCode;
 exports.decodeUtf8NoBom = decodeUtf8NoBom;
 exports.deepnoteBlockSchema = deepnoteBlockSchema;
 exports.deepnoteFileSchema = deepnoteFileSchema;
+exports.deepnoteSnapshotSchema = deepnoteSnapshotSchema;
 exports.deserializeDeepnoteFile = deserializeDeepnoteFile;
 exports.environmentSchema = environmentSchema;
 exports.executionErrorSchema = executionErrorSchema;
 exports.executionSchema = executionSchema;
 exports.executionSummarySchema = executionSummarySchema;
+exports.isExecutableBlock = isExecutableBlock;
+exports.isExecutableBlockType = isExecutableBlockType;
+exports.parseYaml = parseYaml;
 exports.stripMarkdown = stripMarkdown;