text: #!/usr/bin/env python
  # coding:utf-8
  
  "Queues(Pipe)-based independent remote client-server Python Debugger"
  
  __author__ = "Mariano Reingart (reingart@gmail.com)"
  __copyright__ = "Copyright (C) 2011 Mariano Reingart"
  __license__ = "LGPL 3.0"
  __version__ = "1.01b"
  
  # remote debugger queue-based (jsonrpc-like interface):
  # - bidirectional communication (request - response calls in both ways)
  # - request with id == null is a notification (do not send a response)
  # - request with a value for id is a normal call, wait response
  # based on idle, inspired by pythonwin implementation, taken many code from pdb
  
  import bdb
  import inspect
  import linecache
  import os
  import sys
  import traceback
  import cmd
  import pydoc
  import threading
  
  class Qdb(bdb.Bdb):
      "Qdb Debugger Backend"
  
      def __init__(self, pipe, redirect_stdio=True, allow_interruptions=False,
                   skip=[__name__]):
          kwargs = {}
          if sys.version_info > (2, 7):
              kwargs['skip'] = skip
          bdb.Bdb.__init__(self, **kwargs)
          self.frame = None
          self.i = 1  # sequential RPC call id
          self.waiting = False
          self.pipe = pipe # for communication
          self._wait_for_mainpyfile = False
          self._wait_for_breakpoint = False
          self.mainpyfile = ""
          self._lineno = None     # last listed line numbre
          # replace system standard input and output (send them thru the pipe)
          if redirect_stdio:
              sys.stdin = self
              sys.stdout = self
              sys.stderr = self
          if allow_interruptions:
              # fake breakpoint to prevent removing trace_dispatch on set_continue
              self.breaks[None] = []
          self.allow_interruptions = allow_interruptions
          self.burst = 0          # do not send notifications ("burst" mode)
          self.params = {}        # optional parameters for interaction
  
      def pull_actions(self):
          # receive a remote procedure call from the frontend:
          # returns True if action processed
          #         None when 'run' notification is received (see 'startup')
          request = self.pipe.recv()
          if request.get("method") == 'run':
              return None
          response = {'version': '1.1', 'id': request.get('id'),
                      'result': None,
                      'error': None}
          try:
              # dispatch message (JSON RPC like)
              method = getattr(self, request['method'])
              response['result'] = method.__call__(*request['args'],
                                          **request.get('kwargs', {}))
          except Exception, e:
              response['error'] = {'code': 0, 'message': str(e)}
          # send the result for normal method calls, not for notifications
          if request.get('id'):
              self.pipe.send(response)
          return True
  
      # Override Bdb methods
  
      def trace_dispatch(self, frame, event, arg):
          # check for non-interaction rpc (set_breakpoint, interrupt)
          while self.allow_interruptions and self.pipe.poll():
              self.pull_actions()
          # process the frame (see Bdb.trace_dispatch)
          if self.quitting:
              return # None
          if event == 'line':
              return self.dispatch_line(frame)
          if event == 'call':
              return self.dispatch_call(frame, arg)
          if event == 'return':
              return self.dispatch_return(frame, arg)
          if event == 'exception':
              return self.dispatch_exception(frame, arg)
          return self.trace_dispatch
  
      def user_call(self, frame, argument_list):
          """This method is called when there is the remote possibility
          that we ever need to stop in this function."""
          if self._wait_for_mainpyfile or self._wait_for_breakpoint:
              return
          if self.stop_here(frame):
              self.interaction(frame, None)
  
      def user_line(self, frame):
          """This function is called when we stop or break at this line."""
          if self._wait_for_mainpyfile:
              if (not self.canonic(frame.f_code.co_filename).startswith(self.mainpyfile)
                  or frame.f_lineno<= 0):
                  return
              self._wait_for_mainpyfile = 0
          if self._wait_for_breakpoint:
              if not self.break_here(frame):
                  return
              self._wait_for_breakpoint = 0
          self.interaction(frame)
  
      def user_exception(self, frame, info):
          """This function is called if an exception occurs,
          but only if we are to stop at or just below this level."""
          if self._wait_for_mainpyfile or self._wait_for_breakpoint:
              return
          extype, exvalue, trace = info
          # pre-process stack trace as it isn't pickeable (cannot be sent pure)
          msg = ''.join(traceback.format_exception(extype, exvalue, trace))
          trace = traceback.extract_tb(trace)
          title = traceback.format_exception_only(extype, exvalue)[0]
          # send an Exception notification
          msg = {'method': 'exception',
                 'args': (title, extype.__name__, exvalue, trace, msg),
                 'id': None}
          self.pipe.send(msg)
          self.interaction(frame, info)
  
      def run(self, code, interp=None, *args, **kwargs):
          try:
              return bdb.Bdb.run(self, code, *args, **kwargs)
          finally:
              pass
  
      def runcall(self, function, interp=None, *args, **kwargs):
          try:
              self.interp = interp
              return bdb.Bdb.runcall(self, function, *args, **kwargs)
          finally:
              pass
  
      def _runscript(self, filename):
          # The script has to run in __main__ namespace (clear it)
          import __main__
          import imp
          __main__.__dict__.clear()
          __main__.__dict__.update({"__name__"    : "__main__",
                                    "__file__"    : filename,
                                    "__builtins__": __builtins__,
                                    "imp"         : imp,          # need for run
                                   })
  
          # avoid stopping before we reach the main script
          self._wait_for_mainpyfile = 1
          self.mainpyfile = self.canonic(filename)
          self._user_requested_quit = 0
          statement = 'imp.load_source("__main__", "%s")' % filename
          # notify and wait frontend to set initial params and breakpoints
          self.pipe.send({'method': 'startup', 'args': (__version__, )})
          while self.pull_actions() is not None:
              pass
          self.run(statement)
  
      # General interaction function
  
      def interaction(self, frame, info=None):
          # chache frame locals to ensure that modifications are not overwritten
          self.frame_locals = frame and frame.f_locals or {}
          # extract current filename and line number
          code, lineno = frame.f_code, frame.f_lineno
          filename = code.co_filename
          basename = os.path.basename(filename)
          message = "%s:%s" % (basename, lineno)
          if code.co_name != "?":
              message = "%s: %s()" % (message, code.co_name)
  
          # wait user events
          self.waiting = True
          self.frame = frame
          try:
              while self.waiting:
                  #  sync_source_line()
                  if frame and filename[:1] + filename[-1:] != "<>" and os.path.exists(filename):
                      line = linecache.getline(filename, self.frame.f_lineno,
                                               self.frame.f_globals)
                  else:
                      line = ""
                  # send the notification (debug event) - DOESN'T WAIT RESPONSE
                  self.burst -= 1
                  if self.burst < 0:
                      kwargs = {}
                      if self.params.get('call_stack'):
                          kwargs['call_stack'] = self.do_where()
                      if self.params.get('environment'):
                          kwargs['environment'] = self.do_environment()
                      self.pipe.send({'method': 'interaction', 'id': None,
                                  'args': (filename, self.frame.f_lineno, line),
                                  'kwargs': kwargs})
  
                  self.pull_actions()
  
          finally:
              self.waiting = False
          self.frame = None
  
      def do_debug(self, mainpyfile=None, wait_breakpoint=1):
          self.reset()
          if not wait_breakpoint or mainpyfile:
              self._wait_for_mainpyfile = 1
              if not mainpyfile:
                  frame = sys._getframe().f_back
                  mainpyfile = frame.f_code.co_filename
              self.mainpyfile = self.canonic(mainpyfile)
          self._wait_for_breakpoint = wait_breakpoint
          sys.settrace(self.trace_dispatch)
  
      def set_trace(self, frame=None):
          # start debugger interaction immediatelly
          if frame is None:
              frame = sys._getframe().f_back
          self._wait_for_mainpyfile = frame.f_code.co_filename
          self._wait_for_breakpoint = 0
          bdb.Bdb.set_trace(self, frame)
  
      # Command definitions, called by interaction()
  
      def do_continue(self):
          self.set_continue()
          self.waiting = False
  
      def do_step(self):
          self.set_step()
          self.waiting = False
  
      def do_return(self):
          self.set_return(self.frame)
          self.waiting = False
  
      def do_next(self):
          self.set_next(self.frame)
          self.waiting = False
  
      def interrupt(self):
          self.set_step()
  
      def do_quit(self):
          self.set_quit()
          self.waiting = False
  
      def do_jump(self, lineno):
          arg = int(lineno)
          try:
              self.frame.f_lineno = arg
              return arg
          except ValueError, e:
              print '*** Jump failed:', e
              return False
  
      def do_list(self, arg):
          last = None
          if arg:
              if isinstance(arg, tuple):
                  first, last = arg
              else:
                  first = arg
          elif not self._lineno:
              first = max(1, self.frame.f_lineno - 5)
          else:
              first = self._lineno + 1
          if last is None:
              last = first + 10
          filename = self.frame.f_code.co_filename
          breaklist = self.get_file_breaks(filename)
          lines = []
          for lineno in range(first, last+1):
              line = linecache.getline(filename, lineno,
                                       self.frame.f_globals)
              if not line:
                  lines.append((filename, lineno, '', current, "<EOF>\n"))
                  break
              else:
                  breakpoint = "B" if lineno in breaklist else ""
                  current = "->" if self.frame.f_lineno == lineno else ""
                  lines.append((filename, lineno, breakpoint, current, line))
                  self._lineno = lineno
          return lines
  
      def do_read(self, filename):
          return open(filename, "Ur").read()
  
      def do_set_breakpoint(self, filename, lineno, temporary=0, cond=None):
          return self.set_break(filename, int(lineno), temporary, cond)
  
      def do_list_breakpoint(self):
          breaks = []
          if self.breaks:  # There's at least one
              for bp in bdb.Breakpoint.bpbynumber:
                  if bp:
                      breaks.append((bp.number, bp.file, bp.line,
                          bp.temporary, bp.enabled, bp.hits, bp.cond, ))
          return breaks
  
      def do_clear_breakpoint(self, filename, lineno):
          self.clear_break(filename, lineno)
  
      def do_clear_file_breakpoints(self, filename):
          self.clear_all_file_breaks(filename)
  
      def do_clear(self, arg):
          # required by BDB to remove temp breakpoints!
          err = self.clear_bpbynumber(arg)
          if err:
              print '*** DO_CLEAR failed', err
  
      def do_eval(self, arg, safe=True):
          ret = eval(arg, self.frame.f_globals,
                      self.frame_locals)
          if safe:
              ret = pydoc.cram(repr(ret), 255)
          return ret
  
      def do_exec(self, arg):
          locals = self.frame_locals
          globals = self.frame.f_globals
          code = compile(arg + '\n', '<stdin>', 'single')
          save_displayhook = sys.displayhook
          self.displayhook_value = None
          try:
              sys.displayhook = self.displayhook
              exec code in globals, locals
          finally:
              sys.displayhook = save_displayhook
          return self.displayhook_value
  
      def do_where(self):
          "print_stack_trace"
          stack, curindex = self.get_stack(self.frame, None)
          lines = []
          for frame, lineno in stack:
              filename = frame.f_code.co_filename
              line = linecache.getline(filename, lineno)
              lines.append((filename, lineno, "", "", line, ))
          return lines
  
      def do_environment(self):
          "return current frame local and global environment"
          env = {'locals': {}, 'globals': {}}
          # converts the frame global and locals to a short text representation:
          if self.frame:
              for name, value in self.frame_locals.items():
                  env['locals'][name] = pydoc.cram(repr(value), 255), repr(type(value))
              for name, value in self.frame.f_globals.items():
                  env['globals'][name] = pydoc.cram(repr(value), 20), repr(type(value))
          return env
  
      def get_autocomplete_list(self, expression):
          "Return list of auto-completion options for expression"
          try:
              obj = self.do_eval(expression)
          except:
              return []
          else:
              return dir(obj)
  
      def get_call_tip(self, expression):
          "Return list of auto-completion options for expression"
          try:
              obj = self.do_eval(expression)
          except Exception, e:
              return ('', '', str(e))
          else:
              name = ''
              try:
                  name = obj.__name__
              except AttributeError:
                  pass
              argspec = ''
              drop_self = 0
              f = None
              try:
                  if inspect.isbuiltin(obj):
                      pass
                  elif inspect.ismethod(obj):
                      # Get the function from the object
                      f = obj.im_func
                      drop_self = 1
                  elif inspect.isclass(obj):
                      # Get the __init__ method function for the class.
                      if hasattr(obj, '__init__'):
                          f = obj.__init__.im_func
                      else:
                          for base in object.__bases__:
                              if hasattr(base, '__init__'):
                                  f = base.__init__.im_func
                                  break
                      if f is not None:
                          drop_self = 1
                  elif callable(obj):
                      # use the obj as a function by default
                      f = obj
                      # Get the __call__ method instead.
                      f = obj.__call__.im_func
                      drop_self = 0
              except AttributeError:
                  pass
              if f:
                  argspec = apply(inspect.formatargspec, inspect.getargspec(f))
              doc = ''
              if callable(obj):
                  try:
                      doc = inspect.getdoc(obj)
                  except:
                      pass
              return (name, argspec[1:-1], doc.strip())
  
      def set_burst(self, val):
          "Set burst mode -multiple command count- (shut up notifications)"
          self.burst = val
  
      def set_params(self, params):
          "Set parameters for interaction"
          self.params.update(params)
  
      def displayhook(self, obj):
          """Custom displayhook for the do_exec which prevents
          assignment of the _ variable in the builtins.
          """
          self.displayhook_value = repr(obj)
  
      def reset(self):
          bdb.Bdb.reset(self)
          self.waiting = False
          self.frame = None
  
      def post_mortem(self, t=None):
          # handling the default
          if t is None:
              # sys.exc_info() returns (type, value, traceback) if an exception is
              # being handled, otherwise it returns None
              t = sys.exc_info()[2]
              if t is None:
                  raise ValueError("A valid traceback must be passed if no "
                                   "exception is being handled")
          self.reset()
          # get last frame:
          while t is not None:
              frame = t.tb_frame
              t = t.tb_next
              code, lineno = frame.f_code, frame.f_lineno
              filename = code.co_filename
              line = linecache.getline(filename, lineno)
              #(filename, lineno, "", current, line, )}
  
          self.interaction(frame)
  
      # console file-like object emulation
      def readline(self):
          "Replacement for stdin.readline()"
          msg = {'method': 'readline', 'args': (), 'id': self.i}
          self.pipe.send(msg)
          msg = self.pipe.recv()
          self.i += 1
          return msg['result']
  
      def readlines(self):
          "Replacement for stdin.readlines()"
          lines = []
          while lines[-1:] != ['\n']:
              lines.append(self.readline())
          return lines
  
      def write(self, text):
          "Replacement for stdout.write()"
          msg = {'method': 'write', 'args': (text, ), 'id': None}
          self.pipe.send(msg)
  
      def writelines(self, l):
          map(self.write, l)
  
      def flush(self):
          pass
  
      def isatty(self):
          return 0
  
  
  class QueuePipe(object):
      "Simulated pipe for threads (using two queues)"
  
      def __init__(self, name, in_queue, out_queue):
          self.__name = name
          self.in_queue = in_queue
          self.out_queue = out_queue
  
      def send(self, data):
          self.out_queue.put(data, block=True)
  
      def recv(self, count=None, timeout=None):
          data = self.in_queue.get(block=True, timeout=timeout)
          return data
  
      def poll(self, timeout=None):
          return not self.in_queue.empty()
  
      def close(self):
          pass
  
  
  class RPCError(RuntimeError):
      "Remote Error (not user exception)"
      pass
  
  
  class Frontend(object):
      "Qdb generic Frontend interface"
  
      def __init__(self, pipe):
          self.i = 1
          self.pipe = pipe
          self.notifies = []
          self.read_lock = threading.RLock()
          self.write_lock = threading.RLock()
  
      def recv(self):
          self.read_lock.acquire()
          try:
              return self.pipe.recv()
          finally:
              self.read_lock.release()
  
      def send(self, data):
          self.write_lock.acquire()
          try:
              return self.pipe.send(data)
          finally:
              self.write_lock.release()
  
      def startup(self):
          self.send({'method': 'run', 'args': (), 'id': None})
  
      def interaction(self, filename, lineno, line, *kwargs):
          raise NotImplementedError
  
      def exception(self, title, extype, exvalue, trace, request):
          "Show a user_exception"
          raise NotImplementedError
  
      def write(self, text):
          "Console output (print)"
          raise NotImplementedError
  
      def readline(self, text):
          "Console input/rawinput"
          raise NotImplementedError
  
      def run(self):
          "Main method dispatcher (infinite loop)"
          if self.pipe:
              if not self.notifies:
                  # wait for a message...
                  request = self.recv()
              else:
                  # process an asyncronus notification received earlier
                  request = self.notifies.pop(0)
              return self.process_message(request)
  
      def process_message(self, request):
          if request:
              result = None
              if request.get("error"):
                  # it is not supposed to get an error here
                  # it should be raised by the method call
                  raise RPCError(res['error']['message'])
              elif request.get('method') == 'interaction':
                  self.interaction(*request.get("args"), **request.get("kwargs"))
              elif request.get('method') == 'startup':
                  self.startup()
              elif request.get('method') == 'exception':
                  self.exception(*request['args'])
              elif request.get('method') == 'write':
                  self.write(*request.get("args"))
              elif request.get('method') == 'readline':
                  result = self.readline()
              if result:
                  response = {'version': '1.1', 'id': request.get('id'),
                          'result': result,
                          'error': None}
                  self.send(response)
              return True
  
      def call(self, method, *args):
          "Actually call the remote method (inside the thread)"
          req = {'method': method, 'args': args, 'id': self.i}
          self.send(req)
          self.i += 1  # increment the id
          while 1:
              # wait until command acknowledge (response id match the request)
              res = self.recv()
              if 'id' not in res or not res['id']:
                  # nested notification received (i.e. write)! process it!
                  self.process_message(res)
              elif 'result' not in res:
                  # nested request received (i.e. readline)! process it!
                  self.process_message(res)
              elif long(req['id']) != long(res['id']):
                  print "DEBUGGER wrong packet received: expecting id", req['id'], res['id']
                  # protocol state is unknown
              elif 'error' in res and res['error']:
                  raise RPCError(res['error']['message'])
              else:
                  return res['result']
  
      def do_step(self, arg=None):
          "Execute the current line, stop at the first possible occasion"
          self.call('do_step')
  
      def do_next(self, arg=None):
          "Execute the current line, do not stop at function calls"
          self.call('do_next')
  
      def do_continue(self, arg=None):
          "Continue execution, only stop when a breakpoint is encountered."
          self.call('do_continue')
  
      def do_return(self, arg=None):
          "Continue execution until the current function returns"
          self.call('do_return')
  
      def do_jump(self, arg):
          "Set the next line that will be executed."
          res = self.call('do_jump', arg)
          print res
  
      def do_where(self, arg=None):
          "Print a stack trace, with the most recent frame at the bottom."
          return self.call('do_where')
  
      def do_quit(self, arg=None):
          "Quit from the debugger. The program being executed is aborted."
          self.call('do_quit')
  
      def do_eval(self, expr):
          "Inspect the value of the expression"
          return self.call('do_eval', expr)
  
      def do_environment(self):
          "List all the locals and globals variables (string representation)"
          return self.call('do_environment')
  
      def do_list(self, arg=None):
          "List source code for the current file"
          return self.call('do_list', arg)
  
      def do_read(self, filename):
          "Read and send a local filename"
          return self.call('do_read', filename)
  
      def do_set_breakpoint(self, filename, lineno, temporary=0, cond=None):
          "Set a breakpoint at filename:breakpoint"
          self.call('do_set_breakpoint', filename, lineno, temporary, cond)
  
      def do_clear_breakpoint(self, filename, lineno):
          "Remove a breakpoint at filename:breakpoint"
          self.call('do_clear_breakpoint', filename, lineno)
  
      def do_clear_file_breakpoints(self, filename):
          "Remove all breakpoints at filename"
          self.call('do_clear_breakpoints', filename, lineno)
  
      def do_list_breakpoint(self):
          "List all breakpoints"
          return self.call('do_list_breakpoint')
  
      def do_exec(self, statement):
          return self.call('do_exec', statement)
  
      def get_autocomplete_list(self, expression):
          return self.call('get_autocomplete_list', expression)
  
      def get_call_tip(self, expression):
          return self.call('get_call_tip', expression)
  
      def interrupt(self):
          "Immediately stop at the first possible occasion (outside interaction)"
          # this is a notification!, do not expect a response
          req = {'method': 'interrupt', 'args': ()}
          self.send(req)
  
      def set_burst(self, value):
          req = {'method': 'set_burst', 'args': (value, )}
          self.send(req)
  
      def set_params(self, params):
          req = {'method': 'set_params', 'args': (params, )}
          self.send(req)
  
  
  class Cli(Frontend, cmd.Cmd):
      "Qdb Front-end command line interface"
  
      def __init__(self, pipe, completekey='tab', stdin=None, stdout=None, skip=None):
          cmd.Cmd.__init__(self, completekey, stdin, stdout)
          Frontend.__init__(self, pipe)
  
      # redefine Frontend methods:
  
      def run(self):
          while 1:
              try:
                  Frontend.run(self)
              except KeyboardInterrupt:
                  print "Interupting..."
                  self.interrupt()
  
      def interaction(self, filename, lineno, line):
          print "> %s(%d)\n-> %s" % (filename, lineno, line),
          self.filename = filename
          self.cmdloop()
  
      def exception(self, title, extype, exvalue, trace, request):
          print "=" * 80
          print "Exception", title
          print request
          print "-" * 80
  
      def write(self, text):
          print text,
  
      def readline(self):
          return raw_input()
  
      def postcmd(self, stop, line):
          return not line.startswith("h") # stop
  
      do_h = cmd.Cmd.do_help
  
      do_s = Frontend.do_step
      do_n = Frontend.do_next
      do_c = Frontend.do_continue
      do_r = Frontend.do_return
      do_j = Frontend.do_jump
      do_q = Frontend.do_quit
  
      def do_eval(self, args):
          "Inspect the value of the expression"
          print Frontend.do_eval(self, args)
  
      def do_list(self, args):
          "List source code for the current file"
          lines = Frontend.do_list(self, eval(args, {}, {}) if args else None)
          self.print_lines(lines)
  
      def do_where(self, args):
          "Print a stack trace, with the most recent frame at the bottom."
          lines = Frontend.do_where(self)
          self.print_lines(lines)
  
      def do_environment(self, args=None):
          env = Frontend.do_environment(self)
          for key in env:
              print "=" * 78
              print key.capitalize()
              print "-" * 78
              for name, value in env[key].items():
                  print "%-12s = %s" % (name, value)
  
      def do_list_breakpoint(self, arg=None):
          "List all breakpoints"
          breaks = Frontend.do_list_breakpoint(self)
          print "Num File                          Line Temp Enab Hits Cond"
          for bp in breaks:
              print '%-4d%-30s%4d %4s %4s %4d %s' % bp
          print
  
      def do_set_breakpoint(self, arg):
          "Set a breakpoint at filename:breakpoint"
          if arg:
              if ':' in arg:
                  args = arg.split(":")
              else:
                  args = (self.filename, arg)
              Frontend.do_set_breakpoint(self, *args)
          else:
              self.do_list_breakpoint()
  
      do_b = do_set_breakpoint
      do_l = do_list
      do_p = do_eval
      do_w = do_where
      do_e = do_environment
  
      def default(self, line):
          "Default command"
          if line[:1] == '!':
              print self.do_exec(line[1:])
          else:
              print "*** Unknown command: ", line
  
      def print_lines(self, lines):
          for filename, lineno, bp, current, source in lines:
              print "%s:%4d%s%s\t%s" % (filename, lineno, bp, current, source),
          print
  
  
  def test():
      def f(pipe):
          print "creating debugger"
          qdb = Qdb(pipe=pipe, redirect_stdio=False)
          print "set trace"
  
          my_var = "Mariano!"
          qdb.set_trace()
          print "hello world!"
          print "good by!"
          saraza
  
      if '--process' in sys.argv:
          from multiprocessing import Process, Pipe
          pipe, child_conn = Pipe()
          p = Process(target=f, args=(child_conn,))
      else:
          from threading import Thread
          from Queue import Queue
          parent_queue, child_queue = Queue(), Queue()
          front_conn = QueuePipe("parent", parent_queue, child_queue)
          child_conn = QueuePipe("child", child_queue, parent_queue)
          p = Thread(target=f, args=(child_conn,))
  
      p.start()
      import time
  
      class Test(Frontend):
          def interaction(self, *args):
              print "interaction!", args
          def exception(self, *args):
              print "exception", args
              #raise RuntimeError("exception %s" % repr(args))
  
      qdb = Test(front_conn)
      time.sleep(5)
  
      while 1:
          print "running..."
          Frontend.run(qdb)
          time.sleep(1)
          print "do_next"
          qdb.do_next()
      p.join()
  
  
  def connect(host="localhost", port=6000, authkey='secret password'):
      "Connect to a running debugger backend"
  
      address = (host, port)
      from multiprocessing.connection import Client
  
      print "qdb debugger fronted: waiting for connection to", address
      conn = Client(address, authkey=authkey)
      try:
          Cli(conn).run()
      except EOFError:
          pass
      finally:
          conn.close()
  
  
  def main(host='localhost', port=6000, authkey='secret password'):
      "Debug a script and accept a remote frontend"
  
      if not sys.argv[1:] or sys.argv[1] in ("--help", "-h"):
          print "usage: pdb.py scriptfile [arg] ..."
          sys.exit(2)
  
      mainpyfile =  sys.argv[1]     # Get script filename
      if not os.path.exists(mainpyfile):
          print 'Error:', mainpyfile, 'does not exist'
          sys.exit(1)
  
      del sys.argv[0]         # Hide "pdb.py" from argument list
  
      # Replace pdb's dir with script's dir in front of module search path.
      sys.path[0] = os.path.dirname(mainpyfile)
  
      from multiprocessing.connection import Listener
      address = (host, port)     # family is deduced to be 'AF_INET'
      listener = Listener(address, authkey=authkey)
      print "qdb debugger backend: waiting for connection at", address
      conn = listener.accept()
      print 'qdb debugger backend: connected to', listener.last_accepted
  
      # create the backend
      qdb = Qdb(conn, redirect_stdio=True, allow_interruptions=True)
      try:
          print "running", mainpyfile
          qdb._runscript(mainpyfile)
          print "The program finished"
      except SystemExit:
          # In most cases SystemExit does not warrant a post-mortem session.
          print "The program exited via sys.exit(). Exit status: ",
          print sys.exc_info()[1]
          raise
      except:
          raise
  
      conn.close()
      listener.close()
  
  
  qdb = None
  def set_trace(host='localhost', port=6000, authkey='secret password'):
      "Simplified interface to debug running programs"
      global qdb, listener, conn
  
      from multiprocessing.connection import Listener
      # only create it if not currently instantiated
      if not qdb:
          address = (host, port)     # family is deduced to be 'AF_INET'
          listener = Listener(address, authkey=authkey)
          conn = listener.accept()
  
          # create the backend
          qdb = Qdb(conn)
      # start debugger backend:
      qdb.set_trace()
  
  
  def quit():
      "Remove trace and quit"
      global qdb, listener, conn
      if qdb:
          sys.settrace(None)
          qdb = None
      if conn:
          conn.close()
          conn = None
      if listener:
          listener.close()
          listener = None
  
  if __name__ == '__main__':
      # When invoked as main program:
      if '--test' in sys.argv:
          test()
      # Check environment for configuration parameters:
      kwargs = {}
      for param in 'host', 'port', 'authkey':
         if 'QDB_%s' % param.upper() in os.environ:
              kwargs[param] = os.environ['QDB_%s' % param.upper()]
  
      if not sys.argv[1:]:
          # connect to a remote debbuger
          connect(**kwargs)
      else:
          # start the debugger on a script
          # reimport as global __main__ namespace is destroyed
          import qdb
          qdb.main(**kwargs)
  
  
  
  
  