def script_runner(config=None, **kwargs):
# each cea script is represented by this function - but assigned the name of the script at module
# level. this is done when the module is read. Note that we use the LazyLoader below to only actually
# import the module when it's accessed the first time to save startup time (scripts are often run
# infrequently and most are not run at all during an average cea session)
if not config:
config = cea.config.Configuration()
option_list = cea_script.parameters
config.restrict_to(option_list)
for section, parameter in config.matching_parameters(option_list):
if parameter.py_name in kwargs:
parameter.set(kwargs[parameter.py_name])
cea_script.print_script_configuration(config)
if list(cea_script.missing_input_files(config)):
cea_script.print_missing_input_files(config)
raise cea.MissingInputDataException()
t0 = datetime.datetime.now()
# run the script
script_module.main(config)
# print success message
msg = "Script completed. Execution time: %.2fs" % (
datetime.datetime.now() - t0).total_seconds()
print("")
print("-" * len(msg))
print(msg)
def print_help(config, remaining_args):
"""Print out the help message for the ``cea-doc`` command line interface"""
if remaining_args:
script_name = remaining_args[0]
try:
cea_script = cea.scripts.by_name(script_name,
plugins=config.plugins)
except:
print("Invalid value for SCRIPT.")
print_valid_script_names(plugins=config.plugins)
return
script_module = importlib.import_module(cea_script.module)
print(script_module.__doc__)
print("")
print("OPTIONS for %s:" % script_name)
for _, parameter in config.matching_parameters(cea_script.parameters):
print("--%s: %s" % (parameter.name, parameter.get()))
print(" %s" % parameter.help)
print(" (default: %s)" % parameter.default)
else:
print("usage: cea SCRIPT [OPTIONS]")
print(" to run a specific script")
print("usage: cea --help SCRIPT")
print(" to get additional help specific to a script")
print_valid_script_names(plugins=config.plugins)
def parameters_for_script(script_name, config):
"""Return a list consisting of :py:class:`cea.config.Parameter` objects for each parameter of a script"""
parameters = [
p for _, p in config.matching_parameters(
cea.scripts.by_name(script_name).parameters)
]
return parameters
def get_parameters(cea_tool, config):
"""Return a list of cea.config.Parameter objects for each parameter associated with the tool."""
cli_config = ConfigParser.SafeConfigParser()
cli_config.read(os.path.join(os.path.dirname(__file__), '..', 'cli', 'cli.config'))
option_list = cli_config.get('config', cea_tool).split()
for _, parameter in config.matching_parameters(option_list):
yield parameter
def route_tool(script_name):
config = current_app.cea_config
locator = cea.inputlocator.InputLocator(config.scenario)
script = cea.scripts.by_name(script_name)
weather_dict = {
wn: locator.get_weather(wn)
for wn in locator.get_weather_names()
}
parameters = []
categories = {}
for _, parameter in config.matching_parameters(script.parameters):
if parameter.category:
if parameter.category not in categories:
categories[parameter.category] = []
categories[parameter.category].append(parameter)
else:
parameters.append(parameter)
return render_template('tool.html',
script=script,
parameters=parameters,
categories=categories,
weather_dict=weather_dict,
last_updated=dir_last_updated())
def do_script_step(config, step):
"""Run a script based on the step's "script" and "parameters" (optional) keys."""
script = cea.scripts.by_name(step["script"])
print("Workflow step: script={script}".format(script=script.name))
parameters = {p.name: p.get() for s, p in config.matching_parameters(script.parameters)}
if "parameters" in step:
parameters.update(step["parameters"])
py_script = script.name.replace("-", "_")
py_parameters = {k.replace("-", "_"): v for k, v in parameters.items()}
run(config, py_script, **py_parameters)
def script_runner(config=config, subprocess=False, **kwargs):
cea_script.print_script_configuration(config)
option_list = cea_script.parameters
module_path = cea_script.module
script_module = importlib.import_module(module_path)
config.restrict_to(option_list)
for section, parameter in config.matching_parameters(option_list):
if parameter.name in kwargs:
parameter.set(kwargs[parameter.name])
if not subprocess:
script_module.main(config)
def script_runner(config=config, subprocess=False, **kwargs):
print('running script {}'.format(script_name))
option_list = cli_config.get('config', script_name).split()
module_path = cli_config.get('scripts', script_name)
script_module = importlib.import_module(module_path)
config.restrict_to(option_list)
for section, parameter in config.matching_parameters(option_list):
if parameter.name in kwargs:
parameter.set(kwargs[parameter.name])
if not subprocess:
script_module.main(config)
def script_runner(config=config, **kwargs):
option_list = cea_script.parameters
config.restrict_to(option_list)
for section, parameter in config.matching_parameters(option_list):
if parameter.py_name in kwargs:
parameter.set(kwargs[parameter.py_name])
cea_script.print_script_configuration(config)
if list(cea_script.missing_input_files(config)):
cea_script.print_missing_input_files(config)
raise cea.MissingInputDataException()
t0 = datetime.datetime.now()
# run the script
script_module.main(config)
# print success message
msg = "Script completed. Execution time: %.2fs" % (datetime.datetime.now() - t0).total_seconds()
print("")
print("-" * len(msg))
print(msg)
def do_script_step(config, i, step, trace_input):
"""Run a script based on the step's "script" and "parameters" (optional) keys."""
script = cea.scripts.by_name(step["script"], plugins=config.plugins)
print("")
print("=" * 80)
print("Workflow step {i}: script={script}".format(i=i, script=script.name))
print("=" * 80)
parameters = {
p.name: p.get()
for s, p in config.matching_parameters(script.parameters)
}
if "parameters" in step:
parameters.update(step["parameters"])
py_script = script.name.replace("-", "_")
py_parameters = {k.replace("-", "_"): v for k, v in parameters.items()}
if trace_input:
run_with_trace(config, py_script, **py_parameters)
else:
run(config, py_script, **py_parameters)
def get(self, tool_name):
config = cea.config.Configuration()
script = cea.scripts.by_name(tool_name)
parameters = []
categories = {}
for _, parameter in config.matching_parameters(script.parameters):
if parameter.category:
if parameter.category not in categories:
categories[parameter.category] = []
categories[parameter.category].append(
deconstruct_parameters(parameter))
else:
parameters.append(deconstruct_parameters(parameter))
out = {
'label': script.label,
'category': script.category,
'parameters': parameters,
'categorical_parameters': categories,
}
return out
def main():
config = cea.config.Configuration(config_file=cea.config.DEFAULT_CONFIG)
script_defs = [] # a list of script defs in SCRIPTS_FILE
with open(SCRIPT_DEF_TEMPLATE_FILE, "r") as script_def_fp:
script_def_template = script_def_fp.read()
with open(BADGERFILE, "r") as badger_fp:
badgerfile = json.load(badger_fp)
# collect previous guids, if possible:
guids = {c["name"]: c["id"] for c in badgerfile["components"]}
badgerfile["components"] = []
for script in cea.scripts.for_interface("cli", plugins=[]):
script_py_name = script.name.replace("-", "_")
component = {
"id":
guids[script.label]
if script.label in guids else str(uuid.uuid4()),
"class-name":
"".join(s.capitalize() for s in script.name.split("-")),
"abbreviation":
script.name,
"name":
script.label,
"description":
script.description,
"category":
CATEGORY,
"subcategory":
script.category,
"icon":
"icons/{name}.png".format(name=script.name),
"main-module":
"cea_scripts",
"main-function":
script_py_name,
"use-kwargs":
True,
"inputs": [{
"type": "boolean",
"name": "start",
"description": "Set this to true to start computation",
"default": False,
"nick-name": "start"
}],
"outputs": [{
"type": "boolean",
"name": "continue",
"description":
"This is set to true if component successfully ran and start was set to true",
"nick-name": "continue"
}],
}
script_defs.append(
script_def_template.replace("SCRIPT_PY_NAME",
script_py_name).replace(
"SCRIPT_NAME", script.name))
print(script.name)
for _, parameter in config.matching_parameters(script.parameters):
print("\t{pname}={pvalue}".format(pname=parameter.name,
pvalue=parameter.get_raw()))
input = {
"type": "string",
"name": parameter.fqname,
"description": parameter.help,
"nick-name": parameter.name,
"default": parameter.get_raw(),
"access": "item"
}
component["inputs"].append(input)
badgerfile["components"].append(component)
# copy the icon if it doesn't exist yet
icon_path = os.path.join(os.path.dirname(__file__), component["icon"])
default_icon_path = os.path.join(os.path.dirname(__file__),
"default_icon.png")
if not os.path.exists(icon_path):
shutil.copyfile(default_icon_path, icon_path)
with open(BADGERFILE, "w") as badger_fp:
json.dump(badgerfile, badger_fp, indent=4)
with open(SCRIPTS_FILE, "w") as scripts_fp:
scripts_fp.write("\n".join(script_defs))
def get_cea_parameters(config, cea_tool):
"""Return a list of cea.config.Parameter objects for each cea_parameter associated with the tool."""
for _, cea_parameter in config.matching_parameters(
cea.scripts.by_name(cea_tool).parameters):
yield cea_parameter
