def list_jobs(filter_prj=None, filter_cmd=None, by_id=None): db_results = [] if by_id: job = rms_db.get(doc_id=by_id) if job: db_results.append(rms_db.get(doc_id=by_id)) else: print(colorful.bold_red(f" no job with id {by_id} found")) else: db_results = rms_db.all() if filter_cmd: db_results = rms_db.search(Query()["<command>"] == filter_cmd) if filter_prj: db_results = [r for r in db_results if filter_prj in r["<project_code>"]] if db_results: print(colorful.cyan("id".rjust(6)), colorful.cyan("project_code".ljust(18)), colorful.cyan("command".ljust(14)), colorful.cyan("start_time".rjust(12)), colorful.cyan("timeout".rjust(8)), ) for job in db_results: job_id = job.doc_id job_timeout = job.get("timeout") if not job_timeout: job_timeout = 60 print(str(job_id).rjust(6), job["<project_code>"].ljust(18), job["<command>"].ljust(14), job[">start_time"].rjust(12), str(job_timeout).rjust(8), ) else: print(colorful.bold_red(" no matching entries found."))
def test_step_not_match(sentence, expected_not_matching_step, steps): step_to_print = ( colorful.cyan(expected_not_matching_step) if expected_not_matching_step else "ANY" ) sys.stdout.write( '{0} STEP "{1}" SHOULD NOT MATCH {2} '.format( colorful.yellow(">>"), colorful.cyan(sentence), step_to_print ) ) result = match_step(sentence, steps) if result: if ( not expected_not_matching_step or result.func.__name__ == expected_not_matching_step ): output_failure( None, [ "Expected sentence did match {0} but it shouldn't".format( expected_not_matching_step ) ], ) return False print(u(colorful.bold_green("✔"))) return True
def test_step_match(sentence, expected_step, expected_arguments, steps): sys.stdout.write('{0} STEP "{1}" SHOULD MATCH {2} '.format( colorful.yellow('>>'), colorful.cyan(sentence), colorful.cyan(expected_step))) result = match_step(sentence, steps) if not result: output_failure( None, ['Expected sentence didn\'t match any step implementation']) return False if expected_step != result.func.__name__: output_failure(result.func, [ 'Expected sentence matched {0} instead of {1}'.format( result.func.__name__, expected_step) ]) return False if expected_arguments: arguments = merge_step_args(result) expected_arguments = { k: v for expected_arguments in expected_arguments for k, v in expected_arguments.items() } argument_errors = check_step_arguments(expected_arguments, arguments) if argument_errors: output_failure(result.func, argument_errors) return False print(u(colorful.bold_green(u'✔'))) return True
def test_step_matches(match_config, steps): """ Test if the given match config matches the actual matched step implementations. """ failed = 0 passed = 0 for item in match_config: validate_config_item(item) sentence = item['sentence'] expected_step = item['should_match'] sys.stdout.write('{0} STEP "{1}" SHOULD MATCH {2} '.format( colorful.yellow('>>'), colorful.cyan(sentence), colorful.cyan(expected_step))) result = match_step(item['sentence'], steps) if not result: output_failure( None, ['Expected sentence didn\'t match any step implementation']) failed += 1 continue if expected_step != result.func.__name__: output_failure(result.func, [ 'Expected sentence matched {0} instead of {1}'.format( result.func.__name__, expected_step) ]) failed += 1 continue expected_arguments = item.get('with_arguments') if expected_arguments: arguments = merge_step_args(result) expected_arguments = { k: v for expected_arguments in expected_arguments for k, v in expected_arguments.items() } argument_errors = check_step_arguments(expected_arguments, arguments) if argument_errors: output_failure(result.func, argument_errors) failed += 1 continue # check if arguments match print(u(colorful.bold_green(u'✔'))) passed += 1 return failed, passed
def show(): """ Show the modifiers and colors """ # modifiers sys.stdout.write(colorful.bold('bold') + ' ') sys.stdout.write(colorful.dimmed('dimmed') + ' ') sys.stdout.write(colorful.italic('italic') + ' ') sys.stdout.write(colorful.underlined('underlined') + ' ') sys.stdout.write(colorful.inversed('inversed') + ' ') sys.stdout.write(colorful.concealed('concealed') + ' ') sys.stdout.write(colorful.struckthrough('struckthrough') + '\n') # foreground colors sys.stdout.write(colorful.red('red') + ' ') sys.stdout.write(colorful.green('green') + ' ') sys.stdout.write(colorful.yellow('yellow') + ' ') sys.stdout.write(colorful.blue('blue') + ' ') sys.stdout.write(colorful.magenta('magenta') + ' ') sys.stdout.write(colorful.cyan('cyan') + ' ') sys.stdout.write(colorful.white('white') + '\n') # background colors sys.stdout.write(colorful.on_red('red') + ' ') sys.stdout.write(colorful.on_green('green') + ' ') sys.stdout.write(colorful.on_yellow('yellow') + ' ') sys.stdout.write(colorful.on_blue('blue') + ' ') sys.stdout.write(colorful.on_magenta('magenta') + ' ') sys.stdout.write(colorful.on_cyan('cyan') + ' ') sys.stdout.write(colorful.on_white('white') + '\n')
def first_run_tui(): ''' first setups and creating key's and personal passwords ''' import os if (platform.system() == "Darwin"): pass if (platform.system() == "Windows"): os.system("pip install -r requirements.txt") # pass if (platform.system() == "Linux"): pass from cryptography.fernet import Fernet cryptocut_art = text2art("cRYPTOcUT", "confused3") setup_art = text2art("setup") print('\n', cf.green(cryptocut_art)) print(cf.cyan(setup_art)) user_pass = input( cf.yellow("enter your password for symmetric encryption : ")) user_key = (create_user_key(user_pass)) # generate a random secret for user using crypto lib fernet = Fernet(user_key) random_key = Fernet.generate_key() symmetric_key = fernet.encrypt(random_key) # write the random secret as symmetric_key in symmetric.key # TODO : we can use a diffrent path for this with open("symmetric.key", "wb") as key_file: key_file.write(symmetric_key) print(cf.green("done! \nsuccessfully initialized the symmetric key"))
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 test_step_not_match(sentence, expected_not_matching_step, steps): step_to_print = colorful.cyan( expected_not_matching_step) if expected_not_matching_step else 'ANY' sys.stdout.write('{0} STEP "{1}" SHOULD NOT MATCH {2} '.format( colorful.yellow('>>'), colorful.cyan(sentence), step_to_print)) result = match_step(sentence, steps) if result: if not expected_not_matching_step or result.func.__name__ == expected_not_matching_step: output_failure(None, [ 'Expected sentence did match {0} but it shouldn\'t'.format( expected_not_matching_step) ]) return False print(u(colorful.bold_green(u'✔'))) return True
def main(): """Converts a given url with the specified arguments.""" options = get_options() cf.use_style("solarized") if options["nocolor"]: cf.disable() newline() header("Thumbor v%s (of %s)" % (__version__, __release_date__)) newline() print( "Thumbor doctor will analyze your install and verify if everything is working as expected." ) errors = check_modules() errors += check_compiled_extensions() errors += check_filters() errors += check_extensions() newline() if errors: print( cf.bold_red( "😞 Oh no! We found some things that could improve... 😞")) newline() print("\n".join(["* %s" % str(err) for err in errors])) newline() newline() print( cf.cyan( "If you don't know how to fix them, please open an issue with thumbor." )) print( cf.cyan( "Don't forget to copy this log and add it to the description of your issue." )) print("Open an issue at https://github.com/thumbor/thumbor/issues/new") sys.exit(1) return print(cf.bold_green("🎉 Congratulations! No errors found! 🎉"))
def labeled_value(self, key, msg, *args, **kwargs): """Displays a key-value pair with special formatting. Args: key (str): Label that is prepended to the message. For other arguments, see `_format_msg`. """ self._print( cf.cyan(key) + ": " + _format_msg(cf.bold(msg), *args, **kwargs))
def format(self, record): levelname = record.levelname if levelname in ('NOTSET', 'DEBUG'): record.levelname = colorful.cyan(levelname) elif levelname in ('INFO', ): record.levelname = colorful.green(levelname) elif levelname in ('WARNING', ): record.levelname = colorful.bold_yellow(levelname) elif levelname in ('ERROR', 'CRITICAL'): record.levelname = colorful.bold_red(levelname) return logging.Formatter.format(self, record)
def test_step_not_match(sentence, expected_not_matching_step, steps): step_to_print = (colorful.cyan(expected_not_matching_step) if expected_not_matching_step else "ANY") sys.stdout.write('{0} STEP "{1}" SHOULD NOT MATCH {2} '.format( colorful.yellow(">>"), colorful.cyan(sentence), step_to_print)) result = match_step(sentence, steps) if result: if (not expected_not_matching_step or result.func.__name__ == expected_not_matching_step): output_failure( None, [ "Expected sentence did match {0} but it shouldn't".format( expected_not_matching_step) ], ) return False print(u(colorful.bold_green("✔"))) return True
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 _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 test_evaluate_deck(): set_infos = load_card_csv() for test_number, (expected_performance, test_deck) in enumerate(load_test_cases(), start=1): print( colorful.dimmed_blue(f'Evaluating test deck {test_number} ') + colorful.cyan(f'(Expected to be "{expected_performance}")')) deck_summary = summarize_deck(test_deck, set_infos=set_infos) print(f'Deck summary: {colorful.yellow(deck_summary)}') penalties = evaluate_deck(deck_summary) print(f'Evaluation: {colorful.orange(penalties)}') print(f'Total Penalty: {colorful.bold_red(sum(penalties))}') print()
def test_step_match(sentence, expected_step, expected_arguments, steps): sys.stdout.write( '{0} STEP "{1}" SHOULD MATCH {2} '.format( colorful.yellow(">>"), colorful.cyan(sentence), colorful.cyan(expected_step) ) ) result = match_step(sentence, steps) if not result: output_failure(None, ["Expected sentence didn't match any step implementation"]) return False if expected_step != result.func.__name__: output_failure( result.func, [ "Expected sentence matched {0} instead of {1}".format( result.func.__name__, expected_step ) ], ) return False if expected_arguments: arguments = merge_step_args(result) expected_arguments = { k: v for expected_arguments in expected_arguments for k, v in expected_arguments.items() } argument_errors = check_step_arguments(expected_arguments, arguments) if argument_errors: output_failure(result.func, argument_errors) return False print(u(colorful.bold_green("✔"))) return True
def remove_db_job_by_id(preset=None): """ removes rms job from db by id """ print(" please enter job_id to remove from db") job_id = prompt("> remove_job_by_db_id> ", **sub_prompt_options) job_id = int(job_id) job = rms_db.get(doc_id=job_id) if job: list_jobs(by_id=job_id) cmd_str = serdes(job=job) print(colorful.cyan(" got removed from db")) job = rms_db.remove(doc_ids=[job_id]) else: print(" no job with this id found")
def show_db_job_by_id(preset=None): """ show config details of rms job from db by id """ if not preset: print(" please enter job_id to show details") job_id = prompt("> show_job_by_db_id> ", **sub_prompt_options) job_id = int(job_id) else: job_id = int(preset) job = rms_db.get(doc_id=job_id) if job: list_jobs(by_id=job_id) cmd_str = serdes(job=job) print(colorful.cyan("\n command:")) print(cmd_str) return else: print(" no job with this id found")
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 main(): pa = ArgumentParser() pa.add_argument('location', help='The location to lookup.') pa.add_argument('--unit', help='The unit to be used. Default is Celsius.', default='c', nargs='?', choices=['c', 'f']) pa.add_argument('--log', help='Pass this argument to output logging', default=False, action='store_true', dest='log') pa.add_argument("--start", nargs="?", help="The forecast start") pa.add_argument("--end", nargs="?", help="The forecast end") args = pa.parse_args() weather = Weather(args.unit, args.log) loc = weather.lookup_by_location(args.location) condition = loc.condition print( colorful.bold("Weather report for %s, %s" % (loc.location.city, loc.location.country))) row = PrettyTable() row.field_names = ["Condition", "Temperature"] row.align = 'l' row.add_row([condition.text, condition.temp]) print(row) print(colorful.cyan("Weather Forecasts")) row = PrettyTable() row.field_names = ["Date", "Condition", "High", "Low"] row.align = 'l' start = 0 if not args.start else int(args.start) end = len(loc.forecast) if not args.end else int(args.end) for forecast in loc.forecast[start:end]: row.add_row( [forecast.date, forecast.text, forecast.high, forecast.low]) print(row)
def _row_(self, row: Sequence[Any], left: str = '│', middle: str = '│', right: str = '│', fill: str = ' ', bold: bool = False, odd: int = 0) -> str: columns = [] for index in range(self.size): value = row[index] if isinstance(value, int): cell = str(value).rjust(self.widths[index], fill) value = colorful.cyan(cell) elif isinstance(value, float): cell = f'{value:.2f}'.rjust(self.widths[index], fill) value = (colorful.green if value > 0 else colorful.red)(cell) else: value = str(value).ljust(self.widths[index], fill) columns.append(fill + value + fill) middle = middle.join(columns) if odd: middle = colorful.on_black(middle) return left + middle + right
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, )
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 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 labeled_value(self, key, msg, *args, **kwargs): self._print( cf.cyan(key) + ": " + _format_msg(cf.bold(msg), *args, **kwargs))
def _(value: Union[None, Number], seen: Set[int], show_values: bool = True, indent: int = 0, batch_dims: Optional[Tuple[Optional[int], ...]] = None) -> str: return cf.cyan(str(value)) + "\n"
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 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 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)
from collections import namedtuple import colorful colorful.use_style("solarized") SIZE = 9 LINE_LENGTH = (SIZE * 3) + 3 EMPTY = "-" SHIP = "S" HIT = "H" MISS = "M" SUNK = "Sunk" BOARD_COLOURS = { SHIP: colorful.blue, HIT: colorful.red, MISS: colorful.violet, EMPTY: colorful.base02, "recent": colorful.yellow, } SEPERATOR = " " BOARD_SEPERATOR = colorful.cyan(" --|-- ") PROMPT = colorful.orange(">>> ") START_SHIPS = [7, 5, 4, 4, 3, 2] Point = namedtuple("Point", "x y") Ship = namedtuple("Ship", "position length orientation")
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 print(cf.yellow('yellow'), cf.orange('orange'), cf.red('red'), cf.magenta('magenta'), cf.violet('violet'), cf.blue('blue'), cf.cyan('cyan'), cf.green('green')) # directly print with colors cf.print('{c.bold_blue}Hello World{c.reset}') # choose specific color mode for one block with cf.with_8_ansi_colors() as c: print(c.bold_green('colorful is awesome!')) # create and choose your own color palette MY_COMPANY_PALETTE = { 'companyOrange': '#f4b942', 'companyBaige': '#e8dcc5' } with cf.with_palette(my_company_palette) as c: print(c.companyOrange_on_companyBaige('Thanks for choosing our product!'))
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 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 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 add_keyboards(config): for key, value in config["keyboards"].items(): logger.info("Running script to add keyboard for keyboard " + colorful.cyan(key) + "...") print("") # Padding system("cd " + getcwd() + " && python3 -m " + MODULE_NAME + " add " + key) print("") # Padding
def debug(self, text): if not self.silent and self.isDebug: print( colorful.magenta(self.name) + " " + colorful.cyan("debug") + " " + str(text))
def style_prompt(text): return colorful.bold_cyan(f'{text}', nested=True) def style_text(text): return colorful.white(f'{text}', nested=True) def style_highlight(text): return colorful.bold(f'{text}', nested=True) NOT = 'NOT' NEW_LINE = '\n' ARROW = colorful.cyan('>', nested=True) + colorful.cyanLight( '>', nested=True) + style_text('>') def info(text): print(NEW_LINE + style_info(text) + NEW_LINE) def warn(text): print(NEW_LINE + style_warn(text) + NEW_LINE) def error(text): print(NEW_LINE + style_error(text) + NEW_LINE)