tandav / musiclib

Set of tools to work with scales, modes, modulations, chord progressions, voice leading, rhythm and more

musiclib

set of tools to work with scales, modes, modulations, chord progressions, voice leading, rhythm and more

install

install from pypi

pip install musiclib

or install the latest version from github

pip install git+https://github.com/tandav/musiclib

development

pip install -e .[dev]

examples

>>> from musiclib.scale import Scale
>>> from musiclib.noteset import SpecificNoteSet
>>> from musiclib.noterange import NoteRange

>>> scale = Scale.from_name('C', 'major')

>>> scale.root
Note('C')

>>> scale.notes
frozenset({Note('C'),
           Note('D'),
           Note('E'),
           Note('F'),
           Note('G'),
           Note('A'),
           Note('B')})

>>> scale.bits
'101011010101'

>>> scale.intervals
frozenset({0, 2, 4, 5, 7, 9, 11})

Scale.from_name('C', 'phrygian')

SpecificNoteSet.from_str('C1_e1_G1_C2_b2_E3')

NoteRange(SpecificNote('C', 1), SpecificNote('B', 3))

musiclib's Issues

remove config.default_octave from SpecificNote

maybe rename NoteSet to scale and scale to diatonic etc

add cached_property origin to SpecificChord in order to not compute twice

delete Note.play (explicit is better than implicit)

• grep for usages in jupyter notebooks

Test all meters , eg 4/2

4/2 means there are 2 whole notes in a bar (not 1 as on 4/4)

maybe this will be confusing notation (whole note no more means 1 bar)

seems like denominator is powrs of 2:

Any time signature can be used, provided it has a numerator between 1 and 99 and a denominator with a beat value of 1, 2, 4, 8 or 16.
https://www.ableton.com/en/manual/session-view/#tracks-and-scenes

maybe this is all useless because note durations in MIDI file are represented by on/off ticks, not by fractions (1,1/2,1/4 etc)

separate voice_leading into submodules

Remove underscore: note_range > noterange

https://github.com/tandav/musictool/blob/master/musictool/voice_leading/progression.py#L229

cache Note, SpecificNote, Chord, SpecificChord instead of creating new

inherit SpecificChord from Chord or from NoteSet

abstract piano_svg logic, it should be in notes.Notes, not in scale.Scale

create Notes - dedupe common parts in Chord and Scale

• inherit Chord(Notes)
• inherit Scale(Notes)
• musictools.scale.Scale should be DiatonicScale(Scale) ???

add util function to make legato notes in chord progressions

delete notes.str_chord, just use __str__ / __repr__

• encode / for server urls with .replace('/', '__') and .replace('__', '/')
• make repr cached property

test notes.str_to_note

add 2,4,5 notes chords examples in test_chord_transitons

update curr_prev_constraint

it should support not only -1 but also -2, -3, .. -n. candidate_constraint is not good for this because it difficult to handle loop=True case. So general curr_prev_constraint is required , it should support loop=True

fix transition_graph, it should reach all named_chords

Test it

test NoteRange when start == stop

save chord transitions checks to sqlite

schema:

• chord a (str) (eg C3_G5_C6_E7/C)
• chord b (str)
• check function name (str)
• return (bool)

function checks table:

• check function name (str)
• function code (str)
• sha? md5?

check: is there at least one V-I chord transition which meets the current constraints

checks cache should be aware of transpose_unique chords. Computing for different note names is expensive

• add test to check cache is used
• use Progression.transpose_unique_key as helper (rewrite it, update tests)

improve sequence_builder

• Add access to prefix in sequence_builder constraints
  For example to check that -1, -2, -3 root notes are not equal to current
• #66
• more tests
  • test unique and parallel (theres frozenset usage inside)
• feature: take callable which generates options for each step. (now you can only iterate through every possible options)
  pass args to that callable
• upgrade to class
  classmethods for different scenarios: options is iterable, iterable of iterables, callable
• add caching
  • profile cache, is it used in my algo, maybe computing permutations-like sequences didn't use cache (waste of RAM)
  • its kinda not used (ensure this is not because of some stupid bug) sequence_builder.cache_info(): CacheInfo(hits=0, misses=1397182, maxsize=None, currsize=1397182)
  • maybe some parts of the build / constraint checks can be cached
• parallel computing
  • test that parallel results are equal to single threaded
  • paralellize sequence_builder (multiprocessing), make an api to compute on server
  • #65
• fix #49
• tqdm progressbar
• use iter, next for SequenceBuilder

rename have_voice_overlap to have_voice_crossing

separate requirements.txt and requirements-dev.txt

Sample random chords with root from graph. And then find shortest paths between them

Use it for everlasting video

paralellize sequence_builder (multiprocessing), make an api to compute on server

Todo: generate all chord progressions of length=4 bars and at least 1 chord with root note=C

Split into 3 different projects: musictools, stream and web (musictool.tandav.me)

All targets in Makefile should be phony

svg jupyter repr for NoteSet, Chord, SpecificChord

Delete key in sorted

https://github.com/tandav/musictool/blob/master/musictool/chord.py#L47

NoteRange(tuple) (base) NoteRange (specific, abstract) (subclasses)

Realtime playing in terminal, draw colors, scales on keyboard using rich, colorama libs

Rename dim-7 to dim7

rename to musictool and publish to PYPI

Remove self.notes = tuple(itertools.compress(chromatic.iterate(start_note=root)

Also remove /refactor chromatic.iterate

Maybe NoteSet is better name than Notes

add invalid str checks to Note.from_str and SpecificNote.from_str

Functools.cache sequence_builder

add distance (actually subtract to not loose sign) to NoteSet (distance between 2 notes within some scale/noteset)

add test for make_major_scale_leading_tone_resolving_semitone_up

change chromatic.sort_notes to sorted() in NoteSet

        self.notes_ascending = chromatic.sort_notes(self.notes, start=self.root)

rewrite progression.py functions using new NoteRange class, update tests

Remove stale docstrings from notes

https://github.com/tandav/musictools/blob/master/musictools/notes.py#L50

rewrite chord_transitons using Scale.add_note instead of note_range math

sequence_builder(loop=True) not working example

sequence_builder(
    ...
    curr_prev_constraint={-1: no_bad_checks, -2: lambda a, b: not equal_roots(a, b)},
    loop=True,
)

gives this False positive exmple: EDFECD (second D has -2 root == D)
full chords:

[E1_B1_D2_G2_E3/E, D1_C2_F2_A2_C3/D, F1_C2_F2_A2_E3/F, E1_D2_G2_B2_E3/E, C1_C2_E2_B2_G3/C, D1_C2_F2_A2_F3/D]

Use itertools.pairwise

https://github.com/tandav/musictool/blob/master/musictool/voice_leading/checks.py#L64

https://github.com/tandav/musictool/blob/master/musictool/chord.py#L48

Add helper to find all I - V paths. (with resolving leading tone in V - I)

add NoteRange.__getitem__(item: slice) support

get rid of __new__ in Scale cache implementation (try to use functools.cache)