def print_information(destinations):
print('\n' + bg(255,255,255) + fg(0,0,0) + ' Line Time Destination ' + rs.bg + '\n')
for stop in destinations:
if stop['product'] == 'UBAHN':
destination = stop['destination']
time = stop['departureTimeMinutes']
color = {'U1':bg(70, 132, 71),
'U2':bg(221, 61, 77),
'U3':bg(239, 136, 36),
'U4':bg(4, 175, 144),
'U5':bg(183, 135, 48),
'U6':bg(4, 114, 179),
'U7':fg(255,255,255) + bg(70, 132, 71) + ' U' + bg(221, 61, 77) + '7 ' + rs.bg,
'U' :fg(255,255,255) + bg(0, 108, 178) + ' U ' + rs.bg}
finalLine = color[stop['label']] + fg(255,255,255) + ' ' + stop['label'] + ' ' + rs.bg
sep_time = {"1":7, "2":6, "3":5}
tam_time = str(len(str(time)))
print(' {} {}{}{}'.format(finalLine,time," "*sep_time[tam_time],destination))
print('\n')
def cPrint(string):
global expectL
global initLen
j = 0
for i in range(len(string) - (initLen - 1)):
#if chance[i] is positive, it is more likely than average
c0 = 0
c1 = 0
if expectL[i] < 0:
c0 = int(-expectL[i] * 6 * 255)
if c0 > 255:
c0 = 255
elif expectL[i] > 0:
c1 = int(expectL[i] * 200)
#clump together initial gram or passed root
if i == 0:
while j < initLen:
print(bg(c0, c1, 0) + string[j] + bg.rs, end='')
j += 1
#print trailing \n as space
elif i == len(string) - initLen:
print(bg(c0, c1, 0) + " " + bg.rs, end='')
#normally
else:
print(bg(c0, c1, 0) + string[j] + bg.rs, end='')
j += 1
print()
def color_op(option):
colores = ""
counter = 0
for tone in Color:
color = tone.value
if counter == option:
colores += (bg(color[0], color[1], color[2]) + " \u2573 " +
bg.rs + "\t")
counter += 1
else:
colores += (bg(color[0], color[1], color[2]) + " " + bg.rs +
"\t")
counter += 1
print(colores)
def get_info(station):
global print_information
try:
Id = mvg_api.get_id_for_station(station)
if Id:
destinations = mvg_api.get_departures(Id)
print_information(destinations)
else:
print('\n ' + bg(255,0,0) + ' The station does not exists ' + rs.bg + '\n')
except:
print('\n ' + bg(255,0,0) + ' Something wrong has happened ' + rs.bg + '\n')
def benchmark(liste_fonction, liste_affichage, X_train, X_test, y_train,
y_test, test):
lut = [
202, 203, 204, 205, 206, 207, 171, 135, 99, 63, 27, 33, 39, 45, 51, 49
] #50, 48, 47, 46]
colorbar = "\n"
for l in lut:
colorbar += bg(l) + " " + bg.rs
lut.reverse()
defaut_debiles = [randomDumb, moyDumb, medDumb]
defaut_intelligentes = [
foret, sgdRegressor, gradientRegressor, mlpRegressor
]
valeur_bg = {}
valeur_brute = {}
y_resultat = {}
for f in defaut_debiles + defaut_intelligentes + liste_fonction:
valeur_brute[f()], y_resultat[f()] = f(X_train, X_test, y_train,
y_test)
minimum = np.min([x for x in valeur_brute.values()])
maximum = np.max([x for x in valeur_brute.values()])
for f in defaut_debiles + defaut_intelligentes + liste_fonction:
valeur_bg[f()] = lut[int((valeur_brute[f()] - minimum) /
(maximum - minimum) * (len(lut) - 1))]
print(
"\033[5;37;40m Root Mean Squared Error "
) #erreur quadratique moyenne pris à la racine carrée pour avoir des jours
print()
print("\033[5;30;44m Méthodes naïves ")
for f in defaut_debiles:
pretty_print(f(), valeur_brute[f()], "30", "44", valeur_bg[f()])
print()
print("\033[5;30;44m Autres méthodes ")
for f in defaut_intelligentes:
pretty_print(f(), valeur_brute[f()], "30", "44", valeur_bg[f()])
for f in liste_fonction:
pretty_print(f(), valeur_brute[f()], "30", "46", valeur_bg[f()])
print()
print("\033[5;37;40m Statistiques Modes ")
pretty_print("minimum", np.min(y_test), "37", "40", 235)
pretty_print("1er quartile", np.quantile(y_test, 0.25), "37", "40", 235)
pretty_print("moyenne", np.mean(y_test), "37", "40", 235)
pretty_print("médiane", np.median(y_test), "37", "40", 235)
pretty_print("3ème quartile", np.quantile(y_test, 0.75), "37", "40", 235)
pretty_print("maximum", np.max(y_test), "37", "40", 235)
print(colorbar)
#show_distrib(train,y_train,'-')
print()
print("données tests")
show_distrib(test, y_test, '-')
for f in liste_affichage + liste_fonction:
print(f())
show_distrib(test, y_resultat[f()], '--')
def scheme(vowels, congrps_bv, chunks, colorids):
"""
Prints the ARPA with rhyme colors assigned
"""
for j in range(len(vowels)):
print([congrps_bv[j].consonant_list[i].name for i in range(len(congrps_bv[j].consonant_list))], end=" ")
if vowels[j].root_word not in ['a', 'the', 'i', 'of', 'hustle', 'young']:
print(bg(colorids[j][0], colorids[j][1], colorids[j][2]) + str([chunks[j].vowel.name]) +
str([chunks[j].congrp.consonant_list[i].name
for i in range(len(chunks[j].congrp.consonant_list))]) + bg.rs, end=" ")
else:
print(bg(255, 255, 255) +
str([chunks[j].vowel.name]) +
str([chunks[j].congrp.consonant_list[i].name
for i in range(len(chunks[j].congrp.consonant_list))]) + bg.rs, end=" ")
def printColor(self, rgb):
for CLUSTERS in range(len(rgb)):
r = int(rgb[CLUSTERS][0])
g = int(rgb[CLUSTERS][1])
b = int(rgb[CLUSTERS][2])
foo = bg(r, g, b) + ' ' + rs.bg
print(str(CLUSTERS+1) + foo)
def parse_word_val_list(word_list, h, n, val_list):
sum_str = ""
removed_str = ""
token_removed_ct = 0
to_highlight = np.asarray([i for i in val_list if i > h])
scaler = MinMaxScaler(feature_range=(20, 255))
scaler.fit(to_highlight.reshape(-1, 1))
for sum_word in word_list:
if float(sum_word[1]) > h:
if dynamic:
bgnum = int(
scaler.transform(sum_word[1].detach().numpy().reshape(
-1, 1)))
else:
bgnum = 50
sum_str += ef.u + bg(bgnum, bgnum, 0)
runner = par.add_run(sum_word[0] + " ")
runner.underline = True
runner.bold = True
sum_str += " ".join([str(sum_word[0]), rs.all])
elif float(sum_word[1]) > n:
sum_str += ef.u
runner = par.add_run(sum_word[0] + " ")
runner.underline = True
sum_str += " ".join([str(sum_word[0]), rs.all])
else:
token_removed_ct += 1
sum_str += str(sum_word[0])
runner = par.add_run(sum_word[0] + " ")
sum_str += " "
removed_str += str(sum_word[0])
removed_str += " "
return sum_str, removed_str, token_removed_ct
def sgr_bg(names):
items = [bg(name) + ' ' + name.ljust(12) + bg.rs for name in names]
items.insert(8, rs.bg + '\n')
items.insert(16 + 1, rs.fg + '\n')
line = '\nSGR_BG:\n-------\n' + ''.join(items)
return line
def _render(self, text, fg: ColorPoint, bg: ColorPoint = None):
out = ''
out += sty.fg(fg.ansi)
if bg:
out += sty.bg(bg.ansi)
out += text
out += sty.rs.all
return out
def format_string_for_ids(self, fg_id=None, bg_id=None):
s = '{}' + sty.rs.all
if fg_id:
s = sty.fg(fg_id.four_bit_color_name) + s
self.used_color_ids.add(fg_id)
if bg_id:
s = sty.bg(bg_id.four_bit_color_name) + s
self.used_color_ids.add(bg_id)
return s
def __repr__(self) -> str:
"""
formal version of printing tiles
used in terminal version of game
just displays color
"""
color = self.color.value
return str(
bg(color[0], color[1], color[2]) + (" " * self.width) + bg.rs)
def _render(self, text, fg: ColorPoint, bg: ColorPoint = None):
rgb = rgb_to_RGB255(fg.target.rgb)
out = ''
out += sty.fg(*rgb)
if bg:
bgrgb = rgb_to_RGB255(bg.target.rgb)
out += sty.bg(*bgrgb)
out += text
out += sty.rs.all
return out
def convert_truecolor_char(rgba0, rgba1):
top = rgba0[:3]
bottom = rgba1[:3]
char = "▄"
if len(rgba0) > 3 and rgba0[3] == 0:
top = fg.rs
if len(rgba1) > 3 and rgba1[3] == 0:
bottom = bg.rs
char = " "
result = bg(*top) + fg(*bottom) + char + rs.all
return result
def test_dynamic_attr_access(reps):
print("Test Dynamic Attribute Access: ", end="")
start = timer()
for i in range(reps):
f = fg("blue") + "" + rs("fg")
b = bg("green") + "" + rs("bg")
e = ef("underl") + "" + rs("underl")
end = timer()
print(end - start)
def print_attributions(tokens, attributions, special=True):
if not special:
attributions = torch.tensor([
e for e, w in zip(attributions, tokens)
if w not in ("[CLS]", "[SEP]")
])
tokens = [e for e in tokens if e not in ("[CLS]", "[SEP]")]
print(" ".join([
bg(*_get_color(a)) + w + bg.rs
for w, a in zip(tokens, attributions / attributions.max())
]))
class Salyangoz():
def __init__(self, interpreter):
self.__sys = interpreter.sistem
def yaz(self, yazı, stil):
ön = son = ""
if t := stil.get("renk", None):
ön += fg(*t)
son += fg.rs
if t := stil.get("arkaplan", None):
ön += bg(*t)
son += bg.rs
def printColors(self, colors):
block = ' ' + ' ' * 4
out_color = ''
label = ''
for color in colors:
single_c = bg(color[0], color[1], color[2]) + block + bg.rs
out_color += single_c
label += ' #%s ' % self.rgb2hex(color)
for i in range(2):
print(out_color)
print(label)
def sgr_bg():
output = ""
for row_num in range(0, len(GROUPS[0])):
line = ""
for group in GROUPS:
try:
name = group[row_num]
except IndexError:
continue
fore = fg.da_grey if name in ["white", "li_grey"] else ""
line += fore + bg(name) + " " + name.rjust(12) + rs.all
output += line + "\n"
return "\nSGR_BG:\n-------\n" + output
def verbose_status_code(value, elapsed):
if value == 200:
bg_status_code = bg(29, 139, 58)
fg_elapsed = 'green'
else:
bg_status_code = bg.red
fg_elapsed = 'red'
click.secho(' * ', fg='green', nl=False)
click.secho(bg_status_code + fg.white + ' ' + str(value) + ' ' + rs.all,
bold=True,
nl=False)
click.secho(' ' + 'Request status ' + ' ', fg='white', nl=False)
click.secho('- ' + str(elapsed) + '', fg=fg_elapsed)
def check_vulnerability(browser, target, dork):
url = '%s%s site:%s'%(query, dork, target)
browser.get(url)
try:
#Search for reCaptcha
browser.find_element_by_id('captcha-form')
input('\nGoogle is trying to block you... solve captcha and hit enter when ready.\n')
except:
dork = dork.strip()
try:
browser.find_element_by_id('resultStats')
print(bg(1)+fg(15)+"[ *** VULNERABILITY DETECTED! *** ] - %s site:%s"%(dork, target)+fg.rs+bg.rs)
output.append('%s site:%s'%(dork, target))
except:
print('Dork failed - %s site:%s'%(dork, target))
def preview():
print(f"{warn} Preview?")
if (waitConfirm()):
for y in range(im.size[1]):
for x in range(im.size[0]):
#print(f"{x=}{y=}")
c = monochromize(pix[y][x])
#double scale to introduce the flat lose.
c = scaleIntensity(c, 255, intensity)
c = scaleIntensity(c, intensity, 255)
c = monochromize(pix[y][x])
c = bg(c, c, c)
print(c + " ", end='')
print(bg.rs)
def printAttentionedWordsAndSentences(review, all_sent_index, sent_index,
sorted_wordlist, MAX_SENTENCE_NUM):
"""
Utility function for hanPredict that provides a colored terminal printing (thanks to Sty Python library) of most
attentioned sentences and words in a predicted review (with partial weights from attention layers of Han network
model).
:param review: a string of the review.
:param all_sent_index: all sentences index.
:param sent_index: most important sencentences index.
:param sorted_wordlist: most important words list, sorted by importance.
:param MAX_SENTENCE_NUM: same parameter of network.
:return: None
"""
sentences = tokenize.sent_tokenize(review)
all_sent_index = np.array(all_sent_index[:len(sentences)])
nothing = ' '
low = sty.bg(200, 200, 255) + ' ' + sty.bg.rs
medium = sty.bg(100, 100, 255) + ' ' + sty.bg.rs
high = sty.bg(0, 0, 255) + ' ' + sty.bg.rs
high_word, medium_word, low_word = np.array_split(sorted_wordlist, 3)
high_sent, medium_sent, low_sent, nothing_sent = np.array_split(
all_sent_index, 4)
sent_color = nothing
for idx, sent in enumerate(sentences):
if idx in high_sent and idx <= MAX_SENTENCE_NUM:
sent_color = high
elif idx in medium_sent and idx <= MAX_SENTENCE_NUM:
sent_color = medium
elif idx in low_sent and idx <= MAX_SENTENCE_NUM:
sent_color = low
else:
sent_color = nothing
sent_to_print = ''
for idy, word in enumerate(tokenize.word_tokenize(sent)):
if word in high_word and idx in sent_index:
sent_to_print += (sty.bg(255, 70, 70) + word + sty.bg.rs + ' ')
elif word in medium_word and idx in sent_index:
sent_to_print += (sty.bg(255, 140, 140) + word + sty.bg.rs +
' ')
elif word in low_word and idx in sent_index:
sent_to_print += (sty.bg(255, 220, 220) + word + sty.bg.rs +
' ')
else:
sent_to_print += (word + ' ')
print(sent_color, idx, sent_to_print)
def getCanvasText(self):
'''
Return a string representation of the canvas. This string is what will be printed for visuals.
'''
# Allocated all the memory for the string right at the start
resultingString: List[str] = [""] * (self.width * self.height + 2)
# Loop through all the characters of both the string and the formatString, and create the resulting string list
previousTextColor = None
previousBackgroundColor = None
for j in range(self.height):
for i in range(self.width):
character = chr(self.characters[i, j])
textColor = tuple(self.textColors[i, j])
backgroundColor = tuple(self.backgroundColors[i, j])
if not previousTextColor or textColor != previousTextColor:
character = fg(*textColor) + character
previousTextColor = textColor
if not previousBackgroundColor or backgroundColor != previousBackgroundColor:
character = bg(*backgroundColor) + character
previousBackgroundColor = backgroundColor
# If at the beginning of the line, need to include a new line \n to the character
if i == 0:
if "win" in platform.system().lower():
character = "\n" + character
resultingString[j * self.width + i] = character
# Clear the terminal format after each draw
resultingString[-2] = bg.rs
resultingString[-1] = fg.rs
# Add the last
return "".join(resultingString)
def print_stat(content, palette, cat_id_to_color_id):
print(' images:', len(content['images']))
print(' annotations:', len(content['annotations']))
print(' categories:', len(content['categories']))
per_cat_counts = defaultdict(int)
per_cat_occluded_counts = defaultdict(int)
per_cat_is_crowd_counts = defaultdict(int)
for i, ann in enumerate(content['annotations']):
per_cat_counts[ann['category_id']] += 1
if ann.get('is_occluded', False):
per_cat_occluded_counts[ann['category_id']] += 1
if ann['iscrowd']:
per_cat_is_crowd_counts[ann['category_id']] += 1
for i, cat in enumerate(content['categories']):
color = palette[cat_id_to_color_id[cat['id']]]
print(' ', bg(*color) + ' ' + bg.rs + ' ' + str(cat) +
f' objects {per_cat_counts[cat["id"]]}'
f' occluded {per_cat_occluded_counts[cat["id"]]}'
f' is_crowd {per_cat_is_crowd_counts[cat["id"]]}')
def get_str_representation(self):
rows = ''
for r in range(self.height):
for c in range(self.width):
color_decider=randint(0,25)
if self.dungeon[r][c]=='#':
if color_decider<=8:
rows+= fg(22)+bg(22)+self.dungeon[r][c]+rs.bg
elif color_decider>12 and color_decider<=20:
rows+= fg(236)+bg(236)+self.dungeon[r][c]+rs.bg
else:
rows+= fg(237)+bg(237)+self.dungeon[r][c]+rs.bg
else:
if color_decider<=14:
rows+= fg(242)+bg(242)+self.dungeon[r][c]+rs.bg
elif color_decider>14 and color_decider<=20:
rows+= fg(243)+bg(243)+self.dungeon[r][c]+rs.bg
else:
rows+= fg(244)+bg(244)+self.dungeon[r][c]+rs.bg
rows+='\n'
return rows
def draw(self, idx):
if self.values[idx]:
return bg(self.color) + " " + rs.bg
return " "
def make_marker(label, ground_truth):
if label == "reject":
return bg("da_black") + " " + rs.bg
return marker(label == ground_truth)
# Add custom colors:
from sty import Style, RgbFg
fg.orange = Style(RgbFg(255, 150, 50))
buf = fg.orange + 'Yay, Im orange.' + fg.rs
print(foo, bar, baz, qux, qui, buf, sep='\n')
# ===== End =====
# ===== Start =====
Example("gettings started: select dynamically")
a = ef('italic') + 'Italic text.' + rs.italic
b = fg('blue') + 'Blue text.' + rs.fg
c = bg(randint(0, 254)) + 'Random colored bg' + rs.bg
print(a, b, c, sep='\n')
# ===== End =====
# ===== Start =====
Example("gettings started: select 8bit and 24bit directly")
# select an 8bit color directly.
a = fg(196) + 'This is red text' + rs.fg
# select a 24bit rgb color directly.
b = bg(50, 255, 50) + 'Text with green bg' + rs.bg
print(a, b, sep='\n')
# ===== End =====
def marker(correct):
return bg("da_green" if correct else "da_red") + " " + rs.bg
