eric: comparison Debugger/DebuggerInterfacePython.py

-:1b59c4ba121e
+:8cd4d08fa9f6
 from eric5config import getConfig
 ClientDefaultCapabilities = DebugClientCapabilities.HasAll
 def getRegistryData():
 """
 Module function to get characterising data for the debugger interface.
 @return list of the following data. Client type (string), client
 capabilities (integer), client type association (list of strings)
 """
 exts = []
 for ext in Preferences.getDebugger("PythonExtensions").split():
 if ext.startswith("."):
 if exts and Preferences.getDebugger("PythonInterpreter"):
 return ["Python2", ClientDefaultCapabilities, exts]
 else:
 return ["", 0, []]
 class DebuggerInterfacePython(QObject):
 """
 Class implementing the Python debugger interface for the debug server.
 """
 def __init__(self, debugServer, passive):
 Preferences.getDebugger("PathTranslationLocal")
 self.translate = self.__remoteTranslation
 else:
 self.translate = self.__identityTranslation
-def __identityTranslation(self, fn, remote2local = True):
+def __identityTranslation(self, fn, remote2local=True):
 """
 Private method to perform the identity path translation.
 @param fn filename to be translated (string)
 @param remote2local flag indicating the direction of translation
 (False = local to remote, True = remote to local [default])
 @return translated filename (string)
 """
 return fn
-def __remoteTranslation(self, fn, remote2local = True):
+def __remoteTranslation(self, fn, remote2local=True):
 """
 Private method to perform the path translation.
 @param fn filename to be translated (string)
 @param remote2local flag indicating the direction of translation
 if remote2local:
 return fn.replace(self.translateRemote, self.translateLocal)
 else:
 return fn.replace(self.translateLocal, self.translateRemote)
-def __startProcess(self, program, arguments, environment = None):
+def __startProcess(self, program, arguments, environment=None):
 """
 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)
 def startRemote(self, port, runInConsole):
 """
 Public method to start a remote Python interpreter.
 @param port portnumber the debug server is listening on (integer)
 @param runInConsole flag indicating to start the debugger in a
 console window (boolean)
 @return client process object (QProcess) and a flag to indicate
 a network connection (boolean)
 """
 interpreter = Preferences.getDebugger("PythonInterpreter")
 """<p>No Python2 interpreter configured.</p>"""))
 return None, False
 debugClientType = Preferences.getDebugger("DebugClientType")
 if debugClientType == "standard":
 debugClient = os.path.join(getConfig('ericDir'),
 "DebugClients", "Python", "DebugClient.py")
 elif debugClientType == "threaded":
 debugClient = os.path.join(getConfig('ericDir'),
 "DebugClients", "Python", "DebugClientThreads.py")
 else:
 self.trUtf8("Start Debugger"),
 self.trUtf8(
 """<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>"""))
 def startRemoteForProject(self, port, runInConsole):
 """
 Public method to start a remote Python interpreter for a project.
 @param port portnumber the debug server is listening on (integer)
 @param runInConsole flag indicating to start the debugger in a
 console window (boolean)
 @return client process object (QProcess) and a flag to indicate
 a network connection (boolean)
 """
 project = e5App().getObject("Project")
 self.trUtf8("Start Debugger"),
 self.trUtf8(
 """<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>"""))
 @param env environment settings (dictionary)
 """
 self.__sendCommand('{0}{1}\n'.format(RequestEnv, str(env)))
-def remoteLoad(self, fn, argv, wd, traceInterpreter = False, autoContinue = True,
+def remoteLoad(self, fn, argv, wd, traceInterpreter=False, autoContinue=True,
-autoFork = False, forkChild = False):
+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)
 self.__sendCommand('{0}{1}\n'.format(RequestForkMode, repr((autoFork, forkChild))))
 self.__sendCommand('{0}{1}|{2}|{3}|{4:d}\n'.format(
 RequestLoad, wd, fn, str(Utilities.parseOptionString(argv)),
 traceInterpreter))
-def remoteRun(self, fn, argv, wd, autoFork = False, forkChild = False):
+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)
 fn = self.translate(os.path.abspath(fn), False)
 self.__sendCommand('{0}{1}\n'.format(RequestForkMode, repr((autoFork, forkChild))))
 self.__sendCommand('{0}{1}|{2}|{3}\n'.format(
 RequestRun, wd, fn, str(Utilities.parseOptionString(argv))))
-def remoteCoverage(self, fn, argv, wd, erase = False):
+def remoteCoverage(self, fn, argv, wd, erase=False):
 """
 Public method to load a new program to collect coverage 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 coverage info should be
 cleared first (boolean)
 """
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
 self.__sendCommand('{0}{1}@@{2}@@{3}@@{4:d}\n'.format(
 RequestCoverage, wd, fn, str(Utilities.parseOptionString(argv)),
 erase))
-def remoteProfile(self, fn, argv, wd, erase = False):
+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)
 self.__sendCommand('{0}{1}|{2}|{3}|{4:d}\n'.format(
 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('{0}\n'.format(stmt))
 """
 Public method to stop the debugged program.
 """
 self.__sendCommand(RequestStepQuit + '\n')
-def remoteContinue(self, special = False):
+def remoteContinue(self, special=False):
 """
 Public method to continue the debugged program.
 @param special flag indicating a special continue operation (boolean)
 """
 self.__sendCommand('{0}{1:d}\n'.format(RequestContinue, special))
-def remoteBreakpoint(self, fn, line, set, cond = None, temp = False):
+def remoteBreakpoint(self, fn, line, set, cond=None, temp=False):
 """
 Public method to set or clear a breakpoint.
 @param fn filename the breakpoint belongs to (string)
 @param line linenumber of the breakpoint (int)
 """
 fn = self.translate(fn, False)
 self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
 RequestBreakIgnore, fn, line, count))
-def remoteWatchpoint(self, cond, set, temp = False):
+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 count number of occurrences to ignore (int)
 """
 # cond is combination of cond and special (s. watch expression viewer)
 self.__sendCommand('{0}{1},{2:d}\n'.format(RequestWatchIgnore, cond, count))
-def remoteRawInput(self,s):
+def remoteRawInput(self, s):
 """
 Public method to send the raw input to the debugged program.
 @param s the raw input (string)
 """
 @param tid id of the thread (integer)
 """
 self.__sendCommand('{0}{1:d}\n'.format(RequestThreadSet, tid))
-def remoteClientVariables(self, scope, filter, framenr = 0):
+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('{0}{1:d}, {2:d}, {3}\n'.format(
 RequestVariables, framenr, scope, str(filter)))
-def remoteClientVariable(self, scope, filter, var, framenr = 0):
+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)
 cf = stack[0]
 if self.__autoContinue:
 self.__autoContinue = False
 QTimer.singleShot(0, self.remoteContinue)
 else:
 self.debugServer.signalClientLine(cf[0], int(cf[1]),
 resp == ResponseStack)
 self.debugServer.signalClientStack(stack)
 continue
 if resp == ResponseThreadList:

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebuggerInterfacePython.py

Debugger/DebuggerInterfacePython.py