def __str__(self): t = Terminal() pos = self.pos text = self.token.value # TODO: lack of bounds check... next_token = self.tokens[pos + 1] msg = ("try inserting '{t.bold}{text}{t.normal}' " "".format_map(locals())) line_tokens = get_token_line(self.pos, self.tokens) if self.insert_after: line = format_line(line_tokens) # Add an extra space BEFORE the insertion point: padding = ' ' * (2 + 1 + self.column) else: # Add an extra space AFTER insertion point; line = format_line(line_tokens, insert_space_before=self.tokens[self.pos]) padding = ' ' * (1 + self.column) arrow = padding + t.bold_green('^') suggestion = padding + t.green(text) return '\n'.join((msg, line, arrow, suggestion))
def print_bugs_and_errors(bugs: Iterable[Bug], errs: Iterable[ValidationError]) -> None: t = Terminal() for bug in bugs: print(t.bold_green("✔ ") + t.green(repr(bug))) for err in errs: model = err.model assert isinstance(model, ModelMetaclass) title = model.schema()["title"] for sub_err in err.errors(): (loc, ) = sub_err["loc"] msg = sub_err["msg"] print(t.bold_red("✘ ") + t.red(f"{title}.{loc}: {msg}"))
cycle = cycle + 1 sleep(1) r_mppt_v = avg_volt / cycle; r_mppt_i = avg_current / cycle; if float(r_mppt_i) > float(current_max): result = t.bold_red('FAILED') elif float(r_mppt_i) < float(current_min): result = t.bold_red('FAILED') elif float(r_mppt_v) > float(voltage_max): result = t.bold_red('FAILED') elif float(r_mppt_v) < float(voltage_min): result = t.bold_red('FAILED') else: result = t.bold_green('PASSED') print 'Franz CH%s @ %sV, %sA....[%s]' %(ch, r_mppt_v, r_mppt_i, result) print '' def config_acs(pfc_path): sleep(5) tom = shell.Shell(pfc_path) sleep(1) sb = shell.Scoreboard(tom,'acs') sleep(1) tom.sendline('power on acs') sleep(3) print sb.query('power_acs_enabled') sleep(1) tom.sendline('acs esc on')
class Cli: def __init__(self): self.data = OrgData.load() self.total_points = 0 self.personal_points = [] self.terminal = Terminal() def run(self): self.list_names() self.print_prompt( "Please enter a person's name and their effort ratings, separated by spaces." ) self.print_prompt( "Add a comma to the end of each line to continue to the next person." ) ratings = self.get_ratings() self.calculate_points(ratings) self.calculate_shares() def list_names(self): text = 'People: ' for (i, person) in enumerate(self.data.people): text += self.terminal.bold_yellow(person['name']) if i < len(self.data.people) - 1: text += ' | ' print(text) def get_ratings(self): ratings = [] while True: input_line = input('<- ') ratings.append(input_line.replace(',', '')) if not input_line.endswith(','): break return ratings def calculate_points(self, ratings): for rating in ratings: frags = rating.split(' ') name = frags[0] standing = list( filter(lambda p: p['name'] == name, self.data.people))[0]['standing'] multiplier = float( list( filter(lambda m: m['name'] == standing, self.data.standings))[0]['rate']) points = sum(list(map(int, frags[1:]))) * multiplier self.personal_points.append((name, points)) self.total_points += points def calculate_shares(self): remainder = 0.0 for person in self.personal_points: share = person[1] / self.total_points * 100 truncated_share = math.trunc(share) remainder += share - truncated_share self.print_result(person[0], truncated_share) self.print_result('Remainder', remainder) def print_prompt(self, prompt): print(self.terminal.italic(prompt)) def print_result(self, label, percentage): left = self.terminal.bold_yellow(f"{label}") right = self.terminal.bold_green(f"{percentage}%") print(left, '->', right)
class ProgressiveResult(TextTestResult): """Test result which updates a progress bar instead of printing dots Nose's ResultProxy will wrap it, and other plugins can still print stuff---but without smashing into my progress bar, care of my Plugin's stderr/out wrapping. """ def __init__(self, cwd, total_tests, stream, config=None): super(ProgressiveResult, self).__init__(stream, None, 0, config=config) self._cwd = cwd self._options = config.options self._term = Terminal(stream=stream, force_styling=config.options.with_styling) if self._term.is_a_tty or self._options.with_bar: # 1 in case test counting failed and returned 0 self.bar = ProgressBar(total_tests or 1, self._term, config.options.bar_filled_color, config.options.bar_empty_color) else: self.bar = NullProgressBar() # Declare errorclass-savviness so ErrorClassPlugins don't monkeypatch # half my methods away: self.errorClasses = {} def startTest(self, test): """Update the progress bar.""" super(ProgressiveResult, self).startTest(test) self.bar.update(nose_selector(test), self.testsRun) def _printTraceback(self, test, err): """Print a nicely formatted traceback. :arg err: exc_info()-style traceback triple :arg test: the test that precipitated this call """ # Don't bind third item to a local var; that can create # circular refs which are expensive to collect. See the # sys.exc_info() docs. exception_type, exception_value = err[:2] # TODO: In Python 3, the traceback is attached to the exception # instance through the __traceback__ attribute. If the instance # is saved in a local variable that persists outside the except # block, the traceback will create a reference cycle with the # current frame and its dictionary of local variables. This will # delay reclaiming dead resources until the next cyclic garbage # collection pass. extracted_tb = extract_relevant_tb( err[2], exception_type, exception_type is test.failureException) test_frame_index = index_of_test_frame( extracted_tb, exception_type, exception_value, test) if test_frame_index: # We have a good guess at which frame is the test, so # trim everything until that. We don't care to see test # framework frames. extracted_tb = extracted_tb[test_frame_index:] with self.bar.dodging(): self.stream.write(''.join( format_traceback( extracted_tb, exception_type, exception_value, self._cwd, self._term, self._options.function_color, self._options.dim_color, self._options.editor, self._options.editor_shortcut_template))) def _printHeadline(self, kind, test, is_failure=True): """Output a 1-line error summary to the stream if appropriate. The line contains the kind of error and the pathname of the test. :arg kind: The (string) type of incident the precipitated this call :arg test: The test that precipitated this call """ if is_failure or self._options.show_advisories: with self.bar.dodging(): self.stream.writeln( '\n' + (self._term.bold if is_failure else '') + '%s: %s' % (kind, nose_selector(test)) + (self._term.normal if is_failure else '')) # end bold def _recordAndPrintHeadline(self, test, error_class, artifact): """Record that an error-like thing occurred, and print a summary. Store ``artifact`` with the record. Return whether the test result is any sort of failure. """ # We duplicate the errorclass handling from super rather than calling # it and monkeying around with showAll flags to keep it from printing # anything. is_error_class = False for cls, (storage, label, is_failure) in self.errorClasses.items(): if isclass(error_class) and issubclass(error_class, cls): if is_failure: test.passed = False storage.append((test, artifact)) is_error_class = True if not is_error_class: self.errors.append((test, artifact)) test.passed = False is_any_failure = not is_error_class or is_failure self._printHeadline(label if is_error_class else 'ERROR', test, is_failure=is_any_failure) return is_any_failure def addSkip(self, test, reason): """Catch skipped tests in Python 2.7 and above. Though ``addSkip()`` is deprecated in the nose plugin API, it is very much not deprecated as a Python 2.7 ``TestResult`` method. In Python 2.7, this will get called instead of ``addError()`` for skips. :arg reason: Text describing why the test was skipped """ self._recordAndPrintHeadline(test, SkipTest, reason) # Python 2.7 users get a little bonus: the reason the test was skipped. if isinstance(reason, Exception): reason = reason.message if reason and self._options.show_advisories: with self.bar.dodging(): self.stream.writeln(reason) def addError(self, test, err): # We don't read this, but some other plugin might conceivably expect it # to be there: excInfo = self._exc_info_to_string(err, test) is_failure = self._recordAndPrintHeadline(test, err[0], excInfo) if is_failure: self._printTraceback(test, err) def addFailure(self, test, err): super(ProgressiveResult, self).addFailure(test, err) self._printHeadline('FAIL', test) self._printTraceback(test, err) def printSummary(self, start, stop): """As a final summary, print number of tests, broken down by result.""" def renderResultType(type, number, is_failure): """Return a rendering like '2 failures'. :arg type: A singular label, like "failure" :arg number: The number of tests with a result of that type :arg is_failure: Whether that type counts as a failure """ # I'd rather hope for the best with plurals than totally punt on # being Englishlike: ret = '%s %s%s' % (number, type, 's' if number != 1 else '') if is_failure and number: ret = self._term.bold(ret) return ret # Summarize the special cases: counts = [('test', self.testsRun, False), ('failure', len(self.failures), True), ('error', len(self.errors), True)] # Support custom errorclasses as well as normal failures and errors. # Lowercase any all-caps labels, but leave the rest alone in case there # are hard-to-read camelCaseWordBreaks. counts.extend([(label.lower() if label.isupper() else label, len(storage), is_failure) for (storage, label, is_failure) in self.errorClasses.values() if len(storage)]) summary = (', '.join(renderResultType(*a) for a in counts) + ' in %.1fs' % (stop - start)) # Erase progress bar. Bash doesn't clear the whole line when printing # the prompt, leaving a piece of the bar. Also, the prompt may not be # at the bottom of the terminal. self.bar.erase() self.stream.writeln() if self.wasSuccessful(): self.stream.write(self._term.bold_green('OK! ')) self.stream.writeln(summary)
class BasePlugin(Cmd): """ BasePlugin - the base class which all of our plugins should inherit from. It is meant to define all the necessary base functions for plugins. """ prompt = '>> ' ruler = '-' intro = banner() terminators = [] CATEGORY_SHELL = to_bold_cyan('Shell Based Operations') CATEGORY_GENERAL = to_bold_cyan('General Commands') def __init__(self): Cmd.__init__(self, startup_script=read_config().get('STARTUP_SCRIPT', ''), use_ipython=True) self.aliases.update({'exit': 'quit', 'help': 'help -v'}) self.hidden_commands.extend([ 'load', 'pyscript', 'set', 'shortcuts', 'alias', 'unalias', 'shell', 'macro' ]) self.t = Terminal() self.selected_client = None self.prompt = self.get_prompt() self.allow_cli_args = False # Alerts Thread self._stop_thread = False self._seen_clients = set(Client.unique_client_ids()) self._alert_thread = Thread() # Register the hook functions self.register_preloop_hook(self._alert_thread_preloop_hook) self.register_postloop_hook(self._alert_thread_postloop_hook) # Set the window title self.set_window_title('<< JSShell 2.0 >>') categorize([ BasePlugin.do_help, BasePlugin.do_quit, BasePlugin.do_py, BasePlugin.do_ipy, BasePlugin.do_history, BasePlugin.do_edit ], BasePlugin.CATEGORY_GENERAL) self.register_postparsing_hook( self._refresh_client_data_post_parse_hook) def _alert_thread_preloop_hook(self) -> None: """ Start the alerter thread """ self._stop_thread = False self._alert_thread = Thread(name='alerter', target=self._alert_function) self._alert_thread.start() def _alert_thread_postloop_hook(self) -> None: """ Stops the alerter thread """ self._stop_thread = True if self._alert_thread.is_alive(): self._alert_thread.join() def _alert_function(self) -> None: """ When the client list is larger than the one we know of alert the user that a new client has registered """ while not self._stop_thread: if self.terminal_lock.acquire(blocking=False): current_clients = set(Client.unique_client_ids()) delta = current_clients - self._seen_clients if len(delta) > 0: self.async_alert( self.t.bold_blue(' << new client registered >>'), self.prompt) self._seen_clients = current_clients self.terminal_lock.release() sleep(0.5) def print_error(self, text: str, end: str = '\n', start: str = '') -> None: """ Prints a formatted error message """ self.poutput(start + self.t.bold_red('[-]') + ' ' + self.t.red(text), end=end) def print_info(self, text: str, end: str = '\n', start: str = '') -> None: """ Prints a formatted informational message """ self.poutput(start + self.t.bold_yellow('[!]') + ' ' + self.t.yellow(text), end=end) def print_ok(self, text: str, end: str = '\n', start: str = '') -> None: """ Prints a formatted success message """ self.poutput(start + self.t.bold_green('[+]') + ' ' + self.t.green(text), end=end) def print_pairs(self, title: str, body: Dict[str, str], just_return: bool = False, colors: bool = True) -> Union[str, None]: """ Prints pairs of values with a certain title """ if colors: data = [self.t.bold_white_underline(title)] else: data = [title] for key, value in body.items(): k = key + ':' if colors: data.append(f' - {self.t.bold(k)} {value}') else: data.append(f' - {k} {value}') if just_return: return '\n'.join(data) self.ppaged('\n'.join(data)) def select_client(self, client: Client) -> None: """ Handles the operation of selecting a new client """ self.selected_client = client self.update_prompt() def _refresh_client_data_post_parse_hook( self, params: PostparsingData) -> PostparsingData: """ Refreshes the selected client data from the database. We do that because of `mongoengine`s behaviour, where if we set the current client, we do not track for modifications. This way, before every command is parsed we re-select the client """ if self.selected_client: cid = self.selected_client.cid self.select_client(Client.objects(cid=cid).first()) return params def get_prompt(self) -> str: """ Handles the operations of getting the prompt string """ prompt = self.t.bold_cyan('>> ') if self.selected_client: client_id = self.t.bold_red(self.selected_client.cid) prompt = self.t.cyan(f"[Client #{client_id}]") + ' ' + prompt return prompt def update_prompt(self) -> None: """ Handles what is needed when updating the prompt """ self.prompt = get_prompt(self)
class Interface: def __init__(self, config_filename): self.config_filename = config_filename self.config = collections.OrderedDict() self.term = Terminal() self.hline = u'\u2500' self.left_up = u'\u250c' self.right_up = u'\u2510' self.left_down = u'\u2514' self.right_down = u'\u2518' self.left_middle = u'\u251c' self.right_middle = u'\u2524' self.vline = u'\u2502' self.TITLE = [ 'SDNProbe: A Lightweight Tool for Securing SDN Data Plane with Active Probing' .center(self.term.width - 2) ] self.MENU = [ 'Show the configure file', 'Generate test packets from topology file', 'Generate topology graph for the controller as input', 'Start probing', 'Exit (or press q)' ] self.menu_pos = 0 def show_menu(self): while True: os.system('clear') print self.left_up + self.hline * (self.term.width - 2) + self.right_up print self.vline + self.term.bold_cyan(self.TITLE[0]) + self.vline print self.left_middle + self.hline * (self.term.width - 2) + self.right_middle for i, menu in enumerate(self.MENU): if i == self.menu_pos: print self.vline + ' ' + self.term.yellow_reverse( '[' + str(i + 1) + '] ' + menu) + ' ' * ( self.term.width - len(menu) - 7) + self.vline else: print self.vline + ' ' + '[' + str( i + 1) + '] ' + menu + ' ' * ( self.term.width - len(menu) - 7) + self.vline print self.left_down + self.hline * (self.term.width - 2) + self.right_down print press = self.getch() if press == 'up': self.menu_pos = (self.menu_pos - 1) % (len(self.MENU)) elif press == 'down': self.menu_pos = (self.menu_pos + 1) % (len(self.MENU)) elif press == 'exit': return 5 elif press == 'enter': return self.menu_pos + 1 def read_config(self): try: with open(self.config_filename, 'r') as f: for line in f: var, val = line.strip().split('=') self.config[var] = val except IOError: self.print_IOError(self.config_filename) exit() except: print self.term.bold_red('[-] Error') exit() def show_config(self): max_var_len = len(max(self.config.keys(), key=len)) max_val_len = len(max(self.config.values(), key=len)) width = max_var_len + 3 + max_val_len + 1 print self.term.bold_green(' [+] Config file: ' + self.config_filename) print ' ' + self.left_up + self.hline * width + self.right_up for var, val in self.config.iteritems(): print ' ' + self.vline + ' ' + var.ljust( max_var_len) + ' = ' + val.ljust(max_val_len) + self.vline print ' ' + self.left_down + self.hline * width + self.right_down self.check_config() self.show_coninue() def generate_test_packets(self): print self.term.bold_green(' [+] Generating test packets from "' + self.config['TOPOLOGY_FILE'] + '"') if not self.check_config(): self.show_coninue() return False print p = Popen(['make', '-C', 'cmodule/'], stdout=PIPE) print self.term.bold_green(' [+] Make file') for line in iter(p.stdout.readline, b''): print self.term.bold_magenta(' ' * 5 + line.strip()) print p = Popen( ['cmodule/./generate_test_packets', self.config['TOPOLOGY_FILE']], stdout=PIPE) print self.term.bold_green(' [+] Start to generate test packets') for line in iter(p.stdout.readline, b''): if line.startswith(' '): print self.term.bold_magenta(' ' * 5 + line.strip()) elif line.strip() == '': pass else: print self.term.bold_green(' [+] ' + line.strip()) self.show_coninue() def generate_topology_graph(self): print self.term.bold_green(' [+] Generating topology graph from "' + self.config['TOPOLOGY_FILE'] + '" and "' + self.config['TOPOLOGY_FILE'] + '.testpackets"') if not self.check_config(): self.show_coninue() return False p = Popen([ 'pymodule/generate_topology_graph.py', '-i', self.config['TOPOLOGY_FILE'] ], stdout=PIPE) for line in iter(p.stdout.readline, b''): print self.term.bold_green(' [+] ' + line.rstrip()) self.show_coninue() def start_probing(self): p = Popen(['ryu-manager', 'pymodule/controller.py'], stdout=PIPE, stderr=PIPE) for line in iter(p.stderr.readline, b''): try: if line.startswith('---'): print self.term.bold_magenta(' [+] ' + line.strip()) elif line.startswith(' '): print self.term.bold_magenta(' ' * 5 + line.strip()) else: print self.term.bold_green(' [+] ' + line.strip()) except: pass print self.show_coninue() def show_exit(self): print self.term.bold_red(' [+] Exit...\n') def show_coninue(self): print print self.term.bold_green(' [+] Press any key to continue...') self.getch() def check_config(self): if not os.path.exists(self.config['TOPOLOGY_FILE']): self.print_IOError(self.config['TOPOLOGY_FILE']) return False return True def print_IOError(self, filename): print self.term.bold_red(' [-] IOError: No such file: ' + filename) def getch(self): def input_key(): fd = sys.stdin.fileno() old_settings = termios.tcgetattr(fd) key = '' try: tty.setraw(sys.stdin.fileno()) ch = sys.stdin.read(1) if ord(ch) == 13: return 'enter' elif ord(ch) == 113 or ord(ch) == 81: return 'exit' elif ord(ch) != 27: return False ch = sys.stdin.read(1) if ord(ch) != 91: return False ch = sys.stdin.read(1) if ord(ch) == 65: return 'up' elif ord(ch) == 66: return 'down' #elif ord(ch) == 67: return 'right' #elif ord(ch) == 68: return 'left' else: return False finally: termios.tcsetattr(fd, termios.TCSADRAIN, old_settings) while True: press_key = input_key() if press_key != '': break return press_key
action = agent.get_action(state) next_state, reward, done, info = env.step(action) agent.train((state, action, next_state, reward, done)) state = next_state total_reward += reward print("reward:", reward, "state:", state, "action:", action, "episode:", episode, "steps:", steps, "total_reward:", total_reward, "epsilon:", agent.epsilon) # env.render() with tf.variable_scope('q_table', reuse=True): weights = agent.sess.run(tf.get_variable('kernel')) # print(weights) # time.sleep(.01) clear_output(wait=True) steps += 1 print(t.bold_red("Fell into a hole.")) if reward == 0.0 else print( t.bold_green("Success!")) # time.sleep(.7) # how many times it fell into a hole vs success per episode agent.episode_plot.append(episode) agent.total_reward_plot.append(total_reward) agent.steps_plot.append(steps) plot_seaborn(agent.episode_plot, agent.total_reward_plot, agent.steps_plot)
class BaseMixin(Cmd): """The Mqtt-Pwn Base Command Line Interface Mixin""" prompt = '>> ' ruler = '-' intro = banner() CMD_CAT_BROKER_OP = 'Broker Related Operations' CMD_CAT_VICTIM_OP = 'Victim Related Operations' CMD_CAT_GENERAL = 'General Commands' variables_choices = ['victim', 'scan'] def __init__(self): """The class initializer""" Cmd.__init__(self, startup_script=config.STARTUP_SCRIPT) self.aliases.update({'exit': 'quit'}) self.hidden_commands.extend( ['load', 'pyscript', 'set', 'shortcuts', 'alias', 'unalias', 'py']) self.current_victim = None self.mqtt_client = None self.current_scan = None self.t = Terminal() self.base_prompt = get_prompt(self) self.prompt = self.base_prompt categorize(( BaseMixin.do_edit, BaseMixin.do_help, BaseMixin.do_history, BaseMixin.do_quit, BaseMixin.do_shell, ), BaseMixin.CMD_CAT_GENERAL) def print_error(self, text, end='\n', start=''): """Prints an error message with colors""" self.poutput(start + self.t.bold_red('[-]') + ' ' + self.t.red(text), end=end) def print_info(self, text, end='\n', start=''): """Prints an information message with colors""" self.poutput(start + self.t.bold_yellow('[!]') + ' ' + self.t.yellow(text), end=end) def print_ok(self, text, end='\n', start=''): """Prints a successful message with colors""" self.poutput(start + self.t.bold_green('[+]') + ' ' + self.t.green(text), end=end) def print_pairs(self, title, body): """Prints a message that contains pairs for data""" self.poutput(self.t.bold_white_underline(title)) for key, value in body.items(): k = key + ':' self.poutput(f' - {self.t.bold(k)} {value}') def update_prompt(self): """Updates the command prompt""" self.prompt = get_prompt(self)
for episode in range(300): # 1500 10000 state = env.reset() done = False steps = 0 while not done: action = agent.get_action(state) next_state, reward, done, info = env.step(action) agent.train((state, action, next_state, reward, done)) state = next_state total_reward += reward print("reward:", reward, "state:", state, "action:", action, "episode:", episode, "steps:", steps, "total_reward:", total_reward, "epsilon:", agent.epsilon) env.render() # print(agent.q_table) time.sleep(.01) clear_output(wait=True) steps += 1 print(t.bold_red("Fell into a hole.")) if reward == 0.0 else print(t.bold_green("Success!")) time.sleep(.7) # how many times it fell into a hole vs success per episode agent.episode_plot.append(episode) agent.total_reward_plot.append(total_reward) agent.steps_plot.append(steps) plot_seaborn(agent.episode_plot, agent.total_reward_plot, agent.steps_plot)