Python Shell.IPShellEmbed类代码示例

 def __init__(self, kwargs):
     argv = [
              '-prompt_in1','\C_Blue\#) \C_Greenrestcli\$ ',
            ]
     IPShellEmbed.__init__(self,argv,banner='restkit shell %s' % __version__,
                           exit_msg=None,rc_override=None,
                           user_ns=kwargs)

    def __call__(self, context, args):
        # hijacked from pylons
        locs = {'ctx': context}
        banner_header = 'Melkman Interactive Shell\n'
        banner_footer = '\n\nYou may access the current context as "ctx"'
        try:
            # try to use IPython if possible
            from IPython.Shell import IPShellEmbed
            shell = IPShellEmbed(argv=sys.argv)
            banner = banner_header + shell.IP.BANNER + banner_footer
            shell.set_banner(banner)
            shell(local_ns=locs, global_ns={})
        except ImportError:
            import code
            pyver = 'Python %s' % sys.version
            banner = banner_header +  pyver + banner_footer

            shell = code.InteractiveConsole(locals=locs)
            try:
                import readline
            except ImportError:
                pass
            try:
                shell.interact(banner)
            finally:
                pass

 def run(self, args):
     banner = None
     if not sys.stdin.isatty() or args.files:
         opts = [
             '-noautoindent',
             '-nobanner',
             '-colors', 'NoColor',
             '-noconfirm_exit',
             '-nomessages',
             '-nosep',
             '-prompt_in1', '\x00',
             '-prompt_in2', '\x00',
             '-prompt_out', '\x00',
             '-xmode', 'Plain',
         ]
     else:
         opts = [
             '-prompt_in1', 'clusto [\#]> ',
             '-prompt_out', 'out [\#]> ',
         ]
         banner = '\nThis is the clusto shell. Respect it.'
     if args.loglevel == 'DEBUG':
         opts.append('-debug')
     ipshell = IPShellEmbed(opts)
     if banner:
         ipshell.set_banner(banner)
     ipshell()

    def run(self, args):
        banner = None
        if IPython.__version__ >= '0.11':
            config=IPython.config.application.Config()
        if not sys.stdin.isatty() or args.files:
            opts = [
                '-noautoindent',
                '-nobanner',
                '-colors', 'NoColor',
                '-noconfirm_exit',
                '-nomessages',
                '-nosep',
                '-prompt_in1', '\x00',
                '-prompt_in2', '\x00',
                '-prompt_out', '\x00',
                '-xmode', 'Plain',
            ]
            if IPython.__version__ >= '0.11':
                config.TerminalInteractiveShell.autoindent = False
                config.TerminalIPythonApp.display_banner = False
                config.TerminalInteractiveShell.color_info = False
                config.TerminalInteractiveShell.confirm_exit = False
                config.TerminalInteractiveShell.quiet = True
                config.TerminalIPythonApp.ignore_old_config = True
                config.TerminalInteractiveShell.separate_in = ''
                config.PromptManager.in_template = '\x00'
                config.PromptManager.in_template1 = '\x00'
                config.PromptManager.in_template2 = '\x00'
                config.PromptManager.out_template = '\x00'
                config.TerminalInteractiveShell.xmode = 'Plain'
        else:
            opts = [
                '-prompt_in1', 'clusto [\#]> ',
                '-prompt_out', 'out [\#]> ',
            ]
            banner = '\nThis is the clusto shell. Respect it.'
            if IPython.__version__ >= '0.11':
                config.PromptManager.in_template = 'clusto [\#]> '
                config.PromptManager.out_template = 'out [\#]> '
        if args.loglevel == 'DEBUG':
            opts.append('-debug')
            config.debug = True

        plugins = script_helper.load_plugins(self.config)
        plugins.update(globals())
        if IPython.__version__ < '0.11':
            from IPython.Shell import IPShellEmbed
            ipshell = IPShellEmbed(opts, user_ns=plugins)
            if banner:
                ipshell.set_banner(banner)
        elif IPython.__version__ < '1.0':
            from IPython.frontend.terminal import embed
            ipshell = embed.InteractiveShellEmbed(banner1=banner,
                config=config, user_ns=plugins)
        else:
            from IPython.terminal import embed
            ipshell = embed.InteractiveShellEmbed(banner1=banner,
                config=config, user_ns=plugins)
        ipshell()

 def ipython(self, locs, banner):
     try:
         from IPython import embed
         embed(user_ns=locs, banner2=banner)
     except ImportError:
         from IPython.Shell import IPShellEmbed
         shell = IPShellEmbed(argv=[])
         shell.set_banner(shell.IP.BANNER + '\n\n' + banner)
         shell(local_ns=locs, global_ns={})

def main():
    clear()
    banner = '+----------------------------------------------------+\n'
    banner += ' SimpleCV [interactive shell]\n'
    banner += '+----------------------------------------------------+\n'
    banner += '\n'
    banner += 'Commands: \n'
    banner += '\t"exit()" or press "Ctrl+ D" to exit the shell\n'
    banner += '\t"clear" to clear the shell screen\n'
    banner += '\t"tutorial" to begin the SimpleCV interactive tutorial\n'
    banner += '\t"cheatsheet" gives a cheatsheet of all the shell functions\n' 
    banner += '\t"simplehelp" gives list of commands or help on a certain command\n'
    banner += '\t"example" gives a list of examples you can run'
    banner += '\n'
    banner += 'Usage:\n'
    banner += '\tdot complete works to show library\n'
    banner += '\tfor example: Image().save("/tmp/test.jpg") will dot complete\n'
    banner += '\tjust by touching TAB after typing Image().\n'
    banner += '\n'
    banner += 'API Documentation:\n'
    banner += '\t"help function_name" will give in depth documentation of API\n'
    banner += '\t\texample:'
    banner += 'help Image or ?Image\n'
    banner += '\t\twill give the in-depth information about that class\n'
    banner += '\t"?function_name" will give the quick API documentation\n'
    banner += '\t\texample:'
    banner += '?Image.save\n'
    banner += '\t\twill give help on the image save function'

    

    
    exit_msg = '\nExiting the SimpleCV interactive shell\n'
    

    #setup terminal to show SCV prompt
    argsv = ['-pi1','SimpleCV:\\#>','-pi2','   .\\D.:','-po','SimpleCV:\\#>','-nosep']

    scvShell = IPShellEmbed(argsv)
    scvShell.set_banner(banner)
    scvShell.set_exit_msg(exit_msg)
    scvShell.IP.api.expose_magic("tutorial",magic_tutorial)
    scvShell.IP.api.expose_magic("clear", magic_clear)
    scvShell.IP.api.expose_magic("simplehelp", magic_help)
    scvShell.IP.api.expose_magic("cheatsheet", magic_cheatsheet)
    scvShell.IP.api.expose_magic("example", magic_examples)
    

    #Note that all loaded libraries are inherited in the embedded ipython shell
    sys.exit(scvShell())

    def __call__(self):
        class ShellCommands:
            pass

        cmds = ShellCommands()
        ShellCommands.__doc__ = "Commands:"
        for Command in sorted(plugins.get(COMMANDLINE_PLUGIN), key=attrgetter('command_name')):
            # help is skipped because it relates to the command line option
            # info for the commands.  The built-in python help should be 
            # used in the shell.
            if (not hasattr(Command, '__call__') or 
                Command == HelpCommand or 
                isinstance(self, Command)):
                continue
            
            shell_cmd = Command(self.config).__call__
            shell_cmd.__func__.__name__ = Command.command_name
            setattr(cmds, Command.command_name, shell_cmd)
            ShellCommands.__doc__ += "\n  "
            ShellCommands.__doc__ += Command.command_name.ljust(20)
            ShellCommands.__doc__ += Command.description
        ShellCommands.__doc__ += "\n\nType: help(cmds.<function>) for more info"
        
        locs = {'config': self.config, 'cmds': cmds }
        banner_header = 'RadarPost Interactive Shell\n'
        banner_footer = '\n\nYou may access the current config as "config"'
        banner_footer += '\nCLI commands are available as "cmds.<command>"'
        banner_footer += '\nType: help(cmds) for more info'
        try:
            # try to use IPython if possible
            from IPython.Shell import IPShellEmbed
            shell = IPShellEmbed(argv=sys.argv)
            banner = banner_header + shell.IP.BANNER + banner_footer
            shell.set_banner(banner)
            shell(local_ns=locs, global_ns={})
        except ImportError:
            import code
            pyver = 'Python %s' % sys.version
            banner = banner_header +  pyver + banner_footer

            shell = code.InteractiveConsole(locals=locs)
            try:
                import readline
            except ImportError:
                pass
            try:
                shell.interact(banner)
            finally:
                pass

 def command(self):
     
     # load the application
     config = self.load_configuration(self.args[0])
     setattr(config.app, 'reload', False)
     app = self.load_app(config)
     
     # prepare the locals
     locs = dict(__name__='pecan-admin')
     locs['wsgiapp'] = app
     locs['app'] = TestApp(app)
     
     # find the model for the app
     model = self.load_model(config)
     if model:
         locs['model'] = model
     
     # insert the pecan locals
     exec('from pecan import abort, conf, redirect, request, response') in locs
     
     # prepare the banner
     banner = '  The following objects are available:\n'
     banner += '  %-10s - This project\'s WSGI App instance\n' % 'wsgiapp'
     banner += '  %-10s - The current configuration\n' % 'conf'
     banner += '  %-10s - webtest.TestApp wrapped around wsgiapp\n' % 'app'
     if model:
         model_name = getattr(model, '__module__', getattr(model, '__name__', 'model'))
         banner += '  %-10s - Models from %s\n' % ('model', model_name)
     
     # launch the shell, using IPython if available
     try:
         from IPython.Shell import IPShellEmbed
         shell = IPShellEmbed(argv=self.args)
         shell.set_banner(shell.IP.BANNER + '\n\n' + banner)
         shell(local_ns=locs, global_ns={})
     except ImportError:
         import code
         py_prefix = sys.platform.startswith('java') and 'J' or 'P'
         shell_banner = 'Pecan Interactive Shell\n%sython %s\n\n' % \
             (py_prefix, sys.version)
         shell = code.InteractiveConsole(locals=locs)
         try:
             import readline
         except ImportError:
             pass
         shell.interact(shell_banner + banner)

    def do_shell(self, backend_name):
        """
        shell BACKEND

        Debug a backend.
        """
        try:
            backend = self.weboob.load_backends(names=[backend_name])[backend_name]
        except KeyError:
            print >>sys.stderr, u'Unable to load backend "%s"' % backend_name
            return 1
        browser = backend.browser
        from IPython.Shell import IPShellEmbed
        shell = IPShellEmbed(argv=[])
        locs = dict(backend=backend, browser=browser, application=self, weboob=self.weboob)
        banner = 'Weboob debug shell\nBackend "%s" loaded.\nAvailable variables: %s' % (backend_name, locs)
        shell.set_banner(shell.IP.BANNER + '\n\n' + banner)
        shell(local_ns=locs, global_ns={})

def setup_shell():  
    banner = '+----------------------------------------------------+\n'
    banner += ' SimpleCV [interactive shell] - http://simplecv.org\n'
    banner += '+----------------------------------------------------+\n'
    banner += '\n'
    banner += 'Commands: \n'
    banner += '\t"exit()" or press "Ctrl+ D" to exit the shell\n'
    banner += '\t"clear" to clear the shell screen\n'
    banner += '\t"tutorial" to begin the SimpleCV interactive tutorial\n'
    banner += '\t"cheatsheet" gives a cheatsheet of all the shell functions\n' 
    banner += '\t"example" gives a list of examples you can run'
    banner += '\n'
    banner += 'Usage:\n'
    banner += '\tdot complete works to show library\n'
    banner += '\tfor example: Image().save("/tmp/test.jpg") will dot complete\n'
    banner += '\tjust by touching TAB after typing Image().\n'
    banner += 'API Documentation:\n'
    banner += '\t"help function_name" will give in depth documentation of API\n'
    banner += '\texample: help Image\n'
    banner += 'Editor:\n'
    banner += '\t"editor" will run the SimpleCV code editor in a browser\n'
    banner += '\t\texample:'
    banner += 'help Image or ?Image\n'
    banner += '\t\twill give the in-depth information about that class\n'
    banner += '\t"?function_name" will give the quick API documentation\n'
    banner += '\t\texample:'
    banner += '?Image.save\n'
    banner += '\t\twill give help on the image save function'
    exit_msg = '\nExiting the SimpleCV interactive shell\n'
    

    #setup terminal to show SCV prompt
    argsv = ['-pi1','SimpleCV:\\#>','-pi2','   .\\D.:','-po','SimpleCV:\\#>','-nosep']

    scvShell = IPShellEmbed(argsv)
    scvShell.set_banner(banner)
    scvShell.set_exit_msg(exit_msg)
    scvShell.IP.api.expose_magic("tutorial",magic_tutorial)
    scvShell.IP.api.expose_magic("clear", magic_clear)
    scvShell.IP.api.expose_magic("cheatsheet", magic_cheatsheet)
    scvShell.IP.api.expose_magic("example", magic_examples)
    scvShell.IP.api.expose_magic("editor", magic_editor)
    
    return scvShell

def main():
    
    options, args, proxy = default_main() # pylint: disable=W0612
    ipshell = IPShellEmbed()
    ipshell.set_banner("""

Launching IPython shell...

Available variables:
 - proxy: the ArduinoProxy instance.
 - options, args: parsed argument options.

To import ArduinoProxy class:
>>> from arduino_proxy import ArduinoProxy

Enter 'quit()' to exit.
 
    """)
    ipshell()

import sys
from IPython.Shell import IPShellEmbed
from evnet import pyevThread
from pwrcall import Node, expose, loop, unloop
from pwrcall.util import NodeException, parse_url

CERT = 'clientside.pem'
t = pyevThread()
t.start()
n = Node(cert=CERT)
ipshell = IPShellEmbed()

def establish(pwrurl):
	return t.blockingCall(n.establish, pwrurl)

def pwrcall(obj, fn, *args):
	return t.blockingCall(obj.call, fn, *args)	

if __name__ == '__main__':
	ipshell.set_banner(
'''pwrcall Interactive Shell
-------------------------
starts up a evnet loop and pwrcall Node
use the Node through the t.blockingCall function''')
	ipshell.set_exit_msg('Exit.')
	ipshell()
	sys.exit(0)

    def command(self):
        """Main command to create a new shell"""
        self.verbose = 3
        if len(self.args) == 0:
            # Assume the .ini file is ./development.ini
            config_file = 'development.ini'
            if not os.path.isfile(config_file):
                raise BadCommand('%sError: CONFIG_FILE not found at: .%s%s\n'
                                 'Please specify a CONFIG_FILE' % \
                                 (self.parser.get_usage(), os.path.sep,
                                  config_file))
        else:
            config_file = self.args[0]

        config_name = 'config:%s' % config_file
        here_dir = os.getcwd()

        if not self.options.quiet:
            # Configure logging from the config file
            self.logging_file_config(config_file)

        conf = appconfig(config_name, relative_to=here_dir)
        conf.update(dict(app_conf=conf.local_conf, global_conf=conf.global_conf))
        paste.deploy.config.CONFIG.push_thread_config(conf)

        # Load locals and populate with objects for use in shell
        sys.path.insert(0, here_dir)

        # Load the wsgi app first so that everything is initialized right
        wsgiapp = loadapp(config_name, relative_to=here_dir)
        test_app = paste.fixture.TestApp(wsgiapp)

        # Query the test app to setup the environment
        tresponse = test_app.get('/_test_vars')
        request_id = int(tresponse.body)

        # Disable restoration during test_app requests
        test_app.pre_request_hook = lambda self: paste.registry.restorer.restoration_end()
        test_app.post_request_hook = lambda self: paste.registry.restorer.restoration_begin(request_id)

        paste.registry.restorer.restoration_begin(request_id)

        locs = dict(__name__="webcore-admin", application=wsgiapp, test=test_app)

        exec 'import web' in locs
        exec 'from web.core import http, Controller, request, response, cache, session' in locs

        if len(self.args) == 2:
            execfile(self.args[1], {}, locs)
            return

        banner = "Welcome to the WebCore shell."

        try:
            if self.options.disable_ipython:
                raise ImportError()

            # try to use IPython if possible
            from IPython.Shell import IPShellEmbed

            shell = IPShellEmbed(argv=self.args)
            shell.set_banner(shell.IP.BANNER + '\n\n' + banner)

            try:
                shell(local_ns=locs, global_ns={})
            finally:
                paste.registry.restorer.restoration_end()
        except ImportError:
            import code
            py_prefix = sys.platform.startswith('java') and 'J' or 'P'
            newbanner = "WebCore Interactive Shell\n%sython %s\n\n" % (py_prefix, sys.version)
            banner = newbanner + banner
            shell = code.InteractiveConsole(locals=locs)

            try:
                import readline
            except ImportError:
                pass

            try:
                shell.interact(banner)
            finally:
                paste.registry.restorer.restoration_end()

#.........这里部分代码省略.........
        conf.update(dict(app_conf=conf.local_conf,
                         global_conf=conf.global_conf))
        paste.deploy.config.CONFIG.push_thread_config(conf)

        # Load locals and populate with objects for use in shell
        sys.path.insert(0, here_dir)

        # Load the wsgi app first so that everything is initialized right
        wsgiapp = loadapp(config_name, relative_to=here_dir)
        test_app = paste.fixture.TestApp(wsgiapp)

        # Query the test app to setup the environment
        tresponse = test_app.get('/_test_vars')
        request_id = int(tresponse.body)

        # Disable restoration during test_app requests
        test_app.pre_request_hook = lambda self: \
            paste.registry.restorer.restoration_end()
        test_app.post_request_hook = lambda self: \
            paste.registry.restorer.restoration_begin(request_id)

        # Restore the state of the Pylons special objects
        # (StackedObjectProxies)
        paste.registry.restorer.restoration_begin(request_id)

        # Determine the package name from the .egg-info top_level.txt.
        egg_info = find_egg_info_dir(here_dir)
        f = open(os.path.join(egg_info, 'top_level.txt'))
        packages = [l.strip() for l in f.readlines()
                    if l.strip() and not l.strip().startswith('#')]
        f.close()

        # Start the rest of our imports now that the app is loaded
        found_base = False
        for pkg_name in packages:
            # Import all objects from the base module
            base_module = pkg_name + '.lib.base'
            found_base = can_import(base_module)
            if not found_base:
                # Minimal template
                base_module = pkg_name + '.controllers'
                found_base = can_import(base_module)

            if found_base:
                break

        if not found_base:
            raise ImportError("Could not import base module. Are you sure "
                              "this is a Pylons app?")

        base = sys.modules[base_module]
        base_public = [__name for __name in dir(base) if not \
                       __name.startswith('_') or __name == '_']
        for name in base_public:
            locs[name] = getattr(base, name)
        locs.update(dict(wsgiapp=wsgiapp, app=test_app))

        mapper = tresponse.config.get('routes.map')
        if mapper:
            locs['mapper'] = mapper

        banner = "  All objects from %s are available\n" % base_module
        banner += "  Additional Objects:\n"
        if mapper:
            banner += "  %-10s -  %s\n" % ('mapper', 'Routes mapper object')
        banner += "  %-10s -  %s\n" % ('wsgiapp',
            "This project's WSGI App instance")
        banner += "  %-10s -  %s\n" % ('app',
            'paste.fixture wrapped around wsgiapp')

        if not self.options.quiet:
            # Configure logging from the config file
            self.logging_file_config(config_file)
        
        try:
            if self.options.disable_ipython:
                raise ImportError()

            # try to use IPython if possible
            from IPython.Shell import IPShellEmbed

            shell = IPShellEmbed(argv=self.args)
            shell.set_banner(shell.IP.BANNER + '\n\n' + banner)
            try:
                shell(local_ns=locs, global_ns={})
            finally:
                paste.registry.restorer.restoration_end()
        except ImportError:
            import code
            newbanner = "Pylons Interactive Shell\nPython %s\n\n" % sys.version
            banner = newbanner + banner
            shell = code.InteractiveConsole(locals=locs)
            try:
                import readline
            except ImportError:
                pass
            try:
                shell.interact(banner)
            finally:
                paste.registry.restorer.restoration_end()

        argv = ['-pi1','In <\\#>:','-pi2','   .\\D.:','-po','Out<\\#>:']
        banner = '*** Starting Interactive Shell - Ctrl-D to exit...\n\nnapi is your NexposeAPI variable to play with\n'

        if IPython.__version__ >= "0.11":
            from IPython.config.loader import Config
            cfg = Config()
            cfg.InteractiveShellEmbed.prompt_in1="myprompt [\\#]> "
            cfg.InteractiveShellEmbed.prompt_out="myprompt [\\#]: "
            #cfg.InteractiveShellEmbed.profile=ipythonprofile
            # directly open the shell
            IPython.embed(config=cfg, banner2=banner)
        else:
            try:
                from IPython.Shell import IPShellEmbed
                argv = ['-pi1','In <\\#>:','-pi2','   .\\D.:','-po','Out<\\#>:']
                ipshell = IPShellEmbed(argv,banner='*** Starting Interactive Shell - Ctrl-D to exit...\n\nnapi is your NexposeAPI variable to play with\n')
                ipshell.set_exit_msg('Buh-bye!')
                ipshell()
            except ImportError, e:
                sys.exit("IPython not installed, won't continue...")

    if options.listvulns:
        vuln_class = VulnData(napi.sessionid)
        vuln_class.populate_summary()
        if (vuln_class.vulnerabilities) > 0:
            if options.listvulns.upper() == "CSV":
                print vuln_class.csvout()
            else:
                print vuln_class.vulnxml
        else:
            print "Error: No Vulnerabilities loaded, check your Nexpose server address or user/pass"