IPython/gui/wx/ipshell_nonblocking.py

#!/usr/bin/python
# -*- coding: iso-8859-15 -*-
'''
Provides IPython remote instance.

@author: Laurent Dufrechou
laurent.dufrechou _at_ gmail.com
@license: BSD

All rights reserved. This program and the accompanying materials are made
available under the terms of the BSD which accompanies this distribution, and
is available at U{http://www.opensource.org/licenses/bsd-license.php}
'''

__version__ = 0.9
__author__  = "Laurent Dufrechou"
__email__   = "laurent.dufrechou _at_ gmail.com"
__license__ = "BSD"

import re
import sys
import os
import locale
import time
import pydoc,__builtin__,site
from thread_ex import ThreadEx
from StringIO import StringIO

try:
        import IPython
except Exception,e:
        raise "Error importing IPython (%s)" % str(e)

##############################################################################
class _Helper(object):
    """Redefine the built-in 'help'.
    This is a wrapper around pydoc.help (with a twist).
    """

    def __init__(self,pager):
        self._pager = pager

    def __repr__(self):
        return "Type help() for interactive help, " \
               "or help(object) for help about object."
    
    def __call__(self, *args, **kwds):
        class DummyWriter(object):
            def __init__(self,pager):
                self._pager = pager
                
            def write(self,data):
                self._pager(data)

        import pydoc
        pydoc.help.output = DummyWriter(self._pager)
        pydoc.help.interact = lambda :1
        
        return pydoc.help(*args, **kwds)

  
##############################################################################
class _CodeExecutor(ThreadEx):
    
    def __init__(self, instance, after):
        ThreadEx.__init__(self)
        self.instance = instance
        self._afterExecute=after

    def run(self):
        try:
            self.instance._doc_text = None
            self.instance._help_text = None
            self.instance._execute()
            # used for uper class to generate event after execution
            self._afterExecute() 
            
        except KeyboardInterrupt:
            pass
 

##############################################################################
class NonBlockingIPShell(object):
    '''
    Create an IPython instance, running the commands in a separate,
    non-blocking thread. 
    This allows embedding in any GUI without blockage.

    Note: The ThreadEx class supports asynchroneous function call
          via raise_exc()
    '''

    def __init__(self,argv
                 =[],user_ns={},user_global_ns=None,
                 cin=None, cout=None, cerr=None,
                 ask_exit_handler=None):
        '''
        @param argv: Command line options for IPython
        @type argv: list
        @param user_ns: User namespace.
        @type user_ns: dictionary
        @param user_global_ns: User global namespace.
        @type user_global_ns: dictionary.
        @param cin: Console standard input.
        @type cin: IO stream
        @param cout: Console standard output.
        @type cout: IO stream
        @param cerr: Console standard error.
        @type cerr: IO stream
        @param exit_handler: Replacement for builtin exit() function
        @type exit_handler: function
        @param time_loop: Define the sleep time between two thread's loop
        @type int
        '''
        #ipython0 initialisation
        self.initIpython0(argv, user_ns, user_global_ns,
                          cin, cout, cerr,
                          ask_exit_handler)
        
        #vars used by _execute
        self._iter_more = 0
        self._history_level = 0
        self._complete_sep =  re.compile('[\s\{\}\[\]\(\)]')
        self._prompt = str(self._IP.outputcache.prompt1).strip()

        #thread working vars
        self._line_to_execute = ''

        #vars that will be checked by GUI loop to handle thread states...
        #will be replaced later by PostEvent GUI funtions...
        self._doc_text = None
        self._help_text = None
        self._add_button = None

    def initIpython0(self, argv=[], user_ns={}, user_global_ns=None,
                     cin=None, cout=None, cerr=None,
                     ask_exit_handler=None):
        #first we redefine in/out/error functions of IPython 
        if cin:
            IPython.Shell.Term.cin = cin
        if cout:
            IPython.Shell.Term.cout = cout
        if cerr:
            IPython.Shell.Term.cerr = cerr
        
        # This is to get rid of the blockage that accurs during
        # IPython.Shell.InteractiveShell.user_setup()
        IPython.iplib.raw_input = lambda x: None

        self._term = IPython.genutils.IOTerm(cin=cin, cout=cout, cerr=cerr)

        excepthook = sys.excepthook

        self._IP = IPython.Shell.make_IPython(
                                            argv,user_ns=user_ns,
                                            user_global_ns=user_global_ns,
                                            embedded=True,
                                            shell_class=IPython.Shell.InteractiveShell)

        #we replace IPython default encoding by wx locale encoding
	loc = locale.getpreferredencoding()
	if loc:
        	self._IP.stdin_encoding = loc
        #we replace the ipython default pager by our pager
        self._IP.set_hook('show_in_pager',self._pager)
        
        #we replace the ipython default shell command caller by our shell handler
	self._IP.set_hook('shell_hook',self._shell)
        
        #we replace the ipython default input command caller by our method
        IPython.iplib.raw_input_original = self._raw_input
        #we replace the ipython default exit command by our method
        self._IP.exit = ask_exit_handler
        #we replace the help command
        self._IP.user_ns['help'] = _Helper(self._pager_help)
        
        sys.excepthook = excepthook

    #----------------------- Thread management section ----------------------    
    def doExecute(self,line):
        """
        Tell the thread to process the 'line' command
        """

        self._line_to_execute = line
        #we launch the ipython line execution in a thread to make it interruptible
        self.ce = _CodeExecutor(self,self._afterExecute)
        self.ce.start()
        
    #----------------------- IPython management section ----------------------    
    def getDocText(self):
        """
        Returns the output of the processing that need to be paged (if any)

        @return: The std output string.
        @rtype: string
        """
        return self._doc_text
        
    def getHelpText(self):
        """
        Returns the output of the processing that need to be paged via help pager(if any)

        @return: The std output string.
        @rtype: string
        """
        return self._help_text

    def getBanner(self):
        """
        Returns the IPython banner for useful info on IPython instance

        @return: The banner string.
        @rtype: string
        """
        return self._IP.BANNER
    
    def getPromptCount(self):
        """
        Returns the prompt number.
        Each time a user execute a line in the IPython shell the prompt count is increased

        @return: The prompt number
        @rtype: int
        """
        return self._IP.outputcache.prompt_count

    def getPrompt(self):
        """
        Returns current prompt inside IPython instance
        (Can be In [...]: ot ...:)

        @return: The current prompt.
        @rtype: string
        """
        return self._prompt

    def getIndentation(self):
        """
        Returns the current indentation level
        Usefull to put the caret at the good start position if we want to do autoindentation.

        @return: The indentation level.
        @rtype: int
        """
        return self._IP.indent_current_nsp
        
    def updateNamespace(self, ns_dict):
        '''
        Add the current dictionary to the shell namespace.

        @param ns_dict: A dictionary of symbol-values.
        @type ns_dict: dictionary
        '''
        self._IP.user_ns.update(ns_dict)

    def complete(self, line):
        '''
        Returns an auto completed line and/or posibilities for completion.

        @param line: Given line so far.
        @type line: string

        @return: Line completed as for as possible,
        and possible further completions.
        @rtype: tuple
        '''
        split_line = self._complete_sep.split(line)
        possibilities = self._IP.complete(split_line[-1])
        if possibilities:

            def _commonPrefix(str1, str2):
                '''
                Reduction function. returns common prefix of two given strings.

                @param str1: First string.
                @type str1: string
                @param str2: Second string
                @type str2: string

                @return: Common prefix to both strings.
                @rtype: string
                '''
                for i in range(len(str1)):
                    if not str2.startswith(str1[:i+1]):
                        return str1[:i]
                return str1
            common_prefix = reduce(_commonPrefix, possibilities)
            completed = line[:-len(split_line[-1])]+common_prefix
        else:
            completed = line
        return completed, possibilities

    def historyBack(self):
        '''
        Provides one history command back.

        @return: The command string.
        @rtype: string
        '''
        history = ''
        #the below while loop is used to suppress empty history lines
	while((history == '' or history == '\n') and self._history_level >0):
		if self._history_level>=1:
			self._history_level -= 1
		history = self._getHistory()		
        return history

    def historyForward(self):
        '''
        Provides one history command forward.

        @return: The command string.
        @rtype: string
        '''
	history = ''
	#the below while loop is used to suppress empty history lines
	while((history == '' or history == '\n') and self._history_level <= self._getHistoryMaxIndex()):
		if self._history_level < self._getHistoryMaxIndex():
			self._history_level += 1
			history = self._getHistory()
		else:
			if self._history_level == self._getHistoryMaxIndex():
				history = self._getHistory()
				self._history_level += 1
			else:
				history = ''
        return history

    def initHistoryIndex(self):
        '''
        set history to last command entered
        '''
        self._history_level = self._getHistoryMaxIndex()+1

    #----------------------- IPython PRIVATE management section --------------
    def _afterExecute(self):
        '''
        Can be redefined to generate post event after excution is done
        '''
        pass

    #def _askExit(self):
    #    '''
    #    Can be redefined to generate post event to exit the Ipython shell
    #    '''
    #    pass

    def _getHistoryMaxIndex(self):
        '''
        returns the max length of the history buffer

        @return: history length
        @rtype: int
        '''
        return len(self._IP.input_hist_raw)-1
        
    def _getHistory(self):
        '''
        Get's the command string of the current history level.

        @return: Historic command stri
        @rtype: string
        '''
        rv = self._IP.input_hist_raw[self._history_level].strip('\n')
        return rv

    def _pager_help(self,text):
        '''
        This function is used as a callback replacment to IPython help pager function

        It puts the 'text' value inside the self._help_text string that can be retrived via getHelpText
        function.
        '''
        if self._help_text == None:
            self._help_text = text
        else:
            self._help_text += text
    
    def _pager(self,IP,text):
        '''
        This function is used as a callback replacment to IPython pager function

        It puts the 'text' value inside the self._doc_text string that can be retrived via getDocText
        function.
        '''
        self._doc_text = text
    
    def _raw_input(self, prompt=''):
        '''
        Custom raw_input() replacement. Get's current line from console buffer.

        @param prompt: Prompt to print. Here for compatability as replacement.
        @type prompt: string

        @return: The current command line text.
        @rtype: string
        '''
        return self._line_to_execute

    def _execute(self):
        '''
        Executes the current line provided by the shell object.
        '''
        orig_stdout = sys.stdout
        sys.stdout = IPython.Shell.Term.cout
                
        try:
            line = self._IP.raw_input(None, self._iter_more)
            if self._IP.autoindent:
                self._IP.readline_startup_hook(None)

        except KeyboardInterrupt:
            self._IP.write('\nKeyboardInterrupt\n')
            self._IP.resetbuffer()
            # keep cache in sync with the prompt counter:
            self._IP.outputcache.prompt_count -= 1

            if self._IP.autoindent:
                self._IP.indent_current_nsp = 0
            self._iter_more = 0
        except:
            self._IP.showtraceback()
        else:
            self._iter_more = self._IP.push(line)
            if (self._IP.SyntaxTB.last_syntax_error and
                    self._IP.rc.autoedit_syntax):
                self._IP.edit_syntax_error()
        if self._iter_more:
            self._prompt = str(self._IP.outputcache.prompt2).strip()
            if self._IP.autoindent:
                self._IP.readline_startup_hook(self._IP.pre_readline)
        else:
            self._prompt = str(self._IP.outputcache.prompt1).strip()
            self._IP.indent_current_nsp = 0 #we set indentation to 0
        sys.stdout = orig_stdout
    
    def _shell(self, ip, cmd):
        '''
        Replacement method to allow shell commands without them blocking.

        @param ip: Ipython instance, same as self._IP
        @type cmd: Ipython instance
        @param cmd: Shell command to execute.
        @type cmd: string
        '''
        stdin, stdout = os.popen4(cmd)
        result = stdout.read().decode('cp437').encode(locale.getpreferredencoding())
        #we use print command because the shell command is called inside IPython instance and thus is
        #redirected to thread cout
        #"\x01\x1b[1;36m\x02" <-- add colour to the text...
        print "\x01\x1b[1;36m\x02"+result
        stdout.close()
        stdin.close()