我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用readline.write_history_file()。
def interactive(self): utils.set_prompt(ps1="(rudra) ", ps2="... ") import os import readline import rlcompleter import atexit histfile = os.path.join(os.environ["HOME"], ".rudrahistory") if os.path.isfile(histfile): readline.read_history_file(histfile) atexit.register(readline.write_history_file, histfile) r = self print "Use the \"r\" object to analyze files" vars = globals() vars.update(locals()) readline.set_completer(rlcompleter.Completer(vars).complete) readline.parse_and_bind("tab: complete") del os, histfile, readline, rlcompleter, atexit code.interact(banner="", local=vars)
def setup(self): """ Initialization of third-party libraries Setting interpreter history. Setting appropriate completer function. :return: """ if not os.path.exists(self.history_file): open(self.history_file, 'a+').close() readline.read_history_file(self.history_file) readline.set_history_length(self.history_length) atexit.register(readline.write_history_file, self.history_file) readline.parse_and_bind('set enable-keypad on') readline.set_completer(self.complete) readline.set_completer_delims(' \t\n;') readline.parse_and_bind("tab: complete")
def input_loop(): if os.path.exists(HISTORY_FILENAME): readline.read_history_file(HISTORY_FILENAME) print('Max history file length:', readline.get_history_length()) print('Startup history:', get_history_items()) try: while True: line = input('Prompt ("stop" to quit): ') if line == 'stop': break if line: print('Adding {!r} to the history'.format(line)) finally: print('Final history:', get_history_items()) readline.write_history_file(HISTORY_FILENAME) # Register our completer function
def enable_autocomplete_and_history(adir, env): try: import rlcompleter import atexit import readline except ImportError: pass else: readline.parse_and_bind("tab: complete") history_file = os.path.join(adir, '.pythonhistory') try: readline.read_history_file(history_file) except IOError: open(history_file, 'a').close() atexit.register(readline.write_history_file, history_file) readline.set_completer(rlcompleter.Completer(env).complete)
def __exit__(self, ex_tp, ex_val, ex_tb): if not haveReadline: return False try: # update the history for this project readline.write_history_file(self.historyFile) except Exception as E: print "Failed to write history to {0} - {1}".format(self.historyFile, E) # put back the original history! readline.clear_history() readline.read_history_file(self.oldhistFile) os.unlink(self.oldhistFile) # and put back the old completer readline.set_completer(self.oldCompleter) # linegenerators, pass one of these to the "run" # method of the CommandLineInterface object #import ctypes #rllib = ctypes.cdll.LoadLibrary("libreadline.so") #rl_line_buffer = ctypes.c_char_p.in_dll(rllib, "rl_line_buffer") #rl_done = ctypes.c_int.in_dll(rllib, "rl_done")
def setup_readline_history(histfn): import readline try: readline.read_history_file(histfn) except IOError: # guess it doesn't exist pass def save(): try: readline.write_history_file(histfn) except IOError: print ("bad luck, couldn't save readline history to %s" % histfn) import atexit atexit.register(save)
def hook_readline_hist(): try: import readline except ImportError: return histfile = os.environ['HOME'] + '/.web_develop_history' # ??????????????? readline.parse_and_bind('tab: complete') try: readline.read_history_file(histfile) except IOError: pass # It doesn't exist yet. def savehist(): try: readline.write_history_file(histfile) except: print 'Unable to save Python command history' atexit.register(savehist)
def save_history(self): if self.history_file_full_path is not None: global readline if readline is None: try: import readline except ImportError: return try: readline.write_history_file(self.history_file_full_path) except IOError: e = sys.exc_info()[1] warnings.warn("Cannot save history file, reason: %s" % str(e)) #------------------------------------------------------------------------------ # Main loop # Debugging loop.
def pre_input(self, completefn): if self.raw_input: if HAVE_READLINE: import atexit self.old_completer = readline.get_completer() # Fix Bug #3129: Limit the history size to consume less memory readline.set_history_length(self.historysize) readline.set_completer(completefn) readline.parse_and_bind(self.completekey+": complete") try: readline.read_history_file() except IOError: pass atexit.register(readline.write_history_file) self.havecolor = True if mswindows and self.enablecolor: self.cwrite = readline.GetOutputFile().write_color else: self.cwrite = self.stdout.write
def save_history(self): if self.history_file_full_path is not None: global readline if readline is None: try: import readline except ImportError: return try: readline.write_history_file(self.history_file_full_path) except IOError, e: warnings.warn("Cannot save history file, reason: %s" % str(e)) #------------------------------------------------------------------------------ # Main loop # Debugging loop.
def init_readline(complete_method, histfile=None): """Init the readline library if available.""" try: import readline readline.parse_and_bind("tab: complete") readline.set_completer(complete_method) string = readline.get_completer_delims().replace(':', '') readline.set_completer_delims(string) if histfile is not None: try: readline.read_history_file(histfile) except IOError: pass import atexit atexit.register(readline.write_history_file, histfile) except: print('readline is not available :-(')
def cmdloop_with_history(self): """ Better command loop, with history file and tweaked readline completion delimiters. """ old_completer_delims = readline.get_completer_delims() if self.histfile is not None: try: readline.read_history_file(self.histfile) except IOError: pass try: readline.set_completer_delims("".join(set(old_completer_delims) - set(self.identchars))) self.cmdloop() finally: if self.histfile is not None and readline.get_current_history_length(): readline.write_history_file(self.histfile) readline.set_completer_delims(old_completer_delims)
def enable_autocomplete_and_history(adir,env): try: import rlcompleter import atexit import readline except ImportError: pass else: readline.parse_and_bind("bind ^I rl_complete" if sys.platform == 'darwin' else "tab: complete") history_file = os.path.join(adir,'.pythonhistory') try: readline.read_history_file(history_file) except IOError: open(history_file, 'a').close() atexit.register(readline.write_history_file, history_file) readline.set_completer(rlcompleter.Completer(env).complete)
def run(self): self.program_counter = 0 self.total_steps_executed = 0 if self.inbox is None: self.inbox = deque([]) self.original_inbox = list(self.inbox) self.outbox = [] escape = False try: while self.program_counter < len(self.program) and not escape: if self.program_counter in self.breakpoints.union(self.temporary_breakpoints): self.temporary_breakpoints = set() escape = self._menu() self.program[self.program_counter].execute(self) except InboxIsEmptyError: pass if not escape: print() print('Program ran to completion. Post-mortem:') self._menu() self.program_counter = None readline.write_history_file(self.history_file)
def _save_history(self): hist_file = self.hist_file() if hist_file: readline.write_history_file(os.path.expanduser(hist_file))
def scapy_write_history_file(readline): if conf.histfile: try: readline.write_history_file(conf.histfile) except IOError,e: try: warning("Could not write history to [%s]\n\t (%s)" % (conf.histfile,e)) tmp = utils.get_temp_file(keep=True) readline.write_history_file(tmp) warning("Wrote history to [%s]" % tmp) except: warning("Cound not write history to [%s]. Discarded" % tmp)
def postcmd(self, stop, line): readline.write_history_file('.pupy_history')
def init_readline(self): """Activates history and tab completion """ # - mainly borrowed from site.enablerlcompleter() from py3.4+ # Reading the initialization (config) file may not be enough to set a # completion key, so we set one first and then read the file. readline_doc = getattr(readline, '__doc__', '') if readline_doc is not None and 'libedit' in readline_doc: readline.parse_and_bind('bind ^I rl_complete') else: readline.parse_and_bind('tab: complete') try: readline.read_init_file() except OSError: # An OSError here could have many causes, but the most likely one # is that there's no .inputrc file (or .editrc file in the case of # Mac OS X + libedit) in the expected location. In that case, we # want to ignore the exception. pass if readline.get_current_history_length() == 0: # If no history was loaded, default to .python_history. # The guard is necessary to avoid doubling history size at # each interpreter exit when readline was already configured # see: http://bugs.python.org/issue5845#msg198636 try: readline.read_history_file(config['HISTFILE']) except IOError: pass atexit.register(readline.write_history_file, config['HISTFILE']) readline.set_history_length(config['HISTSIZE']) # - replace default completer readline.set_completer(self.improved_rlcompleter()) # - enable auto-indenting readline.set_pre_input_hook(self.auto_indent_hook)
def stop_running(self): readline.write_history_file(self.HISTORY_PATH)
def scapy_write_history_file(readline): if conf.histfile: try: readline.write_history_file(conf.histfile) except IOError as e: try: warning("Could not write history to [%s]\n\t (%s)" % (conf.histfile,e)) tmp = utils.get_temp_file(keep=True) readline.write_history_file(tmp) warning("Wrote history to [%s]" % tmp) except: warning("Cound not write history to [%s]. Discarded" % tmp)
def init_history(self): try: readline.read_history_file(self.hist_file) readline.set_history_length(HISTORY_FILE_SIZE) readline.write_history_file(self.hist_file) except IOError: readline.write_history_file(self.hist_file) atexit.register(self.save_history)
def save_history(self): try: readline.write_history_file(self.hist_file) except IOError: pass
def save_history(self, histfile): readline.set_history_length(1000) readline.write_history_file(histfile)
def __enter__(self): # we only do something if we have readline if not haveReadline: return self ## Set up the new history context self.historyFile = os.path.join( os.getenv('HOME'), ".{0}.history".format(self.basename)) (h, self.oldhistFile) = tempfile.mkstemp(prefix=self.basename, suffix=".hist", dir="/tmp") # only need the filename, really os.close(h) readline.write_history_file(self.oldhistFile) readline.clear_history() # if reading the old history fails, fail silently # (the file might not exist yet) try: readline.read_history_file(self.historyFile) except: pass # store the old completer, install our own one readline.parse_and_bind("tab: complete") #readline.parse_and_bind("C-c: backward-kill-line") self.oldCompleter = readline.get_completer() readline.set_completer(self.completer) return self # clean up the context
def _load_history(self): """Load history file and register dump on exit.""" # Create a file without truncating it in case it exists. open(config.history_path, 'a').close() readline.set_history_length(100) try: readline.read_history_file(config.history_path) except IOError: pass atexit.register(readline.write_history_file, config.history_path)
def init_python_session(): """Construct new Python session. """ from code import InteractiveConsole class SymPyConsole(InteractiveConsole): """An interactive console with readline support. """ def __init__(self): InteractiveConsole.__init__(self) try: import readline except ImportError: pass else: import os import atexit readline.parse_and_bind('tab: complete') if hasattr(readline, 'read_history_file'): history = os.path.expanduser('~/.sympy-history') try: readline.read_history_file(history) except IOError: pass atexit.register(readline.write_history_file, history) return SymPyConsole()
def main(): url = sys.argv[1] context['url'] = url pkg = app.dispatch_url(url) context['pkg'] = pkg for item in pkg.to_dict().items(): print '{} = {}'.format(*item) def prepare_readline(): import os import readline import atexit readline.parse_and_bind('tab: complete') histfile = os.path.expanduser("~/.daenerys_history") try: readline.read_history_file(histfile) except IOError: pass def savehist(histfile): readline.write_history_file(histfile) atexit.register(savehist, histfile) del atexit try: from IPython.terminal.interactiveshell import TerminalInteractiveShell shell = TerminalInteractiveShell(user_ns=context) shell.mainloop() except ImportError: import code shell = code.InteractiveConsole(locals=context) shell.runcode(prepare_readline.__code__) shell.interact()
def save_console_history(self): if not os.path.exists(self._history_file_dir): # make the directory available for every user try: original_umask = os.umask(0) os.makedirs(self._history_file_dir, mode = 0o777) finally: os.umask(original_umask) # os.mknod(self._history_file) readline.write_history_file(self._history_file) return
