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

-:7446a7eacfc3
+:663f1c3d6f53
 Module implementing an import hook patching thread modules to get debugged too.
 """
 import os
 import sys
-import importlib
 if sys.version_info[0] == 2:
 import thread as _thread
 else:
 import _thread
 def __init__(self):
 """
 Constructor
 """
 self.threadNumber = 1
-self.enableImportHooks = True
 self._original_start_new_thread = None
-self.threadingAttached = False
-self.qtThreadAttached = False
-self.greenlet = False
 self.clientLock = threading.RLock()
 # dictionary of all threads running {id: DebugBase}
 self.threads = {_thread.get_ident(): self}
 # the thread we are at a breakpoint continuing at next command
 self.currentThreadExec = self
 # special objects representing the main scripts thread and frame
 self.mainThread = self
-if sys.version_info[0] == 2:
-self.threadModName = 'thread'
-else:
-self.threadModName = '_thread'
-# reset already imported thread module to apply hooks at next import
-del sys.modules[self.threadModName]
-del sys.modules['threading']
-sys.meta_path.insert(0, self)
 def attachThread(self, target=None, args=None, kwargs=None,
 mainThread=False):
 """
 Public method to setup a standard thread for DebugClient to debug.
 # Clean up obsolet because terminated threads
 self.threads = {id_: thrd for id_, thrd in self.threads.items()
 if id_ in frames}
-def find_module(self, fullname, path=None):
+#######################################################################
-"""
+## Methods below deal with patching various modules to support
-Public method returning the module loader.
+## debugging of threads.
+#######################################################################
-@param fullname name of the module to be loaded
-@type str
+def patchPyThread(self, module):
-@param path path to resolve the module name
+"""
-@type str
+Public method to patch Python _thread (Python3) and thread (Python2)
-@return module loader object
+modules.
-@rtype object
-"""
+@param module reference to the imported module to be patched
-if fullname in sys.modules or not self.debugging:
+@type module
-return None
+"""
+# make thread hooks available to system
-if fullname in [self.threadModName, 'PyQt4.QtCore', 'PyQt5.QtCore',
+self._original_start_new_thread = module.start_new_thread
-'PySide.QtCore', 'PySide2.QtCore', 'greenlet',
+module.start_new_thread = self.attachThread
-'threading'] and self.enableImportHooks:
-# Disable hook to be able to import original module
+def patchGreenlet(self, module):
-self.enableImportHooks = False
+"""
-return self
+Public method to patch the 'greenlet' module.
-return None
+@param module reference to the imported module to be patched
+@type module
-def load_module(self, fullname):
+@return flag indicating that the module was processed
-"""
+@rtype bool
-Public method to load a module.
+"""
+# Check for greenlet.settrace
-@param fullname name of the module to be loaded
+if hasattr(module, 'settrace'):
-@type str
+DebugBase.pollTimerEnabled = False
-@return reference to the loaded module
+return True
-@rtype module
+return False
-"""
-module = importlib.import_module(fullname)
+def patchPyThreading(self, module):
-sys.modules[fullname] = module
+"""
-if (fullname == self.threadModName and
+Public method to patch the Python threading module.
-self._original_start_new_thread is None):
-# make thread hooks available to system
+@param module reference to the imported module to be patched
-self._original_start_new_thread = module.start_new_thread
+@type module
-module.start_new_thread = self.attachThread
+"""
+# _debugClient as a class attribute can't be accessed in following
-elif (fullname == 'greenlet' and self.greenlet is False):
+# class. Therefore we need a global variable.
-# Check for greenlet.settrace
+_debugClient = self
-if hasattr(module, 'settrace'):
-self.greenlet = True
+def _bootstrap(self, run):
-DebugBase.pollTimerEnabled = False
+"""
+Bootstrap for threading, which reports exceptions correctly.
-# Add hook for threading.run()
-elif (fullname == "threading" and self.threadingAttached is False):
+@param run the run method of threading.Thread
-self.threadingAttached = True
+@type method pointer
+"""
-# _debugClient as a class attribute can't be accessed in following
+newThread = DebugBase(_debugClient)
-# class. Therefore we need a global variable.
+_debugClient.threads[self.ident] = newThread
-_debugClient = self
+newThread.name = self.name
+# see DebugBase.bootstrap
-def _bootstrap(self, run):
+sys.settrace(newThread.trace_dispatch)
-"""
+try:
-Bootstrap for threading, which reports exceptions correctly.
+run()
+except Exception:
+excinfo = sys.exc_info()
+newThread.user_exception(excinfo, True)
+finally:
+sys.settrace(None)
+class ThreadWrapper(module.Thread):
+"""
+Wrapper class for threading.Thread.
+"""
+def __init__(self, *args, **kwargs):
+"""
+Constructor
+"""
+# Overwrite the provided run method with our own, to
+# intercept the thread creation by threading.Thread
+self.run = lambda s=self, run=self.run: _bootstrap(s, run)
-@param run the run method of threading.Thread
+super(ThreadWrapper, self).__init__(*args, **kwargs)
-@type method pointer
-"""
+module.Thread = ThreadWrapper
-newThread = DebugBase(_debugClient)
-_debugClient.threads[self.ident] = newThread
+# Special handling of threading.(_)Timer
-newThread.name = self.name
+if sys.version_info[0] == 2:
-# see DebugBase.bootstrap
+timer = module._Timer
-sys.settrace(newThread.trace_dispatch)
+else:
-try:
+timer = module.Timer
-run()
-except Exception:
+class TimerWrapper(timer, ThreadWrapper):
-excinfo = sys.exc_info()
+"""
-newThread.user_exception(excinfo, True)
+Wrapper class for threading.(_)Timer.
-finally:
+"""
-sys.settrace(None)
+def __init__(self, interval, function, *args, **kwargs):
+"""
-class ThreadWrapper(module.Thread):
+Constructor
 """
-Wrapper class for threading.Thread.
+super(TimerWrapper, self).__init__(
-"""
+interval, function, *args, **kwargs)
-def __init__(self, *args, **kwargs):
-"""
+if sys.version_info[0] == 2:
-Constructor
+module._Timer = TimerWrapper
-"""
+else:
-# Overwrite the provided run method with our own, to
+module.Timer = TimerWrapper
-# intercept the thread creation by threading.Thread
-self.run = lambda s=self, run=self.run: _bootstrap(s, run)
+# Special handling of threading._DummyThread
+class DummyThreadWrapper(module._DummyThread, ThreadWrapper):
-super(ThreadWrapper, self).__init__(*args, **kwargs)
+"""
+Wrapper class for threading._DummyThread.
-module.Thread = ThreadWrapper
+"""
+def __init__(self, *args, **kwargs):
-# Special handling of threading.(_)Timer
+"""
-if sys.version_info[0] == 2:
+Constructor
-timer = module._Timer
+"""
-else:
+super(DummyThreadWrapper, self).__init__(*args, **kwargs)
-timer = module.Timer
+module._DummyThread = DummyThreadWrapper
+def patchQThread(self, module):
+"""
+Public method to patch the QtCore module's QThread.
+@param module reference to the imported module to be patched
+@type module
+"""
+# _debugClient as a class attribute can't be accessed in following
+# class. Therefore we need a global variable.
+_debugClient = self
+def _bootstrapQThread(self, run):
+"""
+Bootstrap for QThread, which reports exceptions correctly.
+@param run the run method of *.QThread
+@type method pointer
+"""
+global _qtThreadNumber
+newThread = DebugBase(_debugClient)
+ident = _thread.get_ident()
+name = 'QtThread-{0}'.format(_qtThreadNumber)
+_qtThreadNumber += 1
+newThread.id = ident
+newThread.name = name
+_debugClient.threads[ident] = newThread
+# see DebugBase.bootstrap
+sys.settrace(newThread.trace_dispatch)
+try:
+run()
+except SystemExit:
+# *.QThreads doesn't like SystemExit
+pass
+except Exception:
+excinfo = sys.exc_info()
+newThread.user_exception(excinfo, True)
+finally:
+sys.settrace(None)
+class QThreadWrapper(module.QThread):
+"""
+Wrapper class for *.QThread.
+"""
+def __init__(self, *args, **kwargs):
+"""
+Constructor
+"""
+# Overwrite the provided run method with our own, to
+# intercept the thread creation by Qt
+self.run = lambda s=self, run=self.run: (
+_bootstrapQThread(s, run))
-class TimerWrapper(timer, ThreadWrapper):
+super(QThreadWrapper, self).__init__(*args, **kwargs)
-"""
-Wrapper class for threading.(_)Timer.
+module.QThread = QThreadWrapper
-"""
-def __init__(self, interval, function, *args, **kwargs):
-"""
-Constructor
-"""
-super(TimerWrapper, self).__init__(
-interval, function, *args, **kwargs)
-if sys.version_info[0] == 2:
-module._Timer = TimerWrapper
-else:
-module.Timer = TimerWrapper
-# Special handling of threading._DummyThread
-class DummyThreadWrapper(module._DummyThread, ThreadWrapper):
-"""
-Wrapper class for threading._DummyThread.
-"""
-def __init__(self, *args, **kwargs):
-"""
-Constructor
-"""
-super(DummyThreadWrapper, self).__init__(*args, **kwargs)
-module._DummyThread = DummyThreadWrapper
-# Add hook for *.QThread
-elif (fullname in ['PyQt4.QtCore', 'PyQt5.QtCore',
-'PySide.QtCore', 'PySide2.QtCore'] and
-self.qtThreadAttached is False):
-self.qtThreadAttached = True
-# _debugClient as a class attribute can't be accessed in following
-# class. Therefore we need a global variable.
-_debugClient = self
-def _bootstrapQThread(self, run):
-"""
-Bootstrap for QThread, which reports exceptions correctly.
-@param run the run method of *.QThread
-@type method pointer
-"""
-global _qtThreadNumber
-newThread = DebugBase(_debugClient)
-ident = _thread.get_ident()
-name = 'QtThread-{0}'.format(_qtThreadNumber)
-_qtThreadNumber += 1
-newThread.id = ident
-newThread.name = name
-_debugClient.threads[ident] = newThread
-# see DebugBase.bootstrap
-sys.settrace(newThread.trace_dispatch)
-try:
-run()
-except SystemExit:
-# *.QThreads doesn't like SystemExit
-pass
-except Exception:
-excinfo = sys.exc_info()
-newThread.user_exception(excinfo, True)
-finally:
-sys.settrace(None)
-class QThreadWrapper(module.QThread):
-"""
-Wrapper class for *.QThread.
-"""
-def __init__(self, *args, **kwargs):
-"""
-Constructor
-"""
-# Overwrite the provided run method with our own, to
-# intercept the thread creation by Qt
-self.run = lambda s=self, run=self.run: (
-_bootstrapQThread(s, run))
-super(QThreadWrapper, self).__init__(*args, **kwargs)
-module.QThread = QThreadWrapper
-self.enableImportHooks = True
-return module
 #
 # eflag: noqa = M702

Mercurial Repositories > eric / file comparison

comparison: eric6/DebugClients/Python/ThreadExtension.py

eric6/DebugClients/Python/ThreadExtension.py