Exemple #1
0
 def restore_old_history(self):
     readline.clear_history()
     for line in self._oldHistory:
         if line is None:
             continue
         readline.add_history(line)
     self._oldHistory = []
Exemple #2
0
    def __init__(self):
        """Class constructor. Read class docstring for more details"""

        pprint_try_use_unicode()
        self.variables = {}
        self.options = {
            "implicit_multiplication": True,
            "num_tolerance": 1e-10,
            "integration_variable": None,
            "diff_variable": None,
            "tau_kills_pi": False,
            "always_sub": False,
            "always_num": False}
        self.update_completer()

        self.sub = False
        self.num = False

        # History . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

        path = join(dirname(abspath(__file__)), ".symi_history")
        try:
            with open(path, "r") as f:
                readline.clear_history()
                history = f.readlines()
                for his in history:
                    his = his.strip()
                    if his == "":
                        continue
                    readline.add_history(his)
        except FileNotFoundError:
            pass

        print(self.welcome_msg)
Exemple #3
0
    def input_callback(self, prompt, completions=True):
        # Setup subedit
        self.curs_set(1)

        self.callbacks["set_var"]("input_do_completions", completions)
        self.callbacks["set_var"]("input_prompt", prompt)

        self.input_box.reset()
        self.input_box.refresh()
        curses.doupdate()

        self.pseudo_input_box.keypad(0)

        r = raw_readline()
        if not r:
            r = ""

        self.pseudo_input_box.keypad(1)

        # Only add history for commands, not other prompts
        if completions:
            readline.add_history(r)

        self.callbacks["set_var"]("input_prompt", "")
        self.input_box.reset()
        self.input_box.refresh()
        curses.doupdate()

        self.curs_set(0)
        return r
Exemple #4
0
 def _exec_from_file(self,
                     filename,
                     quiet=False,
                     skip_history=False,
                     print_comments=config['POST_EDIT_PRINT_COMMENTS']):
     previous = ''
     for stmt in open(filename):
         # - skip over multiple empty lines
         stripped = stmt.strip()
         if stripped == '' and stripped == previous:
             continue
         if not quiet:
             if stripped.startswith('#'):
                 if print_comments:
                     self.write(grey("... {}".format(stmt), bold=False))
             else:
                 self.write(cyan("... {}".format(stmt)))
         if not stripped.startswith('#'):
             line = stmt.strip('\n')
             if line and not line[0].isspace():
                 source = "\n".join(self.buffer)
                 more = self.runsource(source, self.filename)
                 if not more:
                     self.resetbuffer()
             self.buffer.append(line)
             if line.strip() and not skip_history:
                 readline.add_history(line)
         previous = stripped
     self.push('')
Exemple #5
0
def readline(prompt="user> "):
    global history_loaded
    #检验history是否载入,若没有,先载入
    if not history_loaded:
        history_loaded = True
        try:
            with open(history_file, 'r') as f:
                for line in f.readlines():
                    pyreadline.add_history(line.rstrip("\r\n"))
                pass
        except IOError:
            #
            pass
    #读用户输入行
    try:
        line = input(prompt)
        pyreadline.add_history(line)

        with open(history_file, 'a') as f:
            f.write(line + '\n')
    except IOError:
        pass
    except EOFError:
        return None
    return line
Exemple #6
0
def exec_cmd(cmdline):
    """Interpret a command."""
    cmd, arg = _parse_cmdline(cmdline)
    if not cmd:
        print('Bad command.')
    else:
        cmd_callable = get_cmd(cmd)
        if not cmd:
            print('Type a command. Try \'help\'.')
        elif cmd_callable:
            try:
                cmd_callable(arg)
            except ImproperArgError as e:
                print(str(e))
            except UsageError as e:
                print('usage: ' + cmd + ' ' + str(e))
            except MissingDeckError:
                print('No active deck. Create a new deck with the \'deck\' '
                      'command.')
            except cards.ScrapeError as e:
                print('Scrape failed: ' + str(e))
            if 'readline' in sys.modules:
                readline.add_history(cmdline)
        else:
            print('%s is not a command. Try \'help\'.' % str(cmd))
    return True
Exemple #7
0
    def get_meta(prompt, default, default_list):
        default_count = 0
        if default_list:
            if not default:
                count = len(default_list)
                if count == 0:
                    default = ''
                else:
                    if type(default_list[0]) is str:
                        default = default_list[0]
                    else:
                        default = default_list[0][0]
                    default_count = count - 1

            readline.clear_history()
            default_list.reverse()
            for d in default_list:
                if type(d) is str:
                    readline.add_history(d)
                else:
                    readline.add_history(d[0])

        if default_count > 0:
            full_prompt = ('{} [{}](+ {} more): '.
                    format(prompt, default, default_count))
        else:
            full_prompt = ('{} [{}]: '.
                    format(prompt, default))

        result = input(full_prompt)
        if result == '':
            return default
        else:
            return result
Exemple #8
0
def _push_readline_history(history, clear_history=True):
    """Restores readline's history and optionally clears it first (default)"""
    if rl_type != RlType.NONE:
        if clear_history:
            readline.clear_history()
        for line in history:
            readline.add_history(line)
def main():
    global es_host, es_port, request_host

    parser = argparse.ArgumentParser()
    parser.add_argument(
        '-host', help='elasticsearch host (default is http://localhost)')
    parser.add_argument('-port', help='elasticsearch port (default is 9200)')

    args = parser.parse_args()

    es_host = args.host if args.host else es_host
    es_port = args.port if args.port else es_port

    es_uri = (es_host + ':' + es_port).replace('http://', '')
    request_host = 'http://' + es_uri

    completer = CustomCompleter(support_commands)
    readline.set_completer(completer.complete)
    readline.parse_and_bind('tab: complete')

    check_connection()
    input_text = es_uri + '> '
    while True:
        try:
            user_input = input(input_text).lstrip().rstrip()
            readline.add_history(user_input)

            command_split_list = user_input.split(' ')
            command_master = command_split_list[0]

            if command_master == 'exit':
                sys.exit(1)
            elif command_master == 'help':
                help_input()
            elif command_master == 'get':
                command_get(command_split_list)
            elif command_master == 'del':
                command_del(command_split_list)
            elif command_master == 'delete_by_query':
                command_delete_by_query(command_split_list)
            elif command_master == 'cat':
                command_cat(command_split_list)
            elif command_master == 'info':
                command_info()
            elif command_master == 'match_all':
                command_match_all(command_split_list)
            elif command_master == 'match':
                command_match(command_split_list)
            elif command_master == 'analyze':
                command_analyze(command_split_list)
            elif command_master == 'settings':
                command_settings(command_split_list)
            elif command_master.replace(' ', '') == '':
                continue
            else:
                print("(error) ERR unknown command '" + user_input + "'")

        except KeyboardInterrupt:
            print('thank you!')
            sys.exit(0)
Exemple #10
0
 def run(self):
     try:
         import readline
     except ImportError:
         return
     hist = builtins.__xonsh_history__
     while self.wait_for_gc and hist.gc.is_alive():
         time.sleep(0.011)  # gc sleeps for 0.01 secs, sleep a beat longer
     files = hist.gc.files()
     i = 1
     for _, _, f in files:
         try:
             lj = LazyJSON(f, reopen=False)
             for command in lj['cmds']:
                 inp = command['inp'].splitlines()
                 for line in inp:
                     if line == 'EOF':
                         continue
                     readline.add_history(line)
                     if RL_LIB is not None:
                         RL_LIB.history_set_pos(i)
                     i += 1
             lj.close()
         except (IOError, OSError, ValueError):
             continue
Exemple #11
0
    def eventFilter(self, source, event):

        # Console Input
        if source is self.ui.console_input:
            if event.type() == QEvent.KeyPress:
                if event.key() in (Qt.Key_Enter, Qt.Key_Return):
                    command = self.ui.console_input.text()
                    if command != "":
                        readline.add_history(command)
                    self.length = readline.get_current_history_length()
                    self.index = -1

                if event.key() == Qt.Key_Up:
                    if self.index < self.length:
                        self.index += 1
                        command = readline.get_history_item(self.length -
                                                            self.index)
                        self.ui.console_input.setText(command)

                if event.key() == Qt.Key_Down:
                    if self.index > 0:
                        self.index -= 1
                        command = readline.get_history_item(self.length -
                                                            self.index)

                        self.ui.console_input.setText(command)

            return False
        return False
Exemple #12
0
    def _run(self):
        try:
            while self.running():
                with self._lock:
                    if self._code:
                        codeColor = Fore.RED
                    else:
                        codeColor = Fore.GREEN

                    cliJoined = ' '.join(self._cli)
                    codePart = '{}{}{}'.format(
                        codeColor, self._code, Style.RESET_ALL)
                    cliPart = '{}{}{}'.format(
                        Fore.LIGHTCYAN_EX, cliJoined, Style.RESET_ALL)

                    line = input('[{}] ({}) > '.format(codePart, cliPart))
                    if readline.get_history_length() == 0:
                        readline.add_history(line)
                    elif line != readline.get_history_item(readline.get_current_history_length()):
                        readline.add_history(line)

                    self._execute(shlex.split(line))
        except EOFError:
            self.stop()
            try:
                readline.write_history_file(self._historyFile)
            except:
                print()
                print('Could not save history file: {}'.format(
                    self._historyFile))
Exemple #13
0
    def _run(self):
        """Go through all commands on a pseudo-shell, and execute them,
        caching the passphrase at some point."""

        print "Welcome to SFLvault. Type 'help' for help."
        prompt = "SFLvault> "

        while True:
            cmd = raw_input(prompt)
            if not cmd:
                continue

            # Get sys.argv-like parameters
            args = shlex.split(cmd)

            # Local (shell) cmds take precedence over SFLvaultCommand cmds.
            if len(args) and hasattr(self, args[0]):
                getattr(self, args[0])()
            else:
                parser = NoExitParser(usage=optparse.SUPPRESS_USAGE)
                runcmd = SFLvaultCommand(self.config, self.vault, parser)
                try:
                    runcmd._run(args)
                except ExitParserException, e:
                    pass

                if hasattr(runcmd, 'next_command') \
                          and platform.system() != 'Windows':
                    print "[Added to shell history: %s]" % runcmd.next_command
                    readline.add_history(runcmd.next_command)
Exemple #14
0
    def append(self, event):
        '''
        Append a new history event.

        :param str event: event to append
        '''
        readline.add_history(event)
 def executeOneCmd(self):
     line = ''
     if len(self.doLines) > 0:
         if self.doPtr == len(self.doLines):
             self.doLines = []
             self.doPtr = 0
             line = (input(self.getPromptStr()))
         else:
             line = self.doLines[self.doPtr]
             readline.add_history(line)
             self.doPtr += 1
             self.printPrompt()
             print(line)
     else:
         line = (input(self.getPromptStr()))
     gSet.myUsg.start()
     cmd = self.RegCmd(line.split()[0])
     if cmd != None:
         if cmd.isQuitCmd():
             return cmd.execute(line)
         cmd.execute(line)
     else:
         print("Unknown command \"" + line.split()[0] + "\"\n")
     gSet.myUsg.end()
     return True
Exemple #16
0
 def input(self, prompt, continuation_prompt):
     """Get input from the user, similar to the Python input() function. The prompt is printed
     before the first line of input. If the input line ends with the continuation string,
     then additional lines are requested, using the continuation prompt."""
     lines = []
     while True:
         line = input(prompt if len(lines) == 0 else continuation_prompt)
         # The len(lines) > 0 check is needed to fix bug 41.
         if len(line) > 0 or len(lines) > 0:
             history_length = readline.get_current_history_length()
             if history_length > 0:
                 readline.remove_history_item(history_length - 1)
             # If line was recalled from history, then convert to its original multiline form.
             from_history = self._multiline(line)
             if from_history is None:
                 # Wasn't from history
                 lines.append(line)
             else:
                 lines = from_history
                 line = lines[-1]
             if not line.endswith(self.continuation):
                 break
     # Store history as a single line with continuations and line breaks.
     readline.add_history('\n'.join(lines))
     # Return a single string without continuations and line breaks.
     lines[-1] += self.continuation
     return ''.join([line[:-len(self.continuation)] for line in lines])
Exemple #17
0
    def _run(self):
        """Go through all commands on a pseudo-shell, and execute them,
        caching the passphrase at some point."""
        
        print "Welcome to SFLvault. Type 'help' for help."
        prompt = "SFLvault> "
        
        while True:
            cmd = raw_input(prompt)
            if not cmd:
                continue
            
            # Get sys.argv-like parameters
            args = shlex.split(cmd)

            # Local (shell) cmds take precedence over SFLvaultCommand cmds.
            if len(args) and hasattr(self, args[0]):
                getattr(self, args[0])()
            else:
                parser = NoExitParser(usage=optparse.SUPPRESS_USAGE)
                runcmd = SFLvaultCommand(self.config, self.vault, parser)
                try:
                    runcmd._run(args)
                except ExitParserException, e:
                    pass
                
                if hasattr(runcmd, 'next_command') \
                          and platform.system() != 'Windows':
                    print "[Added to shell history: %s]" % runcmd.next_command
                    readline.add_history(runcmd.next_command)
Exemple #18
0
    def input_callback(self, prompt, completions=True):
        # Setup subedit
        self.curs_set(1)

        self.callbacks["set_var"]("input_do_completions", completions)
        self.callbacks["set_var"]("input_prompt", prompt)

        self.input_box.reset()
        self.input_box.refresh()
        curses.doupdate()

        self.pseudo_input_box.keypad(0)

        r = raw_readline()
        if not r:
            r = ""

        self.pseudo_input_box.keypad(1)

        # Only add history for commands, not other prompts
        if completions:
            readline.add_history(r)

        self.callbacks["set_var"]("input_prompt", "")
        self.input_box.reset()
        self.input_box.refresh()
        curses.doupdate()

        self.curs_set(0)
        return r
Exemple #19
0
    def set_context(self, name):
        """Set the current history context.

        This swaps in a new history context by loading
        the history from the contexts filename.  The
        old context's history is saved first.
        """

        if name not in self.contexts:
            raise ValueError("Invalid history context: %s" % name)

        if self.current:
            if name == self.current.name:
                return
            self.save()

        self.current = self.contexts[name]

        try:
            readline.clear_history()
            if self.current.obj:
                with open(self.current.filename, 'r') as f:
                    lines = pickle.load(f)

                for line in lines:
                    readline.add_history(line)

            else:
                readline.read_history_file(self.current.filename)
        except IOError:
            pass
Exemple #20
0
        def _process_input(self):
            if sys.version_info[0] >= 3:
                input_impl = input
            else:
                input_impl = raw_input
            while True:
                self._idle.wait()
                expression = ""
                line = ""
                while len(expression) == 0 or line.endswith("\\"):
                    try:
                        if len(expression) == 0:
                            line = input_impl(">>> ")
                        else:
                            line = input_impl("... ")
                    except EOFError:
                        return
                    if len(line.strip()) > 0:
                        if len(expression) > 0:
                            expression += "\n"
                        expression += line.rstrip("\\")

                if HAVE_READLINE:
                    readline.add_history(expression)
                self._idle.clear()
                self._reactor.schedule(lambda: self._send_expression(expression))
Exemple #21
0
    def append(self, event):
        '''
        Append a new history event.

        :param str event: event to append
        '''
        readline.add_history(event)
Exemple #22
0
 def run(self):
     try:
         import readline
     except ImportError:
         return
     hist = builtins.__xonsh_history__
     while self.wait_for_gc and hist.gc.is_alive():
         time.sleep(0.011)  # gc sleeps for 0.01 secs, sleep a beat longer
     files = hist.gc.files()
     i = 1
     for _, _, f in files:
         try:
             lj = LazyJSON(f, reopen=False)
             for command in lj['cmds']:
                 inp = command['inp'].splitlines()
                 for line in inp:
                     if line == 'EOF':
                         continue
                     readline.add_history(line)
                     if RL_LIB is not None:
                         RL_LIB.history_set_pos(i)
                     i += 1
             lj.close()
         except (IOError, OSError, ValueError):
             continue
    def wrapper(*args, **kwargs):
        try:
            import readline
            handle_readline = True
        except ImportError:
            handle_readline = False

        if handle_readline:
            # backup & reset readline completer
            old_readline_completer = readline.get_completer()
            readline.set_completer((lambda x: x))
            # backup & reset readline history
            old_readline_history = []
            hist_sz = readline.get_current_history_length()
            for i in range(1, hist_sz + 1):
                line = readline.get_history_item(i)
                old_readline_history.append(line)
            readline.clear_history()

        try:
            retval = function(*args, **kwargs)
        finally:

            if handle_readline:
                # restore old readline completer
                readline.set_completer(old_readline_completer)
                # restore old readline history
                readline.clear_history()
                for line in old_readline_history:
                    readline.add_history(line)

        return retval
    def input(self, prompt=None, *, history=True):
        """Read a single line

        Parameters
        ----------
        history: bool, optional
            append read line to history (only if ``stdin`` is ``None``) (defaults to ``True``)

        Returns
        -------
        str
            the read line
        """
        if prompt is None:
            prompt = self.__prompt
        if self.__stdin is not None:
            try:
                line = next(self.__stdin)
                if readline_module:
                    readline_module.add_history(line.rstrip('\n'))
                return line
            except StopIteration:
                return None
        else:
            return input_function(prompt=prompt, history=history)  # pylint: disable=bad-builtin
Exemple #25
0
    def add_item(self, line, force=False):
        # Kludge. pyreadline is a pain in the ass.
        from pyreadline import lineobj
        from pyreadline.unicode_helper import ensure_unicode

        line = ensure_unicode(line.rstrip())
        readline.add_history(lineobj.ReadLineTextBuffer(line))
Exemple #26
0
    def run(self):

        with self.connect() as client:

            commands = Commands(Actions(client))

            readline.set_completer(commands.completer())
            readline.set_completer_delims("\t")
            readline.parse_and_bind("tab: complete")

            def sigint_handler(signum, frame):
                commands.lookup("cont").sigint()

            signal.signal(signal.SIGINT, sigint_handler)

            while True:
                line = input("(dbg): ").strip()
                if line != "":
                    readline.add_history(line)
                try:
                    cmd = commands.lookup(line)
                    msg = cmd(line)

                except CommandNotFound as e:
                    if e.command != "":
                        print(e)
                except ActionError as e:
                    print("ActionError")
                    print(e.message)
                    raise e
Exemple #27
0
def show_operation_dialog():
    running = True
    output = None
    all_history = [
        readline.get_history_item(i)
        for i in range(1,
                       readline.get_current_history_length() + 1)
    ]
    readline.clear_history()
    while running:
        try:
            line = raw_input(
                'Type "yes" or "no" to confirm or decline the operation: ')
        except (KeyboardInterrupt, EOFError):
            break
        if line == 'yes':
            output = True
        elif line == 'no':
            output = False
        else:
            print 'Invalid response'
        # Remove whatever the user typed so we don't see "yes" or "no" in the history
        readline.remove_history_item(readline.get_current_history_length() - 1)
        if output is not None:
            break
    for item in all_history:
        readline.add_history(item)
    return output or False
Exemple #28
0
    def init(cls):
        """Initialize a nice environment to run in
        """
        import os

        cls.debug = os.getenv("PYTHONRC_DEBUG")

        if os.getenv("NOPYTHONRC"):
            # Not loading the python environment
            cls.dp("Skipping loading the pythonrc environment stuff")
            return

        try:
            import readline
        except ImportError:
            print("Failed to load readline")
            readline = None
        cls.readline = readline

        if readline:
            # Set the history file
            cls.histfile = os.path.join(os.getenv("HOME", "."),
                                        ".python_history")
            cls.dp("Using history file '%s'" % cls.histfile)

            # Read the history file
            if os.path.exists(cls.histfile):
                readline.read_history_file(cls.histfile)
                cls.dp("Using existing history information")
            else:
                cls.dp("Creating new history file")

            # Set the number of history items to 3000
            readline.set_history_length(3000)
            cls.dp("History size set to 3000")

            # Put a marker for the starting time.
            readline.add_history("# starting %s" % cls.strtime())
            cls.dp("Marked start of history file")

            # Allow Tab Completion
            import rlcompleter  # This sets up python specific completion

            readline.parse_and_bind("tab: complete")
            cls.dp("Started completion")
        else:
            cls.dp("No readline available")

        # Set the prompts
        import sys

        sys.ps1 = "python%s> " % ".".join(map(str, sys.version_info[:2]))
        sys.ps2 = " " * (len(sys.ps1) - 2) + "> "
        cls.dp("Set prompts")

        # The the exit function
        import atexit

        atexit.register(cls.exit)
        cls.dp("Registered exit function")
Exemple #29
0
    def loop(self):
        """
        Starts the command loop

        loop() -> None
        """

        # Process commands
        # NOTE: doesn't work with ; inside quoted arguments
        cmds = [arg.strip() for arg in self._args.command.split(';')] if self._args.command else []

        self._entry()

        while True:
            self._preInput()

            try:
                if len(cmds):
                    res = cmds.pop(0)
                    print(">>> " + res)
                    readline.add_history(res)
                else:
                    res = input('>>> ').strip()
            except EOFError:
                print(colored("(EOF)", 'yellow'))
                break

            self.runCommandRaw(res)
            self._postInput()

        self._exit()
Exemple #30
0
    def edit_track(self, files):
        input = raw_input('[A]ccept, 1-%d to edit name, s/pattern/repl/g: ' % len(files))

        try:
            filename = files.keys()[int(input) - 1]
            old_name = files[filename]

            readline.add_history(old_name)
            new_name = raw_input('New name [%s] (press up): ' % old_name)

            files[filename] = new_name or old_name
        except (ValueError, IndexError):
            if input.upper() in ('', 'Y'):
                return True

        if input.startswith('s/'):
            elems = [re.escape(x) for x in input.split('/')]
            if len(elems) != 4:
                print "W: Malformed regular expression"
                return False

            count = 0
            for filename, name in files.iteritems():
                new_name = re.sub(elems[1], elems[2], name)
                if name != new_name:
                    files[filename] = new_name
                    count += 1
            print "I: %d track(s) changed" % count

        return False
Exemple #31
0
    def wrapper(*args, **kwargs):
        try:
            import readline
            handle_readline = True
        except ImportError:
            handle_readline = False

        if handle_readline:
            # backup & reset readline completer
            old_readline_completer = readline.get_completer()
            readline.set_completer((lambda x: x))
            # backup & reset readline history
            old_readline_history = []
            hist_sz = readline.get_current_history_length()
            for i in range(1, hist_sz + 1):
                line = readline.get_history_item(i)
                old_readline_history.append(line)
            readline.clear_history()

        try:
            retval = function(*args, **kwargs)
        finally:

            if handle_readline:
                # restore old readline completer
                readline.set_completer(old_readline_completer)
                # restore old readline history
                readline.clear_history()
                for line in old_readline_history:
                    readline.add_history(line)

        return retval
Exemple #32
0
        def _process_input(self):
            if sys.version_info[0] >= 3:
                input_impl = input
            else:
                input_impl = raw_input
            while True:
                self._idle.wait()
                expression = ""
                line = ""
                while len(expression) == 0 or line.endswith("\\"):
                    try:
                        if len(expression) == 0:
                            line = input_impl(">>> ")
                        else:
                            line = input_impl("... ")
                    except EOFError:
                        return
                    if len(line.strip()) > 0:
                        if len(expression) > 0:
                            expression += "\n"
                        expression += line.rstrip("\\")

                if HAVE_READLINE:
                    readline.add_history(expression)
                self._idle.clear()
                self._reactor.schedule(
                    lambda: self._send_expression(expression))
Exemple #33
0
    def _read_file(self, fname):
        """
        Generator to read ScriptLine objects from the file named
        `fname`.
        """

        lno = 0
        # Ignore leading blank lines that would be treated as pauses
        inhibit_pause = True
        with open(fname, 'r') as f:
            for line in f:
                # Track the line number
                lno += 1

                # Parse the line
                sc_line = ScriptLine(fname, lno, line)

                # Process pauses
                if sc_line.type == 'pause':
                    if inhibit_pause:
                        # Apply pause inhibition
                        continue

                    # Inhibit future pausing
                    inhibit_pause = True
                else:
                    # Not inhibiting any more pauses
                    inhibit_pause = False

                # Add the line to the history
                readline.add_history(sc_line.raw)

                # Yield the line
                yield sc_line
Exemple #34
0
    def edit_track(self, files):
        input = raw_input(
            '[A]ccept, 1-%d to edit name, s/pattern/repl/g: ' % len(files)
        )

        try:
            filename = files.keys()[int(input) - 1]
            old_name = files[filename]

            readline.add_history(old_name)
            new_name = raw_input('New name [%s] (press up): ' % old_name)

            files[filename] = new_name or old_name
        except (ValueError, IndexError):
            if input.upper() in ('', 'Y'):
                return True

        if input.startswith('s/'):
            elems = [re.escape(x) for x in input.split('/')]
            if len(elems) != 4:
                print "W: Malformed regular expression"
                return False

            count = 0
            for filename, name in files.iteritems():
                new_name = re.sub(elems[1], elems[2], name)
                if name != new_name:
                    files[filename] = new_name
                    count += 1
            print "I: %d track(s) changed" % count

        return False
Exemple #35
0
 def _add_line_to_history(self, line):
     """Adds the given line to readline history, only if the line
     is non-empty. If the line starts with a prompt symbol, the
     prompt is stripped from the line.
     """
     if line and HAS_READLINE:
         readline.add_history(line)
Exemple #36
0
def exec_cmd(cmdline):
    """Interpret a command."""
    cmd, arg = _parse_cmdline(cmdline)
    if not cmd:
        print("Bad command.")
    else:
        cmd_callable = get_cmd(cmd)
        if not cmd:
            print("Type a command. Try 'help'.")
        elif cmd_callable:
            try:
                cmd_callable(arg)
            except ImproperArgError as e:
                print(str(e))
            except UsageError as e:
                print("usage: " + cmd + " " + str(e))
            except MissingDeckError:
                print("No active deck. Create a new deck with the 'deck' " "command.")
            except cards.ScrapeError as e:
                print("Scrape failed: " + str(e))
            if "readline" in sys.modules:
                readline.add_history(cmdline)
        else:
            print("%s is not a command. Try 'help'." % str(cmd))
    return True
Exemple #37
0
    def append(self, event):
        """
        Append a new history event.

        :param str event: event to append
        """
        readline.add_history(event)
Exemple #38
0
    def _process_edit_cmd(self):
        # - setup the edit buffer
        fd, filename = mkstemp('.py')

        # - make a list of all lines in session history, commenting any
        #   non-blank lines.
        lines = []
        for line in self.session_history:
            line = line.strip('\n')
            if line:
                lines.append('# {}'.format(line))
            else:
                lines.append(line)

        # - join list into a single string delimited by \n and write to a
        #   temporary file.
        lines = '\n'.join(lines)
        os.write(fd, lines.encode('utf-8'))
        os.close(fd)

        # - shell out to the editor
        os.system('{} {}'.format(EDITOR, filename))

        # - process commands
        lines = open(filename)
        os.unlink(filename)
        for stmt in lines:
            self.write(cyan("... {}".format(stmt)))
            line = stmt.strip('\n')
            if not line.strip().startswith('#'):
                self.push(line)
                readline.add_history(line)
        return ''
Exemple #39
0
    def set_context(self, name):
        """Set the current history context.

        This swaps in a new history context by loading
        the history from the contexts filename.  The
        old context's history is saved first.
        """

        if name not in self.contexts:
            raise ValueError("Invalid history context: %s" % name)

        if self.current:
            if name == self.current.name:
                return
            self.save()

        self.current = self.contexts[name]

        try:
            readline.clear_history()
            if self.current.obj:
                with open(self.current.filename, "r") as f:
                    lines = pickle.load(f)

                for line in lines:
                    readline.add_history(line)

            else:
                readline.read_history_file(self.current.filename)
        except IOError:
            pass
def exec_cmd(cmdline):
    """Interpret a command."""
    cmd, arg = _parse_cmdline(cmdline)
    if not cmd:
        print('Bad command.')
    else:
        cmd_callable = get_cmd(cmd)
        if not cmd:
            print('Type a command. Try \'help\'.')
        elif cmd_callable:
            try:
                cmd_callable(arg)
            except ImproperArgError as e:
                print(str(e))
            except UsageError as e:
                print('usage: ' + cmd + ' ' + str(e))
            except MissingDeckError:
                print('No active deck. Create a new deck with the \'deck\' '
                      'command.')
            except cards.ScrapeError as e:
                print('Scrape failed: ' + str(e))
            if 'readline' in sys.modules:
                readline.add_history(cmdline)
        else:
            print('%s is not a command. Try \'help\'.' % str(cmd))
    return True
Exemple #41
0
def user_interface():
	global block, terminate, forever_back, wait_start
	spaces = '                                        '
	cmds = database.cmds_get()
	for cmd in cmds:
		readline.add_history(cmd['command'])
	while not terminate:
		try:
			line = raw_input(prompt())
			block = True
			try:
				done = process_line(line)
				while not done:
					done = process_line(line)
			except KeyboardInterrupt:
				wait_start = None
				print 'Command cancelled:',line
			block = False
			sys.stdout.write(forever_back+spaces+forever_back)
			sys.stdout.flush()
		except EOFError:
			print '\nPrune exiting for Ctl-d...'
			sys.exit(0)
		except KeyboardInterrupt:
			print '\nPrune exiting for Ctl-c...'
			return
		except Exception:
			print traceback.format_exc()
Exemple #42
0
def remove_history_item(line_number, initial_history_length=None):
    """
    Function to remove an item from the readline history 
    since readline.remove_history_item() is not working

    Args:
        line_number (int): History line that will removed
        initial_history_length (int): The history length recorded at the start of the Pybash session,
            used for history management.  If the removed line was prior to the initial history length, 
            then this needs to be adjusted.
    Returns:
        int: If initial_history_length was provided, the adjusted initial history length is returned
            If not, then None is returned
    """

    # Get all history items except for the one at line_number
    hist_len = readline.get_current_history_length()
    new_history = [
        readline.get_history_item(i) for i in range(1, hist_len)
        if not i == line_number
    ]

    # Replace history
    readline.clear_history()
    for l in new_history:
        readline.add_history(l)

    # If initial_history_length was specified, check to see if it needs to be adjusted
    if initial_history_length:
        if line_number < initial_history_length:
            return initial_history_length - 1
        else:
            return initial_history_length
    else:
        return
Exemple #43
0
    def multiline(self, firstline=''):
        full_input = []
        # keep a list of the entries that we've made in history
        old_hist = []
        if firstline:
            print '  ' + firstline
            full_input.append(firstline)
        while True:
            if hasReadline:
                # add the current readline position
                old_hist.append(readline.get_current_history_length())
            if self.use_rawinput:
                try:
                    line = raw_input(self.multiline_prompt)
                except EOFError:
                    line = 'EOF'
            else:
                self.stdout.write(self.multiline_prompt)
                self.stdout.flush()
                line = self.stdin.readline()
                if not len(line):
                    line = 'EOF'
                else:
                    line = line[:-1] # chop \n
            if line == 'EOF':
                break
            full_input.append(line)

        # add the final readline history position
        if hasReadline:
            old_hist.append(readline.get_current_history_length())

        cmd = '\n'.join(full_input) + '\n'

        if hasReadline:
            # remove the old, individual readline history entries.

            # first remove any duplicate entries
            old_hist = sorted(set(old_hist))

            # Make sure you do this in reversed order so you move from
            # the end of the history up.
            for pos in reversed(old_hist):
                # get_current_history_length returns pos + 1
                readline.remove_history_item(pos - 1)
            # now add the full line
            readline.add_history(cmd)

        locals = self.curframe.f_locals
        globals = self.curframe.f_globals
        print
        self.save_history()
        try:
            try:
                code = compile(cmd, '<stdin>', 'single')
                exec code in globals, locals
            except:
                print self._reprExc()
        finally:
            self.read_history()
Exemple #44
0
    def getInput(self):
        out = None
        if self._default == None:
            self._default = datetime.datetime.now(dateutil.tz.tzlocal())
        readline.clear_history()

        # put the default value into history
        readline.add_history(self._formatDate(self._default))

        # try to complete during typing.
        readline.set_completer_delims('\n;')
        readline.parse_and_bind("tab: complete")
        readline.set_completer(self.comp)

        # get user input until it's acceptable
        while out == None:
            inp = input(self._display + " [{}]: "
                        .format(self._formatDate(self._default)))
            if inp == "?":
                self.printSpec()
            else:
                try:
                    out = self.tryParse(inp.strip(), self._default)
                except Exception as e:
                    # although the value is not acceptable, give user
                    # a chance to modify it.
                    hist = inp.strip()
                    if len(hist) > 0:
                        readline.add_history(inp.strip())
                    self.printSpec()

        readline.clear_history()
        readline.set_completer()
        # print(">> {}: {}".format(self._display, out.strftime("%Y/%m/%d %H:%M")))
        return out
    def cmdloop(self, opts):
        """ Interactive mode worker function

        :param opts: command options
        :type opts: options.
        """
        self.interactive = True

        if not opts.nologo:
            CLI.version(self._progname, versioning.__version__,\
                                versioning.__extracontent__, fileh=sys.stdout)

        if opts.debug:
            LOGGER.setLevel(logging.DEBUG)
            LERR.setLevel(logging.DEBUG)

        #**********Handler for GUI tab tab ***************
        for section in self._commands:
            if section.startswith('_'):
                continue

            for command in self._commands[section]:
                self.commlist.append(command.name)

        for item in self.commlist:
            if item == "help":
                self.candidates[item] = self.commlist
            else:
                self.candidates[item] = []

        self._redobj = TabAndHistoryCompletionClass(dict(self.candidates))
        readline.set_completer(self._redobj.main_completer_handler)
        readline.parse_and_bind("tab: complete")
        #***************************************************

        while True:
            line = input(versioning.__shortname__ + ' > ')
            readline.add_history(line)

            if not len(line):
                continue
            elif line.endswith(os.linesep):
                line.rstrip(os.linesep)

            nargv = shlex.split(line, posix=False)

            try:
                if "login " in line or line == 'login':
                    self.app.logout()

                self.retcode = self._run_command(opts, nargv)
                self.check_for_tab_lists(nargv)
            except Exception as excp:
                self.handle_exceptions(excp)

            if self.opts.verbose:
                sys.stdout.write(u"REDFISH return code: %s\n" % self.retcode)

        return self.retcode
Exemple #46
0
    def edit(self, i):
        '''Edit unit i.'''
        suspects = self.job.units[i]['suspects']    # suspect substrings
        value = self.job.units[i]['value']          # unit value
        newval = ''
        status = None

        for suspect in suspects:
            print self.OUT_PROMPT, self.highlight(suspect, value)
            new = raw_input(self.IN_PROMPT)
            if new:
                newval = value.replace(suspect, new)
                print self.OUT_PROMPT, self.highlight(new, newval, 'GREEN')
                print
                status = 'edit'
            else:
                while True:
                    input = raw_input(self.CMD_PROMPT)
                    if input in ("?", "h", "help"):
                        print self.EDIT_OPTS,
                        input = raw_input(self.CMD_PROMPT)
                    if not input:
                        return None                             # do nothing
                    elif input == 'q':
                        return 'quit'
                    elif input == 'r':
                        _i, _value = self._previous           
                        if not _value:
                            self.helper("no previous value stored!")
                            continue
                        self.job.units[_i]['value'] = _value    # restore prev
                        self.edit(_i)                       # redo edit
                        return 'redo'
                    elif input.startswith('o'):             # omit unit
                        if '-t' in input:
                            self.do_tag(str(i) + input.replace("o", "", 1))
                        print
                        return 'omit'
                    elif input == 'c':
                        self.do_context(i)
                        status = None
                    elif input.startswith('t'):
                        self.do_tag("{0} -{1}".format(i, input))
                        status = None
                    elif input == 'e':
                        self.helper("use up arrow to get existing line", 4)
                        readline.add_history(value)
                        newval = raw_input(self.IN_PROMPT)
                        if newval:
                            print self.OUT_PROMPT, newval
                            print
                            status = 'edit'
                            break

        if status == 'edit':
            self._previous = (i, value)         # store prev index, value
            self.job.units[i]['value'] = newval
            # self.job.set_value(i, newval)
        return status
Exemple #47
0
    def handle_cmd (self):

        cmd = self.lines[self.line_index].get().strip()
        if not cmd:
            return

        op, param = self.split_cmd(cmd)
        
        func = self.ac.get(op)
        if func:
            with self.async_.tui_global_lock:
                func_rc = func(param)

        # take out the empty line
        empty_line = self.lines.popleft()
        assert(empty_line.ro_line == '')

        if not self.lines or self.lines[0].ro_line != cmd:
            self.lines.appendleft(CmdLine(cmd))
        
        # back in
        self.lines.appendleft(empty_line)
        self.line_index = 0
        readline.add_history(cmd)
        self.save_console_history()

        # back to readonly
        for line in self.lines:
            line.invalidate()

        assert(self.lines[0].modified == False)
        color = None
        if not func:
            self.last_status = "unknown command: '{0}'".format(format_text(cmd.split()[0], 'bold'))
        else:
            # internal commands
            if isinstance(func_rc, str):
                self.last_status = func_rc

            # RC response
            else:
                # success
                if func_rc is None:
                    self.last_status = format_text("[OK]", 'green')
                # errors
                else:
                    err_msgs = ascii_split(str(func_rc))
                    if not err_msgs:
                        err_msgs = ['Unknown error']
                    self.last_status = format_text(clear_formatting(err_msgs[0]), 'red')
                    if len(err_msgs) > 1:
                        self.last_status += " [{0} more errors messages]".format(len(err_msgs) - 1)
                    color = 'red'


        # trim too long lines
        if ansi_len(self.last_status) > TrexTUI.MIN_COLS:
            self.last_status = format_text(self.last_status[:TrexTUI.MIN_COLS] + "...", color, 'bold')
Exemple #48
0
  def terminal(self, url, pwd):
    
    hostname=urlparse.urlparse(url)[1]
    
    while True:
		cmnd = raw_input( hostname + '> ' )
		if cmnd!='\n':
			readline.add_history(cmnd)
			print self.host.execute(cmnd)
def main(argv):
    parser = optparse.OptionParser()
    parser.add_option('-s', '--server',
                      dest='server',
                      help='The hostname your app is deployed on. '
                      'Defaults to <app_id>.appspot.com.')
    parser.add_option('--secure',
                      dest='secure',
                      action="store_true",
                      default=False,
                      help='Use HTTPS when communicating '
                      'with the server.')
    (options, args) = parser.parse_args() 

    if not args or len(args) > 3:
        print >> sys.stderr, __doc__
        if len(args) > 3:
            print >> sys.stderr, 'Unexpected arguments: %s' % args[2:]
        sys.exit(1)

    appid = args[1]
    if len(args) == 3:
        path = args[2]
    else:
        path = DEFAULT_PATH

    remote_api_stub.ConfigureRemoteApi(appid, path, __auth_func,
                                       servername=options.server,
                                       save_cookies=True, secure=options.secure)
    remote_api_stub.MaybeInvokeAuthentication()

    servername = options.server
    if not servername:
        servername = '%s.appspot.com' % (appid,)
    rpc_server = appengine_rpc.HttpRpcServer(servername,
                                             __cached_auth_func,
                                             remote_api_stub.GetUserAgent() + ' remote_driver_shell/1.0',
                                             remote_api_stub.GetSourceName(),
                                             save_cookies=True,
                                             debug_data=False,
                                             secure=options.secure)
    global __remote_driver_server
    __remote_driver_server = rpc_server

    os.environ['SERVER_SOFTWARE'] = 'Development (remote_driver_shell/1.0)'

    sys.ps1 = '%s/driver> ' % appid
    if readline:
        readline.parse_and_bind('tab: complete')
        atexit.register(lambda: readline.write_history_file(HISTORY_PATH))
        if os.path.exists(HISTORY_PATH):
            readline.read_history_file(HISTORY_PATH)
            readline.add_history('')
            global __readline_history_session_start
            __readline_history_session_start = readline.get_current_history_length()

    code.interact(banner=BANNER, readfunc=__magic_input, local=globals())
    def terminal(self, url, pwd):

        hostname = urlparse.urlparse(url)[1]

        while True:
            cmnd = raw_input(hostname + '> ')
            if cmnd != '\n':
                readline.add_history(cmnd)
                print self.host.execute(cmnd)
Exemple #51
0
 def input(self, add_to_history: str = '', prompt: str = '> ') -> str:
     import readline
     print(end=set_cursor_shape('bar'))
     if add_to_history:
         readline.add_history(add_to_history)
     try:
         return input(prompt)
     finally:
         print(end=set_cursor_shape())
Exemple #52
0
def last_history(line):
	if line == "":
		return False
	if (readline.get_current_history_length() == 0
			or readline.get_history_item(
				readline.get_current_history_length()) != line.encode("utf-8")):
		readline.add_history(line.encode("utf-8"))
		return True
	return False
Exemple #53
0
 def execute(self, pos, end=None):
     """execute history number from pos to end"""
     if not end:
         end = pos
     commands = []
     for item in self.iterator(pos, end):
         commands.append(item)
         readline.add_history(item)
     exec_stub("\n".join(commands), globals())
 def add_history(self, line):
     # Emulate HISTCONTROL=ignorespace to avoid adding to history.
     if line.startswith(' '):
         return
     # Emulate HISTCONTROL=ignoredups to avoid duplicate history entries.
     nitems = readline.get_current_history_length()
     lastline = readline.get_history_item(nitems)
     if lastline != line:
         readline.add_history(line)
Exemple #55
0
def get_sentence(text):
    if text is not None:
        print("Previous sentences:\n", text)
    sentence = input("Enter a sentence: ")

    if READLINE_IMPORTED:
        readline.add_history(sentence)

    return sentence
Exemple #56
0
def interact(banner="", local=None, stackLevel=1, frame=None,
             mode='interact', history=False):
    """Interact using the current global and local scope and history.

    arguments:
    banner -- print this text before interacting.
    local -- ignored
    history: bool or int
        if non-false, this many lines of history are found from the
        file being interacted with and inserted into the readline
        buffer


    """
    if len(banner) > 0:
        print banner
    # Get data from calling frame
    #calling_data = inspect.stack()[stackLevel]
    #filename = calling_data[1]
    #lineno   = calling_data[2]
    #frame = calling_data[0]
    #local = frame.f_locals
    #global_ = frame.f_globals

    if frame is None:
        frame = inspect.stack()[stackLevel][0]
    filename = frame.f_code.co_filename
    lineno = frame.f_lineno
    local = frame.f_locals
    global_ = frame.f_globals


    if history:
        new_history = [ ]
        if os.access(filename, os.R_OK):
            new_history.extend(get_history(filename, lineno))
        # add lines to history, removing proper amount of whitespace
        for line in new_history:
            readline.add_history(line)

    # add an exit() function under the name __exit.  Hopefully this
    # won't cause namespace collisions!
    local["__exit"] = sys.exit
    if mode == 'pdb':
        import pdb
        p = pdb.Pdb()
        def do_quit(self, arg):
            sys.exit()
        p.do_quit = type(p.do_quit)(do_quit, p, pdb.Pdb)
        p.do_q = p.do_quit
        p.reset()
        p.interaction(frame, None)
        #from fitz import interactnow
        #pdb.post_mortem(frame)
    else:
        interact2(local=local, global_=global_, banner="")
Exemple #57
0
 def load_history(self):
     """Load saved command history from local history file"""
     try:
         with file(self.history_file_name, 'r') as f:
             for line in f.readlines():
                 stripped_line = line.strip()
                 self.history.append(stripped_line)
                 readline.add_history(stripped_line)
     except IOError:
         pass  # ignore if file cannot be read
Exemple #58
0
    def update(self, inc):
        """Update comment, handle commands. Return position increment."""

        rv = 0  # position increment default is do same again
        if not os.path.exists(self.name):
            self.selected = False
        if not self.selected:
            return inc
        if self.comment:
            print self
            readline.add_history(self.comment)
        try:
            comment = raw_input('%s: ' % self.repname)
        except (KeyboardInterrupt, EOFError):
            print   # newline
            return 2  # return quit signal
        if len(comment) == 0:  # pass to next
            rv = 1  # next
        elif len(comment) > 1:  # save as comment
            readline.add_history(comment)
            self.comment = comment
            rv = 1  # next
        elif comment == 'b':  # go back one
            rv = -1  # previous
        elif comment == 'd':  # get data
            print self.hist() ,
            print ' '.join(cmd_output("ls -dl '%s'" % self.name).split()[:8]) ,
            nlines = cmd_output("wc -l '%s'" % self.name)[1:].split() or ['?']
            print '%s lines' % nlines[0]
            print ' '.join(cmd_output(
                "file '%s'" % self.name).split(':')[1:]).strip()
            print cmd_output("od  -cN64 -An '%s'" % self.name)
            line_width = FileComment.cols - 5
            tc = "cat -t '%s' | cut -c1-%d | head -6" % (self.name, line_width)
            if os.path.isdir(self.name): tc = "ls -l %s | head -6" % self.name
            print cmd_output(tc)
        elif comment == 'e':  # erase existing comment
            self.comment = ''
            rv = 1  # next
        elif comment == 'l':  # use less to paginate file
            subprocess.call(['less', self.name])
        elif comment == 'm':  # use less to paginate file
            subprocess.call(['man', self.name])
        elif comment == 'q':  # quit
            rv = 2  # quit signal
        elif comment == 'r':  # delete
            cmd_output("rm -rf '%s'" % self.name)
            rv = 1  # next
        elif comment == 't':  # cat
            print open(self.name).read().rstrip()
        elif comment == 'v':  # open with vi
            subprocess.call(['vim', self.name])
        else:
            print USAGE
        return rv
    def init(cls):
        """Initialize a nice environment to run in
        """
        import os
        cls.debug = os.getenv('PYTHONRC_DEBUG')

        if os.getenv('NOPYTHONRC'):
            # Not loading the python environment
            cls.dp( "Skipping loading the pythonrc environment stuff" )
            return

        try:
            import readline
        except ImportError:
            readline = None
        cls.readline = readline

        if readline:
            # Set the history file
            cls.histfile = os.path.join( os.getenv('HOME', '.'),
                                         '.python_history' )
            cls.dp( "Using history file '%s'" % cls.histfile )

            # Read the history file
            if os.path.exists( cls.histfile ):
                readline.read_history_file(cls.histfile)
                cls.dp( "Using existing history information" )
            else:
                cls.dp( "Creating new history file" )

            # Set the number of history items to 3000
            readline.set_history_length(3000)
            cls.dp( "History size set to 3000" )

            # Put a marker for the starting time.
            readline.add_history("# starting %s" % cls.strtime() )
            cls.dp( "Marked start of history file" )

            # Allow Tab Completion
            import rlcompleter # This sets up python specific completion
            readline.parse_and_bind("tab: complete")
            cls.dp( "Started completion" )
        else:
            cls.dp( "No readline available" )

        # Set the prompts
        import sys
        sys.ps1 = "python%s> " % ".".join( map( str, sys.version_info[:2] ) )
        sys.ps2 = " " * ( len( sys.ps1 ) - 2 ) + "> "
        cls.dp( "Set prompts" )

        # The the exit function
        import atexit
        atexit.register(cls.exit)
        cls.dp( "Registered exit function" )