fix few app admin py3 issues, updated qdb (close #1471)

gluon/debug.py

@@ -87,9 +87,9 @@ def communicate(command=None):
     return ''.join(result)
 
 
-# New debugger implementation using qdb and a web UI
+# New debugger implementation using dbg and a web UI
 
-import gluon.contrib.qdb as qdb
+import gluon.contrib.dbg as dbg
 from threading import RLock
 
 interact_lock = RLock()
@@ -109,11 +109,11 @@ def check_interaction(fn):
     return check_fn
 
 
-class WebDebugger(qdb.Frontend):
+class WebDebugger(dbg.Frontend):
     """Qdb web2py interface"""
 
     def __init__(self, pipe, completekey='tab', stdin=None, stdout=None):
-        qdb.Frontend.__init__(self, pipe)
+        dbg.Frontend.__init__(self, pipe)
         self.clear_interaction()
 
     def clear_interaction(self):
@@ -128,7 +128,7 @@ class WebDebugger(qdb.Frontend):
         run_lock.acquire()
         try:
             while self.pipe.poll():
-                qdb.Frontend.run(self)
+                dbg.Frontend.run(self)
         finally:
             run_lock.release()
 
@@ -149,23 +149,23 @@ class WebDebugger(qdb.Frontend):
 
     @check_interaction
     def do_continue(self):
-        qdb.Frontend.do_continue(self)
+        dbg.Frontend.do_continue(self)
 
     @check_interaction
     def do_step(self):
-        qdb.Frontend.do_step(self)
+        dbg.Frontend.do_step(self)
 
     @check_interaction
     def do_return(self):
-        qdb.Frontend.do_return(self)
+        dbg.Frontend.do_return(self)
 
     @check_interaction
     def do_next(self):
-        qdb.Frontend.do_next(self)
+        dbg.Frontend.do_next(self)
 
     @check_interaction
     def do_quit(self):
-        qdb.Frontend.do_quit(self)
+        dbg.Frontend.do_quit(self)
 
     def do_exec(self, statement):
         interact_lock.acquire()
@@ -175,22 +175,22 @@ class WebDebugger(qdb.Frontend):
                 # avoid spurious interaction notifications:
                 self.set_burst(2)
                 # execute the statement in the remote debugger:
-                return qdb.Frontend.do_exec(self, statement)
+                return dbg.Frontend.do_exec(self, statement)
         finally:
             interact_lock.release()
 
 # create the connection between threads:
 
 parent_queue, child_queue = Queue.Queue(), Queue.Queue()
-front_conn = qdb.QueuePipe("parent", parent_queue, child_queue)
-child_conn = qdb.QueuePipe("child", child_queue, parent_queue)
+front_conn = dbg.QueuePipe("parent", parent_queue, child_queue)
+child_conn = dbg.QueuePipe("child", child_queue, parent_queue)
 
 web_debugger = WebDebugger(front_conn)                                     # frontend
-qdb_debugger = qdb.Qdb(pipe=child_conn, redirect_stdio=False, skip=None)   # backend
-dbg = qdb_debugger
+dbg_debugger = dbg.Qdb(pipe=child_conn, redirect_stdio=False, skip=None)   # backend
+dbg = dbg_debugger
 
 # enable getting context (stack, globals/locals) at interaction
-qdb_debugger.set_params(dict(call_stack=True, environment=True))
+dbg_debugger.set_params(dict(call_stack=True, environment=True))
 
 import gluon.main
 gluon.main.global_settings.debugging = True