def __init__(self): Cmd.shortcuts.update({'!': 'bang', '$': 'shell'}) Cmd.__init__(self) self.abbrev = True self.prompt = '[] > ' self.explorer = None self.dir_stack = list()
def __init__(self, url_root='http://localhost'): Cmd.__init__(self) self.allow_cli_args = False self._format_url_root(url_root) self.resource = '' self._set_prompt() self.response = None
def __init__(self, logical_device_id, get_stub): Cmd.__init__(self) self.get_stub = get_stub self.logical_device_id = logical_device_id self.prompt = '(' + self.colorize( self.colorize('logical device {}'.format(logical_device_id), 'red'), 'bold') + ') '
def __init__(self): Cmd.__init__(self) try: import readline readline.set_completer_delims(' \t\n"') # initially it was ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?', but I dont want to break on too many except: pass
def __init__(self): """The class initializer""" Cmd.__init__(self, startup_script=config.STARTUP_SCRIPT) self.aliases.update({'exit': 'quit'}) self.hidden_commands.extend( ['load', 'pyscript', 'set', 'shortcuts', 'alias', 'unalias', 'py']) self.current_victim = None self.mqtt_client = None self.current_scan = None self.t = Terminal() self.base_prompt = get_prompt(self) self.prompt = self.base_prompt categorize(( BaseMixin.do_edit, BaseMixin.do_help, BaseMixin.do_history, BaseMixin.do_quit, BaseMixin.do_shell, ), BaseMixin.CMD_CAT_GENERAL)
def __init__(self, file_path): Cmd.__init__(self) self.prompt = 'saam > ' self.shortcuts.remove(('@', 'load')) self.shortcuts.append(('@', 'adb_cmd')) self.shortcuts.remove(('@@', '_relative_load')) self.shortcuts.append(('$', 'adb_shell_cmd')) self.shortcuts.append(('qc', 'quit_and_clean')) self.apk_path = file_path self.apk = APK(self.apk_path) self.apk_out = os.path.basename(file_path) + ".out" self.smali_files = None self.smali_dir = None self.adb = None self.smali_method_descs = [] self.java_files = [] vsmali_action = CmdLineApp.vsmali_parser.add_argument( 'sfile', help='smali file path') setattr(vsmali_action, argparse_completer.ACTION_ARG_CHOICES, ('delimiter_complete', { 'delimiter': '/', 'match_against': self.smali_method_descs })) vjava_action = CmdLineApp.vjava_parser.add_argument( 'jfile', help='java file path') setattr(vjava_action, argparse_completer.ACTION_ARG_CHOICES, ('delimiter_complete', { 'delimiter': '/', 'match_against': self.java_files }))
def __init__(self): Cmd.__init__(self) mixins.bootstrap.BootstrapMixin.__init__(self) self._load_config() if 'url' in self.config and self.config['url']: self._init_stacks() self._validate_auth()
def use_module(self,line): self.active_module = line.split()[1] self.active_payload = self.active_device = None # clear all settables for param_type in self.current_parameters: for x in self.current_parameters[param_type]: Cmd.settable.pop(x) if len(self.modules[self.active_module].payload_actions)>0: self.current_parameters = {"module":["payload"], "device":[], "payload":[]} if "payload" not in Cmd.settable: Cmd.settable.append("payload") #initialize parameters and payload if getattr(self.modules[self.active_module], "payload", None) is None: self.modules[self.active_module].payload="" self.modules[self.active_module].payload_custom=True self.payload = self.modules[self.active_module].payload else: self.current_parameters = {"module":[], "device":[], "payload":[]} for name,p in self.modules[self.active_module].parameters.iteritems(): if "value" not in p: p["value"]=p["default"] setattr(self,name,p["value"]) self.current_parameters["module"].append(name) Cmd.settable.append(name) if not self.modules[self.active_module].payload_custom: self.use_payload("payload "+self.modules[self.active_module].loaded_payload) self.prompt = Cmd().colorize("HID [","green")+ \ Cmd().colorize(self.active_module,"red")+ \ "("+\ ( Cmd().colorize("custom","blue") if self.modules[self.active_module].payload_custom else Cmd().colorize(self.active_payload,"blue"))+\ ")"+ \ (" @ "+Cmd().colorize(self.active_device,"red") if self.active_device!=None else "")+ \ Cmd().colorize("] > ","green")
def __init__(self, device_id, get_stub): Cmd.__init__(self) self.get_stub = get_stub self.device_id = device_id self.prompt = '(' + self.colorize( self.colorize('omci {}'.format(device_id), 'green'), 'bold') + ') '
def __init__(self, verbose=False): Cmd.__init__(self) self.pp = pprint.PrettyPrinter(indent=4) try: self.conn = boto.connect_dynamodb() except Exception as e: self.conn = None print e print "Cannot connect to dynamodb - Check your credentials in ~/.boto or use the 'login' command" # by default readline thinks - and other characters are word delimiters :( if readline: readline.set_completer_delims(re.sub('[-~]', '', readline.get_completer_delims())) path = os.path.join(os.environ.get('HOME', ''), HISTORY_FILE) self.history_file = os.path.abspath(path) else: self.history_file = None self.tables = [] self.table = None self.consistent = False self.consumed = False self.verbose = verbose self.next_key = None self.schema = {} if verbose: self._onchange_verbose(None, verbose)
def __init__(self, *args, **kwargs): self.cutoff = None self.allow_cli_args = False self.titration = kwargs.get('titration') # environment attributes self.name = self.titration.name Cmd.__init__(self) self._set_prompt() # Exclude irrelevant cmds from help menu self.exclude_from_help += [ 'do__relative_load', 'do_cmdenvironment', 'do_edit', 'do_run' ] # Set path completion for save/load self.complete_save_job = self.path_complete self.complete_load_job = self.path_complete self.complete_add_step = self.path_complete self.complete_concentrations = self.path_complete self.complete_make_init = self.path_complete self.complete_init = self.path_complete self.complete_update = self.path_complete self.intro = "\n".join([ "\n\n\tWelcome to Shift2Me !", "{summary}\n{intro}".format(summary=self.titration.summary, intro=self.intro) ])
def __init__(self, persistent_history_file=history_file): # self.settable.update({'row': 'Number of crossbar rows'}) # self.settable.update({'col': 'Number of crossbar columns'}) # self.settable.update({'dev': '1S1R or VTEAM'}) super().__init__() Cmd.__init__(self)
def __init__(self, game): Cmd.__init__(self) self._transcript_files = None self.prompt = ">" self.game = game self.map = game.world.map self.player_loc = game.player_loc
def __init__(self, namefile): Cmd.__init__(self) self.last = [] self.last.append([]) self.prompt = bcolors.PROMPT + "ForPCAP >>> " + bcolors.ENDC self.loadPcap(namefile) self.cmd = ""
def __init__(self): Cmd.__init__(self) # Disable CLI level arguments self.allow_cli_args = False # Enable debug - prints trace in case there is an issue self.debug = True # Remove the unused built-in commands from help self.exclude_from_help.append('do_edit') self.exclude_from_help.append('do_pyscript') self.exclude_from_help.append('do_load') self.exclude_from_help.append('do_py') self.exclude_from_help.append('do_shell') # Normal stuff self.gClient = None self.modelMap= { "wifi-mac": "wifi/mac/openconfig-wifi-mac.yang", "wifi-phy": "wifi/phy/openconfig-wifi-phy.yang", "wifi-system": "wifi/system/openconfig-system-wifi-ext.yang", "vlan": "vlan/openconfig-vlan.yang", "interfaces": "interfaces/openconfig-interfaces.yang", "acl": "acl/openconfig-acl.yang", }
def __init__(self, workspace_path): Cmd.__init__(self) self.prompt = "> " self.intro = "Welcome to TEP solver console" self.tep_workspace = [] # type: TepSolverWorkspace self.open_workspace(workspace_path) self.timing = True
def __init__(self, config, server, sandbox, quiet=False): persistent_history_file = config.get('Shell Parameters', 'persistent_history_file') # Prevents running of commands by abbreviation self.abbrev = False self.debug = True self.help_path = os.path.join(os.path.dirname(__file__), "shell_help/") self.psiturk_header = 'psiTurk command help:' self.super_header = 'basic CMD command help:' self.config = config self.quiet = quiet self.server = server self.sandbox = sandbox self.sandbox_hits = 0 self.live_hits = 0 Cmd.__init__(self, persistent_history_file=persistent_history_file) if not self.amt_services_wrapper: sys.exit() self.maybe_update_hit_tally() if not self.quiet: self.prompt = self.color_prompt() self.intro = self.get_intro_prompt() else: self.intro = ''
def __init__(self, *args, **kwargs): Cmd.__init__(self, *args, **kwargs) self.core = Core() self.t = Terminal() self.last_result = None self.args = None self.noninteractive = None self.config = None self.logdir = '.' self.piddir = '.' self.daemon = None self.running = True self.run_thread = None self.stop_event = threading.Event() self.local_data = threading.local() self.crawl_thread = None self.publish_thread = None self.publish_fb_thread = None self.db_config = None self.engine = None self.session = None self.api = None self.auth = None self.graph = None
def use_device(self, line): if not action_manager.filter_supported_modules( action_manager.device_map[line.split()[1]], {self.active_module: self.modules[self.active_module]} ): various.print_warning("device not supporting selected module") return self.active_device = line.split()[1] # clear settables for x in self.current_parameters["device"]: self.settable.pop(x) self.current_parameters["device"] = [] for name, p in six.iteritems(action_manager.device_map[self.active_device].parameters): if "value" not in p: p["value"] = p["default"] setattr(self, name, p["value"]) self.current_parameters["device"].append(name) self.settable[name] = "" self.prompt = Cmd().colorize("HID [", "green") + \ Cmd().colorize(self.active_module, "red") + \ ("(" + Cmd().colorize(self.active_payload, "blue") + ")" if self.active_payload != None else "") + \ " @ " + \ Cmd().colorize(self.active_device, "red") + \ Cmd().colorize("] > ", "green")
def __init__(self, attempts=5, threads=1, state=None, state_file=None, config_file=None, audit_file=None, max_mem=None, *args, **kwargs): Cmd.__init__(self, *args, **kwargs) self.t = Terminal() self.args = None self.attempts = int(attempts) self.total = None self.terminate = False self.last_users_count = None self.user_lock = Lock() self.processed_user_set = set() self.processed_user_set_lock = Lock() self.orgs_loaded_set = set() self.orgs_loaded_lock = Lock() self.max_mem = max_mem self.state = state self.state_file_path = state_file self.rate_limit_reset = None self.rate_limit_remaining = None self.config = None self.config_file = config_file self.audit_file = audit_file self.audit_records_buffered = [] self.audit_lock = Lock() self.stop_event = threading.Event() self.threads = int(threads) self.link_queue = Queue.PriorityQueue() # Store links to download here self.worker_threads = [] self.state_thread = None self.state_thread_lock = Lock() self.resources_list = [] self.resources_queue = Queue.PriorityQueue() self.local_data = threading.local() self.new_users_events = EvtDequeue() self.new_keys_events = EvtDequeue() self.db_config = None self.engine = None self.session = None self.mem_tracker = None
def do_help(self, arg): """Command to display help info""" self.stdout.write("\n%s Namespace Help\n" % self.namespace) # If we're just in the cmd2 namespace, return its help if (self.namespace == 'cmd2'): Cmd.do_help(arg) return else: # Else, if we're in another namespace, try the following: if arg: # If getting help for a specific command in the namespace, try: # First see if the namespace command exists try: do_func = getattr(self, 'do_' + self.namespace + "_" + arg) except AttributeError: # Namespace function doesn't exist - see if there is a non-namespace / cmd2 command with arg name try: do_func = getattr(self, 'do_' + arg) Cmd.do_help(arg) return except AttributeError: self.stdout.write("[ERROR] Command does not exist in this or top-level namespace: %s\n" % arg) return try: # Next see if there is a help_<namespace>_<command> method is available to call help_func = getattr(self, 'help_' + self.namespace + '_' + arg) help_func() return except AttributeError: # If no help method for the command, get the __doc__ for the method if exists try: doc=getattr(self, 'do_' + self.namespace + '_' + arg).__doc__ if doc: self.stdout.write("%s\n" % str(doc)) return except AttributeError: self.stdout.write("%s\n"%str(self.nohelp % (arg,))) return # Otherwise display generic help else: #names = self.get_names() + self.get_names_addendum names = self.get_names() cmds_doc = [] cmds_undoc = [] cmds_cmd2_namespace = [] for name in names: if name.startswith('do_' + self.namespace): cmd_prefix_length = len(self.namespace)+4 cmd=name[cmd_prefix_length:] if getattr(self, name).__doc__: cmds_doc.append(cmd) else: cmds_undoc.append(cmd) elif name[:3] == 'do_': cmd=name[3:] cmds_cmd2_namespace.append(cmd) self.stdout.write("%s\n" % str(self.doc_leader)) self.print_topics(self.doc_header, cmds_doc, 15,80) self.print_topics(self.undoc_header, cmds_undoc, 15,80) self.print_topics("'cmd2' Namespace Commands", cmds_cmd2_namespace, 15, 80)
def __init__(self, session_obj): Cmd.__init__(self) self.my_session = session_obj self.supported_namespaces = ['poortego', 'cmd2'] self.namespace = 'poortego' self.no_namespace_commands = ['help', 'welcome', 'namespace', 'exit'] self.get_names_addendum = [] # list of additional class methods not returned from python dir() at runtime self.prompt = self.my_session.my_conf.conf_settings['poortego_prompt'] + ' '
def __init__(self, *args, **kwargs): self.user = kwargs.pop("user") self.username = kwargs.pop("username") self.passwd = kwargs.pop("passwd") self.api_auth = HTTPBasicAuth(self.username, self.passwd) self.site = Site.objects.get_current() self.prompt = "Schemanizer(%s)> " % (self.username) Cmd.__init__(self, *args, **kwargs)
def __init__(self, user, pswd, enable_pswd): Cmd.__init__(self) self.controller = DBController() self.runner = TestRunner(self.controller) self.user = user self.pswd = pswd self.enable_pswd = enable_pswd if enable_pswd else pswd self.current_results = {}
def __init__(self): Cmd.__init__(self) logging.basicConfig(filename='/tmp/darkdashboard.log', level=logging.INFO,\ format='%(asctime)s:%(name)s:%(levelname)s:%(message)s') self.logger = logging.getLogger("darkdashboard") self.prompt = 'dark> ' self.rdb = redis_connection() print(self.bold(self.colorize('Welcome to DarkServer Dashboard', 'blue')))
def __init__(self, device_id, get_stub): Cmd.__init__(self) self.get_stub = get_stub self.device_id = device_id self.prompt = '(' + self.colorize( self.colorize('device {}'.format(device_id), 'red'), 'bold') + ') ' self.pm_config_last = None self.pm_config_dirty = False
def __init__(self, parent): Cmd.__init__(self) self.parent = parent self.prompt = self.parent.prompt[:-2] + "find:: " self.machines = [] self.project = "" self.locdata_dirs = [] self.project_dirs = [] self.record = self.parent.record
def __init__(self): Cmd.__init__(self) self.cli_parser = argparse.ArgumentParser() subparsers = self.cli_parser.add_subparsers(help='internal commands') publish_parser = subparsers.add_parser('publish', help='publish') publish_parser.add_argument('--to', dest="to", metavar='PATH', type=str, help='acoustic model directory', required=True)
def __init__(self, **kwargs): Cmd.__init__(self, **kwargs) self.prompt = 'BES> ' #self.do_conf(None) self.BES_ROOT_SERVER = None self.BES_USER_NAME = None self.BES_PASSWORD = None self.bes_conn = None
def __init__(self): # Enable the optional ipy command if IPython is installed by setting use_ipython=True Cmd.__init__(self, use_ipython=True) self._set_prompt() self.autorun_on_edit = False self.intro = 'Happy 𝛑 Day. Note the full Unicode support: 😇 (Python 3 only) 💩' # For option commands, pass a list of argument strings instead of a single argument string to the do_* methods set_use_arg_list(True)
def __init__(self, app: ShowtimeApp, dry_run=False) -> None: """Inits Showtime""" config = app.config_get() Cmd.__init__( self, persistent_history_file=config.get('History', 'Path')) self.app = app self.dry_run = dry_run self.output = Output(self.poutput, self.perror, self.pfeedback, self.ppaged) self.prompt = self._get_prompt('')
def __init__(self): Cmd.__init__(self) logging.basicConfig(filename='/tmp/darkdashboard.log', level=logging.INFO,\ format='%(asctime)s:%(name)s:%(levelname)s:%(message)s') self.logger = logging.getLogger("darkdashboard") self.prompt = 'dark> ' self.rdb = redis_connection() print( self.bold(self.colorize('Welcome to DarkServer Dashboard', 'blue')))
def __init__(self, session_obj): Cmd.__init__(self) self.my_session = session_obj self.supported_namespaces = ['poortego', 'cmd2'] self.namespace = 'poortego' self.no_namespace_commands = ['help', 'welcome', 'namespace', 'exit'] self.get_names_addendum = [ ] # list of additional class methods not returned from python dir() at runtime self.prompt = self.my_session.my_conf.conf_settings[ 'poortego_prompt'] + ' '
def __init__(self): self.multilineCommands = ['orate'] self.maxrepeats = 3 # Add stuff to settable and shortcuts before calling base class initializer self.settable['maxrepeats'] = 'max repetitions for speak command' self.shortcuts.update({'&': 'speak'}) # Set use_ipython to True to enable the "ipy" command which embeds and interactive IPython shell Cmd.__init__(self, use_ipython=False)
def __init__(self, data_store, spec): Cmd.__init__(self) self.data_store = data_store self.spec = spec self.print_header() self.similar_specs = data_store.find_similar(spec) print print self.colorize("Similar specs", 'green') self.do_print('similar_specs')
def __init__(self): Cmd.__init__(self) self.bin_loaded = False self.bin_running = False self.arm_dbg = None if DEBUG_MODE: import ipdb; ipdb.set_trace()
def __init__(self, log=None, ygg_browser=None, **kwargs): Cmd.__init__(self, **kwargs) self.log = log or yggscr.ylogging.init_default_logger() self.intro = "Welcome to Ygg Shell. Type help or ? to list commands.\n" self.prompt = "> " self.allow_redirection = False if ygg_browser is not None: self.ygg_browser = ygg_browser else: self.ygg_browser = yggscr.ygg.YggBrowser(self.log)
def __init__(self, files, apk): Binja.__init__(self) self.t = Terminal() self.logger = Logger() self.files = files self.apk = apk self.libs = list() self.rpc = None self.target_library = None self._init_binja()
def set(self, app: Cmd): """ Adds settings to cmd2 application""" #make sure there is not a setting collision if hasattr(app, 'special_setting'): raise SettingCollisionError app.special_setting = 33 app.add_settable(Settable('special_setting', int, 'Special Setting'))
def __init__(self): package = kolala.actions for loader, name, is_pkg in pkgutil.walk_packages(package.__path__): module = loader.find_module(name).load_module(name) if getattr(module, 'main', None) is not None: setattr(self, 'do_' + name, module.main) if getattr(module, 'help', None) is not None: setattr(self, 'help_' + name, module.help) Cmd.__init__(self)
def cmdloop(self): try: Cmd.cmdloop(self) except KeyboardInterrupt as e: self.__key_interrupt = self.__key_interrupt + 1 if self.__key_interrupt > 1: print('^C') self.do_exit(self) else: print('Press Ctrl-C again to exit.') self.cmdloop()
def __init__(self, silent, user, passwd): self.base_cmds = ['exec', 'help', 'history','manual', 'quit', 'use', 'contexts', 'script'] base_cmd2 = ['li', 'load', 'pause', 'py', 'run', 'save', 'shortcuts', 'set', 'show', 'historysession'] self.base_cmds += base_cmd2 self._locals = {} self._globals = {} self.user = user self.passwd = "" self.passwdtype = "ldappass" userCred = FGCredential(self.passwdtype,passwd) if not self.check_simpleauth(userCred): sys.exit() #Load Config self._conf = fgShellConf() #Setup log self._log = fgLog(self._conf.getLogFile(), self._conf.getLogLevel(), "FGShell", False) self._log.debug("\nReading Configuration file from " + self._conf.getConfigFile() + "\n") Cmd.__init__(self) fgShellUtils.__init__(self) #Context self.env = ["repo", "hadoop", "image", "rain", ""] self.text = {'image': 'Image Management', 'repo':'Image Repository', 'rain':'FG Dynamic Provisioning', 'hadoop':'Apache Hadoop'} self._use = "" self._requirements = [] self._contextOn = [] # initialized contexts #Help self._docHelp = [] self._undocHelp = [] self._specdocHelp = [] self.getDocUndoc("") self.prompt = "fg> " self.silent = silent if self.silent: self.intro = "" else: self.intro = self.loadBanner() ##Load History self.loadhist("no argument needed")
def __init__(self, port, debug): Cmd.__init__(self) if readline: path = os.path.join(os.environ.get('HOME', ''), HISTORY_FILE) self.history_file = os.path.abspath(path) else: self.history_file = None self.debug = debug self.port = port self.init_search()
def __init__(self, voltha_grpc, voltha_sim_rest, global_request=False): VolthaCli.voltha_grpc = voltha_grpc VolthaCli.voltha_sim_rest = voltha_sim_rest VolthaCli.global_request = global_request Cmd.__init__(self) self.prompt = '(' + self.colorize( self.colorize(self.prompt, 'blue'), 'bold') + ') ' self.channel = None self.stub = None self.device_ids_cache = None self.device_ids_cache_ts = time() self.logical_device_ids_cache = None self.logical_device_ids_cache_ts = time()
def __init__(self): self.multilineCommands = ['orate'] self.maxrepeats = 3 # Add stuff to settable and shortcutgs before calling base class initializer self.settable['maxrepeats'] = 'max repetitions for speak command' self.shortcuts.update({'&': 'speak'}) # Set use_ipython to True to enable the "ipy" command which embeds and interactive IPython shell Cmd.__init__(self, use_ipython=False) # For option commands, pass a single argument string instead of a list of argument strings to the do_* methods set_use_arg_list(False)
def do_show(self, line): """show <subject> Show details on various subject types""" if not line: # hacky-hack to display settable values # called from cmd2's do_set() with no args Cmd.do_show(self, line) else: # Find all SHOW subjects if not self.show_command: self.show_command = PrimaryCommand(show_cmd) args = line.split() self.show_command._subjects[args[0]](args)
def __init__(self, config_path="config/config.yaml"): self.config_path = config_path conf = Confiture("config/templates/general.yaml") # Parse configuration file and get result self.config = conf.check_and_get(config_path) # Before we checked the config, it is considered KO self.config_ok = False # Set the log directory self.log_dir = self.config["log"]["path"] # Available pintools self.__pintools = dict() for pintool in self.config["pintool"]: # Check the needed two arguments req = ["src", "obj"] for r in req: if r not in self.config["pintool"][pintool].keys(): #TODO raise Exception src = self.config["pintool"][pintool]["src"] obj = self.config["pintool"][pintool]["obj"] # Check potential extra argument if "prev_step" in self.config["pintool"][pintool].keys(): prev_step = self.config["pintool"][pintool]["prev_step"] else: prev_step = None # Create pintool object pintool_obj = Pintool( name=pintool, src_path=src, obj_path=obj, pinconf=self.config["pin"], stdout=self.out, stderr=self.out, log_dir=self.log_dir, prev_step=prev_step, ) self.__pintools[pintool] = pintool_obj # Create a test object # Testing options kwargs = dict() kwargs["log"] = self.out if "test" in self.config.keys() and "proto" in self.config["test"]: kwargs["proto"] = self.config["test"]["proto"] self.test = ScatTest(**kwargs) # Init shell Cmd.__init__(self, completekey='tab')
def precmd(self, line): self.api.set_position( self.location['latitude'], self.location['longitude'], self.location['altitude'] ) return Cmd.precmd(self, line)
def __init__(self, *args, **kwargs): Cmd.__init__(self, *args, **kwargs) self.intro = '''\ \n ----\n Welcome to the NXOS type shell for tac-pac. \ \n ----\n''' self.file = '/tmp/nxos_shell' # build time lists self.all_module_cmds = [[] for i in xrange(20)] self.offset_tuple_list = [[] for i in xrange(20)] self.module_s_list = [] self.module_e_list = [] #run time locals self.local_mod = [] self.s=[] self.cmd_dict = {} self.attach_mod_dict = {}
def onecmd(self, s): try: return Cmd.onecmd(self, s) except NotImplementedError as e: print(e.message) except: traceback.print_exc() return False
def cmdloop(self): while True: stop = Cmd._cmdloop(self) if not stop: self.intro = '' self.color_prompt() print "^C" else: break
def __init__(self, ROOT_DIR): Lobotomy.__init__(self) self.ROOT_DIR = ROOT_DIR self.t = Terminal() self.logger = Logger() self.util = Util() self.apk = None self.package = None self.vm = None self.vmx = None self.gmx = None self.components = None self.dex = None self.strings = None self.permissions = None self.permissions_details = None self.files = None self.attack_surface = None
def parseline(self, line): ''' Overrride the parse line, allowing the implementation of plugins to receive piped valus ''' if '|' in line: self._out('piped', line) return Cmd.parseline(self, line)
def preloop(self, *args): ''' Add the context object to the command line scope ''' _plugins.create(self) self.create_root(*args) self.set_prompt(self._cwd()) return Cmd.preloop(self, *args)
def __init__(self, config, server, quiet=False): Cmd.__init__(self) self.config = config self.server = server # Prevents running of commands by abbreviation self.abbrev = False self.debug = True self.help_path = os.path.join(os.path.dirname(__file__), "shell_help/") self.psiturk_header = 'psiTurk command help:' self.super_header = 'basic CMD command help:' if not self.quiet: self.color_prompt() self.intro = self.get_intro_prompt() else: self.intro = '' self.already_prelooped = False