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

-:f7cb83647621
+:72721823d453
 from DebugConfig import ConfigQtNames, ConfigVarTypeStrings
 from FlexCompleter import Completer
 from DebugUtilities import prepareJsonCommand
 from BreakpointWatch import Breakpoint, Watch
-if sys.version_info[0] == 2:
+from DebugUtilities import getargvalues, formatargvalues
-from inspect import getargvalues, formatargvalues
-else:
-unichr = chr
-from DebugUtilities import getargvalues, formatargvalues
 DebugClientInstance = None
 ###############################################################################
-def DebugClientRawInput(prompt="", echo=True):
-"""
-Replacement for the standard raw_input() builtin (Python 2) and
-the standard input() builtin (Python 3).
-This function works with the split debugger.
-@param prompt prompt to be shown
-@type str
-@param echo flag indicating echoing of the input
-@type bool
-@return result of the raw_input()/input() call
-@rtype str
-"""
-if DebugClientInstance is None or not DebugClientInstance.redirect:
-return DebugClientOrigRawInput(prompt)
-return DebugClientInstance.raw_input(prompt, echo)
 def DebugClientInput(prompt=""):
 """
-Replacement for the standard input() builtin (Python 2).
+Replacement for the standard input() builtin.
 This function works with the split debugger.
 @param prompt prompt to be shown
 @type str
 if DebugClientInstance is None or not DebugClientInstance.redirect:
 return DebugClientOrigInput(prompt)
 return DebugClientInstance.input(prompt)
-# Use our own input() and on Python 2 raw_input().
+# Use our own input().
-if sys.version_info[0] == 2:
+try:
-try:
+DebugClientOrigInput = __builtins__.__dict__['input']
-DebugClientOrigRawInput = __builtins__.__dict__['raw_input']
+__builtins__.__dict__['input'] = DebugClientInput
-__builtins__.__dict__['raw_input'] = DebugClientRawInput
+except (AttributeError, KeyError):
-except (AttributeError, KeyError):
+import __main__
-import __main__
+DebugClientOrigInput = __main__.__builtins__.__dict__['input']
-DebugClientOrigRawInput = __main__.__builtins__.__dict__['raw_input']
+__main__.__builtins__.__dict__['input'] = DebugClientInput
-__main__.__builtins__.__dict__['raw_input'] = DebugClientRawInput
-try:
-DebugClientOrigInput = __builtins__.__dict__['input']
-__builtins__.__dict__['input'] = DebugClientInput
-except (AttributeError, KeyError):
-import __main__
-DebugClientOrigInput = __main__.__builtins__.__dict__['input']
-__main__.__builtins__.__dict__['input'] = DebugClientInput
-else:
-try:
-DebugClientOrigInput = __builtins__.__dict__['input']
-__builtins__.__dict__['input'] = DebugClientRawInput
-except (AttributeError, KeyError):
-import __main__
-DebugClientOrigInput = __main__.__builtins__.__dict__['input']
-__main__.__builtins__.__dict__['input'] = DebugClientRawInput
 ###############################################################################
 def DebugClientFork():
 if m:
 self.__coding = m.group(1)
 return
 self.__coding = default
-def raw_input(self, prompt, echo):
+def input(self, prompt, echo=True):
 """
-Public method to implement raw_input() / input() using the event loop.
+Public method to implement input() using the event loop.
 @param prompt the prompt to be shown (string)
 @param echo Flag indicating echoing of the input (boolean)
 @return the entered string
 """
 "echo": echo,
 })
 self.eventLoop(True)
 return self.rawLine
-def input(self, prompt):
-"""
-Public method to implement input() (Python 2) using the event loop.
-@param prompt the prompt to be shown (string)
-@return the entered string evaluated as a Python expresion
-"""
-return eval(self.raw_input(prompt, True))
 def sessionClose(self, terminate=True):
 """
 Public method to close the session with the debugger and optionally
 terminate.
 @param terminate flag indicating to terminate (boolean)
 """
 try:
 self.set_quit()
-except Exception:
+except Exception:       # secok
 pass
 self.debugging = False
 # make sure we close down our end of the socket
 @param mode kind of code to be generated (string, exec or eval)
 @return compiled code object (None in case of errors)
 """
 with codecs.open(filename, encoding=self.__coding) as fp:
 statement = fp.read()
-if sys.version_info[0] == 2:
-lines = statement.splitlines(True)
-for lineno, line in enumerate(lines[:2]):
-lines[lineno] = self.coding_re.sub('', line)
-statement = unicode('').join(lines)  # __IGNORE_WARNING__
 try:
 code = compile(statement + '\n', filename, mode)
 except SyntaxError:
 exctype, excval, exctb = sys.exc_info()
 printerr(str(err))
 return
 method = commandDict["method"]
 params = commandDict["params"]
-if "filename" in params and sys.version_info[0] == 2:
-params["filename"] = params["filename"].encode(
-sys.getfilesystemencoding())
 if method == "RequestVariables":
 self.__dumpVariables(
 params["frameNumber"], params["scope"], params["filters"])
 self.sendJsonCommand("ResponseStack", {
 "stack": stack,
 })
 elif method == "RequestCapabilities":
-clientType = "Python2" if sys.version_info[0] == 2 else "Python3"
+clientType = "Python3"
 self.sendJsonCommand("ResponseCapabilities", {
 "capabilities": self.__clientCapabilities(),
 "clientType": clientType
 })
 if params["erase"]:
 self.prof.erase()
 self.debugMod.__dict__['__file__'] = sys.argv[0]
 sys.modules['__main__'] = self.debugMod
 script = ''
-if sys.version_info[0] == 2:
+with codecs.open(sys.argv[0], encoding=self.__coding) as fp:
-script = 'execfile({0!r})'.format(sys.argv[0])
+script = fp.read()
-else:
+if script and not script.endswith('\n'):
-with codecs.open(sys.argv[0], encoding=self.__coding) as fp:
+script += '\n'
-script = fp.read()
-if script and not script.endswith('\n'):
-script += '\n'
 if script:
 self.running = sys.argv[0]
 res = 0
 try:
 else:
 self.buffer = ''
 try:
 if self.running is None:
-exec(code, self.debugMod.__dict__)
+exec(code, self.debugMod.__dict__)      # secok
 else:
 if self.currentThread is None:
 # program has terminated
 self.running = None
 _globals = self.debugMod.__dict__
 ## reset sys.stdout to our redirector
 ## (unconditionally)
 if "sys" in _globals:
 __stdout = _globals["sys"].stdout
 _globals["sys"].stdout = self.writestream
-exec(code, _globals, _locals)
+exec(code, _globals, _locals)       # secok
 _globals["sys"].stdout = __stdout
 elif "sys" in _locals:
 __stdout = _locals["sys"].stdout
 _locals["sys"].stdout = self.writestream
-exec(code, _globals, _locals)
+exec(code, _globals, _locals)       # secok
 _locals["sys"].stdout = __stdout
 else:
-exec(code, _globals, _locals)
+exec(code, _globals, _locals)       # secok
 self.currentThread.storeFrameLocals(self.framenr)
 except SystemExit as exc:
 self.progTerminated(exc.code)
 except Exception:
 @param fn filename (string)
 @return the converted filename (string)
 """
 if os.path.isabs(fn):
-if sys.version_info[0] == 2:
-fn = fn.decode(sys.getfilesystemencoding())
 return fn
 # Check the cache.
 if fn in self._fncache:
 return self._fncache[fn]
 for p in sys.path:
 afn = os.path.abspath(os.path.join(p, fn))
 nafn = os.path.normcase(afn)
 if os.path.exists(nafn):
-if sys.version_info[0] == 2:
-afn = afn.decode(sys.getfilesystemencoding())
 self._fncache[fn] = afn
 d = os.path.dirname(afn)
 if (d not in sys.path) and (d not in self.dircache):
 self.dircache.append(d)
 return afn
 return var, ""
 def __formatQtVariable(self, value, qttype):
 """
-Private method to produce a formatted output of a simple Qt4/Qt5 type.
+Private method to produce a formatted output of a simple Qt5 type.
 @param value variable to be formatted
 @param qttype type of the Qt variable to be formatted (string)
 @return A tuple consisting of a list of formatted variables. Each
 variable entry is a tuple of three elements, the variable name,
 its type and value.
 """
 varlist = []
 if qttype == 'QChar':
 varlist.append(
-("", "QChar", "{0}".format(unichr(value.unicode()))))
+("", "QChar", "{0}".format(chr(value.unicode()))))
 varlist.append(("", "int", "{0:d}".format(value.unicode())))
 elif qttype == 'QByteArray':
 varlist.append(
 ("bytes", "QByteArray", "{0}".format(bytes(value))[2:-1]))
 varlist.append(
 if 0 in filterList and str(key)[:2] == '__':
 continue
 # special handling for '__builtins__' (it's way too big)
 if key == '__builtins__':
-rvalue = '<module __builtin__ (built-in)>'
+rvalue = '<module builtins (built-in)>'
 valtype = 'module'
 if ConfigVarTypeStrings.index(valtype) in filterList:
 continue
 else:
 isQt = False
 if "" in sysPath:
 sysPath.remove("")
 sysPath.insert(0, firstEntry)
 sysPath.insert(0, '')
 return sysPath
-#
-# eflag: noqa = M702

Mercurial Repositories > eric / file comparison

comparison: eric6/DebugClients/Python/DebugClientBase.py

eric6/DebugClients/Python/DebugClientBase.py