@platforma-sdk/workflow-tengo 5.3.3 → 5.3.5

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

@@ -10,10 +10,15 @@ render := import("@platforma-sdk/workflow-tengo:render")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 util := import("@platforma-sdk/workflow-tengo:pframes.util")
 pBuilder := import("@platforma-sdk/workflow-tengo:pframes.builder")
+pframesSpec := import("@platforma-sdk/workflow-tengo:pframes.spec")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 assets := import("@platforma-sdk/workflow-tengo:assets")
 xsvIF := import("@platforma-sdk/workflow-tengo:pframes.xsv-import-file")
 text := import("text")
+execConstants := import("@platforma-sdk/workflow-tengo:exec.constants")
+pt := import("@platforma-sdk/workflow-tengo:pt")
+slices := import("@platforma-sdk/workflow-tengo:slices")
+canonical := import("@platforma-sdk/workflow-tengo:canonical")
 
 importXsvIfNullTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.xsv-import-if-not-null")
 
@@ -210,60 +215,6 @@ importFileMap := func(xsvMap, xsvType, spec, ...ops) {
 	return result
 }
 
-isFlatPfMap := func(pf) {
-	if !is_map(pf) {
-		return false
-	}
-
-	for key, _ in pf {
-		if !text.has_suffix(key, ".spec") && !text.has_suffix(key, ".data") {
-			return false
-		}
-	}
-
-	return true
-}
-
-isStructuredPfMap := func(pf) {
-	if !is_map(pf) {
-		return false
-	}
-
-	for _, value in pf {
-		if !is_map(value) {
-			return false
-		}
-
-		for k, _ in value {
-			if k != "spec" && k != "data" {
-				return false
-			}
-		}
-
-		if is_undefined(value.spec) || is_undefined(value.data) {
-			return false
-		}
-	}
-
-	return true
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 
 
@@ -288,13 +239,44 @@ isStructuredPfMap := func(pf) {
 
 
 
+exportFrame := func(pf, xsvType, params, ...ops) {
+	validation.assertType(params, util.PFCONV_EXPORT_CFG_SCHEMA)
+	partialParams := objects.deleteUndefined({
+		naStr: params.naStr,
+		nullStr: params.nullStr,
+		joinType: params.joinType
+	})
 
+	ops := renderOps({}, ops...)
+	ll.assert(is_undefined(ops.partitions), "partitions option is no longer supported")
 
+	runMetaInputs := {
+		queue: ops.queue,
+		cpu: ops.cpu,
+		mem: ops.mem,
+		inputCache: ops.inputCache
+	}
 
-exportFrame := func(pf, xsvType, params, ...ops) {
-	exportPfTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.xsv-export-pframe")
+	if !is_undefined(params.queue) {
+		runMetaInputs.queue = params.queue
+		delete(params, "queue")
+	}
+	if !is_undefined(params.cpu) {
+		runMetaInputs.cpu = params.cpu
+		delete(params, "cpu")
+	}
+	if !is_undefined(params.mem) {
+		runMetaInputs.mem = params.mem
+		delete(params, "mem")
+	}
+	if !is_undefined(params.inputCache) {
+		runMetaInputs.inputCache = params.inputCache
+		delete(params, "inputCache")
+	}
 
-	ops := renderOps({}, ops...)
+	if len(partialParams) < len(params) {
+		ll.panic("Some params are not supported: %v", params)
+	}
 
 	if is_array(pf) {
 
@@ -308,7 +290,7 @@ exportFrame := func(pf, xsvType, params, ...ops) {
 			i = i + 1
 		}
 		pf = pfBuilder.build()
-	} else if isStructuredPfMap(pf) {
+	} else if util.isStructuredPfMap(pf) {
 		pfBuilder := pBuilder.pFrameBuilder()
 		for key, value in pf {
 			pfBuilder.add(key, value.spec, value.data)
@@ -318,18 +300,88 @@ exportFrame := func(pf, xsvType, params, ...ops) {
 		if !pf.checkResourceType(constants.RTYPE_P_FRAME) {
 			ll.panic("Unexpected resource type: %s", pf.info().Type.Name)
 		}
-	} else if !isFlatPfMap(pf) && !smart.isReference(pf) {
+	} else if !util.isFlatPfMap(pf) && !smart.isReference(pf) {
 		ll.panic("Unexpected p-frame format: %s", pf)
 	}
 
-	r := render.create(exportPfTpl, {
-		pf: pf,
-		xsvType: xsvType,
-		params: params,
-		ops: ops
+	resultFile := "result." + xsvType
+
+	columnEntries := []
+	rawColumns := []
+	maps.forEach(util.pFrameToColumnsMap(pf), func(frameUniqueColumnId, columnInfo) {
+		columnEntries = append(columnEntries, pt.p.column(frameUniqueColumnId, columnInfo))
+		rawColumns = append(rawColumns, { id: frameUniqueColumnId, spec: columnInfo.spec })
 	})
 
-	return r.output("result")
+	frameInput := undefined
+	if params.joinType == "Inner" {
+		frameInput = pt.p.inner(columnEntries...)
+	} else {
+		frameInput = pt.p.full(columnEntries...)
+	}
+
+	numericSelector := pt.sc.numeric()
+	if is_string(params.naStr) {
+		numericSelector = numericSelector.fillNull(params.naStr)
+	}
+	stringSelector := pt.sc.string()
+	if is_string(params.nullStr) {
+		stringSelector = stringSelector.fillNull(params.nullStr)
+	}
+
+	specDistiller := pframesSpec.createSpecDistiller(slices.map(rawColumns, func(c) { return c.spec }))
+	canonicalMap := {}
+	uniqueAxes := []
+	for column in rawColumns {
+		for axis in column.spec.axesSpec {
+			distilledAxis := specDistiller.distill(axis)
+			canonicalizedAxisSpec := canonical.encode(distilledAxis)
+			if is_undefined(canonicalMap[canonicalizedAxisSpec]) {
+				canonicalMap[canonicalizedAxisSpec] = true
+				distilledAxis.label = axis.annotations["pl7.app/label"]
+				uniqueAxes = append(uniqueAxes, distilledAxis)
+			}
+		}
+	}
+
+	columnSelectors := []
+	for axis in uniqueAxes {
+		label := axis.label
+		delete(axis, "label")
+		columnSelectors = append(columnSelectors, pt.sc.axis(axis).alias(label))
+	}
+	for column in rawColumns {
+		columnSelectors = append(columnSelectors, pt.col(column.id).alias(column.spec.annotations["pl7.app/label"]))
+	}
+
+	wf := pt.workflow()
+	if runMetaInputs.queue == execConstants.LIGHT_QUEUE {
+		wf = wf.inLightQueue()
+	} else if runMetaInputs.queue == execConstants.MEDIUM_QUEUE {
+		wf = wf.inMediumQueue()
+	} else if runMetaInputs.queue == execConstants.HEAVY_QUEUE {
+		wf = wf.inHeavyQueue()
+	} else if runMetaInputs.queue == execConstants.UI_TASKS_QUEUE {
+		wf = wf.inUiQueue()
+	} else if !is_undefined(runMetaInputs.queue) {
+		ll.panic("Unsupported queue: %v", runMetaInputs.queue)
+	}
+	if !is_undefined(runMetaInputs.cpu) {
+		wf = wf.cpu(runMetaInputs.cpu)
+	}
+	if !is_undefined(runMetaInputs.mem) {
+		wf = wf.mem(runMetaInputs.mem)
+	}
+	if !is_undefined(runMetaInputs.inputCache) {
+		wf = wf.cacheInputs(runMetaInputs.inputCache)
+	}
+	wf.frame(frameInput).
+		select(numericSelector, stringSelector).
+		select(columnSelectors...).
+		save(resultFile)
+
+	result := wf.run()
+	return result.getFile(resultFile)
 }
 
 export ll.toStrict({