Python bindings for kate

Only wraps some of the KTextEditor stuff, not ready for use atm

CMakeLists.txt

@@ -16,6 +16,10 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
+set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+
+option(BUILD_PYTHON_BINDINDS "Enable building python bindings" OFF)
+
 # We need some parts of the ECM CMake helpers.
 find_package(ECM ${KF5_DEP_VERSION} QUIET REQUIRED NO_MODULE)
 
@@ -35,12 +39,6 @@ include(ECMDeprecationSettings)
 
 include(FeatureSummary)
 
-
-ecm_set_disabled_deprecation_versions(
-    QT 5.15
-    KF 5.90
-)
-
 # forbid some old things
 add_definitions(-DQT_NO_FOREACH)
 
@@ -64,6 +62,11 @@ ecm_optional_add_subdirectory(apps)
 # our documentation
 ecm_optional_add_subdirectory(doc)
 
+# python bindings
+if (BUILD_PYTHON_BINDINDS)
+    ecm_optional_add_subdirectory(python)
+endif()
+
 ki18n_install(po)
 if(KF5DocTools_FOUND)
     kdoctools_install(po)

addons/CMakeLists.txt

+ecm_set_disabled_deprecation_versions(
+    QT 5.15
+    KF 5.90
+)
+
 function (kate_add_plugin name)
     kcoreaddons_add_plugin(${name} INSTALL_NAMESPACE "ktexteditor")
 endfunction()

apps/lib/CMakeLists.txt

 # Kate shared library, used by Kate/KWrite and the addons
+ecm_set_disabled_deprecation_versions(
+    QT 5.15
+    KF 5.90
+)
+
 add_library(kateprivate SHARED "")
 set_target_properties(kateprivate PROPERTIES VERSION ${RELEASE_SERVICE_VERSION})
 install(TARGETS kateprivate ${KDE_INSTALL_TARGETS_DEFAULT_ARGS} LIBRARY NAMELINK_SKIP)

cmake/FindPySide2.cmake

+#
+# SPDX-FileCopyrightText: 2019-2022 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+# Author: Renato Araujo Oliveira Filho <renato.araujo@kdab.com>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+#  PYSIDE_BASEDIR       - Top of the PySide2 installation
+#  PYSIDE_INCLUDE_DIR   - Directories to include to use PySide2
+#  PYSIDE_LIBRARY       - Files to link against to use PySide2
+#  PYSIDE_TYPESYSTEMS   - Type system files that should be used by other bindings extending PySide2
+#
+# You can install PySide2 from Qt repository with
+# pip3 install --index-url=https://download.qt.io/official_releases/QtForPython --trusted-host download.qt.io pyside2
+
+find_package(PkgConfig)
+if(PKG_CONFIG_FOUND)
+    pkg_check_modules(PYSIDE2_PRIV QUIET pyside2)
+endif()
+
+set(PYSIDE2_FOUND FALSE)
+
+if(PYSIDE2_PRIV_FOUND)
+    set(PYSIDE2_FOUND TRUE)
+    message(STATUS "Using PySide2 found in the system!")
+    pkg_get_variable(SHIBOKEN_BINARY
+        pyside2
+        generator_location
+    )
+    pkg_get_variable(PYSIDE2_BASEDIR
+        pyside2
+        typesystemdir
+    )
+    pkg_get_variable(PYSIDE_INCLUDE_DIR
+        pyside2
+        includedir
+    )
+    set(PYSIDE_TYPESYSTEMS ${PYSIDE2_BASEDIR})
+    set(PYSIDE2_SO_VERSION ${PYSIDE2_PRIV_VERSION})
+    set(PYSIDE_LIBRARY ${PYSIDE2_PRIV_LINK_LIBRARIES})
+    list(GET PYSIDE_LIBRARY 0 PYSIDE_LIBRARY)
+else()
+    # extract python library basename
+    list(GET Python3_LIBRARIES 0 PYTHON_LIBRARY_FILENAME)
+    get_filename_component(PYTHON_LIBRARY_FILENAME ${PYTHON_LIBRARY_FILENAME} NAME)
+
+    execute_process(
+        COMMAND ${Python3_EXECUTABLE} -c "if True:
+            import os, sys
+            try:
+              import PySide2.QtCore as QtCore
+              print(os.path.dirname(QtCore.__file__))
+            except Exception as error:
+              print(error, file=sys.stderr)
+              exit()
+        "
+        OUTPUT_VARIABLE PYSIDE2_BASEDIR
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(NOT PYSIDE2_BASEDIR)
+        message(
+            FATAL_ERROR
+                "The PySide2 module could not be imported. Make sure you have it installed "
+                "by checking the output of \"pip${Python3_VERSION_MAJOR}.${Python3_VERSION_MINOR} list\""
+        )
+    endif()
+
+    set(PYSIDE_BASEDIR ${PYSIDE2_BASEDIR} CACHE PATH "Top level install of PySide2" FORCE)
+    execute_process(
+        COMMAND ${Python3_EXECUTABLE} -c "if True:
+            import os
+            import PySide2.QtCore as QtCore
+            print(os.path.basename(QtCore.__file__).split('.', 1)[1])
+        "
+        OUTPUT_VARIABLE PYSIDE2_SUFFIX
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+    execute_process(
+        COMMAND ${Python3_EXECUTABLE} -c "if True:
+            import os
+            import PySide2.QtCore as QtCore
+            print(';'.join(map(str, QtCore.__version_info__)))
+        "
+        OUTPUT_VARIABLE PYSIDE2_SO_VERSION
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    list(GET PYSIDE2_SO_VERSION 0 PYSIDE2_SO_MACRO_VERSION)
+    list(GET PYSIDE2_SO_VERSION 1 PYSIDE2_SO_MICRO_VERSION)
+    list(GET PYSIDE2_SO_VERSION 2 PYSIDE2_SO_MINOR_VERSION)
+    string(REPLACE ";" "." PYSIDE2_SO_VERSION "${PYSIDE2_SO_VERSION}")
+
+    if(NOT APPLE)
+        set(PYSIDE2_SUFFIX "${PYSIDE2_SUFFIX}.${PYSIDE2_SO_MACRO_VERSION}.${PYSIDE2_SO_MICRO_VERSION}")
+    else()
+        string(REPLACE ".so" "" PYSIDE2_SUFFIX ${PYSIDE2_SUFFIX})
+        set(PYSIDE2_SUFFIX "${PYSIDE2_SUFFIX}.${PYSIDE2_SO_MACRO_VERSION}.${PYSIDE2_SO_MICRO_VERSION}.dylib")
+    endif()
+
+    set(PYSIDE2_FOUND TRUE)
+    message(STATUS "PySide2 base dir:           ${PYSIDE2_BASEDIR}")
+    message(STATUS "PySide2 suffix:             ${PYSIDE2_SUFFIX}")
+
+    #PySide
+    #===============================================================================
+    find_path(PYSIDE_INCLUDE_DIR
+        pyside.h
+        PATHS ${PYSIDE2_BASEDIR}/include ${PYSIDE_CUSTOM_PREFIX}/include/PySide2
+        NO_DEFAULT_PATH)
+
+    # Platform specific library names
+    if(MSVC)
+        set(PYSIDE_LIBRARY_BASENAMES "pyside2.abi3.lib")
+    elseif(CYGWIN)
+        set(PYSIDE_LIBRARY_BASENAMES "")
+    elseif(WIN32)
+        set(PYSIDE_LIBRARY_BASENAMES "libpyside2.${PYSIDE2_SUFFIX}")
+    else()
+        set(PYSIDE_LIBRARY_BASENAMES "libpyside2.${PYSIDE2_SUFFIX}")
+    endif()
+
+    find_file(PYSIDE_LIBRARY
+        ${PYSIDE_LIBRARY_BASENAMES}
+        PATHS ${PYSIDE2_BASEDIR} ${PYSIDE_CUSTOM_PREFIX}/lib
+        NO_DEFAULT_PATH)
+
+    find_path(PYSIDE_TYPESYSTEMS
+        typesystem_core.xml
+        PATHS ${PYSIDE2_BASEDIR}/typesystems ${PYSIDE_CUSTOM_PREFIX}/share/PySide2/typesystems
+        NO_DEFAULT_PATH)
+endif()
+
+if(PYSIDE2_FOUND)
+    message(STATUS "PySide include dir:         ${PYSIDE_INCLUDE_DIR}")
+    message(STATUS "PySide library:             ${PYSIDE_LIBRARY}")
+    message(STATUS "PySide typesystems:         ${PYSIDE_TYPESYSTEMS}")
+    message(STATUS "PySide2 version:            ${PYSIDE2_SO_VERSION}")
+
+    # Create PySide2 target
+    add_library(PySide2::pyside2 SHARED IMPORTED GLOBAL)
+    if(MSVC)
+        set_property(TARGET PySide2::pyside2 PROPERTY IMPORTED_IMPLIB ${PYSIDE_LIBRARY})
+    endif()
+    set_property(TARGET PySide2::pyside2 PROPERTY IMPORTED_LOCATION ${PYSIDE_LIBRARY})
+    set_property(TARGET PySide2::pyside2 APPEND PROPERTY
+        INTERFACE_INCLUDE_DIRECTORIES
+        ${PYSIDE_INCLUDE_DIR}
+        ${PYSIDE_INCLUDE_DIR}/QtCore/
+        ${PYSIDE_INCLUDE_DIR}/QtGui/
+        ${PYSIDE_INCLUDE_DIR}/QtWidgets/
+        ${Python3_INCLUDE_DIRS}
+    )
+endif()
+
+find_package_handle_standard_args(PySide2
+    REQUIRED_VARS PYSIDE2_BASEDIR PYSIDE_INCLUDE_DIR PYSIDE_LIBRARY PYSIDE_TYPESYSTEMS
+    VERSION_VAR PYSIDE2_SO_VERSION
+)

cmake/FindShiboken2.cmake

+#
+# SPDX-FileCopyrightText: 2019-2022 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+# Author: Renato Araujo Oliveira Filho <renato.araujo@kdab.com>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+#  SHIBOKEN_INCLUDE_DIR        - Directories to include to use SHIBOKEN
+#  SHIBOKEN_LIBRARY            - Files to link against to use SHIBOKEN
+#  SHIBOKEN_BINARY             - Executable name
+#  SHIBOKEN_BUILD_TYPE         - Tells if Shiboken was compiled in Release or Debug mode.
+
+# You can install Shiboken from Qt repository with
+# pip3 install --index-url=https://download.qt.io/official_releases/QtForPython \
+#     --trusted-host download.qt.io shiboken2-generator
+
+find_package(PkgConfig)
+if(PKG_CONFIG_FOUND)
+    pkg_check_modules(SHIBOKEN2_PRIV QUIET shiboken2)
+endif()
+
+set(SHIBOKEN_FOUND FALSE)
+
+if(SHIBOKEN2_PRIV_FOUND)
+    set(SHIBOKEN_FOUND TRUE)
+    message(STATUS "Using shiboken found in the system!")
+    pkg_get_variable(SHIBOKEN_BINARY
+        shiboken2
+        generator_location
+    )
+    pkg_get_variable(SHIBOKEN_BASEDIR
+        shiboken2
+        libdir
+    )
+    pkg_get_variable(SHIBOKEN_INCLUDE_DIR
+        shiboken2
+        includedir
+    )
+    set(SHIBOKEN_VERSION ${SHIBOKEN2_PRIV_VERSION})
+    set(SHIBOKEN_LIBRARY ${SHIBOKEN2_PRIV_LINK_LIBRARIES})
+else()
+    execute_process(
+        COMMAND ${Python3_EXECUTABLE} -c "if True:
+            import os
+            try:
+                import shiboken2_generator
+                print(shiboken2_generator.__path__[0])
+            except:
+                exit()
+        "
+        OUTPUT_VARIABLE SHIBOKEN_GENERATOR_BASEDIR
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(NOT SHIBOKEN_GENERATOR_BASEDIR)
+        message(
+            FATAL_ERROR
+            "The shiboken2_generator module could not be imported. Make sure you have it installed "
+            "by checking the output of \"pip${Python3_VERSION_MAJOR}.${Python3_VERSION_MINOR} list\""
+        )
+    endif()
+    execute_process(
+        COMMAND ${Python3_EXECUTABLE} -c "if True:
+            import os
+            try:
+                import shiboken2
+                print(shiboken2.__path__[0])
+            except:
+                exit()
+        "
+        OUTPUT_VARIABLE SHIBOKEN_BASEDIR
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(NOT SHIBOKEN_BASEDIR)
+        message(
+            FATAL_ERROR
+            "The shiboken2 module could not be imported. Make sure you have it installed "
+            "by checking the output of \"pip${Python3_VERSION_MAJOR}.${Python3_VERSION_MINOR} list\""
+        )
+    endif()
+    execute_process(
+        COMMAND ${Python3_EXECUTABLE} -c "if True:
+            import os
+            import shiboken2
+            print(';'.join(filter(None, map(str, shiboken2.__version_info__))))
+        "
+        OUTPUT_VARIABLE SHIBOKEN_VERSION
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    list(GET SHIBOKEN_VERSION 0 SHIBOKEN_MACRO_VERSION)
+    list(GET SHIBOKEN_VERSION 1 SHIBOKEN_MICRO_VERSION)
+    list(GET SHIBOKEN_VERSION 2 SHIBOKEN_MINOR_VERSION)
+    string(REPLACE ";" "." SHIBOKEN_VERSION "${SHIBOKEN_VERSION}")
+
+    message(STATUS "ShibokenGenerator base dir: ${SHIBOKEN_GENERATOR_BASEDIR}")
+    message(STATUS "Shiboken base dir:          ${SHIBOKEN_BASEDIR}")
+    message(STATUS "Shiboken custom path:       ${SHIBOKEN_CUSTOM_PREFIX}")
+
+    if(SHIBOKEN_BASEDIR)
+        find_path(SHIBOKEN_INCLUDE_DIR
+            shiboken.h
+            PATHS ${SHIBOKEN_CUSTOM_PREFIX} ${SHIBOKEN_GENERATOR_BASEDIR}/include
+            NO_DEFAULT_PATH
+        )
+        if(MSVC)
+            set(SHIBOKEN_LIBRARY_BASENAMES "shiboken2.abi3.lib")
+        elseif(CYGWIN)
+            set(SHIBOKEN_LIBRARY_BASENAMES "")
+        elseif(WIN32)
+            set(SHIBOKEN_LIBRARY_BASENAMES "libshiboken2.${PYSIDE2_SUFFIX}")
+        elseif(APPLE)
+            set(SHIBOKEN_LIBRARY_BASENAMES
+                libshiboken2.abi3.dylib
+                libshiboken2.abi3.${SHIBOKEN_MACRO_VERSION}.dylib
+                libshiboken2.abi3.${SHIBOKEN_MACRO_VERSION}.${SHIBOKEN_MICRO_VERSION}.dylib
+                libshiboken2.abi3.${SHIBOKEN_VERSION}.dylib
+            )
+        else()
+            set(SHIBOKEN_LIBRARY_BASENAMES
+                libshiboken2.abi3.so
+                libshiboken2.abi3.so.${SHIBOKEN_MACRO_VERSION}
+                libshiboken2.abi3.so.${SHIBOKEN_MACRO_VERSION}.${SHIBOKEN_MICRO_VERSION}
+                libshiboken2.abi3.so.${SHIBOKEN_VERSION}
+            )
+        endif()
+
+        if(NOT SHIBOKEN_INCLUDE_DIR)
+            return()
+        endif()
+        set(SHIBOKEN_SEARCH_PATHS ${SHIBOKEN_CUSTOM_PREFIX})
+        list(APPEND SHIBOKEN_SEARCH_PATHS ${SHIBOKEN_BASEDIR})
+        list(APPEND SHIBOKEN_SEARCH_PATHS ${SHIBOKEN_GENERATOR_BASEDIR})
+        find_file(SHIBOKEN_LIBRARY
+            ${SHIBOKEN_LIBRARY_BASENAMES}
+            PATHS ${SHIBOKEN_SEARCH_PATHS}
+            NO_DEFAULT_PATH)
+
+        find_program(SHIBOKEN_BINARY
+            shiboken2
+            PATHS ${SHIBOKEN_SEARCH_PATHS}
+            NO_DEFAULT_PATH
+        )
+    endif()
+    if(SHIBOKEN_INCLUDE_DIR AND SHIBOKEN_LIBRARY AND SHIBOKEN_BINARY)
+        set(SHIBOKEN_FOUND TRUE)
+    endif()
+
+    if(SHIBOKEN_FOUND)
+    endif()
+
+    if(MSVC)
+        # On Windows we must link to python3.dll that is a small library that links against python3x.dll
+        # that allow us to choose any python3x.dll at runtime
+        execute_process(
+            COMMAND ${Python3_EXECUTABLE} -c "if True:
+                for lib in '${Python3_LIBRARIES}'.split(';'):
+                    if '/' in lib:
+                        prefix, py = lib.rsplit('/', 1)
+                        if py.startswith('python3'):
+                            print(prefix + '/python3.lib')
+                            break
+                "
+            OUTPUT_VARIABLE PYTHON_LIMITED_LIBRARIES
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+    else()
+        # On Linux and MacOs our modules should not link with any python library
+        # that must be handled by the main process
+        set(PYTHON_LIMITED_LIBRARIES "")
+    endif()
+endif()
+if(SHIBOKEN_FOUND)
+    message(STATUS "Shiboken include dir:       ${SHIBOKEN_INCLUDE_DIR}")
+    message(STATUS "Shiboken library:           ${SHIBOKEN_LIBRARY}")
+    message(STATUS "Shiboken binary:            ${SHIBOKEN_BINARY}")
+    message(STATUS "Shiboken version:           ${SHIBOKEN_VERSION}")
+
+    # Create shiboke2 target
+    add_library(Shiboken2::libshiboken SHARED IMPORTED GLOBAL)
+    if(MSVC)
+        set_property(TARGET Shiboken2::libshiboken PROPERTY
+            IMPORTED_IMPLIB ${SHIBOKEN_LIBRARY})
+    endif()
+    set_property(TARGET Shiboken2::libshiboken PROPERTY IMPORTED_LOCATION ${SHIBOKEN_LIBRARY})
+    set_property(TARGET Shiboken2::libshiboken APPEND PROPERTY
+        INTERFACE_INCLUDE_DIRECTORIES ${SHIBOKEN_INCLUDE_DIR} ${Python3_INCLUDE_DIRS}
+    )
+    set_property(TARGET Shiboken2::libshiboken APPEND PROPERTY
+        INTERFACE_LINK_LIBRARIES ${PYTHON_LIMITED_LIBRARIES}
+    )
+
+    # Generator target
+    add_executable(Shiboken2::shiboken IMPORTED GLOBAL)
+    set_property(TARGET Shiboken2::shiboken PROPERTY IMPORTED_LOCATION ${SHIBOKEN_BINARY})
+endif()
+
+find_package_handle_standard_args(Shiboken2
+    REQUIRED_VARS SHIBOKEN_BASEDIR SHIBOKEN_INCLUDE_DIR SHIBOKEN_LIBRARY SHIBOKEN_BINARY
+    VERSION_VAR SHIBOKEN_VERSION
+)

cmake/PySide2ModuleBuild.cmake

+#
+# SPDX-FileCopyrightText: 2019-2022 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+# Author: Renato Araujo Oliveira Filho <renato.araujo@kdab.com>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+if(NOT PYTHON_BINDINGS_INSTALL_PREFIX)
+    # cmake-lint: disable=C0103
+    set(PYTHON_BINDINGS_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}
+        CACHE FILEPATH "Custom path to install python bindings."
+    )
+endif()
+
+message(STATUS "PYTHON INSTALL PREFIX ${PYTHON_BINDINGS_INSTALL_PREFIX}")
+
+if(WIN32)
+    set(PATH_SEP "\;")
+else()
+    set(PATH_SEP ":")
+endif()
+#Qt5 requires C++14
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+#remove noisy compiler warnings (as the generated code is not necessarily super-warning-free)
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-all -Wno-extra")
+endif()
+
+# On macOS, check if Qt is a framework build. This affects how include paths should be handled.
+get_target_property(QtCore_is_framework Qt5::Core FRAMEWORK)
+if(QtCore_is_framework)
+    # Get the path to the framework dir.
+    list(GET Qt5Core_INCLUDE_DIRS 0 QT_INCLUDE_DIR)
+    get_filename_component(QT_FRAMEWORK_INCLUDE_DIR "${QT_INCLUDE_DIR}/../" ABSOLUTE)
+
+    # QT_INCLUDE_DIR points to the QtCore.framework directory, so we need to adjust this to point
+    # to the actual include directory, which has include files for non-framework parts of Qt.
+    get_filename_component(QT_INCLUDE_DIR "${QT_INCLUDE_DIR}/../../include" ABSOLUTE)
+endif()
+
+# Flags that we will pass to shiboken-generator
+# --generator-set=shiboken:  tells the generator that we want to use shiboken to generate code,
+#                            a doc generator is also available
+# --enable-parent-ctor-heuristic: Enable heuristics to detect parent relationship on constructors,
+#                           this try to guess parent ownership based on the arguments of the constructors
+# --enable-pyside-extensionsL: This will generate code for Qt based classes, adding extra attributes,
+#                           like signal, slot;
+# --enable-return-value-heuristic: Similar as --enable-parent-ctor-heuristic this use some logic to guess
+#                           parent child relationship based on the returned argument
+# --use-isnull-as-nb_nonzero: If a class have an isNull() const method, it will be used to compute
+#                           the value of boolean casts.
+#                           Example, QImage::isNull() will be used when on python side you do `if (myQImage)`
+set(GENERATOR_EXTRA_FLAGS
+    --generator-set=shiboken
+    --enable-parent-ctor-heuristic
+    --enable-pyside-extensions
+    --enable-return-value-heuristic
+    --use-isnull-as-nb_nonzero
+    -std=c++${CMAKE_CXX_STANDARD}
+)
+
+# 2017-04-24 The protected hack can unfortunately not be disabled, because
+# Clang does produce linker errors when we disable the hack.
+# But the ugly workaround in Python is replaced by a shiboken change.
+if(WIN32 OR DEFINED AVOID_PROTECTED_HACK)
+    set(GENERATOR_EXTRA_FLAGS ${GENERATOR_EXTRA_FLAGS} --avoid-protected-hack)
+    add_definitions(-DAVOID_PROTECTED_HACK)
+endif()
+
+# Replace all semicolons in a string with this platform's path separator
+macro(make_path varname)
+    # accepts any number of path variables
+    string(REPLACE ";" "${PATH_SEP}" ${varname} "${ARGN}")
+endmacro()
+
+# Creates a PySide module target based on the arguments
+# This will:
+# 1 - Create a Cmake custom-target that call shiboken-generator passign the correct arguments
+# 2 - Create a Cmake library target called "Py${libraryName}" the output name of this target
+#     will be changed to match PySide template
+# Args:
+#   libraryName - The name of the output module
+#   typesystemPaths - A list of paths where shiboken should look for typesystem files
+#   includePaths - Include paths necessary to parse your class. *This is not the same as build*
+#   outputSource - The files that will be generated by shiboken
+#   targetIncludeDirs - This will be passed to target_include_directories
+#   targetLinkLibraries - This will be passed to targetLinkLibraries
+#   globalInclude - A header-file that contains all classes that will be generated
+#   typesystemXML - The target binding typesystem (that should be the full path)
+#   dependsArg - This var will be passed to add_custom_command(DEPENDS) so a new generation will be
+#             trigger if one of these files changes
+#   moduleOutputDir - Where the library file should be stored
+macro(create_python_bindings
+    libraryName
+    typesystemPaths
+    includePaths
+    outputSource
+    targetIncludeDirs
+    targetLinkLibraries
+    globalInclude
+    typesystemXML
+    dependsArg
+    moduleOutputDir)
+
+    # Transform the path separators into something shiboken understands.
+    make_path(shiboken_include_dirs ${includePaths})
+    make_path(shiboken_typesystem_dirs ${typesystemPaths})
+    get_property(raw_python_dir_include_dirs DIRECTORY PROPERTY INCLUDE_DIRECTORIES)
+    make_path(python_dir_include_dirs ${raw_python_dir_include_dirs})
+    set(shiboken_include_dirs "${shiboken_include_dirs}${PATH_SEP}${python_dir_include_dirs}")
+
+    set(shiboken_framework_include_dirs_option "")
+    if(CMAKE_HOST_APPLE)
+        set(shiboken_framework_include_dirs "${QT_FRAMEWORK_INCLUDE_DIR}")
+        make_path(shiboken_framework_include_dirs ${shiboken_framework_include_dirs})
+        set(shiboken_framework_include_dirs_option "--framework-include-paths=${shiboken_framework_include_dirs}")
+    endif()
+    set_property(SOURCE ${outputSource} PROPERTY SKIP_AUTOGEN ON)
+    add_custom_command(
+        OUTPUT ${outputSource}
+        COMMAND $<TARGET_PROPERTY:Shiboken2::shiboken,LOCATION> ${GENERATOR_EXTRA_FLAGS}
+                ${globalInclude}
+                --include-paths=${shiboken_include_dirs}
+                --typesystem-paths=${shiboken_typesystem_dirs}
+                ${shiboken_framework_include_dirs_option}
+                --output-directory=${CMAKE_CURRENT_BINARY_DIR}
+                ${typesystemXML}
+        DEPENDS ${typesystemXML} ${dependsArg}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        COMMENT "Running generator for ${libraryName} binding..."
+    )
+
+    set(TARGET_NAME "Py${libraryName}")
+    set(MODULE_NAME "${libraryName}")
+    add_library(${TARGET_NAME} MODULE ${outputSource})
+
+    set_target_properties(
+        ${TARGET_NAME} PROPERTIES
+        PREFIX ""
+        OUTPUT_NAME ${MODULE_NAME}
+        LIBRARY_OUTPUT_DIRECTORY ${moduleOutputDir}
+    )
+    if(APPLE)
+        set_target_properties(${TARGET_NAME} PROPERTIES INSTALL_RPATH "@loader_path")
+    elseif(NOT WIN32) #ie. linux
+        set_target_properties(${TARGET_NAME} PROPERTIES INSTALL_RPATH "$ORIGIN")
+    endif()
+
+    if(WIN32)
+        set_target_properties(${TARGET_NAME} PROPERTIES SUFFIX ".pyd")
+    endif()
+
+    target_include_directories(${TARGET_NAME} PUBLIC ${targetIncludeDirs})
+
+    target_link_libraries(
+        ${TARGET_NAME}
+        ${targetLinkLibraries}
+        PySide2::pyside2
+        Shiboken2::libshiboken
+    )
+    target_compile_definitions(${TARGET_NAME} PRIVATE Py_LIMITED_API=0x03050000)
+    if(APPLE)
+        set_property(TARGET ${TARGET_NAME} APPEND PROPERTY LINK_FLAGS "-undefined dynamic_lookup")
+    endif()
+    install(
+        TARGETS ${TARGET_NAME}
+        LIBRARY DESTINATION ${PYTHON_BINDINGS_INSTALL_PREFIX}
+    )
+endmacro()

python/CMakeLists.txt

+remove_definitions(-DQT_STRICT_ITERATORS)
+
+set(PYTHON_BINDING_NAMESPACE "PyKate")
+
+# Just to fix warnings with --warn-uninitialized
+if(NOT DEFINED SHIBOKEN_CUSTOM_PREFIX) #look for shiboken in a custom location
+    set(SHIBOKEN_CUSTOM_PREFIX "")
+endif()
+if(NOT DEFINED PYSIDE_CUSTOM_PREFIX) #look for pyside in a custom location
+    set(PYSIDE_CUSTOM_PREFIX "")
+endif()
+
+if(${PROJECT_NAME}_QT6)
+    set(PYSIDE_MAJOR_VERSION "6")
+    set(PYTHON_BINDING_NAMESPACE "${PYTHON_BINDING_NAMESPACE}Qt${PYSIDE_MAJOR_VERSION}")
+    set(QtWidgets_VERSION ${Qt6Widgets_VERSION})
+else()
+    set(PYSIDE_MAJOR_VERSION "2")
+    set(QtWidgets_VERSION ${Qt5Widgets_VERSION})
+endif()
+
+find_package(Python3 3.7 REQUIRED COMPONENTS Interpreter Development)
+find_package(Shiboken${PYSIDE_MAJOR_VERSION} REQUIRED)
+find_package(PySide${PYSIDE_MAJOR_VERSION} ${QtWidgets_VERSION} EXACT REQUIRED)
+
+if(NOT PYTHON_BINDINGS_INSTALL_PREFIX)
+    set(PYTHON_BINDINGS_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+endif()
+
+set(Python3_VERSION_MAJORMINOR "${Python3_VERSION_MAJOR}.${Python3_VERSION_MINOR}")
+set(BINDINGS_DIR "${INSTALL_LIBRARY_DIR}/python${Python3_VERSION_MAJORMINOR}/site-packages/${PYTHON_BINDING_NAMESPACE}")
+set(PYTHON_BINDINGS_INSTALL_PREFIX "${PYTHON_BINDINGS_INSTALL_PREFIX}/${BINDINGS_DIR}")
+
+include(PySide${PYSIDE_MAJOR_VERSION}ModuleBuild)
+add_subdirectory(PyKate)
+
+# if(${PROJECT_NAME}_TESTS)
+#     add_subdirectory(tests)
+# endif()

python/PyKate/CMakeLists.txt

+# Auto-Genereate files every class will have his cpp/h files