Rewrite and greatly simplify qt_compat.py.

anntzer · anntzer · commit 55a9d88dafdb · 2017-12-13T12:13:49.000-08:00
The selection logic is now described in the module's docstring.  The
only changes is that the QT_ENV_MAJOR_VERSION global, which would
sometimes be defined (depending on the state of the import cache, the
QT_API environment variable, and the requested backend) is never defined
anymore.
diff --git a/INSTALL.rst b/INSTALL.rst
@@ -189,8 +189,9 @@ interface toolkits. See :ref:`what-is-a-backend` for more details on the
 optional Matplotlib backends and the capabilities they provide.
 
   * :term:`tk` (>= 8.3, != 8.6.0 or 8.6.1): for the TkAgg backend;
-  * `PyQt4 <https://pypi.python.org/pypi/PyQt4>`_ (>= 4.4) or
-    `PySide <https://pypi.python.org/pypi/PySide>`_: for the Qt4Agg backend;
+  * `PyQt4 <https://pypi.python.org/pypi/PyQt4>`_ (>= 4.6) or
+    `PySide <https://pypi.python.org/pypi/PySide>`_ (>= 1.0.3): for the Qt4Agg
+    backend;
   * `PyQt5 <https://pypi.python.org/pypi/PyQt5>`_: for the Qt5Agg backend;
   * :term:`pygtk` (>= 2.4): for the GTK and the GTKAgg backend;
   * :term:`wxpython` (>= 2.9 or later): for the WX or WXAgg backend;
diff --git a/doc/conf.py b/doc/conf.py
@@ -355,6 +355,9 @@ class Frame(object):
 
 
 class MyPyQt4(MagicMock):
+    class QtCore(MagicMock):
+        PYQT_VERSION_STR = "4.6"
+
     class QtGui(object):
         # PyQt4.QtGui public classes.
         # Generated with
@@ -450,6 +453,9 @@ class QtGui(object):
             locals()[_name] = type(_name, (), {})
         del _name
 
+    QtCore = QtCore()
+    QtGui = QtGui()
+
 
 class MySip(MagicMock):
     def getapi(*args):
diff --git a/lib/matplotlib/backends/qt_compat.py b/lib/matplotlib/backends/qt_compat.py
@@ -1,227 +1,144 @@
-""" A Qt API selector that can be used to switch between PyQt and PySide.
 """
+Qt binding and backend selector.
+
+The selection logic is as follows:
+- if any of PyQt5, PySide2, PyQt4 or PySide have already been imported (checked
+  in that order), use it;
+- otherwise, if the QT_API environment variable (used by Enthought) is
+  set, use it to determine which binding to use (but do not change the
+  backend based on it; i.e. if the Qt4Agg backend is requested but QT_API
+  is set to "pyqt5", then actually use Qt4 with the binding specified by
+  ``rcParams["backend.qt4"]``;
+- otherwise, use whatever the rcParams indicate.
+"""
+
 from __future__ import (absolute_import, division, print_function,
                         unicode_literals)
 
 import six
 
+from distutils.version import LooseVersion
 import os
-import logging
 import sys
-from matplotlib import rcParams
 
-_log = logging.getLogger(__name__)
-
-# Available APIs.
-QT_API_PYQT = 'PyQt4'       # API is not set here; Python 2.x default is V 1
-QT_API_PYQTv2 = 'PyQt4v2'   # forced to Version 2 API
-QT_API_PYSIDE = 'PySide'    # only supports Version 2 API
-QT_API_PYQT5 = 'PyQt5'      # use PyQt5 API; Version 2 with module shim
-QT_API_PYSIDE2 = 'PySide2'  # Version 2 API with module shim
+from matplotlib import rcParams
 
-ETS = dict(pyqt=(QT_API_PYQTv2, 4), pyside=(QT_API_PYSIDE, 4),
-           pyqt5=(QT_API_PYQT5, 5), pyside2=(QT_API_PYSIDE2, 5))
-# ETS is a dict of env variable to (QT_API, QT_MAJOR_VERSION)
-# If the ETS QT_API environment variable is set, use it, but only
-# if the varible if of the same major QT version.  Note that
-# ETS requires the version 2 of PyQt4, which is not the platform
-# default for Python 2.x.
 
+QT_API_PYQT = "PyQt4"
+QT_API_PYQTv2 = "PyQt4v2"
+QT_API_PYSIDE = "PySide"
+QT_API_PYQT5 = "PyQt5"
+QT_API_PYSIDE2 = "PySide2"
 QT_API_ENV = os.environ.get('QT_API')
-
-if rcParams['backend'] == 'Qt5Agg':
-    QT_RC_MAJOR_VERSION = 5
-elif rcParams['backend'] == 'Qt4Agg':
-    QT_RC_MAJOR_VERSION = 4
+# First, check if anything is already imported.
+if "PyQt5" in sys.modules:
+    QT_API = rcParams["backend.qt5"] = QT_API_PYQT5
+elif "PySide2" in sys.modules:
+    QT_API = rcParams["backend.qt5"] = QT_API_PYSIDE2
+elif "PyQt4" in sys.modules:
+    QT_API = rcParams["backend.qt4"] = QT_API_PYQTv2
+elif "PySide" in sys.modules:
+    QT_API = rcParams["backend.qt4"] = QT_API_PYSIDE
+# Otherwise, check the QT_API environment variable (from Enthought).  This can
+# only override the binding, not the backend (in other words, we check that the
+# requested backend actually matches).
+elif rcParams["backend"] == "Qt5Agg":
+    if QT_API_ENV == "pyqt5":
+        rcParams["backend.qt5"] = QT_API_PYQT5
+    elif QT_API_ENV == "pyside2":
+        rcParams["backend.qt5"] = QT_API_PYSIDE2
+    QT_API = rcParams["backend.qt5"]
+elif rcParams["backend"] == "Qt4Agg":
+    if QT_API_ENV == "pyqt4":
+        rcParams["backend.qt4"] = QT_API_PYQTv2
+    elif QT_API_ENV == "pyside":
+        rcParams["backend.qt4"] = QT_API_PYSIDE
+    QT_API = rcParams["backend.qt5"]
+# A non-Qt backend was selected but we still got there (possible, e.g., when
+# fully manually embedding Matplotlib in a Qt app without using pyplot).
 else:
-    # A different backend was specified, but we still got here because a Qt
-    # related file was imported. This is allowed, so lets try and guess
-    # what we should be using.
-    if "PyQt4" in sys.modules or "PySide" in sys.modules:
-        # PyQt4 or PySide is actually used.
-        QT_RC_MAJOR_VERSION = 4
-    else:
-        # This is a fallback: PyQt5
-        QT_RC_MAJOR_VERSION = 5
-
-QT_API = None
-
-# check if any binding is already imported, if so silently ignore the
-# rcparams/ENV settings and use what ever is already imported.
-if 'PySide' in sys.modules:
-    # user has imported PySide before importing mpl
-    QT_API = QT_API_PYSIDE
-
-if 'PySide2' in sys.modules:
-    # user has imported PySide before importing mpl
-    QT_API = QT_API_PYSIDE2
+    QT_API = None
 
-if 'PyQt4' in sys.modules:
-    # user has imported PyQt4 before importing mpl
-    # this case also handles the PyQt4v2 case as once sip is imported
-    # the API versions can not be changed so do not try
-    QT_API = QT_API_PYQT
 
-if 'PyQt5' in sys.modules:
-    # the user has imported PyQt5 before importing mpl
-    QT_API = QT_API_PYQT5
+def _setup_pyqt4():
+    global QtCore, QtGui, QtWidgets, __version__, is_pyqt5, _getSaveFileName
 
-if (QT_API_ENV is not None) and QT_API is None:
-    try:
-        QT_ENV_MAJOR_VERSION = ETS[QT_API_ENV][1]
-    except KeyError:
-        raise RuntimeError(
-            ('Unrecognized environment variable %r, valid values are:'
-             ' %r, %r, %r or %r'
-             % (QT_API_ENV, 'pyqt', 'pyside', 'pyqt5', 'pyside2')))
-    if QT_ENV_MAJOR_VERSION == QT_RC_MAJOR_VERSION:
-        # Only if backend and env qt major version are
-        # compatible use the env variable.
-        QT_API = ETS[QT_API_ENV][0]
-
-_fallback_to_qt4 = False
-if QT_API is None:
-    # No ETS environment or incompatible so use rcParams.
-    if rcParams['backend'] == 'Qt5Agg':
-        QT_API = rcParams['backend.qt5']
-    elif rcParams['backend'] == 'Qt4Agg':
-        QT_API = rcParams['backend.qt4']
-    else:
-        # A non-Qt backend was specified, no version of the Qt
-        # bindings is imported, but we still got here because a Qt
-        # related file was imported. This is allowed, fall back to Qt5
-        # using which ever binding the rparams ask for.
-        _fallback_to_qt4 = True
-        QT_API = rcParams['backend.qt5']
-
-# We will define an appropriate wrapper for the differing versions
-# of file dialog.
-_getSaveFileName = None
-
-# Flag to check if sip could be imported
-_sip_imported = False
-
-# Now perform the imports.
-if QT_API in (QT_API_PYQT, QT_API_PYQTv2, QT_API_PYQT5):
-    try:
+    def _setup_pyqt4(api):
+        global QtCore, QtGui, QtWidgets, \
+            __version__, is_pyqt5, _getSaveFileName
+        # List of incompatible APIs:
+        # http://pyqt.sourceforge.net/Docs/PyQt4/incompatible_apis.html
+        _sip_apis = ["QDate", "QDateTime", "QString", "QTextStream", "QTime",
+                     "QUrl", "QVariant"]
         import sip
-        _sip_imported = True
-    except ImportError:
-        # Try using PySide
-        if QT_RC_MAJOR_VERSION == 5:
-            QT_API = QT_API_PYSIDE2
-        else:
-            QT_API = QT_API_PYSIDE
-        cond = ("Could not import sip; falling back on PySide\n"
-                "in place of PyQt4 or PyQt5.\n")
-        _log.info(cond)
-
-if _sip_imported:
-    if QT_API == QT_API_PYQTv2:
-        if QT_API_ENV == 'pyqt':
-            cond = ("Found 'QT_API=pyqt' environment variable. "
-                    "Setting PyQt4 API accordingly.\n")
-        else:
-            cond = "PyQt API v2 specified."
-        try:
-            sip.setapi('QString', 2)
-        except:
-            res = 'QString API v2 specification failed. Defaulting to v1.'
-            _log.info(cond + res)
-            # condition has now been reported, no need to repeat it:
-            cond = ""
-        try:
-            sip.setapi('QVariant', 2)
-        except:
-            res = 'QVariant API v2 specification failed. Defaulting to v1.'
-            _log.info(cond + res)
-    if QT_API == QT_API_PYQT5:
-        try:
-            from PyQt5 import QtCore, QtGui, QtWidgets
-            _getSaveFileName = QtWidgets.QFileDialog.getSaveFileName
-        except ImportError:
-            if _fallback_to_qt4:
-                # fell through, tried PyQt5, failed fall back to PyQt4
-                QT_API = rcParams['backend.qt4']
-                QT_RC_MAJOR_VERSION = 4
-            else:
-                raise
-
-    # needs to be if so we can re-test the value of QT_API which may
-    # have been changed in the above if block
-    if QT_API in [QT_API_PYQT, QT_API_PYQTv2]:  # PyQt4 API
+        for _sip_api in _sip_apis:
+            try:
+                sip.setapi(_sip_api, api)
+            except ValueError:
+                pass
         from PyQt4 import QtCore, QtGui
+        __version__ = QtCore.PYQT_VERSION_STR
+        # PyQt 4.6 introduced getSaveFileNameAndFilter:
+        # https://riverbankcomputing.com/news/pyqt-46
+        if __version__ < LooseVersion(str("4.6")):
+            raise ImportError("PyQt<4.6 is not supported")
+        QtCore.Signal = QtCore.pyqtSignal
+        QtCore.Slot = QtCore.pyqtSlot
+        QtCore.Property = QtCore.pyqtProperty
+        _getSaveFileName = QtGui.QFileDialog.getSaveFileNameAndFilter
 
-        try:
-            if sip.getapi("QString") > 1:
-                # Use new getSaveFileNameAndFilter()
-                _getSaveFileName = QtGui.QFileDialog.getSaveFileNameAndFilter
-            else:
+    if QT_API == QT_API_PYQT:
+        _setup_pyqt4(api=1)
+    elif QT_API == QT_API_PYQTv2:
+        _setup_pyqt4(api=2)
+    elif QT_API == QT_API_PYSIDE:
+        from PySide import QtCore, QtGui, __version__, __version_info__
+        # PySide 1.0.3 fixed the following:
+        # https://srinikom.github.io/pyside-bz-archive/809.html
+        if __version_info__ < (1, 0, 3):
+            raise ImportError("PySide<1.0.3 is not supported")
+        _getSaveFileName = QtGui.QFileDialog.getSaveFileName
+    else:
+        raise ValueError('Unexpected value for the "backend.qt4" rcparam')
+    QtWidgets = QtGui
 
-                # Use old getSaveFileName()
-                def _getSaveFileName(*args, **kwargs):
-                    return (QtGui.QFileDialog.getSaveFileName(*args, **kwargs),
-                            None)
+    def is_pyqt5():
+        return False
 
-        except (AttributeError, KeyError):
 
-            # call to getapi() can fail in older versions of sip
-            def _getSaveFileName(*args, **kwargs):
-                return QtGui.QFileDialog.getSaveFileName(*args, **kwargs), None
-    try:
-        # Alias PyQt-specific functions for PySide compatibility.
-        QtCore.Signal = QtCore.pyqtSignal
-        try:
-            QtCore.Slot = QtCore.pyqtSlot
-        except AttributeError:
-            # Not a perfect match but works in simple cases
-            QtCore.Slot = QtCore.pyqtSignature
+def _setup_pyqt5():
+    global QtCore, QtGui, QtWidgets, __version__, is_pyqt5, _getSaveFileName
 
-        QtCore.Property = QtCore.pyqtProperty
+    if QT_API == QT_API_PYQT5:
+        from PyQt5 import QtCore, QtGui, QtWidgets
         __version__ = QtCore.PYQT_VERSION_STR
-    except NameError:
-        # QtCore did not get imported, fall back to pyside
-        if QT_RC_MAJOR_VERSION == 5:
-            QT_API = QT_API_PYSIDE2
-        else:
-            QT_API = QT_API_PYSIDE
+        QtCore.Signal = QtCore.pyqtSignal
+        QtCore.Slot = QtCore.pyqtSlot
+        QtCore.Property = QtCore.pyqtProperty
+    elif QT_API == QT_API_PYSIDE2:
+        from PySide2 import QtCore, QtGui, QtWidgets, __version__
+    else:
+        raise ValueError('Unexpected value for the "backend.qt5" rcparam')
+    _getSaveFileName = QtWidgets.QFileDialog.getSaveFileName
 
+    def is_pyqt5():
+        return True
 
-if QT_API == QT_API_PYSIDE2:
-    try:
-        from PySide2 import QtCore, QtGui, QtWidgets, __version__
-        _getSaveFileName = QtWidgets.QFileDialog.getSaveFileName
-    except ImportError:
-        # tried PySide2, failed, fall back to PySide
-        QT_RC_MAJOR_VERSION = 4
-        QT_API = QT_API_PYSIDE
 
-if QT_API == QT_API_PYSIDE:  # try importing pyside
+if QT_API in [QT_API_PYQT5, QT_API_PYSIDE2]:
+    _setup_pyqt5()
+elif QT_API in [QT_API_PYQT, QT_API_PYQTv2, QT_API_PYSIDE]:
+    _setup_pyqt4()
+elif QT_API is None:
     try:
-        from PySide import QtCore, QtGui, __version__, __version_info__
+        _setup_pyqt5()
     except ImportError:
-        raise ImportError(
-            "Matplotlib qt-based backends require an external PyQt4, PyQt5,\n"
-            "PySide or PySide2 package to be installed, but it was not found.")
-
-    if __version_info__ < (1, 0, 3):
-        raise ImportError(
-            "Matplotlib backend_qt4 and backend_qt4agg require PySide >=1.0.3")
-
-    _getSaveFileName = QtGui.QFileDialog.getSaveFileName
-
-
-# Apply shim to Qt4 APIs to make them look like Qt5
-if QT_API in (QT_API_PYQT, QT_API_PYQTv2, QT_API_PYSIDE):
-    '''Import all used QtGui objects into QtWidgets
-
-    Here I've opted to simple copy QtGui into QtWidgets as that
-    achieves the same result as copying over the objects, and will
-    continue to work if other objects are used.
-
-    '''
-    QtWidgets = QtGui
+        _setup_pyqt4()
+else:
+    raise RuntimeError  # We should not get there.
 
 
-def is_pyqt5():
-    return QT_API == QT_API_PYQT5
+# These globals are only defined for backcompatibilty purposes.
+ETS = dict(pyqt=(QT_API_PYQTv2, 4), pyside=(QT_API_PYSIDE, 4),
+           pyqt5=(QT_API_PYQT5, 5), pyside2=(QT_API_PYSIDE2, 5))
+QT_RC_MAJOR_VERSION = 5 if is_pyqt5() else 4
diff --git a/lib/matplotlib/backends/qt_editor/formlayout.py b/lib/matplotlib/backends/qt_editor/formlayout.py
@@ -53,7 +53,7 @@
 import six
 
 from matplotlib import colors as mcolors
-from matplotlib.backends.qt_compat import QtGui, QtWidgets, QtCore
+from ..qt_compat import QtCore, QtGui, QtWidgets
 
 
 BLACKLIST = {"title", "label"}
