@platforma-sdk/workflow-tengo 4.8.1 → 4.9.0

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

@@ -18,6 +18,8 @@ validation := import("@platforma-sdk/workflow-tengo:validation")
 
 
 
+
+
 _unmarshal := func(resource, preprocessors) {
 	ll.assert(smart.isResource(resource), "expected resource, found ", resource)
 
@@ -645,6 +647,7 @@ tpl := func(ops) {
 				renderer                : self.renderer,
 				registerUnmarshaller    : self.registerUnmarshaller,
 				rawInputs               : self.rawInputs,
+				rawServiceInputs        : self.rawServiceInputs,
 				hasInput                : self.hasInput,
 				inputs                  : self.inputs,
 				defineOutputs           : self.defineOutputs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "4.8.1",
+  "version": "4.9.0",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",

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

@@ -1,430 +0,0 @@
-
-
-
-
-
-
-
-ll := import("@platforma-sdk/workflow-tengo:ll")
-feats := import("@platforma-sdk/workflow-tengo:feats")
-
-json := import("json")
-times := import("times")
-text := import("text")
-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")
-runcmd := import("@platforma-sdk/workflow-tengo:exec.runcmd")
-python := import("@platforma-sdk/workflow-tengo:exec.python")
-R := import("@platforma-sdk/workflow-tengo:exec.R")
-constants := import("@platforma-sdk/workflow-tengo:exec.constants")
-desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
-validation := import("@platforma-sdk/workflow-tengo:validation")
-
-
-
-
-_ARG_VAR_PKG                 := "pkg"  // abs path to software package
-_ARG_VAR_JAVA                := "java" // abs path to 'java' run environment
-
-_ARG_VAR_PYTHON_VENV         := "python" // abs path to python virtual environment. WARNING: not change the name, it's used in other part of code
-_ARG_VAR_PYTHON_RUN_ENV      := "python_run_env" // abs path to python run environment used to create venv
-_ARG_VAR_VENV_BIN_DIR        := "venv_bin_dir" // name of bin dir in python venv depending on OS type (Scripts on Windows, bin on Unix)
-_ARG_PYTHON_LOCAL_SCRIPT_DIR := "python_local_script_dir" // abs path to directory with local python scripts.
-_ARG_PATH_DELIMETER          := "path_delimeter"
-
-_ARG_VAR_R              := "R" // abs path to 'R' run environment runtime
-_ARG_VAR_R_VENV         := "rVenv" // abs path to 'R' portable virtual environment
-_ARG_VAR_MNZ            := "monetization" // monetization env value
-
-
-
-
-pythonBinDir := undefined
-
-
-_expr := func(varName) {
-	return "{" + varName + "}"
-}
-
-_newTypedArg := func(type, value) {
-	return ll.toStrict({
-		type: type,
-		value: value
-	})
-}
-
-
-
-
-
-
-
-
-_newArg := func(isString, value) {
-	if isString {
-		return _newTypedArg(constants.ARG_TYPE_STRING, value)
-	}
-	if feats.commandExpressions {
-		return _newTypedArg(constants.ARG_TYPE_EXPRESSION, value)
-	}
-	return _newTypedArg(constants.ARG_TYPE_VAR, value)
-}
-
-_newRefVar := func(varName, refName, reference) {
-
-	if !feats.commandExpressions {
-		return ll.toStrict({
-			varName: "{" + varName + "}",
-			refName: refName,
-			reference: reference
-		})
-	}
-
-	return ll.toStrict({
-		varName: varName,
-		refName: refName,
-		reference: reference
-	})
-}
-
-_installSoftware := func(registry, pkgName) {
-	ll.assert(is_string(registry), "exec.internal._installSoftware(): registry is not a string, got: %v", registry, pkgName)
-	ll.assert(is_string(pkgName), "exec.internal._installSoftware(): pkgName is not a string, got: %v", pkgName, registry)
-
-	archive := pkg.get(registry, pkgName).archive()
-	return pkg.install(archive).package()
-}
-
-_directCallOptions := func(runOptions) {
-	return ll.toStrict({
-		variables: [],
-		customPaths: [],
-		cmd: _newArg(true, runOptions.cmd),
-		args: [],
-		envs: {}
-	})
-}
-
-_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(false, path.join(_expr(_ARG_VAR_JAVA), descriptor.runEnv.binDir)) ],
-		envs: {}
-	})
-}
-
-_loadPythonRunEnvironment := func(operationMode, descriptor, softName, softPkg) {
-	venvBuilder := python.venvBuilder().
-		software(softPkg).
-		runEnvDescriptor(descriptor.runEnv).
-		dependencies(descriptor.dependencies)
-
-	if !is_undefined(descriptor.toolset) && descriptor.toolset != "" {
-		venvBuilder.useToolset(descriptor.toolset)
-	}
-
-	venv := venvBuilder.
-		cacheDays(7).
-		build()
-
-	pythonRefVar := _newRefVar(_ARG_VAR_PYTHON_RUN_ENV, softName+"/python", venv.python())
-	pythonVenvRefVar := _newRefVar(_ARG_VAR_PYTHON_VENV, softName + "/venv", venv.venv())
-	venvBinDirRefVar := _newRefVar(_ARG_VAR_VENV_BIN_DIR, softName + "/binDir", venv.binDir() )
-	pathDelimeterRefVar := _newRefVar(_ARG_PATH_DELIMETER, softName + "/pathDelimeter", venv.pathDelimeter())
-
-	return ll.toStrict({
-		runEnvType: "python",
-
-		variables: [ pythonRefVar, pythonVenvRefVar, venvBinDirRefVar, pathDelimeterRefVar ],
-		customPaths: [ _newArg(false, path.join(_expr(_ARG_VAR_PYTHON_VENV), "venv", _expr(_ARG_VAR_VENV_BIN_DIR))) ],
-		envs: {
-			"VIRTUAL_ENV": _newArg(false, path.join(_expr(_ARG_VAR_PYTHON_VENV), "venv")),
-			"PYTHONPATH": _newArg(false, path.join(_expr(_ARG_VAR_PYTHON_RUN_ENV), descriptor.runEnv.binDir, "python_stdlib") + _expr(_ARG_PATH_DELIMETER) + _expr(_ARG_VAR_PKG))
-		}
-	})
-}
-
-_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(_expr(_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)
-
-	renvRootArg := path.join(_expr(_ARG_VAR_R), "renv-root")
-
-	envs := {
-		"RHOME": _newArg(false, _expr(_ARG_VAR_R)), // for Rscript (it uses RHOME instead of R_HOME)
-		"R_HOME_DIR": _newArg(false, _expr(_ARG_VAR_R)), // for R startup script. It configures all the rest required for R to start.
-		"RENV_PATHS_ROOT": _newArg(false, renvRootArg),
-		"RENV_PATHS_BINARY": _newArg(false, path.join(renvRootArg, "binaries")),
-		"RENV_PATHS_SOURCE": _newArg(false, path.join(renvRootArg, "sources")),
-		"RENV_PATHS_CACHE": _newArg(false, path.join(renvRootArg, "cache")),
-		"RENV_PATHS_RENV": _newArg(false, path.join(_expr(_ARG_VAR_R_VENV), "renv")),
-		"RENV_PATHS_LOCKFILE": _newArg(false, path.join(renvRootArg, "renv.lock"))
-	}
-
-
-
-
-	envs["RENV_CONFIG_REPOS_OVERRIDE"] = _newArg(false, path.join(_expr(_ARG_VAR_R), "packages"))
-
-	return ll.toStrict({
-		runEnvType: "R",
-
-		variables: [ rRefVar, rEnvRefVar ],
-		customPaths: [ _newArg(false, rBinDir) ],
-		envs: envs
-	})
-}
-
-
-_loadRunEnvironment := func(operationMode, descriptor, softName, softPackage) {
-	if descriptor.runEnv.type == "java" {
-		return _loadJavaRunEnvironment(operationMode, descriptor)
-	}
-	if descriptor.runEnv.type == "python" {
-		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(operationMode, softwareName, variables, descriptor, softPackage) {
-	customPaths := []
-	envs := ll.toStrict({})
-	args := []
-	runEnvType := "binary"
-
-
-
-	if (maps.containsKey(descriptor, "runEnv")) {
-		runEnvInfo := _loadRunEnvironment(operationMode, descriptor, softwareName, softPackage)
-
-		runEnvType = runEnvInfo.runEnvType
-		if len(runEnvInfo.variables) > 0 {
-			variables = append(variables, runEnvInfo.variables...)
-		}
-		if len(runEnvInfo.customPaths) > 0 {
-			customPaths = append(customPaths, runEnvInfo.customPaths...)
-		}
-		if len(runEnvInfo.envs) > 0 {
-			for n, v in runEnvInfo.envs {
-				envs[n] = v
-			}
-		}
-	}
-
-	ll.assert(
-		len(descriptor.cmd) != 0,
-		"cannot render final command for software: empty 'cmd' and 'command' in software descriptor")
-
-	cmd := _newArg(false, descriptor.cmd[0])
-
-	for arg in splice(descriptor.cmd, 1) {
-		args = append(args, _newArg(false, arg))
-	}
-
-	return ll.toStrict({
-		runEnvType: runEnvType,
-		variables: variables,
-		customPaths: customPaths,
-		cmd: cmd,
-		args: args,
-		envs: envs
-	})
-}
-
-_devLocalPackageCallOptions := func(softwareName, localDescriptor) {
-	softPackage := pkg.use({
-		hash: localDescriptor.hash,
-		path: localDescriptor.path,
-		descriptor: json.encode(ll.fromStrict(localDescriptor)),
-		origin: {
-			registry: "dev-local",
-			url: "file://" + localDescriptor.path,
-			packageName: softwareName
-		}
-	}).package()
-
-	variables := [ _newRefVar(_ARG_VAR_PKG, softwareName, softPackage) ]
-
-	return _binPackageCallOptions("dev-local", softwareName, variables, localDescriptor, softPackage)
-}
-
-_remotePackageCallOptions := func(softwareName, binaryDescriptor) {
-	softPackage := _installSoftware(binaryDescriptor.registry, binaryDescriptor.package)
-
-	variables := [ _newRefVar(_ARG_VAR_PKG, softwareName, softPackage) ]
-
-	return _binPackageCallOptions("remote", softwareName, variables, binaryDescriptor, softPackage)
-}
-
-
-
-
-
-swToRunCmdOptions := func(softwareName, softwareVersion, softwareDescriptor) {
-	ll.assert(is_string(softwareName),
-		"exec.internal.swToRunCmdOptions: software name must be a string, got %v", softwareName)
-	ll.assert(is_string(softwareVersion),
-		"exec.internal.swToRunCmdOptions: software version must be a string, got %v", softwareVersion)
-	validation.assertType(softwareDescriptor, desc.scheme,
-		"exec.internal.swToRunCmdOptions: descriptor does not fit schema")
-
-	result := undefined
-	if maps.containsKey(softwareDescriptor, "local") {
-		result = _devLocalPackageCallOptions(softwareName, softwareDescriptor.local)
-	} else if maps.containsKey(softwareDescriptor, "binary") {
-		result = _remotePackageCallOptions(softwareName, softwareDescriptor.binary)
-	} else {
-		ll.panic(
-			"Unable to run software %s v%s: 'binary' execution mode is not enabled in software descriptor",
-			softwareName, softwareVersion)
-	}
-
-
-
-	return ll.toStrict({
-		runEnvType: result.runEnvType,
-		variables: result.variables,
-		customPaths: result.customPaths,
-		cmd: result.cmd,
-		args: result.args,
-		envs: result.envs
-	})
-}
-
-binaryRunOptions := func(runOptions, mnzEnvs) {
-	validation.assertType(mnzEnvs, {"any": validation.reference})
-
-	runCmdOpts := undefined
-	if (is_undefined(ll.fromStrict(runOptions).software)) {
-
-
-
-		runCmdOpts = _directCallOptions(runOptions)
-	} else {
-		software := runOptions.software
-		descriptor := software.descriptor
-
-		runCmdOpts = swToRunCmdOptions(software.name, software.version, descriptor)
-	}
-
-
-
-
-
-	opts := ll.fromStrict(runOptions)
-	shouldUseNewTyped := !is_undefined(opts.argsTyped) || !is_undefined(opts.envsTyped)
-
-	args := shouldUseNewTyped ? runOptions.argsTyped : runOptions.args
-	for _, arg in args {
-		typedArg := shouldUseNewTyped ? _newTypedArg(arg.type, arg.value) :	_newArg(true, arg)
-		runCmdOpts.args = append(runCmdOpts.args, typedArg)
-	}
-
-	envs := shouldUseNewTyped ? runOptions.envsTyped : runOptions.envs
-	for name, v in envs {
-		typedEnv := shouldUseNewTyped ? _newTypedArg(v.type, v.value) : _newArg(true, v)
-		runCmdOpts.envs[name] = typedEnv
-	}
-
-	for name, val in mnzEnvs { // can be empty
-
-
-		runCmdOpts.envs[name] = _newArg(false, _expr(_ARG_VAR_MNZ))
-
-		runCmdOpts.variables = append(runCmdOpts.variables,
-			_newRefVar(_ARG_VAR_MNZ, "monetization", val))
-	}
-
-
-	return oop.inherit(runOptions, ll.fromStrict(runCmdOpts))
-}
-
-prepareCommandRun := func(wd, opts) {
-	runBuilder := runcmd.builder(wd)
-
-
-	for varInfo in opts.variables {
-		runBuilder.ref(varInfo.refName, varInfo.reference)
-		runBuilder.substitutionRule(varInfo.varName, varInfo.refName)
-	}
-
-
-	for p in opts.customPaths {
-		runBuilder.addToPath(p.type, p.value)
-	}
-
-
-	for name, value in opts.envs {
-		runBuilder.envTyped(name, value.type, value.value)
-	}
-
-	return runBuilder
-}
-
-_activateRenv := func(wd, opts) {
-	activateRenv := prepareCommandRun(wd, opts)
-	activateRenv.
-		cmd("R").
-		inQueue(constants.LIGHT_QUEUE).
-		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 {
-	swToRunCmdOptions           : swToRunCmdOptions,
-	binaryRunOptions			: binaryRunOptions,
-
-	prepareWDForRunEnvironment	: prepareWDForRunEnvironment,
-	prepareCommandRun			: prepareCommandRun
-}