SpotiFLAC 4.2.0__tar.gz → 4.2.2__tar.gz

{spotiflac-4.2.0/SpotiFLAC.egg-info → spotiflac-4.2.2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: SpotiFLAC
-Version: 4.2.0
+Version: 4.2.2
 Summary: Fetch Spotify track metadata and retrieve matching lossless audio through configurable Tidal, Qobuz & Amazon Music provider backends.
-Author:  BartolomeoRusso9, ShuKurenais
+Author:  BartolomeoRusso9
 License: MIT
 Project-URL: Homepage, https://github.com/BartolomeoRusso9/SpotiFLAC-Module-Version
 Project-URL: Repository, https://github.com/BartolomeoRusso9/SpotiFLAC-Module-Version

{spotiflac-4.2.0 → spotiflac-4.2.2}/SpotiFLAC/api_mixins/search.py

@@ -42,7 +42,9 @@ def empty_results() -> dict[str, list]:
     return {"tracks": [], "albums": [], "artists": [], "playlists": []}
 
 
-def shape_search_results(results: dict, limit: int = 50) -> dict[str, list]:
+def shape_search_results(
+    results: dict, limit: int = 50, provider: str = "spotify"
+) -> dict[str, list]:
     """Turns the client's objects into the dicts every frontend reads.
 
     `getattr` with a default throughout: a provider that stops returning one
@@ -72,7 +74,7 @@ def shape_search_results(results: dict, limit: int = 50) -> dict[str, list]:
                 "is_explicit": getattr(t, "is_explicit", False),
                 "explicit": getattr(t, "is_explicit", False),
                 "isrc": getattr(t, "isrc", ""),
-                "provider": "spotify",
+                "provider": provider,
             },
         )
 
@@ -91,7 +93,7 @@ def shape_search_results(results: dict, limit: int = 50) -> dict[str, list]:
                 "release_date": a.get("release_date", ""),
                 "external_urls": a.get("external_url", ""),
                 "external_url": a.get("external_url", ""),
-                "provider": "spotify",
+                "provider": provider,
             },
         )
 
@@ -107,7 +109,7 @@ def shape_search_results(results: dict, limit: int = 50) -> dict[str, list]:
                 "cover": art.get("cover_url", ""),
                 "external_urls": art.get("external_url", ""),
                 "external_url": art.get("external_url", ""),
-                "provider": "spotify",
+                "provider": provider,
             },
         )
 
@@ -124,13 +126,31 @@ def shape_search_results(results: dict, limit: int = 50) -> dict[str, list]:
                 "cover": p.get("cover_url", ""),
                 "external_urls": p.get("external_url", ""),
                 "external_url": p.get("external_url", ""),
-                "provider": "spotify",
+                "provider": provider,
             },
         )
     return out
 
 
-async def search_metadata_async(query: str, limit: int = 50) -> dict[str, list]:
+def _is_spotify(source: str | None) -> bool:
+    return not source or source == "spotify"
+
+
+def _search_client(source: str | None):
+    """Spotify, or the catalogue extension named `source` (see
+    core/extension_metadata.py — Melon, Bugs, Genie)."""
+    if _is_spotify(source):
+        from ..core.spotify_metadata import SpotifyMetadataClient
+
+        return SpotifyMetadataClient()
+    from ..core.extension_metadata import ExtensionMetadataClient
+
+    return ExtensionMetadataClient.for_source(source)
+
+
+async def search_metadata_async(
+    query: str, limit: int = 50, source: str | None = None
+) -> dict[str, list]:
     """Searches and shapes, on the caller's event loop.
 
     The client has an async search; the sync `search()` next to it only
@@ -140,51 +160,73 @@ async def search_metadata_async(query: str, limit: int = 50) -> dict[str, list]:
     if not query:
         return empty_results()
 
-    from ..core.spotify_metadata import SpotifyMetadataClient
-
-    client = SpotifyMetadataClient()
+    client = _search_client(source)
     results = await client.search_async(query, limit=limit)
-    return shape_search_results(results, limit)
+    return shape_search_results(results, limit, source or "spotify")
 
 
 class SearchMixin:
     """The two blocking entry points the desktop GUI needs."""
 
-    def search_provider(self, query, limit=50):
+    def get_metadata_sources(self):
+        """What the search box can search: Spotify, then every installed
+        catalogue extension."""
+        try:
+            from ..core.extension_metadata import metadata_sources
+
+            return metadata_sources()
+        except Exception as exc:
+            self.log(f"get_metadata_sources error: {exc}", "error")
+            return [{"id": "spotify", "label": "Spotify"}]
+
+    def search_provider(self, query, limit=50, source=None):
         """Search music providers (Spotify) for metadata matching `query`.
 
         Returns a dictionary with 4 sections: tracks, albums, artists,
         playlists (max `limit` results each).
         """
         try:
-            from ..core.spotify_metadata import SpotifyMetadataClient
-
-            client = SpotifyMetadataClient()
-            return shape_search_results(client.search(query, limit=limit), limit)
+            client = _search_client(source)
+            return shape_search_results(
+                client.search(query, limit=limit), limit, source or "spotify"
+            )
         except Exception as exc:
             self.log(f"search_provider error: {exc}", "error")
             return empty_results()
 
-    def search_provider_async(self, query, limit=50):
-        """Starts the search in a thread and pushes the result to the window."""
+    def search_provider_async(self, query, limit=50, source=None, request_id=None):
+        """Starts the search in a thread and pushes the result to the window.
+
+        `request_id` comes back with the result or the error, so the window
+        can drop an answer that arrives after a newer search — typing on, or
+        switching the source, starts another while this one is still out.
+        """
         if not query:
             return {"status": "empty"}
         threading.Thread(
             target=self._search_provider_thread,
-            args=(query, limit),
+            args=(query, limit, source, request_id),
             daemon=True,
         ).start()
         return {"status": "started"}
 
-    def _search_provider_thread(self, query, limit) -> None:
+    def _search_provider_thread(
+        self, query, limit, source=None, request_id=None
+    ) -> None:
         try:
-            from ..core.spotify_metadata import SpotifyMetadataClient
-
-            client = SpotifyMetadataClient()
-            out = shape_search_results(client.search(query, limit=limit), limit)
+            client = _search_client(source)
+            out = shape_search_results(
+                client.search(query, limit=limit), limit, source or "spotify"
+            )
         except Exception as exc:
-            self._push_quietly("app_handle_provider_search_error", str(exc))
+            # A bare string without an id, as before, for callers that send none.
+            error: Any = str(exc)
+            if request_id is not None:
+                error = {"message": str(exc), "request_id": request_id}
+            self._push_quietly("app_handle_provider_search_error", error)
             return
+        if request_id is not None:
+            out["request_id"] = request_id
         self._push_quietly("app_handle_provider_search_results", out)
 
     def _push_quietly(self, event: str, payload: Any) -> None:

spotiflac-4.2.2/SpotiFLAC/api_mixins/signed_sessions.py

@@ -0,0 +1,55 @@
+"""api_mixins/signed_sessions.py — which signed sessions are live, and until when.
+
+A thin wrapper over `core/signed_session_status.py`, which is also what the
+terminal UI and `--signed-sessions` call, so the three views cannot disagree.
+
+Reading is harmless: no row carries a secret. Clearing and pruning edit
+instance-wide state every account's downloads depend on, so in multi-user
+mode (`owner` set) they are refused to anyone who is not an admin.
+"""
+
+from __future__ import annotations
+
+
+class SignedSessionsMixin:
+    def _may_edit_signed_sessions(self) -> bool:
+        owner = getattr(self, "owner", "") or ""
+        if not owner:
+            return True
+        try:
+            from ..core.web_users import is_admin
+
+            return is_admin(owner)
+        except Exception:
+            return False
+
+    def get_signed_sessions(self) -> dict:
+        """Shape: {"sessions": [row, ...]} — see `list_signed_sessions`."""
+        try:
+            from ..core.signed_session_status import list_signed_sessions
+
+            return {"sessions": list_signed_sessions()}
+        except Exception as e:
+            return {"sessions": [], "error": str(e)}
+
+    def clear_signed_session(self, key: str) -> dict:
+        if not self._may_edit_signed_sessions():
+            return {"ok": False, "error": "Only an admin can clear signed sessions."}
+        try:
+            from ..core.signed_session_status import clear_signed_session
+
+            if not clear_signed_session(str(key or "")):
+                return {"ok": False, "error": "Unknown session."}
+            return {"ok": True}
+        except Exception as e:
+            return {"ok": False, "error": str(e)}
+
+    def prune_signed_sessions(self) -> dict:
+        if not self._may_edit_signed_sessions():
+            return {"ok": False, "error": "Only an admin can remove signed sessions."}
+        try:
+            from ..core.signed_session_status import prune_orphaned_sessions
+
+            return {"ok": True, "removed": prune_orphaned_sessions()}
+        except Exception as e:
+            return {"ok": False, "error": str(e)}

{spotiflac-4.2.0 → spotiflac-4.2.2}/SpotiFLAC/app.py

@@ -24,6 +24,7 @@ from .api_mixins.extension_health import ExtensionHealthMixin
 from .api_mixins.failed_tracks import FailedTracksMixin
 from .api_mixins.local_tagging import LocalTaggingMixin
 from .api_mixins.search import SearchMixin
+from .api_mixins.signed_sessions import SignedSessionsMixin
 from .api_mixins.stats import StatsMixin
 from .api_mixins.subscriptions import SubscriptionsMixin
 from .api_mixins.trust import TrustMixin
@@ -176,6 +177,7 @@ class SpotiFLAC_API(
     CsvImportMixin,
     StatsMixin,
     FailedTracksMixin,
+    SignedSessionsMixin,
 ):
     """pywebview/`--web` bridge — every method here (plus the two mixins
     above) becomes a callable the frontend invokes as `pywebview.api.<name>`
@@ -1047,19 +1049,21 @@ class SpotiFLAC_API(
             # setup — for every search typed into the box.
             from .core.tracklist import metadata_client_for
 
-            client = metadata_client_for(url)
-
             # ── Universal call ──────────────────────────────────────────────────
             # get_url() is sync on SpotifyMetadataClient but async on
             # TidalMetadataClient/AppleMusicMetadataClient — calling it directly
             # here would hand back an un-awaited coroutine for the latter two
             # (crashing on the very next line, `result[0]`). Reuse the same
             # sync/async dispatch helper the real download path already relies
-            # on instead of duplicating (and re-diverging from) that logic.
+            # on instead of duplicating (and re-diverging from) that logic —
+            # through the fallback that asks an installed metadata extension
+            # when the built-in Spotify or Apple Music client fails.
             # Returns (name, tracks) OR (name, tracks, cover) OR (name, tracks, cover, meta).
-            from .downloader import _call_metadata_get_url
+            from .core.metadata_fallback import get_url_with_fallback
 
-            result = await _call_metadata_get_url(client, stripped)
+            result = await get_url_with_fallback(
+                stripped, lambda: metadata_client_for(url)
+            )
             collection_name = result[0]
             tracks = result[1]
             collection_cover = result[2] if len(result) > 2 else ""

spotiflac-4.2.2/SpotiFLAC/core/cross_loop_lock.py

@@ -0,0 +1,53 @@
+"""SpotiFLAC/core/cross_loop_lock.py — a lock `async with` can use from any loop.
+
+An ``asyncio.Lock`` binds to the first event loop that has to *wait* on it
+and raises on every other one:
+
+    RuntimeError: <asyncio.locks.Lock ...> is bound to a different event loop
+
+This process runs many loops. ``core/loop_runner.py`` owns a long-lived one
+for the GUI and web bridges, ``client.SpotiFLAC()`` keeps its own
+``asyncio.run()`` per batch, and under ``--web`` each background download is
+its own ``asyncio.run()`` on its own thread. A module-level ``asyncio.Lock``
+therefore works for the first batch and crashes the first time two later ones
+contend. Uncontended acquires never touch the loop, which is why it only
+shows up under load.
+
+A ``threading.Lock`` has no loop affinity. It is taken without blocking, and
+the caller yields while it is busy, so the loop is never held up. It also
+serialises *threads*, which the asyncio lock never did: two downloads on two
+threads writing the same cache file were not actually excluded by it.
+
+Holding it across an ``await`` is allowed — waiters just poll a little longer
+— but keep what it guards short.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+
+
+class CrossLoopLock:
+    """``async with`` mutual exclusion across event loops and threads."""
+
+    def __init__(self, poll_interval: float = 0.01) -> None:
+        self._lock = threading.Lock()
+        self._poll_interval = poll_interval
+
+    def locked(self) -> bool:
+        return self._lock.locked()
+
+    async def __aenter__(self) -> CrossLoopLock:
+        # A plain yield first: an uncontended lock is the overwhelmingly
+        # common case, and a contended one is usually free again within a
+        # single tick, so the poll interval should be the exception.
+        if not self._lock.acquire(blocking=False):
+            await asyncio.sleep(0)
+            while not self._lock.acquire(blocking=False):
+                await asyncio.sleep(self._poll_interval)
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> bool:
+        self._lock.release()
+        return False

{spotiflac-4.2.0 → spotiflac-4.2.2}/SpotiFLAC/core/dns_doh.py

@@ -26,11 +26,12 @@ its DNS server would be useless in exactly the situation it exists for.
 
 from __future__ import annotations
 
-import asyncio
 import ipaddress
 import logging
 import time
 
+from .cross_loop_lock import CrossLoopLock
+
 logger = logging.getLogger(__name__)
 
 #: Resolvers, by literal address so this never needs DNS itself. Cloudflare
@@ -47,7 +48,8 @@ DOH_ENDPOINTS = (
 _TTL_S = 300.0
 
 _cache: dict[str, tuple[float, list[str]]] = {}
-_cache_lock = asyncio.Lock()
+#: Shared by every download, each possibly on its own event loop.
+_cache_lock = CrossLoopLock()
 
 
 def _is_public(address: str) -> bool: