music_dsl

View Source

 1from dataclasses import dataclass
 2
 3from music_dsl.domain.static.notes import Notes
 4from music_dsl.encode import Scales
 5
 6
 7@dataclass
 8class Key:
 9    root: Notes
10    scale: Scales
11
12
13__version__ = "0.1.0"
14
15# The thin top-level surface (Key/Notes/Scales) is intentional: deeper theory is
16# submodule-scoped (see API-SURFACE.md). __all__ keeps `import *` to exactly this.
17__all__ = ["Key", "Notes", "Scales", "__version__"]

@dataclass

class Key: View Source

 8@dataclass
 9class Key:
10    root: Notes
11    scale: Scales

Key( root: Notes, scale: Scales)

root: Notes

scale: Scales

class Notes(music_dsl.utils.JsonSerializableEnum): View Source

11class Notes(JsonSerializableEnum):
12    C = "C"
13    Cs = "C#"
14    Db = "Db"
15    D = "D"
16    Ds = "D#"
17    Eb = "Eb"
18    E = "E"
19    F = "F"
20    Fs = "F#"
21    Gb = "Gb"
22    G = "G"
23    Gs = "G#"
24    Ab = "Ab"
25    A = "A"
26    As = "A#"
27    Bb = "Bb"
28    B = "B"
29
30    def to_flat(self):
31        if self.value not in _SHARPS_TO_FLATS:
32            return self
33        return Notes(_SHARPS_TO_FLATS[self.value])
34
35    def normalized(self):
36        return self.to_flat()
37
38    def __eq__(self, other):
39        if not isinstance(other, Notes):
40            return NotImplemented  # note == None / str / ScaleDegree → False, not a crash
41        enharmonic = _SHARPS_TO_FLATS.get(other.value) or _FLATS_TO_SHARPS.get(
42            other.value
43        )
44        return self.value == other.value or self.value == enharmonic
45
46    def __hash__(self):
47        # Consistent with the enharmonic __eq__: sharps/flats of the same pitch
48        # (Cs/Db, ...) normalize to one flat spelling, so equal notes hash equal.
49        return hash(self.to_flat().value)
50
51    @classmethod
52    def names_by_value(cls):
53        """Map each note's string value to its member name (e.g. ``'C#' -> 'Cs'``)."""
54        return {note.value: note.name for note in cls}

C = <Notes.C: 'C'>

Cs = <Notes.Cs: 'C#'>

Db = <Notes.Db: 'Db'>

D = <Notes.D: 'D'>

Ds = <Notes.Ds: 'D#'>

Eb = <Notes.Eb: 'Eb'>

E = <Notes.E: 'E'>

F = <Notes.F: 'F'>

Fs = <Notes.Fs: 'F#'>

Gb = <Notes.Gb: 'Gb'>

G = <Notes.G: 'G'>

Gs = <Notes.Gs: 'G#'>

Ab = <Notes.Ab: 'Ab'>

A = <Notes.A: 'A'>

As = <Notes.As: 'A#'>

Bb = <Notes.Bb: 'Bb'>

B = <Notes.B: 'B'>

def to_flat(self): View Source

30    def to_flat(self):
31        if self.value not in _SHARPS_TO_FLATS:
32            return self
33        return Notes(_SHARPS_TO_FLATS[self.value])

def normalized(self): View Source

35    def normalized(self):
36        return self.to_flat()

@classmethod

def names_by_value(cls): View Source

51    @classmethod
52    def names_by_value(cls):
53        """Map each note's string value to its member name (e.g. ``'C#' -> 'Cs'``)."""
54        return {note.value: note.name for note in cls}

Map each note's string value to its member name (e.g. 'C#' -> 'Cs').

__version__ = '0.1.0'