cloudspin 0.1.0__py3-none-any.whl

cloudspin/songlook.py

@@ -0,0 +1,116 @@
+"""The look of a song: a background and two accents pulled from its cover art.
+
+Songs without art still get a look of their own, derived from the album or
+title, so the deck changes colour whenever the music does.
+"""
+
+from __future__ import annotations
+
+import colorsys
+import hashlib
+import io
+from dataclasses import dataclass
+
+from .color import RGB
+
+THUMB = 24  # the cover is kept as a THUMB x THUMB swatch for the record label
+
+
+@dataclass(frozen=True)
+class SongLook:
+    background: RGB
+    accent: RGB
+    accent2: RGB
+    art: bytes | None = None  # THUMB * THUMB * 3 RGB bytes
+
+
+def _rgb(h: float, s: float, v: float) -> RGB:
+    r, g, b = colorsys.hsv_to_rgb(h % 1.0, max(0.0, min(1.0, s)), max(0.0, min(1.0, v)))
+    return (int(r * 255 + 0.5), int(g * 255 + 0.5), int(b * 255 + 0.5))
+
+
+def _hsv(c: RGB) -> tuple[float, float, float]:
+    return colorsys.rgb_to_hsv(c[0] / 255.0, c[1] / 255.0, c[2] / 255.0)
+
+
+def _hue_gap(a: float, b: float) -> float:
+    d = abs(a - b) % 1.0
+    return min(d, 1.0 - d)
+
+
+def _as_accent(c: RGB, floor: float = 0.84) -> RGB:
+    """Keep a colour's hue but make it bright and calm enough to read on a dark deck."""
+    h, s, v = _hsv(c)
+    return _rgb(h, min(max(s, 0.36), 0.80), min(max(v, floor), 0.98))
+
+
+def from_text(text: str) -> SongLook:
+    digest = hashlib.sha1(text.encode("utf-8", "replace")).digest()
+    hue = digest[0] / 256.0 + digest[1] / 65536.0
+    turn = 0.08 + (digest[2] / 255.0) * 0.10
+    return SongLook(
+        background=_rgb(hue, 0.50, 0.125),
+        accent=_rgb(hue, 0.52, 0.96),
+        accent2=_rgb(hue + turn, 0.58, 0.92),
+    )
+
+
+def from_art(data: bytes) -> SongLook | None:
+    """Read a cover image and pick colours from it. None if it can't be decoded."""
+    try:
+        from PIL import Image
+    except ImportError:
+        return None
+    try:
+        image = Image.open(io.BytesIO(data))
+        image.draft("RGB", (160, 160))
+        image = image.convert("RGB")
+        art = image.resize((THUMB, THUMB), Image.Resampling.LANCZOS).tobytes()
+        small = image.resize((40, 40), Image.Resampling.BILINEAR)
+        quantized = small.quantize(colors=8, method=Image.Quantize.MEDIANCUT)
+        palette = quantized.getpalette() or []
+        counts = quantized.getcolors() or []
+    except Exception:
+        return None
+    total = float(sum(count for count, _ in counts)) or 1.0
+    swatches: list[tuple[float, RGB]] = []
+    for count, index in counts:
+        rgb = tuple(palette[index * 3 : index * 3 + 3])
+        if len(rgb) == 3:
+            swatches.append((count / total, (int(rgb[0]), int(rgb[1]), int(rgb[2]))))
+    if not swatches:
+        return None
+
+    def vivid(entry: tuple[float, RGB]) -> float:
+        share, colour = entry
+        _, s, v = _hsv(colour)
+        if s < 0.16 or v < 0.16:
+            return 0.0
+        return (share**0.35) * s * (0.35 + v)
+
+    dominant = max(swatches, key=lambda entry: entry[0])[1]
+    ranked = sorted(swatches, key=vivid, reverse=True)
+    if vivid(ranked[0]) <= 0.0:
+        # A black-and-white cover: stay monochrome.
+        return SongLook(background=(14, 14, 17), accent=(228, 230, 236), accent2=(152, 158, 172), art=art)
+    first = ranked[0][1]
+    hue = _hsv(first)[0]
+    second = next(
+        (colour for entry in ranked[1:] if vivid(entry) > 0.0 and _hue_gap(_hsv((colour := entry[1]))[0], hue) >= 0.07),
+        None,
+    )
+    accent = _as_accent(first)
+    accent2 = _as_accent(second, 0.78) if second is not None else _rgb(hue + 0.09, 0.58, 0.90)
+    dh, ds, dv = _hsv(dominant)
+    if ds < 0.14:
+        dh, ds = hue, 0.22
+    background = _rgb(dh, min(ds, 0.62) * 0.9, 0.125)
+    return SongLook(background=background, accent=accent, accent2=accent2, art=art)
+
+
+def look_for(title: str, artist: str, album: str, art: bytes | None) -> SongLook:
+    if art:
+        look = from_art(art)
+        if look is not None:
+            return look
+    return from_text(f"{artist}\n{album}" if (artist or album) else title)

cloudspin/spectrum.py

@@ -0,0 +1,83 @@
+"""The bars beside the record.
+
+This is a generative spectrum, not an FFT of the audio: it is driven by the
+play state, the volume and a tempo picked per song, so it moves like music
+without needing access to the sound card.
+"""
+
+from __future__ import annotations
+
+import math
+import random
+
+
+class Spectrum:
+    def __init__(self) -> None:
+        self.levels: list[float] = []
+        self.peaks: list[float] = []
+        self.energy = 0.0
+        self._t = 0.0
+        self._tempo = 110.0
+        self._phases: list[tuple[float, float, float]] = []
+        self._rng = random.Random(1)
+        self._noise: list[float] = []
+
+    def resize(self, bars: int) -> None:
+        bars = max(0, bars)
+        if bars == len(self.levels):
+            return
+        self.levels = [0.0] * bars
+        self.peaks = [0.0] * bars
+        self._noise = [0.0] * bars
+        self._seed_phases()
+
+    def retune(self, seed: str, tempo: float | None = None) -> None:
+        """Give a song its own motion."""
+        self._rng = random.Random(seed)
+        self._tempo = tempo if tempo and 50 <= tempo <= 220 else self._rng.uniform(84, 132)
+        self._seed_phases()
+
+    def _seed_phases(self) -> None:
+        rng = self._rng
+        self._phases = [
+            (rng.uniform(0, math.tau), rng.uniform(0.7, 2.6), rng.uniform(0, math.tau)) for _ in self.levels
+        ]
+
+    def step(self, dt: float, playing: bool, volume: float) -> None:
+        bars = len(self.levels)
+        if not bars:
+            self.energy *= 0.8
+            return
+        self._t += dt
+        t = self._t
+        beat = (t * self._tempo / 60.0) % 1.0
+        kick = math.exp(-5.0 * beat)
+        offbeat = math.exp(-7.0 * ((beat + 0.5) % 1.0))
+        gain = (0.35 + 0.65 * min(1.0, volume)) if playing else 0.0
+        rng = self._rng
+        total = 0.0
+        for i in range(bars):
+            u = i / max(1, bars - 1)
+            a, rate, b = self._phases[i]
+            self._noise[i] += (rng.random() - self._noise[i]) * min(1.0, dt * 9.0)
+            shape = 0.92 - 0.55 * u**0.8
+            body = 0.5 + 0.5 * math.sin(t * rate + a) * math.sin(t * 0.37 * rate + b)
+            low = kick * max(0.0, 1.0 - u * 3.2)
+            mid = offbeat * max(0.0, 1.0 - abs(u - 0.45) * 3.0) * 0.6
+            target = gain * min(1.0, shape * (0.26 + 0.62 * body + 0.34 * self._noise[i]) + 0.6 * low + mid * 0.55)
+            level = self.levels[i]
+            if target > level:
+                level += (target - level) * min(1.0, dt * 22.0)
+            else:
+                level += (target - level) * min(1.0, dt * 6.5)
+            self.levels[i] = level
+            peak = self.peaks[i] - dt * 0.38
+            self.peaks[i] = level if level > peak else max(0.0, peak)
+            if u < 0.3:
+                total += level
+        low_bars = max(1, int(bars * 0.3) + 1)
+        self.energy += (min(1.0, total / low_bars * 1.3) - self.energy) * min(1.0, dt * 14.0)
+
+    @property
+    def still(self) -> bool:
+        return self.energy < 0.004 and all(p < 0.004 for p in self.peaks)

cloudspin/themes.py

@@ -0,0 +1,100 @@
+"""Colour for everything that isn't the sky.
+
+Two themes are alive: ``sky`` takes its colours from whatever the sky is doing,
+and ``cover`` takes them from the playing song's cover art. The rest are fixed
+palettes, and you can add your own under ``[themes.<name>]`` in the config.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .color import RGB, approach, lerp, parse
+
+
+@dataclass(frozen=True)
+class Theme:
+    name: str
+    label: str
+    accent: RGB | None = None
+    accent2: RGB | None = None
+    background: RGB | None = None
+    disc: RGB | None = None  # record label, defaults to the accent
+    disc2: RGB | None = None
+
+
+BUILT_IN: dict[str, Theme] = {
+    theme.name: theme
+    for theme in (
+        Theme("sky", "Colours follow the sky"),
+        Theme("cover", "Colours follow the cover art"),
+        Theme("amber", "Amber", (255, 184, 82), (255, 112, 84), (20, 14, 10)),
+        Theme("orchid", "Orchid", (214, 150, 255), (255, 120, 190), (17, 11, 24)),
+        Theme("lagoon", "Lagoon", (84, 214, 206), (96, 160, 255), (8, 17, 24)),
+        Theme("moss", "Moss", (170, 220, 104), (72, 196, 150), (10, 17, 13)),
+        Theme("rose", "Rose", (255, 140, 150), (255, 196, 140), (22, 12, 15)),
+        Theme("mono", "Mono", (232, 232, 232), (140, 140, 140), (12, 12, 12)),
+    )
+}
+
+
+def load_themes(custom: dict[str, dict[str, str]]) -> dict[str, Theme]:
+    """Built-in themes plus any valid ones from the config file."""
+    themes = dict(BUILT_IN)
+    for name, table in custom.items():
+        if name in ("sky", "cover"):
+            continue
+        try:
+            colours = {
+                key: parse(table[key])
+                for key in ("accent", "accent2", "background", "disc", "disc2")
+                if key in table
+            }
+        except ValueError:
+            continue
+        if "accent" not in colours:
+            continue
+        colours.setdefault("accent2", colours["accent"])
+        themes[name] = Theme(name=name, label=name.capitalize(), **colours)
+    return themes
+
+
+@dataclass
+class Palette:
+    """The colours every widget paints with, resolved for this moment."""
+
+    bg: RGB = (10, 14, 24)
+    accent: RGB = (255, 202, 98)
+    accent2: RGB = (112, 182, 255)
+    disc: RGB = (255, 202, 98)
+    disc2: RGB = (112, 182, 255)
+
+    @property
+    def text(self) -> RGB:
+        return (238, 241, 246)
+
+    @property
+    def soft(self) -> RGB:
+        return lerp(self.bg, self.text, 0.62)
+
+    @property
+    def faint(self) -> RGB:
+        return lerp(self.bg, self.text, 0.34)
+
+    @property
+    def raised(self) -> RGB:
+        return lerp(self.bg, self.text, 0.085)
+
+    @property
+    def lifted(self) -> RGB:
+        return lerp(self.bg, self.text, 0.16)
+
+    def key(self) -> tuple:
+        return (self.bg, self.accent, self.accent2, self.disc, self.disc2)
+
+    def ease_to(self, target: Palette, k: float) -> None:
+        self.bg = approach(self.bg, target.bg, k)
+        self.accent = approach(self.accent, target.accent, k)
+        self.accent2 = approach(self.accent2, target.accent2, k)
+        self.disc = approach(self.disc, target.disc, k)
+        self.disc2 = approach(self.disc2, target.disc2, k)

cloudspin/vinyl.py

@@ -0,0 +1,182 @@
+"""The record: grooves that catch the light, a label that turns, a tonearm that tracks."""
+
+from __future__ import annotations
+
+import math
+
+from .canvas import Canvas
+from .color import RGB, lerp
+from .songlook import THUMB
+
+RPM = 33.333
+_LIGHT = math.radians(-38.0)  # where the sheen sits on the grooves
+
+
+class Vinyl:
+    def __init__(self) -> None:
+        self.w = 0
+        self.h = 0
+        self.angle = 0.0
+        self.speed = 0.0  # 0 stopped .. 1 full speed
+        self.reach = 1.16  # tonearm head, in disc radii from the centre
+        self.cx = 0.0
+        self.cy = 0.0
+        self.radius = 0.0
+        self._groove: list[tuple[int, int, int, float, float, int]] = []
+        self._label: list[tuple[int, float, float, float, int]] = []
+        self._halo: list[tuple[int, int]] = []
+        self._pivot = (0.0, 0.0)
+        self._arm = 0.0
+        self._base = 0.0
+
+    @staticmethod
+    def width_for(pixel_height: int) -> int:
+        """How many columns a record of this height needs, tonearm included."""
+        radius = (pixel_height - 2) / 2.0
+        return int(radius * 2.36) + 6
+
+    def resize(self, w: int, h: int) -> None:
+        if (w, h) == (self.w, self.h):
+            return
+        self.w, self.h = w, h
+        radius = max(3.0, min((h - 2) / 2.0, (w - 6) / 2.36))
+        self.radius = radius
+        self.cx = radius + 2.0
+        self.cy = (h - 1) / 2.0
+        cx, cy = self.cx, self.cy
+        groove, label, halo = [], [], []
+        label_edge = 0.36
+        gaps = (0.53, 0.69, 0.84)
+        for y in range(h):
+            for x in range(w):
+                dx, dy = x - cx, y - cy
+                dist = math.hypot(dx, dy)
+                d = dist / radius
+                i = y * w + x
+                if d > 1.0 + 0.5 / radius:
+                    fall = 1.0 - (d - 1.0) / 0.55
+                    if fall > 0.0:
+                        halo.append((i, int(fall * fall * 256)))
+                    continue
+                theta = math.atan2(dy, dx)
+                if d <= label_edge + 0.5 / radius:
+                    cover = min(1.0, (label_edge - d) * radius + 0.5)
+                    label.append((i, dx / (label_edge * radius), dy / (label_edge * radius), d, int(cover * 256)))
+                    if cover >= 1.0:
+                        continue
+                edge = min(1.0, (1.0 - d) * radius + 0.5)
+                base = 15.0 + 6.0 * math.sin(dist * 2.3)
+                for gap in gaps:
+                    if abs(d - gap) < 0.55 / radius:
+                        base -= 7.0
+                if d > 0.955:
+                    base += 16.0
+                if d < label_edge + 1.2 / radius:
+                    base -= 5.0
+                wedge = max(0.0, math.cos(2.0 * (theta - _LIGHT))) ** 14
+                sheen = wedge * (0.62 + 0.38 * math.sin(math.pi * min(1.0, max(0.0, (d - 0.36) / 0.64))))
+                phase = 3.0 * theta + d * 9.0
+                groove.append((i, int(base), int(sheen * 256), math.sin(phase), math.cos(phase), int(edge * 256)))
+        self._groove, self._label, self._halo = groove, label, halo
+        self._pivot = (cx + radius * 1.0, cy - radius * 0.84)
+        self._arm = radius * 1.25
+        self._base = math.hypot(self._pivot[0] - cx, self._pivot[1] - cy)
+
+    def step(self, dt: float, spinning: bool, loaded: bool, progress: float) -> None:
+        goal = 1.0 if spinning else 0.0
+        rate = 0.45 if spinning else 0.9
+        self.speed += (goal - self.speed) * (1.0 - math.exp(-dt / rate))
+        if abs(goal - self.speed) < 0.004:
+            self.speed = goal
+        self.angle = (self.angle + self.speed * (RPM / 60.0) * math.tau * dt) % math.tau
+        reach = 0.93 - 0.50 * max(0.0, min(1.0, progress)) if loaded else 1.16
+        self.reach += (reach - self.reach) * (1.0 - math.exp(-dt / 0.3))
+
+    @property
+    def moving(self) -> bool:
+        return self.speed > 0.0
+
+    def render(
+        self, cv: Canvas, bg: RGB, label: RGB, label2: RGB, glow: RGB, pulse: float, art: bytes | None = None
+    ) -> None:
+        if cv.w != self.w or cv.h != self.h or not self._groove:
+            return
+        cv.fill(bg)
+        R, G, B = cv.r, cv.g, cv.b
+        br, bg_, bb = bg
+
+        strength = 0.07 + 0.2 * pulse
+        hr, hg, hb = int(glow[0] * strength), int(glow[1] * strength), int(glow[2] * strength)
+        for i, fall in self._halo:
+            R[i] = min(255, br + (hr * fall >> 8))
+            G[i] = min(255, bg_ + (hg * fall >> 8))
+            B[i] = min(255, bb + (hb * fall >> 8))
+
+        turn = 3.0 * self.angle
+        cos_t, sin_t = math.cos(turn), math.sin(turn)
+        tr, tg, tb = glow[0] * 0.30, glow[1] * 0.30, glow[2] * 0.30
+        for i, base, sheen, s3, c3, edge in self._groove:
+            shimmer = s3 * cos_t - c3 * sin_t
+            v = base + shimmer * (2.5 + sheen * 0.085) + sheen * 0.26
+            r = v + (tr * sheen) / 256.0
+            g = v + (tg * sheen) / 256.0
+            b = v + 2.0 + (tb * sheen) / 256.0
+            if edge < 256:
+                r = br + (r - br) * edge / 256.0
+                g = bg_ + (g - bg_) * edge / 256.0
+                b = bb + (b - bb) * edge / 256.0
+            R[i] = 0 if r < 0 else 255 if r > 255 else int(r)
+            G[i] = 0 if g < 0 else 255 if g > 255 else int(g)
+            B[i] = 0 if b < 0 else 255 if b > 255 else int(b)
+
+        ca, sa = math.cos(self.angle), math.sin(self.angle)
+        hole = max(0.05, 1.0 / self.radius)
+        ring = hole * 2.0
+        dark = (10, 10, 13)
+        metal = (176, 180, 190)
+        stripe = lerp(label2, (255, 255, 255), 0.1)
+        rim = lerp(label, (0, 0, 0), 0.32)
+        half = THUMB / 2.0
+        for i, nx, ny, d, cover in self._label:
+            u = nx * ca + ny * sa
+            v = -nx * sa + ny * ca
+            if d < hole:
+                tone = dark
+            elif d < ring:
+                tone = metal
+            elif art is not None:
+                ax = min(THUMB - 1, max(0, int((u * 0.98 + 1.0) * half)))
+                ay = min(THUMB - 1, max(0, int((v * 0.98 + 1.0) * half)))
+                k = (ay * THUMB + ax) * 3
+                tone = (art[k], art[k + 1], art[k + 2])
+                if u * u + v * v > 0.86:
+                    tone = lerp(tone, (0, 0, 0), 0.35)
+            elif u * u + v * v > 0.84:
+                tone = rim
+            elif abs(v) < 0.24 and abs(u) > 0.3:
+                tone = stripe
+            else:
+                tone = label
+            if cover >= 256:
+                R[i], G[i], B[i] = tone
+            else:
+                R[i] += (tone[0] - R[i]) * cover >> 8
+                G[i] += (tone[1] - G[i]) * cover >> 8
+                B[i] += (tone[2] - B[i]) * cover >> 8
+
+        self._paint_arm(cv, glow)
+
+    def _paint_arm(self, cv: Canvas, accent: RGB) -> None:
+        px, py = self._pivot
+        radius, arm, base = self.radius, self._arm, self._base
+        rho = self.reach * radius
+        cos_a = max(-1.0, min(1.0, (base * base + arm * arm - rho * rho) / (2.0 * base * arm)))
+        heading = math.atan2(self.cy - py, self.cx - px) - math.acos(cos_a)
+        ux, uy = math.cos(heading), math.sin(heading)
+        hx, hy = px + ux * arm, py + uy * arm
+        thick = max(1.0, radius * 0.075)
+        cv.line(px - ux * radius * 0.2, py - uy * radius * 0.2, px, py, (112, 116, 128), 256, thick * 2.2)
+        cv.line(px, py, hx, hy, (204, 208, 218), 256, thick)
+        cv.line(hx - ux * radius * 0.17, hy - uy * radius * 0.17, hx, hy, accent, 256, thick * 2.3)
+        cv.disc(px, py, max(1.4, radius * 0.1), (148, 152, 164))
+        cv.disc(px, py, max(0.5, radius * 0.04), (232, 234, 240))