Pycharm debugger not stopping on QThread breakpoints

Interesting, I've had the same issue for many months, but I just assumed Pycharm Debugger didn't work well with PyQt.

However, a Qt4-Qt5 issue on matplotlib made me dig deeper, and what was my surprise when I realized that Pycharm was the culprit!! Basically, matplotlib chooses between PyQt4 or PyQt5 based on which one has already been imported to sys.modules [if none of them have been imported yet, then it chooses based on a user setting]. And matplotlib was breaking because my setting was to use PyQt5 but PyQt4 was in my sys.modules even though *I had never imported it*! When I ran the same script from the Terminal, it worked perfectly and matplotlib didn't break, and it was using PyQt5 as I had requested.

So here's what I found: in order to debug QThreads, PyCharm patches PyQt imports to insert hooks that will allow the debugger to trace QThreads. This is done in the file `/Applications/PyCharm.app/Contents/helpers/pydev/_pydev_bundle/pydev_monkey_qt.py` (I assume windows will have a similar file structure rooted on the `Contents` folder).

Here's what's interesting: PyCharm determines which PyQt version to insert the hooks on by trying to load, *in this order*, PySide, PyQt4 and PyQt5 (instead of patching them all which is what seems logical to me). That means that if you have more than one of those modules installed (I have both PyQt4 and PyQt5), it'll only allow you to debug the one that comes earlier in that order (PyQt4 in my case). So I simply changed the order of imports to try PyQt5 *before* trying to import PyQt4, and... SUPRISE!!! Now the debugger stops in my QThreads!! Woooo :)

In case anyone is interested, here's my patched version of `pydev_monkey_qt.py` (line 12 defines whether qt5 should be preferred over qt4 or not, through the boolean variable `_prioritize_qt5`):

from __future__ import nested_scopes

def set_trace_in_qt():
    from _pydevd_bundle import pydevd_tracing
    from _pydevd_bundle.pydevd_comm import get_global_debugger
    debugger = get_global_debugger()
    if debugger is not None:
        pydevd_tracing.SetTrace(debugger.trace_dispatch)


_patched_qt = False
_prioritize_qt5 = True
def patch_qt():
    '''
    This method patches qt (PySide, PyQt4, PyQt5) so that we have hooks to set the tracing for QThread.
    '''

    # Avoid patching more than once
    global _patched_qt
    if _patched_qt:
        return

    _patched_qt = True


    # Ok, we have an issue here:
    # PyDev-452: Selecting PyQT API version using sip.setapi fails in debug mode
    # http://pyqt.sourceforge.net/Docs/PyQt4/incompatible_apis.html
    # Mostly, if the user uses a different API version (i.e.: v2 instead of v1),
    # that has to be done before importing PyQt4/5 modules (PySide doesn't have this issue
    # as it only implements v2).

    patch_qt_on_import = None
    try:
        import PySide  # @UnresolvedImport @UnusedImport
    except:
        try:
            if _prioritize_qt5:
                import PyQt5  # @UnresolvedImport @UnusedImport
                patch_qt_on_import = 'PyQt5'
            else:
                import PyQt4  # @UnresolvedImport @UnusedImport
                patch_qt_on_import = 'PyQt4'
        except:
            try:
                if _prioritize_qt5:
                    import PyQt4  # @UnresolvedImport @UnusedImport
                    patch_qt_on_import = 'PyQt4'
                else:
                    import PyQt5  # @UnresolvedImport @UnusedImport
                    patch_qt_on_import = 'PyQt5'
            except:
                return

    if patch_qt_on_import:
        _patch_import_to_patch_pyqt_on_import(patch_qt_on_import)
    else:
        _internal_patch_qt()


def _patch_import_to_patch_pyqt_on_import(patch_qt_on_import):
    # I don't like this approach very much as we have to patch __import__, but I like even less
    # asking the user to configure something in the client side...
    # So, our approach is to patch PyQt4/5 right before the user tries to import it (at which
    # point he should've set the sip api version properly already anyways).

    dotted = patch_qt_on_import + '.'
    original_import = __import__

    from _pydev_imps._pydev_sys_patch import patch_sys_module, patch_reload, cancel_patches_in_sys_module

    patch_sys_module()
    patch_reload()

    def patched_import(name, *args, **kwargs):
        if patch_qt_on_import == name or name.startswith(dotted):
            builtins.__import__ = original_import
            cancel_patches_in_sys_module()
            _internal_patch_qt() # Patch it only when the user would import the qt module
        return original_import(name, *args, **kwargs)

    try:
        import builtins
    except ImportError:
        import __builtin__ as builtins
    builtins.__import__ = patched_import


def _internal_patch_qt():
    try:
        from PySide import QtCore # @UnresolvedImport @UnusedImport
    except:
        try:
            if _prioritize_qt5:
                from PyQt5 import QtCore # @UnresolvedImport @UnusedImport @Reimport
            else:
                from PyQt4 import QtCore # @UnresolvedImport @UnusedImport @Reimport
        except:
            try:
                if _prioritize_qt5:
                    from PyQt4 import QtCore # @UnresolvedImport @UnusedImport @Reimport
                else:
                    from PyQt5 import QtCore # @UnresolvedImport @UnusedImport @Reimport
            except:
                return

    _original_thread_init = QtCore.QThread.__init__
    _original_runnable_init = QtCore.QRunnable.__init__
    _original_QThread = QtCore.QThread


    class FuncWrapper:

        def __init__(self, original):
            self._original = original

        def __call__(self, *args, **kwargs):
            set_trace_in_qt()
            return self._original(*args, **kwargs)

    class StartedSignalWrapper:  # Wrapper for the QThread.started signal

        def __init__(self, thread, original_started):
            self.thread = thread
            self.original_started = original_started

        def connect(self, func, *args, **kwargs):
            return self.original_started.connect(FuncWrapper(func), *args, **kwargs)

        def disconnect(self, *args, **kwargs):
            return self.original_started.disconnect(*args, **kwargs)

        def emit(self, *args, **kwargs):
            return self.original_started.emit(*args, **kwargs)


    class ThreadWrapper(QtCore.QThread):  # Wrapper for QThread

        def __init__(self, *args, **kwargs):
            _original_thread_init(self, *args, **kwargs)

            # In PyQt5 the program hangs when we try to call original run method of QThread class.
            # So we need to distinguish instances of QThread class and instances of QThread inheritors.
            if self.__class__.run == _original_QThread.run:
                self.run = self._exec_run
            else:
                self._original_run = self.run
                self.run = self._new_run
            self._original_started = self.started
            self.started = StartedSignalWrapper(self, self.started)

        def _exec_run(self):
            set_trace_in_qt()
            self.exec_()
            return None

        def _new_run(self):
            set_trace_in_qt()
            return self._original_run()

    class RunnableWrapper(QtCore.QRunnable):  # Wrapper for QRunnable

        def __init__(self, *args, **kwargs):
            _original_runnable_init(self, *args, **kwargs)

            self._original_run = self.run
            self.run = self._new_run


        def _new_run(self):
            set_trace_in_qt()
            return self._original_run()

    QtCore.QThread = ThreadWrapper
    QtCore.QRunnable = RunnableWrapper

Thanks for the hint, @Carlos. In my case, I tried to install pyside (on OSX) but it was so broken I gave up and went with PyQt5. I had both installed via brew. I didn't have pyside imports in my program. After I removed pyside with brew, the breakpoints in QThreads started to work. This is definitely a bug in PyCharm.

Hi dear all,
Please add one more affected run. Seems to be same issue:

```

/home/sh/REPOS/python3_5_3/bin/python /opt/pycharm-2016.3.2/helpers/pydev/pydevd.py --multiproc --qt-support --client 127.0.0.1 --port 44604 --file /home/sh/REPOS/python3_5_3/bin/autoxtrabackup --backup -v -l DEBUG --defaults_file=/home/sh/txt.ff
PYDEVD_FILTER_LIBRARIES False

Started in multiproc mode

('Connecting to ', '127.0.0.1', ':', '44604')
('Connected.',)
debugger: received >>99    -1    41977
<<
Received command: ??? 99    -1    41977

Received port 41977

pydev debugger: process 16580 is connecting

Connected to pydev debugger (build 163.10154.50)
('Connecting to ', '127.0.0.1', ':', '41977')
('Connected.',)
debugger: received >>501    1    0.1    UNIX
<<
Received command: CMD_VERSION 501    1    0.1    UNIX

sending cmd -->          CMD_VERSION 501    1    @@BUILD_NUMBER@@
debugger: received >>111    3    python-line    /home/sh/REPOS/MySQL-AutoXtraBackup/autoxtrabackup.py    53    all_procedure    ALL    None    None
<<
Received command: CMD_SET_BREAK 111    3    python-line    /home/sh/REPOS/MySQL-AutoXtraBackup/autoxtrabackup.py    53    all_procedure    ALL    None    None

Added breakpoint:/home/sh/REPOS/MySQL-AutoXtraBackup/autoxtrabackup.py - line:53 - func_name:b'all_procedure'

debugger: received >>146    5    SHOW_RETURN_VALUES    0
101    7    
<<
Received command: CMD_SHOW_RETURN_VALUES 146    5    SHOW_RETURN_VALUES    0

Show return values: False

Received command: CMD_RUN 101    7    

IDE_PROJECT_ROOTS ['/home/sh/REPOS/MySQL-AutoXtraBackup']

Patching args: ['/bin/sh', '-c', 'uname -p 2> /dev/null']
Process is not python, returning.
sending cmd -->  CMD_PROCESS_CREATED 149    2    <process/>
Traceback (most recent call last):
  File "/opt/pycharm-2016.3.2/helpers/pydev/pydevd.py", line 1596, in <module>
    globals = debugger.run(setup['file'], None, None, is_module)
  File "/opt/pycharm-2016.3.2/helpers/pydev/pydevd.py", line 974, in run
    pydev_imports.execfile(file, globals, locals)  # execute the script
  File "/opt/pycharm-2016.3.2/helpers/pydev/_pydev_imps/_pydev_execfile.py", line 18, in execfile
    exec(compile(contents+"\n", file, 'exec'), glob, loc)
  File "/home/sh/REPOS/python3_5_3/bin/autoxtrabackup", line 11, in <module>
    load_entry_point('mysql-autoxtrabackup==1.4.4', 'console_scripts', 'autoxtrabackup')()
  File "/home/sh/REPOS/python3_5_3/lib/python3.5/site-packages/click/core.py", line 722, in __call__
    return self.main(*args, **kwargs)
  File "/home/sh/REPOS/python3_5_3/lib/python3.5/site-packages/click/core.py", line 697, in main
    rv = self.invoke(ctx)
  File "/home/sh/REPOS/python3_5_3/lib/python3.5/site-packages/click/core.py", line 895, in invoke
    return ctx.invoke(self.callback, **ctx.params)
  File "/home/sh/REPOS/python3_5_3/lib/python3.5/site-packages/click/core.py", line 535, in invoke
    return callback(*args, **kwargs)
  File "/home/sh/REPOS/python3_5_3/lib/python3.5/site-packages/mysql_autoxtrabackup-1.4.4-py3.5.egg/autoxtrabackup.py", line 69, in all_procedure
    with pid_file: # User PidFile for locking to single instance
UnboundLocalError: local variable 'pid_file' referenced before assignment
'MySQL'

Process finished with exit code 1

```

Hi everyone! Since PyCharm 2017.1.1 you can define PyQt backend for debug session by setting environment variable PYDEVD_PYQT_MODE to 'pyqt4', 'pyqt5' or 'pyside'. It helps to solve the problem described in the original post.

I finally have this issue resolved, but it appears to be due to all the breakpoints I had set in other programs? After following the above recommendations with environment variables, I still couldn't get the debugger to stop on any breakpoints (running version 2017.1.4). However, upon clicking the view all breakpoints button (the icon with two red circles in the debug section...see image), the debugger now works. I obviuosly don't know enough about the debugger to understand why this fixed things, but after several hours of frustration, I'm just glad it works...hopefully this will help someone else out too.