eric: comparison Debugger/DebuggerInterfacePython.py

-:374066392929
+:eacf81fad150
 exts = []
 for ext in Preferences.getDebugger("PythonExtensions").split():
 if ext.startswith("."):
 exts.append(ext)
 else:
-exts.append(".%s" % ext)
+exts.append(".{0}".format(ext))
 if exts and Preferences.getDebugger("PythonInterpreter"):
 return ["Python", ClientDefaultCapabilities, exts]
 else:
 return ["", 0, []]
 """
 proc = QProcess()
 if environment is not None:
 env = []
 for key, value in list(environment.items()):
-env.append("%s=%s" % (key, value))
+env.append("{0}={1}".format(key, value))
 proc.setEnvironment(env)
 args = []
 for arg in arguments:
 args.append(arg)
 proc.start(program, args)
 self.disconnect(self.qsock, SIGNAL('disconnected()'),
 self.debugServer.startClient)
 self.disconnect(self.qsock, SIGNAL('readyRead()'), self.__parseClientLine)
 # close down socket, and shut down client as well.
-self.__sendCommand('%s\n' % RequestShutdown)
+self.__sendCommand('{0}\n'.format(RequestShutdown))
 self.qsock.flush()
 self.qsock.close()
 # reinitialize
 """
 Public method to set the environment for a program to debug, run, ...
 @param env environment settings (dictionary)
 """
-self.__sendCommand('%s%s\n' % (RequestEnv, str(env)))
+self.__sendCommand('{0}{1}\n'.format(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.
 """
 self.__autoContinue = autoContinue
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
-self.__sendCommand('%s%s\n' % (RequestForkMode, repr((autoFork, forkChild))))
+self.__sendCommand('{0}{1}\n'.format(RequestForkMode, repr((autoFork, forkChild))))
-self.__sendCommand('%s%s|%s|%s|%d\n' % \
+self.__sendCommand('{0}{1}|{2}|{3}|{4:d}\n'.format(
-(RequestLoad, wd, fn, str(Utilities.parseOptionString(argv)),
+RequestLoad, wd, fn, str(Utilities.parseOptionString(argv)),
 traceInterpreter))
 def remoteRun(self, fn, argv, wd, autoFork = False, forkChild = False):
 """
 Public method to load a new program to run.
 @keyparam autoFork flag indicating the automatic fork mode (boolean)
 @keyparam forkChild flag indicating to debug the child after forking (boolean)
 """
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
-self.__sendCommand('%s%s\n' % (RequestForkMode, repr((autoFork, forkChild))))
+self.__sendCommand('{0}{1}\n'.format(RequestForkMode, repr((autoFork, forkChild))))
-self.__sendCommand('%s%s|%s|%s\n' % \
+self.__sendCommand('{0}{1}|{2}|{3}\n'.format(
-(RequestRun, wd, fn, str(Utilities.parseOptionString(argv))))
+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.
 @keyparam erase flag indicating that coverage info should be
 cleared first (boolean)
 """
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
-self.__sendCommand('%s%s@@%s@@%s@@%d\n' % \
+self.__sendCommand('{0}{1}@@{2}@@{3}@@{4:d}\n'.format(
-(RequestCoverage, wd, fn, str(Utilities.parseOptionString(argv)),
+RequestCoverage, wd, fn, 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 wd the working directory for the program (string)
 @keyparam erase flag indicating that timing info should be cleared first (boolean)
 """
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
-self.__sendCommand('%s%s|%s|%s|%d\n' % \
+self.__sendCommand('{0}{1}|{2}|{3}|{4:d}\n'.format(
-(RequestProfile, wd, fn, str(Utilities.parseOptionString(argv)), erase))
+RequestProfile, wd, fn, str(Utilities.parseOptionString(argv)), erase))
 def remoteStatement(self, stmt):
 """
 Public method to execute a Python statement.
 @param stmt the Python statement to execute (string). It
 should not have a trailing newline.
 """
-self.__sendCommand('%s\n' % stmt)
+self.__sendCommand('{0}\n'.format(stmt))
 self.__sendCommand(RequestOK + '\n')
 def remoteStep(self):
 """
 Public method to single step the debugged program.
 """
 Public method to continue the debugged program.
 @param special flag indicating a special continue operation (boolean)
 """
-self.__sendCommand('%s%d\n' % (RequestContinue, special))
+self.__sendCommand('{0}{1:d}\n'.format(RequestContinue, special))
 def remoteBreakpoint(self, fn, line, set, cond = None, temp = False):
 """
 Public method to set or clear a breakpoint.
 @param set flag indicating setting or resetting a breakpoint (boolean)
 @param cond condition of the breakpoint (string)
 @param temp flag indicating a temporary breakpoint (boolean)
 """
 fn = self.translate(fn, False)
-self.__sendCommand('%s%s@@%d@@%d@@%d@@%s\n' % \
+self.__sendCommand('{0}{1}@@{2:d}@@{3:d}@@{4:d}@@{5}\n'.format(
-(RequestBreak, fn, line, temp, set, cond))
+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)
 """
 fn = self.translate(fn, False)
-self.__sendCommand('%s%s,%d,%d\n' % (RequestBreakEnable, fn, line, enable))
+self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
+RequestBreakEnable, fn, line, enable))
 def remoteBreakpointIgnore(self, fn, line, count):
 """
 Public method to ignore a breakpoint the next couple of occurrences.
 @param fn filename the breakpoint belongs to (string)
 @param line linenumber of the breakpoint (int)
 @param count number of occurrences to ignore (int)
 """
 fn = self.translate(fn, False)
-self.__sendCommand('%s%s,%d,%d\n' % (RequestBreakIgnore, fn, line, count))
+self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
+RequestBreakIgnore, fn, line, count))
 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 temp flag indicating a temporary watch expression (boolean)
 """
 # cond is combination of cond and special (s. watch expression viewer)
-self.__sendCommand('%s%s@@%d@@%d\n' % (RequestWatch, cond, temp, set))
+self.__sendCommand('{0}{1}@@{2:d}@@{3:d}\n'.format(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)
 """
 # cond is combination of cond and special (s. watch expression viewer)
-self.__sendCommand('%s%s,%d\n' % (RequestWatchEnable, cond, enable))
+self.__sendCommand('{0}{1},{2:d}\n'.format(RequestWatchEnable, cond, enable))
 def remoteWatchpointIgnore(self, cond, count):
 """
 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)
-self.__sendCommand('%s%s,%d\n' % (RequestWatchIgnore, cond, count))
+self.__sendCommand('{0}{1},{2:d}\n'.format(RequestWatchIgnore, cond, count))
 def remoteRawInput(self,s):
 """
 Public method to send the raw input to the debugged program.
 def remoteThreadList(self):
 """
 Public method to request the list of threads from the client.
 """
-self.__sendCommand('%s\n' % RequestThreadList)
+self.__sendCommand('{0}\n'.format(RequestThreadList))
 def remoteSetThread(self, tid):
 """
 Public method to request to set the given thread as current thread.
 @param tid id of the thread (integer)
 """
-self.__sendCommand('%s%d\n' % (RequestThreadSet, tid))
+self.__sendCommand('{0}{1:d}\n'.format(RequestThreadSet, tid))
 def remoteClientVariables(self, scope, filter, framenr = 0):
 """
 Public method to request the variables of the debugged program.
 @param scope the scope of the variables (0 = local, 1 = global)
 @param filter list of variable types to filter out (list of int)
 @param framenr framenumber of the variables to retrieve (int)
 """
-self.__sendCommand('%s%d, %d, %s\n' % \
+self.__sendCommand('{0}{1:d}, {2:d}, {3}\n'.format(
-(RequestVariables, framenr, scope, str(filter)))
+RequestVariables, framenr, scope, str(filter)))
 def remoteClientVariable(self, scope, filter, var, framenr = 0):
 """
 Public method to request the variables of the debugged program.
 @param scope the scope of the variables (0 = local, 1 = global)
 @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('%s%s, %d, %d, %s\n' % \
+self.__sendCommand('{0}{1}, {2:d}, {3:d}, {4}\n'.format(
-(RequestVariable, str(var), framenr, scope, str(filter)))
+RequestVariable, str(var), framenr, scope, str(filter)))
 def remoteClientSetFilter(self, scope, filter):
 """
 Public method to set a variables filter list.
 @param scope the scope of the variables (0 = local, 1 = global)
 @param filter regexp string for variable names to filter out (string)
 """
-self.__sendCommand('%s%d, "%s"\n' % (RequestSetFilter, scope, filter))
+self.__sendCommand('{0}{1:d}, "{2}"\n'.format(RequestSetFilter, scope, filter))
 def remoteEval(self, arg):
 """
 Public method to evaluate arg in the current context of the debugged program.
 @param arg the arguments to evaluate (string)
 """
-self.__sendCommand('%s%s\n' % (RequestEval, arg))
+self.__sendCommand('{0}{1}\n'.format(RequestEval, arg))
 def remoteExec(self, stmt):
 """
 Public method to execute stmt in the current context of the debugged program.
 @param stmt statement to execute (string)
 """
-self.__sendCommand('%s%s\n' % (RequestExec, stmt))
+self.__sendCommand('{0}{1}\n'.format(RequestExec, stmt))
 def remoteBanner(self):
 """
 Public slot to get the banner info of the remote client.
 """
 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("%s%s\n" % (RequestCompletion, text))
+self.__sendCommand("{0}{1}\n".format(RequestCompletion, text))
 def remoteUTPrepare(self, fn, tn, tfn, cov, covname, coverase):
 """
 Public method to prepare a new unittest run.
 @param covname filename to be used to assemble the coverage caches
 filename
 @param coverase flag indicating erasure of coverage data is requested
 """
 fn = self.translate(os.path.abspath(fn), False)
-self.__sendCommand('%s%s|%s|%s|%d|%s|%d\n' % \
+self.__sendCommand('{0}{1}|{2}|{3}|{4:d}|{5}|{6:d}\n'.format(
-(RequestUTPrepare, fn, tn, tfn, cov, covname, coverase))
+RequestUTPrepare, fn, tn, tfn, cov, covname, coverase))
 def remoteUTRun(self):
 """
 Public method to start a unittest run.
 """
-self.__sendCommand('%s\n' % RequestUTRun)
+self.__sendCommand('{0}\n'.format(RequestUTRun))
 def remoteUTStop(self):
 """
 Public method to stop a unittest run.
 """
-self.__sendCommand('%s\n' % RequestUTStop)
+self.__sendCommand('{0}\n'.format(RequestUTStop))
 def __askForkTo(self):
 """
 Private method to ask the user which branch of a fork to follow.
 """

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebuggerInterfacePython.py

Debugger/DebuggerInterfacePython.py