cloudspin 0.1.0__tar.gz → 0.1.1__tar.gz

cloudspin-0.1.1/.github/workflows/ci.yml

@@ -0,0 +1,37 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        python: ["3.11", "3.12", "3.13"]
+        include:
+          - os: windows-latest
+            python: "3.12"
+          - os: macos-latest
+            python: "3.12"
+    env:
+      # On Windows the tests download mpv the same way a first run does.
+      CLOUDSPIN_TEST_DOWNLOAD: "1"
+      PYTHONUTF8: "1"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - name: Install mpv and ffmpeg (Linux)
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends mpv ffmpeg
+      - name: Install mpv and ffmpeg (macOS)
+        if: runner.os == 'macOS'
+        run: brew install mpv ffmpeg
+      - run: pip install -e ".[dev]"
+      - run: pytest -q -rs

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cloudspin
-Version: 0.1.0
+Version: 0.1.1
 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
@@ -12,6 +12,7 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
@@ -22,6 +23,7 @@ Requires-Python: >=3.11
 Requires-Dist: mutagen>=1.47
 Requires-Dist: pillow>=10.0
 Requires-Dist: textual>=8.0
+Requires-Dist: yt-dlp
 Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest>=8; extra == 'dev'
@@ -53,26 +55,29 @@ synthwave turns the stars on.
 
 ## Install
 
-Cloudspin is not on PyPI, the AUR or npm yet. Until it is, install it from this repository:
+Pick whichever you already have:
 
 ```sh
-pipx install git+https://github.com/itsHarshDabas/Cloudspin
-# or
-uv tool install git+https://github.com/itsHarshDabas/Cloudspin
+pipx install cloudspin        # Python
+uv tool install cloudspin     # uv
+npm install -g cloudspin      # npm (a launcher; it runs the Python app through uv or pipx)
 ```
 
-You also need `mpv` for sound. Two more tools are optional:
+Or try it without installing: `uvx cloudspin --demo` or `npx cloudspin --demo`.
 
-| Tool | Why |
-| --- | --- |
-| `mpv` | Plays the music. Without it Cloudspin runs silently. |
-| `ffmpeg` | Lets Cloudspin listen to songs that have no genre tag, to guess a sky. |
-| `yt-dlp` | Lets mpv play YouTube, SoundCloud and similar links. |
+Works on Linux, macOS and Windows, with Python 3.11 or newer and a truecolor
+terminal (Windows Terminal, kitty, foot, Alacritty, WezTerm, Ghostty, iTerm2
+and most others).
+
+### What comes with it
 
-On Arch: `sudo pacman -S mpv ffmpeg yt-dlp`.
+| Tool | What it's for | How you get it |
+| --- | --- | --- |
+| `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 |
 
-Needs Python 3.11 or newer, Linux or macOS, and a terminal with truecolor
-(kitty, foot, Alacritty, WezTerm, Ghostty, iTerm2 and most others).
+Without mpv Cloudspin still runs, silently, and tells you the command to install it.
 
 ## Use
 
@@ -85,6 +90,8 @@ cloudspin --city "New Delhi"    # set the city once; it is remembered
 cloudspin --demo                # look around without any music or sound
 ```
 
+No music folder? Start `cloudspin`, press `o` and paste a link.
+
 ### Keys
 
 | Key | Does |
@@ -161,23 +168,25 @@ Built-in themes: `sky`, `cover`, `amber`, `orchid`, `lagoon`, `moss`, `rose`, `m
 - **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.
-- **Links need mpv.** Plain audio URLs and radio streams work with mpv alone.
-  Sites like YouTube also need `yt-dlp`.
-- **Windows is not supported** except through WSL: playback control uses a
-  Unix socket.
-- **MPRIS** (media keys, `playerctl`, Waybar) works if you have the
+- **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.
+- **Windows** uses the mpv that Cloudspin downloads for itself unless `mpv` is
+  already on your PATH.
+- **MPRIS** (media keys, `playerctl`, Waybar) works on Linux if you have the
   `mpv-mpris` plugin installed for mpv; Cloudspin loads your normal mpv config.
 
-## Packaging status
+## Releases
 
 | Channel | Status |
 | --- | --- |
-| Git (`pipx`, `uv`) | Works today |
-| PyPI and npm | Published by `.github/workflows/release.yml` when a `v*` tag is pushed. Setup steps are at the top of that file. |
-| AUR | `packaging/aur/PKGBUILD` is written; it builds from the PyPI release |
+| [PyPI](https://pypi.org/project/cloudspin/) | Published |
+| [npm](https://www.npmjs.com/package/cloudspin) | Published (launcher for the Python app) |
+| AUR | `packaging/aur/PKGBUILD` is written, not submitted yet |
 | Homebrew | Not started |
 
-The npm package is a small launcher that runs the Python app through `uv` or `pipx`.
+Pushing a `v*` tag runs `.github/workflows/release.yml`, which tests, then
+publishes to PyPI and npm.
 
 ## Develop
 
@@ -199,6 +208,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 |
+| `mpvget.py` | Finding mpv and yt-dlp; the Windows mpv download |
 | `widgets.py`, `app.py` | The interface |
 
 ## Licence

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

@@ -24,26 +24,29 @@ synthwave turns the stars on.
 
 ## Install
 
-Cloudspin is not on PyPI, the AUR or npm yet. Until it is, install it from this repository:
+Pick whichever you already have:
 
 ```sh
-pipx install git+https://github.com/itsHarshDabas/Cloudspin
-# or
-uv tool install git+https://github.com/itsHarshDabas/Cloudspin
+pipx install cloudspin        # Python
+uv tool install cloudspin     # uv
+npm install -g cloudspin      # npm (a launcher; it runs the Python app through uv or pipx)
 ```
 
-You also need `mpv` for sound. Two more tools are optional:
+Or try it without installing: `uvx cloudspin --demo` or `npx cloudspin --demo`.
 
-| Tool | Why |
-| --- | --- |
-| `mpv` | Plays the music. Without it Cloudspin runs silently. |
-| `ffmpeg` | Lets Cloudspin listen to songs that have no genre tag, to guess a sky. |
-| `yt-dlp` | Lets mpv play YouTube, SoundCloud and similar links. |
+Works on Linux, macOS and Windows, with Python 3.11 or newer and a truecolor
+terminal (Windows Terminal, kitty, foot, Alacritty, WezTerm, Ghostty, iTerm2
+and most others).
+
+### What comes with it
 
-On Arch: `sudo pacman -S mpv ffmpeg yt-dlp`.
+| Tool | What it's for | How you get it |
+| --- | --- | --- |
+| `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 |
 
-Needs Python 3.11 or newer, Linux or macOS, and a terminal with truecolor
-(kitty, foot, Alacritty, WezTerm, Ghostty, iTerm2 and most others).
+Without mpv Cloudspin still runs, silently, and tells you the command to install it.
 
 ## Use
 
@@ -56,6 +59,8 @@ cloudspin --city "New Delhi"    # set the city once; it is remembered
 cloudspin --demo                # look around without any music or sound
 ```
 
+No music folder? Start `cloudspin`, press `o` and paste a link.
+
 ### Keys
 
 | Key | Does |
@@ -132,23 +137,25 @@ Built-in themes: `sky`, `cover`, `amber`, `orchid`, `lagoon`, `moss`, `rose`, `m
 - **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.
-- **Links need mpv.** Plain audio URLs and radio streams work with mpv alone.
-  Sites like YouTube also need `yt-dlp`.
-- **Windows is not supported** except through WSL: playback control uses a
-  Unix socket.
-- **MPRIS** (media keys, `playerctl`, Waybar) works if you have the
+- **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.
+- **Windows** uses the mpv that Cloudspin downloads for itself unless `mpv` is
+  already on your PATH.
+- **MPRIS** (media keys, `playerctl`, Waybar) works on Linux if you have the
   `mpv-mpris` plugin installed for mpv; Cloudspin loads your normal mpv config.
 
-## Packaging status
+## Releases
 
 | Channel | Status |
 | --- | --- |
-| Git (`pipx`, `uv`) | Works today |
-| PyPI and npm | Published by `.github/workflows/release.yml` when a `v*` tag is pushed. Setup steps are at the top of that file. |
-| AUR | `packaging/aur/PKGBUILD` is written; it builds from the PyPI release |
+| [PyPI](https://pypi.org/project/cloudspin/) | Published |
+| [npm](https://www.npmjs.com/package/cloudspin) | Published (launcher for the Python app) |
+| AUR | `packaging/aur/PKGBUILD` is written, not submitted yet |
 | Homebrew | Not started |
 
-The npm package is a small launcher that runs the Python app through `uv` or `pipx`.
+Pushing a `v*` tag runs `.github/workflows/release.yml`, which tests, then
+publishes to PyPI and npm.
 
 ## Develop
 
@@ -170,6 +177,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 |
+| `mpvget.py` | Finding mpv and yt-dlp; the Windows mpv download |
 | `widgets.py`, `app.py` | The interface |
 
 ## Licence

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

@@ -3,15 +3,14 @@
 # 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.0
+pkgver=0.1.1
 pkgrel=1
 pkgdesc="A terminal music player under a living sky: spinning vinyl, real weather, scenes that follow the song"
 arch=('any')
 url="https://github.com/itsHarshDabas/Cloudspin"
 license=('MIT')
-depends=('python' 'python-textual' 'python-mutagen' 'python-pillow' 'mpv')
-optdepends=('ffmpeg: guess a sky for songs with no genre tag'
-            'yt-dlp: play YouTube and similar links')
+depends=('python' 'python-textual' 'python-mutagen' 'python-pillow' 'yt-dlp' 'mpv')
+optdepends=('ffmpeg: guess a sky for songs with no genre tag')
 makedepends=('python-build' 'python-installer' 'python-hatchling')
 source=("https://files.pythonhosted.org/packages/source/c/cloudspin/cloudspin-$pkgver.tar.gz")
 sha256sums=('SKIP')

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

@@ -1,6 +1,6 @@
 {
   "name": "cloudspin",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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.0 → cloudspin-0.1.1}/pyproject.toml

@@ -18,6 +18,7 @@ classifiers = [
     "Intended Audience :: End Users/Desktop",
     "Operating System :: POSIX :: Linux",
     "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -28,6 +29,7 @@ dependencies = [
     "textual>=8.0",
     "mutagen>=1.47",
     "pillow>=10.0",
+    "yt-dlp",
 ]
 
 [project.optional-dependencies]

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

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

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

@@ -26,11 +26,28 @@ def build_parser() -> argparse.ArgumentParser:
     return parser
 
 
+def _fetch_mpv(mpvget) -> str | None:
+    """First run on Windows: download mpv, showing progress on the plain terminal."""
+    print("Cloudspin plays sound through mpv. Downloading it once (about 30 MB)...")
+
+    def progress(done: int, total: int) -> None:
+        if total:
+            print(f"\r  {done * 100 // total:3d}%", end="", flush=True)
+
+    try:
+        binary = mpvget.download_mpv(progress)
+    except mpvget.MpvInstallError as error:
+        print(f"\n{error}\nStarting without sound. You can install mpv yourself from https://mpv.io")
+        return None
+    print("\r  done.")
+    return binary
+
+
 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, weather
+    from . import library, mood, mpvget, weather
     from .app import CloudspinApp
     from .config import Config
     from .player import DEMO_TRACKS, BackendError, Deck, DemoBackend, MpvBackend
@@ -71,19 +88,25 @@ def main(argv: list[str] | None = None) -> int:
     else:
         sources = args.music or [config.music]
         tracks = library.scan(sources)
+        try:
+            binary = mpvget.find_mpv()
+            if binary is None and mpvget.WINDOWS:
+                binary = _fetch_mpv(mpvget)
+            if binary is None:
+                raise BackendError(f"mpv isn't installed, so there's no sound. Get it with: {mpvget.install_hint()}")
+            backend = MpvBackend(volume=config.volume, binary=binary, ytdlp=mpvget.find_ytdlp())
+        except BackendError as error:
+            backend = DemoBackend()
+            silent_reason = "No sound"
+            notice = str(error)
         if not tracks:
             where = ", ".join(str(Path(s).expanduser()) if "://" not in s else s for s in sources)
-            tracks = [type(t)(**vars(t)) for t in DEMO_TRACKS]
-            backend = DemoBackend()
-            silent_reason = "Silent demo"
-            notice = f"No music found in {where}. Showing a silent demo; start with: cloudspin <folder>"
-        else:
-            try:
-                backend = MpvBackend(volume=config.volume)
-            except BackendError as error:
-                backend = DemoBackend()
-                silent_reason = "No sound"
-                notice = str(error)
+            if backend.silent:
+                tracks = [type(t)(**vars(t)) for t in DEMO_TRACKS]
+                silent_reason = "Silent demo"
+                notice = notice or f"No music found in {where}. Showing a silent demo; start with: cloudspin <folder>"
+            else:
+                notice = f"No music found in {where}. Press o to play a link, a file or a folder"
 
     deck = Deck(backend, tracks, volume=config.volume)
     app = CloudspinApp(config, deck, silent_reason=silent_reason, notice=notice)

cloudspin-0.1.1/src/cloudspin/mpvget.py

@@ -0,0 +1,119 @@
+"""Finding mpv and yt-dlp, and fetching mpv on Windows where there is no
+package manager to lean on.
+
+yt-dlp comes with Cloudspin as a Python dependency. mpv is a separate program:
+on Linux and macOS it comes from the system's package manager; on Windows
+Cloudspin downloads a build once into its cache folder.
+"""
+
+from __future__ import annotations
+
+import json
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+from collections.abc import Callable
+from pathlib import Path
+
+from . import __version__
+from .config import cache_dir
+
+WINDOWS = sys.platform == "win32"
+RELEASES = "https://api.github.com/repos/shinchiro/mpv-winbuild-cmake/releases/latest"
+
+
+class MpvInstallError(Exception):
+    """mpv could not be fetched; the message is written for the user."""
+
+
+def _bundled_mpv() -> Path:
+    return cache_dir() / "mpv" / "mpv.exe"
+
+
+def find_mpv() -> str | None:
+    """mpv from the PATH, or the copy Cloudspin downloaded earlier."""
+    found = shutil.which("mpv")
+    if found:
+        return found
+    if WINDOWS and _bundled_mpv().exists():
+        return str(_bundled_mpv())
+    return None
+
+
+def find_ytdlp() -> str | None:
+    """yt-dlp from the same Python environment as Cloudspin, or from the PATH."""
+    name = "yt-dlp.exe" if WINDOWS else "yt-dlp"
+    beside = Path(sys.executable).parent / name
+    if beside.exists():
+        return str(beside)
+    return shutil.which("yt-dlp")
+
+
+def install_hint() -> str:
+    """The command that installs mpv on this machine, as far as can be told."""
+    if sys.platform == "darwin":
+        return "brew install mpv"
+    for tool, command in (
+        ("pacman", "sudo pacman -S mpv"),
+        ("apt", "sudo apt install mpv"),
+        ("dnf", "sudo dnf install mpv"),
+        ("zypper", "sudo zypper install mpv"),
+    ):
+        if shutil.which(tool):
+            return command
+    return "install mpv with your package manager"
+
+
+def _asset_pattern() -> re.Pattern[str]:
+    arch = "aarch64" if platform.machine().lower() in ("arm64", "aarch64") else "x86_64"
+    return re.compile(rf"^mpv-{arch}-\d{{8}}-git-[0-9a-f]+\.7z$")
+
+
+def _open(url: str):
+    request = urllib.request.Request(url, headers={"User-Agent": f"cloudspin/{__version__}"})
+    return urllib.request.urlopen(request, timeout=30)
+
+
+def download_mpv(progress: Callable[[int, int], None] | None = None) -> str:
+    """Windows only: download mpv into the cache folder and return its path."""
+    target = _bundled_mpv()
+    folder = target.parent
+    try:
+        with _open(RELEASES) as response:
+            release = json.loads(response.read().decode("utf-8"))
+        pattern = _asset_pattern()
+        asset = next((a for a in release.get("assets", []) if pattern.match(a.get("name", ""))), None)
+        if asset is None:
+            raise MpvInstallError("No mpv build for this computer was found to download.")
+        folder.mkdir(parents=True, exist_ok=True)
+        archive = folder / "mpv.7z"
+        total = int(asset.get("size") or 0)
+        done = 0
+        with _open(asset["browser_download_url"]) as response, open(archive, "wb") as out:
+            while True:
+                chunk = response.read(256 * 1024)
+                if not chunk:
+                    break
+                out.write(chunk)
+                done += len(chunk)
+                if progress is not None:
+                    progress(done, total)
+    except (urllib.error.URLError, TimeoutError, OSError, ValueError, KeyError) as error:
+        raise MpvInstallError(f"mpv couldn't be downloaded ({error}).") from error
+    # Windows 10 and later ship a tar that reads 7z archives.
+    try:
+        subprocess.run(
+            ["tar", "-xf", str(archive), "-C", str(folder)],
+            check=True, stdin=subprocess.DEVNULL, capture_output=True, timeout=300,
+        )  # fmt: skip
+    except (OSError, subprocess.SubprocessError) as error:
+        raise MpvInstallError("mpv was downloaded but couldn't be unpacked.") from error
+    finally:
+        archive.unlink(missing_ok=True)
+    if not target.exists():
+        raise MpvInstallError("mpv was downloaded but mpv.exe wasn't inside.")
+    return str(target)

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

@@ -5,10 +5,12 @@ backend, and the ``Deck`` that turns either into a queue with shuffle and repeat
 from __future__ import annotations
 
 import json
+import os
 import random
 import shutil
 import socket
 import subprocess
+import sys
 import tempfile
 import threading
 import time
@@ -87,13 +89,79 @@ class DemoBackend:
         self.alive = False
 
 
+class _SocketLink:
+    """mpv's control channel on Linux and macOS: a unix socket."""
+
+    def __init__(self, path: str) -> None:
+        self._sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        try:
+            self._sock.connect(path)
+        except OSError:
+            self._sock.close()
+            raise
+
+    def send(self, data: bytes) -> None:
+        self._sock.sendall(data)
+
+    def receive(self) -> bytes:
+        """Block until data arrives; empty bytes means mpv hung up."""
+        return self._sock.recv(65536)
+
+    def close(self) -> None:
+        try:
+            self._sock.close()
+        except OSError:
+            pass
+
+
+class _PipeLink:
+    """mpv's control channel on Windows: a named pipe.
+
+    A blocking read on a pipe handle would hold up writes from other threads,
+    so this only reads what PeekNamedPipe says is already waiting.
+    """
+
+    def __init__(self, path: str) -> None:
+        import msvcrt
+
+        self._file = open(path, "r+b", buffering=0)
+        self._handle = msvcrt.get_osfhandle(self._file.fileno())
+        self._closed = False
+
+    def send(self, data: bytes) -> None:
+        self._file.write(data)
+
+    def receive(self) -> bytes:
+        import _winapi
+
+        while not self._closed:
+            waiting = _winapi.PeekNamedPipe(self._handle, 0)[0]
+            if waiting:
+                return self._file.read(waiting) or b""
+            time.sleep(0.02)
+        return b""
+
+    def close(self) -> None:
+        self._closed = True
+        try:
+            self._file.close()
+        except OSError:
+            pass
+
+
 class MpvBackend:
     """Plays audio by running mpv in the background and talking to its IPC socket."""
 
     name = "mpv"
     silent = False
 
-    def __init__(self, volume: int = 70, binary: str | None = None) -> None:
+    def __init__(
+        self,
+        volume: int = 70,
+        binary: str | None = None,
+        ytdlp: str | None = None,
+        extra_args: tuple[str, ...] = (),
+    ) -> None:
         self.position = 0.0
         self.duration = 0.0
         self.media_title = ""
@@ -102,7 +170,7 @@ class MpvBackend:
         self._ended = False
         self._error = ""
         self._lock = threading.Lock()
-        self._sock: socket.socket | None = None
+        self._sock: _SocketLink | _PipeLink | None = None
         self._dir = ""
         self._process: subprocess.Popen | None = None
 
@@ -110,7 +178,14 @@ class MpvBackend:
         if not binary:
             raise BackendError("mpv isn't installed, so there's no sound yet. Install mpv and start Cloudspin again.")
         self._dir = tempfile.mkdtemp(prefix="cloudspin-")
-        path = str(Path(self._dir) / "mpv.sock")
+        if sys.platform == "win32":
+            path = rf"\\.\pipe\cloudspin-{os.getpid()}-{Path(self._dir).name}"
+        else:
+            path = str(Path(self._dir) / "mpv.sock")
+        options = list(extra_args)
+        if ytdlp:
+            # Point mpv at the yt-dlp that was installed with Cloudspin.
+            options.append(f"--script-opts=ytdl_hook-ytdl_path={ytdlp}")
         try:
             self._process = subprocess.Popen(
                 [
@@ -122,6 +197,7 @@ class MpvBackend:
                     "--keep-open=no",
                     f"--volume={int(volume)}",
                     f"--input-ipc-server={path}",
+                    *options,
                 ],
                 stdin=subprocess.DEVNULL,
                 stdout=subprocess.DEVNULL,
@@ -143,13 +219,10 @@ class MpvBackend:
             if self._process is not None and self._process.poll() is not None:
                 break
             try:
-                sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-                sock.connect(path)
-                self._sock = sock
+                self._sock = _PipeLink(path) if sys.platform == "win32" else _SocketLink(path)
                 return
             except OSError as error:
                 last = error
-                sock.close()
                 time.sleep(0.05)
         self.close()
         raise BackendError("mpv started but didn't open its control socket.") from last
@@ -161,7 +234,7 @@ class MpvBackend:
         data = (json.dumps({"command": command}) + "\n").encode("utf-8")
         try:
             with self._lock:
-                sock.sendall(data)
+                sock.send(data)
         except OSError:
             self.alive = False
 
@@ -170,7 +243,7 @@ class MpvBackend:
         buffer = b""
         while sock is not None:
             try:
-                chunk = sock.recv(65536)
+                chunk = sock.receive()
             except OSError:
                 break
             if not chunk:
@@ -250,13 +323,10 @@ class MpvBackend:
         self.alive = False
         if self._sock is not None:
             try:
-                self._sock.sendall(b'{"command": ["quit"]}\n')
-            except OSError:
-                pass
-            try:
-                self._sock.close()
+                self._sock.send(b'{"command": ["quit"]}\n')
             except OSError:
                 pass
+            self._sock.close()
             self._sock = None
         if self._process is not None:
             try:

{cloudspin-0.1.0 → cloudspin-0.1.1}/src/cloudspin/widgets.py

@@ -274,7 +274,8 @@ class SkyView(Pixels):
     def _write_big(self, texts: dict[int, RowText], report: Report, x0: int, room: int) -> int:
         name = fit(report.place.label, min(room, 30))
         used = lay_text(texts, x0, 1, name, INK, True)
-        when = f"{report.local_now():%a %-d %b  %H:%M}"
+        now = report.local_now()
+        when = f"{now:%a} {now.day} {now:%b}  {now:%H:%M}"  # %-d is not portable to Windows
         if used + 3 + len(when) <= min(room, 52):
             used += 3 + lay_text(texts, x0 + used + 3, 1, when, INK_SOFT)
         number = str(round(report.temperature))
@@ -387,7 +388,7 @@ class NowPlaying(Painted):
         lines: list[list[Segment]] = []
         if track is None:
             title = "Nothing on the platter"
-            second = "Press space to start playing" if deck.tracks else "Start Cloudspin with a music folder to fill the queue"
+            second = "Press space to start playing" if deck.tracks else "Press o to play a link, a file or a folder"
             third = ""
         else:
             title = track.title

{cloudspin-0.1.0 → cloudspin-0.1.1}/tests/test_player.py

@@ -131,7 +131,7 @@ def mpv():
     backend.close()
 
 
-@pytest.mark.skipif(sys.platform == "win32", reason="mpv is driven over a unix socket")
+@pytest.mark.skipif(sys.platform == "win32", reason="the stand-in mpv speaks over a unix socket")
 def test_mpv_backend_speaks_the_protocol(mpv):
     backend, commands = mpv
     deck = Deck(backend, [Track("/music/one.flac", "one"), Track("/music/two.flac", "two")], volume=55)
@@ -151,7 +151,7 @@ def test_mpv_backend_speaks_the_protocol(mpv):
     assert wait_for(lambda: backend.position == 31.25)
 
 
-@pytest.mark.skipif(sys.platform == "win32", reason="mpv is driven over a unix socket")
+@pytest.mark.skipif(sys.platform == "win32", reason="the stand-in mpv speaks over a unix socket")
 def test_mpv_backend_moves_on_at_the_end_and_stops_on_errors(mpv):
     backend, _ = mpv
     deck = Deck(backend, [Track("/music/short.mp3", "short"), Track("https://example.com/missing", "link"), Track("/c.mp3", "c")])

cloudspin-0.1.1/tests/test_real_mpv.py

@@ -0,0 +1,80 @@
+"""Playback against a real mpv, with the sound thrown away.
+
+Skipped when mpv isn't installed. On Windows CI, CLOUDSPIN_TEST_DOWNLOAD=1 makes
+this download mpv first, which also checks the downloader end to end.
+"""
+
+import os
+import sys
+import time
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent))
+import synth  # noqa: E402
+
+from cloudspin import mpvget  # noqa: E402
+from cloudspin.player import Deck, MpvBackend, Track  # noqa: E402
+
+
+@pytest.fixture(scope="module")
+def mpv_binary():
+    binary = mpvget.find_mpv()
+    if binary is None and mpvget.WINDOWS and os.environ.get("CLOUDSPIN_TEST_DOWNLOAD"):
+        binary = mpvget.download_mpv()
+        assert Path(binary).exists() and mpvget.find_mpv() == binary
+    if binary is None:
+        pytest.skip("mpv is not installed")
+    return binary
+
+
+def wait_for(check, seconds=15.0):
+    end = time.monotonic() + seconds
+    while time.monotonic() < end:
+        if check():
+            return True
+        time.sleep(0.05)
+    return False
+
+
+def test_real_mpv_plays_seeks_pauses_and_moves_on(mpv_binary, tmp_path):
+    first, second = tmp_path / "first song.wav", tmp_path / "second.wav"
+    synth.write_wav(first, synth.gentle()[: 8000 * 4])
+    synth.write_wav(second, synth.gentle()[: 8000 * 4])
+    backend = MpvBackend(volume=40, binary=mpv_binary, extra_args=("--ao=null", "--no-config"))
+    deck = Deck(backend, [Track(str(first), "first"), Track(str(second), "second")])
+    try:
+        deck.play(0)
+        assert wait_for(lambda: 3.5 < backend.duration < 4.5), "mpv should report the length"
+        assert wait_for(lambda: backend.position > 0.3), "time should move while playing"
+        deck.toggle()
+        time.sleep(0.4)
+        held = backend.position
+        time.sleep(0.5)
+        assert abs(backend.position - held) < 0.15, "time should stop while paused"
+        deck.toggle()
+        deck.seek_to(0.8)
+        assert wait_for(lambda: backend.position > 2.5), "seeking should jump ahead"
+        assert wait_for(lambda: (deck.tick(), deck.index == 1)[1]), "the next song should start at the end"
+        assert backend.alive
+    finally:
+        deck.close()
+
+
+def test_real_mpv_reports_a_file_it_cannot_play(mpv_binary, tmp_path):
+    backend = MpvBackend(binary=mpv_binary, extra_args=("--ao=null", "--no-config"))
+    deck = Deck(backend, [Track(str(tmp_path / "missing.mp3"), "missing")])
+    try:
+        deck.play(0)
+        assert wait_for(lambda: (deck.tick(), deck.failure != "")[1])
+    finally:
+        deck.close()
+
+
+def test_ytdlp_ships_with_cloudspin():
+    assert mpvget.find_ytdlp() is not None
+
+
+def test_install_hint_names_a_command():
+    assert "mpv" in mpvget.install_hint()

cloudspin-0.1.0/.github/workflows/ci.yml

@@ -1,23 +0,0 @@
-name: Tests
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        python: ["3.11", "3.12", "3.13"]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python }}
-      - name: Install ffmpeg (used to listen to songs)
-        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends ffmpeg
-      - run: pip install -e ".[dev]"
-      - run: pytest -q