Return the JavaScript runtime that is specified in EXECJS_RUNTIME environment variable.
        If EXECJS_RUNTIME environment variable is empty or invalid, return None.
331684
def get_from_environment():
    '''
        
    '''
    name = os.environ.get("EXECJS_RUNTIME", "")
    if not name:
        return None

    try:
        return _find_runtime_by_name(name)
    except exceptions.RuntimeUnavailableError:
        return None
368306
def get_runconfig(path=None, root=None, db=None):
    

    return load(path, root=root, db=db)
604722
private Properties getEnvironmentVariables() throws Throwable {
		Properties environmentVariables = new Properties();
		String operatingSystem = System.getProperty("os.name").toLowerCase();
		Runtime runtime = Runtime.getRuntime();
		Process process = null;
		if (operatingSystem.startsWith("windows 95")
				|| operatingSystem.startsWith("windows 98")
				|| operatingSystem.startsWith("me")) {
			process = runtime.exec("command.com /c set");
		} else if (operatingSystem.startsWith("windows")) {
			// Modern windows
			process = runtime.exec("cmd.exe /c set");
		} else {
			process = runtime.exec("env");
		}
		BufferedReader environmentStream = new BufferedReader(new InputStreamReader(process.getInputStream()));
		String inputLine = "";
		int idx = -1;
		while ((inputLine = environmentStream.readLine()) != null) {
			idx = inputLine.indexOf('=');
			environmentVariables.setProperty(inputLine.substring(0, idx),
					inputLine.substring(idx + 1));
		}
		return environmentVariables;
	}
353106
def env(var_name, default=False):
    
    try:
        value = os.environ[var_name]
        if str(value).strip().lower() in ['false', 'f', 'no', 'off' '0', 'none', 'null', '', ]:
            return None
        return value
    except:
        from traceback import format_exc
        msg = "Unable to find the %s environment variable.\nUsing the value %s (the default) instead.\n" % (var_name, default)
        sys.stderr.write(format_exc())
        sys.stderr.write(msg)
        return default
712180
def get_env_default(self, variable, default):
        
        if variable in os.environ:
            env_var = os.environ[variable]
        else:
            env_var = default
        return env_var
209604
def _get_exe(prog):
        ''''''
        if prog in prog_to_env_var:
            env_var = prog_to_env_var[prog]
            if env_var in os.environ:
                return os.environ[env_var]

        return prog_to_default[prog]
1329336
def get_run_configuration(fname):
    """"""
    configurations = _get_run_configurations()
    for filename, options in configurations:
        if fname == filename:
            runconf = RunConfiguration()
            runconf.set(options)
            return runconf
55622
private Properties getEnvVars()
    {
        Process p = null;
        Properties envVars = new Properties();

        try
        {
            Runtime r = Runtime.getRuntime();
            String OS = System.getProperty("os.name").toLowerCase();

            if (OS.indexOf("windows 9") > -1)
            {
                p = r.exec("command.com /c set");
            }
            else if ((OS.indexOf("nt") > -1) ||
                     (OS.indexOf("windows 2000") > -1) ||
                     (OS.indexOf("windows xp") > -1))
            {
                p = r.exec("cmd.exe /c set");
            }
            else
            {
                // our last hope, we assume Unix (thanks to H. Ware for the fix)
                p = r.exec("env");
            }
            BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String line;
            while((line = br.readLine()) != null)
            {
                int idx = line.indexOf('=');
                String key = line.substring(0, idx);
                String value = line.substring(idx + 1);
                envVars.setProperty(key, value);
            }
        }
        catch (Exception ExIgnore)
        {
        }
        return envVars;
    }
646662
private static ScriptRunner getRunner() throws IOException {
		if (sharedRunner.get() == null) {
			//create JavaScript runner
			ScriptRunner runner = ScriptRunnerFactory.createRunner();
			
			//load bundled scripts
			try {
				runner.loadScript(CSL.class.getResource("dump.js"));
				runner.loadScript(CSL.class.getResource("citeproc.js"));
				runner.loadScript(CSL.class.getResource("formats.js"));
				runner.loadScript(CSL.class.getResource("loadsys.js"));
			} catch (ScriptRunnerException e) {
				//should never happen because bundled JavaScript files
				//should be OK indeed
				throw new RuntimeException("Invalid bundled javascript file", e);
			}
			
			sharedRunner.set(runner);
		}
		return sharedRunner.get();
	}
1020699
function runtimeReq(mId) {
  const parsed = parse(mId);
  return _fetch(parsed.cleanId)
  .then(response => {
    // ensure default user space
    define.switchToUserSpace();

    for (let i = 0, len = _translators.length; i < len; i++) {
      const result = _translators[i](parsed, response);
      if (result && typeof result.then === 'function') return result;
    }
    throw new Error(`no runtime translator to handle ${parsed.cleanId}`);
  })
  .then(() => {
    if (userSpace.has(parsed.cleanId)) return userSpace.req(parsed.cleanId);
    throw new Error(`module "${parsed.cleanId}" is missing from url "${toUrl(mId)}"`);
  })
  .catch(err => {
    console.error(`could not load module "${parsed.cleanId}" from remote`); // eslint-disable-line no-console
    throw err;
  });
}
1351361
function getPythonExecutable(options, platform) {
    if (options.virtualenv) {
      var isWin = /^win/.test(platform);
      var pythonExec = isWin ?
        path.join(options.virtualenv, 'Scripts', 'python.exe') :
        path.join(options.virtualenv, 'bin', 'python');
      delete options.virtualenv;
      return pythonExec;
    } else {
      return 'python';
    }
  }
1280258
def get_runtime_value(self, ihcid: int):
        
        if self.client.get_runtime_value(ihcid):
            return True
        self.re_authenticate()
        return self.client.get_runtime_value(ihcid)
4747
function () {
    var pluginDir = $bc_$18.App.getAppPluginDir();
    var runOS = $bc_$18.App.getAppRunOnOS();
    if (runOS === 'MacOSX') {
      return pluginDir + '/pythonCLI.app/Contents/MacOS/pythonCLI'
    } else if (runOS === 'win32') {
      return pluginDir + '/python/pythonCLI/romanysoft.services.exe'
    } else {
      console.error(logCord$9, 'not found plugin config');
    }
  }
482442
def runtime(self):
        
        t = time.time() - self.start
        self.start = time.time()
        return t
980396
def get_environment_var(varstr):
    """"""
    mo=_get_env_var.match(to_String(varstr))
    if mo:
        var = mo.group(1)
        if var[0] == '{':
            return var[1:-1]
        else:
            return var
    else:
        return None
877241
function () {
        const crons = _.get(Shared, 'runtimeArgs.cron') || _.get(Shared, 'runtimeArgs.crons');
        if (crons) {
            const cronTasks = crons.replace(/\s/g, '').split(',');
            return cronTasks.length > 0 ? cronTasks : undefined;
        }
        return undefined;
    }
202219
public static String getEnv(){
        if(ENV == null){
            if(!blank(System.getenv("ACTIVE_ENV"))) {
                ENV = System.getenv("ACTIVE_ENV");
            }

            if(!blank(System.getProperty("ACTIVE_ENV"))) {
                ENV = System.getProperty("ACTIVE_ENV");
            }

            if(!blank(System.getProperty("active_env"))) {
                ENV = System.getProperty("active_env");
            }

            if(blank(ENV)){                
                ENV = "development";
                LOGGER.warn("Environment variable ACTIVE_ENV not provided, defaulting to '" + ENV + "'");
            }
        }
        return ENV;
    }