@platforma-sdk/workflow-tengo 2.5.0 → 2.7.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };
-declare type TplName = "pframes.aggregate" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.map-pframe" | "workdir.save" | "workflow.build-ctx" | "exec.python.install-deps" | "pframes.export-multiple-pcolumns" | "pframes.export-pframe" | "exec.python.create-venv" | "exec.exec" | "pframes.xsv-export-pframe" | "pframes.xsv-import-map";
+declare type TplName = "pframes.aggregate" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.map-pframe" | "workdir.save" | "workflow.build-ctx" | "exec.R.create-renv" | "exec.python.install-deps" | "pframes.export-multiple-pcolumns" | "pframes.export-pframe" | "exec.python.create-venv" | "exec.exec" | "pframes.xsv-export-pframe" | "pframes.xsv-import-map";
 declare const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -5,6 +5,7 @@ module.exports = { Templates: {
   'pframes.map-pframe': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.map-pframe.plj.gz') },
   'workdir.save': { type: 'from-file', path: require.resolve('./tengo/tpl/workdir.save.plj.gz') },
   'workflow.build-ctx': { type: 'from-file', path: require.resolve('./tengo/tpl/workflow.build-ctx.plj.gz') },
+  'exec.R.create-renv': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.R.create-renv.plj.gz') },
   'exec.python.install-deps': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.python.install-deps.plj.gz') },
   'pframes.export-multiple-pcolumns': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-multiple-pcolumns.plj.gz') },
   'pframes.export-pframe': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-pframe.plj.gz') },

package/dist/index.mjs

@@ -6,6 +6,7 @@ export const Templates = {
   'pframes.map-pframe': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.map-pframe.plj.gz') },
   'workdir.save': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/workdir.save.plj.gz') },
   'workflow.build-ctx': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/workflow.build-ctx.plj.gz') },
+  'exec.R.create-renv': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.R.create-renv.plj.gz') },
   'exec.python.install-deps': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.python.install-deps.plj.gz') },
   'pframes.export-multiple-pcolumns': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-multiple-pcolumns.plj.gz') },
   'pframes.export-pframe': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-pframe.plj.gz') },

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

@@ -0,0 +1,29 @@
+ll := import("@platforma-sdk/workflow-tengo:ll")
+validation := import("@platforma-sdk/workflow-tengo:validation")
+runcmd := import("@platforma-sdk/workflow-tengo:exec.runcmd")
+pkg := import("@platforma-sdk/workflow-tengo:exec.package")
+path := import("@platforma-sdk/workflow-tengo:path")
+
+rVenvInputSchema := {
+	operationMode: "string",
+	toolset: "string",
+	dependencies: {"any": "string"},
+	software: validation.reference,
+
+	rDescriptor: pkg.runEnvDescriptorScheme,
+	R: validation.reference
+}
+
+runRBuilder := func(wd, rPackage, rDescriptor) {
+	return runcmd.builder(wd).
+		ref("r-run-environment", rPackage).
+		substitutionRule("{R}", "r-run-environment").
+		addToPath(path.join("{R}", rDescriptor.binDir), true).
+		envVar("R_HOME_DIR", "{R}").
+		envVar("RENV_PATHS_ROOT", path.join("{R}", "renv-root"))
+}
+
+export ll.toStrict({
+	rVenvInputSchema                   : rVenvInputSchema,
+	runRBuilder                        : runRBuilder
+})

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

@@ -0,0 +1,186 @@
+times := import("times")
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+oop := import("@platforma-sdk/workflow-tengo:oop")
+validation := import("@platforma-sdk/workflow-tengo:validation")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+render := import("@platforma-sdk/workflow-tengo:render")
+pkg := import("@platforma-sdk/workflow-tengo:exec.package")
+internal := import("@platforma-sdk/workflow-tengo:exec.R.internal")
+runenv := import("@platforma-sdk/workflow-tengo:exec.runenv")
+
+_OUTPUT_RUN_ENV       := "runEnv"
+
+rVenvBuilder := func() {
+	self := undefined
+
+	opMode := "remote"
+	toolset := "renv"
+	rDescriptor := undefined
+	softwareRef := undefined
+	dependencies := undefined
+	cache := 0
+
+	self = {
+		operationMode: func(mode) {
+			validation.assertJsonSchema(mode, "string",
+				"exec.R.operationMode: <mode> must be string")
+
+			ll.assert(mode == "remote" || mode == "dev-local",
+				"exec.R.operationMode: unsupported operation mode: 'remote', 'dev-local' are valid in this version of workflow-tengo SDK")
+
+			opMode = mode
+			return self
+		},
+
+		useToolset: func(name) {
+			validation.assertJsonSchema(name, "string",
+				"exec.R.useToolset: <name> must be valid name of R packaging toolset (i.e. 'renv')")
+			ll.assert(name != "", "exec.R.useToolset: toolset name must not be empty")
+
+			toolset = name
+			return self
+		},
+
+		runEnvDescriptor: func(descriptor) {
+			validation.assertJsonSchema(descriptor, pkg.runEnvDescriptorScheme, "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)
+
+			rDescriptor = ll.fromStrict(descriptor)
+			return self
+		},
+
+		software: func(pkgRef) {
+			validation.assertJsonSchema(pkgRef, validation.reference, "exec.R.software: <pkgRef> must be a reference to software package")
+
+			softwareRef = pkgRef
+			return self
+		},
+
+		dependencies: func(deps) {
+			validation.assertJsonSchema(deps, { "any": "string" }, "exec.R.dependencies: <deps> must be map of reference file paths")
+
+			dependencies = deps
+			return self
+		},
+
+		/**
+		 * Sets the cache time in milliseconds.
+		 *
+		 * @param millis: number
+		 */
+		cacheMillis: func(millis) {
+			ll.assert(is_int(millis) && millis > 0, "exec.R.cacheMillis: cache time must be a number of milliseconds")
+			cache = millis * times.millisecond
+			return self
+		},
+
+		/**
+		 * Sets the cache time in seconds.
+		 *
+		 * @param seconds: number
+		 */
+		cacheSeconds: func(seconds) {
+			ll.assert(is_int(seconds) && seconds > 0, "exec.R.cacheSeconds: cache time must be a number of seconds")
+			cache = seconds * times.second
+			return self
+		},
+
+		/**
+		 * Sets the cache time in minutes.
+		 *
+		 * @param minutes: number
+		 */
+		cacheMinutes: func(minutes) {
+			ll.assert(is_int(minutes) && minutes > 0, "exec.R.cacheMinutes: cache time must be a number of minutes")
+			cache = minutes * times.minute
+			return self
+		},
+
+		/**
+		 * Sets the cache time in hours.
+		 *
+		 * @param hours: number
+		 */
+		cacheHours: func(hours) {
+			ll.assert(is_int(hours) && hours > 0, "exec.R.cacheHours: cache time must be a number of hours")
+			cache = hours * times.hour
+			return self
+		},
+
+		/**
+		 * Sets the cache time in days
+		 *
+		 * @param days: number
+		 */
+		cacheDays: func(days) {
+			ll.assert(is_int(days) && days > 0, "exec.R.cacheDays: cache time must be a number of days")
+			cache = days * times.hour * 24
+			return self
+		},
+
+		/**
+		 * @deprecated, use cacheMillis, cacheSeconds, cacheMinutes, cacheHours and cacheDays instead.
+		 * Sets the cache time.
+		 *
+		 * @param time: duration - the cache time from 'times' library.
+		 */
+		cache: func(time) {
+			ll.assert(
+				is_int(time) && time > times.millisecond,
+				"exec.R.cache: cache time must be an integer. " +
+					"Did you forget to import a standard tengo library 'times'?")
+			cache = time
+			return self
+		},
+
+		build: func() {
+			archive := pkg.get(rDescriptor.registry, rDescriptor.package).archive()
+			rPkg := pkg.install(archive).package()
+
+			rVenvInputs := {
+				operationMode: opMode,
+				toolset: toolset,
+				dependencies: dependencies,
+				software: softwareRef,
+				rDescriptor: rDescriptor,
+				R: rPkg
+			}
+
+			validation.assertJsonSchema(rVenvInputs, internal.rVenvInputSchema, "incomplete R runenv configuration")
+
+			tpl := render.create(assets.importTemplate("@platforma-sdk/workflow-tengo:exec.R.create-renv"), rVenvInputs)
+
+			self := undefined
+			self = ll.toStrict(oop.inherit(tpl, {
+				/**
+				 * R virtual environment with all dependencies installed.
+				 *
+				 * @return renv: smart.field - a reference to the R portable run environment.
+				 */
+				venv: func() {
+					return tpl.output(_OUTPUT_RUN_ENV, cache)
+				},
+
+				/**
+				 * R runtime used for R virtual environment creation.
+				 *
+				 * @return R: smart.Field - a reference to the R runtime.
+				 */
+				R: func() {
+					return rPkg
+				}
+			}))
+
+			return self
+		}
+	}
+
+	return self
+}
+
+
+export ll.toStrict({
+	rVenvBuilder                        : rVenvBuilder
+})

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

@@ -13,12 +13,16 @@ oop := import("@platforma-sdk/workflow-tengo:oop")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 path := import("@platforma-sdk/workflow-tengo:path")
 pkg := import("@platforma-sdk/workflow-tengo:exec.package")
-runenv := import("@platforma-sdk/workflow-tengo:exec.runenv")
+runcmd := import("@platforma-sdk/workflow-tengo:exec.runcmd")
+python := import("@platforma-sdk/workflow-tengo:exec.python")
+R := import("@platforma-sdk/workflow-tengo:exec.R")
 
 // Variables, substituted in command arguments and environment variable values
 _ARG_VAR_PKG            := "{pkg}"  // abs path to software package
 _ARG_VAR_JAVA           := "{java}" // abs path to 'java' run environment
 _ARG_VAR_PYTHON         := "{python}" // abs path to 'python' run environment
+_ARG_VAR_R              := "{R}" // abs path to 'R' run environment runtime
+_ARG_VAR_R_VENV         := "{rVenv}" // abs path to 'R' portable virtual environment
 
 /**
  * Create new argument marking it as 'with' or 'without' variables inside.
@@ -67,19 +71,21 @@ _directCallOptions := func(runOptions) {
 	})
 }
 
-_loadJavaRunEnvironment := func(descriptor) {
+_loadJavaRunEnvironment := func(operationMode, descriptor) {
 	javaPkg := _installSoftware(descriptor.runEnv.registry, descriptor.runEnv.package)
 	javaRefVar := _newRefVar(_ARG_VAR_JAVA, descriptor.runEnv.name, javaPkg)
 
 	return ll.toStrict({
+		runEnvType: "java",
+
 		variables: [ javaRefVar ],
 		customPaths: [ _newArg(true, path.join(_ARG_VAR_JAVA, descriptor.runEnv.binDir)) ],
 		envs: {}
 	})
 }
 
-_loadPythonRunEnvironment := func(descriptor, softName, softPkg) {
-	venvBuilder := runenv.pythonVenv().
+_loadPythonRunEnvironment := func(operationMode, descriptor, softName, softPkg) {
+	venvBuilder := python.venvBuilder().
 		software(softPkg).
 		runEnvDescriptor(descriptor.runEnv).
 		dependencies(descriptor.dependencies)
@@ -99,6 +105,8 @@ _loadPythonRunEnvironment := func(descriptor, softName, softPkg) {
 	pythonRefVar := _newRefVar(_ARG_VAR_PYTHON, venvRefKey, venv)
 
 	return ll.toStrict({
+		runEnvType: "python",
+
 		variables: [ pythonRefVar ],
 		customPaths: [ _newArg(true, path.join(venvRoot, "bin")) ],
 		envs: {
@@ -107,27 +115,78 @@ _loadPythonRunEnvironment := func(descriptor, softName, softPkg) {
 	})
 }
 
-_loadRunEnvironment := func(descriptor, softName, softPackage) {
+_loadRRunEnvironment := func(operationMode, descriptor, softName, softPkg) {
+	renvBuilder := R.rVenvBuilder().
+		operationMode(operationMode).
+		software(softPkg).
+		runEnvDescriptor(descriptor.runEnv).
+		dependencies(descriptor.dependencies)
+
+	if !is_undefined(descriptor.toolset) && descriptor.toolset != "" {
+		renvBuilder.useToolset(descriptor.toolset)
+	}
+
+	rRuntime := renvBuilder.
+		cacheDays(7).
+		build()
+
+	rEnv := rRuntime.venv()
+	rPackage := rRuntime.R()
+
+	rBinDir := path.join(_ARG_VAR_R, descriptor.runEnv.binDir)
+
+	rRefKey := softName + "/R-runtime"
+	rRefVar := _newRefVar(_ARG_VAR_R, rRefKey, rPackage)
+
+	rEnvRefKey := softName + "/R-virtual-env"
+	rEnvRefVar := _newRefVar(_ARG_VAR_R_VENV, rEnvRefKey, rEnv)
+
+	return ll.toStrict({
+		runEnvType: "R",
+
+		variables: [ rRefVar, rEnvRefVar ],
+		customPaths: [ _newArg(true, rBinDir) ],
+		envs: {
+			"R_HOME_DIR": _newArg(true, _ARG_VAR_R),
+			"RENV_PATHS_ROOT": _newArg(true, path.join(_ARG_VAR_R, "renv-root")),
+			"RENV_PATHS_RENV": _newArg(true, path.join(_ARG_VAR_R_VENV, "renv")),
+			"RENV_PATHS_LOCKFILE": _newArg(true, path.join(_ARG_VAR_PKG, descriptor.dependencies.lockFile)),
+			"RENV_CONFIG_AUTO_SNAPSHOT": _newArg(false, "FALSE"),
+			"RENV_CONFIG_SYNCHRONIZED_CHECK": _newArg(false, "FALSE")
+		}
+	})
+}
+
+
+_loadRunEnvironment := func(operationMode, descriptor, softName, softPackage) {
 	if descriptor.runEnv.type == "java" {
-		return _loadJavaRunEnvironment(descriptor)
+		return _loadJavaRunEnvironment(operationMode, descriptor)
 	}
 	if descriptor.runEnv.type == "python" {
-		return _loadPythonRunEnvironment(descriptor, softName, softPackage)
+		return _loadPythonRunEnvironment(operationMode, descriptor, softName, softPackage)
+	}
+	if descriptor.runEnv.type == "R" {
+		return _loadRRunEnvironment(operationMode, descriptor, softName, softPackage)
 	}
 
 	ll.panic("run environment type %q is not currently supported by workflow-sdk",	descriptor.runEnv.type)
 }
 
-_binPackageCallOptions := func(runOptions, variables, descriptor, softPackage) {
+/**
+ * @param operationMode: 'remote' | 'dev-local'
+ */
+_binPackageCallOptions := func(operationMode, runOptions, variables, descriptor, softPackage) {
 	customPaths := []
 	envs := ll.toStrict({})
 	args := []
+	runEnvType := "binary"
 
 	// Real command should be:
 	//   [<runEnv bin>] [<runEnv options>] [<entrypoint bin>] [<entrypoint options>] <cmd> <args>
 	if (maps.containsKey(descriptor, "runEnv")) {
-		runEnvInfo := _loadRunEnvironment(descriptor, runOptions.software.name, softPackage)
+		runEnvInfo := _loadRunEnvironment(operationMode, descriptor, runOptions.software.name, softPackage)
 
+		runEnvType = runEnvInfo.runEnvType
 		if len(runEnvInfo.variables) > 0 {
 			variables = append(variables, runEnvInfo.variables...)
 		}
@@ -157,6 +216,7 @@ _binPackageCallOptions := func(runOptions, variables, descriptor, softPackage) {
 	}
 
 	return oop.inherit(runOptions, {
+		runEnvType: runEnvType,
 		variables: variables,
 		customPaths: customPaths,
 		cmd: cmd,
@@ -182,7 +242,7 @@ _devLocalPackageCallOptions := func(runOptions) {
 
 	variables := [ _newRefVar(_ARG_VAR_PKG, software.name, softPackage) ]
 
-	return _binPackageCallOptions(runOptions, variables, localDescriptor, softPackage)
+	return _binPackageCallOptions("dev-local", runOptions, variables, localDescriptor, softPackage)
 }
 
 _remotePackageCallOptions := func(runOptions) {
@@ -192,7 +252,7 @@ _remotePackageCallOptions := func(runOptions) {
 
 	variables := [ _newRefVar(_ARG_VAR_PKG, software.name, softPackage) ]
 
-	return _binPackageCallOptions(runOptions, variables, binaryDescriptor, softPackage)
+	return _binPackageCallOptions("remote", runOptions, variables, binaryDescriptor, softPackage)
 }
 
 binaryRunOptions := func(runOptions) {
@@ -217,6 +277,58 @@ binaryRunOptions := func(runOptions) {
 	ll.panic("Unable to run software %s v%s: 'binary' execution mode is not enabled in software descriptor", software.name, software.version)
 }
 
+prepareCommandRun := func(wd, opts) {
+	runBuilder := runcmd.builder(wd)
+
+	// Make installed packages to be available for the command run
+	for varInfo in opts.variables {
+		runBuilder.ref(varInfo.refName, varInfo.reference)
+		runBuilder.substitutionRule(varInfo.varName, varInfo.refName)
+	}
+
+	// Patch command's PATH env variable
+	for p in opts.customPaths {
+		runBuilder.addToPath(p.value, p.hasVars)
+	}
+
+	// Configure environment variables required for correct command run environment setup
+	for name, value in opts.envs {
+		if value.hasVars {
+			runBuilder.envVar(name, value.value)
+		} else {
+			runBuilder.env(name, value.value)
+		}
+	}
+
+	return runBuilder
+}
+
+_activateRenv := func(wd, opts) {
+	activateRenv := prepareCommandRun(wd, opts)
+	activateRenv.
+		cmd("R").
+		arg("-e").arg("renv::activate()")
+
+	activateRenvRun := activateRenv.build()
+
+	return activateRenvRun
+}
+
+prepareWDForRunEnvironment := func(wd, opts) {
+	if (!maps.containsKey(opts, "runEnvType")) {
+		return wd
+	}
+
+	if (opts.runEnvType == "R") {
+		return _activateRenv(wd, opts).workdir
+	}
+
+	return wd
+}
+
 export {
-	binaryRunOptions              : binaryRunOptions
+	binaryRunOptions			: binaryRunOptions,
+
+	prepareWDForRunEnvironment	: prepareWDForRunEnvironment,
+	prepareCommandRun			: prepareCommandRun
 }

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

@@ -0,0 +1,16 @@
+ll := import("@platforma-sdk/workflow-tengo:ll")
+validation := import("@platforma-sdk/workflow-tengo:validation")
+pkg := import("@platforma-sdk/workflow-tengo:exec.package")
+
+pythonVenvInputSchema := {
+	toolset: "string",
+	dependencies: {"any": validation.reference},
+	// software: validation.reference,
+
+	pythonDescriptor: pkg.runEnvDescriptorScheme,
+	python: validation.reference
+}
+
+export ll.toStrict({
+	pythonVenvInputSchema                       : pythonVenvInputSchema
+})

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

@@ -0,0 +1,165 @@
+times := import("times")
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+oop := import("@platforma-sdk/workflow-tengo:oop")
+validation := import("@platforma-sdk/workflow-tengo:validation")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+render := import("@platforma-sdk/workflow-tengo:render")
+pkg := import("@platforma-sdk/workflow-tengo:exec.package")
+internal := import("@platforma-sdk/workflow-tengo:exec.python.internal")
+runenv := import("@platforma-sdk/workflow-tengo:exec.runenv")
+
+_OUTPUT_RUN_ENV       := "runEnv"
+
+pythonVenvBuilder := func() {
+	self := undefined
+
+	toolset := "pip"
+	pythonDescriptor := undefined
+	softwareRef := undefined
+	dependencies := undefined
+	cache := 0
+
+	self = {
+		useToolset: func(name) {
+			validation.assertJsonSchema(name, "string",
+				"exec.python.useToolset: <name> must be valid name of python packaging toolset (pip, pipenv and so on)")
+			ll.assert(name != "", "exec.python.useToolset: toolset name must not be empty")
+
+			toolset = name
+			return self
+		},
+
+		runEnvDescriptor: func(descriptor) {
+			validation.assertJsonSchema(descriptor, pkg.runEnvDescriptorScheme, "exec.python.runEnvDescriptor: <descriptor> must be run environment specification")
+			ll.assert(descriptor.type == "python", "exec.python.runEnvDescriptor: not a 'python' run environment: %q", descriptor.type)
+
+			pythonDescriptor = ll.fromStrict(descriptor)
+			return self
+		},
+
+		software: func(pkgRef) {
+			validation.assertJsonSchema(pkgRef, validation.reference, "exec.python.software: <pkgRef> must be a reference to software package")
+
+			softwareRef = pkgRef
+			return self
+		},
+
+		dependencies: func(deps) {
+			validation.assertJsonSchema(deps, { "any": "string" }, "exec.python.dependencies: <deps> must be map of reference file paths")
+
+			dependencies = deps
+			return self
+		},
+
+		/**
+		 * Sets the cache time in milliseconds.
+		 *
+		 * @param millis: number
+		 */
+		cacheMillis: func(millis) {
+			ll.assert(is_int(millis) && millis > 0, "exec.python.cacheMillis: cache time must be a number of milliseconds")
+			cache = millis * times.millisecond
+			return self
+		},
+
+		/**
+		 * Sets the cache time in seconds.
+		 *
+		 * @param seconds: number
+		 */
+		cacheSeconds: func(seconds) {
+			ll.assert(is_int(seconds) && seconds > 0, "exec.python.cacheSeconds: cache time must be a number of seconds")
+			cache = seconds * times.second
+			return self
+		},
+
+		/**
+		 * Sets the cache time in minutes.
+		 *
+		 * @param minutes: number
+		 */
+		cacheMinutes: func(minutes) {
+			ll.assert(is_int(minutes) && minutes > 0, "exec.python.cacheMinutes: cache time must be a number of minutes")
+			cache = minutes * times.minute
+			return self
+		},
+
+		/**
+		 * Sets the cache time in hours.
+		 *
+		 * @param hours: number
+		 */
+		cacheHours: func(hours) {
+			ll.assert(is_int(hours) && hours > 0, "exec.python.cacheHours: cache time must be a number of hours")
+			cache = hours * times.hour
+			return self
+		},
+
+		/**
+		 * Sets the cache time in days
+		 *
+		 * @param days: number
+		 */
+		cacheDays: func(days) {
+			ll.assert(is_int(days) && days > 0, "exec.python.cacheDays: cache time must be a number of days")
+			cache = days * times.hour * 24
+			return self
+		},
+
+		/**
+		 * @deprecated, use cacheMillis, cacheSeconds, cacheMinutes, cacheHours and cacheDays instead.
+		 * Sets the cache time.
+		 *
+		 * @param time: duration - the cache time from 'times' library.
+		 */
+		cache: func(time) {
+			ll.assert(
+				is_int(time),
+				"exec.python.cache: cache time must be an integer. " +
+					"Did you forget to import a standard tengo library 'times'?")
+			cache = time
+			return self
+		},
+
+		build: func() {
+			depsMap := runenv.loadDependencyFiles(softwareRef, dependencies)
+
+			archive := pkg.get(pythonDescriptor.registry, pythonDescriptor.package).archive()
+			pythonPkg := pkg.install(archive).package()
+
+			pyVenvInputs := {
+				toolset: toolset,
+				dependencies: depsMap,
+				// software: softwareRef,
+				pythonDescriptor: pythonDescriptor,
+				python: pythonPkg
+			}
+
+			validation.assertJsonSchema(pyVenvInputs, internal.pythonVenvInputSchema, "incomplete python runenv configuration")
+
+			tpl := render.create(assets.importTemplate("@platforma-sdk/workflow-tengo:exec.python.create-venv"), pyVenvInputs)
+
+			self := undefined
+			self = ll.toStrict(oop.inherit(tpl, {
+				/**
+				 * Python virtual environment with all dependencies installed.
+				 *
+				 * @return venv: smart.field - a reference to the runenv with python venv inside.
+				 */
+				venv: func() {
+					return tpl.output(_OUTPUT_RUN_ENV, cache)
+				}
+			}))
+
+			return self
+		}
+	}
+
+	return self
+}
+
+export ll.toStrict({
+	venvBuilder                         : pythonVenvBuilder
+})

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

@@ -8,9 +8,6 @@ oop := import("@platforma-sdk/workflow-tengo:oop")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 pkg := import("@platforma-sdk/workflow-tengo:exec.package")
-assets := import("@platforma-sdk/workflow-tengo:assets")
-render := import("@platforma-sdk/workflow-tengo:render")
-times := import("times")
 
 _RTYPE_SAVE_RUN_ENV   := { Name: "SaveRunEnv/executor", Version: "1" }
 _INPUT_SETTINGS       := "settings"
@@ -97,15 +94,6 @@ saveBuilder := func(wd) {
 	return self
 }
 
-pythonVenvInputSchema := {
-	toolset: "string",
-	dependencies: {"string": validation.reference},
-	// software: validation.reference,
-
-	pythonDescriptor: pkg.runEnvDescriptorScheme,
-	python: validation.reference
-}
-
 loadDependencyFiles := func(packageRef, dependencies) {
 	if len(dependencies) == 0 {
 		return {}
@@ -126,157 +114,7 @@ loadDependencyFiles := func(packageRef, dependencies) {
 	return depsMap
 }
 
-pythonVenv := func() {
-	self := undefined
-
-	toolset := "pip"
-	pythonDescriptor := undefined
-	softwareRef := undefined
-	dependencies := undefined
-	cache := 0
-
-	self = {
-		useToolset: func(name) {
-			validation.assertJsonSchema(name, "string",
-				"runenv.python.useToolset: <name> must be valid name of python packaging toolset (pip, pipenv and so on)")
-			ll.assert(name != "", "runenv.python.useToolset: toolset name must not be empty")
-
-			toolset = name
-			return self
-		},
-
-		runEnvDescriptor: func(descriptor) {
-			validation.assertJsonSchema(descriptor, pkg.runEnvDescriptorScheme, "runenv.python.runEnvDescriptor: <descriptor> must be run environment specification")
-			ll.assert(descriptor.type == "python", "runenv.python.runEnvDescriptor: not a 'python' run environment: %q", descriptor.type)
-
-			pythonDescriptor = ll.fromStrict(descriptor)
-			return self
-		},
-
-		software: func(pkgRef) {
-			validation.assertJsonSchema(pkgRef, validation.reference, "runenv.python.software: <pkgRef> must be a reference to software package")
-
-			softwareRef = pkgRef
-			return self
-		},
-
-		dependencies: func(deps) {
-			validation.assertJsonSchema(deps, { "any": "string" }, "runenv.python.dependencies: <deps> must be map of reference file paths")
-
-			dependencies = deps
-			return self
-		},
-
-		/**
-		 * Sets the cache time in milliseconds.
-		 *
-		 * @param millis: number
-		 */
-		cacheMillis: func(millis) {
-			ll.assert(is_int(millis) && millis > 0, "cache time must be a number of milliseconds")
-			cache = millis * times.millisecond
-			return self
-		},
-
-		/**
-		 * Sets the cache time in seconds.
-		 *
-		 * @param seconds: number
-		 */
-		cacheSeconds: func(seconds) {
-			ll.assert(is_int(seconds) && seconds > 0, "cache time must be a number of seconds")
-			cache = seconds * times.second
-			return self
-		},
-
-		/**
-		 * Sets the cache time in minutes.
-		 *
-		 * @param minutes: number
-		 */
-		cacheMinutes: func(minutes) {
-			ll.assert(is_int(minutes) && minutes > 0, "cache time must be a number of minutes")
-			cache = minutes * times.minute
-			return self
-		},
-
-		/**
-		 * Sets the cache time in hours.
-		 *
-		 * @param hours: number
-		 */
-		cacheHours: func(hours) {
-			ll.assert(is_int(hours) && hours > 0, "cache time must be a number of hours")
-			cache = hours * times.hour
-			return self
-		},
-
-		/**
-		 * Sets the cache time in days
-		 *
-		 * @param days: number
-		 */
-		cacheDays: func(days) {
-			ll.assert(is_int(days) && days > 0, "cache time must be a number of days")
-			cache = days * times.hour * 24
-			return self
-		},
-
-		/**
-		 * @deprecated, use cacheMillis, cacheSeconds, cacheMinutes, cacheHours and cacheDays instead.
-		 * Sets the cache time.
-		 *
-		 * @param time: duration - the cache time from 'times' library.
-		 */
-		cache: func(time) {
-			ll.assert(
-				is_int(time),
-				"cache time must be an integer. " +
-					"Did you forget to import a standard tengo library 'times'?")
-			cache = time
-			return self
-		},
-
-		build: func() {
-			depsMap := loadDependencyFiles(softwareRef, dependencies)
-
-			archive := pkg.get(pythonDescriptor.registry, pythonDescriptor.package).archive()
-			pythonPkg := pkg.install(archive).package()
-
-			pyVenvInputs := {
-				toolset: toolset,
-				dependencies: smart.createMapResource(depsMap),
-				// software: softwareRef,
-				pythonDescriptor: pythonDescriptor,
-				python: pythonPkg
-			}
-
-			validation.assertJsonSchema(pyVenvInputs, pythonVenvInputSchema, "incomplete python runenv configuration")
-
-			tpl := render.create(assets.importTemplate("@platforma-sdk/workflow-tengo:exec.python.create-venv"), pyVenvInputs)
-
-			self := undefined
-			self = ll.toStrict(oop.inherit(tpl, {
-				/**
-				 * Python virtual environment with all dependencies installed.
-				 *
-				 * @return venv: smart.field - a reference to the runenv with python venv inside.
-				 */
-				venv: func() {
-					return tpl.output(_OUTPUT_RUN_ENV, cache)
-				}
-			}))
-
-			return self
-		}
-	}
-
-	return self
-}
-
 export ll.toStrict({
 	saveBuilder                        : saveBuilder,
-
-	pythonVenv                         : pythonVenv,
-	pythonVenvInputSchema              : pythonVenvInputSchema
+	loadDependencyFiles                : loadDependencyFiles
 })

package/dist/tengo/lib/smart.lib.tengo

@@ -705,8 +705,8 @@ field = func(f) {
 		 * @param millis: number
 		 */
 		setCacheMillis: func(millis) {
-			ll.assert(is_int(millis),
-				"smart.field.setCacheMillis: cache time must be a number of milliseconds")
+			ll.assert(is_int(millis) && millis > 0,
+				"smart.field.setCacheMillis: cache time must be a number of milliseconds (> 0)")
 			return self.setCache(millis * times.millisecond)
 		},
 
@@ -716,8 +716,8 @@ field = func(f) {
 		 * @param seconds: number
 		 */
 		setCacheSeconds: func(seconds) {
-			ll.assert(is_int(seconds),
-				"smart.field.setCacheSeconds: cache time must be a number of seconds")
+			ll.assert(is_int(seconds) && seconds > 0,
+				"smart.field.setCacheSeconds: cache time must be a number of seconds (> 0)")
 			return self.setCache(seconds * times.second)
 		},
 
@@ -727,8 +727,8 @@ field = func(f) {
 		 * @param minutes: number
 		 */
 		setCacheMinutes: func(minutes) {
-			ll.assert(is_int(minutes),
-				"smart.field.setCacheMinutes: cache time must be a number of minutes")
+			ll.assert(is_int(minutes) && minutes > 0,
+				"smart.field.setCacheMinutes: cache time must be a number of minutes (> 0)")
 			return self.setCache(minutes * times.minute)
 		},
 
@@ -738,7 +738,7 @@ field = func(f) {
 		 * @param hours: number
 		 */
 		setCacheHours: func(hours) {
-			ll.assert(is_int(hours), "smart.field.setCacheHours: cache time must be a number of hours")
+			ll.assert(is_int(hours) && hours > 0, "smart.field.setCacheHours: cache time must be a number of hours (> 0)")
 			return self.setCache(hours * times.hour)
 		},
 
@@ -748,7 +748,7 @@ field = func(f) {
 		 * @param days: number
 		 */
 		setCacheDays: func(days) {
-			ll.assert(is_int(days), "smart.field.setCacheDays: cache time must be a number of days")
+			ll.assert(is_int(days) && days > 0, "smart.field.setCacheDays: cache time must be a number of days (> 0)")
 			return self.setCache(days * 24 * times.hour)
 		},
 

package/dist/tengo/lib/tpl.lib.tengo

@@ -11,6 +11,8 @@ constants := import("@platforma-sdk/workflow-tengo:constants")
 stateAwait := import("@platforma-sdk/workflow-tengo:tpl.state-await")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 
+bquery := import("@platforma-sdk/workflow-tengo:workflow.bquery")
+
 /**
  * Unmarshal resource according by:
  *  - converting all json resources (potentially nested) into a tengo objects (maps)
@@ -106,7 +108,7 @@ tpl := func() {
 			return smart.resource(_templateId)
 		},
 
-		_unmarshallers: [],
+		_unmarshallers: [bquery.resultUnmarshaller()],
 
 		/**
 		 * Register a preprocessor of input resource. The preprocessor must have two

package/dist/tengo/lib/workflow.bquery.lib.tengo

@@ -49,7 +49,7 @@ create := func(spec, ctx, ...options) {
 		// @TODO validate options
 
 		// override defaults
-		for k, v in options[0]{
+		for k, v in options[0] {
 			ops[k] = v
 		}
 	}
@@ -121,7 +121,7 @@ resultUnmarshaller := func() {
 					return undefined
 				}
 
-				result  := {
+				result := {
 					ref: resource.get("ref").getDataAsJson(),
 					spec: resource.get("spec").getDataAsJson()
 				}

package/dist/tengo/lib/workflow.lib.tengo

@@ -49,8 +49,8 @@ _isStaging := func() {
 	return !_isProduction()
 }
 
-// register standard inputs preprocessors
-self.registerUnmarshaller(bquery.resultUnmarshaller())
+// register standard inputs preprocessors [now added by default for all templates]
+// self.registerUnmarshaller(bquery.resultUnmarshaller())
 
 _args := undefined
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "2.5.0",
+  "version": "2.7.0",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -16,7 +16,7 @@
     "./dist/**/*"
   ],
   "dependencies": {
-    "@milaboratories/software-pframes-conv": "2.1.0",
+    "@milaboratories/software-pframes-conv": "2.1.2",
     "@platforma-open/milaboratories.software-small-binaries": "^1.14.6"
   },
   "devDependencies": {