eric: comparison src/eric7/DebugClients/Python/DebugClientBase.py

-:411df92e881f
+:3b34efa2857c
 # -*- coding: utf-8 -*-
-# Copyright (c) 2002 - 2023 Detlev Offenbach <detlev@die-offenbachs.de>
+# Copyright (c) 2002 - 2024 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing a debug client base class.
 """
 def DebugClientClose(fd):
 """
 Replacement for the standard os.close(fd).
-@param fd open file descriptor to be closed (integer)
+@param fd open file descriptor to be closed
+@type int
 """
 if DebugClientInstance is None:
 DebugClientOrigClose(fd)
 else:
 DebugClientInstance.close(fd)
 def DebugClientSetRecursionLimit(limit):
 """
 Replacement for the standard sys.setrecursionlimit(limit).
-@param limit recursion limit (integer)
+@param limit recursion limit
+@type int
 """
 rl = max(limit, 64)
 setRecursionLimit(rl)
 DebugClientOrigSetRecursionLimit(rl + 64)
 def getCoding(self):
 """
 Public method to return the current coding.
-@return codec name (string)
+@return codec name
+@rtype str
 """
 return self.__coding
 def __setCoding(self, filename):
 """
 Private method to set the coding used by a python file.
-@param filename name of the file to inspect (string)
+@param filename name of the file to inspect
+@type str
 """
 if self.noencoding:
 self.__coding = sys.getdefaultencoding()
 else:
 default = "utf-8"
 def sessionClose(self, terminate=True):
 """
 Public method to close the session with the debugger and optionally
 terminate.
-@param terminate flag indicating to terminate (boolean)
+@param terminate flag indicating to terminate
+@type bool
 """
 with contextlib.suppress(Exception):  # secok
 self.set_quit()
 self.debugging = False
 @param filename name of the source file
 @type str
 @param mode kind of code to be generated (exec or eval)
 @type str
 @return compiled code object (None in case of errors)
+@rtype Code
 """
 with codecs.open(filename, encoding=self.__coding) as fp:
 statement = fp.read()
 return self.__compileCommand(statement, filename=filename, mode=mode)
 @param filename name of the source file
 @type str
 @param mode kind of code to be generated (exec or eval)
 @type str
 @return compiled code object (None in case of errors)
+@rtype Code
 """
 try:
 code = compile(statement + "\n", filename, mode)
 except SyntaxError:
 exctype, excval, exctb = sys.exc_info()
 Public method to handle a command serialized as a JSON string.
 @param jsonStr string containing the command received from the IDE
 @type str
 """
-##        printerr(jsonStr)          ## debug       # __IGNORE_WARNING_M891__
+##        printerr(jsonStr)          ## debug       # noqa: M891
 try:
 commandDict = json.loads(jsonStr.strip())
 except (TypeError, ValueError) as err:
 printerr("Error handling command: " + jsonStr)
 """
 Public method to signal the deletion of a temporary breakpoint.
 @param filename name of the file the bp belongs to
 @type str
-@param lineno linenumber of the bp
+@param lineno line number of the bp
 @type int
 """
 self.sendJsonCommand(
 "ResponseClearBreakpoint", {"filename": filename, "line": lineno}
 )
 def __clientCapabilities(self):
 """
 Private method to determine the clients capabilities.
-@return client capabilities (integer)
+@return client capabilities
+@rtype int
 """
 if importlib.util.find_spec("PyProfile") is None:
 return self.clientCapabilities & ~DebugClientCapabilities.HasProfiler
 else:
 return self.clientCapabilities
 def readReady(self, stream):
 """
 Public method called when there is data ready to be read.
 @param stream file like object that has data to be read
+@type file like
 @return flag indicating an error condition
 @rtype bool
 """
 error = False
 def writeReady(self, stream):
 """
 Public method called when we are ready to write data.
 @param stream file like object that has data to be written
+@type file like
 """
 stream.write_p("")
 stream.flush()
 def __interact(self):
 def eventLoop(self, disablePolling=False):
 """
 Public method implementing our event loop.
 @param disablePolling flag indicating to enter an event loop with
-polling disabled (boolean)
+polling disabled
+@type bool
 """
 self.eventExit = False
 self.pollingDisabled = disablePolling
 selectErrors = 0
 def __unhandled_exception(self, exctype, excval, exctb):
 """
 Private method called to report an uncaught exception.
-@param exctype the type of the exception
+@param exctype class of the exception
-@param excval data about the exception
+@type type
+@param excval exception instance
+@type Exception
 @param exctb traceback for the exception
+@type traceback
 """
 self.mainThread.user_exception((exctype, excval, exctb), True)
 def __interceptSignals(self):
 """
 Public method to convert a filename to an absolute name.
 sys.path is used as a set of possible prefixes. The name stays
 relative if a file could not be found.
-@param fn filename (string)
+@param fn filename
-@return the converted filename (string)
+@type str
+@return the converted filename
+@rtype str
 """
 if os.path.isabs(fn):
 return fn
 # Check the cache.
 def getRunning(self):
 """
 Public method to return the main script we are currently running.
-@return flag indicating a running debug session (boolean)
+@return flag indicating a running debug session
+@rtype bool
 """
 return self.running
 def progTerminated(self, status, message="", closeSession=True):
 """
 def __generateFilterObjects(self, scope, filterString):
 """
 Private slot to convert a filter string to a list of filter objects.
 @param scope 1 to generate filter for global variables, 0 for local
-variables (int)
+variables
+@type int
 @param filterString string of filter patterns separated by ';'
+@type str
 """
 patternFilterObjects = None
 filterString = filterString.strip()
 if filterString:
 if filterString[0] == "~":
 def __completionList(self, text):
 """
 Private slot to handle the request for a commandline completion list.
-@param text the text to be completed (string)
+@param text the text to be completed
+@type str
 """
 completerDelims = " \t\n`~!@#$%^&*()-=+[{]}\\|;:'\",<>/?"
 completions = set()
 # find position of last delim character
 def __getCompletionList(self, text, completer, completions):
 """
 Private method to create a completions list.
-@param text text to complete (string)
+@param text text to complete
+@type str
 @param completer completer method
-@param completions set where to add new completions strings (set)
+@type function
+@param completions set where to add new completions strings
+@type set
 """
 state = 0
 try:
 comp = completer(text, state)
 except Exception:
 def run_call(self, scriptname, func, *args):
 """
 Public method used to start the remote debugger and call a function.
-@param scriptname name of the script to be debugged (string)
+@param scriptname name of the script to be debugged
+@type str
 @param func function to be called
+@type function
 @param *args arguments being passed to func
+@type list
 @return result of the function call
+@rtype Any
 """
 self.startDebugger(scriptname, enableTrace=False)
 res = self.mainThread.runcall(func, *args)
 self.progTerminated(res, closeSession=False)
 return res
 def __resolveHost(self, host):
 """
 Private method to resolve a hostname to an IP address.
-@param host hostname of the debug server (string)
+@param host hostname of the debug server
-@return IP address (string)
+@type str
+@return IP address
+@rtype str
 """
 try:
 host, version = host.split("@@")
 except ValueError:
 version = "v4"
 Public method implementing a close method as a replacement for
 os.close().
 It prevents the debugger connections from being closed.
-@param fd file descriptor to be closed (integer)
+@param fd file descriptor to be closed
+@type int
 """
 if fd in [
 self.readstream.fileno(),
 self.writestream.fileno(),
 self.errorstream.fileno(),
 def __getSysPath(self, firstEntry):
 """
 Private slot to calculate a path list including the PYTHONPATH
 environment variable.
-@param firstEntry entry to be put first in sys.path (string)
+@param firstEntry entry to be put first in sys.path
-@return path list for use as sys.path (list of strings)
+@type str
+@return path list for use as sys.path
+@rtype list of str
 """
 sysPath = [
 path
 for path in os.environ.get("PYTHONPATH", "").split(os.pathsep)
 if path not in sys.path

Mercurial Repositories > eric / file comparison

comparison: src/eric7/DebugClients/Python/DebugClientBase.py

src/eric7/DebugClients/Python/DebugClientBase.py