refrain 0.4.2__tar.gz → 0.4.3__tar.gz

{refrain-0.4.2 → refrain-0.4.3}/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -13,7 +13,7 @@ body:
     attributes:
       label: Refrain version
       description: Run `refrain --version` or check the bottom-right of the settings window.
-      placeholder: "0.4.2"
+      placeholder: "0.4.3"
     validations:
       required: true
 

{refrain-0.4.2 → refrain-0.4.3}/.github/workflows/security.yml

@@ -78,7 +78,7 @@ jobs:
           fetch-depth: 0
 
       - name: Run TruffleHog
-        uses: trufflesecurity/trufflehog@6f3c981e7b77f235fd2702dd74af25fc4b72bf11  # v3.96.0
+        uses: trufflesecurity/trufflehog@bcfcf73aaf4759d4dadc2783177c245a02792318  # v3.97.0
         with:
           # --only-verified: a secret only counts as flagged when TruffleHog
           # successfully validates it against the live service. Drops the

{refrain-0.4.2 → refrain-0.4.3}/CHANGELOG.md

@@ -9,6 +9,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing here
 
+## [0.4.3] - 2026-08-24
+
+Fixed a startup crash on installs that run against the PySide6 wheel's
+bundled Qt while the distro ships a newer Qt patch release.
+
+### Fixed
+
+- **No Qt platform plugin could be initialized on a patch-version skew.**
+  `_augment_qt_plugin_path()` adds the distro's Qt plugin tree so a
+  pip / pipx / AppImage install can still find the system styles, and it
+  gated that on Qt's `MAJOR.MINOR` alone. That is not the rule Qt
+  enforces: Qt refuses any plugin built against a *newer* Qt than the one
+  running. On a rolling distro one patch ahead of the wheel (bundled Qt
+  6.11.1, system Qt 6.11.2) the check passed, and because
+  `addLibraryPath()` *prepends*, the rejected system `wayland` and `xcb`
+  plugins shadowed the wheel's own working copies instead of falling back
+  to them — the app aborted with "This application failed to start
+  because no Qt platform plugin could be initialized". Two guards now
+  apply: the version check mirrors Qt's actual rule (same `MAJOR.MINOR`
+  *and* the system Qt no newer than ours), and the plugin tree is
+  appended rather than prepended, so the bundled Qt keeps first claim on
+  the platform plugin. A mismatched system tree can now only cost the
+  themed style, never the ability to start. Installs running against the
+  distro PySide6 — the AUR and distro packages — were never affected;
+  they short-circuit before any of this.
+
 ## [0.4.2] - 2026-08-12
 
 Fixed Apple Music RPC URL handling and Discord buttons,
@@ -1237,7 +1263,8 @@ with a proper, installable Linux app.
   pip-audit, trufflehog, release), Dependabot, issue + PR templates,
   `CONTRIBUTING.md`, `CODE_OF_CONDUCT.md`, `SECURITY.md`.
 
-[Unreleased]: https://github.com/Rockykln/refrain/compare/v0.4.2...HEAD
+[Unreleased]: https://github.com/Rockykln/refrain/compare/v0.4.3...HEAD
+[0.4.3]: https://github.com/Rockykln/refrain/compare/v0.4.2...v0.4.3
 [0.4.2]: https://github.com/Rockykln/refrain/compare/v0.4.1...v0.4.2
 [0.4.1]: https://github.com/Rockykln/refrain/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/Rockykln/refrain/compare/v0.3.0...v0.4.0

{refrain-0.4.2 → refrain-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: refrain
-Version: 0.4.2
+Version: 0.4.3
 Summary: Discord Rich Presence for Apple Music on Linux
 Project-URL: Homepage, https://github.com/Rockykln/refrain
 Project-URL: Repository, https://github.com/Rockykln/refrain

{refrain-0.4.2 → refrain-0.4.3}/packaging/appimage/AppImageBuilder.yml

@@ -30,7 +30,7 @@ AppDir:
     id: io.github.Rockykln.Refrain
     name: Refrain
     icon: refrain
-    version: 0.4.2
+    version: 0.4.3
     exec: usr/bin/python3
     exec_args: -m refrain $@
 

{refrain-0.4.2 → refrain-0.4.3}/packaging/aur/refrain/.SRCINFO

@@ -1,6 +1,6 @@
 pkgbase = refrain
 	pkgdesc = Discord Rich Presence for Apple Music on Linux
-	pkgver = 0.4.2
+	pkgver = 0.4.3
 	pkgrel = 1
 	url = https://github.com/Rockykln/refrain
 	arch = any
@@ -14,7 +14,7 @@ pkgbase = refrain
 	depends = python-dbus
 	depends = pyside6
 	optdepends = python-gobject: enables MPRIS-server publication so Plasma media controls reach Refrain
-	source = refrain-0.4.2.tar.gz::https://github.com/Rockykln/refrain/archive/v0.4.2.tar.gz
-	sha256sums = d5558cd419c8d46bdc958064cb97f963d1ea793866414c025906ec15033512ed
+	source = refrain-0.4.3.tar.gz::https://github.com/Rockykln/refrain/archive/v0.4.3.tar.gz
+	sha256sums = 0000000000000000000000000000000000000000000000000000000000000000
 
 pkgname = refrain

{refrain-0.4.2 → refrain-0.4.3}/packaging/aur/refrain/PKGBUILD

@@ -1,7 +1,7 @@
 # Maintainer: Rockykln <contact@rockykln.com>
 
 pkgname=refrain
-pkgver=0.4.2
+pkgver=0.4.3
 pkgrel=1
 pkgdesc="Discord Rich Presence for Apple Music on Linux"
 arch=('any')
@@ -23,7 +23,9 @@ makedepends=(
     'python-wheel'
 )
 source=("$pkgname-$pkgver.tar.gz::https://github.com/Rockykln/refrain/archive/v$pkgver.tar.gz")
-sha256sums=('d5558cd419c8d46bdc958064cb97f963d1ea793866414c025906ec15033512ed')
+# Filled in once the v0.4.3 tarball exists (after the tag is pushed):
+#   makepkg -g   /   updpkgsums
+sha256sums=('0000000000000000000000000000000000000000000000000000000000000000')
 
 build() {
     cd "$pkgname-$pkgver"

{refrain-0.4.2 → refrain-0.4.3}/packaging/aur/refrain-git/.SRCINFO

@@ -1,6 +1,6 @@
 pkgbase = refrain-git
 	pkgdesc = Discord Rich Presence for Apple Music on Linux (git)
-	pkgver = 0.4.2.r108.gb4e0e07
+	pkgver = 0.4.3.r116.gafe7701
 	pkgrel = 1
 	url = https://github.com/Rockykln/refrain
 	arch = any

{refrain-0.4.2 → refrain-0.4.3}/packaging/aur/refrain-git/PKGBUILD

@@ -2,7 +2,7 @@
 
 pkgname=refrain-git
 _pkgname=refrain
-pkgver=0.4.2.r108.gb4e0e07
+pkgver=0.4.3.r116.gafe7701
 pkgrel=1
 pkgdesc="Discord Rich Presence for Apple Music on Linux (git)"
 arch=('any')

{refrain-0.4.2 → refrain-0.4.3}/packaging/flatpak/io.github.Rockykln.Refrain.metainfo.xml

@@ -51,6 +51,15 @@
   <content_rating type="oars-1.1" />
 
   <releases>
+    <release version="0.4.3" date="2026-08-24">
+      <description>
+        <p>
+          Fixed a startup crash on systems whose Qt is a patch release ahead
+          of the one bundled with PySide6, which left pip, pipx and AppImage
+          installs unable to initialise any Qt platform plugin.
+        </p>
+      </description>
+    </release>
     <release version="0.4.2" date="2026-08-12">
       <description>
         <p>

{refrain-0.4.2 → refrain-0.4.3}/packaging/flatpak/io.github.Rockykln.Refrain.yaml

@@ -102,5 +102,5 @@ modules:
     sources:
       - type: git
         url: https://github.com/Rockykln/refrain.git
-        tag: v0.4.2
-        commit: b4e0e07a3cfcb55499e0fd87652ff9b508d32f6e
+        tag: v0.4.3
+        commit: afe770105f250eb48e4781dbf917602f6681aaea

{refrain-0.4.2 → refrain-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "refrain"
-version = "0.4.2"
+version = "0.4.3"
 description = "Discord Rich Presence for Apple Music on Linux"
 readme = "README.md"
 requires-python = ">=3.11"

refrain-0.4.3/src/refrain/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.3"

{refrain-0.4.2 → refrain-0.4.3}/src/refrain/app.py

@@ -123,6 +123,40 @@ def _detect_system_qt6_version() -> str | None:
     return None
 
 
+def _qt_version_tuple(version: str) -> tuple[int, ...]:
+    """Parse ``"6.11.2"`` into ``(6, 11, 2)``, stopping at the first
+    non-numeric component so suffixed versions still compare sanely."""
+    parts: list[int] = []
+    for chunk in version.split("."):
+        digits = ""
+        for ch in chunk:
+            if not ch.isdigit():
+                break
+            digits += ch
+        if not digits:
+            break
+        parts.append(int(digits))
+    return tuple(parts)
+
+
+def _system_qt_plugins_loadable(bundled: str, system: str) -> bool:
+    """Whether the system Qt's plugins can load into our bundled Qt.
+
+    Qt refuses a plugin built against a *newer* Qt than the one running,
+    so the system tree is only usable when it shares our MAJOR.MINOR and
+    is no newer at the patch level. A distro that is a single patch ahead
+    (bundled 6.11.1, system 6.11.2 — the common case on a rolling distro)
+    would otherwise hand us platform plugins Qt then rejects.
+    """
+    b = _qt_version_tuple(bundled)
+    s = _qt_version_tuple(system)
+    if len(b) < 2 or len(s) < 2:
+        return False
+    if b[:2] != s[:2]:
+        return False
+    return s <= b
+
+
 # Where distros put Qt 6 plugins. Order matters: try the
 # multiarch path first (Debian/Ubuntu derivatives), then lib64
 # (Fedora/RHEL/openSUSE), then the plain lib (Arch/CachyOS).
@@ -151,10 +185,11 @@ def _augment_qt_plugin_path() -> None:
     visibly different from the AUR / system build that runs against the
     distro PySide6.
 
-    If a system Qt 6 plugin tree exists and the system Qt's MAJOR.MINOR
-    matches ours, we prepend it so Qt finds the styles. We require a
-    minor-version match because mixing plugins across Qt minors risks
-    a silent ABI break.
+    If a system Qt 6 plugin tree exists and its plugins can actually load
+    into our Qt (see ``_system_qt_plugins_loadable``), we *append* it so
+    Qt finds the styles. Appending matters: the bundled Qt must keep first
+    claim on the platform plugin, otherwise a system plugin that Qt then
+    refuses takes the whole startup down with it.
 
     Must be called before ``QApplication`` is constructed — Qt resolves
     the platform/style plugin during construction.
@@ -174,13 +209,11 @@ def _augment_qt_plugin_path() -> None:
     if not system_version:
         log.debug("Could not determine system Qt 6 version; not augmenting plugin path")
         return
-    bundled_minor = ".".join(bundled_version.split(".")[:2])
-    system_minor = ".".join(system_version.split(".")[:2])
-    if bundled_minor != system_minor:
+    if not _system_qt_plugins_loadable(bundled_version, system_version):
         log.debug(
-            "Qt minor mismatch (bundled=%s system=%s); not augmenting plugin path",
-            bundled_version,
+            "System Qt %s cannot supply plugins for bundled Qt %s; not augmenting plugin path",
             system_version,
+            bundled_version,
         )
         return
     log.info(
@@ -189,7 +222,10 @@ def _augment_qt_plugin_path() -> None:
         bundled_version,
         system_version,
     )
-    QCoreApplication.addLibraryPath(str(system_plugins))
+    # Append, never prepend (``addLibraryPath`` prepends): the bundled Qt
+    # keeps first claim on the platform plugin, so a mismatched system tree
+    # can only cost us the styles, never the ability to start.
+    QCoreApplication.setLibraryPaths(QCoreApplication.libraryPaths() + [str(system_plugins)])
 
 
 def _user_apps_dir() -> Path:

refrain-0.4.3/tests/test_qt_plugin_path.py

@@ -0,0 +1,197 @@
+"""System Qt plugin-path augmentation must never break startup.
+
+Regression test for the 0.4.2 pipx ship-blocker: ``_augment_qt_plugin_path``
+compared only Qt's MAJOR.MINOR, so a PySide6 wheel bundling Qt 6.11.1 on a
+distro carrying Qt 6.11.2 (a rolling distro one patch ahead) *prepended* the
+system plugin tree via ``addLibraryPath``. Qt refuses a plugin built against
+a newer Qt than the one running, so both the wayland and xcb platform
+plugins were found, rejected, and — because the prepended path won — never
+fell back to the wheel's own. The app aborted with "no Qt platform plugin
+could be initialized".
+
+Two independent guards are asserted here:
+  * the version check rejects a system Qt newer than ours, and
+  * augmentation appends rather than prepends, so even a wrongly accepted
+    system tree can only cost the styles, never the ability to start.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+pytest.importorskip("PySide6")
+
+
+# ---------------------------------------------------------------------------
+# Version compatibility
+# ---------------------------------------------------------------------------
+@pytest.mark.parametrize(
+    ("bundled", "system", "loadable"),
+    [
+        # The shipped bug: wheel Qt 6.11.1 against Arch/CachyOS Qt 6.11.2.
+        ("6.11.1", "6.11.2", False),
+        # System older or equal is fine — Qt loads older plugins.
+        ("6.11.2", "6.11.1", True),
+        ("6.11.2", "6.11.2", True),
+        ("6.11.2", "6.11", True),
+        # Minor mismatches stay off-limits in both directions.
+        ("6.11.0", "6.12.0", False),
+        ("6.12.0", "6.11.0", False),
+        ("6.11.0", "5.15.2", False),
+        # Unparsable input must fail closed, not raise.
+        ("6.11.1", "garbage", False),
+        ("", "6.11.1", False),
+    ],
+)
+def test_system_qt_plugins_loadable(bundled, system, loadable):
+    from refrain.app import _system_qt_plugins_loadable
+
+    assert _system_qt_plugins_loadable(bundled, system) is loadable
+
+
+def test_qt_version_tuple_stops_at_non_numeric():
+    from refrain.app import _qt_version_tuple
+
+    assert _qt_version_tuple("6.11.2") == (6, 11, 2)
+    assert _qt_version_tuple("6.11") == (6, 11)
+    assert _qt_version_tuple("6.11.2rc1") == (6, 11, 2)
+    assert _qt_version_tuple("garbage") == ()
+
+
+# ---------------------------------------------------------------------------
+# Augmentation behaviour
+# ---------------------------------------------------------------------------
+class _FakeQCoreApplication:
+    """Records library-path mutations the way Qt would apply them."""
+
+    def __init__(self, initial: list[str]) -> None:
+        self._paths = list(initial)
+
+    def libraryPaths(self) -> list[str]:
+        return list(self._paths)
+
+    def setLibraryPaths(self, paths) -> None:
+        self._paths = list(paths)
+
+    def addLibraryPath(self, path: str) -> None:
+        # Qt prepends — the behaviour that caused the crash.
+        self._paths.insert(0, str(path))
+
+
+def _install_fakes(monkeypatch, tmp_path, *, bundled: str, system: str):
+    """Point ``_augment_qt_plugin_path`` at a wheel-shaped bundled tree
+    (no ``styles/``) and a fake system tree, and capture path mutations."""
+    import refrain.app as app
+
+    bundled_plugins = tmp_path / "wheel" / "PySide6" / "Qt" / "plugins"
+    (bundled_plugins / "platforms").mkdir(parents=True)
+
+    system_plugins = tmp_path / "usr" / "lib" / "qt6" / "plugins"
+    (system_plugins / "styles").mkdir(parents=True)
+
+    fake_info = SimpleNamespace(
+        LibraryPath=SimpleNamespace(PluginsPath=object()),
+        path=lambda _which: str(bundled_plugins),
+        version=lambda: SimpleNamespace(toString=lambda: bundled),
+    )
+    monkeypatch.setattr(app, "QLibraryInfo", fake_info)
+    monkeypatch.setattr(app, "_find_system_qt6_plugin_path", lambda: system_plugins)
+    monkeypatch.setattr(app, "_detect_system_qt6_version", lambda: system)
+    monkeypatch.setattr(app.sys, "platform", "linux")
+
+    fake_qapp = _FakeQCoreApplication([str(bundled_plugins)])
+    monkeypatch.setattr(app, "QCoreApplication", fake_qapp)
+    return app, fake_qapp, bundled_plugins, system_plugins
+
+
+def test_newer_system_qt_is_not_added(monkeypatch, tmp_path):
+    """The exact shipped failure: system one patch ahead must be skipped."""
+    app, qapp, bundled, _system = _install_fakes(
+        monkeypatch, tmp_path, bundled="6.11.1", system="6.11.2"
+    )
+
+    app._augment_qt_plugin_path()
+
+    assert qapp.libraryPaths() == [str(bundled)]
+
+
+def test_compatible_system_qt_is_appended_not_prepended(monkeypatch, tmp_path):
+    """When the versions do line up, the bundled tree keeps first claim on
+    the platform plugin — the system tree may only be consulted after it."""
+    app, qapp, bundled, system = _install_fakes(
+        monkeypatch, tmp_path, bundled="6.11.2", system="6.11.2"
+    )
+
+    app._augment_qt_plugin_path()
+
+    assert qapp.libraryPaths() == [str(bundled), str(system)]
+
+
+def test_distro_pyside_short_circuits(monkeypatch, tmp_path):
+    """Running against the distro PySide6 (its plugin dir already has
+    ``styles/``) must leave the library paths completely alone."""
+    import refrain.app as app
+
+    plugins = tmp_path / "usr" / "lib" / "qt6" / "plugins"
+    (plugins / "styles").mkdir(parents=True)
+
+    fake_info = SimpleNamespace(
+        LibraryPath=SimpleNamespace(PluginsPath=object()),
+        path=lambda _which: str(plugins),
+        version=lambda: SimpleNamespace(toString=lambda: "6.11.2"),
+    )
+    monkeypatch.setattr(app, "QLibraryInfo", fake_info)
+    monkeypatch.setattr(app.sys, "platform", "linux")
+
+    def _boom():  # pragma: no cover - must not be reached
+        raise AssertionError("system plugin lookup should be short-circuited")
+
+    monkeypatch.setattr(app, "_find_system_qt6_plugin_path", _boom)
+
+    fake_qapp = _FakeQCoreApplication([str(plugins)])
+    monkeypatch.setattr(app, "QCoreApplication", fake_qapp)
+
+    app._augment_qt_plugin_path()
+
+    assert fake_qapp.libraryPaths() == [str(plugins)]
+
+
+def test_unknown_system_version_is_not_added(monkeypatch, tmp_path):
+    app, qapp, bundled, _system = _install_fakes(
+        monkeypatch, tmp_path, bundled="6.11.2", system="6.11.2"
+    )
+    monkeypatch.setattr(app, "_detect_system_qt6_version", lambda: None)
+
+    app._augment_qt_plugin_path()
+
+    assert qapp.libraryPaths() == [str(bundled)]
+
+
+def test_non_linux_is_left_alone(monkeypatch, tmp_path):
+    app, qapp, bundled, _system = _install_fakes(
+        monkeypatch, tmp_path, bundled="6.11.2", system="6.11.2"
+    )
+    monkeypatch.setattr(app.sys, "platform", "darwin")
+
+    app._augment_qt_plugin_path()
+
+    assert qapp.libraryPaths() == [str(bundled)]
+
+
+def test_real_augmentation_never_breaks_qapplication(monkeypatch, tmp_path):
+    """Belt-and-braces: the real function against the real Qt must leave a
+    constructible QApplication behind."""
+    from PySide6.QtCore import QCoreApplication
+
+    import refrain.app as app
+
+    before = QCoreApplication.libraryPaths()
+    app._augment_qt_plugin_path()
+    after = QCoreApplication.libraryPaths()
+
+    # Whatever it decided, the originally-first path stays first.
+    assert after[: len(before)] == before
+    assert Path(after[0]).is_dir()

refrain-0.4.2/src/refrain/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.2"