From 30a1c9c41e5e6d4166f171b9477c6f46cafa782f Mon Sep 17 00:00:00 2001 From: Christian Tismer Date: Tue, 23 May 2017 17:10:26 +0200 Subject: Implement introspection with __signature__ package The signature module was turned into a package under 'PySide2/support/signature'. The package is completely isolated so that nothing is leaking into the normal import machinery. The package is also not initialized unless a __signature__ attribute is accessed. The only change to Python during a PySide run is the existence of the __signature__ attribute. As a side effect, all tests run at the same speed as before this extension. The module does not actively import PySide modules. Instead, it inspects sys.modules and reloads its mapping.py if needed. Example usage: >>> PySide2.QtWidgets.QGraphicsAnchorLayout.addAnchors.__signature__ >>> PySide2.QtWidgets.QGraphicsAnchorLayout.__signature__ The module has been thoroughly tested on macOS. I consider this ready. Task-number: PYSIDE-510 Change-Id: Ibb231a7fbb4ccc1a7249df55e3881a4e21a19c0d Reviewed-by: Christian Tismer --- .../pyside2/PySide2/support/signature/mapping.py | 364 +++++++++++++++++++++ 1 file changed, 364 insertions(+) create mode 100644 sources/pyside2/PySide2/support/signature/mapping.py (limited to 'sources/pyside2/PySide2/support/signature/mapping.py') diff --git a/sources/pyside2/PySide2/support/signature/mapping.py b/sources/pyside2/PySide2/support/signature/mapping.py new file mode 100644 index 000000000..d18ee561b --- /dev/null +++ b/sources/pyside2/PySide2/support/signature/mapping.py @@ -0,0 +1,364 @@ +############################################################################# +## +## Copyright (C) 2017 The Qt Company Ltd. +## Contact: https://www.qt.io/licensing/ +## +## This file is part of PySide2. +## +## $QT_BEGIN_LICENSE:LGPL$ +## Commercial License Usage +## Licensees holding valid commercial Qt licenses may use this file in +## accordance with the commercial license agreement provided with the +## Software or, alternatively, in accordance with the terms contained in +## a written agreement between you and The Qt Company. For licensing terms +## and conditions see https://www.qt.io/terms-conditions. For further +## information use the contact form at https://www.qt.io/contact-us. +## +## GNU Lesser General Public License Usage +## Alternatively, this file may be used under the terms of the GNU Lesser +## General Public License version 3 as published by the Free Software +## Foundation and appearing in the file LICENSE.LGPL3 included in the +## packaging of this file. Please review the following information to +## ensure the GNU Lesser General Public License version 3 requirements +## will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +## +## GNU General Public License Usage +## Alternatively, this file may be used under the terms of the GNU +## General Public License version 2.0 or (at your option) the GNU General +## Public license version 3 or any later version approved by the KDE Free +## Qt Foundation. The licenses are as published by the Free Software +## Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +## included in the packaging of this file. Please review the following +## information to ensure the GNU General Public License requirements will +## be met: https://www.gnu.org/licenses/gpl-2.0.html and +## https://www.gnu.org/licenses/gpl-3.0.html. +## +## $QT_END_LICENSE$ +## +############################################################################# + +from __future__ import print_function, absolute_import + +""" +signature_mapping.py + +This module has the mapping from the pyside C-modules view of signatures +to the Python representation. + +The PySide modules are not loaded in advance, but only after they appear +in sys.modules. This minimises the loading overhead. +In principle, we need to re-load the module, when the imports change. +But it is much easier to do it on demand, when we get an exception. +See _resolve_value() in singature.py +""" + +import sys +import collections +import struct + +PY3 = sys.version_info >= (3,) +if PY3: + from . import typing + exec("ellipsis = ...") + Char = typing.Union[str, int] # how do I model the limitation to 1 char? + StringList = typing.List[str] + Variant = typing.Union[str, int, float, Char, StringList, type(ellipsis)] + # much more, do we need that? + ModelIndexList = typing.List[int] + QImageCleanupFunction = typing.Callable[[bytes], None] +else: + ellipsis = "..." + Char = str + StringList = list + Variant = object + ModelIndexList = list + QImageCleanupFunction = object +Pair = collections.namedtuple('Pair', ['first', 'second']) +# ulong_max is the long size, which is only 32 bit on windows. +ulong_max = sys.maxsize if len(struct.pack("L", 1)) != 4 else 0xffffffff +ushort_max = 0xffff + +GL_COLOR_BUFFER_BIT = 0x00004000 +GL_NEAREST = 0x2600 + +WId = int + +# from 5.9 +GL_TEXTURE_2D = 0x0DE1 +GL_RGBA = 0x1908 + +# Some types are abstract. They just show their name. +class Virtual(str): + def __repr__(self): + return "Virtual({})".format(self) + +# Other types I simply could not find. +class Missing(str): + def __repr__(self): + return "Missing({})".format(self) + +TYPE_MAP_DOC = """ + The type_map variable is central for the signature module. + + PySide has a new function 'CppGenerator::writeSignatureInfo()' + that extracts the gathered information about the function arguments + and defaults as good as it can. But what PySide generates is still + very C-ish and has many constants that Python doesn't understand. + + The function 'try_to_guess()' below understands a lot of PySide's + peculiar way to assume local context. If it is able to do the guess, + then the result is inserted into the dict, so the search happens + not again. For everything that is not covered by these automatic + guesses, we provide an entry in 'type_map' that resolves it. + + In effect, 'type_map' maps text to real Python objects. +""" +type_map = {} + +loaded_modules = sys.modules + +# QtCore +if "PySide2.QtCore" in loaded_modules: + import PySide2.QtCore + from PySide2.QtCore import Qt, QUrl, QDir, QGenericArgument + from PySide2.QtCore import QMarginsF # 5.9 + try: + # seems to be not generated by 5.9 ATM. + from PySide2.QtCore import Connection, QRect, QSize, QPoint + except ImportError: + pass + type_map.update({ + "str": str, + "int": int, + "QString": str, + "bool": bool, + "PyObject": object, + "void": int, # be more specific? + "char": Char, + "'%'": "%", + "' '": " ", + "false": False, + "double": float, + "'g'": "g", + "long long": int, + "unsigned int": int, # should we define an unsigned type? + "Q_NULLPTR": None, + "long": int, + "float": float, + "short": int, + "unsigned long": int, + "unsigned long long": int, + "unsigned short": int, + "QStringList": StringList, + "QList": list, + "QChar": Char, + "signed char": Char, + "QVariant": Variant, + "QVariant.Type": type, # not so sure here... + "QStringRef": str, + "QString()": None, # unclear: "" would be isEmpty(), but not isNull() + "QModelIndexList": ModelIndexList, + "QPair": Pair, + "unsigned char": Char, + "QSet": set, # seems _not_ to work + "QVector": list, + "QJsonObject": dict, # seems to work + "QStringList()": [], + "ULONG_MAX": ulong_max, + "quintptr": int, + "PyCallable": callable, + "...": ellipsis, # no idea how this should be translated... maybe so? + "PyTypeObject": type, + "PySequence": list, # could be more generic + "qptrdiff": int, + "true": True, + "Qt.HANDLE": int, # be more explicit with some consts? + "list of QAbstractState": list, # how to use typing.List when we don't have QAbstractState? + "list of QAbstractAnimation": list, # dto. + "QVariant()": (ellipsis,), # no idea what to use here for "invalid Variant"? + "QMap": dict, + "PySide2.QtCore.bool": bool, + "QHash": dict, + "PySide2.QtCore.QChar": Char, + "PySide2.QtCore.qreal": float, + "PySide2.QtCore.float": float, + "PySide2.QtCore.qint16": int, + "PySide2.QtCore.qint32": int, + "PySide2.QtCore.qint64": int, + "PySide2.QtCore.qint8": int, + "PySide2.QtCore.QString": str, + "PySide2.QtCore.QStringList": StringList, + "PySide2.QtCore.QVariant": Variant, + "PySide2.QtCore.quint16": int, + "PySide2.QtCore.quint32": int, + "PySide2.QtCore.quint64": int, + "PySide2.QtCore.quint8": int, + "PySide2.QtCore.uchar": Char, + "QGenericArgument(0)": QGenericArgument(None), + "PySide2.QtCore.long": int, + "PySide2.QtCore.QUrl.ComponentFormattingOptions": + PySide2.QtCore.QUrl.ComponentFormattingOption, # mismatch option/enum, why??? + "QUrl.FormattingOptions(PrettyDecoded)": QUrl.FormattingOptions(QUrl.PrettyDecoded), + # from 5.9 + "QDir.Filters(AllEntries | NoDotAndDotDot)": QDir.Filters(QDir.AllEntries | + QDir.NoDotAndDotDot), + "QGenericArgument(Q_NULLPTR)": QGenericArgument(None), + "NULL": None, # 5.6, MSVC + "QGenericArgument(NULL)": QGenericArgument(None), # 5.6, MSVC + "QDir.SortFlags(Name | IgnoreCase)": QDir.SortFlags(QDir.Name | QDir.IgnoreCase), + "PyBytes": bytes, + "PyUnicode": str if PY3 else unicode, + "signed long": int, + "PySide2.QtCore.int": int, + "unsigned long int": int, # 5.6, RHEL 6.6 + "unsigned short int": int, # 5.6, RHEL 6.6 + "QGenericArgument((0))": None, # 5.6, RHEL 6.6. Is that ok? + "4294967295UL": 4294967295, # 5.6, RHEL 6.6 + }) + + try: + type_map.update({ + "PySide2.QtCore.QMetaObject.Connection": PySide2.QtCore.Connection, # wrong! + }) + except AttributeError: + # this does not exist on 5.9 ATM. + pass + +# QtGui +if "PySide2.QtGui" in loaded_modules: + import PySide2.QtGui + from PySide2.QtGui import QPageLayout, QPageSize # 5.9 + type_map.update({ + "QVector< QTextLayout.FormatRange >()": [], # do we need more structure? + "USHRT_MAX": ushort_max, + "0.0f": 0.0, + "1.0f": 1.0, + "uint32_t": int, + "uint8_t": int, + "int32_t": int, + "GL_COLOR_BUFFER_BIT": GL_COLOR_BUFFER_BIT, + "GL_NEAREST": GL_NEAREST, + "WId": WId, + "PySide2.QtGui.QPlatformSurface": Virtual("PySide2.QtGui.QPlatformSurface"), # hmm... + "PySide2.QtCore.char": StringList, # A 'char **' is a list of strings. + "QList< QTouchEvent.TouchPoint >()": list, + "QPixmap()": lambda:QPixmap(), # we cannot create this without qApp + }) + +# QtWidgets +if "PySide2.QtWidgets" in loaded_modules: + import PySide2.QtWidgets + from PySide2.QtWidgets import QWidget, QMessageBox, QStyleOption, QStyleHintReturn, QStyleOptionComplex + type_map.update({ + "QMessageBox.StandardButtons(Yes | No)": QMessageBox.StandardButtons( + QMessageBox.Yes | QMessageBox.No), + "QWidget.RenderFlags(DrawWindowBackground | DrawChildren)": QWidget.RenderFlags( + QWidget.DrawWindowBackground | QWidget.DrawChildren), + "static_cast(Qt.MatchExactly|Qt.MatchCaseSensitive)": ( + Qt.MatchFlags(Qt.MatchExactly | Qt.MatchCaseSensitive)), + "QVector< int >()": [], + # from 5.9 + "Type": PySide2.QtWidgets.QListWidgetItem.Type, + "SO_Default": QStyleOption.SO_Default, + "SH_Default": QStyleHintReturn.SH_Default, + "SO_Complex": QStyleOptionComplex.SO_Complex, + }) + +# QtSql +if "PySide2.QtSql" in loaded_modules: + import PySide2.QtSql + from PySide2.QtSql import QSqlDatabase + type_map.update({ + "QLatin1String(defaultConnection)": QSqlDatabase.defaultConnection, + "QVariant.Invalid": -1, # not sure what I should create, here... + }) + +# QtNetwork +if "PySide2.QtNetwork" in loaded_modules: + import PySide2.QtNetwork + type_map.update({ + "QMultiMap": typing.DefaultDict(list) if PY3 else {}, + }) + +# QtXmlPatterns +if "PySide2.QtXmlPatterns" in loaded_modules: + import PySide2.QtXmlPatterns + from PySide2.QtXmlPatterns import QXmlName + type_map.update({ + "QXmlName.PrefixCode": Missing("PySide2.QtXmlPatterns.QXmlName.PrefixCode"), + "QXmlName.NamespaceCode": Missing("PySide2.QtXmlPatterns.QXmlName.NamespaceCode") + }) + +# QtMultimedia +if "PySide2.QtMultimedia" in loaded_modules: + import PySide2.QtMultimedia + import PySide2.QtMultimediaWidgets + type_map.update({ + "QVariantMap": dict, + "QGraphicsVideoItem": PySide2.QtMultimediaWidgets.QGraphicsVideoItem, + "QVideoWidget": PySide2.QtMultimediaWidgets.QVideoWidget, + }) + +# QtOpenGL +if "PySide2.QtOpenGL" in loaded_modules: + import PySide2.QtOpenGL + type_map.update({ + "GLuint": int, + "GLenum": int, + "GLint": int, + "GLbitfield": int, + "PySide2.QtOpenGL.GLint": int, + "PySide2.QtOpenGL.GLuint": int, + "GLfloat": float, # 5.6, MSVC 15 + }) + +# QtQml +if "PySide2.QtQml" in loaded_modules: + import PySide2.QtQml + type_map.update({ + "QJSValueList()": [], + "PySide2.QtQml.bool volatile": bool, + # from 5.9 + "QVariantHash()": {}, + }) + +# QtQml +if "PySide2.QtQuick" in loaded_modules: + import PySide2.QtQuick + type_map.update({ + "PySide2.QtQuick.QSharedPointer": int, + "PySide2.QtCore.uint": int, + "T": int, + }) + +# QtScript +if "PySide2.QtScript" in loaded_modules: + import PySide2.QtScript + type_map.update({ + "QScriptValueList()": [], + }) + +# QtTest +if "PySide2.QtTest" in loaded_modules: + import PySide2.QtTest + type_map.update({ + "PySide2.QtTest.QTouchEventSequence": PySide2.QtTest.QTest.QTouchEventSequence, + }) + +# from 5.9 +if "PySide2.QtWebEngineWidgets" in loaded_modules: + import PySide2.QtWebEngineWidgets + type_map.update({ + "PySide2.QtTest.QTouchEventSequence": PySide2.QtTest.QTest.QTouchEventSequence, + }) + +# from 5.6, MSVC +if "PySide2.QtWinExtras" in loaded_modules: + import PySide2.QtWinExtras + type_map.update({ + "QList< QWinJumpListItem* >()": [], + }) + +# Here was testbinding, actually the source of all evil. + +# end of file -- cgit v1.2.3 From f643be1153275b804e8846b54afccbfef8db43c8 Mon Sep 17 00:00:00 2001 From: Christian Tismer Date: Sun, 24 Sep 2017 18:24:10 +0200 Subject: Signature: Simplify parser by not reloading mapping The mapping had been reloading on demand. This is overkill, since we only want to initialize the new constants. This patch replaces reloading by explicit init functions. This simplifies the parser and even the loader, because sys.path is no longer relevant and no context manager is needed for a single sys.path patch. Task-number: PYSIDE-510 Change-Id: I9e3a45cb10570211183952bd517abb0084b94f47 Reviewed-by: Friedemann Kleint --- .../pyside2/PySide2/support/signature/mapping.py | 102 +++++++++++---------- 1 file changed, 52 insertions(+), 50 deletions(-) (limited to 'sources/pyside2/PySide2/support/signature/mapping.py') diff --git a/sources/pyside2/PySide2/support/signature/mapping.py b/sources/pyside2/PySide2/support/signature/mapping.py index d18ee561b..f6ec9868d 100644 --- a/sources/pyside2/PySide2/support/signature/mapping.py +++ b/sources/pyside2/PySide2/support/signature/mapping.py @@ -55,15 +55,16 @@ See _resolve_value() in singature.py import sys import collections import struct +import PySide2 PY3 = sys.version_info >= (3,) if PY3: from . import typing - exec("ellipsis = ...") + ellipsis = eval("...") Char = typing.Union[str, int] # how do I model the limitation to 1 char? StringList = typing.List[str] Variant = typing.Union[str, int, float, Char, StringList, type(ellipsis)] - # much more, do we need that? + # Much more, do we need that? Do we better kill it? ModelIndexList = typing.List[int] QImageCleanupFunction = typing.Callable[[bytes], None] else: @@ -74,8 +75,8 @@ else: ModelIndexList = list QImageCleanupFunction = object Pair = collections.namedtuple('Pair', ['first', 'second']) -# ulong_max is the long size, which is only 32 bit on windows. -ulong_max = sys.maxsize if len(struct.pack("L", 1)) != 4 else 0xffffffff +# ulong_max is only 32 bit on windows. +ulong_max = 2*sys.maxsize+1 if len(struct.pack("L", 1)) != 4 else 0xffffffff ushort_max = 0xffff GL_COLOR_BUFFER_BIT = 0x00004000 @@ -97,28 +98,27 @@ class Missing(str): def __repr__(self): return "Missing({})".format(self) -TYPE_MAP_DOC = """ - The type_map variable is central for the signature module. - - PySide has a new function 'CppGenerator::writeSignatureInfo()' - that extracts the gathered information about the function arguments - and defaults as good as it can. But what PySide generates is still - very C-ish and has many constants that Python doesn't understand. - - The function 'try_to_guess()' below understands a lot of PySide's - peculiar way to assume local context. If it is able to do the guess, - then the result is inserted into the dict, so the search happens - not again. For everything that is not covered by these automatic - guesses, we provide an entry in 'type_map' that resolves it. - - In effect, 'type_map' maps text to real Python objects. -""" +class Reloader(object): + def __init__(self): + self.sys_module_count = 0 + self.uninitialized = PySide2.__all__[:] + + def update(self): + if self.sys_module_count == len(sys.modules): + return + self.sys_module_count = len(sys.modules) + for mod_name in self.uninitialized[:]: + if "PySide2." + mod_name in sys.modules: + self.uninitialized.remove(mod_name) + proc_name = "init_" + mod_name + if proc_name in globals(): + init_proc = globals()[proc_name] + globals().update(init_proc()) + +update_mapping = Reloader().update type_map = {} -loaded_modules = sys.modules - -# QtCore -if "PySide2.QtCore" in loaded_modules: +def init_QtCore(): import PySide2.QtCore from PySide2.QtCore import Qt, QUrl, QDir, QGenericArgument from PySide2.QtCore import QMarginsF # 5.9 @@ -169,7 +169,7 @@ if "PySide2.QtCore" in loaded_modules: "PyCallable": callable, "...": ellipsis, # no idea how this should be translated... maybe so? "PyTypeObject": type, - "PySequence": list, # could be more generic + "PySequence": list, # needs to be changed, QApplication for instance! "qptrdiff": int, "true": True, "Qt.HANDLE": int, # be more explicit with some consts? @@ -215,7 +215,6 @@ if "PySide2.QtCore" in loaded_modules: "QGenericArgument((0))": None, # 5.6, RHEL 6.6. Is that ok? "4294967295UL": 4294967295, # 5.6, RHEL 6.6 }) - try: type_map.update({ "PySide2.QtCore.QMetaObject.Connection": PySide2.QtCore.Connection, # wrong! @@ -223,9 +222,9 @@ if "PySide2.QtCore" in loaded_modules: except AttributeError: # this does not exist on 5.9 ATM. pass + return locals() -# QtGui -if "PySide2.QtGui" in loaded_modules: +def init_QtGui(): import PySide2.QtGui from PySide2.QtGui import QPageLayout, QPageSize # 5.9 type_map.update({ @@ -244,9 +243,9 @@ if "PySide2.QtGui" in loaded_modules: "QList< QTouchEvent.TouchPoint >()": list, "QPixmap()": lambda:QPixmap(), # we cannot create this without qApp }) + return locals() -# QtWidgets -if "PySide2.QtWidgets" in loaded_modules: +def init_QtWidgets(): import PySide2.QtWidgets from PySide2.QtWidgets import QWidget, QMessageBox, QStyleOption, QStyleHintReturn, QStyleOptionComplex type_map.update({ @@ -263,34 +262,34 @@ if "PySide2.QtWidgets" in loaded_modules: "SH_Default": QStyleHintReturn.SH_Default, "SO_Complex": QStyleOptionComplex.SO_Complex, }) + return locals() -# QtSql -if "PySide2.QtSql" in loaded_modules: +def init_QtSql(): import PySide2.QtSql from PySide2.QtSql import QSqlDatabase type_map.update({ "QLatin1String(defaultConnection)": QSqlDatabase.defaultConnection, "QVariant.Invalid": -1, # not sure what I should create, here... }) + return locals() -# QtNetwork -if "PySide2.QtNetwork" in loaded_modules: +def init_QtNetwork(): import PySide2.QtNetwork type_map.update({ "QMultiMap": typing.DefaultDict(list) if PY3 else {}, }) + return locals() -# QtXmlPatterns -if "PySide2.QtXmlPatterns" in loaded_modules: +def init_QtXmlPatterns(): import PySide2.QtXmlPatterns from PySide2.QtXmlPatterns import QXmlName type_map.update({ "QXmlName.PrefixCode": Missing("PySide2.QtXmlPatterns.QXmlName.PrefixCode"), "QXmlName.NamespaceCode": Missing("PySide2.QtXmlPatterns.QXmlName.NamespaceCode") }) + return locals() -# QtMultimedia -if "PySide2.QtMultimedia" in loaded_modules: +def init_QtMultimedia(): import PySide2.QtMultimedia import PySide2.QtMultimediaWidgets type_map.update({ @@ -298,9 +297,9 @@ if "PySide2.QtMultimedia" in loaded_modules: "QGraphicsVideoItem": PySide2.QtMultimediaWidgets.QGraphicsVideoItem, "QVideoWidget": PySide2.QtMultimediaWidgets.QVideoWidget, }) + return locals() -# QtOpenGL -if "PySide2.QtOpenGL" in loaded_modules: +def init_QtOpenGL(): import PySide2.QtOpenGL type_map.update({ "GLuint": int, @@ -311,9 +310,9 @@ if "PySide2.QtOpenGL" in loaded_modules: "PySide2.QtOpenGL.GLuint": int, "GLfloat": float, # 5.6, MSVC 15 }) + return locals() -# QtQml -if "PySide2.QtQml" in loaded_modules: +def init_QtQml(): import PySide2.QtQml type_map.update({ "QJSValueList()": [], @@ -321,43 +320,46 @@ if "PySide2.QtQml" in loaded_modules: # from 5.9 "QVariantHash()": {}, }) + return locals() -# QtQml -if "PySide2.QtQuick" in loaded_modules: +def init_QtQuick(): import PySide2.QtQuick type_map.update({ "PySide2.QtQuick.QSharedPointer": int, "PySide2.QtCore.uint": int, "T": int, }) + return locals() -# QtScript -if "PySide2.QtScript" in loaded_modules: +def init_QtScript(): import PySide2.QtScript type_map.update({ "QScriptValueList()": [], }) + return locals() -# QtTest -if "PySide2.QtTest" in loaded_modules: +def init_QtTest(): import PySide2.QtTest type_map.update({ "PySide2.QtTest.QTouchEventSequence": PySide2.QtTest.QTest.QTouchEventSequence, }) + return locals() # from 5.9 -if "PySide2.QtWebEngineWidgets" in loaded_modules: +def init_QtWebEngineWidgets(): import PySide2.QtWebEngineWidgets type_map.update({ "PySide2.QtTest.QTouchEventSequence": PySide2.QtTest.QTest.QTouchEventSequence, }) + return locals() # from 5.6, MSVC -if "PySide2.QtWinExtras" in loaded_modules: +def init_QtWinExtras(): import PySide2.QtWinExtras type_map.update({ "QList< QWinJumpListItem* >()": [], }) + return locals() # Here was testbinding, actually the source of all evil. -- cgit v1.2.3 From 7aa010a0a0526b2cc3b947cfc277dc0da22a8081 Mon Sep 17 00:00:00 2001 From: Christian Tismer Date: Tue, 26 Sep 2017 13:59:24 +0200 Subject: Signature: support the new types and constants of 5.9 This patch covers macOS and Ubuntu (which actually had one addition). No idea how oftem we must iterate ;-) Task-number: PYSIDE-510 Change-Id: I950c57c2d225b289eafc46e7f1758338b4d62838 Reviewed-by: Friedemann Kleint --- .../pyside2/PySide2/support/signature/mapping.py | 25 ++++++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) (limited to 'sources/pyside2/PySide2/support/signature/mapping.py') diff --git a/sources/pyside2/PySide2/support/signature/mapping.py b/sources/pyside2/PySide2/support/signature/mapping.py index f6ec9868d..32ac9422f 100644 --- a/sources/pyside2/PySide2/support/signature/mapping.py +++ b/sources/pyside2/PySide2/support/signature/mapping.py @@ -67,6 +67,7 @@ if PY3: # Much more, do we need that? Do we better kill it? ModelIndexList = typing.List[int] QImageCleanupFunction = typing.Callable[[bytes], None] + FloatMatrix = typing.List[typing.List[float]] else: ellipsis = "..." Char = str @@ -74,6 +75,7 @@ else: Variant = object ModelIndexList = list QImageCleanupFunction = object + FloatMatrix = list Pair = collections.namedtuple('Pair', ['first', 'second']) # ulong_max is only 32 bit on windows. ulong_max = 2*sys.maxsize+1 if len(struct.pack("L", 1)) != 4 else 0xffffffff @@ -121,10 +123,11 @@ type_map = {} def init_QtCore(): import PySide2.QtCore from PySide2.QtCore import Qt, QUrl, QDir, QGenericArgument + from PySide2.QtCore import QRect, QSize, QPoint from PySide2.QtCore import QMarginsF # 5.9 try: # seems to be not generated by 5.9 ATM. - from PySide2.QtCore import Connection, QRect, QSize, QPoint + from PySide2.QtCore import Connection except ImportError: pass type_map.update({ @@ -210,10 +213,20 @@ def init_QtCore(): "PyUnicode": str if PY3 else unicode, "signed long": int, "PySide2.QtCore.int": int, + "PySide2.QtCore.char": StringList, # A 'char **' is a list of strings. + "char[]": StringList, # 5.9 "unsigned long int": int, # 5.6, RHEL 6.6 "unsigned short int": int, # 5.6, RHEL 6.6 "QGenericArgument((0))": None, # 5.6, RHEL 6.6. Is that ok? "4294967295UL": 4294967295, # 5.6, RHEL 6.6 + "PySide2.QtCore.int32_t": int, # 5.9 + "PySide2.QtCore.int64_t": int, # 5.9 + "UnsignedShortType": int, # 5.9 + "nullptr": None, # 5.9 + "uint64_t": int, # 5.9 + "PySide2.QtCore.uint32_t": int, # 5.9 + "float[][]": FloatMatrix, # 5.9 + "PySide2.QtCore.unsigned int": int, # 5.9 Ubuntu }) try: type_map.update({ @@ -239,7 +252,6 @@ def init_QtGui(): "GL_NEAREST": GL_NEAREST, "WId": WId, "PySide2.QtGui.QPlatformSurface": Virtual("PySide2.QtGui.QPlatformSurface"), # hmm... - "PySide2.QtCore.char": StringList, # A 'char **' is a list of strings. "QList< QTouchEvent.TouchPoint >()": list, "QPixmap()": lambda:QPixmap(), # we cannot create this without qApp }) @@ -248,6 +260,13 @@ def init_QtGui(): def init_QtWidgets(): import PySide2.QtWidgets from PySide2.QtWidgets import QWidget, QMessageBox, QStyleOption, QStyleHintReturn, QStyleOptionComplex + from PySide2.QtWidgets import QGraphicsItem, QStyleOptionGraphicsItem # 5.9 + if PY3: + GraphicsItemList = typing.List[QGraphicsItem] + StyleOptionGraphicsItemList = typing.List[QStyleOptionGraphicsItem] + else: + GraphicsItemList = list + StyleOptionGraphicsItemList = list type_map.update({ "QMessageBox.StandardButtons(Yes | No)": QMessageBox.StandardButtons( QMessageBox.Yes | QMessageBox.No), @@ -261,6 +280,8 @@ def init_QtWidgets(): "SO_Default": QStyleOption.SO_Default, "SH_Default": QStyleHintReturn.SH_Default, "SO_Complex": QStyleOptionComplex.SO_Complex, + "QGraphicsItem[]": GraphicsItemList, + "QStyleOptionGraphicsItem[]": StyleOptionGraphicsItemList, }) return locals() -- cgit v1.2.3 From 67ac7e473e312298eeb2deb16f2a50644b5f76e7 Mon Sep 17 00:00:00 2001 From: Christian Tismer Date: Thu, 28 Sep 2017 04:48:14 +0200 Subject: Signature: support the new types and constants of 5.9 part 3 This patch adds a type to MSVC. Task-number: PYSIDE-510 Change-Id: I3290c91cd6f2937bddf8ec1f673b4a672bc49db3 Reviewed-by: Friedemann Kleint --- sources/pyside2/PySide2/support/signature/mapping.py | 1 + 1 file changed, 1 insertion(+) (limited to 'sources/pyside2/PySide2/support/signature/mapping.py') diff --git a/sources/pyside2/PySide2/support/signature/mapping.py b/sources/pyside2/PySide2/support/signature/mapping.py index 32ac9422f..869e9e71e 100644 --- a/sources/pyside2/PySide2/support/signature/mapping.py +++ b/sources/pyside2/PySide2/support/signature/mapping.py @@ -227,6 +227,7 @@ def init_QtCore(): "PySide2.QtCore.uint32_t": int, # 5.9 "float[][]": FloatMatrix, # 5.9 "PySide2.QtCore.unsigned int": int, # 5.9 Ubuntu + "PySide2.QtCore.long long": int, # 5.9, MSVC 15 }) try: type_map.update({ -- cgit v1.2.3