def perform_activity(value):
""" Handle the keypresses """
pm.evolve()
org = pm.selectfittest()
if options.verbose:
show_verbose_info(org)
express_genome(org, sync=random.randint(0, 2))
if value == ord('q'):
show_verbose_info(org)
time.sleep(2)
curses.echo()
curses.endwin()
exit()
elif value == ord('v'):
input_box.clear()
clear_verbose()
options.verbose = not options.verbose
elif value == ord('r'):
input_box.clear()
pm.reset()
elif value == ord('b'):
options.noblink = not options.noblink
def receive_command(self):
numlines, numcols = self.get_termsize()
# clear command line
cl = ""
for i in range(numcols-1):
cl += " "
self.screen.addstr(numlines-1, 0, cl)
# get command w/ visual response
self.dontupdate.acquire()
curses.echo()
curses.curs_set(1)
self.screen.addstr(numlines-1, 0, ":")
command = self.screen.getstr(numlines-1, 1)
curses.curs_set(0)
curses.noecho()
self.dontupdate.release()
if command == 'q':
self.running = False
else:
self.screen.addstr(numlines-1,0,"received unknown command:\"%s\"" %
(command,))
def run(win, timeout=3): # timeout in seconds
curses.echo()
win.timeout(0) # Non-block read.
line = 0
while True:
win.addstr(line, 0, "Enter something: ")
s = []
start = time.time()
run = True
while run:
c = win.getch()
time_taken = time.time() - start
if c < 0:
pass
elif c in ENTER_KEY:
break
else:
s.append(chr(c))
if time_taken >= timeout:
# Out of time.
s.append(-1)
run = False
if len(s) == 0:
break
if s[-1] == -1:
s.pop()
answer = ''.join(s)
win.addstr(line + 1, 0, "Your input was: %s" % answer)
line += 2
def uninitcurse(self):
curses.echo()
curses.nocbreak();
curses.curs_set(1)
self.w.keypad(0);
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 quit(leave_message = "", exit_status= 0): curses.nocbreak() stdscr.keypad(0) curses.echo() curses.endwin() print leave_message sys.exit(exit_status)
def close(self):
""" clean up """
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
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 show_menu(self, title, items):
""" Show a menu """
done = False
while not done:
self.newpage(title)
self.nextrow()
options = []
for item in items:
self.stdscr.addstr(self.row, 0, " {0}) {1}".format(*item))
options.append(item[0])
self.nextrow()
self.nextrow()
self.stdscr.addstr(self.row, 0, "Select an option (" + ", ".join(options) + "): ")
curses.echo()
answer = self.stdscr.getstr()
curses.noecho()
for item in items:
if answer == item[0]:
if item[2] == None:
done = True
else:
item[2](self)
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 __init__(self, irc, server, room, screen, theme):
self.theme = theme
self.screen = screen
self.irc = irc
self.server = server
self.room = room
self.height, self.width = self._limits();
self.topic = Line('topic', '', False)
self.status = Line('status', '', False)
self.input_line = Line('input', '', False)
self.lines = []
curses.echo()
curses.start_color()
self.screen.clear()
self.screen.timeout(0)
self.screen.scrollok(True)
self.screen.setscrreg(1, self.height-3)
self._draw_chat()
self.irc.add_global_handler("welcome", self.on_connect)
self.irc.add_global_handler("motd", self.on_motd)
self.irc.add_global_handler("pubmsg", self.on_pubmsg)
self.irc.add_global_handler("currenttopic", self.on_currenttopic)
def end_interface(self): # {{{
self.stdscr.erase()
self.stdscr.refresh()
curses.curs_set(1)
curses.nocbreak()
curses.echo()
curses.endwin()
def killWindow(self):
"""restore terminal window"""
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
curses.curs_set(1)
curses.endwin()
def refresh(self, txt):
# Compute row and scrolling information
currRow = 0
nTxtRows = (len( txt ) // self.width) + 3 # + 1 due to array indexing and + 2 for the documentation and newline
maxRow = 0
if nTxtRows > self.height:
maxRow = nTxtRows - self.height
curses.noecho()
self.inner_window.clear()
self.inner_window.addstr(0, 0, "j/k -- scroll down/up | y/n -- yes/no, q -- quit") # Documentation line
self.inner_window.addstr(2, 0, txt)
# Enter loop with simple interactivity
while True:
self.outer_window.box()
self.outer_window.noutrefresh()
self.inner_window.refresh(currRow, 0, self.yOffset, self.xOffset, self.yOffset + self.height, self.xOffset + self.width)
c = self.inner_window.getch()
if c == 106 and currRow < maxRow: # j scroll down
currRow += 1
if c == 107 and currRow > 0: # k scroll up
currRow -= 1
if c == 113: # q quit dialog
break
self.outer_window.clear()
self.outer_window.noutrefresh()
self.inner_window.clear()
self.inner_window.refresh(currRow, 0, 1, self.xOffset, 11, self.xOffset + self.width)
curses.echo()
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 Go(self):
key2Direction = {\
curses.KEY_UP : Vector((-1, 0)),\
curses.KEY_LEFT : Vector(( 0,-1)),\
curses.KEY_DOWN : Vector((+1, 0)),\
curses.KEY_RIGHT : Vector(( 0,+1)),\
}
null = Vector((0, 0))
self.alive = True
while self.alive:
# Wait a little for keypress
key = self.pad.getch()
if key in key2Direction:
if null != self.snakeDirection + key2Direction[key]:
self.snakeDirection = key2Direction[key]
elif ord('q') == key:
self.alive = False
break
self.Increment()
# Nuke curses
self.pad.keypad(0)
curses.curs_set(1)
curses.echo()
curses.endwin()
return
def close(self):
curses.curs_set(1)
self.screen.immedok(False)
self.screen.keypad(0)
curses.nocbreak()
curses.echo()
curses.endwin()
def exitCurses(screen):
curses.nocbreak()
screen.keypad(OFF)
screen.nodelay(OFF)
curses.curs_set(ON)
curses.echo()
curses.endwin()
def _dbg_instr(self): # messy input string (intended for debugging)
curses.echo()
self.s.nodelay(0)
curses.halfdelay(100)
str = self.s.getstr()
curses.noecho()
return str
def close(self):
if not self.enable:
return
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
curses.endwin()
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 clean_up_and_exit(screen):
curses.curs_set(1)
curses.nocbreak()
screen.nodelay(0)
screen.keypad(0)
curses.echo()
curses.endwin()
def main():
we_are_the_server = "--server" in sys.argv
meta = {"we_are_the_server": copy.copy(we_are_the_server)}
meta_lock = RLock()
db = {}
db_lock = RLock()
if we_are_the_server:
if server == 0:
kill_time()
exit(0)
server_pid = get_children()[0]
client = os.fork()
if client == 0:
kill_time()
exit(0)
client_pid = [x for x in get_children() if x.pid != server_pid.pid][0]
with CursesScreen() as win:
curses.echo()
win.timeout(500)
while True:
state_server = None
state_client = None
ch = win.getch()
win.erase()
if ch != -1:
win.addstr(11, 3, "%s" % chr(ch))
if ch == ord("b") or ch == ord("q"):
exit()
if ch == ord("c"):
client_pid.terminate()
if ch == ord("s"):
server_pid.terminate()
win.border(0)
win.addstr(2, 3, "Boss (%d) - alive (obviously)" % (os.getpid()))
win.addstr(
4,
3,
"Server (%d) - %s"
% (server_pid.pid, server_pid.is_running() and not server_pid.status() == psutil.STATUS_ZOMBIE),
)
win.addstr(
6,
3,
"Client (%d) - %s"
% (client_pid.pid, client_pid.is_running() and not client_pid.status() == psutil.STATUS_ZOMBIE),
)
win.addstr(9, 3, "Press 'b' kill Boss, 's' to kill Server and 'c' to kill Client.")
win.refresh()
def new_user_view():
"""
User is directed here if they selected that they are a new user to this system
Here, they enter a username and password
Those are stored in the database
User is then redirected back to the main login page to login as an existing user
:return:
"""
screen = curses.initscr()
screen.clear()
screen.addstr(5, 5, 'Enter Username:'******'Enter Password:'******' account created...')
screen.refresh()
time.sleep(2)
dashboard_database.database_menu(username)
else:
# print "User already exists"
screen.addstr(11, 5, 'Username ' + username + ' already exists...')
screen.refresh()
time.sleep(2)
dashboard_program.main_menu()
def terminate_curses():
global stdscr
if stdscr:
stdscr.keypad(0)
curses.echo()
curses.nocbreak()
curses.endwin()
def login(): curses.echo() scr.border(1) scr.addstr(2,2,"Host IP:", norm) ip = scr.getstr(2,10) scr.addstr(3,2,"Port #:", norm) port = scr.getstr(3,9,7) scr.addstr(4,2,"Database Name:", norm) db = scr.getstr(4,16,15) scr.addstr(5,2,"Username:"******"Password:"******"I'm sorry, a connection was not able to be made.", bold) scr.addstr(11,10," Press 'q' to quit, or enter to try again", bold) option = scr.getch() if option == 113: # press 'q' curses.endwin() #exits ncurses return 0 else: return 1
def tear_down():
win.keypad(0)
curses.nocbreak()
curses.echo()
curses.endwin()
if __name__ == "__main__":
try:
stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
curses.curs_set(False)
stdscr.keypad(True)
sequence = []
refreshScreen(sequence)
while True:
c = stdscr.getch()
if c == 8 or c == 127: # Backspace
if len(sequence) != 0:
sequence.pop()
elif c == 27: # Escape
break
elif c == ord('r') or c == ord('R'):
sequence = []
elif convertSlashChar(chr(c)) is not None:
sequence.append(convertSlashChar(chr(c)))
refreshScreen(sequence)
finally:
curses.echo()
curses.nocbreak()
stdscr.keypad(False)
curses.endwin()
def exit_winlib(self):
self.stdscr.keypad(0)
curses.curs_set(1)
curses.nocbreak()
curses.echo()
curses.endwin()
def curses_stop(self):
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
curses.endwin()
def main():
GPIO.setmode(GPIO.BOARD)
GPIO.setup(7, GPIO.OUT)
GPIO.setup(11, GPIO.OUT)
GPIO.setup(13, GPIO.OUT)
GPIO.setup(15, GPIO.OUT)
screen = curses.initscr()
curses.noecho()
curses.cbreak()
screen.keypad(True)
screen.nodelay(True)
action_timestamp = time.time()
try:
while True:
char = screen.getch()
if char == ord('q'):
break
elif char == curses.KEY_UP:
print('up')
GPIO.output(7, False)
GPIO.output(11, True)
GPIO.output(13, False)
GPIO.output(15, True)
action_timestamp = time.time()
elif char == curses.KEY_DOWN:
print('down')
GPIO.output(7, True)
GPIO.output(11, False)
GPIO.output(13, True)
GPIO.output(15, False)
action_timestamp = time.time()
elif char == curses.KEY_RIGHT:
print('right')
GPIO.output(7, True)
GPIO.output(11, False)
GPIO.output(13, False)
GPIO.output(15, True)
action_timestamp = time.time()
elif char == curses.KEY_LEFT:
print('left')
GPIO.output(7, False)
GPIO.output(11, True)
GPIO.output(13, True)
GPIO.output(15, False)
action_timestamp = time.time()
elif char == 10:
print('stop')
GPIO.output(7, False)
GPIO.output(11, False)
GPIO.output(13, False)
GPIO.output(15, False)
else:
if time.time() - action_timestamp > 0.5:
print('release')
GPIO.output(7, False)
GPIO.output(11, False)
GPIO.output(13, False)
GPIO.output(15, False)
action_timestamp = time.time()
finally:
curses.nocbreak()
screen.keypad(0)
curses.echo()
curses.endwin()
def __exit__(self, exc_type, exc_val, exc_tb):
curses.noraw()
self.screen.keypad(False)
curses.echo()
curses.endwin()
def end_curses(self):
curses.nocbreak()
self.screen.keypad(False)
curses.echo()
curses.flushinp()
curses.endwin()
def deinit(self):
"""Deinitializes curses."""
curses.nocbreak()
self.screen.keypad(False)
curses.echo()
curses.endwin()
def __exit__(self, exc_type, exc_value, traceback):
logger.debug(f"Exiting context and closing View object")
curses.nocbreak()
curses.echo()
curses.endwin()
return True
def close(self):
self.scr.nodelay(0)
curses.nocbreak()
curses.echo()
curses.endwin()
def main(stdscr):
students = []
courses = []
current_row = 0
curses.curs_set(0)
curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE)
print_menu(stdscr, current_row)
while 1:
key = stdscr.getch()
stdscr.clear()
if key == curses.KEY_UP and current_row > 0:
current_row -= 1
elif key == curses.KEY_DOWN and current_row < len(menu):
current_row += 1
elif (key == curses.KEY_ENTER or key in [10, 17]) and current_row == 0:
stdscr.clear()
curses.echo()
std_number = std_num(stdscr)
for i in range(std_number):
stdscr.clear()
stdscr.addstr(0, 0, f"- Student number {i + 1} info is: ")
stdscr.addstr(2, 0, " + Student name: ")
student_name = stdscr.getstr(3, 0).decode()
stdscr.addstr(4, 0, ' + Student DoB: ')
dob = stdscr.getstr(5, 0).decode()
students.append(Student(student_name, dob))
stdscr.refresh()
stdscr.getch()
elif (key == curses.KEY_ENTER or key in [10, 17]) and current_row == 1:
stdscr.clear()
curses.echo()
course_number = course_num(stdscr)
for i in range(course_number):
stdscr.addstr(0, 0, f"- Course number {i + 1} info is: ")
stdscr.addstr(1, 0, f" + Course {i + 1} name: ")
course_name = stdscr.getstr(2, 0).decode()
stdscr.addstr(3, 0, f" + Course {i + 1} credit: ")
course_credit = stdscr.getstr(4, 0).decode()
courses.append(Course(course_name, course_credit))
stdscr.refresh()
stdscr.getch()
elif (key == curses.KEY_ENTER or key in [10, 17]) and current_row == 2:
stdscr.clear()
curses.echo()
stdscr.addstr(0, 0, "- Which course do you want to add marks")
course_name = stdscr.getstr(1, 0).decode()
course_index = contain_course(course_name, courses)
if course_index < 0:
stdscr.addstr(2, 0, "This course does not exist")
else:
courses[course_index].set_mark(students, stdscr)
stdscr.getch()
elif (key == curses.KEY_ENTER or key in [10, 17]) and current_row == 3:
stdscr.clear()
curses.echo()
show_students(students, stdscr)
stdscr.getch()
elif (key == curses.KEY_ENTER or key in [10, 17]) and current_row == 4:
stdscr.clear()
curses.echo()
show_course(courses, stdscr)
stdscr.getch()
elif (key == curses.KEY_ENTER or key in [10, 17]) and current_row == 5:
stdscr.clear()
curses.echo()
show_gpa(students, stdscr)
stdscr.getch()
elif (key == curses.KEY_ENTER or key in [10, 17]) and current_row == 6:
break
print_menu(stdscr, current_row)
# import curses
import curses
# Get the curses window, turn off echoing of keyboard to screen, turn on
# instant (no waiting) key response, and use special values for cursor keys
screen = curses.initscr()
curses.noecho()
curses.cbreak()
screen.keypad(True)
try:
while True:
char = screen.getch()
if char == ord('q'):
break
elif char == curses.KEY_UP:
print "up"
elif char == curses.KEY_DOWN:
print "down"
elif char == curses.KEY_RIGHT:
print "right"
elif char == curses.KEY_LEFT:
print "left"
elif char == 10:
print "stop"
finally:
#Close down curses properly, inc turn echo back on!
curses.nocbreak(); screen.keypad(0); curses.echo()
curses.endwin()
def edit(self):
x = self.row + self.cornerx
y = self.col + self.cornery + len(self.descriptor.name) + 2
if self.descriptor.type == self.descriptor.TYPE_ENUM:
options = len(self.descriptor.enum_type.values)
self.win = curses.newwin(options, 20, x, y)
elif self.descriptor.type == self.descriptor.TYPE_BOOL:
self.win = curses.newwin(2, 6, x, y)
else:
self.win = curses.newwin(1, 20, x, y)
self.win.bkgd(' ', curses.color_pair(3))
self.win.erase()
self.panel = curses.panel.new_panel(self.win)
self.panel.top()
curses.panel.update_panels()
self.win.refresh()
if self.descriptor.type == self.descriptor.TYPE_ENUM:
options = [
value.name for value in self.descriptor.enum_type.values
]
value, modified = self.get_input(options, self.value)
if modified and value != self.value:
self.value = value
self.modified = modified
elif self.descriptor.type == self.descriptor.TYPE_BOOL:
options = ["False", "True"]
select = 1 if self.value else 0
value, modified = self.get_input(options, select)
value = True if value == 1 else False
if modified and value != self.value:
self.value = value
self.modified = modified
else:
curses.echo()
s = self.win.getstr(0, 0, 20)
if len(s) == 0:
pass
elif self.descriptor.type == self.descriptor.TYPE_FLOAT or \
self.descriptor.type == self.descriptor.TYPE_DOUBLE:
try:
value = float(s)
self.modified = True
self.value = value
except ValueError:
pass
elif self.descriptor.type == self.descriptor.TYPE_STRING:
if s != self.value:
self.value = s
self.modified = True
else:
try:
value = int(s)
self.modified = True
self.value = value
except ValueError:
pass
curses.noecho()
del self.win
del self.panel
curses.panel.update_panels()
def module_funcs(stdscr):
"Test module-level functions"
for func in [
curses.baudrate, curses.beep, curses.can_change_color,
curses.cbreak, curses.def_prog_mode, curses.doupdate,
curses.filter, curses.flash, curses.flushinp, curses.has_colors,
curses.has_ic, curses.has_il, curses.isendwin, curses.killchar,
curses.longname, curses.nocbreak, curses.noecho, curses.nonl,
curses.noqiflush, curses.noraw, curses.reset_prog_mode,
curses.termattrs, curses.termname, curses.erasechar, curses.getsyx
]:
func()
# Functions that actually need arguments
if curses.tigetstr("cnorm"):
curses.curs_set(1)
curses.delay_output(1)
curses.echo()
curses.echo(1)
f = tempfile.TemporaryFile()
stdscr.putwin(f)
f.seek(0)
curses.getwin(f)
f.close()
curses.halfdelay(1)
curses.intrflush(1)
curses.meta(1)
curses.napms(100)
curses.newpad(50, 50)
win = curses.newwin(5, 5)
win = curses.newwin(5, 5, 1, 1)
curses.nl()
curses.nl(1)
curses.putp('abc')
curses.qiflush()
curses.raw()
curses.raw(1)
curses.setsyx(5, 5)
curses.tigetflag('hc')
curses.tigetnum('co')
curses.tigetstr('cr')
curses.tparm('cr')
curses.typeahead(sys.__stdin__.fileno())
curses.unctrl('a')
curses.ungetch('a')
curses.use_env(1)
# Functions only available on a few platforms
if curses.has_colors():
curses.start_color()
curses.init_pair(2, 1, 1)
curses.color_content(1)
curses.color_pair(2)
curses.pair_content(curses.COLOR_PAIRS - 1)
curses.pair_number(0)
if hasattr(curses, 'use_default_colors'):
curses.use_default_colors()
if hasattr(curses, 'keyname'):
curses.keyname(13)
if hasattr(curses, 'has_key'):
curses.has_key(13)
if hasattr(curses, 'getmouse'):
(availmask, oldmask) = curses.mousemask(curses.BUTTON1_PRESSED)
# availmask indicates that mouse stuff not available.
if availmask != 0:
curses.mouseinterval(10)
# just verify these don't cause errors
m = curses.getmouse()
curses.ungetmouse(*m)
if hasattr(curses, 'is_term_resized'):
curses.is_term_resized(*stdscr.getmaxyx())
if hasattr(curses, 'resizeterm'):
curses.resizeterm(*stdscr.getmaxyx())
if hasattr(curses, 'resize_term'):
curses.resize_term(*stdscr.getmaxyx())
def usr_input(window, r, c, length, prompt):
curses.echo()
window.addstr(r, c, prompt)
choice = window.getstr(r, c + 2, length)
dec = choice.decode("utf-8")
return dec
def cleanup():
curses.nocbreak()
curses.echo()
curses.endwin()
pi.stop()
def close(self):
curses.echo()
curses.endwin()
def cleanup_curses():
'''Return the console to a usable state'''
curses.echo()
curses.nocbreak()
curses.endwin()
os.system("/usr/bin/clear")
def __exit__(self,a,b,c):
curses.nocbreak()
curses.curs_set(self.old)
self.scr.keypad(0)
curses.echo()
curses.endwin()
def shutDown(self):
self.isRunning = False
curses.nocbreak()
self.stdscr.keypad(0)
curses.echo()
def finish(): curses.nocbreak() curses.echo() curses.curs_set(True) curses.endwin()
def yayornay_words():
word_frequencies = read_word_frequencies()
word_items = iter(word_frequencies.items())
results_path = "/tmp/word_choices.json"
try:
with io.open(results_path, mode="r", encoding="utf-8") as fobj:
results = json.loads(fobj.read())
except:
results = {}
stdscr = curses.initscr()
stdscr.clear()
curses.noecho()
curses.cbreak()
stdscr.keypad(True)
KEY_F = 102
KEY_J = 106
KEY_K = 107
try:
last_word = list(results)[-1]
word, n = next(word_items)
while True:
is_candidate_word = (
4 <= len(word) <= 9 and word not in results
and not word.endswith("ing") and
not (word.endswith("ish") and word[:-3] in word_frequencies)
and not (word.endswith("ed") and word[:-2] in word_frequencies)
and not word[-1] == "s" and word[:-1] in word_frequencies)
if not is_candidate_word:
word, n = next(word_items)
continue
stdscr.clear()
stdscr.addstr(f"\n\n {last_word:<11} {results[last_word]}")
stdscr.addstr(f"\n\n {word:<11} ")
ch = stdscr.getch()
if ch == KEY_J:
results[word] = 1
stdscr.addstr(f"1")
last_word = word
word, n = next(word_items)
elif ch == KEY_F:
results[word] = 0
stdscr.addstr(f"0")
last_word = word
word, n = next(word_items)
elif ch == KEY_K:
results[last_word] = (results[last_word] + 1) % 2
else:
break
except KeyboardInterrupt:
pass
finally:
curses.nocbreak()
stdscr.keypad(False)
curses.echo()
curses.endwin()
results_data = json.dumps(results)
with io.open(results_path, mode="w", encoding="utf-8") as fobj:
fobj.write(results_data)
def end (self): if self.curses_on == 1: curses.echo() curses.endwin() self.curses_on = 0
def stop(self):
""" Reset the terminal """
curses.nocbreak()
self.screen.keypad(0)
curses.echo()
curses.endwin()
def main(stdscr):
# Create a new Curses window
win = curses.newwin(ROWS, COLUMNS)
curses.noecho()
curses.cbreak()
win.keypad(1)
curses.curs_set(0)
# Initialize color pairs
curses.start_color()
curses.init_pair(1, curses.COLOR_GREEN, curses.COLOR_GREEN)
curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_WHITE)
curses.init_pair(3, curses.COLOR_RED, curses.COLOR_CYAN)
# Game variables
speed = randomize_speed()
player = computer = 0
player_y = ROWS / 3
player_x = 2
computer_y = ROWS / 3
computer_x = COLUMNS - 3
ball_y, ball_x = get_new_ball_coord()
# Display welcome screen and wait for key press
win.clear()
win.border()
win.addstr(ROWS / 2 - 2, (COLUMNS / 2 + 1) - len('PONGX') / 2, \
'PONGX', curses.color_pair(3) | curses.A_BOLD)
win.refresh()
q = win.getch()
win.clear()
win.border()
win.nodelay(1)
# Game loop
while True:
# Delete old ball and paddles
draw_paddle(win, player_y, player_x)
draw_paddle(win, computer_y, computer_x)
win.addch(ball_y, ball_x, ' ')
# Get user input and check if the user has pressed 'q' to quit
# otherwise move the player
key = win.getch()
if key == ESCAPE or key == ord('q'):
break
elif key == curses.KEY_DOWN \
and player_y < ROWS - (PADDLE_LENGTH + 1):
player_y += 1
elif key == curses.KEY_UP and player_y > 1:
player_y -= 1
# Move the computer
if computer_y - random.randint(0, 3) < ball_y \
and computer_y < ROWS - (PADDLE_LENGTH + 1):
computer_y += 1
if computer_y + PADDLE_LENGTH > ball_y \
and computer_y > 1:
computer_y -= 1
# Move the ball
ball_y += speed[0]
ball_x += speed[1]
# Check ball collision
if has_collided(ball_y, ball_x, player_y, player_x):
speed[1] = -speed[1]
if has_collided(ball_y, ball_x, computer_y, computer_x - 1):
speed[1] = -speed[1]
# Checks if the ball is going off win
if ball_y <= 1 or ball_y >= ROWS - 2:
speed[0] = -speed[0]
if ball_x <= 1:
speed[0] = random.choice((-1, 1))
ball_y, ball_x = get_new_ball_coord()
computer += 1
elif ball_x >= COLUMNS - 2:
speed[0] = random.choice((-1, 1))
ball_y, ball_x = get_new_ball_coord()
player +=1
# Draw the net, paddles and ball
for i in range(1, ROWS, 2):
win.addch(i, 40, '|')
draw_paddle(win, player_y, player_x, 1)
draw_paddle(win, computer_y, computer_x, 1)
win.addstr(1, 10, 'Player: %s' % player, curses.color_pair(3))
win.addstr(1, COLUMNS - \
len('Computer: %s' % computer) - 11, 'Computer: %s' % computer, \
curses.color_pair(3))
# Check if there is a winner and display it on screen
if player == 11 or computer == 11:
if player > computer:
key = display_winner(win, 'Player')
else:
key = display_winner(win, 'Computer')
if key == ESCAPE or key == ord('q'):
break
# Reset game variables
speed = randomize_speed()
player = computer = 0
player_y = ROWS / 3
player_x = 2
computer_y = ROWS / 3
computer_x = COLUMNS - 3
ball_y, ball_x = get_new_ball_coord()
win.clear()
win.border()
win.nodelay(1)
win.addch(ball_y, ball_x, 'x', curses.color_pair(2))
win.refresh()
time.sleep(0.05)
# Clean up before exiting
curses.nocbreak()
win.keypad(0)
curses.echo()
curses.endwin()
def main(stdscr):
students = []
courses = []
current_row = 0
curses.curs_set(0)
curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE)
if os.path.isfile('students.dat'):
zip_file = zipfile.ZipFile('students.dat', 'r')
zip_file.extractall()
print_menu(stdscr, current_row)
while 1:
key = stdscr.getch()
stdscr.clear()
if key == curses.KEY_UP and current_row > 0:
current_row -= 1
elif key == curses.KEY_DOWN and current_row < len(menu):
current_row += 1
elif key == curses.KEY_ENTER and current_row == 0:
stdscr.clear()
curses.echo()
std_number = std_num(stdscr)
for i in range(std_number):
stdscr.clear()
stdscr.addstr(0, 0, f"- Student number {i + 1} info is: ")
stdscr.addstr(2, 0, " + Student name: ")
student_name = stdscr.getstr(3, 0).decode()
stdscr.addstr(4, 0, ' + Student DoB: ')
dob = stdscr.getstr(5, 0).decode()
students.append(Student(student_name, dob))
stdscr.refresh()
with open("student.txt", "w") as sf:
for student in students:
sf.write(
f"{student.get_id()} : {student.get_name()} : {student.get_dob()} \n"
)
stdscr.getch()
elif key == curses.KEY_ENTER and current_row == 1:
stdscr.clear()
curses.echo()
course_number = course_num(stdscr)
for i in range(course_number):
stdscr.addstr(0, 0, f"- Course number {i + 1} info is: ")
stdscr.addstr(1, 0, f" + Course {i + 1} name: ")
course_name = stdscr.getstr(2, 0).decode()
stdscr.addstr(3, 0, f" + Course {i + 1} credit: ")
course_credit = stdscr.getstr(4, 0).decode()
courses.append(Course(course_name, course_credit))
stdscr.refresh()
with open("course.txt", "w") as cf:
for course in courses:
cf.write(
f"{course.get_id()}: {course.get_name()} with {course.get_credit()} credit \n"
)
stdscr.getch()
elif key == curses.KEY_ENTER and current_row == 2:
stdscr.clear()
curses.echo()
stdscr.addstr(0, 0, "- Which course do you want to add marks")
course_name = stdscr.getstr(1, 0).decode()
course_index = contain_course(course_name, courses)
if course_index < 0:
stdscr.addstr(2, 0, "This course does not exist")
else:
courses[course_index].set_mark(students, stdscr)
with open("mark.txt", "w") as mf:
mf.write(f"{course_name} \n")
for name, mark in courses[course_index].get_mark().items():
mf.write(f"{name} : {mark} \n")
mf.write("\n")
stdscr.getch()
elif key == curses.KEY_ENTER and current_row == 3:
stdscr.clear()
curses.echo()
show_students(students, stdscr)
stdscr.getch()
elif key == curses.KEY_ENTER and current_row == 4:
stdscr.clear()
curses.echo()
show_course(courses, stdscr)
stdscr.getch()
elif (key == curses.KEY_ENTER or key in [10, 17]) and current_row == 5:
stdscr.clear()
curses.echo()
show_gpa(students, stdscr)
stdscr.getch()
elif (key == curses.KEY_ENTER or key in [10, 17]) and current_row == 6:
files = [student.txt, mark.txt, course.txt]
with zipfile.ZipFile("student.dat", "w") as compressed_file:
for file in files:
compressed_file.write(file)
break
print_menu(stdscr, current_row)
def run(self, stdscr):
"""
Cheats selection menu processing..
:param stdscr: screen
"""
# init
Gui.init_colors()
stdscr.clear()
self.height, self.width = stdscr.getmaxyx()
self.max_visible_cheats = self.height - 7
self.cursorpos = 0
while True:
stdscr.refresh()
self.cheats = self.search()
self.draw(stdscr)
c = stdscr.getch()
if c == curses.KEY_ENTER or c == 10 or c == 13:
# Process selected command (if not empty)
if self.selected_cheat() is not None:
Gui.cmd = command.Command(self.selected_cheat(),
Gui.arsenalGlobalVars)
# check if arguments are needed
# if len(Gui.cmd.args) != 0:
# args needed -> ask
args_menu = ArgslistMenu(self)
curses.endwin()
curses.echo()
wrapper(args_menu.run)
break
elif c == curses.KEY_F10 or c == 27:
Gui.cmd = None
break # Exit the while loop
elif c == 339 or c == curses.KEY_PPAGE:
# Page UP
self.move_page(-1)
elif c == 338 or c == curses.KEY_NPAGE:
# Page DOWN
self.move_page(1)
elif c == curses.KEY_UP:
# Move UP
self.move_position(-1)
elif c == curses.KEY_DOWN:
# Move DOWN
self.move_position(1)
elif c == curses.KEY_BACKSPACE or c == 127 or c == 8:
if self.check_move_cursor(-1):
i = self.xcursor - self.x_init - 1
self.input_buffer = self.input_buffer[:
i] + self.input_buffer[
i + 1:]
self.xcursor -= 1
# new search -> reset position
self.position = 0
self.page_position = 0
elif c == curses.KEY_DC or c == 127:
if self.check_move_cursor(1):
i = self.xcursor - self.x_init - 1
self.input_buffer = self.input_buffer[:i +
1] + self.input_buffer[
i + 2:]
# new search -> reset position
self.position = 0
self.page_position = 0
elif c == curses.KEY_LEFT:
# Move cursor LEFT
if self.check_move_cursor(-1): self.xcursor -= 1
elif c == curses.KEY_RIGHT:
# Move cursor RIGHT
if self.check_move_cursor(1): self.xcursor += 1
elif c == curses.KEY_BEG or c == curses.KEY_HOME:
# Move cursor to the BEGIN
self.xcursor = self.x_init
elif c == curses.KEY_END:
# Move cursor to the END
self.xcursor = self.x_init + len(self.input_buffer)
elif c == 9:
# TAB cmd auto complete
if self.input_buffer != "":
predictions = []
for cheat in self.cheats:
if cheat.command.startswith(self.input_buffer):
predictions.append(cheat.command)
if len(predictions) != 0:
self.input_buffer = commonprefix(predictions)
self.xcursor = self.x_init + len(self.input_buffer)
self.position = 0
self.page_position = 0
elif 20 <= c < 127:
i = self.xcursor - self.x_init
self.input_buffer = self.input_buffer[:i] + chr(
c) + self.input_buffer[i:]
self.xcursor += 1
# new search -> reset position
self.position = 0
self.page_position = 0
curses.endwin()
def cleanup():
curses.nocbreak()
stdscr.keypad(0)
curses.echo()
curses.endwin()
def destruct(window, stdscr):
curses.nocbreak()
stdscr.keypad(False)
curses.echo()
curses.endwin()
def cleanup_curses(self):
self.screen.keypad(0)
curses.curs_set(1)
curses.echo()
curses.endwin()
