def dump_all(out_dir, heatmaps):
stats = {}
t = Terminal()
t.clear()
sys.stdout.write("\x1b[2J\x1b[H")
print('{t.underline}{outdir}{t.normal}\n'.format(t=t, outdir=out_dir))
keys = list(heatmaps.keys())
keys.sort()
for layer in keys:
if len(heatmaps[layer].log) == 0:
continue
with open("%s/%s.json" % (out_dir, layer), "w") as f:
json.dump(heatmaps[layer].get_heatmap(), f)
stats[layer] = heatmaps[layer].get_stats()
left = stats[layer]['hands']['left']
right = stats[layer]['hands']['right']
print('{t.bold}{layer}{t.normal} ({total:,} taps):'.format(
t=t, layer=layer, total=int(stats[layer]['total-keys'] / 2)))
print (('{t.underline} | ' + \
'left ({l[usage]:6.2f}%) | ' + \
'right ({r[usage]:6.2f}%) |{t.normal}').format(t=t, l=left, r=right))
print ((' {t.bright_magenta}pinky{t.white} | {left[pinky]:6.2f}% | {right[pinky]:6.2f}% |\n' + \
' {t.bright_cyan}ring{t.white} | {left[ring]:6.2f}% | {right[ring]:6.2f}% |\n' + \
' {t.bright_blue}middle{t.white} | {left[middle]:6.2f}% | {right[middle]:6.2f}% |\n' + \
' {t.bright_green}index{t.white} | {left[index]:6.2f}% | {right[index]:6.2f}% |\n' + \
' {t.bright_red}thumb{t.white} | {left[thumb]:6.2f}% | {right[thumb]:6.2f}% |\n' + \
'').format(left=left['fingers'], right=right['fingers'], t=t))
def dump_all(out_dir, heatmaps):
stats = {}
t = Terminal()
t.clear()
sys.stdout.write("\x1b[2J\x1b[H")
print ('{t.underline}{outdir}{t.normal}\n'.format(t=t, outdir=out_dir))
keys = list(heatmaps.keys())
keys.sort()
for layer in keys:
if len(heatmaps[layer].log) == 0:
continue
with open ("%s/%s.json" % (out_dir, layer), "w") as f:
json.dump(heatmaps[layer].get_heatmap(), f)
stats[layer] = heatmaps[layer].get_stats()
left = stats[layer]['hands']['left']
right = stats[layer]['hands']['right']
print ('{t.bold}{layer}{t.normal} ({total:,} taps):'.format(t=t, layer=layer,
total=int(stats[layer]['total-keys'] / 2)))
print (('{t.underline} | ' + \
'left ({l[usage]:6.2f}%) | ' + \
'right ({r[usage]:6.2f}%) |{t.normal}').format(t=t, l=left, r=right))
print ((' {t.bright_magenta}pinky{t.white} | {left[pinky]:6.2f}% | {right[pinky]:6.2f}% |\n' + \
' {t.bright_cyan}ring{t.white} | {left[ring]:6.2f}% | {right[ring]:6.2f}% |\n' + \
' {t.bright_blue}middle{t.white} | {left[middle]:6.2f}% | {right[middle]:6.2f}% |\n' + \
' {t.bright_green}index{t.white} | {left[index]:6.2f}% | {right[index]:6.2f}% |\n' + \
' {t.bright_red}thumb{t.white} | {left[thumb]:6.2f}% | {right[thumb]:6.2f}% |\n' + \
'').format(left=left['fingers'], right=right['fingers'], t=t))
def dump_all(out_dir, heatmaps, save):
stats = {}
t = Terminal()
t.clear()
sys.stdout.write("\x1b[2J\x1b[H")
print('{t.underline}{outdir}{t.normal}\n'.format(t=t, outdir=out_dir))
keys = list(heatmaps.keys())
keys.sort()
to_log = {}
fingers = [
('pinky', t.bright_magenta),
('ring', t.bright_cyan),
('middle', t.bright_blue),
('index', t.bright_green),
('thumb', t.bright_red)
]
output_file_str = '{output_dir}/{layer}.json'
for layer in keys:
if len(heatmaps[layer].log) == 0:
continue
output_file = output_file_str.format(output_dir=out_dir, layer=layer)
with open(output_file, 'w') as file:
json.dump(heatmaps[layer].get_heatmap(out_dir), file)
to_log[layer] = heatmaps[layer].get_dict()
stats[layer] = heatmaps[layer].get_stats()
left = stats[layer]['hands']['left']
right = stats[layer]['hands']['right']
print(
'{t.bold}{layer}{t.normal} ({total:,} taps):'.format(
t=t, layer=layer, total=int(stats[layer]['total-keys'])
)
)
print(
'{t.underline:12s}| left ({left:7.2%}) | right ({right:7.2%}) |{t.normal}'.format(
t=t, left=left['usage']/100, right=right['usage']/100
)
)
finger_row = ' {color}{finger:>6s}{t.white} | {left:^15.2%} | {right:^15.2%} |'
for finger, color in fingers:
left_val = left['fingers'][finger]/100
right_val = right['fingers'][finger]/100
print(finger_row.format(left=left_val, right=right_val, t=t, color=color, finger=finger))
print()
if save:
save_file = '{output_dir}/heatmap_data.json'.format(output_dir=out_dir)
with open(save_file, 'w') as file:
json.dump(to_log, file)
def tie_a_tie():
"""
Interactive tie tying.
"""
def throw():
print(term.clear())
with term.location(10, term.height):
print("Please enter a valid choice.")
sleep(1)
print(term.clear())
def start_knot():
print(term.clear())
starting_point = input("Start in or out? ").lower()
if starting_point in ["i", "in"]:
return Knot('Li')
elif starting_point in ["o", "out"]:
return Knot('Lo')
else:
return Knot()
term = Terminal()
with term.location(0,0):
tie = start_knot()
while tie.final() != 'Ti':
print(term.clear())
choices = tie.legal_intersection()
tie_str = str(tie)
try:
while True:
with term.location(0,3):
possibilities = [name for walk, name in NAMED_KNOTS.items() if tie_str == walk[:len(tie_str)]]
print("\nPossible knots:\n{}\n".format("\n".join(possibilities)))
next_step = input("Your knot so far: {}\nNext step ({}{}): "
.format(tie_str, choices, " back" if len(tie) > 1 else "")).title()
if next_step == "Back" and len(tie) > 1:
tie.pop()
break
if next_step == "Back" and len(tie) == 1:
tie = start_knot()
break
if next_step in choices:
tie.append(next_step)
break
if not next_step:
tie.append(choices[0])
break
else:
throw()
except:
throw()
print(term.clear())
tie.analyze()
class Renderer():
"""renders a grid with values (for the gridworld)"""
cell_width = 7
cell_height = 3
def __init__(self, grid):
self.term = Terminal()
self.grid = grid
def _draw_cell(self, x, y, color, value, pos):
x_mid = math.floor(self.cell_width / 2)
y_mid = math.floor(self.cell_height / 2)
for i in range(self.cell_width):
for j in range(self.cell_height):
char = ' '
print(
self.term.move(y + j, x + i) + self.term.on_color(color) +
'{}'.format(char) + self.term.normal)
v = str(value)
cx = x_mid + x
cy = y_mid + y
offset = len(v) // 2
if value is None:
highlight = 230
elif value < 0:
highlight = 1
elif value > 0:
highlight = 34 # 2
else:
highlight = 245
for i, char in enumerate(v):
x = cx - offset + i
print(
self.term.move(cy, x) + self.term.on_color(color) +
self.term.color(highlight) + char + self.term.normal)
print(
self.term.move(y, x) + self.term.on_color(color) +
self.term.color(248) + '{},{}'.format(*pos) + self.term.normal)
def render(self, pos=None):
"""renders the grid,
highlighting the specified position if there is one"""
print(self.term.clear())
for r, row in enumerate(self.grid):
for c, val in enumerate(row):
if val is None:
# continue # uncomment this if holes should be nothing
color = 160
else:
color = 252 if (r + c) % 2 == 0 else 253
if pos is not None and pos == (r, c):
color = 4
self._draw_cell(c * self.cell_width, r * self.cell_height,
color, val, (r, c))
# move cursor to end
print(self.term.move(len(self.grid) * self.cell_height, 0))
def niceEndless(ser, cockpitAddress): t = Terminal() with t.fullscreen(): while True: print t.clear() runData = getRunDaten(ser, cockpitAddress) with t.location(10, 2): print "Person: " + C_PERSONS[runData[C_RUN_PERSON]] with t.location(10, 3): print "Programm: " + str(runData[C_RUN_PROGRAM]) with t.location(10, 4): progressBar = " " + "#" * (runData[C_RUN_RPM] / 2) print "Umdrehungen: " + str(runData[C_RUN_RPM]) + " [" + progressBar with t.location(124, 4): print "]" time.sleep(1)
def select_chromecast(cls):
name = None
chromecasts = pychromecast.get_chromecasts_as_dict().keys()
if not chromecasts:
return
if len(chromecasts) > 1:
term = Terminal()
print(term.clear())
print(term.bold("Touchandgo\n"))
print(term.red("Chromecasts Availables"))
for i, cc_name in enumerate(chromecasts, 1):
option = term.cyan("%s) " % i)
option += cc_name
print(option)
input_text = "Select which chromecast you want to cast (1-%d): " % \
len(chromecasts)
user_input = raw_input(input_text)
try:
opt = int(user_input) - 1
if opt > len(chromecasts) or opt < 1:
opt = 0
except ValueError:
opt = 0
name = chromecasts[opt]
elif len(chromecasts) == 1:
name = chromecasts[0]
return name
class ColorTerminal(object) :
def __init__ (self,nocolor=False) :
self.term = None
if not nocolor :
try :
# https://pypi.python.org/pypi/blessings/
from blessings import Terminal
self.term = Terminal ()
except :
logging.info("blessings module isn't available thus no color")
def __getattr__(self, attr) :
if self.term and attr != 'default':
return getattr(self.term,attr)
else :
return self._nocolorterm
def clear_sceeen(self) :
if self.term :
sys.stdout.write(self.term.clear())
else :
os.system('clear')
@staticmethod
def screen_size() :
rows, columns = os.popen('stty size', 'r').read().split()
return int(rows), int(columns)
@staticmethod
def _nocolorterm(*pars) :
if len(pars) == 1 :
return pars[0]
class Terminal:
def __init__(self):
self._term = BlessingsTerm()
def __getattribute__(self, name):
if name in (
'black',
'red',
'green',
'yellow',
'blue',
'magenta',
'cyan',
'white',
'bold',
'reverse',
'underline',
'no_underline',
'blink',
'normal',
):
return getattr(self._term, name)
else:
return super().__getattribute__(name)
def display(self, val, color=None):
if color:
print(color, end='')
print(val, end='')
if color:
print(self._term.normal, end='')
def clear(self):
self.display(self._term.clear())
def move(self, row_or_location, column=None):
if isinstance(row_or_location, Location):
if column is not None:
raise ValueError('column cannot be provided with a Location')
self.display(self._term.move(*row_or_location))
elif column is None:
raise ValueError('column must be provided when used without a Location')
else:
self.display(self._term.move(row_or_location, column))
def move_right(self):
self.display(self._term.move_right)
def move_left(self):
self.display(self._term.move_left)
def move_up(self):
self.display(self._term.move_up)
def move_down(self):
self.display(self._term.move_down)
class ConsoleWindow(object):
""" Represents the Console Window displayed to the user """
def __init__(self):
""" Build the window """
self.screen = None
self.terminal = Terminal()
self.write(self.terminal.enter_fullscreen())
self.write(self.terminal.hide_cursor())
def close(self):
self.write(self.terminal.exit_fullscreen())
self.write(self.terminal.normal_cursor())
@property
def width(self):
""" Return the width of the window """
return self.terminal.width
@property
def height(self):
""" Return the height of the window """
return self.terminal.height
def setScreen(self, screen):
""" Sets the current Screen Display """
self.screen = screen
self.clear()
def update(self):
""" Update the screen """
self.screen.update()
self.screen.draw(self)
def draw(self):
""" Draw the Screen """
self.screen.draw()
def clear(self):
""" Clears the window """
print self.terminal.clear()
def write(self, string):
""" Write the string directly to stdout """
sys.stdout.write(string)
class ConsoleWindow(object):
""" Represents the Console Window displayed to the user """
def __init__(self):
""" Build the window """
self.screen = None
self.terminal = Terminal()
self.write(self.terminal.enter_fullscreen())
self.write(self.terminal.hide_cursor())
def close(self):
self.write(self.terminal.exit_fullscreen())
self.write(self.terminal.normal_cursor())
@property
def width(self):
""" Return the width of the window """
return self.terminal.width
@property
def height(self):
""" Return the height of the window """
return self.terminal.height
def setScreen(self, screen):
""" Sets the current Screen Display """
self.screen = screen
self.clear()
def update(self):
""" Update the screen """
self.screen.update()
self.screen.draw(self)
def draw(self):
""" Draw the Screen """
self.screen.draw()
def clear(self):
""" Clears the window """
print self.terminal.clear()
def write(self, string):
""" Write the string directly to stdout """
sys.stdout.write(string)
class ConsoleWindow(object):
""" Represents the Console Window displayed to the user """
def __init__(self):
""" Build the window """
self.screen = None
self.terminal = Terminal()
print self.terminal.enter_fullscreen()
print self.terminal.hide_cursor()
def close(self):
print self.terminal.exit_fullscreen()
print self.terminal.normal_cursor()
def getWidth(self):
""" Return the width of the window """
return self.terminal.width
def getHeight(self):
""" Return the height of the window """
return self.terminal.height
def setScreen(self, screen):
""" Sets the current Screen Display """
self.screen = screen
window.clear()
def update(self):
""" Update the screen """
self.screen.update()
self.screen.draw(self)
def draw(self, text, pos):
""" Draws the text to the window """
lineNum = pos[1]
for line in text:
with self.terminal.location(int(pos[0]), int(lineNum)):
print line
lineNum += 1
def clear(self):
""" Clears the window """
print self.terminal.clear()
class Screen(object):
def __init__(self):
self.term = Terminal()
self.top_lines = {}
self.bottom_lines = {}
self.next_line_top = 0
self.next_line_bottom = 1
print self.term.enter_fullscreen()
def redraw(self):
print self.term.clear()
for n, line in self.top_lines.iteritems():
with self.term.location(0, n):
for component in line:
print str(component),
for n, line in self.bottom_lines.iteritems():
with self.term.location(0, self.term.height - n):
for component in line:
print str(component),
sys.stdout.flush()
def add_line(self, line, to_bottom=False):
if to_bottom is False:
self.top_lines[self.next_line_top] = line
self.next_line_top += 1
else:
self.bottom_lines[self.next_line_bottom] = line
self.next_line_bottom += 1
def add_component(self, component, to_bottom=False):
if to_bottom is False:
self.top_lines[self.next_line_top] = Line(comp=component)
self.next_line_top += 1
else:
self.bottom_lines[self.next_line_bottom] = Line(comp=component)
self.next_line_bottom += 1
def exit(self):
print self.term.clear()
print self.term.exit_fullscreen()
class ConsoleWindow(object):
""" Represents the Console Window displayed to the user """
def __init__(self):
""" Build the window """
self.screen = None
self.terminal = Terminal()
print self.terminal.enter_fullscreen()
print self.terminal.hide_cursor()
def close(self):
print self.terminal.exit_fullscreen()
print self.terminal.normal_cursor()
def getWidth(self):
""" Return the width of the window """
return self.terminal.width
def getHeight(self):
""" Return the height of the window """
return self.terminal.height
def setScreen(self, screen):
""" Sets the current Screen Display """
self.screen = screen
window.clear()
def update(self):
""" Update the screen """
self.screen.update()
self.screen.draw(self)
def draw(self, text, pos):
""" Draws the text to the window """
lineNum = pos[1]
for line in text:
with self.terminal.location(int(pos[0]), int(lineNum)):
print line
lineNum += 1
def clear(self):
""" Clears the window """
print self.terminal.clear()
class Renderer():
cell_width = 7
cell_height = 3
def __init__(self, game):
self.term = Terminal()
self.game = game
def _draw_cell(self, x, y, color, values=None):
x_mid = math.floor(self.cell_width/2)
y_mid = math.floor(self.cell_height/2)
for i in range(self.cell_width):
for j in range(self.cell_height):
char = ' '
if values is not None:
if i == x_mid and j == 0:
char = values[0]
elif j == y_mid and i == self.cell_width-1:
char = values[1]
elif i == x_mid and j == self.cell_height-1:
char = values[2]
elif j == y_mid and i == 0:
char = values[3]
print(self.term.move(y+j, x+i) + self.term.on_color(color) + '{}'.format(char) + self.term.normal)
def render(self):
print(self.term.clear())
self._render_board()
self._render_cards()
def _render_board(self):
for row in range(self.game.rows):
for col in range(self.game.cols):
card = self.game.board[row, col]
if card is None:
color = 250 if (row + col) % 2 == 0 else 253
values = None
else:
color = card.player.color
values = card.values
self._draw_cell(row * self.cell_width, col * self.cell_height, color, values=values)
def _render_cards(self):
padding = 1
y = self.cell_height * self.game.rows
cell_mid = math.floor(self.cell_width/2)
for player in self.game.players:
y += padding
print(self.term.move(y, 0) + '{}'.format(player))
y += 1
for j, card in enumerate(player.unplayed_cards):
self._draw_cell(j * (self.cell_width + 1), y, player.color, card.values)
print(self.term.move(y + self.cell_height, j * (self.cell_width + 1) + cell_mid) + str(j))
y += self.cell_height + 1
def print_formatted(self,
fp=sys.stdout,
force_color=False,
no_color=False,
show_cmd=False,
show_user=False,
show_pid=False,
show_power=None,
gpuname_width=16,
show_header=True,
clear_term=False,
**kwargs):
# ANSI color configuration
if force_color and no_color:
raise ValueError(
"--color and --no_color can't be used at the same time")
if force_color:
t_color = Terminal(kind='xterm-color', force_styling=True)
elif no_color:
t_color = Terminal(force_styling=None)
else:
t_color = Terminal() # auto, depending on isatty
if clear_term:
print(t_color.clear())
# header
if show_header:
time_format = locale.nl_langinfo(locale.D_T_FMT)
header_msg = '{t.bold_white}{hostname}{t.normal} {timestr}'.format(
**{
'hostname': self.hostname,
'timestr': self.query_time.strftime(time_format),
't': t_color,
})
fp.write(header_msg)
fp.write('\n')
# body
gpuname_width = max([gpuname_width] +
[len(g.entry['name']) for g in self])
for g in self:
g.print_to(fp,
show_cmd=show_cmd,
show_user=show_user,
show_pid=show_pid,
show_power=show_power,
gpuname_width=gpuname_width,
term=t_color)
fp.write('\n')
fp.flush()
class StatusDisplay(Thread):
def __init__(self, qla_data, status_data, stop_event, logfile=None):
self.status_data = status_data
self.qla_data = qla_data
self.term = Terminal()
self.stop_event = stop_event
self.logfile = logfile
super(StatusDisplay, self).__init__()
def run(self):
with self.term.fullscreen(), self.term.hidden_cursor():
print(self.term.clear())
while not self.stop_event.is_set():
self.update_status()
self.stop_event.wait(5)
def update_status(self):
print(self.term.clear())
print(self.term.move(0, 0) + self.term.cyan(timestamp()))
print(self.term.move(2, 0) + 'System Status')
for i, (key, val) in enumerate(six.iteritems(self.status_data)):
print(self.term.move(3+i, 0) + u'{:<20} {:>6} {:<6}'.format(
key, *val
))
print(self.term.move(2, 40) + 'Maximum Source Activity')
for i, (key, val) in enumerate(six.iteritems(self.qla_data)):
print(self.term.move(3+i, 40) + u'{:<20} {:>6} {:<6}'.format(
key, *val
))
if self.logfile is not None:
logs = check_output('tail -n20 {}'.format(self.logfile), shell=True)
n_lines = term.height - 15
loglines = list(
reversed(logs.decode('utf-8').splitlines())
)[:n_lines]
print(self.term.move(14, 0) + '\n'.join(loglines))
class Renderer():
"""renders a grid with values"""
cell_width = 7
cell_height = 3
def __init__(self, grid):
self.term = Terminal()
self.grid = grid
def _draw_cell(self, x, y, color, value, pos):
x_mid = math.floor(self.cell_width/2)
y_mid = math.floor(self.cell_height/2)
for i in range(self.cell_width):
for j in range(self.cell_height):
char = ' '
print(self.term.move(y+j, x+i) + self.term.on_color(color) + '{}'.format(char) + self.term.normal)
v = str(value)
cx = x_mid + x
cy = y_mid + y
offset = len(v)//2
if value < 0:
highlight = 1
elif value > 0:
highlight = 2
else:
highlight = 245
for i, char in enumerate(v):
x = cx - offset + i
print(self.term.move(cy, x) + self.term.on_color(color) + self.term.color(highlight) + char + self.term.normal)
print(self.term.move(y, x) + self.term.on_color(color) + self.term.color(248) + '{},{}'.format(*pos) + self.term.normal)
def render(self, pos=None):
"""renders the grid,
highlighting the specified position if there is one"""
print(self.term.clear())
for r, row in enumerate(self.grid):
for c, val in enumerate(row):
if val is None:
continue
color = 252 if (r + c) % 2 == 0 else 253
if pos is not None and pos == (r, c):
color = 4
self._draw_cell(c * self.cell_width, r * self.cell_height, color, val, (r,c))
# move cursor to end
print(self.term.move(len(self.grid) * self.cell_height, 0))
else:
shutil.rmtree(ARGS.tempdir)
os.makedirs(ARGS.tempdir)
interpolation = configparser.ExtendedInterpolation()
cfg = configparser.ConfigParser(interpolation=interpolation)
cfg.read(ARGS.config)
if ARGS.logfile is not None:
logging.basicConfig(filename=ARGS.logfile, level=logging.DEBUG,)
else:
logging.basicConfig(filename=cfg['log']['logfile'], level=logging.DEBUG,)
logging.info('START LOG FILE : ' + time.strftime("%c"))
TERM = Terminal()
print(TERM.clear())
tasks_queue = mp.Queue()
done_queue = mp.Queue()
processpool = []
for i in range(ARGS.nr_workers):
p = mp.Process(target=worker, args=(tasks_queue, done_queue)).start()
processpool.append(p)
def job_to_tasks(job):
""" Seperates a job into tasks. """
tasks = []
for index, T in enumerate(numpy.linspace(float(cfg[job]['mintemp']),
float(cfg[job]['maxtemp']),
def start(self):
# Parse args
global args, APs
args = parse_args()
# Check args
check_args(args)
# Are you root?
if os.geteuid():
sys.exit('[' + R + '-' + W + '] Please run as root')
self.network_manager.start()
# 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:
if self.network_manager.is_interface_valid(
args.internetinterface, "internet"):
internet_interface = args.internetinterface
self.network_manager.unblock_interface(internet_interface)
if not args.nojamming:
if args.jamminginterface and args.apinterface:
if self.network_manager.is_interface_valid(
args.jamminginterface, "monitor"):
mon_iface = args.jamminginterface
self.network_manager.unblock_interface(mon_iface)
if self.network_manager.is_interface_valid(
args.apinterface, "AP"):
ap_iface = args.apinterface
else:
mon_iface, ap_iface = self.network_manager.get_interface_automatically(
)
# 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, ap_iface)
# randomize the mac addresses
if not args.no_mac_randomization:
if args.mac_ap_interface:
self.network_manager.set_interface_mac(
ap_iface, args.mac_ap_interface)
else:
self.network_manager.set_interface_mac_random(ap_iface)
if args.mac_deauth_interface:
self.network_manager.set_interface_mac(
mon_iface, args.mac_deauth_interface)
else:
self.network_manager.set_interface_mac_random(
mon_iface)
else:
if args.apinterface:
if self.network_manager.is_interface_valid(
args.apinterface, "AP"):
ap_iface = args.apinterface
else:
ap_iface = self.network_manager.get_interface(True, False)
mon_iface = ap_iface
if not args.no_mac_randomization:
if args.mac_ap_interface:
self.network_manager.set_interface_mac(
ap_iface, args.mac_ap_interface)
else:
self.network_manager.set_interface_mac_random(ap_iface)
print(
"[{0}+{1}] Selecting {0}{2}{1} interface for creating the "
"rogue Access Point").format(G, W, ap_iface)
# randomize the mac addresses
if not args.no_mac_randomization:
self.network_manager.set_interface_mac_random(ap_iface)
# make sure interfaces are not blocked
self.network_manager.unblock_interface(ap_iface)
self.network_manager.unblock_interface(mon_iface)
if not args.internetinterface:
kill_interfering_procs()
self.network_manager.set_interface_mode(mon_iface, "monitor")
except (interfaces.InvalidInterfaceError,
interfaces.InterfaceCantBeFoundError,
interfaces.InterfaceManagedByNetworkManagerError) as err:
print("[{0}!{1}] {2}").format(R, W, err)
time.sleep(1)
self.stop()
if not args.no_mac_randomization:
ap_mac = self.network_manager.get_interface_mac(ap_iface)
print "[{0}+{1}] {2} mac address becomes is now {3} ".format(
G, W, ap_iface, ap_mac)
if not args.nojamming:
mon_mac = self.network_manager.get_interface_mac(mon_iface)
print("[{0}+{1}] {2} mac address becomes {3}".format(
G, W, mon_iface, mon_mac))
if args.internetinterface:
self.fw.nat(ap_iface, args.internetinterface)
set_ip_fwd()
else:
self.fw.redirect_requests_localhost()
set_route_localnet()
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,
self.network_manager)
# 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)
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.internetinterface)
print '[' + T + '*' + W + '] Starting the fake access point...'
try:
self.access_point.start()
self.access_point.start_dhcp_dns()
except BaseException:
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 = []
if not args.nojamming:
# Start Extension Manager
shared_data = {
'target_ap_channel': channel or "",
'target_ap_essid': essid or "",
'target_ap_bssid': ap_mac or "",
'target_ap_encryption': enctype or "",
'target_ap_logo_path': ap_logo_path or "",
'rogue_ap_mac': ap_mac,
'APs': APs_context,
'args': args
}
self.em.set_interface(mon_iface)
extensions = DEFAULT_EXTENSIONS
if args.lure10_exploit:
extensions.append(LURE10_EXTENSION)
self.em.set_extensions(extensions)
self.em.init_extensions(shared_data)
self.em.start_extensions()
# Main loop.
try:
term = Terminal()
with term.fullscreen():
while True:
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
print term.move(5, term.width - 30) + "|" + "_" * 29
print term.move(
1, 0) + term.blue("Deauthenticating clients: ")
if not args.nojamming:
# show the 5 most recent entries
for line in self.em.get_output()[-5:]:
print line
print term.move(7, 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(8, 0) + proc
print term.move(14, 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(15, 0) + proc
if phishinghttp.terminate and args.quitonsuccess:
raise KeyboardInterrupt
except KeyboardInterrupt:
self.stop()
import socket
import sys
from string import printable
from blessings import Terminal
term = Terminal()
username = sys.argv[1]
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
with term.fullscreen():
while True:
print(term.clear() + '>>> ', end='')
msg = input()
if msg.rstrip("\n\r") != '':
payload = "{} {}".format(username, msg)
client.sendto(payload.encode(), ('<broadcast>', 34567))
#!/usr/bin/env python3
#25 May 2018, Lab 31 'defining functions'
from blessings import Terminal #blessings is some thing made by some dude named Kevin that makes it a lot easier for us to manipulate (among other things) the terminal
import os # more imported tools/libraries(?)
import sys
t = Terminal() #set variable to save typing time
print(t.clear()) #terminal.clear() is like entering $clear
def close(event): #I'm not sure what this does
master.withdraw()
sys.exit()
def yellow_wp(p): #function with-parameters, prints text in color
print(t.bold_black_on_yellow(p))
def trx(p): # function that right-aligns string p in terminal window
x = t.width - len(p)
return int(x)
def top_right(p): # function to execute yellow_wp(p) function in top right
with t.location(trx(p), 0):
yellow_wp(p)
def prompt_location(
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$.............$$$$$$$$$$$$$$$$$$$$$$$$$'''
welcome = term.clear() + '''\n\n
~~~~~~~~~~~~ WELCOME TO TERMCHAT ~~~~~~~~~~~
~~~ facebook messenger for your terminal ~~~
\n\n\n\n\n\n\n'''
class FBChat(Client):
def login(self, email, password, max_tries):
self.onLoggingIn(email=email)
self.email = email
self.password = password
login_successful, login_url = self._login()
def control_led_by_pot():
try:
while True:
knob_val = adc.read_oneshot(POTI)
print("Pot value is", hex(knob_val))
pct_full_scale = min(1.0, knob_val / 0x4fffff)
print("Pot % is", pct_full_scale)
dac.write_dac(DAC_A, DEFAULT_LED_BIAS + int(LED_RANGE*pct_full_scale))
except (KeyboardInterrupt):
print("\n" * 8 + "User exit.\n")
return
print(term.clear() + term.bold_red_on_bright_green(' Wavefront ADC/DAC Board with PiGPIO Demo '))
host = input('Raspberry Pi hostname (enter for localhost):')
hostName = host if host else 'localhost'
print(term.blue('Connecting to'), term.bold(hostName))
pi = io.pi(host)
if not pi.connected:
print(term.white_on_red("Could not connect to PiGPIO target " + hostName + "!"))
sys.exit(-1)
print(term.dim('...connection established'))
adc = ADS1256(pi=pi)
# calibrate
adc.cal_self()
dac = DAC8552(pi=pi)
def on_close(ws):
print "### closed ###"
def on_open(ws):
def run(*args):
while True:
time.sleep(1)
print "thread terminating..."
thread.start_new_thread(run, ())
if __name__ == "__main__":
try:
t.enter_fullscreen()
print t.clear()
#websocket.enableTrace(True)
ws = websocket.WebSocketApp("wss://az.skyhunter.ca:8083/",
on_message=on_message,
on_error=on_error,
on_close=on_close)
ws.on_open = on_open
ws.run_forever(sslopt={"cert_reqs": ssl.CERT_NONE})
except:
print t.normal
t.exit_fullscreen()
print t.clear()
exit()
if ICMP in pkt:
# print " ICMP"
sendled(68686)
def handle_error(self,request,client_address): # All callbacks
pass
with term.fullscreen():
print term.on_black('Ok:'+args.interface)
sleep(2)
print(term.clear())
#sniff(iface=args.interface, prn=print_summary, store=0,filter="not (host 192.168.1.42 and not port 22)")
sniff(iface=args.interface, prn=print_summary, store=0,filter=args.filter)
time.sleep(2)
print term.normal
term.exit_fullscreen
if key == keyboard.Key.esc: ## Esc:
running = False ## Finish the app
listener = keyboard.Listener(on_press=on_press, on_release=None)
## GAME
listener.start()
won = ''
running = True
while running:
# system('clear')
print(term.clear() + '') ## Use that instead if ur allergic to `os.system`
print('Press YOUR button to progress YOUR bar\n')
progress = []
for letter in board.keys():
amount = board[letter]
progress.append(
f'{letter} [{"=" * amount}{"-" * (bar_size - amount)}]')
for line in progress:
print(line)
if line.count('=') >= bar_size:
won = line[0]
if won:
my_input = sys.stdin.readline()
return # RETURN
loop = asyncio.get_event_loop()
checkout_path = sys.argv[1]
tasks = []
tasks.append(run_waf(checkout_path, "opt_exc_mt", target="bsls"))
tasks.append(run_waf(checkout_path, "dbg_exc_mt_64", target="bslscm"))
tasks.append(run_waf(checkout_path, "dbg_exc_mt_cpp11", target="bsls"))
print(term.clear())
with term.location(1, (LineProcessor.position + 2) * 2):
with term.hidden_cursor():
try:
loop.run_until_complete(asyncio.wait(tasks))
except e:
print("Failed with exception:")
print(e)
loop.close()
print(term.move(1, 50))
if debug_mode:
print("Hit enter to exit")
elif selection == '2': # if user wishes to exit to main menu
break
else: # if anything else then loop
print('Invalid selection')
def print_entrys(): # function for printing the inventory
print('\nItem\t\tLocation')
print('----\t\t--------')
with open(filename, 'r') as myfile: # open file with implied close (with)
myDict = json.loads(myfile.read()) # read file into a dictionary
for itm, loc in myDict.items(): # loop through dictionary
print(itm + '\t\t' + loc) # print dictionary item
input('\nPress enter to continue') # wait for user before continuing
while True:
print(t.clear()) # clear screen
print('\nInventory Tracker 1.0\n')
print('Main Menu:\n') # print main menu
print(' 1 - Create or modify an entry')
print(' 2 - Search for an entry')
print(' 3 - Print inventory')
print(' q - Quit')
menu_selection = input('\nPlease enter a selection: ') # get user input
if menu_selection.lower() == 'q': # if user enters 'q' then quit
break
elif menu_selection == '1': # if user wishes to add/modify an entry
new_item = input('Please enter an item: ')
new_location = input('Please enter the location: ')
def run():
print ('[' + T + '*' + W + '] Starting Wifiphisher %s at %s' %
(VERSION, time.strftime("%Y-%m-%d %H:%M")))
# Parse args
global args, APs, clients_APs, mon_MAC, mac_matcher, hop_daemon_running
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
network_manager = interfaces.NetworkManager()
mac_matcher = macmatcher.MACMatcher(MAC_PREFIX_FILE)
# get interfaces for monitor mode and AP mode and set the monitor interface
# to monitor mode. shutdown on any errors
try:
if not args.nojamming:
if args.jamminginterface and args.apinterface:
mon_iface = network_manager.get_jam_iface(
args.jamminginterface)
ap_iface = network_manager.get_ap_iface(args.apinterface)
else:
mon_iface, ap_iface = network_manager.find_interface_automatically()
network_manager.set_jam_iface(mon_iface.get_name())
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())
else:
if args.apinterface:
ap_iface = network_manager.get_ap_iface(
interface_name=args.apinterface)
else:
ap_iface = network_manager.get_ap_iface()
mon_iface = ap_iface
network_manager.set_ap_iface(ap_iface.get_name())
print ("[{0}+{1}] Selecting {0}{2}{1} interface for creating the "
"rogue Access Point").format(G, W, ap_iface.get_name())
kill_interfering_procs()
# set monitor mode to monitor interface
network_manager.set_interface_mode(mon_iface, "monitor")
except (interfaces.NotEnoughInterfacesFoundError,
interfaces.JammingInterfaceInvalidError,
interfaces.ApInterfaceInvalidError,
interfaces.NoApInterfaceFoundError,
interfaces.NoMonitorInterfaceFoundError) as err:
print ("[{0}!{1}] " + str(err)).format(R, W)
time.sleep(2)
shutdown()
set_fw_rules()
set_kernel_var()
network_manager.up_ifaces([ap_iface, mon_iface])
print '[' + T + '*' + W + '] Cleared leases, started DHCP, set up iptables'
if args.essid:
essid = args.essid
channel = str(CHANNEL)
args.accesspoint = False
args.channel = False
ap_mac = None
enctype = None
else:
# Copy AP
time.sleep(3)
hop = Thread(target=channel_hop, args=(mon_iface,))
hop.daemon = True
hop.start()
sniffing(mon_iface.get_name(), targeting_cb)
channel, essid, ap_mac, enctype = copy_AP()
args.accesspoint = ap_mac
args.channel = channel
hop_daemon_running = False
# get the correct template
template = select_template(args.phishingscenario)
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': mac_matcher.get_vendor_name(APs[i][2]) or ""
})
template.merge_context({'APs': APs_context})
ap_logo_path = template.use_file(mac_matcher.get_vendor_logo_path(ap_mac))
template.merge_context({
'target_ap_channel': args.channel or "",
'target_ap_essid': essid or "",
'target_ap_bssid': ap_mac or "",
'target_ap_encryption': enctype or "",
'target_ap_vendor': 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).
network_manager.set_interface_mode(ap_iface, "managed")
# Start AP
start_ap(ap_iface.get_name(), channel, essid, args)
dhcpconf = dhcp_conf(ap_iface.get_name())
if not dhcp(dhcpconf, ap_iface.get_name()):
print('[' + G + '+' + W +
'] Could not set IP address on %s!' % ap_iface.get_name()
)
shutdown(template)
subprocess.call('clear', shell=True)
print ('[' + T + '*' + W + '] ' + T +
essid + W + ' set up on channel ' +
T + channel + W + ' via ' + T + mon_iface.get_name() +
W + ' on ' + T + str(ap_iface.get_name()) + W)
# With configured DHCP, we may now start the web server
# 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
mac_matcher.unbind()
clients_APs = []
APs = []
monitor_on = None
conf.iface = mon_iface.get_name()
mon_MAC = mon_mac(mon_iface.get_name())
if not args.nojamming:
monchannel = channel
# Start channel hopping
hop = Thread(target=channel_hop2, args=(mon_iface,))
hop.daemon = True
hop.start()
# Start sniffing
sniff_thread = Thread(target=sniff_dot11, args=(mon_iface.get_name(),))
sniff_thread.daemon = True
sniff_thread.start()
# 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: " + mon_iface.get_name()
print term.move(5, term.width - 30) + "|" + "_"*29
print term.move(1,0) + term.blue("Jamming devices: ")
if os.path.isfile('/tmp/wifiphisher-jammer.tmp'):
proc = check_output(['tail', '-5', '/tmp/wifiphisher-jammer.tmp'])
print term.move(4,0) + proc
print term.move(9,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(10,0) + proc
print term.move(17,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(18,0) + proc
if phishinghttp.terminate and args.quitonsuccess:
raise KeyboardInterrupt
except KeyboardInterrupt:
shutdown(template, network_manager)
from AddressReader import *
from GeoIPLookup import *
from RDAPLookup import *
from CommandTerminal import *
from QueryFilter import *
import sys
import subprocess as sp
from blessings import Terminal
import time
commandTerminal = 0
def shutdown():
commandTerminal.printSystem("Stopping...")
commandTerminal.end()
if __name__ == "__main__":
sp.call('clear', shell=True)
terminal = Terminal()
terminal.clear()
terminal.fullscreen()
queryFilter = QueryFilter(shutdown)
commandTerminal = CommandTerminal(terminal, queryFilter.runCommand)
commandTerminal.start()
time.sleep(1)
queryFilter.printHeader()
#!/usr/bin/env python3
#Defining Functions
#Written by Homer Walden
#Import files
from blessings import Terminal
t = Terminal() #set variable t for Terminal file
print(t.clear()) #clears the text
print(t.bold('Hi there!')) #prints bold test
print(t.move_down) #moves cursor down one line
print(t.bold_red_on_bright_green('It hurts my eyes!')) #print in bold and green
print(t.move_down+t.bold_underline_black_on_yellow('Look! A 1997 web page! No, the font would have to be blinking'))
print(t.move_down)
print(" Terminal width: ",t.width)
print(" Terminal height: ",t.height)
print(t.move_down+"A one-liner way to show terminal width and height",t.reverse,t.width,"by",t.height," ") #combine height and width methods into one line
with t.location(20, t.height - 1):
print(t.reverse + t.blink('This is at the bottom and printed in REVERSE.'))
class Progress(object):
""" Handle progress indication using callbacks.
This class will create an object that stores information about a
running yumsync process. It stores information about each repository
being synced, including total packages, completed packages, and
the status of the repository metadata. This makes it possible to
display aggregated status of multiple repositories during a sync.
"""
repos = {}
totals = {
'numpkgs': 0,
'dlpkgs': 0,
'md_complete': 0,
'md_total': 0,
'errors':0
}
errors = []
def __init__(self):
""" records the time the sync started.
and initialise blessings terminal """
self.start = datetime.datetime.now()
self.linecount = 0
if sys.stdout.isatty():
self.term = Terminal()
sys.stdout.write(self.term.clear())
def __del__(self):
""" destructor - need to reset the terminal ."""
if sys.stdout.isatty():
sys.stdout.write(self.term.normal)
sys.stdout.write(self.term.move(self.linecount, 0))
sys.stdout.flush()
def update(self, repo_id, set_total=None, pkgs_downloaded=None,
pkg_exists=None, repo_metadata=None, repo_error=None):
""" Handles updating the object itself.
This method will be called any time the number of packages in
a repository becomes known, when any package finishes downloading,
when repository metadata begins indexing and when it completes.
"""
if not repo_id in self.repos:
self.repos[repo_id] = {'numpkgs':0, 'dlpkgs':0, 'repomd':''}
self.totals['md_total'] += 1
if set_total:
self.repos[repo_id]['numpkgs'] = set_total
self.totals['numpkgs'] += set_total
if pkgs_downloaded:
self.repos[repo_id]['dlpkgs'] += pkgs_downloaded
self.totals['dlpkgs'] += pkgs_downloaded
if repo_metadata:
self.repos[repo_id]['repomd'] = repo_metadata
if repo_metadata == 'complete':
self.totals['md_complete'] += 1
if repo_error:
self.totals['errors'] += 1
if self.repos[repo_id]['repomd'] != 'complete':
self.totals['md_total'] -= 1
self.errors.append((repo_id, repo_error))
if sys.stdout.isatty():
self.formatted()
def color(self, string, color=None):
if color and hasattr(self.term, color):
return '{}{}{}'.format(getattr(self.term, color),
string,
self.term.normal)
return string
def pct(self, current, total):
""" Calculate a percentage. """
val = current / float(total) * 100
formatted = '{:0.1f}%'.format(val)
return formatted if int(val) < 100 else 'complete'
def elapsed(self):
""" Calculate and return elapsed time.
This function does dumb rounding by just plucking off anything past a
dot "." in a time delta between two datetime.datetime()'s.
"""
return str(datetime.datetime.now() - self.start).split('.')[0]
def format_header(self, repos):
max_repo = len(max(repos, key=len))
repo = '{:<{}s}'.format('Repository', max_repo)
done = '{:>5s}'.format('Done')
total = '{:>5s}'.format('Total')
complete = 'Packages'
metadata = 'Metadata'
header_str = '{} {}/{} {} {}'.format(repo, done, total, complete, metadata)
return header_str, len(repo), len(done), len(total), len(complete), len(metadata)
def format_line(self, reponame, package_counts, percent, repomd):
""" Return a string formatted for output.
Since there is a common column layout in the progress indicator, we can
we can implement the printf-style formatter in a function.
"""
return '{} {} {} {}'.format(reponame, package_counts, percent, repomd)
def represent_repo_pkgs(self, repo_id, a, b):
""" Format the ratio of packages in a repository. """
numpkgs = self.repos[repo_id]['numpkgs']
dlpkgs = self.repos[repo_id]['dlpkgs']
return self.represent_pkgs(dlpkgs, numpkgs, a, b)
def represent_total_pkgs(self, a, b):
""" Format the total number of packages in all repositories. """
numpkgs = self.totals['numpkgs']
dlpkgs = self.totals['dlpkgs']
return self.represent_pkgs(dlpkgs, numpkgs, a, b)
def represent_pkgs(self, dlpkgs, numpkgs, a, b):
""" Represent a package ratio.
This will display nothing if the number of packages is 0 or unknown, or
typical done/total if total is > 0.
"""
if numpkgs == 0:
return '{:^{}s}'.format('-', a + b + 1)
elif dlpkgs >= numpkgs:
return '{:>{}}'.format(dlpkgs, a + b + 1)
else:
return '{0:>{2}}/{1:<{3}}'.format(dlpkgs, numpkgs, a, b)
def represent_repo_percent(self, repo_id, length):
""" Display the percentage of packages downloaded in a repository. """
numpkgs = self.repos[repo_id]['numpkgs']
dlpkgs = self.repos[repo_id]['dlpkgs']
return self.represent_percent(dlpkgs, numpkgs, length)
def represent_total_percent(self, length):
""" Display the overall percentage of downloaded packages. """
numpkgs = self.totals['numpkgs']
dlpkgs = self.totals['dlpkgs']
return self.represent_percent(dlpkgs, numpkgs, length)
def represent_total_metadata_percent(self, length):
""" Display the overall percentage of metadata completion. """
a = self.totals['md_total']
b = self.totals['md_complete']
return self.represent_percent(b, a, length)
def represent_percent(self, dlpkgs, numpkgs, length):
""" Display a percentage of completion.
If the number of packages is unknown, nothing is displayed. Otherwise,
a number followed by the percent sign is displayed.
"""
if dlpkgs == 0:
return '{:^{}s}'.format('-', length)
else:
return '{:^{}s}'.format(self.pct(dlpkgs, numpkgs), length)
def represent_repomd(self, repo_id, length):
""" Display the current status of repository metadata. """
if not self.repos[repo_id]['repomd']:
return '{:^{}s}'.format('-', length)
else:
return self.repos[repo_id]['repomd']
def represent_repo(self, repo_id, h1, h2, h3, h4, h5):
""" Represent an entire repository in one line.
This makes calls to the other methods of this class to create a
formatted string, which makes nice columns.
"""
repo = '{:<{}s}'.format(repo_id, h1)
if 'error' in self.repos[repo_id]:
repo = self.color(repo, 'red')
packages = self.color('{:^{}s}'.format('error', h2 + h3 + 1), 'red')
percent = self.color('{:^{}s}'.format('-', h4), 'red')
metadata = self.color('{:^{}s}'.format('-', h5), 'red')
else:
repo = self.color(repo, 'blue')
packages = self.represent_repo_pkgs(repo_id, h2, h3)
percent = self.represent_repo_percent(repo_id, h4)
metadata = self.represent_repomd(repo_id, h5)
if percent == 'complete':
percent = self.color(percent, 'green')
if metadata == 'building':
metadata = self.color(metadata, 'yellow')
elif metadata == 'complete':
metadata = self.color(metadata, 'green')
return self.format_line(repo, packages, percent, metadata)
def represent_total(self, h1, h2, h3, h4, h5):
total = self.color('{:>{}s}'.format('Total', h1), 'yellow')
packages = self.represent_total_pkgs(h2, h3)
percent = self.represent_total_percent(h4)
metadata = self.represent_total_metadata_percent(h5)
if percent == 'complete':
percent = self.color(percent, 'green')
if metadata == 'complete':
metadata = self.color(metadata, 'green')
return self.format_line(total, packages, percent, metadata)
def emit(self, line=''):
numlines = len(line.split('\n'))
self.linecount += numlines
with self.term.location(x=0, y=self.linecount - numlines):
sys.stdout.write(line)
sys.stdout.write(self.term.clear_eol())
def formatted(self):
""" Print all known progress data in a nicely formatted table.
This method keeps track of what it has printed before, so that it can
backtrack over the console screen, clearing out the previous flush and
printing out a new one. This method is called any time any value is
updated, which is what gives us that real-time feeling.
Unfortunately, the YUM library calls print directly rather than just
throwing exceptions and handling them in the presentation layer, so
this means that yumsync's output will be slightly flawed if YUM prints
something directly to the screen from a worker process.
"""
# Remove repos with errors from totals
if self.totals['errors'] > 0:
for repo_id, error in self.errors:
if repo_id in self.repos:
if not 'error' in self.repos[repo_id]:
self.totals['dlpkgs'] -= self.repos[repo_id]['dlpkgs']
self.totals['numpkgs'] -= self.repos[repo_id]['numpkgs']
self.repos[repo_id]['error'] = True
self.linecount = 0 # reset line counter
header, h1, h2, h3, h4, h5 = self.format_header(self.repos.keys())
self.emit('-' * len(header))
self.emit(self.color('{}'.format(header), 'green'))
self.emit('-' * len(header))
error_repos = []
complete_repos = []
metadata_repos = []
other_repos = []
for repo_id in sorted(self.repos):
if 'error' in self.repos[repo_id]:
error_repos.append(repo_id)
elif self.repos[repo_id]['repomd'] == 'complete':
complete_repos.append(repo_id)
elif self.repos[repo_id]['repomd']:
metadata_repos.append(repo_id)
else:
other_repos.append(repo_id)
for repo_id in itertools.chain(error_repos, complete_repos, metadata_repos, other_repos):
self.emit(self.represent_repo(repo_id, h1, h2, h3, h4, h5))
self.emit('-' * len(header))
self.emit(self.represent_total(h1, h2, h3, h4, h5))
self.emit('-' * len(header))
# Append errors to output if any found.
if self.totals['errors'] > 0:
self.emit(self.color('Errors ({}):'.format(self.totals['errors']), 'red'))
for repo_id, error in self.errors:
self.emit(self.color('{}: {}'.format(repo_id, error), 'red'))
with self.term.location(x=0, y=self.linecount):
sys.stdout.write(self.term.clear_eos())
sys.stdout.flush()
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$Z Z$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$Z Z$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$\n' +
'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$.............$$$$$$$$$$$$$$$$$$$$$$$$$\n')
raw_input('Hit enter to continue...')
welcome = term.clear() + '\n\n\n' + '~~~~~~~~~~~~ WELCOME TO TERMCHAT ~~~~~~~~~~~\n' + '~~~ facebook messenger for your terminal ~~~' + '\n\n\n\n\n\n\n\n' + 'Enter your login credentials to continue...'
print(welcome)
raw_input('Email: ')
raw_input('Password: ')
from blessings import Terminal
import os
import time
import hashlib
wrap = Terminal()
run = True
logged = False
root = False
print(wrap.clear())
time.sleep(2)
with wrap.location(0, wrap.height):
print(wrap.bold("Login backup inited!"))
time.sleep(1)
print(wrap.clear())
with wrap.location(0, wrap.height):
print(wrap.bold("Password backup inited!"))
time.sleep(1)
print(wrap.clear())
time.sleep(1)
wrap.location(0, wrap.height)
while run:
if not logged:
print("Welcome to the MMC net. MMC(2020) All rights reserved.")
print("For continue enter login & password")
username = input("Login: "******"Password: ")
def on_error(ws, error):
print error
def on_close(ws):
print "### closed ###"
def on_open(ws):
def run(*args):
while True:
time.sleep(1)
print "thread terminating..."
thread.start_new_thread(run, ())
if __name__ == "__main__":
try:
t.enter_fullscreen()
print t.clear()
#websocket.enableTrace(True)
ws = websocket.WebSocketApp("wss://az.skyhunter.ca:8083/",
on_message = on_message,
on_error = on_error,
on_close = on_close)
ws.on_open = on_open
ws.run_forever(sslopt={"cert_reqs": ssl.CERT_NONE})
except:
print t.normal
t.exit_fullscreen()
print t.clear()
exit()
class Progress(object):
""" Handle progress indication using callbacks.
This class will create an object that stores information about a
running yumsync process. It stores information about each repository
being synced, including total packages, completed packages, and
the status of the repository metadata. This makes it possible to
display aggregated status of multiple repositories during a sync.
"""
repos = {}
totals = {
'numpkgs': 0,
'dlpkgs': 0,
'md_complete': 0,
'md_total': 0,
'errors': 0
}
errors = []
def __init__(self):
""" records the time the sync started.
and initialise blessings terminal """
self.start = datetime.datetime.now()
self.linecount = 0
if sys.stdout.isatty():
self.term = Terminal()
sys.stdout.write(self.term.clear())
def __del__(self):
""" destructor - need to reset the terminal ."""
if sys.stdout.isatty():
sys.stdout.write(self.term.normal)
sys.stdout.write(self.term.move(self.linecount, 0))
sys.stdout.flush()
def update(self,
repo_id,
set_total=None,
pkgs_downloaded=None,
pkg_exists=None,
repo_metadata=None,
repo_error=None):
""" Handles updating the object itself.
This method will be called any time the number of packages in
a repository becomes known, when any package finishes downloading,
when repository metadata begins indexing and when it completes.
"""
if not repo_id in self.repos:
self.repos[repo_id] = {'numpkgs': 0, 'dlpkgs': 0, 'repomd': ''}
self.totals['md_total'] += 1
if set_total:
self.repos[repo_id]['numpkgs'] = set_total
self.totals['numpkgs'] = 0
for _, repo in six.iteritems(self.repos):
self.totals['numpkgs'] += repo['numpkgs']
if pkgs_downloaded:
self.repos[repo_id]['dlpkgs'] += pkgs_downloaded
self.totals['dlpkgs'] += pkgs_downloaded
if repo_metadata:
self.repos[repo_id]['repomd'] = repo_metadata
if repo_metadata == 'complete':
self.totals['md_complete'] += 1
if repo_error:
self.totals['errors'] += 1
if self.repos[repo_id]['repomd'] != 'complete':
self.totals['md_total'] -= 1
self.errors.append((repo_id, repo_error))
if sys.stdout.isatty():
self.formatted()
def color(self, string, color=None):
if color and hasattr(self.term, color):
return '{}{}{}'.format(getattr(self.term, color), string,
self.term.normal)
return string
@classmethod
def pct(cls, current, total):
""" Calculate a percentage. """
if total == 0:
return "0"
val = current / float(total) * 100
formatted = '{:0.1f}%'.format(val)
return formatted
def elapsed(self):
""" Calculate and return elapsed time.
This function does dumb rounding by just plucking off anything past a
dot "." in a time delta between two datetime.datetime()'s.
"""
return str(datetime.datetime.now() - self.start).split('.')[0]
def format_header(self):
repos = self.repos.keys()
max_repo = len(max(repos, key=len))
repo = '{:<{}s}'.format('Repository', max_repo)
done = '{:>5s}'.format('Done')
total = '{:>5s}'.format('Total')
complete = 'Packages'
metadata = 'Metadata'
header_str = '{} {}/{} {} {}'.format(repo, done, total, complete,
metadata)
return header_str, len(repo), len(done), len(total), len(
complete), len(metadata)
@classmethod
def format_line(cls, reponame, package_counts, percent, repomd):
""" Return a string formatted for output.
Since there is a common column layout in the progress indicator, we can
we can implement the printf-style formatter in a function.
"""
return '{} {} {} {}'.format(reponame, package_counts, percent,
repomd)
def represent_repo_pkgs(self, repo_id, a, b):
""" Format the ratio of packages in a repository. """
numpkgs = self.repos[repo_id]['numpkgs']
dlpkgs = self.repos[repo_id]['dlpkgs']
return self.represent_pkgs(dlpkgs, numpkgs, a, b)
def represent_total_pkgs(self, a, b):
""" Format the total number of packages in all repositories. """
numpkgs = self.totals['numpkgs']
dlpkgs = self.totals['dlpkgs']
return self.represent_pkgs(dlpkgs, numpkgs, a, b)
@classmethod
def represent_pkgs(cls, dlpkgs, numpkgs, a, b):
""" Represent a package ratio.
This will display nothing if the number of packages is 0 or unknown, or
typical done/total if total is > 0.
"""
if numpkgs == 0:
return '{:^{}s}'.format('-', a + b + 1)
else:
return '{0:>{2}}/{1:<{3}}'.format(dlpkgs, numpkgs, a, b)
def represent_repo_percent(self, repo_id, length):
""" Display the percentage of packages downloaded in a repository. """
numpkgs = self.repos[repo_id]['numpkgs']
dlpkgs = self.repos[repo_id]['dlpkgs']
return self.represent_percent(dlpkgs, numpkgs, length)
def represent_total_percent(self, length):
""" Display the overall percentage of downloaded packages. """
numpkgs = self.totals['numpkgs']
dlpkgs = self.totals['dlpkgs']
return self.represent_percent(dlpkgs, numpkgs, length)
def represent_total_metadata_percent(self, length):
""" Display the overall percentage of metadata completion. """
a = self.totals['md_total']
b = self.totals['md_complete']
return self.represent_percent(b, a, length)
def represent_percent(self, dlpkgs, numpkgs, length):
""" Display a percentage of completion.
If the number of packages is unknown, nothing is displayed. Otherwise,
a number followed by the percent sign is displayed.
"""
if dlpkgs == 0:
return '{:^{}s}'.format('-', length)
else:
return '{:^{}s}'.format(self.pct(dlpkgs, numpkgs), length)
def represent_repomd(self, repo_id, length):
""" Display the current status of repository metadata. """
if not self.repos[repo_id]['repomd']:
return '{:^{}s}'.format('-', length)
else:
return self.repos[repo_id]['repomd']
def represent_repo(self, repo_id, h1, h2, h3, h4, h5):
""" Represent an entire repository in one line.
This makes calls to the other methods of this class to create a
formatted string, which makes nice columns.
"""
repo = '{:<{}s}'.format(repo_id, h1)
if 'error' in self.repos[repo_id]:
repo = self.color(repo, 'red')
else:
repo = self.color(repo, 'blue')
packages = self.represent_repo_pkgs(repo_id, h2, h3)
percent = self.represent_repo_percent(repo_id, h4)
metadata = self.represent_repomd(repo_id, h5)
if percent == 'complete':
percent = self.color(percent, 'green')
if metadata == 'building' or (
(isinstance(metadata, int) or metadata.isdigit())
and int(metadata) <= 100):
if isinstance(metadata, str) and metadata.isdigit():
metadata += "%"
if isinstance(metadata, int):
metadata = "{}%".format(metadata)
metadata = self.color(metadata, 'yellow')
elif metadata == 'complete':
metadata = self.color(metadata, 'green')
return self.format_line(repo, packages, percent, metadata)
def represent_total(self, h1, h2, h3, h4, h5):
total = self.color('{:>{}s}'.format('Total', h1), 'yellow')
packages = self.represent_total_pkgs(h2, h3)
percent = self.represent_total_percent(h4)
metadata = self.represent_total_metadata_percent(h5)
if percent == 'complete':
percent = self.color(percent, 'green')
if metadata == 'complete':
metadata = self.color(metadata, 'green')
return self.format_line(total, packages, percent, metadata)
def emit(self, line=''):
numlines = len(line.split('\n'))
self.linecount += numlines
with self.term.location(x=0, y=self.linecount - numlines):
sys.stdout.write(line)
sys.stdout.write(self.term.clear_eol())
def formatted(self):
""" Print all known progress data in a nicely formatted table.
This method keeps track of what it has printed before, so that it can
backtrack over the console screen, clearing out the previous flush and
printing out a new one. This method is called any time any value is
updated, which is what gives us that real-time feeling.
Unfortunately, the YUM library calls print directly rather than just
throwing exceptions and handling them in the presentation layer, so
this means that yumsync's output will be slightly flawed if YUM prints
something directly to the screen from a worker process.
"""
# Remove repos with errors from totals
if self.totals['errors'] > 0:
for repo_id, error in self.errors:
if repo_id in self.repos:
if not 'error' in self.repos[repo_id]:
self.totals['dlpkgs'] -= self.repos[repo_id]['dlpkgs']
self.totals['numpkgs'] -= self.repos[repo_id][
'numpkgs']
self.repos[repo_id]['error'] = True
self.linecount = 0 # reset line counter
header, h1, h2, h3, h4, h5 = self.format_header()
self.emit('-' * len(header))
self.emit(self.color('{}'.format(header), 'green'))
self.emit('-' * len(header))
error_repos = []
complete_repos = []
metadata_repos = []
other_repos = []
for repo_id in sorted(self.repos):
if 'error' in self.repos[repo_id]:
error_repos.append(repo_id)
elif self.repos[repo_id]['repomd'] == 'complete':
complete_repos.append(repo_id)
elif self.repos[repo_id]['repomd']:
metadata_repos.append(repo_id)
else:
other_repos.append(repo_id)
for repo_id in sorted(self.repos):
self.emit(self.represent_repo(repo_id, h1, h2, h3, h4, h5))
self.emit('-' * len(header))
self.emit(self.represent_total(h1, h2, h3, h4, h5))
self.emit('-' * len(header))
# Append errors to output if any found.
if self.totals['errors'] > 0:
self.emit(
self.color('Errors ({}):'.format(self.totals['errors']),
'red'))
for repo_id, error in self.errors:
self.emit(self.color('{}: {}'.format(repo_id, error), 'red'))
with self.term.location(x=0, y=self.linecount):
sys.stdout.write(self.term.clear_eos())
sys.stdout.flush()
class CalculonDisplay (object):
def __init__(self):
self.term = Terminal()
print(self.term.enter_fullscreen())
# parse config
self.config = self.init_config(CONFIG)
self.bin_mode = self.config['bin_mode']
self.cur_bin_mode = None
self.bits = self.config['bits']
self.formats = self.config['formats']
self.align = self.config['align']
self.padding = self.config['padding']
self.attrs = self.config['attrs']
self.header = 'calculon v1.0'
self.show_header = True
# Watched variables
self.lastval = 0
# Watched expressions
self.exprs = []
self.draw_state = {
'header': True, 'value': True, 'vallabel': True, 'binlabel': True,
'varlabel': True, 'varvalue': True, 'exprlabel': True, 'exprvalue': True,
'all': True
}
# set initial value
self.update_value(0)
def init_config(self, config):
# update text attributes
for sec in config['attrs']:
config['attrs'][sec] = ''.join(['{t.' + x + '}' for x in config['attrs'][sec]])
return config
def set_win(self, win, repl_win):
self.win = win
self.repl_win = repl_win
self.update_value(0)
self.redraw()
def update_bin_mode(self):
# detect bin display mode
old_mode = self.cur_bin_mode
if self.bin_mode == "auto":
self.cur_bin_mode = "wide" if self.term.width >= BIN_MODE_WIDTH_WIDE else "narrow"
if self.cur_bin_mode != old_mode:
self.draw_state['all'] = True
# round up bits to nearest row
self.bin_row = BIN_MODE_ROW_NARROW if self.cur_bin_mode == "narrow" else BIN_MODE_ROW_WIDE
if self.bits % self.bin_row > 0:
self.bits += self.bin_row - (self.bits % self.bin_row)
def update_value(self, value):
self.lastval = value
self.draw_state['value'] = True
self.redraw()
def set_exprs(self, values):
self.exprs = values
self.draw_state['exprvalue'] = True
self.draw_state['exprlabel'] = True
self.redraw()
def redraw(self, all=False):
self.update_bin_mode()
if all:
self.draw_state['all'] = True
if self.draw_state['all']:
print(self.term.clear())
if self.draw_state['header'] or self.draw_state['all']:
self.draw_header()
self.draw_state['header'] = False
if self.draw_state['value'] or self.draw_state['all']:
self.clear_value()
self.draw_value()
self.draw_binary()
self.draw_state['value'] = False
if self.draw_state['vallabel'] or self.draw_state['all']:
self.draw_value_labels()
self.draw_binary_labels()
self.draw_state['vallabel'] = False
if self.draw_state['exprlabel'] or self.draw_state['all']:
self.draw_expr_labels()
self.draw_state['exprlabel'] = False
if self.draw_state['exprvalue'] or self.draw_state['all']:
self.clear_exprs()
self.draw_exprs()
self.draw_expr_labels()
self.draw_state['exprvalue'] = False
self.draw_state['all'] = False
def get_value_formats(self):
return filter(lambda x: x in VALID_FORMATS and x != 'b', self.formats)
def num_rows(self):
return self.offset_exprs() + self.num_rows_exprs() + self.padding['bottom']
def num_cols(self):
if self.cur_bin_mode == "wide":
c = BIN_MODE_WIDTH_WIDE + self.padding['left'] + self.padding['right']
else:
c = BIN_MODE_WIDTH_NARROW + self.padding['left'] + self.padding['right']
return c
def num_rows_val(self):
return len(self.get_value_formats())
def num_rows_bin(self):
return self.bits / self.bin_row + self.padding['bintop'] + self.padding['binbottom']
def num_rows_exprs(self):
n = len(self.exprs)
if n > 0:
n += self.padding['vartop'] + self.padding['varbottom']
return n
def offset_val(self):
return self.padding['top']
def offset_bin(self):
return self.offset_val() + self.num_rows_val()
def offset_exprs(self):
return self.offset_bin() + self.num_rows_bin()
def draw_str(self, str, attr='', x=0, y=0):
print((self.term.normal + self.term.move(y, x) + attr + str).format(t=self.term))
def draw_header(self):
if self.show_header:
head = self.header + ' ' * (self.term.width - len(self.header))
self.draw_str(head, self.attrs['header'])
def clear_value(self, varname=None):
y = self.padding['top']
for fmt in self.get_value_formats():
w = self.num_cols() - self.padding['left'] - len(' ' + fmt) - self.padding['right'] - self.padding['label']*2
x = self.padding['left'] + len(' ' + fmt)
if varname:
w -= len(varname)
if self.align == 'right':
x += len(varname)
self.draw_str(' '*w, '', x, y)
y += 1
def draw_value(self, varname=None):
y = self.padding['top']
for fmt in self.get_value_formats():
self.draw_value_at_row(self.lastval, fmt, y)
y += 1
def draw_value_at_row(self, value, fmt, row, label=None):
fmtd = ''
if fmt in ['h', 'd', 'o']:
fmtd = BASE_FMT[fmt].format(value)
attr = self.attrs[fmt + 'val']
elif fmt == 'a':
s = ('{0:0=%dX}' % (self.bits/4)).format(value)
a = [chr(int(s[i:i+2],16)) for i in range(0, len(s), 2)]
for c in a:
if c not in string.printable or c == '\n':
fmtd += '.'
else:
fmtd += c
if c in (r'{', r'}'):
fmtd += c
attr = self.attrs['aval']
elif fmt == 'u':
# s = ('{0:0=%dX}' % (self.bits/4)).format(value)
# a = [(chr(int(s[i:i+2],16)) + chr(int(s[i+2:i+4],16))).decode('utf-16') for i in range(0, len(s), 4)]
attr = self.attrs['uval']
if self.align == 'right':
col = self.num_cols() - self.padding['right'] - self.padding['label'] - len(fmtd) - 2
self.draw_str(fmtd, attr, col, row)
elif self.align == 'left':
col = self.padding['left'] + len(' ' + fmt) + self.padding['label']
self.draw_str(fmtd, attr, col, row)
def draw_value_labels(self):
y = self.padding['top']
for fmt in self.get_value_formats():
self.draw_labels_at_row(fmt, y)
y += 1
def draw_labels_at_row(self, fmt, row, label=None):
if self.align == 'right':
col = self.num_cols() - self.padding['right'] - self.padding['label']
self.draw_str(fmt, self.attrs['vallabel'], col, row)
if label != None:
self.draw_str(label, self.attrs['vallabel'], self.padding['left'], row)
elif self.align == 'left':
col = self.padding['left']
self.draw_str(fmt, self.attrs['vallabel'], col, row)
if label != None:
self.draw_str(label, self.attrs['vallabel'], self.num_cols() - self.padding['right'] - len(label), row)
def draw_binary(self):
s = (BASE_FMT['b'] % self.bits).format(self.lastval)
if len(s) > self.bits:
s = s[len(s)-self.bits:]
y = len(self.get_value_formats()) + self.padding['top'] + self.padding['bintop']
x = self.padding['left']
p = 0
if self.lastval >= 1<<self.bits:
attr = self.attrs['err']
else:
attr = self.attrs['bval']
for i in xrange(len(s)):
if i != 0 and i % self.bin_row == 0:
y += 1
x = self.padding['left']
p = 0
elif i != 0 and i % 8 == 0:
p += 3
elif i != 0 and i % 4 == 0:
p += 1
x += 1
self.draw_str(s[i], attr, x*2+p, y)
def draw_binary_labels(self):
rows = range(self.bits / self.bin_row)
y = self.offset_bin() + self.padding['bintop'] + len(rows) - 1
for i in rows:
right = str(i * self.bin_row)
left = str((i+1) * self.bin_row - 1)
self.draw_str(left, self.attrs['binlabel'], self.padding['left'], y)
self.draw_str(right, self.attrs['binlabel'], self.num_cols() - self.padding['right'] - 2, y)
y -= 1
def clear_exprs(self):
y = self.offset_exprs() + self.padding['vartop']
for idx, (value, fmt, label) in enumerate(self.exprs):
self.draw_str(' ' * self.num_cols(), '', 0, y)
def draw_exprs(self):
y = self.offset_exprs() + self.padding['vartop']
x = self.padding['left']
for idx, (value, fmt, label) in enumerate(self.exprs):
self.draw_value_at_row(value, fmt, y + idx, label)
def draw_expr_labels(self):
top = self.offset_exprs() + self.padding['vartop']
for idx, (value, fmt, label) in enumerate(self.exprs):
y = top + idx
if self.align == 'left':
self.draw_str(fmt, self.attrs['exprlabel'], self.padding['left'], y)
self.draw_str(str(idx), self.attrs['exprlabel'], self.num_cols() - self.padding['right'] - 2, y)
self.draw_str(label, self.attrs['expr'], self.num_cols() - self.padding['right'] - 2 - self.padding['label'] - len(label), y)
else:
self.draw_str(fmt, self.attrs['exprlabel'], self.num_cols() - self.padding['right'] - 2, y)
self.draw_str(str(idx), self.attrs['exprlabel'], self.padding['left'], y)
self.draw_str(label, self.attrs['expr'], self.padding['left'] + 2 + self.padding['label'], y)
def handle(self, *args, **options):
from django.db.models import get_model
from django.db import reset_queries
reset_queries()
term = Terminal(stream=self.stdout)
print(term.clear())
self.verbosity = int(options.get('verbosity'))
if settings.DEBUG:
self.stderr.write("Django is in debug mode, which causes memory leak. "
"Set settings.DEBUG to False and run again.")
return
target_database = options.get('targetDatabase')
if not target_database:
if self.verbosity >= 1:
self.stderr.write("No target database given")
return
source_database = options.get('sourceDatabase')
if not source_database:
if self.verbosity >= 1:
self.stderr.write("No source database given")
return
self.concurrency_model = options.get('concurrencyModel')
self.n_jobs = int(options.get('numberOfJobs', 0))
source_model_name = options.get('sourceModelName')
if not source_model_name:
if self.verbosity >= 1:
self.stderr.write("No source model name given")
return
source_model = get_model(self.app_name, source_model_name)
if not source_model:
if self.verbosity >= 1:
self.stderr.write("No model named {0} defined for {1} application"
.format(source_model_name, self.app_name))
return
target_model_name = options.get('targetModelName')
if not target_model_name:
if self.verbosity >= 1:
self.stderr.write("No target model name given")
return
target_model = get_model(self.app_name, target_model_name)
if not target_model:
if self.verbosity >= 1:
self.stderr.write("No model named {0} defined for {1} application"
.format(target_model_name, self.app_name))
return
if self.verbosity >= 2:
self.stdout.write("Populating model {0} from database {1} with data taken from model {2} from database {3}"
.format(target_model_name, target_database, source_model_name, source_database))
size = int(options.get('chunk_size'))
limit = int(options.get('limit'))
offset = int(options.get('offset'))
inchi_conversion = options.get('inchiConversion')
if not inchi_conversion:
if self.verbosity >= 1:
self.stderr.write("No inchi conversion method given")
return
self.dispatch(target_model_name, target_database, source_model_name, source_database,
size, limit, offset, inchi_conversion)
if self.verbosity >= 2:
self.stdout.write("Finished populating model {0}".format(target_model_name))
self.stdout.write("{0} records out of {1} has been successfully populated"
.format(self.total_success, self.records_to_be_populated))
self.stdout.write("{0} records out of {1} has failed to populate"
.format(self.total_failure, self.records_to_be_populated))
self.stdout.write("{0} records out of {1} were empty (no inchi key)"
.format(self.total_empty, self.records_to_be_populated))
self.stdout.write("{0} records out of {1} were ignored (blacklisted)"
.format(self.total_ignored, self.records_to_be_populated))
class screenOutput(_OutputModule):
def __init__(self, parent, name):
_OutputModule.__init__(self, parent, name)
self.logger = logging.getLogger()
self.timerSet = False
self.windows = {}
self.logger.debug("Initialising Blessings")
self.terminal = Terminal()
def run(self):
print(self.terminal.enter_fullscreen() + self.terminal.clear())
# Iterate through config and print any staticText entries
# In config-speak we're using 'area' to mean a curses 'window' as we'll never need a scrolling area
with self.terminal.location():
for areaName, area in self.myConfig["settings"]["areas"].items():
s = None
if "staticText" in area.keys():
s = area["staticText"][:self.terminal.width - 1]
elif "specialText" in area.keys():
s = config()[area["specialText"]][:self.terminal.width - 1]
self.__updateArea(s, area)
while self.running:
if self.timerSet and time.time() > self.timerTarget:
self.timerFunction(self.timerText, self.timerArea)
self.timerSet = False
time.sleep(0.001)
print(self.terminal.exit_fullscreen())
def performAction(self, args):
#self.logger.debug("performAction called with args {}".format(args))
if "area" in args.keys():
# We're expected to update a text area with new text
if args["area"] in self.myConfig["settings"]["areas"]:
area = self.myConfig["settings"]["areas"][args["area"]]
if "text" in args.keys():
with self.terminal.location():
self.__updateArea(args["text"], area)
else:
self.logger.warn(
"Area specified with no text\n{}".format(args))
else:
self.logger.warn("Area not found\n{}".format(args))
elif "toast" in args.keys():
area = self.myConfig["settings"]["toast"]["area"]
if area in self.myConfig["settings"]["areas"]:
self.__updateArea(args["toast"],
self.myConfig["settings"]["areas"][area])
self.__startClearTimer(
self.myConfig["settings"]["toast"]["duration"], "",
self.myConfig["settings"]["areas"][area])
else:
self.logger.warn("Area not found\n{}".format(area))
def __updateArea(self, text, area):
colourFunction = self.__dummyColourFunction
x = area["x"] if "x" in area else 0
if "useSymbol" in area.keys():
text = self.myConfig["settings"]["symbols"][
text] if text in self.myConfig["settings"]["symbols"] else "?"
if text:
if "align" in area.keys():
if area["align"] in ["center", "centre"]:
text = text.center(
self.terminal.width)[:self.terminal.width]
elif area["align"] == "right":
text = text.rjust(
self.terminal.width)[:self.terminal.width]
else:
text = text.ljust(
self.terminal.width)[:self.terminal.width]
if "colourFunction" in area.keys():
try:
colourFunction = getattr(self.terminal,
area["colourFunction"])
except Exception:
self.logger.warn("Colour function not found: {}",
area["colourFunction"])
print(
self.terminal.move(area["y"], x) + self.terminal.clear_eol +
colourFunction(text))
def __startClearTimer(self, duration, text, area):
self.timerTarget = time.time() + duration
self.timerSet = True
self.timerText = text
self.timerArea = area
self.timerFunction = self.__clearTimer
def __clearTimer(self, text, area):
with self.terminal.location():
print(
self.terminal.move(area["y"], area["x"]) +
self.terminal.clear_eol + text)
def __dummyColourFunction(self, string):
return string
print(t.cyan_bold("Good "+ tod() +"."))
say("Good "+tod())
# sleep(2)
with t.location(20, 20):
t.clear
print(t.cyan_bold("How are you feeling today?"))
# os.system("say \"How are you feeling today?\"")
say("How are you feeling today?")
with t.location(20, 21):
feel = input()
with t.location(20, 20):
t.clear()
print(t.cyan_bold("I am glad you are feeling "+feel+"."))
say("I am glad that you are feeling "+ feel)
with t.location(20, 20):
t.clear()
print(t.cyan_bold("What will you do on this machine?"))
say("What will you do on this machine?")
with t.location(20, 21):
task = input()
with t.location(20, 20):
t.clear()
print(t.cyan_bold("Why will you "+ task +"?"))
say("Why will you "+task)
#!/usr/bin/env python3
from blessings import Terminal
t = Terminal()
print(t.clear())
print(t.bold('Hi there!'))
print(t.move_down)
print(t.bold_red_on_bright_green('It hurts my eyes!'))
print(t.move_down + t.bold_underline_black_on_yellow(
'Look! a 1997 web page! No, the font would have to be blinking'))
print(t.move_down)
print(" Terminal width: ", t.width)
print(" Terminal height: ", t.height)
print(t.move_down + "A one-liner way to show terminal width and height",
t.reverse, t.width, "by", t.height, " ")
with t.location(20, t.height - 1):
print(t.reverse + t.blink('This is at thebottom and printed in REVERSE. '))
class Game():
def __init__(self, shape=(10, 10)):
self.shape = shape
self.height, self.width = shape
self.last_row = self.height - 1
self.paddle_padding = 1
self.n_actions = 3 # left, stay, right
self.term = Terminal()
self.reset()
def reset(self):
# reset grid
self.grid = np.zeros(self.shape)
# can only move left or right (or stay)
# so position is only its horizontal position (col)
self.pos = np.random.randint(self.paddle_padding,
self.width - 1 - self.paddle_padding)
self.set_paddle(1)
# item to catch
self.target = (0, np.random.randint(self.width - 1))
self.set_position(self.target, 1)
def move(self, action):
# clear previous paddle position
self.set_paddle(0)
# action is either -1, 0, 1,
# but comes in as 0, 1, 2, so subtract 1
action -= 1
self.pos = min(max(self.pos + action, self.paddle_padding),
self.width - 1 - self.paddle_padding)
# set new paddle position
self.set_paddle(1)
def set_paddle(self, val):
for i in range(1 + self.paddle_padding * 2):
pos = self.pos - self.paddle_padding + i
self.set_position((self.last_row, pos), val)
@property
def state(self):
return self.grid.reshape((1, -1)).copy()
def set_position(self, pos, val):
r, c = pos
self.grid[r, c] = val
def update(self):
r, c = self.target
self.set_position(self.target, 0)
self.set_paddle(1) # in case the target is on the paddle
self.target = (r + 1, c)
# off the map, it's gone
if r == self.last_row:
# reward of 1 if collided with paddle, else -1
if abs(c - self.pos) <= self.paddle_padding:
return 1
else:
return -1
self.set_position(self.target, 1)
return 0
def render(self):
print(self.term.clear())
for r, row in enumerate(self.grid):
for c, on in enumerate(row):
if on:
color = 235
else:
color = 229
print(
self.term.move(r, c) + self.term.on_color(color) + ' ' +
self.term.normal)
# move cursor to end
print(self.term.move(self.height, 0))
class Game():
def __init__(self, shape=(10,10)):
self.shape = shape
self.height, self.width = shape
self.last_row = self.height - 1
self.paddle_padding = 1
self.n_actions = 3 # left, stay, right
self.term = Terminal()
self.reset()
def reset(self):
# reset grid
self.grid = np.zeros(self.shape)
# can only move left or right (or stay)
# so position is only its horizontal position (col)
self.pos = np.random.randint(self.paddle_padding, self.width - 1 - self.paddle_padding)
self.set_paddle(1)
# item to catch
self.target = (0, np.random.randint(self.width - 1))
self.set_position(self.target, 1)
def move(self, action):
# clear previous paddle position
self.set_paddle(0)
# action is either -1, 0, 1,
# but comes in as 0, 1, 2, so subtract 1
action -= 1
self.pos = min(max(self.pos + action, self.paddle_padding), self.width - 1 - self.paddle_padding)
# set new paddle position
self.set_paddle(1)
def set_paddle(self, val):
for i in range(1 + self.paddle_padding*2):
pos = self.pos - self.paddle_padding + i
self.set_position((self.last_row, pos), val)
@property
def state(self):
return self.grid.reshape((1,-1)).copy()
def set_position(self, pos, val):
r, c = pos
self.grid[r,c] = val
def update(self):
r, c = self.target
self.set_position(self.target, 0)
self.set_paddle(1) # in case the target is on the paddle
self.target = (r+1, c)
self.set_position(self.target, 1)
# off the map, it's gone
if r+1 == self.last_row:
# reward of 1 if collided with paddle, else -1
if abs(c - self.pos) <= self.paddle_padding:
return 1
else:
return -1
return 0
def render(self):
print(self.term.clear())
for r, row in enumerate(self.grid):
for c, on in enumerate(row):
if on:
color = 235
else:
color = 229
print(self.term.move(r, c) + self.term.on_color(color) + ' ' + self.term.normal)
# move cursor to end
print(self.term.move(self.height, 0))
class Game():
def __init__(self, shape=(10, 40)):
self.shape = shape
self.height, self.width = shape
self.last_col = self.width
self.first_col = -2
self.first_row = -1
self.last_row = self.height
self.paddle_padding = 1
self.xspeed = 2
self.yspeed = 1
self.n_actions = 3 # left, stay, right
self.term = Terminal()
self.reset()
def reset(self):
# reset grid
self.grid = np.zeros(self.shape)
# can only move left or right (or stay)
# so position is only its horizontal position (col)
self.pos = np.random.randint(self.paddle_padding,
self.height - 1 - self.paddle_padding)
self.set_paddle(1)
#y direc
n = np.random.randint(1, 2)
if n == 0:
self.yspeed = 1
if n == 1:
self.yspeed = -1
self.target = (5, 20)
self.set_position(self.target, 1)
def move(self, action):
# clear previous paddle position
self.set_paddle(0)
# action is either -1, 0, 1,
# but comes in as 0, 1, 2, so subtract 1
action -= 1
self.pos = min(max(self.pos + action, self.paddle_padding),
self.height - 1 - self.paddle_padding)
# set new paddle position
self.set_paddle(1)
def set_paddle(self, val):
for i in range(1 + self.paddle_padding * 2):
pos = self.pos - self.paddle_padding + i
self.set_position((pos, 0), val)
def paddle_pt(self):
return [self.pos, self.pos + 2]
@property
def state(self):
return self.grid.reshape((1, -1)).copy()
def set_position(self, pos, val):
r, c = pos
self.grid[r, c] = val
#returns reward
def update(self):
#erase previous location
r, c = self.target
self.set_position(self.target, 0)
[paddle_start, paddle_end] = self.paddle_pt()
# collision
#right side
if c + self.xspeed >= self.last_col:
self.xspeed = -self.xspeed
#left side
if c + self.xspeed <= self.first_col:
if r + self.yspeed >= paddle_start and r + self.yspeed <= paddle_end:
self.xspeed = -self.xspeed
return 1
return -1
#top side
if r + self.yspeed <= self.first_row:
self.yspeed = -self.yspeed
#bottom
if r + self.yspeed >= self.last_row:
self.yspeed = -self.yspeed
#set new coordinates
self.target = (r + self.yspeed, c + self.xspeed)
self.set_position(self.target, 1)
return 0
def render(self):
print(self.term.clear())
for r, row in enumerate(self.grid):
for c, on in enumerate(row):
if on:
color = 255
else:
color = 20
print(
self.term.move(r, c) + self.term.on_color(color) + ' ' +
self.term.normal)
# move cursor to end
print(self.term.move(self.height, 0))
