@platforma-sdk/workflow-tengo 3.0.3 → 3.1.0

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

@@ -0,0 +1,544 @@
+smart := import("@platforma-sdk/workflow-tengo:smart")
+json := import("json")
+text := import("text")
+pConstants := import("@platforma-sdk/workflow-tengo:pframes.constants")
+bquery := import("@platforma-sdk/workflow-tengo:workflow.bquery")
+canonical := import("@platforma-sdk/workflow-tengo:canonical")
+pSpec := import("@platforma-sdk/workflow-tengo:pframes.spec")
+pBuilder := import("@platforma-sdk/workflow-tengo:pframes.builder")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+ll := import("@platforma-sdk/workflow-tengo:ll")
+xsv := import("@platforma-sdk/workflow-tengo:pframes.xsv")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+render := import("@platforma-sdk/workflow-tengo:render")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+createBuilder := func(ctx) {
+
+
+
+	refs := {}
+
+	anchors := {}
+
+	queries := {}
+
+	self := undefined
+	self = {
+
+
+
+
+
+		addRef: func(ref) {
+			refKey := canonical.encode(ref)
+
+
+			if !is_string(refs[refKey]) {
+				refs[refKey] = ref
+			}
+		},
+
+
+
+
+
+
+
+		addAnchor: func(anchorId, ref) {
+			anchors[anchorId] = ref
+			refKey := canonical.encode(ref)
+			if is_undefined(refs[refKey]) || is_map(refs[refKey]) {
+				refs[refKey] = anchorId
+			} else {
+				refs[refKey] = ref
+			}
+		},
+
+
+
+
+
+
+
+
+		addById: func(id) {
+			encodedId := undefined
+			decodedId := undefined
+
+			if is_string(id) {
+				decodedId = json.decode(id)
+				encodedId = id
+			} else if is_map(id) {
+				decodedId = id
+			} else {
+				ll.panic("Invalid column ID type. Expected string or object.")
+			}
+
+			if is_map(decodedId) && !is_undefined(decodedId.source) && !is_undefined(decodedId.axisFilters) {
+
+				columnKey := canonical.encode(decodedId.source)
+				queries[columnKey] = decodedId.source
+			} else {
+				queries[encodedId] = decodedId
+			}
+		},
+
+
+
+
+
+
+
+		addQuery: func(queryId, query) {
+			queries[queryId] = query
+		},
+
+
+
+
+
+
+		build: func() {
+			resolveResult := bquery.anchoredQuery(ctx, anchors, queries)
+
+			bundle := smart.mapBuilder(pConstants.RTYPE_P_COLUMN_BUNDLE)
+
+			for refKey, ref in refs {
+				if is_string(ref) {
+					bundle.addRef(refKey, resolveResult.getAnchor(ref))
+				} else {
+					bundle.addRef(refKey, bquery.resolve(ref, ctx))
+				}
+			}
+
+			for queryId, query in queries {
+				bundle.addRef(queryId, resolveResult.getResult(queryId))
+			}
+
+			return bundle.build()
+		}
+	}
+
+	return self
+}
+
+nameCleanPattern := text.re_compile("[-_,.:; \\[\\]}{\"\\\\/:]+")
+
+cleanColumnName := func(name) {
+	return nameCleanPattern.replace(name, "_")
+}
+
+
+
+
+
+
+
+
+
+pColumnBundleUnmarshaller := func() {
+	return {
+		canParse: func(resource) {
+			return smart.isResource(resource) &&
+				resource.info().Type.Name == pConstants.RTYPE_P_COLUMN_BUNDLE.Name
+		},
+
+		parse: func(resource, parser) {
+			bResultUnmarshaller := bquery.resultUnmarshaller()
+
+			pool := {}
+
+			for resultKey, value in resource.inputs() {
+				if !bResultUnmarshaller.canParse(value.getValue()) {
+					ll.panic("Failed to unmarshal value for key: " + resultKey)
+				}
+
+				result := bResultUnmarshaller.parse(value.getValue(), parser)
+
+				pool[resultKey] = {
+					spec: result.spec,
+					data: result.data
+				}
+			}
+
+
+
+
+			axisHeaderOverrides := []
+
+			bundle := undefined
+			bundle = ll.toStrict({
+
+
+
+
+
+				getColumn: func(resultKey) {
+					if !is_string(resultKey) {
+						resultKey = canonical.encode(resultKey)
+					}
+
+					if is_undefined(pool[resultKey]) {
+						ll.panic("Column not found: " + resultKey)
+					}
+					return pool[resultKey]
+				},
+
+
+
+
+
+
+
+				setAxisHeader: func(matcher, header) {
+					if is_string(matcher) {
+						matcher = { name: matcher, domain: {} }
+					}
+
+					axisHeaderOverrides = [[matcher, header]] + axisHeaderOverrides
+					return bundle
+				},
+
+
+
+
+				xsvTableBuilder: func() {
+					localAxisHeaderOverrides := copy(axisHeaderOverrides)
+
+					requests := []
+					addedColumns := {}
+
+					findAxisHeaderOverride := func(spec) {
+						for _, override in localAxisHeaderOverrides {
+							matcher := override[0]
+
+							if matcher.name == spec.name {
+								domainsMatch := true
+
+								for domainKey, domainValue in matcher.domain {
+									if is_undefined(spec.domain) ||
+									   is_undefined(spec.domain[domainKey]) ||
+									   spec.domain[domainKey] != domainValue {
+										domainsMatch = false
+										break
+									}
+								}
+
+								if domainsMatch {
+									return override[1]
+								}
+							}
+						}
+						return undefined
+					}
+
+					distiller := undefined
+
+					getSpecDistiller := func() {
+						if is_undefined(distiller) {
+							columnsToDistill := []
+							for request in requests {
+								col := pool[request.key]
+								columnsToDistill = append(columnsToDistill, col.spec)
+							}
+							distiller = pSpec.createSpecDistiller(columnsToDistill)
+						}
+						return distiller
+					}
+
+					generateLabelForAxis := func(spec) {
+						name := spec.name
+						label := undefined
+
+						label = findAxisHeaderOverride(spec)
+
+						if is_undefined(label) {
+							specDistiller := getSpecDistiller()
+							discriminativeDomains := specDistiller.getDiscriminativeDomains(name)
+
+							if len(discriminativeDomains) == 0 {
+								label = cleanColumnName(name)
+							} else {
+								ll.panic("Cannot deduce header for %s in axis. Discriminative domains: %s. Please provide a header override.",
+									name, discriminativeDomains)
+							}
+						}
+
+						if is_undefined(label) {
+							ll.panic("Cannot deduce header for %s in axis. Please provide a header override.",
+								name)
+						}
+
+						return label
+					}
+
+
+					processColumnId := func(id) {
+						columnKey := undefined
+						columnAxisFilters := undefined
+						serializedId := undefined
+
+						if is_string(id) {
+							serializedId = id
+							decodedId := json.decode(id)
+
+							if is_map(decodedId) && !is_undefined(decodedId.source) && !is_undefined(decodedId.axisFilters) {
+								columnKey = canonical.encode(decodedId.source)
+								columnAxisFilters = decodedId.axisFilters
+							} else {
+								columnKey = id
+							}
+						} else if is_map(id) {
+							if !is_undefined(id.source) && !is_undefined(id.axisFilters) {
+								columnKey = canonical.encode(id.source)
+								columnAxisFilters = id.axisFilters
+								serializedId = canonical.encode(id)
+							} else {
+								columnKey = canonical.encode(id)
+								serializedId = columnKey
+							}
+						} else {
+							ll.panic("Invalid column ID type. Expected string or object.")
+						}
+
+						return {
+							columnKey: columnKey,
+							axisFilters: columnAxisFilters,
+							canonicalId: serializedId
+						}
+					}
+
+					tableBuilder := undefined
+					tableBuilder = {
+
+
+
+
+
+
+
+						add: func(key, ...ops) {
+
+							distiller = undefined
+
+							processedId := processColumnId(key)
+							columnKey := processedId.columnKey
+							columnAxisFilters := processedId.axisFilters
+							serializedId := processedId.canonicalId
+
+							if is_undefined(pool[columnKey]) {
+								ll.panic("Column not found: " + columnKey)
+							}
+
+							request := {
+								key: columnKey,
+								canonicalId: serializedId
+							}
+
+							if !is_undefined(columnAxisFilters) {
+								request.axisFilters = columnAxisFilters
+							}
+
+							if len(ops) > 0 {
+								if !is_undefined(ops[0].header) {
+									request.headerOverride = ops[0].header
+								}
+
+								if !is_undefined(ops[0].axisFilters) {
+									if !is_undefined(request.axisFilters) {
+										ll.panic("Cannot provide axis filters in both FilteredPColumnId and options. Use either one, not both.")
+									} else {
+										request.axisFilters = ops[0].axisFilters
+
+										request.canonicalId = canonical.encode({
+											source: json.decode(columnKey),
+											axisFilters: ops[0].axisFilters
+										})
+									}
+								}
+							}
+
+							if !is_undefined(request.axisFilters) && len(request.axisFilters) > 0 {
+								colSpec := pool[columnKey].spec
+								prepared := pSpec.prepareAxisFilters(request.axisFilters, colSpec)
+
+								request.axisFilters = prepared.axisFilters
+								request.columnSpec = prepared.columnSpec
+							} else {
+								request.columnSpec = pool[columnKey].spec
+							}
+
+							if !is_undefined(addedColumns[request.canonicalId]) {
+								ll.panic("Duplicate column detected: %s. This column has already been added to the table.",
+									request.canonicalId)
+							}
+
+							addedColumns[request.canonicalId] = true
+
+							request.safeId = cleanColumnName(request.canonicalId)
+
+							if !is_undefined(request.headerOverride) {
+								request.header = request.headerOverride
+							} else {
+
+								request.header = request.safeId
+							}
+
+							requests = append(requests, request)
+							return tableBuilder
+						},
+
+
+
+
+
+
+
+						setAxisHeader: func(matcher, header) {
+							if is_string(matcher) {
+								matcher = { name: matcher, domain: {} }
+							}
+
+							localAxisHeaderOverrides = [[matcher, header]] + localAxisHeaderOverrides
+							return tableBuilder
+						},
+
+
+
+
+
+
+
+
+
+
+						build: func(format, ...params) {
+							if format != "csv" && format != "tsv" {
+								ll.panic("Invalid format: '%s'. Expected 'csv' or 'tsv'.", format)
+							}
+
+							exportParams := {
+								naStr: "",
+								nullStr: ""
+							}
+							if len(params) > 0 {
+								exportParams = maps.deepMerge(exportParams, params[0])
+							}
+
+							sliceDataTemplate := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.slice-data")
+
+							columnDistiller := getSpecDistiller()
+
+							pFrame := pBuilder.pFrameBuilder()
+
+							for request in requests {
+								col := pool[request.key]
+								colData := col.data
+
+								if !is_undefined(request.axisFilters) {
+									colData = render.createEphemeral(sliceDataTemplate, {
+										data: colData,
+										slicingParams: smart.createJsonResource(request.axisFilters)
+									}).output("result")
+								}
+
+								preparedSpec := columnDistiller.distill(request.columnSpec)
+
+								preparedSpec = maps.deepMerge(preparedSpec, {
+									annotations: { "pl7.app/label": request.header }
+								})
+
+								for i, axis in preparedSpec.axesSpec {
+									preparedSpec.axesSpec[i] = maps.deepMerge(axis, {
+										annotations: { "pl7.app/label": generateLabelForAxis(axis) }
+									})
+								}
+
+
+								pFrame.add(request.safeId, preparedSpec, colData)
+							}
+
+							return xsv.exportFrame(pFrame.build(), format, exportParams)
+						},
+
+
+
+
+
+
+
+
+						getHeader: func(item) {
+
+							if is_map(item) && !is_undefined(item.type) {
+								return generateLabelForAxis(item)
+							}
+
+							serializedId := processColumnId(item).canonicalId
+
+							for _, request in requests {
+								if request.canonicalId == serializedId {
+									return request.header
+								}
+							}
+
+							ll.panic("Column not found in the table: %s. Make sure to call add() before getHeader().",
+								serializedId)
+						}
+					}
+
+					return tableBuilder
+				}
+			})
+
+			return bundle
+		}
+	}
+}
+
+export ll.toStrict({
+	createBuilder: createBuilder,
+	pColumnBundleUnmarshaller: pColumnBundleUnmarshaller
+})

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

@@ -43,6 +43,8 @@ P_COLUMN_SUPER_PARTITIONED_DATA_TYPE_PREFIX := P_COLUMN_DATA_TYPE_PREFIX + "Part
 RTYPE_P_COLUMN_DATA_JSON_SUPER_PARTITIONED := { Name: P_COLUMN_SUPER_PARTITIONED_DATA_TYPE_PREFIX + "JsonPartitioned", Version: "1" }
 RTYPE_P_COLUMN_DATA_BINARY_SUPER_PARTITIONED := { Name: P_COLUMN_SUPER_PARTITIONED_DATA_TYPE_PREFIX + "BinaryPartitioned", Version: "1" }
 
+RTYPE_P_COLUMN_BUNDLE := { Name: "PColumnBundle", Version: "1" }
+
 KIND_P_COLUMN := "PColumn"
 
 export ll.toStrict({
@@ -63,5 +65,7 @@ export ll.toStrict({
 	RTYPE_P_COLUMN_DATA_JSON_PARTITIONED          : RTYPE_P_COLUMN_DATA_JSON_PARTITIONED,
 	RTYPE_P_COLUMN_DATA_BINARY_PARTITIONED        : RTYPE_P_COLUMN_DATA_BINARY_PARTITIONED,
 	RTYPE_P_COLUMN_DATA_JSON_SUPER_PARTITIONED    : RTYPE_P_COLUMN_DATA_JSON_SUPER_PARTITIONED,
-	RTYPE_P_COLUMN_DATA_BINARY_SUPER_PARTITIONED  : RTYPE_P_COLUMN_DATA_BINARY_SUPER_PARTITIONED
+	RTYPE_P_COLUMN_DATA_BINARY_SUPER_PARTITIONED  : RTYPE_P_COLUMN_DATA_BINARY_SUPER_PARTITIONED,
+
+	RTYPE_P_COLUMN_BUNDLE                         : RTYPE_P_COLUMN_BUNDLE
 })

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

@@ -273,6 +273,9 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			}
 			outputSpecs[output.name] = spec
 		} else if output.type == "Xsv" {
+			if is_undefined(output.settings) {
+				ll.panic("settings are required for Xsv output")
+			}
 			decomposition := pUtil.decomposePfconvImportCfg(output.settings, {
 				additionalAxesSpec: iterationAxesSpec
 			})