@platforma-sdk/workflow-tengo 6.8.3 → 6.9.0

package/dist/tengo/lib/exec.constants.lib.tengo

@@ -28,6 +28,7 @@ RUNNER_EXECUTOR := "executor" // local binary execution
 META_INPUT_MEM_FORMULA := "__memFormula__"
 META_INPUT_CPU_FORMULA := "__cpuFormula__"
 META_INPUT_GPU_FORMULA := "__gpuFormula__"
+META_INPUT_SCRATCH_FORMULA := "__scratchFormula__"
 REGULAR_INPUT_LINE_COUNT := "__metric_lineCount__"
 
 export ll.toStrict({
@@ -49,5 +50,6 @@ export ll.toStrict({
 	META_INPUT_MEM_FORMULA: META_INPUT_MEM_FORMULA,
 	META_INPUT_CPU_FORMULA: META_INPUT_CPU_FORMULA,
 	META_INPUT_GPU_FORMULA: META_INPUT_GPU_FORMULA,
+	META_INPUT_SCRATCH_FORMULA: META_INPUT_SCRATCH_FORMULA,
 	REGULAR_INPUT_LINE_COUNT: REGULAR_INPUT_LINE_COUNT
 })

package/dist/tengo/lib/exec.delayed-compute-allocation.lib.tengo

@@ -22,7 +22,8 @@ create := func(workdir, req) {
 		"queue": "string",
 		"cpu,?": "number",
 		"ram,?": ["or", "number", "string"],
-		"gpuMemory,?": "string"
+		"gpuMemory,?": "string",
+		"scratchFreeSpace,?": ["or", "number", "string"]
 	}, "request must be a valid request")
 
 	reqMap := { queue: req.queue }
@@ -35,6 +36,9 @@ create := func(workdir, req) {
 	if !is_undefined(req.gpuMemory) {
 		reqMap.gpuMemory = req.gpuMemory
 	}
+	if !is_undefined(req.scratchFreeSpace) {
+		reqMap.scratchFreeSpace = req.scratchFreeSpace
+	}
 
 	delayedComputeAllocation := render.createEphemeral(tpl, {
 		request: smart.createJsonResource(reqMap),

package/dist/tengo/lib/exec.formula.lib.tengo

@@ -298,12 +298,21 @@ referencedMetricFiles := func(resolvedNode) {
 
 
 
+
+
+
+
+
+
+
+
 
 
 
 applyFormulaFallback := func(dims) {
 	gpu := is_undefined(dims.gpu) ? {} : dims.gpu
-	res := { ram: dims.ram.static, cpu: dims.cpu.static, gpu: gpu.static, err: undefined }
+	scratch := is_undefined(dims.scratch) ? {} : dims.scratch
+	res := { ram: dims.ram.static, cpu: dims.cpu.static, gpu: gpu.static, scratch: scratch.static, err: undefined }
 	if !is_undefined(_unwrap(dims.ram.ast)) && is_undefined(res.ram) {
 		if is_undefined(dims.ram.fallback) {
 			res.err = "exec.builder: the RAM formula needs a static fallback on backends that can't evaluate resource formulas at run time. Provide .staticFallback(...) on the RAM formula, set a static ram, or upgrade the backend."
@@ -325,6 +334,9 @@ applyFormulaFallback := func(dims) {
 		}
 		res.gpu = gpu.fallback
 	}
+	if !is_undefined(_unwrap(scratch.ast)) && is_undefined(res.scratch) {
+		res.scratch = scratch.fallback
+	}
 	return res
 }
 

package/dist/tengo/lib/exec.lib.tengo

@@ -61,6 +61,12 @@ _assertValidGpuRequest := func(amount, ctx) {
 }
 
 
+_assertValidScratchRequest := func(amount, ctx) {
+	validation.assertType(amount, ["or", "number", "string"], ctx + ": scratch space amount must be a number of bytes or a size string like '500GiB'")
+	ll.assert(is_string(amount) || amount >= 16 * units.MiB, ctx + ": scratch space in bytes should be at least 16MiB (did you pass bytes instead of GiB?)")
+}
+
+
 
 
 
@@ -92,6 +98,7 @@ builder := func() {
 	cpuRequest := undefined
 	ramRequest := undefined
 	gpuMemory := undefined
+	scratchFreeSpace := undefined
 
 
 
@@ -103,6 +110,8 @@ builder := func() {
 	cpuFormulaFallback := undefined
 	gpuFormulaAst := undefined
 	gpuFormulaFallback := undefined
+	scratchFormulaAst := undefined
+	scratchFormulaFallback := undefined
 	fileTags := {}   // fileName -> tag (for f.size("tag") / f.lineCount("tag") aggregation)
 
 	commandName := ""
@@ -520,6 +529,27 @@ builder := func() {
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -592,6 +622,20 @@ builder := func() {
 					memFormulaFallback = undefined
 				}
 			}
+			setScratch := func(v, ctx) {
+				if execFormula.isFormula(v) {
+					scratchFormulaAst = execFormula.astOf(v)
+					scratchFormulaFallback = undefined
+					fb := execFormula.fallbackOf(v)
+					if !is_undefined(fb) { _assertValidScratchRequest(fb, ctx + " scratchFreeSpace fallback"); scratchFormulaFallback = fb }
+					scratchFreeSpace = undefined
+				} else {
+					_assertValidScratchRequest(v, ctx + " scratchFreeSpace")
+					scratchFreeSpace = v
+					scratchFormulaAst = undefined
+					scratchFormulaFallback = undefined
+				}
+			}
 			setVram := func(v, ctx) {
 				if execFormula.isFormula(v) {
 					gpuFormulaAst = execFormula.astOf(v)
@@ -610,8 +654,8 @@ builder := func() {
 			assertKeys := func(block, name, allowVram) {
 				ll.assert(ll.isMap(block), "exec.builder.resources.%s: expected a map", name)
 				for k, _ in block {
-					ok := k == "cpu" || k == "ram" || (allowVram && k == "vram")
-					ll.assert(ok, "exec.builder.resources.%s: unknown key %q (allowed: %s)", name, k, allowVram ? "cpu, ram, vram" : "cpu, ram")
+					ok := k == "cpu" || k == "ram" || k == "scratchFreeSpace" || (allowVram && k == "vram")
+					ll.assert(ok, "exec.builder.resources.%s: unknown key %q (allowed: %s)", name, k, allowVram ? "cpu, ram, vram, scratchFreeSpace" : "cpu, ram, scratchFreeSpace")
 				}
 				ll.assert(!is_undefined(block.cpu) && !is_undefined(block.ram),
 					"exec.builder.resources.%s: cpu and ram are required", name)
@@ -636,15 +680,30 @@ builder := func() {
 					"exec.builder.resources: onGPU was set without onCPU (GPU required), but this backend has no GPU support (exec.hasGpu is false). Add an onCPU block for an adaptive CPU fallback, or run on a GPU-enabled backend.")
 			}
 
+
+
+
+			setScratchFrom := func(block, ctx) {
+				if is_undefined(block.scratchFreeSpace) {
+					scratchFreeSpace = undefined
+					scratchFormulaAst = undefined
+					scratchFormulaFallback = undefined
+					return
+				}
+				setScratch(block.scratchFreeSpace, ctx)
+			}
+
 			if useGPU {
 				g := spec.onGPU
 				setCpu(g.cpu, "resources.onGPU")
 				setRam(g.ram, "resources.onGPU")
 				setVram(g.vram, "resources.onGPU")
+				setScratchFrom(g, "resources.onGPU")
 			} else {
 				c := spec.onCPU
 				setCpu(c.cpu, "resources.onCPU")
 				setRam(c.ram, "resources.onCPU")
+				setScratchFrom(c, "resources.onCPU")
 
 
 				gpuMemory = undefined
@@ -1333,10 +1392,12 @@ builder := func() {
 
 
 
-			hasFormula := !is_undefined(memFormulaAst) || !is_undefined(cpuFormulaAst) || !is_undefined(gpuFormulaAst)
+			hasFormula := !is_undefined(memFormulaAst) || !is_undefined(cpuFormulaAst) ||
+				!is_undefined(gpuFormulaAst) || !is_undefined(scratchFormulaAst)
 			resolvedMem := undefined
 			resolvedCpu := undefined
 			resolvedGpu := undefined
+			resolvedScratch := undefined
 			lineCountMapResource := undefined
 
 			if hasFormula {
@@ -1358,14 +1419,20 @@ builder := func() {
 					fb := execFormula.applyFormulaFallback({
 						ram: { ast: memFormulaAst, fallback: memFormulaFallback, static: ramRequest },
 						cpu: { ast: cpuFormulaAst, fallback: cpuFormulaFallback, static: cpuRequest },
-						gpu: { ast: gpuFormulaAst, fallback: gpuFormulaFallback, static: gpuMemory }
+						gpu: { ast: gpuFormulaAst, fallback: gpuFormulaFallback, static: gpuMemory },
+						scratch: { ast: scratchFormulaAst, fallback: scratchFormulaFallback, static: scratchFreeSpace }
 					})
 					ll.assert(is_undefined(fb.err), fb.err)
 					ramRequest = fb.ram
 					cpuRequest = fb.cpu
 					gpuMemory = fb.gpu
+
+
+
+					scratchFreeSpace = fb.scratch
 					if is_int(ramRequest) { ramRequest = string(ramRequest) + "b" }
 					if is_int(gpuMemory) { gpuMemory = string(gpuMemory) + "b" }
+					if is_int(scratchFreeSpace) { scratchFreeSpace = string(scratchFreeSpace) + "b" }
 				} else {
 					tagMap := {}
 					for fileName, tag in fileTags {
@@ -1390,6 +1457,11 @@ builder := func() {
 						refs := execFormula.referencedMetricFiles(resolvedGpu)
 						if !is_undefined(refs.lineCount) { sets.add(neededLineCount, refs.lineCount...) }
 					}
+					if !is_undefined(scratchFormulaAst) {
+						resolvedScratch = execFormula.resolveAst(scratchFormulaAst, tagMap, allFiles)
+						refs := execFormula.referencedMetricFiles(resolvedScratch)
+						if !is_undefined(refs.lineCount) { sets.add(neededLineCount, refs.lineCount...) }
+					}
 
 					if len(neededLineCount) > 0 {
 						perFile := {}
@@ -1419,6 +1491,9 @@ builder := func() {
 
 				if !is_undefined(gpuMemory) { quotaData.gpuMemory = gpuMemory }
 			}
+
+
+			if !is_undefined(scratchFreeSpace) { quotaData.scratchFreeSpace = scratchFreeSpace }
 			metaExecInputs := {
 				quota: smart.createJsonResource(quotaData)
 			}
@@ -1442,6 +1517,7 @@ builder := func() {
 			if !is_undefined(resolvedMem) { metaExecInputs[execConstants.META_INPUT_MEM_FORMULA] = smart.createJsonResource(resolvedMem) }
 			if !is_undefined(resolvedCpu) { metaExecInputs[execConstants.META_INPUT_CPU_FORMULA] = smart.createJsonResource(resolvedCpu) }
 			if !is_undefined(resolvedGpu) { metaExecInputs[execConstants.META_INPUT_GPU_FORMULA] = smart.createJsonResource(resolvedGpu) }
+			if !is_undefined(resolvedScratch) { metaExecInputs[execConstants.META_INPUT_SCRATCH_FORMULA] = smart.createJsonResource(resolvedScratch) }
 			if !is_undefined(lineCountMapResource) { pureExecInputs[execConstants.REGULAR_INPUT_LINE_COUNT] = lineCountMapResource }
 
 

package/dist/tengo/lib/exec.limits.lib.tengo

@@ -56,6 +56,7 @@ quotaBuilder := func() {
 	cpu_request := undefined
 	ram_request := undefined
 	gpu_request := undefined
+	scratch_request := undefined
 
 	self = ll.toStrict({
 
@@ -127,6 +128,30 @@ quotaBuilder := func() {
 
 
 
+
+
+
+
+
+
+
+		scratchFreeSpace: func(amount) {
+			validation.assertType(
+				amount,
+				["or", "number", "string", "null"],
+				"exec.quota.builder.scratchFreeSpace: scratch space amount should be a number or string")
+			ll.assert(is_undefined(amount) || is_string(amount) || amount > 0,
+				"exec.quota.builder.scratchFreeSpace: amount in bytes should be greater than 0")
+			scratch_request = amount
+
+			return self
+		},
+
+
+
+
+
+
 		build: func() {
 			ll.assert(queue_name != "", "exec.quota.builder: queue name is mandatory and could not be empty string")
 
@@ -142,6 +167,9 @@ quotaBuilder := func() {
 			if !is_undefined(gpu_request) {
 				data.gpuMemory = gpu_request
 			}
+			if !is_undefined(scratch_request) {
+				data.scratchFreeSpace = scratch_request
+			}
 
 			return smart.ephemeralBuilder(_RTYPE_QUOTA, json.encode(data)).lockAndBuild()
 		}

package/dist/tengo/lib/feats.lib.tengo

@@ -82,5 +82,10 @@ export ll.toStrict({
 
 
 
+	hasScratchSpace:          _isEnabled("scratchSpace"),
+
+
+
+
 	multiStepProgress:        _isEnabled("multiStepProgress")
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "6.8.3",
+  "version": "6.9.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -19,11 +19,11 @@
     "@milaboratories/pframes-rs-wasip2": "1.1.56",
     "@milaboratories/software-pframes-conv": "2.2.9",
     "@platforma-open/milaboratories.software-small-binaries": "^2.1.1",
-    "@platforma-open/milaboratories.software-ptabler": "2.1.8",
-    "@platforma-open/milaboratories.software-ptexter": "1.2.4"
+    "@platforma-open/milaboratories.software-ptexter": "1.2.4",
+    "@platforma-open/milaboratories.software-ptabler": "2.1.8"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "4.0.23"
+    "@platforma-sdk/tengo-builder": "4.0.25"
   },
   "scripts": {
     "type-check": "pl-tengo check",