eric: comparison Debugger/DebuggerInterfacePython.py

-:c99695c0f13a
+:f53c03574697
 self.qsock = None
 self.queue = []
 # set default values for capabilities of clients
 self.clientCapabilities = ClientDefaultCapabilities
-self.codec = QTextCodec.codecForName(Preferences.getSystem("StringEncoding"))
+self.codec = QTextCodec.codecForName(
+Preferences.getSystem("StringEncoding"))
 self.__unicodeRe = re.compile(r"""\bu(["'])""")
 if passive:
 # set translation function
 """
 Private method to start the debugger client process.
 @param program name of the executable to start (string)
 @param arguments arguments to be passed to the program (list of string)
-@param environment dictionary of environment settings to pass (dict of string)
+@param environment dictionary of environment settings to pass
+(dict of string)
 @return the process object (QProcess) or None
 """
 proc = QProcess()
 if environment is not None:
 env = []
 return None, False
 debugClientType = Preferences.getDebugger("DebugClientType")
 if debugClientType == "standard":
 debugClient = os.path.join(getConfig('ericDir'),
-"DebugClients", "Python", "DebugClient.py")
+"DebugClients", "Python",
+"DebugClient.py")
 elif debugClientType == "threaded":
 debugClient = os.path.join(getConfig('ericDir'),
-"DebugClients", "Python", "DebugClientThreads.py")
+"DebugClients", "Python",
+"DebugClientThreads.py")
 else:
 debugClient = Preferences.getDebugger("DebugClient")
 if debugClient == "":
 debugClient = os.path.join(sys.path[0],
-"DebugClients", "Python", "DebugClient.py")
+"DebugClients", "Python",
+"DebugClient.py")
 redirect = str(Preferences.getDebugger("PythonRedirect"))
-noencoding = \
+noencoding = Preferences.getDebugger("PythonNoEncoding") and \
-Preferences.getDebugger("PythonNoEncoding") and '--no-encoding' or ''
+'--no-encoding' or ''
 if Preferences.getDebugger("RemoteDbgEnabled"):
 ipaddr = self.debugServer.getHostAddress(False)
 rexec = Preferences.getDebugger("RemoteExecution")
 rhost = Preferences.getDebugger("RemoteHost")
 process = self.__startProcess(args[0], args[1:])
 if process is None:
 E5MessageBox.critical(None,
 self.trUtf8("Start Debugger"),
 self.trUtf8(
-"""<p>The debugger backend could not be started.</p>"""))
+"""<p>The debugger backend could not be"""
+""" started.</p>"""))
 # set translation function
 if Preferences.getDebugger("PathTranslation"):
 self.translateRemote = \
 Preferences.getDebugger("PathTranslationRemote")
 process = self.__startProcess(args[0], args[1:], clientEnv)
 if process is None:
 E5MessageBox.critical(None,
 self.trUtf8("Start Debugger"),
 self.trUtf8(
-"""<p>The debugger backend could not be started.</p>"""))
+"""<p>The debugger backend could not be"""
+""" started.</p>"""))
 return process, self.__isNetworked
 process = self.__startProcess(interpreter,
 [debugClient, noencoding, str(port), redirect, ipaddr],
 clientEnv)
 if process is None:
 E5MessageBox.critical(None,
 self.trUtf8("Start Debugger"),
-self.trUtf8("""<p>The debugger backend could not be started.</p>"""))
+self.trUtf8(
+"""<p>The debugger backend could not be started.</p>"""))
 return process, self.__isNetworked
 def startRemoteForProject(self, port, runInConsole):
 """
 Public method to start a remote Python interpreter for a project.
 process = self.__startProcess(args[0], args[1:])
 if process is None:
 E5MessageBox.critical(None,
 self.trUtf8("Start Debugger"),
 self.trUtf8(
-"""<p>The debugger backend could not be started.</p>"""))
+"""<p>The debugger backend could not be"""
+""" started.</p>"""))
 # set translation function
 if project.getDebugProperty("PATHTRANSLATION"):
-self.translateRemote = project.getDebugProperty("REMOTEPATH")
+self.translateRemote = \
-self.translateLocal = project.getDebugProperty("LOCALPATH")
+project.getDebugProperty("REMOTEPATH")
+self.translateLocal = \
+project.getDebugProperty("LOCALPATH")
 self.translate = self.__remoteTranslation
 else:
 self.translate = self.__identityTranslation
 return process, self.__isNetworked
 process = self.__startProcess(args[0], args[1:], clientEnv)
 if process is None:
 E5MessageBox.critical(None,
 self.trUtf8("Start Debugger"),
 self.trUtf8(
-"""<p>The debugger backend could not be started.</p>"""))
+"""<p>The debugger backend could not be"""
+""" started.</p>"""))
 return process, self.__isNetworked
 process = self.__startProcess(interpreter,
 [debugClient, noencoding, str(port), redirect, ipaddr],
 clientEnv)
 if process is None:
 E5MessageBox.critical(None,
 self.trUtf8("Start Debugger"),
-self.trUtf8("""<p>The debugger backend could not be started.</p>"""))
+self.trUtf8(
+"""<p>The debugger backend could not be started.</p>"""))
 return process, self.__isNetworked
 def getClientCapabilities(self):
 """
 Public method to retrieve the debug clients capabilities.
 """
 Public method to set the environment for a program to debug, run, ...
 @param env environment settings (dictionary)
 """
-self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestEnv, str(env)))
+self.__sendCommand('{0}{1}\n'.format(
+DebugProtocol.RequestEnv, str(env)))
 def remoteLoad(self, fn, argv, wd, traceInterpreter=False, autoContinue=True,
 autoFork=False, forkChild=False):
 """
 Public method to load a new program to debug.
 @param fn the filename to debug (string)
 @param argv the commandline arguments to pass to the program (string)
 @param wd the working directory for the program (string)
-@keyparam traceInterpreter flag indicating if the interpreter library should be
+@keyparam traceInterpreter flag indicating if the interpreter library
-traced as well (boolean)
+should be traced as well (boolean)
-@keyparam autoContinue flag indicating, that the debugger should not stop
+@keyparam autoContinue flag indicating, that the debugger should not
-at the first executable line (boolean)
+stop at the first executable line (boolean)
 @keyparam autoFork flag indicating the automatic fork mode (boolean)
-@keyparam forkChild flag indicating to debug the child after forking (boolean)
+@keyparam forkChild flag indicating to debug the child after forking
+(boolean)
 """
 self.__autoContinue = autoContinue
 self.__scriptName = os.path.abspath(fn)
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
 self.__sendCommand('{0}{1}\n'.format(
 DebugProtocol.RequestForkMode, repr((autoFork, forkChild))))
 self.__sendCommand('{0}{1}|{2}|{3}|{4:d}\n'.format(
-DebugProtocol.RequestLoad, wd, fn, str(Utilities.parseOptionString(argv)),
+DebugProtocol.RequestLoad, wd, fn,
-traceInterpreter))
+str(Utilities.parseOptionString(argv)),
+traceInterpreter))
 def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
 """
 Public method to load a new program to run.
 @param fn the filename to run (string)
 @param argv the commandline arguments to pass to the program (string)
 @param wd the working directory for the program (string)
 @keyparam autoFork flag indicating the automatic fork mode (boolean)
-@keyparam forkChild flag indicating to debug the child after forking (boolean)
+@keyparam forkChild flag indicating to debug the child after forking
+(boolean)
 """
 self.__scriptName = os.path.abspath(fn)
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
 self.__sendCommand('{0}{1}\n'.format(
 DebugProtocol.RequestForkMode, repr((autoFork, forkChild))))
 self.__sendCommand('{0}{1}|{2}|{3}\n'.format(
-DebugProtocol.RequestRun, wd, fn, str(Utilities.parseOptionString(argv))))
+DebugProtocol.RequestRun, wd, fn,
+str(Utilities.parseOptionString(argv))))
 def remoteCoverage(self, fn, argv, wd, erase=False):
 """
 Public method to load a new program to collect coverage data.
 self.__scriptName = os.path.abspath(fn)
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
 self.__sendCommand('{0}{1}@@{2}@@{3}@@{4:d}\n'.format(
-DebugProtocol.RequestCoverage, wd, fn, str(Utilities.parseOptionString(argv)),
+DebugProtocol.RequestCoverage, wd, fn,
-erase))
+str(Utilities.parseOptionString(argv)), erase))
 def remoteProfile(self, fn, argv, wd, erase=False):
 """
 Public method to load a new program to collect profiling data.
 @param fn the filename to run (string)
 @param argv the commandline arguments to pass to the program (string)
 @param wd the working directory for the program (string)
-@keyparam erase flag indicating that timing info should be cleared first (boolean)
+@keyparam erase flag indicating that timing info should be cleared
+first (boolean)
 """
 self.__scriptName = os.path.abspath(fn)
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
 """
 Public method to continue the debugged program.
 @param special flag indicating a special continue operation (boolean)
 """
-self.__sendCommand('{0}{1:d}\n'.format(DebugProtocol.RequestContinue, special))
+self.__sendCommand('{0}{1:d}\n'.format(
+DebugProtocol.RequestContinue, special))
 def remoteBreakpoint(self, fn, line, set, cond=None, temp=False):
 """
 Public method to set or clear a breakpoint.
 @param cond condition of the breakpoint (string)
 @param temp flag indicating a temporary breakpoint (boolean)
 """
 fn = self.translate(fn, False)
 self.__sendCommand('{0}{1}@@{2:d}@@{3:d}@@{4:d}@@{5}\n'.format(
-DebugProtocol.RequestBreak, fn, line, temp, set, cond))
+DebugProtocol.RequestBreak, fn, line, temp, set,
+cond))
 def remoteBreakpointEnable(self, fn, line, enable):
 """
 Public method to enable or disable a breakpoint.
 @param fn filename the breakpoint belongs to (string)
 @param line linenumber of the breakpoint (int)
-@param enable flag indicating enabling or disabling a breakpoint (boolean)
+@param enable flag indicating enabling or disabling a breakpoint
+(boolean)
 """
 fn = self.translate(fn, False)
 self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
 DebugProtocol.RequestBreakEnable, fn, line, enable))
 def remoteWatchpoint(self, cond, set, temp=False):
 """
 Public method to set or clear a watch expression.
 @param cond expression of the watch expression (string)
-@param set flag indicating setting or resetting a watch expression (boolean)
+@param set flag indicating setting or resetting a watch expression
+(boolean)
 @param temp flag indicating a temporary watch expression (boolean)
 """
 # cond is combination of cond and special (s. watch expression viewer)
 self.__sendCommand('{0}{1}@@{2:d}@@{3:d}\n'.format(
 DebugProtocol.RequestWatch, cond, temp, set))
 def remoteWatchpointEnable(self, cond, enable):
 """
 Public method to enable or disable a watch expression.
 @param cond expression of the watch expression (string)
-@param enable flag indicating enabling or disabling a watch expression (boolean)
+@param enable flag indicating enabling or disabling a watch expression
+(boolean)
 """
 # cond is combination of cond and special (s. watch expression viewer)
 self.__sendCommand('{0}{1},{2:d}\n'.format(
 DebugProtocol.RequestWatchEnable, cond, enable))
 def remoteWatchpointIgnore(self, cond, count):
 """
-Public method to ignore a watch expression the next couple of occurrences.
+Public method to ignore a watch expression the next couple of
+occurrences.
 @param cond expression of the watch expression (string)
 @param count number of occurrences to ignore (int)
 """
 # cond is combination of cond and special (s. watch expression viewer)
 """
 Public method to request to set the given thread as current thread.
 @param tid id of the thread (integer)
 """
-self.__sendCommand('{0}{1:d}\n'.format(DebugProtocol.RequestThreadSet, tid))
+self.__sendCommand('{0}{1:d}\n'.format(
+DebugProtocol.RequestThreadSet, tid))
 def remoteClientVariables(self, scope, filter, framenr=0):
 """
 Public method to request the variables of the debugged program.
 @param filter list of variable types to filter out (list of int)
 @param var list encoded name of variable to retrieve (string)
 @param framenr framenumber of the variables to retrieve (int)
 """
 self.__sendCommand('{0}{1}, {2:d}, {3:d}, {4}\n'.format(
-DebugProtocol.RequestVariable, str(var), framenr, scope, str(filter)))
+DebugProtocol.RequestVariable, str(var), framenr, scope,
+str(filter)))
 def remoteClientSetFilter(self, scope, filter):
 """
 Public method to set a variables filter list.
 """
 if on:
 cmd = "on"
 else:
 cmd = "off"
-self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestCallTrace, cmd))
+self.__sendCommand('{0}{1}\n'.format(
+DebugProtocol.RequestCallTrace, cmd))
 def remoteEval(self, arg):
 """
-Public method to evaluate arg in the current context of the debugged program.
+Public method to evaluate arg in the current context of the debugged
+program.
 @param arg the arguments to evaluate (string)
 """
 self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestEval, arg))
 def remoteExec(self, stmt):
 """
-Public method to execute stmt in the current context of the debugged program.
+Public method to execute stmt in the current context of the debugged
+program.
 @param stmt statement to execute (string)
 """
 self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestExec, stmt))
 Public slot to get the a list of possible commandline completions
 from the remote client.
 @param text the text to be completed (string)
 """
-self.__sendCommand("{0}{1}\n".format(DebugProtocol.RequestCompletion, text))
+self.__sendCommand("{0}{1}\n".format(
+DebugProtocol.RequestCompletion, text))
 def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase):
 """
 Public method to prepare a new unittest run.
 @param fn the filename to load (string)
 @param tn the testname to load (string)
 @param tfn the test function name to load tests from (string)
 @param failed list of failed test, if only failed test should be run
 (list of strings)
-@param cov flag indicating collection of coverage data is requested (boolean)
+@param cov flag indicating collection of coverage data is requested
+(boolean)
 @param covname filename to be used to assemble the coverage caches
 filename (string)
-@param coverase flag indicating erasure of coverage data is requested (boolean)
+@param coverase flag indicating erasure of coverage data is requested
+(boolean)
 """
 self.__scriptName = os.path.abspath(fn)
 fn = self.translate(os.path.abspath(fn), False)
 self.__sendCommand('{0}{1}|{2}|{3}|{4}|{5:d}|{6}|{7:d}\n'.format(
 def __askForkTo(self):
 """
 Private method to ask the user which branch of a fork to follow.
 """
-selections = [self.trUtf8("Parent Process"), self.trUtf8("Child process")]
+selections = [self.trUtf8("Parent Process"),
+self.trUtf8("Child process")]
 res, ok = QInputDialog.getItem(
 None,
 self.trUtf8("Client forking"),
 self.trUtf8("Select the fork branch to follow."),
 selections,
 cf = stack[0]
 if self.__autoContinue:
 self.__autoContinue = False
 QTimer.singleShot(0, self.remoteContinue)
 else:
-self.debugServer.signalClientLine(cf[0], int(cf[1]),
+self.debugServer.signalClientLine(
-resp == DebugProtocol.ResponseStack)
+cf[0], int(cf[1]),
+resp == DebugProtocol.ResponseStack)
 self.debugServer.signalClientStack(stack)
 continue
 if resp == DebugProtocol.CallTrace:
 event, fromStr, toStr = line[eoc:-1].split("@@")
 toFile, toLineno, toFunc)
 continue
 if resp == DebugProtocol.ResponseThreadList:
 currentId, threadList = eval(evalArg)
-self.debugServer.signalClientThreadList(currentId, threadList)
+self.debugServer.signalClientThreadList(
+currentId, threadList)
 continue
 if resp == DebugProtocol.ResponseThreadSet:
 self.debugServer.signalClientThreadSet()
 continue
 break
 except (IndexError, ValueError, SyntaxError):
 exctype = None
 excmessage = ''
 stack = []
-self.debugServer.signalClientException(exctype, excmessage, stack)
+self.debugServer.signalClientException(
+exctype, excmessage, stack)
 continue
 if resp == DebugProtocol.ResponseSyntax:
 exc = self.translate(evalArg, True)
 try:
 fn = ''
 ln = 0
 cn = 0
 if cn is None:
 cn = 0
-self.debugServer.signalClientSyntaxError(message, fn, ln, cn)
+self.debugServer.signalClientSyntaxError(
+message, fn, ln, cn)
 continue
 if resp == DebugProtocol.ResponseExit:
 self.__scriptName = ""
 self.debugServer.signalClientExit(evalArg)
 if resp == DebugProtocol.ResponseBPConditionError:
 fn, lineno = evalArg.split(',')
 lineno = int(lineno)
 fn = self.translate(fn, True)
-self.debugServer.signalClientBreakConditionError(fn, lineno)
+self.debugServer.signalClientBreakConditionError(
+fn, lineno)
 continue
 if resp == DebugProtocol.ResponseClearWatch:
 self.debugServer.signalClientClearWatch(evalArg)
 continue
 self.debugServer.signalClientRawInput(prompt, echo)
 continue
 if resp == DebugProtocol.ResponseBanner:
 version, platform, dbgclient = eval(evalArg)
-self.debugServer.signalClientBanner(version, platform, dbgclient)
+self.debugServer.signalClientBanner(
+version, platform, dbgclient)
 continue
 if resp == DebugProtocol.ResponseCapabilities:
 cap, clType = eval(evalArg)
 self.clientCapabilities = cap
 self.debugServer.clientUtStopTest()
 continue
 if resp == DebugProtocol.ResponseUTTestFailed:
 testname, traceback, id = eval(evalArg)
-self.debugServer.clientUtTestFailed(testname, traceback, id)
+self.debugServer.clientUtTestFailed(
+testname, traceback, id)
 continue
 if resp == DebugProtocol.ResponseUTTestErrored:
 testname, traceback, id = eval(evalArg)
-self.debugServer.clientUtTestErrored(testname, traceback, id)
+self.debugServer.clientUtTestErrored(
+testname, traceback, id)
 continue
 if resp == DebugProtocol.ResponseUTTestSkipped:
 testname, reason, id = eval(line[eoc:-1])
 self.debugServer.clientUtTestSkipped(testname, reason, id)
 continue
 if resp == DebugProtocol.ResponseUTTestFailedExpected:
 testname, traceback, id = eval(line[eoc:-1])
-self.debugServer.clientUtTestFailedExpected(testname, traceback, id)
+self.debugServer.clientUtTestFailedExpected(
+testname, traceback, id)
 continue
 if resp == DebugProtocol.ResponseUTTestSucceededUnexpected:
 testname, id = eval(line[eoc:-1])
-self.debugServer.clientUtTestSucceededUnexpected(testname, id)
+self.debugServer.clientUtTestSucceededUnexpected(
+testname, id)
 continue
 if resp == DebugProtocol.ResponseUTFinished:
 self.debugServer.clientUtFinished()
 continue

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebuggerInterfacePython.py

Debugger/DebuggerInterfacePython.py