Function patch_thread_module

_pydev_bundle/pydev_monkey.py:1175–1240

(thread_module)

def patch_thread_module(thread_module):
    # Note: this is needed not just for the tracing, but to have an early way to
    # notify that a thread was created (i.e.: tests_python.test_debugger_json.test_case_started_exited_threads_protocol)
    start_thread_attrs = ["_start_new_thread", "start_new_thread", "start_new"]
    start_joinable_attrs = ["start_joinable_thread", "_start_joinable_thread"]
    check = start_thread_attrs + start_joinable_attrs

    replace_attrs = []
    for attr in check:
        if hasattr(thread_module, attr):
            replace_attrs.append(attr)

    if not replace_attrs:
        return

    for attr in replace_attrs:
        if attr in start_joinable_attrs:
            if getattr(thread_module, "_original_start_joinable_thread", None) is None:
                _original_start_joinable_thread = thread_module._original_start_joinable_thread = getattr(thread_module, attr)
            else:
                _original_start_joinable_thread = thread_module._original_start_joinable_thread
        else:
            if getattr(thread_module, "_original_start_new_thread", None) is None:
                _original_start_new_thread = thread_module._original_start_new_thread = getattr(thread_module, attr)
            else:
                _original_start_new_thread = thread_module._original_start_new_thread

    class ClassWithPydevStartNewThread:
        def pydev_start_new_thread(self, function, args=(), kwargs={}):
            """
            We need to replace the original thread_module.start_new_thread with this function so that threads started
            through it and not through the threading module are properly traced.
            """
            return _original_start_new_thread(_UseNewThreadStartup(function, args, kwargs), ())

    class ClassWithPydevStartJoinableThread:
        def pydev_start_joinable_thread(self, function, *args, **kwargs):
            """
            We need to replace the original thread_module._start_joinable_thread with this function so that threads started
            through it and not through the threading module are properly traced.
            """
            # Note: only handling the case from threading.py where the handle
            # and daemon flags are passed explicitly. This will fail if some user library
            # actually passes those without being a keyword argument!
            handle = kwargs.pop("handle", None)
            daemon = kwargs.pop("daemon", True)
            return _original_start_joinable_thread(_UseNewThreadStartup(function, args, kwargs), handle=handle, daemon=daemon)

    # This is a hack for the situation where the thread_module.start_new_thread is declared inside a class, such as the one below
    # class F(object):
    #    start_new_thread = thread_module.start_new_thread
    #
    #    def start_it(self):
    #        self.start_new_thread(self.function, args, kwargs)
    # So, if it's an already bound method, calling self.start_new_thread won't really receive a different 'self' -- it
    # does work in the default case because in builtins self isn't passed either.
    pydev_start_new_thread = ClassWithPydevStartNewThread().pydev_start_new_thread
    pydev_start_joinable_thread = ClassWithPydevStartJoinableThread().pydev_start_joinable_thread