Add all qflags bases classes

CHANGELOG.md

@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Added
 * [#138](https://github.com/python-qt-tools/PyQt5-stubs/pull/138) update to PyQt5 5.15.3
+* [#145](https://github.com/python-qt-tools/PyQt5-stubs/pull/145) Support all implemented arithmetic operations between Qt.WindowType and Qt.WindowFlags and int
 * [#144](https://github.com/python-qt-tools/PyQt5-stubs/pull/144) add `QTreeWidgetItem.__lt__()` to allow sorting of items in a QTreeWidget
 
 ## 5.15.2.0

PyQt5-stubs/QtCore.pyi

@@ -2376,6 +2376,9 @@ class Qt(sip.simplewrapper):
     WindowActive = ...  # type: Qt.WindowState
 
     class WindowType(int):
+        def __or__ (self, other: 'Qt.WindowType') -> 'Qt.WindowFlags': ...  # type: ignore[override]
+        def __ror__ (self, other: int) -> 'Qt.WindowFlags': ...             # type: ignore[override, misc]
+
         Widget = ... # type: Qt.WindowType
         Window = ... # type: Qt.WindowType
         Dialog = ... # type: Qt.WindowType
@@ -2489,6 +2492,9 @@ class Qt(sip.simplewrapper):
     TextJustificationForced = ...  # type: Qt.TextFlag
 
     class AlignmentFlag(int):
+        def __or__ (self, other: 'Qt.AlignmentFlag') -> 'Qt.Alignment': ...  # type: ignore[override]
+        def __ror__ (self, other: int) -> 'Qt.Alignment': ...             # type: ignore[override, misc]
+
         AlignLeft = ... # type: Qt.AlignmentFlag
         AlignLeading = ... # type: Qt.AlignmentFlag
         AlignRight = ... # type: Qt.AlignmentFlag
@@ -2746,7 +2752,7 @@ class Qt(sip.simplewrapper):
         @typing.overload
         def __init__(self) -> None: ...
         @typing.overload
-        def __init__(self, f: typing.Union['Qt.Alignment', 'Qt.AlignmentFlag']) -> None: ...
+        def __init__(self, f: typing.Union['Qt.Alignment', 'Qt.AlignmentFlag', int]) -> None: ...
         @typing.overload
         def __init__(self, a0: 'Qt.Alignment') -> None: ...
 
@@ -2755,13 +2761,19 @@ class Qt(sip.simplewrapper):
         def __invert__(self) -> 'Qt.Alignment': ...
         def __index__(self) -> int: ...
         def __int__(self) -> int: ...
+        def __or__ (self, other: typing.Union['Qt.Alignemtn', 'Qt.AlignmentFlag', int]) -> 'Qt.Alignemtn': ...
+        def __and__(self, other: typing.Union['Qt.Alignemtn', 'Qt.AlignmentFlag', int]) -> 'Qt.Alignemtn': ...
+        def __xor__(self, other: typing.Union['Qt.Alignemtn', 'Qt.AlignmentFlag', int]) -> 'Qt.Alignemtn': ...
+        def __ror__ (self, other: 'Qt.AlignmentFlag') -> 'Qt.Alignemtn': ...
+        def __rand__(self, other: 'Qt.AlignmentFlag') -> 'Qt.Alignemtn': ...
+        def __rxor__(self, other: 'Qt.AlignmentFlag') -> 'Qt.Alignemtn': ...
 
     class WindowFlags(sip.simplewrapper):
 
         @typing.overload
         def __init__(self) -> None: ...
         @typing.overload
-        def __init__(self, f: typing.Union['Qt.WindowFlags', 'Qt.WindowType']) -> None: ...
+        def __init__(self, f: typing.Union['Qt.WindowFlags', 'Qt.WindowType', int]) -> None: ...
         @typing.overload
         def __init__(self, a0: 'Qt.WindowFlags') -> None: ...
 
@@ -2770,6 +2782,12 @@ class Qt(sip.simplewrapper):
         def __invert__(self) -> 'Qt.WindowFlags': ...
         def __index__(self) -> int: ...
         def __int__(self) -> int: ...
+        def __or__ (self, other: typing.Union['Qt.WindowFlags', 'Qt.WindowType', int]) -> 'Qt.WindowFlags': ...
+        def __and__(self, other: typing.Union['Qt.WindowFlags', 'Qt.WindowType', int]) -> 'Qt.WindowFlags': ...
+        def __xor__(self, other: typing.Union['Qt.WindowFlags', 'Qt.WindowType', int]) -> 'Qt.WindowFlags': ...
+        def __ror__ (self, other: 'Qt.WindowType') -> 'Qt.WindowFlags': ...
+        def __rand__(self, other: 'Qt.WindowType') -> 'Qt.WindowFlags': ...
+        def __rxor__(self, other: 'Qt.WindowType') -> 'Qt.WindowFlags': ...
 
     class WindowStates(sip.simplewrapper):
 

tests/generate_qflags_tests.py

@@ -0,0 +1,69 @@
+from typing import Tuple, List
+
+SOURCE = 'windowFlags.py'
+MARKER_SPECIFIC_START = '### Specific part'
+MARKER_SPECIFIC_END = '### End of specific part'
+
+# Content is:
+# - name of the file to generate
+# - name of the QFlags<> class
+# - name of the individual flag class (inheriting from int)
+# - one individual flag value
+# - a second individual flag value
+FLAGS_FILES = [
+    ('qflags_alignmentflags.py', 'QtCore.Qt.Alignment', 'QtCore.Qt.AlignmentFlag', 'QtCore.Qt.AlignLeft', 'QtCore.Qt.AlignRight'),
+
+]
+
+# global values for simplicity of the code
+sourcePart1, sourcePart2, sourcePart3 = [], [], []  # type: Tuple[List[str], List[str], List[str]]
+
+def generate_qflags_files() -> None:
+    global sourcePart1, sourcePart2, sourcePart3
+    with open(SOURCE) as f:
+        lines = f.readlines()
+
+    sourcePart1, sourcePart2, sourcePart3 = [], [], []
+    fillPart2, fillPart3 = False, False
+    for l in lines:
+        if fillPart3:
+            sourcePart3.append(l)
+            continue
+
+        if fillPart2:
+            if MARKER_SPECIFIC_END in l:
+                fillPart3 = True
+                sourcePart3.append(l)
+                continue
+
+            sourcePart2.append(l)
+            continue
+
+        sourcePart1.append(l)
+        if MARKER_SPECIFIC_START in l:
+            fillPart2 = True
+
+    for qflag_info in FLAGS_FILES:
+        generate_one_qflag_file(*qflag_info)
+
+
+def generate_one_qflag_file(qflag_fname: str, multiFlagName: str, oneFlagName: str, oneFlagValue1: str, oneFlagValue2: str) -> None:
+    with open(qflag_fname, 'w') as f:
+        f.writelines(sourcePart1)
+        f.write('''# file generated from {source} for QFlags class "{multiFlagName}" and flag class "{oneFlagName}"
+
+OneFlagClass = {oneFlagName}
+MultiFlagClass = {multiFlagName}
+
+oneFlagRefValue1 = {oneFlagValue1}
+oneFlagRefValue2 = {oneFlagValue2}
+'''.format(source=SOURCE, multiFlagName=multiFlagName, oneFlagName=oneFlagName,
+            oneFlagValue1=oneFlagValue1, oneFlagValue2=oneFlagValue2
+    ))
+        f.writelines(sourcePart3)
+    print('File %s generated' % qflag_fname)
+
+
+if __name__ == '__main__':
+    generate_qflags_files()
+

tests/qflags_alignmentflags.py

@@ -0,0 +1,231 @@
+from typing import Union, TypeVar, Type
+import pytest		# type: ignore
+from PyQt5 import QtCore, QtWidgets
+
+### Specific part
+# file generated from windowFlags.py for QFlags class "QtCore.Qt.Alignment" and flag class "QtCore.Qt.AlignmentFlag"
+
+OneFlagClass = QtCore.Qt.AlignmentFlag
+MultiFlagClass = QtCore.Qt.Alignment
+
+oneFlagRefValue1 = QtCore.Qt.AlignLeft
+oneFlagRefValue2 = QtCore.Qt.AlignRight
+### End of specific part
+
+T = TypeVar('T')
+def assert_type_of_value(expected_type: Type[T], value: T) -> None:
+	'''Raise an exception if the value is not of type expected_type'''
+	assert type(value) == expected_type
+
+
+def test_on_one_flag_class() -> None:
+	oneFlagValue1 = oneFlagRefValue1
+	oneFlagValue2 = oneFlagRefValue2
+	oneFlagValueTest = oneFlagValue1    # type: OneFlagClass
+	intValue = 0                    # type: int
+	oneOrMultiFlagValueTest = oneFlagValue1		# type: Union[OneFlagClass, MultiFlagClass]
+	oneFlagOrIntValue = oneFlagValue1	# type: Union[int, OneFlagClass]
+
+	assert_type_of_value(OneFlagClass, oneFlagValue1)
+	assert_type_of_value(OneFlagClass, oneFlagValue2)
+	assert_type_of_value(OneFlagClass, oneFlagValueTest)
+	assert_type_of_value(int, intValue)
+
+
+	# upcast from OneFlagClass to int
+	intValue = oneFlagValue1
+
+	# conversion also accepted
+	intValue = int(oneFlagValue1)
+
+	# this is not supported type-safely for a good reason
+	oneFlagValueTest = 33		# type: ignore
+
+	# correct way to do it
+	oneFlagValueTest = OneFlagClass(33)
+	oneFlagValueTest = OneFlagClass(oneFlagValue1)
+
+	# The rules of OneFlagClass conversion defined in PyQt5 are:
+	# 1. | ~= with OneFlagClass return a MultiFlagClass (which is not compatible to int)
+	#   Note that this breaks Liskov principle
+	# 2. everything else returns int: & ^ &= ^=
+	# 3. operations with int return int.
+
+	assert_type_of_value(MultiFlagClass, oneFlagValue1 | oneFlagValue2)
+	assert_type_of_value(int, ~oneFlagValue1)
+	assert_type_of_value(int, oneFlagValue1 & oneFlagValue2)
+	assert_type_of_value(int, oneFlagValue1 ^ oneFlagValue2)
+
+	# right operand
+	assert_type_of_value(int, oneFlagValue1 | 33)
+	assert_type_of_value(int, oneFlagValue1 & 33)
+	assert_type_of_value(int, oneFlagValue1 ^ 33)
+	assert_type_of_value(int, oneFlagValue1 + 33)
+	assert_type_of_value(int, oneFlagValue1 - 33)
+
+	# left operand
+	assert_type_of_value(MultiFlagClass, 33 | oneFlagValue1)
+	assert_type_of_value(int, 33 & oneFlagValue1)
+	assert_type_of_value(int, 33 ^ oneFlagValue1)
+	assert_type_of_value(int, 33 + oneFlagValue1)
+	assert_type_of_value(int, 33 - oneFlagValue1)
+
+	oneOrMultiFlagValueTest = oneFlagValue1	# reset type and value
+	assert_type_of_value(OneFlagClass, oneOrMultiFlagValueTest)
+	oneOrMultiFlagValueTest |= oneFlagValue2
+	assert_type_of_value(MultiFlagClass, oneOrMultiFlagValueTest)	# nice violation of Liskov principle here
+
+	oneFlagOrIntValue = oneFlagValue1	# reset type and value
+	assert_type_of_value(OneFlagClass, oneFlagOrIntValue)
+	oneFlagOrIntValue |= 33
+	assert_type_of_value(int, oneFlagOrIntValue)
+
+	oneFlagOrIntValue = oneFlagValue1	# reset type and value
+	assert_type_of_value(OneFlagClass, oneFlagOrIntValue)
+	oneFlagOrIntValue &= 33
+	assert_type_of_value(int, oneFlagOrIntValue)
+
+	oneFlagOrIntValue = oneFlagValue1	# reset type and value
+	assert_type_of_value(OneFlagClass, oneFlagOrIntValue)
+	oneFlagOrIntValue &= oneFlagValue2
+	assert_type_of_value(int, oneFlagOrIntValue)
+
+	oneFlagOrIntValue = oneFlagValue1	# reset type and value
+	assert_type_of_value(OneFlagClass, oneFlagOrIntValue)
+	oneFlagOrIntValue ^= 33
+	assert_type_of_value(int, oneFlagOrIntValue)
+
+	oneFlagOrIntValue = oneFlagValue1	# reset type and value
+	assert_type_of_value(OneFlagClass, oneFlagOrIntValue)
+	oneFlagOrIntValue ^= oneFlagValue2
+	assert_type_of_value(int, oneFlagOrIntValue)
+
+
+
+def test_on_multi_flag_class() -> None:
+	oneFlagValue1 = oneFlagRefValue1
+	multiFlagValue1 = MultiFlagClass()
+	multiFlagValue2 = MultiFlagClass()
+	multiFlagValueTest = multiFlagValue1     # type: MultiFlagClass
+	intValue = 0
+
+	assert_type_of_value(OneFlagClass, oneFlagValue1)
+	assert_type_of_value(MultiFlagClass, multiFlagValue1)
+	assert_type_of_value(MultiFlagClass, multiFlagValue2)
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+	assert_type_of_value(int, intValue)
+
+
+	# MultiFlagClass may be created by combining MultiFlagClass together
+	assert_type_of_value(MultiFlagClass,  ~multiFlagValue1 )
+	assert_type_of_value(MultiFlagClass,  multiFlagValue1 | multiFlagValue2 )
+	assert_type_of_value(MultiFlagClass,  multiFlagValue1 & multiFlagValue2 )
+	assert_type_of_value(MultiFlagClass,  multiFlagValue1 ^ multiFlagValue2 )
+
+
+	# MultiFlagClass may be created by combining MultiFlagClass and OneFlagClass, left or right
+	assert_type_of_value(MultiFlagClass,  multiFlagValue1 | oneFlagValue1 )
+	assert_type_of_value(MultiFlagClass,  multiFlagValue1 & oneFlagValue1 )
+	assert_type_of_value(MultiFlagClass,  multiFlagValue1 ^ oneFlagValue1 )
+
+	assert_type_of_value(MultiFlagClass,  oneFlagValue1 | multiFlagValue1 )
+	assert_type_of_value(MultiFlagClass,  oneFlagValue1 & multiFlagValue1 )
+	assert_type_of_value(MultiFlagClass,  oneFlagValue1 ^ multiFlagValue1 )
+
+
+	# MultClassFlag may be created by combining MultiFlagClass and int, right only
+	assert_type_of_value(MultiFlagClass, multiFlagValue1 | 33)
+	assert_type_of_value(MultiFlagClass, multiFlagValue1 & 33)
+	assert_type_of_value(MultiFlagClass, multiFlagValue1 ^ 33)
+
+
+	# this is rejected by mypy and is slightly annoying: you can not pass a OneFlagClass variable to a method expecting a MultiFlagClass
+	# explicit typing must be used on those methods to accept both OneFlagClass and MultiFlagClass
+	multiFlagValueTest = oneFlagValue1   # type: ignore
+
+	# correct way to do it
+	multiFlagValueTest = MultiFlagClass(oneFlagValue1)
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+
+	# this is rejected for the same reason as for OneFlagClass.
+	intValue = multiFlagValueTest      # type: ignore
+
+	# correct way to do it
+	intValue = int(multiFlagValueTest)
+	assert_type_of_value(int, intValue)
+
+	# rejected by mypy rightfully
+	multiFlagValueTest = 33            # type: ignore
+
+	# correct way to do it
+	multiFlagValueTest = MultiFlagClass(33)
+
+	# assignments operations with OneFlagClass
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+	multiFlagValueTest |= oneFlagValue1
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+	multiFlagValueTest &= oneFlagValue1
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+	multiFlagValueTest ^= oneFlagValue1
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+
+	# assignments operations with int
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+	multiFlagValueTest |= 33
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+	multiFlagValueTest &= 33
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+	multiFlagValueTest ^= 33
+	assert_type_of_value(MultiFlagClass, multiFlagValueTest)
+
+	#########################################################3
+	#
+	#        Exploring errors
+	#
+	#########################################################3
+
+	# This checks the following:
+	# + and - operations are not supported on MultiFlagClass
+	# combining int with MultiFlagClass does not work
+
+	pytest.raises(TypeError, lambda: 33 | multiFlagValue1 )	# type: ignore[operator]
+	pytest.raises(TypeError, lambda: 33 & multiFlagValue1 )	# type: ignore[operator]
+	pytest.raises(TypeError, lambda: 33 ^ multiFlagValue1 )	# type: ignore[operator]
+
+	pytest.raises(TypeError, lambda: multiFlagValue1 + multiFlagValue2 )	# type: ignore[operator]
+	pytest.raises(TypeError, lambda: multiFlagValue1 - multiFlagValue2 )	# type: ignore[operator]
+	pytest.raises(TypeError, lambda: multiFlagValue1 + oneFlagValue1)	# type: ignore[operator]
+	pytest.raises(TypeError, lambda: multiFlagValue1 - oneFlagValue1)	# type: ignore[operator]
+	pytest.raises(TypeError, lambda: multiFlagValue1 + 33)				# type: ignore[operator]
+	pytest.raises(TypeError, lambda: multiFlagValue1 - 33)				# type: ignore[operator]
+	pytest.raises(TypeError, lambda: oneFlagValue1 + multiFlagValue1)	# type: ignore[operator]
+	pytest.raises(TypeError, lambda: oneFlagValue1 - multiFlagValue1)	# type: ignore[operator]
+	pytest.raises(TypeError, lambda: 33 + multiFlagValue1)				# type: ignore[operator]
+	pytest.raises(TypeError, lambda: 33 - multiFlagValue1)				# type: ignore[operator]
+
+	def f1() -> None:
+		multiFlagValueTest = MultiFlagClass()
+		multiFlagValueTest += oneFlagValue1	  # type: ignore[assignment, operator]
+	def f2() -> None:
+		multiFlagValueTest = MultiFlagClass()
+		multiFlagValueTest += 33	  # type: ignore[assignment, operator]
+	def f3() -> None:
+		multiFlagValueTest = MultiFlagClass()
+		multiFlagValueTest -= oneFlagValue1	  # type: ignore[assignment, operator]
+	def f4() -> None:
+		multiFlagValueTest = MultiFlagClass()
+		multiFlagValueTest -= 33	  # type: ignore[assignment, operator]
+
+	pytest.raises(TypeError, f1)
+	pytest.raises(TypeError, f2)
+	pytest.raises(TypeError, f3)
+	pytest.raises(TypeError, f4)
+