eric: comparison eric6/DebugClients/Python/DebugClientBase.py

-:fb0ef164f536
+:698ae46f40a4
 import signal
 import time
 import types
 import importlib.util
 import fnmatch
+import contextlib
 import DebugClientCapabilities
 import DebugVariables
 from DebugBase import setRecursionLimit, printerr   # __IGNORE_WARNING__
 from AsyncFile import AsyncFile, AsyncPendingWrite
 @return result of the input() call
 @rtype str
 """
 if DebugClientInstance is None or not DebugClientInstance.redirect:
 return DebugClientOrigInput(prompt)
+else:
 return DebugClientInstance.input(prompt)
 # Use our own input().
 try:
 DebugClientOrigInput = __builtins__.__dict__['input']
 __builtins__.__dict__['input'] = DebugClientInput
 @param fd open file descriptor to be closed (integer)
 """
 if DebugClientInstance is None:
 DebugClientOrigClose(fd)
+else:
 DebugClientInstance.close(fd)
 # use our own close().
 if 'close' in dir(os):
 DebugClientOrigClose = os.close
 os.close = DebugClientClose
 DebugClientSetRecursionLimit(sys.getrecursionlimit())
 ###############################################################################
-class DebugClientBase(object):
+class DebugClientBase:
 """
 Class implementing the client side of the debugger.
 It provides access to the Python interpeter from a debugger running in
 another process.
 Public method to close the session with the debugger and optionally
 terminate.
 @param terminate flag indicating to terminate (boolean)
 """
-try:
+with contextlib.suppress(Exception):
 self.set_quit()
-except Exception:       # secok
-pass
 self.debugging = False
 self.multiprocessSupport = False
 self.noDebugList = []
 @return client capabilities (integer)
 """
 try:
 import PyProfile    # __IGNORE_WARNING__
-try:
+with contextlib.suppress(KeyError):
 del sys.modules['PyProfile']
-except KeyError:
-pass
 return self.clientCapabilities
 except ImportError:
 return (
 self.clientCapabilities & ~DebugClientCapabilities.HasProfiler)
 elif f.f_globals is f.f_locals:
 scope = -1
 else:
 varDict = f.f_locals
-if scope == -1:
+varlist = [] if scope == -1 else self.__formatVariablesList(
-varlist = []
+varDict, scope, filterList)
-else:
-varlist = self.__formatVariablesList(varDict, scope, filterList)
 self.sendJsonCommand("ResponseVariables", {
 "scope": scope,
 "variables": varlist,
 })
 # XML stuff
 elif qttype == 'QDomAttr':
 varlist.append(("name", "str", "{0}".format(value.name())))
 varlist.append(("value", "str", "{0}".format(value.value())))
-elif qttype == 'QDomCharacterData':
+elif qttype in ('QDomCharacterData', 'QDomComment', 'QDomText'):
-varlist.append(("data", "str", "{0}".format(value.data())))
-elif qttype == 'QDomComment':
 varlist.append(("data", "str", "{0}".format(value.data())))
 elif qttype == 'QDomDocument':
 varlist.append(("text", "str", "{0}".format(value.toString())))
 elif qttype == 'QDomElement':
 varlist.append(("tagName", "str", "{0}".format(value.tagName())))
 varlist.append(("text", "str", "{0}".format(value.text())))
-elif qttype == 'QDomText':
-varlist.append(("data", "str", "{0}".format(value.data())))
 # Networking stuff
 elif qttype == 'QHostAddress':
 varlist.append(
 ("address", "QHostAddress", "{0}".format(value.toString())))
 @rtype list of tuple of (str, str, str)
 """
 filterList = [] if filterList is None else filterList[:]
 varlist = []
-if scope:
+patternFilterObjects = (
-patternFilterObjects = self.globalsFilterObjects
+self.globalsFilterObjects
-else:
+if scope else
-patternFilterObjects = self.localsFilterObjects
+self.localsFilterObjects
+)
 if type(dict_) == dict:
 dict_ = dict_.items()
 for key, value in dict_:
 # no more elements available
 rvalue = '<module builtins (built-in)>'
 valtype = 'module'
 if valtype in filterList:
 continue
 elif (
-key in SpecialAttributes and
+(key in SpecialAttributes and
-"special_attributes" in filterList
+"special_attributes" in filterList) or
-):
+(key == "__hash__" and
-continue
+"builtin_function_or_method" in filterList)
-elif (
-key == "__hash__" and
-"builtin_function_or_method" in filterList
 ):
 continue
 else:
 isQt = False
 # valtypestr, e.g. class 'PyQt5.QtCore.QPoint'
 elif valtype == "method-wrapper":
 valtype = "builtin_function_or_method"
 # valtypename, e.g. QPoint
 valtypename = type(value).__name__
-if valtype in filterList:
+if (
-continue
+valtype in filterList or
-elif (
+(valtype in ("sip.enumtype", "sip.wrappertype") and
-valtype in ("sip.enumtype", "sip.wrappertype") and
+'class' in filterList) or
-'class' in filterList
+(valtype in (
+"sip.methoddescriptor", "method_descriptor") and
+'method' in filterList) or
+(valtype in ("numpy.ndarray", "array.array") and
+'list' in filterList) or
+(valtypename == "MultiValueDict" and
+'dict' in filterList) or
+'instance' in filterList
 ):
-continue
-elif (
-valtype in (
-"sip.methoddescriptor", "method_descriptor") and
-'method' in filterList
-):
-continue
-elif (
-valtype in ("numpy.ndarray", "array.array") and
-'list' in filterList
-):
-continue
-elif valtypename == "MultiValueDict" and 'dict' in filterList:
-continue
-elif 'instance' in filterList:
 continue
 isQt = valtype.startswith(ConfigQtNames)
 try:
 text = text[pos + 1:]
 break
 pos -= 1
 # Get local and global completions
-try:
+with contextlib.suppress(AttributeError):
 localdict = self.currentThread.getFrameLocals(self.framenr)
 localCompleter = Completer(localdict).complete
 self.__getCompletionList(text, localCompleter, completions)
-except AttributeError:
-pass
 cf = self.currentThread.getCurrentFrame()
 frmnr = self.framenr
 while cf is not None and frmnr > 0:
 cf = cf.f_back
 frmnr -= 1
-if cf is None:
+globaldict = self.debugMod.__dict__ if cf is None else cf.f_globals
-globaldict = self.debugMod.__dict__
-else:
-globaldict = cf.f_globals
 globalCompleter = Completer(globaldict).complete
 self.__getCompletionList(text, globalCompleter, completions)
 self.sendJsonCommand("ResponseCompletion", {
 host = os.getenv('ERICHOST', 'localhost')
 if port is None:
 port = os.getenv('ERICPORT', 42424)
 remoteAddress = self.__resolveHost(host)
-if filename is not None:
+name = os.path.basename(filename) if filename is not None else ""
-name = os.path.basename(filename)
-else:
-name = ""
 self.connectDebugger(port, remoteAddress, redirect, name=name)
 if filename is not None:
 self.running = os.path.abspath(filename)
 else:
 try:
 "__spec__": modSpec,
 "__builtins__": __builtins__,
 })
 else:
 code = self.__compileFileSource(self.running)
-if code:
+res = (
-res = self.mainThread.run(code, self.debugMod.__dict__, debug=True)
+self.mainThread.run(code, self.debugMod.__dict__, debug=True)
-else:
+if code else
-res = 42        # should not happen
+42        # should not happen
+)
 return res
 def run_call(self, scriptname, func, *args):
 """
 Public method used to start the remote debugger and call a function.
 """
 try:
 host, version = host.split("@@")
 except ValueError:
 version = 'v4'
-if version == 'v4':
+family = socket.AF_INET if version == 'v4' else socket.AF_INET6
-family = socket.AF_INET
-else:
-family = socket.AF_INET6
 retryCount = 0
 while retryCount < 10:
 try:
 addrinfo = socket.getaddrinfo(
 redirect = int(sys.argv[2])
 except (ValueError, IndexError):
 redirect = True
 ipOrHost = sys.argv[3]
-if ':' in ipOrHost:
+if ':' in ipOrHost or ipOrHost[0] in '0123456789':
-# IPv6 address
+# IPv6 address or IPv4 address
-remoteAddress = ipOrHost
-elif ipOrHost[0] in '0123456789':
-# IPv4 address
 remoteAddress = ipOrHost
 else:
 remoteAddress = self.__resolveHost(ipOrHost)
 sys.argv = ['']
 @param scriptName name of the script to check
 @type str
 @return flag indicating eligibility
 @rtype bool
 """
-for pattern in self.noDebugList:
+return any(fnmatch.fnmatch(scriptName, pattern)
-if fnmatch.fnmatch(scriptName, pattern):
+for pattern in self.noDebugList)
-return True
-return False

Mercurial Repositories > eric / file comparison

comparison: eric6/DebugClients/Python/DebugClientBase.py

eric6/DebugClients/Python/DebugClientBase.py