예제 #1
0
 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)
예제 #2
0
파일: runner.py 프로젝트: jab/melkman
    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
예제 #3
0
 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)
예제 #4
0
파일: cli.py 프로젝트: sringe/catmap-1
def sh(banner):
    """Wrapper around interactive ipython shell
    that factors out ipython version depencies.

    """

    from distutils.version import LooseVersion
    import IPython
    if hasattr(IPython, 'release'):
        try:
            from IPython.terminal.embed import InteractiveShellEmbed
            InteractiveShellEmbed(banner1=banner)()

        except ImportError:
            try:
                from IPython.frontend.terminal.embed \
                    import InteractiveShellEmbed
                InteractiveShellEmbed(banner1=banner)()

            except ImportError:
                from IPython.Shell import IPShellEmbed
                IPShellEmbed(banner=banner)()
    else:
        from IPython.Shell import IPShellEmbed
        IPShellEmbed(banner=banner)()
예제 #5
0
파일: shell.py 프로젝트: BillTheBest/clusto
 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()
예제 #6
0
        def __init__(self, *args, **kwargs):
            
            IPShellEmbed.__init__(self, *args, **kwargs)
            
            # now self.IP exisits

            
            old_interact = self.IP.interact # save the real method
            
            def new_interact(self, *args):
                """ wrapper method which checks the user namespace
                """
                
                self.IP.user_ns.update({'_ips_exit':False})

                old_interact(*args) # call the real interact method
                
                # now look if the user wants to stop
                if self.IP.user_ns['_ips_exit']:
                    def do_nothing(*args, **kwargs):
                        pass
                    
                    # harakiri
                    # the calling method replaces itself with a the dummy
                    self.IP.interact = do_nothing 
                
                
            # replace the original interact method with the wrapper 
            self.IP.interact = new.instancemethod(new_interact, self,
                                                                  type(self))
예제 #7
0
        def __init__(self, *args, **kwargs):

            IPShellEmbed.__init__(self, *args, **kwargs)

            # now self.IP exisits

            old_interact = self.IP.interact  # save the real method

            def new_interact(self, *args):
                """ wrapper method which checks the user namespace
                """

                self.IP.user_ns.update({'_ips_exit': False})

                old_interact(*args)  # call the real interact method

                # now look if the user wants to stop
                if self.IP.user_ns['_ips_exit']:

                    def do_nothing(*args, **kwargs):
                        pass

                    # harakiri
                    # the calling method replaces itself with a the dummy
                    self.IP.interact = do_nothing

            # replace the original interact method with the wrapper
            self.IP.interact = new.instancemethod(new_interact, self,
                                                  type(self))
예제 #8
0
    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()
예제 #9
0
파일: shell.py 프로젝트: antonwinter/clusto
    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()
예제 #10
0
 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={})
예제 #11
0
 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={})
예제 #12
0
 def __init__(self, section=''):
     argv = [
         '-prompt_in1',
         '\C_Blue\#) \C_Greenldap/%s\$ ' % section,
     ]
     IPShellEmbed.__init__(self,
                           argv,
                           banner='',
                           exit_msg=None,
                           rc_override=None,
                           user_ns=None)
예제 #13
0
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())
예제 #14
0
파일: basic.py 프로젝트: ltucker/radarpost
    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 ipython(self, locals=None):
        """Provides an interactive shell aka console inside your testcase.
        Uses ipython for on steroids shell...

        It looks exact like in a doctestcase and you can copy and paste
        code from the shell into your doctest. The locals in the testcase are
        available, becasue you are in the testcase.

        In your testcase or doctest you can invoke the shell at any point by
        calling::

            >>> self.ipython( locals() )

        locals -- passed to InteractiveInterpreter.__init__()
        """
        savestdout = sys.stdout
        sys.stdout = sys.stderr
        sys.stderr.write('=' * 70)
        embedshell = IPShellEmbed(
            argv=[],
            banner="""
IPython Interactive Console

Note: You have the same locals available as in your test-case.
""",
            exit_msg="""end of ZopeTestCase Interactive Console session""",
            user_ns=locals)
        embedshell()
        sys.stdout.write('=' * 70 + '\n')
        sys.stdout = savestdout
예제 #16
0
def ipython():
	from IPython.Shell import IPShellEmbed

	Base.metadata.create_all(engine)
	session = Session()

	student = session.query(User).filter_by(name='curtis').first()
	_class = session.query(Class).filter_by(name='OPENSTACK 101').first()
	image = session.query(Image).filter_by(name='CentOS 6').first()

	try:
		servers = nova.servers.list()
	except:
		servers = None

	

	#reservation = Reservation(user_id=student.id, class_id=_class.id, image_id=image.id)

	#session.add(reservation)
	#session.commit()

	ipshell = IPShellEmbed()

	ipshell() 
def shell():
    '''
  shell()

  Return ipython shell. To actually start the shell, invoke the function
  returned by this function.

  This is particularly useful for debugging embedded
  python or for crawling over the data when something has gone wrong.
  '''
    import sys

    if not hasattr(sys, "argv"):
        sys.argv = []

    try:
        from IPython.Shell import IPShellEmbed
    except ImportError:
        sys.stderr.write("""
      *****************************************************
      *** Failed to import IPython. This probably means ***
      *** you don't have it installed. Please install   ***
      *** IPython and try again.                        ***
      *****************************************************
      """)
        raise

    banner = """
  This is an IPython shell embedded in Fluidity. You can use it to examine
  or even set variables. Press CTRL+d to exit and return to Fluidity.
  """

    ipshell = IPShellEmbed(banner=banner)

    return ipshell
예제 #18
0
def ipython(frame_or_depth=1, runs=1, argv=None, _frame_type=type(sys._getframe()), _lock=threading.RLock(), **kwargs):
    """Embed an IPython shell in-line for debugging"""
    try:
        with _lock:
            from IPython.Shell import IPShellEmbed
            if IPShellEmbed.__dict__.setdefault('runs', 0) < runs:
                IPShellEmbed.runs += 1
                if isinstance(frame_or_depth, numbers.Integral):
                    frame = sys._getframe(frame_or_depth)
                elif isinstance(frame_or_depth, _frame_type):
                    frame = frame_or_depth
                else:
                    raise TypeError('arg 1 must be frame or depth, not ' + type(frame_or_depth).__name__)
                if argv is None:
                    argv = ['ipython']
                old_argv, sys.argv[:] = sys.argv[:], argv[:]
                try:
                    IPShellEmbed(user_ns=kwargs)(
                            header='locals: ' + ' '.join(sorted(frame.f_locals)) if frame.f_locals else '',
                            local_ns=frame.f_locals, global_ns=frame.f_globals)
                finally:
                    sys.argv[:] = old_argv[:]
    except (SystemExit, KeyboardInterrupt, EOFError):
        raise
    except:
        exc_info = sys.exc_info()
        traceback.print_exception(*exc_info)
예제 #19
0
def use_ipython(options, sched, plasm, locals={}):
    '''Launch a plasm using ipython, and a scheduler of choice.

       Keyword arguments:
       options -- are from scheduler_options
       sched -- is an already initialized scheduler for plasm.
       plasm -- The graph to execute
       locals -- are a dictionary of locals to forward to the ipython shell, use locals()
    '''
    #expose the locals to the ipython prompt.
    for key, val in locals.items():
        vars()[key] = val

    sched.prepare_jobs(options.niter)
    print "Scheduler ready to run. To execute for some number of microseconds, type:"
    print "sched.run(1000)"

    import IPython
    if IPython.__version__ < '0.11':
        from IPython.Shell import IPShellEmbed
        #the argv is important so that the IPShellEmbed doesn't use the global
        #Also fancy colors!!!!
        ipython_argv = ['-prompt_in1', 'Input <\\#>', '-colors', 'LightBG']
        ipshell = IPShellEmbed(ipython_argv)
        ipshell()
    else:
        from IPython import embed
        embed()  # this call anywhere in your program will start IPython
예제 #20
0
def setupIpython():
    try:
        import IPython
        from IPython.config.loader import Config
        from IPython.frontend.terminal.embed import InteractiveShellEmbed

        cfg = Config()
        cfg.PromptManager.in_template = "BinPy:\\#> "
        cfg.PromptManager.out_template = "BinPy:\\#: "
        bpyShell = InteractiveShellEmbed(config=cfg,
                                         banner1=banner,
                                         exit_msg=exit_msg)
        bpyShell.define_magic("clear", magic_clear)

    except ImportError:
        try:
            from IPython.Shell import IPShellEmbed
            argsv = [
                '-pi1', 'BinPY:\\#>', '-pi2', '   .\\D.:', '-po', 'BinPy:\\#>',
                '-nosep'
            ]
            bpyShell = IPShellEmbed(argsv)
            bpyShell.set_banner(banner)
            bpyShell.set_exit_msg(exit_msg)
        except ImportError:
            raise

    return bpyShell()
예제 #21
0
def start_python_console(namespace=None, noipython=False, banner=''):
    """Start Python console binded to the given namespace. If IPython is
    available, an IPython console will be started instead, unless `noipython`
    is True. Also, tab completion will be used on Unix systems.
    """
    if namespace is None:
        namespace = {}

    try:
        try:  # use IPython if available
            if noipython:
                raise ImportError()
            try:
                try:
                    from IPython.terminal import embed
                except ImportError:
                    from IPython.frontend.terminal import embed
                sh = embed.InteractiveShellEmbed(banner1=banner)
            except ImportError:
                from IPython.Shell import IPShellEmbed
                sh = IPShellEmbed(banner=banner)
            sh(global_ns={}, local_ns=namespace)
        except ImportError:
            import code
            try:  # readline module is only available on unix systems
                import readline
            except ImportError:
                pass
            else:
                import rlcompleter
                readline.parse_and_bind("tab:complete")
            code.interact(banner=banner, local=namespace)
    except SystemExit:  # raised when using exit() in python code.interact
        pass
예제 #22
0
def startIpythonShell(in_template='CING \#>  ',
                      in2_template='CING \#>> ',
                      out_template='CING \#:  ',
                      banner='--------Dropping to IPython--------',
                      exit_msg='--------Leaving IPython--------'):
    iPythonVersionType = getIpythonVersionType()
    if iPythonVersionType == None:
        nTerror("Failed to getIpythonVersionType")
    elif iPythonVersionType == IPYTHON_VERSION_A:
        # The next import is missing in one OSX installation but is on all others.
        # The new way of doing this would be the below but that still fails on all OSX installs but the one above.
        # from IPython.frontend.terminal.embed import InteractiveShellEmbed
        # The next method started to fail in 2012 see issue 329
        # pylint: disable=W0404
        # pylint: disable=E0611
        from IPython.Shell import IPShellEmbed  #@UnresolvedImport
        ipshell = IPShellEmbed(
            ['-prompt_in1', in_template
             ],  # Fails to be set correctly on ipython version 0.11.
            banner=banner,
            exit_msg=exit_msg)
        ipshell()
    elif iPythonVersionType == IPYTHON_VERSION_B:
        # pylint: disable=W0404
        # pylint: disable=E0611
        from IPython.config.loader import Config  #@UnresolvedImport
        cfg = Config()
        cfg.PromptManager.in_template = in_template
        cfg.PromptManager.in2_template = in2_template
        cfg.PromptManager.out_template = out_template
        IPython.embed(config=cfg, banner1=banner, exit_msg=exit_msg)  #@UnresolvedImport # pylint: disable=E1101
    else:
        nTerror("Got unexpected value %s from getIpythonVersionType" %
                str(iPythonVersionType))
예제 #23
0
def shell(*args):
    """Interactive Shell"""
    if "--ipython" in args:
        """IPython Interactive Shell - IPython must be installed to use."""
        # remove an argument that confuses ipython
        sys.argv.pop(sys.argv.index("--ipython"))
        from IPython.Shell import IPShellEmbed
        import infogami  # noqa: F401
        from infogami.utils import delegate
        from infogami.core import db  # noqa: F401
        from infogami.utils.context import context as ctx  # noqa: F401

        delegate.fakeload()
        ipshell = IPShellEmbed()
        ipshell()
    else:
        from code import InteractiveConsole

        console = InteractiveConsole()
        console.push("import infogami")
        console.push("from infogami.utils import delegate")
        console.push("from infogami.core import db")
        console.push("from infogami.utils.context import context as ctx")
        console.push("delegate.fakeload()")
        console.interact()
def ip_thread():
    from IPython.Shell import IPShellEmbed
    ipshell = IPShellEmbed(
        argv='',
        banner='OpenRAVE Dropping into IPython, variables:' + 'env, robot',
        exit_msg='Leaving Interpreter and ' + 'closing program.')
    ipshell(local_ns=locals())
예제 #25
0
    def start_shell(self, runner):
        try:
            import IPython
        except:
            IPython = None
        if not hasattr(self, 'bridge'):
            self.start_jsbridge_network()
        jsobj = JSObject(self.bridge, window_string)

        if IPython is None or self.options.usecode:
            import code
            code.interact(
                local={
                    "jsobj": jsobj,
                    "getBrowserWindow": lambda: getBrowserWindow(self.bridge),
                    "back_channel": self.back_channel,
                })
        else:
            from IPython.Shell import IPShellEmbed
            ipshell = IPShellEmbed([])
            ipshell(
                local_ns={
                    "jsobj": jsobj,
                    "getBrowserWindow": lambda: getBrowserWindow(self.bridge),
                    "back_channel": self.back_channel,
                })
        runner.stop()
예제 #26
0
    def ipython_break(frame, depth, #pylint: disable-msg=W0613
                      color_scheme='Linux'):
        '''Start an interactive debugger session based on the IPython
        debugger'''
        #This code is a pretty dirty hack to get around some obscure
        #IPython issue
        global IPYTHON_TRACER

        if not IPYTHON_TRACER:
            # This is the first time this procedure is called
            # Due to some funky IPython 0.10 internals, we need the following:
            import IPython

            if map(int, IPython.__version__.split('.'))[:2] == [0, 10]:
                from IPython.Shell import IPShellEmbed
                IPShellEmbed(argv=[])

        old_colors = ExceptionColors.active_scheme_name
        ExceptionColors.active_scheme_name = color_scheme

        if not IPYTHON_TRACER:
            IPYTHON_TRACER = Tracer(color_scheme)

        IPYTHON_TRACER.debugger.set_trace(frame)
        ExceptionColors.active_scheme_name = old_colors
예제 #27
0
def command_shell(*args):
    '''
        Runs a Python shell inside the application context.
    '''
    context = None
    banner = 'Open Media Library'

    import db
    with db.session():
        # Try BPython
        try:
            from bpython import embed
            embed(banner=banner, locals_=context)
            return
        except ImportError:
            pass

        # Try IPython
        try:
            try:
                # 0.10.x
                from IPython.Shell import IPShellEmbed
                ipshell = IPShellEmbed(banner=banner)
                ipshell(global_ns=dict(), local_ns=context)
            except ImportError:
                # 0.12+
                from IPython import embed
                embed(banner1=banner, user_ns=context)
            return
        except ImportError:
            pass

        import code
        # Use basic python shell
        code.interact(banner, local=context)
예제 #28
0
파일: querycli.py 프로젝트: mm1ke/gentoopm
        def __call__(self, pm, args):
            import gentoopm.filters as f
            import gentoopm.matchers as m

            our_imports = (('pm', pm), ('f', f), ('m', m))

            welc = '''The following objects have been imported for you:\n'''
            welc += '\n'.join(
                ['\t%s: %s' % (key, repr(var)) for key, var in our_imports])
            kwargs = {}

            try:
                from IPython import embed
            except ImportError:
                try:
                    from IPython.Shell import IPShellEmbed
                except ImportError:
                    print('For better user experience, install IPython.')
                    from code import InteractiveConsole
                    embed = InteractiveConsole({'pm': pm}).interact
                    kwargs['banner'] = welc
                else:
                    embed = IPShellEmbed()
                    embed.set_banner(embed.IP.BANNER + '\n\n' + welc)
            else:
                kwargs['banner2'] = welc

            embed(**kwargs)
예제 #29
0
def shell():
    try:
        from IPython.Shell import IPShellEmbed
        IPShellEmbed()(INTRO_MESSAGE)
    except ImportError:
        import code
        code.InteractiveConsole(globals()).interact(INTRO_MESSAGE)
예제 #30
0
def main():
    try:
        opts, args = getopt.getopt(sys.argv[1:], "hf:v", ["help", "file"])
    except getopt.GetoptError:
        # print help information and exit:
        usage()
        sys.exit(2)
    output = None
    verbose = False

    global dat
    dat = {}
    for o, a in opts:
        if o == "-v":
            verbose = True
        if o in ("-h", "--help"):
            usage()
            sys.exit()
        if o in ("-o", "--output"):
            output = a
        if o in ("-f", "--file"):
            filename = a
            dat = load_data(filename)

    filename = args[0]
    dat = (load_data(filename))

    from IPython.Shell import IPShellEmbed
    ipshell = IPShellEmbed()
    pl.ion()
    ipshell("Interactive Qucs Data Plotter")
예제 #31
0
파일: ipython.py 프로젝트: rrosajp/pystuck
def ishell(local_ns):
    """Embed an IPython shell handing it the local namespace from
    :var:`local_ns`.
    """
    banner = (
        "Welcome to the pystuck interactive shell.\nUse the 'modules' dictionary "
        "to access remote modules (like 'os', or '__main__')\nUse the `%show "
        "threads` magic to display all thread stack traces.\n")
    try:
        from IPython.terminal.embed import InteractiveShellEmbed
        ipshell = InteractiveShellEmbed(banner1=banner)
        ipshell.register_magics(IntrospectMagics)
        ipshell(local_ns=local_ns)
    except ImportError:
        # IPython < 0.11
        # Explicitly pass an empty list as arguments, because otherwise
        # IPython would use sys.argv from this script.
        try:
            from IPython.Shell import IPShellEmbed
            ipshell = IPShellEmbed(argv=[], user_ns=local_ns, banner1=banner)
            ipshell.register_magics(IntrospectMagics)
            ipshell()
        except ImportError:
            # IPython not found at all, raise ImportError
            raise
예제 #32
0
def use_ipython(options, sched, plasm, locals={}):
    '''Launch a plasm using ipython, and a scheduler of choice.

       Keyword arguments:
       options -- are from scheduler_options
       sched -- is an already initialized scheduler for plasm.
       plasm -- The graph to execute
       locals -- are a dictionary of locals to forward to the ipython shell, use locals()
    '''
    #expose the locals to the ipython prompt.
    for key, val in locals.items():
        vars()[key] = val

    if type(sched) == ecto.schedulers.Singlethreaded:
        sched.execute_async(options.niter)
    else:
        sched.execute_async(options.niter, options.nthreads)

    import IPython
    if IPython.__version__ < '0.11':
        from IPython.Shell import IPShellEmbed
        #the argv is important so that the IPShellEmbed doesn't use the global
        #Also fancy colors!!!!
        ipython_argv = ['-prompt_in1', 'Input <\\#>', '-colors', 'LightBG']
        ipshell = IPShellEmbed(ipython_argv)
        ipshell()
    else:
        from IPython import embed
        embed() # this call anywhere in your program will start IPython
예제 #33
0
    def __call__(self, args):
        """
        Copied from IPython embed-short example
        """
        import logging
        logging.basicConfig()
        from omero.util.upgrade_check import UpgradeCheck
        check = UpgradeCheck("shell")
        check.run()
        if check.isUpgradeNeeded():
            self.ctx.out("")

        ns = {}
        if args.login:
            import omero
            client = self.ctx.conn(args)
            ns = {"client": client, "omero": omero}

        try:
            # IPython 0.11 (see #7112)
            from IPython import embed
            embed(user_ns=ns)
        except ImportError:
            from IPython.Shell import IPShellEmbed
            ipshell = IPShellEmbed(args.arg)
            ipshell(local_ns=ns)
예제 #34
0
def embedd_ipython010(local_ns={}, global_ns={}):
    from IPython.Shell import IPShellEmbed
    ipshell = IPShellEmbed( [""],
                            banner = IPYTHON_BANNER,
                            exit_msg = IPYTHON_EXIT_MSG
                          )
    ipshell(local_ns=local_ns, global_ns=global_ns)
예제 #35
0
파일: cli.py 프로젝트: danellis/dextrose
 def run(self, args):
     from IPython.Shell import IPShellEmbed
     from werkzeug import Client, EnvironBuilder
     from dextrose.context import Context
     from dextrose.http import Response
     app = load_application(args.package, args.environment)
     environ_builder = EnvironBuilder()
     environ = environ_builder.get_environ()
     request = environ_builder.get_request()
     client = Client(app, Response)
     with Context(app, environ, request, {}) as context:
         banner = "Dextrose IPython shell\n%s" % args.package
         shell = IPShellEmbed(
             banner=banner,
             argv=[
                 '-prompt_in1',
                 '%s> ' % args.package, '-prompt_in2',
                 '%s... ' % (' ' * (len(args.package) - 3)), '-prompt_out',
                 '=> '
             ])
         shell(global_ns={},
               local_ns={
                   'app': app,
                   'environ': environ,
                   'client': client,
                   'context': context
               })
예제 #36
0
    def run_rpc_shell(self, app_name):
        settings = self.get_app_settings(app_name)
        api = self.get_api(self.settings.__dict__, app_name, use_bind=True)

        # Make PyFlakes ignore the 'unused' variables
        settings, api = settings, api

        logfile_root = os.path.expanduser("~/.dirt_api_logs/")
        if not os.path.exists(logfile_root):
            print "%r doesn't exist - not logging API calls" %(logfile_root, )
        else:
            logfile = os.path.join(logfile_root, app_name)
            from .rpc import connection
            connection.full_message_log_enable(logfile)
            print "Logging API calls to %r", logfile

        print "access the api using the `api` variable"
        print

        try:
            from IPython.frontend.terminal.embed import embed
            embed()
        except ImportError:
            # compat with older ipython
            from IPython.Shell import IPShellEmbed
            IPShellEmbed(argv='')()
예제 #37
0
def shell(no_ipython):
    """Start a new interactive python session."""
    banner = ('\nWelcome to the interactive shell environment of LodgeIt!\n'
              '\n'
              'You can use the following predefined objects: app, local, db.\n'
              'To run the application (creates a request) use *run_app*.')
    namespace = make_shell()
    if not no_ipython:
        try:
            try:
                from IPython.frontend.terminal.embed import InteractiveShellEmbed

                sh = InteractiveShellEmbed.instance(banner1=banner)
            except ImportError:
                from IPython.Shell import IPShellEmbed

                sh = IPShellEmbed(banner=banner)
        except ImportError:
            pass
        else:
            sh(local_ns=namespace)
            return
    from code import interact

    interact(banner, local=namespace)
예제 #38
0
파일: shell.py 프로젝트: cajun-code/pecan
 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)
예제 #39
0
파일: test_ovf.py 프로젝트: anyint/nmag-src
def ipython(globals=None, locals=None):
    calling_frame = sys._getframe(1)
    if globals == None:
        globals = calling_frame.f_globals
    if locals == None:
        locals = calling_frame.f_locals
    from IPython.Shell import IPShellEmbed
    IPShellEmbed([])(local_ns=locals, global_ns=globals)
예제 #40
0
    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={})
예제 #41
0
파일: Shell.py 프로젝트: blackball/SimpleCV
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
예제 #42
0
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()
예제 #43
0
파일: icli.py 프로젝트: rep/pwrcall
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)

예제 #44
0
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 = '\n... [Exiting the SimpleCV interactive shell] ...\n'


  #IPython version is less than 11
  if IPVER <= 10:
    #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

  #IPython version 0.11 or higher
  else:
    cfg = Config()
    cfg.PromptManager.in_template = "SimpleCV:\\#> "
    cfg.PromptManager.out_template = "SimpleCV:\\#: "
    #~ cfg.InteractiveShellEmbed.prompt_in1 = "SimpleCV:\\#> "
    #~ cfg.InteractiveShellEmbed.prompt_out="SimpleCV:\\#: "
    scvShell = InteractiveShellEmbed(config=cfg, banner1=banner, exit_msg = exit_msg)
    scvShell.define_magic("tutorial",magic_tutorial)
    scvShell.define_magic("clear", magic_clear)
    scvShell.define_magic("cheatsheet", magic_cheatsheet)
    scvShell.define_magic("example", magic_examples)
    scvShell.define_magic("editor", magic_editor)

    return scvShell
예제 #45
0
파일: shell.py 프로젝트: Hazer/WebCore
    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()
예제 #46
0
파일: shell.py 프로젝트: RusAnon/dfhack
maps = DF.maps
refc = dict(pydfhack=pydfhack, API=pydfhack.API, DF=DF, pos=pos, maps=maps)
cursor = pos.get_cursor()
msize = maps.get_size()
block = None
tile  = None
if cursor:
    block  = maps.get_block(point=cursor)
    if block:
        tile = block.get_tile(point=cursor)
DF.Resume()

locs = dict(pydfhack=pydfhack, API=pydfhack.API, DF=DF, pos=pos, maps=maps, msize=msize, cursor=cursor, block=block, tile=tile)

banner = """DFHack Shell\n\n"""\
         """\tpydfhack = {pydfhack}\n"""\
         """\tAPI      = {API}\n"""\
         """\tDF       = {DF}\n"""\
         """\tpos      = {pos}\n"""\
         """\tmaps     = {maps}\n"""\
         """\tmsize    = {msize}\n"""\
         """\tcursor   = {cursor}\n"""\
         """\tblock    = {block}\n"""\
         """\ttile     = {tile}\n""".format(**locs)

from IPython.Shell import IPShellEmbed
shell = IPShellEmbed()
shell.set_banner(shell.IP.BANNER + '\n\n' + banner)
shell(local_ns=locs, global_ns={})
DF.Detach()
예제 #47
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()
        locs = dict(__name__="pylons-admin")

        # XXX: Note, initializing CONFIG here is Legacy support. pylons.config
        # will automatically be initialized and restored via the registry
        # restorer along with the other StackedObjectProxys
        # Load app config into paste.deploy to simulate request config
        # Setup the Paste CONFIG object, adding app_conf/global_conf for legacy
        # code
        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)

        # 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()
예제 #48
0
else:
    print "Running nested copies of IPython."
    print "The prompts for the nested copy have been modified"
    nested = 1
    # what the embedded instance will see as sys.argv:
    args = ['-pi1','In <\\#>:','-pi2','   .\\D.:','-po','Out<\\#>:','-nosep']

# First import the embeddable shell class
from IPython.Shell import IPShellEmbed

# Now create an instance of the embeddable shell. The first argument is a
# string with options exactly as you would type them if you were starting
# IPython at the system command line. Any parameters you want to define for
# configuration can thus be specified here.
ipshell = IPShellEmbed(args,
                       banner = 'Dropping into IPython',
                       exit_msg = 'Leaving Interpreter, back to program.')

# Make a second instance, you can have as many as you want.
if nested:
    args[1] = 'In2<\\#>'
else:
    args = ['-pi1','In2<\\#>:','-pi2','   .\\D.:','-po','Out<\\#>:','-nosep']
ipshell2 = IPShellEmbed(args,banner = 'Second IPython instance.')

print '\nHello. This is printed from the main controller program.\n'

# You can then call ipshell() anywhere you need it (with an optional
# message):
ipshell('***Called from top level. '
        'Hit Ctrl-D to exit interpreter and continue program.')
예제 #49
0
파일: commands.py 프로젝트: solos/pylons
    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()
        locs = dict(__name__="pylons-admin")

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

        # XXX: Note, initializing CONFIG here is Legacy support. pylons.config
        # will automatically be initialized and restored via the registry
        # restorer along with the other StackedObjectProxys
        # Load app config into paste.deploy to simulate request config
        # Setup the Paste CONFIG object, adding app_conf/global_conf for legacy
        # code
        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)

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

        # Determine the package name from the pylons.config object
        pkg_name = pylons.config['pylons.package']

        # Start the rest of our imports now that the app is loaded
        if is_minimal_template(pkg_name, True):
            model_module = None
            helpers_module = pkg_name + '.helpers'
            base_module = pkg_name + '.controllers'
        else:
            model_module = pkg_name + '.model'
            helpers_module = pkg_name + '.lib.helpers'
            base_module = pkg_name + '.lib.base'

        if model_module and can_import(model_module):
            locs['model'] = sys.modules[model_module]

        if can_import(helpers_module):
            locs['h'] = sys.modules[helpers_module]

        exec ('from pylons import app_globals, c, config, g, request, '
              'response, session, tmpl_context, url') in locs
        exec ('from pylons.controllers.util import abort, redirect_to') in locs
        exec 'from pylons.i18n import _, ungettext, N_' in locs
        exec 'from pylons.templating import render' in locs

        # Import all objects from the base module
        __import__(base_module)

        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')

        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 = "Pylons 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()
예제 #50
0
파일: NexposeAPI.py 프로젝트: 001001/Kvasir
        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"
예제 #51
0
    def command(self):

        self.verbose = 3
        if len(self.args) == 0:
            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()
        locs = dict(__name__="pylons-admin")

        if not self.options.quiet:
            self.logging_file_config(config_file)

        sys.path.insert(0, here_dir)

        wsgiapp = loadapp(config_name, relative_to=here_dir)
        test_app = paste.fixture.TestApp(wsgiapp)

        tresponse = test_app.get("/_test_vars")
        request_id = int(tresponse.body)

        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)

        pkg_name = pylons.config["pylons.package"]

        if is_minimal_template(pkg_name, True):
            model_module = None
            helpers_module = pkg_name + ".helpers"
            base_module = pkg_name + ".controllers"
        else:
            model_module = pkg_name + ".model"
            helpers_module = pkg_name + ".lib.helpers"
            base_module = pkg_name + ".lib.base"

        if model_module and can_import(model_module):
            locs["model"] = sys.modules[model_module]

        if can_import(helpers_module):
            locs["h"] = sys.modules[helpers_module]

        exec ("from pylons import app_globals, config, request, response, " "session, tmpl_context, url") in locs
        exec ("from pylons.controllers.util import abort, redirect") in locs
        exec "from pylons.i18n import _, ungettext, N_" in locs
        locs.pop("__builtins__", None)

        __import__(base_module)

        base = sys.modules[base_module]
        base_public = [__name for __name in dir(base) if not __name.startswith("_") or __name == "_"]
        locs.update((name, getattr(base, name)) for name in base_public)
        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")

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

            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 = "Pylons 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()
예제 #52
0
def setup_shell():

  banner = '+-----------------------------------------------------------+\n'
  banner += ' SimpleCV '
  banner += SIMPLECV_VERSION
  banner += ' [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"example" gives a list of examples you can run\n'
  banner += '\t"forums" will launch a web browser for the help forums\n'
  banner += '\t"walkthrough" will launch a web browser with a walkthrough\n'
  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 += 'Documentation:\n'
  banner += '\thelp(Image), ?Image, Image?, or Image()? all do the same\n'
  banner += '\t"docs" will launch webbrowser showing documentation'
  banner += '\n'
  exit_msg = '\n... [Exiting the SimpleCV interactive shell] ...\n'
  


  #IPython version is less than 11
  if IPVER <= 10:
    #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("example", magic_examples)
    scvShell.IP.api.expose_magic("forums", magic_forums)
    scvShell.IP.api.expose_magic("walkthrough", magic_walkthrough)
    scvShell.IP.api.expose_magic("docs", magic_docs)

    return scvShell

  #IPython version 0.11 or higher
  else:
    cfg = Config()
    cfg.PromptManager.in_template = "SimpleCV:\\#> "
    cfg.PromptManager.out_template = "SimpleCV:\\#: "
    #~ cfg.InteractiveShellEmbed.prompt_in1 = "SimpleCV:\\#> "
    #~ cfg.InteractiveShellEmbed.prompt_out="SimpleCV:\\#: "
    scvShell = InteractiveShellEmbed(config=cfg, banner1=banner, exit_msg = exit_msg)
    scvShell.define_magic("tutorial",magic_tutorial)
    scvShell.define_magic("clear", magic_clear)
    scvShell.define_magic("example", magic_examples)
    scvShell.define_magic("forums", magic_forums)
    scvShell.define_magic("walkthrough", magic_walkthrough)
    scvShell.define_magic("docs", magic_docs)

    return scvShell
예제 #53
0
파일: console.py 프로젝트: audip/lunr
 def __init__(self, banner=None, locals=None):
     IPShellEmbed.__init__(self, argv=[], banner=banner,
                           user_ns=locals)