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

-:e9e7eca7efee
+:bf71ee032bb4
 else:
 mod_dict = globals()
 for k, v in COMPILER_FLAG_NAMES.items():
 mod_dict["CO_" + v] = k
-ArgInfo = namedtuple('ArgInfo', 'args varargs keywords locals')
+ArgInfo = namedtuple("ArgInfo", "args varargs keywords locals")
 def getargvalues(frame):
 """
 Function to get information about arguments passed into a
 particular frame.
 @param frame reference to a frame object to be processed
 @type frame
 @return tuple of four things, where 'args' is a list of the argument names,
 'varargs' and 'varkw' are the names of the * and ** arguments or None
 and 'locals' is the locals dictionary of the given frame.
 @exception TypeError raised if the input parameter is not a frame object
 """
 if not isframe(frame):
-raise TypeError('{0!r} is not a frame object'.format(frame))
+raise TypeError("{0!r} is not a frame object".format(frame))
 args, varargs, kwonlyargs, varkw = _getfullargs(frame.f_code)
 return ArgInfo(args + kwonlyargs, varargs, varkw, frame.f_locals)
 def _getfullargs(co):
 """
 Protected function to get information about the arguments accepted
 by a code object.
 @param co reference to a code object to be processed
 @type code
 @return tuple of four things, where 'args' and 'kwonlyargs' are lists of
 argument names, and 'varargs' and 'varkw' are the names of the
 * and ** arguments or None.
 @exception TypeError raised if the input parameter is not a code object
 """
 if not iscode(co):
-raise TypeError('{0!r} is not a code object'.format(co))
+raise TypeError("{0!r} is not a code object".format(co))
 nargs = co.co_argcount
 names = co.co_varnames
 nkwargs = co.co_kwonlyargcount
 args = list(names[:nargs])
-kwonlyargs = list(names[nargs:nargs + nkwargs])
+kwonlyargs = list(names[nargs : nargs + nkwargs])
 nargs += nkwargs
 varargs = None
 if co.co_flags & CO_VARARGS:
 varargs = co.co_varnames[nargs]
 if co.co_flags & CO_VARKEYWORDS:
 varkw = co.co_varnames[nargs]
 return args, varargs, kwonlyargs, varkw
-def formatargvalues(args, varargs, varkw, localsDict,
+def formatargvalues(
-formatarg=str,
+args,
-formatvarargs=lambda name: '*' + name,
+varargs,
-formatvarkw=lambda name: '**' + name,
+varkw,
-formatvalue=lambda value: '=' + repr(value)):
+localsDict,
+formatarg=str,
+formatvarargs=lambda name: "*" + name,
+formatvarkw=lambda name: "**" + name,
+formatvalue=lambda value: "=" + repr(value),
+):
 """
 Function to format an argument spec from the 4 values returned
 by getargvalues.
 @param args list of argument names
 @type list of str
 @param varargs name of the variable arguments
 @type str
 @param varkw name of the keyword arguments
 specs.append(formatarg(name) + formatvalue(localsDict[name]))
 if varargs:
 specs.append(formatvarargs(varargs) + formatvalue(localsDict[varargs]))
 if varkw:
 specs.append(formatvarkw(varkw) + formatvalue(localsDict[varkw]))
-argvalues = '(' + ', '.join(specs) + ')'
+argvalues = "(" + ", ".join(specs) + ")"
-if '__return__' in localsDict:
+if "__return__" in localsDict:
-argvalues += " -> " + formatvalue(localsDict['__return__'])
+argvalues += " -> " + formatvalue(localsDict["__return__"])
 return argvalues
 def prepareJsonCommand(method, params):
 """
 Function to prepare a single command or response for transmission to
 the IDE.
 @param method command or response name to be sent
 @type str
 @param params dictionary of named parameters for the command or response
 @type dict
 @return prepared JSON command or response string
 commandDict = {
 "jsonrpc": "2.0",
 "method": method,
 "params": params,
 }
-return json.dumps(commandDict) + '\n'
+return json.dumps(commandDict) + "\n"
 ###########################################################################
 ## Things related to monkey patching below
 ###########################################################################
 def isWindowsPlatform():
 """
 Function to check, if this is a Windows platform.
 @return flag indicating Windows platform
 @rtype bool
 """
 return sys.platform.startswith(("win", "cygwin"))
 def isExecutable(program):
 """
 Function to check, if the given program is executable.
 @param program program path to be checked
 @type str
 @return flag indicating an executable program
 @rtype bool
 """
 def startsWithShebang(program):
 """
 Function to check, if the given program start with a Shebang line.
 @param program program path to be checked
 @type str
 @return flag indicating an existing and valid shebang line
 @rtype bool
 """
 if os.path.exists(program):
 with open(program) as f:
 for line in f:
 line = line.strip()
 if line:
-for name in PYTHON_NAMES:   # __IGNORE_WARNING_Y110__
+for name in PYTHON_NAMES:  # __IGNORE_WARNING_Y110__
-if (
+if line.startswith("#!/usr/bin/env {0}".format(name)) or (
-line.startswith(
+line.startswith("#!") and name in line
-'#!/usr/bin/env {0}'.format(name)) or
-(line.startswith('#!') and name in line)
 ):
 return True
 return False
 else:
 return False
 def isPythonProgram(program):
 """
 Function to check, if the given program is a Python interpreter or
 program.
 @param program program to be checked
 @type str
 @return flag indicating a Python interpreter or program
 @rtype bool
 """
 if not program:
 return False
 prog = os.path.basename(program).lower()
 if any(pyname in prog for pyname in PYTHON_NAMES):
 return True
 return (
-not isWindowsPlatform() and
+not isWindowsPlatform() and isExecutable(program) and startsWithShebang(program)
-isExecutable(program) and
-startsWithShebang(program)
 )
 def removeQuotesFromArgs(args):
 """
 Function to remove quotes from the arguments list.
 @param args list of arguments
 @type list of str
 @return list of unquoted strings
 @rtype list of str
 """
 def quoteArgs(args):
 """
 Function to quote the given list of arguments.
 @param args list of arguments to be quoted
 @type list of str
 @return list of quoted arguments
 @rtype list of str
 """
 quotedArgs = []
 for x in args:
 if x.startswith('"') and x.endswith('"'):
 quotedArgs.append(x)
 else:
-if ' ' in x:
+if " " in x:
 x = x.replace('"', '\\"')
 quotedArgs.append('"{0}"'.format(x))
 else:
 quotedArgs.append(x)
 return quotedArgs
 def patchArguments(debugClient, arguments, noRedirect=False):
 """
 Function to patch the arguments given to start a program in order to
 execute it in our debugger.
 @param debugClient reference to the debug client object
 @type DebugClient
 @param arguments list of program arguments
 @type list of str
 @param noRedirect flag indicating to not redirect stdin and stdout
 @type bool
 @return modified argument list
 @rtype list of str
 """
-debugClientScript = os.path.join(
+debugClientScript = os.path.join(os.path.dirname(__file__), "DebugClient.py")
-os.path.dirname(__file__), "DebugClient.py")
 if debugClientScript in arguments:
 # it is already patched
 return arguments
-args = list(arguments[:])    # create a copy of the arguments list
+args = list(arguments[:])  # create a copy of the arguments list
 args = removeQuotesFromArgs(args)
 # support for shebang line
 program = os.path.basename(args[0]).lower()
 for pyname in PYTHON_NAMES:
 if pyname in program:
 break
 else:
-if (
+if (not isWindowsPlatform() and startsWithShebang(args[0])) or (
-(not isWindowsPlatform() and startsWithShebang(args[0])) or
+isWindowsPlatform() and args[0].lower().endswith(".py")
-(isWindowsPlatform() and args[0].lower().endswith(".py"))
 ):
 # 1. insert our interpreter as first argument if not Windows
 # 2. insert our interpreter as first argument if on Windows and
 #    it is a Python script
 args.insert(0, sys.executable)
 # extract list of interpreter arguments, i.e. all arguments before the
 # first one not starting with '-'.
 interpreter = args.pop(0)
 interpreterArgs = []
 hasCode = False
 break
 else:
 interpreterArgs.append(args.pop(0))
 else:
 break
-(wd, host, port, exceptions, tracePython, redirect, noencoding
+(
-) = debugClient.startOptions[:7]
+wd,
+host,
+port,
+exceptions,
+tracePython,
+redirect,
+noencoding,
+) = debugClient.startOptions[:7]
 modifiedArguments = [interpreter]
 modifiedArguments.extend(interpreterArgs)
-modifiedArguments.extend([
+modifiedArguments.extend(
-debugClientScript,
+[
-"-h", host,
+debugClientScript,
-"-p", str(port),
+"-h",
-"--no-passive",
+host,
-])
+"-p",
+str(port),
+"--no-passive",
+]
+)
 if wd:
 modifiedArguments.extend(["-w", wd])
 if not exceptions:
 modifiedArguments.append("-e")
 if tracePython:
 if hasScriptModule:
 modifiedArguments.append("--module")
 modifiedArguments.append(args.pop(0))
 modifiedArguments.append("--")
 # end the arguments for DebugClient
 # append the arguments for the program to be debugged
 modifiedArguments.extend(args)
 modifiedArguments = quoteArgs(modifiedArguments)
 return modifiedArguments
 def stringToArgumentsWindows(args):
 """
 Function to prepare a string of arguments for Windows platform.
 @param args list of command arguments
 @type str
 @return list of command arguments
 @rtype list of str
 @exception RuntimeError raised to indicate an illegal arguments parsing
 condition
 """
 # see http://msdn.microsoft.com/en-us/library/a1y7w461.aspx
 result = []
 DEFAULT = 0
 ARG = 1
 IN_DOUBLE_QUOTE = 2
 state = DEFAULT
 backslashes = 0
-buf = ''
+buf = ""
 argsLen = len(args)
 i = 0
 while i < argsLen:
 ch = args[i]
-if ch == '\\':
+if ch == "\\":
 backslashes += 1
 i += 1
 continue
 elif backslashes != 0:
 if ch == '"':
 while backslashes >= 2:
 backslashes -= 2
-buf += '\\'
+buf += "\\"
 if backslashes == 1:
 if state == DEFAULT:
 state = ARG
 buf += '"'
 backslashes = 0
 i += 1
 continue
 else:
 # false alarm, treat passed backslashes literally...
 if state == DEFAULT:
 state = ARG
 while backslashes > 0:
 backslashes -= 1
-buf += '\\'
+buf += "\\"
-if ch in (' ', '\t'):
+if ch in (" ", "\t"):
 if state == DEFAULT:
 # skip
 i += 1
 continue
 elif state == ARG:
 state = DEFAULT
 result.append(buf)
-buf = ''
+buf = ""
 i += 1
 continue
 if state not in (DEFAULT, ARG, IN_DOUBLE_QUOTE):
-raise RuntimeError('Illegal condition')
+raise RuntimeError("Illegal condition")
 if state == IN_DOUBLE_QUOTE:
 if ch == '"':
 if i + 1 < argsLen and args[i + 1] == '"':
 # Undocumented feature in Windows:
 # Two consecutive double quotes inside a double-quoted
 # argument are interpreted as a single double quote.
 buf += '"'
 i += 1
 elif len(buf) == 0:
-result.append("\"\"")
+result.append('""')
 state = DEFAULT
 else:
 state = ARG
 else:
 buf += ch
 else:
 if ch == '"':
 state = IN_DOUBLE_QUOTE
 else:
 state = ARG
 buf += ch
 i += 1
 if len(buf) > 0 or state != DEFAULT:
 result.append(buf)
 return result
 def patchArgumentStringWindows(debugClient, argStr):
 """
 Function to patch an argument string for Windows.
 @param debugClient reference to the debug client object
 @type DebugClient
 @param argStr argument string
 @type str
 @return patched argument string
 @rtype str
 """
 args = stringToArgumentsWindows(argStr)
 if not args or not isPythonProgram(args[0]):
 return argStr
-argStr = ' '.join(patchArguments(debugClient, args))
+argStr = " ".join(patchArguments(debugClient, args))
 return argStr

Mercurial Repositories > eric / file comparison

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

src/eric7/DebugClients/Python/DebugUtilities.py