@platforma-sdk/workflow-tengo 5.5.2 → 5.5.3

package/dist/tengo/lib/exec.R.internal.lib.tengo

@@ -1,12 +1,11 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
-feats := import("@platforma-sdk/workflow-tengo:feats")
 
 validation := import("@platforma-sdk/workflow-tengo:validation")
-runcmd := import("@platforma-sdk/workflow-tengo:exec.runcmd")
 path := import("@platforma-sdk/workflow-tengo:path")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+
+runcmd := import("@platforma-sdk/workflow-tengo:exec.runcmd")
 desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
-constants := import("@platforma-sdk/workflow-tengo:exec.constants")
-pkg := import("@platforma-sdk/workflow-tengo:exec.package")
 
 rVenvInputSchema := {
 	operationMode: "string",
@@ -14,37 +13,107 @@ rVenvInputSchema := {
 	dependencies: {"any": "string"},
 	software: validation.reference,
 
-	rDescriptor: desc.runEnvScheme,
+	rRunEnvDescriptor: desc.runEnvScheme,
 	R: validation.reference
 }
 
-runRBuilder := func(operationMode, wd, rPackage, rDescriptor) {
-	t := feats.commandExpressions ? constants.ARG_TYPE_EXPRESSION : constants.ARG_TYPE_VAR
-	rule := feats.commandExpressions ? "R" : "{R}"
+ARG_VAR_R                   := "R"     // abs path to 'R' run environment runtime
+ARG_VAR_R_VENV              := "rVenv" // abs path to 'R' portable virtual environment, restored on runner side
+
+RENV_ROOT_DIR_NAME          := "renv-root" // directory inside R run environment package, where RENV_PATHS_ROOT is stored.
+
+_expr := func(varName) {
+	return "{" + varName + "}"
+}
+
+
+
+
+
+
+runRPlan := func(refsPrefix, rPkgRef, rRunEnvDescriptor, rVenvRef) {
+	validation.assertType(refsPrefix, "string", "exec.R.runRPlan: <refsPrefix> is expected to be string with prefix for all default references attached to R-based command")
+	validation.assertType(rPkgRef, validation.reference, "exec.R.runRPlan: <rPkgRef> is expected to be reference to R run environment package")
+	validation.assertType(rRunEnvDescriptor, desc.runEnvScheme, "exec.R.runRPlan: <rRunEnvDescriptor> is expected to be run environment descriptor")
+	validation.assert(rRunEnvDescriptor.type == "R", "exec.R.runRPlan: <rRunEnvDescriptor> is expected to be R run environment descriptor")
+	if (!is_undefined(rVenvRef)) {
+		validation.assertType(rVenvRef, validation.reference, "exec.R.runRPlan: <rVenvRef> is expected to be reference to R virtual environment")
+	}
+
+	plan := runcmd.createRunCommandPlan()
 
-	builder := runcmd.builder(wd).
-		inQueue(pkg.DEFAULT_ALLOCATION_QUEUE).
-		cpu(pkg.DEFAULT_ALLOCATION_CPU).
-		mem(pkg.DEFAULT_ALLOCATION_RAM).
-		ref("r-run-environment", rPackage).
-		substitutionRule(rule, "r-run-environment").
-		addPathTyped(t, path.join("{R}", rDescriptor.binDir)).
-		envTyped("RHOME", t, "{R}").
-		envTyped("R_HOME_DIR", t, "{R}").
-		envTyped("RENV_PATHS_ROOT", t, path.join("{R}", "renv-root")).
-		envTyped("RENV_PATHS_BINARY", t, path.join("{R}", "renv-root", "binaries")).
-		envTyped("RENV_PATHS_SOURCE", t, path.join("{R}", "renv-root", "sources")).
-		envTyped("RENV_PATHS_CACHE", t, path.join("{R}", "renv-root", "cache"))
+	rRefKey := refsPrefix + "/R-runtime"
+	rEnvRefKey := refsPrefix + "/R-virtual-env"
 
+	rBinDir := path.join(_expr(ARG_VAR_R), rRunEnvDescriptor.binDir)
+	renvRootArg := path.join(_expr(ARG_VAR_R), RENV_ROOT_DIR_NAME)
 
+	plan.
+		refVar(ARG_VAR_R, rRefKey, rPkgRef).
+		addPathExpression(rBinDir).
+		envExpression("RHOME", _expr(ARG_VAR_R)).      // RScript uses this variable instead of R_HOME_DIR or R_HOME
+		envExpression("R_HOME_DIR", _expr(ARG_VAR_R)). // R starter sh script uses this to correctly set R_HOME and many others
+		envExpression("RENV_PATHS_ROOT", renvRootArg).
+		envExpression("RENV_PATHS_BINARY", path.join(renvRootArg, "binaries")).
+		envExpression("RENV_PATHS_SOURCE", path.join(renvRootArg, "sources")).
+		envExpression("RENV_PATHS_CACHE", path.join(renvRootArg, "cache"))
 
+	if (!is_undefined(rVenvRef)) {
+		plan.
+			refVar(ARG_VAR_R_VENV, rEnvRefKey, rVenvRef).
+			envExpression("RENV_PATHS_RENV", path.join(_expr(ARG_VAR_R_VENV), "r-venv")).
+			envExpression("RENV_PATHS_LOCKFILE", path.join(_expr(ARG_VAR_R_VENV), "renv.lock"))
+	}
 
-	builder.envTyped("RENV_CONFIG_REPOS_OVERRIDE", t, path.join("{R}", "packages"))
 
-	return builder
+
+
+	plan.envExpression("RENV_CONFIG_REPOS_OVERRIDE", path.join("{R}", "packages"))
+
+	return plan
+}
+
+activateRenvInWD := func(wd, queue, computeResources, plan) {
+	validation.assertType(wd, validation.reference, "exec.R.activateRenvInWD: <wd> must be a reference to workdir")
+	validation.assertType(queue, "string", "exec.R.activateRenvInWD: <queue> must be a string")
+	validation.assertType(computeResources,
+		["or",
+			validation.reference,
+			{ "cpu": "number", "ram": ["or", "number", "string"] }
+			],
+		"exec.R.activateRenvInWD: <computeResources> must be a reference to allocation, or a map with cpu and ram"
+	)
+	validation.assertType(plan, runcmd.RUN_CMD_PLAN_STATE_OR_OBJECT_SCHEMA, "exec.R.activateRenvInWD: <plan> must be a run command plan or state")
+
+	activateRenv := runcmd.builder(wd, plan).
+		cmd("R").
+		inQueue(queue).
+		resetArgs().
+		arg("--no-echo").
+		arg("--no-restore").
+		arg("-e").arg("renv::activate()")
+
+	if (smart.isReference(computeResources)) {
+		activateRenv.allocation(computeResources)
+	} else {
+		activateRenv.
+			cpu(computeResources.cpu).
+			mem(computeResources.ram)
+	}
+
+	return activateRenv.build().workdir
 }
 
 export ll.toStrict({
+
+	ARG_VAR_R                          : ARG_VAR_R,
+	ARG_VAR_R_VENV                     : ARG_VAR_R_VENV,
+	RENV_ROOT_DIR_NAME                 : RENV_ROOT_DIR_NAME,
+
+
 	rVenvInputSchema                   : rVenvInputSchema,
-	runRBuilder                        : runRBuilder
+
+
+	runRPlan                           : runRPlan,
+	activateRenvInWD                   : activateRenvInWD
 })

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

@@ -19,7 +19,7 @@ rVenvBuilder := func() {
 
 	opMode := "remote"
 	toolset := "renv"
-	rDescriptor := undefined
+	rRunEnvDescriptor := undefined
 	softwareRef := undefined
 	dependencies := undefined
 	cache := 0
@@ -47,9 +47,9 @@ rVenvBuilder := func() {
 
 		runEnvDescriptor: func(descriptor) {
 			validation.assertType(descriptor, desc.runEnvScheme, "exec.R.runEnvDescriptor: <descriptor> must be run environment specification")
-			ll.assert(descriptor.type == "R", "exec.R.runEnvDescriptor: not a 'R' run environment: %q", descriptor.type)
+			ll.assert(descriptor.type == "R", "exec.R.runEnvDescriptor: incorrect run environment type. Expected 'R', got %q", descriptor.type)
 
-			rDescriptor = ll.fromStrict(descriptor)
+			rRunEnvDescriptor = ll.fromStrict(descriptor)
 			return self
 		},
 
@@ -138,20 +138,19 @@ rVenvBuilder := func() {
 		},
 
 		build: func() {
-			archive := pkg.get(rDescriptor.registry, rDescriptor.package).archive()
-			rPkg := pkg.install(archive).package()
+			archiveRef := pkg.get(rRunEnvDescriptor.registry, rRunEnvDescriptor.package).archive()
+			rPkgRef := pkg.install(archiveRef).package()
 
 			rVenvInputs := {
 				operationMode: opMode,
 				toolset: toolset,
 				dependencies: dependencies,
 				software: softwareRef,
-				rDescriptor: rDescriptor,
-				R: rPkg
+				rRunEnvDescriptor: rRunEnvDescriptor,
+				R: rPkgRef
 			}
 
 			validation.assertType(rVenvInputs, internal.rVenvInputSchema, "incomplete R runenv configuration")
-
 			tpl := render.create(createRenvTpl, rVenvInputs)
 
 			self := undefined
@@ -171,7 +170,8 @@ rVenvBuilder := func() {
 
 
 				R: func() {
-					return rPkg
+
+					return rPkgRef
 				}
 			}))
 
@@ -184,5 +184,7 @@ rVenvBuilder := func() {
 
 
 export ll.toStrict({
-	rVenvBuilder                        : rVenvBuilder
+	rVenvBuilder                        : rVenvBuilder,
+	runRPlan                            : internal.runRPlan,
+	activateRenvInWD                    : internal.activateRenvInWD
 })

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

@@ -44,13 +44,27 @@ RUN_CMD_PLAN_OPTIONS_SCHEMA := {
 	"dockerEntrypoint,?": ["string"]
 }
 
-RUN_CMD_PLAN_SCHEMA := {
+RUN_CMD_PLAN_STATE_SCHEMA := {
 	"refs": RUN_CMD_PLAN_REFS_SCHEMA,
 	"options": RUN_CMD_PLAN_OPTIONS_SCHEMA
 }
 
+_isRunCommandPlanObject := func(obj) {
+	return ll.isStrict(obj) && maps.containsKey(obj, "_type") && obj["_type"] == "runcmd.plan"
+}
+
+_validateIsRunCommandPlanObject := func(obj, keyPath, stack) {
+	if !_isRunCommandPlanObject(obj) {
+		return validation.fail(keyPath, "item %q is not a run command plan object", obj)
+	}
+
+	return validation.success
+}
+
+RUN_CMD_PLAN_STATE_OR_OBJECT_SCHEMA := [ "or", RUN_CMD_PLAN_STATE_SCHEMA, _validateIsRunCommandPlanObject ]
+
 _initStateFromPlan := func(state, initState, context) {
-	validation.assertType(initState, RUN_CMD_PLAN_SCHEMA, "invalid initial state for " + context)
+	validation.assertType(initState, RUN_CMD_PLAN_STATE_SCHEMA, "invalid initial state for " + context)
 
 	initOptions := initState.options
 	state.options.cmd = maps.clone(initOptions.cmd)
@@ -119,6 +133,8 @@ _createAbstractRunCommandPlan := func(state, returnSelfFn) {
 	self := undefined
 
 	self = ll.toStrict({
+		_type: "runcmd.plan",
+
 
 
 
@@ -492,6 +508,9 @@ builder := func(workdir, ...initialState) {
 
 	if len(initialState) == 1 {
 		initState := initialState[0]
+		if (_isRunCommandPlanObject(initState)) {
+			initState = initState.state()
+		}
 		_initStateFromPlan(state, initState, "run command builder")
 	} else {
 		ll.assert(len(initialState) == 0, "builder accepts at most two arguments")
@@ -642,10 +661,13 @@ builder := func(workdir, ...initialState) {
 
 
 
-			ll.assert(is_undefined(allocation) || (is_undefined(cpu) && is_undefined(ram)),
-				"runcmd.builder.build: allocation cannot be set along with cpu or ram")
+			hasAllocation := !is_undefined(allocation)
+			hasCpuRamRequest := !is_undefined(cpu) || !is_undefined(ram)
+
+			ll.assert(!(hasAllocation && hasCpuRamRequest), // none specified is OK: default queue limits would be applied.
+				"runcmd.builder.build: allocation and CPU/RAM request are mutually exclusive for the same command run")
 
-			ll.assert(!is_undefined(queue), "queue must be set")
+			ll.assert(!is_undefined(queue), "runcmd.builder.build: queue is required for any command run")
 
 			useBatch := limits.useBatch(queue)
 
@@ -728,13 +750,17 @@ builder := func(workdir, ...initialState) {
 }
 
 export ll.toStrict({
+
+	ARG_SCHEMA:                             ARG_SCHEMA,
+	RUN_CMD_PLAN_REFS_SCHEMA:               RUN_CMD_PLAN_REFS_SCHEMA,
+	RUN_CMD_PLAN_OPTIONS_SCHEMA:            RUN_CMD_PLAN_OPTIONS_SCHEMA,
+	RUN_CMD_PLAN_STATE_SCHEMA:              RUN_CMD_PLAN_STATE_SCHEMA,
+	RUN_CMD_PLAN_STATE_OR_OBJECT_SCHEMA:    RUN_CMD_PLAN_STATE_OR_OBJECT_SCHEMA,
+
+
 	builder: builder,
 	simpleArg: simpleArg,
 	variableArg: variableArg,
 	expressionArg: expressionArg,
-	createRunCommandPlan: createRunCommandPlan,
-	ARG_SCHEMA: ARG_SCHEMA,
-	RUN_CMD_PLAN_REFS_SCHEMA: RUN_CMD_PLAN_REFS_SCHEMA,
-	RUN_CMD_PLAN_OPTIONS_SCHEMA: RUN_CMD_PLAN_OPTIONS_SCHEMA,
-	RUN_CMD_PLAN_SCHEMA: RUN_CMD_PLAN_SCHEMA
+	createRunCommandPlan: createRunCommandPlan
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "5.5.2",
+  "version": "5.5.3",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",