def history(name): histfile = os.path.join(os.environ["HOME"],name) try: readline.read_history_file(histfile) atexit.register(readline.write_history_file, histfile) except IOError: pass
def reg(): histfile = os.path.join(os.environ['HOME'], '.pythonhistory') try: readline.read_history_file(histfile) except IOError: pass atexit.register(readline.write_history_file,histfile)
def main_loop(self): readline.parse_and_bind('tab: complete') readline.set_completer(self.rl_completer_safe) #print 'delims: ', repr(readline.get_completer_delims()) hist_file = os.path.expanduser("~/.qadmin_history") try: readline.read_history_file(hist_file) except IOError: pass print "Use 'show help;' to see available commands." while 1: try: ln = self.line_input() self.exec_string(ln) except KeyboardInterrupt: print except EOFError: print break self.reset_comp_cache() try: readline.write_history_file(hist_file) except IOError: pass
def setup_readline(): histfile = os.path.join(os.path.expanduser("~"), ".flux_robot_history") try: readline.read_history_file(histfile) except IOError: pass atexit.register(readline.write_history_file, histfile)
def interactive(self): try: readline.read_history_file(Debugger.HISTORY_FILE) except IOError: pass cpu = self.cpu try: while True: cmd,args = self.prompt() if cmd in 'xq': return elif cmd == 's': cpu.step() elif cmd == 'k': self.stack(args) elif cmd == 'b': self.breakpoint(args) elif cmd == 'r': self.run() elif cmd == 'ret': self.runUntilRet() elif cmd == '?': self.evalPrint(args) elif cmd == 'l': self.listSource(args) else: print 'Unknown command! (%s)' % cmd finally: readline.write_history_file(Debugger.HISTORY_FILE)
def register_readline(): import atexit try: import readline import rlcompleter except ImportError: return # Reading the initialization (config) file may not be enough to set a # completion key, so we set one first and then read the file if 'libedit' in getattr(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 history = os.path.join(os.path.expanduser('~'), '.python_history') try: readline.read_history_file(history) except IOError: pass atexit.register(readline.write_history_file, history)
def Interact(session): import readline try: readline.read_history_file(session.config.history_file()) except IOError: pass # Negative history means no saving state to disk. history_length = session.config.sys.history_length if history_length >= 0: readline.set_history_length(history_length) else: readline.set_history_length(-history_length) try: prompt = session.ui.palette.color('mailpile> ', color=session.ui.palette.BLACK, weight=session.ui.palette.BOLD) while True: session.ui.block() opt = raw_input(prompt).decode('utf-8').strip() session.ui.unblock() if opt: if ' ' in opt: opt, arg = opt.split(' ', 1) else: arg = '' try: session.ui.display_result(Action(session, opt, arg)) except UsageError, e: session.error(unicode(e)) except UrlRedirectException, e: session.error('Tried to redirect to: %s' % e.url)
def _load_history(self): try: hist_file = self.hist_file() if hist_file: readline.read_history_file(os.path.expanduser(hist_file)) except FileNotFoundError: pass
def run_classic_shell(locals, globals, first_time): if first_time: banner = "Hit Ctrl-D to return to PuDB." else: banner = "" ns = SetPropagatingDict([locals, globals], locals) from pudb.settings import get_save_config_path from os.path import join hist_file = join( get_save_config_path(), "shell-history") if HAVE_READLINE: readline.set_completer( rlcompleter.Completer(ns).complete) readline.parse_and_bind("tab: complete") try: readline.read_history_file(hist_file) except IOError: pass from code import InteractiveConsole cons = InteractiveConsole(ns) cons.interact(banner) if HAVE_READLINE: readline.write_history_file(hist_file)
def run_shell(self): do_readline = sys.stdin.isatty() and ('-', sys.stdin) in self.files if do_readline and os.path.exists(os.path.expanduser('~/.fsh_history')): readline.read_history_file(os.path.expanduser('~/.fsh_history')) for file in ('/etc/inputrc', os.path.expanduser('~/.inputrc')): if os.path.exists(file): with open(file) as fd: readline.parse_and_bind(fd.read()) while self.files: self.curfile, self.curfd, self.curline = self.files[0] self.files = self.files[1:] if self.verbose: print "%s(Now processing %s)" % (self.ps4, self.curfile) try: while True: line = self.get_input() if not line: break if self.verbose: print '%s%s (%s, line %d)' % (self.ps4, line, self.curfile, self.curline) self.parse_and_run(line) except: if do_readline: readline.write_history_file(os.path.expanduser('~/.fsh_history')) raise if do_readline: readline.write_history_file(os.path.expanduser('~/.fsh_history'))
def init_history(self): histfile=os.path.expanduser("~/.%s-history" % self.__name) try: readline.read_history_file(histfile) except IOError: pass atexit.register(self.save_history, histfile)
def main(self, argv): cmd_args = argv[1:] if cmd_args: cmd_line = u' '.join(cmd_args) cmds = cmd_line.split(';') for cmd in cmds: ret = self.onecmd(cmd) if ret: return ret elif self.DISABLE_REPL: self._parser.print_help() self._parser.exit() else: try: import readline except ImportError: pass else: # Remove '-' from delims readline.set_completer_delims(readline.get_completer_delims().replace('-', '')) history_filepath = os.path.join(self.weboob.workdir, '%s_history' % self.APPNAME) try: readline.read_history_file(history_filepath) except IOError: pass def savehist(): readline.write_history_file(history_filepath) atexit.register(savehist) self.intro += '\nLoaded backends: %s\n' % ', '.join(sorted(backend.name for backend in self.weboob.iter_backends())) self._interactive = True self.cmdloop()
def _test_main(): import os import readline import atexit # Setup history and readline facility for remote q: histfile = os.path.join(os.environ['HOME'], '.pyhistory') try: readline.read_history_file(histfile) except IOError: pass atexit.register(readline.write_history_file, histfile) conn = connect() print('"conn" is your handle to rserve. Type e.g. "conn(\'1\')" ' 'for string evaluation.') # r('x<-1:20; y<-x*2; lm(y~x)') sc = open('../testData/test-script.R').read() v = conn.r(sc) open('r-test-png.png', 'w').write(v[3]) conn.r.v = 'abc' conn.r('func0 <- function() { 3 }') conn.r('func1 <- function(a1) { a1 }') conn.r('func2 <- function(a1, a2) { list(a1, a2) }') conn.r('funcKW <- function(a1=1, a2=4) { list(a1, a2) }') conn.r('squared<-function(t) t^2')
def _init_history(self): try: readline.set_history_length(100) readline.read_history_file(self._history_file) except IOError: pass atexit.register(self._save_history)
def _init_history_file(self): if hasattr(readline, "read_history_file"): try: readline.read_history_file(self.history_file) except FileNotFoundError: pass atexit.register(self.save_history)
def interact(): import readline history_file = os.path.expanduser(HISTORY_FILE_TEMPLATE) try: readline.read_history_file(history_file) except IOError: pass atexit.register(readline.write_history_file, history_file) interp = gcode.Interpreter() while True: try: line = raw_input('> ') except (EOFError, KeyboardInterrupt): print return restart_as_needed() try: sline = gcode.SourceLine(line, source='<tty>') action = interp.interpret_line(sline) if action: print 'ACTION', action except gcode.GCodeSyntaxError: z = traceback.format_exc(0) z = z.split('\n', 3)[3] # discard first three lines z = z.replace(' ^', '^') # move caret left two columns z = z.rstrip() # discard trailing newline print >>sys.stderr, z except gcode.GCodeException: z = traceback.format_exc(0) z = z.split('\n', 1)[1] # discard first line z = z.rstrip() # discard trailing newline print >>sys.stderr, z
def main(args=None, options=None): if options is None: options = ClientOptions() options.realize(args, doc=__doc__) c = Controller(options) if options.args: c.onecmd(" ".join(options.args)) if options.interactive: try: import readline if options.history_file: try: readline.read_history_file(options.history_file) except IOError: pass def save(): try: readline.write_history_file(options.history_file) except IOError: pass import atexit atexit.register(save) except ImportError: pass try: c.cmdqueue.append('status') c.cmdloop() except KeyboardInterrupt: c.output('') pass
def init(self, **kw): if kw.has_key('stdin'): cmd.Cmd.__init__(self, None, stdin=kw['stdin']) self.use_rawinput = False else: cmd.Cmd.__init__(self) # initialize a new local namespace. namespaces.new_local_dict() # import readline history, if available. if readline: try: readline.read_history_file('.twill-history') except IOError: pass # fail on unknown commands? for test-shell, primarily. self.fail_on_unknown = kw.get('fail_on_unknown', False) # handle initial URL argument if kw.get('initial_url'): commands.go(kw['initial_url']) self._set_prompt() self.names = [] global_dict, local_dict = namespaces.get_twill_glocals() ### add all of the commands from twill. for command in parse.command_list: fn = global_dict.get(command) self.add_command(command, fn.__doc__)
def __init__(self, inp=None, out=None, opts={}): get_option = lambda key: Mmisc.option_set(opts, key, DEFAULT_USER_SETTINGS) Minput = import_relative('input', '..inout', 'trepan') Moutput = import_relative('output', '..inout', 'trepan') atexit.register(self.finalize) self.interactive = True # Or at least so we think initially self.input = inp or Minput.DebuggerUserInput() self.output = out or Moutput.DebuggerUserOutput() if self.input.use_history(): complete = get_option('complete') if complete: parse_and_bind("tab: complete") set_completer(complete) pass self.histfile = get_option('histfile') if self.histfile: try: read_history_file(histfile) except IOError: pass set_history_length(50) atexit.register(write_history_file, self.histfile) pass return
def __init__(self, db, hasxsel, callback, config_parser, **kwargs): """ initialize CLI interface, set up the DB connecion, see if we have xsel ... """ super(PwmanCli, self).__init__(**kwargs) self.intro = "%s %s (c) visit: %s" % ('pwman3', version, website) self._historyfile = config_parser.get_value("Readline", "history") self.hasxsel = hasxsel self.config = config_parser try: enc = CryptoEngine.get() enc.callback = callback() self._db = db # this cascades down all the way to setting the database key self._db.open() except Exception as e: # pragma: no cover self.error(e) sys.exit(1) try: readline.read_history_file(self._historyfile) except IOError as e: # pragma: no cover pass self.prompt = "pwman> "
def init_history(self, histfile): if hasattr(readline, "read_history_file"): try: readline.read_history_file(histfile) except IOError: pass atexit.register(self.save_history, histfile)
def history_init(self, filename, size): self.history_file = filename self.history_size = size if filename and os.path.exists(filename): readline.read_history_file(filename) readline.set_history_length(size) self.history_reset()
def exec_cmdloop(self, args, options): try: import readline delims = readline.get_completer_delims() delims = delims.replace(':', '') # "group:process" as one word delims = delims.replace('*', '') # "group:*" as one word delims = delims.replace('-', '') # names with "-" as one word readline.set_completer_delims(delims) if options.history_file: try: readline.read_history_file(options.history_file) except IOError: pass def save(): try: readline.write_history_file(options.history_file) except IOError: pass import atexit atexit.register(save) except ImportError: pass try: self.cmdqueue.append('status') self.cmdloop() except KeyboardInterrupt: self.output('') pass
def rlinput(prompt, prefill='', oneline=False, ctxkey=''): """ Get user input with readline editing support. """ sentinel = '' if prefill is None: prefill = '' def only_once(text): """ generator for startup hook """ readline.insert_text(text) yield while True: yield savedhist = NamedTemporaryFile() readline.write_history_file(savedhist.name) ctxhistname = ".tl" + ctxkey + "history" ctxhistfile = os.path.join(G.ProjectFolder, ctxhistname) try: readline.clear_history() except AttributeError: print "This readline doesn't support clear_history()" raise savedcompleter = readline.get_completer() try: ulines = uniqify(ctxhistfile) readline.read_history_file(ctxhistfile) readline.set_completer(HistoryCompleter(ulines).complete) except IOError: pass readline.parse_and_bind('tab: complete') saveddelims = readline.get_completer_delims() readline.set_completer_delims('') ## No delims. Complete entire lines. readline.set_completion_display_matches_hook(match_display_hook) gen = only_once(prefill) readline.set_startup_hook(gen.next) try: if oneline: edited = raw_input(prompt) else: print prompt edited = "\n".join(iter(raw_input, sentinel)) if edited.endswith(r'%%'): ## Invoke external editor edited = external_edit(edited[0:-2]) return edited finally: ## Restore readline state readline.write_history_file(ctxhistfile) readline.clear_history() readline.read_history_file(savedhist.name) savedhist.close() readline.set_completer(savedcompleter) readline.set_completer_delims(saveddelims) readline.set_startup_hook()
def get_input_with_readline(filename): """ sets up readline support for entering sitenames, completed from the existing list and accepts a line of input. """ if not os.path.exists(filename): file(filename, "w").close() all_lines = map(lambda x: x.strip(), file(filename).readlines()) def completer(text, state): """ custom readline completer """ candidates = filter(lambda x: x.startswith(text), all_lines) if state <= len(candidates): return candidates[state-1] else: return None try: import readline readline.set_completer(completer) readline.read_history_file(filename) readline.parse_and_bind('tab: complete') if hasattr(readline, 'readline'): print "sitename: ", readline._issued = True return readline.readline(history=all_lines, histfile=None) else: return raw_input("sitename: ") except: # no readline? return raw_input("sitename: ")
def setup(self): """ Initialization of third-party libraries Setting interpreter history. Setting appropriate completer function. :return: """ if not os.path.exists(self.history_file): with open(self.history_file, 'a+') as history: if is_libedit(): history.write("_HiStOrY_V2_\n\n") 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;') if is_libedit(): readline.parse_and_bind("bind ^I rl_complete") else: readline.parse_and_bind("tab: complete")
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.') (options, args) = parser.parse_args() if not args or len(args) > 2: print >> sys.stderr, __doc__ if len(args) > 2: print >> sys.stderr, 'Unexpected arguments: %s' % args[2:] sys.exit(1) appid = args[0] if len(args) == 2: path = args[1] else: path = DEFAULT_PATH remote_api_stub.ConfigureRemoteApi(appid, path, auth_func, servername=options.server) remote_api_stub.MaybeInvokeAuthentication() readline.parse_and_bind('tab: complete') atexit.register(lambda: readline.write_history_file(HISTORY_PATH)) sys.ps1 = '%s> ' % appid if os.path.exists(HISTORY_PATH): readline.read_history_file(HISTORY_PATH) code.interact(banner=BANNER, local=globals())
def enable_readline(): """ Imports the `readline` module to enable advanced repl text manipulation, and command history navigation. Returns True if success, otherwise False. """ try: import readline except ImportError: return False import os import atexit histfile = os.path.join(os.path.expanduser("~"), ".clojurepyhist") if not os.path.isfile(histfile): with open(histfile, 'a'): os.utime(histfile, None) os.chmod(histfile, int('640',8)) try: readline.read_history_file(histfile) except IOError: # Pass here as there isn't any history file, so one will be # written by atexit pass atexit.register(readline.write_history_file, histfile) return True
def __enter__(self): if readline_loaded: if readline.__doc__ and 'libedit' in readline.__doc__: readline.parse_and_bind("bind '\t' rl_complete") # Enable tab completions on MacOS else: readline.parse_and_bind("tab: complete") # and on other OSs readline.parse_and_bind("set completion-ignore-case on") readline.parse_and_bind("set show-all-if-ambiguous on") readline.parse_and_bind("set completion-map-case on") readline.parse_and_bind("set show-all-if-unmodified on") readline.parse_and_bind("set expand-tilde on") history_file_dir = appdirs.user_data_dir(self.this_program_name, self.this_program_name) os.makedirs(history_file_dir, exist_ok=True) self.history_file_path = os.path.join(history_file_dir, "." + self.this_program_name + "_console_history") try: readline.read_history_file(self.history_file_path) except Exception: # Corrupt or non existent history file might raise an exception try: os.remove(self.history_file_path) except Exception: pass # if removing the file also fail - just ignore it if colorama_loaded: colorama.init() self.prompt = self.this_program_name + ": " self.save_dir = os.getcwd() return self
def setup_readline_history(histfile=None): """Handle readline / history.""" if not histfile: histfile = "./.python_history" # histfile = os.path.join(os.path.expanduser("~"), ".python_history") if sys.version_info.major >= 3: # python3 try: readline.read_history_file(histfile) h_len = readline.get_current_history_length() except os.FileNotFoundError: open(histfile, 'wb').close() h_len = 0 elif sys.version_info.major == 2: # python2 try: readline.read_history_file(histfile) h_len = readline.get_current_history_length() except IOError: open(histfile, 'wb').close() h_len = 0 else: h_len = 0 print("readline history length: {}".format( readline.get_current_history_length() )) atexit.register(save, h_len, histfile)
def start(self): # log start log.info('Starting viper-cli') # Logo. logo() # Setup shell auto-complete. def complete(text, state): # filesystem path completion only makes sense for a few commands/modules fs_path_completion = False # clean up user input so far (no leading/trailing/duplicate spaces) line = " ".join(readline.get_line_buffer().split()) words = line.split(" ") # split words; e.g. store -f /tmp -> ['store', '-f', '/tmp'] if words[0] in [i for i in self.cmd.commands]: # handle completion for commands # enable filesystem path completion for certain commands (e.g. export, store) if words[0] in [x for x in self.cmd.commands if self.cmd.commands[x]["fs_path_completion"]]: fs_path_completion = True options = [key for key in self.cmd.commands[words[0]]["parser_args"]] completions = [i for i in options if i.startswith(text) and i not in words] elif words[0] in [i for i in __modules__]: # handle completion for modules if len(words) == 1: # only the module name is give so far - present all args and the subparsers (if any) options = [key for key in __modules__[words[0]]["parser_args"]] options += [key for key in __modules__[words[0]]["subparser_args"]] elif len(words) == 2: # 1 complete word and one either complete or incomplete that specifies the subparser or an arg if words[1] in list(__modules__[words[0]]["parser_args"]): # full arg for a module is given options = [key for key in __modules__[words[0]]["parser_args"]] elif words[1] in list(__modules__[words[0]]["subparser_args"]): # subparser is specified - get all subparser args options = [key for key in __modules__[words[0]]["subparser_args"][words[1]]] else: options = [key for key in __modules__[words[0]]["parser_args"]] options += [key for key in __modules__[words[0]]["subparser_args"]] else: # more that 2 words if words[1] in list(__modules__[words[0]]["subparser_args"]): # subparser is specified - get all subparser args options = [key for key in __modules__[words[0]]["subparser_args"][words[1]]] else: options = [key for key in __modules__[words[0]]["parser_args"]] completions = [i for i in options if i.startswith(text) and i not in words] else: # initial completion for both commands and modules completions = [i for i in self.cmd.commands if i.startswith(text)] completions += [i for i in __modules__ if i.startswith(text)] if state < len(completions): return completions[state] if fs_path_completion: # completion for paths only if it makes sense if text.startswith("~"): text = "{0}{1}".format(expanduser("~"), text[1:]) return (glob.glob(text + '*') + [None])[state] return # Auto-complete on tabs. readline.set_completer_delims(' \t\n;') readline.parse_and_bind('tab: complete') readline.set_completer(complete) # Save commands in history file. def save_history(path): readline.write_history_file(path) # If there is an history file, read from it and load the history # so that they can be loaded in the shell. # Now we are storing the history file in the local project folder history_path = os.path.join(__project__.path, 'history') if os.path.exists(history_path): readline.read_history_file(history_path) readline.set_history_length(10000) # Register the save history at program's exit. atexit.register(save_history, path=history_path) # Main loop. while self.active: # If there is an open session, we include the path to the opened # file in the shell prompt. # TODO: perhaps this block should be moved into the session so that # the generation of the prompt is done only when the session's # status changes. prefix = '' if __project__.name: prefix = bold(cyan(__project__.name)) + ' ' if __sessions__.is_set(): stored = '' filename = '' if __sessions__.current.file: filename = __sessions__.current.file.name if not Database().find(key='sha256', value=__sessions__.current.file.sha256): stored = magenta(' [not stored]', True) misp = '' if __sessions__.current.misp_event: misp = ' [MISP' if __sessions__.current.misp_event.event.id: misp += ' {}'.format(__sessions__.current.misp_event.event.id) else: misp += ' New Event' if __sessions__.current.misp_event.off: misp += ' (Offline)' misp += ']' prompt = (prefix + cyan('viper ', True) + white(filename, True) + blue(misp, True) + stored + cyan(' > ', True)) # Otherwise display the basic prompt. else: prompt = prefix + cyan('viper > ', True) # force str (Py3) / unicode (Py2) for prompt if sys.version_info <= (3, 0): prompt = prompt.encode('utf-8') else: prompt = str(prompt) # Wait for input from the user. try: data = input(prompt).strip() except KeyboardInterrupt: print("") # Terminate on EOF. except EOFError: self.stop() print("") continue # Parse the input if the user provided any. else: # If there are recognized keywords, we replace them with # their respective value. data = self.keywords(data) # Skip if the input is empty. if not data: continue # Check for output redirection # If there is a > in the string, we assume the user wants to output to file. if '>' in data: data, console_output['filename'] = data.split('>', 1) if ';' in console_output['filename']: console_output['filename'], more_commands = console_output['filename'].split(';', 1) data = '{};{}'.format(data, more_commands) print("Writing output to {0}".format(console_output['filename'].strip())) # If the input starts with an exclamation mark, we treat the # input as a bash command and execute it. # At this point the keywords should be replaced. if data.startswith('!'): os.system(data[1:]) continue # Try to split commands by ; so that you can sequence multiple # commands at once. # For example: # viper > find name *.pdf; open --last 1; pdf id # This will automatically search for all PDF files, open the first entry # and run the pdf module against it. split_commands = data.split(';') for split_command in split_commands: split_command = split_command.strip() if not split_command: continue # If it's an internal command, we parse the input and split it # between root command and arguments. root, args = self.parse(split_command) # Check if the command instructs to terminate. if root in ('exit', 'quit'): self.stop() continue try: # If the root command is part of the embedded commands list we # execute it. if root in self.cmd.commands: self.cmd.commands[root]['obj'](*args) del(self.cmd.output[:]) # If the root command is part of loaded modules, we initialize # the module and execute it. elif root in __modules__: module = __modules__[root]['obj']() module.set_commandline(args) module.run() if cfg.modules.store_output and __sessions__.is_set(): try: Database().add_analysis(__sessions__.current.file.sha256, split_command, module.output) except: pass del(module.output[:]) else: print("Command not recognized.") except KeyboardInterrupt: pass except Exception: print_error("The command {0} raised an exception:".format(bold(root))) traceback.print_exc() console_output['filename'] = None # reset output to stdout
# import some modules which might be useful on the command line import numpy as np # Use CLI history and tab completion import atexit import os historyPath = os.path.expanduser("~/.pyhistory") try: import readline except ImportError: print("Import Error in __main__: Module readline not available.") else: import rlcompleter readline.parse_and_bind("tab: complete") if os.path.exists(historyPath): readline.read_history_file(historyPath) def save_history(new_historyPath=historyPath): try: import readline except ImportError: print("Import Error in __main__: Module readline not available.") else: readline.write_history_file(new_historyPath) atexit.register(save_history) else: # non-interactive, start application in different modes if args.profile: # with profiler import cProfile, pstats
#import tab completion functionality import rlcompleter #Override completer from rlcompleter to disable automatic ( on callable completer_obj = rlcompleter.Completer() def nop(val, word): return word completer_obj._callable_postfix = nop readline.set_completer(completer_obj.complete) #activate tab completion readline.parse_and_bind("tab: complete") readline.set_history_length(_history_length) readline.read_history_file(_history_file_name) atexit.register(at_exit_callback) import sys print("Python " + sys.version + " on " + sys.platform) sys.path.append(os.path.abspath(os.curdir)) # output = subprocess.check_output("../install/bin/clang-cl.exe -Xclang -ast-print -fsyntax-only sample.c") command_line = [ "../install/bin/clang-cl.exe", "-Xclang", "-ast-print", "-fsyntax-only", "-Wno-unused-command-line-argument", "-Wno-macro-redefined", "-Wno-unused-parameter", "-fms-compatibility-version=1700", "-fms-compatibility", "-m64" ] command_line.append(
dict([(k, self._base % v) for k, v in self.COLOR_TEMPLATES])) else: self.update( dict([(k, self.NoColor) for k, v in self.COLOR_TEMPLATES])) _c = TermColors() # Enable a History ################## HISTFILE = "%s/.pyhistory" % os.environ["HOME"] # Read the existing history if there is one if os.path.exists(HISTFILE): readline.read_history_file(HISTFILE) # Set maximum number of items that will be written to the history file readline.set_history_length(1000) def savehist(): readline.write_history_file(HISTFILE) readline.parse_and_bind("tab: complete") atexit.register(savehist) # Enable Color Prompts ######################
def _pop_history(self, tmp_file): readline.clear_history() readline.read_history_file(tmp_file.name) tmp_file.close()
def load_console_history(self): if os.path.exists(self._history_file): readline.read_history_file(self._history_file) return
cmd.Cmd.__init__(self) self.intro = "%s %s (c) %s <%s>" % (pwman.appname, pwman.version, pwman.author, pwman.authoremail) self._historyfile = config.get_value("Readline", "history") try: enc = CryptoEngine.get() enc.set_callback(CLICallback()) self._db = db self._db.open() except Exception, e: self.error(e) sys.exit(1) try: readline.read_history_file(self._historyfile) except Exception, e: pass self.prompt = "pwman> " _defaultwidth = 10 def getonechar(question, width=_defaultwidth): question = "%s " % (question) print question.ljust(width), sys.stdout.flush() fd = sys.stdin.fileno()
def start(self): from stf.core.dataset import __datasets__ # Logo. logo() self.db.list() # Setup shell auto-complete. def complete(text, state): # Try to autocomplete commands. cmds = [i for i in self.cmd.commands if i.startswith(text)] if state < len(cmds): return cmds[state] # Try to autocomplete modules. #mods = [i for i in __modules__ if i.startswith(text)] #if state < len(mods): #return mods[state] # Then autocomplete paths. if text.startswith("~"): text = "{0}{1}".format(os.getenv("HOME"), text[1:]) return (glob.glob(text + '*') + [None])[state] # Auto-complete on tabs. readline.set_completer_delims(' \t\n;') readline.parse_and_bind('tab: complete') readline.parse_and_bind('set editing-mode vi') readline.set_completer(complete) # Save commands in history file. def save_history(path): readline.write_history_file(path) if os.path.exists(self.history_path): readline.read_history_file(self.history_path) # Register the save history at program's exit. atexit.register(save_history, path=self.history_path) # Main loop. while self.active: if __datasets__.current: self.prefix = red(__datasets__.current.get_name() + ': ') else: self.prefix = '' prompt = self.prefix + cyan('stf > ', True) # Wait for input from the user. try: data = raw_input(prompt).strip() except KeyboardInterrupt: print("") # Terminate on EOF. except EOFError: self.stop() print("") continue # Parse the input if the user provided any. else: # Skip if the input is empty. if not data: continue # If the input starts with an exclamation mark, we treat the # input as a bash command and execute it. if data.startswith('!'): os.system(data[1:]) continue # Try to split commands by ; so that you can sequence multiple # commands at once. # For example: # viper > find name *.pdf; open --last 1; pdf id # This will automatically search for all PDF files, open the first entry # and run the pdf module against it. split_commands = data.split(';') for split_command in split_commands: split_command = split_command.strip() if not split_command: continue # If it's an internal command, we parse the input and split it # between root command and arguments. root, args = self.parse(split_command) # Check if the command instructs to terminate. if root in ('exit', 'quit'): self.stop() continue try: # If the root command is part of the embedded commands list we # execute it. if root in self.cmd.commands: self.cmd.commands[root]['obj'](*args) # If the root command is part of loaded modules, we initialize # the module and execute it. #elif root in __modules__: # module = __modules__[root]['obj']() # module.set_commandline(args) # module.run() # self.print_output(module.output, filename) # del(module.output[:]) else: print("Command not recognized.") except KeyboardInterrupt: pass except Exception as e: print_error( "The command {0} raised an exception:".format( bold(root))) traceback.print_exc()
def read_history(self): if hasReadline and self._history_path: try: readline.read_history_file(self._history_path) except: pass
def save_history(historyPath=historyPath): import readline readline.write_history_file(historyPath) if os.path.exists(historyPath): readline.read_history_file(historyPath)
def _init(): import atexit import os import sys import readline import types import time import uuid import pprint import hashlib import datetime try: import __builtin__ except ImportError: import builtins as __builtin__ __import__('rlcompleter') histdir = os.path.expanduser('~/.pyhist') try: os.makedirs(histdir) except OSError: pass def _b(x): if not isinstance(x, bytes): x = x.encode('utf-8') return x histfile = os.path.join( histdir, hashlib.sha1(os.path.normpath(_b(os.path.abspath( sys.prefix)))).hexdigest()) try: readline.read_history_file(histfile) except IOError: pass if 'libedit' in readline.__doc__: readline.parse_and_bind("bind '\t' rl_complete") else: readline.parse_and_bind("tab: complete") atexit.register(readline.write_history_file, histfile) def _magic_uuid(val=None): if val is None: return uuid.uuid4() elif isinstance(val, uuid.UUID): return val elif len(val) == 16: return uuid.UUID(bytes=val) return uuid.UUID(val) helpers = types.ModuleType('helpers') helpers.histfile = histfile helpers.pp = pprint.pprint helpers.uuid = _magic_uuid helpers.UUID = uuid.UUID helpers.uuid3 = uuid.uuid3 helpers.uuid4 = uuid.uuid4 helpers.uuid5 = uuid.uuid5 helpers.dt = datetime.datetime helpers.datetime = datetime.datetime helpers.td = datetime.timedelta helpers.timedelta = datetime.timedelta helpers.time = time.time __builtin__.h = helpers
import os import readline import atexit import json import vibrance histfile = os.path.join(os.path.expanduser("~"), ".vibrance_history") try: readline.read_history_file(histfile) readline.set_history_length(1000) except FileNotFoundError: pass atexit.register(readline.write_history_file, histfile) api = vibrance.Interface("Terminal Composer") @api.loop def loop(): i = input("Messages> ") api.messages = json.loads(i)
try: client = APP.CLIClient() signature = client.recv() except socket.error: print "Connection failed." sys.exit(1) cliRoot = CreateCliTree(signature) cliRoot.root = True print signature print cliRoot.printall() try: if hasReadline: readline.read_history_file ( os.path.expanduser("~/.prov-history") ) except IOError: pass if hasReadline: atexit.register(readline.write_history_file, os.path.expanduser("~/.prov-history") ) readline.parse_and_bind("tab: complete") readline.set_completer ( command_completer ) readline.set_completer_delims("\n") currentLevel = cliRoot while True: try: command = raw_input("(provcli) %s> " % currentLevel.path()) if command.upper() in ["EXIT", "QUIT"]: break
def init_history(histfile: str) -> None: if hasattr(readline, "read_history_file"): try: readline.read_history_file(histfile) except IOError: pass
def shell_thread(**kwargs): hist_loc = ".overwatch_shell.history" console = InteractiveConsole() console.locals = locals() console.locals.update(kwargs) console.locals.update(globals()) console.push("import sys") console.push("import os") console.push("sys.path.append(os.getcwd())") readline.set_completer(rlcompleter.Completer(console.locals).complete) readline.parse_and_bind("tab: complete") if not os.path.isfile(hist_loc): f = open(hist_loc, "x") f.write("\n") f.close() readline.read_history_file(hist_loc) # Opens a Python shell todo = TodoPointer() def snip(location, _todo=todo): _todo.location = location console.locals["snip"] = snip buf = [] def get_input(prompt): if len(buf) > 0: l = buf.pop(0) print("::: " + l.rstrip("\n")) return l else: return input(prompt) while True: try: c = get_input(">>> ") if (not c == ""): if console.push( c ): # console.push(c) executes the string c in the console. # if it is True, it means it expects more input # (for example a function definition) _input = ' ' totalcommand = '' while _input != '': _input = get_input('... ') totalcommand += _input + '\n' console.push(totalcommand) if todo.location is not None: with open(todo.location, 'r') as f: code = f.readlines() buf.extend(code) buf.append("") todo.location = None except (EOFError, KeyboardInterrupt): print("\nShell ended.") break except Exception as e: console.showtraceback() readline.write_history_file(hist_loc)
def main(): global xnodes global no_run # read all the input files if readline: history = os.path.join(os.path.expanduser("~"), ".steuermann_history") try: readline.read_history_file(history) except IOError: pass import atexit atexit.register(readline.write_history_file, history) # easyargs spec definition: # # '-v' : '', # arg takes no parameter, opt['-v'] is # # how many times it occurred # '-f' : '=', # arg takes a parameter # '-mf' : '=+', # arg takes a parameter, may be specified # # several times to get a list # '--verbose' : '-v', # arg is an alias for some other arg opt, args = easyargs.get(allowed_flags, allow_unexpected=True) do_all = opt['-a'] no_run = opt['-n'] ''' NOTE: moving this functionality into nodes.py # find any unknown arguments like --something=whatever, set as conditions arguments = sys.argv[1:] for a in arguments: if '--' in a and '=' in a: not_allowed_flag = True for f in allowed_flags.keys(): if a.startswith(f): not_allowed_flag = False break if not_allowed_flag: a = a.lstrip('--') k, v = a.split('=') nodes.saved_conditions[k] = eval(v) ''' sm_files = [ os.path.abspath(a) for a in args if ('--' not in a and '=' not in a) ] di_nodes = nodes.read_file_list(sm_files) xnodes = di_nodes.node_index # get run name if '-r' in opt: run_name = opt['-r'] else: run_name = "user_%s_%s" % (username, str( datetime.datetime.now()).replace(' ', '_')) # get hosts (*.ini) file name if '-h' in opt: hosts_ini = opt['-h'] else: hosts_ini = os.path.join(os.path.dirname(__file__), 'hosts.ini') # Use a user-defined config if it exists if os.path.exists(config.hosts_config): hosts_ini = config.hosts_config # parse common resources from hosts INI file get_common_resources(hosts_ini) db = config.open_db() if do_all: run_all(xnodes, run_name, hosts_ini, db) else: run_interactive(xnodes, run_name, hosts_ini, db)
fout = open(os.path.join(rundir,filename)) measure_rate(fout,samples,triggers) fout.close() elif keys[0] == "help": print "Possible commands are:" for i in range(len(commands)): print " ",commands[i] else: print "Unknown command" except (ValueError, struct.error), e: print "Bad Input:",e if os.path.exists(HISTORY_FILENAME): readline.read_history_file(HISTORY_FILENAME) # keyboard input loop try: while True: line = raw_input() if line: if line.startswith("readall"): nline = line.replace('readall', 'read') nruns = int(get_key_value(line.split(),"n",1)) for i in range(0,nruns): transmissiondone=0 process_command(nline) while transmissiondone==0: time.sleep(1)
def __enter__(self) -> 'HistoryCompleter': if self.history_path: with suppress(Exception): readline.read_history_file(self.history_path) readline.set_completer(self.complete) return self
def interact(mydict=None,argv=None,mybanner=None,loglevel=20): global session import code,sys,cPickle,os,getopt,re from config import conf conf.interactive = True if loglevel is not None: conf.logLevel=loglevel the_banner = "Welcome to Scapy (%s)" if mybanner is not None: the_banner += "\n" the_banner += mybanner if argv is None: argv = sys.argv import atexit try: import rlcompleter,readline except ImportError: log_loading.info("Can't load Python libreadline or completer") READLINE=0 else: READLINE=1 class ScapyCompleter(rlcompleter.Completer): def global_matches(self, text): matches = [] n = len(text) for lst in [dir(__builtin__), session.keys()]: for word in lst: if word[:n] == text and word != "__builtins__": matches.append(word) return matches def attr_matches(self, text): m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text) if not m: return expr, attr = m.group(1, 3) try: object = eval(expr) except: object = eval(expr, session) if isinstance(object, Packet) or isinstance(object, Packet_metaclass): words = filter(lambda x: x[0]!="_",dir(object)) words += [x.name for x in object.fields_desc] else: words = dir(object) if hasattr( object,"__class__" ): words = words + rlcompleter.get_class_members(object.__class__) matches = [] n = len(attr) for word in words: if word[:n] == attr and word != "__builtins__": matches.append("%s.%s" % (expr, word)) return matches readline.set_completer(ScapyCompleter().complete) readline.parse_and_bind("C-o: operate-and-get-next") readline.parse_and_bind("tab: complete") session=None session_name="" STARTUP_FILE = DEFAULT_STARTUP_FILE PRESTART_FILE = DEFAULT_PRESTART_FILE iface = None try: opts=getopt.getopt(argv[1:], "hs:Cc:Pp:d") for opt, parm in opts[0]: if opt == "-h": _usage() elif opt == "-s": session_name = parm elif opt == "-c": STARTUP_FILE = parm elif opt == "-C": STARTUP_FILE = None elif opt == "-p": PRESTART_FILE = parm elif opt == "-P": PRESTART_FILE = None elif opt == "-d": conf.logLevel = max(1,conf.logLevel-10) if len(opts[1]) > 0: raise getopt.GetoptError("Too many parameters : [%s]" % " ".join(opts[1])) except getopt.GetoptError as msg: log_loading.error(msg) sys.exit(1) if PRESTART_FILE: _read_config_file(PRESTART_FILE) scapy_builtins = __import__("all",globals(),locals(),".").__dict__ __builtin__.__dict__.update(scapy_builtins) globkeys = scapy_builtins.keys() globkeys.append("scapy_session") scapy_builtins=None # XXX replace with "with" statement if mydict is not None: __builtin__.__dict__.update(mydict) globkeys += mydict.keys() conf.color_theme = DefaultTheme() if STARTUP_FILE: _read_config_file(STARTUP_FILE) if session_name: try: os.stat(session_name) except OSError: log_loading.info("New session [%s]" % session_name) else: try: try: session = cPickle.load(gzip.open(session_name,"rb")) except IOError: session = cPickle.load(open(session_name,"rb")) log_loading.info("Using session [%s]" % session_name) except EOFError: log_loading.error("Error opening session [%s]" % session_name) except AttributeError: log_loading.error("Error opening session [%s]. Attribute missing" % session_name) if session: if "conf" in session: conf.configure(session["conf"]) session["conf"] = conf else: conf.session = session_name session={"conf":conf} else: session={"conf": conf} __builtin__.__dict__["scapy_session"] = session if READLINE: if conf.histfile: try: readline.read_history_file(conf.histfile) except IOError: pass atexit.register(scapy_write_history_file,readline) atexit.register(scapy_delete_temp_files) IPYTHON=False if conf.interactive_shell.lower() == "ipython": try: import IPython IPYTHON=True except ImportError as e: log_loading.warning("IPython not available. Using standard Python shell instead.") IPYTHON=False if IPYTHON: banner = the_banner % (conf.version) + " using IPython %s" % IPython.__version__ # Old way to embed IPython kept for backward compatibility try: args = [''] # IPython command line args (will be seen as sys.argv) ipshell = IPython.Shell.IPShellEmbed(args, banner = banner) ipshell(local_ns=session) except AttributeError as e: pass # In the IPython cookbook, see 'Updating-code-for-use-with-IPython-0.11-and-later' IPython.embed(user_ns=session, banner2=banner) else: code.interact(banner = the_banner % (conf.version), local=session, readfunc=conf.readfunc) if conf.session: save_session(conf.session, session) for k in globkeys: try: del(__builtin__.__dict__[k]) except: pass
def preloop(self): if readline and os.path.exists(histfile): readline.read_history_file(histfile)
# -*- coding: UTF-8 -*- # Example snippet to use in a PYTHONSTARTUP file try: import pyreadline.rlmain # pyreadline.rlmain.config_path=r"c:\xxx\pyreadlineconfig.ini" import readline, atexit import pyreadline.unicode_helper # # # Normally the codepage for pyreadline is set to be sys.stdout.encoding # if you need to change this uncomment the following line # pyreadline.unicode_helper.pyreadline_codepage="utf8" except ImportError: print "Module readline not available." else: # import tab completion functionality import rlcompleter # activate tab completion readline.parse_and_bind("tab: complete") readline.read_history_file() atexit.register(readline.write_history_file) del readline, rlcompleter, atexit
def run(self): super(ConsoleCLI, self).run() sshpass = None becomepass = None vault_pass = None # hosts if len(self.args) != 1: self.pattern = 'all' else: self.pattern = self.args[0] self.options.cwd = self.pattern # dynamically add modules as commands self.modules = self.list_modules() for module in self.modules: setattr( self, 'do_' + module, lambda arg, module=module: self.default(module + ' ' + arg)) setattr(self, 'help_' + module, lambda module=module: self.helpdefault(module)) self.normalize_become_options() (sshpass, becomepass) = self.ask_passwords() self.passwords = {'conn_pass': sshpass, 'become_pass': becomepass} self.loader = DataLoader() if self.options.vault_password_file: # read vault_pass from a file vault_pass = CLI.read_vault_password_file( self.options.vault_password_file, loader=self.loader) self.loader.set_vault_password(vault_pass) elif self.options.ask_vault_pass: vault_pass = self.ask_vault_passwords()[0] self.loader.set_vault_password(vault_pass) self.variable_manager = VariableManager() self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=self.options.inventory) self.variable_manager.set_inventory(self.inventory) if len(self.inventory.list_hosts(self.pattern)) == 0: # Empty inventory display.warning( "provided hosts list is empty, only localhost is available") self.inventory.subset(self.options.subset) self.groups = self.inventory.list_groups() self.hosts = [x.name for x in self.inventory.list_hosts(self.pattern)] # This hack is to work around readline issues on a mac: # http://stackoverflow.com/a/7116997/541202 if 'libedit' in readline.__doc__: readline.parse_and_bind("bind ^I rl_complete") else: readline.parse_and_bind("tab: complete") histfile = os.path.join(os.path.expanduser("~"), ".ansible-console_history") try: readline.read_history_file(histfile) except IOError: pass atexit.register(readline.write_history_file, histfile) self.set_prompt() self.cmdloop()
def start_repl(args): exploits = [] # Transactions to frontrun if args.skip_mythril is False: print("Scanning for exploits in contract: {contract}".format( contract=args.contract)) exploits += exploits_from_mythril( rpcHTTP=args.rpc_http, rpcWS=args.rpc_ws, rpcIPC=args.rpc_ipc, contract=args.contract, account_pk=args.account_pk, timeout=args.timeout, ) if args.load_file is not None: exploits += exploits_from_file( file=args.load_file, rpcHTTP=args.rpc_http, rpcWS=args.rpc_ws, rpcIPC=args.rpc_ipc, contract=args.contract, account_pk=args.account_pk, timeout=args.timeout, ) if len(exploits) == 0: print("No exploits found. You're going to need to load some exploits.") else: print("") print("Found exploits(s):") print(exploits) # Add local tools for console w3 = Web3( Web3.HTTPProvider(args.rpc_http, request_kwargs={"timeout": args.timeout})) from theo.exploit.exploit import Exploit from theo.exploit.tx import Tx # Imports for REPL import os, atexit, readline, rlcompleter # Load history history_path = os.path.join(os.environ["HOME"], ".theo_history") if os.path.isfile(history_path): readline.read_history_file(history_path) # Trigger history save on exit atexit.register(readline.write_history_file, history_path) # Load variables vars = globals() vars.update(locals()) # Start REPL readline.set_completer(rlcompleter.Completer(vars).complete) readline.parse_and_bind("tab: complete") del os, atexit, readline, rlcompleter code.InteractiveConsole(vars).interact(banner=""" Tools available in the console: - `exploits` is an array of loaded exploits found by Mythril or read from a file - `w3` an initialized instance of web3py for the provided HTTP RPC endpoint - `dump()` writing a json representation of an object to a local file Check the readme for more info: https://github.com/cleanunicorn/theo Theo version {version}. """.format(version=__version__)) print("Shutting down")
def main(): reload(sys) sys.setdefaultencoding('utf-8') sys.stdout = codecs.getwriter('utf-8')(sys.stdout) #defino argumentos de script parser = argparse.ArgumentParser(description='menu for t-hoarder_kit') parser.add_argument('root', type=str, help='path where t_hoarder_kit was installed') action = parser.add_mutually_exclusive_group(required=True) action.add_argument('--windows', action='store_true', help='windows OS') action.add_argument('--linux', action='store_true', help='linux OS') action.add_argument('--mac', action='store_true', help='mac OS') args = parser.parse_args() root = args.root if args.windows: path_keys = '%s\\keys\\' % root path_scripts = '%s\\scripts\\' % root path_store = '%s\\store\\' % root if args.linux or args.mac: path_keys = '%s/keys/' % root path_scripts = '%s/scripts/' % root path_store = '%s/store/' % root list_suboptions_2 = [ 'profile', 'followers', 'following', 'relations', 'tweets', 'h_index' ] list_suboptions_6 = ['RT', 'reply', 'mentions'] list_suboptions_7 = ['sort', 'entities', 'classify', 'users', 'spread'] enviroment = False option = 8 exit = 'n' histfile = os.path.join(os.path.expanduser("~"), ".pyhist") readline.parse_and_bind("tab: complete") try: readline.read_history_file(histfile) # default history len is -1 (infinite), which may grow unruly readline.set_history_length(1000) except IOError: pass if not enviroment: print 'working in', root print ' ' print '----------------------------------------' print '------> Environment data <------' print '----------------------------------------' app_keys = get_inputfile( 'Enter the file name with the application keys: ', path_keys) user = raw_input('Enter a twitter user: '******'Enter experiment name: ', path_store) enviroment = True file_app_keys = '%s%s' % (path_keys, app_keys) file_user_keys = '%s%s.key' % (path_keys, user) if args.windows: path_experiment = '%s%s\\' % (path_store, experiment) path_resources = '%s\resources\\' % (root) elif args.linux or args.mac: path_experiment = '%s%s/' % (path_store, experiment) path_resources = '%s/resources/' % (root) while exit != 'y': try: print '--------------------------------' print ' Working with:' print ' app:', app_keys print ' user:'******' experiment:', experiment print '--------------------------------' print 'What function do you want to run?' print '--------------------------------' print '1. Get a user token access' print '2. Get users information (profile | followers | following | relations | tweets | h_index)' print '3. Make a query on Twitter' print '4. Get tweets on real time' print '5. Generate the declared relations graph (followers or following or both)' print '6. Generate the dynamic relations graph (RT | reply | mentions)' print '7. Processing tweets (sort |entities| classify| users | spread)' print '8. Exit' print ' ' while True: try: option = int(raw_input('--> Enter option: ')) break except: pass if option == 1: os.chdir(path_keys) command = "python %stweet_auth.py '%s' '%s'" % (path_scripts, app_keys, user) os.system(command) elif option == 2: os.chdir(path_experiment) inputfile = get_inputfile( 'Enter input file name with the list of users or list of profiles (each user in a line): ', path_experiment) option_rest = get_suboption( 'Enter an option (profile | followers | following |relations | tweets| h_index) : ', list_suboptions_2) command = "python %stweet_rest.py '%s' '%s' '%s' '--%s'" % ( path_scripts, file_app_keys, file_user_keys, inputfile, option_rest) os.system(command) elif option == 3: os.chdir(path_experiment) query = raw_input( 'Enter a query (allows AND / OR connectors): ') outputfile = get_outputfile('Enter output file name: ', path_experiment) if outputfile != None: command = "python %stweet_search.py '%s' '%s' '--query' '%s' '--file_out' '%s'" % ( path_scripts, file_app_keys, file_user_keys, query, outputfile) os.system(command) else: print 'Option not executed' elif option == 4: os.chdir(path_experiment) file = get_inputfile( 'Enter input file name with the keywords separated by , : ', path_experiment) outputfile = get_outputfile('Enter output file name: ', path_experiment) if outputfile != None: command = "python %stweet_streaming.py '%s' '%s' '%s' '%s' '--words' '%s'" % ( path_scripts, file_app_keys, file_user_keys, path_experiment, outputfile, file) os.system(command) else: print 'Option not executed' elif option == 5: os.chdir(path_experiment) inputfile = get_inputfile( 'Enter input file name with the users profiles (It is necessary to get before the users profiles): ', path_experiment) command = "python %stweet_rest.py '%s' '%s' '%s' '--connections' " % ( path_scripts, file_app_keys, file_user_keys, inputfile) fast = raw_input('opción --fast? (y/n:) ') if fast == 'y': command = command + '--fast' os.system(command) elif option == 6: os.chdir(path_experiment) inputfile = get_inputfile( 'Enter input file name with the tweets (got from a query or in real time): ', path_experiment) relation = get_suboption( 'Enter the relationship type (RT | reply | mention): ', list_suboptions_6) top = raw_input('Introduce top size (100-50000): ') command = "python %stweets_grafo.py '%s' '--%s' '--top_size' '%s'" % ( path_scripts, inputfile, relation, top) os.system(command) elif option == 7: os.chdir(path_experiment) option_processing = get_suboption( 'Enter option (sort |entities| classify| users | spread): ', list_suboptions_7) if option_processing == 'sort': inputfile = get_inputfile( 'Enter input file name with the tweets (got from a query or in real time): ', path_experiment) if args.linux: filename, file_extension = os.path.splitext(inputfile) command = '(head -n 1 %s && tail -n +2 %s | sort -u) > %s_ok%s' % ( inputfile, inputfile, filename, file_extension) os.system(command) print 'file sorted in %s_ok%s)' % (filename, file_extension) if args.windows: print 'in construccion' elif option_processing == 'entities': inputfile = get_inputfile( 'Enter input file name with the tweets (got from a query or in real time): ', path_experiment) time_setting = raw_input( 'Offset GMT time (in Spain 1 in winter, 2 in summer): ' ) command = "python %stweets_entity.py '%s' '%s' '%s' '--top_size' '10' '--TZ' '%s'" % ( path_scripts, inputfile, path_experiment, path_resources, time_setting) os.system(command) elif option_processing == 'classify': inputfile = get_inputfile( 'Enter input file name with the tweets (got from a query or in real time): ', path_experiment) topicsfile = get_inputfile( 'Enter file name with topics dictionary: ', path_experiment) command = "python %stweets_classify.py '%s' '%s' '%s' " % ( path_scripts, inputfile, topicsfile, path_experiment) os.system(command) elif option_processing == 'users': inputfile = get_inputfile( 'Enter input file name with the tweets (got from a query or in real time): ', path_experiment) command = "python %susers_types.py '%s' '%s' " % ( path_scripts, inputfile, path_experiment) os.system(command) elif option_processing == 'spread': inputfile = get_inputfile( 'Enter input file name with the tweets (got from a query or in real time): ', path_experiment) time_setting = raw_input( 'Offset GMT time (in Spain 1 in winter, 2 in summer): ' ) command = "python %stweets_spread.py '%s' '%s' '--top_size' '1000' '--TZ' '%s' " % ( path_scripts, inputfile, path_experiment, time_setting) os.system(command) elif option == 8: exit = 'y' except KeyboardInterrupt: pass finally: pass
def main(): print "Slinkie IP Debug Host Tool 1.0" print "Copyright (C)2003,2004 Dan Potter" print "" # Initialize readline histfile = os.path.join(os.environ["HOME"], ".slshhist") try: readline.read_history_file(histfile) except IOError: pass # Read the user's config, if it exists global conf conffile = os.path.join(os.environ["HOME"], ".slshrc") conf = Config() conf.load(conffile) # Spawn off a file server thread srv = Net() #thread.start_new_thread(srv.serve, ()) # Create a command processor object cmdproc = CommandProcessor() # Are we auto-connecting? if conf.autoConnect: cmdproc.doConnect("connect") # Our main command loop while 1: # What's our prompt? cmdprompt = cmdproc.getPrompt() # Get a line of input try: s = raw_input("%s> " % cmdprompt) except EOFError: print "" break # Skip blanks if len(string.strip(s)) == 0: continue # Parse out the command piece cmd = string.split(s)[0] if cmd == '?': cmd = "help" cmdname = "do" + string.capitalize(cmd) # Is it a quit request? if cmd == 'quit': break # Try to invoke it if not hasattr(cmdproc, cmdname): print "Unknown command '%s'" % cmd continue cmdfunc = getattr(cmdproc, cmdname) cmdfunc(s) # Write out the history file from readline try: readline.write_history_file(histfile) except IOError: print "Warning: couldn't write history file '%s'" % histfile return 0
def cli( unet, histfile=None, sockpath=None, force_window=False, title=None, prompt=None, background=True, ): logger = logging.getLogger("cli-client") if prompt is None: prompt = "unet> " if force_window or not sys.stdin.isatty(): # Run CLI in another window b/c we have no tty. sock, sockdir, sockpath = cli_server_setup(unet) python_path = unet.get_exec_path(["python3", "python"]) us = os.path.realpath(__file__) cmd = "{} {}".format(python_path, us) if histfile: cmd += " --histfile=" + histfile if title: cmd += " --prompt={}".format(title) cmd += " " + sockpath try: unet.run_in_window(cmd, new_window=True, title=title, background=background) return cli_server(unet, sock) finally: unet.cmd_status("rm -rf " + sockdir) if not unet: logger.debug("client-cli using sockpath %s", sockpath) try: if histfile is None: histfile = os.path.expanduser("~/.micronet-history.txt") if not os.path.exists(histfile): if unet: unet.cmd("touch " + histfile) else: subprocess.run("touch " + histfile) if histfile: readline.read_history_file(histfile) except Exception: pass try: if sockpath: cli_client(sockpath, prompt=prompt) else: local_cli(unet, sys.stdout, prompt=prompt) except EOFError: pass except Exception as ex: logger.critical("cli: got exception: %s", ex, exc_info=True) raise finally: readline.write_history_file(histfile)
def _init(): import atexit import os import sys try: import readline except Exception: readline = None import types import time import uuid import json import pprint import hashlib import subprocess import datetime try: import __builtin__ except ImportError: import builtins as __builtin__ PY2 = sys.version_info[0] == 2 __import__('rlcompleter') histdir = os.path.expanduser('~/.pyhist') try: os.makedirs(histdir) except OSError: pass if PY2: text_type = unicode else: text_type = str def _b(x): if not isinstance(x, bytes): x = x.encode('utf-8') return x histfile = os.path.join( histdir, hashlib.sha1(os.path.normpath(_b(os.path.abspath( sys.prefix)))).hexdigest()) if readline is not None: try: readline.read_history_file(histfile) except IOError: pass if 'libedit' in readline.__doc__: readline.parse_and_bind("bind '\t' rl_complete") else: readline.parse_and_bind("tab: complete") atexit.register(readline.write_history_file, histfile) def _magic_uuid(val=None): if val is None: return uuid.uuid4() elif isinstance(val, uuid.UUID): return val elif len(val) == 16: return uuid.UUID(bytes=val) return uuid.UUID(val) def _dump_json(x, as_string=False, indent=2, cp=False): s = '\n'.join( x.rstrip() for x in json.dumps(x, indent=indent).rstrip().splitlines()) if cp: _copy(s) if as_string: return s print(s) def _cat(path): with open(path, 'rb') as f: return f.read() def _tcat(path): return _cat(path).decode('utf-8') def _paste(): return subprocess.Popen(['pbpaste'], stdout=subprocess.PIPE).communicate()[0] def _tpaste(): return _paste().decode('utf-8') def _jpaste(): return json.loads(_paste()) def _copy(val): if isinstance(val, text_type): val = val.encode('utf-8') return subprocess.Popen(['pbcopy'], stdin=subprocess.PIPE).communicate(val) def _jcopy(val, indent=None): _copy(_dump_json(val, indent=indent, as_string=True)) helpers = types.ModuleType('helpers') helpers.histfile = histfile helpers.pp = pprint.pprint helpers.uuid = _magic_uuid helpers.UUID = uuid.UUID helpers.uuid3 = uuid.uuid3 helpers.uuid4 = uuid.uuid4 helpers.uuid5 = uuid.uuid5 helpers.dt = datetime.datetime helpers.datetime = datetime.datetime helpers.td = datetime.timedelta helpers.timedelta = datetime.timedelta helpers.time = time.time helpers.j = _dump_json helpers.cat = _cat helpers.tcat = _tcat helpers.cp = _copy helpers.jcp = _jcopy helpers.copy = _copy helpers.jcopy = _jcopy helpers.paste = _paste helpers.tpaste = _tpaste helpers.jpaste = _jpaste __builtin__.h = helpers __builtin__.true = True __builtin__.false = False __builtin__.null = None
def init_readline(self): try: readline.read_history_file(".pupy_history") except Exception: pass self.init_completer()
raise getopt.GetoptError("Too many parameters : [%s]" % " ".join(opts[1])) except getopt.GetoptError, msg: log_loading.error(msg) sys.exit(1) if PRESTART_FILE: _read_config_file(PRESTART_FILE) globkeys = init_session(mydict, session_name, STARTUP_FILE) if READLINE: if conf.histfile: try: readline.read_history_file(conf.histfile) except IOError: pass atexit.register(scapy_write_history_file,readline) atexit.register(scapy_delete_temp_files) IPYTHON=False if conf.interactive_shell.lower() == "ipython": try: import IPython IPYTHON=True except ImportError, e: log_loading.warning("IPython not available. Using standard Python shell instead.") IPYTHON=False
def __init__(self, conndata): NicosClient.__init__(self, self.put_error) # connection data as an object self.conndata = conndata # whether to suppress printing history and other info on connection self.quiet_connect = False # various state variables self.in_question = False self.in_editing = False self.tip_shown = False # number of automatic reconnect tries before giving up self.reconnect_count = 0 self.reconnect_time = 0 # current script, line within it and filename of script self.current_script = [''] self.current_line = -1 self.current_filename = '' # pending requests (i.e. scripts) in the daemon self.pending_requests = OrderedDict() # filename of last edited/simulated script self.last_filename = '' # instrument name from NICOS, pre-filled with server name self.instrument = conndata.host.split('.')[0] # script directory from NICOS self.scriptpath = '.' # execution mode of the NICOS session self.current_mode = MASTER # messages queueing up while the editor is running self.message_queue = [] # whether a stop is pending self.stop_pending = False # whether we are in debugging mode self.debug_mode = False # whether we are in spy mode (entering commands disabled) self.spy_mode = False # detected text-mode browser for help display self.browser = None # used for determining how much history to print by default self.tsize = terminalSize() # output stream to print to self.out = sys.stdout # uuid of the last simulation self.simuuid = '' # whether we display timestamps with subsecond precision self.subsec_ts = False # current ETA information self.cur_eta = '' # set up readline for line in DEFAULT_BINDINGS.splitlines(): readline.parse_and_bind(line) readline.set_completer(self.completer) readline.set_history_length(10000) self.histfile = os.environ.get('NICOS_HISTORY_FILE', path.expanduser('~/.nicoshistory')) if path.isfile(self.histfile): readline.read_history_file(self.histfile) self.completions = [] # set up "wakeup" pipe to notify readline of output and changed prompt self.wakeup_pipe_r, self.wakeup_pipe_w = os.pipe() # pre-set prompt to sane default self.set_status('disconnected')