concertina_helper.layouts.bisonoric

  1from __future__ import annotations
  2from typing import Any
  3from collections.abc import Callable
  4from dataclasses import dataclass
  5
  6from .unisonoric import UnisonoricFingering, UnisonoricLayout
  7from ..type_defs import Shape, PitchToStr, Mask, Pitch, Direction, Annotation
  8from .base_classes import Layout, Fingering
  9
 10
 11@dataclass(frozen=True, kw_only=True)
 12class BisonoricLayout(Layout['BisonoricFingering']):
 13    '''
 14    Represents a bisonoric concertina layout:
 15    the layout of the buttons on the left and right,
 16    and the pitches they produce on push and pull.
 17
 18    >>> from concertina_helper.layouts.layout_loader import (
 19    ...     load_bisonoric_layout_by_name)
 20    >>> layout = load_bisonoric_layout_by_name('30_wheatstone_cg')
 21    >>> print(layout)
 22    PUSH:
 23    E3  A3  C#4 A4  G#4     C#5 A5  G#5 C#6 A6
 24    C3  G3  C4  E4  G4      C5  E5  G5  C6  E6
 25    B3  D4  G4  B4  D5      G5  B5  D6  G6  B6
 26    PULL:
 27    F3  Bb3 D#4 G4  Bb4     D#5 G5  Bb5 D#6 F6
 28    G3  B3  D4  F4  A4      B4  D5  F5  A5  B5
 29    A3  F#4 A4  C5  E5      F#5 A5  C6  E6  F#6
 30
 31    With a layout, you can get all fingerings for a particular pitch.
 32    Fingerings can be combined to produce chords:
 33
 34    >>> c = layout.get_fingerings(Pitch('C4')).pop()
 35    >>> e = layout.get_fingerings(Pitch('E4')).pop()
 36    >>> print(c | e)
 37    PUSH:
 38    --- --- --- --- ---    --- --- --- --- ---
 39    --- --- C4  E4  ---    --- --- --- --- ---
 40    --- --- --- --- ---    --- --- --- --- ---
 41
 42    Fingerings with different bellow directions can not be combined:
 43    >>> f = layout.get_fingerings(Pitch('F4')).pop()
 44    >>> print(c | f)
 45    Traceback (most recent call last):
 46    ...
 47    ValueError: different bellows directions
 48    '''
 49    push_layout: UnisonoricLayout
 50    pull_layout: UnisonoricLayout
 51
 52    def __post_init__(self) -> None:
 53        if self.push_layout.shape != self.pull_layout.shape:
 54            raise ValueError(
 55                'Push and pull layout shapes must match: '
 56                f'{self.push_layout.shape} != {self.pull_layout.shape}')
 57
 58    @property
 59    def shape(self) -> Shape:
 60        return (
 61            [len(row) for row in self.push_layout.left],
 62            [len(row) for row in self.push_layout.right],
 63        )
 64
 65    def get_fingerings(self, pitch: Pitch) -> set[BisonoricFingering]:
 66        '''
 67        Given a pitch, return all possible fingerings as a set.
 68        '''
 69        push_fingerings = self.push_layout.get_fingerings(pitch)
 70        pull_fingerings = self.pull_layout.get_fingerings(pitch)
 71        return (
 72            {BisonoricFingering(Direction.PUSH, pf) for pf in push_fingerings} |
 73            {BisonoricFingering(Direction.PULL, pf) for pf in pull_fingerings}
 74        )
 75
 76    def __str__(self) -> str:
 77        return f'{Direction.PUSH.name}:\n{self.push_layout}\n' \
 78            f'{Direction.PULL.name}:\n{self.pull_layout}'
 79
 80    def transpose(self, semitones: int) -> BisonoricLayout:
 81        '''
 82        Given a number of semitones, return a new layout,
 83        transposed up or down.
 84        '''
 85        return BisonoricLayout(
 86            push_layout=self.push_layout.transpose(semitones),
 87            pull_layout=self.pull_layout.transpose(semitones))
 88
 89
 90@dataclass(frozen=True)
 91class BisonoricFingering(Fingering):
 92    '''
 93    Represents a fingering on a bisonoric concertina.
 94    '''
 95    direction: Direction
 96    _fingering: UnisonoricFingering
 97
 98    @property
 99    def left_mask(self) -> Mask:
100        return self._fingering.left_mask
101
102    @property
103    def right_mask(self) -> Mask:
104        return self._fingering.right_mask
105
106    def __str__(self) -> str:
107        return f'{self.direction.name}:\n{self._fingering}'
108
109    def format(
110        self,
111        button_down_f: PitchToStr = lambda pitch: '@',
112        button_up_f: PitchToStr = lambda pitch: '.',
113        direction_f: Callable[[Direction], str] =
114            lambda direction: direction.name) -> str:
115        return f'{direction_f(self.direction)}:\n' \
116            f'{self._fingering.format(button_down_f, button_up_f)}'
117
118    def __or__(self, other: Any) -> BisonoricFingering:
119        if type(self) != type(other):
120            raise TypeError('mixed operand types')
121        if self.direction != other.direction:
122            raise ValueError('different bellows directions')
123        return BisonoricFingering(self.direction, self._fingering | other._fingering)
124
125    def get_pitches(self) -> set[Pitch]:
126        return self._fingering.get_pitches()
127
128
129@dataclass(frozen=True, kw_only=True)
130class AnnotatedBisonoricFingering:
131    '''
132    Adds contextual information to the fingering
133    that is useful in finding the best fingering for a tune.
134    '''
135    fingering: BisonoricFingering
136    annotation: Annotation
137
138    def __str__(self) -> str:
139        a = self.annotation
140        return f'Measure {a.measure} - {a.pitch}\n{self.fingering}'
141
142    def format(  # pragma: no branch
143            self,
144            button_down_f: PitchToStr = lambda pitch: '@',
145            button_up_f: PitchToStr = lambda pitch: '.',
146            direction_f: Callable[[Direction], str] =
147            lambda direction: direction.name) -> str:
148        a = self.annotation
149        formatted = self.fingering.format(
150            button_down_f=button_down_f,
151            button_up_f=button_up_f,
152            direction_f=direction_f)
153        return f'Measure {a.measure} - {a.pitch}\n{formatted}'