@deepnote/blocks 3.0.0 → 3.2.1

package/dist/index.js

@@ -2,6 +2,48 @@ import { z } from "zod";
 import { parseDocument } from "yaml";
 import { dedent } from "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 = () => z.preprocess(() => "", z.literal("").optional());
@@ -46,7 +88,7 @@ const baseBlockFields = {
 	id: z.string(),
 	blockGroup: z.string(),
 	sortingKey: z.string(),
-	contentHash: z.string().regex(/^(md5|sha256):[a-f0-9]+$/i).optional(),
+	contentHash: z.string().regex(/^([a-z0-9]+:)?[a-f0-9]+$/i).optional(),
 	version: z.number().optional()
 };
 const executableBlockFields = {
@@ -394,6 +436,17 @@ const deepnoteFileSchema = z.object({
 	}),
 	version: z.string()
 });
+const deepnoteSnapshotSchema = deepnoteFileSchema.extend({
+	environment: environmentSchema.unwrap(),
+	execution: executionSchema.unwrap(),
+	metadata: z.object({
+		checksum: z.string().optional(),
+		createdAt: z.string(),
+		exportedAt: z.string().optional(),
+		modifiedAt: z.string().optional(),
+		snapshotHash: z.string()
+	})
+});
 
 //#endregion
 //#region src/deserialize-file/parse-yaml.ts
@@ -503,15 +556,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) {
@@ -912,6 +956,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 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 = dedent`
+    _dntk.run_notebook_function(
+        ${escapePythonString(notebookId)},
+        inputs=${inputsAsString},
+        export_mappings=${exportMappingsAsString}
+    )
+  `;
+	if (enabledExports.length === 0) return dedent`
+      # Notebook Function: ${notebookId}
+      # ${inputsComment}
+      # ${exportsComment}
+      ${functionCall}
+    `;
+	if (enabledExports.length === 1) return dedent`
+      # Notebook Function: ${notebookId}
+      # ${inputsComment}
+      # ${exportsComment}
+      ${enabledExports[0][1]?.variable_name} = ${functionCall}
+    `;
+	return dedent`
+    # Notebook Function: ${notebookId}
+    # ${inputsComment}
+    # ${exportsComment}
+    ${enabledExports.map(([, mapping]) => mapping.variable_name).join(", ")} = ${functionCall}
+  `;
+}
+
 //#endregion
 //#region src/blocks/sql-utils.ts
 function convertToEnvironmentVariableName(str) {
@@ -987,8 +1078,9 @@ 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
-export { createMarkdown, createPythonCode, decodeUtf8NoBom, deepnoteBlockSchema, deepnoteFileSchema, deserializeDeepnoteFile, environmentSchema, executionErrorSchema, executionSchema, executionSummarySchema, stripMarkdown };
+export { UnsupportedBlockTypeError, createMarkdown, createPythonCode, decodeUtf8NoBom, deepnoteBlockSchema, deepnoteFileSchema, deepnoteSnapshotSchema, deserializeDeepnoteFile, environmentSchema, executionErrorSchema, executionSchema, executionSummarySchema, isExecutableBlock, isExecutableBlockType, parseYaml, stripMarkdown };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepnote/blocks",
-  "version": "3.0.0",
+  "version": "3.2.1",
   "description": "",
   "keywords": [],
   "repository": {