PyQt enums patch

Qt.py

@@ -1800,6 +1800,30 @@ def __call__(self, *a, **kw):
         raise NotImplementedError(self.__err)
 
 
+def _pyqt_enums_patch():
+    """Patch ``PyQt*`` Qt namespace enums to behave like ``PySide*``.
+
+    i.e. ``PyQt*`` only has Qt.Checked and Qt.CheckState, but not ``PySide*``
+    Qt.CheckState.Checked attribute or Qt.CheckState.values dictionary.
+    """
+    qt_attrs = {
+        name: getattr(Qt.QtCore.Qt, name)
+        for name in dir(Qt.QtCore.Qt)
+        if not name.startswith("_")
+    }
+
+    known_enums = set()
+    for attr_name, enum_class in qt_attrs.items():
+        if inspect.isclass(enum_class) and issubclass(enum_class, int):
+            known_enums.add(enum_class)
+            enum_class.values = {}
+
+    for attr_name, attr in qt_attrs.items():
+        if isinstance(attr, int) and attr.__class__ in known_enums:
+            attr.__class__.values[attr_name] = attr
+            setattr(attr.__class__, attr_name, attr)
+
+
 def _install():
     # Default order (customize order and content via QT_PREFERRED_BINDING)
     default_order = ("PySide2", "PyQt5", "PySide", "PyQt4")
@@ -1915,6 +1939,12 @@ def _install():
     if hasattr(Qt.QtCompat, 'loadUi'):
         Qt.QtCompat.load_ui = Qt.QtCompat.loadUi
 
+    if Qt.__binding__.startswith("PyQt"):
+        if getattr(getattr(Qt, "QtCore", None), "Qt", None) is None:
+            _warn("Qt.QtCore.Qt not available. Not applying enums patch.")
+        else:
+            _pyqt_enums_patch()
+
 
 _install()
 

tests.py

@@ -1159,3 +1159,42 @@ def test_multiple_preferred():
         assert Qt.__binding__ == "PyQt4", (
             "PyQt4 should have been picked, "
             "instead got %s" % Qt.__binding__)
+
+    def test_pyqt_enums():
+        """Check some known enums/flags mappings."""
+        from Qt import QtCore
+
+        class_attributes = {  # Version agnostic flags and enums
+            "CheckState": ["Checked", "Unchecked", "PartiallyChecked"],
+            "Orientation": ["Horizontal", "Vertical"],
+        }
+        for class_name, attributes in class_attributes.items():
+            qt_class = getattr(QtCore.Qt, class_name)
+
+            values_path = "QtCore.Qt.{0}.{1}".format(class_name, "values")
+            assert hasattr(qt_class, "values"), (
+                "{0} should exist, but is missing".format(values_path))
+
+            cls_values = getattr(qt_class, "values", None)
+            assert cls_values and isinstance(cls_values, dict), (
+                "{0} should be a non-empty dictionary, "
+                "not {1}".format(values_path, cls_values))
+
+            for attr_name in attributes:
+                attr_path = "QtCore.Qt.{0}.{1}".format(class_name, attr_name)
+
+                assert hasattr(qt_class, attr_name), (
+                    "{0} should exist, but is missing".format(attr_path))
+
+                value = getattr(qt_class, attr_name, None)
+                assert value is not None, (
+                    "{0} shouldn't be None".format(attr_path))
+
+                assert attr_name in cls_values, (
+                    "{0} key should exist in {1} "
+                    "dict".format(attr_name, values_path))
+
+                cls_value = cls_values[attr_name]
+                assert value == cls_values[attr_name], (
+                    "({0}) {1!r} != {2!r} ({3}[{4}])".format(
+                    attr_path, value, cls_value, values_path, attr_name))