@platforma-sdk/workflow-tengo 4.12.0 → 4.13.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };
-declare type TplName = "ll.get-field" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.remove-nulls" | "waiter.waiter" | "workdir.save" | "workflow.build-ctx" | "workflow.query-anchored" | "anonymize.deanonymize" | "anonymize.impl" | "check_network.workdir_type_name_extractor" | "exec.delayed-compute-allocation.impl" | "exec.monetization_to_json" | "exec.python.install-deps" | "exec.python.venv-bin-path" | "pframes.export-multiple-pcolumns" | "pframes.slice-data" | "check_network.create_workdir_from_storage" | "check_network.download_blob" | "check_network.upload_blob" | "check_network.upload_template" | "exec.R.create-renv" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "exec.load-software.impl" | "exec.exec" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "pframes.export-pframe-for-ui";
+declare type TplName = "ll.get-field" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.remove-nulls" | "waiter.waiter" | "workdir.save" | "workflow.build-ctx" | "workflow.query-anchored" | "anonymize.deanonymize" | "anonymize.impl" | "check_network.workdir_type_name_extractor" | "exec.delayed-compute-allocation.impl" | "exec.monetization_to_json" | "exec.python.install-deps" | "exec.python.venv-bin-path" | "pframes.export-multiple-pcolumns" | "pframes.slice-data" | "check_network.create_workdir_from_storage" | "check_network.download_blob" | "check_network.upload_blob" | "check_network.upload_template" | "exec.R.create-renv" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "pframes.parse-to-json" | "exec.load-software.impl" | "exec.exec" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "pframes.export-pframe-for-ui";
 declare const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -24,6 +24,7 @@ module.exports = { Templates: {
   'exec.exec-impl': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.exec-impl.plj.gz') },
   'exec.monetization_info': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.monetization_info.plj.gz') },
   'exec.python.create-venv': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.python.create-venv.plj.gz') },
+  'pframes.parse-to-json': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.parse-to-json.plj.gz') },
   'exec.load-software.impl': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.load-software.impl.plj.gz') },
   'exec.exec': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.exec.plj.gz') },
   'pframes.xsv-export-pframe': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.xsv-export-pframe.plj.gz') },

package/dist/index.mjs

@@ -25,6 +25,7 @@ export const Templates = {
   'exec.exec-impl': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.exec-impl.plj.gz') },
   'exec.monetization_info': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.monetization_info.plj.gz') },
   'exec.python.create-venv': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.python.create-venv.plj.gz') },
+  'pframes.parse-to-json': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.parse-to-json.plj.gz') },
   'exec.load-software.impl': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.load-software.impl.plj.gz') },
   'exec.exec': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.exec.plj.gz') },
   'pframes.xsv-export-pframe': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.xsv-export-pframe.plj.gz') },

package/dist/tengo/lib/maps.lib.tengo

@@ -213,8 +213,14 @@ deepTransform = func(...maps) {
 				} else {
 					res[k] = result
 				}
-			} else if is_map(res[k]) && is_map(v) {
-				res[k] = deepTransform(res[k], v)
+			} else if is_map(v) {
+				if is_map(res[k]) {
+					res[k] = deepTransform(res[k], v)
+				} else {
+
+
+					res[k] = deepTransform({}, v)
+				}
 			} else {
 				res[k] = v
 			}

package/dist/tengo/lib/pframes.lib.tengo

@@ -20,6 +20,29 @@ pColumnData := import("@platforma-sdk/workflow-tengo:pframes.data")
 llProcessTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.process-pcolumn-data")
 
 
+TSV_CONTENT_SETTINGS_SCHEMA := {
+	"axes": [{
+		"column": "string",
+		"spec": {
+			"type": "string,regex=Int|Long|Float|Double|String",
+			"name,?": "string",
+			"domain,?": { "any": "string" },
+			"annotations,?": { "any": "string" }
+		}
+	}],
+	"columns": [{
+		"column": "string",
+		"id,?": "string",
+		"spec": {
+			"valueType": "string,regex=Int|Long|Float|Double|String",
+			"name,?": "string",
+			"domain,?": { "any": "string" },
+			"annotations,?": { "any": "string" }
+		}
+	}]
+}
+
+
 
 
 
@@ -185,6 +208,36 @@ __primitiveValueTypes := { "Int": true, "Long": true, "Float": true, "Double": t
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -249,12 +302,25 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 		ll.panic("can't use passAggregationAxesSpec, passAggregationAxesNames or passDistilledAggregationSpec without aggregate")
 	}
 
+	createOutputTrace := func(output) {
+		hasOutputTrace := !is_undefined(output.traceSteps)
+		hasGlobalTrace := !is_undefined(opts.traceSteps)
+		hasInputTrace := !is_undefined(input.spec.annotations[pSpec.A_TRACE])
 
-	trace := undefined
-	if !is_undefined(opts.traceSteps) || !is_undefined(input.spec.annotations[pSpec.A_TRACE]) {
-		trace = pSpec.makeTrace(input.spec, (opts.traceSteps ? opts.traceSteps : [])...)
-	}
+		outputTraceSteps := slices.normalize(opts.traceSteps) + slices.normalize(output.traceSteps)
+
+		trace := undefined
+		if len(outputTraceSteps) > 0 || hasInputTrace {
+			trace = pSpec.makeTrace(input.spec, outputTraceSteps...)
+		}
 
+		outputOverrideTrace := output.overrideTrace
+		if is_undefined(outputOverrideTrace) {
+			outputOverrideTrace = hasOutputTrace || hasGlobalTrace
+		}
+
+		return { trace: trace, overrideTrace: outputOverrideTrace }
+	}
 
 	processTemplateParams := {
 		eph: opts.isEphemeral,
@@ -289,7 +355,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 		metaExtra = {}
 	}
 
-	iterationAxesSpec := input.spec.axesSpec
+	iterationAxesSpec := copy(input.spec.axesSpec)
 
 
 	if !isPotentiallyPartitioned {
@@ -376,19 +442,20 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 	for output in outputs {
 
 		outputsMap[output.name] = output
+		traceInfo := createOutputTrace(output)
 		if output.type == "Resource" || output.type == "BinaryPartitioned" || output.type == "JsonPartitioned" {
-			spec := maps.merge(output.spec, { axesSpec: iterationAxesSpec + slices.normalize(output.spec.axesSpec) })
-			if !is_undefined(trace) {
-				spec = trace.inject(spec)
+			spec := maps.merge(output.spec, { axesSpec: copy(iterationAxesSpec) + slices.normalize(output.spec.axesSpec) })
+			if !is_undefined(traceInfo.trace) {
+				spec = traceInfo.trace.inject(spec, {override: traceInfo.overrideTrace})
 			}
 			outputSpecs[output.name] = spec
-			processedOutputs = append(processedOutputs, maps.merge(output, {spec: undefined })) // removing spec field
+			processedOutputs = append(processedOutputs, maps.merge(output, {spec: undefined, traceSteps: undefined, overrideTrace: undefined }))
 		} else if output.type == "ResourceMap" {
 			processedOutputs = append(processedOutputs, maps.merge(output,
-				{ keyLength: len(output.spec.axesSpec), spec: undefined }))
-			spec := maps.merge(output.spec, { axesSpec: iterationAxesSpec + slices.normalize(output.spec.axesSpec) })
-			if !is_undefined(trace) {
-				spec = trace.inject(spec)
+				{ keyLength: len(output.spec.axesSpec), spec: undefined, traceSteps: undefined, overrideTrace: undefined }))
+			spec := maps.merge(output.spec, { axesSpec: copy(iterationAxesSpec) + slices.normalize(output.spec.axesSpec) })
+			if !is_undefined(traceInfo.trace) {
+				spec = traceInfo.trace.inject(spec, {override: traceInfo.overrideTrace})
 			}
 			outputSpecs[output.name] = spec
 		} else if output.type == "Xsv" {
@@ -400,17 +467,68 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			})
 			purifiedPfconvCfg := decomposition.purifiedCfg
 			columnsSpec := decomposition.columnsSpec
-			if !is_undefined(trace) {
+			if !is_undefined(traceInfo.trace) {
 				for columnName, spec in columnsSpec {
-					columnsSpec[columnName] = trace.inject(spec)
+					columnsSpec[columnName] = traceInfo.trace.inject(spec, {override: traceInfo.overrideTrace})
 				}
 			}
 			outputSpecs[output.name] = columnsSpec
 			processedOutputs = append(processedOutputs, maps.merge(output,
 				{
 					settings: purifiedPfconvCfg,
-					flattenWithDelimiter: "/"
+					flattenWithDelimiter: "/",
+					traceSteps: undefined,
+					overrideTrace: undefined
 				}))
+		} else if output.type == "TsvContent" {
+			validation.assertType(output.settings, TSV_CONTENT_SETTINGS_SCHEMA, "Invalid TsvContent settings")
+
+
+			transformedSettings := {
+				axes: slices.map(output.settings.axes, func(axis) {
+					return {
+						name: axis.column,
+						type: axis.spec.type
+					}
+				}),
+				columns: slices.map(output.settings.columns, func(column) {
+					transformedColumn := {
+						name: column.column,
+						type: column.spec.valueType
+					}
+					if !is_undefined(column.id) {
+						transformedColumn.id = column.id
+					}
+					return transformedColumn
+				})
+			}
+
+
+			columnsSpec := {}
+			axesSpec := copy(iterationAxesSpec)
+			for axis in output.settings.axes {
+				axesSpec = append(axesSpec, axis.spec)
+			}
+
+			for column in output.settings.columns {
+				columnId := column.id
+				if is_undefined(columnId) {
+					columnId = column.column
+				}
+				spec := maps.merge(column.spec, { axesSpec: axesSpec, kind: "PColumn" })
+				if !is_undefined(traceInfo.trace) {
+					spec = traceInfo.trace.inject(spec, {override: traceInfo.overrideTrace})
+				}
+				columnsSpec[columnId] = spec
+			}
+
+			outputSpecs[output.name] = columnsSpec
+			processedOutputs = append(processedOutputs, maps.merge(output, {
+				settings: transformedSettings,
+				flattenWithDelimiter: "/",
+				traceSteps: undefined,
+				overrideTrace: undefined
+			}))
 		} else {
 			ll.panic("unknown output type: " + output.type)
 		}
@@ -455,9 +573,9 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			}
 
 			spec := outputSpecs[name]
-			if output.type == "Xsv" {
+			if output.type == "Xsv" || output.type == "TsvContent" {
 				if len(column) != 1 {
-					ll.panic("column name must be provided for Xsv output")
+					ll.panic("column name must be provided for " + output.type + " output")
 				}
 				columnName := column[0]
 				spec = spec[columnName]
@@ -467,7 +585,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 				return spec
 			} else {
 				if len(column) > 0 {
-					ll.panic("column name should not be provided for non-Xsv output")
+					ll.panic("column name should not be provided for non-Xsv/TsvContent output")
 				}
 				return spec
 			}
@@ -490,14 +608,14 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 				ll.panic("unknown output: " + name)
 			}
 
-			if output.type == "Xsv" {
+			if output.type == "Xsv" || output.type == "TsvContent" {
 				if len(column) != 1 {
-					ll.panic("column name must be provided for Xsv output")
+					ll.panic("column name must be provided for " + output.type + " output")
 				}
 				return renderResult.output(name + "/" + column[0])
 			} else {
 				if len(column) > 0 {
-					ll.panic("column name should not be provided for non-Xsv output")
+					ll.panic("column name should not be provided for non-Xsv/TsvContent output")
 				}
 				return renderResult.output(name)
 			}
@@ -520,9 +638,9 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 				ll.panic("unknown output: " + name)
 			}
 
-			if output.type == "Xsv" {
+			if output.type == "Xsv" || output.type == "TsvContent" {
 				if len(column) != 1 {
-					ll.panic("column name must be provided for Xsv output")
+					ll.panic("column name must be provided for " + output.type + " output")
 				}
 				columnName := column[0]
 				spec := outputSpecs[name][columnName]
@@ -535,7 +653,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 				}
 			} else {
 				if len(column) > 0 {
-					ll.panic("column name should not be provided for non-Xsv output")
+					ll.panic("column name should not be provided for non-Xsv/TsvContent output")
 				}
 				return {
 					data: renderResult.output(name),
@@ -556,8 +674,8 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 				ll.panic("unknown output: " + name)
 			}
 
-			if output.type != "Xsv" {
-				ll.panic("outputFrame can only be used with Xsv outputs")
+			if output.type != "Xsv" && output.type != "TsvContent" {
+				ll.panic("outputFrame can only be used with Xsv or TsvContent outputs")
 			}
 
 			builder := builder.pFrameBuilder()
@@ -581,7 +699,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			}
 
 			maps.forEach(outputsMap, func(name, output) {
-				if output.type == "Xsv" {
+				if output.type == "Xsv" || output.type == "TsvContent" {
 
 					for columnName, spec in outputSpecs[name] {
 						builder.add(
@@ -649,8 +767,8 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			if is_undefined(output) {
 				ll.panic("unknown output: " + name)
 			}
-			if output.type != "Xsv" {
-				ll.panic("output is not Xsv: " + name)
+			if output.type != "Xsv" && output.type != "TsvContent" {
+				ll.panic("output is not Xsv or TsvContent: " + name)
 			}
 
 			return maps.getKeys(outputSpecs[name])

package/dist/tengo/lib/pframes.spec.lib.tengo

@@ -258,10 +258,44 @@ makeTrace := func(input, ...steps) {
 	return ll.toStrict({
 		value: currentTrace,
 		valueStr: currentTraceStr,
-		
-		inject: func(spec) {
+
+
+
+
+
+
+
+
+
+
+
+
+		inject: func(spec, ...opts) {
 			validation.assertType(spec, P_COLUMN_SPEC_SCHEMA)
-			return maps.deepMerge(spec, {annotations: {"pl7.app/trace": currentTraceStr}})
+
+
+			options := {}
+			if len(opts) > 0 {
+				if len(opts) == 1 && is_map(opts[0]) {
+					options = opts[0]
+				} else {
+					ll.panic("inject: optional parameters must be a single map argument, got: %v", opts)
+				}
+			}
+
+
+			override := options.override
+			if is_undefined(override) {
+				override = true
+			}
+
+			return maps.deepTransform(spec, {annotations: {"pl7.app/trace": func(oldValue) {
+
+				if override || is_undefined(oldValue) {
+					return currentTraceStr
+				}
+				return oldValue
+			}}})
 		}
 	})
 }

package/dist/tengo/lib/slices.lib.tengo

@@ -310,7 +310,7 @@ normalize := func(s) {
 	if is_undefined(s) {
 		return []
 	}
-	return s
+	return copy(s)
 }
 
 export ll.toStrict({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "4.12.0",
+  "version": "4.13.0",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",