TidalCycles Mini-Notation Pattern Visualiser

Math essence

parse(pattern) -> cycles[[ev]], steps_per_cycle. For each (r, s, sample, variant): radius = min(row_h, col_w) * 0.36; (cx, cy) = (margin + (s+0.5) * col_w - scroll_x, margin + (r+0.5) * row_h); scroll_x = (tick * 0.6) mod (steps * col_w); hue = HSV2RGB(HSV(palette[sample]) + variant * 0.06); dot(cx, cy, r) = 1 - clip(dist2 / r^2, 0, 1); halo(dist in [r, r+2]) = 0.35; canvas = max(canvas, body*color + halo*color).

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/live_coding_synth/TidalCyclesPattern/reference.py

"""TidalCyclesPattern — Alex McLean's TidalCycles rhythm language in numpy.

A minimal Tidal mini-notation parser that expands a pattern string
into a list of (step, sample_name) events, then visualises the
result as a row of pulsing shapes — one shape per fired sample.

Supported mini-notation (a strict subset of TidalCycles):

    bd                  one event
    ~                   rest
    bd sn hh cp         four events
    [bd sn] hh          sub-grouping (euclidean-ish)
    bd*2                repeat (speeds up by 2)
    bd/2                slow down by 2
    bd:3                sample variant
    bd*2 sn:1           combine
    <bd sn hh>          step-wise alternation (rotates per cycle)
    bd, sn, hh          parallel stacks (each becomes its own row)

Pattern expansion follows Tidal's "step → step / speed" rule:

    "a*b"  ->  a expanded to b copies within the same step
    "a/b"  ->  a expanded to 1 copy taking b steps

Visualisation: each row is a timeline of `steps_per_cycle` cells.
Every step shows a small filled circle whose radius scales with
the sample's index, hue is sampled from a 4-stop palette, and a
1-cell glow halo is drawn for the four canonical "beat" samples
(bd, sn, hh, cp). The whole canvas drifts horizontally with the
current cycle count so the pattern rolls like a TR-8.
"""

from __future__ import annotations

import re
from dataclasses import dataclass
from typing import ClassVar

import numpy as np


# ---------------------------------------------------------------------------
# Mini-notation parser
# ---------------------------------------------------------------------------

_TOKEN_RE = re.compile(
    r"""
    \s+                                  |   # whitespace
    (?P<rest>\~)                         |
    (?P<lbrack>\[)                       |
    (?P<rbrack>\])                       |
    (?P<langle>\<)                       |
    (?P<rangle>\>)                       |
    (?P<comma>,)                         |
    (?P<star>\*)                         |
    (?P<slash>/)                         |
    (?P<colon>\:)                        |
    (?P<number>[0-9]+(?:\.[0-9]+)?)      |
    (?P<word>[A-Za-z_][A-Za-z0-9_]*)     |
    (?P<bang>\!)