golden hour

/usr/lib64/python2.7/idlelib

File/Folder	Size	Actions
AutoComplete.py	8.79 KB
AutoComplete.pyc	7.69 KB
AutoComplete.pyo	7.69 KB
AutoCompleteWindow.py	16.8 KB
AutoCompleteWindow.pyc	12.15 KB
AutoCompleteWindow.pyo	12.09 KB
AutoExpand.py	2.42 KB
AutoExpand.pyc	2.5 KB
AutoExpand.pyo	2.5 KB
Bindings.py	3.22 KB
Bindings.pyc	4.76 KB
Bindings.pyo	4.76 KB
CREDITS.txt	1.82 KB
CallTipWindow.py	5.98 KB
CallTipWindow.pyc	6.14 KB
CallTipWindow.pyo	6.14 KB
CallTips.py	7.75 KB
CallTips.pyc	10.14 KB
CallTips.pyo	10.14 KB
ChangeLog	55.07 KB
ClassBrowser.py	6.22 KB
ClassBrowser.pyc	8.95 KB
ClassBrowser.pyo	8.95 KB
CodeContext.py	8.15 KB
CodeContext.pyc	6.52 KB
CodeContext.pyo	6.47 KB
ColorDelegator.py	10.13 KB
ColorDelegator.pyc	8.71 KB
ColorDelegator.pyo	8.71 KB
Debugger.py	15.45 KB
Debugger.pyc	16.55 KB
Debugger.pyo	16.55 KB
Delegator.py	831 B
Delegator.pyc	1.58 KB
Delegator.pyo	1.58 KB
EditorWindow.py	63.29 KB
EditorWindow.pyc	55.13 KB
EditorWindow.pyo	55.03 KB
FileList.py	3.57 KB
FileList.pyc	3.86 KB
FileList.pyo	3.82 KB
FormatParagraph.py	5.66 KB
FormatParagraph.pyc	4.69 KB
FormatParagraph.pyo	4.69 KB
GrepDialog.py	3.96 KB
GrepDialog.pyc	4.9 KB
GrepDialog.pyo	4.9 KB
HISTORY.txt	10.08 KB
HyperParser.py	10.31 KB
HyperParser.pyc	6.49 KB
HyperParser.pyo	6.49 KB
IOBinding.py	20.69 KB
IOBinding.pyc	17.16 KB
IOBinding.pyo	17.16 KB
Icons	-
IdleHistory.py	3.07 KB
IdleHistory.pyc	3.13 KB
IdleHistory.pyo	3.13 KB
MultiCall.py	17.07 KB
MultiCall.pyc	15.55 KB
MultiCall.pyo	15.48 KB
MultiStatusBar.py	783 B
MultiStatusBar.pyc	1.49 KB
MultiStatusBar.pyo	1.49 KB
NEWS.txt	28.32 KB
ObjectBrowser.py	4.05 KB
ObjectBrowser.pyc	6.56 KB
ObjectBrowser.pyo	6.56 KB
OutputWindow.py	4.47 KB
OutputWindow.pyc	5.11 KB
OutputWindow.pyo	5.11 KB
ParenMatch.py	6.47 KB
ParenMatch.pyc	6.82 KB
ParenMatch.pyo	6.82 KB
PathBrowser.py	2.58 KB
PathBrowser.pyc	4.02 KB
PathBrowser.pyo	4.02 KB
Percolator.py	2.55 KB
Percolator.pyc	3.55 KB
Percolator.pyo	3.37 KB
PyParse.py	19.05 KB
PyParse.pyc	9.77 KB
PyParse.pyo	9.34 KB
PyShell.py	54.81 KB
PyShell.pyc	49.14 KB
PyShell.pyo	49.04 KB
README.txt	2.56 KB
RemoteDebugger.py	11.38 KB
RemoteDebugger.pyc	15.97 KB
RemoteDebugger.pyo	15.82 KB
RemoteObjectBrowser.py	942 B
RemoteObjectBrowser.pyc	2.1 KB
RemoteObjectBrowser.pyo	2.1 KB
ReplaceDialog.py	5.69 KB
ReplaceDialog.pyc	6.32 KB
ReplaceDialog.pyo	6.32 KB
RstripExtension.py	824 B
RstripExtension.pyc	1.45 KB
RstripExtension.pyo	1.45 KB
ScriptBinding.py	8.22 KB
ScriptBinding.pyc	7.96 KB
ScriptBinding.pyo	7.96 KB
ScrolledList.py	3.9 KB
ScrolledList.pyc	6.03 KB
ScrolledList.pyo	6.03 KB
SearchDialog.py	1.99 KB
SearchDialog.pyc	2.93 KB
SearchDialog.pyo	2.93 KB
SearchDialogBase.py	4.28 KB
SearchDialogBase.pyc	5.37 KB
SearchDialogBase.pyo	5.37 KB
SearchEngine.py	6.57 KB
SearchEngine.pyc	7.02 KB
SearchEngine.pyo	7.02 KB
StackViewer.py	3.77 KB
StackViewer.pyc	5.79 KB
StackViewer.pyo	5.79 KB
TODO.txt	8.28 KB
ToolTip.py	2.67 KB
ToolTip.pyc	4.05 KB
ToolTip.pyo	4.05 KB
TreeWidget.py	14.87 KB
TreeWidget.pyc	17.48 KB
TreeWidget.pyo	17.48 KB
UndoDelegator.py	10.04 KB
UndoDelegator.pyc	12.27 KB
UndoDelegator.pyo	12.27 KB
WidgetRedirector.py	4.37 KB
WidgetRedirector.pyc	5.23 KB
WidgetRedirector.pyo	5.23 KB
WindowList.py	2.42 KB
WindowList.pyc	3.55 KB
WindowList.pyo	3.55 KB
ZoomHeight.py	1.28 KB
ZoomHeight.pyc	1.61 KB
ZoomHeight.pyo	1.61 KB
__init__.py	37 B
__init__.pyc	127 B
__init__.pyo	127 B
aboutDialog.py	6.42 KB
aboutDialog.pyc	6.63 KB
aboutDialog.pyo	6.63 KB
config-extensions.def	2.72 KB
config-highlight.def	1.7 KB
config-keys.def	7.35 KB
config-main.def	2.45 KB
configDialog.py	52.23 KB
configDialog.pyc	43.81 KB
configDialog.pyo	43.81 KB
configHandler.py	28.68 KB
configHandler.pyc	26.83 KB
configHandler.pyo	26.83 KB
configHelpSourceEdit.py	6.52 KB
configHelpSourceEdit.pyc	6.56 KB
configHelpSourceEdit.pyo	6.56 KB
configSectionNameDialog.py	3.63 KB
configSectionNameDialog.pyc	4.21 KB
configSectionNameDialog.pyo	4.21 KB
dynOptionMenuWidget.py	1.27 KB
dynOptionMenuWidget.pyc	1.66 KB
dynOptionMenuWidget.pyo	1.66 KB
extend.txt	3.56 KB
help.txt	11.72 KB
idle.py	400 B
idle.pyc	406 B
idle.pyo	406 B
idle.pyw	664 B
idlever.py	23 B
idlever.pyc	159 B
idlever.pyo	159 B
keybindingDialog.py	12.12 KB
keybindingDialog.pyc	12.05 KB
keybindingDialog.pyo	12.05 KB
macosxSupport.py	6.08 KB
macosxSupport.pyc	6.25 KB
macosxSupport.pyo	6.25 KB
rpc.py	19.75 KB
rpc.pyc	21.26 KB
rpc.pyo	21.16 KB
run.py	11.54 KB
run.pyc	12.14 KB
run.pyo	12.08 KB
tabbedpages.py	17.76 KB
tabbedpages.pyc	17.67 KB
tabbedpages.pyo	17.67 KB
textView.py	3.46 KB
textView.pyc	4.2 KB
textView.pyo	4.2 KB

Edit: Debugger.py

import os
import bdb
import types
from Tkinter import *
from idlelib.WindowList import ListedToplevel
from idlelib.ScrolledList import ScrolledList
from idlelib import macosxSupport

class Idb(bdb.Bdb):

def __init__(self, gui):
        self.gui = gui
        bdb.Bdb.__init__(self)

def user_line(self, frame):
        if self.in_rpc_code(frame):
            self.set_step()
            return
        message = self.__frame2message(frame)
        self.gui.interaction(message, frame)

def user_exception(self, frame, info):
        if self.in_rpc_code(frame):
            self.set_step()
            return
        message = self.__frame2message(frame)
        self.gui.interaction(message, frame, info)

def in_rpc_code(self, frame):
        if frame.f_code.co_filename.count('rpc.py'):
            return True
        else:
            prev_frame = frame.f_back
            if prev_frame.f_code.co_filename.count('Debugger.py'):
                # (that test will catch both Debugger.py and RemoteDebugger.py)
                return False
            return self.in_rpc_code(prev_frame)

def __frame2message(self, frame):
        code = frame.f_code
        filename = code.co_filename
        lineno = frame.f_lineno
        basename = os.path.basename(filename)
        message = "%s:%s" % (basename, lineno)
        if code.co_name != "?":
            message = "%s: %s()" % (message, code.co_name)
        return message

class Debugger:

vstack = vsource = vlocals = vglobals = None

def __init__(self, pyshell, idb=None):
        if idb is None:
            idb = Idb(self)
        self.pyshell = pyshell
        self.idb = idb
        self.frame = None
        self.make_gui()
        self.interacting = 0

def run(self, *args):
        try:
            self.interacting = 1
            return self.idb.run(*args)
        finally:
            self.interacting = 0

def close(self, event=None):
        if self.interacting:
            self.top.bell()
            return
        if self.stackviewer:
            self.stackviewer.close(); self.stackviewer = None
        # Clean up pyshell if user clicked debugger control close widget.
        # (Causes a harmless extra cycle through close_debugger() if user
        # toggled debugger from pyshell Debug menu)
        self.pyshell.close_debugger()
        # Now close the debugger control window....
        self.top.destroy()

def make_gui(self):
        pyshell = self.pyshell
        self.flist = pyshell.flist
        self.root = root = pyshell.root
        self.top = top = ListedToplevel(root)
        self.top.wm_title("Debug Control")
        self.top.wm_iconname("Debug")
        top.wm_protocol("WM_DELETE_WINDOW", self.close)
        self.top.bind("<Escape>", self.close)
        #
        self.bframe = bframe = Frame(top)
        self.bframe.pack(anchor="w")
        self.buttons = bl = []
        #
        self.bcont = b = Button(bframe, text="Go", command=self.cont)
        bl.append(b)
        self.bstep = b = Button(bframe, text="Step", command=self.step)
        bl.append(b)
        self.bnext = b = Button(bframe, text="Over", command=self.next)
        bl.append(b)
        self.bret = b = Button(bframe, text="Out", command=self.ret)
        bl.append(b)
        self.bret = b = Button(bframe, text="Quit", command=self.quit)
        bl.append(b)
        #
        for b in bl:
            b.configure(state="disabled")
            b.pack(side="left")
        #
        self.cframe = cframe = Frame(bframe)
        self.cframe.pack(side="left")
        #
        if not self.vstack:
            self.__class__.vstack = BooleanVar(top)
            self.vstack.set(1)
        self.bstack = Checkbutton(cframe,
            text="Stack", command=self.show_stack, variable=self.vstack)
        self.bstack.grid(row=0, column=0)
        if not self.vsource:
            self.__class__.vsource = BooleanVar(top)
        self.bsource = Checkbutton(cframe,
            text="Source", command=self.show_source, variable=self.vsource)
        self.bsource.grid(row=0, column=1)
        if not self.vlocals:
            self.__class__.vlocals = BooleanVar(top)
            self.vlocals.set(1)
        self.blocals = Checkbutton(cframe,
            text="Locals", command=self.show_locals, variable=self.vlocals)
        self.blocals.grid(row=1, column=0)
        if not self.vglobals:
            self.__class__.vglobals = BooleanVar(top)
        self.bglobals = Checkbutton(cframe,
            text="Globals", command=self.show_globals, variable=self.vglobals)
        self.bglobals.grid(row=1, column=1)
        #
        self.status = Label(top, anchor="w")
        self.status.pack(anchor="w")
        self.error = Label(top, anchor="w")
        self.error.pack(anchor="w", fill="x")
        self.errorbg = self.error.cget("background")
        #
        self.fstack = Frame(top, height=1)
        self.fstack.pack(expand=1, fill="both")
        self.flocals = Frame(top)
        self.flocals.pack(expand=1, fill="both")
        self.fglobals = Frame(top, height=1)
        self.fglobals.pack(expand=1, fill="both")
        #
        if self.vstack.get():
            self.show_stack()
        if self.vlocals.get():
            self.show_locals()
        if self.vglobals.get():
            self.show_globals()

def interaction(self, message, frame, info=None):
        self.frame = frame
        self.status.configure(text=message)
        #
        if info:
            type, value, tb = info
            try:
                m1 = type.__name__
            except AttributeError:
                m1 = "%s" % str(type)
            if value is not None:
                try:
                    m1 = "%s: %s" % (m1, str(value))
                except:
                    pass
            bg = "yellow"
        else:
            m1 = ""
            tb = None
            bg = self.errorbg
        self.error.configure(text=m1, background=bg)
        #
        sv = self.stackviewer
        if sv:
            stack, i = self.idb.get_stack(self.frame, tb)
            sv.load_stack(stack, i)
        #
        self.show_variables(1)
        #
        if self.vsource.get():
            self.sync_source_line()
        #
        for b in self.buttons:
            b.configure(state="normal")
        #
        self.top.wakeup()
        self.root.mainloop()
        #
        for b in self.buttons:
            b.configure(state="disabled")
        self.status.configure(text="")
        self.error.configure(text="", background=self.errorbg)
        self.frame = None

def sync_source_line(self):
        frame = self.frame
        if not frame:
            return
        filename, lineno = self.__frame2fileline(frame)
        if filename[:1] + filename[-1:] != "<>" and os.path.exists(filename):
            self.flist.gotofileline(filename, lineno)

def __frame2fileline(self, frame):
        code = frame.f_code
        filename = code.co_filename
        lineno = frame.f_lineno
        return filename, lineno

def cont(self):
        self.idb.set_continue()
        self.root.quit()

def step(self):
        self.idb.set_step()
        self.root.quit()

def next(self):
        self.idb.set_next(self.frame)
        self.root.quit()

def ret(self):
        self.idb.set_return(self.frame)
        self.root.quit()

def quit(self):
        self.idb.set_quit()
        self.root.quit()

stackviewer = None

def show_stack(self):
        if not self.stackviewer and self.vstack.get():
            self.stackviewer = sv = StackViewer(self.fstack, self.flist, self)
            if self.frame:
                stack, i = self.idb.get_stack(self.frame, None)
                sv.load_stack(stack, i)
        else:
            sv = self.stackviewer
            if sv and not self.vstack.get():
                self.stackviewer = None
                sv.close()
            self.fstack['height'] = 1

def show_source(self):
        if self.vsource.get():
            self.sync_source_line()

def show_frame(self, (frame, lineno)):
        self.frame = frame
        self.show_variables()

localsviewer = None
    globalsviewer = None

def show_locals(self):
        lv = self.localsviewer
        if self.vlocals.get():
            if not lv:
                self.localsviewer = NamespaceViewer(self.flocals, "Locals")
        else:
            if lv:
                self.localsviewer = None
                lv.close()
                self.flocals['height'] = 1
        self.show_variables()

def show_globals(self):
        gv = self.globalsviewer
        if self.vglobals.get():
            if not gv:
                self.globalsviewer = NamespaceViewer(self.fglobals, "Globals")
        else:
            if gv:
                self.globalsviewer = None
                gv.close()
                self.fglobals['height'] = 1
        self.show_variables()

def show_variables(self, force=0):
        lv = self.localsviewer
        gv = self.globalsviewer
        frame = self.frame
        if not frame:
            ldict = gdict = None
        else:
            ldict = frame.f_locals
            gdict = frame.f_globals
            if lv and gv and ldict is gdict:
                ldict = None
        if lv:
            lv.load_dict(ldict, force, self.pyshell.interp.rpcclt)
        if gv:
            gv.load_dict(gdict, force, self.pyshell.interp.rpcclt)

def set_breakpoint_here(self, filename, lineno):
        self.idb.set_break(filename, lineno)

def clear_breakpoint_here(self, filename, lineno):
        self.idb.clear_break(filename, lineno)

def clear_file_breaks(self, filename):
        self.idb.clear_all_file_breaks(filename)

def load_breakpoints(self):
        "Load PyShellEditorWindow breakpoints into subprocess debugger"
        pyshell_edit_windows = self.pyshell.flist.inversedict.keys()
        for editwin in pyshell_edit_windows:
            filename = editwin.io.filename
            try:
                for lineno in editwin.breakpoints:
                    self.set_breakpoint_here(filename, lineno)
            except AttributeError:
                continue

class StackViewer(ScrolledList):

def __init__(self, master, flist, gui):
        if macosxSupport.runningAsOSXApp():
            # At least on with the stock AquaTk version on OSX 10.4 you'll
            # get an shaking GUI that eventually kills IDLE if the width
            # argument is specified.
            ScrolledList.__init__(self, master)
        else:
            ScrolledList.__init__(self, master, width=80)
        self.flist = flist
        self.gui = gui
        self.stack = []

def load_stack(self, stack, index=None):
        self.stack = stack
        self.clear()
        for i in range(len(stack)):
            frame, lineno = stack[i]
            try:
                modname = frame.f_globals["__name__"]
            except:
                modname = "?"
            code = frame.f_code
            filename = code.co_filename
            funcname = code.co_name
            import linecache
            sourceline = linecache.getline(filename, lineno)
            import string
            sourceline = string.strip(sourceline)
            if funcname in ("?", "", None):
                item = "%s, line %d: %s" % (modname, lineno, sourceline)
            else:
                item = "%s.%s(), line %d: %s" % (modname, funcname,
                                                 lineno, sourceline)
            if i == index:
                item = "> " + item
            self.append(item)
        if index is not None:
            self.select(index)

def popup_event(self, event):
        "override base method"
        if self.stack:
            return ScrolledList.popup_event(self, event)

def fill_menu(self):
        "override base method"
        menu = self.menu
        menu.add_command(label="Go to source line",
                         command=self.goto_source_line)
        menu.add_command(label="Show stack frame",
                         command=self.show_stack_frame)

def on_select(self, index):
        "override base method"
        if 0 <= index < len(self.stack):
            self.gui.show_frame(self.stack[index])

def on_double(self, index):
        "override base method"
        self.show_source(index)

def goto_source_line(self):
        index = self.listbox.index("active")
        self.show_source(index)

def show_stack_frame(self):
        index = self.listbox.index("active")
        if 0 <= index < len(self.stack):
            self.gui.show_frame(self.stack[index])

def show_source(self, index):
        if not (0 <= index < len(self.stack)):
            return
        frame, lineno = self.stack[index]
        code = frame.f_code
        filename = code.co_filename
        if os.path.isfile(filename):
            edit = self.flist.open(filename)
            if edit:
                edit.gotoline(lineno)

class NamespaceViewer:

def __init__(self, master, title, dict=None):
        width = 0
        height = 40
        if dict:
            height = 20*len(dict) # XXX 20 == observed height of Entry widget
        self.master = master
        self.title = title
        import repr
        self.repr = repr.Repr()
        self.repr.maxstring = 60
        self.repr.maxother = 60
        self.frame = frame = Frame(master)
        self.frame.pack(expand=1, fill="both")
        self.label = Label(frame, text=title, borderwidth=2, relief="groove")
        self.label.pack(fill="x")
        self.vbar = vbar = Scrollbar(frame, name="vbar")
        vbar.pack(side="right", fill="y")
        self.canvas = canvas = Canvas(frame,
                                      height=min(300, max(40, height)),
                                      scrollregion=(0, 0, width, height))
        canvas.pack(side="left", fill="both", expand=1)
        vbar["command"] = canvas.yview
        canvas["yscrollcommand"] = vbar.set
        self.subframe = subframe = Frame(canvas)
        self.sfid = canvas.create_window(0, 0, window=subframe, anchor="nw")
        self.load_dict(dict)

dict = -1

def load_dict(self, dict, force=0, rpc_client=None):
        if dict is self.dict and not force:
            return
        subframe = self.subframe
        frame = self.frame
        for c in subframe.children.values():
            c.destroy()
        self.dict = None
        if not dict:
            l = Label(subframe, text="None")
            l.grid(row=0, column=0)
        else:
            names = dict.keys()
            names.sort()
            row = 0
            for name in names:
                value = dict[name]
                svalue = self.repr.repr(value) # repr(value)
                # Strip extra quotes caused by calling repr on the (already)
                # repr'd value sent across the RPC interface:
                if rpc_client:
                    svalue = svalue[1:-1]
                l = Label(subframe, text=name)
                l.grid(row=row, column=0, sticky="nw")
                l = Entry(subframe, width=0, borderwidth=0)
                l.insert(0, svalue)
                l.grid(row=row, column=1, sticky="nw")
                row = row+1
        self.dict = dict
        # XXX Could we use a <Configure> callback for the following?
        subframe.update_idletasks() # Alas!
        width = subframe.winfo_reqwidth()
        height = subframe.winfo_reqheight()
        canvas = self.canvas
        self.canvas["scrollregion"] = (0, 0, width, height)
        if height > 300:
            canvas["height"] = 300
            frame.pack(expand=1)
        else:
            canvas["height"] = height
            frame.pack(expand=0)

def close(self):
        self.frame.destroy()