src/eric7/Debugger/DebugServer.py

branch
eric7
changeset 9221
bf71ee032bb4
parent 9209
b99e7fd55fd3
child 9264
18a7312cfdb3
child 9278
36448ca469c2
--- a/src/eric7/Debugger/DebugServer.py	Wed Jul 13 11:16:20 2022 +0200
+++ b/src/eric7/Debugger/DebugServer.py	Wed Jul 13 14:55:47 2022 +0200
@@ -12,9 +12,7 @@
 import contextlib
 
 from PyQt6.QtCore import pyqtSignal, pyqtSlot, QModelIndex
-from PyQt6.QtNetwork import (
-    QTcpServer, QHostAddress, QHostInfo, QNetworkInterface
-)
+from PyQt6.QtNetwork import QTcpServer, QHostAddress, QHostInfo, QNetworkInterface
 
 from EricWidgets.EricApplication import ericApp
 from EricWidgets import EricMessageBox
@@ -35,7 +33,7 @@
 class DebugServer(QTcpServer):
     """
     Class implementing the debug server embedded within the IDE.
-    
+
     @signal clientProcessStdout(str) emitted after the client has sent some
         output via stdout
     @signal clientProcessStderr(str) emitted after the client has sent some
@@ -109,6 +107,7 @@
     @signal clientDebuggerId(debuggerId) emitted to indicate a newly connected
         debugger backend
     """
+
     clientClearBreak = pyqtSignal(str, int, str)
     clientClearWatch = pyqtSignal(str, str)
     clientGone = pyqtSignal(bool)
@@ -118,7 +117,7 @@
     clientOutput = pyqtSignal(str)
     clientLine = pyqtSignal(str, int, str, str, bool)
     clientStack = pyqtSignal(list, str, str)
-    clientThreadList = pyqtSignal('PyQt_PyObject', list, str)
+    clientThreadList = pyqtSignal("PyQt_PyObject", list, str)
     clientThreadSet = pyqtSignal(str)
     clientVariables = pyqtSignal(int, list, str)
     clientVariable = pyqtSignal(int, list, str)
@@ -142,12 +141,17 @@
     passiveDebugStarted = pyqtSignal(str, bool)
     callTraceInfo = pyqtSignal(bool, str, str, str, str, str, str, str)
     appendStdout = pyqtSignal(str)
-    
-    def __init__(self, originalPathString, preventPassiveDebugging=False,
-                 project=None, parent=None):
+
+    def __init__(
+        self,
+        originalPathString,
+        preventPassiveDebugging=False,
+        project=None,
+        parent=None,
+    ):
         """
         Constructor
-        
+
         @param originalPathString original PATH environment variable
         @type str
         @param preventPassiveDebugging flag overriding the PassiveDbgEnabled
@@ -159,9 +163,9 @@
         @type QObject
         """
         super().__init__(parent)
-        
+
         self.__originalPathString = originalPathString
-        
+
         self.__debuggerInterfaces = {}
         # the interface name is the key, a function to get the
         # registration data is the value
@@ -171,19 +175,21 @@
         # function reference to create the debugger interface (see
         # __createDebuggerInterface() below) and the interface name is
         # the value
-        
+
         # create our models
         self.breakpointModel = BreakPointModel(project, self)
         self.watchpointModel = WatchPointModel(self)
         self.watchSpecialCreated = self.tr(
-            "created", "must be same as in EditWatchpointDialog")
+            "created", "must be same as in EditWatchpointDialog"
+        )
         self.watchSpecialChanged = self.tr(
-            "changed", "must be same as in EditWatchpointDialog")
-        
+            "changed", "must be same as in EditWatchpointDialog"
+        )
+
         # arrays to track already reported issues
         self.__reportedBreakpointIssues = []
         self.__reportedWatchpointIssues = []
-        
+
         self.networkInterface = Preferences.getDebugger("NetworkInterface")
         if self.networkInterface == "all":
             hostAddress = QHostAddress("0.0.0.0")
@@ -193,11 +199,12 @@
             # QHostAddress.SpecialAddress.AnyIPv6)
         else:
             hostAddress = QHostAddress(self.networkInterface)
-        self.networkInterfaceName, self.networkInterfaceIndex = (
-            self.__getNetworkInterfaceAndIndex(self.networkInterface))
-        
-        if (not preventPassiveDebugging and
-                Preferences.getDebugger("PassiveDbgEnabled")):
+        (
+            self.networkInterfaceName,
+            self.networkInterfaceIndex,
+        ) = self.__getNetworkInterfaceAndIndex(self.networkInterface)
+
+        if not preventPassiveDebugging and Preferences.getDebugger("PassiveDbgEnabled"):
             sock = Preferences.getDebugger("PassiveDbgPort")  # default: 42424
             self.listen(hostAddress, sock)
             self.passive = True
@@ -207,49 +214,49 @@
                 hostAddress.setScopeId(self.networkInterfaceName)
             self.listen(hostAddress)
             self.passive = False
-        
+
         self.debuggerInterface = None
         self.debugging = False
         self.running = False
         self.clientProcess = None
         self.clientInterpreter = ""
-        self.clientType = Preferences.getSettings().value('DebugClient/Type')
+        self.clientType = Preferences.getSettings().value("DebugClient/Type")
         if self.clientType is None:
-            self.clientType = 'Python3'
-        
-        self.lastClientType = ''
+            self.clientType = "Python3"
+
+        self.lastClientType = ""
         self.__autoClearShell = False
         self.__forProject = False
-        
+
         self.clientClearBreak.connect(self.__clientClearBreakPoint)
         self.clientClearWatch.connect(self.__clientClearWatchPoint)
         self.newConnection.connect(self.__newConnection)
-        
-        self.breakpointModel.rowsAboutToBeRemoved.connect(
-            self.__deleteBreakPoints)
+
+        self.breakpointModel.rowsAboutToBeRemoved.connect(self.__deleteBreakPoints)
         self.breakpointModel.dataAboutToBeChanged.connect(
-            self.__breakPointDataAboutToBeChanged)
+            self.__breakPointDataAboutToBeChanged
+        )
         self.breakpointModel.dataChanged.connect(self.__changeBreakPoints)
         self.breakpointModel.rowsInserted.connect(self.__addBreakPoints)
-        
-        self.watchpointModel.rowsAboutToBeRemoved.connect(
-            self.__deleteWatchPoints)
+
+        self.watchpointModel.rowsAboutToBeRemoved.connect(self.__deleteWatchPoints)
         self.watchpointModel.dataAboutToBeChanged.connect(
-            self.__watchPointDataAboutToBeChanged)
+            self.__watchPointDataAboutToBeChanged
+        )
         self.watchpointModel.dataChanged.connect(self.__changeWatchPoints)
         self.watchpointModel.rowsInserted.connect(self.__addWatchPoints)
-        
+
         self.__maxVariableSize = Preferences.getDebugger("MaxVariableSize")
-        
+
         self.__multiprocessNoDebugList = []
-        
+
         self.__registerDebuggerInterfaces()
-    
+
     def getHostAddress(self, localhost):
         """
         Public method to get the IP address or hostname the debug server is
         listening.
-        
+
         @param localhost flag indicating to return the address for localhost
         @type bool
         @return IP address or hostname
@@ -266,14 +273,13 @@
             else:
                 return "{0}@@v6".format(QHostInfo.localHostName())
         else:
-            return "{0}@@i{1}".format(self.networkInterface,
-                                      self.networkInterfaceIndex)
-    
+            return "{0}@@i{1}".format(self.networkInterface, self.networkInterfaceIndex)
+
     def __getNetworkInterfaceAndIndex(self, address):
         """
         Private method to determine the network interface and the interface
         index.
-        
+
         @param address address to determine the info for
         @type str
         @return tuple of network interface name and index
@@ -284,34 +290,38 @@
                 addressEntries = networkInterface.addressEntries()
                 if len(addressEntries) > 0:
                     for addressEntry in addressEntries:
-                        if (addressEntry.ip().toString().lower() ==
-                                address.lower()):
-                            return (networkInterface.humanReadableName(),
-                                    networkInterface.index())
-        
+                        if addressEntry.ip().toString().lower() == address.lower():
+                            return (
+                                networkInterface.humanReadableName(),
+                                networkInterface.index(),
+                            )
+
         return "", 0
-    
+
     def preferencesChanged(self):
         """
         Public slot to handle the preferencesChanged signal.
         """
         registeredInterfaces = {}
         for interfaceName in self.__debuggerInterfaces:
-            registeredInterfaces[interfaceName] = (
-                self.__debuggerInterfaces[interfaceName])
-        
+            registeredInterfaces[interfaceName] = self.__debuggerInterfaces[
+                interfaceName
+            ]
+
         self.__debuggerInterfaceRegistry = {}
         for interfaceName, getRegistryData in registeredInterfaces.items():
-            self.registerDebuggerInterface(interfaceName, getRegistryData,
-                                           reregister=True)
-        
+            self.registerDebuggerInterface(
+                interfaceName, getRegistryData, reregister=True
+            )
+
         self.__maxVariableSize = Preferences.getDebugger("MaxVariableSize")
-    
-    def registerDebuggerInterface(self, interfaceName, getRegistryData,
-                                  reregister=False):
+
+    def registerDebuggerInterface(
+        self, interfaceName, getRegistryData, reregister=False
+    ):
         """
         Public method to register a debugger interface.
-        
+
         @param interfaceName name of the debugger interface
         @type str
         @param getRegistryData reference to a function to be called
@@ -327,41 +337,53 @@
             EricMessageBox.warning(
                 None,
                 self.tr("Register Debugger Interface"),
-                self.tr("""<p>The debugger interface <b>{0}</b> has already"""
-                        """ been registered. Ignoring this request.</p>"""))
+                self.tr(
+                    """<p>The debugger interface <b>{0}</b> has already"""
+                    """ been registered. Ignoring this request.</p>"""
+                ),
+            )
             return
-        
+
         if not reregister:
             self.__debuggerInterfaces[interfaceName] = getRegistryData
         registryDataList = getRegistryData()
         if registryDataList:
-            for (clientLanguage, clientCapabilities, clientExtensions,
-                 interfaceCreator) in registryDataList:
+            for (
+                clientLanguage,
+                clientCapabilities,
+                clientExtensions,
+                interfaceCreator,
+            ) in registryDataList:
                 self.__debuggerInterfaceRegistry[clientLanguage] = [
-                    clientCapabilities, clientExtensions, interfaceCreator,
-                    interfaceName]
-    
+                    clientCapabilities,
+                    clientExtensions,
+                    interfaceCreator,
+                    interfaceName,
+                ]
+
     def unregisterDebuggerInterface(self, interfaceName):
         """
         Public method to unregister a debugger interface.
-        
+
         @param interfaceName interfaceName of the debugger interface
         @type str
         """
         if interfaceName in self.__debuggerInterfaces:
             clientLanguages = []
-            for clientLanguage, registryData in (
-                    self.__debuggerInterfaceRegistry.items()):
+            for (
+                clientLanguage,
+                registryData,
+            ) in self.__debuggerInterfaceRegistry.items():
                 if interfaceName == registryData[-1]:
                     clientLanguages.append(clientLanguage)
             for clientLanguage in clientLanguages:
                 del self.__debuggerInterfaceRegistry[clientLanguage]
             del self.__debuggerInterfaces[interfaceName]
-    
+
     def __findLanguageForExtension(self, ext):
         """
         Private method to get the language associated with a file extension.
-        
+
         @param ext file extension
         @type str
         @return associated language
@@ -370,9 +392,9 @@
         for language in self.__debuggerInterfaceRegistry:
             if ext in self.__debuggerInterfaceRegistry[language][1]:
                 return language
-        
+
         return ""
-    
+
     def __registerDebuggerInterfaces(self):
         """
         Private method to register the available internal debugger interfaces.
@@ -380,16 +402,16 @@
         for name, interface in DebuggerInterfaces.items():
             modName = "Debugger.{0}".format(interface)
             mod = __import__(modName)
-            components = modName.split('.')
+            components = modName.split(".")
             for comp in components[1:]:
                 mod = getattr(mod, comp)
-            
+
             self.registerDebuggerInterface(name, mod.getRegistryData)
-    
+
     def getSupportedLanguages(self, shellOnly=False):
         """
         Public slot to return the supported programming languages.
-        
+
         @param shellOnly flag indicating only languages supporting an
             interactive shell should be returned
         @type bool
@@ -399,18 +421,21 @@
         languages = list(self.__debuggerInterfaceRegistry.keys())
         with contextlib.suppress(ValueError):
             languages.remove("None")
-        
+
         if shellOnly:
-            languages = [lang for lang in languages
-                         if self.__debuggerInterfaceRegistry[lang][0] &
-                         DebugClientCapabilities.HasShell]
-        
+            languages = [
+                lang
+                for lang in languages
+                if self.__debuggerInterfaceRegistry[lang][0]
+                & DebugClientCapabilities.HasShell
+            ]
+
         return languages[:]
-    
+
     def getExtensions(self, language):
         """
         Public slot to get the extensions associated with the given language.
-        
+
         @param language language to get extensions for
         @type str
         @return tuple of extensions associated with the language
@@ -420,11 +445,11 @@
             return tuple(self.__debuggerInterfaceRegistry[language][1])
         else:
             return ()
-    
+
     def __createDebuggerInterface(self, clientType=None):
         """
         Private slot to create the debugger interface object.
-        
+
         @param clientType type of the client interface to be created
         @type str
         """
@@ -432,33 +457,39 @@
             if clientType is None:
                 clientType = self.clientType
             if clientType in self.__debuggerInterfaceRegistry:
-                self.debuggerInterface = (
-                    self.__debuggerInterfaceRegistry[clientType][2](
-                        self, self.passive))
+                self.debuggerInterface = self.__debuggerInterfaceRegistry[clientType][
+                    2
+                ](self, self.passive)
             else:
-                self.debuggerInterface = (
-                    self.__debuggerInterfaceRegistry["None"][2](
-                        self, self.passive))
+                self.debuggerInterface = self.__debuggerInterfaceRegistry["None"][2](
+                    self, self.passive
+                )
                 self.clientType = "None"
-    
+
     def __setClientType(self, clType):
         """
         Private method to set the client type.
-        
+
         @param clType type of client to be started
         @type str
         """
         if clType is not None and clType in self.getSupportedLanguages():
             self.clientType = clType
-            Preferences.getSettings().setValue(
-                'DebugClient/Type', self.clientType)
-    
-    def startClient(self, unplanned=True, clType=None, forProject=False,
-                    runInConsole=False, venvName="", workingDir=None,
-                    configOverride=None):
+            Preferences.getSettings().setValue("DebugClient/Type", self.clientType)
+
+    def startClient(
+        self,
+        unplanned=True,
+        clType=None,
+        forProject=False,
+        runInConsole=False,
+        venvName="",
+        workingDir=None,
+        configOverride=None,
+    ):
         """
         Public method to start a debug client.
-        
+
         @param unplanned flag indicating that the client has died
         @type bool
         @param clType type of client to be started
@@ -477,23 +508,23 @@
         @type dict
         """
         self.running = False
-        
+
         if (
-            (not self.passive or not self.passiveClientExited) and
-            self.debuggerInterface and
-            self.debuggerInterface.isConnected()
+            (not self.passive or not self.passiveClientExited)
+            and self.debuggerInterface
+            and self.debuggerInterface.isConnected()
         ):
             self.shutdownServer()
             self.debugging = False
             self.clientGone.emit(unplanned and self.debugging)
-        
+
         if clType:
             if clType not in self.getSupportedLanguages():
                 # a not supported client language was requested
                 return
-            
+
             self.__setClientType(clType)
-        
+
         # only start the client, if we are not in passive mode
         if not self.passive:
             if self.clientProcess:
@@ -504,36 +535,59 @@
                     self.clientProcess.waitForFinished(1000)
                     self.clientProcess.deleteLater()
                 self.clientProcess = None
-            
+
             self.__forProject = forProject
             self.__createDebuggerInterface()
             if forProject:
                 project = ericApp().getObject("Project")
                 if not project.isDebugPropertiesLoaded():
-                    self.clientProcess, isNetworked, clientInterpreter = (
-                        self.debuggerInterface.startRemote(
-                            self.serverPort(), runInConsole, venvName,
-                            self.__originalPathString, workingDir=workingDir,
-                            configOverride=configOverride))
+                    (
+                        self.clientProcess,
+                        isNetworked,
+                        clientInterpreter,
+                    ) = self.debuggerInterface.startRemote(
+                        self.serverPort(),
+                        runInConsole,
+                        venvName,
+                        self.__originalPathString,
+                        workingDir=workingDir,
+                        configOverride=configOverride,
+                    )
                 else:
-                    self.clientProcess, isNetworked, clientInterpreter = (
-                        self.debuggerInterface.startRemoteForProject(
-                            self.serverPort(), runInConsole, venvName,
-                            self.__originalPathString, workingDir=workingDir,
-                            configOverride=configOverride))
+                    (
+                        self.clientProcess,
+                        isNetworked,
+                        clientInterpreter,
+                    ) = self.debuggerInterface.startRemoteForProject(
+                        self.serverPort(),
+                        runInConsole,
+                        venvName,
+                        self.__originalPathString,
+                        workingDir=workingDir,
+                        configOverride=configOverride,
+                    )
             else:
-                self.clientProcess, isNetworked, clientInterpreter = (
-                    self.debuggerInterface.startRemote(
-                        self.serverPort(), runInConsole, venvName,
-                        self.__originalPathString, workingDir=workingDir,
-                        configOverride=configOverride))
-            
+                (
+                    self.clientProcess,
+                    isNetworked,
+                    clientInterpreter,
+                ) = self.debuggerInterface.startRemote(
+                    self.serverPort(),
+                    runInConsole,
+                    venvName,
+                    self.__originalPathString,
+                    workingDir=workingDir,
+                    configOverride=configOverride,
+                )
+
             if self.clientProcess:
                 self.clientProcess.readyReadStandardError.connect(
-                    self.__clientProcessError)
+                    self.__clientProcessError
+                )
                 self.clientProcess.readyReadStandardOutput.connect(
-                    self.__clientProcessOutput)
-                
+                    self.__clientProcessOutput
+                )
+
                 # Perform actions necessary, if client type has changed
                 if self.lastClientType != self.clientType:
                     self.lastClientType = self.clientType
@@ -547,34 +601,38 @@
         else:
             self.__createDebuggerInterface("None")
             clientInterpreter = ""
-        
+
         if clientInterpreter != self.clientInterpreter:
             self.clientInterpreter = clientInterpreter
             self.clientInterpreterChanged.emit(clientInterpreter)
-    
+
     def __clientProcessOutput(self):
         """
         Private slot to process client output received via stdout.
         """
-        output = str(self.clientProcess.readAllStandardOutput(),
-                     Preferences.getSystem("IOEncoding"),
-                     'replace')
+        output = str(
+            self.clientProcess.readAllStandardOutput(),
+            Preferences.getSystem("IOEncoding"),
+            "replace",
+        )
         self.clientProcessStdout.emit(output)
-    
+
     def __clientProcessError(self):
         """
         Private slot to process client output received via stderr.
         """
-        error = str(self.clientProcess.readAllStandardError(),
-                    Preferences.getSystem("IOEncoding"),
-                    'replace')
+        error = str(
+            self.clientProcess.readAllStandardError(),
+            Preferences.getSystem("IOEncoding"),
+            "replace",
+        )
         self.clientProcessStderr.emit(error)
-    
+
     @pyqtSlot(str, int)
     def __clientClearBreakPoint(self, fn, lineno):
         """
         Private slot to handle the clientClearBreak signal.
-        
+
         @param fn filename of breakpoint to clear
         @type str
         @param lineno line number of breakpoint to clear
@@ -585,11 +643,11 @@
             self.breakpointModel.deleteBreakPointByIndex(index)
             if (fn, lineno) in self.__reportedBreakpointIssues:
                 self.__reportedBreakpointIssues.remove((fn, lineno))
-    
+
     def __deleteBreakPoints(self, parentIndex, start, end):
         """
         Private slot to delete breakpoints.
-        
+
         @param parentIndex index of parent item
         @type QModelIndex
         @param start start row
@@ -600,44 +658,41 @@
         if self.debugging:
             for row in range(start, end + 1):
                 index = self.breakpointModel.index(row, 0, parentIndex)
-                fn, lineno = (
-                    self.breakpointModel.getBreakPointByIndex(index)[0:2])
+                fn, lineno = self.breakpointModel.getBreakPointByIndex(index)[0:2]
                 # delete the breakpoints of all connected backends
                 self.remoteBreakpoint("", fn, lineno, False)
                 if (fn, lineno) in self.__reportedBreakpointIssues:
                     self.__reportedBreakpointIssues.remove((fn, lineno))
-    
+
     def __changeBreakPoints(self, startIndex, endIndex):
         """
         Private slot to set changed breakpoints.
-        
+
         @param startIndex starting index of the change breakpoins
         @type QModelIndex
         @param endIndex ending index of the change breakpoins
         @type QModelIndex
         """
         if self.debugging:
-            self.__addBreakPoints(
-                QModelIndex(), startIndex.row(), endIndex.row())
-    
+            self.__addBreakPoints(QModelIndex(), startIndex.row(), endIndex.row())
+
     def __breakPointDataAboutToBeChanged(self, startIndex, endIndex):
         """
         Private slot to handle the dataAboutToBeChanged signal of the
         breakpoint model.
-        
+
         @param startIndex start index of the rows to be changed
         @type QModelIndex
         @param endIndex end index of the rows to be changed
         @type QModelIndex
         """
         if self.debugging:
-            self.__deleteBreakPoints(
-                QModelIndex(), startIndex.row(), endIndex.row())
-    
+            self.__deleteBreakPoints(QModelIndex(), startIndex.row(), endIndex.row())
+
     def __addBreakPoints(self, parentIndex, start, end, debuggerId=""):
         """
         Private slot to add breakpoints.
-        
+
         @param parentIndex index of parent item
         @type QModelIndex
         @param start start row
@@ -651,24 +706,28 @@
         if self.debugging:
             for row in range(start, end + 1):
                 index = self.breakpointModel.index(row, 0, parentIndex)
-                fn, lineno, cond, temp, enabled, ignorecount = (
-                    self.breakpointModel.getBreakPointByIndex(index)[:6])
-                
+                (
+                    fn,
+                    lineno,
+                    cond,
+                    temp,
+                    enabled,
+                    ignorecount,
+                ) = self.breakpointModel.getBreakPointByIndex(index)[:6]
+
                 if (fn, lineno) in self.__reportedBreakpointIssues:
                     self.__reportedBreakpointIssues.remove((fn, lineno))
-                
+
                 self.remoteBreakpoint(debuggerId, fn, lineno, True, cond, temp)
                 if not enabled:
-                    self.__remoteBreakpointEnable(
-                        debuggerId, fn, lineno, False)
+                    self.__remoteBreakpointEnable(debuggerId, fn, lineno, False)
                 if ignorecount:
-                    self.__remoteBreakpointIgnore(
-                        debuggerId, fn, lineno, ignorecount)
-    
+                    self.__remoteBreakpointIgnore(debuggerId, fn, lineno, ignorecount)
+
     def __makeWatchCondition(self, cond, special):
         """
         Private method to construct the condition string.
-        
+
         @param cond condition
         @type str
         @param special special condition
@@ -684,11 +743,11 @@
             elif special == self.watchSpecialChanged:
                 _cond = "{0} ??changed??".format(cond)
         return _cond
-    
+
     def __splitWatchCondition(self, cond):
         """
         Private method to split a remote watch expression.
-        
+
         @param cond remote expression
         @type str
         @return tuple of local expression (string) and special condition
@@ -703,14 +762,14 @@
         else:
             cond = cond
             special = ""
-        
+
         return cond, special
-    
+
     @pyqtSlot(str)
     def __clientClearWatchPoint(self, condition):
         """
         Private slot to handle the clientClearWatch signal.
-        
+
         @param condition expression of watch expression to clear
         @type str
         """
@@ -720,11 +779,11 @@
             self.watchpointModel.deleteWatchPointByIndex(index)
             if condition in self.__reportedWatchpointIssues:
                 self.__reportedWatchpointIssues.remove(condition)
-    
+
     def __deleteWatchPoints(self, parentIndex, start, end):
         """
         Private slot to delete watch expressions.
-        
+
         @param parentIndex index of parent item
         @type QModelIndex
         @param start start row
@@ -735,31 +794,29 @@
         if self.debugging:
             for row in range(start, end + 1):
                 index = self.watchpointModel.index(row, 0, parentIndex)
-                cond, special = (
-                    self.watchpointModel.getWatchPointByIndex(index)[0:2])
+                cond, special = self.watchpointModel.getWatchPointByIndex(index)[0:2]
                 cond = self.__makeWatchCondition(cond, special)
                 self.__remoteWatchpoint("", cond, False)
                 if cond in self.__reportedWatchpointIssues:
                     self.__reportedWatchpointIssues.remove(cond)
-    
+
     def __watchPointDataAboutToBeChanged(self, startIndex, endIndex):
         """
         Private slot to handle the dataAboutToBeChanged signal of the
         watch expression model.
-        
+
         @param startIndex start index of the rows to be changed
         @type QModelIndex
         @param endIndex end index of the rows to be changed
         @type QModelIndex
         """
         if self.debugging:
-            self.__deleteWatchPoints(
-                QModelIndex(), startIndex.row(), endIndex.row())
-    
+            self.__deleteWatchPoints(QModelIndex(), startIndex.row(), endIndex.row())
+
     def __addWatchPoints(self, parentIndex, start, end, debuggerId=""):
         """
         Private slot to set a watch expression.
-        
+
         @param parentIndex index of parent item
         @type QModelIndex
         @param start start row
@@ -773,37 +830,40 @@
         if self.debugging:
             for row in range(start, end + 1):
                 index = self.watchpointModel.index(row, 0, parentIndex)
-                cond, special, temp, enabled, ignorecount = (
-                    self.watchpointModel.getWatchPointByIndex(index)[:5])
+                (
+                    cond,
+                    special,
+                    temp,
+                    enabled,
+                    ignorecount,
+                ) = self.watchpointModel.getWatchPointByIndex(index)[:5]
                 cond = self.__makeWatchCondition(cond, special)
-                
+
                 if cond in self.__reportedWatchpointIssues:
                     self.__reportedWatchpointIssues.remove(cond)
-                
+
                 self.__remoteWatchpoint(debuggerId, cond, True, temp)
                 if not enabled:
                     self.__remoteWatchpointEnable(debuggerId, cond, False)
                 if ignorecount:
-                    self.__remoteWatchpointIgnore(debuggerId, cond,
-                                                  ignorecount)
-    
+                    self.__remoteWatchpointIgnore(debuggerId, cond, ignorecount)
+
     def __changeWatchPoints(self, startIndex, endIndex):
         """
         Private slot to set changed watch expressions.
-        
+
         @param startIndex start index of the rows to be changed
         @type QModelIndex
         @param endIndex end index of the rows to be changed
         @type QModelIndex
         """
         if self.debugging:
-            self.__addWatchPoints(
-                QModelIndex(), startIndex.row(), endIndex.row())
-    
+            self.__addWatchPoints(QModelIndex(), startIndex.row(), endIndex.row())
+
     def getClientCapabilities(self, clientType):
         """
         Public method to retrieve the debug clients capabilities.
-        
+
         @param clientType debug client type
         @type str
         @return debug client capabilities
@@ -812,35 +872,35 @@
         try:
             return self.__debuggerInterfaceRegistry[clientType][0]
         except KeyError:
-            return 0    # no capabilities
-    
+            return 0  # no capabilities
+
     def getClientInterpreter(self):
         """
         Public method to get the interpreter of the debug client.
-        
+
         @return interpreter of the debug client
         @rtype str
         """
         return self.clientInterpreter
-    
+
     def getClientType(self):
         """
         Public method to get the currently running debug client type.
-        
+
         @return debug client type
         @rtype str
         """
         return self.clientType
-    
+
     def isClientProcessUp(self):
         """
         Public method to check, if the debug client process is up.
-        
+
         @return flag indicating a running debug client process
         @rtype bool
         """
         return self.clientProcess is not None
-    
+
     def __newConnection(self):
         """
         Private slot to handle a new connection.
@@ -854,9 +914,10 @@
                 self.tr("Connection from illegal host"),
                 self.tr(
                     """<p>A connection was attempted by the illegal host"""
-                    """ <b>{0}</b>. Accept this connection?</p>""")
-                .format(peerAddress),
-                icon=EricMessageBox.Warning)
+                    """ <b>{0}</b>. Accept this connection?</p>"""
+                ).format(peerAddress),
+                icon=EricMessageBox.Warning,
+            )
             if not res:
                 sock.abort()
                 return
@@ -864,13 +925,12 @@
                 allowedHosts = Preferences.getDebugger("AllowedHosts")
                 allowedHosts.append(peerAddress)
                 Preferences.setDebugger("AllowedHosts", allowedHosts)
-        
+
         if self.passive:
-            self.__createDebuggerInterface(
-                Preferences.getDebugger("PassiveDbgType"))
-        
+            self.__createDebuggerInterface(Preferences.getDebugger("PassiveDbgType"))
+
         self.debuggerInterface.newConnection(sock)
-    
+
     def masterClientConnected(self):
         """
         Public method to perform actions after the master client has finally
@@ -885,42 +945,55 @@
             self.remoteBanner()
         elif self.passive:
             self.remoteBanner()
-    
+
     def shutdownServer(self):
         """
         Public method to cleanly shut down.
-        
+
         It closes our socket and shuts down
         the debug client. (Needed on Win OS)
         """
         if self.debuggerInterface is not None:
             self.debuggerInterface.shutdown()
-    
+
     def remoteEnvironment(self, env):
         """
         Public method to set the environment for a program to debug, run, ...
-        
+
         @param env environment settings
         @type str
         """
         envlist = shlex.split(env)
         envdict = {}
         for el in envlist:
-            if '=' in el:
-                key, value = el.split('=', 1)
+            if "=" in el:
+                key, value = el.split("=", 1)
                 envdict[key] = value
             else:
                 envdict[el] = ""
         self.debuggerInterface.remoteEnvironment(envdict)
-    
-    def remoteLoad(self, venvName, fn, argv, wd, env, autoClearShell=True,
-                   tracePython=False, autoContinue=True, forProject=False,
-                   runInConsole=False, clientType="", enableCallTrace=False,
-                   enableMultiprocess=False, multiprocessNoDebug="",
-                   configOverride=None):
+
+    def remoteLoad(
+        self,
+        venvName,
+        fn,
+        argv,
+        wd,
+        env,
+        autoClearShell=True,
+        tracePython=False,
+        autoContinue=True,
+        forProject=False,
+        runInConsole=False,
+        clientType="",
+        enableCallTrace=False,
+        enableMultiprocess=False,
+        multiprocessNoDebug="",
+        configOverride=None,
+    ):
         """
         Public method to load a new program to debug.
-        
+
         @param venvName name of the virtual environment to be used
         @type str
         @param fn the filename to debug
@@ -964,7 +1037,7 @@
         self.__multiprocessNoDebugList = [
             s.strip() for s in multiprocessNoDebug.split(os.pathsep)
         ]
-        
+
         if clientType not in self.getSupportedLanguages():
             # a not supported client language was requested
             EricMessageBox.critical(
@@ -972,42 +1045,62 @@
                 self.tr("Start Debugger"),
                 self.tr(
                     """<p>The debugger type <b>{0}</b> is not supported"""
-                    """ or not configured.</p>""").format(clientType)
+                    """ or not configured.</p>"""
+                ).format(clientType),
             )
             return
-        
+
         # Restart the client
         try:
             if clientType:
                 self.__setClientType(clientType)
             else:
                 self.__setClientType(
-                    self.__findLanguageForExtension(os.path.splitext(fn)[1]))
+                    self.__findLanguageForExtension(os.path.splitext(fn)[1])
+                )
         except KeyError:
-            self.__setClientType('Python3')    # assume it is a Python3 file
-        self.startClient(False, forProject=forProject,
-                         runInConsole=runInConsole, venvName=venvName,
-                         configOverride=configOverride)
-        
+            self.__setClientType("Python3")  # assume it is a Python3 file
+        self.startClient(
+            False,
+            forProject=forProject,
+            runInConsole=runInConsole,
+            venvName=venvName,
+            configOverride=configOverride,
+        )
+
         self.setCallTraceEnabled("", enableCallTrace)
         self.remoteEnvironment(env)
-        
+
         self.debuggerInterface.remoteLoad(
-            fn, argv, wd, tracePython, autoContinue,
-            enableMultiprocess=enableMultiprocess
+            fn,
+            argv,
+            wd,
+            tracePython,
+            autoContinue,
+            enableMultiprocess=enableMultiprocess,
         )
         self.debugging = True
         self.running = True
         self.__restoreBreakpoints()
         self.__restoreWatchpoints()
         self.__restoreNoDebugList()
-    
-    def remoteRun(self, venvName, fn, argv, wd, env, autoClearShell=True,
-                  forProject=False, runInConsole=False, clientType="",
-                  configOverride=None):
+
+    def remoteRun(
+        self,
+        venvName,
+        fn,
+        argv,
+        wd,
+        env,
+        autoClearShell=True,
+        forProject=False,
+        runInConsole=False,
+        clientType="",
+        configOverride=None,
+    ):
         """
         Public method to load a new program to run.
-        
+
         @param venvName name of the virtual environment to be used
         @type str
         @param fn the filename to debug
@@ -1033,43 +1126,60 @@
         @type dict
         """
         self.__autoClearShell = autoClearShell
-        
+
         if clientType not in self.getSupportedLanguages():
             EricMessageBox.critical(
                 None,
                 self.tr("Start Debugger"),
                 self.tr(
                     """<p>The debugger type <b>{0}</b> is not supported"""
-                    """ or not configured.</p>""").format(clientType)
+                    """ or not configured.</p>"""
+                ).format(clientType),
             )
             # a not supported client language was requested
             return
-        
+
         # Restart the client
         try:
             if clientType:
                 self.__setClientType(clientType)
             else:
                 self.__setClientType(
-                    self.__findLanguageForExtension(os.path.splitext(fn)[1]))
+                    self.__findLanguageForExtension(os.path.splitext(fn)[1])
+                )
         except KeyError:
-            self.__setClientType('Python3')    # assume it is a Python3 file
-        self.startClient(False, forProject=forProject,
-                         runInConsole=runInConsole, venvName=venvName,
-                         configOverride=configOverride)
-        
+            self.__setClientType("Python3")  # assume it is a Python3 file
+        self.startClient(
+            False,
+            forProject=forProject,
+            runInConsole=runInConsole,
+            venvName=venvName,
+            configOverride=configOverride,
+        )
+
         self.remoteEnvironment(env)
-        
+
         self.debuggerInterface.remoteRun(fn, argv, wd)
         self.debugging = False
         self.running = True
-    
-    def remoteCoverage(self, venvName, fn, argv, wd, env,
-                       autoClearShell=True, erase=False, forProject=False,
-                       runInConsole=False, clientType="", configOverride=None):
+
+    def remoteCoverage(
+        self,
+        venvName,
+        fn,
+        argv,
+        wd,
+        env,
+        autoClearShell=True,
+        erase=False,
+        forProject=False,
+        runInConsole=False,
+        clientType="",
+        configOverride=None,
+    ):
         """
         Public method to load a new program to collect coverage data.
-        
+
         @param venvName name of the virtual environment to be used
         @type str
         @param fn the filename to debug
@@ -1098,7 +1208,7 @@
         @type dict
         """
         self.__autoClearShell = autoClearShell
-        
+
         if clientType not in self.getSupportedLanguages():
             # a not supported client language was requested
             EricMessageBox.critical(
@@ -1106,35 +1216,52 @@
                 self.tr("Start Debugger"),
                 self.tr(
                     """<p>The debugger type <b>{0}</b> is not supported"""
-                    """ or not configured.</p>""").format(clientType)
+                    """ or not configured.</p>"""
+                ).format(clientType),
             )
             return
-        
+
         # Restart the client
         try:
             if clientType:
                 self.__setClientType(clientType)
             else:
                 self.__setClientType(
-                    self.__findLanguageForExtension(os.path.splitext(fn)[1]))
+                    self.__findLanguageForExtension(os.path.splitext(fn)[1])
+                )
         except KeyError:
-            self.__setClientType('Python3')    # assume it is a Python3 file
-        self.startClient(False, forProject=forProject,
-                         runInConsole=runInConsole, venvName=venvName,
-                         configOverride=configOverride)
-        
+            self.__setClientType("Python3")  # assume it is a Python3 file
+        self.startClient(
+            False,
+            forProject=forProject,
+            runInConsole=runInConsole,
+            venvName=venvName,
+            configOverride=configOverride,
+        )
+
         self.remoteEnvironment(env)
-        
+
         self.debuggerInterface.remoteCoverage(fn, argv, wd, erase)
         self.debugging = False
         self.running = True
-    
-    def remoteProfile(self, venvName, fn, argv, wd, env,
-                      autoClearShell=True, erase=False, forProject=False,
-                      runInConsole=False, clientType="", configOverride=None):
+
+    def remoteProfile(
+        self,
+        venvName,
+        fn,
+        argv,
+        wd,
+        env,
+        autoClearShell=True,
+        erase=False,
+        forProject=False,
+        runInConsole=False,
+        clientType="",
+        configOverride=None,
+    ):
         """
         Public method to load a new program to collect profiling data.
-        
+
         @param venvName name of the virtual environment to be used
         @type str
         @param fn the filename to debug
@@ -1163,7 +1290,7 @@
         @type dict
         """
         self.__autoClearShell = autoClearShell
-        
+
         if clientType not in self.getSupportedLanguages():
             # a not supported client language was requested
             EricMessageBox.critical(
@@ -1171,114 +1298,121 @@
                 self.tr("Start Debugger"),
                 self.tr(
                     """<p>The debugger type <b>{0}</b> is not supported"""
-                    """ or not configured.</p>""").format(clientType)
+                    """ or not configured.</p>"""
+                ).format(clientType),
             )
             return
-        
+
         # Restart the client
         try:
             if clientType:
                 self.__setClientType(clientType)
             else:
                 self.__setClientType(
-                    self.__findLanguageForExtension(os.path.splitext(fn)[1]))
+                    self.__findLanguageForExtension(os.path.splitext(fn)[1])
+                )
         except KeyError:
-            self.__setClientType('Python3')    # assume it is a Python3 file
-        self.startClient(False, forProject=forProject,
-                         runInConsole=runInConsole, venvName=venvName,
-                         configOverride=configOverride)
-        
+            self.__setClientType("Python3")  # assume it is a Python3 file
+        self.startClient(
+            False,
+            forProject=forProject,
+            runInConsole=runInConsole,
+            venvName=venvName,
+            configOverride=configOverride,
+        )
+
         self.remoteEnvironment(env)
-        
+
         self.debuggerInterface.remoteProfile(fn, argv, wd, erase)
         self.debugging = False
         self.running = True
-    
+
     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.debuggerInterface.remoteStatement(debuggerId, stmt.rstrip())
-    
+
     def remoteStep(self, debuggerId):
         """
         Public method to single step the debugged program.
-        
+
         @param debuggerId ID of the debugger backend
         @type str
         """
         self.debuggerInterface.remoteStep(debuggerId)
-    
+
     def remoteStepOver(self, debuggerId):
         """
         Public method to step over the debugged program.
-        
+
         @param debuggerId ID of the debugger backend
         @type str
         """
         self.debuggerInterface.remoteStepOver(debuggerId)
-    
+
     def remoteStepOut(self, debuggerId):
         """
         Public method to step out the debugged program.
-        
+
         @param debuggerId ID of the debugger backend
         @type str
         """
         self.debuggerInterface.remoteStepOut(debuggerId)
-    
+
     def remoteStepQuit(self, debuggerId):
         """
         Public method to stop the debugged program.
-        
+
         @param debuggerId ID of the debugger backend
         @type str
         """
         self.debuggerInterface.remoteStepQuit(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
         """
         self.debuggerInterface.remoteContinue(debuggerId, special)
-    
+
     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.debuggerInterface.remoteContinueUntil(debuggerId, line)
-    
+
     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.debuggerInterface.remoteMoveIP(debuggerId, line)
-    
-    def remoteBreakpoint(self, debuggerId, fn, line, setBreakpoint, cond=None,
-                         temp=False):
+
+    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
@@ -1293,12 +1427,13 @@
         @type bool
         """
         self.debuggerInterface.remoteBreakpoint(
-            debuggerId, fn, line, setBreakpoint, cond, temp)
-    
+            debuggerId, fn, line, setBreakpoint, cond, temp
+        )
+
     def __remoteBreakpointEnable(self, debuggerId, fn, line, enable):
         """
         Private method to enable or disable a breakpoint.
-        
+
         @param debuggerId ID of the debugger backend
         @type str
         @param fn filename the breakpoint belongs to
@@ -1308,13 +1443,12 @@
         @param enable flag indicating enabling or disabling a breakpoint
         @type bool
         """
-        self.debuggerInterface.remoteBreakpointEnable(
-            debuggerId, fn, line, enable)
-    
+        self.debuggerInterface.remoteBreakpointEnable(debuggerId, fn, line, enable)
+
     def __remoteBreakpointIgnore(self, debuggerId, fn, line, count):
         """
         Private 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
@@ -1324,13 +1458,12 @@
         @param count number of occurrences to ignore
         @type int
         """
-        self.debuggerInterface.remoteBreakpointIgnore(
-            debuggerId, fn, line, count)
-    
+        self.debuggerInterface.remoteBreakpointIgnore(debuggerId, fn, line, count)
+
     def __remoteWatchpoint(self, debuggerId, cond, setWatch, temp=False):
         """
         Private method to set or clear a watch expression.
-        
+
         @param debuggerId ID of the debugger backend
         @type str
         @param cond expression of the watch expression
@@ -1341,13 +1474,12 @@
         @type bool
         """
         # cond is combination of cond and special (s. watch expression viewer)
-        self.debuggerInterface.remoteWatchpoint(debuggerId, cond, setWatch,
-                                                temp)
-    
+        self.debuggerInterface.remoteWatchpoint(debuggerId, cond, setWatch, temp)
+
     def __remoteWatchpointEnable(self, debuggerId, cond, enable):
         """
         Private method to enable or disable a watch expression.
-        
+
         @param debuggerId ID of the debugger backend
         @type str
         @param cond expression of the watch expression
@@ -1357,12 +1489,12 @@
         """
         # cond is combination of cond and special (s. watch expression viewer)
         self.debuggerInterface.remoteWatchpointEnable(debuggerId, cond, enable)
-    
+
     def __remoteWatchpointIgnore(self, debuggerId, cond, count):
         """
         Private 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
@@ -1372,11 +1504,11 @@
         """
         # cond is combination of cond and special (s. watch expression viewer)
         self.debuggerInterface.remoteWatchpointIgnore(debuggerId, cond, count)
-    
+
     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
@@ -1384,40 +1516,40 @@
         """
         self.debuggerInterface.remoteRawInput(debuggerId, inputString)
         self.clientRawInputSent.emit(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.debuggerInterface.remoteThreadList(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.debuggerInterface.remoteSetThread(debuggerId, tid)
-    
+
     def remoteClientStack(self, debuggerId):
         """
         Public method to request the stack of the main thread.
-        
+
         @param debuggerId ID of the debugger backend
         @type str
         """
         self.debuggerInterface.remoteClientStack(debuggerId)
-    
+
     def remoteClientVariables(self, debuggerId, scope, filterList, framenr=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)
@@ -1428,13 +1560,15 @@
         @type int
         """
         self.debuggerInterface.remoteClientVariables(
-            debuggerId, scope, filterList, framenr, self.__maxVariableSize)
-    
-    def remoteClientVariable(self, debuggerId, scope, filterList, var,
-                             framenr=0, maxSize=0):
+            debuggerId, scope, filterList, framenr, self.__maxVariableSize
+        )
+
+    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)
@@ -1451,23 +1585,23 @@
         @type int
         """
         self.debuggerInterface.remoteClientVariable(
-            debuggerId, scope, filterList, var, framenr,
-            self.__maxVariableSize)
-    
+            debuggerId, scope, filterList, var, framenr, self.__maxVariableSize
+        )
+
     def remoteClientDisassembly(self, debuggerId):
         """
         Public method to ask the client for the latest traceback disassembly.
-        
+
         @param debuggerId ID of the debugger backend
         @type str
         """
         with contextlib.suppress(AttributeError):
             self.debuggerInterface.remoteClientDisassembly(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)
@@ -1475,48 +1609,47 @@
         @param filterStr regexp string for variable names to filter out
         @type str
         """
-        self.debuggerInterface.remoteClientSetFilter(
-            debuggerId, scope, filterStr)
-    
+        self.debuggerInterface.remoteClientSetFilter(debuggerId, scope, filterStr)
+
     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.debuggerInterface.setCallTraceEnabled(debuggerId, on)
-    
+
     def remoteBanner(self):
         """
         Public slot to get the banner info of the remote client.
         """
         self.debuggerInterface.remoteBanner()
-    
+
     def remoteCapabilities(self):
         """
         Public slot to get the debug clients capabilities.
         """
         self.debuggerInterface.remoteCapabilities()
-    
+
     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.debuggerInterface.remoteCompletion(debuggerId, text)
-    
+
     def signalClientOutput(self, line, debuggerId):
         """
         Public method to process a line of client output.
-        
+
         @param line client output
         @type str
         @param debuggerId ID of the debugger backend
@@ -1526,12 +1659,13 @@
             self.clientOutput.emit("{0}: {1}".format(debuggerId, line))
         else:
             self.clientOutput.emit(line)
-    
-    def signalClientLine(self, filename, lineno, debuggerId, forStack=False,
-                         threadName=""):
+
+    def signalClientLine(
+        self, filename, lineno, debuggerId, forStack=False, threadName=""
+    ):
         """
         Public method to process client position feedback.
-        
+
         @param filename name of the file currently being executed
         @type str
         @param lineno line of code currently being executed
@@ -1543,13 +1677,12 @@
         @param threadName name of the thread signaling the event
         @type str
         """
-        self.clientLine.emit(filename, lineno, debuggerId, threadName,
-                             forStack)
-    
+        self.clientLine.emit(filename, lineno, debuggerId, threadName, forStack)
+
     def signalClientStack(self, stack, debuggerId, threadName=""):
         """
         Public method to process a client's stack information.
-        
+
         @param stack list of stack entries. Each entry is a tuple of three
             values giving the filename, linenumber and method
         @type list of lists of (string, integer, string)
@@ -1559,11 +1692,11 @@
         @type str
         """
         self.clientStack.emit(stack, debuggerId, threadName)
-    
+
     def signalClientThreadList(self, currentId, threadList, debuggerId):
         """
         Public method to process the client thread list info.
-        
+
         @param currentId id of the current thread
         @type int
         @param threadList list of dictionaries containing the thread data
@@ -1572,20 +1705,20 @@
         @type str
         """
         self.clientThreadList.emit(currentId, threadList, debuggerId)
-    
+
     def signalClientThreadSet(self, debuggerId):
         """
         Public method to handle the change of the client thread.
-        
+
         @param debuggerId ID of the debugger backend
         @type str
         """
         self.clientThreadSet.emit(debuggerId)
-    
+
     def signalClientVariables(self, scope, variables, debuggerId):
         """
         Public method to process the client variables info.
-        
+
         @param scope scope of the variables
             (-2 = no frame found, -1 = empty locals, 1 = global, 0 = local)
         @type int
@@ -1595,11 +1728,11 @@
         @type str
         """
         self.clientVariables.emit(scope, variables, debuggerId)
-    
+
     def signalClientVariable(self, scope, variables, debuggerId):
         """
         Public method to process the client variable info.
-        
+
         @param scope scope of the variables (-1 = empty global, 1 = global,
             0 = local)
         @type int
@@ -1609,22 +1742,22 @@
         @type str
         """
         self.clientVariable.emit(scope, variables, debuggerId)
-    
+
     def signalClientStatement(self, more, debuggerId):
         """
         Public method to process the input response from the client.
-        
+
         @param more flag indicating that more user input is required
         @type bool
         @param debuggerId ID of the debugger backend
         @type str
         """
         self.clientStatement.emit(more, debuggerId)
-    
+
     def signalClientDisassembly(self, disassembly, debuggerId):
         """
         Public method to process the disassembly info from the client.
-        
+
         @param disassembly dictionary containing the disassembly information
         @type dict
         @param debuggerId ID of the debugger backend
@@ -1632,12 +1765,13 @@
         """
         if self.running:
             self.clientDisassembly.emit(disassembly, debuggerId)
-    
-    def signalClientException(self, exceptionType, exceptionMessage,
-                              stackTrace, debuggerId, threadName=""):
+
+    def signalClientException(
+        self, exceptionType, exceptionMessage, stackTrace, debuggerId, threadName=""
+    ):
         """
         Public method to process the exception info from the client.
-        
+
         @param exceptionType type of exception raised
         @type str
         @param exceptionMessage message given by the exception
@@ -1652,14 +1786,16 @@
         @type str
         """
         if self.running:
-            self.clientException.emit(exceptionType, exceptionMessage,
-                                      stackTrace, debuggerId, threadName)
-    
-    def signalClientSyntaxError(self, message, filename, lineNo, characterNo,
-                                debuggerId, threadName=""):
+            self.clientException.emit(
+                exceptionType, exceptionMessage, stackTrace, debuggerId, threadName
+            )
+
+    def signalClientSyntaxError(
+        self, message, filename, lineNo, characterNo, debuggerId, threadName=""
+    ):
         """
         Public method to process a syntax error info from the client.
-        
+
         @param message message of the syntax error
         @type str
         @param filename translated filename of the syntax error position
@@ -1674,14 +1810,16 @@
         @type str
         """
         if self.running:
-            self.clientSyntaxError.emit(message, filename, lineNo, characterNo,
-                                        debuggerId, threadName)
-    
-    def signalClientSignal(self, message, filename, lineNo,
-                           funcName, funcArgs, debuggerId):
+            self.clientSyntaxError.emit(
+                message, filename, lineNo, characterNo, debuggerId, threadName
+            )
+
+    def signalClientSignal(
+        self, message, filename, lineNo, funcName, funcArgs, debuggerId
+    ):
         """
         Public method to process a signal generated on the client side.
-        
+
         @param message message of the syntax error
         @type str
         @param filename translated filename of the syntax error position
@@ -1696,23 +1834,24 @@
         @type str
         """
         if self.running:
-            self.clientSignal.emit(message, filename, lineNo,
-                                   funcName, funcArgs, debuggerId)
-    
+            self.clientSignal.emit(
+                message, filename, lineNo, funcName, funcArgs, debuggerId
+            )
+
     def signalClientDisconnected(self, debuggerId):
         """
         Public method to send a signal when a debug client has closed its
         connection.
-        
+
         @param debuggerId ID of the debugger backend
         @type str
         """
         self.clientDisconnected.emit(debuggerId)
-    
+
     def signalClientExit(self, program, status, message, debuggerId):
         """
         Public method to process the client exit status.
-        
+
         @param program name of the exited program
         @type str
         @param status exit code
@@ -1723,13 +1862,13 @@
         @type str
         """
         self.clientExit.emit(program, int(status), message, False, debuggerId)
-    
+
     def signalMainClientExit(self):
         """
         Public method to process the main client exiting.
         """
         self.mainClientExit.emit()
-    
+
     def signalLastClientExited(self):
         """
         Public method to process the last client exit event.
@@ -1737,20 +1876,21 @@
         if self.passive:
             self.__passiveShutDown()
         self.lastClientExited.emit()
-        if Preferences.getDebugger("AutomaticReset") or (self.running and
-                                                         not self.debugging):
+        if Preferences.getDebugger("AutomaticReset") or (
+            self.running and not self.debugging
+        ):
             self.debugging = False
             self.startClient(False, forProject=self.__forProject)
         if self.passive:
             self.__createDebuggerInterface("None")
-            self.signalClientOutput(self.tr('\nNot connected\n'))
+            self.signalClientOutput(self.tr("\nNot connected\n"))
             self.signalClientStatement(False, "")
         self.running = False
-    
+
     def signalClientClearBreak(self, filename, lineno, debuggerId):
         """
         Public method to process the client clear breakpoint command.
-        
+
         @param filename filename of the breakpoint
         @type str
         @param lineno line umber of the breakpoint
@@ -1759,11 +1899,11 @@
         @type str
         """
         self.clientClearBreak.emit(filename, lineno, debuggerId)
-    
+
     def signalClientBreakConditionError(self, filename, lineno, debuggerId):
         """
         Public method to process the client breakpoint condition error info.
-        
+
         @param filename filename of the breakpoint
         @type str
         @param lineno line umber of the breakpoint
@@ -1774,22 +1914,22 @@
         if (filename, lineno) not in self.__reportedBreakpointIssues:
             self.__reportedBreakpointIssues.append((filename, lineno))
             self.clientBreakConditionError.emit(filename, lineno, debuggerId)
-    
+
     def signalClientClearWatch(self, condition, debuggerId):
         """
         Public slot to handle the clientClearWatch signal.
-        
+
         @param condition expression of watch expression to clear
         @type str
         @param debuggerId ID of the debugger backend
         @type str
         """
         self.clientClearWatch.emit(condition, debuggerId)
-    
+
     def signalClientWatchConditionError(self, condition, debuggerId):
         """
         Public method to process the client watch expression error info.
-        
+
         @param condition expression of watch expression to clear
         @type str
         @param debuggerId ID of the debugger backend
@@ -1798,11 +1938,11 @@
         if condition not in self.__reportedWatchpointIssues:
             self.__reportedWatchpointIssues.append(condition)
             self.clientWatchConditionError.emit(condition, debuggerId)
-    
+
     def signalClientRawInput(self, prompt, echo, debuggerId):
         """
         Public method to process the client raw input command.
-        
+
         @param prompt the input prompt
         @type str
         @param echo flag indicating an echoing of the input
@@ -1811,11 +1951,11 @@
         @type str
         """
         self.clientRawInput.emit(prompt, echo, debuggerId)
-    
+
     def signalClientBanner(self, version, platform, venvName):
         """
         Public method to process the client banner info.
-        
+
         @param version interpreter version info
         @type str
         @param platform hostname of the client
@@ -1824,11 +1964,11 @@
         @type str
         """
         self.clientBanner.emit(version, platform, venvName)
-    
+
     def signalClientCapabilities(self, capabilities, clientType, venvName):
         """
         Public method to process the client capabilities info.
-        
+
         @param capabilities bitmaks with the client capabilities
         @type int
         @param clientType type of the debug client
@@ -1839,11 +1979,11 @@
         with contextlib.suppress(KeyError):
             self.__debuggerInterfaceRegistry[clientType][0] = capabilities
             self.clientCapabilities.emit(capabilities, clientType, venvName)
-    
+
     def signalClientCompletionList(self, completionList, text, debuggerId):
         """
         Public method to process the client auto completion info.
-        
+
         @param completionList list of possible completions
         @type list of str
         @param text the text to be completed
@@ -1852,12 +1992,21 @@
         @type str
         """
         self.clientCompletionList.emit(completionList, text)
-    
-    def signalClientCallTrace(self, isCall, fromFile, fromLine, fromFunction,
-                              toFile, toLine, toFunction, debuggerId):
+
+    def signalClientCallTrace(
+        self,
+        isCall,
+        fromFile,
+        fromLine,
+        fromFunction,
+        toFile,
+        toLine,
+        toFunction,
+        debuggerId,
+    ):
         """
         Public method to process the client call trace data.
-        
+
         @param isCall flag indicating a 'call'
         @type bool
         @param fromFile name of the originating file
@@ -1876,13 +2025,20 @@
         @type str
         """
         self.callTraceInfo.emit(
-            isCall, fromFile, fromLine, fromFunction,
-            toFile, toLine, toFunction, debuggerId)
-    
+            isCall,
+            fromFile,
+            fromLine,
+            fromFunction,
+            toFile,
+            toLine,
+            toFunction,
+            debuggerId,
+        )
+
     def passiveStartUp(self, fn, exc, debuggerId):
         """
         Public method to handle a passive debug connection.
-        
+
         @param fn filename of the debugged script
         @type str
         @param exc flag to enable exception reporting of the IDE
@@ -1897,7 +2053,7 @@
         self.__restoreBreakpoints(debuggerId)
         self.__restoreWatchpoints(debuggerId)
         self.passiveDebugStarted.emit(fn, exc)
-    
+
     def __passiveShutDown(self):
         """
         Private method to shut down a passive debug connection.
@@ -1905,93 +2061,93 @@
         self.passiveClientExited = True
         self.shutdownServer()
         self.appendStdout.emit(self.tr("Passive debug connection closed\n"))
-    
+
     def __restoreBreakpoints(self, debuggerId=""):
         """
         Private method to restore the breakpoints after a restart.
-        
+
         @param debuggerId ID of the debugger backend to send to. If this is
             empty, they will be broadcast to all connected backends.
         @type str
         """
         if self.debugging:
             self.__addBreakPoints(
-                QModelIndex(), 0, self.breakpointModel.rowCount() - 1,
-                debuggerId)
-    
+                QModelIndex(), 0, self.breakpointModel.rowCount() - 1, debuggerId
+            )
+
     def __restoreWatchpoints(self, debuggerId=""):
         """
         Private method to restore the watch expressions after a restart.
-        
+
         @param debuggerId ID of the debugger backend to send to. If this is
             empty, they will be broadcast to all connected backends.
         @type str
         """
         if self.debugging:
             self.__addWatchPoints(
-                QModelIndex(), 0, self.watchpointModel.rowCount() - 1,
-                debuggerId)
-    
+                QModelIndex(), 0, self.watchpointModel.rowCount() - 1, debuggerId
+            )
+
     def getBreakPointModel(self):
         """
         Public slot to get a reference to the breakpoint model object.
-        
+
         @return reference to the breakpoint model object
         @rtype BreakPointModel
         """
         return self.breakpointModel
-    
+
     def getWatchPointModel(self):
         """
         Public slot to get a reference to the watch expression model object.
-        
+
         @return reference to the watch expression model object
         @rtype WatchPointModel
         """
         return self.watchpointModel
-    
+
     def isConnected(self):
         """
         Public method to test, if the debug server is connected to a backend.
-        
+
         @return flag indicating a connection
         @rtype bool
         """
         return self.debuggerInterface and self.debuggerInterface.isConnected()
-    
+
     def isDebugging(self):
         """
         Public method to test, if the debug server is debugging.
-        
+
         @return flag indicating the debugging state
         @rtype bool
         """
         return self.debugging
-    
+
     def setDebugging(self, on):
         """
         Public method to set the debugging state.
-        
+
         @param on flag indicating the new debugging state
         @type bool
         """
         self.debugging = on
-    
+
     def signalClientDebuggerId(self, debuggerId):
         """
         Public method to signal the receipt of a new debugger ID.
-        
+
         This signal indicates, that a new debugger backend has connected.
-        
+
         @param debuggerId ID of the newly connected debugger backend
         @type str
         """
         self.clientDebuggerId.emit(debuggerId)
-    
+
     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
         """
@@ -1999,27 +2155,28 @@
             return self.debuggerInterface.getDebuggerIds()
         else:
             return []
-    
+
     def initializeClient(self, debuggerId):
         """
         Public method to initialize a freshly connected debug client.
-        
+
         @param debuggerId ID of the connected debugger
         @type str
         """
         self.__restoreBreakpoints(debuggerId)
         self.__restoreWatchpoints(debuggerId)
         self.__restoreNoDebugList(debuggerId)
-    
+
     def __restoreNoDebugList(self, debuggerId=""):
         """
         Private method to restore the list of scripts not to be debugged after
         a restart.
-        
+
         @param debuggerId ID of the debugger backend to send to. If this is
             empty, they will be broadcast to all connected backends.
         @type str
         """
         if self.debugging:
             self.debuggerInterface.remoteNoDebugList(
-                debuggerId, self.__multiprocessNoDebugList)
+                debuggerId, self.__multiprocessNoDebugList
+            )

eric ide

mercurial