Python interactiveshell.TerminalInteractiveShell类代码示例

def interactive(idx=0, DongleClass=RfCat, intro=''):
    global d
    import rflib.chipcon_nic as rfnic
    import atexit

    d = DongleClass(idx=idx)
    d.setModeRX()       # this puts the dongle into receive mode
    atexit.register(cleanupInteractiveAtExit)

    gbls = globals()
    lcls = locals()

    try:
        import IPython.Shell
        ipsh = IPython.Shell.IPShell(argv=[''], user_ns=lcls, user_global_ns=gbls)
        print intro
        ipsh.mainloop(intro)

    except ImportError, e:
        try:
            from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
            ipsh = TerminalInteractiveShell()
            ipsh.user_global_ns.update(gbls)
            ipsh.user_global_ns.update(lcls)
            ipsh.autocall = 2       # don't require parenthesis around *everything*.  be smart!
            ipsh.mainloop(intro)
        except ImportError, e:
            print e
            shell = code.InteractiveConsole(gbls)
            shell.interact(intro)

    def handle(self, *args, **kwargs):
        imported_objects = {
            'config' : self.config,
        }
        try:
            # Try IPython imports
            from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
            from IPython.config.loader import Config

            cfg = Config()
            shell = TerminalInteractiveShell(config=cfg, user_ns=imported_objects)
            shell.mainloop(display_banner='\n  Samovar  \n')
        except:
            import code
            code.InteractiveConsole(locals=imported_objects).interact()

def run_ipython_shell_v11(locals, globals, first_time):
    '''IPython shell from IPython version 0.11'''
    if first_time:
        banner = "Hit Ctrl-D to return to PuDB."
    else:
        banner = ""

    from IPython.frontend.terminal.interactiveshell import \
            TerminalInteractiveShell
    from IPython.frontend.terminal.ipapp import load_default_config
    # XXX: in the future it could be useful to load a 'pudb' config for the
    # user (if it exists) that could contain the user's macros and other
    # niceities.
    config = load_default_config()
    shell = TerminalInteractiveShell.instance(config=config,
            banner2=banner)
    # XXX This avoids a warning about not having unique session/line numbers.
    # See the HistoryManager.writeout_cache method in IPython.core.history.
    shell.history_manager.new_session()
    # Save the originating namespace
    old_locals = shell.user_ns
    old_globals = shell.user_global_ns
    # Update shell with current namespace
    _update_ns(shell, locals, globals)
    shell.mainloop(banner)
    # Restore originating namespace
    _update_ns(shell, old_locals, old_globals)

    def construct(self):
        # I am a little hesitant to put these into InteractiveShell itself.
        # But that might be the place for them
        sys.path.insert(0, '')

        # Create an InteractiveShell instance.
        self.shell = TerminalInteractiveShell.instance(config=self.master_config)

def start_ipython():
    """Start a global IPython shell, which we need for IPython-specific syntax.
    """
    global get_ipython

    # This function should only ever run once!
    if hasattr(start_ipython, 'already_called'):
        return
    start_ipython.already_called = True
    
    # Store certain global objects that IPython modifies
    _displayhook = sys.displayhook
    _excepthook = sys.excepthook
    _main = sys.modules.get('__main__')

    # Create custom argv and namespaces for our IPython to be test-friendly
    config = tools.default_config()

    # Create and initialize our test-friendly IPython instance.
    shell = TerminalInteractiveShell.instance(config=config, 
                                              user_ns=ipnsdict(),
                                              user_global_ns={}
                                              )

    # A few more tweaks needed for playing nicely with doctests...
    
    # These traps are normally only active for interactive use, set them
    # permanently since we'll be mocking interactive sessions.
    shell.builtin_trap.activate()

    # Modify the IPython system call with one that uses getoutput, so that we
    # can capture subcommands and print them to Python's stdout, otherwise the
    # doctest machinery would miss them.
    shell.system = MethodType(xsys, shell, TerminalInteractiveShell)
                       

    shell._showtraceback = MethodType(_showtraceback, shell,
                                      TerminalInteractiveShell)

    # IPython is ready, now clean up some global state...
    
    # Deactivate the various python system hooks added by ipython for
    # interactive convenience so we don't confuse the doctest system
    sys.modules['__main__'] = _main
    sys.displayhook = _displayhook
    sys.excepthook = _excepthook

    # So that ipython magics and aliases can be doctested (they work by making
    # a call into a global _ip object).  Also make the top-level get_ipython
    # now return this without recursively calling here again.
    _ip = shell
    get_ipython = _ip.get_ipython
    __builtin__._ip = _ip
    __builtin__.get_ipython = get_ipython
    
    # To avoid extra IPython messages during testing, suppress io.stdout/stderr
    io.stdout = StreamProxy('stdout')
    io.stderr = StreamProxy('stderr')

    return _ip

 def init_shell(self):
     """initialize the InteractiveShell instance"""
     # Create an InteractiveShell instance.
     # shell.display_banner should always be False for the terminal
     # based app, because we call shell.show_banner() by hand below
     # so the banner shows *before* all extension loading stuff.
     self.shell = TerminalInteractiveShell.instance(
         config=self.config, display_banner=False, profile_dir=self.profile_dir, ipython_dir=self.ipython_dir
     )
     self.shell.configurables.append(self)

    def init_shell(self):
        """initialize the InteractiveShell instance"""
        # I am a little hesitant to put these into InteractiveShell itself.
        # But that might be the place for them
        sys.path.insert(0, '')

        # Create an InteractiveShell instance.
        # shell.display_banner should always be False for the terminal 
        # based app, because we call shell.show_banner() by hand below
        # so the banner shows *before* all extension loading stuff.
        self.shell = TerminalInteractiveShell.instance(config=self.config,
                        display_banner=False, profile_dir=self.profile_dir,
                        ipython_dir=self.ipython_dir)

def execute(file_, verbose = 0, stop_on_error = 1, store_history = 0):
    """ Read and execute lines of code in given open file.
    Supports pure python or ipython-bash style syntax,
    multi-line code, and the IPython feature set
    """
    shell = TerminalInteractiveShell()

    c = shell.get_ipython()
    c.instance() # initialize ipython config

    raw_cells = file_.readlines()
    exception = None

    while raw_cells:
        # Extract smallest possible executable block of code from raw source
        is_completed = c.input_splitter.push(raw_cells.pop(0))
        while not is_completed:
            is_completed = c.input_splitter.push(raw_cells.pop(0))

        cell, raw_cell = c.input_splitter.source_raw_reset()
        # Transform cell into syntactically correct python
        cell = c.prefilter_manager.prefilter_lines(cell) + '\n'

        # If we are storing script in/out history
        if store_history:
            c.history_manager.store_inputs(c.execution_count,
                                              cell, raw_cell)
        # Compile to byte code
        code = compile(cell, 'cellname', 'exec')
        if verbose:
            print '========'
            print 'executing:', cell
            print '========'
        outflag = c.run_code(code)

        if stop_on_error and outflag:
            c.exit()
            break

    def __init__(self, *args, **kwargs):        
        # Initialization based on: from IPython.testing.globalipapp import start_ipython
        
        self._curr_exec_line = 0
        # Store certain global objects that IPython modifies
        _displayhook = sys.displayhook
        _excepthook = sys.excepthook
    
        # Create and initialize our IPython instance.
        shell = TerminalInteractiveShell.instance()
        # Create an intput splitter to handle input separation
        self.input_splitter = IPythonInputSplitter()

        shell.showtraceback = _showtraceback
        # IPython is ready, now clean up some global state...
        
        # Deactivate the various python system hooks added by ipython for
        # interactive convenience so we don't confuse the doctest system
        sys.displayhook = _displayhook
        sys.excepthook = _excepthook
    
        # So that ipython magics and aliases can be doctested (they work by making
        # a call into a global _ip object).  Also make the top-level get_ipython
        # now return this without recursively calling here again.
        get_ipython = shell.get_ipython
        try:
            import __builtin__
        except:
            import builtins as __builtin__
        __builtin__._ip = shell
        __builtin__.get_ipython = get_ipython
        
        # We want to print to stdout/err as usual.
        io.stdout = original_stdout
        io.stderr = original_stderr

        self.ipython = shell

import os

try:
    from IPython import ipapi
except ImportError:
    from IPython.frontend.terminal.interactiveshell import \
            TerminalInteractiveShell
    ip = TerminalInteractiveShell.instance()
    _ipython_version = (0, 11)
else:
    ip = ipapi.get()
    _ipython_version = (0, 10)


def pudb_f_v10(self, arg):
    """ Debug a script (like %run -d) in IPython process, using PuDB.

    This conforms to IPython version 0.10

    Usage:

    %pudb test.py [args]
        Run script test.py under PuDB.
    """

    if not arg.strip():
        print __doc__
        return

    from IPython.genutils import arg_split
    args = arg_split(arg)

def debug():
    from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell

    shell = TerminalInteractiveShell(user_ns=vars())
    shell.mainloop()