self.tkconsole.resetoutput()            self.active_seq = None            how, what = response            console = self.tkconsole.console            if how == "OK":                if what is not None:                    print >>console, repr(what)            elif how == "EXCEPTION":                if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):                    self.remote_stack_viewer()            elif how == "ERROR":                errmsg = "PyShell.ModifiedInterpreter: Subprocess ERROR:\n"                print >>sys.__stderr__, errmsg, what                print >>console, errmsg, what            # we received a response to the currently active seq number:            try:                self.tkconsole.endexecuting()            except AttributeError:  # shell may have closed                pass        # Reschedule myself        if not self.tkconsole.closing:            self.tkconsole.text.after(self.tkconsole.pollinterval,                                      self.poll_subprocess)     debugger = None     def setdebugger(self, debugger):        self.debugger = debugger     def getdebugger(self):        return self.debugger     def open_remote_stack_viewer(self):        """Initiate the remote stack viewer from a separate thread.         This method is called from the subprocess, and by returning from this        method we allow the subprocess to unblock.  After a bit the shell        requests the subprocess to open the remote stack viewer which returns a        static object looking at the last exceptiopn.  It is queried through        the RPC mechanism.         """        self.tkconsole.text.after(300, self.remote_stack_viewer)        return     def remote_stack_viewer(self):        import RemoteObjectBrowser        oid = self.rpcclt.remotequeue("exec", "stackviewer", ("flist",), {})        if oid is None:            self.tkconsole.root.bell()            return        item = RemoteObjectBrowser.StubObjectTreeItem(self.rpcclt, oid)        from TreeWidget import ScrolledCanvas, TreeNode        top = Toplevel(self.tkconsole.root)        theme = idleConf.GetOption('main','Theme','name')        background = idleConf.GetHighlight(theme, 'normal')['background']        sc = ScrolledCanvas(top, bg=background, highlightthickness=0)        sc.frame.pack(expand=1, fill="both")        node = TreeNode(sc.canvas, None, item)        node.expand()        # XXX Should GC the remote tree when closing the window     gid = 0     def execsource(self, source):        "Like runsource() but assumes complete exec source"        filename = self.stuffsource(source)        self.execfile(filename, source)     def execfile(self, filename, source=None):        "Execute an existing file"        if source is None:            source = open(filename, "r").read()        try:            code = compile(source, filename, "exec")        except (OverflowError, SyntaxError):            self.tkconsole.resetoutput()            tkerr = self.tkconsole.stderr            print>>tkerr, '*** Error in script or command!\n'            print>>tkerr, 'Traceback (most recent call last):'            InteractiveInterpreter.showsyntaxerror(self, filename)            self.tkconsole.showprompt()        else:            self.runcode(code)     def runsource(self, source):        "Extend base class method: Stuff the source in the line cache first"        filename = self.stuffsource(source)        self.more = 0        self.save_warnings_filters = warnings.filters[:]        warnings.filterwarnings(action="error", category=SyntaxWarning)        if isinstance(source, types.UnicodeType):            import IOBinding            try:                source = source.encode(IOBinding.encoding)            except UnicodeError:                self.tkconsole.resetoutput()                self.write("Unsupported characters in input\n")                return        try:            # InteractiveInterpreter.runsource() calls its runcode() method,            # which is overridden (see below)            return InteractiveInterpreter.runsource(self, source, filename)        finally:            if self.save_warnings_filters is not None:                warnings.filters[:] = self.save_warnings_filters                self.save_warnings_filters = None     def stuffsource(self, source):        "Stuff source in the filename cache"        filename = "<pyshell#%d>" % self.gid        self.gid = self.gid + 1        lines = source.split("\n")        linecache.cache[filename] = len(source)+1, 0, lines, filename        return filename     def prepend_syspath(self, filename):        "Prepend sys.path with file's directory if not already included"        self.runcommand("""if 1:            _filename = %r            import sys as _sys            from os.path import dirname as _dirname            _dir = _dirname(_filename)            if not _dir in _sys.path:                _sys.path.insert(0, _dir)            del _filename, _sys, _dirname, _dir            \n""" % (filename,))     def showsyntaxerror(self, filename=None):        """Extend base class method: Add Colorizing         Color the offending position instead of printing it and pointing at it        with a caret.         """        text = self.tkconsole.text        stuff = self.unpackerror()        if stuff:            msg, lineno, offset, line = stuff            if lineno == 1:                pos = "iomark + %d chars" % (offset-1)            else:                pos = "iomark linestart + %d lines + %d chars" % \                      (lineno-1, offset-1)            text.tag_add("ERROR", pos)            text.see(pos)            char = text.get(pos)            if char and char in IDENTCHARS:                text.tag_add("ERROR", pos + " wordstart", pos)            self.tkconsole.resetoutput()            self.write("SyntaxError: %s\n" % str(msg))        else:            self.tkconsole.resetoutput()            InteractiveInterpreter.showsyntaxerror(self, filename)        self.tkconsole.showprompt()     def unpackerror(self):        type, value, tb = sys.exc_info()        ok = type is SyntaxError        if ok:            try:                msg, (dummy_filename, lineno, offset, line) = value                if not offset:                    offset = 0            except:                ok = 0        if ok:            return msg, lineno, offset, line        else:            return None     def showtraceback(self):        "Extend base class method to reset output properly"        self.tkconsole.resetoutput()        self.checklinecache()        InteractiveInterpreter.showtraceback(self)        if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):            self.tkconsole.open_stack_viewer()     def checklinecache(self):        c = linecache.cache        for key in c.keys():            if key[:1] + key[-1:] != "<>":                del c[key]     def runcommand(self, code):        "Run the code without invoking the debugger"        # The code better not raise an exception!        if self.tkconsole.executing:            self.display_executing_dialog()            return 0        if self.rpcclt:            self.rpcclt.remotequeue("exec", "runcode", (code,), {})        else:            exec code in self.locals        return 1     def runcode(self, code):        "Override base class method"        if self.tkconsole.executing:            self.interp.restart_subprocess()        self.checklinecache()        if self.save_warnings_filters is not None:            warnings.filters[:] = self.save_warnings_filters            self.save_warnings_filters = None        debugger = self.debugger        try:            self.tkconsole.beginexecuting()            try:                if not debugger and self.rpcclt is not None:                    self.active_seq = self.rpcclt.asyncqueue("exec", "runcode",                                                            (code,), {})                elif debugger:                    debugger.run(code, self.locals)                else:                    exec code in self.locals            except SystemExit:                if not self.tkconsole.closing:                    if tkMessageBox.askyesno(                        "Exit?",                        "Do you want to exit altogether?",                        default="yes",                        master=self.tkconsole.text):                        raise                    else:                        self.showtraceback()                else:                    raise            except:                if use_subprocess:                    print >> self.tkconsole.stderr, \                             "IDLE internal error in runcode()"                self.showtraceback()                if use_subprocess:                    self.tkconsole.endexecuting()        finally:            if not use_subprocess:                try:                    self.tkconsole.endexecuting()                except AttributeError:  # shell may have closed                    pass     def write(self, s):        "Override base class method"        self.tkconsole.stderr.write(s)     def display_port_binding_error(self):        tkMessageBox.showerror(            "Port Binding Error",            "IDLE can't bind TCP/IP port 8833, which is necessary to "            "communicate with its Python execution server.  Either "            "no networking is installed on this computer or another "            "process (another IDLE?) is using the port.  Run IDLE with the -n "            "command line switch to start without a subprocess and refer to "            "Help/IDLE Help 'Running without a subprocess' for further "            "details.",            master=self.tkconsole.text)     def display_no_subprocess_error(self):        tkMessageBox.showerror(            "Subprocess Startup Error",            "IDLE's subprocess didn't make connection.  Either IDLE can't "            "start a subprocess or personal firewall software is blocking "            "the connection.",            master=self.tkconsole.text)     def display_executing_dialog(self):        tkMessageBox.showerror(            "Already executing",            "The Python Shell window is already executing a command; "            "please wait until it is finished.",            master=self.tkconsole.text)  class PyShell(OutputWindow):     shell_title = "Python Shell"     # Override classes    ColorDelegator = ModifiedColorDelegator    UndoDelegator = ModifiedUndoDelegator     # Override menus    menu_specs = [        ("file", "_File"),        ("edit", "_Edit"),        ("debug", "_Debug"),        ("options", "_Options"),        ("windows", "_Windows"),        ("help", "_Help"),    ]     if macosxSupport.runningAsOSXApp():        del menu_specs[-3]        menu_specs[-2] = ("windows", "_Window")      # New classes    from IdleHistory import History     def __init__(self, flist=None):        if use_subprocess:            ms = self.menu_specs            if ms[2][0] != "shell":                ms.insert(2, ("shell", "She_ll"))        self.interp = ModifiedInterpreter(self)        if flist is None:            root = Tk()            fixwordbreaks(root)            root.withdraw()            flist = PyShellFileList(root)        #        OutputWindow.__init__(self, flist, None, None)        ###        self.config(usetabs=1, indentwidth=8, context_use_ps1=1)        self.usetabs = True        # indentwidth must be 8 when using tabs.  See note in EditorWindow:        self.indentwidth = 8        self.context_use_ps1 = True        #        text = self.text        text.configure(wrap="char")        text.bind("<<newline-and-indent>>", self.enter_callback)        text.bind("<<plain-newline-and-indent>>", self.linefeed_callback)        text.bind("<<interrupt-execution>>", self.cancel_callback)        text.bind("<<beginning-of-line>>", self.home_callback)        text.bind("<<end-of-file>>", self.eof_callback)        text.bind("<<open-stack-viewer>>", self.open_stack_viewer)        text.bind("<<toggle-debugger>>", self.toggle_debugger)        text.bind("<<toggle-jit-stack-viewer>>", self.toggle_jit_stack_viewer)        if use_subprocess:            text.bind("<<view-restart>>", self.view_restart_mark)            text.bind("<<restart-shell>>", self.restart_shell)        #        self.save_stdout = sys.stdout        self.save_stderr = sys.stderr        self.save_stdin = sys.stdin        import IOBinding        self.stdout = PseudoFile(self, "stdout", IOBinding.encoding)        self.stderr = PseudoFile(self, "stderr", IOBinding.encoding)        self.console = PseudoFile(self, "console", IOBinding.encoding)        if not use_subprocess:            sys.stdout = self.stdout            sys.stderr = self.stderr            sys.stdin = self        #        self.history = self.History(self.text)        #        self.pollinterval = 50  # millisec     def get_standard_extension_names(self):        return idleConf.GetExtensions(shell_only=True)     reading = False    executing = False    canceled = False    endoffile = False    closing = False     def set_warning_stream(self, stream):        global warning_stream        warning_stream = stream     def get_warning_stream(self):        return warning_stream     def toggle_debugger(self, event=None):        if self.executing:            tkMessageBox.showerror("Don't debug now",                "You can only toggle the debugger when idle",                master=self.text)            self.set_debugger_indicator()            return "break"        else:            db = self.interp.getdebugger()            if db:                self.close_debugger()            else:                self.open_debugger()     def set_debugger_indicator(self):        db = self.interp.getdebugger()        self.setvar("<<toggle-debugger>>", not not db)     def toggle_jit_stack_viewer(self, event=None):        pass # All we need is the variable     def close_debugger(self):        db = self.interp.getdebugger()        if db:            self.interp.setdebugger(None)            db.close()            if self.interp.rpcclt:                RemoteDebugger.close_remote_debugger(self.interp.rpcclt)            self.resetoutput()            self.console.write("[DEBUG OFF]\n")            sys.ps1 = ">>> "            self.showprompt()        self.set_debugger_indicator()     def open_debugger(self):        if self.interp.rpcclt:            dbg_gui = RemoteDebugger.start_remote_debugger(self.interp.rpcclt,                                                           self)        else:            dbg_gui = Debugger.Debugger(self)        self.interp.setdebugger(dbg_gui)        dbg_gui.load_breakpoints()        sys.ps1 = "[DEBUG ON]\n>>> "        self.showprompt()        self.set_debugger_indicator()     def beginexecuting(self):        "Helper for ModifiedInterpreter"        self.resetoutput()        self.executing = 1     def endexecuting(self):        "Helper for ModifiedInterpreter"        self.executing = 0        self.canceled = 0        self.showprompt()     def close(self):        "Extend EditorWindow.close()"        if self.executing:            response = tkMessageBox.askokcancel(                "Kill?",                "The program is still running!\n Do you want to kill it?",                default="ok",                parent=self.text)            if response == False:                return "cancel"        if self.reading:            self.top.quit()        self.canceled = True        self.closing = True        # Wait for poll_subprocess() rescheduling to stop        self.text.after(2 * self.pollinterval, self.close2)     def close2(self):        return EditorWindow.close(self)     def _close(self):        "Extend EditorWindow._close(), shut down debugger and execution server"        self.close_debugger()        if use_subprocess:            self.interp.kill_subprocess()        # Restore std streams        sys.stdout = self.save_stdout        sys.stderr = self.save_stderr        sys.stdin = self.save_stdin        # Break cycles        self.interp = None        self.console = None        self.flist.pyshell = None        self.history = None        EditorWindow._close(self)     def ispythonsource(self, filename):        "Override EditorWindow method: never remove the colorizer"        return True     def short_title(self):        return self.shell_title     COPYRIGHT = \          'Type "copyright", "credits" or "license()" for more information.'     firewallmessage = """    ****************************************************************    Personal firewall software may warn about the connection IDLE    makes to its subprocess using this computer's internal loopback    interface.  This connection is not visible on any external    interface and no data is sent to or received from the Internet.    ****************************************************************    """     def begin(self):        self.resetoutput()        if use_subprocess:            nosub = ''            client = self.interp.start_subprocess()            if not client:                self.close()                return False        else:            nosub = "==== No Subprocess ===="        self.write("Python %s on %s\n%s\n%s\nIDLE %s      %s\n" %                   (sys.version, sys.platform, self.COPYRIGHT,                    self.firewallmessage, idlever.IDLE_VERSION, nosub))        self.showprompt()        import Tkinter        Tkinter._default_root = None # 03Jan04 KBK What's this?        return True     def readline(self):        save = self.reading        try:            self.reading = 1

Lines 501–1000 of 1441. Previous lines Load more