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

-:61566f35ab22
+:c878e8255972
 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):
+def DebugClientRawInput(prompt=""):
 """
-Replacement for the standard raw_input() builtin (Python 2) and
+Replacement for the standard input() builtin.
-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).
-This function works with the split debugger.
-@param prompt prompt to be shown
-@type str
-@return result of the input() call
-@rtype 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'] = DebugClientRawInput
-__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'] = DebugClientRawInput
-__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):
 """
-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
 """
 self.sendJsonCommand("RequestRaw", {
 "prompt": prompt,
-"echo": echo,
+"echo": True,
 })
 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))       # secok
 def sessionClose(self, terminate=True):
 """
 Public method to close the session with the debugger and optionally
 terminate.
 @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:
 @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
 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(

Mercurial Repositories > eric / file comparison

comparison: eric6/DebugClients/Python/DebugClientBase.py

eric6/DebugClients/Python/DebugClientBase.py