@platforma-sdk/workflow-tengo 5.4.5 → 5.5.0

package/dist/index.cjs

@@ -31,6 +31,7 @@ module.exports = { Templates: {
   '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') },
   'pt.workflow-run': { type: 'from-file', path: require.resolve('./tengo/tpl/pt.workflow-run.plj.gz') },
+  'annotations.compute': { type: 'from-file', path: require.resolve('./tengo/tpl/annotations.compute.plj.gz') },
   'check_network.run_hello_world': { type: 'from-file', path: require.resolve('./tengo/tpl/check_network.run_hello_world.plj.gz') },
   'check_network.run_hello_world_py': { type: 'from-file', path: require.resolve('./tengo/tpl/check_network.run_hello_world_py.plj.gz') },
   'pframes.xsv-export-pframe': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.xsv-export-pframe.plj.gz') },

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-parquet-pcolumn-chunk" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.remove-nulls" | "pt.import-dir" | "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.conda.create-env" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "pframes.parse-to-json" | "exec.load-software.impl" | "exec.exec" | "pt.workflow-run" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "pframes.export-pframe-for-ui";
+declare type TplName = "ll.get-field" | "pframes.export-parquet-pcolumn-chunk" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.remove-nulls" | "pt.import-dir" | "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.conda.create-env" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "pframes.parse-to-json" | "exec.load-software.impl" | "exec.exec" | "pt.workflow-run" | "annotations.compute" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "pframes.export-pframe-for-ui";
 declare const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -32,6 +32,7 @@ export const Templates = {
   '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') },
   'pt.workflow-run': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pt.workflow-run.plj.gz') },
+  'annotations.compute': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/annotations.compute.plj.gz') },
   'check_network.run_hello_world': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/check_network.run_hello_world.plj.gz') },
   'check_network.run_hello_world_py': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/check_network.run_hello_world_py.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/annotations.lib.tengo

@@ -0,0 +1,92 @@
+ll := import("@platforma-sdk/workflow-tengo:ll")
+wf := import("@platforma-sdk/workflow-tengo:workflow")
+util := import("@platforma-sdk/workflow-tengo:annotations.util")
+render := import("@platforma-sdk/workflow-tengo:render")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+slices := import("@platforma-sdk/workflow-tengo:slices")
+validation := import("@platforma-sdk/workflow-tengo:validation")
+
+compute := assets.importTemplate("@platforma-sdk/workflow-tengo:annotations.compute")
+
+_STEP_SCHEMA := {
+	type: "string",
+	name: "string",
+	value: { "any": "any" }
+}
+
+_STEP_SCHEMAS := [_STEP_SCHEMA]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+computeAnnotations := func(inputs) {
+	if len(inputs.steps) == 0 {
+		return {}
+	}
+
+	validation.assertType(inputs.steps, _STEP_SCHEMAS)
+
+	steps := inputs.steps
+	title := inputs.title
+	inputAnchor := inputs.inputAnchor
+	resultAxesSpec := inputs.resultAxesSpec
+	resultColumnSpec := util.prepareResultColumnSpec(inputs)
+	shouldComputeFilters := is_bool(inputs.shouldComputeFilters) ? inputs.shouldComputeFilters : false
+	
+	columnsFromExpressions := util.extractColumnsFromExpressions(slices.map(steps, func(step) { return step.value }))
+	additionalColumns := is_array(inputs.additionalColumns) ? inputs.additionalColumns : []
+	columns := columnsFromExpressions + additionalColumns
+	
+	bundleBuilder := wf.createPBundleBuilder()
+	bundleBuilder.addAnchor("main", inputAnchor)
+	for column in columns { bundleBuilder.addById(column) }
+	columnBundle := bundleBuilder.build()
+
+	result := render.create(compute, {
+		columnBundle: columnBundle,
+		params: {
+			steps: steps,
+			columns: columns,
+			resultColumnSpec: resultColumnSpec,
+			shouldComputeFilters: shouldComputeFilters
+		}
+	})
+
+	annotationsData := result.output("annotationsData")
+	annotationsColumn := { column: util.ANNOTATION_HEADER, data: annotationsData, spec: resultColumnSpec }
+
+	idx := 0
+	annotationsFiltersColumns := shouldComputeFilters ? slices.map(steps, func(v) {
+		idx += 1
+		column := util.encodeColumnName(v.name, idx)
+		filterData := result.resolveOutput(["filtersData", column])
+		filterSpec := util.createFilterColumnSpec(resultColumnSpec, column, v.name)
+		return {
+			column: v.name,
+			data: filterData,
+			spec: filterSpec
+		}
+	}) : []
+
+	return {
+		annotationsColumn: annotationsColumn,
+		annotationsFiltersColumns: annotationsFiltersColumns
+	}
+}
+
+export ll.toStrict({
+	computeAnnotations: computeAnnotations
+})

package/dist/tengo/lib/annotations.util.lib.tengo

@@ -0,0 +1,117 @@
+hex := import("hex")
+rand := import("rand")
+text := import("text")
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+wf := import("@platforma-sdk/workflow-tengo:workflow")
+sets := import("@platforma-sdk/workflow-tengo:sets")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+slices := import("@platforma-sdk/workflow-tengo:slices")
+
+pSpec := import("@platforma-sdk/workflow-tengo:pframes.spec")
+
+expr := import("@platforma-sdk/workflow-tengo:pt.expression-traverse")
+
+ANNOTATION_HEADER := "annotation"
+
+createFilterFrameName := func(colName) {
+	return colName + "_filter_frame"
+}
+
+createFilterColumnSpec := func(columnSpec, colName, label) {
+	return maps.deepMerge(columnSpec, {
+		kind: "PColumn",
+		valueType: "Int",
+		name: columnSpec.name + "/filter/" + colName,
+		annotations: {
+			"pl7.app/label": columnSpec.annotations["pl7.app/label"] + "/" + label,
+			"pl7.app/isSubset": "true"
+		}
+	});
+}
+
+ENCODE_SEPARATOR := "_encoded_"
+
+encodeColumnName := func(name, idx) {
+	return hex.encode(name) + ENCODE_SEPARATOR + string(idx)
+}
+
+decodeColumnName := func(encoded) {
+	parts := text.split(encoded, ENCODE_SEPARATOR)
+	if len(parts) != 2 {
+		ll.panic("Invalid encoded column name: " + encoded)
+	}
+
+	return string(hex.decode(parts[0]))
+}
+
+addColumnsFromExpression := func(expression, columnsSet) {
+	expr.expressionTraverse(expression, func(node) {
+		if node.type == "col" {
+
+			if is_string(node.name) {
+				sets.add(columnsSet, node.name)
+			}
+			return
+		}
+	})
+}
+
+mapExpressionColumnNames := func(expression, transformFn) {
+	copy := maps.clone(expression)
+	
+	expr.expressionTraverse(copy, func(node) {
+		if node.type == "col" {
+
+			if is_string(node.name) {
+				node.name = transformFn(node.name)
+			}
+		}
+	})
+
+	return copy
+}
+
+extractColumnsFromExpressions := func(expressions) {
+	columnsSet := {}
+
+	for expression in expressions {
+		addColumnsFromExpression(expression, columnsSet)
+	}
+
+	return sets.toSlice(columnsSet)
+}
+
+prepareResultColumnSpec := func(args) {
+	blockId := wf.getBlockId()
+	
+	steps := slices.filter([args.trace, {
+		id: blockId,
+		type: "milaboratories.annotation",
+		label: args.title,
+		importance: 20
+	}], func(v) { return !is_undefined(v) })
+	
+	trace := pSpec.makeTrace(steps...)
+
+	return trace.inject({
+		kind: "PColumn",
+		valueType: "String",
+		name: "pl7.app/annotation/result",
+		domain: { "pl7.app/annotationRunId": blockId },
+		axesSpec: args.resultAxesSpec,
+		annotations: { "pl7.app/label": args.title }
+	})
+}
+
+export ll.toStrict({
+	ANNOTATION_HEADER: ANNOTATION_HEADER,
+
+	encodeColumnName: encodeColumnName,
+	decodeColumnName: decodeColumnName,
+	createFilterFrameName: createFilterFrameName,
+	prepareResultColumnSpec: prepareResultColumnSpec,
+	createFilterColumnSpec: createFilterColumnSpec,
+	mapExpressionColumnNames: mapExpressionColumnNames,
+	extractColumnsFromExpressions: extractColumnsFromExpressions
+})

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

@@ -394,11 +394,6 @@ pColumnBundleUnmarshaller := func() {
 				}
 			}
 
-
-
-
-			axisHeaderOverrides := []
-
 			get := func(resultKey) {
 				if !is_string(resultKey) {
 					resultKey = canonical.encode(resultKey)
@@ -435,7 +430,11 @@ pColumnBundleUnmarshaller := func() {
 
 
 
-				getColumn: func(resultKey) {
+
+
+
+				getColumn: func(resultKey, ...options) {
+					options = is_array(options) && is_map(options[0]) ? options[0] : {}
 					processedId := processColumnId(resultKey)
 					columnKeyForPool := processedId.columnKey // Key to fetch from the pool (source for filtered)
 					columnAxisFilters := processedId.axisFilters // Filters from FilteredPColumnId
@@ -450,7 +449,7 @@ pColumnBundleUnmarshaller := func() {
 						ll.panic("Cannot get a single column from a multi-column result: %v. Use getColumns() instead.", columnKeyForPool)
 					}
 
-					currentSpec := bundle.getSpec(resultKey) // getSpec already handles filtering for the spec
+					currentSpec := bundle.getSpec(resultKey, options) // getSpec already handles filtering for the spec
 					currentData := result.data
 
 
@@ -458,7 +457,9 @@ pColumnBundleUnmarshaller := func() {
 						sliceDataTemplate := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.slice-data")
 						currentData = render.createEphemeral(sliceDataTemplate, {
 							data: currentData,
-							slicingParams: smart.createJsonResource(columnAxisFilters)
+							slicingParams: smart.createJsonResource(columnAxisFilters),
+							keepColumns: options.keepColumns,
+							ignoreNonPartitioned: options.ignoreNonPartitioned
 						}).output("result")
 					}
 
@@ -475,11 +476,16 @@ pColumnBundleUnmarshaller := func() {
 
 
 
-				getSpec: func(id) {
+
+
+				getSpec: func(id, ...options) {
 					processedId := processColumnId(id)
 					columnKey := processedId.columnKey
 					columnAxisFilters := processedId.axisFilters // Filters from FilteredPColumnId
 
+					options = is_array(options) && is_map(options[0]) ? options[0] : {}
+					keepColumns := is_bool(options.keepColumns) ? options.keepColumns : false
+
 					if is_undefined(pool[columnKey]) {
 						ll.panic("Column not found in bundle: " + columnKey)
 					}
@@ -492,9 +498,11 @@ pColumnBundleUnmarshaller := func() {
 					baseSpec := result.spec
 
 
-					if !is_undefined(columnAxisFilters) && len(columnAxisFilters) > 0 {
-						prepared := pSpec.prepareAxisFilters(columnAxisFilters, baseSpec)
-						return prepared.columnSpec
+					if !keepColumns && !is_undefined(columnAxisFilters) && len(columnAxisFilters) > 0 {
+						prepared := pSpec.prepareAxisFiltersAndAxesSpec(columnAxisFilters, baseSpec.axesSpec)
+						clonedSpec := maps.clone(baseSpec)
+						clonedSpec.axesSpec = prepared.axesSpec
+						return clonedSpec
 					} else {
 
 						return baseSpec
@@ -505,15 +513,73 @@ pColumnBundleUnmarshaller := func() {
 
 
 
+				getColumnKeys: func() {
+					return maps.getKeys(pool)
+				},
+
+
+
+
+
+
+
+
 
 
-				setAxisHeader: func(matcher, header) {
-					if is_string(matcher) {
-						matcher = { name: matcher, domain: {} }
+				getAxesSpec: func(...columnIds) {
+
+					uniqueAxesMap := {}
+					allAxes := []
+
+
+					processAxesSpec := func(spec) {
+						if !is_undefined(spec) && !is_undefined(spec.axesSpec) {
+							for axis in spec.axesSpec {
+								axisKey := pSpec.getAxisId(axis)
+								
+
+								if is_undefined(uniqueAxesMap[axisKey]) {
+									uniqueAxesMap[axisKey] = true
+									allAxes = append(allAxes, axis)
+								}
+							}
+						}
+					}
+
+
+					processResult := func(result) {
+						if is_array(result) {
+
+							for _, col in result {
+								processAxesSpec(col.spec)
+							}
+						} else {
+
+							processAxesSpec(result.spec)
+						}
+					}
+
+
+					if len(columnIds) > 0 {
+						for id in columnIds {
+							processedId := processColumnId(id)
+							columnKey := processedId.columnKey
+
+							result := pool[columnKey]
+							if is_undefined(result) {
+								ll.panic("Column not found: %v. Pool: %v", columnKey, maps.getKeys(pool))
+							}
+							
+							processResult(result)
+						}
+					} else {
+
+						for result in pool {
+							processResult(result)
+						}
 					}
 
-					axisHeaderOverrides = [[matcher, header]] + axisHeaderOverrides
-					return bundle
+					return allAxes
 				}
 			})
 

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

@@ -165,6 +165,7 @@ transformTsvSettings := func(settings) {
 
 
 exportFrame := func(pf) {
+	ll.assert(!is_undefined(pf), "pframe reference is required")
 	return render.createEphemeral(assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.export-pframe"), { pf: pf }).output("result")
 }
 

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

@@ -10,6 +10,7 @@ sets := import("@platforma-sdk/workflow-tengo:sets")
 slices := import("@platforma-sdk/workflow-tengo:slices")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 json := import("json")
+canonical := import("@platforma-sdk/workflow-tengo:canonical")
 
 
 
@@ -234,27 +235,33 @@ _TRACE_SCHEMA := [_TRACE_STEP_SCHEMA]
 
 
 
-makeTrace := func(input, ...steps) {
-
-	validation.assertType(steps, _TRACE_SCHEMA)
-
-	currentTraceContent := undefined
-	if is_string(input) {
-		currentTraceContent = input
-	} else if is_string(input[A_TRACE]) {
-		currentTraceContent = input[A_TRACE]
-	} else if is_string(input["annotations"][A_TRACE]) {
-		currentTraceContent = input["annotations"][A_TRACE]
-	}
+makeTrace := func(...steps) {
+	ll.assert(len(steps) > 0, "makeTrace: expects at least one argument")
+	
 
+	input := steps[0]
+	steps = steps[1:]
 	currentTrace := []
-	if !is_undefined(currentTraceContent) {
-		currentTrace = json.decode(currentTraceContent)
+	
+	if (!validation.isValid(input, _TRACE_STEP_SCHEMA)) {
+		inputTraceContent := undefined
+
+		if is_string(input) {
+			inputTraceContent = input
+		} else if is_map(input) && is_string(input[A_TRACE]) {
+			inputTraceContent = input[A_TRACE]
+		} else if is_map(input["annotations"]) && is_map(input["annotations"]) && is_string(input["annotations"][A_TRACE]) {
+			inputTraceContent = input["annotations"][A_TRACE]
+		}
 
-		validation.assertType(currentTrace, _TRACE_SCHEMA)
+		if !is_undefined(inputTraceContent) {
+			currentTrace = json.decode(inputTraceContent)
+			validation.assertType(currentTrace, _TRACE_SCHEMA)
+		}
 	}
 
 	if len(steps) > 0 {
+		validation.assertType(steps, _TRACE_SCHEMA)
 		currentTrace = append(currentTrace, steps...)
 	}
 	currentTraceStr := string(json.encode(currentTrace))
@@ -465,7 +472,7 @@ createSpecDistiller := func(specs) {
 
 
 
-prepareAxisFilters := func(rules, spec) {
+prepareAxisFiltersAndAxesSpec := func(rules, axesSpec) {
 	axisFilters := []
 	filteredIndices := {}
 
@@ -480,7 +487,7 @@ prepareAxisFilters := func(rules, spec) {
 		axisIdx := axisIdentifier
 		if is_string(axisIdentifier) {
 			axisIdx = -1
-			for idx, axis in spec.axesSpec {
+			for idx, axis in axesSpec {
 				if axis.name == axisIdentifier {
 					axisIdx = idx
 					break
@@ -488,7 +495,7 @@ prepareAxisFilters := func(rules, spec) {
 			}
 
 			if axisIdx == -1 {
-				ll.panic("Cannot find axis with name '%v' in column spec %v", axisIdentifier, spec)
+				ll.panic("Cannot find axis with name '%v' in column spec %v", axisIdentifier, axesSpec)
 			}
 		}
 
@@ -501,18 +508,16 @@ prepareAxisFilters := func(rules, spec) {
 		filteredIndices[axisIdx] = true
 	}
 
-	transformedSpec := maps.clone(spec)
 	newAxesSpec := []
-	for idx, axis in spec.axesSpec {
+	for idx, axis in axesSpec {
 		if !filteredIndices[idx] {
 			newAxesSpec = append(newAxesSpec, maps.clone(axis))
 		}
 	}
-	transformedSpec.axesSpec = newAxesSpec
 
 	return {
 		axisFilters: axisFilters,
-		columnSpec: transformedSpec
+		axesSpec: newAxesSpec
 	}
 }
 
@@ -535,6 +540,15 @@ axisSpecToMatcher := func(axisSpec) {
 	return matcher
 }
 
+getAxisId := func(axisSpec) {
+	validation.assertType(axisSpec, P_AXIS_SPEC_SCHEMA)
+	return canonical.encode({
+		name: axisSpec.name,
+		type: axisSpec.type,
+		domain: axisSpec.domain
+	})
+}
+
 export ll.toStrict({
 	P_UNTYPED_SPEC_SCHEMA: P_UNTYPED_SPEC_SCHEMA,
 	P_AXIS_SPEC_SCHEMA: P_AXIS_SPEC_SCHEMA,
@@ -561,7 +575,9 @@ export ll.toStrict({
 
 	createSpecDistiller: createSpecDistiller,
 
-	prepareAxisFilters: prepareAxisFilters,
-	axisSpecToMatcher: axisSpecToMatcher
+	prepareAxisFiltersAndAxesSpec: prepareAxisFiltersAndAxesSpec,
+	axisSpecToMatcher: axisSpecToMatcher,
+
+	getAxisId: getAxisId
 })
 

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

@@ -436,7 +436,7 @@ pFrameToColumnsMap := func(pf) {
 		ll.assert(pf.checkResourceType(constants.RTYPE_P_FRAME), "Unexpected resource type: %v", pf.info().Type)
 		ll.assert(pf.info().InputsLocked, "PFrame resource does not have inputs locked")
 		for key, field in pf.inputs() {
-			addColumnSegment(key, field.getValue())
+			addColumnSegment(key, field)
 		}
 	} else if ll.isMap(pf) {
 		for key, value in pf {

package/dist/tengo/lib/pt.expression-traverse.lib.tengo

@@ -0,0 +1,198 @@
+ll := import("@platforma-sdk/workflow-tengo:ll")
+
+isExpression := func(v) {
+	return !is_undefined(v) && is_map(v) && is_string(v.type)
+}
+
+expressionTraverse := func(expression, visitFn) {
+	if (!isExpression(expression)) {
+		return
+	}
+
+	visitFn(expression)
+
+
+	t := expression.type
+
+	if t == "col" {
+		return
+	}
+
+	if t == "const" {
+		return
+	}
+
+
+	if t == "eq" || t == "neq" || t == "gt" || t == "lt" || t == "ge" || t == "le" {
+		expressionTraverse(expression.lhs, visitFn)
+		expressionTraverse(expression.rhs, visitFn)
+		return
+	}
+
+
+	if t == "and" || t == "or" {
+		if is_array(expression.operands) {
+			for _, op in expression.operands { expressionTraverse(op, visitFn) }
+		}
+		return
+	}
+	if t == "not" {
+		expressionTraverse(expression.value, visitFn)
+		return
+	}
+
+
+	if t == "plus" || t == "minus" || t == "multiply" || t == "truediv" || t == "floordiv" {
+		expressionTraverse(expression.lhs, visitFn)
+		expressionTraverse(expression.rhs, visitFn)
+		return
+	}
+
+
+	if t == "log10" || t == "log" || t == "log2" || t == "abs" || t == "sqrt" || t == "negate" || t == "floor" || t == "round" || t == "ceil" {
+		expressionTraverse(expression.value, visitFn)
+		return
+	}
+
+	if t == "cast" {
+		expressionTraverse(expression.value, visitFn)
+		return
+	}
+
+
+	if t == "is_na" || t == "is_not_na" {
+		expressionTraverse(expression.value, visitFn)
+		return
+	}
+
+
+	if t == "str_join" {
+		if is_array(expression.operands) {
+			for _, op in expression.operands { expressionTraverse(op, visitFn) }
+		}
+		return
+	}
+	if t == "hash" {
+		expressionTraverse(expression.value, visitFn)
+		return
+	}
+	if t == "to_upper" || t == "to_lower" || t == "str_len" {
+		expressionTraverse(expression.value, visitFn)
+		return
+	}
+	if t == "string_distance" {
+		expressionTraverse(expression.string1, visitFn)
+		expressionTraverse(expression.string2, visitFn)
+		return
+	}
+	if t == "fuzzy_string_filter" {
+		expressionTraverse(expression.value, visitFn)
+		if isExpression(expression.pattern) { expressionTraverse(expression.pattern, visitFn) }
+		return
+	}
+	if t == "when_then_otherwise" {
+		if is_array(expression.conditions) {
+			for _, c in expression.conditions {
+
+				if is_map(c) {
+					expressionTraverse(c.when, visitFn)
+					expressionTraverse(c.then, visitFn)
+				}
+			}
+		}
+		expressionTraverse(expression.otherwise, visitFn)
+		return
+	}
+	if t == "substring" {
+		expressionTraverse(expression.value, visitFn)
+		expressionTraverse(expression.start, visitFn)
+		if !is_undefined(expression.length) { expressionTraverse(expression.length, visitFn) }
+		if !is_undefined(expression.end) { expressionTraverse(expression.end, visitFn) }
+		return
+	}
+	if t == "str_replace" {
+		expressionTraverse(expression.value, visitFn)
+		if isExpression(expression.pattern) { expressionTraverse(expression.pattern, visitFn) }
+		if isExpression(expression.replacement) { expressionTraverse(expression.replacement, visitFn) }
+		return
+	}
+	if t == "str_contains" {
+		expressionTraverse(expression.value, visitFn)
+		if isExpression(expression.pattern) { expressionTraverse(expression.pattern, visitFn) }
+		return
+	}
+	if t == "str_starts_with" {
+		expressionTraverse(expression.value, visitFn)
+		if isExpression(expression.prefix) { expressionTraverse(expression.prefix, visitFn) }
+		return
+	}
+	if t == "str_ends_with" {
+		expressionTraverse(expression.value, visitFn)
+		if isExpression(expression.suffix) { expressionTraverse(expression.suffix, visitFn) }
+		return
+	}
+	if t == "str_contains_any" {
+		expressionTraverse(expression.value, visitFn)
+		return
+	}
+	if t == "str_count_matches" {
+		expressionTraverse(expression.value, visitFn)
+		if isExpression(expression.pattern) { expressionTraverse(expression.pattern, visitFn) }
+		return
+	}
+	if t == "str_extract" {
+		expressionTraverse(expression.value, visitFn)
+		if isExpression(expression.pattern) { expressionTraverse(expression.pattern, visitFn) }
+		return
+	}
+
+
+	if t == "min" || t == "max" {
+		if is_array(expression.operands) {
+			for _, op in expression.operands { expressionTraverse(op, visitFn) }
+		}
+		return
+	}
+	if t == "fill_null" || t == "fill_nan" {
+		expressionTraverse(expression.input, visitFn)
+		expressionTraverse(expression.fillValue, visitFn)
+		return
+	}
+	if t == "aggregate" {
+		expressionTraverse(expression.value, visitFn)
+		if is_array(expression.partitionBy) {
+			for _, p in expression.partitionBy { expressionTraverse(p, visitFn) }
+		}
+		return
+	}
+	if t == "rank" {
+		if is_array(expression.partitionBy) {
+			for _, p in expression.partitionBy { expressionTraverse(p, visitFn) }
+		}
+		if is_array(expression.orderBy) {
+			for _, o in expression.orderBy { expressionTraverse(o, visitFn) }
+		}
+		return
+	}
+	if t == "cumsum" {
+		expressionTraverse(expression.value, visitFn)
+		if is_array(expression.additionalOrderBy) {
+			for _, o in expression.additionalOrderBy { expressionTraverse(o, visitFn) }
+		}
+		if is_array(expression.partitionBy) {
+			for _, p in expression.partitionBy { expressionTraverse(p, visitFn) }
+		}
+		return
+	}
+	if t == "struct_field" {
+		expressionTraverse(expression.struct, visitFn)
+		return
+	}
+
+	ll.panic("Unknown expression type: " + t)
+}
+
+export ll.toStrict({
+    expressionTraverse: expressionTraverse,
+    isExpression: isExpression
+})

package/dist/tengo/lib/pt.lib.tengo

@@ -58,7 +58,6 @@ _newDataFrameGroupBy := undefined
 
 workflowCounter := 0
 
-
 _validateColumn := func(name, columnStruct) {
 	ll.assert(is_string(name), "column name must be a string")
 	ll.assert(is_map(columnStruct), "columnStruct must be a map")
@@ -646,25 +645,35 @@ workflow := func() {
 
 
 
-		frameFromColumnBundle: func(bundle, options) {
+		frameFromColumnBundle: func(bundle, ...options) {
+			options = len(options) > 0 && is_map(options[0]) ? options[0] : {}
 			util.validateParamsForFrameFromColumnBundle(options)
 
+			columns := is_array(options.columns) ? options.columns : bundle.getColumnKeys()
+
+			axes := bundle.getAxesSpec(columns...)
+
 			entries := []
 			aliases := []
-			for axis in options.axes {
-				aliases = append(aliases, exp.sc.axis(axis.spec).alias(axis.column))
+
+			for axis in axes {
+				aliases = append(aliases, exp.sc.axis(axis).alias(pframesSpec.getAxisId(axis)))
 			}
-			for column in options.columns {
+
+			for column in columns {
 				decoded := json.decode(column)
+				aliases = append(aliases, exp.col(column))
+
 				if (is_undefined(decoded.axisFilters)) {
-					aliases = append(aliases, exp.col(decoded.name))
-					entry := p.column(decoded.name, bundle.getColumn(decoded))
+					entry := p.column(column, bundle.getColumn(decoded))
 					entries = append(entries, entry)
 				} else {
-					aliases = append(aliases, exp.col(decoded.source.name))
 					entry := p.slicedColumn(
-						decoded.source.name,
-						bundle.getColumn(decoded.source),
+						column,
+						bundle.getColumn(decoded, {
+							keepColumns: true,
+							ignoreNonPartitioned: true
+						}),
 						slices.map(decoded.axisFilters, func(axisFilter) {
 							return {
 								axisIndex: axisFilter[0],
@@ -675,6 +684,7 @@ workflow := func() {
 					entries = append(entries, entry)
 				}
 			}
+
 			return self.frame(p.full(entries...)).select(aliases...)
 		},
 
@@ -978,30 +988,31 @@ _newDataFrameGroupBy = func(parentWorkflow, dfName, groupByExpressions) {
 }
 
 _newDataFrame = func(parentWorkflow, dfName) {
-	_mapExprsToStepCols := func(exprs, methodName, ctx) {
-		ll.assert(len(exprs) > 0, methodName + " requires at least one expression argument.")
+	_mapExprsToStepCols := func(items, methodName, ctx) {
+		ll.assert(len(items) > 0, methodName + " requires at least one expression argument.")
 		cols := []
-		for expr in exprs {
-			if !exp._isExpression(expr) {
-				ll.panic("Invalid argument to " + methodName + ": Expected an expression object, got %v", expr)
+		for item in items {
+			if exp._isExpression(item) {
+				cols = append(cols, item._getExpression(ctx))
+			} else {
+				ll.panic("Invalid argument to " + methodName + ": Expected an expression/column object, got %v", item)
 			}
-			cols = append(cols, expr._getExpression(ctx))
 		}
 		return cols
 	}
 
-	_mapExprsToStepColsAllowingStrings := func(exprs, methodName, ctx) {
-		ll.assert(len(exprs) > 0, methodName + " requires at least one expression argument.")
+	_mapExprsToStepColsAllowingStrings := func(items, methodName, ctx) {
+		ll.assert(len(items) > 0, methodName + " requires at least one expression argument.")
 		cols := []
-		for expr in exprs {
-			if is_string(expr) {
+		for item in items {
+			if is_string(item) {
 
-				colExpr := exp.col(expr)
+				colExpr := exp.col(item)
 				cols = append(cols, colExpr._getExpression(ctx))
-			} else if exp._isExpression(expr) {
-				cols = append(cols, expr._getExpression(ctx))
+			} else if exp._isExpression(item) {
+				cols = append(cols, item._getExpression(ctx))
 			} else {
-				ll.panic("Invalid argument to " + methodName + ": Expected an expression object or string column name, got %v", expr)
+				ll.panic("Invalid argument to " + methodName + ": Expected an expression/column object or string column name, got %v", item)
 			}
 		}
 		return cols

package/dist/tengo/lib/pt.util.lib.tengo

@@ -84,15 +84,13 @@ validateParamsForSaveFrameDirect := func(params) {
 
 _FRAME_FROM_COLUMN_BUNDLE_PARAMS_SCHEMA := {
 
-	`axes`: [_AXIS_SCHEMA],
+	`axes,?`: [spec.P_AXIS_SPEC_SCHEMA],
 
-	`columns`: [`string`]
+	`columns,?`: [`string`]
 }
 
 validateParamsForFrameFromColumnBundle := func(params) {
 	validation.assertType(params, _FRAME_FROM_COLUMN_BUNDLE_PARAMS_SCHEMA, "Invalid params structure")
-    ll.assert(len(params.axes) > 0, "At least one axis is required")
-    ll.assert(len(params.columns) > 0, "At least one column is required")
 }
 
 makeFrameSpecs := func(params) {

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

@@ -140,15 +140,10 @@ map := func(slice, fn) {
 
 
 reduce := func(slice, fn, ...init) {
-	result := undefined
+	result := len(init) > 0 ? init[0] : undefined
 	for i, elem in slice {
-		if i == 0 {
-			result = len(init) > 0 ? init : elem
-		} else {
-			result = fn(result, elem)
-		}
+		result = fn(result, elem)
 	}
-
 	return result
 }
 
@@ -158,6 +153,20 @@ reduce := func(slice, fn, ...init) {
 
 
 
+reverse := func(slice) {
+	rev := []
+	for i := len(slice)-1; i >= 0; i-- {
+		rev = append(rev, slice[i])
+	}
+	return rev
+}
+
+
+
+
+
+
+
 
 
 
@@ -376,6 +385,7 @@ export ll.toStrict({
 	filter: filter,
 	map: map,
 	reduce: reduce,
+	reverse: reverse,
 	flatten: flatten,
 	every: every,
 	quickSortInPlace: quickSortInPlace,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "5.4.5",
+  "version": "5.5.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -18,11 +18,11 @@
   "dependencies": {
     "@milaboratories/software-pframes-conv": "2.2.9",
     "@platforma-open/milaboratories.software-small-binaries": "^1.15.23",
-    "@platforma-open/milaboratories.software-ptabler": "1.12.12",
-    "@platforma-open/milaboratories.software-ptexter": "1.1.1"
+    "@platforma-open/milaboratories.software-ptabler": "1.13.0",
+    "@platforma-open/milaboratories.software-ptexter": "1.2.0"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "2.3.2"
+    "@platforma-sdk/tengo-builder": "2.3.3"
   },
   "scripts": {
     "type-check": "pl-tengo check",