Mercurial Repositories > eric / changeset

--- a/APIs/Python3/eric6.api	Thu Aug 03 14:50:59 2017 +0200
+++ b/APIs/Python3/eric6.api	Fri Sep 01 12:08:17 2017 +0200
@@ -430,7 +430,7 @@
 eric6.Debugger.DebugServer.DebugServer.passiveDebugStarted?7
 eric6.Debugger.DebugServer.DebugServer.passiveStartUp?4(fn, exc)
 eric6.Debugger.DebugServer.DebugServer.preferencesChanged?4()
-eric6.Debugger.DebugServer.DebugServer.registerDebuggerInterface?4(name, getRegistryData)
+eric6.Debugger.DebugServer.DebugServer.registerDebuggerInterface?4(interfaceName, getRegistryData)
 eric6.Debugger.DebugServer.DebugServer.remoteBanner?4()
 eric6.Debugger.DebugServer.DebugServer.remoteBreakpoint?4(fn, line, setBreakpoint, cond=None, temp=False)
 eric6.Debugger.DebugServer.DebugServer.remoteCapabilities?4()
@@ -480,7 +480,7 @@
 eric6.Debugger.DebugServer.DebugServer.signalClientVariables?4(scope, variables)
 eric6.Debugger.DebugServer.DebugServer.signalClientWatchConditionError?4(condition)
 eric6.Debugger.DebugServer.DebugServer.startClient?4(unplanned=True, clType=None, forProject=False, runInConsole=False)
-eric6.Debugger.DebugServer.DebugServer.unregisterDebuggerInterface?4(name)
+eric6.Debugger.DebugServer.DebugServer.unregisterDebuggerInterface?4(interfaceName)
 eric6.Debugger.DebugServer.DebugServer.utFinished?7
 eric6.Debugger.DebugServer.DebugServer.utPrepared?7
 eric6.Debugger.DebugServer.DebugServer.utStartTest?7
@@ -583,90 +583,49 @@
 eric6.Debugger.DebuggerInterfaceNone.DebuggerInterfaceNone?1(debugServer, passive)
 eric6.Debugger.DebuggerInterfaceNone.createDebuggerInterfaceNone?4(debugServer, passive)
 eric6.Debugger.DebuggerInterfaceNone.getRegistryData?4()
-eric6.Debugger.DebuggerInterfacePython2.ClientDefaultCapabilities?7
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.flush?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.getClientCapabilities?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.isConnected?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.newConnection?4(sock)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteBanner?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteBreakpoint?4(fn, line, setBreakpoint, cond=None, temp=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteBreakpointEnable?4(fn, line, enable)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteBreakpointIgnore?4(fn, line, count)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteCapabilities?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteClientSetFilter?4(scope, filterStr)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteClientVariable?4(scope, filterList, var, framenr=0)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteClientVariables?4(scope, filterList, framenr=0)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteCompletion?4(text)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteContinue?4(special=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteCoverage?4(fn, argv, wd, erase=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteEnvironment?4(env)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteLoad?4(fn, argv, wd, traceInterpreter=False, autoContinue=True, autoFork=False, forkChild=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteMoveIP?4(line)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteProfile?4(fn, argv, wd, erase=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteRawInput?4(s)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteRun?4(fn, argv, wd, autoFork=False, forkChild=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteSetThread?4(tid)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteStatement?4(stmt)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteStep?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteStepOut?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteStepOver?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteStepQuit?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteThreadList?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteUTPrepare?4(fn, tn, tfn, failed, cov, covname, coverase)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteUTRun?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteUTStop?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteWatchpoint?4(cond, setWatch, temp=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteWatchpointEnable?4(cond, enable)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteWatchpointIgnore?4(cond, count)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.setCallTraceEnabled?4(on)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.shutdown?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.startRemote?4(port, runInConsole)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.startRemoteForProject?4(port, runInConsole)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2?1(debugServer, passive)
-eric6.Debugger.DebuggerInterfacePython2.createDebuggerInterfacePython2?4(debugServer, passive)
-eric6.Debugger.DebuggerInterfacePython2.getRegistryData?4()
-eric6.Debugger.DebuggerInterfacePython3.ClientDefaultCapabilities?7
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.flush?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.getClientCapabilities?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.isConnected?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.newConnection?4(sock)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteBanner?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteBreakpoint?4(fn, line, setBreakpoint, cond=None, temp=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteBreakpointEnable?4(fn, line, enable)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteBreakpointIgnore?4(fn, line, count)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteCapabilities?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteClientSetFilter?4(scope, filterStr)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteClientVariable?4(scope, filterList, var, framenr=0)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteClientVariables?4(scope, filterList, framenr=0)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteCompletion?4(text)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteContinue?4(special=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteCoverage?4(fn, argv, wd, erase=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteEnvironment?4(env)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteLoad?4(fn, argv, wd, traceInterpreter=False, autoContinue=True, autoFork=False, forkChild=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteMoveIP?4(line)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteProfile?4(fn, argv, wd, erase=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteRawInput?4(s)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteRun?4(fn, argv, wd, autoFork=False, forkChild=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteSetThread?4(tid)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteStatement?4(stmt)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteStep?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteStepOut?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteStepOver?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteStepQuit?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteThreadList?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteUTPrepare?4(fn, tn, tfn, failed, cov, covname, coverase)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteUTRun?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteUTStop?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteWatchpoint?4(cond, setWatch, temp=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteWatchpointEnable?4(cond, enable)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteWatchpointIgnore?4(cond, count)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.setCallTraceEnabled?4(on)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.shutdown?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.startRemote?4(port, runInConsole)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.startRemoteForProject?4(port, runInConsole)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3?1(debugServer, passive)
-eric6.Debugger.DebuggerInterfacePython3.createDebuggerInterfacePython3?4(debugServer, passive)
-eric6.Debugger.DebuggerInterfacePython3.getRegistryData?4()
+eric6.Debugger.DebuggerInterfacePython.ClientDefaultCapabilities?7
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.flush?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.getClientCapabilities?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.isConnected?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.newConnection?4(sock)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteBanner?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteBreakpoint?4(fn, line, setBreakpoint, cond=None, temp=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteBreakpointEnable?4(fn, line, enable)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteBreakpointIgnore?4(fn, line, count)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteCapabilities?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteClientSetFilter?4(scope, filterStr)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteClientVariable?4(scope, filterList, var, framenr=0)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteClientVariables?4(scope, filterList, framenr=0)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteCompletion?4(text)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteContinue?4(special=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteCoverage?4(fn, argv, wd, erase=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteEnvironment?4(env)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteLoad?4(fn, argv, wd, traceInterpreter=False, autoContinue=True, autoFork=False, forkChild=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteMoveIP?4(line)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteProfile?4(fn, argv, wd, erase=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteRawInput?4(s)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteRun?4(fn, argv, wd, autoFork=False, forkChild=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteSetThread?4(tid)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteStatement?4(stmt)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteStep?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteStepOut?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteStepOver?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteStepQuit?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteThreadList?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteUTPrepare?4(fn, tn, tfn, failed, cov, covname, coverase)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteUTRun?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteUTStop?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteWatchpoint?4(cond, setWatch, temp=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteWatchpointEnable?4(cond, enable)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteWatchpointIgnore?4(cond, count)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.setCallTraceEnabled?4(on)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.shutdown?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.startRemote?4(port, runInConsole)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.startRemoteForProject?4(port, runInConsole)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython?1(debugServer, passive, pythonVariant)
+eric6.Debugger.DebuggerInterfacePython.createDebuggerInterfacePython2?4(debugServer, passive)
+eric6.Debugger.DebuggerInterfacePython.createDebuggerInterfacePython3?4(debugServer, passive)
+eric6.Debugger.DebuggerInterfacePython.getRegistryData?4()
 eric6.Debugger.EditBreakpointDialog.EditBreakpointDialog.getAddData?4()
 eric6.Debugger.EditBreakpointDialog.EditBreakpointDialog.getData?4()
 eric6.Debugger.EditBreakpointDialog.EditBreakpointDialog.on_filenamePicker_editTextChanged?4(fn)
@@ -925,7 +884,7 @@
 eric6.E5Gui.E5ErrorMessage.messageHandlerInstalled?4()
 eric6.E5Gui.E5ErrorMessage.qtHandler?4()
 eric6.E5Gui.E5ErrorMessageFilterDialog.E5ErrorMessageFilterDialog.getFilters?4()
-eric6.E5Gui.E5ErrorMessageFilterDialog.E5ErrorMessageFilterDialog?1(messageFilters, parent=None)
+eric6.E5Gui.E5ErrorMessageFilterDialog.E5ErrorMessageFilterDialog?1(messageFilters, defaultFilters, parent=None)
 eric6.E5Gui.E5FileDialog.DontConfirmOverwrite?7
 eric6.E5Gui.E5FileDialog.DontResolveSymlinks?7
 eric6.E5Gui.E5FileDialog.DontUseNativeDialog?7
@@ -1264,8 +1223,10 @@
 eric6.E5Gui.E5SqueezeLabels.E5SqueezeLabelPath?1(parent=None)
 eric6.E5Gui.E5StringListEditWidget.E5StringListEditWidget.getList?4()
 eric6.E5Gui.E5StringListEditWidget.E5StringListEditWidget.on_addButton_clicked?4()
+eric6.E5Gui.E5StringListEditWidget.E5StringListEditWidget.setDefaultVisible?4(visible)
 eric6.E5Gui.E5StringListEditWidget.E5StringListEditWidget.setList?4(stringList)
 eric6.E5Gui.E5StringListEditWidget.E5StringListEditWidget.setListWhatsThis?4(txt)
+eric6.E5Gui.E5StringListEditWidget.E5StringListEditWidget.setToDefault?7
 eric6.E5Gui.E5StringListEditWidget.E5StringListEditWidget?1(parent=None)
 eric6.E5Gui.E5TabWidget.E5DnDTabBar.dragEnterEvent?4(event)
 eric6.E5Gui.E5TabWidget.E5DnDTabBar.dropEvent?4(event)
@@ -1703,6 +1664,7 @@
 eric6.Globals.settingsNameOrganization?7
 eric6.Globals.settingsNameRecent?7
 eric6.Globals.strGroup?4(txt, sep, groupLen=4)
+eric6.Globals.strToQByteArray?4(txt)
 eric6.Globals.toBool?4(value)
 eric6.Globals.toByteArray?4(value)
 eric6.Globals.toDict?4(value)
@@ -7517,6 +7479,8 @@
 eric6.QScintilla.Exporters.ExporterHTML.ExporterHTML?1(editor, parent=None)
 eric6.QScintilla.Exporters.ExporterHTML.HTMLGenerator.generate?4(tabSize=4, useTabs=False, wysiwyg=True, folding=False, onlyStylesUsed=False, titleFullPath=False)
 eric6.QScintilla.Exporters.ExporterHTML.HTMLGenerator?1(editor)
+eric6.QScintilla.Exporters.ExporterHTML._StrikeThroughExtension.DEL_RE?7
+eric6.QScintilla.Exporters.ExporterHTML._StrikeThroughExtension.extendMarkdown?4(md, md_globals)
 eric6.QScintilla.Exporters.ExporterODT.ExporterODT.exportSource?4()
 eric6.QScintilla.Exporters.ExporterODT.ExporterODT?1(editor, parent=None)
 eric6.QScintilla.Exporters.ExporterPDF.ExporterPDF.exportSource?4()
@@ -8838,7 +8802,7 @@
 eric6.UI.Previewer.Previewer.shutdown?4()
 eric6.UI.Previewer.Previewer?1(viewmanager, splitter, parent=None)
 eric6.UI.Previewers.PreviewerHTML.PreviewProcessingThread.htmlReady?7
-eric6.UI.Previewers.PreviewerHTML.PreviewProcessingThread.process?4(filePath, language, text, ssiEnabled, rootPath, useSphinx)
+eric6.UI.Previewers.PreviewerHTML.PreviewProcessingThread.process?4(filePath, language, text, ssiEnabled, rootPath, useSphinx, convertNewLineToBreak, markdownHtmlFormat, restDocutilsHtmlFormat)
 eric6.UI.Previewers.PreviewerHTML.PreviewProcessingThread.run?4()
 eric6.UI.Previewers.PreviewerHTML.PreviewProcessingThread?1(parent=None)
 eric6.UI.Previewers.PreviewerHTML.PreviewerHTML.on_jsCheckBox_clicked?4(checked)
@@ -8944,7 +8908,7 @@
 eric6.UI.UserInterface.UserInterface.showFindFilesDialog?4(txt="", searchDir="", openFiles=False)
 eric6.UI.UserInterface.UserInterface.showLogViewer?4()
 eric6.UI.UserInterface.UserInterface.showMenu?7
-eric6.UI.UserInterface.UserInterface.showNotification?4(icon, heading, text)
+eric6.UI.UserInterface.UserInterface.showNotification?4(icon, heading, text, timeout=None)
 eric6.UI.UserInterface.UserInterface.showPluginsAvailable?4()
 eric6.UI.UserInterface.UserInterface.showPreferences?4(pageName=None)
 eric6.UI.UserInterface.UserInterface.showReplaceFilesDialog?4(txt="", searchDir="", openFiles=False)
@@ -10589,6 +10553,105 @@
 eric6.WebBrowser.QtHelp.QtHelpFiltersDialog.QtHelpFiltersDialog.on_removeButton_clicked?4()
 eric6.WebBrowser.QtHelp.QtHelpFiltersDialog.QtHelpFiltersDialog.on_unusedAttributesButton_clicked?4()
 eric6.WebBrowser.QtHelp.QtHelpFiltersDialog.QtHelpFiltersDialog?1(engine, parent=None)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.ClientId?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.ClientVersion?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.GsbUrlTemplate?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.fairUseDelayExpired?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.getFairUseDelayExpirationDateTime?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.getFullHashes?4(prefixes, clientState)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.getPlatformString?4(platformType)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.getPlatformTypes?4(platform)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.getThreatEntryString?4(threatEntry)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.getThreatLists?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.getThreatMessage?4(threatType)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.getThreatType?4(threatType)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.getThreatsUpdate?4(clientStates)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.networkError?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient.setApiKey?4(apiKey)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingAPIClient.SafeBrowsingAPIClient?1(apiKey, fairUse=True, parent=None)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.HashPrefixList?1(prefixLength, rawHashes)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.addThreatList?4(threatList)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.cleanupFullHashes?4(keepExpiredFor=43200)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.close?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.create_full_hash_cue_idx?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.create_full_hash_expires_idx?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.create_full_hash_value_idx?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.create_full_hashes_stmt?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.create_hash_prefix_stmt?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.create_threat_list_stmt?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.deleteHashPrefixList?4(threatList)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.deleteThreatList?4(threatList)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.drop_full_hash_cue_idx?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.drop_full_hash_expires_idx?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.drop_full_hash_value_idx?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.drop_full_hashes_stmt?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.drop_hash_prefix_stmt?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.drop_threat_list_stmt?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.getHashPrefixValuesToRemove?4(threatList, indexes)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.getThreatLists?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.hashPrefixListChecksum?4(threatList)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.lookupFullHashes?4(hashValues)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.lookupHashPrefix?4(prefixes)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.maxProcessEventsTime?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.populateHashPrefixList?4(threatList, prefixes)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.prepareCacheDb?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.removeHashPrefixIndices?4(threatList, indexes)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.storeFullHash?4(threatList, hashValue, cacheDuration, malwareThreatType)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.updateHashPrefixExpiration?4(threatList, hashPrefix, negativeCacheDuration)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache.updateThreatListClientState?4(threatList, clientState)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.SafeBrowsingCache?1(dbPath, parent=None)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.ThreatList.asTuple?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.ThreatList.fromApiEntry?4(entry)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingCache.ThreatList?1(threatType, platformType, threatEntryType)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingDialog.SafeBrowsingDialog.closeEvent?4(evt)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingDialog.SafeBrowsingDialog.on_buttonBox_clicked?4(button)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingDialog.SafeBrowsingDialog.on_clearCacheButton_clicked?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingDialog.SafeBrowsingDialog.on_gsbHelpButton_clicked?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingDialog.SafeBrowsingDialog.on_saveButton_clicked?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingDialog.SafeBrowsingDialog.on_showUpdateTimeButton_clicked?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingDialog.SafeBrowsingDialog.on_updateCacheButton_clicked?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingDialog.SafeBrowsingDialog.on_urlCheckButton_clicked?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingDialog.SafeBrowsingDialog.on_urlEdit_textChanged?4(text)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingDialog.SafeBrowsingDialog.show?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingDialog.SafeBrowsingDialog?1(manager, parent=None)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingHelp?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingInfoWidget.SafeBrowsingInfoWidget.showAt?4(pos)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingInfoWidget.SafeBrowsingInfoWidget?1(info, parent=None)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingLabel.SafeBrowsingLabel.clicked?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingLabel.SafeBrowsingLabel.getThreatInfo?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingLabel.SafeBrowsingLabel.mouseDoubleClickEvent?4(evt)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingLabel.SafeBrowsingLabel.mouseReleaseEvent?4(evt)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingLabel.SafeBrowsingLabel.nokStyle?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingLabel.SafeBrowsingLabel.setThreatInfo?4(threatType, threatMessages)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingLabel.SafeBrowsingLabel?1(parent=None)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.close?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.configurationChanged?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.fairUseDelayExpired?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.fullCacheCleanup?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.getIgnoreSchemes?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.getPlatformString?4(platformType)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.getThreatEntryString?4(threatEntry)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.getThreatMessage?4(threatType)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.getThreatMessages?4(threatLists)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.getThreatType?4(threatList)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.isEnabled?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.isUpdatingThreatLists?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.lookupUrl?4(url)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.progress?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.progressMessage?7
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.showSafeBrowsingDialog?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager.updateHashPrefixCache?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingManager.SafeBrowsingManager?1()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingUrl.SafeBrowsingUrl.canonical?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingUrl.SafeBrowsingUrl.digest?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingUrl.SafeBrowsingUrl.fullUnescape?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingUrl.SafeBrowsingUrl.hashes?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingUrl.SafeBrowsingUrl.hostPermutations?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingUrl.SafeBrowsingUrl.pathPermutations?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingUrl.SafeBrowsingUrl.permutations?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingUrl.SafeBrowsingUrl.quote?4()
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingUrl.SafeBrowsingUrl?1(url)
+eric6.WebBrowser.SafeBrowsing.SafeBrowsingUtilities.toHex?4(value)
 eric6.WebBrowser.SearchWidget.SearchWidget.findNext?4()
 eric6.WebBrowser.SearchWidget.SearchWidget.findPrevious?4()
 eric6.WebBrowser.SearchWidget.SearchWidget.keyPressEvent?4(event)
@@ -10979,6 +11042,7 @@
 eric6.WebBrowser.WebBrowserPage.WebBrowserPage.certificateError?4(error)
 eric6.WebBrowser.WebBrowserPage.WebBrowserPage.execJavaScript?4(script, worldId=QWebEngineScript.MainWorld, timeout=500)
 eric6.WebBrowser.WebBrowserPage.WebBrowserPage.execPrintPage?4(printer, timeout=1000)
+eric6.WebBrowser.WebBrowserPage.WebBrowserPage.getSafeBrowsingStatus?4()
 eric6.WebBrowser.WebBrowserPage.WebBrowserPage.hitTestContent?4(pos)
 eric6.WebBrowser.WebBrowserPage.WebBrowserPage.icon?4()
 eric6.WebBrowser.WebBrowserPage.WebBrowserPage.isJavaScriptEnabled?4()
@@ -10987,6 +11051,8 @@
 eric6.WebBrowser.WebBrowserPage.WebBrowserPage.printCallback?4(resDict=resultDict)
 eric6.WebBrowser.WebBrowserPage.WebBrowserPage.resultCallback?4(resDict=resultDict)
 eric6.WebBrowser.WebBrowserPage.WebBrowserPage.runJavaScript?4(script, worldId=-1, callback=None)
+eric6.WebBrowser.WebBrowserPage.WebBrowserPage.safeBrowsingAbort?7
+eric6.WebBrowser.WebBrowserPage.WebBrowserPage.safeBrowsingBad?7
 eric6.WebBrowser.WebBrowserPage.WebBrowserPage.scroll?4(x, y)
 eric6.WebBrowser.WebBrowserPage.WebBrowserPage.scrollPosition?4()
 eric6.WebBrowser.WebBrowserPage.WebBrowserPage.scrollTo?4(pos)
@@ -11068,6 +11134,7 @@
 eric6.WebBrowser.WebBrowserView.WebBrowserView.forwardAvailable?7
 eric6.WebBrowser.WebBrowserView.WebBrowserView.getPreview?4()
 eric6.WebBrowser.WebBrowserView.WebBrowserView.getRSS?4()
+eric6.WebBrowser.WebBrowserView.WebBrowserView.getSafeBrowsingStatus?4()
 eric6.WebBrowser.WebBrowserView.WebBrowserView.getSessionData?4()
 eric6.WebBrowser.WebBrowserView.WebBrowserView.hasRSS?4()
 eric6.WebBrowser.WebBrowserView.WebBrowserView.hasSelection?4()
@@ -11090,6 +11157,8 @@
 eric6.WebBrowser.WebBrowserView.WebBrowserView.reload?4()
 eric6.WebBrowser.WebBrowserView.WebBrowserView.reloadBypassingCache?4()
 eric6.WebBrowser.WebBrowserView.WebBrowserView.requestFullScreen?4(enable)
+eric6.WebBrowser.WebBrowserView.WebBrowserView.safeBrowsingAbort?7
+eric6.WebBrowser.WebBrowserView.WebBrowserView.safeBrowsingBad?7
 eric6.WebBrowser.WebBrowserView.WebBrowserView.saveAs?4()
 eric6.WebBrowser.WebBrowserView.WebBrowserView.search?7
 eric6.WebBrowser.WebBrowserView.WebBrowserView.selectAll?4()
@@ -11136,6 +11205,7 @@
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow._performingShutdown?8
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow._performingStartup?8
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow._personalInformationManager?8
+eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow._safeBrowsingManager?8
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow._sessionManager?8
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow._speedDial?8
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow._syncManager?8
@@ -11169,6 +11239,7 @@
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.getQtHelpCollectionFileName?4()
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.getSourceFileList?4()
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.getWindow?4()
+eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.globalStatusBar?4()
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.greaseMonkeyManager?4()
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.helpEngine?4()
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.hideFullScreenNavigation?4()
@@ -11200,6 +11271,7 @@
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.preferencesChanged?4()
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.reloadUserStyleSheet?4()
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.requestVirusTotalScan?4(url)
+eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.safeBrowsingManager?4()
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.search?4(word)
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.searchEnginesAction?4()
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.sessionManager?4()
@@ -11210,7 +11282,7 @@
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.setLoadingActions?4(b)
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.setUseQtHelp?4(use)
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.showFullScreenNavigation?4()
-eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.showNotification?4(icon, heading, text)
+eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.showNotification?4(icon, heading, text, timeout=None)
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.shutdown?4()
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.speedDial?4()
 eric6.WebBrowser.WebBrowserWindow.WebBrowserWindow.syncManager?4()

--- a/APIs/Python3/eric6.bas	Thu Aug 03 14:50:59 2017 +0200
+++ b/APIs/Python3/eric6.bas	Fri Sep 01 12:08:17 2017 +0200
@@ -118,8 +118,7 @@
 DebugViewer QWidget
 DebuggerGeneralPage ConfigurationPageBase Ui_DebuggerGeneralPage
 DebuggerInterfaceNone QObject
-DebuggerInterfacePython2 QObject
-DebuggerInterfacePython3 QObject
+DebuggerInterfacePython QObject
 DebuggerPropertiesDialog QDialog Ui_DebuggerPropertiesDialog
 DebuggerPropertiesReader XMLStreamReaderBase
 DebuggerPropertiesWriter XMLStreamWriterBase
@@ -683,6 +682,12 @@
 RemoveBookmarksCommand QUndoCommand
 RestructuredTextProvider MarkupBase
 SafariImporter BookmarksImporter
+SafeBrowsingAPIClient QObject
+SafeBrowsingCache QObject
+SafeBrowsingDialog QDialog Ui_SafeBrowsingDialog
+SafeBrowsingInfoWidget QMenu
+SafeBrowsingLabel QLabel
+SafeBrowsingManager QObject
 SchemeAccessHandler QObject
 SearchReplaceSlidingWidget QWidget
 SearchReplaceWidget QWidget

--- a/Debugger/DebugServer.py	Thu Aug 03 14:50:59 2017 +0200
+++ b/Debugger/DebugServer.py	Fri Sep 01 12:08:17 2017 +0200
@@ -31,8 +31,7 @@
 
 
 DebuggerInterfaces = {
-    "Python2": "DebuggerInterfacePython2",
-    "Python3": "DebuggerInterfacePython3",
+    "Python": "DebuggerInterfacePython",
     "None": "DebuggerInterfaceNone",
 }
 
@@ -163,12 +162,15 @@
         """
         super(DebugServer, self).__init__()
         
+        self.__debuggerInterfaces = {}
+        # the interface name is the key, a function to get the
+        # registration data is the value
         self.__debuggerInterfaceRegistry = {}
         # the client language is the key, a list containing the client
-        # capabilities, the list of associated file extensions, a
+        # capabilities, a list of associated file extensions, a
         # function reference to create the debugger interface (see
-        # __createDebuggerInterface() below) and a function to be called
-        # to get the registration data as values
+        # __createDebuggerInterface() below) and the interface name is
+        # the value
         
         # create our models
         self.breakpointModel = BreakPointModel(self)
@@ -293,20 +295,20 @@
         Public slot to handle the preferencesChanged signal.
         """
         registeredInterfaces = {}
-        for language in self.__debuggerInterfaceRegistry:
-            registeredInterfaces[language] = \
-                self.__debuggerInterfaceRegistry[language][-1]
-            # last entry is the registry data function
+        for interfaceName in self.__debuggerInterfaces:
+            registeredInterfaces[interfaceName] = \
+                self.__debuggerInterfaces[interfaceName]
         
+        self.__debuggerInterfaces = {}
         self.__debuggerInterfaceRegistry = {}
-        for language, getRegistryData in registeredInterfaces.items():
-            self.registerDebuggerInterface(language, getRegistryData)
+        for interfaceName, getRegistryData in registeredInterfaces.items():
+            self.registerDebuggerInterface(interfaceName, getRegistryData)
         
-    def registerDebuggerInterface(self, name, getRegistryData):
+    def registerDebuggerInterface(self, interfaceName, getRegistryData):
         """
         Public method to register a debugger interface.
         
-        @param name name of the debugger interface
+        @param interfaceName name of the debugger interface
         @type str
         @param getRegistryData reference to a function to be called
             to get the debugger interface details. This method shall
@@ -315,7 +317,7 @@
             to create the debugger interface (see __createDebuggerInterface())
         @type function
         """
-        if name in self.__debuggerInterfaceRegistry:
+        if interfaceName in self.__debuggerInterfaces:
             E5MessageBox.warning(
                 None,
                 self.tr("Register Debugger Interface"),
@@ -323,22 +325,31 @@
                         """ been registered. Ignoring this request.</p>"""))
             return
         
-        clientLanguage, clientCapabilities, clientExtensions, \
-            interfaceCreator = getRegistryData()
-        if clientLanguage:
-            self.__debuggerInterfaceRegistry[clientLanguage] = \
-                [clientCapabilities, clientExtensions, interfaceCreator,
-                 getRegistryData]
+        registryDataList = getRegistryData()
+        if registryDataList:
+            self.__debuggerInterfaces[interfaceName] = getRegistryData
+            for clientLanguage, clientCapabilities, clientExtensions, \
+                    interfaceCreator in registryDataList:
+                self.__debuggerInterfaceRegistry[clientLanguage] = [
+                    clientCapabilities, clientExtensions, interfaceCreator,
+                    interfaceName]
         
-    def unregisterDebuggerInterface(self, name):
+    def unregisterDebuggerInterface(self, interfaceName):
         """
         Public method to unregister a debugger interface.
         
-        @param name name of the debugger interface
+        @param interfaceName interfaceName of the debugger interface
         @type str
         """
-        if name in self.__debuggerInterfaceRegistry:
-            del self.__debuggerInterfaceRegistry[name]
+        if interfaceName in self.__debuggerInterfaces:
+            clientLanguages = []
+            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):
         """

--- a/Debugger/DebuggerInterfaceNone.py	Thu Aug 03 14:50:59 2017 +0200
+++ b/Debugger/DebuggerInterfaceNone.py	Fri Sep 01 12:08:17 2017 +0200
@@ -409,18 +409,19 @@
     @param passive flag indicating passive connection mode
     @type bool
     @return instantiated debugger interface
-    @rtype DebuggerInterfacePython
+    @rtype DebuggerInterfaceNone
     """
     return DebuggerInterfaceNone(debugServer, passive)
 
 
 def getRegistryData():
     """
-    Module functionto get characterizing data for the debugger interface.
+    Module function to get characterizing data for the debugger interface.
     
-    @return tuple containing  client type, client capabilities, client file
-        type associations and reference to creation function
-    @rtype tuple of (str, int, list of str, function)
+    @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)
     """
-    return ["None", ClientDefaultCapabilities, ClientTypeAssociations,
-            createDebuggerInterfaceNone]
+    return [("None", ClientDefaultCapabilities, ClientTypeAssociations,
+            createDebuggerInterfaceNone)]

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Debugger/DebuggerInterfacePython.py	Fri Sep 01 12:08:17 2017 +0200
@@ -0,0 +1,1156 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2009 - 2017 Detlev Offenbach <detlev@die-offenbachs.de>
+#
+
+"""
+Module implementing the Python3 debugger interface for the debug server.
+"""
+
+from __future__ import unicode_literals
+
+import sys
+import os
+
+from PyQt5.QtCore import QObject, QTextCodec, QProcess, QProcessEnvironment, \
+    QTimer
+from PyQt5.QtWidgets import QInputDialog
+
+from E5Gui.E5Application import e5App
+from E5Gui import E5MessageBox
+
+from . import DebugClientCapabilities
+
+import Preferences
+import Utilities
+
+from eric6config import getConfig
+
+
+ClientDefaultCapabilities = DebugClientCapabilities.HasAll
+
+
+class DebuggerInterfacePython(QObject):
+    """
+    Class implementing the debugger interface for the debug server for Python 2
+    and Python 3.
+    """
+    def __init__(self, debugServer, passive, pythonVariant):
+        """
+        Constructor
+        
+        @param debugServer reference to the debug server
+        @type DebugServer
+        @param passive flag indicating passive connection mode
+        @type bool
+        @param pythonVariant Python variant to instantiate for
+        @type str (one of Python2 or Python3)
+        """
+        super(DebuggerInterfacePython, self).__init__()
+        
+        self.__isNetworked = True
+        self.__autoContinue = False
+        
+        self.debugServer = debugServer
+        self.passive = passive
+        self.process = None
+        self.__variant = pythonVariant
+        
+        self.qsock = None
+        self.queue = []
+        
+        # set default values for capabilities of clients
+        self.clientCapabilities = ClientDefaultCapabilities
+        
+        # set translation function
+        self.translate = self.__identityTranslation
+        
+        self.codec = QTextCodec.codecForName(
+            str(Preferences.getSystem("StringEncoding")))
+        
+        if passive:
+            # set translation function
+            if Preferences.getDebugger("PathTranslation"):
+                self.translateRemote = \
+                    Preferences.getDebugger("PathTranslationRemote")
+                self.translateLocal = \
+                    Preferences.getDebugger("PathTranslationLocal")
+                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 (string)
+        @param remote2local flag indicating the direction of translation
+            (False = local to remote, True = remote to local [default])
+        @return translated filename (string)
+        """
+        return fn
+        
+    def __remoteTranslation(self, fn, remote2local=True):
+        """
+        Private method to perform the path translation.
+        
+        @param fn filename to be translated (string)
+        @param remote2local flag indicating the direction of translation
+            (False = local to remote, True = remote to local [default])
+        @return translated filename (string)
+        """
+        if remote2local:
+            return fn.replace(self.translateRemote, self.translateLocal)
+        else:
+            return fn.replace(self.translateLocal, self.translateRemote)
+        
+    def __startProcess(self, program, arguments, environment=None):
+        """
+        Private method to start the debugger client process.
+        
+        @param program name of the executable to start (string)
+        @param arguments arguments to be passed to the program (list of string)
+        @param environment dictionary of environment settings to pass
+            (dict of string)
+        @return the process object (QProcess) or None
+        """
+        proc = QProcess()
+        if environment is not None:
+            env = QProcessEnvironment()
+            for key, value in list(environment.items()):
+                env.insert(key, value)
+            proc.setProcessEnvironment(env)
+        args = []
+        for arg in arguments:
+            args.append(arg)
+        proc.start(program, args)
+        if not proc.waitForStarted(10000):
+            proc = None
+        
+        return proc
+        
+    def startRemote(self, port, runInConsole):
+        """
+        Public method to start a remote Python interpreter.
+        
+        @param port portnumber the debug server is listening on (integer)
+        @param runInConsole flag indicating to start the debugger in a
+            console window (boolean)
+        @return client process object (QProcess), a flag to indicate
+            a network connection (boolean) and the name of the interpreter
+            in case of a local execution (string)
+        """
+        if self.__variant == "Python2":
+            interpreter = Preferences.getDebugger("PythonInterpreter")
+        else:
+            interpreter = Preferences.getDebugger("Python3Interpreter")
+        if interpreter == "":
+            E5MessageBox.critical(
+                None,
+                self.tr("Start Debugger"),
+                self.tr(
+                    """<p>No {0} interpreter configured.</p>""")
+                .format(self.__variant))
+            return None, False, ""
+        
+        if self.__variant == "Python2":
+            debugClientType = Preferences.getDebugger("DebugClientType")
+        else:
+            debugClientType = Preferences.getDebugger("DebugClientType3")
+        if debugClientType == "standard":
+            debugClient = os.path.join(getConfig('ericDir'),
+                                       "DebugClients", "Python",
+                                       "DebugClient.py")
+        else:
+            if self.__variant == "Python2":
+                debugClient = Preferences.getDebugger("DebugClient")
+            else:
+                debugClient = Preferences.getDebugger("DebugClient3")
+            if debugClient == "":
+                debugClient = os.path.join(sys.path[0],
+                                           "DebugClients", "Python",
+                                           "DebugClient.py")
+        
+        if self.__variant == "Python2":
+            redirect = str(Preferences.getDebugger("PythonRedirect"))
+            noencoding = Preferences.getDebugger("PythonNoEncoding") and \
+                '--no-encoding' or ''
+        else:
+            redirect = str(Preferences.getDebugger("Python3Redirect"))
+            noencoding = Preferences.getDebugger("Python3NoEncoding") and \
+                '--no-encoding' or ''
+        
+        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,
+                        noencoding, str(port), redirect, ipaddr]
+                args[0] = Utilities.getExecutablePath(args[0])
+                process = self.__startProcess(args[0], args[1:])
+                if process is None:
+                    E5MessageBox.critical(
+                        None,
+                        self.tr("Start Debugger"),
+                        self.tr(
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
+                
+                # set translation function
+                if Preferences.getDebugger("PathTranslation"):
+                    self.translateRemote = \
+                        Preferences.getDebugger("PathTranslationRemote")
+                    self.translateLocal = \
+                        Preferences.getDebugger("PathTranslationLocal")
+                    self.translate = self.__remoteTranslation
+                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()
+        envlist = Utilities.parseEnvironmentString(
+            Preferences.getDebugger("DebugEnvironment"))
+        for el in envlist:
+            try:
+                key, value = el.split('=', 1)
+                if value.startswith('"') or value.startswith("'"):
+                    value = value[1:-1]
+                clientEnv[str(key)] = str(value)
+            except ValueError:
+                pass
+        
+        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),
+                        noencoding, str(port), '0', ipaddr]
+                args[0] = Utilities.getExecutablePath(args[0])
+                process = self.__startProcess(args[0], args[1:], clientEnv)
+                if process is None:
+                    E5MessageBox.critical(
+                        None,
+                        self.tr("Start Debugger"),
+                        self.tr(
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
+                return process, self.__isNetworked, interpreter
+        
+        process = self.__startProcess(
+            interpreter,
+            [debugClient, noencoding, str(port), redirect, ipaddr],
+            clientEnv)
+        if process is None:
+            E5MessageBox.critical(
+                None,
+                self.tr("Start Debugger"),
+                self.tr(
+                    """<p>The debugger backend could not be started.</p>"""))
+        return process, self.__isNetworked, interpreter
+
+    def startRemoteForProject(self, port, runInConsole):
+        """
+        Public method to start a remote Python interpreter for a project.
+        
+        @param port portnumber the debug server is listening on (integer)
+        @param runInConsole flag indicating to start the debugger in a
+            console window (boolean)
+        @return client process object (QProcess), a flag to indicate
+            a network connection (boolean) and the name of the interpreter
+            in case of a local execution (string)
+        """
+        project = e5App().getObject("Project")
+        if not project.isDebugPropertiesLoaded():
+            return None, self.__isNetworked, ""
+        
+        # start debugger with project specific settings
+        interpreter = project.getDebugProperty("INTERPRETER")
+        debugClient = project.getDebugProperty("DEBUGCLIENT")
+        
+        redirect = str(project.getDebugProperty("REDIRECT"))
+        noencoding = \
+            project.getDebugProperty("NOENCODING") and '--no-encoding' or ''
+        
+        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, os.path.abspath(debugClient),
+                        noencoding, str(port), redirect, ipaddr]
+                args[0] = Utilities.getExecutablePath(args[0])
+                process = self.__startProcess(args[0], args[1:])
+                if process is None:
+                    E5MessageBox.critical(
+                        None,
+                        self.tr("Start Debugger"),
+                        self.tr(
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
+                # set translation function
+                if project.getDebugProperty("PATHTRANSLATION"):
+                    self.translateRemote = \
+                        project.getDebugProperty("REMOTEPATH")
+                    self.translateLocal = \
+                        project.getDebugProperty("LOCALPATH")
+                    self.translate = self.__remoteTranslation
+                else:
+                    self.translate = self.__identityTranslation
+                return process, 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()
+        envlist = Utilities.parseEnvironmentString(
+            project.getDebugProperty("ENVIRONMENTSTRING"))
+        for el in envlist:
+            try:
+                key, value = el.split('=', 1)
+                if value.startswith('"') or value.startswith("'"):
+                    value = value[1:-1]
+                clientEnv[str(key)] = str(value)
+            except ValueError:
+                pass
+        
+        ipaddr = self.debugServer.getHostAddress(True)
+        if runInConsole or project.getDebugProperty("CONSOLEDEBUGGER"):
+            ccmd = project.getDebugProperty("CONSOLECOMMAND") or \
+                Preferences.getDebugger("ConsoleDbgCommand")
+            if ccmd:
+                args = Utilities.parseOptionString(ccmd) + \
+                    [interpreter, os.path.abspath(debugClient),
+                        noencoding, str(port), '0', ipaddr]
+                args[0] = Utilities.getExecutablePath(args[0])
+                process = self.__startProcess(args[0], args[1:], clientEnv)
+                if process is None:
+                    E5MessageBox.critical(
+                        None,
+                        self.tr("Start Debugger"),
+                        self.tr(
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
+                return process, self.__isNetworked, interpreter
+        
+        process = self.__startProcess(
+            interpreter,
+            [debugClient, noencoding, str(port), redirect, ipaddr],
+            clientEnv)
+        if process is None:
+            E5MessageBox.critical(
+                None,
+                self.tr("Start Debugger"),
+                self.tr(
+                    """<p>The debugger backend could not be started.</p>"""))
+        return process, self.__isNetworked, interpreter
+
+    def getClientCapabilities(self):
+        """
+        Public method to retrieve the debug clients capabilities.
+        
+        @return debug client capabilities (integer)
+        """
+        return self.clientCapabilities
+    
+    def newConnection(self, sock):
+        """
+        Public slot to handle a new connection.
+        
+        @param sock reference to the socket object (QTcpSocket)
+        @return flag indicating success (boolean)
+        """
+        # If we already have a connection, refuse this one.  It will be closed
+        # automatically.
+        if self.qsock is not None:
+            return False
+        
+        sock.disconnected.connect(self.debugServer.startClient)
+        sock.readyRead.connect(self.__parseClientLine)
+        
+        self.qsock = sock
+        
+        # Get the remote clients capabilities
+        self.remoteCapabilities()
+        return True
+    
+    def flush(self):
+        """
+        Public slot to flush the queue.
+        """
+        # Send commands that were waiting for the connection.
+        for cmd in self.queue:
+            self.qsock.write(cmd.encode('utf8', 'backslashreplace'))
+        
+        self.queue = []
+    
+    def shutdown(self):
+        """
+        Public method to cleanly shut down.
+        
+        It closes our socket and shuts down
+        the debug client. (Needed on Win OS)
+        """
+        if self.qsock is None:
+            return
+        
+        # do not want any slots called during shutdown
+        self.qsock.disconnected.disconnect(self.debugServer.startClient)
+        self.qsock.readyRead.disconnect(self.__parseClientLine)
+        
+        # close down socket, and shut down client as well.
+        self.__sendJsonCommand("RequestShutdown", {})
+        self.qsock.flush()
+        self.qsock.close()
+        
+        # reinitialize
+        self.qsock = None
+        self.queue = []
+    
+    def isConnected(self):
+        """
+        Public method to test, if a debug client has connected.
+        
+        @return flag indicating the connection status (boolean)
+        """
+        return self.qsock is not None
+    
+    def remoteEnvironment(self, env):
+        """
+        Public method to set the environment for a program to debug, run, ...
+        
+        @param env environment settings (dictionary)
+        """
+        self.__sendJsonCommand("RequestEnvironment", {"environment": env})
+    
+    def remoteLoad(self, fn, argv, wd, traceInterpreter=False,
+                   autoContinue=True, autoFork=False, forkChild=False):
+        """
+        Public method to load a new program to debug.
+        
+        @param fn the filename to debug (string)
+        @param argv the commandline arguments to pass to the program (string)
+        @param wd the working directory for the program (string)
+        @keyparam traceInterpreter flag indicating if the interpreter library
+            should be traced as well (boolean)
+        @keyparam autoContinue flag indicating, that the debugger should not
+            stop at the first executable line (boolean)
+        @keyparam autoFork flag indicating the automatic fork mode (boolean)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
+        """
+        self.__autoContinue = autoContinue
+        self.__scriptName = os.path.abspath(fn)
+        
+        wd = self.translate(wd, False)
+        fn = self.translate(os.path.abspath(fn), False)
+        self.__sendJsonCommand("RequestLoad", {
+            "workdir": wd,
+            "filename": fn,
+            "argv": Utilities.parseOptionString(argv),
+            "traceInterpreter": traceInterpreter,
+            "autofork": autoFork,
+            "forkChild": forkChild,
+        })
+    
+    def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
+        """
+        Public method to load a new program to run.
+        
+        @param fn the filename to run (string)
+        @param argv the commandline arguments to pass to the program (string)
+        @param wd the working directory for the program (string)
+        @keyparam autoFork flag indicating the automatic fork mode (boolean)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
+        """
+        self.__scriptName = os.path.abspath(fn)
+        
+        wd = self.translate(wd, False)
+        fn = self.translate(os.path.abspath(fn), False)
+        self.__sendJsonCommand("RequestRun", {
+            "workdir": wd,
+            "filename": fn,
+            "argv": Utilities.parseOptionString(argv),
+            "autofork": autoFork,
+            "forkChild": forkChild,
+        })
+    
+    def remoteCoverage(self, fn, argv, wd, erase=False):
+        """
+        Public method to load a new program to collect coverage data.
+        
+        @param fn the filename to run (string)
+        @param argv the commandline arguments to pass to the program (string)
+        @param wd the working directory for the program (string)
+        @keyparam erase flag indicating that coverage info should be
+            cleared first (boolean)
+        """
+        self.__scriptName = os.path.abspath(fn)
+        
+        wd = self.translate(wd, False)
+        fn = self.translate(os.path.abspath(fn), False)
+        self.__sendJsonCommand("RequestCoverage", {
+            "workdir": wd,
+            "filename": fn,
+            "argv": Utilities.parseOptionString(argv),
+            "erase": erase,
+        })
+
+    def remoteProfile(self, fn, argv, wd, erase=False):
+        """
+        Public method to load a new program to collect profiling data.
+        
+        @param fn the filename to run (string)
+        @param argv the commandline arguments to pass to the program (string)
+        @param wd the working directory for the program (string)
+        @keyparam erase flag indicating that timing info should be cleared
+            first (boolean)
+        """
+        self.__scriptName = os.path.abspath(fn)
+        
+        wd = self.translate(wd, False)
+        fn = self.translate(os.path.abspath(fn), False)
+        self.__sendJsonCommand("RequestProfile", {
+            "workdir": wd,
+            "filename": fn,
+            "argv": Utilities.parseOptionString(argv),
+            "erase": erase,
+        })
+
+    def remoteStatement(self, stmt):
+        """
+        Public method to execute a Python statement.
+        
+        @param stmt the Python statement to execute (string). It
+              should not have a trailing newline.
+        """
+        self.__sendJsonCommand("ExecuteStatement", {
+            "statement": stmt,
+        })
+
+    def remoteStep(self):
+        """
+        Public method to single step the debugged program.
+        """
+        self.__sendJsonCommand("RequestStep", {})
+
+    def remoteStepOver(self):
+        """
+        Public method to step over the debugged program.
+        """
+        self.__sendJsonCommand("RequestStepOver", {})
+
+    def remoteStepOut(self):
+        """
+        Public method to step out the debugged program.
+        """
+        self.__sendJsonCommand("RequestStepOut", {})
+
+    def remoteStepQuit(self):
+        """
+        Public method to stop the debugged program.
+        """
+        self.__sendJsonCommand("RequestStepQuit", {})
+
+    def remoteContinue(self, special=False):
+        """
+        Public method to continue the debugged program.
+        
+        @param special flag indicating a special continue operation
+        """
+        self.__sendJsonCommand("RequestContinue", {
+            "special": special,
+        })
+
+    def remoteMoveIP(self, line):
+        """
+        Public method to move the instruction pointer to a different line.
+        
+        @param line the new line, where execution should be continued
+        """
+        self.__sendJsonCommand("RequestMoveIP", {
+            "newLine": line,
+        })
+
+    def remoteBreakpoint(self, fn, line, setBreakpoint, cond=None, temp=False):
+        """
+        Public method to set or clear a breakpoint.
+        
+        @param fn filename the breakpoint belongs to (string)
+        @param line linenumber of the breakpoint (int)
+        @param setBreakpoint flag indicating setting or resetting a
+            breakpoint (boolean)
+        @param cond condition of the breakpoint (string)
+        @param temp flag indicating a temporary breakpoint (boolean)
+        """
+        self.__sendJsonCommand("RequestBreakpoint", {
+            "filename": self.translate(fn, False),
+            "line": line,
+            "temporary": temp,
+            "setBreakpoint": setBreakpoint,
+            "condition": cond,
+        })
+    
+    def remoteBreakpointEnable(self, fn, line, enable):
+        """
+        Public method to enable or disable a breakpoint.
+        
+        @param fn filename the breakpoint belongs to (string)
+        @param line linenumber of the breakpoint (int)
+        @param enable flag indicating enabling or disabling a breakpoint
+            (boolean)
+        """
+        self.__sendJsonCommand("RequestBreakpointEnable", {
+            "filename": self.translate(fn, False),
+            "line": line,
+            "enable": enable,
+        })
+    
+    def remoteBreakpointIgnore(self, fn, line, count):
+        """
+        Public method to ignore a breakpoint the next couple of occurrences.
+        
+        @param fn filename the breakpoint belongs to (string)
+        @param line linenumber of the breakpoint (int)
+        @param count number of occurrences to ignore (int)
+        """
+        self.__sendJsonCommand("RequestBreakpointIgnore", {
+            "filename": self.translate(fn, False),
+            "line": line,
+            "count": count,
+        })
+    
+    def remoteWatchpoint(self, cond, setWatch, temp=False):
+        """
+        Public method to set or clear a watch expression.
+        
+        @param cond expression of the watch expression (string)
+        @param setWatch flag indicating setting or resetting a watch expression
+            (boolean)
+        @param temp flag indicating a temporary watch expression (boolean)
+        """
+        # cond is combination of cond and special (s. watch expression viewer)
+        self.__sendJsonCommand("RequestWatch", {
+            "temporary": temp,
+            "setWatch": setWatch,
+            "condition": cond,
+        })
+    
+    def remoteWatchpointEnable(self, cond, enable):
+        """
+        Public method to enable or disable a watch expression.
+        
+        @param cond expression of the watch expression (string)
+        @param enable flag indicating enabling or disabling a watch expression
+            (boolean)
+        """
+        # cond is combination of cond and special (s. watch expression viewer)
+        self.__sendJsonCommand("RequestWatchEnable", {
+            "condition": cond,
+            "enable": enable,
+        })
+    
+    def remoteWatchpointIgnore(self, cond, count):
+        """
+        Public method to ignore a watch expression the next couple of
+        occurrences.
+        
+        @param cond expression of the watch expression (string)
+        @param count number of occurrences to ignore (int)
+        """
+        # cond is combination of cond and special (s. watch expression viewer)
+        self.__sendJsonCommand("RequestWatchIgnore", {
+            "condition": cond,
+            "count": count,
+        })
+    
+    def remoteRawInput(self, s):
+        """
+        Public method to send the raw input to the debugged program.
+        
+        @param s the raw input (string)
+        """
+        self.__sendJsonCommand("RawInput", {
+            "input": s,
+        })
+    
+    def remoteThreadList(self):
+        """
+        Public method to request the list of threads from the client.
+        """
+        self.__sendJsonCommand("RequestThreadList", {})
+        
+    def remoteSetThread(self, tid):
+        """
+        Public method to request to set the given thread as current thread.
+        
+        @param tid id of the thread (integer)
+        """
+        self.__sendJsonCommand("RequestThreadSet", {
+            "threadID": tid,
+        })
+        
+    def remoteClientVariables(self, scope, filterList, framenr=0):
+        """
+        Public method to request the variables of the debugged program.
+        
+        @param scope the scope of the variables (0 = local, 1 = global)
+        @param filterList list of variable types to filter out (list of int)
+        @param framenr framenumber of the variables to retrieve (int)
+        """
+        self.__sendJsonCommand("RequestVariables", {
+            "frameNumber": framenr,
+            "scope": scope,
+            "filters": filterList,
+        })
+    
+    def remoteClientVariable(self, scope, filterList, var, framenr=0):
+        """
+        Public method to request the variables of the debugged program.
+        
+        @param scope the scope of the variables (0 = local, 1 = global)
+        @param filterList list of variable types to filter out (list of int)
+        @param var list encoded name of variable to retrieve (string)
+        @param framenr framenumber of the variables to retrieve (int)
+        """
+        self.__sendJsonCommand("RequestVariable", {
+            "variable": var,
+            "frameNumber": framenr,
+            "scope": scope,
+            "filters": filterList,
+        })
+    
+    def remoteClientSetFilter(self, scope, filterStr):
+        """
+        Public method to set a variables filter list.
+        
+        @param scope the scope of the variables (0 = local, 1 = global)
+        @param filterStr regexp string for variable names to filter out
+            (string)
+        """
+        self.__sendJsonCommand("RequestSetFilter", {
+            "scope": scope,
+            "filter": filterStr,
+        })
+    
+    def setCallTraceEnabled(self, on):
+        """
+        Public method to set the call trace state.
+        
+        @param on flag indicating to enable the call trace function (boolean)
+        """
+        self.__sendJsonCommand("RequestCallTrace", {
+            "enable": on,
+        })
+    
+    def remoteBanner(self):
+        """
+        Public slot to get the banner info of the remote client.
+        """
+        self.__sendJsonCommand("RequestBanner", {})
+    
+    def remoteCapabilities(self):
+        """
+        Public slot to get the debug clients capabilities.
+        """
+        self.__sendJsonCommand("RequestCapabilities", {})
+    
+    def remoteCompletion(self, text):
+        """
+        Public slot to get the a list of possible commandline completions
+        from the remote client.
+        
+        @param text the text to be completed (string)
+        """
+        self.__sendJsonCommand("RequestCompletion", {
+            "text": text,
+        })
+    
+    def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase):
+        """
+        Public method to prepare a new unittest run.
+        
+        @param fn the filename to load (string)
+        @param tn the testname to load (string)
+        @param tfn the test function name to load tests from (string)
+        @param failed list of failed test, if only failed test should be run
+            (list of strings)
+        @param cov flag indicating collection of coverage data is requested
+            (boolean)
+        @param covname filename to be used to assemble the coverage caches
+            filename (string)
+        @param coverase flag indicating erasure of coverage data is requested
+            (boolean)
+        """
+        self.__scriptName = os.path.abspath(fn)
+        
+        fn = self.translate(os.path.abspath(fn), False)
+        self.__sendJsonCommand("RequestUTPrepare", {
+            "filename": fn,
+            "testname": tn,
+            "testfunctionname": tfn,
+            "failed": failed,
+            "coverage": cov,
+            "coveragefile": covname,
+            "coverageerase": coverase,
+        })
+    
+    def remoteUTRun(self):
+        """
+        Public method to start a unittest run.
+        """
+        self.__sendJsonCommand("RequestUTRun", {})
+    
+    def remoteUTStop(self):
+        """
+        Public method to stop a unittest run.
+        """
+        self.__sendJsonCommand("RequestUTStop", {})
+    
+    def __askForkTo(self):
+        """
+        Private method to ask the user which branch of a fork to follow.
+        """
+        selections = [self.tr("Parent Process"),
+                      self.tr("Child process")]
+        res, ok = QInputDialog.getItem(
+            None,
+            self.tr("Client forking"),
+            self.tr("Select the fork branch to follow."),
+            selections,
+            0, False)
+        if not ok or res == selections[0]:
+            self.__sendJsonCommand("ResponseForkTo", {
+                "target": "parent",
+            })
+        else:
+            self.__sendJsonCommand("ResponseForkTo", {
+                "target": "child",
+            })
+    
+    def __parseClientLine(self):
+        """
+        Private method to handle data from the client.
+        """
+        while self.qsock and self.qsock.canReadLine():
+            qs = self.qsock.readLine()
+            if self.codec is not None:
+                line = self.codec.toUnicode(qs)
+            else:
+                line = bytes(qs).decode()
+            
+##            print("Server: ", line)          ##debug
+            
+            self.__handleJsonCommand(line)
+            continue
+    
+    def __handleJsonCommand(self, jsonStr):
+        """
+        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
+        """
+        import json
+        
+        try:
+            commandDict = json.loads(jsonStr.strip())
+        except (TypeError, ValueError) as err:
+            E5MessageBox.critical(
+                None,
+                self.tr("Debug Protocol Error"),
+                self.tr("""<p>The response received from the debugger"""
+                        """ backend could not be decoded. Please report"""
+                        """ this issue with the received data to the"""
+                        """ eric bugs email address.</p>"""
+                        """<p>Error: {0}</p>"""
+                        """<p>Data:<br/>{0}</p>""").format(
+                    str(err), Utilities.html_encode(jsonStr.strip())),
+                E5MessageBox.StandardButtons(
+                    E5MessageBox.Ok))
+            return
+        
+        method = commandDict["method"]
+        params = commandDict["params"]
+        
+        if method == "ClientOutput":
+            self.debugServer.signalClientOutput(params["text"])
+        
+        elif method in ["ResponseLine", "ResponseStack"]:
+            # Check if obsolet thread was clicked
+            if params["stack"] == []:
+                # Request updated list
+                self.remoteThreadList()
+                return
+            for s in params["stack"]:
+                s[0] = self.translate(s[0], True)
+            cf = params["stack"][0]
+            if self.__autoContinue:
+                self.__autoContinue = False
+                QTimer.singleShot(0, self.remoteContinue)
+            else:
+                self.debugServer.signalClientLine(
+                    cf[0], int(cf[1]),
+                    method == "ResponseStack")
+                self.debugServer.signalClientStack(params["stack"])
+        
+        elif method == "CallTrace":
+            isCall = params["event"].lower() == "c"
+            fromInfo = params["from"]
+            toInfo = params["to"]
+            self.debugServer.signalClientCallTrace(
+                isCall,
+                fromInfo["filename"], str(fromInfo["linenumber"]),
+                fromInfo["codename"],
+                toInfo["filename"], str(toInfo["linenumber"]),
+                toInfo["codename"])
+        
+        elif method == "ResponseVariables":
+            self.debugServer.signalClientVariables(
+                params["scope"], params["variables"])
+        
+        elif method == "ResponseVariable":
+            self.debugServer.signalClientVariable(
+                params["scope"], [params["variable"]] + params["variables"])
+        
+        elif method == "ResponseThreadList":
+            self.debugServer.signalClientThreadList(
+                params["currentID"], params["threadList"])
+        
+        elif method == "ResponseThreadSet":
+            self.debugServer.signalClientThreadSet()
+        
+        elif method == "ResponseCapabilities":
+            self.clientCapabilities = params["capabilities"]
+            self.debugServer.signalClientCapabilities(
+                params["capabilities"], params["clientType"])
+        
+        elif method == "ResponseBanner":
+            self.debugServer.signalClientBanner(
+                params["version"],
+                params["platform"],
+                params["dbgclient"])
+        
+        elif method == "ResponseOK":
+            self.debugServer.signalClientStatement(False)
+        
+        elif method == "ResponseContinue":
+            self.debugServer.signalClientStatement(True)
+        
+        elif method == "RequestRaw":
+            self.debugServer.signalClientRawInput(
+                params["prompt"], params["echo"])
+        
+        elif method == "ResponseBPConditionError":
+            fn = self.translate(params["filename"], True)
+            self.debugServer.signalClientBreakConditionError(
+                fn, params["line"])
+        
+        elif method == "ResponseClearBreakpoint":
+            fn = self.translate(params["filename"], True)
+            self.debugServer.signalClientClearBreak(fn, params["line"])
+        
+        elif method == "ResponseWatchConditionError":
+            self.debugServer.signalClientWatchConditionError(
+                params["condition"])
+        
+        elif method == "ResponseClearWatch":
+            self.debugServer.signalClientClearWatch(params["condition"])
+        
+        elif method == "ResponseException":
+            if params:
+                exctype = params["type"]
+                excmessage = params["message"]
+                stack = params["stack"]
+                if stack:
+                    for stackEntry in stack:
+                        stackEntry[0] = self.translate(stackEntry[0], True)
+                    if stack[0] and stack[0][0] == "<string>":
+                        for stackEntry in stack:
+                            if stackEntry[0] == "<string>":
+                                stackEntry[0] = self.__scriptName
+                            else:
+                                break
+            else:
+                exctype = ''
+                excmessage = ''
+                stack = []
+            
+            self.debugServer.signalClientException(
+                exctype, excmessage, stack)
+        
+        elif method == "ResponseSyntax":
+            self.debugServer.signalClientSyntaxError(
+                params["message"], self.translate(params["filename"], True),
+                params["linenumber"], params["characternumber"])
+        
+        elif method == "ResponseSignal":
+            self.debugServer.signalClientSignal(
+                params["message"], self.translate(params["filename"], True),
+                params["linenumber"], params["function"], params["arguments"])
+        
+        elif method == "ResponseExit":
+            self.__scriptName = ""
+            self.debugServer.signalClientExit(
+                params["status"], params["message"])
+        
+        elif method == "PassiveStartup":
+            self.debugServer.passiveStartUp(
+                self.translate(params["filename"], True), params["exceptions"])
+        
+        elif method == "ResponseCompletion":
+            self.debugServer.signalClientCompletionList(
+                params["completions"], params["text"])
+        
+        elif method == "ResponseUTPrepared":
+            self.debugServer.clientUtPrepared(
+                params["count"], params["exception"], params["message"])
+        
+        elif method == "ResponseUTFinished":
+            self.debugServer.clientUtFinished()
+        
+        elif method == "ResponseUTStartTest":
+            self.debugServer.clientUtStartTest(
+                params["testname"], params["description"])
+        
+        elif method == "ResponseUTStopTest":
+            self.debugServer.clientUtStopTest()
+        
+        elif method == "ResponseUTTestFailed":
+            self.debugServer.clientUtTestFailed(
+                params["testname"], params["traceback"], params["id"])
+        
+        elif method == "ResponseUTTestErrored":
+            self.debugServer.clientUtTestErrored(
+                params["testname"], params["traceback"], params["id"])
+        
+        elif method == "ResponseUTTestSkipped":
+            self.debugServer.clientUtTestSkipped(
+                params["testname"], params["reason"], params["id"])
+        
+        elif method == "ResponseUTTestFailedExpected":
+            self.debugServer.clientUtTestFailedExpected(
+                params["testname"], params["traceback"], params["id"])
+        
+        elif method == "ResponseUTTestSucceededUnexpected":
+            self.debugServer.clientUtTestSucceededUnexpected(
+                params["testname"], params["id"])
+        
+        elif method == "RequestForkTo":
+            self.__askForkTo()
+    
+    def __sendJsonCommand(self, command, params):
+        """
+        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
+        """
+        import json
+        
+        commandDict = {
+            "jsonrpc": "2.0",
+            "method": command,
+            "params": params,
+        }
+        cmd = json.dumps(commandDict) + '\n'
+        if self.qsock is not None:
+            self.qsock.write(cmd.encode('utf8', 'backslashreplace'))
+        else:
+            self.queue.append(cmd)
+
+
+def createDebuggerInterfacePython2(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
+    @rtype DebuggerInterfacePython
+    """
+    return DebuggerInterfacePython(debugServer, passive, "Python2")
+    
+
+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
+    @rtype DebuggerInterfacePython
+    """
+    return DebuggerInterfacePython(debugServer, passive, "Python3")
+
+
+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)
+    """
+    py2Exts = []
+    for ext in Preferences.getDebugger("PythonExtensions").split():
+        if ext.startswith("."):
+            py2Exts.append(ext)
+        else:
+            py2Exts.append(".{0}".format(ext))
+    
+    py3Exts = []
+    for ext in Preferences.getDebugger("Python3Extensions").split():
+        if ext.startswith("."):
+            py3Exts.append(ext)
+        else:
+            py3Exts.append(".{0}".format(ext))
+    
+    registryData = []
+    if py2Exts and Preferences.getDebugger("PythonInterpreter"):
+        registryData.append(
+            ("Python2", ClientDefaultCapabilities, py2Exts,
+             createDebuggerInterfacePython2)
+        )
+    
+    if py3Exts and Preferences.getDebugger("Python3Interpreter"):
+        registryData.append(
+            ("Python3", ClientDefaultCapabilities, py3Exts,
+                createDebuggerInterfacePython3)
+        )
+    
+    return registryData

--- a/Debugger/DebuggerInterfacePython2.py	Thu Aug 03 14:50:59 2017 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1102 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2007 - 2017 Detlev Offenbach <detlev@die-offenbachs.de>
-#
-
-"""
-Module implementing the Python debugger interface for the debug server.
-"""
-
-from __future__ import unicode_literals
-
-import sys
-import os
-
-from PyQt5.QtCore import QObject, QTextCodec, QProcess, QProcessEnvironment, \
-    QTimer
-from PyQt5.QtWidgets import QInputDialog
-
-from E5Gui.E5Application import e5App
-from E5Gui import E5MessageBox
-
-from . import DebugClientCapabilities
-
-import Preferences
-import Utilities
-
-from eric6config import getConfig
-
-
-ClientDefaultCapabilities = DebugClientCapabilities.HasAll
-
-
-class DebuggerInterfacePython2(QObject):
-    """
-    Class implementing the Python 2 debugger interface for the debug server.
-    """
-    def __init__(self, debugServer, passive):
-        """
-        Constructor
-        
-        @param debugServer reference to the debug server (DebugServer)
-        @param passive flag indicating passive connection mode (boolean)
-        """
-        super(DebuggerInterfacePython2, self).__init__()
-        
-        self.__isNetworked = True
-        self.__autoContinue = False
-        
-        self.debugServer = debugServer
-        self.passive = passive
-        self.process = None
-        
-        self.qsock = None
-        self.queue = []
-        
-        # set default values for capabilities of clients
-        self.clientCapabilities = ClientDefaultCapabilities
-        
-        # set translation function
-        self.translate = self.__identityTranslation
-        
-        self.codec = QTextCodec.codecForName(
-            Preferences.getSystem("StringEncoding"))
-        
-        if passive:
-            # set translation function
-            if Preferences.getDebugger("PathTranslation"):
-                self.translateRemote = \
-                    Preferences.getDebugger("PathTranslationRemote")
-                self.translateLocal = \
-                    Preferences.getDebugger("PathTranslationLocal")
-                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 (string)
-        @param remote2local flag indicating the direction of translation
-            (False = local to remote, True = remote to local [default])
-        @return translated filename (string)
-        """
-        return fn
-        
-    def __remoteTranslation(self, fn, remote2local=True):
-        """
-        Private method to perform the path translation.
-        
-        @param fn filename to be translated (string)
-        @param remote2local flag indicating the direction of translation
-            (False = local to remote, True = remote to local [default])
-        @return translated filename (string)
-        """
-        if remote2local:
-            return fn.replace(self.translateRemote, self.translateLocal)
-        else:
-            return fn.replace(self.translateLocal, self.translateRemote)
-        
-    def __startProcess(self, program, arguments, environment=None):
-        """
-        Private method to start the debugger client process.
-        
-        @param program name of the executable to start (string)
-        @param arguments arguments to be passed to the program (list of string)
-        @param environment dictionary of environment settings to pass
-            (dict of string)
-        @return the process object (QProcess) or None
-        """
-        proc = QProcess()
-        if environment is not None:
-            env = QProcessEnvironment()
-            for key, value in list(environment.items()):
-                env.insert(key, value)
-            proc.setProcessEnvironment(env)
-        args = []
-        for arg in arguments:
-            args.append(arg)
-        proc.start(program, args)
-        if not proc.waitForStarted(10000):
-            proc = None
-        
-        return proc
-        
-    def startRemote(self, port, runInConsole):
-        """
-        Public method to start a remote Python interpreter.
-        
-        @param port portnumber the debug server is listening on (integer)
-        @param runInConsole flag indicating to start the debugger in a
-            console window (boolean)
-        @return client process object (QProcess), a flag to indicate
-            a network connection (boolean) and the name of the interpreter
-            in case of a local execution (string)
-        """
-        interpreter = Preferences.getDebugger("PythonInterpreter")
-        if interpreter == "":
-            E5MessageBox.critical(
-                None,
-                self.tr("Start Debugger"),
-                self.tr(
-                    """<p>No Python2 interpreter configured.</p>"""))
-            return None, False, ""
-        
-        debugClientType = Preferences.getDebugger("DebugClientType")
-        if debugClientType == "standard":
-            debugClient = os.path.join(getConfig('ericDir'),
-                                       "DebugClients", "Python",
-                                       "DebugClient.py")
-        else:
-            debugClient = Preferences.getDebugger("DebugClient")
-            if debugClient == "":
-                debugClient = os.path.join(sys.path[0],
-                                           "DebugClients", "Python",
-                                           "DebugClient.py")
-        
-        redirect = str(Preferences.getDebugger("PythonRedirect"))
-        noencoding = Preferences.getDebugger("PythonNoEncoding") and \
-            '--no-encoding' or ''
-        
-        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,
-                        noencoding, str(port), redirect, ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:])
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                
-                # set translation function
-                if Preferences.getDebugger("PathTranslation"):
-                    self.translateRemote = \
-                        Preferences.getDebugger("PathTranslationRemote")
-                    self.translateLocal = \
-                        Preferences.getDebugger("PathTranslationLocal")
-                    self.translate = self.__remoteTranslation
-                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()
-        envlist = Utilities.parseEnvironmentString(
-            Preferences.getDebugger("DebugEnvironment"))
-        for el in envlist:
-            try:
-                key, value = el.split('=', 1)
-                if value.startswith('"') or value.startswith("'"):
-                    value = value[1:-1]
-                clientEnv[str(key)] = str(value)
-            except ValueError:
-                pass
-        
-        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),
-                        noencoding, str(port), '0', ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:], clientEnv)
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                return process, self.__isNetworked, interpreter
-        
-        process = self.__startProcess(
-            interpreter,
-            [debugClient, noencoding, str(port), redirect, ipaddr],
-            clientEnv)
-        if process is None:
-            E5MessageBox.critical(
-                None,
-                self.tr("Start Debugger"),
-                self.tr(
-                    """<p>The debugger backend could not be started.</p>"""))
-        return process, self.__isNetworked, interpreter
-
-    def startRemoteForProject(self, port, runInConsole):
-        """
-        Public method to start a remote Python interpreter for a project.
-        
-        @param port portnumber the debug server is listening on (integer)
-        @param runInConsole flag indicating to start the debugger in a
-            console window (boolean)
-        @return client process object (QProcess), a flag to indicate
-            a network connection (boolean) and the name of the interpreter
-            in case of a local execution (string)
-        """
-        project = e5App().getObject("Project")
-        if not project.isDebugPropertiesLoaded():
-            return None, self.__isNetworked, ""
-        
-        # start debugger with project specific settings
-        interpreter = project.getDebugProperty("INTERPRETER")
-        debugClient = project.getDebugProperty("DEBUGCLIENT")
-        
-        redirect = str(project.getDebugProperty("REDIRECT"))
-        noencoding = \
-            project.getDebugProperty("NOENCODING") and '--no-encoding' or ''
-        
-        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, os.path.abspath(debugClient),
-                        noencoding, str(port), redirect, ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:])
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                # set translation function
-                if project.getDebugProperty("PATHTRANSLATION"):
-                    self.translateRemote = \
-                        project.getDebugProperty("REMOTEPATH")
-                    self.translateLocal = \
-                        project.getDebugProperty("LOCALPATH")
-                    self.translate = self.__remoteTranslation
-                else:
-                    self.translate = self.__identityTranslation
-                return process, 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()
-        envlist = Utilities.parseEnvironmentString(
-            project.getDebugProperty("ENVIRONMENTSTRING"))
-        for el in envlist:
-            try:
-                key, value = el.split('=', 1)
-                if value.startswith('"') or value.startswith("'"):
-                    value = value[1:-1]
-                clientEnv[str(key)] = str(value)
-            except ValueError:
-                pass
-        
-        ipaddr = self.debugServer.getHostAddress(True)
-        if runInConsole or project.getDebugProperty("CONSOLEDEBUGGER"):
-            ccmd = project.getDebugProperty("CONSOLECOMMAND") or \
-                Preferences.getDebugger("ConsoleDbgCommand")
-            if ccmd:
-                args = Utilities.parseOptionString(ccmd) + \
-                    [interpreter, os.path.abspath(debugClient),
-                        noencoding, str(port), '0', ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:], clientEnv)
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                return process, self.__isNetworked, interpreter
-        
-        process = self.__startProcess(
-            interpreter,
-            [debugClient, noencoding, str(port), redirect, ipaddr],
-            clientEnv)
-        if process is None:
-            E5MessageBox.critical(
-                None,
-                self.tr("Start Debugger"),
-                self.tr(
-                    """<p>The debugger backend could not be started.</p>"""))
-        return process, self.__isNetworked, interpreter
-
-    def getClientCapabilities(self):
-        """
-        Public method to retrieve the debug clients capabilities.
-        
-        @return debug client capabilities (integer)
-        """
-        return self.clientCapabilities
-        
-    def newConnection(self, sock):
-        """
-        Public slot to handle a new connection.
-        
-        @param sock reference to the socket object (QTcpSocket)
-        @return flag indicating success (boolean)
-        """
-        # If we already have a connection, refuse this one.  It will be closed
-        # automatically.
-        if self.qsock is not None:
-            return False
-        
-        sock.disconnected.connect(self.debugServer.startClient)
-        sock.readyRead.connect(self.__parseClientLine)
-        
-        self.qsock = sock
-        
-        # Get the remote clients capabilities
-        self.remoteCapabilities()
-        return True
-        
-    def flush(self):
-        """
-        Public slot to flush the queue.
-        """
-        # Send commands that were waiting for the connection.
-        for cmd in self.queue:
-            self.qsock.write(cmd.encode('utf8', 'backslashreplace'))
-        
-        self.queue = []
-        
-    def shutdown(self):
-        """
-        Public method to cleanly shut down.
-        
-        It closes our socket and shuts down
-        the debug client. (Needed on Win OS)
-        """
-        if self.qsock is None:
-            return
-        
-        # do not want any slots called during shutdown
-        self.qsock.disconnected.disconnect(self.debugServer.startClient)
-        self.qsock.readyRead.disconnect(self.__parseClientLine)
-        
-        # close down socket, and shut down client as well.
-        self.__sendJsonCommand("RequestShutdown", {})
-        self.qsock.flush()
-        self.qsock.close()
-        
-        # reinitialize
-        self.qsock = None
-        self.queue = []
-        
-    def isConnected(self):
-        """
-        Public method to test, if a debug client has connected.
-        
-        @return flag indicating the connection status (boolean)
-        """
-        return self.qsock is not None
-        
-    def remoteEnvironment(self, env):
-        """
-        Public method to set the environment for a program to debug, run, ...
-        
-        @param env environment settings (dictionary)
-        """
-        self.__sendJsonCommand("RequestEnvironment", {"environment": env})
-        
-    def remoteLoad(self, fn, argv, wd, traceInterpreter=False,
-                   autoContinue=True, autoFork=False, forkChild=False):
-        """
-        Public method to load a new program to debug.
-        
-        @param fn the filename to debug (string)
-        @param argv the commandline arguments to pass to the program (string)
-        @param wd the working directory for the program (string)
-        @keyparam traceInterpreter flag indicating if the interpreter library
-            should be traced as well (boolean)
-        @keyparam autoContinue flag indicating, that the debugger should not
-            stop at the first executable line (boolean)
-        @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking
-            (boolean)
-        """
-        self.__autoContinue = autoContinue
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestLoad", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "traceInterpreter": traceInterpreter,
-            "autofork": autoFork,
-            "forkChild": forkChild,
-        })
-        
-    def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
-        """
-        Public method to load a new program to run.
-        
-        @param fn the filename to run (string)
-        @param argv the commandline arguments to pass to the program (string)
-        @param wd the working directory for the program (string)
-        @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking
-            (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestRun", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "autofork": autoFork,
-            "forkChild": forkChild,
-        })
-        
-    def remoteCoverage(self, fn, argv, wd, erase=False):
-        """
-        Public method to load a new program to collect coverage data.
-        
-        @param fn the filename to run (string)
-        @param argv the commandline arguments to pass to the program (string)
-        @param wd the working directory for the program (string)
-        @keyparam erase flag indicating that coverage info should be
-            cleared first (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestCoverage", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "erase": erase,
-        })
-
-    def remoteProfile(self, fn, argv, wd, erase=False):
-        """
-        Public method to load a new program to collect profiling data.
-        
-        @param fn the filename to run (string)
-        @param argv the commandline arguments to pass to the program (string)
-        @param wd the working directory for the program (string)
-        @keyparam erase flag indicating that timing info should be cleared
-            first (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestProfile", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "erase": erase,
-        })
-
-    def remoteStatement(self, stmt):
-        """
-        Public method to execute a Python statement.
-        
-        @param stmt the Python statement to execute (string). It
-              should not have a trailing newline.
-        """
-        self.__sendJsonCommand("ExecuteStatement", {
-            "statement": stmt,
-        })
-
-    def remoteStep(self):
-        """
-        Public method to single step the debugged program.
-        """
-        self.__sendJsonCommand("RequestStep", {})
-
-    def remoteStepOver(self):
-        """
-        Public method to step over the debugged program.
-        """
-        self.__sendJsonCommand("RequestStepOver", {})
-
-    def remoteStepOut(self):
-        """
-        Public method to step out the debugged program.
-        """
-        self.__sendJsonCommand("RequestStepOut", {})
-
-    def remoteStepQuit(self):
-        """
-        Public method to stop the debugged program.
-        """
-        self.__sendJsonCommand("RequestStepQuit", {})
-
-    def remoteContinue(self, special=False):
-        """
-        Public method to continue the debugged program.
-        
-        @param special flag indicating a special continue operation (boolean)
-        """
-        self.__sendJsonCommand("RequestContinue", {
-            "special": special,
-        })
-
-    def remoteMoveIP(self, line):
-        """
-        Public method to move the instruction pointer to a different line.
-        
-        @param line the new line, where execution should be continued
-        """
-        self.__sendJsonCommand("RequestMoveIP", {
-            "newLine": line,
-        })
-
-    def remoteBreakpoint(self, fn, line, setBreakpoint, cond=None, temp=False):
-        """
-        Public method to set or clear a breakpoint.
-        
-        @param fn filename the breakpoint belongs to (string)
-        @param line linenumber of the breakpoint (int)
-        @param setBreakpoint flag indicating setting or resetting a
-            breakpoint (boolean)
-        @param cond condition of the breakpoint (string)
-        @param temp flag indicating a temporary breakpoint (boolean)
-        """
-        self.__sendJsonCommand("RequestBreakpoint", {
-            "filename": self.translate(fn, False),
-            "line": line,
-            "temporary": temp,
-            "setBreakpoint": setBreakpoint,
-            "condition": cond,
-        })
-        
-    def remoteBreakpointEnable(self, fn, line, enable):
-        """
-        Public method to enable or disable a breakpoint.
-        
-        @param fn filename the breakpoint belongs to (string)
-        @param line linenumber of the breakpoint (int)
-        @param enable flag indicating enabling or disabling a breakpoint
-            (boolean)
-        """
-        self.__sendJsonCommand("RequestBreakpointEnable", {
-            "filename": self.translate(fn, False),
-            "line": line,
-            "enable": enable,
-        })
-        
-    def remoteBreakpointIgnore(self, fn, line, count):
-        """
-        Public method to ignore a breakpoint the next couple of occurrences.
-        
-        @param fn filename the breakpoint belongs to (string)
-        @param line linenumber of the breakpoint (int)
-        @param count number of occurrences to ignore (int)
-        """
-        self.__sendJsonCommand("RequestBreakpointIgnore", {
-            "filename": self.translate(fn, False),
-            "line": line,
-            "count": count,
-        })
-        
-    def remoteWatchpoint(self, cond, setWatch, temp=False):
-        """
-        Public method to set or clear a watch expression.
-        
-        @param cond expression of the watch expression (string)
-        @param setWatch flag indicating setting or resetting a watch expression
-            (boolean)
-        @param temp flag indicating a temporary watch expression (boolean)
-        """
-        # cond is combination of cond and special (s. watch expression viewer)
-        self.__sendJsonCommand("RequestWatch", {
-            "temporary": temp,
-            "setWatch": setWatch,
-            "condition": cond,
-        })
-    
-    def remoteWatchpointEnable(self, cond, enable):
-        """
-        Public method to enable or disable a watch expression.
-        
-        @param cond expression of the watch expression (string)
-        @param enable flag indicating enabling or disabling a watch expression
-            (boolean)
-        """
-        # cond is combination of cond and special (s. watch expression viewer)
-        self.__sendJsonCommand("RequestWatchEnable", {
-            "condition": cond,
-            "enable": enable,
-        })
-    
-    def remoteWatchpointIgnore(self, cond, count):
-        """
-        Public method to ignore a watch expression the next couple of
-        occurrences.
-        
-        @param cond expression of the watch expression (string)
-        @param count number of occurrences to ignore (int)
-        """
-        # cond is combination of cond and special (s. watch expression viewer)
-        self.__sendJsonCommand("RequestWatchIgnore", {
-            "condition": cond,
-            "count": count,
-        })
-    
-    def remoteRawInput(self, s):
-        """
-        Public method to send the raw input to the debugged program.
-        
-        @param s the raw input (string)
-        """
-        self.__sendJsonCommand("RawInput", {
-            "input": s,
-        })
-        
-    def remoteThreadList(self):
-        """
-        Public method to request the list of threads from the client.
-        """
-        self.__sendJsonCommand("RequestThreadList", {})
-        
-    def remoteSetThread(self, tid):
-        """
-        Public method to request to set the given thread as current thread.
-        
-        @param tid id of the thread (integer)
-        """
-        self.__sendJsonCommand("RequestThreadSet", {
-            "threadID": tid,
-        })
-        
-    def remoteClientVariables(self, scope, filterList, framenr=0):
-        """
-        Public method to request the variables of the debugged program.
-        
-        @param scope the scope of the variables (0 = local, 1 = global)
-        @param filterList list of variable types to filter out (list of int)
-        @param framenr framenumber of the variables to retrieve (int)
-        """
-        self.__sendJsonCommand("RequestVariables", {
-            "frameNumber": framenr,
-            "scope": scope,
-            "filters": filterList,
-        })
-        
-    def remoteClientVariable(self, scope, filterList, var, framenr=0):
-        """
-        Public method to request the variables of the debugged program.
-        
-        @param scope the scope of the variables (0 = local, 1 = global)
-        @param filterList list of variable types to filter out (list of int)
-        @param var list encoded name of variable to retrieve (string)
-        @param framenr framenumber of the variables to retrieve (int)
-        """
-        self.__sendJsonCommand("RequestVariable", {
-            "variable": var,
-            "frameNumber": framenr,
-            "scope": scope,
-            "filters": filterList,
-        })
-        
-    def remoteClientSetFilter(self, scope, filterStr):
-        """
-        Public method to set a variables filter list.
-        
-        @param scope the scope of the variables (0 = local, 1 = global)
-        @param filterStr regexp string for variable names to filter out
-            (string)
-        """
-        self.__sendJsonCommand("RequestSetFilter", {
-            "scope": scope,
-            "filter": filterStr,
-        })
-        
-    def setCallTraceEnabled(self, on):
-        """
-        Public method to set the call trace state.
-        
-        @param on flag indicating to enable the call trace function (boolean)
-        """
-        self.__sendJsonCommand("RequestCallTrace", {
-            "enable": on,
-        })
-    
-    def remoteBanner(self):
-        """
-        Public slot to get the banner info of the remote client.
-        """
-        self.__sendJsonCommand("RequestBanner", {})
-        
-    def remoteCapabilities(self):
-        """
-        Public slot to get the debug clients capabilities.
-        """
-        self.__sendJsonCommand("RequestCapabilities", {})
-        
-    def remoteCompletion(self, text):
-        """
-        Public slot to get the a list of possible commandline completions
-        from the remote client.
-        
-        @param text the text to be completed (string)
-        """
-        self.__sendJsonCommand("RequestCompletion", {
-            "text": text,
-        })
-        
-    def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase):
-        """
-        Public method to prepare a new unittest run.
-        
-        @param fn the filename to load (string)
-        @param tn the testname to load (string)
-        @param tfn the test function name to load tests from (string)
-        @param failed list of failed test, if only failed test should be run
-            (list of strings)
-        @param cov flag indicating collection of coverage data is requested
-            (boolean)
-        @param covname filename to be used to assemble the coverage caches
-            filename (string)
-        @param coverase flag indicating erasure of coverage data is requested
-            (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestUTPrepare", {
-            "filename": fn,
-            "testname": tn,
-            "testfunctionname": tfn,
-            "failed": failed,
-            "coverage": cov,
-            "coveragefile": covname,
-            "coverageerase": coverase,
-        })
-        
-    def remoteUTRun(self):
-        """
-        Public method to start a unittest run.
-        """
-        self.__sendJsonCommand("RequestUTRun", {})
-        
-    def remoteUTStop(self):
-        """
-        Public method to stop a unittest run.
-        """
-        self.__sendJsonCommand("RequestUTStop", {})
-        
-    def __askForkTo(self):
-        """
-        Private method to ask the user which branch of a fork to follow.
-        """
-        selections = [self.tr("Parent Process"),
-                      self.tr("Child process")]
-        res, ok = QInputDialog.getItem(
-            None,
-            self.tr("Client forking"),
-            self.tr("Select the fork branch to follow."),
-            selections,
-            0, False)
-        if not ok or res == selections[0]:
-            self.__sendJsonCommand("ResponseForkTo", {
-                "target": "parent",
-            })
-        else:
-            self.__sendJsonCommand("ResponseForkTo", {
-                "target": "child",
-            })
-        
-    def __parseClientLine(self):
-        """
-        Private method to handle data from the client.
-        """
-        while self.qsock and self.qsock.canReadLine():
-            qs = self.qsock.readLine()
-            if self.codec is not None:
-                line = self.codec.toUnicode(qs)
-            else:
-                line = bytes(qs).decode()
-            
-##            print("Server: ", line)          ##debug
-            
-            self.__handleJsonCommand(line)
-            continue
-    
-    def __handleJsonCommand(self, jsonStr):
-        """
-        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
-        """
-        import json
-        
-        try:
-            commandDict = json.loads(jsonStr.strip())
-        except (TypeError, ValueError) as err:
-            E5MessageBox.critical(
-                None,
-                self.tr("Debug Protocol Error"),
-                self.tr("""<p>The response received from the debugger"""
-                        """ backend could not be decoded. Please report"""
-                        """ this issue with the received data to the"""
-                        """ eric bugs email address.</p>"""
-                        """<p>Error: {0}</p>"""
-                        """<p>Data:<br/>{0}</p>""").format(
-                    str(err), Utilities.html_encode(jsonStr.strip())),
-                E5MessageBox.StandardButtons(
-                    E5MessageBox.Ok))
-            return
-        
-        method = commandDict["method"]
-        params = commandDict["params"]
-        
-        if method == "ClientOutput":
-            self.debugServer.signalClientOutput(params["text"])
-        
-        elif method in ["ResponseLine", "ResponseStack"]:
-            # Check if obsolet thread was clicked
-            if params["stack"] == []:
-                # Request updated list
-                self.remoteThreadList()
-                return
-            for s in params["stack"]:
-                s[0] = self.translate(s[0], True)
-            cf = params["stack"][0]
-            if self.__autoContinue:
-                self.__autoContinue = False
-                QTimer.singleShot(0, self.remoteContinue)
-            else:
-                self.debugServer.signalClientLine(
-                    cf[0], int(cf[1]),
-                    method == "ResponseStack")
-                self.debugServer.signalClientStack(params["stack"])
-        
-        elif method == "CallTrace":
-            isCall = params["event"].lower() == "c"
-            fromInfo = params["from"]
-            toInfo = params["to"]
-            self.debugServer.signalClientCallTrace(
-                isCall,
-                fromInfo["filename"], str(fromInfo["linenumber"]),
-                fromInfo["codename"],
-                toInfo["filename"], str(toInfo["linenumber"]),
-                toInfo["codename"])
-        
-        elif method == "ResponseVariables":
-            self.debugServer.signalClientVariables(
-                params["scope"], params["variables"])
-        
-        elif method == "ResponseVariable":
-            self.debugServer.signalClientVariable(
-                params["scope"], [params["variable"]] + params["variables"])
-        
-        elif method == "ResponseThreadList":
-            self.debugServer.signalClientThreadList(
-                params["currentID"], params["threadList"])
-        
-        elif method == "ResponseThreadSet":
-            self.debugServer.signalClientThreadSet()
-        
-        elif method == "ResponseCapabilities":
-            self.clientCapabilities = params["capabilities"]
-            self.debugServer.signalClientCapabilities(
-                params["capabilities"], params["clientType"])
-        
-        elif method == "ResponseBanner":
-            self.debugServer.signalClientBanner(
-                params["version"],
-                params["platform"],
-                params["dbgclient"])
-        
-        elif method == "ResponseOK":
-            self.debugServer.signalClientStatement(False)
-        
-        elif method == "ResponseContinue":
-            self.debugServer.signalClientStatement(True)
-        
-        elif method == "RequestRaw":
-            self.debugServer.signalClientRawInput(
-                params["prompt"], params["echo"])
-        
-        elif method == "ResponseBPConditionError":
-            fn = self.translate(params["filename"], True)
-            self.debugServer.signalClientBreakConditionError(
-                fn, params["line"])
-        
-        elif method == "ResponseClearBreakpoint":
-            fn = self.translate(params["filename"], True)
-            self.debugServer.signalClientClearBreak(fn, params["line"])
-        
-        elif method == "ResponseWatchConditionError":
-            self.debugServer.signalClientWatchConditionError(
-                params["condition"])
-        
-        elif method == "ResponseClearWatch":
-            self.debugServer.signalClientClearWatch(params["condition"])
-        
-        elif method == "ResponseException":
-            if params:
-                exctype = params["type"]
-                excmessage = params["message"]
-                stack = params["stack"]
-                if stack:
-                    for stackEntry in stack:
-                        stackEntry[0] = self.translate(stackEntry[0], True)
-                    if stack[0] and stack[0][0] == "<string>":
-                        for stackEntry in stack:
-                            if stackEntry[0] == "<string>":
-                                stackEntry[0] = self.__scriptName
-                            else:
-                                break
-            else:
-                exctype = ''
-                excmessage = ''
-                stack = []
-            
-            self.debugServer.signalClientException(
-                exctype, excmessage, stack)
-        
-        elif method == "ResponseSyntax":
-            self.debugServer.signalClientSyntaxError(
-                params["message"], self.translate(params["filename"], True),
-                params["linenumber"], params["characternumber"])
-        
-        elif method == "ResponseSignal":
-            self.debugServer.signalClientSignal(
-                params["message"], self.translate(params["filename"], True),
-                params["linenumber"], params["function"], params["arguments"])
-        
-        elif method == "ResponseExit":
-            self.__scriptName = ""
-            self.debugServer.signalClientExit(
-                params["status"], params["message"])
-        
-        elif method == "PassiveStartup":
-            self.debugServer.passiveStartUp(
-                self.translate(params["filename"], True), params["exceptions"])
-        
-        elif method == "ResponseCompletion":
-            self.debugServer.signalClientCompletionList(
-                params["completions"], params["text"])
-        
-        elif method == "ResponseUTPrepared":
-            self.debugServer.clientUtPrepared(
-                params["count"], params["exception"], params["message"])
-        
-        elif method == "ResponseUTFinished":
-            self.debugServer.clientUtFinished()
-        
-        elif method == "ResponseUTStartTest":
-            self.debugServer.clientUtStartTest(
-                params["testname"], params["description"])
-        
-        elif method == "ResponseUTStopTest":
-            self.debugServer.clientUtStopTest()
-        
-        elif method == "ResponseUTTestFailed":
-            self.debugServer.clientUtTestFailed(
-                params["testname"], params["traceback"], params["id"])
-        
-        elif method == "ResponseUTTestErrored":
-            self.debugServer.clientUtTestErrored(
-                params["testname"], params["traceback"], params["id"])
-        
-        elif method == "ResponseUTTestSkipped":
-            self.debugServer.clientUtTestSkipped(
-                params["testname"], params["reason"], params["id"])
-        
-        elif method == "ResponseUTTestFailedExpected":
-            self.debugServer.clientUtTestFailedExpected(
-                params["testname"], params["traceback"], params["id"])
-        
-        elif method == "ResponseUTTestSucceededUnexpected":
-            self.debugServer.clientUtTestSucceededUnexpected(
-                params["testname"], params["id"])
-        
-        elif method == "RequestForkTo":
-            self.__askForkTo()
-
-    def __sendJsonCommand(self, command, params):
-        """
-        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
-        """
-        import json
-        
-        commandDict = {
-            "jsonrpc": "2.0",
-            "method": command,
-            "params": params,
-        }
-        cmd = json.dumps(commandDict) + '\n'
-        if self.qsock is not None:
-            self.qsock.write(cmd.encode('utf8', 'backslashreplace'))
-        else:
-            self.queue.append(cmd)
-    
-
-def createDebuggerInterfacePython2(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
-    @rtype DebuggerInterfacePython
-    """
-    return DebuggerInterfacePython2(debugServer, passive)
-
-
-def getRegistryData():
-    """
-    Module function to get characterizing data for the debugger interface.
-    
-    @return tuple containing  client type, client capabilities, client file
-        type associations and reference to creation function
-    @rtype tuple of (str, int, list of str, function)
-    """
-    exts = []
-    for ext in Preferences.getDebugger("PythonExtensions").split():
-        if ext.startswith("."):
-            exts.append(ext)
-        else:
-            exts.append(".{0}".format(ext))
-    
-    if exts and Preferences.getDebugger("PythonInterpreter"):
-        return ["Python2", ClientDefaultCapabilities, exts,
-                createDebuggerInterfacePython2]
-    else:
-        return ["", 0, [], None]

--- a/Debugger/DebuggerInterfacePython3.py	Thu Aug 03 14:50:59 2017 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1102 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2009 - 2017 Detlev Offenbach <detlev@die-offenbachs.de>
-#
-
-"""
-Module implementing the Python3 debugger interface for the debug server.
-"""
-
-from __future__ import unicode_literals
-
-import sys
-import os
-
-from PyQt5.QtCore import QObject, QTextCodec, QProcess, QProcessEnvironment, \
-    QTimer
-from PyQt5.QtWidgets import QInputDialog
-
-from E5Gui.E5Application import e5App
-from E5Gui import E5MessageBox
-
-from . import DebugClientCapabilities
-
-import Preferences
-import Utilities
-
-from eric6config import getConfig
-
-
-ClientDefaultCapabilities = DebugClientCapabilities.HasAll
-
-
-class DebuggerInterfacePython3(QObject):
-    """
-    Class implementing the Python 3 debugger interface for the debug server.
-    """
-    def __init__(self, debugServer, passive):
-        """
-        Constructor
-        
-        @param debugServer reference to the debug server (DebugServer)
-        @param passive flag indicating passive connection mode (boolean)
-        """
-        super(DebuggerInterfacePython3, self).__init__()
-        
-        self.__isNetworked = True
-        self.__autoContinue = False
-        
-        self.debugServer = debugServer
-        self.passive = passive
-        self.process = None
-        
-        self.qsock = None
-        self.queue = []
-        
-        # set default values for capabilities of clients
-        self.clientCapabilities = ClientDefaultCapabilities
-        
-        # set translation function
-        self.translate = self.__identityTranslation
-        
-        self.codec = QTextCodec.codecForName(
-            str(Preferences.getSystem("StringEncoding")))
-        
-        if passive:
-            # set translation function
-            if Preferences.getDebugger("PathTranslation"):
-                self.translateRemote = \
-                    Preferences.getDebugger("PathTranslationRemote")
-                self.translateLocal = \
-                    Preferences.getDebugger("PathTranslationLocal")
-                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 (string)
-        @param remote2local flag indicating the direction of translation
-            (False = local to remote, True = remote to local [default])
-        @return translated filename (string)
-        """
-        return fn
-        
-    def __remoteTranslation(self, fn, remote2local=True):
-        """
-        Private method to perform the path translation.
-        
-        @param fn filename to be translated (string)
-        @param remote2local flag indicating the direction of translation
-            (False = local to remote, True = remote to local [default])
-        @return translated filename (string)
-        """
-        if remote2local:
-            return fn.replace(self.translateRemote, self.translateLocal)
-        else:
-            return fn.replace(self.translateLocal, self.translateRemote)
-        
-    def __startProcess(self, program, arguments, environment=None):
-        """
-        Private method to start the debugger client process.
-        
-        @param program name of the executable to start (string)
-        @param arguments arguments to be passed to the program (list of string)
-        @param environment dictionary of environment settings to pass
-            (dict of string)
-        @return the process object (QProcess) or None
-        """
-        proc = QProcess()
-        if environment is not None:
-            env = QProcessEnvironment()
-            for key, value in list(environment.items()):
-                env.insert(key, value)
-            proc.setProcessEnvironment(env)
-        args = []
-        for arg in arguments:
-            args.append(arg)
-        proc.start(program, args)
-        if not proc.waitForStarted(10000):
-            proc = None
-        
-        return proc
-        
-    def startRemote(self, port, runInConsole):
-        """
-        Public method to start a remote Python interpreter.
-        
-        @param port portnumber the debug server is listening on (integer)
-        @param runInConsole flag indicating to start the debugger in a
-            console window (boolean)
-        @return client process object (QProcess), a flag to indicate
-            a network connection (boolean) and the name of the interpreter
-            in case of a local execution (string)
-        """
-        interpreter = Preferences.getDebugger("Python3Interpreter")
-        if interpreter == "":
-            E5MessageBox.critical(
-                None,
-                self.tr("Start Debugger"),
-                self.tr(
-                    """<p>No Python3 interpreter configured.</p>"""))
-            return None, False, ""
-        
-        debugClientType = Preferences.getDebugger("DebugClientType3")
-        if debugClientType == "standard":
-            debugClient = os.path.join(getConfig('ericDir'),
-                                       "DebugClients", "Python",
-                                       "DebugClient.py")
-        else:
-            debugClient = Preferences.getDebugger("DebugClient3")
-            if debugClient == "":
-                debugClient = os.path.join(sys.path[0],
-                                           "DebugClients", "Python",
-                                           "DebugClient.py")
-        
-        redirect = str(Preferences.getDebugger("Python3Redirect"))
-        noencoding = Preferences.getDebugger("Python3NoEncoding") and \
-            '--no-encoding' or ''
-        
-        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,
-                        noencoding, str(port), redirect, ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:])
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                
-                # set translation function
-                if Preferences.getDebugger("PathTranslation"):
-                    self.translateRemote = \
-                        Preferences.getDebugger("PathTranslationRemote")
-                    self.translateLocal = \
-                        Preferences.getDebugger("PathTranslationLocal")
-                    self.translate = self.__remoteTranslation
-                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()
-        envlist = Utilities.parseEnvironmentString(
-            Preferences.getDebugger("DebugEnvironment"))
-        for el in envlist:
-            try:
-                key, value = el.split('=', 1)
-                if value.startswith('"') or value.startswith("'"):
-                    value = value[1:-1]
-                clientEnv[str(key)] = str(value)
-            except ValueError:
-                pass
-        
-        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),
-                        noencoding, str(port), '0', ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:], clientEnv)
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                return process, self.__isNetworked, interpreter
-        
-        process = self.__startProcess(
-            interpreter,
-            [debugClient, noencoding, str(port), redirect, ipaddr],
-            clientEnv)
-        if process is None:
-            E5MessageBox.critical(
-                None,
-                self.tr("Start Debugger"),
-                self.tr(
-                    """<p>The debugger backend could not be started.</p>"""))
-        return process, self.__isNetworked, interpreter
-
-    def startRemoteForProject(self, port, runInConsole):
-        """
-        Public method to start a remote Python interpreter for a project.
-        
-        @param port portnumber the debug server is listening on (integer)
-        @param runInConsole flag indicating to start the debugger in a
-            console window (boolean)
-        @return client process object (QProcess), a flag to indicate
-            a network connection (boolean) and the name of the interpreter
-            in case of a local execution (string)
-        """
-        project = e5App().getObject("Project")
-        if not project.isDebugPropertiesLoaded():
-            return None, self.__isNetworked, ""
-        
-        # start debugger with project specific settings
-        interpreter = project.getDebugProperty("INTERPRETER")
-        debugClient = project.getDebugProperty("DEBUGCLIENT")
-        
-        redirect = str(project.getDebugProperty("REDIRECT"))
-        noencoding = \
-            project.getDebugProperty("NOENCODING") and '--no-encoding' or ''
-        
-        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, os.path.abspath(debugClient),
-                        noencoding, str(port), redirect, ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:])
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                # set translation function
-                if project.getDebugProperty("PATHTRANSLATION"):
-                    self.translateRemote = \
-                        project.getDebugProperty("REMOTEPATH")
-                    self.translateLocal = \
-                        project.getDebugProperty("LOCALPATH")
-                    self.translate = self.__remoteTranslation
-                else:
-                    self.translate = self.__identityTranslation
-                return process, 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()
-        envlist = Utilities.parseEnvironmentString(
-            project.getDebugProperty("ENVIRONMENTSTRING"))
-        for el in envlist:
-            try:
-                key, value = el.split('=', 1)
-                if value.startswith('"') or value.startswith("'"):
-                    value = value[1:-1]
-                clientEnv[str(key)] = str(value)
-            except ValueError:
-                pass
-        
-        ipaddr = self.debugServer.getHostAddress(True)
-        if runInConsole or project.getDebugProperty("CONSOLEDEBUGGER"):
-            ccmd = project.getDebugProperty("CONSOLECOMMAND") or \
-                Preferences.getDebugger("ConsoleDbgCommand")
-            if ccmd:
-                args = Utilities.parseOptionString(ccmd) + \
-                    [interpreter, os.path.abspath(debugClient),
-                        noencoding, str(port), '0', ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:], clientEnv)
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                return process, self.__isNetworked, interpreter
-        
-        process = self.__startProcess(
-            interpreter,
-            [debugClient, noencoding, str(port), redirect, ipaddr],
-            clientEnv)
-        if process is None:
-            E5MessageBox.critical(
-                None,
-                self.tr("Start Debugger"),
-                self.tr(
-                    """<p>The debugger backend could not be started.</p>"""))
-        return process, self.__isNetworked, interpreter
-
-    def getClientCapabilities(self):
-        """
-        Public method to retrieve the debug clients capabilities.
-        
-        @return debug client capabilities (integer)
-        """
-        return self.clientCapabilities
-    
-    def newConnection(self, sock):
-        """
-        Public slot to handle a new connection.
-        
-        @param sock reference to the socket object (QTcpSocket)
-        @return flag indicating success (boolean)
-        """
-        # If we already have a connection, refuse this one.  It will be closed
-        # automatically.
-        if self.qsock is not None:
-            return False
-        
-        sock.disconnected.connect(self.debugServer.startClient)
-        sock.readyRead.connect(self.__parseClientLine)
-        
-        self.qsock = sock
-        
-        # Get the remote clients capabilities
-        self.remoteCapabilities()
-        return True
-    
-    def flush(self):
-        """
-        Public slot to flush the queue.
-        """
-        # Send commands that were waiting for the connection.
-        for cmd in self.queue:
-            self.qsock.write(cmd.encode('utf8', 'backslashreplace'))
-        
-        self.queue = []
-    
-    def shutdown(self):
-        """
-        Public method to cleanly shut down.
-        
-        It closes our socket and shuts down
-        the debug client. (Needed on Win OS)
-        """
-        if self.qsock is None:
-            return
-        
-        # do not want any slots called during shutdown
-        self.qsock.disconnected.disconnect(self.debugServer.startClient)
-        self.qsock.readyRead.disconnect(self.__parseClientLine)
-        
-        # close down socket, and shut down client as well.
-        self.__sendJsonCommand("RequestShutdown", {})
-        self.qsock.flush()
-        self.qsock.close()
-        
-        # reinitialize
-        self.qsock = None
-        self.queue = []
-    
-    def isConnected(self):
-        """
-        Public method to test, if a debug client has connected.
-        
-        @return flag indicating the connection status (boolean)
-        """
-        return self.qsock is not None
-    
-    def remoteEnvironment(self, env):
-        """
-        Public method to set the environment for a program to debug, run, ...
-        
-        @param env environment settings (dictionary)
-        """
-        self.__sendJsonCommand("RequestEnvironment", {"environment": env})
-    
-    def remoteLoad(self, fn, argv, wd, traceInterpreter=False,
-                   autoContinue=True, autoFork=False, forkChild=False):
-        """
-        Public method to load a new program to debug.
-        
-        @param fn the filename to debug (string)
-        @param argv the commandline arguments to pass to the program (string)
-        @param wd the working directory for the program (string)
-        @keyparam traceInterpreter flag indicating if the interpreter library
-            should be traced as well (boolean)
-        @keyparam autoContinue flag indicating, that the debugger should not
-            stop at the first executable line (boolean)
-        @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking
-            (boolean)
-        """
-        self.__autoContinue = autoContinue
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestLoad", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "traceInterpreter": traceInterpreter,
-            "autofork": autoFork,
-            "forkChild": forkChild,
-        })
-    
-    def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
-        """
-        Public method to load a new program to run.
-        
-        @param fn the filename to run (string)
-        @param argv the commandline arguments to pass to the program (string)
-        @param wd the working directory for the program (string)
-        @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking
-            (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestRun", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "autofork": autoFork,
-            "forkChild": forkChild,
-        })
-    
-    def remoteCoverage(self, fn, argv, wd, erase=False):
-        """
-        Public method to load a new program to collect coverage data.
-        
-        @param fn the filename to run (string)
-        @param argv the commandline arguments to pass to the program (string)
-        @param wd the working directory for the program (string)
-        @keyparam erase flag indicating that coverage info should be
-            cleared first (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestCoverage", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "erase": erase,
-        })
-
-    def remoteProfile(self, fn, argv, wd, erase=False):
-        """
-        Public method to load a new program to collect profiling data.
-        
-        @param fn the filename to run (string)
-        @param argv the commandline arguments to pass to the program (string)
-        @param wd the working directory for the program (string)
-        @keyparam erase flag indicating that timing info should be cleared
-            first (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestProfile", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "erase": erase,
-        })
-
-    def remoteStatement(self, stmt):
-        """
-        Public method to execute a Python statement.
-        
-        @param stmt the Python statement to execute (string). It
-              should not have a trailing newline.
-        """
-        self.__sendJsonCommand("ExecuteStatement", {
-            "statement": stmt,
-        })
-
-    def remoteStep(self):
-        """
-        Public method to single step the debugged program.
-        """
-        self.__sendJsonCommand("RequestStep", {})
-
-    def remoteStepOver(self):
-        """
-        Public method to step over the debugged program.
-        """
-        self.__sendJsonCommand("RequestStepOver", {})
-
-    def remoteStepOut(self):
-        """
-        Public method to step out the debugged program.
-        """
-        self.__sendJsonCommand("RequestStepOut", {})
-
-    def remoteStepQuit(self):
-        """
-        Public method to stop the debugged program.
-        """
-        self.__sendJsonCommand("RequestStepQuit", {})
-
-    def remoteContinue(self, special=False):
-        """
-        Public method to continue the debugged program.
-        
-        @param special flag indicating a special continue operation
-        """
-        self.__sendJsonCommand("RequestContinue", {
-            "special": special,
-        })
-
-    def remoteMoveIP(self, line):
-        """
-        Public method to move the instruction pointer to a different line.
-        
-        @param line the new line, where execution should be continued
-        """
-        self.__sendJsonCommand("RequestMoveIP", {
-            "newLine": line,
-        })
-
-    def remoteBreakpoint(self, fn, line, setBreakpoint, cond=None, temp=False):
-        """
-        Public method to set or clear a breakpoint.
-        
-        @param fn filename the breakpoint belongs to (string)
-        @param line linenumber of the breakpoint (int)
-        @param setBreakpoint flag indicating setting or resetting a
-            breakpoint (boolean)
-        @param cond condition of the breakpoint (string)
-        @param temp flag indicating a temporary breakpoint (boolean)
-        """
-        self.__sendJsonCommand("RequestBreakpoint", {
-            "filename": self.translate(fn, False),
-            "line": line,
-            "temporary": temp,
-            "setBreakpoint": setBreakpoint,
-            "condition": cond,
-        })
-    
-    def remoteBreakpointEnable(self, fn, line, enable):
-        """
-        Public method to enable or disable a breakpoint.
-        
-        @param fn filename the breakpoint belongs to (string)
-        @param line linenumber of the breakpoint (int)
-        @param enable flag indicating enabling or disabling a breakpoint
-            (boolean)
-        """
-        self.__sendJsonCommand("RequestBreakpointEnable", {
-            "filename": self.translate(fn, False),
-            "line": line,
-            "enable": enable,
-        })
-    
-    def remoteBreakpointIgnore(self, fn, line, count):
-        """
-        Public method to ignore a breakpoint the next couple of occurrences.
-        
-        @param fn filename the breakpoint belongs to (string)
-        @param line linenumber of the breakpoint (int)
-        @param count number of occurrences to ignore (int)
-        """
-        self.__sendJsonCommand("RequestBreakpointIgnore", {
-            "filename": self.translate(fn, False),
-            "line": line,
-            "count": count,
-        })
-    
-    def remoteWatchpoint(self, cond, setWatch, temp=False):
-        """
-        Public method to set or clear a watch expression.
-        
-        @param cond expression of the watch expression (string)
-        @param setWatch flag indicating setting or resetting a watch expression
-            (boolean)
-        @param temp flag indicating a temporary watch expression (boolean)
-        """
-        # cond is combination of cond and special (s. watch expression viewer)
-        self.__sendJsonCommand("RequestWatch", {
-            "temporary": temp,
-            "setWatch": setWatch,
-            "condition": cond,
-        })
-    
-    def remoteWatchpointEnable(self, cond, enable):
-        """
-        Public method to enable or disable a watch expression.
-        
-        @param cond expression of the watch expression (string)
-        @param enable flag indicating enabling or disabling a watch expression
-            (boolean)
-        """
-        # cond is combination of cond and special (s. watch expression viewer)
-        self.__sendJsonCommand("RequestWatchEnable", {
-            "condition": cond,
-            "enable": enable,
-        })
-    
-    def remoteWatchpointIgnore(self, cond, count):
-        """
-        Public method to ignore a watch expression the next couple of
-        occurrences.
-        
-        @param cond expression of the watch expression (string)
-        @param count number of occurrences to ignore (int)
-        """
-        # cond is combination of cond and special (s. watch expression viewer)
-        self.__sendJsonCommand("RequestWatchIgnore", {
-            "condition": cond,
-            "count": count,
-        })
-    
-    def remoteRawInput(self, s):
-        """
-        Public method to send the raw input to the debugged program.
-        
-        @param s the raw input (string)
-        """
-        self.__sendJsonCommand("RawInput", {
-            "input": s,
-        })
-    
-    def remoteThreadList(self):
-        """
-        Public method to request the list of threads from the client.
-        """
-        self.__sendJsonCommand("RequestThreadList", {})
-        
-    def remoteSetThread(self, tid):
-        """
-        Public method to request to set the given thread as current thread.
-        
-        @param tid id of the thread (integer)
-        """
-        self.__sendJsonCommand("RequestThreadSet", {
-            "threadID": tid,
-        })
-        
-    def remoteClientVariables(self, scope, filterList, framenr=0):
-        """
-        Public method to request the variables of the debugged program.
-        
-        @param scope the scope of the variables (0 = local, 1 = global)
-        @param filterList list of variable types to filter out (list of int)
-        @param framenr framenumber of the variables to retrieve (int)
-        """
-        self.__sendJsonCommand("RequestVariables", {
-            "frameNumber": framenr,
-            "scope": scope,
-            "filters": filterList,
-        })
-    
-    def remoteClientVariable(self, scope, filterList, var, framenr=0):
-        """
-        Public method to request the variables of the debugged program.
-        
-        @param scope the scope of the variables (0 = local, 1 = global)
-        @param filterList list of variable types to filter out (list of int)
-        @param var list encoded name of variable to retrieve (string)
-        @param framenr framenumber of the variables to retrieve (int)
-        """
-        self.__sendJsonCommand("RequestVariable", {
-            "variable": var,
-            "frameNumber": framenr,
-            "scope": scope,
-            "filters": filterList,
-        })
-    
-    def remoteClientSetFilter(self, scope, filterStr):
-        """
-        Public method to set a variables filter list.
-        
-        @param scope the scope of the variables (0 = local, 1 = global)
-        @param filterStr regexp string for variable names to filter out
-            (string)
-        """
-        self.__sendJsonCommand("RequestSetFilter", {
-            "scope": scope,
-            "filter": filterStr,
-        })
-    
-    def setCallTraceEnabled(self, on):
-        """
-        Public method to set the call trace state.
-        
-        @param on flag indicating to enable the call trace function (boolean)
-        """
-        self.__sendJsonCommand("RequestCallTrace", {
-            "enable": on,
-        })
-    
-    def remoteBanner(self):
-        """
-        Public slot to get the banner info of the remote client.
-        """
-        self.__sendJsonCommand("RequestBanner", {})
-    
-    def remoteCapabilities(self):
-        """
-        Public slot to get the debug clients capabilities.
-        """
-        self.__sendJsonCommand("RequestCapabilities", {})
-    
-    def remoteCompletion(self, text):
-        """
-        Public slot to get the a list of possible commandline completions
-        from the remote client.
-        
-        @param text the text to be completed (string)
-        """
-        self.__sendJsonCommand("RequestCompletion", {
-            "text": text,
-        })
-    
-    def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase):
-        """
-        Public method to prepare a new unittest run.
-        
-        @param fn the filename to load (string)
-        @param tn the testname to load (string)
-        @param tfn the test function name to load tests from (string)
-        @param failed list of failed test, if only failed test should be run
-            (list of strings)
-        @param cov flag indicating collection of coverage data is requested
-            (boolean)
-        @param covname filename to be used to assemble the coverage caches
-            filename (string)
-        @param coverase flag indicating erasure of coverage data is requested
-            (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestUTPrepare", {
-            "filename": fn,
-            "testname": tn,
-            "testfunctionname": tfn,
-            "failed": failed,
-            "coverage": cov,
-            "coveragefile": covname,
-            "coverageerase": coverase,
-        })
-    
-    def remoteUTRun(self):
-        """
-        Public method to start a unittest run.
-        """
-        self.__sendJsonCommand("RequestUTRun", {})
-    
-    def remoteUTStop(self):
-        """
-        Public method to stop a unittest run.
-        """
-        self.__sendJsonCommand("RequestUTStop", {})
-    
-    def __askForkTo(self):
-        """
-        Private method to ask the user which branch of a fork to follow.
-        """
-        selections = [self.tr("Parent Process"),
-                      self.tr("Child process")]
-        res, ok = QInputDialog.getItem(
-            None,
-            self.tr("Client forking"),
-            self.tr("Select the fork branch to follow."),
-            selections,
-            0, False)
-        if not ok or res == selections[0]:
-            self.__sendJsonCommand("ResponseForkTo", {
-                "target": "parent",
-            })
-        else:
-            self.__sendJsonCommand("ResponseForkTo", {
-                "target": "child",
-            })
-    
-    def __parseClientLine(self):
-        """
-        Private method to handle data from the client.
-        """
-        while self.qsock and self.qsock.canReadLine():
-            qs = self.qsock.readLine()
-            if self.codec is not None:
-                line = self.codec.toUnicode(qs)
-            else:
-                line = bytes(qs).decode()
-            
-##            print("Server: ", line)          ##debug
-            
-            self.__handleJsonCommand(line)
-            continue
-    
-    def __handleJsonCommand(self, jsonStr):
-        """
-        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
-        """
-        import json
-        
-        try:
-            commandDict = json.loads(jsonStr.strip())
-        except (TypeError, ValueError) as err:
-            E5MessageBox.critical(
-                None,
-                self.tr("Debug Protocol Error"),
-                self.tr("""<p>The response received from the debugger"""
-                        """ backend could not be decoded. Please report"""
-                        """ this issue with the received data to the"""
-                        """ eric bugs email address.</p>"""
-                        """<p>Error: {0}</p>"""
-                        """<p>Data:<br/>{0}</p>""").format(
-                    str(err), Utilities.html_encode(jsonStr.strip())),
-                E5MessageBox.StandardButtons(
-                    E5MessageBox.Ok))
-            return
-        
-        method = commandDict["method"]
-        params = commandDict["params"]
-        
-        if method == "ClientOutput":
-            self.debugServer.signalClientOutput(params["text"])
-        
-        elif method in ["ResponseLine", "ResponseStack"]:
-            # Check if obsolet thread was clicked
-            if params["stack"] == []:
-                # Request updated list
-                self.remoteThreadList()
-                return
-            for s in params["stack"]:
-                s[0] = self.translate(s[0], True)
-            cf = params["stack"][0]
-            if self.__autoContinue:
-                self.__autoContinue = False
-                QTimer.singleShot(0, self.remoteContinue)
-            else:
-                self.debugServer.signalClientLine(
-                    cf[0], int(cf[1]),
-                    method == "ResponseStack")
-                self.debugServer.signalClientStack(params["stack"])
-        
-        elif method == "CallTrace":
-            isCall = params["event"].lower() == "c"
-            fromInfo = params["from"]
-            toInfo = params["to"]
-            self.debugServer.signalClientCallTrace(
-                isCall,
-                fromInfo["filename"], str(fromInfo["linenumber"]),
-                fromInfo["codename"],
-                toInfo["filename"], str(toInfo["linenumber"]),
-                toInfo["codename"])
-        
-        elif method == "ResponseVariables":
-            self.debugServer.signalClientVariables(
-                params["scope"], params["variables"])
-        
-        elif method == "ResponseVariable":
-            self.debugServer.signalClientVariable(
-                params["scope"], [params["variable"]] + params["variables"])
-        
-        elif method == "ResponseThreadList":
-            self.debugServer.signalClientThreadList(
-                params["currentID"], params["threadList"])
-        
-        elif method == "ResponseThreadSet":
-            self.debugServer.signalClientThreadSet()
-        
-        elif method == "ResponseCapabilities":
-            self.clientCapabilities = params["capabilities"]
-            self.debugServer.signalClientCapabilities(
-                params["capabilities"], params["clientType"])
-        
-        elif method == "ResponseBanner":
-            self.debugServer.signalClientBanner(
-                params["version"],
-                params["platform"],
-                params["dbgclient"])
-        
-        elif method == "ResponseOK":
-            self.debugServer.signalClientStatement(False)
-        
-        elif method == "ResponseContinue":
-            self.debugServer.signalClientStatement(True)
-        
-        elif method == "RequestRaw":
-            self.debugServer.signalClientRawInput(
-                params["prompt"], params["echo"])
-        
-        elif method == "ResponseBPConditionError":
-            fn = self.translate(params["filename"], True)
-            self.debugServer.signalClientBreakConditionError(
-                fn, params["line"])
-        
-        elif method == "ResponseClearBreakpoint":
-            fn = self.translate(params["filename"], True)
-            self.debugServer.signalClientClearBreak(fn, params["line"])
-        
-        elif method == "ResponseWatchConditionError":
-            self.debugServer.signalClientWatchConditionError(
-                params["condition"])
-        
-        elif method == "ResponseClearWatch":
-            self.debugServer.signalClientClearWatch(params["condition"])
-        
-        elif method == "ResponseException":
-            if params:
-                exctype = params["type"]
-                excmessage = params["message"]
-                stack = params["stack"]
-                if stack:
-                    for stackEntry in stack:
-                        stackEntry[0] = self.translate(stackEntry[0], True)
-                    if stack[0] and stack[0][0] == "<string>":
-                        for stackEntry in stack:
-                            if stackEntry[0] == "<string>":
-                                stackEntry[0] = self.__scriptName
-                            else:
-                                break
-            else:
-                exctype = ''
-                excmessage = ''
-                stack = []
-            
-            self.debugServer.signalClientException(
-                exctype, excmessage, stack)
-        
-        elif method == "ResponseSyntax":
-            self.debugServer.signalClientSyntaxError(
-                params["message"], self.translate(params["filename"], True),
-                params["linenumber"], params["characternumber"])
-        
-        elif method == "ResponseSignal":
-            self.debugServer.signalClientSignal(
-                params["message"], self.translate(params["filename"], True),
-                params["linenumber"], params["function"], params["arguments"])
-        
-        elif method == "ResponseExit":
-            self.__scriptName = ""
-            self.debugServer.signalClientExit(
-                params["status"], params["message"])
-        
-        elif method == "PassiveStartup":
-            self.debugServer.passiveStartUp(
-                self.translate(params["filename"], True), params["exceptions"])
-        
-        elif method == "ResponseCompletion":
-            self.debugServer.signalClientCompletionList(
-                params["completions"], params["text"])
-        
-        elif method == "ResponseUTPrepared":
-            self.debugServer.clientUtPrepared(
-                params["count"], params["exception"], params["message"])
-        
-        elif method == "ResponseUTFinished":
-            self.debugServer.clientUtFinished()
-        
-        elif method == "ResponseUTStartTest":
-            self.debugServer.clientUtStartTest(
-                params["testname"], params["description"])
-        
-        elif method == "ResponseUTStopTest":
-            self.debugServer.clientUtStopTest()
-        
-        elif method == "ResponseUTTestFailed":
-            self.debugServer.clientUtTestFailed(
-                params["testname"], params["traceback"], params["id"])
-        
-        elif method == "ResponseUTTestErrored":
-            self.debugServer.clientUtTestErrored(
-                params["testname"], params["traceback"], params["id"])
-        
-        elif method == "ResponseUTTestSkipped":
-            self.debugServer.clientUtTestSkipped(
-                params["testname"], params["reason"], params["id"])
-        
-        elif method == "ResponseUTTestFailedExpected":
-            self.debugServer.clientUtTestFailedExpected(
-                params["testname"], params["traceback"], params["id"])
-        
-        elif method == "ResponseUTTestSucceededUnexpected":
-            self.debugServer.clientUtTestSucceededUnexpected(
-                params["testname"], params["id"])
-        
-        elif method == "RequestForkTo":
-            self.__askForkTo()
-    
-    def __sendJsonCommand(self, command, params):
-        """
-        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
-        """
-        import json
-        
-        commandDict = {
-            "jsonrpc": "2.0",
-            "method": command,
-            "params": params,
-        }
-        cmd = json.dumps(commandDict) + '\n'
-        if self.qsock is not None:
-            self.qsock.write(cmd.encode('utf8', 'backslashreplace'))
-        else:
-            self.queue.append(cmd)
-    
-
-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
-    @rtype DebuggerInterfacePython
-    """
-    return DebuggerInterfacePython3(debugServer, passive)
-
-
-def getRegistryData():
-    """
-    Module function to get characterizing data for the debugger interface.
-    
-    @return tuple containing  client type, client capabilities, client file
-        type associations and reference to creation function
-    @rtype tuple of (str, int, list of str, function)
-    """
-    exts = []
-    for ext in Preferences.getDebugger("Python3Extensions").split():
-        if ext.startswith("."):
-            exts.append(ext)
-        else:
-            exts.append(".{0}".format(ext))
-    
-    if exts and Preferences.getDebugger("Python3Interpreter"):
-        return ["Python3", ClientDefaultCapabilities, exts,
-                createDebuggerInterfacePython3]
-    else:
-        return ["", 0, [], None]