Make "help()" work.

IPython/frontend/prefilterfrontend.py

@@ -1,139 +1,141 b''
 """
 Frontend class that uses IPython0 to prefilter the inputs.
 
 Using the IPython0 mechanism gives us access to the magics.
 """
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 import sys
 
 from linefrontendbase import LineFrontEndBase, common_prefix
 
 from IPython.ipmaker import make_IPython
 from IPython.ipapi import IPApi
 from IPython.kernel.core.sync_output_trap import SyncOutputTrap
 
 from IPython.genutils import Term
 
 #-------------------------------------------------------------------------------
 # Utility functions (temporary, should be moved out of here)
 #-------------------------------------------------------------------------------
 import os
 def xterm_system(command):
     """ Run a command in a separate console window.
     """
     os.system("""
     xterm -title "%s" -e \'/bin/sh -c "%s ; 
     printf \\"\\\\n\\"; 
     printf \\"press a key to close\\" ; 
     printf \\"\x1b]0;%s (finished -- press a key to close)\x07\\" ;
     read foo;"\'
     """  % (command, command, command) )
 
 #-------------------------------------------------------------------------------
 # Frontend class using ipython0 to do the prefiltering. 
 #-------------------------------------------------------------------------------
 class PrefilterFrontEnd(LineFrontEndBase):
     
     def __init__(self, *args, **kwargs):
         LineFrontEndBase.__init__(self, *args, **kwargs)
         # Instanciate an IPython0 interpreter to be able to use the
         # prefiltering.
         self.ipython0 = make_IPython()
         # Set the pager:
         self.ipython0.set_hook('show_in_pager', 
                     lambda s, string: self.write("\n"+string))
         self.ipython0.write = self.write
         self._ip = _ip = IPApi(self.ipython0)
         # XXX: Hack: mix the two namespaces
         self.shell.user_ns = self.ipython0.user_ns
         self.shell.user_global_ns = self.ipython0.user_global_ns
         # Make sure the raw system call doesn't get called, as we don't
         # have a stdin accessible.
         self._ip.system = xterm_system
         # Redefine a serie of magics to avoid os.system:
         # FIXME: I am redefining way too much magics.
         for alias_name, (_, alias_value) in \
                     _ip.IP.shell.alias_table.iteritems():
             magic = lambda s : _ip.magic('sx %s %s' % (alias_value, s))
             setattr(_ip.IP, 'magic_%s' % alias_name, magic)
         # FIXME: I should create a real file-like object dedicated to this
         # terminal
         self.shell.output_trap = SyncOutputTrap(write_out=self.write,
                                                 write_err=self.write)
 
+        import pydoc
+        pydoc.help.output = self.shell.output_trap.out
 
     
     def prefilter_input(self, input_string):
         """ Using IPython0 to prefilter the commands.
         """
         input_string = LineFrontEndBase.prefilter_input(self, input_string)
         filtered_lines = []
         # The IPython0 prefilters sometime produce output. We need to
         # capture it.
         self.capture_output()
         self.last_result = dict(number=self.prompt_number)
         try:
             for line in input_string.split('\n'):
                 filtered_lines.append(self.ipython0.prefilter(line, False))
         except:
             # XXX: probably not the right thing to do.
             self.ipython0.showsyntaxerror()
             self.after_execute()
         finally:
             self.release_output()
 
         filtered_string = '\n'.join(filtered_lines)
         return filtered_string
 
 
     def show_traceback(self):
         self.capture_output()
         self.ipython0.showtraceback()
         self.release_output()
 
 
     def capture_output(self):
         """ Capture all the output mechanism we can think of.
         """
         self.__old_cout_write = Term.cout.write
         self.__old_err_write = Term.cerr.write
         Term.cout.write = self.write
         Term.cerr.write = self.write
         self.__old_stdout = sys.stdout
         self.__old_stderr= sys.stderr
         sys.stdout = Term.cout
         sys.stderr = Term.cerr
-        # FIXME: I still need to provide the writelines method
+
 
     def release_output(self):
         """ Release all the different captures we have made,
             and flush the buffers.
         """
         Term.cout.write = self.__old_cout_write
         Term.cerr.write = self.__old_err_write
         sys.stdout = self.__old_stdout
         sys.stderr = self.__old_stderr
 
 
     def complete(self, line):
         word = line.split('\n')[-1].split(' ')[-1]
         completions = self.ipython0.complete(word)
         key = lambda x: x.replace('_', '')
         completions.sort(key=key)
         if completions:
             prefix = common_prefix(completions) 
             line = line[:-len(word)] + prefix
         return line, completions 
  
 

IPython/frontend/wx/wx_frontend.py

@@ -1,252 +1,254 b''
 # encoding: utf-8 -*- test-case-name:
 # FIXME: Need to add tests.
 # ipython1.frontend.cocoa.tests.test_cocoa_frontend -*-
 
 """Classes to provide a Wx frontend to the
 IPython.kernel.core.interpreter.
 
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #       Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 
 import wx
 import re
 from wx import stc
 from console_widget import ConsoleWidget
 import __builtin__
 from time import sleep
 
 from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
 
 #_COMMAND_BG = '#FAFAF1' # Nice green
 _RUNNING_BUFFER_BG = '#FDFFD3' # Nice yellow
 _ERROR_BG = '#FFF1F1' # Nice red
 
 _RUNNING_BUFFER_MARKER = 31
 _ERROR_MARKER = 30
 
 #-------------------------------------------------------------------------------
 # Classes to implement the Wx frontend
 #-------------------------------------------------------------------------------
 class WxController(PrefilterFrontEnd, ConsoleWidget):
 
     output_prompt = \
     '\x01\x1b[0;31m\x02Out[\x01\x1b[1;31m\x02%i\x01\x1b[0;31m\x02]: \x01\x1b[0m\x02'
   
     #--------------------------------------------------------------------------
     # Public API
     #--------------------------------------------------------------------------
  
     def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition,
                  size=wx.DefaultSize, style=wx.CLIP_CHILDREN,
                  *args, **kwds):
         """ Create Shell instance.
         """
         ConsoleWidget.__init__(self, parent, id, pos, size, style)
         PrefilterFrontEnd.__init__(self)
 
         # Capture Character keys
         self.Bind(wx.EVT_KEY_DOWN, self._on_key_down)
 
         # Marker for running buffer.
         self.MarkerDefine(_RUNNING_BUFFER_MARKER, stc.STC_MARK_BACKGROUND,
                                 background=_RUNNING_BUFFER_BG)
         # Marker for tracebacks.
         self.MarkerDefine(_ERROR_MARKER, stc.STC_MARK_BACKGROUND,
                                 background=_ERROR_BG)
 
 
 
     def do_completion(self):
         """ Do code completion. 
         """
         line = self.get_current_edit_buffer()
         new_line, completions = self.complete(line)
         if len(completions)>1:
             self.write_completion(completions)
         self.replace_current_edit_buffer(new_line)
 
 
     def do_calltip(self):
         separators =  re.compile('[\s\{\}\[\]\(\)\= ,:]')
         symbol = self.get_current_edit_buffer()
         symbol_string = separators.split(symbol)[-1]
         base_symbol_string = symbol_string.split('.')[0]
         if base_symbol_string in self.shell.user_ns:
             symbol = self.shell.user_ns[base_symbol_string]
         elif base_symbol_string in self.shell.user_global_ns:
             symbol = self.shell.user_global_ns[base_symbol_string]
         elif base_symbol_string in __builtin__.__dict__:
             symbol = __builtin__.__dict__[base_symbol_string]
         else:
             return False
         for name in symbol_string.split('.')[1:] + ['__doc__']:
             symbol = getattr(symbol, name)
         try:
             self.AutoCompCancel()
             wx.Yield()
             self.CallTipShow(self.GetCurrentPos(), symbol)
         except:
             # The retrieve symbol couldn't be converted to a string
             pass
 
 
     def popup_completion(self, create=False):
         """ Updates the popup completion menu if it exists. If create is 
             true, open the menu.
         """
         line = self.get_current_edit_buffer()
         if (self.AutoCompActive() and not line[-1] == '.') \
                     or create==True:
             suggestion, completions = self.complete(line)
             offset=0
             if completions:
                 complete_sep =  re.compile('[\s\{\}\[\]\(\)\= ,:]')
                 residual = complete_sep.split(line)[-1]
                 offset = len(residual)
                 self.pop_completion(completions, offset=offset)
 
 
     def raw_input(self, prompt):
         """ A replacement from python's raw_input.
         """
         self.new_prompt(prompt)
         self.waiting = True
         self.__old_on_enter = self._on_enter
         def my_on_enter():
             self.waiting = False
         self._on_enter = my_on_enter
         # XXX: Busy waiting, ugly.
         while self.waiting:
             wx.Yield()
             sleep(0.1)
         self._on_enter = self.__old_on_enter
         return self.get_current_edit_buffer().rstrip('\n')
         
  
     def execute(self, python_string, raw_string=None):
         self.CallTipCancel()
         self._cursor = wx.BusyCursor()
         if raw_string is None:
             raw_string = python_string
         end_line = self.current_prompt_line \
                         + max(1,  len(raw_string.split('\n'))-1)
         for i in range(self.current_prompt_line, end_line):
             self.MarkerAdd(i, _RUNNING_BUFFER_MARKER)
         # Update the display:
         wx.Yield()
         ## Remove the trailing "\n" for cleaner display
         #self.SetSelection(self.GetLength()-1, self.GetLength())
         #self.ReplaceSelection('')
         self.GotoPos(self.GetLength())
         self.__old_raw_input = __builtin__.raw_input
         __builtin__.raw_input = self.raw_input
         PrefilterFrontEnd.execute(self, python_string, raw_string=raw_string)
         __builtin__.raw_input = self.__old_raw_input
 
 
     def after_execute(self):
         PrefilterFrontEnd.after_execute(self)
         if hasattr(self, '_cursor'):
             del self._cursor
 
 
     def show_traceback(self):
         start_line = self.GetCurrentLine()
         PrefilterFrontEnd.show_traceback(self)
         wx.Yield()
         for i in range(start_line, self.GetCurrentLine()):
             self.MarkerAdd(i, _ERROR_MARKER)
             
 
     #--------------------------------------------------------------------------
     # Private API
     #--------------------------------------------------------------------------
  
 
     def _on_key_down(self, event, skip=True):
         """ Capture the character events, let the parent
             widget handle them, and put our logic afterward.
         """
         current_line_number = self.GetCurrentLine()
+        # Calltips
         if event.KeyCode == ord('('):
             event.Skip()
             self.do_calltip()
         elif self.AutoCompActive():
             event.Skip()
             if event.KeyCode in (wx.WXK_BACK, wx.WXK_DELETE): 
                 wx.CallAfter(self.popup_completion, create=True)
             elif not event.KeyCode in (wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT,
                             wx.WXK_RIGHT):
                 wx.CallAfter(self.popup_completion)
         else:
             # Up history
             if event.KeyCode == wx.WXK_UP and (
                     ( current_line_number == self.current_prompt_line and
                         event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN) ) 
                     or event.ControlDown() ):
                 new_buffer = self.get_history_previous(
                                             self.get_current_edit_buffer())
                 if new_buffer is not None:
                     self.replace_current_edit_buffer(new_buffer)
                     if self.GetCurrentLine() > self.current_prompt_line:
                         # Go to first line, for seemless history up.
                         self.GotoPos(self.current_prompt_pos)
             # Down history
             elif event.KeyCode == wx.WXK_DOWN and (
                     ( current_line_number == self.LineCount -1 and
                         event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN) ) 
                     or event.ControlDown() ):
                 new_buffer = self.get_history_next()
                 if new_buffer is not None:
                     self.replace_current_edit_buffer(new_buffer)
+            # Tab-completion
             elif event.KeyCode == ord('\t'):
                 last_line = self.get_current_edit_buffer().split('\n')[-1]
                 if not re.match(r'^\s*$', last_line):
                     self.do_completion()
                 else:
                     event.Skip()
             else:
                 ConsoleWidget._on_key_down(self, event, skip=skip)
 
 
     def _on_key_up(self, event, skip=True):
         if event.KeyCode == 59:
             # Intercepting '.'
             event.Skip()
             self.popup_completion(create=True)
         else:
             ConsoleWidget._on_key_up(self, event, skip=skip)
 
 
 if __name__ == '__main__':
     class MainWindow(wx.Frame):
         def __init__(self, parent, id, title):
             wx.Frame.__init__(self, parent, id, title, size=(300,250))
             self._sizer = wx.BoxSizer(wx.VERTICAL)
             self.shell = WxController(self)
             self._sizer.Add(self.shell, 1, wx.EXPAND)
             self.SetSizer(self._sizer)
             self.SetAutoLayout(1)
             self.Show(True)
 
     app = wx.PySimpleApp()
     frame = MainWindow(None, wx.ID_ANY, 'Ipython')
     frame.shell.SetFocus()
     frame.SetSize((680, 460))
     self = frame.shell
 
     app.MainLoop()