tuney 0.2.0__py3-none-any.whl

tuney/audio/synth_player.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import dataclasses as dc
+import time
+from contextlib import suppress
+from functools import cached_property
+from threading import Thread
+
+import numpy as np
+
+from ..scale.scale import NoteNumber, Scale
+from ..scale.twelve_tet import TWELVE_TET
+from . import Data, Number
+from . import oscillator as osc
+from .device_config import DeviceConfig
+from .player import Player
+
+INTENSITY = 0.1
+FADE = 0  # 0x40000
+OSC = osc.sawtooth
+
+
+# TODO: relieve the tension between human units (frequency, time) and sample units.
+@dc.dataclass(frozen=True)
+class Sound:
+    period: Number = 0x100
+    intensity: Number = INTENSITY
+    fade_in_samples: Number = 0x1000
+    fade_out_samples: Number = 0x1000
+
+
+@dc.dataclass
+class OscillatorPlayer(Player):
+    sound: Sound = dc.field(default_factory=Sound)
+    oscillator: osc.Oscillator = OSC
+
+    _stopping: bool = False
+
+    #: Records the the frame we started to fade out.
+    _fade_frame: Number | None = None
+
+    def stop(self) -> None:
+        if self.sound.fade_out_samples > 0:
+            self._stopping = True
+        else:
+            super().stop()
+
+    def _fill(self, out: Data) -> bool:
+        start = self.frame_count % self.sound.period
+        end = start + len(out)
+        ratio = self.oscillator.period / self.sound.period
+        wave = np.linspace(start * ratio, end * ratio, len(out))
+        wave = self.oscillator.function(wave, out=wave)
+
+        intensity = self.sound.intensity
+        with suppress(ValueError):
+            # Scale up from [-1, 1] for int types only
+            intensity *= np.iinfo(out.dtype).max
+        wave *= intensity
+
+        fade_in = self.sound.fade_in_samples
+        if self.frame_count < fade_in and not self._stopping:
+            _fade(wave, self.frame_count / fade_in, len(out) / fade_in)
+
+        elif self._stopping:
+            if self._fade_frame is None:
+                # Account for the case when we fade out before we've faded in
+                offset = max(0.0, fade_in - self.frame_count)
+                self._fade_frame = self.frame_count - offset
+
+            fade_out = self.sound.fade_out_samples
+            elapsed = self.frame_count - self._fade_frame
+            if (start := 1 - elapsed / fade_out) <= 0:
+                super().stop()
+                return False
+
+            _fade(wave, start, -len(out) / fade_out)
+
+        wave = wave.reshape((len(wave), 1))
+        out[:] = np.asarray(wave, dtype=out.dtype)
+        return True
+
+
+@dc.dataclass(frozen=True)
+class OscillatorController:
+    config: DeviceConfig = dc.field(default_factory=DeviceConfig)
+    oscillator: osc.Oscillator = OSC
+    players: dict[int, OscillatorPlayer] = dc.field(default_factory=dict)
+    scale: Scale = TWELVE_TET
+    start_note_name: str = 'C3'
+
+    def note(self, note_number: NoteNumber, is_press: bool) -> bool:
+        return self.start(note_number) if is_press else self.stop(note_number)
+
+    def start(self, note_number: NoteNumber) -> bool:
+        if note_number in self.players:
+            return False
+        frequency = self.scale.tuning(note_number + self.start_note_number)
+        period = (self.config.samplerate or 48_000) / frequency
+        op = OscillatorPlayer(
+            config=self.config, oscillator=self.oscillator, sound=Sound(period)
+        )
+        Thread(target=op.run).start()
+        self.players[note_number] = op
+        return True
+
+    def stop(self, note_number: NoteNumber) -> bool:
+        if (op := self.players.pop(note_number, None)) is not None:
+            op.stop()
+        return bool(op)
+
+    def stop_all(self) -> None:
+        for player in self.players.values():
+            player.stop()
+        self.players.clear()
+
+    @cached_property
+    def start_note_number(self) -> int:
+        return self.scale.name_to_number(self.start_note_name)
+
+
+def _clamp(x: Number) -> Number:
+    return max(0.0, min(1.0, x))
+
+
+def _fade(wave: Data, start: Number, length: Number) -> None:
+    wave *= np.linspace(_clamp(start), _clamp(start + length), len(wave))
+
+
+def run_many_notes():
+    oc = OscillatorController()
+    DT = 0.2
+
+    stack = []
+    o1 = 'C4', 'E4', 'D5', 'Eb3', 'G3', 'C3', 'E3', 'D4', 'Eb2', 'G2'
+    o2 = 'C2', 'E2', 'D3', 'Eb1', 'G1', 'C1', 'E1', 'D2', 'Eb0', 'G0'
+
+    for name in (o1 + o2)[0]:
+        stack.append(note := TWELVE_TET.name_to_number(name))
+        if not oc.start(note):
+            print('oops', name)
+        time.sleep(DT)
+
+    while stack:
+        if not oc.stop(note := stack.pop()):
+            print('oops off', note)
+        time.sleep(DT / 2)
+
+
+if __name__ == '__main__':
+    run_many_notes()

tuney/keyboard/__init__.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+__all__ = ['KeyAction', 'KeyboardListener', 'KeyboardQueue']
+
+from .key_types import KeyAction
+from .listener import KeyboardListener
+from .queue import KeyboardQueue
+
+if __name__ == '__main__':
+    if True:
+        KeyboardQueue(print).start()
+    else:
+        KeyboardListener(print).start()

tuney/keyboard/key_types.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import dataclasses as dc
+from collections.abc import Callable
+from typing import TypeAlias
+
+from pynput import keyboard
+
+
+@dc.dataclass(frozen=True)
+class KeyAction:
+    char: str = ''
+    is_press: bool = False
+
+
+Key: TypeAlias = keyboard.Key | keyboard.KeyCode
+Callback: TypeAlias = Callable[[KeyAction], None]

tuney/keyboard/listener.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import dataclasses as dc
+from functools import cached_property, wraps
+from typing import Any
+
+from pynput import keyboard
+
+from .key_types import Callback, Key, KeyAction
+
+
+@dc.dataclass
+class Modifiers:
+    alt: int = 0
+    cmd: int = 0
+    ctrl: int = 0
+    shift: int = 0
+
+    def apply(self, key: keyboard.Key, is_press: bool) -> None:
+        name = key.name.partition('_')[0]
+        if (value := vars(self).get(name)) is not None:
+            value = max(0, min(2, value + (1 if is_press else -1)))
+            setattr(self, name, value)
+
+    @property
+    def is_printable(self) -> bool:
+        return not (self.alt or self.cmd or self.ctrl)
+
+
+@dc.dataclass
+class KeyboardListener:
+    callback: Callback
+    stop_key: keyboard.Key | None = None
+
+    _running: bool = False
+
+    @cached_property
+    def listener(self) -> keyboard.Listener:
+        return _make_listener(self)
+
+    @cached_property
+    def modifiers(self) -> Modifiers:
+        return Modifiers()
+
+    def on_press(self, key: Key | None) -> bool | None:
+        if not self._running or key == self.stop_key:
+            return False
+        self._on(key, True)
+
+    def on_release(self, key: Key | None) -> None:
+        self._on(key, False)
+
+    def start(self) -> None:
+        self._running = True
+        self.listener.__enter__()
+
+    def join(self) -> None:
+        self.listener.join()
+
+    def stop(self) -> None:
+        self._running = False
+        self.listener.stop()
+
+    def _on(self, key: Key | None, is_press: bool) -> None:
+        if isinstance(key, keyboard.Key):
+            self.modifiers.apply(key, is_press)
+        if self.modifiers.is_printable and (char := getattr(key, 'char', '')):
+            self.callback(KeyAction(char, is_press))
+
+
+def _make_listener(kl: KeyboardListener) -> keyboard.Listener:
+    listener = keyboard.Listener(
+        on_press=kl.on_press,
+        on_release=kl.on_release,
+    )
+    log = getattr(listener, '_log', None)
+    if not (log and hasattr(listener, 'IS_TRUSTED')):
+        return listener
+
+    # Work around a bogus warning in pynput and Darwin
+    BOGUS_WARNING = (
+        'This process is not trusted! Input event monitoring will not be possible'
+        ' until it is added to accessibility clients.'
+    )
+    warning_ = log.warning
+
+    @wraps(warning_)
+    def warning(a: str, *args: Any, **kwargs: Any) -> None:
+        if not a.strip() or a.replace(BOGUS_WARNING, '').strip() or args or kwargs:
+            warning_(a, *args, **kwargs)
+
+    log.warning = warning
+    return listener

tuney/keyboard/queue.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import dataclasses as dc
+import sys
+import threading
+import time
+import traceback
+from functools import cached_property
+from queue import Empty, Queue
+
+from .key_types import Callback, KeyAction
+from .listener import KeyboardListener
+
+
+@dc.dataclass
+class KeyboardQueue:
+    callback: Callback
+    timeout: float = 0.01
+    running: bool = False
+
+    def start(self) -> None:
+        self.running = True
+        threading.Thread(target=self._target).start()
+        self._listener.start()
+
+    def stop(self) -> None:
+        self.running = False
+        self._listener.stop()
+
+    def join(self) -> None:
+        # TODO: shouldn't I stop first?
+        try:
+            self._listener.join()
+        finally:
+            self.stop()
+
+    @cached_property
+    def _listener(self) -> KeyboardListener:
+        return KeyboardListener(self._queue.put)
+
+    def _target(self) -> None:
+        try:
+            while self.running:
+                try:
+                    key_action = self._queue.get(timeout=self.timeout)
+                except Empty:
+                    continue
+                if not key_action:
+                    break
+                self.callback(key_action)
+            self.callback(KeyAction())
+        except Exception:
+            print('THREAD TERMINATED', file=sys.stderr)
+            traceback.print_exc()
+
+    @cached_property
+    def _queue(self) -> Queue[KeyAction]:
+        return Queue()
+
+
+def time_keyboard() -> None:
+    def key_callback(k):
+        if k.is_press:
+            nonlocal now
+            old, now = now, time.time()
+            print(now - old)
+
+    now = time.time()
+    kq = KeyboardQueue(key_callback)
+    kq.start()
+
+
+def report() -> None:
+    def key_callback(k):
+        if k.is_press:
+            print(k)
+
+    kq = KeyboardQueue(key_callback)
+    kq.start()
+
+
+if __name__ == '__main__':
+    report()
+    # time_keyboard()

tuney/mapper/linear_mapper.py

@@ -0,0 +1,29 @@
+import dataclasses as dc
+from functools import cached_property
+from string import ascii_letters, ascii_lowercase
+
+
+@dc.dataclass(frozen=True)
+class LinearMapper:
+    alphabet: str | None = None
+    length: int = 0
+    case_sensitive: bool = True
+    invert: bool = False
+    offset: int = 0
+
+    def __call__(self, k: str) -> int | None:
+        return self.char_to_number.get(k if self.case_sensitive else k.lower())
+
+    @cached_property
+    def char_to_number(self) -> dict[str, int]:
+        if not (alphabet := self.alphabet):
+            alphabet = ascii_letters if self.case_sensitive else ascii_lowercase
+
+        def char_to_number(index: int, c: str) -> int:
+            if self.invert:
+                index = len(alphabet) - index - 1
+            if self.length:
+                index %= self.length
+            return index + self.offset
+
+        return {a: char_to_number(i, a) for i, a in enumerate(alphabet)}

tuney/scale/nearest_note.py

@@ -0,0 +1,23 @@
+from .scale import Tuning
+
+EPSILON = 1e-6
+
+
+def nearest_note(
+    tuning: Tuning, frequency: float, epsilon: float = EPSILON
+) -> int | tuple[int, int]:
+    below = above = 0
+    while tuning(below) > frequency:
+        below = (2 * below) or -0x40
+    while tuning(above) < frequency:
+        above = (2 * above) or 0x40
+    while (above - below) > 1:
+        mid = (below + above) // 2
+        f = tuning(mid)
+        if abs(f - frequency) < epsilon:
+            return mid
+        elif f < frequency:
+            below = mid
+        else:
+            above = mid
+    return below, above

tuney/scale/scale.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import NamedTuple
+
+type Frequency = float  # Must be non-negative
+type NoteNumber = int  # May be negative
+type NumberToFrequency = Callable[[NoteNumber], Frequency]
+type Tuning = NumberToFrequency
+
+type NameToNumber = Callable[[str], NoteNumber]
+type NumberToName = Callable[[NoteNumber, ...], str]
+
+
+class Scale(NamedTuple):
+    tuning: Tuning
+    name_to_number: NameToNumber
+    number_to_name: NumberToName
+
+
+class XNote(NamedTuple):  # The future of Note
+    scale: Scale
+    number: NoteNumber
+    name: str
+
+    @staticmethod
+    def make(scale: Scale, n: NoteNumber | str) -> XNote:
+        if isinstance(n, str):
+            name, number = n, scale.name_to_number(n)
+        else:
+            name, number = scale.number_to_name(n), n  # ty: ignore[missing-argument]
+        return XNote(scale, number, name)

tuney/scale/twelve_tet.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import re
+
+from .scale import NoteNumber, Scale
+
+# Standard: 60 = C3, C-1 == 0 Yamaha: 60 = C4, C0 == 0
+A440 = 69
+
+MIDI_ZERO_OCTAVE = -1
+ACCIDENTAL_DICT = {'#': '♯', 'b': '♭', '♭': '♭', '♯': '♯'}
+ACCIDENTALS = '#b♭♯'
+FLAT, SHARP = '♭', '♯'
+CANONICALS = FLAT + SHARP
+NAME_TO_NUMBER = {'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7, 'A': 9, 'B': 11}
+NAMES = ''.join(NAME_TO_NUMBER)
+NUMBER_TO_NAME = {
+    FLAT: ('C', 'D♭', 'D', 'E♭', 'E', 'F', 'G♭', 'G', 'A♭', 'A', 'B♭', 'B'),
+    SHARP: ('C', 'C♯', 'D', 'D♯', 'E', 'F', 'F♯', 'G', 'G♯', 'A', 'A♯', 'B'),
+}
+NOTE_RE = re.compile(rf'([{NAMES}])([{ACCIDENTALS}]*)(-?\d*)')
+
+assert ACCIDENTALS == ''.join(sorted(ACCIDENTAL_DICT))
+assert CANONICALS == ACCIDENTALS[2:]
+
+
+def tuning(note_number: NoteNumber) -> float:
+    return 440.0 * 2 ** ((note_number - A440) / 12)
+
+
+def name_to_number(note_name: str) -> int:
+    if not (m := NOTE_RE.match(note_name)):
+        raise ValueError(f'Cannot understand note {note_name}')
+
+    name, accidentals, octave = m.groups()
+    semitones = sum(2 * (ACCIDENTAL_DICT[a] == SHARP) - 1 for a in accidentals)
+    octaves = int(octave) - MIDI_ZERO_OCTAVE
+    return 12 * octaves + NAME_TO_NUMBER[name] + semitones
+
+
+def number_to_name(number: NoteNumber, use_sharp: bool = True) -> str:
+    accidental = SHARP if use_sharp else FLAT
+    assert accidental in NUMBER_TO_NAME, accidental
+    octave, number1 = divmod(number, 12)
+    octave += MIDI_ZERO_OCTAVE
+    name = NUMBER_TO_NAME[accidental][number1]
+    return f'{name}{octave}'
+
+
+TWELVE_TET = Scale(tuning, name_to_number, number_to_name)

tuney/time/__init__.py

@@ -0,0 +1,4 @@
+from typing import TypeAlias
+
+Milliseconds: TypeAlias = float
+Seconds: TypeAlias = float

tuney/time/event.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import dataclasses as dc
+import heapq
+import time
+from collections.abc import Callable
+from typing import Any
+
+from . import Seconds
+
+MAX_WAIT: Seconds = 0.01
+
+
+@dc.dataclass
+class Event[Data]:
+    timestamp: Seconds
+    data: Data
+
+    def __lt__(self, other: Event) -> bool:
+        return self.timestamp < other.timestamp
+
+
+@dc.dataclass
+class Runner[Data]:
+    events: list[Event[Data]]
+    callback: Callable[..., Any]
+
+    _running: bool = False
+
+    def __post_init__(self) -> None:
+        heapq.heapify(self.events)
+
+    def run(self) -> None:
+        self._running = True
+        while self._running:
+            while self.events and self.events[0].timestamp <= time.time():
+                self.callback(d := heapq.heappop(self.events).data)
+                print('run', d)
+
+            if self.events:
+                time.sleep(min(MAX_WAIT, self.events[0].timestamp - time.time()))
+            else:
+                self.stop()
+
+    def stop(self) -> None:
+        self._running = False
+
+
+def demo() -> None:
+    def event() -> Event[float]:
+        import random
+
+        t = timestamp + random.uniform(0, 1)
+        return Event(t, t - timestamp)
+
+    timestamp = time.time()
+    Runner([event() for _ in range(10)], print).run()
+
+
+if __name__ == '__main__':
+    demo()

tuney/time/text_timings.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import dataclasses as dc
+import random
+from collections.abc import Collection, Iterable, Iterator
+from functools import cached_property
+from typing import NamedTuple
+
+from . import Milliseconds
+
+
+class CharBeginEnd(NamedTuple):
+    char: str
+    begin: Milliseconds
+    end: Milliseconds
+
+
+@dc.dataclass(frozen=True)
+class TextTimings:
+    space: Milliseconds = 100
+    period: Milliseconds = 300
+    comma: Milliseconds = 200
+    colon: Milliseconds = 400
+    semicolon: Milliseconds = 400
+    blank_line: Milliseconds = 1000
+
+    overlap: Milliseconds = 20
+    random_seed: int | None = None
+    alpha_only: bool = True
+    strip_accents: bool = True
+
+    other: dict[str, Milliseconds] = dc.field(default_factory=dict)
+    timings: Collection[Milliseconds] | None = None
+
+    @cached_property
+    def timings_(self) -> Collection[Milliseconds]:
+        return self.timings or _TIMINGS
+
+    @cached_property
+    def average_time(self) -> float:
+        return sum(self.timings_) / len(self.timings_)
+
+    @cached_property
+    def random(self):
+        return random.Random(self.random_seed)
+
+    @cached_property
+    def char_to_time(self) -> dict[str, Milliseconds]:
+        return {v: getattr(self, k) for k, v in _CHARS.items()} | self.other
+
+    def __call__(self, text: str) -> Iterator[CharBeginEnd]:
+        time = 0
+        chars = _strip_accents(text) if self.strip_accents else text
+        for char in _filter_chars(chars):
+            dt = self.char_to_time.get(char)
+            if char.isalpha() or not (dt is None and self.alpha_only):
+                dt = (dt or 0.0) + self.random.choice(self.timings_)
+                yield CharBeginEnd(char, time, time + dt)
+                time += max(0, dt - self.overlap)
+
+
+def _filter_chars(it: Iterable[str]) -> Iterator[str]:
+    # Filter out the first `\n', so each \n means an actual new line,
+    # and any spaces after the first one.
+    previous = ''
+    for c in it:
+        if not c.isspace():
+            yield c
+        elif c not in ' \n':
+            continue
+        elif c == '\n' == previous:
+            yield c
+        elif c == ' ' and previous not in ' \n':
+            yield c
+        previous = c
+
+
+def _strip_accents(s: str) -> Iterator[str]:
+    # https://stackoverflow.com/questions/517923/
+    from unicodedata import category, normalize
+
+    yield from (c for c in normalize('NFD', s) if category(c) != 'Mn')
+
+
+_CHARS = {
+    'space': ' ',
+    'period': '.',
+    'comma': ',',
+    'colon': ':',
+    'semicolon': ';',
+    'blank_line': '\n',
+}
+_TIMINGS = (
+    (56.04, 57.92, 60.35, 61.94, 62.54, 63.29, 63.32, 64.27, 66.26, 66.92)
+    + (67.98, 68.02, 68.44, 69.33, 69.61, 70.61, 72.72, 72.75, 72.76, 73.42)
+    + (75.07, 77.92, 78.52, 80.12, 83.55, 84.34, 85.13, 85.36, 85.47, 85.77)
+    + (85.97, 86.32, 86.7, 88.45, 89.24, 89.26, 89.44, 89.54, 90.82, 91.18)
+    + (91.22, 92.69, 92.94, 93.32, 94.24, 94.59, 94.75, 95.83, 96.64, 97.79)
+    + (98.76, 99.11, 100.01, 100.38, 101.67, 103.73, 104.81, 104.87, 105.41, 106.56)
+    + (107.5, 107.68, 107.97, 110.95, 111.07, 113.24, 115.18, 116.24, 116.24, 117.64)
+    + (120.67, 122.09, 124.4, 125.88, 127.58, 128.57, 129.16, 130.85, 131.73, 133.19)
+    + (133.81, 134.46, 136.04, 138.25, 140.16, 140.21, 140.22, 140.32, 141.9, 142.83)
+    + (143.1, 148.71, 149.47, 149.88, 150.53, 153.21, 153.44, 153.66, 153.95, 156.17)
+    + (157.75, 157.76, 158.17, 159.87, 160.48, 160.87, 160.97, 163.56, 164.12, 167.26)
+    + (167.36, 168.21, 168.55, 169.04, 169.85, 169.86, 170.61, 171.43, 171.46, 172.9)
+    + (173.78, 174.22, 174.76, 175.52, 176.18, 176.38, 176.49, 176.83, 178.75, 179.03)
+    + (179.41, 180.81, 181.69, 182.37, 184.2, 184.48, 185.46, 185.9, 185.96, 187.05)
+    + (188.67, 189.03, 190.0, 190.71, 192.68, 192.74, 192.88, 193.29, 194.49, 197.11)
+    + (197.81, 199.08, 200.55, 200.66, 200.7, 201.65, 202.79, 203.32, 205.1, 205.7)
+    + (206.18, 209.24, 210.69, 213.53, 214.09, 214.13, 222.19, 222.56, 222.58, 223.53)
+    + (224.91, 227.26, 230.08, 234.93, 236.72, 246.01, 259.32, 260.27, 261.92, 266.67)
+    + (269.42, 279.88, 287.71, 295.99, 299.94, 317.22, 329.73, 330.68, 357.17, 367.83)
+    + (419.5, 422.63, 475.46, 521.2, 526.85, 594.64, 738.79)
+)