fluentpyside 0.0.0__tar.gz

fluentpyside-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fluentpyside-0.0.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: fluentpyside
+Version: 0.0.0
+Summary: Fluent WinUI3 QML style helper for PySide6 (copies assets from local PySide6 install)
+Author-email: lousybook <lousybook94@gmail.com>
+Project-URL: Homepage, https://github.com/<your-account>/FluentPySide
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PySide6>=6.6
+Dynamic: license-file
+
+FluentPySide
+===========
+
+fluentpyside packages the FluentWinUI3 Qt Quick Controls style so PySide6 apps can apply the Fluent theme easily.
+
+Quick Start — three ways
+------------------------
+
+1) Install the wrapper package and use the helper (recommended)
+
+Prerequisites:
+- Python 3.8+
+- PySide6 (and optionally PySide6-Essentials for upstream plugin binaries)
+
+Install and run:
+
+```sh
+pip install PySide6
+pip install -e .   # from this repository root (development install)
+python examples/demo.py
+```
+
+Minimal example (use fluentpyside.set_style):
+
+```py
+from PySide6.QtWidgets import QApplication
+from PySide6.QtQml import QQmlApplicationEngine
+import fluentpyside
+
+app = QApplication([])
+engine = QQmlApplicationEngine()
+
+# Ensure package-local QML assets exist (copies from installed PySide6 when missing)
+fluentpyside.install_assets()
+
+# Add import path and try to set the QtQuickControls2 style plugin
+fluentpyside.set_style(engine=engine)
+
+# Load QML that imports FluentWinUI3
+engine.load('examples/gallery.qml')
+app.exec()
+```
+
+2) Drag-and-drop the style into a project (no packaging)
+
+- Copy `fluentpyside/QtQuick` into your project root so there is `./QtQuick/Controls/FluentWinUI3/qmldir`.
+- In Python, add your project root as a QML import path before loading QML:
+
+```py
+from PySide6.QtWidgets import QApplication
+from PySide6.QtQml import QQmlApplicationEngine
+
+app = QApplication([])
+engine = QQmlApplicationEngine()
+engine.addImportPath('path/to/project/root')
+engine.load('main.qml')
+app.exec()
+```
+
+3) Run the included gallery demo
+
+```sh
+pip install PySide6
+pip install -e .
+python examples/demo.py
+```
+
+Files included
+--------------
+- fluentpyside/: Python wrapper and packaged QML assets
+- examples/demo.py: demo app that loads examples/gallery.qml
+- examples/gallery.qml: QML demo UI (gallery of controls)
+- tests/smoke_test.py: non-interactive smoke test
+
+Publishing & GitHub
+-------------------
+
+- I will not publish/delete on your behalf without explicit credentials and confirmation.
+- To publish to PyPI locally:
+
+  python -m build
+  python -m twine upload dist/*
+
+- To create or replace a GitHub repo locally with `gh`:
+
+  gh repo create <owner>/FluentPySide --public --source=. --push
+
+  (If you want me to run these steps from this environment, provide the tokens and explicit confirmation.)
+
+Notes and troubleshooting
+-------------------------
+- Call `fluentpyside.set_style(engine=engine)` or `engine.addImportPath(...)` before loading QML that imports QtQuick.Controls.FluentWinUI3.
+- The package contains a copy of the QML files and (on Windows) the plugin DLL copied from your local PySide6 installation. Packaging platform binaries for cross-platform distribution is not recommended; instead require PySide6-Essentials on the target platform.
+
+License
+-------
+- Wrapper: MIT License (file LICENSE)
+- Upstream QML assets: copied from the locally installed PySide6 / PySide6-Essentials package. Follow Qt/PySide licensing when redistributing.

fluentpyside-0.0.0/README.md

@@ -0,0 +1,98 @@
+FluentPySide
+===========
+
+fluentpyside packages the FluentWinUI3 Qt Quick Controls style so PySide6 apps can apply the Fluent theme easily.
+
+Quick Start — three ways
+------------------------
+
+1) Install the wrapper package and use the helper (recommended)
+
+Prerequisites:
+- Python 3.8+
+- PySide6 (and optionally PySide6-Essentials for upstream plugin binaries)
+
+Install and run:
+
+```sh
+pip install PySide6
+pip install -e .   # from this repository root (development install)
+python examples/demo.py
+```
+
+Minimal example (use fluentpyside.set_style):
+
+```py
+from PySide6.QtWidgets import QApplication
+from PySide6.QtQml import QQmlApplicationEngine
+import fluentpyside
+
+app = QApplication([])
+engine = QQmlApplicationEngine()
+
+# Ensure package-local QML assets exist (copies from installed PySide6 when missing)
+fluentpyside.install_assets()
+
+# Add import path and try to set the QtQuickControls2 style plugin
+fluentpyside.set_style(engine=engine)
+
+# Load QML that imports FluentWinUI3
+engine.load('examples/gallery.qml')
+app.exec()
+```
+
+2) Drag-and-drop the style into a project (no packaging)
+
+- Copy `fluentpyside/QtQuick` into your project root so there is `./QtQuick/Controls/FluentWinUI3/qmldir`.
+- In Python, add your project root as a QML import path before loading QML:
+
+```py
+from PySide6.QtWidgets import QApplication
+from PySide6.QtQml import QQmlApplicationEngine
+
+app = QApplication([])
+engine = QQmlApplicationEngine()
+engine.addImportPath('path/to/project/root')
+engine.load('main.qml')
+app.exec()
+```
+
+3) Run the included gallery demo
+
+```sh
+pip install PySide6
+pip install -e .
+python examples/demo.py
+```
+
+Files included
+--------------
+- fluentpyside/: Python wrapper and packaged QML assets
+- examples/demo.py: demo app that loads examples/gallery.qml
+- examples/gallery.qml: QML demo UI (gallery of controls)
+- tests/smoke_test.py: non-interactive smoke test
+
+Publishing & GitHub
+-------------------
+
+- I will not publish/delete on your behalf without explicit credentials and confirmation.
+- To publish to PyPI locally:
+
+  python -m build
+  python -m twine upload dist/*
+
+- To create or replace a GitHub repo locally with `gh`:
+
+  gh repo create <owner>/FluentPySide --public --source=. --push
+
+  (If you want me to run these steps from this environment, provide the tokens and explicit confirmation.)
+
+Notes and troubleshooting
+-------------------------
+- Call `fluentpyside.set_style(engine=engine)` or `engine.addImportPath(...)` before loading QML that imports QtQuick.Controls.FluentWinUI3.
+- The package contains a copy of the QML files and (on Windows) the plugin DLL copied from your local PySide6 installation. Packaging platform binaries for cross-platform distribution is not recommended; instead require PySide6-Essentials on the target platform.
+
+License
+-------
+- Wrapper: MIT License (file LICENSE)
+- Upstream QML assets: copied from the locally installed PySide6 / PySide6-Essentials package. Follow Qt/PySide licensing when redistributing.

fluentpyside-0.0.0/examples/demo.py

@@ -0,0 +1,33 @@
+"""Full demo that loads the FluentWinUI3 gallery QML and applies the style."""
+
+from pathlib import Path
+import sys
+
+import fluentpyside
+from PySide6.QtWidgets import QApplication
+from PySide6.QtQml import QQmlApplicationEngine
+
+
+def main() -> int:
+    app = QApplication(sys.argv)
+    engine = QQmlApplicationEngine()
+
+    # Ensure the package has the assets (copies from local PySide6 if needed)
+    try:
+        fluentpyside.install_assets()
+    except Exception:
+        pass
+
+    # Add the style and the engine import path
+    fluentpyside.set_style(engine=engine)
+
+    qml_file = Path(__file__).parent / "gallery.qml"
+    engine.load(str(qml_file))
+    if not engine.rootObjects():
+        print("Failed to load demo QML. Make sure the QML import paths are correct.")
+        return 1
+    return app.exec()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fluentpyside-0.0.0/examples/example_app.py

@@ -0,0 +1,60 @@
+"""Minimal example that installs and applies the FluentWinUI3 style then loads a simple QML UI."""
+
+import sys
+from pathlib import Path
+
+import fluentpyside
+from PySide6.QtWidgets import QApplication
+from PySide6.QtQml import QQmlApplicationEngine
+
+
+def main() -> int:
+    app = QApplication(sys.argv)
+
+    # Ensure assets are present in the package folder
+    try:
+        fluentpyside.install_assets()
+    except FileNotFoundError as e:
+        print("Warning: could not copy assets from local PySide6 install:", e)
+
+    # Apply the style (adds import path and attempts QQuickStyle.setStyle)
+    fluentpyside.set_style()
+
+    engine = QQmlApplicationEngine()
+    # add import path explicitly for good measure
+    style_path = Path(__file__).parent.parent / "fluent_winui3"
+    if style_path.exists():
+        engine.addImportPath(str(style_path))
+
+    qml = """
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+import QtQuick.Controls.FluentWinUI3 1.0
+
+ApplicationWindow {
+    visible: true
+    width: 400
+    height: 200
+    title: qsTr("FluentWinUI3 Example")
+
+    Column {
+        anchors.centerIn: parent
+        spacing: 10
+
+        Button { text: "Hello" }
+        CheckBox { text: "Check me" }
+    }
+}
+"""
+
+    # load from string
+    engine.loadData(qml.encode("utf-8"))
+    if not engine.rootObjects():
+        print("Failed to load QML")
+        return 1
+
+    return app.exec()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fluentpyside-0.0.0/fluentpyside/__init__.py

@@ -0,0 +1,9 @@
+"""fluentpyside public API
+
+Provides install_assets() and set_style() convenience helpers.
+"""
+
+from ._installer import install_assets, find_installed_style, default_style_path
+from ._loader import set_style
+
+__all__ = ["install_assets", "find_installed_style", "set_style", "default_style_path"]

fluentpyside-0.0.0/fluentpyside/_installer.py

@@ -0,0 +1,94 @@
+"""Find and copy FluentWinUI3 assets from local PySide6 installation."""
+
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+from typing import Optional
+
+
+def find_installed_style() -> Optional[Path]:
+    """Try to find the FluentWinUI3 folder inside the installed PySide6 package.
+
+    Returns the source path if found, otherwise None.
+    """
+    try:
+        import PySide6
+    except Exception:
+        return None
+
+    pyside_pkg = Path(PySide6.__file__).parent
+    # Common location inside PySide6: qml/QtQuick/Controls/FluentWinUI3
+    candidate = pyside_pkg / "qml" / "QtQuick" / "Controls" / "FluentWinUI3"
+    if candidate.exists():
+        return candidate
+
+    # Fallback: search the PySide6 package qml tree
+    qml_root = pyside_pkg / "qml"
+    if qml_root.exists():
+        for p in qml_root.rglob("FluentWinUI3"):
+            # ensure it's the controls style folder
+            if p.is_dir() and "Controls" in p.parts:
+                return p
+
+    return None
+
+
+def default_style_path() -> Path:
+    """Path inside this package where assets will be copied to."""
+    # Place the style under the QtQuick/Controls/FluentWinUI3 path so QML imports
+    # like `import QtQuick.Controls.FluentWinUI3` work when the package folder
+    # is added to QML import paths.
+    return Path(__file__).parent / "QtQuick" / "Controls" / "FluentWinUI3"
+
+
+def install_assets(dest: Optional[Path | str] = None) -> Path:
+    """Copy the FluentWinUI3 tree from the local PySide6 install into dest.
+
+    If dest is None the package-local `fluent_winui3/` folder is used. Returns the destination path.
+    Raises FileNotFoundError if the source cannot be located.
+    """
+    src = find_installed_style()
+    if src is None:
+        raise FileNotFoundError(
+            "Could not locate FluentWinUI3 in the installed PySide6 package."
+        )
+
+    dest_path = Path(dest) if dest else default_style_path()
+    if dest_path.exists():
+        # remove and replace to ensure a clean copy
+        shutil.rmtree(dest_path)
+    # copytree needs the target parent to exist if src contains the root folder name
+    dest_parent = dest_path.parent
+    dest_parent.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(src, dest_path)
+    # Also try to copy impl/ if present (private plugin impl folder)
+    impl_src = src / "impl"
+    if impl_src.exists():
+        try:
+            shutil.copytree(impl_src, dest_path / "impl")
+        except Exception:
+            # ignore; we still copied the main QML files
+            pass
+
+    # Copy qmldir from the style folder itself if present (this declares the module)
+    src_qmldir = src / "qmldir"
+    if src_qmldir.exists():
+        try:
+            shutil.copy(src_qmldir, dest_path / "qmldir")
+        except Exception:
+            pass
+
+    # Write a small attribution file
+    try:
+        with open(
+            Path(__file__).parent.parent / "THIRD_PARTY_LICENSES.md",
+            "a",
+            encoding="utf-8",
+        ) as f:
+            f.write(f"\nCopied FluentWinUI3 from: {src}\n")
+    except Exception:
+        pass
+
+    return dest_path

fluentpyside-0.0.0/fluentpyside/_loader.py

@@ -0,0 +1,89 @@
+"""Helpers to expose the FluentWinUI3 style to QML and attempt to set QQuickStyle.
+
+This module does not assume assets are present — it will try to copy them from a local
+PySide6 installation when needed.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Optional
+
+from PySide6.QtQml import QQmlEngine
+
+try:
+    from PySide6.QtQuickControls2 import QQuickStyle
+except Exception:
+    QQuickStyle = None
+
+from ._installer import default_style_path, install_assets, find_installed_style
+
+
+def set_style(
+    path: Optional[str | Path] = None, engine: Optional[QQmlEngine] = None
+) -> Path:
+    """Ensure the FluentWinUI3 style is available and add it to QML import paths.
+
+    - path: optional explicit path to a FluentWinUI3 folder. If omitted, use package-local copy
+      and attempt to install assets from the local PySide6 package when missing.
+    - engine: optional QQmlEngine or QQmlApplicationEngine instance to call addImportPath on.
+
+    Returns the path to the style folder used.
+    """
+    if path:
+        style_path = Path(path)
+    else:
+        style_path = default_style_path()
+
+    if not style_path.exists():
+        # try to copy from installed PySide6
+        try:
+            install_assets(style_path)
+        except FileNotFoundError:
+            # last-resort: try to find installed style and use it directly
+            found = find_installed_style()
+            if found:
+                style_path = found
+            else:
+                raise
+
+    # Add to environment QML2_IMPORT_PATH so QML imports can find it
+    current = os.environ.get("QML2_IMPORT_PATH", "")
+    style_str = str(style_path)
+    # The QML import path should point at the folder that contains the "QtQuick"
+    # import root. If the style_path is nested under QtQuick/Controls/FluentWinUI3,
+    # add its parent.parent.parent (the folder that contains QtQuick).
+    add_path = style_str
+    parts = Path(style_str).parts
+    if "QtQuick" in parts:
+        # find index of QtQuick and add up to that parent
+        idx = parts.index("QtQuick")
+        add_path = str(Path(*parts[:idx])) if idx > 0 else Path(".").resolve()
+        # If idx==0 then QtQuick is at the filesystem root; fallback to style_str
+        if add_path == Path(".").resolve():
+            add_path = style_str
+
+    if add_path not in current.split(os.pathsep):
+        os.environ["QML2_IMPORT_PATH"] = add_path + (
+            os.pathsep + current if current else ""
+        )
+
+    # Add to engine if provided
+    if engine is not None:
+        try:
+            # add the QtQuick parent import path to the engine
+            engine.addImportPath(add_path)
+        except Exception:
+            # ignore engine failures
+            pass
+
+    # Try to set QQuickStyle by name — plugin must be available
+    if QQuickStyle is not None:
+        try:
+            QQuickStyle.setStyle("FluentWinUI3")
+        except Exception:
+            # not a plugin or unavailable; ignore
+            pass
+
+    return style_path

fluentpyside-0.0.0/fluentpyside/fluent_winui3/ApplicationWindow.qml

@@ -0,0 +1,13 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+// Qt-Security score:significant reason:default
+
+import QtQuick
+import QtQuick.Controls.impl
+import QtQuick.Templates as T
+
+T.ApplicationWindow {
+    id: window
+
+    color: window.palette.window
+}

fluentpyside-0.0.0/fluentpyside/fluent_winui3/BusyIndicator.qml

@@ -0,0 +1,66 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+// Qt-Security score:significant reason:default
+
+import QtQuick
+import QtQuick.Templates as T
+import QtQuick.Shapes
+
+T.BusyIndicator {
+    id: control
+
+    implicitWidth: Math.max(implicitBackgroundWidth + leftInset + rightInset,
+                            implicitContentWidth + leftPadding + rightPadding)
+    implicitHeight: Math.max(implicitBackgroundHeight + topInset + bottomInset,
+                             implicitContentHeight + topPadding + bottomPadding)
+
+    contentItem: Item {
+        implicitWidth: 32
+        implicitHeight: 32
+        x: (control.availableWidth - width) / 2
+        y: (control.availableHeight - height) / 2
+
+        property Shape ring: Shape {
+            parent: control.contentItem
+            x: (parent.width - width) / 2
+            y: (parent.height - height) / 2
+            implicitWidth: parent.implicitWidth
+            implicitHeight: parent.implicitHeight
+            width: Math.min(control.contentItem.width, control.contentItem.height)
+            height: width
+            preferredRendererType: Shape.CurveRenderer
+            antialiasing: true
+
+            ShapePath {
+                fillColor: "transparent"
+                strokeColor: control.palette.accent
+                strokeWidth: control.contentItem.ring.width >= 64 ? 6 : control.contentItem.ring.width <= 16 ? 1 : 3
+
+                capStyle: ShapePath.RoundCap
+
+                PathAngleArc {
+                    centerX: control.contentItem.ring.width / 2
+                    centerY: control.contentItem.ring.height / 2
+                    radiusX: control.contentItem.ring.width / 2 - 2
+                    radiusY: radiusX
+                    startAngle: -90
+                    sweepAngle: 120
+
+                    SequentialAnimation on startAngle {
+                        loops: Animation.Infinite
+                        running: control.visible && control.running
+                        NumberAnimation { from: 0; to: 450; duration: 1000 }
+                        NumberAnimation { from: 450; to: 1080; duration: 1000 }
+                    }
+
+                    SequentialAnimation on sweepAngle {
+                        loops: Animation.Infinite
+                        running: control.visible && control.running
+                        NumberAnimation { from: 0; to: 180; duration: 1000 }
+                        NumberAnimation { from: 180; to: 0; duration: 1000 }
+                    }
+                }
+            }
+        }
+    }
+}

fluentpyside-0.0.0/fluentpyside/fluent_winui3/Button.qml

@@ -0,0 +1,89 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+// Qt-Security score:significant reason:default
+
+import QtQuick
+import QtQuick.Controls.impl
+import QtQuick.Controls.FluentWinUI3.impl
+import QtQuick.Templates as T
+
+T.Button {
+    id: control
+
+    implicitWidth: Math.max(implicitBackgroundWidth + leftInset + rightInset,
+                            implicitContentWidth + leftPadding + rightPadding)
+    implicitHeight: Math.max(implicitBackgroundHeight + topInset + bottomInset,
+                             implicitContentHeight + topPadding + bottomPadding)
+
+    spacing: __config.spacing || 0
+
+    topPadding: __config.topPadding || 0
+    bottomPadding: __config.bottomPadding || 0
+    leftPadding: __config.leftPadding || 0
+    rightPadding: __config.rightPadding || 0
+
+    topInset: -__config.topInset || 0
+    bottomInset: -__config.bottomInset || 0
+    leftInset: -__config.leftInset || 0
+    rightInset: -__config.rightInset || 0
+
+    icon.width: __config.icon.width
+    icon.height: __config.icon.height
+    icon.color: __buttonText
+
+    readonly property color __buttonText: {
+        if (Application.styleHints.accessibility.contrastPreference === Qt.HighContrast) {
+            return (control.enabled && ((control.flat && (control.down || control.hovered))
+                || ((control.highlighted || control.checked) && !control.down)))
+                ? control.palette.button
+                : control.enabled && (control.hovered || control.down)
+                ? control.palette.highlight
+                : control.palette.buttonText
+        }
+        if (control.down) {
+            return (control.checked || control.highlighted)
+                ? Application.styleHints.colorScheme == Qt.Light
+                    ? Color.transparent("white", 0.7) : Color.transparent("black", 0.5)
+                : (Application.styleHints.colorScheme === Qt.Light
+                    ? Color.transparent(control.palette.buttonText, 0.62)
+                    : Color.transparent(control.palette.buttonText, 0.7725))
+        } else if (control.checked || control.highlighted) {
+            return (Application.styleHints.colorScheme === Qt.Dark && !control.enabled)
+                ? Color.transparent("white", 0.5302)
+                : (Application.styleHints.colorScheme === Qt.Dark ? "black" : "white")
+        } else {
+            return control.palette.buttonText
+        }
+    }
+
+    readonly property string __currentState: [
+        (control.checked || control.highlighted) && "checked",
+        !control.enabled && "disabled",
+        control.enabled && !control.down && control.hovered && "hovered",
+        control.down && "pressed"
+    ].filter(Boolean).join("_") || "normal"
+    readonly property var __config: (control.flat && Config.controls.flatbutton
+        ? Config.controls.flatbutton[__currentState]
+        : Config.controls.button[__currentState]) || {}
+
+    readonly property Item __focusFrameTarget: control
+
+    contentItem: IconLabel {
+        spacing: control.spacing
+        mirrored: control.mirrored
+        display: control.display
+        alignment: control.__config.label.textVAlignment | control.__config.label.textHAlignment
+        icon: control.icon
+        text: control.text
+        font: control.font
+        color: control.icon.color
+    }
+
+    background: ButtonBackground {
+        control: control
+        implicitHeight: control.__config.background.height
+        implicitWidth: control.__config.background.width
+        radius: control.__config.background.topOffset
+        subtle: control.flat
+    }
+}