eric: comparison DebugClients/Python3/DebugClientBase.py

-:cd4e2cab7eb2
+:c99695c0f13a
 from FlexCompleter import Completer
 DebugClientInstance = None
-################################################################################
+###############################################################################
 def DebugClientInput(prompt="", echo=True):
 """
 Replacement for the standard input builtin.
 except (AttributeError, KeyError):
 import __main__
 DebugClientOrigInput = __main__.__builtins__.__dict__['input']
 __main__.__builtins__.__dict__['input'] = DebugClientInput
-################################################################################
+###############################################################################
 def DebugClientFork():
 """
 Replacement for the standard os.fork().
 # use our own fork().
 if 'fork' in dir(os):
 DebugClientOrigFork = os.fork
 os.fork = DebugClientFork
-################################################################################
+###############################################################################
 def DebugClientClose(fd):
 """
 Replacement for the standard os.close(fd).
 # use our own close().
 if 'close' in dir(os):
 DebugClientOrigClose = os.close
 os.close = DebugClientClose
-################################################################################
+###############################################################################
 def DebugClientSetRecursionLimit(limit):
 """
 Replacement for the standard sys.setrecursionlimit(limit).
 if 'setrecursionlimit' in dir(sys):
 DebugClientOrigSetRecursionLimit = sys.setrecursionlimit
 sys.setrecursionlimit = DebugClientSetRecursionLimit
 DebugClientSetRecursionLimit(sys.getrecursionlimit())
-################################################################################
+###############################################################################
 class DebugClientBase(object):
 """
 Class implementing the client side of the debugger.
-It provides access to the Python interpeter from a debugger running in another
+It provides access to the Python interpeter from a debugger running in
-process whether or not the Qt event loop is running.
+another process whether or not the Qt event loop is running.
 The protocol between the debugger and the client assumes that there will be
 a single source of debugger commands and a single source of Python
 statements.  Commands and statement are always exactly one line and may be
 interspersed.
 debugger and then sends a series of one line commands.  A command is either
 &gt;Load&lt;, &gt;Step&lt;, &gt;StepInto&lt;, ... or a Python statement.
 See DebugProtocol.py for a listing of valid protocol tokens.
 A Python statement consists of the statement to execute, followed (in a
-separate line) by &gt;OK?&lt;.  If the statement was incomplete then the response
+separate line) by &gt;OK?&lt;. If the statement was incomplete then the
-is &gt;Continue&lt;.  If there was an exception then the response is
+response is &gt;Continue&lt;. If there was an exception then the response
-&gt;Exception&lt;.
+is &gt;Exception&lt;. Otherwise the response is &gt;OK&lt;.  The reason
-Otherwise the response is &gt;OK&lt;.  The reason for the &gt;OK?&lt; part is to
+for the &gt;OK?&lt; part is to provide a sentinal (ie. the responding
-provide a sentinal (ie. the responding &gt;OK&lt;) after any possible output as a
+&gt;OK&lt;) after any possible output as a result of executing the command.
-result of executing the command.
 The client may send any other lines at any other time which should be
 interpreted as program output.
 If the debugger closes the session there is no response from the client.
 The client may close the session at any time as a result of the script
 being debugged closing or crashing.
-<b>Note</b>: This class is meant to be subclassed by individual DebugClient classes.
+<b>Note</b>: This class is meant to be subclassed by individual
-Do not instantiate it directly.
+DebugClient classes. Do not instantiate it directly.
 """
 clientCapabilities = DebugClientCapabilities.HasAll
 def __init__(self):
 """
 # debugger
 # dictionary of all threads running
 self.threads = {}
-# the "current" thread, basically the thread we are at a breakpoint for.
+# the "current" thread, basically the thread we are at a breakpoint
+# for.
 self.currentThread = self
 # special objects representing the main scripts thread and frame
 self.mainThread = self
 self.mainFrame = None
 if m:
 self.__coding = m.group(1)
 return
 self.__coding = default
-def attachThread(self, target=None, args=None, kwargs=None, mainThread=False):
+def attachThread(self, target=None, args=None, kwargs=None,
+mainThread=False):
 """
 Public method to setup a thread for DebugClient to debug.
 If mainThread is non-zero, then we are attaching to the already
 started mainthread of the app and the rest of the args are ignored.
-@param target the start function of the target thread (i.e. the user code)
+@param target the start function of the target thread (i.e. the
+user code)
 @param args arguments to pass to target
 @param kwargs keyword arguments to pass to target
 @param mainThread True, if we are attaching to the already
 started mainthread of the app
 """
 def __dumpThreadList(self):
 """
 Public method to send the list of threads.
 """
 threadList = []
-if self.threads and self.currentThread:    # indication for the threaded debugger
+if self.threads and self.currentThread:
+# indication for the threaded debugger
 currentId = self.currentThread.get_ident()
 for t in self.threads.values():
 d = {}
 d["id"] = t.get_ident()
 d["name"] = t.get_name()
 @param prompt the prompt to be shown (string)
 @param echo Flag indicating echoing of the input (boolean)
 @return the entered string
 """
-self.write("{0}{1!r}\n".format(DebugProtocol.ResponseRaw, (prompt, echo)))
+self.write("{0}{1!r}\n".format(
+DebugProtocol.ResponseRaw, (prompt, echo)))
 self.inRawMode = True
 self.eventLoop(True)
 return self.rawLine
 def __exceptionRaised(self):
 """
 self.pendingResponse = DebugProtocol.ResponseException
 def sessionClose(self, exit=True):
 """
-Public method to close the session with the debugger and optionally terminate.
+Public method to close the session with the debugger and optionally
+terminate.
 @param exit flag indicating to terminate (boolean)
 """
 try:
 self.set_quit()
 try:
 code = compile(statement + '\n', filename, mode)
 except SyntaxError:
 exctype, excval, exctb = sys.exc_info()
 try:
-message, (filename, linenr, charnr, text) = excval[0], excval[1]
+message, (filename, linenr, charnr, text) = \
+excval[0], excval[1]
 except ValueError:
 exclist = []
 else:
 exclist = [message, [filename, linenr, charnr]]
-self.write("{0}{1}\n".format(DebugProtocol.ResponseSyntax, str(exclist)))
+self.write("{0}{1}\n".format(
+DebugProtocol.ResponseSyntax, str(exclist)))
 return None
 return code
 def handleLine(self, line):
 """
 Public method to handle the receipt of a complete line.
-It first looks for a valid protocol token at the start of the line. Thereafter
+It first looks for a valid protocol token at the start of the line.
-it trys to execute the lines accumulated so far.
+Thereafter it trys to execute the lines accumulated so far.
 @param line the received line
 """
 # Remove any newline.
 if line[-1] == '\n':
 tid = eval(arg)
 if tid in self.threads:
 self.setCurrentThread(tid)
 self.write(DebugProtocol.ResponseThreadSet + '\n')
 stack = self.currentThread.getStack()
-self.write('{0}{1!r}\n'.format(DebugProtocol.ResponseStack, stack))
+self.write('{0}{1!r}\n'.format(
+DebugProtocol.ResponseStack, stack))
 return
 if cmd == DebugProtocol.RequestStep:
 self.currentThread.step(True)
 self.eventExit = True
 else:
 callTraceEnabled = False
 if self.debugging:
 self.callTraceEnabled = callTraceEnabled
 else:
-self.__newCallTraceEnabled = callTraceEnabled   # remember for later
+self.__newCallTraceEnabled = callTraceEnabled
+# remember for later
 return
 if cmd == DebugProtocol.RequestEnv:
 env = eval(arg.replace("u'", "'"))
 for key, value in env.items():
 # set the system exception handling function to ensure, that
 # we report on all unhandled exceptions
 sys.excepthook = self.__unhandled_exception
-# clear all old breakpoints, they'll get set after we have started
+# clear all old breakpoints, they'll get set after we have
+# started
 self.mainThread.clear_all_breaks()
 self.mainThread.tracePython = tracePython
 # This will eventually enter a local event loop.
-# Note the use of backquotes to cause a repr of self.running. The
+# Note the use of backquotes to cause a repr of self.running.
-# need for this is on Windows os where backslash is the path separator.
+# The need for this is on Windows os where backslash is the
-# They will get inadvertantly stripped away during the eval causing
+# path separator. They will get inadvertantly stripped away
-# IOErrors, if self.running is passed as a normal str.
+# during the eval causing IOErrors, if self.running is passed
+# as a normal str.
 self.debugMod.__dict__['__file__'] = self.running
 sys.modules['__main__'] = self.debugMod
 code = self.__compileFileSource(self.running)
 if code:
 self.callTraceEnabled = self.__newCallTraceEnabled
 # we report on all unhandled exceptions
 sys.excepthook = self.__unhandled_exception
 # generate a coverage object
 self.cover = coverage(auto_data=True,
-data_file="{0}.coverage".format(os.path.splitext(sys.argv[0])[0]))
+data_file="{0}.coverage".format(
+os.path.splitext(sys.argv[0])[0]))
 self.cover.use_cache(True)
 if int(erase):
 self.cover.erase()
 sys.modules['__main__'] = self.debugMod
 else:
 try:
 compile(cond, '<string>', 'eval')
 except SyntaxError:
 self.write('{0}{1},{2:d}\n'.format(
-DebugProtocol.ResponseBPConditionError, fn, line))
+DebugProtocol.ResponseBPConditionError,
+fn, line))
 return
 self.mainThread.set_break(fn, line, temporary, cond)
 else:
 self.mainThread.clear_break(fn, line)
 return
 if cmd == DebugProtocol.RequestEval:
 try:
-value = eval(arg, self.currentThread.getCurrentFrame().f_globals,
+value = eval(
-self.currentThread.getCurrentFrameLocals())
+arg,
+self.currentThread.getCurrentFrame().f_globals,
+self.currentThread.getCurrentFrameLocals())
 except:
 # Report the exception and the traceback
 try:
 type, value, tb = sys.exc_info()
 sys.last_type = type
 except AttributeError:
 self.test = unittest.defaultTestLoader\
 .loadTestsFromModule(utModule)
 except:
 exc_type, exc_value, exc_tb = sys.exc_info()
-self.write('{0}{1}\n'.format(DebugProtocol.ResponseUTPrepared,
+self.write('{0}{1}\n'.format(
+DebugProtocol.ResponseUTPrepared,
 str((0, str(exc_type), str(exc_value)))))
 self.__exceptionRaised()
 return
 # generate a coverage object
 if int(cov):
 from coverage import coverage
 self.cover = coverage(auto_data=True,
-data_file="{0}.coverage".format(os.path.splitext(covname)[0]))
+data_file="{0}.coverage".format(
+os.path.splitext(covname)[0]))
 self.cover.use_cache(True)
 if int(erase):
 self.cover.erase()
 else:
 self.cover = None
 try:
 code = self.compile_command(self.buffer, self.readstream.name)
 except (OverflowError, SyntaxError, ValueError):
 # Report the exception
 sys.last_type, sys.last_value, sys.last_traceback = sys.exc_info()
-for l in traceback.format_exception_only(sys.last_type, sys.last_value):
+for l in traceback.format_exception_only(
+sys.last_type, sys.last_value):
 self.write(l)
 self.buffer = ''
 else:
 if code is None:
 self.pendingResponse = DebugProtocol.ResponseContinue
 frmnr = self.framenr
 while cf is not None and frmnr > 0:
 cf = cf.f_back
 frmnr -= 1
 _globals = cf.f_globals
-_locals = self.currentThread.getCurrentFrameLocals()
+_locals = \
+self.currentThread.getCurrentFrameLocals()
 # reset sys.stdout to our redirector (unconditionally)
 if "sys" in _globals:
 __stdout = _globals["sys"].stdout
 _globals["sys"].stdout = self.writestream
 exec(code, _globals, _locals)
 tblist = traceback.extract_tb(exc_tb)
 del tblist[:1]
 list = traceback.format_list(tblist)
 if list:
 list.insert(0, "Traceback (innermost last):\n")
-list[len(list):] = \
+list[len(list):] = traceback.format_exception_only(
-traceback.format_exception_only(exc_type, exc_value)
+exc_type, exc_value)
 finally:
 tblist = exc_tb = None
 for l in list:
 self.write(l)
 del sys.modules['PyProfile']
 except KeyError:
 pass
 return self.clientCapabilities
 except ImportError:
-return self.clientCapabilities & ~DebugClientCapabilities.HasProfiler
+return (self.clientCapabilities &
+~DebugClientCapabilities.HasProfiler)
 def write(self, s):
 """
 Public method to write data to the output stream.
 It opens a network connection to the debugger, connects it to stdin,
 stdout and stderr and saves these file objects in case the application
 being debugged redirects them itself.
 @param port the port number to connect to (int)
-@param remoteAddress the network address of the debug server host (string)
+@param remoteAddress the network address of the debug server host
-@param redirect flag indicating redirection of stdin, stdout and stderr (boolean)
+(string)
-"""
+@param redirect flag indicating redirection of stdin, stdout and
-if remoteAddress is None:                               # default: 127.0.0.1
+stderr (boolean)
+"""
+if remoteAddress is None:                       # default: 127.0.0.1
 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 sock.connect((DebugProtocol.DebugAddress, port))
 else:
 if "@@i" in remoteAddress:
 remoteAddress, index = remoteAddress.split("@@i")
 else:
 index = 0
-if ":" in remoteAddress:                              # IPv6
+if ":" in remoteAddress:                    # IPv6
 sockaddr = socket.getaddrinfo(
 remoteAddress, port, 0, 0, socket.SOL_TCP)[0][-1]
 sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
 sockaddr = sockaddr[:-1] + (int(index),)
 sock.connect(sockaddr)
-else:                                                   # IPv4
+else:                                       # IPv4
 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 sock.connect((remoteAddress, port))
 self.readstream = AsyncFile(sock, sys.stdin.mode, sys.stdin.name)
 self.writestream = AsyncFile(sock, sys.stdout.mode, sys.stdout.name)
 def shouldSkip(self, fn):
 """
 Public method to check if a file should be skipped.
 @param fn filename to be checked
-@return non-zero if fn represents a file we are 'skipping', zero otherwise.
+@return non-zero if fn represents a file we are 'skipping',
+zero otherwise.
 """
 if self.mainThread.tracePython:     # trace into Python library
 return False
 # Eliminate anything that is part of the Python installation.
 def __dumpVariables(self, frmnr, scope, filter):
 """
 Private method to return the variables of a frame to the debug server.
-@param frmnr distance of frame reported on. 0 is the current frame (int)
+@param frmnr distance of frame reported on. 0 is the current frame
+(int)
 @param scope 1 to report global variables, 0 for local variables (int)
-@param filter the indices of variable types to be filtered (list of int)
+@param filter the indices of variable types to be filtered
+(list of int)
 """
 if self.currentThread is None:
 return
 if scope == 0:
 keylist = dict.keys()
 vlist = self.__formatVariablesList(keylist, dict, scope, filter)
 varlist.extend(vlist)
-self.write('{0}{1}\n'.format(DebugProtocol.ResponseVariables, str(varlist)))
+self.write('{0}{1}\n'.format(
+DebugProtocol.ResponseVariables, str(varlist)))
 def __dumpVariable(self, var, frmnr, scope, filter):
 """
 Private method to return the variables of a frame to the debug server.
-@param var list encoded name of the requested variable (list of strings)
+@param var list encoded name of the requested variable
-@param frmnr distance of frame reported on. 0 is the current frame (int)
+(list of strings)
+@param frmnr distance of frame reported on. 0 is the current frame
+(int)
 @param scope 1 to report global variables, 0 for local variables (int)
-@param filter the indices of variable types to be filtered (list of int)
+@param filter the indices of variable types to be filtered
+(list of int)
 """
 if self.currentThread is None:
 return
 f = self.currentThread.getCurrentFrame()
 else:
 if var[i][:-2] == '...':
 if oaccess:
 access = oaccess
 else:
-access = '{0!s}[{1!s}]'.format(access, var[i - 1])
+access = '{0!s}[{1!s}]'.format(
+access, var[i - 1])
 dict = odict
 else:
 if oaccess:
-access = '{0!s}[{1!s}]'.format(oaccess, var[i][:-2])
+access = '{0!s}[{1!s}]'.format(
+oaccess, var[i][:-2])
 oaccess = ''
 else:
-access = '{0!s}[{1!s}]'.format(access, var[i][:-2])
+access = '{0!s}[{1!s}]'.format(
+access, var[i][:-2])
 if var[i][-2:] == "{}":
 isDict = True
 break
 else:
 if not access:
 dict = odict
 else:
 access = '["{0!s}"]'.format(var[i][:-2])
 else:
 if var[i][:-2] == '...':
-access = '{0!s}[{1!s}]'.format(access, var[i - 1])
+access = '{0!s}[{1!s}]'.format(
+access, var[i - 1])
 dict = odict
 else:
 if oaccess:
-access = '{0!s}[{1!s}]'.format(oaccess, var[i][:-2])
+access = '{0!s}[{1!s}]'.format(
+oaccess, var[i][:-2])
 oaccess = ''
 else:
-access = '{0!s}[{1!s}]'.format(access, var[i][:-2])
+access = '{0!s}[{1!s}]'.format(
+access, var[i][:-2])
 else:
 if access:
 if oaccess:
 access = '{0!s}[{1!s}]'.format(oaccess, var[i])
 else:
 exec('slv = dict{0!s}.__slots__'.format(access),
 globals(), loc)
 for v in loc["slv"]:
 try:
 loc["v"] = v
-exec('cdict[v] = dict{0!s}.{1!s}'.format(access, v),
+exec('cdict[v] = dict{0!s}.{1!s}'.format(
+access, v),
 globals, loc)
 except:
 pass
 ndict.update(loc["cdict"])
-exec('obj = dict{0!s}'.format(access), globals(), loc)
+exec('obj = dict{0!s}'.format(access),
+globals(), loc)
 obj = loc["obj"]
 access = ""
 if "PyQt4." in str(type(obj)):
 qtVariable = True
 qvar = obj
 qvtype = str(type(qvar))[1:-1].split()[1][1:-1]
 except:
 pass
 try:
 slv = dict[var[i]].__slots__
-loc = {"cdict": {}, "dict": dict, "var": var, "i": i}
+loc = {"cdict": {}, "dict": dict,
+"var": var, "i": i}
 for v in slv:
 try:
 loc["v"] = v
-exec('cdict[v] = dict[var[i]].{0!s}'.format(v),
+exec('cdict[v] = dict[var[i]].{0!s}'
+.format(v),
 globals(), loc)
 except:
 pass
 ndict.update(loc["cdict"])
 obj = dict[var[i]]
 exec('qvar = udict{0!s}'.format(access), globals(), loc)
 qvar = loc["qvar"]
 # this has to be in line with VariablesViewer.indicators
 elif rvar and rvar[0][-2:] in ["[]", "()", "{}"]:
 loc = {"udict": udict}
-exec('qvar = udict["{0!s}"][{1!s}]'.format(rvar[0][:-2], rvar[1]),
+exec('qvar = udict["{0!s}"][{1!s}]'.format(rvar[0][:-2],
+rvar[1]),
 globals(), loc)
 qvar = loc["qvar"]
 else:
 qvar = udict[var[-1]]
 qvtype = str(type(qvar))[1:-1].split()[1][1:-1]
 exec('qvar = udict{0!s}'.format(access), globals(), loc)
 qvar = loc["qvar"]
 # this has to be in line with VariablesViewer.indicators
 elif rvar and rvar[0][-2:] in ["[]", "()", "{}"]:
 loc = {"udict": udict}
-exec('qvar = udict["{0!s}"][{1!s}]'.format(rvar[0][:-2], rvar[1]),
+exec('qvar = udict["{0!s}"][{1!s}]'.format(
-globals(), loc)
+rvar[0][:-2], rvar[1]), globals(), loc)
 qvar = loc["qvar"]
 else:
 qvar = udict[var[-1]]
 qvtype = str(type(qvar))[1:-1].split()[1][1:-1]
 if qvtype.startswith("PyQt4"):
 dictkeys = dict.keys()
 else:
 # treatment for sequences and dictionaries
 if access:
 loc = {"dict": dict}
-exec("dict = dict{0!s}".format(access), globals(), loc)
+exec("dict = dict{0!s}".format(access), globals(),
+loc)
 dict = loc["dict"]
 else:
 dict = dict[dictkeys[0]]
 if isDict:
 dictkeys = dict.keys()
 else:
 dictkeys = range(len(dict))
-vlist = self.__formatVariablesList(dictkeys, dict, scope, filter,
+vlist = self.__formatVariablesList(
-formatSequences)
+dictkeys, dict, scope, filter, formatSequences)
 varlist.extend(vlist)
 if obj is not None and not formatSequences:
 try:
 if repr(obj).startswith('{'):
-varlist.append(('...', 'dict', "{0:d}".format(len(obj.keys()))))
+varlist.append(
+('...', 'dict', "{0:d}".format(len(obj.keys()))))
 elif repr(obj).startswith('['):
-varlist.append(('...', 'list', "{0:d}".format(len(obj))))
+varlist.append(
+('...', 'list', "{0:d}".format(len(obj))))
 elif repr(obj).startswith('('):
-varlist.append(('...', 'tuple', "{0:d}".format(len(obj))))
+varlist.append(
+('...', 'tuple', "{0:d}".format(len(obj))))
 except:
 pass
-self.write('{0}{1}\n'.format(DebugProtocol.ResponseVariable, str(varlist)))
+self.write('{0}{1}\n'.format(
+DebugProtocol.ResponseVariable, str(varlist)))
 def __formatQt4Variable(self, value, vtype):
 """
 Private method to produce a formatted output of a simple Qt4/Qt5 type.
 varlist = []
 if qttype == 'QChar':
 varlist.append(("", "QChar", "{0}".format(chr(value.unicode()))))
 varlist.append(("", "int", "{0:d}".format(value.unicode())))
 elif qttype == 'QByteArray':
-varlist.append(("bytes", "QByteArray", "{0}".format(bytes(value))[2:-1]))
+varlist.append(
-varlist.append(("hex", "QByteArray", "{0}".format(value.toHex())[2:-1]))
+("bytes", "QByteArray", "{0}".format(bytes(value))[2:-1]))
-varlist.append(("base64", "QByteArray", "{0}".format(value.toBase64())[2:-1]))
+varlist.append(
+("hex", "QByteArray", "{0}".format(value.toHex())[2:-1]))
+varlist.append(
+("base64", "QByteArray", "{0}".format(value.toBase64())[2:-1]))
 varlist.append(("percent encoding", "QByteArray",
 "{0}".format(value.toPercentEncoding())[2:-1]))
 elif qttype == 'QPoint':
 varlist.append(("x", "int", "{0:d}".format(value.x())))
 varlist.append(("y", "int", "{0:d}".format(value.y())))
 varlist.append(("width", "float", "{0:g}".format(value.width())))
 varlist.append(("height", "float", "{0:g}".format(value.height())))
 elif qttype == 'QColor':
 varlist.append(("name", "str", "{0}".format(value.name())))
 r, g, b, a = value.getRgb()
-varlist.append(("rgb", "int",
+varlist.append(
-"{0:d}, {1:d}, {2:d}, {3:d}".format(r, g, b, a)))
+("rgb", "int",
+"{0:d}, {1:d}, {2:d}, {3:d}".format(r, g, b, a)))
 h, s, v, a = value.getHsv()
-varlist.append(("hsv", "int",
+varlist.append(
-"{0:d}, {1:d}, {2:d}, {3:d}".format(h, s, v, a)))
+("hsv", "int",
+"{0:d}, {1:d}, {2:d}, {3:d}".format(h, s, v, a)))
 c, m, y, k, a = value.getCmyk()
-varlist.append(("cmyk", "int",
+varlist.append(
-"{0:d}, {1:d}, {2:d}, {3:d}, {4:d}".format(c, m, y, k, a)))
+("cmyk", "int",
+"{0:d}, {1:d}, {2:d}, {3:d}, {4:d}".format(c, m, y, k, a)))
 elif qttype == 'QDate':
 varlist.append(("", "QDate", "{0}".format(value.toString())))
 elif qttype == 'QTime':
 varlist.append(("", "QTime", "{0}".format(value.toString())))
 elif qttype == 'QDateTime':
 "{0}".format(value.canonicalPath())))
 elif qttype == 'QFile':
 varlist.append(("fileName", "str", "{0}".format(value.fileName())))
 elif qttype == 'QFont':
 varlist.append(("family", "str", "{0}".format(value.family())))
-varlist.append(("pointSize", "int", "{0:d}".format(value.pointSize())))
+varlist.append(
+("pointSize", "int", "{0:d}".format(value.pointSize())))
 varlist.append(("weight", "int", "{0:d}".format(value.weight())))
 varlist.append(("bold", "bool", "{0}".format(value.bold())))
 varlist.append(("italic", "bool", "{0}".format(value.italic())))
 elif qttype == 'QUrl':
 varlist.append(("url", "str", "{0}".format(value.toString())))
 elif qttype == 'QModelIndex':
 varlist.append(("valid", "bool", "{0}".format(value.isValid())))
 if value.isValid():
 varlist.append(("row", "int", "{0}".format(value.row())))
 varlist.append(("column", "int", "{0}".format(value.column())))
-varlist.append(("internalId", "int", "{0}".format(value.internalId())))
+varlist.append(
+("internalId", "int", "{0}".format(value.internalId())))
 varlist.append(("internalPointer", "void *",
 "{0}".format(value.internalPointer())))
 elif qttype == 'QRegExp':
 varlist.append(("pattern", "str", "{0}".format(value.pattern())))
 # GUI stuff
 elif qttype == 'QAction':
 varlist.append(("name", "str", "{0}".format(value.objectName())))
 varlist.append(("text", "str", "{0}".format(value.text())))
-varlist.append(("icon text", "str", "{0}".format(value.iconText())))
+varlist.append(
+("icon text", "str", "{0}".format(value.iconText())))
 varlist.append(("tooltip", "str", "{0}".format(value.toolTip())))
-varlist.append(("whatsthis", "str", "{0}".format(value.whatsThis())))
+varlist.append(
-varlist.append(("shortcut", "str",
+("whatsthis", "str", "{0}".format(value.whatsThis())))
-"{0}".format(value.shortcut().toString())))
+varlist.append(
+("shortcut", "str",
+"{0}".format(value.shortcut().toString())))
 elif qttype == 'QKeySequence':
 varlist.append(("value", "", "{0}".format(value.toString())))
 # XML stuff
 elif qttype == 'QDomAttr':
 elif qttype == 'QDomText':
 varlist.append(("data", "str", "{0}".format(value.data())))
 # Networking stuff
 elif qttype == 'QHostAddress':
-varlist.append(("address", "QHostAddress", "{0}".format(value.toString())))
+varlist.append(
+("address", "QHostAddress", "{0}".format(value.toString())))
 return varlist
 def __formatVariablesList(self, keylist, dict, scope, filter=[],
 formatSequences=False):
 """
 Private method to produce a formated variables list.
 The dictionary passed in to it is scanned. Variables are
 only added to the list, if their type is not contained
-in the filter list and their name doesn't match any of the filter expressions.
+in the filter list and their name doesn't match any of the filter
-The formated variables list (a list of tuples of 3 values) is returned.
+expressions. The formated variables list (a list of tuples of 3
+values) is returned.
 @param keylist keys of the dictionary
 @param dict the dictionary to be scanned
 @param scope 1 to filter using the globals filter, 0 using the locals
 filter (int).
-Variables are only added to the list, if their name do not match any of the
+Variables are only added to the list, if their name do not match
-filter expressions.
+any of the filter expressions.
-@param filter the indices of variable types to be filtered. Variables are
+@param filter the indices of variable types to be filtered. Variables
-only added to the list, if their type is not contained in the filter
+are only added to the list, if their type is not contained in the
-list.
+filter list.
-@param formatSequences flag indicating, that sequence or dictionary variables
+@param formatSequences flag indicating, that sequence or dictionary
-should be formatted. If it is 0 (or false), just the number of items contained
+variables should be formatted. If it is 0 (or false), just the
-in these variables is returned. (boolean)
+number of items contained in these variables is returned. (boolean)
-@return A tuple consisting of a list of formatted variables. Each variable
+@return A tuple consisting of a list of formatted variables. Each
-entry is a tuple of three elements, the variable name, its type and
+variable entry is a tuple of three elements, the variable name,
-value.
+its type and value.
 """
 varlist = []
 if scope:
 patternFilterObjects = self.globalsFilterObjects
 else:
 valtype = valtypestr[7:-1]
 if valtype not in ConfigVarTypeStrings:
 if ConfigVarTypeStrings.index('instance') in filter:
 continue
 elif valtype == "sip.methoddescriptor":
-if ConfigVarTypeStrings.index('instance method') in filter:
+if ConfigVarTypeStrings.index(
+'instance method') in filter:
 continue
 elif valtype == "sip.enumtype":
 if ConfigVarTypeStrings.index('class') in filter:
 continue
 valtype = valtypestr
 try:
 if ConfigVarTypeStrings.index(valtype) in filter:
 continue
 except ValueError:
 if valtype == "classobj":
-if ConfigVarTypeStrings.index('instance') in filter:
+if ConfigVarTypeStrings.index(
+'instance') in filter:
 continue
 elif valtype == "sip.methoddescriptor":
-if ConfigVarTypeStrings.index('instance method') in filter:
+if ConfigVarTypeStrings.index(
+'instance method') in filter:
 continue
 elif valtype == "sip.enumtype":
 if ConfigVarTypeStrings.index('class') in filter:
 continue
 elif not valtype.startswith("PySide") and \
 self.write("{0}{1}||{2}\n".format(DebugProtocol.ResponseCompletion,
 str(completions), text))
 def startDebugger(self, filename=None, host=None, port=None,
-enableTrace=True, exceptions=True, tracePython=False, redirect=True):
+enableTrace=True, exceptions=True, tracePython=False,
+redirect=True):
 """
 Public method used to start the remote debugger.
 @param filename the program to be debugged (string)
 @param host hostname of the debug server (string)
 @param port portnumber of the debug server (int)
 @param enableTrace flag to enable the tracing function (boolean)
-@param exceptions flag to enable exception reporting of the IDE (boolean)
+@param exceptions flag to enable exception reporting of the IDE
-@param tracePython flag to enable tracing into the Python library (boolean)
+(boolean)
-@param redirect flag indicating redirection of stdin, stdout and stderr (boolean)
+@param tracePython flag to enable tracing into the Python library
+(boolean)
+@param redirect flag indicating redirection of stdin, stdout and
+stderr (boolean)
 """
 global debugClient
 if host is None:
 host = os.getenv('ERICHOST', 'localhost')
 if port is None:
 @param progargs commandline for the program to be debugged
 (list of strings)
 @param wd working directory for the program execution (string)
 @param host hostname of the debug server (string)
 @param port portnumber of the debug server (int)
-@param exceptions flag to enable exception reporting of the IDE (boolean)
+@param exceptions flag to enable exception reporting of the IDE
-@param tracePython flag to enable tracing into the Python library (boolean)
+(boolean)
-@param redirect flag indicating redirection of stdin, stdout and stderr (boolean)
+@param tracePython flag to enable tracing into the Python library
+(boolean)
+@param redirect flag indicating redirection of stdin, stdout and
+stderr (boolean)
 """
 if host is None:
 host = os.getenv('ERICHOST', 'localhost')
 if port is None:
 port = os.getenv('ERICPORT', 42424)
 sys.excepthook = self.__unhandled_exception
 # This will eventually enter a local event loop.
 # Note the use of backquotes to cause a repr of self.running. The
 # need for this is on Windows os where backslash is the path separator.
-# They will get inadvertantly stripped away during the eval causing IOErrors
+# They will get inadvertantly stripped away during the eval causing
-# if self.running is passed as a normal str.
+# IOErrors if self.running is passed as a normal str.
 self.debugMod.__dict__['__file__'] = self.running
 sys.modules['__main__'] = self.debugMod
-res = self.mainThread.run('exec(open(' + repr(self.running) + ').read())',
+res = self.mainThread.run(
-self.debugMod.__dict__)
+'exec(open(' + repr(self.running) + ').read())',
+self.debugMod.__dict__)
 self.progTerminated(res)
 def run_call(self, scriptname, func, *args):
 """
 Public method used to start the remote debugger and call a function.
 version = 'v4'
 if version == 'v4':
 family = socket.AF_INET
 else:
 family = socket.AF_INET6
-return socket.getaddrinfo(host, None, family, socket.SOCK_STREAM)[0][4][0]
+return socket.getaddrinfo(host, None,
+family, socket.SOCK_STREAM)[0][4][0]
 def main(self):
 """
 Public method implementing the main method.
 """
 self.sessionClose(0)
 return pid
 def close(self, fd):
 """
-Private method implementing a close method as a replacement for os.close().
+Private method implementing a close method as a replacement for
+os.close().
 It prevents the debugger connections from being closed.
 @param fd file descriptor to be closed (integer)
 """
 environment variable.
 @param firstEntry entry to be put first in sys.path (string)
 @return path list for use as sys.path (list of strings)
 """
-sysPath = [path for path in os.environ.get("PYTHONPATH", "").split(os.pathsep)
+sysPath = [path for path in os.environ.get("PYTHONPATH", "")
+.split(os.pathsep)
 if path not in sys.path] + sys.path[:]
 if "" in sysPath:
 sysPath.remove("")
 sysPath.insert(0, firstEntry)
 sysPath.insert(0, '')

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python3/DebugClientBase.py

DebugClients/Python3/DebugClientBase.py