Python readline.insert_text函数代码示例

    def _readline_getc(self):
        do_comp = self.callbacks["get_var"]("input_do_completions")

        # Don't flush, because readline loses keys.
        r = self.get_key(False)

        if r == curses.KEY_BACKSPACE:
            r = ord("\b")

        if chr(r) == '\t' and do_comp:
            self.input_box.rotate_completions()
            return

        # Accept current completion
        if chr(r) in " \b\n" and do_comp:
            comp = self.input_box.break_completion()
            if comp:
                log.debug("inserting: %s" % comp)
                readline.insert_text(comp)

        # Discard current completion
        else:
            self.input_box.break_completion()

        log.debug("KEY: %s" % r)
        return r

            def pre_input_hook():
                readline.insert_text(display.display(
                    thing, shortid=False, colored=False))
                readline.redisplay()

                # Unset the hook again
                readline.set_pre_input_hook(None)

 def insert_text ( self, line ):
     if util.isPlatformWindows ():
         import pyreadline
         Readline ().insert_text ( line )
     else:
         import readline
         readline.insert_text ( line )

def rl_autoindent():
    """Auto-indent upon typing a new line according to the contents of the
    previous line.  This function will be used as Readline's
    pre-input-hook.

    """
    hist_len = readline.get_current_history_length()
    last_input = readline.get_history_item(hist_len)
    try:
        last_indent_index = last_input.rindex("    ")
    except:
        last_indent = 0
    else:
        last_indent = int(last_indent_index / 4) + 1
    if len(last_input.strip()) > 1:
        if last_input.count("(") > last_input.count(")"):
            indent = ''.join(["    " for n in range(last_indent + 2)])
        elif last_input.count(")") > last_input.count("("):
            indent = ''.join(["    " for n in range(last_indent - 1)])
        elif last_input.count("[") > last_input.count("]"):
            indent = ''.join(["    " for n in range(last_indent + 2)])
        elif last_input.count("]") > last_input.count("["):
            indent = ''.join(["    " for n in range(last_indent - 1)])
        elif last_input.count("{") > last_input.count("}"):
            indent = ''.join(["    " for n in range(last_indent + 2)])
        elif last_input.count("}") > last_input.count("{"):
            indent = ''.join(["    " for n in range(last_indent - 1)])
        elif last_input[-1] == ":":
            indent = ''.join(["    " for n in range(last_indent + 1)])
        else:
            indent = ''.join(["    " for n in range(last_indent)])
    readline.insert_text(indent)

 def defaulter():
     """define default behavior startup"""
     if _readline_available:
         readline.insert_text(default)
     readline.set_startup_hook(defaulter)
     readline.get_completer()
     readline.set_completer(completer)

 def printf(self, string):
     #readline.set_startup_hook(lambda: readline.insert_text("{0}".format(str)) or readline.redisplay())
     self.stdout.write(str("\n{0}\n".format(string))+"\n")
     self.stdout.flush()
     #readline.parse_and_bind('\C-M')
     readline.insert_text("oi\n")
     #readline.parse_and_bind('\\n')
     readline.redisplay()

 def pre_input_hook(self):
     """If a line buffer has been filled then inject it into the readline
     buffer for the user to edit."""
     if self.line_buffer:
         readline.insert_text(
             self.line_buffer.decode(ex_config.FILE_ENCODING).rstrip('\n'))
         readline.redisplay()
         self.line_buffer = None

def _fred_completer(text, state):
    """Custom completer function called when the user presses TAB."""
    s_current_cmd = readline.get_line_buffer()
    # Write partial command+\t to debuggerso it can do the completion.
    result = get_child_response(s_current_cmd + '\t')
    # Erase what text we already have:
    result = result.replace(s_current_cmd, "")
    readline.insert_text(result)

def getUserInWithDef(msg, default):
    readline.set_startup_hook(lambda: readline.insert_text(default))
    var = raw_input(colors.BOLDON + "%s: " % (msg) + colors.BOLDOFF)
    readline.set_startup_hook(lambda: readline.insert_text(''))
    if var == "":
        print("No input given, try again.")
        return getUserIn(msg)
    return var

def startup_hook():
    """startup_hook() -- internal readline callback. Do not call.
    """
    if (Readline.interruption != None):
        readline.insert_text(Readline.interruption[0])
        readline.set_point(Readline.interruption[1])
        readline.set_mark(Readline.interruption[2])
        Readline.interruption = None

    def complete(self, line, buf, state, run=False, full_line=None):
        logger.debug('Walked to: %s' % self.name)
        if line and self.dynamic_args and len(line) > 1:
            logger.debug("Dynamic arg '%s' found" % line[0])
            has_arg_completed = True
            # Dynamic arg already filled, jump to next word
            next_command = line[1]
            line.pop(0)
        elif line:
            next_command = line[0]
            has_arg_completed = False

            candidates = self.get_candidates(next_command)
            if candidates and len(candidates) > 1 and buf:
                logger.debug("More than one candidate, not walking in %s" % buf)
                return self._next_command(state, buf)
            elif candidates and next_command in candidates:
                logger.debug("Found %s in childs, walking." % next_command)
                cmd = candidates.pop(next_command)
                return cmd.complete(line[1:], buf, state, run, full_line)
            else:
                logger.debug('Not walking because %s was not found in childs' % next_command)
                if has_arg_completed:
                    return self._next_command(state, next_command)

        logger.debug('Line=>%s, Buf=>%s, state=>%s' % (line, buf, state))

        if run:
            logger.debug('Executing %s' % self.name)
            return self.run(full_line.rstrip())

        logger.debug('Starting arg complete')

        # Checking if user already typed a valid arg without space at end
        if self.dynamic_args:
            if len(line) and buf and line[0] in self.args():
                readline.insert_text(" ")
                logger.debug("Inserted blank space")
            elif len(line) and not buf and line[0] not in self.args():
                logger.debug("Found an unknown arg, suggesting next command.")
                return self._next_command(state, buf)

        if buf == self.name:
            readline.insert_text(" ")
            logger.debug("Inserted blank space")

        if not self.dynamic_args:
            return self._next_command(state, buf)

        if self.dynamic_args:
            if (buf.strip() in self.args()):
                return self._next_command(state, buf)
            elif line and line[0] in self.args():
                return self._next_command(state, buf)
            else:
                return self._dynamic_args(state, buf)
        else:
            return self._next_command(state, buf)

 def complete(self, text, state):
     if not text:
         readline.insert_text('    ')
         if TabCompleter.uses_editline:
             # It won't move the cursor for us, apparently
             sys.stdout.write('\x1b[4C')
         readline.redisplay()
         sys.stdout.flush()
         return None
     else:
         return rlcompleter.Completer.complete(self, text, state)

    def autocompleter(self, txt, state):
        chopped = []
        try:
            r = []
            self._line = readline.get_line_buffer()
            self.cursorix(readline.get_endidx())
            last = self.lastword()
            if self.atendofcmd() or self.cmd() == "help":
                for c in command.allcmds():
                    if c.startswith(txt):
                        r.append(c + " ")
            else:
                # print "<%s, %s>" % (txt, state)
                curacct = self.currentaccount()

                if not last:
                    acct = curacct
                else:
                    if last.startswith("/"):
                        acct = accounts.getroot()
                        last = last.lstrip("/")
                    else:
                        acct = curacct

                    chopped = last.rsplit("/", 1)
                    tmpacct = acct.getsubaccount(chopped[0])

                    if tmpacct:
                        acct = tmpacct

                    if len(chopped) > 1:
                        txt = chopped[1]

                for a in acct.accounts():
                    if txt == "" or a.name().startswith(txt):
                        r.append(a.name() + "/")
                if len(r) == 1:
                    readline.insert_text("/")
            try:
                return r[state]
            except IndexError:
                return None

        except Exception, ex:
            print "%s:\n%s\n%s" % ("autocompleter exception", type(ex), str(ex))
            print "txt: %s; state: %s" % (txt, state)
            print "chopped: " + str(chopped)
            print "last: " + last

def rlinput(prompt, prefill=''):
    """kind of like ras_input but with readline support and pre-filled answer"""
    readline.set_startup_hook(lambda: readline.insert_text(prefill))
    try:
        return raw_input(prompt)
    finally:
        readline.set_startup_hook()

 def _rlinput(self, prompt, prefill):
     readline.set_startup_hook(lambda: readline.insert_text(prefill))
     try:
         return raw_input(prompt)
     finally:
         readline.set_startup_hook()
     return prefill