Script to generate and check notes of major and minor acoustic fields

notes.py

names = [
    'A', 'A#', 'B', 'C', 'C#', 'D',
    'D#', 'E', 'F', 'F#', 'G', 'G#'
]
name2int = { n:i for i, n in enumerate(names) }


class Note(object):
    def __init__(self, name, major=True) -> None:
        super().__init__()
        if type(name) == str:
            self.value = name2int[name]
        else:
            self.value = name % 12

    def __repr__(self) -> str:
        return names[self.value]

    def __str__(self) -> str:
        return names[self.value]

    def __add__(self, other):
        v2 = self._get_value(other)
        value = (self.value + v2) % 12
        return Note(value)

    def __sub__(self, other):
        v2 = self._get_value(other)
        value = (self.value - v2) % 12
        return Note(value)

    def _get_value(self, obj):
        if (type(obj) == int):
            v = obj
        elif (type(obj) == Note):
            v = obj.value
        else:
            v = name2int[obj]
        return v

    @property
    def name(self):
        return names[self.value]

    @property
    def major_updates(self):
        return [0, 2, 4, 5, 7, 9, 11, 12]

    @property
    def minor_updates(self):
        return [0, 2, 3, 5, 7, 8, 10, 12]

    @property
    def third(self):
        return self + 4

    @property
    def fifth(self):
        return self + 7

    @property
    def seventh(self):
        return self + 11

    def diff(self, other):
        d = (self - other).value
        d = d if d < 10 else d - 12
        return d

    def harmonic_field(self, field):
        for i in range(7):
            tonic = self + field[i]
            third = self + field[(i + 2) % 7]
            third_diff = third.diff(tonic.third)
            fifth = self + field[(i + 4) % 7]
            fifth_diff = fifth.diff(tonic.fifth)
            seventh = self + field[(i + 6) % 7]
            seventh_diff = seventh.diff(seventh)
            print(f'{tonic}\t{third}({third_diff})\t{fifth}({fifth_diff})\t{seventh}({seventh_diff})')

    def major_harmonic_field(self):
        return self.harmonic_field(self.major_updates)

    def minor_harmonic_field(self):
        return self.harmonic_field(self.minor_updates)

    def major_scale(self):
        notes = []
        for i in self.major_updates:
            notes.append(self + i)
        return notes

    def minor_scale(self):
        return self.scale(self.minor_updates)

    def scale(self, updates):
        notes = []
        for i in updates:
            notes.append(self + i)
        return notes


print('Escalas Maiores')

for i in names:
    n = Note(i)
    print('\t'.join([str(nx) for nx in n.major_scale()]))

print('\n\nCampos Harmônicos Maiores')

for i in names:
    n = Note(i)
    n.major_harmonic_field()
    print()

print('\nEscalas Menores')

for i in names:
    n = Note(i)
    print('\t'.join([str(nx) for nx in n.minor_scale()]))

print('\n\nCampos Harmônicos Maiores')

for i in names:
    n = Note(i)
    n.minor_harmonic_field()
    print()