@deepnote/blocks 1.3.0

package/dist/index.cjs

@@ -0,0 +1,598 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let zod = require("zod");
+zod = __toESM(zod);
+let yaml = require("yaml");
+yaml = __toESM(yaml);
+let ts_dedent = require("ts-dedent");
+ts_dedent = __toESM(ts_dedent);
+
+//#region src/deserialize-file/deepnote-file-schema.ts
+const deepnoteBlockSchema = zod.z.object({
+	blockGroup: zod.z.string().optional(),
+	content: zod.z.string().optional(),
+	executionCount: zod.z.number().optional(),
+	id: zod.z.string(),
+	metadata: zod.z.record(zod.z.any()).optional(),
+	outputs: zod.z.array(zod.z.any()).optional(),
+	sortingKey: zod.z.string(),
+	type: zod.z.string(),
+	version: zod.z.number().optional()
+});
+const deepnoteFileSchema = zod.z.object({
+	metadata: zod.z.object({
+		checksum: zod.z.string().optional(),
+		createdAt: zod.z.string(),
+		exportedAt: zod.z.string().optional(),
+		modifiedAt: zod.z.string().optional()
+	}),
+	project: zod.z.object({
+		id: zod.z.string(),
+		initNotebookId: zod.z.string().optional(),
+		integrations: zod.z.array(zod.z.object({
+			id: zod.z.string(),
+			name: zod.z.string(),
+			type: zod.z.string()
+		})).optional(),
+		name: zod.z.string(),
+		notebooks: zod.z.array(zod.z.object({
+			blocks: zod.z.array(deepnoteBlockSchema),
+			executionMode: zod.z.enum(["block", "downstream"]).optional(),
+			id: zod.z.string(),
+			isModule: zod.z.boolean().optional(),
+			name: zod.z.string(),
+			workingDirectory: zod.z.string().optional()
+		})),
+		settings: zod.z.object({
+			environment: zod.z.object({
+				customImage: zod.z.string().optional(),
+				pythonVersion: zod.z.string().optional()
+			}).optional(),
+			requirements: zod.z.array(zod.z.string()).optional(),
+			sqlCacheMaxAge: zod.z.number().optional()
+		}).optional()
+	}),
+	version: zod.z.string()
+});
+
+//#endregion
+//#region src/deserialize-file/parse-yaml.ts
+function parseYaml(yamlContent) {
+	try {
+		return (0, yaml.parse)(yamlContent);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to parse Deepnote file: ${message}`);
+	}
+}
+
+//#endregion
+//#region src/deserialize-file/deserialize-deepnote-file.ts
+/**
+* Deserialize a YAML string into a DeepnoteFile object.
+*/
+function deserializeDeepnoteFile(yamlContent) {
+	const parsed = parseYaml(yamlContent);
+	const result = deepnoteFileSchema.safeParse(parsed);
+	if (!result.success) {
+		const issue = result.error.issues[0];
+		if (!issue) throw new Error("Invalid Deepnote file.");
+		const path = issue.path.join(".");
+		const message = path ? `${path}: ${issue.message}` : issue.message;
+		throw new Error(`Failed to parse the Deepnote file: ${message}.`);
+	}
+	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) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sanitizeWidth(width) {
+	return width.replace(/[^0-9]/g, "") || "";
+}
+function sanitizeAlignment(alignment) {
+	return [
+		"left",
+		"center",
+		"right"
+	].includes(alignment.toLowerCase()) ? alignment.toLowerCase() : "";
+}
+function createMarkdownForImageBlock(block) {
+	return `<img src="${escapeHtmlAttribute(block.metadata.deepnote_img_src ?? "")}" width="${sanitizeWidth(block.metadata.deepnote_img_width ?? "")}" align="${sanitizeAlignment(block.metadata.deepnote_img_alignment ?? "")}" />`;
+}
+function isImageBlock(block) {
+	return block.type === "image";
+}
+
+//#endregion
+//#region src/blocks/text-blocks.ts
+function isTextBlock(block) {
+	return [
+		"text-cell-p",
+		"text-cell-h1",
+		"text-cell-h2",
+		"text-cell-h3",
+		"text-cell-bullet",
+		"text-cell-todo",
+		"text-cell-callout"
+	].includes(block.type.toLowerCase());
+}
+function escapeMarkdown(text) {
+	return text.replace(/([\\`*_{}[\]()#+\-.!|>])/g, "\\$1");
+}
+function createMarkdownForTextBlock(block) {
+	if (block.type === "text-cell-h1") return `# ${escapeMarkdown(block.content)}`;
+	if (block.type === "text-cell-h2") return `## ${escapeMarkdown(block.content)}`;
+	if (block.type === "text-cell-h3") return `### ${escapeMarkdown(block.content)}`;
+	if (block.type === "text-cell-bullet") return `- ${escapeMarkdown(block.content)}`;
+	if (block.type === "text-cell-todo") return `- ${block.metadata.checked ? "[x]" : "[ ]"} ${escapeMarkdown(block.content)}`;
+	if (block.type === "text-cell-callout") return `> ${escapeMarkdown(block.content)}`;
+	if (block.type === "text-cell-p") return escapeMarkdown(block.content);
+	throw new Error("Unhandled block type.");
+}
+function stripMarkdownFromTextBlock(block) {
+	if (block.type === "text-cell-h1") return block.content.replace(/^#\s+/, "").trim();
+	if (block.type === "text-cell-h2") return block.content.replace(/^##\s+/, "").trim();
+	if (block.type === "text-cell-h3") return block.content.replace(/^#{3,6}\s+/, "").trim();
+	if (block.type === "text-cell-bullet") return block.content.replace(/^-+\s+/, "").trim();
+	if (block.type === "text-cell-todo") return block.content.replace(/^-+\s+\[.\]\s+/, "").trim();
+	if (block.type === "text-cell-callout") return block.content.replace(/^>\s+/, "").trim();
+	if (block.type === "text-cell-p") return block.content.trim();
+	throw new Error("Unhandled block type.");
+}
+function createMarkdownForSeparatorBlock(_block) {
+	return "<hr>";
+}
+function isSeparatorBlock(block) {
+	return block.type === "separator";
+}
+
+//#endregion
+//#region src/markdown.ts
+function createMarkdown(block) {
+	if (block.type === "markdown") return block.content ?? "";
+	if (isTextBlock(block)) return createMarkdownForTextBlock(block);
+	if (isSeparatorBlock(block)) return createMarkdownForSeparatorBlock(block);
+	if (isImageBlock(block)) return createMarkdownForImageBlock(block);
+	throw new UnsupportedBlockTypeError(`Creating markdown from block type ${block.type} is not supported yet.`);
+}
+function stripMarkdown(block) {
+	if (isTextBlock(block)) return stripMarkdownFromTextBlock(block);
+	throw new UnsupportedBlockTypeError(`Stripping markdown from block type ${block.type} is not supported yet.`);
+}
+
+//#endregion
+//#region src/blocks/python-utils.ts
+function escapePythonString(value) {
+	return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'").replaceAll("\n", "\\n")}'`;
+}
+function sanitizePythonVariableName(name, options = {}) {
+	let sanitizedVariableName = name.replace(/\s+/g, "_").replace(/[^0-9a-zA-Z_]/g, "").replace(/^[^a-zA-Z_]+/g, "");
+	if (sanitizedVariableName === "" && !options.disableEmptyFallback) sanitizedVariableName = "input_1";
+	return sanitizedVariableName;
+}
+
+//#endregion
+//#region src/python-snippets.ts
+const pythonCode = {
+	setVariableContextValue: (variableName, value) => {
+		return `${sanitizePythonVariableName(variableName)} = ${value ? "True" : "False"}`;
+	},
+	executeBigNumber: (titleTemplate, valueVariableName, comparisonTitleTemplate = "", comparisonVariableName = "") => {
+		const sanitizedValueVariable = sanitizePythonVariableName(valueVariableName);
+		const valuePart = sanitizedValueVariable ? `f"{${sanitizedValueVariable}}"` : `""`;
+		if (!(comparisonTitleTemplate || comparisonVariableName)) return `
+def __deepnote_big_number__():
+    import json
+    import jinja2
+    from jinja2 import meta
+
+    def render_template(template):
+        parsed_content = jinja2.Environment().parse(template)
+
+        required_variables = meta.find_undeclared_variables(parsed_content)
+
+        context = {
+            variable_name: globals().get(variable_name)
+            for variable_name in required_variables
+        }
+
+        result = jinja2.Environment().from_string(template).render(context)
+
+        return result
+
+    rendered_title = render_template(${escapePythonString(titleTemplate)})
+
+    return json.dumps({
+        "title": rendered_title,
+        "value": ${valuePart}
+    })
+
+__deepnote_big_number__()
+`;
+		const sanitizedComparisonVariable = sanitizePythonVariableName(comparisonVariableName);
+		const comparisonValuePart = sanitizedComparisonVariable ? `f"{${sanitizedComparisonVariable}}"` : `""`;
+		return `
+def __deepnote_big_number__():
+    import json
+    import jinja2
+    from jinja2 import meta
+
+    def render_template(template):
+        parsed_content = jinja2.Environment().parse(template)
+
+        required_variables = meta.find_undeclared_variables(parsed_content)
+
+        context = {
+            variable_name: globals().get(variable_name)
+            for variable_name in required_variables
+        }
+
+        result = jinja2.Environment().from_string(template).render(context)
+
+        return result
+
+    rendered_title = render_template(${escapePythonString(titleTemplate)})
+    rendered_comparison_title = render_template(${escapePythonString(comparisonTitleTemplate)})
+
+    return json.dumps({
+        "comparisonTitle": rendered_comparison_title,
+        "comparisonValue": ${comparisonValuePart},
+        "title": rendered_title,
+        "value": ${valuePart}
+    })
+
+__deepnote_big_number__()
+`;
+	},
+	executeVisualization: (variableName, spec, filters) => {
+		return `_dntk.DeepnoteChart(${sanitizePythonVariableName(variableName)}, ${escapePythonString(spec)}, filters=${escapePythonString(filters)})`;
+	},
+	dateRangePast7days: (name) => {
+		return ts_dedent.dedent`
+      from datetime import datetime as _deepnote_datetime, timedelta as _deepnote_timedelta
+      ${sanitizePythonVariableName(name)} = [_deepnote_datetime.now().date() - _deepnote_timedelta(days=7), _deepnote_datetime.now().date()]
+    `;
+	},
+	dateRangePast14days: (name) => {
+		return ts_dedent.dedent`
+      from datetime import datetime as _deepnote_datetime, timedelta as _deepnote_timedelta
+      ${sanitizePythonVariableName(name)} = [_deepnote_datetime.now().date() - _deepnote_timedelta(days=14), _deepnote_datetime.now().date()]
+    `;
+	},
+	dateRangePastMonth: (name) => {
+		return ts_dedent.dedent`
+      from datetime import datetime as _deepnote_datetime
+      from dateutil.relativedelta import relativedelta
+      ${sanitizePythonVariableName(name)} = [_deepnote_datetime.now().date() - relativedelta(months=1), _deepnote_datetime.now().date()]
+    `;
+	},
+	dateRangePast3months: (name) => {
+		return ts_dedent.dedent`
+      from datetime import datetime as _deepnote_datetime
+      from dateutil.relativedelta import relativedelta
+      ${sanitizePythonVariableName(name)} = [_deepnote_datetime.now().date() - relativedelta(months=3), _deepnote_datetime.now().date()]
+    `;
+	},
+	dateRangePast6months: (name) => {
+		return ts_dedent.dedent`
+      from datetime import datetime as _deepnote_datetime
+      from dateutil.relativedelta import relativedelta
+      ${sanitizePythonVariableName(name)} = [_deepnote_datetime.now().date() - relativedelta(months=6), _deepnote_datetime.now().date()]
+    `;
+	},
+	dateRangePastYear: (name) => {
+		return ts_dedent.dedent`
+      from datetime import datetime as _deepnote_datetime
+      from dateutil.relativedelta import relativedelta
+      ${sanitizePythonVariableName(name)} = [_deepnote_datetime.now().date() - relativedelta(years=1), _deepnote_datetime.now().date()]
+    `;
+	},
+	dateRangeCustomDays: (name, days) => {
+		return ts_dedent.dedent`
+      from datetime import datetime, timedelta
+      ${sanitizePythonVariableName(name)} = [datetime.now().date() - timedelta(days=${Math.floor(Number(days)) || 0}), datetime.now().date()]
+    `;
+	},
+	dateRangeAbsolute: (name, startDate, endDate) => {
+		const sanitizedName = sanitizePythonVariableName(name);
+		const escapedStartDate = escapePythonString(startDate);
+		const escapedEndDate = escapePythonString(endDate);
+		return ts_dedent.dedent`
+      from dateutil.parser import parse as _deepnote_parse
+      ${sanitizedName} = [${startDate ? `_deepnote_parse(${escapedStartDate}).date()` : "None"}, ${endDate ? `_deepnote_parse(${escapedEndDate}).date()` : "None"}]
+    `;
+	}
+};
+
+//#endregion
+//#region src/blocks/big-number-blocks.ts
+function createPythonCodeForBigNumberBlock(block) {
+	return pythonCode.executeBigNumber(block.metadata.deepnote_big_number_title ?? "", block.metadata.deepnote_big_number_value ?? "", block.metadata.deepnote_big_number_comparison_title, block.metadata.deepnote_big_number_comparison_value);
+}
+function isBigNumberBlock(block) {
+	return block.type === "big-number";
+}
+
+//#endregion
+//#region src/blocks/button-blocks.ts
+function createPythonCodeForButtonBlock(block, executionContext) {
+	if (block.metadata.deepnote_button_behavior === "set_variable" && block.metadata.deepnote_variable_name) {
+		const sanitizedPythonVariableName = sanitizePythonVariableName(block.metadata.deepnote_variable_name);
+		if (executionContext?.variableContext?.includes(sanitizedPythonVariableName)) return pythonCode.setVariableContextValue(sanitizedPythonVariableName, true);
+		return pythonCode.setVariableContextValue(sanitizedPythonVariableName, false);
+	}
+	return "";
+}
+function isButtonBlock(block) {
+	return block.type === "button";
+}
+
+//#endregion
+//#region src/blocks/data-frame.ts
+function createDataFrameConfig(block) {
+	const tableState = block.metadata.deepnote_table_state ?? {};
+	const tableStateAsJson = JSON.stringify(tableState);
+	return ts_dedent.dedent`
+    if '_dntk' in globals():
+      _dntk.dataframe_utils.configure_dataframe_formatter(${escapePythonString(tableStateAsJson)})
+    else:
+      _deepnote_current_table_attrs = ${escapePythonString(tableStateAsJson)}
+  `;
+}
+
+//#endregion
+//#region src/blocks/code-blocks.ts
+function createPythonCodeForCodeBlock(block) {
+	return ts_dedent.dedent`
+    ${createDataFrameConfig(block)}
+
+    ${block.content}
+  `;
+}
+function isCodeBlock(block) {
+	return block.type === "code";
+}
+
+//#endregion
+//#region src/blocks/input-blocks.ts
+const DATE_RANGE_INPUT_RELATIVE_RANGES = [
+	{
+		value: "past7days",
+		pythonCode: pythonCode.dateRangePast7days
+	},
+	{
+		value: "past14days",
+		pythonCode: pythonCode.dateRangePast14days
+	},
+	{
+		value: "pastMonth",
+		pythonCode: pythonCode.dateRangePastMonth
+	},
+	{
+		value: "past3months",
+		pythonCode: pythonCode.dateRangePast3months
+	},
+	{
+		value: "past6months",
+		pythonCode: pythonCode.dateRangePast6months
+	},
+	{
+		value: "pastYear",
+		pythonCode: pythonCode.dateRangePastYear
+	}
+];
+function isCustomDateRange(value) {
+	if (typeof value !== "string") return false;
+	const days = Number.parseInt(value.split("customDays")[1] ?? "0", 10);
+	return value.startsWith("customDays") && !Number.isNaN(days) && days >= 0;
+}
+function isValidRelativeDateInterval(value) {
+	return typeof value === "string" && DATE_RANGE_INPUT_RELATIVE_RANGES.some((range) => range.value === value);
+}
+function isValidAbsoluteDateRange(value) {
+	const YYYY_MM_DD_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+	return Array.isArray(value) && value.length === 2 && value.every((v) => typeof v === "string" && (v === "" || YYYY_MM_DD_REGEX.test(v)));
+}
+function createPythonCodeForInputTextBlock(block) {
+	return `${sanitizePythonVariableName(block.metadata.deepnote_variable_name)} = ${escapePythonString(block.metadata.deepnote_variable_value)}`;
+}
+function createPythonCodeForInputTextareaBlock(block) {
+	return `${sanitizePythonVariableName(block.metadata.deepnote_variable_name)} = ${escapePythonString(block.metadata.deepnote_variable_value)}`;
+}
+function createPythonCodeForInputCheckboxBlock(block) {
+	return `${sanitizePythonVariableName(block.metadata.deepnote_variable_name)} = ${block.metadata.deepnote_variable_value ? "True" : "False"}`;
+}
+function createPythonCodeForInputSelectBlock(block) {
+	const sanitizedPythonVariableName = sanitizePythonVariableName(block.metadata.deepnote_variable_name);
+	if (block.metadata.deepnote_allow_multiple_values || Array.isArray(block.metadata.deepnote_variable_value)) return `${sanitizedPythonVariableName} = [${(Array.isArray(block.metadata.deepnote_variable_value) ? block.metadata.deepnote_variable_value : [block.metadata.deepnote_variable_value]).map((value) => escapePythonString(value)).join(", ")}]`;
+	else if (!block.metadata.deepnote_allow_multiple_values && !block.metadata.deepnote_variable_value) return `${sanitizedPythonVariableName} = None`;
+	else return `${sanitizedPythonVariableName} = ${escapePythonString(block.metadata.deepnote_variable_value)}`;
+}
+function createPythonCodeForInputSliderBlock(block) {
+	const sanitizedPythonVariableName = sanitizePythonVariableName(block.metadata.deepnote_variable_name);
+	const value = block.metadata.deepnote_variable_value;
+	if (!/^-?\d+\.?\d*$|^-?\d*\.\d+$/.test(value)) throw new Error(`Invalid numeric value for slider input: "${value}". Expected a valid number (integer or float).`);
+	const numericValue = Number(value);
+	if (!Number.isFinite(numericValue)) throw new Error(`Invalid numeric value for slider input: "${value}". Value must be finite.`);
+	return `${sanitizedPythonVariableName} = ${numericValue}`;
+}
+function createPythonCodeForInputFileBlock(block) {
+	const sanitizedPythonVariableName = sanitizePythonVariableName(block.metadata.deepnote_variable_name);
+	if (block.metadata.deepnote_variable_value === "") return `${sanitizedPythonVariableName} = None`;
+	return `${sanitizedPythonVariableName} = ${escapePythonString(block.metadata.deepnote_variable_value)}`;
+}
+function createPythonCodeForInputDateBlock(block) {
+	const sanitizedPythonVariableName = sanitizePythonVariableName(block.metadata.deepnote_variable_name);
+	const escapedValue = escapePythonString(block.metadata.deepnote_variable_value);
+	if (!block.metadata.deepnote_variable_value) return `
+${sanitizedPythonVariableName} = None
+`;
+	if (block.metadata.deepnote_input_date_version === 2) return `
+from dateutil.parser import parse as _deepnote_parse
+${sanitizedPythonVariableName} = _deepnote_parse(${escapedValue}).date()
+`;
+	return `
+from datetime import datetime as _deepnote_datetime
+${sanitizedPythonVariableName} = _deepnote_datetime.strptime(${escapedValue}, "%Y-%m-%dT%H:%M:%S.%fZ")
+`;
+}
+function createPythonCodeForInputDateRangeBlock(block) {
+	const sanitizedPythonVariableName = sanitizePythonVariableName(block.metadata.deepnote_variable_name);
+	if (isValidAbsoluteDateRange(block.metadata.deepnote_variable_value)) {
+		const startDate = block.metadata.deepnote_variable_value[0];
+		const endDate = block.metadata.deepnote_variable_value[1];
+		return pythonCode.dateRangeAbsolute(sanitizedPythonVariableName, startDate, endDate);
+	} else if (isCustomDateRange(block.metadata.deepnote_variable_value)) {
+		const customDays = block.metadata.deepnote_variable_value.replace("customDays", "");
+		return pythonCode.dateRangeCustomDays(sanitizedPythonVariableName, Number(customDays));
+	} else if (isValidRelativeDateInterval(block.metadata.deepnote_variable_value)) {
+		const range = DATE_RANGE_INPUT_RELATIVE_RANGES.find((range$1) => range$1.value === block.metadata.deepnote_variable_value);
+		if (!range) throw new Error(`Invalid relative date interval: "${block.metadata.deepnote_variable_value}". Expected one of: ${DATE_RANGE_INPUT_RELATIVE_RANGES.map((r) => r.value).join(", ")}.`);
+		return ts_dedent.dedent`
+      ${range.pythonCode(sanitizedPythonVariableName)}`;
+	} else return ts_dedent.dedent`
+      ${sanitizedPythonVariableName} = [None, None]
+    `;
+}
+function isInputTextBlock(block) {
+	return block.type === "input-text";
+}
+function isInputTextareaBlock(block) {
+	return block.type === "input-textarea";
+}
+function isInputCheckboxBlock(block) {
+	return block.type === "input-checkbox";
+}
+function isInputSelectBlock(block) {
+	return block.type === "input-select";
+}
+function isInputSliderBlock(block) {
+	return block.type === "input-slider";
+}
+function isInputFileBlock(block) {
+	return block.type === "input-file";
+}
+function isInputDateBlock(block) {
+	return block.type === "input-date";
+}
+function isInputDateRangeBlock(block) {
+	return block.type === "input-date-range";
+}
+
+//#endregion
+//#region src/blocks/sql-utils.ts
+function convertToEnvironmentVariableName(str) {
+	return (/^\d/.test(str) ? `_${str}` : str).toUpperCase().replace(/[^\w]/g, "_");
+}
+function getSqlEnvVarName(integrationId) {
+	return `SQL_${integrationId}`;
+}
+
+//#endregion
+//#region src/blocks/sql-blocks.ts
+function createPythonCodeForSqlBlock(block) {
+	const query = block.content;
+	const pythonVariableName = block.metadata.deepnote_variable_name;
+	const sanitizedPythonVariableName = pythonVariableName !== void 0 ? sanitizePythonVariableName(pythonVariableName) || "input_1" : void 0;
+	const returnVariableType = block.metadata.deepnote_return_variable_type ?? "dataframe";
+	const integrationId = block.metadata.sql_integration_id;
+	const connectionEnvVarName = integrationId ? convertToEnvironmentVariableName(getSqlEnvVarName(integrationId)) : "SQL_ALCHEMY_JSON_ENV_VAR";
+	const escapedQuery = escapePythonString(query);
+	const dataFrameConfig = createDataFrameConfig(block);
+	const executeSqlFunctionCall = ts_dedent.dedent`
+    _dntk.execute_sql(
+      ${escapedQuery},
+      '${connectionEnvVarName}',
+      audit_sql_comment='',
+      sql_cache_mode='cache_disabled',
+      return_variable_type='${returnVariableType}'
+    )
+  `;
+	if (sanitizedPythonVariableName === void 0) return ts_dedent.dedent`
+      ${dataFrameConfig}
+
+      ${executeSqlFunctionCall}
+    `;
+	return ts_dedent.dedent`
+    ${dataFrameConfig}
+
+    ${sanitizedPythonVariableName} = ${executeSqlFunctionCall}
+    ${sanitizedPythonVariableName}
+  `;
+}
+function isSqlBlock(block) {
+	return block.type === "sql";
+}
+
+//#endregion
+//#region src/blocks/visualization-blocks.ts
+function createPythonCodeForVisualizationBlock(block) {
+	const variableName = block.metadata.deepnote_variable_name;
+	const spec = block.metadata.deepnote_visualization_spec;
+	const filters = block.metadata.deepnote_chart_filter?.advancedFilters ?? [];
+	if (!variableName || !spec) return "";
+	const sanitizedVariableName = sanitizePythonVariableName(variableName);
+	return pythonCode.executeVisualization(sanitizedVariableName, JSON.stringify(spec), JSON.stringify(filters));
+}
+function isVisualizationBlock(block) {
+	return block.type === "visualization";
+}
+
+//#endregion
+//#region src/python-code.ts
+function createPythonCode(block, executionContext) {
+	if (isCodeBlock(block)) return createPythonCodeForCodeBlock(block);
+	if (isSqlBlock(block)) return createPythonCodeForSqlBlock(block);
+	if (isInputTextBlock(block)) return createPythonCodeForInputTextBlock(block);
+	if (isInputTextareaBlock(block)) return createPythonCodeForInputTextareaBlock(block);
+	if (isInputCheckboxBlock(block)) return createPythonCodeForInputCheckboxBlock(block);
+	if (isInputSelectBlock(block)) return createPythonCodeForInputSelectBlock(block);
+	if (isInputSliderBlock(block)) return createPythonCodeForInputSliderBlock(block);
+	if (isInputFileBlock(block)) return createPythonCodeForInputFileBlock(block);
+	if (isInputDateBlock(block)) return createPythonCodeForInputDateBlock(block);
+	if (isInputDateRangeBlock(block)) return createPythonCodeForInputDateRangeBlock(block);
+	if (isVisualizationBlock(block)) return createPythonCodeForVisualizationBlock(block);
+	if (isButtonBlock(block)) return createPythonCodeForButtonBlock(block, executionContext);
+	if (isBigNumberBlock(block)) return createPythonCodeForBigNumberBlock(block);
+	throw new UnsupportedBlockTypeError(`Creating python code from block type ${block.type} is not supported yet.`);
+}
+
+//#endregion
+exports.createMarkdown = createMarkdown;
+exports.createPythonCode = createPythonCode;
+exports.deepnoteBlockSchema = deepnoteBlockSchema;
+exports.deserializeDeepnoteFile = deserializeDeepnoteFile;
+exports.stripMarkdown = stripMarkdown;