tuney 0.2.0__py3-none-any.whl

tuney/__main__.py

@@ -0,0 +1,10 @@
+from .ui.keyboard_controller import KeyboardController
+
+
+def main() -> None:
+    with KeyboardController():
+        pass
+
+
+if __name__ == '__main__':
+    main()

tuney/audio/__init__.py

@@ -0,0 +1,8 @@
+from collections.abc import Callable
+from typing import Any, TypeAlias
+
+import numpy as np
+
+Data: TypeAlias = np.ndarray
+Function: TypeAlias = Callable[..., Any]
+Number: TypeAlias = int | float | np.floating | np.integer

tuney/audio/device_config.py

@@ -0,0 +1,40 @@
+import dataclasses as dc
+from typing import Generic, TypeVar, get_args
+
+import sounddevice as sd
+
+_T = TypeVar('_T', bound=sd._StreamBase)
+
+
+@dc.dataclass
+class DeviceConfig:
+    samplerate: int | None = None
+    blocksize: int | None = None
+    device: int | str | None = None
+    channels: int | None = None
+    dtype: type | None = None
+    latency: int | None = None
+    extra_settings: str | None = None
+    clip_off: bool | None = None
+    dither_off: bool | None = None
+    never_drop_input: bool | None = None
+    prime_output_buffers_using_stream_callback: bool | None = None
+
+
+class DeviceMaker(Generic[_T]):
+    @classmethod
+    def type(cls) -> type[_T]:
+        bases = getattr(cls, '__orig_bases__', None)
+        assert bases is not None
+        return get_args(bases[0])[0]
+
+    def __call__(self, config: DeviceConfig) -> _T:
+        return self.type()(**dc.asdict(config))
+
+
+class OutputStreamMaker(DeviceMaker[sd.OutputStream]):
+    pass
+
+
+if __name__ == '__main__':
+    print(OutputStreamMaker.type())

tuney/audio/file_player.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from functools import cached_property
+
+from .device_config import DeviceConfig
+from .player import Player
+from .sample_data import Data, SampleData
+
+
+class FilePlayer(Player):
+    def __init__(self, filename: str, device: str | int = 0) -> None:
+        self.filename = filename
+        self.device = device
+
+    @cached_property
+    def _data(self) -> SampleData:
+        return SampleData.make(self.filename).cut_to(1.5)
+
+    @cached_property
+    def config(self) -> DeviceConfig:
+        return self._data.config(self.device)
+
+    def _fill(self, out: Data) -> bool:
+        chunk = self._data.data[self.frame_count : self.frame_count + self.frame_size]
+        out[: len(chunk)] = chunk
+        success = len(chunk) == self.frame_size
+        if not success:
+            out[len(chunk) : self.frame_size] = 0
+        return success
+
+
+if __name__ == '__main__':
+    import sys
+
+    for a in sys.argv[1:]:
+        print('open', a)
+        FilePlayer(a).run()

tuney/audio/midi.py

@@ -0,0 +1,20 @@
+import dataclasses as dc
+
+import mido
+
+ZERO_IS_NOTE_OFF = True
+
+
+@dc.dataclass(frozen=True)
+class NoteMaker:
+    channel: int = 0
+    velocity: int = 0x40
+    note_offset: int = 0
+
+    def message(self, note_number: int, is_press: bool) -> mido.Message:
+        return mido.Message(
+            channel=self.channel,
+            note=(note_number + self.note_offset) % 128,
+            type='note_on' if is_press or ZERO_IS_NOTE_OFF else 'note_off',
+            velocity=max(0, min(127, is_press * self.velocity)),
+        )

tuney/audio/oscillator.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Callable
+from typing import Any, TypeAlias, override
+
+import numpy as np
+
+from . import Data, Number
+
+Function: TypeAlias = Callable[..., Any]
+
+
+class Oscillator:
+    period: Number = 2 * np.pi
+    # TODO: add intensity to compensate for different energies
+
+    @abstractmethod
+    def function(self, x: Data, out: Data) -> Data: ...
+
+
+class Sine(Oscillator):
+    @override
+    def function(self, x: Data, out: Data) -> Data:
+        return np.sin(x, out=out)
+
+
+class Triangle(Oscillator):
+    width: Number = 0.5
+
+    @override
+    def function(self, x: Data, out: Data) -> Data:
+        from .scipy import sawtooth
+
+        out[:] = sawtooth(x, self.width)
+        return out
+
+
+class OldSawtooth(Oscillator):
+    @override
+    def function(self, x: Data, out: Data) -> Data:
+        return np.add(np.mod(x, 2.0, out=out), -1.0, out=out)
+
+
+class Sawtooth(Triangle):
+    width: Number = 0
+
+
+sawtooth, sine, triangle = Sawtooth(), Sine(), Triangle()

tuney/audio/player.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import dataclasses as dc
+from abc import ABC, abstractmethod
+from functools import cached_property
+from threading import Event
+from typing import override
+
+from sounddevice import CallbackStop, OutputStream
+
+from . import Data
+from .device_config import DeviceConfig
+from .runnable import Runnable
+
+
+@dc.dataclass
+class Player(Runnable, ABC):
+    config: DeviceConfig = dc.field(default_factory=DeviceConfig)
+
+    chunk_count: int = 0
+    frame_size: int = 0
+
+    _event: Event = dc.field(default_factory=Event)
+
+    @abstractmethod
+    def _fill(self, out: Data) -> bool:
+        pass
+
+    def fill(self, out: Data, frame_size: int) -> bool:
+        if self.frame_size and frame_size != self.frame_size:
+            # Hope this never happens
+            print('framesize change', self.frame_size, frame_size)
+        self.frame_size = frame_size
+        success = self._fill(out)
+        self.chunk_count += 1
+        return success
+
+    def callback(self, out: Data, frame_size: int, time: float, status: str) -> None:
+        if status:
+            print('Playback', status)  # TODO:
+
+        if not self.fill(out, frame_size) or not self.is_running:
+            self.stop()
+            raise CallbackStop
+
+    @override
+    def _run(self):
+        with self.stream:
+            self._event.wait()
+
+    @cached_property
+    def stream(self) -> OutputStream:
+        callbacks = {'callback': self.callback, 'finished_callback': self._event.set}
+        return OutputStream(**dc.asdict(self.config), **callbacks)
+
+    @property
+    def frame_count(self) -> int:
+        return self.frame_size * self.chunk_count

tuney/audio/runnable.py

@@ -0,0 +1,22 @@
+from abc import ABC, abstractmethod
+
+
+class Runnable(ABC):
+    def run(self) -> None:
+        self._running = True
+        try:
+            self._run()
+        finally:
+            self.stop()
+
+    @property
+    def is_running(self) -> bool:
+        return self._running
+
+    def stop(self) -> None:
+        self._running = False
+
+    @abstractmethod
+    def _run(self) -> None: ...
+
+    _running: bool = False

tuney/audio/sample_data.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import dataclasses as dc
+from functools import cached_property
+
+import soundfile
+
+from . import Data
+from .device_config import DeviceConfig
+
+
+@dc.dataclass
+class SampleData:
+    data: Data
+    samplerate: int
+
+    def config(self, device: int | str | None) -> DeviceConfig:
+        return DeviceConfig(
+            channels=self.channels, device=device, samplerate=self.samplerate
+        )
+
+    @staticmethod
+    def make(filename: str) -> SampleData:
+        return SampleData(*soundfile.read(filename, always_2d=True))
+
+    def cut_to(self, time: float) -> SampleData:
+        count = round(time * self.samplerate)
+        to_cut = len(self.data) - count
+        if to_cut <= 0:
+            return self
+        half = to_cut // 2
+        return SampleData(self.data[half : count + half], self.samplerate)
+
+    @cached_property
+    def channels(self) -> int:
+        return self.data.shape[1]