def anykey(message=""):
        if message:
            print(message)

        from msvcrt import getch

        # getch returns b'[character]', so we turn it into a string
        # and strip out the b' and ' parts
        while msvcrt.kbhit():
            char = getch()
        # some inputs need to be compared using their number, for some reason
        if ord(char) == 224:
            # aha! an arrow key!
            char = ord(getch())
            if char == 72:
                char = movementButtons[0]  # up
            elif char == 80:
                char = movementButtons[1]  # down
            elif char == 75:
                char = movementButtons[2]  # left
            elif char == 77:
                char = movementButtons[3]  # right
        elif ord(char) == 3:
            char = "q"  # KeyboardInterrupt
        elif ord(char) == 27:
            char = "p"  # Esc
        elif ord(char) == 8:
            char = "\x7F"  # backspace
        elif ord(char) == 18:
            char = "\x12"  # ctrl-R
        else:
            char = str(char)[2:-1]
        if char == "q":
            quit(True)
        return char.lower()

def submenu(string_name_of_submenu):
	print(
		"{} (press 1, 2 or ESC):\n\t1. Donor\n\t2. Event\n\tEsc. Back to the Main menu".format(string_name_of_submenu))
	action = ord(getch())
	while action not in list(ALL_ACTION.values()):
		action = ord(getch())
	if action == ALL_ACTION['KEY_ONE']:
		if not file_is_empty(DONOR_PATH):
			loading()
			if LIST == string_name_of_submenu:
				list_donor()
			if SEARCH == string_name_of_submenu:
				search_donor()
			if MODIFY == string_name_of_submenu:
				modofy_donor()
	if action == ALL_ACTION['KEY_TWO']:
		if not file_is_empty(EVENT_PATH):
			loading()
			if LIST == string_name_of_submenu:
				list_events()
			if SEARCH == string_name_of_submenu:
				search_event()
			if MODIFY == string_name_of_submenu:
				modify_event()
	if action == ALL_ACTION['KEY_ESC']:
		menu()

def getch():
    """getch() for Windows and Linux.
       This won't work unless run from a terminal.
    """
    # this must be executed from a terminal
    if not is_executed_from_console():
        system_exit("libastyle.getch() must be run from the console")
    # WINDOWS uses msvcrt
    if os.name == "nt":
        # clear buffer
        while msvcrt.kbhit():
            msvcrt.getch()
        # read char
        ch_in = msvcrt.getch()
    # LINUX uses termios and tty
    else:
        # clear buffer
        sys.stdin.flush()
        # read char
        fd_in = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd_in)
        try:
            tty.setraw(sys.stdin.fileno())
            ch_in = sys.stdin.read(1)
            if ch_in == '\x1b':			# alt key (27)
                ch_in = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd_in, termios.TCSADRAIN, old_settings)
    # convert to unicode for Python 3
    return ch_in.decode('utf-8')

 def __call__(self):
     msvcrt = self.msvcrt
     
     c = msvcrt.getch()
     if c == '\x00' or c == '\xE0':    #functions keys
         msvcrt.getch()
     return c

def load_text(file_location, progress_file):
	text = np.genfromtxt(file_location,dtype='str')
	text_temp = []
	start_index = 0
	progress_text = []
	if progress_file:
		progress_text = np.genfromtxt(progress_file,dtype=str)
		if len(progress_text) > 0:
			index = np.where(text == progress_text[len(progress_text)-1])
			start_index = index[0]
	print 'start:'+str(start_index)
	key = ''
	prev_word = []
	for word in text[start_index+1:]:
		print word
		key = msvcrt.getch()
		if key == 'k': 
			progress_text = np.append(progress_text, word)
		elif key == 'b':
			progress_text = np.append(progress_text, prev_word)
			print prev_word + ' added. add:'+ word+'?'
			key = msvcrt.getch()
			if key == 'k': 
				progress_text = np.append(progress_text, word)
			else:
				print '--'
		elif key == 'q':
			break
		else:
			print '--'
		prev_word = word
		
	np.savetxt('KeptWords.txt',progress_text,delimiter='\n', fmt="%s")

def maps(summ):
    count = 0
    os.system(clear_fn)
    quit = ''
    for x in full:
        if summ == x['summoner']:
            count += 1
            print 'Champion: %s' % (x['champion'])
            print 'Date: %s - Won: %s - Length: %s' % (x['datetime'], x['won'], x['length'])
            try:
                print 'Kills: %s - Deaths: %s - Assists: %s - KDR: %.2f' % (x['kills'], x['deaths'], x['assists'], x['kills'] / x['deaths'])
            except ZeroDivisionError:
                print 'Kills: %s - Deaths: %s - Assists: %s - KDR: 0' % (x['kills'], x['deaths'], x['assists'])

            print 'Dealt: Phyiscal: %s - Magical: %s - Total: %s' % (com(x['physicalDamageDealt']), com(x['magicDamageDealt']), com(x['physicalDamageDealt'] + x['magicDamageDealt']))
            print 'Received: Phyiscal: %s - Magical: %s - Total: %s' % (com(x['physicalDamageTaken']), com(x['magicDamageTaken']), com(x['physicalDamageTaken'] + x['magicDamageTaken']))
            print 'Gold: %s - Healing: %s - CreepScore: %s ' % (com(x['gold']), com(x['healed']), com(x['neutralMinionsKilled'] + x['minions']))
            length = getsec(x['length'])
            print 'Gold/Min: %s - CS/Min: %.2f\n' % (com((x['gold'] / length) * 60), ((x['neutralMinionsKilled'] + x['minions']) / length) * 60)

            if quit == 'q' or quit == 'Q':
                break

            if count >= 2:
                print 'Press a key to view more or Q to quit\n'
                quit = msvcrt.getch()
                count = 0
                os.system(clear_fn)
    print '\nPress a Key to continue'
    msvcrt.getch()

	def keypress(self):
		
		while True:
			
			key = msvcrt.getch()
			key1 = ""
			if key == u'\xe0'.encode('latin-1'):
				key1 = msvcrt.getch()
			
			
			print "Key:" + key + key1
			
			key = key + key1
			
			if key == u'\xe0M'.encode('latin-1'):
				print 'Right'
				self.tts.next()
			if key == u'\xe0K'.encode('latin-1'):
				print 'Left'
				self.tts.previous()
			if key == 'h':
				print 'Hello'
			if key == 'e':
				self.tts.stopSpeak()
				break;

def main():
    grid = [[0]*4 for i in range(4)]
    x, y = random.randrange(4), random.randrange(4)
    grid[y][x] = 2 if random.random() < .9 else 4
    while True:
        print('\n' * H)
        print(grid_fmt.format(*[i or '' for r in grid for i in r]))
        gridcp = [r[:] for r in grid]
        if not (move_up(gridcp) or move_down(gridcp) or
                move_left(gridcp) or move_right(gridcp)):
            print('Game over!')
            break
        moved = False
        k = msvcrt.getch()
        if msvcrt.kbhit():
            k += msvcrt.getch()
        if k == b'\xe0H':
            moved = move_up(grid)
        elif k == b'\xe0P':
            moved = move_down(grid)
        elif k == b'\xe0K':
            moved = move_left(grid)
        elif k == b'\xe0M':
            moved = move_right(grid)
        elif k in (b'\x1b', b'q'):
            break
        if moved:
            x, y = random.randrange(4), random.randrange(4)
            while grid[y][x]:
                x, y = random.randrange(4), random.randrange(4)
            grid[y][x] = 2 if random.random() < .9 else 4

def wait():
    try:
        import msvcrt
        print("Press any key to continue")
        msvcrt.getch()
    except Exception:
        pass

def getkey(fullterm=False):
    """Return a key from the current console, in a platform independent way"""
    # there's probably a better way to initialize the module without
    # relying onto a singleton pattern. To be fixed
    global _INIT
    if not _INIT:
        _INIT = _init_term(fullterm)
    if os.name == 'nt':
        # w/ py2exe, it seems the importation fails to define the global
        # symbol 'msvcrt', to be fixed
        import msvcrt
        while 1:
            z = msvcrt.getch()
            if z == '\3':
                raise KeyboardInterrupt('Ctrl-C break')
            if z == '\0':
                msvcrt.getch()
            else:
                if z == '\r':
                    return '\n'
                return z
    elif os.name == 'posix':
        c = os.read(sys.stdin.fileno(), 1)
        return c
    else:
        import time
        time.sleep(1)
        return None

 def exit_script(self, error):
     #exit script when an error occured
     print error
     print 'Configuration script stoped.\n'
     print 'Press any key to continue...'
     msvcrt.getch()
     sys.exit(1)

def main():
    print("""Please use the Spacebar to tap,
press any other key to finish or r to restart""")
    data = []
    msvcrt.getch()
    lasttime = time.time()
    while True:
        if msvcrt.kbhit():
            key = ord(msvcrt.getch())
            if key == 32:
                data.append(time.time() - lasttime)
                lasttime = time.time()
            elif key == 114:
                main()
                break
            else:
                invData = [60 / x for x in data]
                for d in invData:
                    print(d)
                break
            avg = sum(data) / float(len(data))
            os.system('cls')
            print("""Please use the Spacebar to tap,
press any other key to finish or r to restart""")
            print('Average BPM:', 60 // avg)

 def p_opts_screen(self, def_num, min_op, max_op, menu):
     enter_not_pressed = True
     while enter_not_pressed:
         cls()
         print()
         print()
         print()
         print(menu[def_num])
         key = ord(getch())
         if key == 224:
             key = ord(getch())
             if key == 72:  # -UP-
                 if def_num == min_op:
                     pass
                 else:
                     def_num -= 1
             if key == 80:  # -DOWN-
                 if def_num == max_op:
                     pass
                 else:
                     def_num += 1
         elif key == 13:
             enter_not_pressed = False
             return def_num
         elif key == 27:
             return False

    def get_user_command(self):
        """Get a command from the user.

        This method displays a prompt to the user and returns when one of
        the command keys is pressed.
        """
        self.cmd_line.display_command()
        cmd_string = ''
        cmd_key = None
        self.tab_count = 0
        while not cmd_key in ['ENTER_POSIX', 'ENTER_WIN']:
            key = getch()
            # If a special key, act on it
            if key in _COMMAND_KEY:
                cmd_key = _COMMAND_KEY[key]
                # Windows does things oddly for some keys
                if not os.name == 'posix' and cmd_key == 'SPECIAL_WIN':
                    key = getch()
                    cmd_key = _WIN_COMMAND_KEY.get(key)
                    if cmd_key is None:
                        continue
                self._process_command_keys(cmd_key)
                cmd_string = self.cmd_line.get_command()
            # else add key to command buffer
            else:
                cmd_string = self.cmd_line.get_command()
                self.cmd_line.add(key)
                cmd_string = self.cmd_line.get_command()
            sys.stdout.flush()

        self.position = 0
        return cmd_string

def alarm(hours, minutes, seconds):
    time.sleep(abs(hours * 3600 + minutes * 60 + seconds))
    while msvcrt.kbhit():
        msvcrt.getch()
    while not msvcrt.kbhit():
        winsound.Beep(440, 250)
        time.sleep(0.25)

 def get_command():
     """Uses the msvcrt module to get key codes from buttons pressed to navigate through the game. The arrows,
     enter, tab, Page Down, and escape keys are used so far."""
     cmd = ""
     while 1:
         key = ord(getch())
         if key == 224:
             key = ord(getch())
             cmd = arrow_keys.get(key, "")
             return cmd
         elif key == 13:
             putch("\n")
             break
         elif key == 8:
             cmd = cmd[:-1]
             putch(chr(8))
             putch(" ")
             putch(chr(8))
         elif key == 27:
             cmd = 'q'
             return cmd
         elif key == 9:
             cmd = 'tab'
             return cmd
         else:
             putch(chr(key))
             cmd += chr(key)
     return cmd

def get_key(timeout=0.0):
    """Non-blocking version of getch"""
    
    if timeout < 0:
        # Revert to blocking version
        return getch()
        
    char = None
    if os.name == 'nt':
        import msvcrt
        start = time.time()
        while True:
            if msvcrt.kbhit():
                char = msvcrt.getch()
                if char in b'\x00\xe0':
                    # special key, two bytes
                    char += msvcrt.getch()
                break
            if time.time() > (start + timeout):
                break
            else:
                # poll at most every 50 ms
                time.sleep(0.05)
    
    elif os.name == 'posix':
        from select import select
        rlist, wlist, xlist = select([sys.stdin], [], [], timeout)
        if sys.stdin in rlist:
            char = sys.stdin.read()
    
    return char

     def get_char(self):
       ch = msvcrt.getch()      
       if len(ch) == 1:
         if ch in string.printable:
           return ch
         elif ch == '\x08':
           self.delchar() 		 
   	 elif ch == '\xe0':
          ch = msvcrt.getch()
          if ch == self.CODE_LEFT: 
            if self.cursor > 0:
	      self.print_text(self.MOVE_LEFT)	
	      self.cursor -= 1	
          elif ch == self.MOVE_RIGHT:
            if self.cursor < len(self.line):
	      pad = len(self.line) - self.cursor
	      self.print_text(self.line[self.cursor:] + (pad - 1) * self.MOVE_LEFT)
	      self.cursor += 1
          elif ch == self.MOVE_UP:
	      self.clear_line()
	      cmd = self.history.getnext()
	      if cmd:
                self.insert_text(cmd)	
          elif ch == self.MOVE_DOWN:
	      self.clear_line()
              cmd = self.history.getprev()
	      if cmd:
	        self.insert_text(cmd)
          return None

def main(channel = 'Z'):
    ##channel = 'X' # This can be 'X' or 'Y' or 'Z' channels
    min_position = -4 # mm
    max_position = 12.2 # m
    rate = 0.5 # number of points written per second to the stage
    density = 2 # number of points across the full scale range
    wait =  6 # Wait time before sweeping back in seconds

    x_mm_array_f = numpy.linspace(min_position,max_position,density)
    x_mm_array_b = numpy.linspace(max_position,min_position,density)
    xps = qt.instruments['xps']

    while 1:
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        print 'Sweeping %s forward...' % channel
        for i in x_mm_array_f:
            xps.set('abs_position%s' % channel, i)
            time.sleep(1.0/rate)
        time.sleep(wait)
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        print 'Sweeping %s backward...' % channel
        for i in x_mm_array_b:
            xps.set('abs_position%s' % channel, i)
            time.sleep(1.0/rate)
        time.sleep(wait)


    f_string = 'set_abs_position' + channel
    # Create function that corresponds to the abs_position set function of
    # the correct channel, then call it to reset the voltage to 0.
    reset_channel = getattr(xps, f_string)
    reset_channel(0.0)
    return

 def __call__(self):
     import msvcrt
     k=ord(msvcrt.getch())
     if k == 0 or k == 224:                    #Special keys
         return 1000+ord(msvcrt.getch())   #return 1000+ 2nd code
     else:
         return k