class_docstr: The debugger interface.
  
  This class handles the drawing of the debugger window and
  the interactions with the underlying debugger session.
docstr: Run the debugger.
docstr_tok: ["Run","the","debugger","."]
code: def run(self, *args):
      """Run the debugger."""
      # Deal with the scenario where we've already got a program running
      # in the debugger and we want to start another. If that is the case,
      # our second 'run' was invoked from an event dispatched not from
      # the main event loop, but from the nested event loop in 'interaction'
      # below. So our stack looks something like this:
      #       outer main event loop
      #         run()
      #           <running program with traces>
      #             callback to debugger's interaction()
      #               nested event loop
      #                 run() for second command
      #
      # This kind of nesting of event loops causes all kinds of problems
      # (see e.g. issue #24455) especially when dealing with running as a
      # subprocess, where there's all kinds of extra stuff happening in
      # there - insert a traceback.print_stack() to check it out.
      #
      # By this point, we've already called restart_subprocess() in
      # ScriptBinding. However, we also need to unwind the stack back to
      # that outer event loop.  To accomplish this, we:
      #   - return immediately from the nested run()
      #   - abort_loop ensures the nested event loop will terminate
      #   - the debugger's interaction routine completes normally
      #   - the restart_subprocess() will have taken care of stopping
      #     the running program, which will also let the outer run complete
      #
      # That leaves us back at the outer main event loop, at which point our
      # after event can fire, and we'll come back to this routine with a
      # clean stack.
      if self.nesting_level > 0:
          self.abort_loop()
          self.root.after(100, lambda: self.run(*args))
          return
      try:
          self.interacting = True
          return self.idb.run(*args)
      finally:
          self.interacting = False
  
imports: import bdb
  import os
  from tkinter import *
  from tkinter.ttk import Frame, Scrollbar
  from idlelib import macosx
  from idlelib.scrolledlist import ScrolledList
  from idlelib.window import ListedToplevel
label_desc: Use image node_id 2 for calling the Debugger obj's underlying member method code with example usage: obj.run() and returns: self