def dump(**kwargs): common = common_args(**kwargs) t = Terminal() ranking_line = " {prob:6.2f}% → {color}{text}{t.normal}" actual_line = "{t.red}Actual{t.normal}: {t.bold}{actual_text}{t.normal}" sent_forwards = Sentences(common.file_vector, size=SENTENCE_LENGTH, backwards=False) sent_backwards = Sentences(common.file_vector, size=SENTENCE_LENGTH, backwards=True) least_agreement = [] forwards_predictions = [] backwards_predictions = [] ranks = [] contexts = enumerate(zip(chop_prefix(common.tokens, PREFIX_LENGTH), sent_forwards, chop_prefix(sent_backwards))) # Note, the index is offset from the true start; i.e., when # index == 0, the true index is SENTENCE_LENGTH for index, (token, (prefix, x1), (suffix, x2)) in contexts: assert x1 == x2 actual = x1 print(unvocabularize(prefix[-5:]), t.bold_underline(token.value), unvocabularize(suffix[:5])) prefix_pred = common.forwards_model.predict(prefix) suffix_pred = common.backwards_model.predict(suffix) # harmonic mean mean = consensus(suffix_pred, prefix_pred) forwards_predictions.append(index_of_max(prefix_pred)) backwards_predictions.append(index_of_max(suffix_pred)) paired_rankings = rank(mean) ranked_vocab = list(tuple(zip(*paired_rankings))[0]) top_5 = paired_rankings[:5] top_5_words = ranked_vocab[:5] for token_id, weight in top_5: color = t.green if token_id == actual else '' text = vocabulary.to_text(token_id) prob = weight * 100.0 print(ranking_line.format_map(locals())) ranks.append(ranked_vocab.index(actual) + 1) min_token_id, min_prob = paired_rankings[0] least_agreement.append(Agreement(min_prob, index)) if actual not in top_5_words: actual_text = vocabulary.to_text(actual) print(actual_line.format_map(locals())) print() if not ranks: print(t.red("Could not analyze file!"), file=sys.stderr) return print("MRR: ", mean_reciprocal_rank(ranks)) print("Lowest rank:", max(ranks)) print("Time at #1: {:.2f}%".format( 100 * sum(1 for rank in ranks if rank == 1) / len(ranks))) print() forwards_text = [vocabulary.to_text(num) for num in forwards_predictions] backwards_text = [vocabulary.to_text(num) for num in backwards_predictions] least_agreement.sort() # Compensate for offset indices file_vector = common.file_vector[SENTENCE_LENGTH:] tokens_text = [tok.value for tok in common.tokens[PREFIX_LENGTH:]] for disagreement in least_agreement[:5]: print(disagreement.probability) prefix = ' '.join(disagreement.prefix(tokens_text)) suffix = ' '.join(disagreement.suffix(tokens_text)) print(" ", prefix, t.yellow(forwards_text @ disagreement), suffix) print(" ", prefix, t.underline(tokens_text @ disagreement), suffix) print(" ", prefix, t.blue(backwards_text @ disagreement), suffix) print()
scaled down to only handle singular fasta files (with the path to that file provided by processor.py). """ import os import subprocess from blessings import Terminal import argparse parser = argparse.ArgumentParser() parser.add_argument( "URL", help="The URL to the file we want to retrive information about") args = parser.parse_args() URL = args.URL colours = Terminal() QUAST = 'python PATH/TO/quast.py ' #change this to match the quast path on a different computer quast_temp_dir = 'PATH/TO/ROOT/fasta_files/quast_results' #where we will store the original quast reports report_tsv = 'PATH/TO/ROOT/fasta_files/quast_results/report.tsv' #path to the most recent quast report out_dir = 'PATH/TO/ROOT/fasta_files/QUAST_reports/' #the path to where the result files will be transported file_name = os.path.basename( URL )[: -6] #.rstrip(".fasta") #extracts the filename of the file being processed & removes the ".fasta" cmdln = QUAST + URL + " -o " + quast_temp_dir + " --no-plots" #the QUAST commandline call. Removes plots for greater speed! process = subprocess.Popen(cmdln, shell=True) #executes the desired program process.wait() #waits until the command has finished processing before ending process = subprocess.Popen(
parser.add_argument( "URL", help="The URL to the file we want to retrive information about") parser.add_argument( "--solo", "-s", help= "Tells this program that it will have to upload information to the database itself", action="store_true") parser.add_argument( "--genome", "-g", help="The name of the genome this PROKKA action is based around") args = parser.parse_args() URL = args.URL colours = Terminal() #for terminal outputs with gorgeous colours! def list_of_toxins(path, file_name): """ Function that takes the full path to a fasta toxin file. It will then determine the number of toxins in the file. It will then make a new temp file for evey toxin in the file (if more than one toxin, else it will return the orginal path it was given, in list form) and return the path to these files in list/tuple form with the desired file names appended to the tuple. """ toxin = open(path, 'r') temp = [] output = [] hold = "" counter = 0
def __init__(self, question, terminal=None, *args, **kwargs): super(BaseConsoleRender, self).__init__(*args, **kwargs) self.question = question self.terminal = terminal or Terminal() self.answers = {}
def __init__(self, stdout=sys.stdout): self.stdout = stdout self.term = Terminal(stream=stdout) self.counter = 0 self.width = self.term.width if self.term.is_a_tty else 80 # when testing t.width is None
def __terminal_expected__(self, h5file, iteration, si, sj, tau, h5key, dim): from blessings import Terminal self.t = Terminal() h = int(self.t.height / 4 * 3.75) # We'll figure out how to subsample the timepoints... w = self.t.width if self.dim == 3: in_tup = (iteration-1, si, sj) else: in_tup = (iteration-1, si) in_tup = (iteration-1, dim) try: yupper = (np.max(h5file) / tau) * 2 except: in_tup = (iteration-1) yupper = (np.max(h5file) / tau) * 2 ylower = (np.min(h5file) / tau) * 2 # Here are points pertaining to height. if yupper > 0: yupper = (np.max(h5file) / tau) * 1.2 ylower = (np.min(h5file) / tau) / 2 scale = np.array([0.0] + [ylower+i*(yupper-ylower)/np.float(h) for i in range(0, h)])[::-1] else: yupper = (np.max(h5file) / tau) / 2 ylower = (np.min(h5file) / tau) * 1.2 scale = np.array([ylower+i*(yupper-ylower)/np.float(h) for i in range(0, h)] + [0.0])[::-1] if iteration > w: block_size = iteration / w else: block_size = 1 with self.t.fullscreen(): try: for x in range(0, w-12): iter = x * block_size if self.dim == 3: in_tup = (iter-1, si, sj) else: in_tup = (iter-1, si) in_tup = (iter-1, dim) try: yupper = (h5file[in_tup] / tau) except: in_tup = (iter-1) yupper = (h5file[in_tup] / tau) ylower = (h5file[in_tup] / tau) ci = np.digitize([yupper, ylower], scale) if x == 0: for y in range(0, h+1): with self.t.location(0, y): print(self.t.bold(self.t.red('{0:.7f}|'.format(scale[y])))) for y in range(ci[0], ci[1]): print(self.t.move(y, x+12) + self.t.on_blue(' ')) #print(self.t.on_blue(' ')) print(self.t.move(np.digitize(h5file[in_tup]/tau, scale), x+12) + self.t.on_blue('-')) for x in range(0, w-12, w/10): if x == 0: with self.t.location(x, h+1): print('Iteration| ') with self.t.location(x+12, h+1): iter = x * block_size print(self.t.blue(str(iter))) except: pass with self.t.location(0, h+2): # We need to improve this. print("{} from iter 1 to {}".format(h5key, self.iteration)) with self.t.location(0, h+3): input("Press enter to continue.")
def info_out(msgs): term = Terminal() _out(msgs, None, term.blue)
def __init_tree__(self): t=Terminal() self.n=ProgressTree(term=t) self.n.make_room(self.graph_data)
def print_exit_msg(): term = Terminal() print "\n\nEnd of Line.\n\n" print(" " + term.bold(term.green("<")) + "bn" + term.bold(term.green("/>"))) print " Benito-Nemitz Inc."
class ColourTextTestResult(result.TestResult): """ A test result class that prints colour formatted text results to a stream. Based on https://github.com/python/cpython/blob/3.3/Lib/unittest/runner.py """ formatter = formatters.Terminal256Formatter() lexer = Lexer() separator1 = '=' * 70 separator2 = '-' * 70 indent = ' ' * 4 _terminal = Terminal() colours = { None: text_type, 'error': _terminal.bold_red, 'expected': _terminal.blue, 'fail': _terminal.bold_yellow, 'skip': text_type, 'success': _terminal.green, 'title': _terminal.blue, 'unexpected': _terminal.bold_red, } _test_class = None def __init__(self, stream, descriptions, verbosity): super(ColourTextTestResult, self).__init__(stream, descriptions, verbosity) self.stream = stream self.showAll = verbosity > 1 self.dots = verbosity == 1 self.descriptions = descriptions def getShortDescription(self, test): doc_first_line = test.shortDescription() if self.descriptions and doc_first_line: return self.indent + doc_first_line return self.indent + test._testMethodName def getLongDescription(self, test): doc_first_line = test.shortDescription() if self.descriptions and doc_first_line: return '\n'.join((str(test), doc_first_line)) return str(test) def getClassDescription(self, test): test_class = test.__class__ doc = test_class.__doc__ if self.descriptions and doc: return doc.split('\n')[0].strip() return strclass(test_class) def startTest(self, test): super(ColourTextTestResult, self).startTest(test) if self.showAll: if self._test_class != test.__class__: self._test_class = test.__class__ title = self.getClassDescription(test) self.stream.writeln(self.colours['title'](title)) self.stream.write(self.getShortDescription(test)) self.stream.write(' ... ') self.stream.flush() def printResult(self, short, extended, colour_key=None): colour = self.colours[colour_key] if self.showAll: self.stream.writeln(colour(extended)) elif self.dots: self.stream.write(colour(short)) self.stream.flush() def addSuccess(self, test): super(ColourTextTestResult, self).addSuccess(test) self.printResult('.', 'ok', 'success') def addError(self, test, err): super(ColourTextTestResult, self).addError(test, err) self.printResult('E', 'ERROR', 'error') def addFailure(self, test, err): super(ColourTextTestResult, self).addFailure(test, err) self.printResult('F', 'FAIL', 'fail') def addSkip(self, test, reason): super(ColourTextTestResult, self).addSkip(test, reason) self.printResult('s', 'skipped {0!r}'.format(reason), 'skip') def addExpectedFailure(self, test, err): super(ColourTextTestResult, self).addExpectedFailure(test, err) self.printResult('x', 'expected failure', 'expected') def addUnexpectedSuccess(self, test): super(ColourTextTestResult, self).addUnexpectedSuccess(test) self.printResult('u', 'unexpected success', 'unexpected') def printErrors(self): if self.dots or self.showAll: self.stream.writeln() self.printErrorList('ERROR', self.errors) self.printErrorList('FAIL', self.failures) def printErrorList(self, flavour, errors): colour = self.colours[flavour.lower()] for test, err in errors: self.stream.writeln(self.separator1) title = '%s: %s' % (flavour, self.getLongDescription(test)) self.stream.writeln(colour(title)) self.stream.writeln(self.separator2) self.stream.writeln(highlight(err, self.lexer, self.formatter))
def start(self): # Parse args global args, APs, mon_MAC args = parse_args() # Check args check_args(args) # Are you root? if os.geteuid(): sys.exit('[' + R + '-' + W + '] Please run as root') # TODO: We should have more checks here: # Is anything binded to our HTTP(S) ports? # Maybe we should save current iptables rules somewhere # get interfaces for monitor mode and AP mode and set the monitor interface # to monitor mode. shutdown on any errors try: if args.internetinterface: internet_interface = self.network_manager.set_internet_iface( args.internetinterface) if not args.nojamming: if args.jamminginterface and args.apinterface: mon_iface = self.network_manager.get_jam_iface( args.jamminginterface) ap_iface = self.network_manager.get_ap_iface( args.apinterface) else: mon_iface, ap_iface = self.network_manager.find_interface_automatically( ) self.network_manager.set_jam_iface(mon_iface.get_name()) self.network_manager.set_ap_iface(ap_iface.get_name()) # display selected interfaces to the user print( "[{0}+{1}] Selecting {0}{2}{1} interface for the deauthentication " "attack\n[{0}+{1}] Selecting {0}{3}{1} interface for creating the " "rogue Access Point").format(G, W, mon_iface.get_name(), ap_iface.get_name()) # randomize the mac addresses if not args.no_mac_randomization: if not args.mac_ap_interface: self.network_manager.randomize_ap_interface_mac_addr() else: self.network_manager.randomize_ap_interface_mac_addr( args.mac_ap_interface) if not args.mac_deauth_interface: self.network_manager.randomize_deauth_interface_mac_addr( ) else: self.network_manager.randomize_deauth_interface_mac_addr( args.mac_deauth_interface) else: if args.apinterface: ap_iface = self.network_manager.get_ap_iface( interface_name=args.apinterface) else: ap_iface = self.network_manager.get_ap_iface() self.network_manager.set_ap_iface(ap_iface.get_name()) mon_iface = ap_iface if not args.no_mac_randomization: if not args.mac_ap_interface: self.network_manager.randomize_ap_interface_mac_addr() else: self.network_manager.randomize_ap_interface_mac_addr( args.mac_ap_interface) print( "[{0}+{1}] Selecting {0}{2}{1} interface for creating the " "rogue Access Point").format(G, W, ap_iface.get_name()) # randomize the mac addresses if not args.no_mac_randomization: ap_iface.randomize_interface_mac(args.mac_ap_interface) kill_interfering_procs() self.network_manager.set_interface_mode(mon_iface, "monitor") except (interfaces.NotEnoughInterfacesFoundError, interfaces.JammingInterfaceInvalidError, interfaces.ApInterfaceInvalidError, interfaces.NoApInterfaceFoundError, interfaces.NoMonitorInterfaceFoundError, interfaces.DeauthInterfaceMacAddrInvalidError, interfaces.ApInterfaceMacAddrInvalidError) as err: print("[{0}!{1}] " + str(err)).format(R, W) time.sleep(1) self.stop() if not args.no_mac_randomization: print("[{0}+{1}] " + ap_iface.get_name() + ' mac address becomes ' + ap_iface.get_current_mac()).format( G, W) if not args.nojamming: print("[{0}+{1}] " + mon_iface.get_name() + ' mac address becomes ' + mon_iface.get_current_mac()).format(G, W) if args.internetinterface: self.fw.nat(ap_iface.get_name(), args.internetinterface) set_ip_fwd() else: self.fw.redirect_requests_localhost() set_route_localnet() if not args.internetinterface: self.network_manager.up_ifaces([ap_iface, mon_iface]) print '[' + T + '*' + W + '] Cleared leases, started DHCP, set up iptables' time.sleep(1) if args.essid: essid = args.essid channel = str(CHANNEL) ap_mac = None enctype = None else: # let user choose access point access_point = curses.wrapper(select_access_point, mon_iface, self.mac_matcher) # if the user has chosen a access point continue # otherwise shutdown if access_point: # store choosen access point's information essid = access_point.get_name() channel = access_point.get_channel() ap_mac = access_point.get_mac_address() enctype = access_point.get_encryption() else: self.stop() # create a template manager object self.template_manager = phishingpage.TemplateManager() # get the correct template template = select_template(args.phishingscenario, self.template_manager) print("[" + G + "+" + W + "] Selecting " + template.get_display_name() + " template") # payload selection for browser plugin update if template.has_payload(): payload_path = False # copy payload to update directory while not payload_path or not os.path.isfile(payload_path): # get payload path payload_path = raw_input( "[" + G + "+" + W + "] Enter the [" + G + "full path" + W + "] to the payload you wish to serve: ") if not os.path.isfile(payload_path): print '[' + R + '-' + W + '] Invalid file path!' print '[' + T + '*' + W + '] Using ' + G + payload_path + W + ' as payload ' copyfile(payload_path, PHISHING_PAGES_DIR + template.get_payload_path()) APs_context = [] for i in APs: APs_context.append({ 'channel': APs[i][0] or "", 'essid': APs[i][1] or "", 'bssid': APs[i][2] or "", 'vendor': self.mac_matcher.get_vendor_name(APs[i][2]) or "" }) template.merge_context({'APs': APs_context}) # only get logo path if MAC address is present ap_logo_path = False if ap_mac: ap_logo_path = template.use_file( self.mac_matcher.get_vendor_logo_path(ap_mac)) template.merge_context({ 'target_ap_channel': channel or "", 'target_ap_essid': essid or "", 'target_ap_bssid': ap_mac or "", 'target_ap_encryption': enctype or "", 'target_ap_vendor': self.mac_matcher.get_vendor_name(ap_mac) or "", 'target_ap_logo_path': ap_logo_path or "" }) # We want to set this now for hostapd. Maybe the interface was in "monitor" # mode for network discovery before (e.g. when --nojamming is enabled). self.network_manager.set_interface_mode(ap_iface, "managed") # Start AP self.access_point.set_interface(ap_iface.get_name()) self.access_point.set_channel(channel) self.access_point.set_essid(essid) if args.presharedkey: self.access_point.set_psk(args.presharedkey) if args.internetinterface: self.access_point.set_internet_interface(args.presharedkey) print '[' + T + '*' + W + '] Starting the fake access point...' try: self.access_point.start() self.access_point.start_dhcp_dns() except: self.stop() # With configured DHCP, we may now start the web server if not args.internetinterface: # Start HTTP server in a background thread print '[' + T + '*' + W + '] Starting HTTP/HTTPS server at ports ' + str( PORT) + ", " + str(SSL_PORT) webserver = Thread(target=phishinghttp.runHTTPServer, args=(NETWORK_GW_IP, PORT, SSL_PORT, template)) webserver.daemon = True webserver.start() time.sleep(1.5) # We no longer need mac_matcher self.mac_matcher.unbind() clients_APs = [] APs = [] mon_MAC = mon_mac(mon_iface.get_name()) deauthentication = None if not args.nojamming: monchannel = channel # set the channel on the deauthenticating interface mon_iface.set_channel(int(channel)) # start deauthenticating all client on target access point deauthentication = deauth.Deauthentication(ap_mac, mon_iface.get_name()) if args.lure10_exploit: deauthentication.add_lure10_beacons(LOCS_DIR + args.lure10_exploit) deauthentication.deauthenticate() # Main loop. try: term = Terminal() with term.fullscreen(): while 1: term.clear() with term.hidden_cursor(): print term.move(0, term.width - 30) + "|" print term.move( 1, term.width - 30) + "|" + " " + term.bold_blue("Wifiphisher " + VERSION) print term.move( 2, term.width - 30) + "|" + " ESSID: " + essid print term.move( 3, term.width - 30) + "|" + " Channel: " + channel print term.move( 4, term.width - 30 ) + "|" + " AP interface: " + ap_iface.get_name() print term.move(5, term.width - 30) + "|" + "_" * 29 print term.move( 1, 0) + term.blue("Deauthenticating clients: ") if not args.nojamming: # only show clients when jamming if deauthentication.get_clients(): # show the 5 most recent devices for client in deauthentication.get_clients( )[-5:]: print client print term.move(6, 0) + term.blue("DHCP Leases: ") if os.path.isfile('/var/lib/misc/dnsmasq.leases'): proc = check_output( ['tail', '-5', '/var/lib/misc/dnsmasq.leases']) print term.move(7, 0) + proc print term.move(13, 0) + term.blue("HTTP requests: ") if os.path.isfile('/tmp/wifiphisher-webserver.tmp'): proc = check_output([ 'tail', '-5', '/tmp/wifiphisher-webserver.tmp' ]) print term.move(14, 0) + proc if phishinghttp.terminate and args.quitonsuccess: raise KeyboardInterrupt except KeyboardInterrupt: if deauthentication != None: deauthentication.on_exit() self.stop()
def main(): parser = argparse.ArgumentParser( description="Command line tool to watch torrents") parser.add_argument("name", help="The name of the series or movie") parser.add_argument("season_number", default=None, nargs="?", type=int, help="Season number") parser.add_argument("episode_number", default=None, nargs="?", type=int, help="Episode number") parser.add_argument("--sub", nargs='?', default=None, help="Subtitle language") parser.add_argument("--serve", action="store_true", help="Do not run VLC") parser.add_argument("--quality", nargs='?', default=None, help="quality of the video [normal|hd|fullhd]") parser.add_argument("--daemon", action="store_true", help="Daemonize the process"), parser.add_argument("--port", "-p", default="8888", help="The port where the stream will be served") parser.add_argument("--verbose", action="store_true", default=None, help="Show _all_ the logs") parser.add_argument("--player", default='vlc', help="Player to use. vlc|omxplayer|chromecast") parser.add_argument( "--search", default=None, help= "search lib to use (only option right now is 'kat' for kickass torrents)" ) parser.add_argument("--nocache", action="store_false", default=True, help="Search for the torrent again"), args = parser.parse_args() log_set_up(args.verbose) log.info("Starting touchandgo") log.debug("Running Python %s on %r", sys.version_info, sys.platform) log.debug("Libtorrent version: %s", libtorrent_version) try: if args.sub is not None: Language(args.sub) touchandgo = SearchAndStream(args.name, season=args.season_number, episode=args.episode_number, sub_lang=args.sub, serve=args.serve, quality=args.quality, port=args.port, player=args.player, search=args.search, use_cache=args.nocache) if args.daemon: def callback(): touchandgo.serve = True touchandgo.watch() daemonize(args, callback) else: term = Terminal() with term.fullscreen(): touchandgo.watch() except ValueError as e: print(e)
def print_status(self, workers): term = Terminal() with term.location(): for thread, worker in workers.items(): self.print_worker(worker) print '{}'.format(term.clear_eos)
def print_to( self, fp, with_colors=True, # deprecated arg show_cmd=False, show_user=False, show_pid=False, show_power=None, gpuname_width=16, term=Terminal(), ): # color settings colors = {} def _conditional(cond_fn, true_value, false_value, error_value=term.bold_black): try: if cond_fn(): return true_value else: return false_value except: return error_value colors['C0'] = term.normal colors['C1'] = term.cyan colors['CName'] = term.blue colors['CTemp'] = _conditional( lambda: int(self.entry['temperature.gpu']) < 50, term.red, term.bold_red) colors['CMemU'] = term.bold_yellow colors['CMemT'] = term.yellow colors['CMemP'] = term.yellow colors['CUser'] = term.bold_black # gray colors['CUtil'] = _conditional( lambda: int(self.entry['utilization.gpu']) < 30, term.green, term.bold_green) colors['CPowU'] = _conditional( lambda: float(self.entry['power.draw']) / self.entry[ 'enforced.power.limit'] < 0.4, term.magenta, term.bold_magenta) colors['CPowL'] = term.magenta if not with_colors: for k in list(colors.keys()): colors[k] = '' def _repr(v, none_value='??'): if v is None: return none_value else: return str(v) # build one-line display information # we want power use optional, but if deserves being grouped with temperature and utilization reps = "%(C1)s[{entry[index]}]%(C0)s %(CName)s{entry[name]:{gpuname_width}}%(C0)s |" \ "%(CTemp)s{entry[temperature.gpu]:>3}'C%(C0)s, %(CUtil)s{entry[utilization.gpu]:>3} %%%(C0)s" if show_power: reps += ", %(CPowU)s{entry[power.draw]:>3}%(C0)s " if show_power is True or 'limit' in show_power: reps += "/ %(CPowL)s{entry[enforced.power.limit]:>3}%(C0)s " reps += "%(CPowL)sW%(C0)s" else: reps += "%(CPowU)sW%(C0)s" reps += " | %(C1)s%(CMemU)s{entry[memory.used]:>5}%(C0)s / %(CMemT)s{entry[memory.total]:>5}%(C0)s MB" reps = (reps) % colors reps = reps.format( entry={k: _repr(v) for (k, v) in self.entry.items()}, gpuname_width=gpuname_width) reps += " |" def process_repr(p): r = '' if not show_cmd or show_user: r += "{CUser}{}{C0}".format(_repr(p['username'], '--'), **colors) if show_cmd: if r: r += ':' r += "{C1}{}{C0}".format( _repr(p.get('command', p['pid']), '--'), **colors) if show_pid: r += ("/%s" % _repr(p['pid'], '--')) r += '({CMemP}{}M{C0})'.format(_repr(p['gpu_memory_usage'], '?'), **colors) return r if self.entry['processes'] is not None: for p in self.entry['processes']: reps += ' ' + process_repr(p) else: # None (not available) reps += ' (Not Supported)' fp.write(reps) return fp
cert_path = storage / 'certs' nginx_path = storage / 'nginx' # Check if an update is available repo = Repo(str(repo_path)) old_hash = repo.head.object.hexsha repo.remotes.origin.fetch() repo.git.reset('--hard', repo.active_branch.tracking_branch().name) new_hash = repo.head.object.hexsha generate_config = args.forced if old_hash != new_hash: generate_config = True print( '{t.normal}Detected change on {t.bold}{t.yellow}{branch}{t.normal}. Updated from {t.bold}{t.magenta}{old}{t.normal} to {t.bold}{t.magenta}{new}{t.normal}.' .format(t=Terminal(), branch=repo.active_branch.name, old=old_hash, new=new_hash)) renew_certificates = False if not generate_config: # Quick scan for certificates that should be renewed for cert in cert_path.glob('**/*.crt'): if should_renew_cert(cert): renew_certificates = True break if not renew_certificates: # No need to continue sys.exit()
def poll_chargepoint_stations(scraper, stations_of_interest=None, stations_to_ignore=None): if stations_to_ignore is None: stations_to_ignore = [] if stations_of_interest is None: stations_of_interest = scraper.get_station_data()['stations'].keys() stations_of_interest = [ x for x in stations_of_interest if x not in stations_to_ignore ] old_free_spots = None old_open_stations = [] t = Terminal() try: i = 0 while True: new_free_spots = 0 new_open_stations = [] try: data = scraper.get_station_data() except ChargePointAuthenticationExpiredException: data = scraper.get_station_data() if i % 10 == 0: print '\t\t\t' + '\t'.join( [station for station in stations_of_interest]) line_parts = [data['time'].strftime('%Y/%m/%d %H:%M:%S')] for k in stations_of_interest: line_part = '%d / %d'.center(9) % ( data['stations'][k]['available'], data['stations'][k]['total']) if data['stations'][k]['available'] == data['stations'][k][ 'total']: line_part = t.black_on_green(line_part) elif data['stations'][k]['available'] == 0: line_part = t.black_on_red(line_part) else: line_part = t.black_on_yellow(line_part) line_parts.append(line_part) new_free_spots += data['stations'][k]['available'] new_open_stations.extend([k] * data['stations'][k]['available']) print '\t'.join(line_parts) if old_free_spots is not None and new_free_spots > old_free_spots: newly_open_stations = new_open_stations for elem in old_open_stations: try: newly_open_stations.remove(elem) except ValueError: pass title = '%s station(s) are open' % ', '.join( newly_open_stations) message = '%d Free Spots' % new_free_spots if _platform == 'darwin': Notifier.notify(title=title, message=message) send_boxcar_notification(title=title, message=message) old_free_spots = new_free_spots old_open_stations = new_open_stations i += 1 sleep(60) except KeyboardInterrupt: pass except KeyError: exit("Unexpected response json.")
def __terminal_ci__(self, h5file, iteration, si, sj, tau, h5key): from blessings import Terminal self.t = Terminal() h = int(self.t.height / 4 * 3.75) # We'll figure out how to subsample the timepoints... w = self.t.width if self.dim == 3: in_tup = (iteration-1, si, sj) else: in_tup = (iteration-1, si) yupper = (h5file[h5key]['ci_ubound'][in_tup] / tau) * 2 ylower = (h5file[h5key]['ci_lbound'][in_tup] / tau) / 2 # Here are points pertaining to height. scale = np.array([0.0] + [ylower+i*(yupper-ylower)/np.float(h) for i in range(0, h)])[::-1] if iteration > w: block_size = iteration / w else: block_size = 1 with self.t.fullscreen(): try: for x in range(0, w-12): iter = x * block_size if self.dim == 3: in_tup = (iter-1, si, sj) else: in_tup = (iter-1, si) yupper = (h5file[h5key]['ci_ubound'][in_tup] / tau) ylower = (h5file[h5key]['ci_lbound'][in_tup] / tau) ci = np.digitize([yupper, ylower], scale) if x == 0: for y in range(0, h+1): with self.t.location(0, y): print(self.t.bold(self.t.red('{0:.7f}|'.format(scale[y])))) for y in range(ci[0], ci[1]): #with self.t.location(x+12, y): print(self.t.move(y, x+12) + self.t.on_blue(' ')) #print(self.t.on_blue(' ')) #with self.t.location(x+12, np.digitize(h5file['rate_evolution']['expected'][iter-1, si, sj]/tau, scale)): # print(self.t.on_blue('-')) print(self.t.move(np.digitize(h5file[h5key]['expected'][in_tup]/tau, scale), x+12) + self.t.on_blue('-')) for x in range(0, w-12, w/10): if x == 0: with self.t.location(x, h+1): print('Iteration| ') with self.t.location(x+12, h+1): iter = x * block_size print(self.t.blue(str(iter))) except: pass with self.t.location(0, h+2): # We need to improve this. #if h5key == 'rate_evolution': # print("k_ij from {} to {} from iter 1 to {}".format(self.state_labels[si], self.state_labels[sj], self.iteration)) #elif h5key == 'conditional_flux_evolution': # print("i->j flux from {} to {} from iter 1 to {}".format(self.state_labels[si], self.state_labels[sj], self.iteration)) if self.dim == 3: print("{} from {} to {} from iter 1 to {}".format(h5key, self.state_labels[si], self.state_labels[sj], self.iteration)) else: print("{} of state {} from iter 1 to {}".format(h5key, self.state_labels[si], self.iteration)) with self.t.location(0, h+3): input("Press enter to continue.")
def __init__(self, cmdargs=None, doc=""): self.t = Terminal() if not cmdargs: cmdargs = None self.cmdargs = cmdargs self.doc = doc
if h in hashes: continue else: hashes.add(h) unique.append(p) duplicates = len(ps) - len(hashes) if duplicates > 0: print(INFORMATIONAL + "Ignoring " + str(duplicates) + " duplicate protocols (identical hashes)") return unique VERSION = "Tamarin Tester v1.0" DESCRIPTION = "tamarin-tester is a tool for testing the correctness of tamarin-prover builds by comparing their output to known-good builds. For a more comprehensive overview, consult the README distributed with this program. In general, you may run tests against benchmark files or generate these benchmark files yourself. Authored by Dennis Jackson, Computer Science Dept, University of Oxford." TERMINAL = Terminal() ERROR = TERMINAL.bold(TERMINAL.red("ERROR ")) INFORMATIONAL = TERMINAL.bold(TERMINAL.blue("INFORMATIONAL ")) WARNING = TERMINAL.yellow(TERMINAL.bold("WARNING ")) CHECK_TIMEOUT = TERMINAL.red(TERMINAL.bold("CHECK TIMEOUT ")) MALFORMED = TERMINAL.bold(TERMINAL.red("MALFORMED ")) BENCH_TIMEOUT = TERMINAL.red(TERMINAL.bold("BENCH TIMEOUT ")) NO_LEMMAS = TERMINAL.yellow(TERMINAL.bold("NO LEMMAS ")) INCORRECT = TERMINAL.bold(TERMINAL.red("\t INCORRECT: ")) STEPSIZE_INC = TERMINAL.bold(TERMINAL.yellow("\t STEPSIZE INC: ")) STEPSIZE_DEC = TERMINAL.bold(TERMINAL.yellow("\t STEPSIZE DEC: ")) TIMEOUT = TERMINAL.bold(TERMINAL.red("\t TIMEOUT "))
### This is the SAbEncryption cracker, made to show the weakness of the SAbE (why? well, just for fun) ### ## General principles: ## - Make math operation, with each guess of the key ## Output format: ## - Wrong guess prints a line with format -<key>: [Err: values too high for ASCII]- ## - A possible guess prints -<key>: <phrase>- from blessings import Terminal ## |-- Some prettyfied terminal output with Blessings t = Terminal() ## | crypted = input('The phrase to decrypt: ') ## The HACK-ing process for key in range(0, 255 + 1): guess = '' tmp = '' for pos, char in enumerate(crypted): tmp += char try: ## Makes sure that -tmp- currently has 3 digits, for any plaintext symbol is always encrypted into a 3-digit number if pos in range(2, 10000, 3): ## Adds a character (stored in -tmp-) to a final guess (for the current key), via guess += str(chr(int(tmp) - 100 - key)) tmp = '' ## It may (and, is likely to do frequently) be so, that the number would be too large for the -chr()- func, so let's leave those blank except ValueError: break if guess == '': print(f'{key}: ' + t.bold_red('[Err: values too high for ASCII]')) else:
def warn_out(msgs): """ Print the given error message (or list of messages) and exit. """ term = Terminal() _out(msgs, "WARNING", term.yellow)
def string_color(ansi_value, string, on_color=16): term = Terminal() return term.on_color(on_color) + term.color( ansi_value) + string + term.normal
def __init__(self): self.term = Terminal()
def main(): term = Terminal() if sys.version_info < (2, 7): raise RuntimeError( "Jirafs requires minimally version 2.7 of Python 2, or " "any version of Python 3. Please upgrade your version of " "python before using Jirafs.") if utils.get_git_version() < LooseVersion('1.8'): raise RuntimeError( "Jirafs requires minimally version 1.8 of Git. Please " "upgrade your version of git before using Jirafs.") commands = utils.get_installed_commands() parser = argparse.ArgumentParser( description='Edit Jira issues locally from your filesystem', add_help=False, ) parser.add_argument('command', type=six.text_type, choices=commands.keys()) parser.add_argument('--subtasks', action='store_true', default=False) parser.add_argument( '--log-level', default='INFO', dest='log_level', ) parser.add_argument('--folder', default=os.getcwd()) parser.add_argument( '--no-subfolders', action='store_true', default=False, ) parser.add_argument( '--traceback', action='store_true', default=False, ) args, extra = parser.parse_known_args() logging.config.dictConfig(LOGGING) root_logger = logging.getLogger() root_logger.setLevel(logging.getLevelName(args.log_level)) command_name = args.command cmd_class = commands[command_name] # Subtasks if args.subtasks: cmd_class.RUN_FOR_SUBTASKS = True started = time.time() logger.debug('Command %s(%s) started', command_name, extra) jira = utils.lazy_get_jira() try: value = cmd_class.execute_command(extra, jira=jira, path=args.folder, command_name=command_name) logger.debug('Command %s(%s) finished in %s seconds', command_name, extra, (time.time() - started)) if value: value.echo() sys.exit(value.return_code) except GitCommandError as e: print(u"{t.red}Error (code: {code}) while running git " u"command.{t.normal}".format(t=term, code=e.returncode)) print("") print(u"{t.red}Command:{t.normal}{t.red}{t.bold}".format(t=term)) print(u" {cmd}".format(cmd=e.command)) print(u"{t.normal}".format(t=term)) print(u"{t.red}Output:{t.normal}{t.red}{t.bold}".format(t=term)) for line in e.output.decode('utf8').split('\n'): print(u" %s" % line) print(u"{t.normal}".format(t=term)) if args.traceback: traceback.print_exc() sys.exit(10) except NotTicketFolderException: if not getattr(cmd_class, 'TRY_SUBFOLDERS', False): print(u"{t.red}The command '{cmd}' must be ran from " u"within an issue folder.{t.normal}".format( t=term, cmd=command_name)) sys.exit(20) elif args.no_subfolders: sys.exit(20) count_runs = 0 for folder in os.listdir(os.getcwd()): full_path = os.path.join( os.getcwd(), folder, ) if not os.path.isdir(full_path): continue try: full_args = copy.copy(sys.argv) if '--no-subfolders' not in full_args: full_args.append('--no-subfolders') result = subprocess.call(' '.join( [shlex_quote(a) for a in full_args]), cwd=full_path, shell=True) if result == 0: count_runs += 1 except NotTicketFolderException: pass if count_runs == 0: if args.traceback: traceback.print_exc() sys.exit(21) except JIRAError as e: print(u"{t.red}Jirafs encountered an error while interacting with " u"your JIRA instance: {t.normal}{t.red}{t.bold}{error}" u"{t.normal}".format(t=term, error=str(e))) if args.traceback: traceback.print_exc() sys.exit(70) except JiraInteractionFailed as e: print(u"{t.red}JIRA was unable to satisfy your " u"request: {t.normal}{t.red}{t.bold}{error}{t.normal}".format( t=term, error=str(e))) if args.traceback: traceback.print_exc() sys.exit(80) except JirafsError as e: print(u"{t.red}Jirafs encountered an error processing your " u"request: {t.normal}{t.red}{t.bold}{error}{t.normal}".format( t=term, error=str(e))) if args.traceback: traceback.print_exc() sys.exit(90)
#!/usr/bin/env python # -*- coding: utf-8 -*- # set your aws env vars to production from blessings import Terminal # terminal colors TERM = Terminal() # Number of previous amis to keep based on grouping strategy # not including the ami currently running by an ec2 instance KEEP_PREVIOUS = 4 # the way to regroup AMIs, the default filtering pattern is the creation date # and the possible other values are : # # name : with a grep into the ami name # ex: ubuntu => ["ubuntu-20160122", "ubuntu-20160123"] # tags : with keys provided in GROUPING_STRATEGY_TAGS_KEYS, it filters AMI tags # ex: ["Role", "Env"] => ["ubuntu-20160122"] # MAPPING_KEY = "tags" MAPPING_VALUES = ["environment", "role"]
logger = logging.getLogger(__name__) ##If set to True all the scraping results will be udpated to the database UPDATE_DB = True import ConfigParser config = ConfigParser.RawConfigParser() config.read("zomato_dom.cfg") driver_exec_path = "/home/%s/Downloads/chromedriver"%(getpass.getuser()) DRIVER_NAME = "CHROME" PROXY_ADDRESS = config.get("proxy", "proxy_addr") #StartScrapeChain.apply_async(["https://www.zomato.com/ncr/restaurants", 30, 0, False]) from blessings import Terminal terminal = Terminal() """ To run tasks for scraping one restaurant runn.apply_async(["https://www.zomato.com/ncr/pita-pit-lounge-greater-kailash-gk-1-delhi", None, None, True]) TO scrape a list of restaurant use this runn.apply_async(args=["https://www.zomato.com/ncr/south-delhi-restaurants", 30, 270, False]) Task.acks_late If set to True messages for this task will be acknowledged after the task has been executed, not just before, which is the default behavior. Task.ErrorMail If the sending of error emails is enabled for this task, then this is the class defining the logic to send error mails. Task.store_errors_even_if_ignored
#!/usr/bin/env python2.7 import os, sys import shodan import pickle import time from blessings import Terminal from subprocess import PIPE, Popen t = Terminal() # Global vars api = "" query = "" workspace = "" local_port = "" local_host = "" configured = False toolbar_width = 60 # Logo def logo(): print t.cyan(""" _____ _ _____ _ _ _ #--Author : Vector/NullArray | _ |_ _| |_ ___| __|___| |___|_| |_ #--Twitter: @Real__Vector | | | | _| . |__ | . | | . | | _| #--Type : Mass Exploiter |__|__|___|_| |___|_____| _|_|___|_|_| #--Version: 1.0.0 |_| ##############################################
def main(): """Handles External PRs (PRs from forks) Performs the following operations: 1. If the external PR's base branch is master we create a new branch and set it as the base branch of the PR. 2. Labels the PR with the "Contribution" label. (Adds the "Hackathon" label where applicable.) 3. Assigns a Reviewer. 4. Creates a welcome comment Will use the following env vars: - CONTENTBOT_GH_ADMIN_TOKEN: token to use to update the PR - EVENT_PAYLOAD: json data from the pull_request event """ t = Terminal() payload_str = get_env_var('EVENT_PAYLOAD') if not payload_str: raise ValueError('EVENT_PAYLOAD env variable not set or empty') payload = json.loads(payload_str) print(f'{t.cyan}Processing PR started{t.normal}') org_name = 'demisto' repo_name = 'content' gh = Github(get_env_var('CONTENTBOT_GH_ADMIN_TOKEN'), verify=False) content_repo = gh.get_repo(f'{org_name}/{repo_name}') pr_number = payload.get('pull_request', {}).get('number') pr = content_repo.get_pull(pr_number) # Add 'Contribution' Label to PR contribution_label = 'Contribution' pr.add_to_labels(contribution_label) print(f'{t.cyan}Added "Contribution" label to the PR{t.normal}') # check base branch is master if pr.base.ref == 'master': print(f'{t.cyan}Determining name for new base branch{t.normal}') branch_prefix = 'contrib/' new_branch_name = f'{branch_prefix}{pr.head.label.replace(":", "_")}' existant_branches = content_repo.get_git_matching_refs( f'heads/{branch_prefix}') potential_conflicting_branch_names = [ branch.ref.lstrip('refs/heads/') for branch in existant_branches ] # make sure new branch name does not conflict with existing branch name while new_branch_name in potential_conflicting_branch_names: # append or increment digit if not new_branch_name[-1].isdigit(): new_branch_name += '-1' else: digit = str(int(new_branch_name[-1]) + 1) new_branch_name = f'{new_branch_name[:-1]}{digit}' master_branch_commit_sha = content_repo.get_branch('master').commit.sha # create new branch print(f'{t.cyan}Creating new branch "{new_branch_name}"{t.normal}') content_repo.create_git_ref(f'refs/heads/{new_branch_name}', master_branch_commit_sha) # update base branch of the PR pr.edit(base=new_branch_name) print( f'{t.cyan}Updated base branch of PR "{pr_number}" to "{new_branch_name}"{t.normal}' ) # assign reviewers / request review from reviewer_to_assign = determine_reviewer(REVIEWERS, content_repo) pr.add_to_assignees(reviewer_to_assign) pr.create_review_request(reviewers=[reviewer_to_assign]) print(f'{t.cyan}Assigned user "{reviewer_to_assign}" to the PR{t.normal}') print( f'{t.cyan}Requested review from user "{reviewer_to_assign}"{t.normal}') # create welcome comment body = WELCOME_MSG.format(selected_reviewer=reviewer_to_assign) pr.create_issue_comment(body) print(f'{t.cyan}Created welcome comment{t.normal}')
import shutil from blessings import Terminal from errors import * from world_map.world_map import WorldMap from world_map.zones import DungeonZone from utilities import turn, health_bar, clear_screen from mobs.player import choose_class # TODO: Rename Utils so it doesn't clash with standard library utils. # initialize terminal term = Terminal() # initialization values player = None world_map = WorldMap() starting_zone = DungeonZone(world_map) starting_room = starting_zone.room_array[1][1] class Main: # test for Python 2 try: input = raw_input except NameError: pass while player is None: player = choose_class(player, starting_room)
def __init__(self, vm, vmx): self.t = Terminal() self.vm = vm self.vmx = vmx self.config = Config()