@platforma-sdk/workflow-tengo 6.14.0 → 6.16.0

package/dist/tengo/lib/pframes.table-builder.lib.tengo

@@ -46,6 +46,33 @@ VALID_FORMATS := {
 
 
 
+
+
+
+
+
+
+
+
+VALID_COLUMN_JOINS := {
+	left: true,
+	full: true,
+	inner: true
+}
+
+
+columnJoinOpt := func(opts) {
+	if len(opts) == 0 || !ll.isMap(opts[0]) || is_undefined(opts[0].join) {
+		return undefined
+	}
+	join := opts[0].join
+	ll.assert(!is_undefined(VALID_COLUMN_JOINS[join]),
+		"join must be one of [left, full, inner], got '%v'", join)
+	return join
+}
+
+
+
 isUnresolved := func(value) {
 	stack := [value]
 	si := 0
@@ -142,6 +169,7 @@ tableBuilder := func(format, ...ctxArg) {
 	_primaries := []
 	_columns := []
 	_joinMode := "inner"
+	_columnJoin := "full"
 	_axisHeaders := []
 	_cpu := undefined
 	_mem := undefined
@@ -195,18 +223,23 @@ tableBuilder := func(format, ...ctxArg) {
 
 
 
+
+
+
 		addColumn: func(query, ...opts) {
 			header := undefined
 			if len(opts) > 0 && ll.isMap(opts[0]) {
 				header = opts[0].header
 			}
+			join := columnJoinOpt(opts)
 			if isUnresolved(query) || isEnrichmentRef(query) {
 				_hasUnresolved = true
 			}
 			_columns = append(_columns, {
 				query: query,
 				header: header,
-				mode: "single"
+				mode: "single",
+				join: join
 			})
 			return self
 		},
@@ -219,6 +252,9 @@ tableBuilder := func(format, ...ctxArg) {
 
 
 
+
+
+
 		addColumns: func(query, ...opts) {
 			headerPrefix := undefined
 			headerSuffix := undefined
@@ -226,6 +262,7 @@ tableBuilder := func(format, ...ctxArg) {
 				headerPrefix = opts[0].headerPrefix
 				headerSuffix = opts[0].headerSuffix
 			}
+			join := columnJoinOpt(opts)
 
 
 
@@ -254,7 +291,8 @@ tableBuilder := func(format, ...ctxArg) {
 						header: entryHeader,
 						headerPrefix: entryPrefix,
 						headerSuffix: entrySuffix,
-						mode: "multi"
+						mode: "multi",
+						join: join
 					})
 				}
 				return self
@@ -267,7 +305,8 @@ tableBuilder := func(format, ...ctxArg) {
 				query: query,
 				headerPrefix: headerPrefix,
 				headerSuffix: headerSuffix,
-				mode: "multi"
+				mode: "multi",
+				join: join
 			})
 			return self
 		},
@@ -291,6 +330,25 @@ tableBuilder := func(format, ...ctxArg) {
 
 
 
+
+
+
+
+
+
+		setColumnJoin: func(mode) {
+			ll.assert(!is_undefined(VALID_COLUMN_JOINS[mode]),
+				"mode must be one of [left, full, inner], got '%v'", mode)
+			_columnJoin = mode
+			return self
+		},
+
+
+
+
+
+
+
 		setAxisHeader: func(matcher, header) {
 			ll.assert(is_string(header), "header must be a string")
 			processedMatcher := undefined
@@ -469,7 +527,8 @@ tableBuilder := func(format, ...ctxArg) {
 					mode: c.mode,
 					header: c.header,
 					headerPrefix: c.headerPrefix,
-					headerSuffix: c.headerSuffix
+					headerSuffix: c.headerSuffix,
+					join: c.join
 				}
 				if isEnrichmentRef(c.query) {
 					resolvedHit := resolveColumn(c.query.hit)
@@ -560,12 +619,14 @@ tableBuilder := func(format, ...ctxArg) {
 				if !is_undefined(c.header) { entry.header = c.header }
 				if !is_undefined(c.headerPrefix) { entry.headerPrefix = c.headerPrefix }
 				if !is_undefined(c.headerSuffix) { entry.headerSuffix = c.headerSuffix }
+				if !is_undefined(c.join) { entry.join = c.join }
 				columnsMap[string(idx)] = entry
 			}
 
 			tplInputs := {
 				format: format,
 				joinMode: _joinMode,
+				columnJoin: _columnJoin,
 				axisHeaders: _axisHeaders,
 				primaryCount: len(primaryEntries),
 				columnCount: len(columnEntries),

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

@@ -410,6 +410,10 @@ workflow := func() {
 	pframeCounter := 0
 
 	cpu := undefined
+	cpuFloor := undefined
+	cpuIntercept := undefined
+	cpuSlope := undefined
+	cpuCeiling := undefined
 	mem := undefined
 	memFloor := undefined
 	memSlope := undefined
@@ -872,6 +876,17 @@ workflow := func() {
 
 
 
+
+
+
+
+
+
+
+
+
+
+
 		cpu: func(amount) {
 			cpu = amount
 			return self
@@ -884,6 +899,61 @@ workflow := func() {
 
 
 
+		cpuFloor: func(cores) {
+			sizing.assertCpuCores(cores, "cpuFloor")
+			cpuFloor = cores
+			return self
+		},
+
+
+
+
+
+
+
+
+		cpuIntercept: func(cores) {
+			sizing.assertCpuCores(cores, "cpuIntercept")
+			cpuIntercept = cores
+			return self
+		},
+
+
+
+
+
+
+
+
+
+
+		cpuSlope: func(slope) {
+			sizing.assertCpuSlope(slope)
+			cpuSlope = slope
+			return self
+		},
+
+
+
+
+
+
+
+
+
+		cpuCeiling: func(cores) {
+			sizing.assertCpuCores(cores, "cpuCeiling")
+			cpuCeiling = cores
+			return self
+		},
+
+
+
+
+
+
+
+
 
 
 
@@ -1094,6 +1164,10 @@ workflow := func() {
 			runMetaInputs := {
 				queue: queue,
 				cpu: cpu,
+				cpuFloor: cpuFloor,
+				cpuIntercept: cpuIntercept,
+				cpuSlope: cpuSlope,
+				cpuCeiling: cpuCeiling,
 				mem: mem,
 				memFloor: memFloor,
 				memSlope: memSlope,

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

@@ -55,6 +55,7 @@
 
 
 
+
 
 
 f := import("@platforma-sdk/workflow-tengo:exec.formula")
@@ -176,10 +177,90 @@ ramFormula := func(opts) {
 
 
 
-cpuFormula := func() {
-	return f.size({ default: 0 }).dividedByFloor(f.gib(CPU_GIB_PER_CORE)).plus(f.const(CPU_MIN)).
-		between(f.const(CPU_MIN), f.const(CPU_MAX)).
-		staticFallback(CPU_MIN)
+assertCpuCores := func(cores, name) {
+	ll.assert(is_int(cores) && cores >= 1,
+		"pt.sizing: %s must be an integer of at least 1, got %v", name, cores)
+}
+
+
+
+
+
+
+assertCpuSlope := func(slope) {
+	ll.assert((is_int(slope) || is_float(slope)) && slope >= 0,
+		"pt.sizing: cpuSlope must be a number of at least 0, got %v", slope)
+}
+
+
+
+
+
+
+
+
+
+cpuSlopeHundredths := func(slope) {
+	assertCpuSlope(slope)
+	return int(float(slope) * 100 + 0.000001)
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+cpuFormula := func(...args) {
+	ll.assert(len(args) <= 1, "pt.sizing.cpuFormula: expected at most one options map")
+	opts := len(args) == 1 && !is_undefined(args[0]) ? args[0] : {}
+	ll.assert(is_map(opts), "pt.sizing.cpuFormula: expected an options map, got %v", opts)
+
+	floor := is_undefined(opts.floor) ? CPU_MIN : opts.floor
+	intercept := is_undefined(opts.intercept) ? CPU_MIN : opts.intercept
+	assertCpuCores(floor, "cpuFloor")
+	assertCpuCores(intercept, "cpuIntercept")
+
+
+
+	slopeTerm := f.size({ default: 0 }).dividedByFloor(f.gib(CPU_GIB_PER_CORE))
+	if !is_undefined(opts.slope) {
+		slopeTerm = f.size({ default: 0 }).times(cpuSlopeHundredths(opts.slope)).dividedByFloor(f.gib(100))
+	}
+	curve := slopeTerm.plus(f.const(intercept))
+	defaultCurve := is_undefined(opts.slope) && is_undefined(opts.intercept)
+
+	ceiling := undefined
+	if !is_undefined(opts.ceiling) {
+		assertCpuCores(opts.ceiling, "cpuCeiling")
+		ll.assert(opts.ceiling >= floor,
+			"pt.sizing: cpuCeiling (%d) must not be less than cpuFloor (%d)", opts.ceiling, floor)
+		ceiling = opts.ceiling
+	} else if defaultCurve {
+		ceiling = floor > CPU_MAX ? floor : CPU_MAX
+	}
+
+
+	fallback := intercept > floor ? intercept : floor
+	if !is_undefined(ceiling) && fallback > ceiling {
+		fallback = ceiling
+	}
+
+	if is_undefined(ceiling) {
+		return curve.atLeast(f.const(floor)).staticFallback(fallback)
+	}
+	return curve.between(f.const(floor), f.const(ceiling)).staticFallback(fallback)
 }
 
 
@@ -206,6 +287,8 @@ export {
 	assertRamIntercept: assertRamIntercept,
 	assertRamFloor: assertRamFloor,
 	cpuFormula: cpuFormula,
+	assertCpuCores: assertCpuCores,
+	assertCpuSlope: assertCpuSlope,
 	scratchFormula: scratchFormula,
 	polarsMaxThreadsExpr: polarsMaxThreadsExpr,
 	assertPolarsMaxThreads: assertPolarsMaxThreads,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "6.14.0",
+  "version": "6.16.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -19,11 +19,11 @@
     "@milaboratories/pframes-rs-wasip2": "1.1.61",
     "@milaboratories/software-pframes-conv": "2.2.9",
     "@platforma-open/milaboratories.software-small-binaries": "^2.1.1",
-    "@platforma-open/milaboratories.software-ptabler": "2.1.14",
-    "@platforma-open/milaboratories.software-ptexter": "1.2.6"
+    "@platforma-open/milaboratories.software-ptexter": "1.2.6",
+    "@platforma-open/milaboratories.software-ptabler": "2.1.14"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "4.1.9"
+    "@platforma-sdk/tengo-builder": "4.1.11"
   },
   "scripts": {
     "types:check": "pl-tengo imports && pl-tengo check",