PySide6-Examples 6.7.0__cp39-abi3-win_amd64.whl

PySide6/examples/utils/pyside_config.py

@@ -0,0 +1,340 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import sysconfig
+from enum import Enum
+import glob
+import os
+import re
+import sys
+
+
+PYSIDE = 'pyside6'
+PYSIDE_MODULE = 'PySide6'
+SHIBOKEN = 'shiboken6'
+
+
+class Package(Enum):
+    SHIBOKEN_MODULE = 1
+    SHIBOKEN_GENERATOR = 2
+    PYSIDE_MODULE = 3
+
+
+generic_error = ('Did you forget to activate your virtualenv? Or perhaps'
+                 f' you forgot to build / install {PYSIDE_MODULE} into your currently active Python'
+                 ' environment?')
+pyside_error = f'Unable to locate {PYSIDE_MODULE}. {generic_error}'
+shiboken_module_error = f'Unable to locate {SHIBOKEN}-module. {generic_error}'
+shiboken_generator_error = f'Unable to locate shiboken-generator. {generic_error}'
+pyside_libs_error = f'Unable to locate the PySide shared libraries.  {generic_error}'
+python_link_error = 'Unable to locate the Python library for linking.'
+python_include_error = 'Unable to locate the Python include headers directory.'
+
+options = []
+
+# option, function, error, description
+options.append(("--shiboken-module-path",
+                lambda: find_shiboken_module(),
+                shiboken_module_error,
+                "Print shiboken module location"))
+options.append(("--shiboken-generator-path",
+                lambda: find_shiboken_generator(),
+                shiboken_generator_error,
+                "Print shiboken generator location"))
+options.append(("--pyside-path", lambda: find_pyside(), pyside_error,
+                f"Print {PYSIDE_MODULE} location"))
+
+options.append(("--python-include-path",
+                lambda: get_python_include_path(),
+                python_include_error,
+                "Print Python include path"))
+options.append(("--shiboken-generator-include-path",
+                lambda: get_package_include_path(Package.SHIBOKEN_GENERATOR),
+                pyside_error,
+                "Print shiboken generator include paths"))
+options.append(("--pyside-include-path",
+                lambda: get_package_include_path(Package.PYSIDE_MODULE),
+                pyside_error,
+                "Print PySide6 include paths"))
+
+options.append(("--python-link-flags-qmake", lambda: python_link_flags_qmake(), python_link_error,
+                "Print python link flags for qmake"))
+options.append(("--python-link-flags-cmake", lambda: python_link_flags_cmake(), python_link_error,
+                "Print python link flags for cmake"))
+
+options.append(("--shiboken-module-qmake-lflags",
+                lambda: get_package_qmake_lflags(Package.SHIBOKEN_MODULE), pyside_error,
+                "Print shiboken6 shared library link flags for qmake"))
+options.append(("--pyside-qmake-lflags",
+                lambda: get_package_qmake_lflags(Package.PYSIDE_MODULE), pyside_error,
+                "Print PySide6 shared library link flags for qmake"))
+
+options.append(("--shiboken-module-shared-libraries-qmake",
+                lambda: get_shared_libraries_qmake(Package.SHIBOKEN_MODULE), pyside_libs_error,
+                "Print paths of shiboken shared libraries (.so's, .dylib's, .dll's) for qmake"))
+options.append(("--shiboken-module-shared-libraries-cmake",
+                lambda: get_shared_libraries_cmake(Package.SHIBOKEN_MODULE), pyside_libs_error,
+                "Print paths of shiboken shared libraries (.so's, .dylib's, .dll's) for cmake"))
+
+options.append(("--pyside-shared-libraries-qmake",
+                lambda: get_shared_libraries_qmake(Package.PYSIDE_MODULE), pyside_libs_error,
+                "Print paths of f{PYSIDE_MODULE} shared libraries (.so's, .dylib's, .dll's) "
+                "for qmake"))
+options.append(("--pyside-shared-libraries-cmake",
+                lambda: get_shared_libraries_cmake(Package.PYSIDE_MODULE), pyside_libs_error,
+                f"Print paths of {PYSIDE_MODULE} shared libraries (.so's, .dylib's, .dll's) "
+                "for cmake"))
+
+options_usage = ''
+for i, (flag, _, _, description) in enumerate(options):
+    options_usage += f'    {flag:<45} {description}'
+    if i < len(options) - 1:
+        options_usage += '\n'
+
+usage = f"""
+Utility to determine include/link options of shiboken/PySide and Python for qmake/CMake projects
+that would like to embed or build custom shiboken/PySide bindings.
+
+Usage: pyside_config.py [option]
+Options:
+{options_usage}
+    -a                                            Print all options and their values
+    --help/-h                                     Print this help
+"""
+
+option = sys.argv[1] if len(sys.argv) == 2 else '-a'
+if option == '-h' or option == '--help':
+    print(usage)
+    sys.exit(0)
+
+
+def clean_path(path):
+    return path if sys.platform != 'win32' else path.replace('\\', '/')
+
+
+def shared_library_suffix():
+    if sys.platform == 'win32':
+        return 'lib'
+    elif sys.platform == 'darwin':
+        return 'dylib'
+    # Linux
+    else:
+        return 'so.*'
+
+
+def import_suffixes():
+    import importlib.machinery
+    return importlib.machinery.EXTENSION_SUFFIXES
+
+
+def is_debug():
+    debug_suffix = '_d.pyd' if sys.platform == 'win32' else '_d.so'
+    return any([s.endswith(debug_suffix) for s in import_suffixes()])
+
+
+def shared_library_glob_pattern():
+    glob = '*.' + shared_library_suffix()
+    return glob if sys.platform == 'win32' else 'lib' + glob
+
+
+def filter_shared_libraries(libs_list):
+    def predicate(lib_name):
+        basename = os.path.basename(lib_name)
+        if 'shiboken' in basename or 'pyside6' in basename:
+            return True
+        return False
+    result = [lib for lib in libs_list if predicate(lib)]
+    return result
+
+
+# Return qmake link option for a library file name
+def link_option(lib):
+    # On Linux:
+    # Since we cannot include symlinks with wheel packages
+    # we are using an absolute path for the libpyside and libshiboken
+    # libraries when compiling the project
+    baseName = os.path.basename(lib)
+    link = ' -l'
+    if sys.platform in ['linux', 'linux2']:  # Linux: 'libfoo.so' -> '/absolute/path/libfoo.so'
+        link = lib
+    elif sys.platform in ['darwin']:  # Darwin: 'libfoo.so' -> '-lfoo'
+        link += os.path.splitext(baseName[3:])[0]
+    else:  # Windows: 'libfoo.dll' -> 'libfoo.dll'
+        link += os.path.splitext(baseName)[0]
+    return link
+
+
+# Locate PySide6 via sys.path package path.
+def find_pyside():
+    return find_package_path(PYSIDE_MODULE)
+
+
+def find_shiboken_module():
+    return find_package_path(SHIBOKEN)
+
+
+def find_shiboken_generator():
+    return find_package_path(f"{SHIBOKEN}_generator")
+
+
+def find_package(which_package):
+    if which_package == Package.SHIBOKEN_MODULE:
+        return find_shiboken_module()
+    if which_package == Package.SHIBOKEN_GENERATOR:
+        return find_shiboken_generator()
+    if which_package == Package.PYSIDE_MODULE:
+        return find_pyside()
+    return None
+
+
+def find_package_path(dir_name):
+    for p in sys.path:
+        if 'site-' in p:
+            package = os.path.join(p, dir_name)
+            if os.path.exists(package):
+                return clean_path(os.path.realpath(package))
+    return None
+
+
+# Return version as "x.y" (e.g. 3.9, 3.12, etc)
+def python_version():
+    return str(sys.version_info[0]) + '.' + str(sys.version_info[1])
+
+
+def get_python_include_path():
+    return sysconfig.get_path('include')
+
+
+def python_link_flags_qmake():
+    flags = python_link_data()
+    if sys.platform == 'win32':
+        libdir = flags['libdir']
+        # This will add the "~1" shortcut for directories that
+        # contain white spaces
+        # e.g.: "Program Files" to "Progra~1"
+        for d in libdir.split("\\"):
+            if " " in d:
+                libdir = libdir.replace(d, d.split(" ")[0][:-1] + "~1")
+        lib_flags = flags['lib']
+        return f'-L{libdir} -l{lib_flags}'
+    elif sys.platform == 'darwin':
+        libdir = flags['libdir']
+        lib_flags = flags['lib']
+        return f'-L{libdir} -l{lib_flags}'
+    else:
+        # Linux and anything else
+        libdir = flags['libdir']
+        lib_flags = flags['lib']
+        return f'-L{libdir} -l{lib_flags}'
+
+
+def python_link_flags_cmake():
+    flags = python_link_data()
+    libdir = flags['libdir']
+    lib = re.sub(r'.dll$', '.lib', flags['lib'])
+    return f'{libdir};{lib}'
+
+
+def python_link_data():
+    # @TODO Fix to work with static builds of Python
+    libdir = sysconfig.get_config_var('LIBDIR')
+    if libdir is None:
+        libdir = os.path.abspath(os.path.join(
+            sysconfig.get_config_var('LIBDEST'), "..", "libs"))
+    version = python_version()
+    version_no_dots = version.replace('.', '')
+
+    flags = {}
+    flags['libdir'] = libdir
+    if sys.platform == 'win32':
+        suffix = '_d' if is_debug() else ''
+        flags['lib'] = f'python{version_no_dots}{suffix}'
+
+    elif sys.platform == 'darwin':
+        flags['lib'] = f'python{version}'
+
+    # Linux and anything else
+    else:
+        flags['lib'] = f'python{version}{sys.abiflags}'
+
+    return flags
+
+
+def get_package_include_path(which_package):
+    package_path = find_package(which_package)
+    if package_path is None:
+        return None
+
+    includes = f"{package_path}/include"
+
+    return includes
+
+
+def get_package_qmake_lflags(which_package):
+    package_path = find_package(which_package)
+    if package_path is None:
+        return None
+
+    link = f"-L{package_path}"
+    glob_result = glob.glob(os.path.join(package_path, shared_library_glob_pattern()))
+    for lib in filter_shared_libraries(glob_result):
+        link += ' '
+        link += link_option(lib)
+    return link
+
+
+def get_shared_libraries_data(which_package):
+    package_path = find_package(which_package)
+    if package_path is None:
+        return None
+
+    glob_result = glob.glob(os.path.join(package_path, shared_library_glob_pattern()))
+    filtered_libs = filter_shared_libraries(glob_result)
+    libs = []
+    if sys.platform == 'win32':
+        for lib in filtered_libs:
+            libs.append(os.path.realpath(lib))
+    else:
+        for lib in filtered_libs:
+            libs.append(lib)
+    return libs
+
+
+def get_shared_libraries_qmake(which_package):
+    libs = get_shared_libraries_data(which_package)
+    if libs is None:
+        return None
+
+    if sys.platform == 'win32':
+        if not libs:
+            return ''
+        dlls = ''
+        for lib in libs:
+            dll = os.path.splitext(lib)[0] + '.dll'
+            dlls += dll + ' '
+
+        return dlls
+    else:
+        libs_string = ''
+        for lib in libs:
+            libs_string += lib + ' '
+        return libs_string
+
+
+def get_shared_libraries_cmake(which_package):
+    libs = get_shared_libraries_data(which_package)
+    result = ';'.join(libs)
+    return result
+
+
+print_all = option == "-a"
+for argument, handler, error, _ in options:
+    if option == argument or print_all:
+        handler_result = handler()
+        if handler_result is None:
+            sys.exit(error)
+
+        line = handler_result
+        if print_all:
+            line = f"{argument:<40}: {line}"
+        print(line)

PySide6/examples/webchannel/standalone/core.py

@@ -0,0 +1,25 @@
+# Copyright (C) 2017 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff <milian.wolff@kdab.com>
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+
+from PySide6.QtCore import QObject, Signal, Slot
+
+
+class Core(QObject):
+    """An instance of this class gets published over the WebChannel and is then
+       accessible to HTML clients."""
+    sendText = Signal(str)
+
+    def __init__(self, dialog, parent=None):
+        super().__init__(parent)
+        self._dialog = dialog
+        self._dialog.send_text.connect(self._emit_send_text)
+
+    @Slot(str)
+    def _emit_send_text(self, text):
+        self.sendText.emit(text)
+
+    @Slot(str)
+    def receiveText(self, text):
+        self._dialog.display_message(f"Received message: {text}")

PySide6/examples/webchannel/standalone/dialog.py

@@ -0,0 +1,32 @@
+# Copyright (C) 2017 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff <milian.wolff@kdab.com>
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+
+from PySide6.QtCore import Signal, Slot
+from PySide6.QtWidgets import QDialog
+from ui_dialog import Ui_Dialog
+
+
+class Dialog(QDialog):
+    send_text = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._ui = Ui_Dialog()
+        self._ui.setupUi(self)
+        self._ui.send.clicked.connect(self.clicked)
+        self._ui.input.returnPressed.connect(self._ui.send.animateClick)
+
+    @Slot(str)
+    def display_message(self, message):
+        self._ui.output.appendPlainText(message)
+
+    @Slot()
+    def clicked(self):
+        text = self._ui.input.text()
+        if not text:
+            return
+        self.send_text.emit(text)
+        self.display_message(f"Sent message: {text}")
+        self._ui.input.clear()

PySide6/examples/webchannel/standalone/dialog.ui

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Dialog</class>
+ <widget class="QDialog" name="Dialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dialog</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="1" column="0">
+    <widget class="QLineEdit" name="input">
+     <property name="placeholderText">
+      <string>Message Contents</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="1">
+    <widget class="QPushButton" name="send">
+     <property name="text">
+      <string>Send</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0" colspan="2">
+    <widget class="QPlainTextEdit" name="output">
+     <property name="readOnly">
+      <bool>true</bool>
+     </property>
+     <property name="plainText">
+      <string notr="true">Initializing WebChannel...</string>
+     </property>
+     <property name="backgroundVisible">
+      <bool>false</bool>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

PySide6/examples/webchannel/standalone/doc/standalone.rst

@@ -0,0 +1,8 @@
+WebChannel Standalone Example
+=============================
+
+A simple chat between a server and a remote client running in a browser.
+
+.. image:: standalone.png
+   :width: 400
+   :alt: WebChannel Standalone Screenshot

PySide6/examples/webchannel/standalone/index.html

@@ -0,0 +1,79 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+        <script type="text/javascript" src="./qwebchannel.js"></script>
+        <script type="text/javascript">
+            //BEGIN SETUP
+            function output(message) {
+                var output = document.getElementById("output");
+                output.innerHTML = output.innerHTML + message + "\n";
+            }
+            window.onload = function() {
+                if (location.search != "")
+                    var baseUrl = (/[?&]webChannelBaseUrl=([A-Za-z0-9\-:/\.]+)/.exec(location.search)[1]);
+                else
+                    var baseUrl = "ws://localhost:12345";
+
+                output("Connecting to WebSocket server at " + baseUrl + ".");
+                var socket = new WebSocket(baseUrl);
+
+                socket.onclose = function() {
+                    console.error("web channel closed");
+                };
+                socket.onerror = function(error) {
+                    console.error("web channel error: " + error);
+                };
+                socket.onopen = function() {
+                    output("WebSocket connected, setting up QWebChannel.");
+                    new QWebChannel(socket, function(channel) {
+                        // make core object accessible globally
+                        window.core = channel.objects.core;
+
+                        document.getElementById("send").onclick = function() {
+                            var input = document.getElementById("input");
+                            var text = input.value;
+                            if (!text) {
+                                return;
+                            }
+
+                            output("Sent message: " + text);
+                            input.value = "";
+                            core.receiveText(text);
+                        }
+
+                        core.sendText.connect(function(message) {
+                            output("Received message: " + message);
+                        });
+
+                        core.receiveText("Client connected, ready to send/receive messages!");
+                        output("Connected to WebChannel, ready to send/receive messages!");
+                    });
+                }
+            }
+            //END SETUP
+        </script>
+        <style type="text/css">
+            html {
+                height: 100%;
+                width: 100%;
+            }
+            #input {
+                width: 400px;
+                margin: 0 10px 0 0;
+            }
+            #send {
+                width: 90px;
+                margin: 0;
+            }
+            #output {
+                width: 500px;
+                height: 300px;
+            }
+        </style>
+    </head>
+    <body>
+        <textarea id="output"></textarea><br />
+        <input id="input" /><input type="submit" id="send" value="Send" onclick="javascript:click();" />
+    </body>
+</html>

PySide6/examples/webchannel/standalone/main.py

@@ -0,0 +1,62 @@
+# Copyright (C) 2016 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff <milian.wolff@kdab.com>
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+
+import os
+import sys
+
+from PySide6.QtWidgets import QApplication
+from PySide6.QtGui import QDesktopServices
+from PySide6.QtNetwork import QHostAddress, QSslSocket
+from PySide6.QtCore import (QFile, QFileInfo, QUrl)
+from PySide6.QtWebChannel import QWebChannel
+from PySide6.QtWebSockets import QWebSocketServer
+
+from dialog import Dialog
+from core import Core
+from websocketclientwrapper import WebSocketClientWrapper
+
+
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+    if not QSslSocket.supportsSsl():
+        print('The example requires SSL support.')
+        sys.exit(-1)
+    cur_dir = os.path.dirname(os.path.abspath(__file__))
+    js_file_info = QFileInfo(f"{cur_dir}/qwebchannel.js")
+    if not js_file_info.exists():
+        QFile.copy(":/qtwebchannel/qwebchannel.js",
+                   js_file_info.absoluteFilePath())
+
+    # setup the QWebSocketServer
+    server = QWebSocketServer("QWebChannel Standalone Example Server",
+                              QWebSocketServer.NonSecureMode)
+    if not server.listen(QHostAddress.LocalHost, 12345):
+        print("Failed to open web socket server.")
+        sys.exit(-1)
+
+    # wrap WebSocket clients in QWebChannelAbstractTransport objects
+    client_wrapper = WebSocketClientWrapper(server)
+
+    # setup the channel
+    channel = QWebChannel()
+    client_wrapper.client_connected.connect(channel.connectTo)
+
+    # setup the UI
+    dialog = Dialog()
+
+    # setup the core and publish it to the QWebChannel
+    core = Core(dialog)
+    channel.registerObject("core", core)
+
+    # open a browser window with the client HTML page
+    url = QUrl.fromLocalFile(f"{cur_dir}/index.html")
+    QDesktopServices.openUrl(url)
+
+    display_url = url.toDisplayString()
+    message = f"Initialization complete, opening browser at {display_url}."
+    dialog.display_message(message)
+    dialog.show()
+
+    sys.exit(app.exec())

PySide6/examples/webchannel/standalone/standalone.pyproject

@@ -0,0 +1,4 @@
+{
+    "files": ["main.py", "core.py", "dialog.py", "websocketclientwrapper.py",
+              "websockettransport.py", "dialog.ui", "index.html"]
+}

PySide6/examples/webchannel/standalone/ui_dialog.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+
+################################################################################
+## Form generated from reading UI file 'dialog.ui'
+##
+## Created by: Qt User Interface Compiler version 6.2.3
+##
+## WARNING! All changes made in this file will be lost when recompiling UI file!
+################################################################################
+
+from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
+    QMetaObject, QObject, QPoint, QRect,
+    QSize, QTime, QUrl, Qt)
+from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
+    QFont, QFontDatabase, QGradient, QIcon,
+    QImage, QKeySequence, QLinearGradient, QPainter,
+    QPalette, QPixmap, QRadialGradient, QTransform)
+from PySide6.QtWidgets import (QApplication, QDialog, QGridLayout, QLineEdit,
+    QPlainTextEdit, QPushButton, QSizePolicy, QWidget)
+
+class Ui_Dialog(object):
+    def setupUi(self, Dialog):
+        if not Dialog.objectName():
+            Dialog.setObjectName(u"Dialog")
+        Dialog.resize(400, 300)
+        self.gridLayout = QGridLayout(Dialog)
+        self.gridLayout.setObjectName(u"gridLayout")
+        self.input = QLineEdit(Dialog)
+        self.input.setObjectName(u"input")
+
+        self.gridLayout.addWidget(self.input, 1, 0, 1, 1)
+
+        self.send = QPushButton(Dialog)
+        self.send.setObjectName(u"send")
+
+        self.gridLayout.addWidget(self.send, 1, 1, 1, 1)
+
+        self.output = QPlainTextEdit(Dialog)
+        self.output.setObjectName(u"output")
+        self.output.setReadOnly(True)
+        self.output.setPlainText(u"Initializing WebChannel...")
+        self.output.setBackgroundVisible(False)
+
+        self.gridLayout.addWidget(self.output, 0, 0, 1, 2)
+
+
+        self.retranslateUi(Dialog)
+
+        QMetaObject.connectSlotsByName(Dialog)
+    # setupUi
+
+    def retranslateUi(self, Dialog):
+        Dialog.setWindowTitle(QCoreApplication.translate("Dialog", u"Dialog", None))
+        self.input.setPlaceholderText(QCoreApplication.translate("Dialog", u"Message Contents", None))
+        self.send.setText(QCoreApplication.translate("Dialog", u"Send", None))
+    # retranslateUi
+