def stop(self):
"""Execute controlled tear down of curses."""
curses.nocbreak()
curses.curs_set(1)
self.screen.keypad(False)
curses.echo()
curses.endwin()
def launch(cmdparser):
stdscr = curses.initscr()
curses.cbreak()
#curses.noecho()
curses.echo()
stdscr.keypad(1)
stdscr.scrollok(True)
stdscr.clear()
stdscr.refresh()
try:
# Run your code here
io = FakeStdIO(stdscr)
sys.stdin = io
sys.stdout = io
cmdparser.stdout = io
cmdparser.stdin = io
cmdparser.cmdloop()
finally:
curses.nocbreak()
stdscr.keypad(0)
curses.echo()
curses.endwin()
def obtainInput( self, option, cnc ):
"""
Create a new window to obtain user input.
@param String option - Selected option
@param CommandAndControl cnc - Command And Control Object
@return tuple (
STRING selectedOption,
STRING userInput,
)
"""
screen = curses.newwin( 3, 65, 4, 6 )
screen.box()
screen.addstr( 1, 2, " "*59, curses.A_UNDERLINE )
screen.refresh()
# Tell curses to allow feedback
curses.echo()
curses.nocbreak()
# Obtain data and assign it for processing
data_in = screen.getstr( 1, 2 )
self.process = data_in
for optIdentifier, call in self.obj[ 'calls' ].iteritems():
if option == optIdentifier:
self.cnc.pushTargets( call )
# Reset curses
curses.noecho()
curses.cbreak()
return ( option, data_in )
def closeWindows(stdscr):
"""nicely close curses window"""
curses.nocbreak()
stdscr.keypad(0)
curses.echo()
curses.endwin()
def quit(leave_message = "", exit_status= 0): curses.nocbreak() stdscr.keypad(0) curses.echo() curses.endwin() print leave_message sys.exit(exit_status)
def CursesMonitor(dev):
stdscr = curses.initscr()
curses.cbreak()
Console = CursesDisplay(stdscr, dev)
Console.monitor()
curses.nocbreak()
curses.endwin()
def prompt_screen(self, should_prompt): if should_prompt: curses.nocbreak() curses.echo() else: curses.cbreak() curses.noecho()
def main():
"""
Main entry point for gunicorn_console.
"""
# Set up curses.
stdscr = curses.initscr()
curses.start_color()
curses.init_pair(1, foreground_colour, background_colour)
curses.noecho()
stdscr.keypad(True)
stdscr.nodelay(True)
try:
curses.curs_set(False)
except:
pass
try:
# Run main event loop until quit.
while True:
try:
update_gunicorns()
handle_keypress(stdscr)
display_output(stdscr)
curses.napms(int(screen_delay * 1000))
except KeyboardInterrupt:
break
finally:
# Tear down curses.
curses.nocbreak()
stdscr.keypad(False)
curses.echo()
curses.endwin()
def close(self):
""" clean up """
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
curses.endwin()
def main(argv):
def __call__(self):
pass
dlog = DebugLog("debug.log")
dlog.msg("Logging started\n")
stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
stdscr.keypad(1)
curses.start_color()
try:
wl = WindowLogic(stdscr)
wl.start()
ci = CommandInterpreter(stdscr, wl)
ci.start()
except Exception as e:
dlog.excpt(e)
raise
ci.join()
dlog.msg("Command Interpreter joined.\n")
wl.stop()
wl.join()
dlog.msg("Thread Fetcher joined.\n")
curses.nocbreak()
stdscr.keypad(0)
curses.echo()
curses.endwin()
curses.resetty()
dlog.msg("Terminal restored.\n")
def __exit__(self, exc_type, exc_value, traceback):
"""Reverse curses settings and kill the stdscr"""
curses.nocbreak()
curses.echo()
self.stdscr.keypad(0)
self.stdscr.clear()
curses.endwin()
def killWindow(self):
"""restore terminal window"""
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
curses.curs_set(1)
curses.endwin()
def end_interface(self): # {{{
self.stdscr.erase()
self.stdscr.refresh()
curses.curs_set(1)
curses.nocbreak()
curses.echo()
curses.endwin()
def printlist(scr):
i = 2
l = 0
if hosts == []:
parser()
j = scr.getmaxyx()
k = j[1]/43
# We can't scroll the list, yet
if len(hosts) >= (k*(j[0]-1)):
curses.nocbreak()
curses.echo()
curses.endwin()
os.system("clear")
sys.exit(-1)
for item in hosts:
line = ""
listid = hosts.index(item)
if k > 1:
scr.addstr(i, 3+l*40, str(listid))
scr.addstr(i, 6+l*40, "- " +item)
l=(l+1)%k
if l==0:
i=i+1
else:
scr.addstr(i, 3, str(listid))
scr.addstr(i, 6, "- " +item)
i=i+1
i = i+2
scr.addstr(i,6, "# ")
return i
def exit(self):
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
curses.endwin()
print("Bye!")
self.done = True
def close(self):
curses.curs_set(1)
self.screen.immedok(False)
self.screen.keypad(0)
curses.nocbreak()
curses.echo()
curses.endwin()
def main():
stdscr = curses.initscr()
curses.nocbreak()
mode = NORMAL
max_y, max_x = stdscr.getmaxyx()
print_before, z = covert("输入一个文件地址:")
stdscr.addstr((max_y-1)/2-1, (max_x-1-z)/2-1, print_before)
stdscr.move((max_y-1)/2, (max_x-1-z)/2-1)
path = ""
while True:
ch = stdscr.getch()
if ch == curses.KEY_ENTER or ch == 10:
break
else:
path += chr(ch)
stdscr.addstr(chr(ch))
stdscr.move(0,0)
stdscr.clear()
stdscr.refresh()
with open(path,'r') as f:
lines = list(line_resize(f.readlines(), 5))
for line in lines[-20:]:
stdscr.addstr(line)
curses.cbreak()
curses.noecho()
while True:
ch = stdscr.getch()
if ch == 27:
break
else:
string = parse(ch)
stdscr.addstr(string)
def display_playback_progress():
stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
stdscr.keypad(True)
stdscr.nodelay(True)
while not done_displaying:
stdout.write('\033c\r\n')
stdout.write('Ingesting Data :\r\n\n')
stdout.write('\tDate Glob : ' + gap_glob + '\r\n')
stdout.write('\tMax Playbacks : ' + str(num_playback_threads) + '\r\n\n')
stdout.write('\tInstruments:\r\n')
list_lock.acquire()
for refdes in playback_list.keys():
stdout.write('\t\t' + refdes + ' ' + SPINNER_CHAR[playback_list[refdes]] + '\r\n')
playback_list[refdes] += 1
if playback_list[refdes] == SPINNER_CHAR.__len__():
playback_list[refdes] = 0
list_lock.release()
if not done_displaying:
get_key_input(stdscr)
stdscr.refresh()
sleep(0.2)
stdscr.keypad(False)
curses.echo()
curses.nocbreak()
curses.endwin()
stdout.write('\033c\n\r')
stdout.write('\tIngest Log File : ' + ingest_log_filename + '\r\n')
stdout.write('\tPlayback Log Files : ' + playback_logs_dir + '\r\n\n')
def exitCurses(screen):
curses.nocbreak()
screen.keypad(OFF)
screen.nodelay(OFF)
curses.curs_set(ON)
curses.echo()
curses.endwin()
def clean_up_and_exit(screen):
curses.curs_set(1)
curses.nocbreak()
screen.nodelay(0)
screen.keypad(0)
curses.echo()
curses.endwin()
def close(self):
if not self.enable:
return
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
curses.endwin()
def uninitcurse(self):
curses.echo()
curses.nocbreak();
curses.curs_set(1)
self.w.keypad(0);
curses.endwin()
def end_game(): pad.getch() curses.nocbreak() curses.echo() curses.curs_set(1) curses.endwin() sys.exit(0)
def wrapper_fork(call_function, reset=True):
pid = os.fork()
if pid:
# Parent
os.waitpid(pid, 0)
if reset:
external_reset()
else:
locale.setlocale(locale.LC_ALL, '')
_SCREEN = curses.initscr()
try:
curses.start_color()
except:
pass
_SCREEN.keypad(1)
curses.noecho()
curses.cbreak()
curses.def_prog_mode()
curses.reset_prog_mode()
return_code = call_function(_SCREEN)
_SCREEN.keypad(0)
curses.echo()
curses.nocbreak()
curses.endwin()
sys.exit(0)
def wrapper_no_fork(call_function, reset=False):
global _NEVER_RUN_INITSCR
if not _NEVER_RUN_INITSCR:
warnings.warn("""Repeated calls of endwin may cause a memory leak. Use wrapper_fork to avoid.""")
global _SCREEN
return_code = None
try:
if _NEVER_RUN_INITSCR:
_NEVER_RUN_INITSCR = False
locale.setlocale(locale.LC_ALL, '')
_SCREEN = curses.initscr()
try:
curses.start_color()
except:
pass
curses.noecho()
curses.cbreak()
_SCREEN.keypad(1)
curses.noecho()
curses.cbreak()
_SCREEN.keypad(1)
return_code = call_function(_SCREEN)
finally:
_SCREEN.keypad(0)
curses.echo()
curses.nocbreak()
# Calling endwin() and then refreshing seems to cause a memory leak.
curses.endwin()
if reset:
external_reset()
return return_code
def close(self): self.db.close() self.screen.keypad(0) curses.echo() curses.nocbreak() curses.endwin() sys.exit()
def loop(self):
'''Main application loop. Receives input and dispatches one of either "up", "down", "select" or "back" commands.'''
# standard curses init
self.stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
self.stdscr.keypad(1)
# display the initial menu
self.update(self.current_menu)
try:
while 1:
c = self.stdscr.getch()
if c == curses.KEY_UP:
self.up()
if c == curses.KEY_DOWN:
self.down()
if c == curses.KEY_BACKSPACE or c == 8: # backspace
self.back()
if c == curses.KEY_SELECT or c == 10: # enter
self.select()
if c == ord('q'):
raise SystemExit
finally:
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
curses.endwin()
def terminateWindow(self):
self.window.clear()
curses.nocbreak()
self.window.keypad(False)
curses.echo()
curses.endwin()
exit()
def __subreddit_menu(self):
"""
Switch to buffered input and prompt for subreddit name
:return: void
"""
#flush input buffer
flushinp()
str_input_subreddit = "subreddit:"
self.stdscr.addstr(
self.__max_y - self.__MARGIN_Y,
self.__FLUSH,
str_input_subreddit
)
# disable cinput mode and enter buffered input mode and echo
nocbreak()
echo()
input_buffer = self.stdscr.getstr()
if input_buffer == "back":
# enable cinput mode and disable echo
cbreak()
noecho()
else:
self.__posts_menu(input_buffer)
def terminate_curses():
global stdscr
if stdscr:
stdscr.keypad(0)
curses.echo()
curses.nocbreak()
curses.endwin()
def end_curses():
curses.nocbreak()
stdscr.keypad(False)
curses.echo()
curses.endwin()
def close_stdscr(self):
""" at the end - we reset everything """
curses.nocbreak()
curses.echo()
self.stdscr.keypad(0)
curses.endwin()
def curses_fini(s):
s.win.keypad(False)
curses.echo()
curses.nocbreak()
curses.endwin()
def end(self):
curses.echo()
curses.nocbreak()
#curses.curs_set(1)
curses.endwin()
def kill(self):
curses.echo()
curses.nocbreak()
self.stdscr.keypad(0)
curses.endwin()
def exit_handler(signum, frame):
curses.echo()
curses.nocbreak()
curses.endwin()
sys.exit(0)
def _reset(self):
self.screen.keypad(0)
curses.echo()
curses.nocbreak()
curses.endwin()
def stop(self):
curses.nocbreak()
curses.echo()
curses.endwin()
def destruct(window, stdscr):
curses.nocbreak()
stdscr.keypad(False)
curses.echo()
curses.endwin()
def clear_ui(ui):
curses.nocbreak()
ui.keypad(False)
curses.echo()
curses.endwin()
def finalize():
stdscr.keypad(0)
curses.echo()
curses.nocbreak()
curses.endwin()
def clean(scr):
if scr is not None:
scr.keypad(0)
curses.echo()
curses.nocbreak()
curses.endwin()
def _cleanup(self):
curses.nocbreak()
_s_screen.keypad(0)
curses.echo()
curses.endwin()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-b',
'--baudrate',
help='UART bitrate',
type=int,
default=9600)
parser.add_argument('-d',
'--device',
help='UART device',
default='/dev/ttyUSB0')
parser.add_argument('-w',
'--winner',
help='Winning ',
default='track',
choices=('track', 'laps', 'bestlap'))
parser.add_argument('drivers', help='Comma separated list of drivers')
args = parser.parse_args()
s = serial.Serial(args.device, args.baudrate, timeout=0.1)
state = []
track = 1
for name in args.drivers.split(','):
state.append({'name': name, 'track': track})
track += 1
reset_state(state)
stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
stdscr.nodelay(1)
curses.curs_set(0)
while True:
if not update(stdscr, sort_cars(state, sortby=args.winner)):
break
data = s.read(1)
if len(data) > 0:
# Log time as fast as possible
now = time.time()
try:
car = int(data)
except:
continue
else:
if car == 7:
reset_state(state)
continue
if car > len(state):
continue
offset = car - 1
if state[offset]['time'] > 0:
state[offset]['lastlap'] = now - state[offset]['time']
if state[offset]['lastlap'] < state[offset][
'bestlap'] or not state[offset]['bestlap']:
state[offset]['bestlap'] = state[offset]['lastlap']
state[offset]['laps'] += 1
state[offset]['time'] = now
curses.curs_set(1)
curses.nocbreak()
stdscr.keypad(0)
curses.echo()
curses.endwin()
highlight += 1
elif key == curses.KEY_UP or key == ord('k'):
if highlight == 0 and page > 0:
page -= 1
highlight = maxitems - 1
elif highlight > 0:
highlight -= 1
elif key == curses.KEY_NPAGE and totalitems > (page+1) * maxitems:
highlight = 0
page += 1
elif key == curses.KEY_PPAGE and page > 0:
highlight = 0
page -= 1
elif key == curses.KEY_RIGHT or key == 10 or key == ord('l'):
if state == "search":
curses.nocbreak(); stdscr.keypad(0); curses.echo()
curses.endwin()
chat_url = "http://www.twitch.tv/"+currentpage[highlight]['channel']['display_name']+"/chat"
print("[twitch-curses]", currentpage[highlight]['channel']['display_name'], "-", currentpage[highlight]['channel']['status'], "(", currentpage[highlight]['viewers'], "viewers )")
print("[twitch-curses] Chat url:", chat_url)
print("[twitch-curses] Launching streamlink")
ls_exit_code = subprocess.call(["streamlink", "--http-header", client_id.replace(': ', '='), currentpage[highlight]['channel']['url'], q[quality]])
while ls_exit_code != 0:
print("\n[twitch-curses] Streamlink returned an error. This usually means that the selected stream quality is not available. If that is the case, then you can now choose one of the available streams printed above (defaults to 'best' if left empty). Or you can type 'A' to abort.")
selected_stream = input("Stream to open [best]: ")
if selected_stream == "A" or selected_stream == "a":
break
if selected_stream == "":
selected_stream = "best"
ls_exit_code = subprocess.call(["streamlink", "--http-header", client_id.replace(': ', '='), currentpage[highlight]['channel']['url'], selected_stream])
stdscr = curses.initscr()
def close(cls):
curses.nocbreak()
cls.screen.keypad(False)
curses.echo()
curses.endwin()
def __exit__(self, a, b, c):
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
curses.curs_set(1)
curses.endwin()
def restoreScreen(self):
curses.nocbreak()
curses.echo()
curses.endwin()
def __init__(self, interactive, disassembler, output):
self.win_y = 0
self.cursor_y = 0
self.cursor_x = 0
self.output = output
self.token_lines = output.token_lines
self.dis = disassembler
self.interact = interactive
self.search = None
self.stack = []
self.saved_stack = [] # when we enter, go back, then re-enter
self.word_accepted_chars = ["_", "@", ".", "$"]
self.time_last_mouse_key = self.MOUSE_INTERVAL + 1
self.set_key_timeout = True
self.main_mapping = {
b"\x1b\x5b\x44": self.main_k_left,
b"\x1b\x5b\x43": self.main_k_right,
b"\x1b\x5b\x41": self.main_k_up,
b"\x1b\x5b\x42": self.main_k_down,
b"\x1b\x5b\x35\x7e": self.main_k_pageup,
b"\x1b\x5b\x36\x7e": self.main_k_pagedown,
b"z": self.main_cmd_line_middle,
b"g": self.main_cmd_top,
b"G": self.main_cmd_bottom,
b";": self.view_inline_comment_editor,
b"%": self.main_cmd_next_bracket,
b"\x01": self.main_k_home, # ctrl-a
b"\x05": self.main_k_end, # ctrl-e
b"\x1b\x5b\x37\x7e": self.main_k_home,
b"\x1b\x5b\x38\x7e": self.main_k_end,
b"*": self.main_cmd_highlight_current_word,
b"\x0b": self.main_cmd_highlight_clear, # ctrl-k
b"\n": self.main_cmd_enter,
b"\x1b": self.main_cmd_escape,
# I wanted ctrl-enter but it cannot be mapped on my terminal
b"u": self.main_cmd_reenter, # u for undo
}
self.inline_mapping = {
b"\x1b\x5b\x44": self.inline_k_left,
b"\x1b\x5b\x43": self.inline_k_right,
b"\x7f": self.inline_k_backspace,
b"\x1b\x5b\x37\x7e": self.inline_k_home,
b"\x1b\x5b\x38\x7e": self.inline_k_end,
b"\x1b\x5b\x33\x7e": self.inline_k_delete,
b"\x15": self.inline_k_ctrl_u,
b"\x0b": self.inline_k_ctrl_k,
b"\n": self.inline_k_enter,
b"\x01": self.inline_k_home, # ctrl-a
b"\x05": self.inline_k_end, # ctrl-e
}
saved_quiet = self.interact.ctx.quiet
self.interact.ctx.quiet = True
self.screen = curses.initscr()
curses.noecho()
curses.cbreak()
curses.mousemask(curses.ALL_MOUSE_EVENTS
| curses.REPORT_MOUSE_POSITION)
curses.start_color()
curses.use_default_colors()
for i in range(0, curses.COLORS):
curses.init_pair(i, i, -1)
curses.init_pair(1, 253, 66) # for the highlight search
curses.wrapper(self.view_main)
curses.nocbreak()
curses.echo()
curses.endwin()
self.interact.ctx.quiet = saved_quiet
if self.stack:
print("last address seen 0x%x" % self.interact.ctx.entry_addr)
def main():
stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
with open('day_8_data.txt', 'r') as data:
BLANK = ' '
LIGHT = 'X'
pattern_rotate = re.compile(r'(\w+) (\w)=(\d+) by (\d+)')
pattern_rect = re.compile(r'(\d+)x(\d+)')
displayer = [[BLANK for x in range(50)] for x in range(6)]
for da in data:
if da.startswith('rect'):
m = re.search(pattern_rect, da)
X, Y = int(m.group(1)), int(m.group(2))
for di in range(Y):
for d in range(X):
displayer[di][d] = LIGHT
elif da.startswith('rotate'):
m = re.search(pattern_rotate, da)
axis = m.group(2)
which = int(m.group(3))
by = int(m.group(4))
if axis == 'x':
tmp = deque([])
for row in range(len(displayer)):
x = displayer[row][which]
tmp.append(x)
tmp.rotate(by)
for row in range(len(displayer)):
displayer[row][which] = tmp[row]
elif axis == 'y':
tmp = deque(displayer[which])
tmp.rotate(by)
displayer[which] = tmp
i = 0
for d in displayer:
stdscr.addstr(i, 0, BLANK.join(d))
i += 1
time.sleep(0.1)
stdscr.refresh()
time.sleep(3)
curses.echo()
curses.nocbreak()
curses.endwin()
counter = 0
for di in displayer:
for d in di:
if d == LIGHT:
counter += 1
return counter
def game_over(self):
maxes = self.screen.getmaxyx()
self.print_snake(False)
score_window = curses.newwin(19, 40, 4, int(maxes[1] / 2) - 20)
score_window.bkgdset(' ', curses.color_pair(4))
score_window.bkgd(' ', curses.color_pair(4))
score_window.border()
midpoint = int(score_window.getmaxyx()[1] / 2)
message4 = 'Press CTRL+C to exit'
continue_message = 'Press any key to continue...'
if self.lost:
message1 = 'OH NOOES!!!!!!'
message2 = f"Your snake died on level {self.level} "
message25 = f"You had {int(self.points)} points"
message3 = "Enter your initials: "
else:
message1 = 'Congratulations!!!!'
message2 = f'Level {self.level} Complete'
message25 = f'You have {int(self.points)} points'
message3 = ''
continue_message = f'Press any key to play level {self.level+1}'
score_window.addstr(2, midpoint - int(len(message1) / 2), message1,
curses.color_pair(4) | curses.A_BOLD)
score_window.addstr(4, midpoint - int(len(message2) / 2), message2,
curses.color_pair(4) | curses.A_BOLD)
score_window.addstr(6, midpoint - int(len(message25) / 2), message25,
curses.color_pair(4) | curses.A_BOLD)
score_window.addstr(14, midpoint - int(len(message4) / 2), message4,
curses.color_pair(4) | curses.A_BOLD)
score_window.addstr(9, midpoint - int(len(continue_message) / 2),
continue_message, curses.color_pair(4))
score_window.refresh()
# make sure no stray keys are picked up
clear_pause(score_window)
if self.lost:
message5 = "HIGH SCORES"
score_window.clear()
self.high_scores = self.get_scores()
sorted_scores = sorted(self.high_scores,
key=lambda item: int(item['score']),
reverse=True)
score_list_length = len(sorted_scores)
if score_list_length > 10:
score_list_length = 9
else:
score_list_length = score_list_length - 1
if int(self.points) > int(
sorted_scores[score_list_length][self.score_fields[1]]):
# get real input
curses.echo()
curses.nocbreak()
score_window.clear()
curses.curs_set(1)
score_window.addstr(2, midpoint - int(len(message5) / 2),
message5,
curses.color_pair(4) | curses.A_BOLD)
score_window.addstr(6, midpoint - int(len(message3) / 2) - 4,
message3, curses.color_pair(4))
score_window.refresh()
initials = score_window.getstr(3)
curses.noecho()
curses.cbreak()
curses.curs_set(0)
score_window.clear()
self.add_score(initials, int(self.points), self.level)
self.high_scores = self.get_scores()
score_window.addstr(2, midpoint - int(len(message5) / 2), message5,
curses.color_pair(4) | curses.A_BOLD)
sorted_scores = sorted(self.high_scores,
key=lambda item: int(item['score']),
reverse=True)
for i in range(10):
if len(sorted_scores) > i:
score_line = f'{i+1} - {sorted_scores[i][self.score_fields[0]]}:' + \
f' \t {sorted_scores[i][self.score_fields[1]]}' + \
f'\t (Level {sorted_scores[i][self.score_fields[2]]})'
if i == 9:
score_window.addstr(4 + i, midpoint - 14 - 1,
score_line, curses.color_pair(4))
else:
score_window.addstr(4 + i, midpoint - 14, score_line,
curses.color_pair(4))
score_window.refresh()
time.sleep(1)
score_window.addstr(15, midpoint - int(len(continue_message) / 2),
continue_message, curses.color_pair(4))
score_window.addstr(17, midpoint - int(len(message4) / 2),
message4,
curses.color_pair(4) | curses.A_BOLD)
score_window.refresh()
clear_pause(score_window)
if self.lost:
return self.lost, self.points, self.walls, self.speed, self.level, self.level_up
else:
return self.lost, self.points + self.snake.l, self.walls + 5, self.start_speed * .95, self.level + 1, self.level_up
def stop(self):
""" Clean up console """
curses.nocbreak()
self.screen.keypad(0)
curses.echo()
curses.endwin()
def resetscreen(self):
with self.lock:
curses.nocbreak()
self.win.keypad(False)
curses.echo()
curses.endwin()
def stop(self):
"""Stop curses, restore terminal sanity."""
self.stdscr.keypad(0)
curses.echo()
curses.nocbreak()
curses.endwin()
def main(host, port):
""" Handle all events. """
#Initialize curses,terminal graphics
stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
stdscr.keypad(1)
#Header window
x_axis = 0
y_axis = 0
height = 3
width = 100
winH = curses.newwin(height, width, y_axis, x_axis)
#Playlist window
x_axis = 0
y_axis = 3
height = 25
width = 100
winPL = curses.newwin(height, width, y_axis, x_axis)
#Now playing window
x_axis = 0
y_axis = 28
height = 3
width = 100
winNPL = curses.newwin(height, width, y_axis, x_axis)
#Playlist object
playlist = Playlist(winH, winPL, winNPL)
playlist.draw
curses.doupdate()
#Possible inputs
inputs = []
inputs.append(sys.stdin)
#Send request to playlist server
sock = connect(host, port)
plpmessage = plp.PLPMessage()
if (sock != None):
req = plpmessage.createLTunezClientRequest()
sock.send(req)
inputs.append(sock)
quit = False
data = ''
#Loop to select user inputs
while True:
try:
inputready, outputready, exceptready = select.select(
inputs, [], [])
except:
inputready = []
for ins in inputready:
if (ins == sys.stdin):
ch = stdscr.getch()
if ch == 113 or ch == 81:
quit = True
elif ch == 112 or ch == 80:
playlist.play()
elif ch == curses.KEY_RIGHT:
playlist.next()
elif ch == curses.KEY_LEFT:
playlist.previous()
elif ch == 114 or ch == 82:
sock = connect(host, port)
if (sock != None):
req = plpmessage.createLTunezClientRequest()
sock.send(req)
inputs.append(sock)
else:
data = data + ins.recv(1024)
if re.search('\\r\\n\\r\\n', data):
plpmessage.parse(data)
if plpmessage.command == "Playlist OK":
playlist.parse(plpmessage.playlist)
else:
print "Request failed\r\n"
data = ''
curses.doupdate()
if quit:
break
if playlist.vlc != 0:
os.system('kill -2 ' + str(playlist.vlc))
curses.nocbreak()
stdscr.keypad(0)
curses.echo()
curses.endwin()
def display_loop(*args):
stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
stdscr.keypad(True)
stdscr.nodelay(True)
curses.curs_set(0)
verbose = False
try:
while True:
rows, cols = stdscr.getmaxyx()
stdscr.clear()
out = f"Serving on port: {settings.port} :: {len(state['job'])} jobs."
stdscr.addstr(0, 0, out)
now = datetime.datetime.now().strftime("%H:%M:%S")
stdscr.addstr(0, cols-len(now), now)
for idx, thread_id in enumerate(state["job"]):
job_state = state["job"][thread_id]["display"] or "..."
job_domain = state["job"][thread_id]["domain"] or ""
if verbose:
out = job_domain + ": " + job_state
else:
percentage = re.search('[0-9\.]{1,5}%', job_state)
if(percentage):
out = str(thread_id)[-4:] + ": " + percentage.group()
else:
out = "Running."
stdscr.addstr(idx+1, 0, out)
if verbose:
stdscr.addstr(rows-1, cols-4, "(v)")
try:
key = stdscr.getkey()
stdscr.addstr(rows-1, 0, "processing")
if key in "Qq":
return
else:
verbose = not(verbose)
except:
try:
stdscr.addstr(rows-1, 0, f"[Q] - Quit")
except curses.error: #addstr's fail when resizing
pass
stdscr.refresh()
sleep(0.25)
except BaseException as error:
print('An exception occurred: {}'.format(error))
raise
finally:
curses.echo()
curses.nocbreak()
stdscr.keypad(False)
curses.endwin()
print("Quit at:", datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
if sys.exc_info()[0] is not None:
_thread.interrupt_main()
raise
return
def __call__(self, stdscr) :
self.stdscr = stdscr
curses.halfdelay(10)
line = 0
start = 0
line_fun = (lambda x: string.join(["{:>{}}".format(file_fun(x[key]) if key == 'data_file' else \
status_fun(x) if key == 'status' else x[key],
self.field_len[key]) for key in \
['data_type', 'data_file', 'data_index', 'label_index',
'segment_size', 'segment_stride', 'window_size',
'window_stride', 'post_process_arg', 'max_simplices', 'persistence_epsilon',
'kernel_scale', 'learning_C', 'status']]))
while True:
for (key,value) in self.fields.items() :
if key == 'data_file' :
self.field_len[key] = max([len(value)] + [len(file_fun(config[key])) for config in self.configs])
elif key == 'status' :
self.field_len[key] = max([len(value)] + [len(status_fun(config)) for config in self.configs])
else :
self.field_len[key] = max([len(value)] + [len(str(config[key])) for config in self.configs])
(max_y, max_x) = self.stdscr.getmaxyx()
blank = " " * (max_x - 1)
heading = string.join(["{:>{}}".format(self.fields[key], self.field_len[key]) \
for key in ['data_type','data_file', 'data_index', 'label_index',
'segment_size', 'segment_stride', 'window_size',
'window_stride', 'post_process_arg', 'max_simplices', 'persistence_epsilon',
'kernel_scale', 'learning_C', 'status']])
if len(heading) < (max_x - 1) :
heading = heading + blank[len(heading):]
heading = heading[:max_x-1]
self.stdscr.addstr(0,0,heading)
if len(self.configs) - (max_y - 1) < start :
start = max(0, len(self.configs) - (max_y - 1))
cfgs = self.configs[start:start+max_y-1]
rng = range(1,len(cfgs)+1)
for (config, y) in zip(cfgs, rng) :
output = line_fun(config)
if len(output) < (max_x - 1) :
output = output + blank[len(output):]
output = output[0:max_x-1]
if start + (y - 1) == line :
self.stdscr.addstr(y,0, output, curses.A_REVERSE)
else :
self.stdscr.addstr(y,0, output, curses.A_NORMAL)
self.stdscr.refresh()
c = self.stdscr.getch()
if c == curses.KEY_UP :
line = max(0, (line - 1))
elif c == curses.KEY_DOWN :
line = min((line + 1), len(self.configs)-1)
elif c == ord('q'):
break
if line < start :
start = line
while (line - start) >= (max_y - 1) :
start = line - (max_y - 2)
curses.nocbreak()