def console_writer_before_each_feature(self, feature):
"""
Writes feature header to the console
:param Feature feature: the feature to write to the console
"""
output = ""
for tag in feature.tags:
output += colorful.cyan(u"@{0}{1}\n".format(
tag.name, "({0})".format(tag.arg) if tag.arg else ""))
leading = "\n " if feature.description else ""
output += u"{0}{1}: {2} # {3}{4}{5}".format(
self.get_id_sentence_prefix(feature, colorful.bold_cyan),
colorful.bold_white(feature.keyword),
colorful.bold_white(feature.sentence),
colorful.bold_black(feature.path), leading,
colorful.white("\n ".join(feature.description)))
if feature.background:
output += u"\n\n {0}: {1}".format(
colorful.bold_white(feature.background.keyword),
colorful.bold_white(feature.background.sentence))
for step in feature.background.all_steps:
output += '\n' + self._get_step_before_output(
step, colorful.cyan)
write(output)
def console_writer_before_each_feature(self, feature):
"""
Writes feature header to the console
:param Feature feature: the feature to write to the console
"""
output = ""
for tag in feature.tags:
output += colorful.cyan(
"@{0}{1}\n".format(tag.name, "({0})".format(tag.arg) if tag.arg else "")
)
leading = "\n " if feature.description else ""
output += "{0}{1}: {2} # {3}{4}{5}".format(
self.get_id_sentence_prefix(feature, colorful.bold_cyan),
colorful.bold_white(feature.keyword),
colorful.bold_white(feature.sentence),
colorful.bold_black(feature.path),
leading,
colorful.white("\n ".join(feature.description)),
)
if feature.background:
output += "\n\n {0}: {1}".format(
colorful.bold_white(feature.background.keyword),
colorful.bold_white(feature.background.sentence),
)
for step in feature.background.all_steps:
output += "\n" + self._get_step_before_output(step, colorful.cyan)
write(output)
def _process(self):
# Prepare message
msg = []
for msg_index in range(0,len(self.message)):
if self.exit_on_failure is False:
msg_header = '{}{}'.format(self.exception_name,
colorful.bold_white(':')) if msg_index == 0 else ' '*(len(self.exception_name)+1)
msg.append('\t\t{} {}'.format(colorful.bold_red(msg_header), colorful.red(self.message[msg_index])))
else:
msg.append(self.message[msg_index] if msg_index == 0
else '{}{} {} {}'.format("\t"*2,
' '*(len(self.exception_name)+1),
colorful.bold_white(':'),
self.message[msg_index]))
if self.exit_on_failure is False:
for message in msg:
console_write(message)
if self.no_failure is False:
self._fail_step(self.step_obj.id)
else:
self.step_obj.state = Step.State.SKIPPED
return
if self.no_failure is False:
raise self.exception('\n'.join(msg))
def console_writer_before_each_scenario(self, scenario):
"""
Writes the scenario header to the console
:param Scenario scenario: the scenario to write to the console
"""
output = "\n"
if isinstance(scenario.parent, ScenarioOutline):
if world.config.write_steps_once:
return
id_prefix = self.get_id_sentence_prefix(
scenario, colorful.bold_yellow, len(scenario.parent.scenarios))
colored_pipe = colorful.bold_white("|")
output = " {0}{1} {2} {1}".format(
id_prefix,
colored_pipe,
(" {0} ").format(colored_pipe).join(
str(
colorful.bold_yellow("{1: <{0}}".format(
scenario.parent.get_column_width(i), x)))
for i, x in enumerate(scenario.example.data)),
)
elif isinstance(scenario.parent, ScenarioLoop):
if world.config.write_steps_once:
return
id_prefix = self.get_id_sentence_prefix(
scenario, colorful.bold_yellow, len(scenario.parent.scenarios))
colored_pipe = colorful.bold_white("|")
output = " {0}{1} {2: <18} {1}".format(
id_prefix, colored_pipe,
str(colorful.bold_yellow(scenario.iteration)))
else:
id_prefix = self.get_id_sentence_prefix(scenario,
colorful.bold_cyan)
for tag in scenario.tags:
if (
tag.name == "precondition" and world.config.expand
and world.config.show
): # exceptional for show command when scenario steps expand and tag is a precondition -> comment it out
output += colorful.white(" # @{0}{1}\n".format(
tag.name, "({0})".format(tag.arg) if tag.arg else ""))
else:
output += colorful.cyan(" @{0}{1}\n".format(
tag.name, "({0})".format(tag.arg) if tag.arg else ""))
output += " {0}{1}: {2}".format(
id_prefix,
colorful.bold_white(scenario.keyword),
colorful.bold_white(scenario.sentence),
)
write(output)
def context_registers(self):
"""Show contents of ARM registers."""
colorful.bold_white = colorful.bold_base2
regs_list = []
# Dump registers R0 to R9
for reg in xrange(UC_ARM_REG_R0, UC_ARM_REG_R0 + 10):
reg_string = colorful.bold_white(
"R{:d}:".format(reg - UC_ARM_REG_R0)) + colorful.bold_base01(
" 0x{:08x}".format(self.emu.reg_read(reg)))
regs_list.append(reg_string)
# Dump registers with alias
sl_reg = colorful.bold_white("SL:") + colorful.base01(
" 0x{:08x}".format(self.emu.reg_read(UC_ARM_REG_SL)))
fp_reg = colorful.bold_white("FP:") + colorful.base01(
" 0x{:08x}".format(self.emu.reg_read(UC_ARM_REG_FP)))
ip_reg = colorful.bold_white("IP:") + colorful.base01(
" 0x{:08x}".format(self.emu.reg_read(UC_ARM_REG_IP)))
sp_reg = colorful.bold_white("SP:") + colorful.base01(
" 0x{:08x}".format(self.emu.reg_read(UC_ARM_REG_SP)))
lr_reg = colorful.bold_white("LR:") + colorful.base01(
" 0x{:08x}".format(self.emu.reg_read(UC_ARM_REG_LR)))
pc_reg = colorful.bold_white("PC:") + colorful.base01(
" 0x{:08x}".format(self.emu.reg_read(UC_ARM_REG_PC)))
cpsr_reg = colorful.bold_white("CPSR:") + colorful.base01(
" 0x{:08x}".format(self.emu.reg_read(UC_ARM_REG_CPSR)))
regs_list.extend(
[sl_reg, fp_reg, ip_reg, sp_reg, lr_reg, pc_reg, cpsr_reg])
table_show_registers(regs_list)
def _get_step_before_output(self, step, color_func=None):
if color_func is None:
color_func = colorful.bold_yellow
output = "\r {0}{1}".format(
self.get_id_sentence_prefix(step, color_func), color_func(step.sentence)
)
if step.text:
id_padding = self.get_id_padding(len(step.parent.steps))
output += colorful.bold_white('\n {0}"""'.format(id_padding))
output += colorful.cyan(
"".join(
[
"\n {0}{1}".format(id_padding, l)
for l in step.raw_text
]
)
)
output += colorful.bold_white('\n {0}"""'.format(id_padding))
if step.table_header:
colored_pipe = colorful.bold_white("|")
col_widths = self.get_table_col_widths(
[step.table_header] + step.table_data
)
# output table header
output += "\n {0} {1} {0}".format(
colored_pipe,
(" {0} ")
.format(colored_pipe)
.join(
str(colorful.white("{1: <{0}}".format(col_widths[i], x)))
for i, x in enumerate(step.table_header)
),
)
# output table data
for row in step.table_data:
output += "\n {0} {1} {0}".format(
colored_pipe,
(" {0} ")
.format(colored_pipe)
.join(
str(color_func("{1: <{0}}".format(col_widths[i], x)))
for i, x in enumerate(row)
),
)
return output
def match_line(input_text):
# determine closest line to input
if input_text in ["testing"]:
line = cf.bold_cornflowerBlue_on_snow(input_text)
else:
line = cf.bold_white(input_text)
return line
def write_feature_header(feature):
"""Write the Feature Header to stdout
The Feature Header will be printed in the form of:
@tag-a
@tag-b
Feature: short description
description line 1
description line 2
"""
# write Tags
for tag in feature.tags:
write_tagline(tag)
# write Feature heading
feature_heading = "{feature_keyword}: {short_description}".format(
feature_keyword=cf.bold_white(feature.keyword),
short_description=cf.white(feature.short_description),
)
print(feature_heading, flush=True)
# write Feature description if available
if feature.description:
feature_description = "\n".join(INDENT_STEP + l
for l in feature.description)
print(feature_description + "\n", flush=True)
# write Background if available
if feature.background:
background = "{background_keyword}: {short_description}".format(
background_keyword=cf.bold_white(feature.background.keyword),
short_description=cf.white(feature.background.short_description)
if feature.background.short_description else "",
)
print(INDENT_STEP + background, flush=True)
# TODO: write background steps
for step in feature.background.steps:
write_step(step,
cf.deepSkyBlue3,
indentation=INDENT_STEP + INDENT_STEP)
print("", flush=True)
def _process(self):
# Prepare message
msg = []
for msg_index in range(0, len(self.message)):
if self.exit_on_failure is False or self.no_failure is True:
msg_header = '{}{}'.format(
self.exception_name, colorful.bold_white(':')
) if msg_index == 0 else ' ' * (len(self.exception_name) + 1)
if str(world.config.formatter) in ('gherkin'):
# this line could be improved by letting radish handle the printing
msg.append('\t\t{} {}'.format(
colorful.bold_red(msg_header),
colorful.red(self.message[msg_index])))
elif str(world.config.formatter) in ('silent_formatter'):
msg.append('{} '.format(colorful.bold_red(msg_header)))
msg.append('{}'.format(
colorful.red(self.message[msg_index])))
else:
msg.append(
self.message[msg_index] if msg_index == 0 else '{}{} {} {}'
.format("\t" * 2, ' ' * (len(self.exception_name) + 1),
colorful.bold_white(':'), self.message[msg_index]))
if self.exit_on_failure is False or (self.no_failure is True and msg):
if str(world.config.formatter) in ('gherkin'):
for message in msg:
console_write(message)
elif str(world.config.formatter) in ('silent_formatter'):
if not hasattr(self.step_obj.context,
'failure_msg'): # where to put this
self.step_obj.context.failure_msg = []
self.step_obj.context.failure_msg.extend(msg)
if self.no_failure is False:
self._fail_step(self.step_obj.id)
else:
self.step_obj.state = Step.State.SKIPPED
for step in self.step_obj.parent.all_steps:
step.runable = False
return
if self.no_failure is False:
raise self.exception('\n'.join(msg))
def _get_step_before_output(self, step, color_func=None):
if color_func is None:
color_func = colorful.bold_yellow
output = "\r {0}{1}".format(
self.get_id_sentence_prefix(step, color_func),
color_func(step.sentence))
if step.text:
id_padding = self.get_id_padding(len(step.parent.steps))
output += colorful.bold_white(
'\n {0}"""'.format(id_padding))
output += colorful.cyan("".join([
"\n {0}{1}".format(id_padding, l)
for l in step.raw_text
]))
output += colorful.bold_white(
'\n {0}"""'.format(id_padding))
if step.table_header:
colored_pipe = colorful.bold_white("|")
col_widths = self.get_table_col_widths([step.table_header] +
step.table_data)
# output table header
output += "\n {0} {1} {0}".format(
colored_pipe,
(" {0} ").format(colored_pipe).join(
str(colorful.white("{1: <{0}}".format(col_widths[i], x)))
for i, x in enumerate(step.table_header)),
)
# output table data
for row in step.table_data:
output += "\n {0} {1} {0}".format(
colored_pipe,
(" {0} ").format(colored_pipe).join(
str(color_func("{1: <{0}}".format(col_widths[i], x)))
for i, x in enumerate(row)),
)
return output
def write_scenario_header(scenario):
"""Write the Scenario header"""
indentation_level = 1 if isinstance(scenario.rule, DefaultRule) else 2
indentation = INDENT_STEP * indentation_level
scenario_heading = "{scenario_keyword}: {short_description}".format(
scenario_keyword=cf.bold_white(scenario.keyword),
short_description=cf.white(scenario.short_description),
)
for tag in scenario.tags:
write_tagline(tag, indentation)
print(indentation + scenario_heading, flush=True)
def write_rule_header(rule):
"""Write the Rule header
The short description is only written if it's not a DefaultRule
"""
if isinstance(rule, DefaultRule):
return
rule_heading = "{rule_keyword}: {short_description}".format(
rule_keyword=cf.bold_white(rule.keyword),
short_description=cf.white(rule.short_description),
)
print(INDENT_STEP + rule_heading + "\n", flush=True)
def read_wikipedia(input_text):
print_output: print(cf.slateGray("Recognized: {0}".format(cf.bold_white(input_text))))
input_text = input_text[13:].strip()
if input_text.strip() != '':
url = "https://en.wikipedia.org/api/rest_v1/page/summary/{}".format(input_text)
logging.info('URL: ' + url)
r = requests.get(url)
page = r.json()
if 'extract' in page:
resp = page["extract"]
print(resp)
echo_line(resp, False)
else:
echo_line('No details found', False)
def dump(filename=None):
"""
dump corpus content
"""
with tempfile.TemporaryDirectory() as temp_dir:
env = dict(os.environ,
LLVM_PROFILE_FILE=os.path.join(temp_dir, 'default.profraw'))
call = [FUZZCOVER_BINARY, '--dump', CORPUS_DIRECTORY]
if filename:
call.append(filename)
subprocess.run(call, env=env)
if filename:
print('Saved corpus to {filename}.'.format(
filename=cf.bold_white(filename)))
def echo_line(input_text, print_output = True):
filename = 'response.wav'
if input_text.strip() != '':
#say_text = 'I heard, ' + input_text
if len(input_text) <= 2:
input_text = 'error with text length'
else:
say_text = input_text
url = 'http://0.0.0.0:5002/api/tts?text={}'.format(say_text)
r = requests.get(url)
with open(filename, 'wb') as f:
f.write(r.content)
logging.debug('saved wav for {}'.format(url))
#p = pyaudio.PyAudio()
#play_wav(filename, p)
play_wav(filename)
#p.terminate()
if print_output: print(cf.slateGray("Recognized: {0}".format(cf.bold_white(input_text))))
return
def console_writer_after_each_step(self, step):
"""
Writes the step to the console after it was run
:param Step step: the step to write to the console
"""
if not isinstance(step.parent.parent, Feature):
return
color_func = self.get_color_func(step.state)
line_jump_seq = self.get_line_jump_seq() * (
((len(step.raw_text) + 3) if step.text else 1)
+ (len(step.table) + 1 if step.table_header else 0)
)
output = "{0} ".format(line_jump_seq)
if isinstance(step.parent, ScenarioOutline):
# Highlight ScenarioOutline placeholders e.g. '<method>'
output += "".join(
str(
colorful.white(item)
if (
self._placeholder_regex.search(item)
and item.strip("<>") in step.parent.examples_header
)
else color_func(item)
)
for item in self._placeholder_regex.split(step.sentence)
)
else:
output += "{0}{1}".format(
self.get_id_sentence_prefix(step, colorful.bold_cyan),
color_func(step.sentence),
)
if step.text:
id_padding = self.get_id_padding(len(step.parent.steps))
output += colorful.bold_white('\n {0}"""'.format(id_padding))
output += colorful.cyan(
"".join(
[
"\n {0}{1}".format(id_padding, l)
for l in step.raw_text
]
)
)
output += colorful.bold_white('\n {0}"""'.format(id_padding))
if step.table_header:
colored_pipe = colorful.bold_white("|")
col_widths = self.get_table_col_widths(
[step.table_header] + step.table_data
)
# output table header
output += "\n {0} {1} {0}".format(
colored_pipe,
(" {0} ")
.format(colored_pipe)
.join(
str(colorful.white("{1: <{0}}".format(col_widths[i], x)))
for i, x in enumerate(step.table_header)
),
)
# output table data
for row in step.table_data:
output += "\n {0} {1} {0}".format(
colored_pipe,
(" {0} ")
.format(colored_pipe)
.join(
str(color_func("{1: <{0}}".format(col_widths[i], x)))
for i, x in enumerate(row)
),
)
if step.state == step.State.FAILED:
if world.config.with_traceback:
output += "\n {0}{1}".format(
self.get_id_padding(len(step.parent.steps) - 2),
"\n ".join(
[
str(colorful.red(l))
for l in step.failure.traceback.split("\n")[:-2]
]
),
)
output += "\n {0}{1}: {2}".format(
self.get_id_padding(len(step.parent.steps) - 2),
colorful.bold_red(step.failure.name),
colorful.red(step.failure.reason),
)
write(output)
def console_writer_after_each_scenario(self, scenario):
"""
If the scenario is a ExampleScenario it will write the Examples header
:param Scenario scenario: the scenario which was ran.
"""
output = ""
if isinstance(scenario, ScenarioOutline):
output += "\n {0}:\n".format(
colorful.bold_white(scenario.example_keyword)
)
output += colorful.bold_white(
" {0}| {1} |".format(
self.get_id_padding(len(scenario.scenarios), offset=2),
" | ".join(
"{1: <{0}}".format(scenario.get_column_width(i), x)
for i, x in enumerate(scenario.examples_header)
),
)
)
elif isinstance(scenario, ScenarioLoop):
output += "\n {0}: {1}".format(
colorful.bold_white(scenario.iterations_keyword),
colorful.cyan(scenario.iterations),
)
elif isinstance(scenario.parent, ScenarioOutline):
colored_pipe = colorful.bold_white("|")
color_func = self.get_color_func(scenario.state)
output += "{0} {1}{2} {3} {2}".format(
self.get_line_jump_seq(),
self.get_id_sentence_prefix(
scenario, colorful.bold_cyan, len(scenario.parent.scenarios)
),
colored_pipe,
(" {0} ")
.format(colored_pipe)
.join(
str(
color_func(
"{1: <{0}}".format(scenario.parent.get_column_width(i), x)
)
)
for i, x in enumerate(scenario.example.data)
),
)
if scenario.state == Step.State.FAILED:
failed_step = scenario.failed_step
if world.config.with_traceback:
output += "\n {0}{1}".format(
self.get_id_padding(len(scenario.parent.scenarios)),
"\n ".join(
[
str(colorful.red(l))
for l in failed_step.failure.traceback.split("\n")[:-2]
]
),
)
output += "\n {0}{1}: {2}".format(
self.get_id_padding(len(scenario.parent.scenarios)),
colorful.bold_red(failed_step.failure.name),
colorful.red(failed_step.failure.reason),
)
elif isinstance(scenario.parent, ScenarioLoop):
colored_pipe = colorful.bold_white("|")
color_func = self.get_color_func(scenario.state)
output += "{0} {1}{2} {3: <18} {2}".format(
self.get_line_jump_seq(),
self.get_id_sentence_prefix(
scenario, colorful.bold_cyan, len(scenario.parent.scenarios)
),
colored_pipe,
str(color_func(scenario.iteration)),
)
if scenario.state == Step.State.FAILED:
failed_step = scenario.failed_step
if world.config.with_traceback:
output += "\n {0}{1}".format(
self.get_id_padding(len(scenario.parent.scenarios)),
"\n ".join(
[
str(colorful.red(l))
for l in failed_step.failure.traceback.split("\n")[:-2]
]
),
)
output += "\n {0}{1}: {2}".format(
self.get_id_padding(len(scenario.parent.scenarios)),
colorful.bold_red(failed_step.failure.name),
colorful.red(failed_step.failure.reason),
)
if output:
write(output)
def console_writer_before_each_scenario(self, scenario):
"""
Writes the scenario header to the console
:param Scenario scenario: the scenario to write to the console
"""
output = "\n"
if isinstance(scenario.parent, ScenarioOutline):
if world.config.write_steps_once:
return
id_prefix = self.get_id_sentence_prefix(
scenario, colorful.bold_yellow, len(scenario.parent.scenarios)
)
colored_pipe = colorful.bold_white("|")
output = " {0}{1} {2} {1}".format(
id_prefix,
colored_pipe,
(" {0} ")
.format(colored_pipe)
.join(
str(
colorful.bold_yellow(
"{1: <{0}}".format(scenario.parent.get_column_width(i), x)
)
)
for i, x in enumerate(scenario.example.data)
),
)
elif isinstance(scenario.parent, ScenarioLoop):
if world.config.write_steps_once:
return
id_prefix = self.get_id_sentence_prefix(
scenario, colorful.bold_yellow, len(scenario.parent.scenarios)
)
colored_pipe = colorful.bold_white("|")
output = " {0}{1} {2: <18} {1}".format(
id_prefix, colored_pipe, str(colorful.bold_yellow(scenario.iteration))
)
else:
id_prefix = self.get_id_sentence_prefix(scenario, colorful.bold_cyan)
for tag in scenario.tags:
if (
tag.name == "precondition"
and world.config.expand
and world.config.show
): # exceptional for show command when scenario steps expand and tag is a precondition -> comment it out
output += colorful.white(
" # @{0}{1}\n".format(
tag.name, "({0})".format(tag.arg) if tag.arg else ""
)
)
else:
output += colorful.cyan(
" @{0}{1}\n".format(
tag.name, "({0})".format(tag.arg) if tag.arg else ""
)
)
output += " {0}{1}: {2}".format(
id_prefix,
colorful.bold_white(scenario.keyword),
colorful.bold_white(scenario.sentence),
)
write(output)
def console_write(self, features, marker):
"""
Writes the endreport for all features
:param list features: all features
"""
stats = {
"features": {"amount": 0, "passed": 0, "failed": 0, "skipped": 0, "untested": 0, "pending": 0},
"scenarios": {"amount": 0, "passed": 0, "failed": 0, "skipped": 0, "untested": 0, "pending": 0},
"steps": {"amount": 0, "passed": 0, "failed": 0, "skipped": 0, "untested": 0, "pending": 0},
}
pending_steps = []
duration = timedelta()
for feature in features:
if not feature.has_to_run(world.config.scenarios):
continue
stats["features"]["amount"] += 1
stats["features"][feature.state] += 1
if feature.state in [Step.State.PASSED, Step.State.FAILED]:
duration += feature.duration
for scenario in feature.all_scenarios:
if not scenario.has_to_run(world.config.scenarios):
continue
if isinstance(scenario, ScenarioOutline): # skip ScenarioOutlines
continue
if isinstance(scenario, ScenarioLoop): # skip ScenarioLoop
continue
stats["scenarios"]["amount"] += 1
stats["scenarios"][scenario.state] += 1
for step in scenario.steps:
stats["steps"]["amount"] += 1
stats["steps"][step.state] += 1
if step.state == Step.State.PENDING:
pending_steps.append(step)
colored_closing_paren = colorful.bold_white(")")
colored_comma = colorful.bold_white(", ")
passed_word = colorful.bold_green("{0} passed")
failed_word = colorful.bold_red("{0} failed")
skipped_word = colorful.cyan("{0} skipped")
pending_word = colorful.bold_yellow("{0} pending")
output = colorful.bold_white("{0} features (".format(stats["features"]["amount"]))
output += passed_word.format(stats["features"]["passed"])
if stats["features"]["failed"]:
output += colored_comma + failed_word.format(stats["features"]["failed"])
if stats["features"]["skipped"]:
output += colored_comma + skipped_word.format(stats["features"]["skipped"])
if stats["features"]["pending"]:
output += colored_comma + pending_word.format(stats["features"]["pending"])
output += colored_closing_paren
output += "\n"
output += colorful.bold_white("{} scenarios (".format(stats["scenarios"]["amount"]))
output += passed_word.format(stats["scenarios"]["passed"])
if stats["scenarios"]["failed"]:
output += colored_comma + failed_word.format(stats["scenarios"]["failed"])
if stats["scenarios"]["skipped"]:
output += colored_comma + skipped_word.format(stats["scenarios"]["skipped"])
if stats["scenarios"]["pending"]:
output += colored_comma + pending_word.format(stats["scenarios"]["pending"])
output += colored_closing_paren
output += "\n"
output += colorful.bold_white("{} steps (".format(stats["steps"]["amount"]))
output += passed_word.format(stats["steps"]["passed"])
if stats["steps"]["failed"]:
output += colored_comma + failed_word.format(stats["steps"]["failed"])
if stats["steps"]["skipped"]:
output += colored_comma + skipped_word.format(stats["steps"]["skipped"])
if stats["steps"]["pending"]:
output += colored_comma + pending_word.format(stats["steps"]["pending"])
output += colored_closing_paren
if pending_steps:
sr = StepRegistry()
pending_step_implementations = make_unique_obj_list(pending_steps, lambda x: x.definition_func)
output += colorful.white("\nYou have {0} pending step implementation{1} affecting {2} step{3}:\n {4}\n\nNote: this could be the reason for some failing subsequent steps".format(
len(pending_step_implementations),
"s" if len(pending_step_implementations) is not 1 else "",
len(pending_steps),
"s" if len(pending_steps) is not 1 else "",
"\n ".join(["- '{0}' @ {1}".format(sr.get_pattern(s.definition_func), get_func_code(s.definition_func).co_filename) for s in pending_step_implementations])
))
output += "\n"
output += colorful.cyan("Run {0} finished within {1}".format(marker, humanize.naturaldelta(duration)))
write(output)
def test_step_matches_configs(
match_config_files, basedirs, cover_min_percentage=None, cover_show_missing=False
):
"""
Test if the given match config files matches the actual
matched step implementations.
"""
if cover_min_percentage is not None and float(cover_min_percentage) > 100:
sys.stderr.write(
str(
colorful.magenta(
"You are a little cocky to think you can reach a minimum coverage of {0:.2f}%\n".format(
float(cover_min_percentage)
)
)
)
)
return 3
# load user's custom python files
for basedir in basedirs:
load_modules(basedir)
steps = StepRegistry().steps
if not steps:
sys.stderr.write(
str(
colorful.magenta(
"No step implementations found in {0}, thus doesn't make sense to continue".format(
basedirs
)
)
)
)
return 4
failed = 0
passed = 0
covered_steps = set()
for match_config_file in match_config_files:
# load the given match config file
with codecs.open(match_config_file, "r", "utf-8") as f:
match_config = yaml.safe_load(f)
if not match_config:
print(
colorful.magenta(
"No sentences found in {0} to test against".format(
match_config_file
)
)
)
return 5
print(
colorful.yellow(
"Testing sentences from {0}:".format(
colorful.bold_yellow(match_config_file)
)
)
)
failed_sentences, passed_senteces = test_step_matches(match_config, steps)
failed += failed_sentences
passed += passed_senteces
covered_steps = covered_steps.union(
x["should_match"] for x in match_config if "should_match" in x
)
# newline
sys.stdout.write("\n")
report = colorful.bold_white("{0} sentences (".format(failed + passed))
if passed > 0:
report += colorful.bold_green("{0} passed".format(passed))
if passed > 0 and failed > 0:
report += colorful.bold_white(", ")
if failed > 0:
report += colorful.bold_red("{0} failed".format(failed))
report += colorful.bold_white(")")
print(report)
step_coverage = 100.0 / len(steps) * len(covered_steps)
coverage_report = colorful.bold_white(
"Covered {0} of {1} step implementations".format(len(covered_steps), len(steps))
)
ret = 0 if failed == 0 else 1
if cover_min_percentage:
coverage_color = (
colorful.bold_green
if step_coverage >= float(cover_min_percentage)
else colorful.bold_red
)
coverage_report += colorful.bold_white(" (coverage: ")
coverage_report += coverage_color("{0:.2f}%".format(step_coverage))
if float(cover_min_percentage) > step_coverage:
coverage_report += colorful.bold_white(
", expected a minimum of {0}".format(
colorful.bold_green(cover_min_percentage + "%")
)
)
if failed == 0:
ret = 2
# if tests have passed and coverage is too low we fail with exit code 2
coverage_report += colorful.bold_white(")")
print(coverage_report)
if cover_show_missing:
missing_steps = get_missing_steps(steps, covered_steps)
if missing_steps:
missing_step_report = colorful.bold_yellow("Missing steps:\n")
for step in missing_steps:
missing_step_report += "- {0} at ".format(colorful.cyan(step[0]))
missing_step_report += colorful.cyan(step[1]) + "\n"
sys.stdout.write(missing_step_report)
return ret
def inspect_tree(root_path=CURRENT_PATH,
options={},
level=ROOT_LEVEL,
**kwargs):
options = dict(options or {}, **kwargs)
indent = options.get('indent', None)
silent = options.get('silent', None)
if silent != False:
silent = bool(silent) or DEFAULT_SILENT
if not indent == False:
indent = bool(indent) or DEFAULT_INDENT
else:
indent = 0
output = ''
try:
if (level == ROOT_LEVEL):
root_item_name = color.darkGray(root_path)
output += '\n'
output += root_item_name
items = None
try:
items = get_tree(root_path, dict(options, **dict(silent=False)))
if items is None:
raise Error(
'Could not get file system tree object: {0}'.format(
root_path))
except Exception as error:
raise error
prefix = None
item_name = None
item_output = None
item_count = len(items)
last_item = items[-1]
for item in items:
prefix = indent * level * SPACE
if item == last_item:
prefix += color.darkGray(BRANCH_ITEM_PREFIX_LAST)
else:
prefix += color.darkGray(BRANCH_ITEM_PREFIX)
if item.is_directory:
if item.is_link:
item_name = SPACE.join([
str(color.bold_white(item.name)),
str(color.darkGray(BRANCH_ITEM_LINK_SUFFIX)),
str(color.darkGray(item.resolved_relative_path)),
str(item.meta),
])
else:
item_name = SPACE.join([
str(color.bold_white(item.name)),
str(item.meta),
])
elif item.is_file:
if item.is_link:
item_name = SPACE.join([
str(color.white(item.name)),
str(color.darkGray(BRANCH_ITEM_LINK_SUFFIX)),
str(color.darkGray(item.resolved_relative_path)),
str(item.meta),
])
else:
item_name = SPACE.join([
str(color.white(item.name)),
str(item.meta),
])
else:
if item.is_link:
item_name = SPACE.join([
str(color.red(item.name)),
str(color.darkGray(BRANCH_ITEM_LINK_SUFFIX)),
str(color.darkGray(BRANCH_ITEM_LINK_BROKEN)),
str(item.meta),
])
else:
item_name = SPACE.join([
str(color.red(item.name)),
str(item.meta),
])
output += '\n'
output += prefix
output += item_name # BUG: unicode issue in Python 2
if item.children:
try:
item_output = inspect_tree(item.path, options, level + 1)
except Exception as error:
pass
if isinstance(item_output, str):
output += item_output
if (level == ROOT_LEVEL):
output += '\n\n'
return output
except Exception as error:
if not silent:
raise error
output += '\n\n'
output += ' {0}'.format(color.red(str(error).split(' - {')[0]))
output += '\n\n'
return output
def console_write(self, features, marker):
"""
Writes the endreport for all features
:param list features: all features
"""
stats = {
"features": {
"amount": 0,
"passed": 0,
"failed": 0,
"skipped": 0,
"untested": 0,
"pending": 0,
},
"scenarios": {
"amount": 0,
"passed": 0,
"failed": 0,
"skipped": 0,
"untested": 0,
"pending": 0,
},
"steps": {
"amount": 0,
"passed": 0,
"failed": 0,
"skipped": 0,
"untested": 0,
"pending": 0,
},
}
pending_steps = []
duration = timedelta()
for feature in features:
if not feature.has_to_run(world.config.scenarios):
continue
stats["features"]["amount"] += 1
stats["features"][feature.state] += 1
if feature.state in [Step.State.PASSED, Step.State.FAILED]:
duration += feature.duration
for scenario in feature.all_scenarios:
if not scenario.has_to_run(world.config.scenarios):
continue
if isinstance(scenario, ScenarioOutline): # skip ScenarioOutlines
continue
if isinstance(scenario, ScenarioLoop): # skip ScenarioLoop
continue
stats["scenarios"]["amount"] += 1
stats["scenarios"][scenario.state] += 1
for step in scenario.steps:
stats["steps"]["amount"] += 1
stats["steps"][step.state] += 1
if step.state == Step.State.PENDING:
pending_steps.append(step)
colored_closing_paren = colorful.bold_white(")")
colored_comma = colorful.bold_white(", ")
passed_word = colorful.bold_green("{0} passed")
failed_word = colorful.bold_red("{0} failed")
skipped_word = colorful.cyan("{0} skipped")
pending_word = colorful.bold_yellow("{0} pending")
output = colorful.bold_white(
"{0} features (".format(stats["features"]["amount"])
)
output += passed_word.format(stats["features"]["passed"])
if stats["features"]["failed"]:
output += colored_comma + failed_word.format(stats["features"]["failed"])
if stats["features"]["skipped"]:
output += colored_comma + skipped_word.format(stats["features"]["skipped"])
if stats["features"]["pending"]:
output += colored_comma + pending_word.format(stats["features"]["pending"])
output += colored_closing_paren
output += "\n"
output += colorful.bold_white(
"{} scenarios (".format(stats["scenarios"]["amount"])
)
output += passed_word.format(stats["scenarios"]["passed"])
if stats["scenarios"]["failed"]:
output += colored_comma + failed_word.format(stats["scenarios"]["failed"])
if stats["scenarios"]["skipped"]:
output += colored_comma + skipped_word.format(stats["scenarios"]["skipped"])
if stats["scenarios"]["pending"]:
output += colored_comma + pending_word.format(stats["scenarios"]["pending"])
output += colored_closing_paren
output += "\n"
output += colorful.bold_white("{} steps (".format(stats["steps"]["amount"]))
output += passed_word.format(stats["steps"]["passed"])
if stats["steps"]["failed"]:
output += colored_comma + failed_word.format(stats["steps"]["failed"])
if stats["steps"]["skipped"]:
output += colored_comma + skipped_word.format(stats["steps"]["skipped"])
if stats["steps"]["pending"]:
output += colored_comma + pending_word.format(stats["steps"]["pending"])
output += colored_closing_paren
if pending_steps:
sr = StepRegistry()
pending_step_implementations = make_unique_obj_list(
pending_steps, lambda x: x.definition_func
)
output += colorful.white(
"\nYou have {0} pending step implementation{1} affecting {2} step{3}:\n {4}\n\nNote: this could be the reason for some failing subsequent steps".format(
len(pending_step_implementations),
"s" if len(pending_step_implementations) is not 1 else "",
len(pending_steps),
"s" if len(pending_steps) is not 1 else "",
"\n ".join(
[
"- '{0}' @ {1}".format(
sr.get_pattern(s.definition_func),
get_func_code(s.definition_func).co_filename,
)
for s in pending_step_implementations
]
),
)
)
output += "\n"
if world.config.wip:
if stats["scenarios"]["passed"] > 0:
output += colorful.red(
"\nThe --wip switch was used, so I didn't expect anything to pass. These scenarios passed:\n"
)
has_passed_scenarios = False
for feature in features:
passed_scenarios = list(
filter(
lambda s: s.state == Step.State.PASSED,
feature.all_scenarios,
)
)
for scenario in passed_scenarios:
output += colorful.red(
"\n - {}: {}".format(feature.path, scenario.sentence)
)
has_passed_scenarios = True
if has_passed_scenarios:
output += "\n"
else:
output += colorful.green(
"\nThe --wip switch was used, so the failures were expected. All is good.\n"
)
output += colorful.cyan(
"Run {0} finished within {1}".format(
marker, humanize.naturaldelta(duration)
)
)
write(output)
def format_integer(i: int) -> str:
s = '{i:+d}'.format(i=i)
if i == 0:
return s
else:
return cf.bold_white(s)
def console_writer_after_each_scenario(self, scenario):
"""
If the scenario is a ExampleScenario it will write the Examples header
:param Scenario scenario: the scenario which was ran.
"""
output = ""
if isinstance(scenario, ScenarioOutline):
output += u"\n {0}:\n".format(
colorful.bold_white(scenario.example_keyword))
output += colorful.bold_white(u" {0}| {1} |".format(
self.get_id_padding(len(scenario.scenarios), offset=2),
u" | ".join("{1: <{0}}".format(scenario.get_column_width(i), x)
for i, x in enumerate(scenario.examples_header))))
elif isinstance(scenario, ScenarioLoop):
output += u"\n {0}: {1}".format(
colorful.bold_white(scenario.iterations_keyword),
colorful.cyan(scenario.iterations))
elif isinstance(scenario.parent, ScenarioOutline):
colored_pipe = colorful.bold_white("|")
color_func = self.get_color_func(scenario.state)
output += u"{0} {1}{2} {3} {2}".format(
self.get_line_jump_seq(),
self.get_id_sentence_prefix(scenario, colorful.bold_cyan,
len(scenario.parent.scenarios)),
colored_pipe, (u" {0} ").format(colored_pipe).join(
str(
color_func(u"{1: <{0}}".format(
scenario.parent.get_column_width(i), x)))
for i, x in enumerate(scenario.example.data)))
if scenario.state == Step.State.FAILED:
failed_step = scenario.failed_step
if world.config.with_traceback:
output += u"\n {0}{1}".format(
self.get_id_padding(len(scenario.parent.scenarios)),
"\n ".join([
str(colorful.red(l)) for l in
failed_step.failure.traceback.split("\n")[:-2]
]))
output += u"\n {0}{1}: {2}".format(
self.get_id_padding(len(scenario.parent.scenarios)),
colorful.bold_red(failed_step.failure.name),
colorful.red(failed_step.failure.reason))
elif isinstance(scenario.parent, ScenarioLoop):
colored_pipe = colorful.bold_white("|")
color_func = self.get_color_func(scenario.state)
output += u"{0} {1}{2} {3: <18} {2}".format(
self.get_line_jump_seq(),
self.get_id_sentence_prefix(scenario, colorful.bold_cyan,
len(scenario.parent.scenarios)),
colored_pipe, str(color_func(scenario.iteration)))
if scenario.state == Step.State.FAILED:
failed_step = scenario.failed_step
if world.config.with_traceback:
output += u"\n {0}{1}".format(
self.get_id_padding(len(scenario.parent.scenarios)),
"\n ".join([
str(colorful.red(l)) for l in
failed_step.failure.traceback.split("\n")[:-2]
]))
output += u"\n {0}{1}: {2}".format(
self.get_id_padding(len(scenario.parent.scenarios)),
colorful.bold_red(failed_step.failure.name),
colorful.red(failed_step.failure.reason))
if output:
write(output)
def console_writer_after_each_step(self, step):
"""
Writes the step to the console after it was run
:param Step step: the step to write to the console
"""
if not isinstance(step.parent.parent, Feature):
return
color_func = self.get_color_func(step.state)
line_jump_seq = self.get_line_jump_seq() * (
((len(step.raw_text) + 3) if step.text else 1) +
(len(step.table) + 1 if step.table_header else 0))
output = u'{0} '.format(line_jump_seq)
if isinstance(step.parent, ScenarioOutline):
# Highlight ScenarioOutline placeholders e.g. '<method>'
output += (u''.join(
str(
colorful.white(item) if (
self._placeholder_regex.search(item)
and item.strip('<>') in step.parent.examples_header
) else color_func(item))
for item in self._placeholder_regex.split(step.sentence)))
else:
output += u"{0}{1}".format(
self.get_id_sentence_prefix(step, colorful.bold_cyan),
color_func(step.sentence))
if step.text:
id_padding = self.get_id_padding(len(step.parent.steps))
output += colorful.bold_white(
u'\n {0}"""'.format(id_padding))
output += colorful.cyan(u"".join([
"\n {0}{1}".format(id_padding, l)
for l in step.raw_text
]))
output += colorful.bold_white(
u'\n {0}"""'.format(id_padding))
if step.table_header:
colored_pipe = colorful.bold_white("|")
col_widths = self.get_table_col_widths([step.table_header] +
step.table_data)
# output table header
output += u"\n {0} {1} {0}".format(
colored_pipe, (" {0} ").format(colored_pipe).join(
str(colorful.white(u"{1: <{0}}".format(col_widths[i], x)))
for i, x in enumerate(step.table_header)))
# output table data
for row in step.table_data:
output += u"\n {0} {1} {0}".format(
colored_pipe, (" {0} ").format(colored_pipe).join(
str(color_func(u"{1: <{0}}".format(col_widths[i], x)))
for i, x in enumerate(row)))
if step.state == step.State.FAILED:
if world.config.with_traceback:
output += u"\n {0}{1}".format(
self.get_id_padding(len(step.parent.steps) - 2),
"\n ".join([
str(colorful.red(l))
for l in step.failure.traceback.split("\n")[:-2]
]))
output += u"\n {0}{1}: {2}".format(
self.get_id_padding(len(step.parent.steps) - 2),
colorful.bold_red(step.failure.name),
colorful.red(step.failure.reason))
write(output)
def write_feature_header(self, feature):
print(cf.bold_white(str(feature.path)) + ":", end=" ", flush=True)
def test_step_matches_configs(match_config_files,
basedirs,
cover_min_percentage=None,
cover_show_missing=False):
"""
Test if the given match config files matches the actual
matched step implementations.
"""
if cover_min_percentage is not None and float(cover_min_percentage) > 100:
sys.stderr.write(
str(
colorful.magenta(
'You are a little cocky to think you can reach a minimum coverage of {0:.2f}%\n'
.format(float(cover_min_percentage)))))
return 3
# load user's custom python files
for basedir in basedirs:
load_modules(basedir)
steps = StepRegistry().steps
if not steps:
sys.stderr.write(
str(
colorful.magenta(
'No step implementations found in {0}, thus doesn\'t make sense to continue'
.format(basedirs))))
return 4
failed = 0
passed = 0
covered_steps = set()
for match_config_file in match_config_files:
# load the given match config file
with codecs.open(match_config_file, "r", "utf-8") as f:
match_config = yaml.safe_load(f)
if not match_config:
print(
colorful.magenta(
'No sentences found in {0} to test against'.format(
match_config_file)))
return 5
print(
colorful.yellow('Testing sentences from {0}:'.format(
colorful.bold_yellow(match_config_file))))
failed_sentences, passed_senteces = test_step_matches(
match_config, steps)
failed += failed_sentences
passed += passed_senteces
covered_steps = covered_steps.union(x['should_match']
for x in match_config
if 'should_match' in x)
# newline
sys.stdout.write('\n')
report = colorful.bold_white('{0} sentences ('.format(failed + passed))
if passed > 0:
report += colorful.bold_green('{0} passed'.format(passed))
if passed > 0 and failed > 0:
report += colorful.bold_white(', ')
if failed > 0:
report += colorful.bold_red('{0} failed'.format(failed))
report += colorful.bold_white(')')
print(report)
step_coverage = 100.0 / len(steps) * len(covered_steps)
coverage_report = colorful.bold_white(
'Covered {0} of {1} step implementations'.format(
len(covered_steps), len(steps)))
ret = 0 if failed == 0 else 1
if cover_min_percentage:
coverage_color = colorful.bold_green if step_coverage >= float(
cover_min_percentage) else colorful.bold_red
coverage_report += colorful.bold_white(' (coverage: ')
coverage_report += coverage_color('{0:.2f}%'.format(step_coverage))
if float(cover_min_percentage) > step_coverage:
coverage_report += colorful.bold_white(
', expected a minimum of {0}'.format(
colorful.bold_green(cover_min_percentage + '%')))
if failed == 0:
ret = 2
# if tests have passed and coverage is too low we fail with exit code 2
coverage_report += colorful.bold_white(')')
print(coverage_report)
if cover_show_missing:
missing_steps = get_missing_steps(steps, covered_steps)
if missing_steps:
missing_step_report = colorful.bold_yellow('Missing steps:\n')
for step in missing_steps:
missing_step_report += '- {0} at '.format(
colorful.cyan(step[0]))
missing_step_report += colorful.cyan(step[1]) + '\n'
sys.stdout.write(missing_step_report)
return ret
def main():
args = docopt(__doc__)
# check if file exits
if not os.path.exists(args["FILE"]):
print(cf.red("{} doesn't exist\n".format(args["FILE"])))
exit(1)
# create the output file
of = args["-o"]
open(of, "w").close()
f = open(args["FILE"])
grammar = f.read()
f.close()
# clear console
clear()
# print banner
print(cf.yellow_bold(BANNER))
print(cf.bold_white("Input Grammar:\n"))
pgrammar = gm.parse(grammar)
orignal = pgrammar
gm.pprint(pgrammar)
print()
write_to_output(of, "Input Grammar", gm.str_pgrammar(pgrammar))
choices = [
"Remove Null Productions",
"Remove Unit Productions",
"Remove Left Recursion",
"First Sets",
"Follow Sets",
"Parsing Table",
]
misc_choices = [
"Restore Original Grammar",
"Print Current Grammar",
"Clear",
"Exit",
]
question = {
"type": "list",
"name": "ops",
"message": "Which operation would you like to perform?",
"choices": choices + [Separator()] + misc_choices,
}
reuse_confirm = {
"type": "confirm",
"name": "last_grammar",
"message": "Use this grammar output for subsequent operations?",
"default": True,
}
reverse_confirm = {
"type": "confirm",
"name": "reverse_grammar",
"message": "Reverse Non-Terminal ordering?",
"default": True,
}
start_input = {
"type": "input",
"name": "start_sym",
"message": "Enter Start Symbol:",
}
# will contain the last output
output = None
# if last output was a grammar (as opposed to follow sets)
output_grammar = False
while True:
answer = prompt(question)
choice = answer["ops"]
if choice == misc_choices[0]:
pgrammar = orignal
print(cf.white_bold("\nRestored\n"))
gm.pprint(pgrammar)
print()
write_to_output(of, choice, gm.str_pgrammar(pgrammar))
continue
elif choice == misc_choices[1]:
print()
gm.pprint(pgrammar)
print()
continue
elif choice == misc_choices[2]:
clear()
continue
if choice == misc_choices[3]:
print(cf.cyan("Bye!"))
print("Remember! Logs are saved in", of)
print()
break
# --------
if choice == choices[0]:
output = elim_null(pgrammar)
elif choice == choices[1]:
output = elim_unit(pgrammar)
output = remove_same_rules(output, False, False)
elif choice == choices[2]:
continuel = False
for rule in pgrammar.values():
if "eps" in rule:
print(
cf.red(
"\nGrammar contains null productions. This operation can't"
" be performed\n"))
continuel = True
break
if continuel:
continue
answer = prompt(reverse_confirm)
reverse = answer["reverse_grammar"]
if reverse:
print(
"\nReversing the order of non-terminals for Left Recursion Removal."
)
ng = gm.reverse_grammar(pgrammar)
else:
ng = pgrammar
ng = elim_lr(ng)
if reverse:
ng = gm.reverse_grammar(ng)
output = ng
elif choice == choices[3]:
fs = first_sets(pgrammar)
output = fs
elif choice == choices[4]:
start_input["validate"] = lambda x: x in pgrammar.keys()
answer = prompt(start_input)
fs = first_sets(pgrammar)
fls = follow_sets(answer["start_sym"], pgrammar, fs)
output = fls
elif choice == choices[5]:
start_input["validate"] = lambda x: x in pgrammar.keys()
answer = prompt(start_input)
fs = first_sets(pgrammar)
fls = follow_sets(answer["start_sym"], pgrammar, fs)
output = parsing_table(pgrammar, fs, fls)
if choice != choices[5]:
# flag to check if the last operation output a pgrammar
# only the first 3 operations output a grammar
output_grammar = choices.index(choice) in range(3)
# print output
print(cf.bold_green("\n=>\n"))
(gm.pprint if output_grammar else gm.set_print)(output)
# log to the output file
write_to_output(
of,
choice,
(gm.str_pgrammar if output_grammar else gm.str_set)(output),
)
print()
# ask to use grammar from last operation
if output_grammar:
answer = prompt(reuse_confirm)
if answer["last_grammar"]:
pgrammar = output
else:
# print parsing table
print("\n" + output + "\n")
write_to_output(
of,
choice,
output,
)
# import termcolor
# string = "type-name-function-location"
# string = string.replace('-', termcolor.colored('-', 'red'))
# print (string)
import colorful as cf
# create a colored string using clever method translation
print(cf.bold_white('Hello World'))
# create a colored string using `str.format()`
print('{c.bold}{c.lightCoral_on_white}Hello World{c.reset}'.format(c=cf))
# nest colors
print(cf.red('red {0} red'.format(cf.white('white'))))
print(cf.red('red' + cf.white(' white ', nested=True) + 'red'))
# combine styles with strings
print(cf.bold & cf.red | 'Hello World')
# use true colors
cf.use_true_colors()
# extend default color palette
cf.update_palette({'mint': '#c5e8c8'})
print(cf.mint_on_snow('Wow, this is actually mint'))
# choose a predefined style
cf.use_style('solarized')
# print the official solarized colors
def main():
args = parser.parse_args()
logger = setup_logger()
## Use below for slurm setting.
# slurm_job_id = os.getenv('SLURM_JOB_ID', 'nojobid')
# slurm_proc_id = os.getenv('SLURM_PROC_ID', None)
# unique_identifier = str(slurm_job_id)
# if slurm_proc_id is not None:
# unique_identifier = unique_identifier + "_" + str(slurm_proc_id)
unique_identifier = ''
# Load config
config_path = args.config
episode_path = args.episode
if args.resume_ckpt and not args.config:
base_dir = os.path.dirname(os.path.dirname(args.resume_ckpt))
config_path = os.path.join(base_dir, 'config.yaml')
episode_path = os.path.join(base_dir, 'episode.yaml')
config = yaml.load(open(config_path), Loader=yaml.FullLoader)
episode = yaml.load(open(episode_path), Loader=yaml.FullLoader)
config['data_schedule'] = episode
# Override options
for option in args.override.split('|'):
if not option:
continue
address, value = option.split('=')
keys = address.split('.')
here = config
for key in keys[:-1]:
if key not in here:
raise ValueError('{} is not defined in config file. '
'Failed to override.'.format(address))
here = here[key]
if keys[-1] not in here:
raise ValueError('{} is not defined in config file. '
'Failed to override.'.format(address))
here[keys[-1]] = yaml.load(value, Loader=yaml.FullLoader)
# Set log directory
config['log_dir'] = os.path.join(args.log_dir, unique_identifier)
if not args.resume_ckpt and os.path.exists(config['log_dir']):
logger.warning('%s already exists' % config['log_dir'])
input('Press enter to continue')
# print the configuration
print(colorful.bold_white("configuration:").styled_string)
pprint(config)
print(colorful.bold_white("configuration end").styled_string)
if args.resume_ckpt and not args.log_dir:
config['log_dir'] = os.path.dirname(
os.path.dirname(args.resume_ckpt)
)
# Save config
os.makedirs(config['log_dir'], mode=0o755, exist_ok=True)
if not args.resume_ckpt or args.config:
config_save_path = os.path.join(config['log_dir'], 'config.yaml')
episode_save_path = os.path.join(config['log_dir'], 'episode.yaml')
yaml.dump(config, open(config_save_path, 'w'))
yaml.dump(episode, open(episode_save_path, 'w'))
print(colorful.bold_yellow('config & episode saved to {}'.format(config['log_dir'])).styled_string)
# Build components
data_scheduler = DataScheduler(config)
writer = SummaryWriter(config['log_dir'])
model = MODEL[config['model_name']](config, writer)
if args.resume_ckpt:
model.load_state_dict(torch.load(args.resume_ckpt))
model.to(config['device'])
train_model(config, model, data_scheduler, writer)
print(colorful.bold_white("\nThank you and Good Job Computer").styled_string)
