eric: comparison DebugClients/Python/DebugClientBase.py

-:878ce843ca9f
+:5f56410e7624
 # -*- coding: utf-8 -*-
-# Copyright (c) 2009 - 2016 Detlev Offenbach <detlev@die-offenbachs.de>
+# Copyright (c) 2002 - 2016 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing a debug client base class.
 """
 import sys
 import socket
 import select
 import codeop
+import codecs
 import traceback
 import os
 import json
 import imp
 import re
 import DebugVariables
 from DebugBase import setRecursionLimit, printerr   # __IGNORE_WARNING__
 from AsyncFile import AsyncFile, AsyncPendingWrite
 from DebugConfig import ConfigVarTypeStrings
 from FlexCompleter import Completer
-from DebugUtilities import getargvalues, formatargvalues, prepareJsonCommand
+from DebugUtilities import prepareJsonCommand
 from BreakpointWatch import Breakpoint, Watch
+if sys.version_info[0] == 2:
+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.
+This function works with the split debugger.
+@param prompt prompt to be shown. (string)
+@param echo flag indicating echoing of the input (boolean)
+@return result of the raw_input() call
+"""
+if DebugClientInstance is None or not DebugClientInstance.redirect:
+return DebugClientOrigRawInput(prompt)
+return DebugClientInstance.raw_input(prompt, echo)
 def DebugClientInput(prompt="", echo=True):
 """
 Replacement for the standard input builtin.
 if DebugClientInstance is None or not DebugClientInstance.redirect:
 return DebugClientOrigInput(prompt)
 return DebugClientInstance.input(prompt, echo)
-# Use our own input().
+# Use our own input() and on Python 2 raw_input().
-try:
+if sys.version_info[0] == 2:
-DebugClientOrigInput = __builtins__.__dict__['input']
+try:
-__builtins__.__dict__['input'] = DebugClientInput
+DebugClientOrigRawInput = __builtins__.__dict__['raw_input']
-except (AttributeError, KeyError):
+__builtins__.__dict__['raw_input'] = DebugClientRawInput
-import __main__
+except (AttributeError, KeyError):
-DebugClientOrigInput = __main__.__builtins__.__dict__['input']
+import __main__
-__main__.__builtins__.__dict__['input'] = DebugClientInput
+DebugClientOrigRawInput = __main__.__builtins__.__dict__['raw_input']
+__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():
 f.close()
 except IOError:
 self.__coding = default
 return
-for l in text.splitlines():
+for line in text.splitlines():
-m = self.coding_re.search(l)
+m = self.coding_re.search(line)
 if m:
 self.__coding = m.group(1)
 return
 self.__coding = default
 self.sendJsonCommand("ResponseThreadList", {
 "currentID": currentId,
 "threadList": threadList,
 })
-def input(self, prompt, echo=True):
+def raw_input(self, prompt, echo):
 """
-Public method to implement input() using the event loop.
+Public method to implement raw_input() / 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, exit=True):
 """
 Public method to close the session with the debugger and optionally
 terminate.
 @param filename name of the source file (string)
 @param mode kind of code to be generated (string, exec or eval)
 @return compiled code object (None in case of errors)
 """
-with open(filename, encoding=self.__coding) as fp:
+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"
 self.sendJsonCommand("ResponseCapabilities", {
 "capabilities": self.__clientCapabilities(),
-"clientType": "Python3"
+"clientType": clientType
 })
 elif method == "RequestBanner":
 self.sendJsonCommand("ResponseBanner", {
 "version": "Python {0}".format(sys.version),
 if params["erase"]:
 self.cover.erase()
 sys.modules['__main__'] = self.debugMod
 self.debugMod.__dict__['__file__'] = sys.argv[0]
-fp = open(sys.argv[0], encoding=self.__coding)
+code = self.__compileFileSource(sys.argv[0])
-try:
+if code:
-script = fp.read()
-finally:
-fp.close()
-if script:
-if not script.endswith('\n'):
-script += '\n'
-code = compile(script, sys.argv[0], 'exec')
 self.running = sys.argv[0]
 res = 0
 self.cover.start()
 try:
 exec(code, self.debugMod.__dict__)
 if params["erase"]:
 self.prof.erase()
 self.debugMod.__dict__['__file__'] = sys.argv[0]
 sys.modules['__main__'] = self.debugMod
-fp = open(sys.argv[0], encoding=self.__coding)
+script = ''
-try:
+if sys.version_info[0] == 2:
-script = fp.read()
+script = 'execfile({0!r})'.format(sys.argv[0])
-finally:
+else:
-fp.close()
+with codecs.open(sys.argv[0], encoding=self.__coding) as fp:
+script = fp.read()
+if script and not script.endswith('\n'):
+script += '\n'
 if script:
-if not script.endswith('\n'):
-script += '\n'
 self.running = sys.argv[0]
 res = 0
 try:
 self.prof.run(script)
 except SystemExit as exc:
 res = exc.code
-atexit._run_exitfuncs()
+atexit._run_exitfuncs()
 self.prof.save()
 self.writestream.flush()
 self.progTerminated(res)
 elif method == "ExecuteStatement":
 else:
 compiledCond = params["condition"]
 flag = ''
 try:
-compiledCond = compile(
+compiledCond = compile(compiledCond, '<string>', 'eval')
-compiledCond, '<string>', 'eval')
 except SyntaxError:
 self.sendJsonCommand("ResponseWatchConditionError", {
 "condition": params["condition"],
 })
 return
 variable entry is a tuple of three elements, the variable name,
 its type and value.
 """
 varlist = []
 if qttype == 'QChar':
-varlist.append(("", "QChar", "{0}".format(chr(value.unicode()))))
+varlist.append(
+("", "QChar", "{0}".format(unichr(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(
 ("hex", "QByteArray", "{0}".format(value.toHex())[2:-1]))
 varlist.append(
 ("base64", "QByteArray", "{0}".format(value.toBase64())[2:-1]))
 varlist.append(("percent encoding", "QByteArray",
 "{0}".format(value.toPercentEncoding())[2:-1]))
+elif qttype == 'QString':
+varlist.append(("", "QString", "{0}".format(value)))
+elif qttype == 'QStringList':
+for i in range(value.count()):
+varlist.append(
+("{0:d}".format(i), "QString", "{0}".format(value[i])))
 elif qttype == 'QPoint':
 varlist.append(("x", "int", "{0:d}".format(value.x())))
 varlist.append(("y", "int", "{0:d}".format(value.y())))
 elif qttype == 'QPointF':
 varlist.append(("x", "float", "{0:g}".format(value.x())))
 varlist.append(
 ("address", "QHostAddress", "{0}".format(value.toString())))
 return varlist
-def __formatVariablesList(self, keylist, dict, scope, filter=[],
+def __formatVariablesList(self, keylist, dict_, scope, filter=[],
 formatSequences=False):
 """
 Private method to produce a formated variables list.
 The dictionary passed in to it is scanned. Variables are
 in the filter list and their name doesn't match any of the filter
 expressions. The formated variables list (a list of tuples of 3
 values) is returned.
 @param keylist keys of the dictionary
-@param dict the dictionary to be scanned
+@param dict_ the dictionary to be scanned
 @param scope 1 to filter using the globals filter, 0 using the locals
 filter (int).
 Variables are only added to the list, if their name do not match
 any of the filter expressions.
 @param filter the indices of variable types to be filtered. Variables
 # special handling for '__builtins__' (it's way too big)
 if key == '__builtins__':
 rvalue = '<module __builtin__ (built-in)>'
 valtype = 'module'
 else:
-value = dict[key]
+value = dict_[key]
 valtypestr = str(type(value))[1:-1]
-valtype = valtypestr[7:-1]
+_, valtype = valtypestr.split(' ', 1)
+valtype = valtype[1:-1]
 if valtype not in ConfigVarTypeStrings:
 if ConfigVarTypeStrings.index('instance') in filter:
 continue
 elif valtype == "sip.methoddescriptor":
 if ConfigVarTypeStrings.index(
 version = 'v4'
 if version == 'v4':
 family = socket.AF_INET
 else:
 family = socket.AF_INET6
-return socket.getaddrinfo(host, None,
+return socket.getaddrinfo(host, None, family,
-family, socket.SOCK_STREAM)[0][4][0]
+socket.SOCK_STREAM)[0][4][0]
 def main(self):
 """
 Public method implementing the main method.
 """

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/DebugClientBase.py

DebugClients/Python/DebugClientBase.py