SpotiFLAC 4.2.1__tar.gz → 4.2.2__tar.gz

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: SpotiFLAC
-Version: 4.2.1
+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.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.1 → 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>`

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.1 → 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:

{spotiflac-4.2.1 → spotiflac-4.2.2}/SpotiFLAC/core/isrc_cache.py

@@ -11,6 +11,7 @@ import json
 import logging
 import time
 
+from .cross_loop_lock import CrossLoopLock
 from .paths import cache_path
 
 try:
@@ -21,15 +22,13 @@ except ImportError:
 logger = logging.getLogger(__name__)
 
 _CACHE_FILE = cache_path("isrc-cache.json")
-_cache_lock: asyncio.Lock | None = None
+#: Not an asyncio.Lock: this cache is shared by every download, and under
+#: --web each one runs its own event loop. See core/cross_loop_lock.py.
+_cache_lock = CrossLoopLock()
 _cache: dict[str, dict] | None = None
 
 
-async def _get_lock() -> asyncio.Lock:
-    """Get or create the asyncio.Lock for cache access."""
-    global _cache_lock
-    if _cache_lock is None:
-        _cache_lock = asyncio.Lock()
+async def _get_lock() -> CrossLoopLock:
     return _cache_lock
 
 

{spotiflac-4.2.1 → spotiflac-4.2.2}/SpotiFLAC/core/lyrics.py

@@ -12,6 +12,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from . import get_amazon_endpoint
+from .cross_loop_lock import CrossLoopLock
 from .http import NetworkManager
 from .response_cache import get as get_cached_response
 from .response_cache import put as put_cached_response
@@ -183,15 +184,12 @@ _LYRICS_MISS_CACHE_TTL = 6 * 60 * 60
 # ---------------------------------------------------------------------------
 
 _spotify_session_cache: dict[str, object] = {}
-_spotify_token_lock: asyncio.Lock | None = None
+#: Every track's lyrics lookup goes through here, from whichever event loop
+#: that download runs on — an asyncio.Lock would bind to the first one.
+_spotify_token_lock = CrossLoopLock()
 
 
-async def _get_spotify_lock() -> asyncio.Lock:
-    global _spotify_token_lock
-
-    if _spotify_token_lock is None:
-        _spotify_token_lock = asyncio.Lock()
-
+async def _get_spotify_lock() -> CrossLoopLock:
     return _spotify_token_lock
 
 

{spotiflac-4.2.1 → spotiflac-4.2.2}/SpotiFLAC/core/profiles.py

@@ -16,12 +16,14 @@ import time
 
 from pydantic import BaseModel, Field, ValidationError, field_validator
 
+from .cross_loop_lock import CrossLoopLock
 from .paths import adopt_legacy_cache_file, cache_path
 
 logger = logging.getLogger(__name__)
 
-# Using asyncio.Lock instead of threading.Lock so it doesn't block the event loop
-_io_lock = asyncio.Lock()
+# Doesn't block the event loop, and — unlike an asyncio.Lock — works from
+# every loop this process runs. See core/cross_loop_lock.py.
+_io_lock = CrossLoopLock()
 _PROFILES_FILE = cache_path("profiles.json")
 
 

{spotiflac-4.2.1 → spotiflac-4.2.2}/SpotiFLAC/core/progress.py

@@ -8,7 +8,6 @@ import io
 import logging
 import os
 import sys
-import threading
 import time
 from dataclasses import dataclass
 from enum import Enum
@@ -18,6 +17,7 @@ from tqdm import tqdm
 from typing_extensions import Self
 
 from .console import print_track_progress
+from .cross_loop_lock import CrossLoopLock
 from .output_sink import STDERR, STDOUT, emit, sink_active, use_thread_only_tqdm_lock
 
 # tqdm.get_lock() remains the native tqdm lock (this is not our own hack;
@@ -362,7 +362,7 @@ class DownloadItem:
     cover_url: str = ""
 
 
-class _CrossLoopLock:
+class _CrossLoopLock(CrossLoopLock):
     """A mutex that survives more than one event loop.
 
     asyncio.Lock binds itself to the loop that first awaits it and raises
@@ -381,30 +381,10 @@ class _CrossLoopLock:
         RuntimeError: <asyncio.locks.Lock ...> is bound to a different
         event loop
 
-    A threading.Lock has no loop affinity. It is acquired without blocking
-    and the caller yields while it is busy, so the loop is never held up —
-    and every critical section it guards is a short synchronous mutation
-    with no await in it, so contention is brief by construction.
+    The implementation now lives in core/cross_loop_lock.py, shared with
+    every other process-wide lock that had the same bug.
     """
 
-    def __init__(self, poll_interval: float = 0.01) -> None:
-        self._lock = threading.Lock()
-        self._poll_interval = poll_interval
-
-    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
-
 
 class DownloadBroadcaster:
     """Singleton for streaming progress events to external listeners

{spotiflac-4.2.1 → spotiflac-4.2.2}/SpotiFLAC/core/provider_stats.py

@@ -7,6 +7,7 @@ from dataclasses import asdict, dataclass
 from pathlib import Path
 
 from .atomic_io import write_json_atomic
+from .cross_loop_lock import CrossLoopLock
 from .paths import cache_path
 
 #: Key prefix used by the download path (see downloader.download_one_async),
@@ -145,9 +146,11 @@ class ProviderScorer:
 
     def __init__(self) -> None:
         self._stats: dict[str, _ProviderStats] = {}
-        self._stats_lock = asyncio.Lock()
+        # Cross-loop, not asyncio.Lock: `_scorer` is a process-wide singleton
+        # every download records into, each from its own event loop.
+        self._stats_lock = CrossLoopLock()
         self._initialized = False
-        self._init_lock = asyncio.Lock()
+        self._init_lock = CrossLoopLock()
 
     async def _ensure_initialized(self) -> None:
         """Loads the database only the first time it's requested."""

{spotiflac-4.2.1 → spotiflac-4.2.2}/SpotiFLAC/core/session_memory.py

@@ -5,11 +5,13 @@ import json
 import logging
 import time
 
+from .cross_loop_lock import CrossLoopLock
 from .paths import adopt_legacy_cache_file, cache_path
 
 logger = logging.getLogger(__name__)
 
-_io_lock = asyncio.Lock()
+#: Called from the GUI's shared loop and from each batch's own asyncio.run().
+_io_lock = CrossLoopLock()
 _SESSION_FILE = cache_path("session.json")
 _MAX_HISTORY = 20