eric: comparison src/eric7/Debugger/DebuggerInterfacePython.py

-:e9e7eca7efee
+:bf71ee032bb4
 import os
 import logging
 import shlex
 import contextlib
-from PyQt6.QtCore import (
+from PyQt6.QtCore import QObject, QProcess, QProcessEnvironment, QTimer
-QObject, QProcess, QProcessEnvironment, QTimer
-)
 from EricWidgets.EricApplication import ericApp
 from EricWidgets import EricMessageBox
 from . import DebugClientCapabilities
 class DebuggerInterfacePython(QObject):
 """
 Class implementing the debugger interface for the debug server for
 Python 3.
 """
 def __init__(self, debugServer, passive):
 """
 Constructor
 @param debugServer reference to the debug server
 @type DebugServer
 @param passive flag indicating passive connection mode
 @type bool
 """
 super().__init__()
 self.__isNetworked = True
 self.__autoContinue = False
 self.__autoContinued = []
 self.__isStepCommand = False
 self.debugServer = debugServer
 self.passive = passive
 self.process = None
 self.__startedVenv = ""
 self.queue = []
 self.__master = None
 self.__connections = {}
 self.__pendingConnections = []
 self.__inShutdown = False
 # set default values for capabilities of clients
 self.clientCapabilities = ClientDefaultCapabilities
 # set translation function
 self.translate = self.__identityTranslation
 if passive:
 # set translation function
 if Preferences.getDebugger("PathTranslation"):
-self.translateRemote = Preferences.getDebugger(
+self.translateRemote = Preferences.getDebugger("PathTranslationRemote")
-"PathTranslationRemote")
 self.translateRemoteWindows = "\\" in self.translateRemote
-self.translateLocal = Preferences.getDebugger(
+self.translateLocal = Preferences.getDebugger("PathTranslationLocal")
-"PathTranslationLocal")
 self.translateLocalWindows = "\\" in self.translateLocal
 self.translate = self.__remoteTranslation
 else:
 self.translate = self.__identityTranslation
 # attribute to remember the name of the executed script
 self.__scriptName = ""
 def __identityTranslation(self, fn, remote2local=True):
 """
 Private method to perform the identity path translation.
 @param fn filename to be translated
 @type str
 @param remote2local flag indicating the direction of translation
 (False = local to remote, True = remote to local [default])
 @type bool
 @return translated filename
 @rtype str
 """
 return fn
 def __remoteTranslation(self, fn, remote2local=True):
 """
 Private method to perform the path translation.
 @param fn filename to be translated
 @type str
 @param remote2local flag indicating the direction of translation
 (False = local to remote, True = remote to local [default])
 @type bool
 path = path.replace("/", "\\")
 else:
 path = fn.replace(self.translateLocal, self.translateRemote)
 if not self.translateRemoteWindows:
 path = path.replace("\\", "/")
 return path
-def __startProcess(self, program, arguments, environment=None,
+def __startProcess(self, program, arguments, environment=None, workingDir=None):
-workingDir=None):
 """
 Private method to start the debugger client process.
 @param program name of the executable to start
 @type str
 @param arguments arguments to be passed to the program
 @type list of str
 @param environment dictionary of environment settings to pass
 if workingDir:
 proc.setWorkingDirectory(workingDir)
 proc.start(program, args)
 if not proc.waitForStarted(10000):
 proc = None
 return proc
-def startRemote(self, port, runInConsole, venvName, originalPathString,
+def startRemote(
-workingDir=None, configOverride=None):
+self,
+port,
+runInConsole,
+venvName,
+originalPathString,
+workingDir=None,
+configOverride=None,
+):
 """
 Public method to start a remote Python interpreter.
 @param port port number the debug server is listening on
 @type int
 @param runInConsole flag indicating to start the debugger in a
 console window
 @type bool
 @return client process object, a flag to indicate a network connection
 and the name of the interpreter in case of a local execution
 @rtype tuple of (QProcess, bool, str)
 """
 global origPathEnv
 if not venvName:
 venvName = Preferences.getDebugger("Python3VirtualEnv")
 venvManager = ericApp().getObject("VirtualEnvManager")
 interpreter = venvManager.getVirtualenvInterpreter(venvName)
 execPath = venvManager.getVirtualenvExecPath(venvName)
 interpreter = Globals.getPythonExecutable()
 if interpreter == "":
 EricMessageBox.critical(
 None,
 self.tr("Start Debugger"),
-self.tr(
+self.tr("""<p>No suitable Python3 environment configured.</p>"""),
-"""<p>No suitable Python3 environment configured.</p>""")
 )
 return None, False, ""
 self.__inShutdown = False
 debugClientType = Preferences.getDebugger("DebugClientType3")
 if debugClientType == "standard":
-debugClient = os.path.join(getConfig('ericDir'),
+debugClient = os.path.join(
-"DebugClients", "Python",
+getConfig("ericDir"), "DebugClients", "Python", "DebugClient.py"
-"DebugClient.py")
+)
 else:
 debugClient = Preferences.getDebugger("DebugClient3")
 if debugClient == "":
-debugClient = os.path.join(sys.path[0],
+debugClient = os.path.join(
-"DebugClients", "Python",
+sys.path[0], "DebugClients", "Python", "DebugClient.py"
-"DebugClient.py")
+)
 redirect = (
 str(configOverride["redirect"])
-if configOverride and configOverride["enable"] else
+if configOverride and configOverride["enable"]
-str(Preferences.getDebugger("Python3Redirect"))
+else str(Preferences.getDebugger("Python3Redirect"))
 )
-noencoding = (Preferences.getDebugger("Python3NoEncoding") and
+noencoding = (
-'--no-encoding' or '')
+Preferences.getDebugger("Python3NoEncoding") and "--no-encoding" or ""
+)
 multiprocessEnabled = (
-'--multiprocess' if Preferences.getDebugger("MultiProcessEnabled")
+"--multiprocess" if Preferences.getDebugger("MultiProcessEnabled") else ""
-else ''
+)
-)
 if Preferences.getDebugger("RemoteDbgEnabled"):
 ipaddr = self.debugServer.getHostAddress(False)
 rexec = Preferences.getDebugger("RemoteExecution")
 rhost = Preferences.getDebugger("RemoteHost")
 if rhost == "":
 rhost = "localhost"
 if rexec:
 args = Utilities.parseOptionString(rexec) + [
-rhost, interpreter, debugClient]
+rhost,
+interpreter,
+debugClient,
+]
 if noencoding:
 args.append(noencoding)
 if multiprocessEnabled:
 args.append(multiprocessEnabled)
 args.extend([str(port), redirect, ipaddr])
 if prog:
 args[0] = prog
 break
 else:
 args[0] = Utilities.getExecutablePath(args[0])
-process = self.__startProcess(args[0], args[1:],
+process = self.__startProcess(args[0], args[1:], workingDir=workingDir)
-workingDir=workingDir)
 if process is None:
 EricMessageBox.critical(
 None,
 self.tr("Start Debugger"),
 self.tr(
 """<p>The debugger backend could not be"""
-""" started.</p>"""))
+""" started.</p>"""
+),
+)
 # set translation function
 if Preferences.getDebugger("PathTranslation"):
 self.translateRemote = Preferences.getDebugger(
-"PathTranslationRemote")
+"PathTranslationRemote"
+)
 self.translateRemoteWindows = "\\" in self.translateRemote
 self.translateLocal = Preferences.getDebugger(
-"PathTranslationLocal")
+"PathTranslationLocal"
+)
 self.translate = self.__remoteTranslation
 self.translateLocalWindows = "\\" in self.translateLocal
 else:
 self.translate = self.__identityTranslation
 return process, self.__isNetworked, ""
 # set translation function
 self.translate = self.__identityTranslation
 # setup the environment for the debugger
 if Preferences.getDebugger("DebugEnvironmentReplace"):
 clientEnv = {}
 else:
 clientEnv = os.environ.copy()
 if originalPathString:
 clientEnv["PATH"] = originalPathString
-envlist = shlex.split(
+envlist = shlex.split(Preferences.getDebugger("DebugEnvironment"))
-Preferences.getDebugger("DebugEnvironment"))
 for el in envlist:
 with contextlib.suppress(ValueError):
-key, value = el.split('=', 1)
+key, value = el.split("=", 1)
 clientEnv[str(key)] = str(value)
 if execPath:
 if "PATH" in clientEnv:
-clientEnv["PATH"] = os.pathsep.join(
+clientEnv["PATH"] = os.pathsep.join([execPath, clientEnv["PATH"]])
-[execPath, clientEnv["PATH"]])
 else:
 clientEnv["PATH"] = execPath
 ipaddr = self.debugServer.getHostAddress(True)
 if runInConsole or Preferences.getDebugger("ConsoleDbgEnabled"):
 ccmd = Preferences.getDebugger("ConsoleDbgCommand")
 if ccmd:
 args = Utilities.parseOptionString(ccmd) + [
-interpreter, os.path.abspath(debugClient)]
+interpreter,
+os.path.abspath(debugClient),
+]
 if noencoding:
 args.append(noencoding)
 if multiprocessEnabled:
 args.append(multiprocessEnabled)
-args.extend([str(port), '0', ipaddr])
+args.extend([str(port), "0", ipaddr])
 args[0] = Utilities.getExecutablePath(args[0])
-process = self.__startProcess(args[0], args[1:], clientEnv,
+process = self.__startProcess(
-workingDir=workingDir)
+args[0], args[1:], clientEnv, workingDir=workingDir
+)
 if process is None:
 EricMessageBox.critical(
 None,
 self.tr("Start Debugger"),
 self.tr(
 """<p>The debugger backend could not be"""
-""" started.</p>"""))
+""" started.</p>"""
+),
+)
 return process, self.__isNetworked, interpreter
 args = [debugClient]
 if noencoding:
 args.append(noencoding)
 if multiprocessEnabled:
 args.append(multiprocessEnabled)
 args.extend([str(port), redirect, ipaddr])
-process = self.__startProcess(interpreter, args, clientEnv,
+process = self.__startProcess(
-workingDir=workingDir)
+interpreter, args, clientEnv, workingDir=workingDir
+)
 if process is None:
 self.__startedVenv = ""
 EricMessageBox.critical(
 None,
 self.tr("Start Debugger"),
-self.tr(
+self.tr("""<p>The debugger backend could not be started.</p>"""),
-"""<p>The debugger backend could not be started.</p>"""))
+)
 else:
 self.__startedVenv = venvName
 return process, self.__isNetworked, interpreter
-def startRemoteForProject(self, port, runInConsole, venvName,
+def startRemoteForProject(
-originalPathString, workingDir=None,
+self,
-configOverride=None):
+port,
+runInConsole,
+venvName,
+originalPathString,
+workingDir=None,
+configOverride=None,
+):
 """
 Public method to start a remote Python interpreter for a project.
 @param port port number the debug server is listening on
 @type int
 @param runInConsole flag indicating to start the debugger in a
 console window
 @type bool
 @return client process object, a flag to indicate a network connection
 and the name of the interpreter in case of a local execution
 @rtype tuple of (QProcess, bool, str)
 """
 global origPathEnv
 project = ericApp().getObject("Project")
 if not project.isDebugPropertiesLoaded():
 return None, self.__isNetworked, ""
 # start debugger with project specific settings
 debugClient = project.getDebugProperty("DEBUGCLIENT")
 redirect = (
 str(configOverride["redirect"])
-if configOverride and configOverride["enable"] else
+if configOverride and configOverride["enable"]
-str(project.getDebugProperty("REDIRECT"))
+else str(project.getDebugProperty("REDIRECT"))
 )
-noencoding = (
+noencoding = "--no-encoding" if project.getDebugProperty("NOENCODING") else ""
-'--no-encoding' if project.getDebugProperty("NOENCODING") else ''
-)
 multiprocessEnabled = (
-'--multiprocess' if Preferences.getDebugger("MultiProcessEnabled")
+"--multiprocess" if Preferences.getDebugger("MultiProcessEnabled") else ""
-else ''
+)
-)
 if venvName:
 venvManager = ericApp().getObject("VirtualEnvManager")
 interpreter = venvManager.getVirtualenvInterpreter(venvName)
 execPath = venvManager.getVirtualenvExecPath(venvName)
 else:
 interpreter = project.getProjectInterpreter()
 if interpreter == "":
 EricMessageBox.critical(
 None,
 self.tr("Start Debugger"),
-self.tr(
+self.tr("""<p>No suitable Python3 environment configured.</p>"""),
-"""<p>No suitable Python3 environment configured.</p>""")
 )
 return None, self.__isNetworked, ""
 self.__inShutdown = False
 if project.getDebugProperty("REMOTEDEBUGGER"):
 ipaddr = self.debugServer.getHostAddress(False)
 rexec = project.getDebugProperty("REMOTECOMMAND")
 rhost = project.getDebugProperty("REMOTEHOST")
 if rhost == "":
 rhost = "localhost"
 if rexec:
 args = Utilities.parseOptionString(rexec) + [
-rhost, interpreter, debugClient]
+rhost,
+interpreter,
+debugClient,
+]
 if noencoding:
 args.append(noencoding)
 if multiprocessEnabled:
 args.append(multiprocessEnabled)
 args.extend([str(port), redirect, ipaddr])
 if prog:
 args[0] = prog
 break
 else:
 args[0] = Utilities.getExecutablePath(args[0])
-process = self.__startProcess(args[0], args[1:],
+process = self.__startProcess(args[0], args[1:], workingDir=workingDir)
-workingDir=workingDir)
 if process is None:
 EricMessageBox.critical(
 None,
 self.tr("Start Debugger"),
 self.tr(
 """<p>The debugger backend could not be"""
-""" started.</p>"""))
+""" started.</p>"""
+),
+)
 # set translation function
 if project.getDebugProperty("PATHTRANSLATION"):
-self.translateRemote = project.getDebugProperty(
+self.translateRemote = project.getDebugProperty("REMOTEPATH")
-"REMOTEPATH")
 self.translateRemoteWindows = "\\" in self.translateRemote
 self.translateLocal = project.getDebugProperty("LOCALPATH")
 self.translateLocalWindows = "\\" in self.translateLocal
 self.translate = self.__remoteTranslation
 else:
 self.translate = self.__identityTranslation
 return process, self.__isNetworked, ""
 else:
 # remote shell command is missing
 return None, self.__isNetworked, ""
 # set translation function
 self.translate = self.__identityTranslation
 # setup the environment for the debugger
 if project.getDebugProperty("ENVIRONMENTOVERRIDE"):
 clientEnv = {}
 else:
 clientEnv = os.environ.copy()
 if originalPathString:
 clientEnv["PATH"] = originalPathString
-envlist = shlex.split(
+envlist = shlex.split(project.getDebugProperty("ENVIRONMENTSTRING"))
-project.getDebugProperty("ENVIRONMENTSTRING"))
 for el in envlist:
 with contextlib.suppress(ValueError):
-key, value = el.split('=', 1)
+key, value = el.split("=", 1)
 clientEnv[str(key)] = str(value)
 if execPath:
 if "PATH" in clientEnv:
-clientEnv["PATH"] = os.pathsep.join(
+clientEnv["PATH"] = os.pathsep.join([execPath, clientEnv["PATH"]])
-[execPath, clientEnv["PATH"]])
 else:
 clientEnv["PATH"] = execPath
 ipaddr = self.debugServer.getHostAddress(True)
 if runInConsole or project.getDebugProperty("CONSOLEDEBUGGER"):
-ccmd = (project.getDebugProperty("CONSOLECOMMAND") or
+ccmd = project.getDebugProperty(
-Preferences.getDebugger("ConsoleDbgCommand"))
+"CONSOLECOMMAND"
+) or Preferences.getDebugger("ConsoleDbgCommand")
 if ccmd:
 args = Utilities.parseOptionString(ccmd) + [
-interpreter, os.path.abspath(debugClient)]
+interpreter,
+os.path.abspath(debugClient),
+]
 if noencoding:
 args.append(noencoding)
 if multiprocessEnabled:
 args.append(multiprocessEnabled)
-args.extend([str(port), '0', ipaddr])
+args.extend([str(port), "0", ipaddr])
 args[0] = Utilities.getExecutablePath(args[0])
-process = self.__startProcess(args[0], args[1:], clientEnv,
+process = self.__startProcess(
-workingDir=workingDir)
+args[0], args[1:], clientEnv, workingDir=workingDir
+)
 if process is None:
 EricMessageBox.critical(
 None,
 self.tr("Start Debugger"),
 self.tr(
 """<p>The debugger backend could not be"""
-""" started.</p>"""))
+""" started.</p>"""
+),
+)
 return process, self.__isNetworked, interpreter
 args = [debugClient]
 if noencoding:
 args.append(noencoding)
 if multiprocessEnabled:
 args.append(multiprocessEnabled)
 args.extend([str(port), redirect, ipaddr])
-process = self.__startProcess(interpreter, args, clientEnv,
+process = self.__startProcess(
-workingDir=workingDir)
+interpreter, args, clientEnv, workingDir=workingDir
+)
 if process is None:
 self.__startedVenv = ""
 EricMessageBox.critical(
 None,
 self.tr("Start Debugger"),
-self.tr(
+self.tr("""<p>The debugger backend could not be started.</p>"""),
-"""<p>The debugger backend could not be started.</p>"""))
+)
 else:
 self.__startedVenv = venvName
 return process, self.__isNetworked, interpreter
 def getClientCapabilities(self):
 """
 Public method to retrieve the debug clients capabilities.
 @return debug client capabilities
 @rtype int
 """
 return self.clientCapabilities
 def newConnection(self, sock):
 """
 Public slot to handle a new connection.
 @param sock reference to the socket object
 @type QTcpSocket
 @return flag indicating success
 @rtype bool
 """
 self.__pendingConnections.append(sock)
 sock.readyRead.connect(lambda: self.__parseClientLine(sock))
 sock.disconnected.connect(lambda: self.__socketDisconnected(sock))
 return True
 def __assignDebuggerId(self, sock, debuggerId):
 """
 Private method to set the debugger id for a recent debugger connection
 attempt.
 @param sock reference to the socket object
 @type QTcpSocket
 @param debuggerId id of the connected debug client
 @type str
 """
 if sock in self.__pendingConnections:
 self.__connections[debuggerId] = sock
 self.__pendingConnections.remove(sock)
 if self.__master is None:
 self.__master = debuggerId
 # Get the remote clients capabilities
 self.remoteCapabilities(debuggerId)
 self.debugServer.signalClientDebuggerId(debuggerId)
 if debuggerId == self.__master:
 self.__flush()
 self.debugServer.masterClientConnected()
 self.debugServer.initializeClient(debuggerId)
 # perform auto-continue except for master
 if (
-debuggerId != self.__master and
+debuggerId != self.__master
-self.__autoContinue and
+and self.__autoContinue
-not self.__isStepCommand
+and not self.__isStepCommand
 ):
 self.__autoContinued.append(debuggerId)
-QTimer.singleShot(
+QTimer.singleShot(0, lambda: self.remoteContinue(debuggerId))
-0, lambda: self.remoteContinue(debuggerId))
 def __socketDisconnected(self, sock):
 """
 Private slot handling a socket disconnecting.
 @param sock reference to the disconnected socket
 @type QTcpSocket
 """
 for debuggerId in self.__connections:
 if self.__connections[debuggerId] is sock:
 self.debugServer.signalClientDisconnected(debuggerId)
 break
 else:
 if sock in self.__pendingConnections:
 self.__pendingConnections.remove(sock)
 if not self.__connections:
 # no active connections anymore
 with contextlib.suppress(RuntimeError):
 self.debugServer.signalLastClientExited()
 # debug server object might have been deleted already
 # ignore this
 self.__autoContinued.clear()
 self.debugServer.startClient()
 def getDebuggerIds(self):
 """
 Public method to return the IDs of the connected debugger backends.
 @return list of connected debugger backend IDs
 @rtype list of str
 """
 return sorted(self.__connections.keys())
 def __flush(self):
 """
 Private slot to flush the queue.
 """
 if self.__master:
 # Send commands that were waiting for the connection.
 for cmd in self.queue:
-self.__writeJsonCommandToSocket(
+self.__writeJsonCommandToSocket(cmd, self.__connections[self.__master])
-cmd, self.__connections[self.__master])
 self.queue = []
 def shutdown(self):
 """
 Public method to cleanly shut down.
 It closes our sockets and shuts down the debug clients.
 (Needed on Win OS)
 """
 if not self.__master:
 return
 self.__inShutdown = True
 while self.__connections:
 debuggerId, sock = self.__connections.popitem()
 self.__shutdownSocket(sock)
 while self.__pendingConnections:
 sock = self.__pendingConnections.pop()
 self.__shutdownSocket(sock)
 # reinitialize
 self.queue = []
 self.__master = None
 def __shutdownSocket(self, sock):
 """
 Private slot to shut down a socket.
 @param sock reference to the socket
 @type QTcpSocket
 """
 # do not want any slots called during shutdown
 sock.readyRead.disconnect()
 # close down socket, and shut down client as well.
 self.__sendJsonCommand("RequestShutdown", {}, sock=sock)
 sock.flush()
 sock.close()
 sock.setParent(None)
 sock.deleteLater()
 del sock
 def isConnected(self):
 """
 Public method to test, if a debug client has connected.
 @return flag indicating the connection status
 @rtype bool
 """
 return bool(self.__connections)
 def remoteEnvironment(self, env):
 """
 Public method to set the environment for a program to debug, run, ...
 @param env environment settings
 @type dict
 """
-self.__sendJsonCommand("RequestEnvironment", {"environment": env},
+self.__sendJsonCommand(
-self.__master)
+"RequestEnvironment", {"environment": env}, self.__master
+)
-def remoteLoad(self, fn, argv, wd, traceInterpreter=False,
-autoContinue=True, enableMultiprocess=False):
+def remoteLoad(
+self,
+fn,
+argv,
+wd,
+traceInterpreter=False,
+autoContinue=True,
+enableMultiprocess=False,
+):
 """
 Public method to load a new program to debug.
 @param fn the filename to debug
 @type str
 @param argv the commandline arguments to pass to the program
 @type str
 @param wd the working directory for the program
 @type bool
 """
 self.__autoContinue = autoContinue
 self.__scriptName = os.path.abspath(fn)
 self.__isStepCommand = False
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
-self.__sendJsonCommand("RequestLoad", {
+self.__sendJsonCommand(
-"workdir": wd,
+"RequestLoad",
-"filename": fn,
+{
-"argv": Utilities.parseOptionString(argv),
+"workdir": wd,
-"traceInterpreter": traceInterpreter,
+"filename": fn,
-"multiprocess": enableMultiprocess,
+"argv": Utilities.parseOptionString(argv),
-}, self.__master)
+"traceInterpreter": traceInterpreter,
+"multiprocess": enableMultiprocess,
+},
+self.__master,
+)
 def remoteRun(self, fn, argv, wd):
 """
 Public method to load a new program to run.
 @param fn the filename to run
 @type str
 @param argv the commandline arguments to pass to the program
 @type str
 @param wd the working directory for the program
 @type str
 """
 self.__scriptName = os.path.abspath(fn)
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
-self.__sendJsonCommand("RequestRun", {
+self.__sendJsonCommand(
-"workdir": wd,
+"RequestRun",
-"filename": fn,
+{
-"argv": Utilities.parseOptionString(argv),
+"workdir": wd,
-}, self.__master)
+"filename": fn,
+"argv": Utilities.parseOptionString(argv),
+},
+self.__master,
+)
 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
 @type str
 @param argv the commandline arguments to pass to the program
 @type str
 @param wd the working directory for the program
 @param erase flag indicating that coverage info should be
 cleared first
 @type bool
 """
 self.__scriptName = os.path.abspath(fn)
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
-self.__sendJsonCommand("RequestCoverage", {
+self.__sendJsonCommand(
-"workdir": wd,
+"RequestCoverage",
-"filename": fn,
+{
-"argv": Utilities.parseOptionString(argv),
+"workdir": wd,
-"erase": erase,
+"filename": fn,
-}, self.__master)
+"argv": Utilities.parseOptionString(argv),
+"erase": erase,
+},
+self.__master,
+)
 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
 @type str
 @param argv the commandline arguments to pass to the program
 @type str
 @param wd the working directory for the program
 @param erase flag indicating that timing info should be cleared
 first
 @type bool
 """
 self.__scriptName = os.path.abspath(fn)
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
-self.__sendJsonCommand("RequestProfile", {
+self.__sendJsonCommand(
-"workdir": wd,
+"RequestProfile",
-"filename": fn,
+{
-"argv": Utilities.parseOptionString(argv),
+"workdir": wd,
-"erase": erase,
+"filename": fn,
-}, self.__master)
+"argv": Utilities.parseOptionString(argv),
+"erase": erase,
+},
+self.__master,
+)
 def remoteStatement(self, debuggerId, stmt):
 """
 Public method to execute a Python statement.
 @param debuggerId ID of the debugger backend
 @type str
 @param stmt the Python statement to execute.
 @type str
 """
-self.__sendJsonCommand("ExecuteStatement", {
+self.__sendJsonCommand(
-"statement": stmt,
+"ExecuteStatement",
-}, debuggerId)
+{
+"statement": stmt,
+},
+debuggerId,
+)
 def remoteStep(self, debuggerId):
 """
 Public method to single step the debugged program.
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.__isStepCommand = True
 self.__sendJsonCommand("RequestStep", {}, debuggerId)
 def remoteStepOver(self, debuggerId):
 """
 Public method to step over the debugged program.
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.__isStepCommand = True
 self.__sendJsonCommand("RequestStepOver", {}, debuggerId)
 def remoteStepOut(self, debuggerId):
 """
 Public method to step out the debugged program.
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.__isStepCommand = True
 self.__sendJsonCommand("RequestStepOut", {}, debuggerId)
 def remoteStepQuit(self, debuggerId):
 """
 Public method to stop the debugged program.
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.__isStepCommand = True
 self.__sendJsonCommand("RequestStepQuit", {}, debuggerId)
 def remoteContinue(self, debuggerId, special=False):
 """
 Public method to continue the debugged program.
 @param debuggerId ID of the debugger backend
 @type str
 @param special flag indicating a special continue operation
 @type bool
 """
 self.__isStepCommand = False
-self.__sendJsonCommand("RequestContinue", {
+self.__sendJsonCommand(
-"special": special,
+"RequestContinue",
-}, debuggerId)
+{
+"special": special,
+},
+debuggerId,
+)
 def remoteContinueUntil(self, debuggerId, line):
 """
 Public method to continue the debugged program to the given line
 or until returning from the current frame.
 @param debuggerId ID of the debugger backend
 @type str
 @param line the new line, where execution should be continued to
 @type int
 """
 self.__isStepCommand = False
-self.__sendJsonCommand("RequestContinueUntil", {
+self.__sendJsonCommand(
-"newLine": line,
+"RequestContinueUntil",
-}, debuggerId)
+{
+"newLine": line,
+},
+debuggerId,
+)
 def remoteMoveIP(self, debuggerId, line):
 """
 Public method to move the instruction pointer to a different line.
 @param debuggerId ID of the debugger backend
 @type str
 @param line the new line, where execution should be continued
 @type int
 """
-self.__sendJsonCommand("RequestMoveIP", {
+self.__sendJsonCommand(
-"newLine": line,
+"RequestMoveIP",
-}, debuggerId)
+{
+"newLine": line,
-def remoteBreakpoint(self, debuggerId, fn, line, setBreakpoint, cond=None,
+},
-temp=False):
+debuggerId,
+)
+def remoteBreakpoint(
+self, debuggerId, fn, line, setBreakpoint, cond=None, temp=False
+):
 """
 Public method to set or clear a breakpoint.
 @param debuggerId ID of the debugger backend
 @type str
 @param fn filename the breakpoint belongs to
 @type str
 @param line linenumber of the breakpoint
 @param cond condition of the breakpoint
 @type str
 @param temp flag indicating a temporary breakpoint
 @type bool
 """
-debuggerList = ([debuggerId] if debuggerId
+debuggerList = [debuggerId] if debuggerId else list(self.__connections.keys())
-else list(self.__connections.keys()))
 for debuggerId in debuggerList:
-self.__sendJsonCommand("RequestBreakpoint", {
+self.__sendJsonCommand(
-"filename": self.translate(fn, False),
+"RequestBreakpoint",
-"line": line,
+{
-"temporary": temp,
+"filename": self.translate(fn, False),
-"setBreakpoint": setBreakpoint,
+"line": line,
-"condition": cond,
+"temporary": temp,
-}, debuggerId)
+"setBreakpoint": setBreakpoint,
+"condition": cond,
+},
+debuggerId,
+)
 def remoteBreakpointEnable(self, debuggerId, fn, line, enable):
 """
 Public method to enable or disable a breakpoint.
 @param debuggerId ID of the debugger backend
 @type str
 @param fn filename the breakpoint belongs to
 @type str
 @param line linenumber of the breakpoint
 @type int
 @param enable flag indicating enabling or disabling a breakpoint
 @type bool
 """
-debuggerList = ([debuggerId] if debuggerId
+debuggerList = [debuggerId] if debuggerId else list(self.__connections.keys())
-else list(self.__connections.keys()))
 for debuggerId in debuggerList:
-self.__sendJsonCommand("RequestBreakpointEnable", {
+self.__sendJsonCommand(
-"filename": self.translate(fn, False),
+"RequestBreakpointEnable",
-"line": line,
+{
-"enable": enable,
+"filename": self.translate(fn, False),
-}, debuggerId)
+"line": line,
+"enable": enable,
+},
+debuggerId,
+)
 def remoteBreakpointIgnore(self, debuggerId, fn, line, count):
 """
 Public method to ignore a breakpoint the next couple of occurrences.
 @param debuggerId ID of the debugger backend
 @type str
 @param fn filename the breakpoint belongs to
 @type str
 @param line linenumber of the breakpoint
 @type int
 @param count number of occurrences to ignore
 @type int
 """
-debuggerList = ([debuggerId] if debuggerId
+debuggerList = [debuggerId] if debuggerId else list(self.__connections.keys())
-else list(self.__connections.keys()))
 for debuggerId in debuggerList:
-self.__sendJsonCommand("RequestBreakpointIgnore", {
+self.__sendJsonCommand(
-"filename": self.translate(fn, False),
+"RequestBreakpointIgnore",
-"line": line,
+{
-"count": count,
+"filename": self.translate(fn, False),
-}, debuggerId)
+"line": line,
+"count": count,
+},
+debuggerId,
+)
 def remoteWatchpoint(self, debuggerId, cond, setWatch, temp=False):
 """
 Public method to set or clear a watch expression.
 @param debuggerId ID of the debugger backend
 @type str
 @param cond expression of the watch expression
 @type str
 @param setWatch flag indicating setting or resetting a watch expression
 @type bool
 @param temp flag indicating a temporary watch expression
 @type bool
 """
-debuggerList = ([debuggerId] if debuggerId
+debuggerList = [debuggerId] if debuggerId else list(self.__connections.keys())
-else list(self.__connections.keys()))
 for debuggerId in debuggerList:
 # cond is combination of cond and special (s. watch expression
 # viewer)
-self.__sendJsonCommand("RequestWatch", {
+self.__sendJsonCommand(
-"temporary": temp,
+"RequestWatch",
-"setWatch": setWatch,
+{
-"condition": cond,
+"temporary": temp,
-}, debuggerId)
+"setWatch": setWatch,
+"condition": cond,
+},
+debuggerId,
+)
 def remoteWatchpointEnable(self, debuggerId, cond, enable):
 """
 Public method to enable or disable a watch expression.
 @param debuggerId ID of the debugger backend
 @type str
 @param cond expression of the watch expression
 @type str
 @param enable flag indicating enabling or disabling a watch expression
 @type bool
 """
-debuggerList = ([debuggerId] if debuggerId
+debuggerList = [debuggerId] if debuggerId else list(self.__connections.keys())
-else list(self.__connections.keys()))
 for debuggerId in debuggerList:
 # cond is combination of cond and special (s. watch expression
 # viewer)
-self.__sendJsonCommand("RequestWatchEnable", {
+self.__sendJsonCommand(
-"condition": cond,
+"RequestWatchEnable",
-"enable": enable,
+{
-}, debuggerId)
+"condition": cond,
+"enable": enable,
+},
+debuggerId,
+)
 def remoteWatchpointIgnore(self, debuggerId, cond, count):
 """
 Public method to ignore a watch expression the next couple of
 occurrences.
 @param debuggerId ID of the debugger backend
 @type str
 @param cond expression of the watch expression
 @type str
 @param count number of occurrences to ignore
 @type int
 """
-debuggerList = ([debuggerId] if debuggerId
+debuggerList = [debuggerId] if debuggerId else list(self.__connections.keys())
-else list(self.__connections.keys()))
 for debuggerId in debuggerList:
 # cond is combination of cond and special (s. watch expression
 # viewer)
-self.__sendJsonCommand("RequestWatchIgnore", {
+self.__sendJsonCommand(
-"condition": cond,
+"RequestWatchIgnore",
-"count": count,
+{
-}, debuggerId)
+"condition": cond,
+"count": count,
+},
+debuggerId,
+)
 def remoteRawInput(self, debuggerId, inputString):
 """
 Public method to send the raw input to the debugged program.
 @param debuggerId ID of the debugger backend
 @type str
 @param inputString the raw input
 @type str
 """
-self.__sendJsonCommand("RawInput", {
+self.__sendJsonCommand(
-"input": inputString,
+"RawInput",
-}, debuggerId)
+{
+"input": inputString,
+},
+debuggerId,
+)
 def remoteThreadList(self, debuggerId):
 """
 Public method to request the list of threads from the client.
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.__sendJsonCommand("RequestThreadList", {}, debuggerId)
 def remoteSetThread(self, debuggerId, tid):
 """
 Public method to request to set the given thread as current thread.
 @param debuggerId ID of the debugger backend
 @type str
 @param tid id of the thread
 @type int
 """
-self.__sendJsonCommand("RequestThreadSet", {
+self.__sendJsonCommand(
-"threadID": tid,
+"RequestThreadSet",
-}, debuggerId)
+{
+"threadID": tid,
+},
+debuggerId,
+)
 def remoteClientStack(self, debuggerId):
 """
 Public method to request the stack of the main thread.
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.__sendJsonCommand("RequestStack", {}, debuggerId)
-def remoteClientVariables(self, debuggerId, scope, filterList, framenr=0,
+def remoteClientVariables(
-maxSize=0):
+self, debuggerId, scope, filterList, framenr=0, maxSize=0
+):
 """
 Public method to request the variables of the debugged program.
 @param debuggerId ID of the debugger backend
 @type str
 @param scope the scope of the variables (0 = local, 1 = global)
 @type int
 @param filterList list of variable types to filter out
 @param maxSize maximum size the formatted value of a variable will
 be shown. If it is bigger than that, a 'too big' indication will
 be given (@@TOO_BIG_TO_SHOW@@).
 @type int
 """
-self.__sendJsonCommand("RequestVariables", {
+self.__sendJsonCommand(
-"frameNumber": framenr,
+"RequestVariables",
-"scope": scope,
+{
-"filters": filterList,
+"frameNumber": framenr,
-"maxSize": maxSize,
+"scope": scope,
-}, debuggerId)
+"filters": filterList,
+"maxSize": maxSize,
-def remoteClientVariable(self, debuggerId, scope, filterList, var,
+},
-framenr=0, maxSize=0):
+debuggerId,
+)
+def remoteClientVariable(
+self, debuggerId, scope, filterList, var, framenr=0, maxSize=0
+):
 """
 Public method to request the variables of the debugged program.
 @param debuggerId ID of the debugger backend
 @type str
 @param scope the scope of the variables (0 = local, 1 = global)
 @type int
 @param filterList list of variable types to filter out
 @param maxSize maximum size the formatted value of a variable will
 be shown. If it is bigger than that, a 'too big' indication will
 be given (@@TOO_BIG_TO_SHOW@@).
 @type int
 """
-self.__sendJsonCommand("RequestVariable", {
+self.__sendJsonCommand(
-"variable": var,
+"RequestVariable",
-"frameNumber": framenr,
+{
-"scope": scope,
+"variable": var,
-"filters": filterList,
+"frameNumber": framenr,
-"maxSize": maxSize,
+"scope": scope,
-}, debuggerId)
+"filters": filterList,
+"maxSize": maxSize,
+},
+debuggerId,
+)
 def remoteClientDisassembly(self, debuggerId):
 """
 Public method to ask the client for the latest traceback disassembly.
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.__sendJsonCommand("RequestDisassembly", {}, debuggerId)
 def remoteClientSetFilter(self, debuggerId, scope, filterStr):
 """
 Public method to set a variables filter list.
 @param debuggerId ID of the debugger backend
 @type str
 @param scope the scope of the variables (0 = local, 1 = global)
 @type int
 @param filterStr regexp string for variable names to filter out
 @type str
 """
-self.__sendJsonCommand("RequestSetFilter", {
+self.__sendJsonCommand(
-"scope": scope,
+"RequestSetFilter",
-"filter": filterStr,
+{
-}, debuggerId)
+"scope": scope,
+"filter": filterStr,
+},
+debuggerId,
+)
 def setCallTraceEnabled(self, debuggerId, on):
 """
 Public method to set the call trace state.
 @param debuggerId ID of the debugger backend
 @type str
 @param on flag indicating to enable the call trace function
 @type bool
 """
-self.__sendJsonCommand("RequestCallTrace", {
+self.__sendJsonCommand(
-"enable": on,
+"RequestCallTrace",
-}, debuggerId)
+{
+"enable": on,
+},
+debuggerId,
+)
 def remoteNoDebugList(self, debuggerId, noDebugList):
 """
 Public method to set a list of programs not to be debugged.
 The programs given in the list will not be run under the control
 of the multi process debugger.
 @param debuggerId ID of the debugger backend
 @type str
 @param noDebugList list of Python programs not to be debugged
 @type list of str
 """
-self.__sendJsonCommand("RequestSetNoDebugList", {
+self.__sendJsonCommand(
-"noDebug": noDebugList,
+"RequestSetNoDebugList",
-}, debuggerId)
+{
+"noDebug": noDebugList,
+},
+debuggerId,
+)
 def remoteBanner(self):
 """
 Public slot to get the banner info of the remote client.
 """
 self.__sendJsonCommand("RequestBanner", {})
 def remoteCapabilities(self, debuggerId):
 """
 Public slot to get the debug clients capabilities.
 @param debuggerId ID of the debugger backend
 @type str
 """
 self.__sendJsonCommand("RequestCapabilities", {}, debuggerId)
 def remoteCompletion(self, debuggerId, text):
 """
 Public slot to get the a list of possible commandline completions
 from the remote client.
 @param debuggerId ID of the debugger backend
 @type str
 @param text the text to be completed
 @type str
 """
-self.__sendJsonCommand("RequestCompletion", {
+self.__sendJsonCommand(
-"text": text,
+"RequestCompletion",
-}, debuggerId)
+{
+"text": text,
+},
+debuggerId,
+)
 def __parseClientLine(self, sock):
 """
 Private method to handle data from the client.
 @param sock reference to the socket to read data from
 @type QTcpSocket
 """
 while sock and sock.canReadLine():
 qs = sock.readLine()
-line = bytes(qs).decode(
+line = bytes(qs).decode(encoding=Preferences.getSystem("StringEncoding"))
-encoding=Preferences.getSystem("StringEncoding"))
 logging.debug("<Debug-Server> %s", line)
-##            print("Server: ", line)    ## debug    # __IGNORE_WARNING_M891__
+##print("Server: ", line)    ## debug       # __IGNORE_WARNING_M891__
 self.__handleJsonCommand(line, sock)
 def __handleJsonCommand(self, jsonStr, sock):
 """
 Private method to handle a command or response serialized as a
 JSON string.
 @param jsonStr string containing the command or response received
 from the debug backend
 @type str
 @param sock reference to the socket the data was received from
 @type QTcpSocket
 """
 import json
 try:
 commandDict = json.loads(jsonStr.strip())
 except (TypeError, ValueError) as err:
 EricMessageBox.critical(
 None,
 self.tr("Debug Protocol Error"),
-self.tr("""<p>The response received from the debugger"""
+self.tr(
-""" backend could not be decoded. Please report"""
+"""<p>The response received from the debugger"""
-""" this issue with the received data to the"""
+""" backend could not be decoded. Please report"""
-""" eric bugs email address.</p>"""
+""" this issue with the received data to the"""
-"""<p>Error: {0}</p>"""
+""" eric bugs email address.</p>"""
-"""<p>Data:<br/>{1}</p>""").format(
+"""<p>Error: {0}</p>"""
-str(err), Utilities.html_encode(jsonStr.strip())),
+"""<p>Data:<br/>{1}</p>"""
-EricMessageBox.Ok)
+).format(str(err), Utilities.html_encode(jsonStr.strip())),
+EricMessageBox.Ok,
+)
 return
 method = commandDict["method"]
 params = commandDict["params"]
 if method == "DebuggerId":
 self.__assignDebuggerId(sock, params["debuggerId"])
 elif method == "ClientOutput":
-self.debugServer.signalClientOutput(
+self.debugServer.signalClientOutput(params["text"], params["debuggerId"])
-params["text"], params["debuggerId"])
 elif method in ["ResponseLine", "ResponseStack"]:
 # Check if obsolete thread was clicked
 if params["stack"] == []:
 # Request updated list
 self.remoteThreadList(params["debuggerId"])
 return
 for s in params["stack"]:
 s[0] = self.translate(s[0], True)
 cf = params["stack"][0]
-if (
+if self.__autoContinue and params["debuggerId"] not in self.__autoContinued:
-self.__autoContinue and
-params["debuggerId"] not in self.__autoContinued
-):
 self.__autoContinued.append(params["debuggerId"])
-QTimer.singleShot(
+QTimer.singleShot(0, lambda: self.remoteContinue(params["debuggerId"]))
-0, lambda: self.remoteContinue(params["debuggerId"]))
 else:
 self.debugServer.signalClientLine(
-cf[0], int(cf[1]), params["debuggerId"],
+cf[0],
-method == "ResponseStack", threadName=params["threadName"])
+int(cf[1]),
+params["debuggerId"],
+method == "ResponseStack",
+threadName=params["threadName"],
+)
 self.debugServer.signalClientStack(
-params["stack"], params["debuggerId"],
+params["stack"],
-threadName=params["threadName"])
+params["debuggerId"],
+threadName=params["threadName"],
+)
 elif method == "CallTrace":
 isCall = params["event"].lower() == "c"
 fromInfo = params["from"]
 toInfo = params["to"]
 self.debugServer.signalClientCallTrace(
 isCall,
-fromInfo["filename"], str(fromInfo["linenumber"]),
+fromInfo["filename"],
+str(fromInfo["linenumber"]),
 fromInfo["codename"],
-toInfo["filename"], str(toInfo["linenumber"]),
+toInfo["filename"],
+str(toInfo["linenumber"]),
 toInfo["codename"],
-params["debuggerId"])
+params["debuggerId"],
+)
 elif method == "ResponseVariables":
 self.debugServer.signalClientVariables(
-params["scope"], params["variables"], params["debuggerId"])
+params["scope"], params["variables"], params["debuggerId"]
+)
 elif method == "ResponseVariable":
 self.debugServer.signalClientVariable(
-params["scope"], [params["variable"]] + params["variables"],
+params["scope"],
-params["debuggerId"])
+[params["variable"]] + params["variables"],
+params["debuggerId"],
+)
 elif method == "ResponseThreadList":
 self.debugServer.signalClientThreadList(
-params["currentID"], params["threadList"],
+params["currentID"], params["threadList"], params["debuggerId"]
-params["debuggerId"])
+)
 elif method == "ResponseThreadSet":
 self.debugServer.signalClientThreadSet(params["debuggerId"])
 elif method == "ResponseCapabilities":
 self.clientCapabilities = params["capabilities"]
 if params["debuggerId"] == self.__master:
 # signal only for the master connection
 self.debugServer.signalClientCapabilities(
 params["capabilities"],
 params["clientType"],
 self.__startedVenv,
 )
 elif method == "ResponseBanner":
 if params["debuggerId"] == self.__master:
 # signal only for the master connection
 self.debugServer.signalClientBanner(
 params["version"],
 params["platform"],
 self.__startedVenv,
 )
 elif method == "ResponseOK":
 self.debugServer.signalClientStatement(False, params["debuggerId"])
 elif method == "ResponseContinue":
 self.debugServer.signalClientStatement(True, params["debuggerId"])
 elif method == "RequestRaw":
 self.debugServer.signalClientRawInput(
-params["prompt"], params["echo"], params["debuggerId"])
+params["prompt"], params["echo"], params["debuggerId"]
+)
 elif method == "ResponseBPConditionError":
 fn = self.translate(params["filename"], True)
 self.debugServer.signalClientBreakConditionError(
-fn, params["line"], params["debuggerId"])
+fn, params["line"], params["debuggerId"]
+)
 elif method == "ResponseClearBreakpoint":
 fn = self.translate(params["filename"], True)
 self.debugServer.signalClientClearBreak(
-fn, params["line"], params["debuggerId"])
+fn, params["line"], params["debuggerId"]
+)
 elif method == "ResponseWatchConditionError":
 self.debugServer.signalClientWatchConditionError(
-params["condition"], params["debuggerId"])
+params["condition"], params["debuggerId"]
+)
 elif method == "ResponseClearWatch":
 self.debugServer.signalClientClearWatch(
-params["condition"], params["debuggerId"])
+params["condition"], params["debuggerId"]
+)
 elif method == "ResponseDisassembly":
 self.debugServer.signalClientDisassembly(
-params["disassembly"], params["debuggerId"])
+params["disassembly"], params["debuggerId"]
+)
 elif method == "ResponseException":
 exctype = params["type"]
 excmessage = params["message"]
 stack = params["stack"]
 if stack:
 for stackEntry in stack:
 if stackEntry[0] == "<string>":
 stackEntry[0] = self.__scriptName
 else:
 break
 self.debugServer.signalClientException(
-exctype, excmessage, stack, params["debuggerId"],
+exctype, excmessage, stack, params["debuggerId"], params["threadName"]
-params["threadName"])
+)
 elif method == "ResponseSyntax":
 self.debugServer.signalClientSyntaxError(
-params["message"], self.translate(params["filename"], True),
+params["message"],
-params["linenumber"], params["characternumber"],
+self.translate(params["filename"], True),
-params["debuggerId"], params["threadName"])
+params["linenumber"],
+params["characternumber"],
+params["debuggerId"],
+params["threadName"],
+)
 elif method == "ResponseSignal":
 self.debugServer.signalClientSignal(
-params["message"], self.translate(params["filename"], True),
+params["message"],
-params["linenumber"], params["function"], params["arguments"],
+self.translate(params["filename"], True),
-params["debuggerId"])
+params["linenumber"],
+params["function"],
+params["arguments"],
+params["debuggerId"],
+)
 elif method == "ResponseExit":
 self.__scriptName = ""
 self.debugServer.signalClientExit(
-params["program"], params["status"], params["message"],
+params["program"],
-params["debuggerId"])
+params["status"],
+params["message"],
+params["debuggerId"],
+)
 if params["debuggerId"] == self.__master:
 self.debugServer.signalMainClientExit()
 elif method == "PassiveStartup":
 self.debugServer.passiveStartUp(
-self.translate(params["filename"], True), params["exceptions"],
+self.translate(params["filename"], True),
-params["debuggerId"])
+params["exceptions"],
+params["debuggerId"],
+)
 elif method == "ResponseCompletion":
 self.debugServer.signalClientCompletionList(
-params["completions"], params["text"], params["debuggerId"])
+params["completions"], params["text"], params["debuggerId"]
+)
 def __sendJsonCommand(self, command, params, debuggerId="", sock=None):
 """
 Private method to send a single command to the client.
 @param command command name to be sent
 @type str
 @param params dictionary of named parameters for the command
 @type dict
 @param debuggerId id of the debug client to send the command to
 @param sock reference to the socket object to be used (only used if
 debuggerId is not given)
 @type QTcpSocket
 """
 import json
 commandDict = {
 "jsonrpc": "2.0",
 "method": command,
 "params": params,
 }
-cmd = json.dumps(commandDict) + '\n'
+cmd = json.dumps(commandDict) + "\n"
 if debuggerId and debuggerId in self.__connections:
 sock = self.__connections[debuggerId]
 elif sock is None and self.__master is not None:
 sock = self.__connections[self.__master]
 if sock is not None:
 self.__writeJsonCommandToSocket(cmd, sock)
 else:
 self.queue.append(cmd)
 def __writeJsonCommandToSocket(self, cmd, sock):
 """
 Private method to write a JSON command to the socket.
 @param cmd JSON command to be sent
 @type str
 @param sock reference to the socket to write to
 @type QTcpSocket
 """
-data = cmd.encode('utf8', 'backslashreplace')
+data = cmd.encode("utf8", "backslashreplace")
 length = "{0:09d}".format(len(data))
 sock.write(length.encode() + data)
 sock.flush()
 def createDebuggerInterfacePython3(debugServer, passive):
 """
 Module function to create a debugger interface instance.
 @param debugServer reference to the debug server
 @type DebugServer
 @param passive flag indicating passive connection mode
 @type bool
 @return instantiated debugger interface
 def getRegistryData():
 """
 Module function to get characterizing data for the supported debugger
 interfaces.
 @return list of tuples containing the client type, the client capabilities,
 the client file type associations and a reference to the creation
 function
 @rtype list of tuple of (str, int, list of str, function)
 """
 for ext in Preferences.getDebugger("Python3Extensions").split():
 if ext.startswith("."):
 py3Exts.append(ext)
 else:
 py3Exts.append(".{0}".format(ext))
 registryData = []
 if py3Exts:
 registryData.append(
-("Python3", ClientDefaultCapabilities, py3Exts,
+(
-createDebuggerInterfacePython3)
+"Python3",
-)
+ClientDefaultCapabilities,
+py3Exts,
+createDebuggerInterfacePython3,
+)
+)
 return registryData

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Debugger/DebuggerInterfacePython.py

src/eric7/Debugger/DebuggerInterfacePython.py