def __init__(self, argv=None, banner='', exit_msg=None, rc_override=None): """Note that argv here is a string, NOT a list.""" self.set_banner(banner) self.set_exit_msg(exit_msg) self.set_dummy_mode(0) # sys.displayhook is a global, we need to save the user's original # Don't rely on __displayhook__, as the user may have changed that. self.sys_displayhook_ori = sys.displayhook # save readline completer status try: #print 'Save completer',sys.ipcompleter # dbg self.sys_ipcompleter_ori = sys.ipcompleter except: pass # not nested with IPython # FIXME. Passing user_ns breaks namespace handling. #self.IP = make_IPython(argv,user_ns=__main__.__dict__) self.IP = make_IPython(argv, rc_override=rc_override, embedded=True) self.IP.name_space_init() # mark this as an embedded instance so we know if we get a crash # post-mortem self.IP.rc.embedded = 1 # copy our own displayhook also self.sys_displayhook_embed = sys.displayhook # and leave the system's display hook clean sys.displayhook = self.sys_displayhook_ori # don't use the ipython crash handler so that user exceptions aren't # trapped sys.excepthook = ultraTB.FormattedTB(color_scheme=self.IP.rc.colors, mode=self.IP.rc.xmode, call_pdb=self.IP.rc.pdb) self.restore_system_completer()
def __init__(self,argv=None,banner='',exit_msg=None,rc_override=None, user_ns=None): """Note that argv here is a string, NOT a list.""" self.set_banner(banner) self.set_exit_msg(exit_msg) self.set_dummy_mode(0) # sys.displayhook is a global, we need to save the user's original # Don't rely on __displayhook__, as the user may have changed that. self.sys_displayhook_ori = sys.displayhook # save readline completer status try: #print 'Save completer',sys.ipcompleter # dbg self.sys_ipcompleter_ori = sys.ipcompleter except: pass # not nested with IPython self.IP = make_IPython(argv,rc_override=rc_override, embedded=True, user_ns=user_ns) ip = ipapi.IPApi(self.IP) ip.expose_magic("kill_embedded",kill_embedded) # copy our own displayhook also self.sys_displayhook_embed = sys.displayhook # and leave the system's display hook clean sys.displayhook = self.sys_displayhook_ori # don't use the ipython crash handler so that user exceptions aren't # trapped sys.excepthook = ultraTB.FormattedTB(color_scheme = self.IP.rc.colors, mode = self.IP.rc.xmode, call_pdb = self.IP.rc.pdb) self.restore_system_completer()
def __init__(self, argv=None, banner='', exit_msg=None, rc_override=None, user_ns=None, callback=None): self.set_banner(banner) self.set_exit_msg(exit_msg) self.set_dummy_mode(0) self.sys_displayhook_ori = sys.displayhook try: self.sys_ipcompleter_ori = sys.ipcompleter except: pass self.IP = make_IPython(argv, rc_override=rc_override, embedded=True, user_ns=user_ns, shell_class=InteractiveShellMadcow) self.IP.callback = callback ip = ipapi.IPApi(self.IP) ip.expose_magic(u"kill_embedded", kill_embedded) self.sys_displayhook_embed = sys.displayhook sys.displayhook = self.sys_displayhook_ori sys.excepthook = ultraTB.FormattedTB(color_scheme=self.IP.rc.colors, mode=self.IP.rc.xmode, call_pdb=self.IP.rc.pdb) self.restore_system_completer()
def __init__(self, namespace=None): if namespace is None: namespace = {} self.namespace = namespace self.last_repr = None self.excepthook = ultraTB.FormattedTB(mode='Verbose', color_scheme='NoColor')
def main(): sys.excepthook = ultraTB.FormattedTB(mode='Context') if (len(sys.argv) > 1): tests = [sys.argv[1]] else: tests = TESTS tests.sort() for test in tests: check(test) sys.exit(0)
def __init__(self, locals=None, filename="<console>"): """Creates a new TrappingInteractiveConsole object.""" InteractiveConsole.__init__(self, locals, filename) self._trap = OutputTrap(debug=0) self._stdin = [] self._stdout = [] self._stderr = [] self._last_type = self._last_traceback = self._last_value = None #self._namespace_lock = threading.Lock() #self._command_lock = threading.Lock() self.lastCommandIndex = -1 # I am using this user defined signal to interrupt the currently # running command. I am not sure if this is the best way, but # it is working! # This doesn't work on Windows as it doesn't have this signal. #signal.signal(signal.SIGUSR1, self._handleSIGUSR1) # An exception handler. Experimental: later we need to make the # modes/colors available to user configuration, etc. self.tbHandler = ultraTB.FormattedTB(color_scheme='NoColor', mode='Context', tb_offset=2)
def __init__(self, namespace=None, translator=None, magic=None, display_formatters=None, traceback_formatters=None, output_trap=None, history=None, message_cache=None, filename='<string>', config=None): # The namespace. if namespace is None: namespace = {} self.namespace = namespace # An object that will translate commands into executable Python. # The current translator does not work properly so for now we are going # without! # if translator is None: # from ipython1.core.translator import IPythonTranslator # translator = IPythonTranslator() self.translator = translator # An object that maintains magic commands. if magic is None: from ipython1.core.magic import Magic magic = Magic(self) self.magic = magic # A list of formatters for the displayhook. if display_formatters is None: display_formatters = default_display_formatters() self.display_formatters = display_formatters # A list of formatters for tracebacks. if traceback_formatters is None: traceback_formatters = default_traceback_formatters() self.traceback_formatters = traceback_formatters # The object trapping stdout/stderr. if output_trap is None: from ipython1.core.output_trap import OutputTrap output_trap = OutputTrap() self.output_trap = output_trap # An object that manages the history. if history is None: from ipython1.core.history import History history = History() self.history = history # An object that caches all of the return messages. if message_cache is None: from ipython1.core.message_cache import SimpleMessageCache message_cache = SimpleMessageCache() self.message_cache = message_cache # The "filename" of the code that is executed in this interpreter. self.filename = filename # An object that contains much configuration information. if config is None: # fixme: Move this constant elsewhere! config = Bunch(ESC_MAGIC='%') self.config = config # Hook managers. # fixme: make the display callbacks configurable. In the meantime, # enable macros. self.display_trap = DisplayTrap( formatters=self.display_formatters, callbacks=[self._possible_macro], ) self.traceback_trap = TracebackTrap( formatters=self.traceback_formatters) # This is used temporarily for reformating exceptions in certain # cases. It will go away once the ultraTB stuff is ported # to ipython1 self.tbHandler = ultraTB.FormattedTB(color_scheme='NoColor', mode='Context', tb_offset=2) # An object that can compile commands and remember __future__ # statements. self.command_compiler = codeop.CommandCompiler() # A replacement for the raw_input() and input() builtins. Change these # attributes later to configure them. self.raw_input_builtin = raw_input self.input_builtin = input # The number of the current cell. self.current_cell_number = 1 # This is the message dictionary assigned temporarily when running the # code. self.message = None self.setup_namespace()
sys.path[0:0] = [oldpath] import wx delta_time('wx loaded') #dbg from nbshell.utils import * from nbshell import ipnNotebookWidget,ipnDocument,frame,tester from ipnNotebookWidget import * # in case you wonder ipn comes from Interactive Python Notebook from ipnDocument import * from frame import ipnFrame delta_time('nbshell modules loaded') #dbg from IPython import ultraTB # For developer use: let's park a nice formatted traceback printer in # here. Once this becomes more stable we can use a CrashHandler, but # for now this will be nice to get feedback. sys.excepthook = ultraTB.FormattedTB(mode='Context',color_scheme='Linux') #test the excepthook class App(wx.App): """Application class.""" plugin_dir = "." #this should be configured somewhere plugin_dict = {} def __init__(self, *args, **kwds): wx.App.__init__(self, *args, **kwds) self.mainloop = False self.test = False def RegisterPlugins(self): """Seeks for plugins and gets their factory objects"""
def __init__(self, user_ns=None, global_ns=None, translator=None, magic=None, display_formatters=None, traceback_formatters=None, output_trap=None, history=None, message_cache=None, filename='<string>', config=None): # The local/global namespaces for code execution local_ns = user_ns # compatibility name if local_ns is None: local_ns = {} self.user_ns = local_ns # The local namespace if global_ns is None: global_ns = {} self.user_global_ns = global_ns # An object that will translate commands into executable Python. # The current translator does not work properly so for now we are going # without! # if translator is None: # from IPython.kernel.core.translator import IPythonTranslator # translator = IPythonTranslator() self.translator = translator # An object that maintains magic commands. if magic is None: from IPython.kernel.core.magic import Magic magic = Magic(self) self.magic = magic # A list of formatters for the displayhook. if display_formatters is None: display_formatters = default_display_formatters() self.display_formatters = display_formatters # A list of formatters for tracebacks. if traceback_formatters is None: traceback_formatters = default_traceback_formatters() self.traceback_formatters = traceback_formatters # The object trapping stdout/stderr. if output_trap is None: from IPython.kernel.core.output_trap import OutputTrap output_trap = OutputTrap() self.output_trap = output_trap # An object that manages the history. if history is None: from IPython.kernel.core.history import InterpreterHistory history = InterpreterHistory() self.history = history self.get_history_item = history.get_history_item self.get_history_input_cache = history.get_input_cache self.get_history_input_after = history.get_input_after # An object that caches all of the return messages. if message_cache is None: from IPython.kernel.core.message_cache import SimpleMessageCache message_cache = SimpleMessageCache() self.message_cache = message_cache # The "filename" of the code that is executed in this interpreter. self.filename = filename # An object that contains much configuration information. if config is None: # fixme: Move this constant elsewhere! config = Bunch(ESC_MAGIC='%') self.config = config # Hook managers. # fixme: make the display callbacks configurable. In the meantime, # enable macros. self.display_trap = DisplayTrap( formatters=self.display_formatters, callbacks=[self._possible_macro], ) self.traceback_trap = TracebackTrap( formatters=self.traceback_formatters) # This is used temporarily for reformating exceptions in certain # cases. It will go away once the ultraTB stuff is ported # to ipython1 self.tbHandler = ultraTB.FormattedTB(color_scheme='NoColor', mode='Context', tb_offset=2) # An object that can compile commands and remember __future__ # statements. self.command_compiler = codeop.CommandCompiler() # A replacement for the raw_input() and input() builtins. Change these # attributes later to configure them. self.raw_input_builtin = raw_input self.input_builtin = input # The number of the current cell. self.current_cell_number = 1 # Initialize cache, set in/out prompts and printing system self.outputcache = CachedOutput(self, rc.cache_size, rc.pprint, input_sep=rc.separate_in, output_sep=rc.separate_out, output_sep2=rc.separate_out2, ps1=rc.prompt_in1, ps2=rc.prompt_in2, ps_out=rc.prompt_out, pad_left=rc.prompts_pad_left) # Need to decide later if this is the right approach, but clients # commonly use sys.ps1/2, so it may be best to just set them here sys.ps1 = self.outputcache.prompt1.p_str sys.ps2 = self.outputcache.prompt2.p_str # This is the message dictionary assigned temporarily when running the # code. self.message = None self.setup_namespace()