cloudspin 0.1.1__tar.gz → 0.2.0__tar.gz

{cloudspin-0.1.1 → cloudspin-0.2.0}/.github/workflows/ci.yml

@@ -35,3 +35,18 @@ jobs:
         run: brew install mpv ffmpeg
       - run: pip install -e ".[dev]"
       - run: pytest -q -rs
+
+  network:
+    # Real Spotify and YouTube. Informational: their servers can refuse CI machines.
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: sudo apt-get update && sudo apt-get install -y --no-install-recommends mpv
+      - run: pip install -e ".[dev]"
+      - run: pytest -q -rs -s tests/test_network.py
+        env:
+          CLOUDSPIN_TEST_NETWORK: "1"

{cloudspin-0.1.1 → cloudspin-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cloudspin
-Version: 0.1.1
+Version: 0.2.0
 Summary: A terminal music player that lives under a living sky: spinning vinyl, real weather, animated scenes.
 Project-URL: Homepage, https://github.com/itsHarshDabas/Cloudspin
 Project-URL: Issues, https://github.com/itsHarshDabas/Cloudspin/issues
@@ -45,7 +45,8 @@ synthwave turns the stars on.
 ## What it does
 
 - Plays local files, folders, radio streams and links through `mpv`.
-- Paste a link while it's running (press `o`) and it starts playing.
+- Opens YouTube, YouTube Music and Spotify playlists as a queue.
+- Paste a link or a playlist while it's running (press `o`) and it starts playing.
 - Shows live weather and a six-day forecast from [Open-Meteo](https://open-meteo.com) (free, no API key).
 - Draws an animated sky: sun, moon with the real phase, stars, drifting clouds, rain, snow, fog and lightning.
 - Picks the sky to suit the song, or follows the real weather, or stays on a scene you pin.
@@ -75,7 +76,6 @@ and most others).
 | --- | --- | --- |
 | `yt-dlp` | YouTube, SoundCloud and similar links | Installed with Cloudspin |
 | `mpv` | Plays the sound | **Windows:** downloaded automatically the first time you start Cloudspin (about 30 MB, kept in its cache folder). **Linux and macOS:** from your package manager, e.g. `sudo pacman -S mpv`, `sudo apt install mpv`, `brew install mpv` |
-| `ffmpeg` | Optional. Lets Cloudspin listen to songs with no genre tag to guess a sky | Your package manager |
 
 Without mpv Cloudspin still runs, silently, and tells you the command to install it.
 
@@ -86,6 +86,8 @@ cloudspin                       # plays ~/Music
 cloudspin ~/Music/phonk         # a folder
 cloudspin song.flac other.mp3   # files
 cloudspin https://example.com/stream.mp3   # a link
+cloudspin "https://music.youtube.com/playlist?list=..."   # a YouTube Music playlist
+cloudspin "https://open.spotify.com/playlist/..."        # a Spotify playlist
 cloudspin --city "New Delhi"    # set the city once; it is remembered
 cloudspin --demo                # look around without any music or sound
 ```
@@ -110,24 +112,43 @@ No music folder? Start `cloudspin`, press `o` and paste a link.
 | `?` | Show the keys |
 | `q` | Quit |
 
+## Playlists
+
+Paste a playlist link with `o`, pass it on the command line, or set it as
+`music` in the settings so Cloudspin opens with it every time.
+
+- **YouTube, YouTube Music, SoundCloud** and other sites yt-dlp knows play
+  straight from the site.
+- **Spotify** works differently. Spotify's audio only plays inside its own
+  apps, so Cloudspin reads the list of songs from the public playlist page and
+  plays each one from the closest match on YouTube. Usually that is the same
+  recording; now and then it is a live or alternate version. The playlist has
+  to be public, and long ones are read up to the first 50 to 100 songs.
+
 ## How the sky picks a scene
 
-With the sky set to follow the song (the default), Cloudspin looks for a
-scene in this order and uses the first one it finds:
-
-1. **Your rules.** Words you map to scenes in the config file.
-2. **The tags.** The genre tag, then sky words in the title or album.
-   `phonk`, `metal` and `dubstep` storm; `lofi`, `jazz` and `acoustic` get the
-   evening; `synthwave` and `r&b` get the night; `blues` rains; `dream pop`
-   fogs over; `christmas` snows; `pop` and `dance` get a sunny day. A song
-   called "Midnight Rain" needs no tag at all.
-3. **A short listen.** If `ffmpeg` is installed, 30 seconds of the song are
-   measured for loudness, tempo, bass and brightness. Loud, fast and
-   bass-heavy becomes a storm; quiet and slow becomes night.
+With the sky set to follow the song (the default), Cloudspin decides like this:
+
+1. **Your rules.** Words you map to scenes in the config file always win.
+2. **How the song sounds.** Thirty seconds are decoded in the background and
+   measured for rhythm (attacks per second, tempo), brightness, bass weight
+   and loudness. Busy, bright and bass-heavy becomes a storm; slow and soft
+   becomes evening or night. This works for links as well as files, and each
+   song is only measured once.
+3. **The words**, as a first guess while the listening happens and as the
+   answer when listening isn't possible: the genre tag, then sky words in the
+   title or album. `phonk`, `hoodtrap` and `metal` storm; `lofi` and `jazz`
+   get the evening; `synthwave` gets the night; "Midnight Rain" needs no tag.
 4. **The real weather**, if nothing above says anything.
 
 The caption in the top right corner of the sky always says which scene is
-showing and why, for example `Thunderstorm, tagged Drift phonk`.
+showing and why, for example `Thunderstorm, hard-hitting and heavy on bass`.
+
+To see what Cloudspin hears in a song, and report one it gets wrong:
+
+```sh
+cloudspin --listen "song.mp3"
+```
 
 The scenes are `storm`, `rain`, `evening`, `night`, `day`, `dawn`, `snow`,
 `fog` and `overcast`.
@@ -141,9 +162,10 @@ city = "New Delhi"
 units = "metric"      # or "imperial"
 sky = "song"          # "song", "weather", or a scene name to pin
 colors = "sky"        # "sky", "cover", a built-in theme, or one of yours
-music = "~/Music"
+music = "~/Music"     # a folder, or a playlist link
 volume = 70
 fps = 24              # lower this on a slow terminal or over SSH
+listen = true         # false: choose the sky from tags and titles only
 
 # Send particular artists, albums or words to a scene.
 [moods]
@@ -165,9 +187,10 @@ Built-in themes: `sky`, `cover`, `amber`, `orchid`, `lagoon`, `moss`, `rose`, `m
 
 - **The bars are generative.** The spectrum moves with the play state, the
   volume and a tempo chosen per song. It is not a live analysis of the audio.
-- **The listen is a guess.** Step 3 above is a heuristic that has only been
-  checked against synthetic test audio. Tags and your own rules are exact;
-  use `[moods]` when it gets a song wrong.
+- **The listening is a rule of thumb.** It has been checked against synthetic
+  test audio, not a real music library, so expect some wrong skies. Use
+  `[moods]` to pin an artist or word to a scene, and `cloudspin --listen` to
+  see the numbers behind a choice.
 - **Links** play through mpv, with the bundled yt-dlp handling sites like
   YouTube. Sites change often; if a link stops working, update with
   `pipx upgrade cloudspin` (or `uv tool upgrade cloudspin`) to get a newer yt-dlp.
@@ -208,6 +231,7 @@ The code is small and split by job:
 | `mood.py` | Choosing a scene for a song |
 | `weather.py` | Open-Meteo and sun and moon maths |
 | `player.py` | mpv control and the queue |
+| `links.py` | Reading YouTube and Spotify playlists |
 | `mpvget.py` | Finding mpv and yt-dlp; the Windows mpv download |
 | `widgets.py`, `app.py` | The interface |
 

{cloudspin-0.1.1 → cloudspin-0.2.0}/README.md

@@ -14,7 +14,8 @@ synthwave turns the stars on.
 ## What it does
 
 - Plays local files, folders, radio streams and links through `mpv`.
-- Paste a link while it's running (press `o`) and it starts playing.
+- Opens YouTube, YouTube Music and Spotify playlists as a queue.
+- Paste a link or a playlist while it's running (press `o`) and it starts playing.
 - Shows live weather and a six-day forecast from [Open-Meteo](https://open-meteo.com) (free, no API key).
 - Draws an animated sky: sun, moon with the real phase, stars, drifting clouds, rain, snow, fog and lightning.
 - Picks the sky to suit the song, or follows the real weather, or stays on a scene you pin.
@@ -44,7 +45,6 @@ and most others).
 | --- | --- | --- |
 | `yt-dlp` | YouTube, SoundCloud and similar links | Installed with Cloudspin |
 | `mpv` | Plays the sound | **Windows:** downloaded automatically the first time you start Cloudspin (about 30 MB, kept in its cache folder). **Linux and macOS:** from your package manager, e.g. `sudo pacman -S mpv`, `sudo apt install mpv`, `brew install mpv` |
-| `ffmpeg` | Optional. Lets Cloudspin listen to songs with no genre tag to guess a sky | Your package manager |
 
 Without mpv Cloudspin still runs, silently, and tells you the command to install it.
 
@@ -55,6 +55,8 @@ cloudspin                       # plays ~/Music
 cloudspin ~/Music/phonk         # a folder
 cloudspin song.flac other.mp3   # files
 cloudspin https://example.com/stream.mp3   # a link
+cloudspin "https://music.youtube.com/playlist?list=..."   # a YouTube Music playlist
+cloudspin "https://open.spotify.com/playlist/..."        # a Spotify playlist
 cloudspin --city "New Delhi"    # set the city once; it is remembered
 cloudspin --demo                # look around without any music or sound
 ```
@@ -79,24 +81,43 @@ No music folder? Start `cloudspin`, press `o` and paste a link.
 | `?` | Show the keys |
 | `q` | Quit |
 
+## Playlists
+
+Paste a playlist link with `o`, pass it on the command line, or set it as
+`music` in the settings so Cloudspin opens with it every time.
+
+- **YouTube, YouTube Music, SoundCloud** and other sites yt-dlp knows play
+  straight from the site.
+- **Spotify** works differently. Spotify's audio only plays inside its own
+  apps, so Cloudspin reads the list of songs from the public playlist page and
+  plays each one from the closest match on YouTube. Usually that is the same
+  recording; now and then it is a live or alternate version. The playlist has
+  to be public, and long ones are read up to the first 50 to 100 songs.
+
 ## How the sky picks a scene
 
-With the sky set to follow the song (the default), Cloudspin looks for a
-scene in this order and uses the first one it finds:
-
-1. **Your rules.** Words you map to scenes in the config file.
-2. **The tags.** The genre tag, then sky words in the title or album.
-   `phonk`, `metal` and `dubstep` storm; `lofi`, `jazz` and `acoustic` get the
-   evening; `synthwave` and `r&b` get the night; `blues` rains; `dream pop`
-   fogs over; `christmas` snows; `pop` and `dance` get a sunny day. A song
-   called "Midnight Rain" needs no tag at all.
-3. **A short listen.** If `ffmpeg` is installed, 30 seconds of the song are
-   measured for loudness, tempo, bass and brightness. Loud, fast and
-   bass-heavy becomes a storm; quiet and slow becomes night.
+With the sky set to follow the song (the default), Cloudspin decides like this:
+
+1. **Your rules.** Words you map to scenes in the config file always win.
+2. **How the song sounds.** Thirty seconds are decoded in the background and
+   measured for rhythm (attacks per second, tempo), brightness, bass weight
+   and loudness. Busy, bright and bass-heavy becomes a storm; slow and soft
+   becomes evening or night. This works for links as well as files, and each
+   song is only measured once.
+3. **The words**, as a first guess while the listening happens and as the
+   answer when listening isn't possible: the genre tag, then sky words in the
+   title or album. `phonk`, `hoodtrap` and `metal` storm; `lofi` and `jazz`
+   get the evening; `synthwave` gets the night; "Midnight Rain" needs no tag.
 4. **The real weather**, if nothing above says anything.
 
 The caption in the top right corner of the sky always says which scene is
-showing and why, for example `Thunderstorm, tagged Drift phonk`.
+showing and why, for example `Thunderstorm, hard-hitting and heavy on bass`.
+
+To see what Cloudspin hears in a song, and report one it gets wrong:
+
+```sh
+cloudspin --listen "song.mp3"
+```
 
 The scenes are `storm`, `rain`, `evening`, `night`, `day`, `dawn`, `snow`,
 `fog` and `overcast`.
@@ -110,9 +131,10 @@ city = "New Delhi"
 units = "metric"      # or "imperial"
 sky = "song"          # "song", "weather", or a scene name to pin
 colors = "sky"        # "sky", "cover", a built-in theme, or one of yours
-music = "~/Music"
+music = "~/Music"     # a folder, or a playlist link
 volume = 70
 fps = 24              # lower this on a slow terminal or over SSH
+listen = true         # false: choose the sky from tags and titles only
 
 # Send particular artists, albums or words to a scene.
 [moods]
@@ -134,9 +156,10 @@ Built-in themes: `sky`, `cover`, `amber`, `orchid`, `lagoon`, `moss`, `rose`, `m
 
 - **The bars are generative.** The spectrum moves with the play state, the
   volume and a tempo chosen per song. It is not a live analysis of the audio.
-- **The listen is a guess.** Step 3 above is a heuristic that has only been
-  checked against synthetic test audio. Tags and your own rules are exact;
-  use `[moods]` when it gets a song wrong.
+- **The listening is a rule of thumb.** It has been checked against synthetic
+  test audio, not a real music library, so expect some wrong skies. Use
+  `[moods]` to pin an artist or word to a scene, and `cloudspin --listen` to
+  see the numbers behind a choice.
 - **Links** play through mpv, with the bundled yt-dlp handling sites like
   YouTube. Sites change often; if a link stops working, update with
   `pipx upgrade cloudspin` (or `uv tool upgrade cloudspin`) to get a newer yt-dlp.
@@ -177,6 +200,7 @@ The code is small and split by job:
 | `mood.py` | Choosing a scene for a song |
 | `weather.py` | Open-Meteo and sun and moon maths |
 | `player.py` | mpv control and the queue |
+| `links.py` | Reading YouTube and Spotify playlists |
 | `mpvget.py` | Finding mpv and yt-dlp; the Windows mpv download |
 | `widgets.py`, `app.py` | The interface |
 

{cloudspin-0.1.1 → cloudspin-0.2.0}/packaging/aur/PKGBUILD

@@ -3,7 +3,7 @@
 # Not on the AUR yet. This builds from the PyPI release, so publish to PyPI
 # first, then run `updpkgsums` here to fill in the checksum.
 pkgname=cloudspin
-pkgver=0.1.1
+pkgver=0.2.0
 pkgrel=1
 pkgdesc="A terminal music player under a living sky: spinning vinyl, real weather, scenes that follow the song"
 arch=('any')

{cloudspin-0.1.1 → cloudspin-0.2.0}/packaging/npm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudspin",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Launcher for Cloudspin, a terminal music player under a living sky. Runs the Python app through uv or pipx.",
   "bin": {
     "cloudspin": "bin/cloudspin.js"

{cloudspin-0.1.1 → cloudspin-0.2.0}/src/cloudspin/__init__.py

@@ -1,3 +1,3 @@
 """Cloudspin: a terminal music player that lives under a living sky."""
 
-__version__ = "0.1.1"
+__version__ = "0.2.0"

{cloudspin-0.1.1 → cloudspin-0.2.0}/src/cloudspin/app.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import math
 import queue
 import threading
@@ -12,7 +13,7 @@ from textual.binding import Binding
 from textual.color import Color
 from textual.containers import Horizontal, Vertical
 
-from . import library, mood, weather
+from . import library, links, mood, weather
 from .config import Config, cache_dir
 from pathlib import Path
 
@@ -108,6 +109,14 @@ class CloudspinApp(App[None]):
         self._weather_due = 0.0
         self._weather_busy = False
         self._closing = False
+        self._heard: set[str] = set()  # songs whose sky came from listening, not from words
+        self._features: dict[str, list[float]] = {}
+        self._features_lock = threading.Lock()
+        try:
+            saved = json.loads((cache_dir() / "listened.json").read_text(encoding="utf-8"))
+            self._features = {str(k): [float(x) for x in v] for k, v in saved.items() if isinstance(v, list) and len(v) == 5}
+        except (OSError, ValueError, TypeError):
+            pass
         self._is_up = False
 
     # -- layout --------------------------------------------------------------
@@ -171,6 +180,8 @@ class CloudspinApp(App[None]):
     # -- the clock -----------------------------------------------------------
 
     def _tick(self) -> None:
+        if self._closing or not self.screen_stack:
+            return  # a last timer tick can land while the app is shutting down
         now = time.monotonic()
         dt = min(0.25, now - self._last)
         self._last = now
@@ -267,7 +278,7 @@ class CloudspinApp(App[None]):
     def _follow_stream(self) -> None:
         """Links only learn their real name once they start playing."""
         track = self.deck.current
-        if track is None or not track.is_stream:
+        if track is None or not track.is_stream or track.pinned:
             return
         backend = self.deck.backend
         title = getattr(backend, "media_title", "")
@@ -281,7 +292,8 @@ class CloudspinApp(App[None]):
         look = look_for(track.title, track.artist, track.album, None)
         guess = mood.from_words(track.title, track.artist, track.album, track.genre, self.config.moods)
         self._looks[track.path] = self.look = look
-        self._moods[track.path] = self.mood = guess
+        if track.path not in self._heard:
+            self._moods[track.path] = self.mood = guess
 
     def _open(self, target: str | None) -> None:
         if not target:
@@ -289,7 +301,18 @@ class CloudspinApp(App[None]):
         target = target.strip()
         if "://" in target:
             if self.deck.backend.silent:
-                self.flash("Links need mpv for sound. Install mpv, plus yt-dlp for YouTube links.", 7.0)
+                self.flash("Links need mpv for sound, and mpv isn't installed.", 7.0)
+                return
+            if links.is_collection(target):
+                self.flash("Reading the playlist…", 30.0)
+
+                def work() -> None:
+                    try:
+                        self._inbox.put(("playlist", links.expand(target), ""))
+                    except links.LinkError as error:
+                        self._inbox.put(("playlist", [], str(error)))
+
+                threading.Thread(target=work, name="cloudspin-playlist", daemon=True).start()
                 return
             tracks = [Track(path=target, title=target.split("://", 1)[1].rstrip("/") or target)]
         else:
@@ -312,15 +335,52 @@ class CloudspinApp(App[None]):
             library.read_tags(track)
             art = library.cover_art(path)
             self._inbox.put(("look", path, look_for(track.title, track.artist, track.album, art)))
-            guess = mood.from_words(track.title, track.artist, track.album, track.genre, self.config.moods)
-            if guess is None and not track.is_stream:
-                features = mood.listen(path)
-                if features is not None:
-                    self._inbox.put(("tempo", path, features.tempo))
-                    guess = mood.from_features(features)
-            self._inbox.put(("mood", path, guess))
+            ruled = mood.from_rules(track.title, track.artist, track.album, track.genre, self.config.moods)
+            if ruled is not None:
+                self._inbox.put(("mood", path, ruled, "sound"))  # your rules outrank everything
+                return
+            # Words give an instant first guess; the sound of the song has the final say.
+            guess = mood.from_words(track.title, track.artist, track.album, track.genre)
+            self._inbox.put(("mood", path, guess, "words"))
+            features = self._listen(track) if self.config.listen else None
+            if features is not None:
+                self._inbox.put(("tempo", path, features.tempo))
+                self._inbox.put(("mood", path, mood.from_features(features), "sound"))
         except Exception:  # a broken file must never take the app down
-            self._inbox.put(("mood", path, None))
+            self._inbox.put(("mood", path, None, "words"))
+        finally:
+            self._inbox.put(("studied", path))
+
+    def _listen(self, track) -> mood.Features | None:
+        """Measure a song, remembering the answer so it is only ever done once."""
+        path = track.path
+        key = path
+        if not track.is_stream:
+            try:
+                stat = Path(path).stat()
+                key = f"{path}|{stat.st_size}|{int(stat.st_mtime)}"
+            except OSError:
+                return None
+        known = self._features.get(key)
+        if known is not None:
+            return mood.Features(*known)
+        backend = self.deck.backend
+        if track.is_stream and backend.silent:
+            return None
+        features = mood.listen(path, getattr(backend, "binary", None), getattr(backend, "ytdlp", None))
+        if features is None:
+            return None
+        with self._features_lock:
+            self._features[key] = [features.loudness, features.tempo, features.onsets, features.bass, features.brightness]
+            while len(self._features) > 4000:
+                self._features.pop(next(iter(self._features)))
+            try:
+                target = cache_dir() / "listened.json"
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.write_text(json.dumps(self._features), encoding="utf-8")
+            except OSError:
+                pass
+        return features
 
     def _read_all_tags(self) -> None:
         for track in list(self.deck.tracks):
@@ -342,10 +402,24 @@ class CloudspinApp(App[None]):
                 if item[1] == current:
                     self.look = item[2]
             elif kind == "mood":
-                self._moods[item[1]] = item[2]
+                path, guess, source = item[1], item[2], item[3]
+                if source == "sound":
+                    self._heard.add(path)
+                elif path in self._heard:
+                    continue  # a guess from words never replaces what was heard
+                self._moods[path] = guess
+                if path == current:
+                    self.mood = guess
+            elif kind == "studied":
                 self._studying.discard(item[1])
-                if item[1] == current:
-                    self.mood = item[2]
+            elif kind == "playlist":
+                tracks, problem = item[1], item[2]
+                if problem:
+                    self.flash(problem, 8.0)
+                else:
+                    first = self.deck.add(tracks)
+                    self.deck.play(first)
+                    self.flash(f"Added {len(tracks)} songs from the playlist", 5.0)
             elif kind == "tempo":
                 self._tempos[item[1]] = item[2]
                 if item[1] == current:

{cloudspin-0.1.1 → cloudspin-0.2.0}/src/cloudspin/cli.py

@@ -15,12 +15,13 @@ def build_parser() -> argparse.ArgumentParser:
         description="A terminal music player under a living sky.",
         epilog="Settings live in ~/.config/cloudspin/config.toml. Press ? inside the app for the keys.",
     )
-    parser.add_argument("music", nargs="*", help="files, folders or stream URLs to play (default: your music folder)")
+    parser.add_argument("music", nargs="*", help="files, folders, links or playlist links to play (default: your music folder)")
     parser.add_argument("--city", help="city for the weather, for example --city \"New Delhi\"")
     parser.add_argument("--sky", metavar="MODE", help="song, weather, or a scene: storm, rain, evening, night, day, dawn, snow, fog, overcast")
     parser.add_argument("--colors", metavar="THEME", help="sky, cover, amber, orchid, lagoon, moss, rose, mono, or one of your own")
     parser.add_argument("--units", choices=("metric", "imperial"), help="°C and km/h, or °F and mph")
     parser.add_argument("--fps", type=int, metavar="N", help="animation frames per second (4-60, default 24)")
+    parser.add_argument("--listen", metavar="SONG", help="measure one file or link, print what was heard and which sky it gets, then exit")
     parser.add_argument("--demo", action="store_true", help="run a silent demo with made-up songs")
     parser.add_argument("--version", action="version", version=f"cloudspin {__version__}")
     return parser
@@ -47,13 +48,28 @@ def main(argv: list[str] | None = None) -> int:
     args = build_parser().parse_args(argv)
 
     # Imported late so --help and --version stay instant.
-    from . import library, mood, mpvget, weather
+    from . import library, links, mood, mpvget, weather
     from .app import CloudspinApp
     from .config import Config
     from .player import DEMO_TRACKS, BackendError, Deck, DemoBackend, MpvBackend
     from .themes import load_themes
 
     config = Config.load()
+    if args.listen:
+        binary = mpvget.find_mpv()
+        features = mood.listen(args.listen, binary, mpvget.find_ytdlp())
+        if features is None:
+            print("Couldn't listen to that. It needs mpv (or ffmpeg for files) and at least 8 seconds of sound.")
+            return 1
+        chosen = mood.from_features(features)
+        print(f"loudness   {features.loudness:6.1f} dBFS")
+        print(f"tempo      {features.tempo:6.0f} bpm (rough)")
+        print(f"attacks    {features.onsets:6.2f} per second")
+        print(f"bass       {features.bass:6.2f} share of energy")
+        print(f"brightness {features.brightness:6.3f}")
+        print(f"intensity  {features.intensity:6.2f}")
+        print(f"sky        {mood.SCENES[chosen.scene].label} ({chosen.why})")
+        return 0
     if args.units:
         config.units = args.units
     if args.fps:
@@ -87,7 +103,16 @@ def main(argv: list[str] | None = None) -> int:
         silent_reason = "Silent demo"
     else:
         sources = args.music or [config.music]
-        tracks = library.scan(sources)
+        tracks = []
+        for source in sources:
+            if links.is_collection(source):
+                print("Reading the playlist...")
+                try:
+                    tracks += links.expand(source)
+                except links.LinkError as error:
+                    print(f"  {error}")
+            else:
+                tracks += library.scan([source])
         try:
             binary = mpvget.find_mpv()
             if binary is None and mpvget.WINDOWS:

{cloudspin-0.1.1 → cloudspin-0.2.0}/src/cloudspin/config.py

@@ -35,6 +35,7 @@ class Config:
     music: str = "~/Music"
     volume: int = 70
     fps: int = 24
+    listen: bool = True  # decode a little of each song to choose its sky
     themes: dict[str, dict[str, str]] = field(default_factory=dict)
     moods: dict[str, str] = field(default_factory=dict)
     path: Path | None = None
@@ -56,6 +57,8 @@ class Config:
         for key, lo, hi in (("volume", 0, 100), ("fps", 4, 60)):
             if isinstance(data.get(key), int) and not isinstance(data.get(key), bool):
                 setattr(config, key, max(lo, min(hi, data[key])))
+        if isinstance(data.get("listen"), bool):
+            config.listen = data["listen"]
         if config.units not in ("metric", "imperial"):
             config.units = "metric"
         themes = data.get("themes")
@@ -91,6 +94,7 @@ class Config:
             f"music = {quote(self.music)}",
             f"volume = {self.volume}",
             f"fps = {self.fps}",
+            f"listen = {str(self.listen).lower()}",
         ]
         if self.moods:
             lines += ["", "[moods]"]

cloudspin-0.2.0/src/cloudspin/links.py

@@ -0,0 +1,166 @@
+"""Turning a playlist link into songs.
+
+YouTube, YouTube Music, SoundCloud and the many other sites yt-dlp knows are
+read with yt-dlp, and their songs play straight from the site.
+
+Spotify is different: its audio is locked to its own apps, so nothing outside
+them can play it. Cloudspin reads the *list* of songs from the public playlist
+page and plays each one from the closest match on YouTube.
+"""
+
+from __future__ import annotations
+
+import html
+import json
+import re
+import urllib.error
+import urllib.request
+
+from .player import Track
+
+LIMIT = 500
+_SPOTIFY = re.compile(r"open\.spotify\.com/(?:intl-[a-z-]+/)?(?:embed/)?(playlist|album|track)/([A-Za-z0-9]+)")
+_NEXT_DATA = re.compile(r'<script id="__NEXT_DATA__"[^>]*>(.*?)</script>', re.S)
+_BROWSER = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36"
+
+
+class LinkError(Exception):
+    """A playlist could not be read; the message is written for the user."""
+
+
+def is_collection(link: str) -> bool:
+    """Does this link point at many songs rather than one?"""
+    if "://" not in link:
+        return False
+    lowered = link.lower()
+    if "open.spotify.com/" in lowered:
+        return True
+    return any(mark in lowered for mark in ("list=", "/playlist", "/album/", "/sets/", "/browse/"))
+
+
+def expand(link: str) -> list[Track]:
+    """Every song behind a playlist link. Raises LinkError with a readable reason."""
+    if _SPOTIFY.search(link):
+        tracks = _spotify(link)
+    else:
+        tracks = _with_ytdlp(link)
+    if not tracks:
+        raise LinkError("That playlist is empty, private, or couldn't be read.")
+    return tracks[:LIMIT]
+
+
+# -- yt-dlp ------------------------------------------------------------------
+
+
+def _with_ytdlp(link: str) -> list[Track]:
+    try:
+        import yt_dlp
+    except ImportError as error:
+        raise LinkError("Reading playlists needs yt-dlp, which should have been installed with Cloudspin.") from error
+    options = {"extract_flat": "in_playlist", "quiet": True, "no_warnings": True, "skip_download": True, "playlistend": LIMIT}
+    try:
+        with yt_dlp.YoutubeDL(options) as reader:
+            info = reader.extract_info(link, download=False)
+    except Exception as error:  # yt-dlp raises many kinds; all mean "couldn't read it"
+        reason = str(error).replace("ERROR: ", "").strip().splitlines()[0][:140] if str(error).strip() else "unknown error"
+        raise LinkError(f"That playlist couldn't be read ({reason}).") from error
+    return tracks_from_ytdlp(info or {}, link)
+
+
+def tracks_from_ytdlp(info: dict, link: str) -> list[Track]:
+    entries = info.get("entries")
+    if entries is None:
+        entries = [info]
+    tracks = []
+    for entry in entries:
+        if not isinstance(entry, dict):
+            continue
+        url = entry.get("url") or entry.get("webpage_url") or ""
+        if "://" not in url:
+            if entry.get("id") and "youtu" in f"{entry.get('ie_key', '')}{link}".lower():
+                url = f"https://www.youtube.com/watch?v={entry['id']}"
+            else:
+                continue
+        title = str(entry.get("title") or "").strip()
+        if not title or title in ("[Deleted video]", "[Private video]"):
+            continue
+        artist = str(entry.get("artist") or entry.get("channel") or entry.get("uploader") or "")
+        artist = artist.removesuffix(" - Topic").strip()
+        tracks.append(Track(path=url, title=title, artist=artist, duration=float(entry.get("duration") or 0.0)))
+    return tracks
+
+
+# -- Spotify -----------------------------------------------------------------
+
+
+def _find_track_list(node) -> list | None:
+    if isinstance(node, dict):
+        found = node.get("trackList")
+        if isinstance(found, list) and found:
+            return found
+        if node.get("type") == "track" and node.get("title") and "artists" in node:
+            return [node]
+        for value in node.values():
+            deeper = _find_track_list(value)
+            if deeper:
+                return deeper
+    elif isinstance(node, list):
+        for value in node:
+            deeper = _find_track_list(value)
+            if deeper:
+                return deeper
+    return None
+
+
+def tracks_from_spotify_page(page: str) -> list[Track]:
+    """Pull the song list out of a Spotify embed page."""
+    match = _NEXT_DATA.search(page)
+    if not match:
+        return []
+    try:
+        data = json.loads(html.unescape(match.group(1)) if "&quot;" in match.group(1) else match.group(1))
+    except ValueError:
+        return []
+    tracks = []
+    for item in _find_track_list(data) or []:
+        if not isinstance(item, dict):
+            continue
+        title = str(item.get("title") or item.get("name") or "").strip()
+        artist = item.get("subtitle")
+        if not artist and isinstance(item.get("artists"), list):
+            artist = ", ".join(str(a.get("name", "")) for a in item["artists"] if isinstance(a, dict))
+        artist = str(artist or "").replace(" ", " ").strip()
+        if not title:
+            continue
+        # Spotify itself can't be played from here, so each song is found on YouTube.
+        search = f"{artist} - {title}" if artist else title
+        tracks.append(
+            Track(
+                path=f"ytdl://ytsearch1:{search}",
+                title=title,
+                artist=artist,
+                duration=float(item.get("duration") or 0) / 1000.0,
+                pinned=True,
+            )
+        )
+    return tracks
+
+
+def _spotify(link: str) -> list[Track]:
+    kind, ident = _SPOTIFY.search(link).groups()  # type: ignore[union-attr]
+    request = urllib.request.Request(
+        f"https://open.spotify.com/embed/{kind}/{ident}", headers={"User-Agent": _BROWSER, "Accept-Language": "en"}
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=20) as response:
+            page = response.read().decode("utf-8", "replace")
+    except urllib.error.HTTPError as error:
+        if error.code == 404:
+            raise LinkError("Spotify says that playlist doesn't exist or is private.") from error
+        raise LinkError(f"Spotify answered with an error ({error.code}).") from error
+    except (urllib.error.URLError, TimeoutError, OSError) as error:
+        raise LinkError("Can't reach Spotify. Check your connection.") from error
+    tracks = tracks_from_spotify_page(page)
+    if not tracks:
+        raise LinkError("Spotify's page didn't list any songs. The playlist may be private.")
+    return tracks

{cloudspin-0.1.1 → cloudspin-0.2.0}/src/cloudspin/mood.py

@@ -1,11 +1,12 @@
 """Which sky suits a song.
 
-Three sources, in order of trust:
+In order of trust:
 
 1. your own ``[moods]`` rules from the config file,
-2. words in the genre tag, title and album ("phonk", "lofi", "rain", ...),
-3. a short listen: 30 seconds decoded with ffmpeg and measured for loudness,
-   tempo, bass weight and brightness. This last one is a rough guess.
+2. how the song sounds: 30 seconds are decoded (by mpv, or ffmpeg for files)
+   and measured for rhythm, brightness, bass weight and loudness,
+3. words in the genre tag, title and album ("phonk", "lofi", "rain", ...),
+   which also give an instant first guess while the listening happens.
 
 If none of them says anything, the sky goes back to showing the real weather.
 """
@@ -17,8 +18,10 @@ import re
 import shutil
 import subprocess
 import sys
+import tempfile
 from array import array
 from dataclasses import dataclass
+from pathlib import Path
 
 from .sky import Daylight, Weather
 
@@ -55,7 +58,7 @@ class Mood:
 
 # A trailing * matches any ending ("melanchol*" matches "melancholy").
 _GENRES: list[tuple[str, tuple[str, ...]]] = [
-    ("storm", ("phonk", "metal", "metalcore", "deathcore", "hardstyle", "hardcore", "drill", "dubstep",
+    ("storm", ("phonk", "hoodtrap", "hood trap", "trap metal", "rage", "bass boosted", "metal", "metalcore", "deathcore", "hardstyle", "hardcore", "drill", "dubstep",
                "drum and bass", "drum & bass", "dnb", "industrial", "rage", "grindcore", "punk",
                "breakcore", "gabber", "riddim", "hard rock", "thrash", "screamo")),
     ("rain", ("blues", "emo", "sad", "melanchol*", "grunge", "slowcore", "doom")),
@@ -75,7 +78,7 @@ _GENRES: list[tuple[str, tuple[str, ...]]] = [
 
 # Only words that plainly name a sky are trusted in titles and album names.
 _TITLES: list[tuple[str, tuple[str, ...]]] = [
-    ("storm", ("phonk", "thunder*", "storm*", "lightning", "hurricane", "tempest")),
+    ("storm", ("phonk", "hoodtrap", "hood trap", "bass boosted", "thunder*", "storm*", "lightning", "hurricane", "tempest")),
     ("rain", ("rain*", "monsoon", "petrichor", "drizzle", "downpour", "tears", "umbrella")),
     ("snow", ("snow*", "winter", "christmas", "xmas", "frost*", "blizzard", "icicle*")),
     ("fog", ("fog*", "mist*", "haze", "hazy", "smoke")),
@@ -96,16 +99,26 @@ _GENRE_RULES = [(scene, word, _pattern(word)) for scene, words in _GENRES for wo
 _TITLE_RULES = [(scene, word, _pattern(word)) for scene, words in _TITLES for word in words]
 
 
-def from_words(
+def from_rules(
     title: str, artist: str = "", album: str = "", genre: str = "", rules: dict[str, str] | None = None
 ) -> Mood | None:
-    """Guess a sky from what the song is called and how it is tagged."""
-    genre_text = genre.lower()
-    name_text = f"{title} {album}".lower()
+    """Your own ``[moods]`` rules. These always win, even over what the song sounds like."""
     everything = f"{genre} {title} {artist} {album}".lower()
     for word, scene in (rules or {}).items():
         if scene in SCENES and word.strip() and _pattern(word.strip().lower()).search(everything):
             return Mood(scene, f"your rule for “{word.strip()}”")
+    return None
+
+
+def from_words(
+    title: str, artist: str = "", album: str = "", genre: str = "", rules: dict[str, str] | None = None
+) -> Mood | None:
+    """Guess a sky from what the song is called and how it is tagged."""
+    genre_text = genre.lower()
+    name_text = f"{title} {album}".lower()
+    ruled = from_rules(title, artist, album, genre, rules)
+    if ruled is not None:
+        return ruled
     if genre_text.strip():
         # Rules run in order, so "dream pop" is caught as fog before "pop" can claim it.
         for scene, word, pattern in _GENRE_RULES:
@@ -131,10 +144,13 @@ class Features:
 
     @property
     def intensity(self) -> float:
+        """How hard the song hits, 0..1. Rhythm counts for more than volume,
+        because nearly everything is mastered loud."""
         loud = min(1.0, max(0.0, (self.loudness + 28.0) / 18.0))
-        busy = min(1.0, self.onsets / 5.0)
+        busy = min(1.0, self.onsets / 6.0)
+        bright = min(1.0, self.brightness / 0.10)
         fast = min(1.0, max(0.0, (self.tempo - 70.0) / 90.0))
-        return 0.5 * loud + 0.3 * busy + 0.2 * fast
+        return 0.25 * loud + 0.35 * busy + 0.2 * bright + 0.2 * fast
 
 
 def measure(samples, rate: int = 8000) -> Features | None:
@@ -202,41 +218,82 @@ def measure(samples, rate: int = 8000) -> Features | None:
     )
 
 
-def listen(path: str, ffmpeg: str | None = None) -> Features | None:
-    """Decode half a minute from the middle of a file and measure it."""
-    if "://" in path:
-        return None
-    ffmpeg = ffmpeg or shutil.which("ffmpeg")
-    if not ffmpeg:
-        return None
-    raw = b""
-    for start in (40, 0):
+SAMPLE_RATE = 8000
+_ENOUGH = SAMPLE_RATE * 2 * 8  # eight seconds is the least worth measuring
+
+
+def _decode_with_mpv(mpv: str, path: str, ytdlp: str | None, start: int, timeout: float) -> bytes:
+    """Have mpv write 30 seconds of the song as raw samples. Works for links too."""
+    with tempfile.TemporaryDirectory(prefix="cloudspin-listen-") as folder:
+        clip = Path(folder) / "clip.raw"
+        command = [
+            mpv, "--no-config", "--no-terminal", "--no-video", "--ytdl-format=bestaudio/best",
+            f"--start={start}", "--length=30", "--audio-channels=mono", f"--audio-samplerate={SAMPLE_RATE}",
+            "--oac=pcm_s16le", "--of=s16le", f"--o={clip}",
+        ]  # fmt: skip
+        if ytdlp:
+            command.append(f"--script-opts=ytdl_hook-ytdl_path={ytdlp}")
         try:
-            done = subprocess.run(
-                [ffmpeg, "-v", "error", "-nostdin", "-ss", str(start), "-t", "30", "-i", path,
-                 "-vn", "-ac", "1", "-ar", "8000", "-f", "s16le", "-"],
-                stdin=subprocess.DEVNULL, capture_output=True, timeout=25,
+            subprocess.run(
+                [*command, "--", path],
+                stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout,
             )  # fmt: skip
+            return clip.read_bytes()
         except (OSError, subprocess.SubprocessError):
-            return None
-        raw = done.stdout
-        if len(raw) >= 8000 * 2 * 8:
+            return b""
+
+
+def _decode_with_ffmpeg(ffmpeg: str, path: str, start: int) -> bytes:
+    try:
+        done = subprocess.run(
+            [ffmpeg, "-v", "error", "-nostdin", "-ss", str(start), "-t", "30", "-i", path,
+             "-vn", "-ac", "1", "-ar", str(SAMPLE_RATE), "-f", "s16le", "-"],
+            stdin=subprocess.DEVNULL, capture_output=True, timeout=25,
+        )  # fmt: skip
+    except (OSError, subprocess.SubprocessError):
+        return b""
+    return done.stdout
+
+
+def listen(
+    path: str,
+    mpv: str | None = None,
+    ytdlp: str | None = None,
+    ffmpeg: str | None | bool = None,
+) -> Features | None:
+    """Decode half a minute from inside a song and measure it.
+
+    mpv does the decoding when it is given, which covers links as well as
+    files. ffmpeg is the fallback for files; pass ``ffmpeg=False`` to rule it out.
+    """
+    stream = "://" in path
+    if ffmpeg is None:
+        ffmpeg = shutil.which("ffmpeg")
+    raw = b""
+    for start in (40, 0):
+        if mpv:
+            raw = _decode_with_mpv(mpv, path, ytdlp, start, 75 if stream else 30)
+        if len(raw) < _ENOUGH and ffmpeg and not stream:
+            raw = _decode_with_ffmpeg(str(ffmpeg), path, start)
+        if len(raw) >= _ENOUGH:
             break
+    if len(raw) < _ENOUGH:
+        return None
     samples = array("h")
     samples.frombytes(raw[: len(raw) // 2 * 2])
     if sys.byteorder == "big":
         samples.byteswap()
-    return measure(samples, 8000)
+    return measure(samples, SAMPLE_RATE)
 
 
 def from_features(features: Features) -> Mood:
-    """Turn measurements into a sky. Heavy and loud storms; quiet and slow settles."""
+    """Turn measurements into a sky. Busy, bright and bass-heavy storms; slow and soft settles."""
     intensity = features.intensity
-    if intensity >= 0.68:
-        if features.bass >= 0.42:
-            return Mood("storm", "loud, fast and heavy on bass")
+    if intensity >= 0.62:
+        if features.bass >= 0.40:
+            return Mood("storm", "hard-hitting and heavy on bass")
         return Mood("day", "bright and energetic")
-    if intensity >= 0.48:
+    if intensity >= 0.45:
         if features.brightness < 0.06 and features.bass >= 0.35:
             return Mood("rain", "dark and steady")
         return Mood("day", "upbeat")

{cloudspin-0.1.1 → cloudspin-0.2.0}/src/cloudspin/player.py

@@ -26,6 +26,7 @@ class Track:
     album: str = ""
     duration: float = 0.0
     genre: str = ""
+    pinned: bool = False  # the title and artist are already right; don't take them from the stream
 
     @property
     def is_stream(self) -> bool:
@@ -182,6 +183,8 @@ class MpvBackend:
             path = rf"\\.\pipe\cloudspin-{os.getpid()}-{Path(self._dir).name}"
         else:
             path = str(Path(self._dir) / "mpv.sock")
+        self.binary = binary
+        self.ytdlp = ytdlp
         options = list(extra_args)
         if ytdlp:
             # Point mpv at the yt-dlp that was installed with Cloudspin.

{cloudspin-0.1.1 → cloudspin-0.2.0}/src/cloudspin/screens.py

@@ -78,7 +78,7 @@ def city_prompt(current: str = "") -> Prompt:
 def link_prompt() -> Prompt:
     return Prompt(
         "Play from a link",
-        "Paste a link to a song, a radio stream or a video. A file or folder path works too.",
+        "Paste a song, a radio stream, or a YouTube, YouTube Music or Spotify playlist. A file or folder path works too.",
         placeholder="https://",
         confirm="play",
     )
@@ -93,7 +93,7 @@ _KEYS = (
     ("r", "Repeat: off, all, one"),
     ("w", "Sky: follow the song, follow the weather, or pin a scene"),
     ("t", "Colours: follow the sky, follow the cover art, or pick a theme"),
-    ("o", "Open a link, file or folder and play it"),
+    ("o", "Open a link, a playlist, a file or a folder and play it"),
     ("c", "Choose the city for the weather"),
     ("u", "Switch between °C and °F"),
     ("q", "Quit"),

cloudspin-0.2.0/tests/conftest.py

@@ -0,0 +1,13 @@
+import pytest
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "src"))
+sys.path.insert(0, str(ROOT / "tests"))
+
+
+@pytest.fixture(autouse=True)
+def _private_cache(tmp_path, monkeypatch):
+    """Keep tests from reading or writing the real cache folder."""
+    monkeypatch.setenv("XDG_CACHE_HOME", str(tmp_path / "cache"))

cloudspin-0.2.0/tests/test_links.py

@@ -0,0 +1,75 @@
+"""Playlist links: which links count as playlists, and turning what yt-dlp and
+Spotify's page say into songs."""
+
+import json
+
+from cloudspin import links
+from cloudspin.links import is_collection, tracks_from_spotify_page, tracks_from_ytdlp
+
+
+def test_which_links_are_playlists():
+    assert is_collection("https://www.youtube.com/playlist?list=PL123")
+    assert is_collection("https://music.youtube.com/playlist?list=OLAK5uy_abc")
+    assert is_collection("https://www.youtube.com/watch?v=abc&list=PL123")
+    assert is_collection("https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M?si=x")
+    assert is_collection("https://open.spotify.com/intl-de/album/4aawyAB9vmqN3uQ7FjRGTy")
+    assert is_collection("https://soundcloud.com/someone/sets/a-set")
+    assert not is_collection("https://www.youtube.com/watch?v=abc")
+    assert not is_collection("https://example.com/stream.mp3")
+    assert not is_collection("/home/me/Music/playlist")
+
+
+def test_youtube_playlists_become_songs():
+    info = {
+        "_type": "playlist",
+        "entries": [
+            {"id": "aaa", "url": "https://www.youtube.com/watch?v=aaa", "title": "First", "channel": "Band - Topic", "duration": 201},
+            {"id": "bbb", "ie_key": "Youtube", "title": "Second", "uploader": "Someone", "duration": None},
+            {"id": "ccc", "url": "https://www.youtube.com/watch?v=ccc", "title": "[Deleted video]"},
+            None,
+        ],
+    }
+    tracks = tracks_from_ytdlp(info, "https://www.youtube.com/playlist?list=PL1")
+    assert [(t.path, t.title, t.artist, t.duration) for t in tracks] == [
+        ("https://www.youtube.com/watch?v=aaa", "First", "Band", 201.0),
+        ("https://www.youtube.com/watch?v=bbb", "Second", "Someone", 0.0),
+    ]
+    assert not tracks[0].pinned  # the site's own title may still improve on this one
+
+
+def test_a_single_video_is_one_song():
+    info = {"id": "x", "webpage_url": "https://www.youtube.com/watch?v=x", "title": "Solo", "uploader": "Me", "duration": 61}
+    assert [t.title for t in tracks_from_ytdlp(info, "https://www.youtube.com/watch?v=x")] == ["Solo"]
+
+
+def spotify_page(track_list):
+    data = {"props": {"pageProps": {"state": {"data": {"entity": {"type": "playlist", "trackList": track_list}}}}}}
+    return f'<html><script id="__NEXT_DATA__" type="application/json">{json.dumps(data)}</script></html>'
+
+
+def test_spotify_songs_are_matched_on_youtube():
+    page = spotify_page(
+        [
+            {"uri": "spotify:track:1", "title": "Blue Hour", "subtitle": "Nine Volt Garden, Kestrel", "duration": 229000},
+            {"uri": "spotify:track:2", "title": "", "subtitle": "Nobody"},
+        ]
+    )
+    tracks = tracks_from_spotify_page(page)
+    assert len(tracks) == 1
+    song = tracks[0]
+    assert song.path == "ytdl://ytsearch1:Nine Volt Garden, Kestrel - Blue Hour"
+    assert (song.title, song.artist, song.duration) == ("Blue Hour", "Nine Volt Garden, Kestrel", 229.0)
+    assert song.pinned and song.is_stream  # keep Spotify's name, not the video's
+
+
+def test_a_spotify_page_without_songs_gives_nothing():
+    assert tracks_from_spotify_page("<html>nothing here</html>") == []
+    assert tracks_from_spotify_page('<script id="__NEXT_DATA__">{broken</script>') == []
+
+
+def test_expand_explains_failures(monkeypatch):
+    import pytest
+
+    monkeypatch.setattr(links, "_with_ytdlp", lambda link: [])
+    with pytest.raises(links.LinkError, match="empty, private"):
+        links.expand("https://www.youtube.com/playlist?list=PLnothing")

cloudspin-0.2.0/tests/test_network.py

@@ -0,0 +1,40 @@
+"""Checks against the real internet. Only run when CLOUDSPIN_TEST_NETWORK=1,
+and allowed to fail in CI, because other people's servers decide the outcome."""
+
+import os
+
+import pytest
+
+from cloudspin import links, mood, mpvget
+
+pytestmark = pytest.mark.skipif(not os.environ.get("CLOUDSPIN_TEST_NETWORK"), reason="network tests are opt-in")
+
+
+def test_spotify_playlist_lists_its_songs():
+    tracks = links.expand("https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M")
+    print("spotify:", len(tracks), [(t.artist, t.title, t.duration) for t in tracks[:3]])
+    assert len(tracks) >= 10 and all(t.title and t.pinned for t in tracks)
+    assert sum(1 for t in tracks if t.artist) >= len(tracks) // 2
+
+
+def test_ytdlp_reads_a_list_of_results():
+    tracks = links._with_ytdlp("ytsearch3:creative commons lofi music")
+    print("youtube:", [(t.path, t.title, t.artist, t.duration) for t in tracks])
+    assert len(tracks) == 3 and all("://" in t.path for t in tracks)
+
+
+def test_listening_to_a_link():
+    binary = mpvget.find_mpv()
+    if binary is None:
+        pytest.skip("mpv is not installed")
+    import subprocess
+
+    probe = subprocess.run(
+        [binary, "--no-config", "--no-video", "--ao=null", "--length=2", "--msg-level=all=warn,ytdl_hook=debug",
+         f"--script-opts=ytdl_hook-ytdl_path={mpvget.find_ytdlp()}", "ytdl://ytsearch1:creative commons lofi music"],
+        capture_output=True, text=True, timeout=120,
+    )  # fmt: skip
+    print("mpv says:", probe.returncode, (probe.stdout + probe.stderr)[-1500:])
+    features = mood.listen("ytdl://ytsearch1:creative commons lofi music", binary, mpvget.find_ytdlp())
+    print("heard:", features, features and mood.from_features(features))
+    assert features is not None

{cloudspin-0.1.1 → cloudspin-0.2.0}/tests/test_real_mpv.py

@@ -72,6 +72,39 @@ def test_real_mpv_reports_a_file_it_cannot_play(mpv_binary, tmp_path):
         deck.close()
 
 
+def test_mpv_can_do_the_listening_without_ffmpeg(mpv_binary, tmp_path):
+    from cloudspin import mood
+
+    heavy = synth.write_wav(tmp_path / "heavy.wav", synth.heavy(14))
+    soft = synth.write_wav(tmp_path / "soft.wav", synth.gentle(14))
+    heard = mood.listen(str(heavy), mpv_binary, ffmpeg=False)
+    assert heard is not None and heard.bass > 0.6
+    assert mood.from_features(heard).scene == "storm"
+    quiet = mood.listen(str(soft), mpv_binary, ffmpeg=False)
+    assert quiet is not None and mood.from_features(quiet).scene in ("night", "evening")
+    assert mood.listen(str(tmp_path / "missing.wav"), mpv_binary, ffmpeg=False) is None
+
+
+def test_mpv_listens_to_a_link(mpv_binary, tmp_path):
+    """A song served over http, the way a link is, with no outside server involved."""
+    import functools
+    import http.server
+    import threading
+
+    from cloudspin import mood
+
+    synth.write_wav(tmp_path / "heavy.wav", synth.heavy(14))
+    handler = functools.partial(http.server.SimpleHTTPRequestHandler, directory=str(tmp_path))
+    handler.log_message = lambda *args: None
+    server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), handler)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    try:
+        heard = mood.listen(f"http://127.0.0.1:{server.server_address[1]}/heavy.wav", mpv_binary, mpvget.find_ytdlp())
+    finally:
+        server.shutdown()
+    assert heard is not None and mood.from_features(heard).scene == "storm"
+
+
 def test_ytdlp_ships_with_cloudspin():
     assert mpvget.find_ytdlp() is not None
 

cloudspin-0.1.1/tests/conftest.py

@@ -1,6 +0,0 @@
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(ROOT / "src"))
-sys.path.insert(0, str(ROOT / "tests"))