From 85e14a0d72b3470748e3cbe8871e23a818820ee9 Mon Sep 17 00:00:00 2001
From: Alexandru Croitor <alexandru.croitor@qt.io>
Date: Fri, 23 Feb 2018 14:24:21 +0100
Subject: Add rudimentary support for address sanitizer builds

This change adds a new setup.py option called --sanitize-address
which will build all executables and shared libraries with address
sanitizer enabled. The builds will only succeed on Linux and macOS
machines that have new enough gcc / clang versions, so it is a
"use at your own risk" build configuration.

This change was necessitated by the random crashes that are sometimes
observed on the CI machines, and due to valgrind not working properly
on new macOS versions, using AddressSanitizer is the next best thing.

Note that when running tests with address sanitizer builds, you
might need to export a LD_PRELOAD / DYLD_INSERT_LIBRARIES environment
variable pointing to the address sanitizer runtime library path, which
will be provided by the crashed application.

Change-Id: I93014002e5c5e94bcc808ba2fb830d60724cfb69
Reviewed-by: Christian Tismer <tismer@stackless.com>
---
 sources/pyside2/CMakeLists.txt   | 16 ++++++++++++++++
 sources/shiboken2/CMakeLists.txt | 16 ++++++++++++++++
 2 files changed, 32 insertions(+)

(limited to 'sources')

diff --git a/sources/pyside2/CMakeLists.txt b/sources/pyside2/CMakeLists.txt
index 08ed52473..fac031fdb 100644
--- a/sources/pyside2/CMakeLists.txt
+++ b/sources/pyside2/CMakeLists.txt
@@ -398,6 +398,22 @@ else()
     message(STATUS "PySide will be generated using the protected hack!")
 endif()
 
+# Build with Address sanitizer enabled if requested. This may break things, so use at your own risk.
+if (SANITIZE_ADDRESS AND NOT MSVC)
+    # Currently this does not check that the clang / gcc version used supports Address sanitizer,
+    # so once again, use at your own risk.
+    add_compile_options("-fsanitize=address" "-g" "-fno-omit-frame-pointer")
+    # We need to add the sanitize address option to all linked executables / shared libraries
+    # so that proper sanitizer symbols are linked in.
+    #
+    # Note that when running tests, you may need to set an additional environment variable
+    # in set_tests_properties for shiboken2 / pyside tests, or exported in your shell. Address
+    # sanitizer will tell you what environment variable needs to be exported. For example:
+    # export DYLD_INSERT_LIBRARIES=/Applications/Xcode.app/Contents/Developer/Toolchains/
+    #   ./XcodeDefault.xctoolchain/usr/lib/clang/8.1.0/lib/darwin/libclang_rt.asan_osx_dynamic.dylib
+    set(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_STANDARD_LIBRARIES} -fsanitize=address")
+endif()
+
 add_subdirectory(libpyside)
 find_package(Qt5Designer)
 if(Qt5UiTools_FOUND AND Qt5Designer_FOUND)
diff --git a/sources/shiboken2/CMakeLists.txt b/sources/shiboken2/CMakeLists.txt
index 238ee2d34..c5cca506e 100644
--- a/sources/shiboken2/CMakeLists.txt
+++ b/sources/shiboken2/CMakeLists.txt
@@ -144,6 +144,22 @@ if(CMAKE_HOST_APPLE)
     endif()
 endif()
 
+# Build with Address sanitizer enabled if requested. This may break things, so use at your own risk.
+if (SANITIZE_ADDRESS AND NOT MSVC)
+    # Currently this does not check that the clang / gcc version used supports Address sanitizer,
+    # so once again, use at your own risk.
+    add_compile_options("-fsanitize=address" "-g" "-fno-omit-frame-pointer")
+    # We need to add the sanitize address option to all linked executables / shared libraries
+    # so that proper sanitizer symbols are linked in.
+    #
+    # Note that when running tests, you may need to set an additional environment variable
+    # in set_tests_properties for shiboken2 / pyside tests, or exported in your shell. Address
+    # sanitizer will tell you what environment variable needs to be exported. For example:
+    # export DYLD_INSERT_LIBRARIES=/Applications/Xcode.app/Contents/Developer/Toolchains/
+    #   ./XcodeDefault.xctoolchain/usr/lib/clang/8.1.0/lib/darwin/libclang_rt.asan_osx_dynamic.dylib
+    set(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_STANDARD_LIBRARIES} -fsanitize=address")
+endif()
+
 add_subdirectory(ApiExtractor)
 
 set(generator_plugin_DIR ${LIB_INSTALL_DIR}/generatorrunner${generator_SUFFIX})
-- 
cgit v1.2.3


From 6c0a0d70305cd6e12260a352099e74d34f3c239e Mon Sep 17 00:00:00 2001
From: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>
Date: Tue, 27 Feb 2018 14:44:39 +0100
Subject: Fix QValidator fixup() behavior

The return value from the fixup() method was ignored
leaving an Intermediate or Invalid input intact.
This was solved injecting code to the native wrapper
for the fixup() method that allows to change its value.
A test case is provided.

Task-number: PYSIDE-106
Change-Id: I1d796955178dbdbcfff90adb6ede5c8b2dd1acc3
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
---
 .../PySide2/QtGui/typesystem_gui_common.xml        |  3 +++
 sources/pyside2/PySide2/typesystem_templates.xml   |  6 +++++
 sources/pyside2/tests/QtWidgets/qvalidator_test.py | 27 ++++++++++++++++++----
 3 files changed, 32 insertions(+), 4 deletions(-)

(limited to 'sources')

diff --git a/sources/pyside2/PySide2/QtGui/typesystem_gui_common.xml b/sources/pyside2/PySide2/QtGui/typesystem_gui_common.xml
index 55bc438be..2578a1aa9 100644
--- a/sources/pyside2/PySide2/QtGui/typesystem_gui_common.xml
+++ b/sources/pyside2/PySide2/QtGui/typesystem_gui_common.xml
@@ -1713,6 +1713,9 @@
       <modify-argument index="return">
         <replace-type modified-type="QString"/>
       </modify-argument>
+      <inject-code class="native" position="end">
+        <insert-template name="return_QString_native"/>
+      </inject-code>
       <inject-code class="target" position="end">
         <insert-template name="return_QString"/>
       </inject-code>
diff --git a/sources/pyside2/PySide2/typesystem_templates.xml b/sources/pyside2/PySide2/typesystem_templates.xml
index 7ac4ac158..e0b47b6e3 100644
--- a/sources/pyside2/PySide2/typesystem_templates.xml
+++ b/sources/pyside2/PySide2/typesystem_templates.xml
@@ -278,6 +278,12 @@
     <template name="return_QString">
         %PYARG_0 = %CONVERTTOPYTHON[QString](%1);
     </template>
+    <template name="return_QString_native">
+        if (%ISCONVERTIBLE[QString](%PYARG_0))
+            %1 = %CONVERTTOCPP[QString](%PYARG_0);
+        else
+            qWarning("%TYPE::%FUNCTION_NAME: Argument is not convertible to unicode.");
+    </template>
 
     <template name="return_tuple_QValidator_QString_int">
     %BEGIN_ALLOW_THREADS
diff --git a/sources/pyside2/tests/QtWidgets/qvalidator_test.py b/sources/pyside2/tests/QtWidgets/qvalidator_test.py
index 951d6b2b0..dd5eaadb3 100644
--- a/sources/pyside2/tests/QtWidgets/qvalidator_test.py
+++ b/sources/pyside2/tests/QtWidgets/qvalidator_test.py
@@ -29,38 +29,49 @@
 from PySide2.QtCore import *
 from PySide2.QtGui import *
 from PySide2.QtWidgets import *
+from PySide2.QtTest import *
 
 import unittest
 from helper import UsesQApplication
 
 class MyValidator1(QValidator):
-    def fixUp(self, input):
+    def fixup(self, input):
         return "fixed"
 
     def validate(self, input, pos):
         return (QValidator.Acceptable, "fixed", 1)
 
 class MyValidator2(QValidator):
-    def fixUp(self, input):
+    def fixup(self, input):
         return "fixed"
 
     def validate(self, input, pos):
         return (QValidator.Acceptable, "fixed")
 
 class MyValidator3(QValidator):
-    def fixUp(self, input):
+    def fixup(self, input):
         return "fixed"
 
     def validate(self, input, pos):
         return (QValidator.Acceptable,)
 
 class MyValidator4(QValidator):
-    def fixUp(self, input):
+    def fixup(self, input):
         return "fixed"
 
     def validate(self, input, pos):
         return QValidator.Acceptable
 
+class MyValidator5(QValidator):
+    def validate(self, input, pos):
+        if input.islower():
+            return (QValidator.Intermediate, input, pos)
+        else:
+            return (QValidator.Acceptable, input, pos)
+
+    def fixup(self, input):
+        return "22"
+
 class QValidatorTest(UsesQApplication):
     def testValidator1(self):
         line = QLineEdit()
@@ -110,5 +121,13 @@ class QValidatorTest(UsesQApplication):
         self.assertEqual(line.text(), "foo")
         self.assertEqual(line.cursorPosition(), 3)
 
+    def testValidator5(self):
+        line = QLineEdit()
+        line.show()
+        line.setValidator(MyValidator5())
+        line.setText("foo")
+        QTest.keyClick(line, Qt.Key_Return)
+        self.assertEqual(line.text(), "22")
+
 if __name__ == '__main__':
     unittest.main()
-- 
cgit v1.2.3


From b57c557c8cd1012851f8a245075591dc33be425b Mon Sep 17 00:00:00 2001
From: Alexandru Croitor <alexandru.croitor@qt.io>
Date: Thu, 1 Mar 2018 11:50:07 +0100
Subject: Implement proper package versioning

This change is inspired by / follows PEP 440 for handling version
numbers and also takes into account the Qt versioning scheme.

PySide2 as package name will stay as-is (not renamed to PySide5).

Release versions would have the following pattern:
PySide2 5.x.y (e.g. 5.6.3)

Package (wheel) name would also contain the bundled Qt version, e.g.:
PySide2-5.6.0-5.6.4-cp27-cp27m-macosx_10_7_intel.whl

Pre-release versions would look like:
PySide2 5.6.0a1, 5.6.0a2, 5.6.0b1, 5.6.0b2, 5.6.0rc1, etc.

Development (snapshot) versions would look like:
PySide2 5.6.0-dev123456789 (last part is timestamp of build time)

All of the examples above comply with the PEP 440 rules.

In the example above where the Qt version is specified as part of the
wheel package name ("5.6.4"), the Qt version is not part of the
package version itself, because it doesn't comply with PEP 440.

But it does comply with wheel package names (PEP 427), and by that
PEP's definitions, it will be the optional "build tag" part of the
file name, which is preceded by the actual package version, and
followed by the python version / abi tag.

Implementation:
This change defines two new python configuration files which will be
the authoritative source for the shiboken and PySide2 libraries, as
well as the final PySide2 package itself:
sources/shiboken/shiboken_version.py
sources/pyside2/pyside_version.py

The pyside_version.py file will be the source of the final package
version.

The shiboken and PySide2 version should be modified in sync, when
bumping the version of the package before a release.

The reason for having both files instead of 1, is to make life easier
for developers that might extract only shiboken from the repository.
If at some point shiboken and PySide2 CMake projects get merged into
one project, the duplicate version files would go away.

The version files are parsed by CMake to correctly name the shared
libraries (and SO versions), and they are also read by the setup.py
script, to generate correct package metadata and a correct package
(wheel) name.

This change also removes the broken dist targets from PySide2's and
shiboken's CMakelists files, which depended on some version suffix
which was never set in setup.py.

PEP440: https://www.python.org/dev/peps/pep-0440/
PEP427: https://www.python.org/dev/peps/pep-0427/

Change-Id: I3226460b1adf2555c8711fa2ba47c223b957cb44
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>
---
 sources/pyside2/CMakeLists.txt                   | 67 ++++++++++++++----------
 sources/pyside2/PySide2/CMakeLists.txt           |  5 ++
 sources/pyside2/PySide2/__init__.py.in           |  7 ++-
 sources/pyside2/PySide2/_config.py.in            | 11 ++++
 sources/pyside2/pyside_version.py                | 10 ++++
 sources/pyside2/tests/pysidetest/version_test.py |  6 ++-
 sources/shiboken2/CMakeLists.txt                 | 44 +++++++++-------
 sources/shiboken2/shiboken_version.py            | 10 ++++
 8 files changed, 110 insertions(+), 50 deletions(-)
 create mode 100644 sources/pyside2/pyside_version.py
 create mode 100644 sources/shiboken2/shiboken_version.py

(limited to 'sources')

diff --git a/sources/pyside2/CMakeLists.txt b/sources/pyside2/CMakeLists.txt
index fac031fdb..56eadb844 100644
--- a/sources/pyside2/CMakeLists.txt
+++ b/sources/pyside2/CMakeLists.txt
@@ -21,6 +21,27 @@ else()
     find_package(PythonLibs 2.6)
 endif()
 
+set(PYSIDE_VERSION_FILE_PATH "${CMAKE_SOURCE_DIR}/pyside_version.py")
+set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
+  ${PYSIDE_VERSION_FILE_PATH}
+)
+execute_process(
+  COMMAND ${PYTHON_EXECUTABLE} "${PYSIDE_VERSION_FILE_PATH}"
+  OUTPUT_VARIABLE PYSIDE_VERSION_OUTPUT
+  ERROR_VARIABLE PYSIDE_VERSION_OUTPUT_ERROR
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
+if (NOT PYSIDE_VERSION_OUTPUT)
+    message(FATAL_ERROR "Could not identify PySide2 version. Error: ${PYSIDE_VERSION_OUTPUT_ERROR}")
+endif()
+
+list(GET PYSIDE_VERSION_OUTPUT 0 BINDING_API_MAJOR_VERSION)
+list(GET PYSIDE_VERSION_OUTPUT 1 BINDING_API_MINOR_VERSION)
+list(GET PYSIDE_VERSION_OUTPUT 2 BINDING_API_MICRO_VERSION)
+# a - alpha, b - beta, rc - rc
+list(GET PYSIDE_VERSION_OUTPUT 3 BINDING_API_PRE_RELEASE_VERSION_TYPE)
+# the number of the pre release (alpha1, beta3, rc7, etc.)
+list(GET PYSIDE_VERSION_OUTPUT 4 BINDING_API_PRE_RELEASE_VERSION)
+
 macro(get_python_extension_suffix)
   # Result of imp.get_suffixes() depends on the platform, but generally looks something like:
   # [('.cpython-34m-x86_64-linux-gnu.so', 'rb', 3), ('.cpython-34m.so', 'rb', 3),
@@ -160,19 +181,15 @@ if(NOT CMAKE_BUILD_TYPE)
 endif()
 
 set(BINDING_NAME PySide2)
-set(BINDING_API_MAJOR_VERSION "2")
-set(BINDING_API_MINOR_VERSION "0")
-set(BINDING_API_MICRO_VERSION "0")
-set(BINDING_API_RELEASE_LEVEL "alpha") # alpha, beta, rc, or final
-set(BINDING_API_SERIAL 0) # leave as 0 when release level is final
-set(BINDING_API_VERSION "${BINDING_API_MAJOR_VERSION}.${BINDING_API_MINOR_VERSION}.${BINDING_API_MICRO_VERSION}" CACHE STRING "PySide version" FORCE)
+
+set(BINDING_API_VERSION "${BINDING_API_MAJOR_VERSION}.${BINDING_API_MINOR_VERSION}.${BINDING_API_MICRO_VERSION}" CACHE STRING "PySide2 version" FORCE)
 set(PYSIDE_SO_VERSION ${BINDING_API_MAJOR_VERSION}.${BINDING_API_MINOR_VERSION})
-if (BINDING_API_RELEASE_LEVEL STREQUAL "final")
+if (BINDING_API_PRE_RELEASE_VERSION_TYPE STREQUAL "")
     set(BINDING_API_VERSION_FULL "${BINDING_API_MAJOR_VERSION}.${BINDING_API_MINOR_VERSION}.${BINDING_API_MICRO_VERSION}"
-        CACHE STRING "PySide version [full]" FORCE)
+        CACHE STRING "PySide2 version [full]" FORCE)
 else()
-    set(BINDING_API_VERSION_FULL "${BINDING_API_MAJOR_VERSION}.${BINDING_API_MINOR_VERSION}.${BINDING_API_MICRO_VERSION}~${BINDING_API_RELEASE_LEVEL}${BINDING_API_SERIAL}"
-        CACHE STRING "PySide version [full]" FORCE)
+    set(BINDING_API_VERSION_FULL "${BINDING_API_MAJOR_VERSION}.${BINDING_API_MINOR_VERSION}.${BINDING_API_MICRO_VERSION}~${BINDING_API_PRE_RELEASE_VERSION_TYPE}${BINDING_API_PRE_RELEASE_VERSION}"
+        CACHE STRING "PySide2 version [full]" FORCE)
 endif()
 
 string(TIMESTAMP PYSIDE_BUILD_DATE "%Y-%m-%dT%H:%M:%S+00:00" UTC)
@@ -180,6 +197,19 @@ if (PYSIDE_BUILD_DATE)
     set(PYSIDE_BUILD_DATE "__build_date__ = '${PYSIDE_BUILD_DATE}'")
 endif()
 
+if (PYSIDE_SETUP_PY_PACKAGE_VERSION)
+    set(PYSIDE_SETUP_PY_PACKAGE_VERSION_ASSIGNMENT "__setup_py_package_version__ = '${PYSIDE_SETUP_PY_PACKAGE_VERSION}'")
+    set(FINAL_PACKAGE_VERSION ${PYSIDE_SETUP_PY_PACKAGE_VERSION})
+else()
+    set(FINAL_PACKAGE_VERSION ${BINDING_API_VERSION_FULL})
+endif()
+
+if (PYSIDE_SETUP_PY_PACKAGE_TIMESTAMP)
+    set(PYSIDE_SETUP_PY_PACKAGE_TIMESTAMP_ASSIGNMENT "__setup_py_package_timestamp__ = '${PYSIDE_SETUP_PY_PACKAGE_TIMESTAMP}'")
+else()
+    set(PYSIDE_SETUP_PY_PACKAGE_TIMESTAMP_ASSIGNMENT "__setup_py_package_timestamp__ = ''")
+endif()
+
 find_package(Git)
 if(GIT_FOUND)
     # Check if current source folder is inside a git repo, so that commit information can be
@@ -221,11 +251,6 @@ if(GIT_FOUND)
     endif()
 endif()
 
-# Used by setup.py to know which symlink to resolve and copy in to the final package, in order to
-# avoid resolving all symlinks and thus copying unnecessary duplicate files.
-set(config_py_shiboken_library_version "")
-set(config_py_pyside_library_version "")
-
 include(PySideModules)
 
 macro(COLLECT_MODULE_IF_FOUND shortname)
@@ -346,8 +371,6 @@ endif()
 # Define supported Qt Version
 set(SUPPORTED_QT_VERSION "${QT_VERSION_MAJOR}.${QT_VERSION_MINOR}")
 
-set(BINDING_VERSION ${BINDING_API_VERSION}.${QT_VERSION_MAJOR}.${QT_VERSION_MINOR})
-
 # uninstall target
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake"
                "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
@@ -356,16 +379,6 @@ add_custom_target(uninstall "${CMAKE_COMMAND}"
                   -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
 
 
-set(ARCHIVE_NAME pyside-qt${QT_VERSION_MAJOR}.${QT_VERSION_MINOR}+${BINDING_API_VERSION_FULL})
-add_custom_target(dist
-    COMMAND mkdir -p "${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}" &&
-            git log > "${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}/ChangeLog" &&
-            git archive --prefix=${ARCHIVE_NAME}/ HEAD --format=tar --output="${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar" &&
-            tar -C "${CMAKE_BINARY_DIR}" --owner=root --group=root -r "${ARCHIVE_NAME}/ChangeLog" -f "${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar" &&
-            bzip2 -f9 "${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar" &&
-            echo "Source package created at ${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar.bz2.\n"
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
-
 if (NOT PYTHON_SITE_PACKAGES)
     execute_process(
         COMMAND ${SHIBOKEN_PYTHON_INTERPRETER} -c "if True:
diff --git a/sources/pyside2/PySide2/CMakeLists.txt b/sources/pyside2/PySide2/CMakeLists.txt
index 931842b00..02b4a7c16 100644
--- a/sources/pyside2/PySide2/CMakeLists.txt
+++ b/sources/pyside2/PySide2/CMakeLists.txt
@@ -10,6 +10,9 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/__init__.py.in"
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/_config.py.in"
               "${CMAKE_CURRENT_BINARY_DIR}/_config.py" @ONLY)
 
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/../pyside_version.py"
+               "${CMAKE_CURRENT_BINARY_DIR}/_git_pyside_version.py" @ONLY)
+
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/support/__init__.py"
                "${CMAKE_CURRENT_BINARY_DIR}/support/__init__.py" COPYONLY)
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/support/signature/__init__.py"
@@ -48,6 +51,8 @@ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/__init__.py"
         DESTINATION "${PYTHON_SITE_PACKAGES}/${BINDING_NAME}${pyside2_SUFFIX}")
 install(FILES "${CMAKE_CURRENT_BINARY_DIR}/_config.py"
         DESTINATION "${PYTHON_SITE_PACKAGES}/${BINDING_NAME}${pyside2_SUFFIX}")
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/_git_pyside_version.py"
+        DESTINATION "${PYTHON_SITE_PACKAGES}/${BINDING_NAME}${pyside2_SUFFIX}")
 install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/typesystem_templates.xml
         DESTINATION share/PySide2${pyside_SUFFIX}/typesystems)
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pyside2_global.h
diff --git a/sources/pyside2/PySide2/__init__.py.in b/sources/pyside2/PySide2/__init__.py.in
index 92e52a81a..4ce266b69 100644
--- a/sources/pyside2/PySide2/__init__.py.in
+++ b/sources/pyside2/PySide2/__init__.py.in
@@ -1,14 +1,17 @@
 __all__ = list("Qt" + body for body in
     "@all_module_shortnames@"
     .split(";"))
-__version__         = "@BINDING_API_VERSION_FULL@"
-__version_info__    = (@BINDING_API_MAJOR_VERSION@, @BINDING_API_MINOR_VERSION@, @BINDING_API_MICRO_VERSION@, "@BINDING_API_RELEASE_LEVEL@", @BINDING_API_SERIAL@)
+__version__ = "@FINAL_PACKAGE_VERSION@"
+__version_info__ = (@BINDING_API_MAJOR_VERSION@, @BINDING_API_MINOR_VERSION@, @BINDING_API_MICRO_VERSION@, "@BINDING_API_PRE_RELEASE_VERSION_TYPE@", @BINDING_API_PRE_RELEASE_VERSION@)
 
 @PYSIDE_BUILD_DATE@
 @PYSIDE_BUILD_COMMIT_DATE@
 @PYSIDE_BUILD_COMMIT_HASH@
 @PYSIDE_BUILD_COMMIT_HASH_DESCRIBED@
 
+# Timestamp used for snapshot build, which is part of snapshot package version.
+@PYSIDE_SETUP_PY_PACKAGE_TIMESTAMP_ASSIGNMENT@
+
 def _setupQtDirectories():
     import sys
     import os
diff --git a/sources/pyside2/PySide2/_config.py.in b/sources/pyside2/PySide2/_config.py.in
index db8a17210..6f8d022dc 100644
--- a/sources/pyside2/PySide2/_config.py.in
+++ b/sources/pyside2/PySide2/_config.py.in
@@ -4,3 +4,14 @@ built_modules = list(name for name in
 
 shiboken_library_soversion = str(@SHIBOKEN_SO_VERSION@)
 pyside_library_soversion = str(@PYSIDE_SO_VERSION@)
+
+version = "@FINAL_PACKAGE_VERSION@"
+version_info = (@BINDING_API_MAJOR_VERSION@, @BINDING_API_MINOR_VERSION@, @BINDING_API_MICRO_VERSION@, "@BINDING_API_PRE_RELEASE_VERSION_TYPE@", @BINDING_API_PRE_RELEASE_VERSION@)
+
+@PYSIDE_BUILD_DATE@
+@PYSIDE_BUILD_COMMIT_DATE@
+@PYSIDE_BUILD_COMMIT_HASH@
+@PYSIDE_BUILD_COMMIT_HASH_DESCRIBED@
+
+# Timestamp used for snapshot build, which is part of snapshot package version.
+@PYSIDE_SETUP_PY_PACKAGE_TIMESTAMP_ASSIGNMENT@
diff --git a/sources/pyside2/pyside_version.py b/sources/pyside2/pyside_version.py
new file mode 100644
index 000000000..b207d6b9c
--- /dev/null
+++ b/sources/pyside2/pyside_version.py
@@ -0,0 +1,10 @@
+major_version = "5"
+minor_version = "6"
+patch_version = "0"
+pre_release_version_type = "a" # e.g. "a", "b", "rc".
+pre_release_version = "1" # e.g "1", "2", (which means "beta1", "beta2", if type is "b")
+
+if __name__ == '__main__':
+    # Used by CMake.
+    print('{0};{1};{2};{3};{4}'.format(major_version, minor_version, patch_version,
+                                       pre_release_version_type, pre_release_version))
diff --git a/sources/pyside2/tests/pysidetest/version_test.py b/sources/pyside2/tests/pysidetest/version_test.py
index 5901a56c1..01e88dbc6 100644
--- a/sources/pyside2/tests/pysidetest/version_test.py
+++ b/sources/pyside2/tests/pysidetest/version_test.py
@@ -33,8 +33,10 @@ from PySide2 import __version_info__, __version__, QtCore
 
 class CheckForVariablesTest(unittest.TestCase):
     def testVesions(self):
-        self.assertTrue(__version_info__ >= (1, 0, 0))
-        self.assertTrue(__version_info__ < (99, 99, 99))
+        version_tuple = (__version_info__[0], __version_info__[1], __version_info__[2])
+        self.assertTrue(version_tuple >= (1, 0, 0))
+
+        self.assertTrue(version_tuple < (99, 99, 99))
         self.assertTrue(__version__)
 
         self.assertTrue(QtCore.__version_info__ >= (4, 5, 0))
diff --git a/sources/shiboken2/CMakeLists.txt b/sources/shiboken2/CMakeLists.txt
index c5cca506e..5735fea18 100644
--- a/sources/shiboken2/CMakeLists.txt
+++ b/sources/shiboken2/CMakeLists.txt
@@ -11,12 +11,6 @@ find_package(Qt5 REQUIRED COMPONENTS Core Xml XmlPatterns)
 
 add_definitions(${Qt5Core_DEFINITIONS})
 
-set(shiboken_MAJOR_VERSION "2")
-set(shiboken_MINOR_VERSION "0")
-set(shiboken_MICRO_VERSION "0")
-set(shiboken2_VERSION "${shiboken_MAJOR_VERSION}.${shiboken_MINOR_VERSION}.${shiboken_MICRO_VERSION}")
-set(shiboken2_library_so_version "${shiboken_MAJOR_VERSION}.${shiboken_MINOR_VERSION}")
-
 option(BUILD_TESTS "Build tests." TRUE)
 option(USE_PYTHON_VERSION "Use specific python version to build shiboken2." "")
 
@@ -28,6 +22,31 @@ else()
     find_package(PythonLibs 2.6)
 endif()
 
+set(SHIBOKEN_VERSION_FILE_PATH "${CMAKE_SOURCE_DIR}/shiboken_version.py")
+set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
+  ${SHIBOKEN_VERSION_FILE_PATH}
+)
+execute_process(
+  COMMAND ${PYTHON_EXECUTABLE} "${SHIBOKEN_VERSION_FILE_PATH}"
+  OUTPUT_VARIABLE SHIBOKEN_VERSION_OUTPUT
+  ERROR_VARIABLE SHIBOKEN_VERSION_OUTPUT_ERROR
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
+if (NOT SHIBOKEN_VERSION_OUTPUT)
+    message(FATAL_ERROR "Could not identify shiboken version. \
+                         Error: ${SHIBOKEN_VERSION_OUTPUT_ERROR}")
+endif()
+
+list(GET SHIBOKEN_VERSION_OUTPUT 0 shiboken_MAJOR_VERSION)
+list(GET SHIBOKEN_VERSION_OUTPUT 1 shiboken_MINOR_VERSION)
+list(GET SHIBOKEN_VERSION_OUTPUT 2 shiboken_MICRO_VERSION)
+# a - alpha, b - beta, rc - rc
+list(GET SHIBOKEN_VERSION_OUTPUT 3 shiboken_PRE_RELEASE_VERSION_TYPE)
+# the number of the pre release (alpha1, beta3, rc7, etc.)
+list(GET SHIBOKEN_VERSION_OUTPUT 4 shiboken_PRE_RELEASE_VERSION)
+
+set(shiboken2_VERSION "${shiboken_MAJOR_VERSION}.${shiboken_MINOR_VERSION}.${shiboken_MICRO_VERSION}")
+set(shiboken2_library_so_version "${shiboken_MAJOR_VERSION}.${shiboken_MINOR_VERSION}")
+
 ## For debugging the PYTHON* variables
 message("PYTHONLIBS_FOUND: " ${PYTHONLIBS_FOUND})
 message("PYTHON_LIBRARIES: " ${PYTHON_LIBRARIES})
@@ -279,16 +298,3 @@ else()
 endif()
 
 add_subdirectory(data)
-
-# dist target
-set(ARCHIVE_NAME ${CMAKE_PROJECT_NAME}-${shiboken2_VERSION})
-add_custom_target(dist
-    COMMAND mkdir -p "${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}" &&
-            git log > "${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}/ChangeLog" &&
-            git archive --prefix=${ARCHIVE_NAME}/ HEAD --format=tar --output="${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar" &&
-            tar -C "${CMAKE_BINARY_DIR}" --owner=root --group=root -r "${ARCHIVE_NAME}/ChangeLog" -f "${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar" &&
-            bzip2 -f9 "${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar" &&
-            echo "Source package created at ${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar.bz2."
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
-
-
diff --git a/sources/shiboken2/shiboken_version.py b/sources/shiboken2/shiboken_version.py
new file mode 100644
index 000000000..b207d6b9c
--- /dev/null
+++ b/sources/shiboken2/shiboken_version.py
@@ -0,0 +1,10 @@
+major_version = "5"
+minor_version = "6"
+patch_version = "0"
+pre_release_version_type = "a" # e.g. "a", "b", "rc".
+pre_release_version = "1" # e.g "1", "2", (which means "beta1", "beta2", if type is "b")
+
+if __name__ == '__main__':
+    # Used by CMake.
+    print('{0};{1};{2};{3};{4}'.format(major_version, minor_version, patch_version,
+                                       pre_release_version_type, pre_release_version))
-- 
cgit v1.2.3