Datasets:

---

CM

/

codexglue_code2text_python

like 8

[ "def", "header", "(", "self", ")", ":", "tracks", "=", "a2b_hex", "(", "'%04x'", "%", "len", "(", "[", "t", "for", "t", "in", "self", ".", "tracks", "if", "t", ".", "track_data", "!=", "''", "]", ")", ")", "return", "'MThd\\x00\\x00\\x00\\x06\\x00\\x01'", "+", "tracks", "+", "self", ".", "time_division" ]

[ "Return", "a", "header", "for", "type", "1", "MIDI", "file", "." ]

[ "def", "write_file", "(", "self", ",", "file", ",", "verbose", "=", "False", ")", ":", "dat", "=", "self", ".", "get_midi_data", "(", ")", "try", ":", "f", "=", "open", "(", "file", ",", "'wb'", ")", "except", ":", "print", "\"Couldn't open '%s' for writing.\"", "%", "file", "return", "False", "try", ":", "f", ".", "write", "(", "dat", ")", "except", ":", "print", "'An error occured while writing data to %s.'", "%", "file", "return", "False", "f", ".", "close", "(", ")", "if", "verbose", ":", "print", "'Written %d bytes to %s.'", "%", "(", "len", "(", "dat", ")", ",", "file", ")", "return", "True" ]

[ "Collect", "the", "data", "from", "get_midi_data", "and", "write", "to", "file", "." ]

[ "def", "fingers_needed", "(", "fingering", ")", ":", "split", "=", "False", "# True if an open string must be played, thereby making any", "# subsequent strings impossible to bar with the index finger", "indexfinger", "=", "False", "# True if the index finger was already accounted for", "# in the count", "minimum", "=", "min", "(", "finger", "for", "finger", "in", "fingering", "if", "finger", ")", "# the index finger", "# plays the lowest", "# finger position", "result", "=", "0", "for", "finger", "in", "reversed", "(", "fingering", ")", ":", "if", "finger", "==", "0", ":", "# an open string is played", "split", "=", "True", "# subsequent strings are impossible to bar with the", "# index finger", "else", ":", "if", "not", "split", "and", "finger", "==", "minimum", ":", "# if an open string hasn't been", "# played and this is a job for", "# the index finger:", "if", "not", "indexfinger", ":", "# if the index finger hasn't been accounted", "# for:", "result", "+=", "1", "indexfinger", "=", "True", "# index finger has now been accounted for", "else", ":", "result", "+=", "1", "return", "result" ]

[ "Return", "the", "number", "of", "fingers", "needed", "to", "play", "the", "given", "fingering", "." ]

[ "def", "add_tuning", "(", "instrument", ",", "description", ",", "tuning", ")", ":", "t", "=", "StringTuning", "(", "instrument", ",", "description", ",", "tuning", ")", "if", "_known", ".", "has_key", "(", "str", ".", "upper", "(", "instrument", ")", ")", ":", "_known", "[", "str", ".", "upper", "(", "instrument", ")", "]", "[", "1", "]", "[", "str", ".", "upper", "(", "description", ")", "]", "=", "t", "else", ":", "_known", "[", "str", ".", "upper", "(", "instrument", ")", "]", "=", "(", "instrument", ",", "{", "str", ".", "upper", "(", "description", ")", ":", "t", "}", ")" ]

[ "Add", "a", "new", "tuning", "to", "the", "index", "." ]

[ "def", "get_tuning", "(", "instrument", ",", "description", ",", "nr_of_strings", "=", "None", ",", "nr_of_courses", "=", "None", ")", ":", "searchi", "=", "str", ".", "upper", "(", "instrument", ")", "searchd", "=", "str", ".", "upper", "(", "description", ")", "keys", "=", "_known", ".", "keys", "(", ")", "for", "x", "in", "keys", ":", "if", "(", "searchi", "not", "in", "keys", "and", "x", ".", "find", "(", "searchi", ")", "==", "0", "or", "searchi", "in", "keys", "and", "x", "==", "searchi", ")", ":", "for", "(", "desc", ",", "tun", ")", "in", "_known", "[", "x", "]", "[", "1", "]", ".", "iteritems", "(", ")", ":", "if", "desc", ".", "find", "(", "searchd", ")", "==", "0", ":", "if", "nr_of_strings", "is", "None", "and", "nr_of_courses", "is", "None", ":", "return", "tun", "elif", "nr_of_strings", "is", "not", "None", "and", "nr_of_courses", "is", "None", ":", "if", "tun", ".", "count_strings", "(", ")", "==", "nr_of_strings", ":", "return", "tun", "elif", "nr_of_strings", "is", "None", "and", "nr_of_courses", "is", "not", "None", ":", "if", "tun", ".", "count_courses", "(", ")", "==", "nr_of_courses", ":", "return", "tun", "else", ":", "if", "tun", ".", "count_courses", "(", ")", "==", "nr_of_courses", "and", "tun", ".", "count_strings", "(", ")", "==", "nr_of_strings", ":", "return", "tun" ]

[ "Get", "the", "first", "tuning", "that", "satisfies", "the", "constraints", "." ]

[ "def", "get_tunings", "(", "instrument", "=", "None", ",", "nr_of_strings", "=", "None", ",", "nr_of_courses", "=", "None", ")", ":", "search", "=", "''", "if", "instrument", "is", "not", "None", ":", "search", "=", "str", ".", "upper", "(", "instrument", ")", "result", "=", "[", "]", "keys", "=", "_known", ".", "keys", "(", ")", "inkeys", "=", "search", "in", "keys", "for", "x", "in", "keys", ":", "if", "(", "instrument", "is", "None", "or", "not", "inkeys", "and", "x", ".", "find", "(", "search", ")", "==", "0", "or", "inkeys", "and", "search", "==", "x", ")", ":", "if", "nr_of_strings", "is", "None", "and", "nr_of_courses", "is", "None", ":", "result", "+=", "_known", "[", "x", "]", "[", "1", "]", ".", "values", "(", ")", "elif", "nr_of_strings", "is", "not", "None", "and", "nr_of_courses", "is", "None", ":", "result", "+=", "[", "y", "for", "y", "in", "_known", "[", "x", "]", "[", "1", "]", ".", "itervalues", "(", ")", "if", "y", ".", "count_strings", "(", ")", "==", "nr_of_strings", "]", "elif", "nr_of_strings", "is", "None", "and", "nr_of_courses", "is", "not", "None", ":", "result", "+=", "[", "y", "for", "y", "in", "_known", "[", "x", "]", "[", "1", "]", ".", "itervalues", "(", ")", "if", "y", ".", "count_courses", "(", ")", "==", "nr_of_courses", "]", "else", ":", "result", "+=", "[", "y", "for", "y", "in", "_known", "[", "x", "]", "[", "1", "]", ".", "itervalues", "(", ")", "if", "y", ".", "count_strings", "(", ")", "==", "nr_of_strings", "and", "y", ".", "count_courses", "(", ")", "==", "nr_of_courses", "]", "return", "result" ]

[ "Search", "tunings", "on", "instrument", "strings", "courses", "or", "a", "combination", "." ]

[ "def", "count_courses", "(", "self", ")", ":", "c", "=", "0", "for", "x", "in", "self", ".", "tuning", ":", "if", "type", "(", "x", ")", "==", "list", ":", "c", "+=", "len", "(", "x", ")", "else", ":", "c", "+=", "1", "return", "float", "(", "c", ")", "/", "len", "(", "self", ".", "tuning", ")" ]

[ "Return", "the", "average", "number", "of", "courses", "per", "string", "." ]

[ "def", "find_frets", "(", "self", ",", "note", ",", "maxfret", "=", "24", ")", ":", "result", "=", "[", "]", "if", "type", "(", "note", ")", "==", "str", ":", "note", "=", "Note", "(", "note", ")", "for", "x", "in", "self", ".", "tuning", ":", "if", "type", "(", "x", ")", "==", "list", ":", "base", "=", "x", "[", "0", "]", "else", ":", "base", "=", "x", "diff", "=", "base", ".", "measure", "(", "note", ")", "if", "0", "<=", "diff", "<=", "maxfret", ":", "result", ".", "append", "(", "diff", ")", "else", ":", "result", ".", "append", "(", "None", ")", "return", "result" ]

[ "Return", "a", "list", "with", "for", "each", "string", "the", "fret", "on", "which", "the", "note", "is", "played", "or", "None", "if", "it", "can", "t", "be", "played", "on", "that", "particular", "string", "." ]

[ "def", "frets_to_NoteContainer", "(", "self", ",", "fingering", ")", ":", "res", "=", "[", "]", "for", "(", "string", ",", "fret", ")", "in", "enumerate", "(", "fingering", ")", ":", "if", "fret", "is", "not", "None", ":", "res", ".", "append", "(", "self", ".", "get_Note", "(", "string", ",", "fret", ")", ")", "return", "NoteContainer", "(", "res", ")" ]

[ "Convert", "a", "list", "such", "as", "returned", "by", "find_fret", "to", "a", "NoteContainer", "." ]

[ "def", "get_Note", "(", "self", ",", "string", "=", "0", ",", "fret", "=", "0", ",", "maxfret", "=", "24", ")", ":", "if", "0", "<=", "string", "<", "self", ".", "count_strings", "(", ")", ":", "if", "0", "<=", "fret", "<=", "maxfret", ":", "s", "=", "self", ".", "tuning", "[", "string", "]", "if", "type", "(", "s", ")", "==", "list", ":", "s", "=", "s", "[", "0", "]", "n", "=", "Note", "(", "int", "(", "s", ")", "+", "fret", ")", "n", ".", "string", "=", "string", "n", ".", "fret", "=", "fret", "return", "n", "else", ":", "raise", "RangeError", "(", "\"Fret '%d' on string '%d' is out of range\"", "%", "(", "string", ",", "fret", ")", ")", "else", ":", "raise", "RangeError", "(", "\"String '%d' out of range\"", "%", "string", ")" ]

[ "Return", "the", "Note", "on", "string", "fret", "." ]

[ "def", "load_img", "(", "name", ")", ":", "fullname", "=", "name", "try", ":", "image", "=", "pygame", ".", "image", ".", "load", "(", "fullname", ")", "if", "image", ".", "get_alpha", "(", ")", "is", "None", ":", "image", "=", "image", ".", "convert", "(", ")", "else", ":", "image", "=", "image", ".", "convert_alpha", "(", ")", "except", "pygame", ".", "error", ",", "message", ":", "print", "\"Error: couldn't load image: \"", ",", "fullname", "raise", "SystemExit", ",", "message", "return", "(", "image", ",", "image", ".", "get_rect", "(", ")", ")" ]

[ "Load", "image", "and", "return", "an", "image", "object" ]

[ "def", "play_note", "(", "note", ")", ":", "index", "=", "None", "if", "note", "==", "Note", "(", "'B'", ",", "2", ")", ":", "index", "=", "0", "elif", "note", "==", "Note", "(", "'A'", ",", "2", ")", ":", "index", "=", "1", "elif", "note", "==", "Note", "(", "'G'", ",", "2", ")", ":", "index", "=", "2", "elif", "note", "==", "Note", "(", "'E'", ",", "2", ")", ":", "index", "=", "3", "elif", "note", "==", "Note", "(", "'C'", ",", "2", ")", ":", "index", "=", "4", "elif", "note", "==", "Note", "(", "'A'", ",", "3", ")", ":", "index", "=", "5", "elif", "note", "==", "Note", "(", "'B'", ",", "3", ")", ":", "index", "=", "6", "elif", "note", "==", "Note", "(", "'A#'", ",", "2", ")", ":", "index", "=", "7", "elif", "note", "==", "Note", "(", "'G#'", ",", "2", ")", ":", "index", "=", "8", "if", "index", "!=", "None", "and", "status", "==", "'record'", ":", "playing", ".", "append", "(", "[", "index", ",", "tick", "]", ")", "recorded", ".", "append", "(", "[", "index", ",", "tick", ",", "note", "]", ")", "recorded_buffer", ".", "append", "(", "[", "index", ",", "tick", "]", ")", "fluidsynth", ".", "play_Note", "(", "note", ",", "9", ",", "100", ")" ]

[ "play_note", "determines", "which", "pad", "was", "hit", "and", "send", "the", "play", "request", "to", "fluidsynth" ]

[ "def", "play_note", "(", "note", ")", ":", "global", "text", "octave_offset", "=", "(", "note", ".", "octave", "-", "LOWEST", ")", "*", "width", "if", "note", ".", "name", "in", "WHITE_KEYS", ":", "# Getting the x coordinate of a white key can be done automatically", "w", "=", "WHITE_KEYS", ".", "index", "(", "note", ".", "name", ")", "*", "white_key_width", "w", "=", "w", "+", "octave_offset", "# Add a list containing the x coordinate, the tick at the current time", "# and of course the note itself to playing_w", "playing_w", ".", "append", "(", "[", "w", ",", "tick", ",", "note", "]", ")", "else", ":", "# For black keys I hard coded the x coordinates. It's ugly.", "i", "=", "BLACK_KEYS", ".", "index", "(", "note", ".", "name", ")", "if", "i", "==", "0", ":", "w", "=", "18", "elif", "i", "==", "1", ":", "w", "=", "58", "elif", "i", "==", "2", ":", "w", "=", "115", "elif", "i", "==", "3", ":", "w", "=", "151", "else", ":", "w", "=", "187", "w", "=", "w", "+", "octave_offset", "playing_b", ".", "append", "(", "[", "w", ",", "tick", ",", "note", "]", ")", "# To find out what sort of chord is being played we have to look at both the", "# white and black keys, obviously:", "notes", "=", "playing_w", "+", "playing_b", "notes", ".", "sort", "(", ")", "notenames", "=", "[", "]", "for", "n", "in", "notes", ":", "notenames", ".", "append", "(", "n", "[", "2", "]", ".", "name", ")", "# Determine the chord", "det", "=", "chords", ".", "determine", "(", "notenames", ")", "if", "det", "!=", "[", "]", ":", "det", "=", "det", "[", "0", "]", "else", ":", "det", "=", "''", "# And render it onto the text surface", "t", "=", "font", ".", "render", "(", "det", ",", "2", ",", "(", "0", ",", "0", ",", "0", ")", ")", "text", ".", "fill", "(", "(", "255", ",", "255", ",", "255", ")", ")", "text", ".", "blit", "(", "t", ",", "(", "0", ",", "0", ")", ")", "# Play the note", "fluidsynth", ".", "play_Note", "(", "note", ",", "channel", ",", "100", ")" ]

[ "play_note", "determines", "the", "coordinates", "of", "a", "note", "on", "the", "keyboard", "image", "and", "sends", "a", "request", "to", "play", "the", "note", "to", "the", "fluidsynth", "server" ]

[ "def", "add_composition", "(", "self", ",", "composition", ")", ":", "if", "not", "hasattr", "(", "composition", ",", "'tracks'", ")", ":", "raise", "UnexpectedObjectError", "(", "\"Object '%s' not expected. Expecting \"", "\"a mingus.containers.Composition object.\"", "%", "composition", ")", "self", ".", "compositions", ".", "append", "(", "composition", ")", "return", "self" ]

[ "Add", "a", "composition", "to", "the", "suite", "." ]

[ "def", "set_author", "(", "self", ",", "author", ",", "email", "=", "''", ")", ":", "self", ".", "author", "=", "author", "self", ".", "email", "=", "email" ]

[ "Set", "the", "author", "of", "the", "suite", "." ]

[ "def", "set_title", "(", "self", ",", "title", ",", "subtitle", "=", "''", ")", ":", "self", ".", "title", "=", "title", "self", ".", "subtitle", "=", "subtitle" ]

[ "Set", "the", "title", "and", "the", "subtitle", "of", "the", "suite", "." ]

[ "def", "set_range", "(", "self", ",", "range", ")", ":", "if", "type", "(", "range", "[", "0", "]", ")", "==", "str", ":", "range", "[", "0", "]", "=", "Note", "(", "range", "[", "0", "]", ")", "range", "[", "1", "]", "=", "Note", "(", "range", "[", "1", "]", ")", "if", "not", "hasattr", "(", "range", "[", "0", "]", ",", "'name'", ")", ":", "raise", "UnexpectedObjectError", "(", "\"Unexpected object '%s'. \"", "\"Expecting a mingus.containers.Note object\"", "%", "range", "[", "0", "]", ")", "self", ".", "range", "=", "range" ]

[ "Set", "the", "range", "of", "the", "instrument", "." ]

[ "def", "note_in_range", "(", "self", ",", "note", ")", ":", "if", "type", "(", "note", ")", "==", "str", ":", "note", "=", "Note", "(", "note", ")", "if", "not", "hasattr", "(", "note", ",", "'name'", ")", ":", "raise", "UnexpectedObjectError", "(", "\"Unexpected object '%s'. \"", "\"Expecting a mingus.containers.Note object\"", "%", "note", ")", "if", "note", ">=", "self", ".", "range", "[", "0", "]", "and", "note", "<=", "self", ".", "range", "[", "1", "]", ":", "return", "True", "return", "False" ]

[ "Test", "whether", "note", "is", "in", "the", "range", "of", "this", "Instrument", "." ]

[ "def", "can_play_notes", "(", "self", ",", "notes", ")", ":", "if", "hasattr", "(", "notes", ",", "'notes'", ")", ":", "notes", "=", "notes", ".", "notes", "if", "type", "(", "notes", ")", "!=", "list", ":", "notes", "=", "[", "notes", "]", "for", "n", "in", "notes", ":", "if", "not", "self", ".", "note_in_range", "(", "n", ")", ":", "return", "False", "return", "True" ]

[ "Test", "if", "the", "notes", "lie", "within", "the", "range", "of", "the", "instrument", "." ]

[ "def", "play_Note", "(", "self", ",", "note", ")", ":", "velocity", "=", "64", "channel", "=", "1", "if", "hasattr", "(", "note", ",", "'dynamics'", ")", ":", "if", "'velocity'", "in", "note", ".", "dynamics", ":", "velocity", "=", "note", ".", "dynamics", "[", "'velocity'", "]", "if", "'channel'", "in", "note", ".", "dynamics", ":", "channel", "=", "note", ".", "dynamics", "[", "'channel'", "]", "if", "hasattr", "(", "note", ",", "'channel'", ")", ":", "channel", "=", "note", ".", "channel", "if", "hasattr", "(", "note", ",", "'velocity'", ")", ":", "velocity", "=", "note", ".", "velocity", "if", "self", ".", "change_instrument", ":", "self", ".", "set_instrument", "(", "channel", ",", "self", ".", "instrument", ")", "self", ".", "change_instrument", "=", "False", "self", ".", "track_data", "+=", "self", ".", "note_on", "(", "channel", ",", "int", "(", "note", ")", "+", "12", ",", "velocity", ")" ]

[ "Convert", "a", "Note", "object", "to", "a", "midi", "event", "and", "adds", "it", "to", "the", "track_data", "." ]

[ "def", "play_NoteContainer", "(", "self", ",", "notecontainer", ")", ":", "if", "len", "(", "notecontainer", ")", "<=", "1", ":", "[", "self", ".", "play_Note", "(", "x", ")", "for", "x", "in", "notecontainer", "]", "else", ":", "self", ".", "play_Note", "(", "notecontainer", "[", "0", "]", ")", "self", ".", "set_deltatime", "(", "0", ")", "[", "self", ".", "play_Note", "(", "x", ")", "for", "x", "in", "notecontainer", "[", "1", ":", "]", "]" ]

[ "Convert", "a", "mingus", ".", "containers", ".", "NoteContainer", "to", "the", "equivalent", "MIDI", "events", "and", "add", "it", "to", "the", "track_data", "." ]

[ "def", "play_Bar", "(", "self", ",", "bar", ")", ":", "self", ".", "set_deltatime", "(", "self", ".", "delay", ")", "self", ".", "delay", "=", "0", "self", ".", "set_meter", "(", "bar", ".", "meter", ")", "self", ".", "set_deltatime", "(", "0", ")", "self", ".", "set_key", "(", "bar", ".", "key", ")", "for", "x", "in", "bar", ":", "tick", "=", "int", "(", "round", "(", "(", "1.0", "/", "x", "[", "1", "]", ")", "*", "288", ")", ")", "if", "x", "[", "2", "]", "is", "None", "or", "len", "(", "x", "[", "2", "]", ")", "==", "0", ":", "self", ".", "delay", "+=", "tick", "else", ":", "self", ".", "set_deltatime", "(", "self", ".", "delay", ")", "self", ".", "delay", "=", "0", "if", "hasattr", "(", "x", "[", "2", "]", ",", "'bpm'", ")", ":", "self", ".", "set_deltatime", "(", "0", ")", "self", ".", "set_tempo", "(", "x", "[", "2", "]", ".", "bpm", ")", "self", ".", "play_NoteContainer", "(", "x", "[", "2", "]", ")", "self", ".", "set_deltatime", "(", "self", ".", "int_to_varbyte", "(", "tick", ")", ")", "self", ".", "stop_NoteContainer", "(", "x", "[", "2", "]", ")" ]

[ "Convert", "a", "Bar", "object", "to", "MIDI", "events", "and", "write", "them", "to", "the", "track_data", "." ]

[ "def", "play_Track", "(", "self", ",", "track", ")", ":", "if", "hasattr", "(", "track", ",", "'name'", ")", ":", "self", ".", "set_track_name", "(", "track", ".", "name", ")", "self", ".", "delay", "=", "0", "instr", "=", "track", ".", "instrument", "if", "hasattr", "(", "instr", ",", "'instrument_nr'", ")", ":", "self", ".", "change_instrument", "=", "True", "self", ".", "instrument", "=", "instr", ".", "instrument_nr", "for", "bar", "in", "track", ":", "self", ".", "play_Bar", "(", "bar", ")" ]

[ "Convert", "a", "Track", "object", "to", "MIDI", "events", "and", "write", "them", "to", "the", "track_data", "." ]

[ "def", "stop_Note", "(", "self", ",", "note", ")", ":", "velocity", "=", "64", "channel", "=", "1", "if", "hasattr", "(", "note", ",", "'dynamics'", ")", ":", "if", "'velocity'", "in", "note", ".", "dynamics", ":", "velocity", "=", "note", ".", "dynamics", "[", "'velocity'", "]", "if", "'channel'", "in", "note", ".", "dynamics", ":", "channel", "=", "note", ".", "dynamics", "[", "'channel'", "]", "if", "hasattr", "(", "note", ",", "'channel'", ")", ":", "channel", "=", "note", ".", "channel", "if", "hasattr", "(", "note", ",", "'velocity'", ")", ":", "velocity", "=", "note", ".", "velocity", "self", ".", "track_data", "+=", "self", ".", "note_off", "(", "channel", ",", "int", "(", "note", ")", "+", "12", ",", "velocity", ")" ]

[ "Add", "a", "note_off", "event", "for", "note", "to", "event_track", "." ]

[ "def", "stop_NoteContainer", "(", "self", ",", "notecontainer", ")", ":", "# if there is more than one note in the container, the deltatime should", "# be set back to zero after the first one has been stopped", "if", "len", "(", "notecontainer", ")", "<=", "1", ":", "[", "self", ".", "stop_Note", "(", "x", ")", "for", "x", "in", "notecontainer", "]", "else", ":", "self", ".", "stop_Note", "(", "notecontainer", "[", "0", "]", ")", "self", ".", "set_deltatime", "(", "0", ")", "[", "self", ".", "stop_Note", "(", "x", ")", "for", "x", "in", "notecontainer", "[", "1", ":", "]", "]" ]

[ "Add", "note_off", "events", "for", "each", "note", "in", "the", "NoteContainer", "to", "the", "track_data", "." ]

[ "def", "set_instrument", "(", "self", ",", "channel", ",", "instr", ",", "bank", "=", "1", ")", ":", "self", ".", "track_data", "+=", "self", ".", "select_bank", "(", "channel", ",", "bank", ")", "self", ".", "track_data", "+=", "self", ".", "program_change_event", "(", "channel", ",", "instr", ")" ]

[ "Add", "a", "program", "change", "and", "bank", "select", "event", "to", "the", "track_data", "." ]

[ "def", "header", "(", "self", ")", ":", "chunk_size", "=", "a2b_hex", "(", "'%08x'", "%", "(", "len", "(", "self", ".", "track_data", ")", "+", "len", "(", "self", ".", "end_of_track", "(", ")", ")", ")", ")", "return", "TRACK_HEADER", "+", "chunk_size" ]

[ "Return", "the", "bytes", "for", "the", "header", "of", "track", "." ]

[ "def", "midi_event", "(", "self", ",", "event_type", ",", "channel", ",", "param1", ",", "param2", "=", "None", ")", ":", "assert", "event_type", "<", "0x80", "and", "event_type", ">=", "0", "assert", "channel", "<", "16", "and", "channel", ">=", "0", "tc", "=", "a2b_hex", "(", "'%x%x'", "%", "(", "event_type", ",", "channel", ")", ")", "if", "param2", "is", "None", ":", "params", "=", "a2b_hex", "(", "'%02x'", "%", "param1", ")", "else", ":", "params", "=", "a2b_hex", "(", "'%02x%02x'", "%", "(", "param1", ",", "param2", ")", ")", "return", "self", ".", "delta_time", "+", "tc", "+", "params" ]

[ "Convert", "and", "return", "the", "paraters", "as", "a", "MIDI", "event", "in", "bytes", "." ]

[ "def", "note_off", "(", "self", ",", "channel", ",", "note", ",", "velocity", ")", ":", "return", "self", ".", "midi_event", "(", "NOTE_OFF", ",", "channel", ",", "note", ",", "velocity", ")" ]

[ "Return", "bytes", "for", "a", "note", "off", "event", "." ]

[ "def", "note_on", "(", "self", ",", "channel", ",", "note", ",", "velocity", ")", ":", "return", "self", ".", "midi_event", "(", "NOTE_ON", ",", "channel", ",", "note", ",", "velocity", ")" ]

[ "Return", "bytes", "for", "a", "note_on", "event", "." ]

[ "def", "controller_event", "(", "self", ",", "channel", ",", "contr_nr", ",", "contr_val", ")", ":", "return", "self", ".", "midi_event", "(", "CONTROLLER", ",", "channel", ",", "contr_nr", ",", "contr_val", ")" ]

[ "Return", "the", "bytes", "for", "a", "MIDI", "controller", "event", "." ]

[ "def", "set_deltatime", "(", "self", ",", "delta_time", ")", ":", "if", "type", "(", "delta_time", ")", "==", "int", ":", "delta_time", "=", "self", ".", "int_to_varbyte", "(", "delta_time", ")", "self", ".", "delta_time", "=", "delta_time" ]

[ "Set", "the", "delta_time", "." ]

[ "def", "set_tempo", "(", "self", ",", "bpm", ")", ":", "self", ".", "bpm", "=", "bpm", "self", ".", "track_data", "+=", "self", ".", "set_tempo_event", "(", "self", ".", "bpm", ")" ]

[ "Convert", "the", "bpm", "to", "a", "midi", "event", "and", "write", "it", "to", "the", "track_data", "." ]

[ "def", "set_tempo_event", "(", "self", ",", "bpm", ")", ":", "ms_per_min", "=", "60000000", "mpqn", "=", "a2b_hex", "(", "'%06x'", "%", "(", "ms_per_min", "/", "bpm", ")", ")", "return", "self", ".", "delta_time", "+", "META_EVENT", "+", "SET_TEMPO", "+", "'\\x03'", "+", "mpqn" ]

[ "Calculate", "the", "microseconds", "per", "quarter", "note", "." ]

[ "def", "time_signature_event", "(", "self", ",", "meter", "=", "(", "4", ",", "4", ")", ")", ":", "numer", "=", "a2b_hex", "(", "'%02x'", "%", "meter", "[", "0", "]", ")", "denom", "=", "a2b_hex", "(", "'%02x'", "%", "int", "(", "log", "(", "meter", "[", "1", "]", ",", "2", ")", ")", ")", "return", "self", ".", "delta_time", "+", "META_EVENT", "+", "TIME_SIGNATURE", "+", "'\\x04'", "+", "numer", "+", "denom", "+", "'\\x18\\x08'" ]

[ "Return", "a", "time", "signature", "event", "for", "meter", "." ]

[ "def", "set_key", "(", "self", ",", "key", "=", "'C'", ")", ":", "if", "isinstance", "(", "key", ",", "Key", ")", ":", "key", "=", "key", ".", "name", "[", "0", "]", "self", ".", "track_data", "+=", "self", ".", "key_signature_event", "(", "key", ")" ]

[ "Add", "a", "key", "signature", "event", "to", "the", "track_data", "." ]

[ "def", "key_signature_event", "(", "self", ",", "key", "=", "'C'", ")", ":", "if", "key", ".", "islower", "(", ")", ":", "val", "=", "minor_keys", ".", "index", "(", "key", ")", "-", "7", "mode", "=", "'\\x01'", "else", ":", "val", "=", "major_keys", ".", "index", "(", "key", ")", "-", "7", "mode", "=", "'\\x00'", "if", "val", "<", "0", ":", "val", "=", "256", "+", "val", "key", "=", "a2b_hex", "(", "'%02x'", "%", "val", ")", "return", "'{0}{1}{2}\\x02{3}{4}'", ".", "format", "(", "self", ".", "delta_time", ",", "META_EVENT", ",", "KEY_SIGNATURE", ",", "key", ",", "mode", ")" ]

[ "Return", "the", "bytes", "for", "a", "key", "signature", "event", "." ]

[ "def", "track_name_event", "(", "self", ",", "name", ")", ":", "l", "=", "self", ".", "int_to_varbyte", "(", "len", "(", "name", ")", ")", "return", "'\\x00'", "+", "META_EVENT", "+", "TRACK_NAME", "+", "l", "+", "name" ]

[ "Return", "the", "bytes", "for", "a", "track", "name", "meta", "event", "." ]

[ "def", "int_to_varbyte", "(", "self", ",", "value", ")", ":", "# Warning: bit kung-fu ahead. The length of the integer in bytes", "length", "=", "int", "(", "log", "(", "max", "(", "value", ",", "1", ")", ",", "0x80", ")", ")", "+", "1", "# Remove the highest bit and move the bits to the right if length > 1", "bytes", "=", "[", "value", ">>", "i", "*", "7", "&", "0x7F", "for", "i", "in", "range", "(", "length", ")", "]", "bytes", ".", "reverse", "(", ")", "# Set the first bit on every one but the last bit.", "for", "i", "in", "range", "(", "len", "(", "bytes", ")", "-", "1", ")", ":", "bytes", "[", "i", "]", "=", "bytes", "[", "i", "]", "|", "0x80", "return", "pack", "(", "'%sB'", "%", "len", "(", "bytes", ")", ",", "*", "bytes", ")" ]

[ "Convert", "an", "integer", "into", "a", "variable", "length", "byte", "." ]

[ "def", "to_chords", "(", "progression", ",", "key", "=", "'C'", ")", ":", "if", "type", "(", "progression", ")", "==", "str", ":", "progression", "=", "[", "progression", "]", "result", "=", "[", "]", "for", "chord", "in", "progression", ":", "# strip preceding accidentals from the string", "(", "roman_numeral", ",", "acc", ",", "suffix", ")", "=", "parse_string", "(", "chord", ")", "# There is no roman numeral parsing, just a simple check. Sorry to", "# disappoint. warning Should throw exception", "if", "roman_numeral", "not", "in", "numerals", ":", "return", "[", "]", "# These suffixes don't need any post processing", "if", "suffix", "==", "'7'", "or", "suffix", "==", "''", ":", "roman_numeral", "+=", "suffix", "# ahh Python. Everything is a dict.", "r", "=", "chords", ".", "__dict__", "[", "roman_numeral", "]", "(", "key", ")", "else", ":", "r", "=", "chords", ".", "__dict__", "[", "roman_numeral", "]", "(", "key", ")", "r", "=", "chords", ".", "chord_shorthand", "[", "suffix", "]", "(", "r", "[", "0", "]", ")", "while", "acc", "<", "0", ":", "r", "=", "map", "(", "notes", ".", "diminish", ",", "r", ")", "acc", "+=", "1", "while", "acc", ">", "0", ":", "r", "=", "map", "(", "notes", ".", "augment", ",", "r", ")", "acc", "-=", "1", "result", ".", "append", "(", "r", ")", "return", "result" ]

[ "Convert", "a", "list", "of", "chord", "functions", "or", "a", "string", "to", "a", "list", "of", "chords", "." ]

[ "def", "determine", "(", "chord", ",", "key", ",", "shorthand", "=", "False", ")", ":", "result", "=", "[", "]", "# Handle lists of chords", "if", "type", "(", "chord", "[", "0", "]", ")", "==", "list", ":", "for", "c", "in", "chord", ":", "result", ".", "append", "(", "determine", "(", "c", ",", "key", ",", "shorthand", ")", ")", "return", "result", "func_dict", "=", "{", "'I'", ":", "'tonic'", ",", "'ii'", ":", "'supertonic'", ",", "'iii'", ":", "'mediant'", ",", "'IV'", ":", "'subdominant'", ",", "'V'", ":", "'dominant'", ",", "'vi'", ":", "'submediant'", ",", "'vii'", ":", "'subtonic'", ",", "}", "expected_chord", "=", "[", "[", "'I'", ",", "'M'", ",", "'M7'", "]", ",", "[", "'ii'", ",", "'m'", ",", "'m7'", "]", ",", "[", "'iii'", ",", "'m'", ",", "'m7'", "]", ",", "[", "'IV'", ",", "'M'", ",", "'M7'", "]", ",", "[", "'V'", ",", "'M'", ",", "'7'", "]", ",", "[", "'vi'", ",", "'m'", ",", "'m7'", "]", ",", "[", "'vii'", ",", "'dim'", ",", "'m7b5'", "]", ",", "]", "type_of_chord", "=", "chords", ".", "determine", "(", "chord", ",", "True", ",", "False", ",", "True", ")", "for", "chord", "in", "type_of_chord", ":", "name", "=", "chord", "[", "0", "]", "# Get accidentals", "a", "=", "1", "for", "n", "in", "chord", "[", "1", ":", "]", ":", "if", "n", "==", "'b'", ":", "name", "+=", "'b'", "elif", "n", "==", "'#'", ":", "name", "+=", "'#'", "else", ":", "break", "a", "+=", "1", "chord_type", "=", "chord", "[", "a", ":", "]", "# Determine chord function", "(", "interval_type", ",", "interval", ")", "=", "intervals", ".", "determine", "(", "key", ",", "name", ")", ".", "split", "(", "' '", ")", "if", "interval", "==", "'unison'", ":", "func", "=", "'I'", "elif", "interval", "==", "'second'", ":", "func", "=", "'ii'", "elif", "interval", "==", "'third'", ":", "func", "=", "'iii'", "elif", "interval", "==", "'fourth'", ":", "func", "=", "'IV'", "elif", "interval", "==", "'fifth'", ":", "func", "=", "'V'", "elif", "interval", "==", "'sixth'", ":", "func", "=", "'vi'", "elif", "interval", "==", "'seventh'", ":", "func", "=", "'vii'", "# Check whether the chord is altered or not", "for", "x", "in", "expected_chord", ":", "if", "x", "[", "0", "]", "==", "func", ":", "# Triads", "if", "chord_type", "==", "x", "[", "1", "]", ":", "if", "not", "shorthand", ":", "func", "=", "func_dict", "[", "func", "]", "elif", "chord_type", "==", "x", "[", "2", "]", ":", "# Sevenths", "if", "shorthand", ":", "func", "+=", "'7'", "else", ":", "func", "=", "func_dict", "[", "func", "]", "+", "' seventh'", "else", ":", "# Other", "if", "shorthand", ":", "func", "+=", "chord_type", "else", ":", "func", "=", "func_dict", "[", "func", "]", "+", "chords", ".", "chord_shorthand_meaning", "[", "chord_type", "]", "# Handle b's and #'s (for instance Dbm in key C is bII)", "if", "shorthand", ":", "if", "interval_type", "==", "'minor'", ":", "func", "=", "'b'", "+", "func", "elif", "interval_type", "==", "'augmented'", ":", "func", "=", "'#'", "+", "func", "elif", "interval_type", "==", "'diminished'", ":", "func", "=", "'bb'", "+", "func", "else", ":", "if", "interval_type", "==", "'minor'", ":", "func", "=", "'minor '", "+", "func", "elif", "interval_type", "==", "'augmented'", ":", "func", "=", "'augmented '", "+", "func", "elif", "interval_type", "==", "'diminished'", ":", "func", "=", "'diminished '", "+", "func", "# Add to results", "result", ".", "append", "(", "func", ")", "return", "result" ]

[ "Determine", "the", "harmonic", "function", "of", "chord", "in", "key", "." ]

[ "def", "tuple_to_string", "(", "prog_tuple", ")", ":", "(", "roman", ",", "acc", ",", "suff", ")", "=", "prog_tuple", "if", "acc", ">", "6", ":", "acc", "=", "0", "-", "acc", "%", "6", "elif", "acc", "<", "-", "6", ":", "acc", "=", "acc", "%", "6", "while", "acc", "<", "0", ":", "roman", "=", "'b'", "+", "roman", "acc", "+=", "1", "while", "acc", ">", "0", ":", "roman", "=", "'#'", "+", "roman", "acc", "-=", "1", "return", "roman", "+", "suff" ]

[ "Create", "a", "string", "from", "tuples", "returned", "by", "parse_string", "." ]

[ "def", "substitute_minor_for_major", "(", "progression", ",", "substitute_index", ",", "ignore_suffix", "=", "False", ")", ":", "(", "roman", ",", "acc", ",", "suff", ")", "=", "parse_string", "(", "progression", "[", "substitute_index", "]", ")", "res", "=", "[", "]", "# Minor to major substitution", "if", "suff", "==", "'m'", "or", "suff", "==", "'m7'", "or", "suff", "==", "''", "and", "roman", "in", "[", "'II'", ",", "'III'", ",", "'VI'", "]", "or", "ignore_suffix", ":", "n", "=", "skip", "(", "roman", ",", "2", ")", "a", "=", "interval_diff", "(", "roman", ",", "n", ",", "3", ")", "+", "acc", "if", "suff", "==", "'m'", "or", "ignore_suffix", ":", "res", ".", "append", "(", "tuple_to_string", "(", "(", "n", ",", "a", ",", "'M'", ")", ")", ")", "elif", "suff", "==", "'m7'", "or", "ignore_suffix", ":", "res", ".", "append", "(", "tuple_to_string", "(", "(", "n", ",", "a", ",", "'M7'", ")", ")", ")", "elif", "suff", "==", "''", "or", "ignore_suffix", ":", "res", ".", "append", "(", "tuple_to_string", "(", "(", "n", ",", "a", ",", "''", ")", ")", ")", "return", "res" ]

[ "Substitute", "minor", "chords", "for", "its", "major", "equivalent", "." ]

[ "def", "substitute_diminished_for_diminished", "(", "progression", ",", "substitute_index", ",", "ignore_suffix", "=", "False", ")", ":", "(", "roman", ",", "acc", ",", "suff", ")", "=", "parse_string", "(", "progression", "[", "substitute_index", "]", ")", "res", "=", "[", "]", "# Diminished progressions", "if", "suff", "==", "'dim7'", "or", "suff", "==", "'dim'", "or", "suff", "==", "''", "and", "roman", "in", "[", "'VII'", "]", "or", "ignore_suffix", ":", "if", "suff", "==", "''", ":", "suff", "=", "'dim'", "# Add diminished chord", "last", "=", "roman", "for", "x", "in", "range", "(", "3", ")", ":", "next", "=", "skip", "(", "last", ",", "2", ")", "acc", "+=", "interval_diff", "(", "last", ",", "next", ",", "3", ")", "res", ".", "append", "(", "tuple_to_string", "(", "(", "next", ",", "acc", ",", "suff", ")", ")", ")", "last", "=", "next", "return", "res" ]

[ "Substitute", "a", "diminished", "chord", "for", "another", "diminished", "chord", "." ]

[ "def", "interval_diff", "(", "progression1", ",", "progression2", ",", "interval", ")", ":", "i", "=", "numeral_intervals", "[", "numerals", ".", "index", "(", "progression1", ")", "]", "j", "=", "numeral_intervals", "[", "numerals", ".", "index", "(", "progression2", ")", "]", "acc", "=", "0", "if", "j", "<", "i", ":", "j", "+=", "12", "while", "j", "-", "i", ">", "interval", ":", "acc", "-=", "1", "j", "-=", "1", "while", "j", "-", "i", "<", "interval", ":", "acc", "+=", "1", "j", "+=", "1", "return", "acc" ]

[ "Return", "the", "number", "of", "half", "steps", "progression2", "needs", "to", "be", "diminished", "or", "augmented", "until", "the", "interval", "between", "progression1", "and", "progression2", "is", "interval", "." ]

[ "def", "skip", "(", "roman_numeral", ",", "skip", "=", "1", ")", ":", "i", "=", "numerals", ".", "index", "(", "roman_numeral", ")", "+", "skip", "return", "numerals", "[", "i", "%", "7", "]" ]

[ "Skip", "the", "given", "places", "to", "the", "next", "roman", "numeral", "." ]

[ "def", "add_note", "(", "self", ",", "note", ",", "octave", "=", "None", ",", "dynamics", "=", "{", "}", ")", ":", "if", "type", "(", "note", ")", "==", "str", ":", "if", "octave", "is", "not", "None", ":", "note", "=", "Note", "(", "note", ",", "octave", ",", "dynamics", ")", "elif", "len", "(", "self", ".", "notes", ")", "==", "0", ":", "note", "=", "Note", "(", "note", ",", "4", ",", "dynamics", ")", "else", ":", "if", "Note", "(", "note", ",", "self", ".", "notes", "[", "-", "1", "]", ".", "octave", ")", "<", "self", ".", "notes", "[", "-", "1", "]", ":", "note", "=", "Note", "(", "note", ",", "self", ".", "notes", "[", "-", "1", "]", ".", "octave", "+", "1", ",", "dynamics", ")", "else", ":", "note", "=", "Note", "(", "note", ",", "self", ".", "notes", "[", "-", "1", "]", ".", "octave", ",", "dynamics", ")", "if", "not", "hasattr", "(", "note", ",", "'name'", ")", ":", "raise", "UnexpectedObjectError", "(", "\"Object '%s' was not expected. \"", "\"Expecting a mingus.containers.Note object.\"", "%", "note", ")", "if", "note", "not", "in", "self", ".", "notes", ":", "self", ".", "notes", ".", "append", "(", "note", ")", "self", ".", "notes", ".", "sort", "(", ")", "return", "self", ".", "notes" ]

[ "Add", "a", "note", "to", "the", "container", "and", "sorts", "the", "notes", "from", "low", "to", "high", "." ]

[ "def", "add_notes", "(", "self", ",", "notes", ")", ":", "if", "hasattr", "(", "notes", ",", "'notes'", ")", ":", "for", "x", "in", "notes", ".", "notes", ":", "self", ".", "add_note", "(", "x", ")", "return", "self", ".", "notes", "elif", "hasattr", "(", "notes", ",", "'name'", ")", ":", "self", ".", "add_note", "(", "notes", ")", "return", "self", ".", "notes", "elif", "type", "(", "notes", ")", "==", "str", ":", "self", ".", "add_note", "(", "notes", ")", "return", "self", ".", "notes", "for", "x", "in", "notes", ":", "if", "type", "(", "x", ")", "==", "list", "and", "len", "(", "x", ")", "!=", "1", ":", "if", "len", "(", "x", ")", "==", "2", ":", "self", ".", "add_note", "(", "x", "[", "0", "]", ",", "x", "[", "1", "]", ")", "else", ":", "self", ".", "add_note", "(", "x", "[", "0", "]", ",", "x", "[", "1", "]", ",", "x", "[", "2", "]", ")", "else", ":", "self", ".", "add_note", "(", "x", ")", "return", "self", ".", "notes" ]

[ "Feed", "notes", "to", "self", ".", "add_note", "." ]

[ "def", "from_chord_shorthand", "(", "self", ",", "shorthand", ")", ":", "self", ".", "empty", "(", ")", "self", ".", "add_notes", "(", "chords", ".", "from_shorthand", "(", "shorthand", ")", ")", "return", "self" ]

[ "Empty", "the", "container", "and", "add", "the", "notes", "in", "the", "shorthand", "." ]

[ "def", "from_interval", "(", "self", ",", "startnote", ",", "shorthand", ",", "up", "=", "True", ")", ":", "return", "self", ".", "from_interval_shorthand", "(", "startnote", ",", "shorthand", ",", "up", ")" ]

[ "Shortcut", "to", "from_interval_shorthand", "." ]

[ "def", "from_interval_shorthand", "(", "self", ",", "startnote", ",", "shorthand", ",", "up", "=", "True", ")", ":", "self", ".", "empty", "(", ")", "if", "type", "(", "startnote", ")", "==", "str", ":", "startnote", "=", "Note", "(", "startnote", ")", "n", "=", "Note", "(", "startnote", ".", "name", ",", "startnote", ".", "octave", ",", "startnote", ".", "dynamics", ")", "n", ".", "transpose", "(", "shorthand", ",", "up", ")", "self", ".", "add_notes", "(", "[", "startnote", ",", "n", "]", ")", "return", "self" ]

[ "Empty", "the", "container", "and", "add", "the", "note", "described", "in", "the", "startnote", "and", "shorthand", "." ]

[ "def", "remove_note", "(", "self", ",", "note", ",", "octave", "=", "-", "1", ")", ":", "res", "=", "[", "]", "for", "x", "in", "self", ".", "notes", ":", "if", "type", "(", "note", ")", "==", "str", ":", "if", "x", ".", "name", "!=", "note", ":", "res", ".", "append", "(", "x", ")", "else", ":", "if", "x", ".", "octave", "!=", "octave", "and", "octave", "!=", "-", "1", ":", "res", ".", "append", "(", "x", ")", "else", ":", "if", "x", "!=", "note", ":", "res", ".", "append", "(", "x", ")", "self", ".", "notes", "=", "res", "return", "res" ]

[ "Remove", "note", "from", "container", "." ]

[ "def", "remove_notes", "(", "self", ",", "notes", ")", ":", "if", "type", "(", "notes", ")", "==", "str", ":", "return", "self", ".", "remove_note", "(", "notes", ")", "elif", "hasattr", "(", "notes", ",", "'name'", ")", ":", "return", "self", ".", "remove_note", "(", "notes", ")", "else", ":", "map", "(", "lambda", "x", ":", "self", ".", "remove_note", "(", "x", ")", ",", "notes", ")", "return", "self", ".", "notes" ]

[ "Remove", "notes", "from", "the", "containers", "." ]

[ "def", "remove_duplicate_notes", "(", "self", ")", ":", "res", "=", "[", "]", "for", "x", "in", "self", ".", "notes", ":", "if", "x", "not", "in", "res", ":", "res", ".", "append", "(", "x", ")", "self", ".", "notes", "=", "res", "return", "res" ]

[ "Remove", "duplicate", "and", "enharmonic", "notes", "from", "the", "container", "." ]

[ "def", "transpose", "(", "self", ",", "interval", ",", "up", "=", "True", ")", ":", "for", "n", "in", "self", ".", "notes", ":", "n", ".", "transpose", "(", "interval", ",", "up", ")", "return", "self" ]

[ "Transpose", "all", "the", "notes", "in", "the", "container", "up", "or", "down", "the", "given", "interval", "." ]

[ "def", "get_note_names", "(", "self", ")", ":", "res", "=", "[", "]", "for", "n", "in", "self", ".", "notes", ":", "if", "n", ".", "name", "not", "in", "res", ":", "res", ".", "append", "(", "n", ".", "name", ")", "return", "res" ]

[ "Return", "a", "list", "with", "all", "the", "note", "names", "in", "the", "current", "container", "." ]

[ "def", "determine", "(", "notes", ")", ":", "notes", "=", "set", "(", "notes", ")", "res", "=", "[", "]", "for", "key", "in", "keys", ":", "for", "scale", "in", "_Scale", ".", "__subclasses__", "(", ")", ":", "if", "scale", ".", "type", "==", "'major'", ":", "if", "(", "notes", "<=", "set", "(", "scale", "(", "key", "[", "0", "]", ")", ".", "ascending", "(", ")", ")", "or", "notes", "<=", "set", "(", "scale", "(", "key", "[", "0", "]", ")", ".", "descending", "(", ")", ")", ")", ":", "res", ".", "append", "(", "scale", "(", "key", "[", "0", "]", ")", ".", "name", ")", "elif", "scale", ".", "type", "==", "'minor'", ":", "if", "(", "notes", "<=", "set", "(", "scale", "(", "get_notes", "(", "key", "[", "1", "]", ")", "[", "0", "]", ")", ".", "ascending", "(", ")", ")", "or", "notes", "<=", "set", "(", "scale", "(", "get_notes", "(", "key", "[", "1", "]", ")", "[", "0", "]", ")", ".", "descending", "(", ")", ")", ")", ":", "res", ".", "append", "(", "scale", "(", "get_notes", "(", "key", "[", "1", "]", ")", "[", "0", "]", ")", ".", "name", ")", "return", "res" ]

[ "Determine", "the", "scales", "containing", "the", "notes", "." ]

[ "def", "degree", "(", "self", ",", "degree_number", ",", "direction", "=", "'a'", ")", ":", "if", "degree_number", "<", "1", ":", "raise", "RangeError", "(", "\"degree '%s' out of range\"", "%", "degree_number", ")", "if", "direction", "==", "'a'", ":", "notes", "=", "self", ".", "ascending", "(", ")", "[", ":", "-", "1", "]", "return", "notes", "[", "degree_number", "-", "1", "]", "elif", "direction", "==", "'d'", ":", "notes", "=", "reversed", "(", "self", ".", "descending", "(", ")", ")", "[", ":", "-", "1", "]", "return", "notes", "[", "degree_number", "-", "1", "]", "else", ":", "raise", "FormatError", "(", "\"Unrecognised direction '%s'\"", "%", "direction", ")" ]

[ "Return", "the", "asked", "scale", "degree", "." ]

[ "def", "begin_track", "(", "tuning", ",", "padding", "=", "2", ")", ":", "# find longest shorthand tuning base", "names", "=", "[", "x", ".", "to_shorthand", "(", ")", "for", "x", "in", "tuning", ".", "tuning", "]", "basesize", "=", "len", "(", "max", "(", "names", ")", ")", "+", "3", "# Build result", "res", "=", "[", "]", "for", "x", "in", "names", ":", "r", "=", "' %s'", "%", "x", "spaces", "=", "basesize", "-", "len", "(", "r", ")", "r", "+=", "' '", "*", "spaces", "+", "'||'", "+", "'-'", "*", "padding", "res", ".", "append", "(", "r", ")", "return", "res" ]

[ "Helper", "function", "that", "builds", "the", "first", "few", "characters", "of", "every", "bar", "." ]

[ "def", "add_headers", "(", "width", "=", "80", ",", "title", "=", "'Untitled'", ",", "subtitle", "=", "''", ",", "author", "=", "''", ",", "email", "=", "''", ",", "description", "=", "''", ",", "tunings", "=", "[", "]", ")", ":", "result", "=", "[", "''", "]", "title", "=", "str", ".", "upper", "(", "title", ")", "result", "+=", "[", "str", ".", "center", "(", "' '", ".", "join", "(", "title", ")", ",", "width", ")", "]", "if", "subtitle", "!=", "''", ":", "result", "+=", "[", "''", ",", "str", ".", "center", "(", "str", ".", "title", "(", "subtitle", ")", ",", "width", ")", "]", "if", "author", "!=", "''", "or", "email", "!=", "''", ":", "result", "+=", "[", "''", ",", "''", "]", "if", "email", "!=", "''", ":", "result", "+=", "[", "str", ".", "center", "(", "'Written by: %s <%s>'", "%", "(", "author", ",", "email", ")", ",", "width", ")", "]", "else", ":", "result", "+=", "[", "str", ".", "center", "(", "'Written by: %s'", "%", "author", ",", "width", ")", "]", "if", "description", "!=", "''", ":", "result", "+=", "[", "''", ",", "''", "]", "words", "=", "description", ".", "split", "(", ")", "lines", "=", "[", "]", "line", "=", "[", "]", "last", "=", "0", "for", "word", "in", "words", ":", "if", "len", "(", "word", ")", "+", "last", "<", "width", "-", "10", ":", "line", ".", "append", "(", "word", ")", "last", "+=", "len", "(", "word", ")", "+", "1", "else", ":", "lines", ".", "append", "(", "line", ")", "line", "=", "[", "word", "]", "last", "=", "len", "(", "word", ")", "+", "1", "lines", ".", "append", "(", "line", ")", "for", "line", "in", "lines", ":", "result", "+=", "[", "str", ".", "center", "(", "' '", ".", "join", "(", "line", ")", ",", "width", ")", "]", "if", "tunings", "!=", "[", "]", ":", "result", "+=", "[", "''", ",", "''", ",", "str", ".", "center", "(", "'Instruments'", ",", "width", ")", "]", "for", "(", "i", ",", "tuning", ")", "in", "enumerate", "(", "tunings", ")", ":", "result", "+=", "[", "''", ",", "str", ".", "center", "(", "'%d. %s'", "%", "(", "i", "+", "1", ",", "tuning", ".", "instrument", ")", ",", "width", ")", ",", "str", ".", "center", "(", "tuning", ".", "description", ",", "width", ")", "]", "result", "+=", "[", "''", ",", "''", "]", "return", "result" ]

[ "Create", "a", "nice", "header", "in", "the", "form", "of", "a", "list", "of", "strings", "using", "the", "information", "that", "has", "been", "filled", "in", "." ]

[ "def", "from_Note", "(", "note", ",", "width", "=", "80", ",", "tuning", "=", "None", ")", ":", "if", "tuning", "is", "None", ":", "tuning", "=", "default_tuning", "result", "=", "begin_track", "(", "tuning", ")", "min", "=", "1000", "(", "s", ",", "f", ")", "=", "(", "-", "1", ",", "-", "1", ")", "# Do an attribute check", "if", "hasattr", "(", "note", ",", "'string'", ")", "and", "hasattr", "(", "note", ",", "'fret'", ")", ":", "n", "=", "tuning", ".", "get_Note", "(", "note", ".", "string", ",", "note", ".", "fret", ")", "if", "n", "is", "not", "None", "and", "int", "(", "n", ")", "==", "int", "(", "note", ")", ":", "(", "s", ",", "f", ")", "=", "(", "note", ".", "string", ",", "note", ".", "fret", ")", "min", "=", "0", "if", "min", "==", "1000", ":", "for", "(", "string", ",", "fret", ")", "in", "enumerate", "(", "tuning", ".", "find_frets", "(", "note", ")", ")", ":", "if", "fret", "is", "not", "None", ":", "if", "fret", "<", "min", ":", "min", "=", "fret", "(", "s", ",", "f", ")", "=", "(", "string", ",", "fret", ")", "l", "=", "len", "(", "result", "[", "0", "]", ")", "w", "=", "max", "(", "4", ",", "(", "width", "-", "l", ")", "-", "1", ")", "# Build ASCII", "if", "min", "!=", "1000", ":", "fret", "=", "str", "(", "f", ")", "for", "i", "in", "range", "(", "len", "(", "result", ")", ")", ":", "d", "=", "len", "(", "fret", ")", "if", "i", "!=", "s", ":", "result", "[", "i", "]", "+=", "'-'", "*", "w", "+", "'|'", "else", ":", "d", "=", "w", "-", "len", "(", "fret", ")", "result", "[", "i", "]", "+=", "'-'", "*", "(", "d", "/", "2", ")", "+", "fret", "d", "=", "(", "w", "-", "d", "/", "2", ")", "-", "len", "(", "fret", ")", "result", "[", "i", "]", "+=", "'-'", "*", "d", "+", "'|'", "else", ":", "raise", "RangeError", "(", "\"No fret found that could play note '%s'. \"", "\"Note out of range.\"", "%", "note", ")", "result", ".", "reverse", "(", ")", "return", "os", ".", "linesep", ".", "join", "(", "result", ")" ]

[ "Return", "a", "string", "made", "out", "of", "ASCII", "tablature", "representing", "a", "Note", "object", "or", "note", "string", "." ]

[ "def", "from_Track", "(", "track", ",", "maxwidth", "=", "80", ",", "tuning", "=", "None", ")", ":", "result", "=", "[", "]", "width", "=", "_get_width", "(", "maxwidth", ")", "if", "not", "tuning", ":", "tuning", "=", "track", ".", "get_tuning", "(", ")", "lastlen", "=", "0", "for", "bar", "in", "track", ":", "r", "=", "from_Bar", "(", "bar", ",", "width", ",", "tuning", ",", "collapse", "=", "False", ")", "barstart", "=", "r", "[", "1", "]", ".", "find", "(", "'||'", ")", "+", "2", "if", "(", "len", "(", "r", "[", "0", "]", ")", "+", "lastlen", ")", "-", "barstart", "<", "maxwidth", "and", "result", "!=", "[", "]", ":", "for", "i", "in", "range", "(", "1", ",", "len", "(", "r", ")", "+", "1", ")", ":", "item", "=", "r", "[", "len", "(", "r", ")", "-", "i", "]", "result", "[", "-", "i", "]", "+=", "item", "[", "barstart", ":", "]", "else", ":", "result", "+=", "[", "''", ",", "''", "]", "+", "r", "lastlen", "=", "len", "(", "result", "[", "-", "1", "]", ")", "return", "os", ".", "linesep", ".", "join", "(", "result", ")" ]

[ "Convert", "a", "mingus", ".", "containers", ".", "Track", "object", "to", "an", "ASCII", "tablature", "string", "." ]

[ "def", "from_Composition", "(", "composition", ",", "width", "=", "80", ")", ":", "# Collect tunings", "instr_tunings", "=", "[", "]", "for", "track", "in", "composition", ":", "tun", "=", "track", ".", "get_tuning", "(", ")", "if", "tun", ":", "instr_tunings", ".", "append", "(", "tun", ")", "else", ":", "instr_tunings", ".", "append", "(", "default_tuning", ")", "result", "=", "add_headers", "(", "width", ",", "composition", ".", "title", ",", "composition", ".", "subtitle", ",", "composition", ".", "author", ",", "composition", ".", "email", ",", "composition", ".", "description", ",", "instr_tunings", ",", ")", "# Some variables", "w", "=", "_get_width", "(", "width", ")", "barindex", "=", "0", "bars", "=", "width", "/", "w", "lastlen", "=", "0", "maxlen", "=", "max", "(", "[", "len", "(", "x", ")", "for", "x", "in", "composition", ".", "tracks", "]", ")", "while", "barindex", "<", "maxlen", ":", "notfirst", "=", "False", "for", "tracks", "in", "composition", ":", "tuning", "=", "tracks", ".", "get_tuning", "(", ")", "ascii", "=", "[", "]", "for", "x", "in", "xrange", "(", "bars", ")", ":", "if", "barindex", "+", "x", "<", "len", "(", "tracks", ")", ":", "bar", "=", "tracks", "[", "barindex", "+", "x", "]", "r", "=", "from_Bar", "(", "bar", ",", "w", ",", "tuning", ",", "collapse", "=", "False", ")", "barstart", "=", "r", "[", "1", "]", ".", "find", "(", "'||'", ")", "+", "2", "# Add extra '||' to quarter note marks to connect tracks.", "if", "notfirst", ":", "r", "[", "0", "]", "=", "(", "r", "[", "0", "]", ")", "[", ":", "barstart", "-", "2", "]", "+", "'||'", "+", "(", "r", "[", "0", "]", ")", "[", "barstart", ":", "]", "# Add bar to ascii", "if", "ascii", "!=", "[", "]", ":", "for", "i", "in", "range", "(", "1", ",", "len", "(", "r", ")", "+", "1", ")", ":", "item", "=", "r", "[", "len", "(", "r", ")", "-", "i", "]", "ascii", "[", "-", "i", "]", "+=", "item", "[", "barstart", ":", "]", "else", ":", "ascii", "+=", "r", "# Add extra '||' to connect tracks", "if", "notfirst", "and", "ascii", "!=", "[", "]", ":", "pad", "=", "ascii", "[", "-", "1", "]", ".", "find", "(", "'||'", ")", "result", "+=", "[", "' '", "*", "pad", "+", "'||'", ",", "' '", "*", "pad", "+", "'||'", "]", "else", ":", "notfirst", "=", "True", "# Finally, add ascii to result", "result", "+=", "ascii", "result", "+=", "[", "''", ",", "''", ",", "''", "]", "barindex", "+=", "bars", "return", "os", ".", "linesep", ".", "join", "(", "result", ")" ]

[ "Convert", "a", "mingus", ".", "containers", ".", "Composition", "to", "an", "ASCII", "tablature", "string", "." ]

[ "def", "from_Suite", "(", "suite", ",", "maxwidth", "=", "80", ")", ":", "subtitle", "=", "str", "(", "len", "(", "suite", ".", "compositions", ")", ")", "+", "' Compositions'", "if", "suite", ".", "subtitle", "==", "''", "else", "suite", ".", "subtitle", "result", "=", "os", ".", "linesep", ".", "join", "(", "add_headers", "(", "maxwidth", ",", "suite", ".", "title", ",", "subtitle", ",", "suite", ".", "author", ",", "suite", ".", "email", ",", "suite", ".", "description", ",", ")", ")", "hr", "=", "maxwidth", "*", "'='", "n", "=", "os", ".", "linesep", "result", "=", "n", "+", "hr", "+", "n", "+", "result", "+", "n", "+", "hr", "+", "n", "+", "n", "for", "comp", "in", "suite", ":", "c", "=", "from_Composition", "(", "comp", ",", "maxwidth", ")", "result", "+=", "c", "+", "n", "+", "hr", "+", "n", "+", "n", "return", "result" ]

[ "Convert", "a", "mingus", ".", "containers", ".", "Suite", "to", "an", "ASCII", "tablature", "string", "complete", "with", "headers", "." ]

[ "def", "_get_qsize", "(", "tuning", ",", "width", ")", ":", "names", "=", "[", "x", ".", "to_shorthand", "(", ")", "for", "x", "in", "tuning", ".", "tuning", "]", "basesize", "=", "len", "(", "max", "(", "names", ")", ")", "+", "3", "barsize", "=", "(", "(", "width", "-", "basesize", ")", "-", "2", ")", "-", "1", "# x * 4 + 0.5x - barsize = 0 4.5x = barsize x = barsize / 4.5", "return", "max", "(", "0", ",", "int", "(", "barsize", "/", "4.5", ")", ")" ]

[ "Return", "a", "reasonable", "quarter", "note", "size", "for", "tuning", "and", "width", "." ]

[ "def", "_get_width", "(", "maxwidth", ")", ":", "width", "=", "maxwidth", "/", "3", "if", "maxwidth", "<=", "60", ":", "width", "=", "maxwidth", "elif", "60", "<", "maxwidth", "<=", "120", ":", "width", "=", "maxwidth", "/", "2", "return", "width" ]

[ "Return", "the", "width", "of", "a", "single", "bar", "when", "width", "of", "the", "page", "is", "given", "." ]

[ "def", "triad", "(", "note", ",", "key", ")", ":", "return", "[", "note", ",", "intervals", ".", "third", "(", "note", ",", "key", ")", ",", "intervals", ".", "fifth", "(", "note", ",", "key", ")", "]" ]

[ "Return", "the", "triad", "on", "note", "in", "key", "as", "a", "list", "." ]

[ "def", "triads", "(", "key", ")", ":", "if", "_triads_cache", ".", "has_key", "(", "key", ")", ":", "return", "_triads_cache", "[", "key", "]", "res", "=", "map", "(", "lambda", "x", ":", "triad", "(", "x", ",", "key", ")", ",", "keys", ".", "get_notes", "(", "key", ")", ")", "_triads_cache", "[", "key", "]", "=", "res", "return", "res" ]

[ "Return", "all", "the", "triads", "in", "key", "." ]

[ "def", "augmented_triad", "(", "note", ")", ":", "return", "[", "note", ",", "intervals", ".", "major_third", "(", "note", ")", ",", "notes", ".", "augment", "(", "intervals", ".", "major_fifth", "(", "note", ")", ")", "]" ]

[ "Build", "an", "augmented", "triad", "on", "note", "." ]

[ "def", "seventh", "(", "note", ",", "key", ")", ":", "return", "triad", "(", "note", ",", "key", ")", "+", "[", "intervals", ".", "seventh", "(", "note", ",", "key", ")", "]" ]

[ "Return", "the", "seventh", "chord", "on", "note", "in", "key", "." ]

[ "def", "sevenths", "(", "key", ")", ":", "if", "_sevenths_cache", ".", "has_key", "(", "key", ")", ":", "return", "_sevenths_cache", "[", "key", "]", "res", "=", "map", "(", "lambda", "x", ":", "seventh", "(", "x", ",", "key", ")", ",", "keys", ".", "get_notes", "(", "key", ")", ")", "_sevenths_cache", "[", "key", "]", "=", "res", "return", "res" ]

[ "Return", "all", "the", "sevenths", "chords", "in", "key", "in", "a", "list", "." ]

[ "def", "dominant_flat_ninth", "(", "note", ")", ":", "res", "=", "dominant_ninth", "(", "note", ")", "res", "[", "4", "]", "=", "intervals", ".", "minor_second", "(", "note", ")", "return", "res" ]

[ "Build", "a", "dominant", "flat", "ninth", "chord", "on", "note", "." ]

[ "def", "dominant_sharp_ninth", "(", "note", ")", ":", "res", "=", "dominant_ninth", "(", "note", ")", "res", "[", "4", "]", "=", "notes", ".", "augment", "(", "intervals", ".", "major_second", "(", "note", ")", ")", "return", "res" ]

[ "Build", "a", "dominant", "sharp", "ninth", "chord", "on", "note", "." ]

[ "def", "eleventh", "(", "note", ")", ":", "return", "[", "note", ",", "intervals", ".", "perfect_fifth", "(", "note", ")", ",", "intervals", ".", "minor_seventh", "(", "note", ")", ",", "intervals", ".", "perfect_fourth", "(", "note", ")", "]" ]

[ "Build", "an", "eleventh", "chord", "on", "note", "." ]

[ "def", "dominant_flat_five", "(", "note", ")", ":", "res", "=", "dominant_seventh", "(", "note", ")", "res", "[", "2", "]", "=", "notes", ".", "diminish", "(", "res", "[", "2", "]", ")", "return", "res" ]

[ "Build", "a", "dominant", "flat", "five", "chord", "on", "note", "." ]

[ "def", "from_shorthand", "(", "shorthand_string", ",", "slash", "=", "None", ")", ":", "# warning reduce??", "if", "type", "(", "shorthand_string", ")", "==", "list", ":", "res", "=", "[", "]", "for", "x", "in", "shorthand_string", ":", "res", ".", "append", "(", "from_shorthand", "(", "x", ")", ")", "return", "res", "if", "shorthand_string", "in", "[", "'NC'", ",", "'N.C.'", "]", ":", "return", "[", "]", "# Shrink shorthand_string to a format recognised by chord_shorthand", "shorthand_string", "=", "shorthand_string", ".", "replace", "(", "'min'", ",", "'m'", ")", "shorthand_string", "=", "shorthand_string", ".", "replace", "(", "'mi'", ",", "'m'", ")", "shorthand_string", "=", "shorthand_string", ".", "replace", "(", "'-'", ",", "'m'", ")", "shorthand_string", "=", "shorthand_string", ".", "replace", "(", "'maj'", ",", "'M'", ")", "shorthand_string", "=", "shorthand_string", ".", "replace", "(", "'ma'", ",", "'M'", ")", "# Get the note name", "if", "not", "notes", ".", "is_valid_note", "(", "shorthand_string", "[", "0", "]", ")", ":", "raise", "NoteFormatError", ",", "\"Unrecognised note '%s' in chord '%s'\"", "%", "(", "shorthand_string", "[", "0", "]", ",", "shorthand_string", ")", "name", "=", "shorthand_string", "[", "0", "]", "# Look for accidentals", "for", "n", "in", "shorthand_string", "[", "1", ":", "]", ":", "if", "n", "==", "'#'", ":", "name", "+=", "n", "elif", "n", "==", "'b'", ":", "name", "+=", "n", "else", ":", "break", "# Look for slashes and polychords '|'", "slash_index", "=", "-", "1", "s", "=", "0", "rest_of_string", "=", "shorthand_string", "[", "len", "(", "name", ")", ":", "]", "for", "n", "in", "rest_of_string", ":", "if", "n", "==", "'/'", ":", "slash_index", "=", "s", "elif", "n", "==", "'|'", ":", "# Generate polychord", "return", "from_shorthand", "(", "shorthand_string", "[", ":", "len", "(", "name", ")", "+", "s", "]", ",", "from_shorthand", "(", "shorthand_string", "[", "len", "(", "name", ")", "+", "s", "+", "1", ":", "]", ")", ")", "s", "+=", "1", "# Generate slash chord", "if", "slash_index", "!=", "-", "1", "and", "rest_of_string", "not", "in", "[", "'m/M7'", ",", "'6/9'", ",", "'6/7'", "]", ":", "res", "=", "shorthand_string", "[", ":", "len", "(", "name", ")", "+", "slash_index", "]", "return", "from_shorthand", "(", "shorthand_string", "[", ":", "len", "(", "name", ")", "+", "slash_index", "]", ",", "shorthand_string", "[", "len", "(", "name", ")", "+", "slash_index", "+", "1", ":", "]", ")", "shorthand_start", "=", "len", "(", "name", ")", "short_chord", "=", "shorthand_string", "[", "shorthand_start", ":", "]", "if", "chord_shorthand", ".", "has_key", "(", "short_chord", ")", ":", "res", "=", "chord_shorthand", "[", "short_chord", "]", "(", "name", ")", "if", "slash", "!=", "None", ":", "# Add slashed chords", "if", "type", "(", "slash", ")", "==", "str", ":", "if", "notes", ".", "is_valid_note", "(", "slash", ")", ":", "res", "=", "[", "slash", "]", "+", "res", "else", ":", "raise", "NoteFormatError", ",", "\"Unrecognised note '%s' in slash chord'%s'\"", "%", "(", "slash", ",", "slash", "+", "shorthand_string", ")", "elif", "type", "(", "slash", ")", "==", "list", ":", "# Add polychords", "r", "=", "slash", "for", "n", "in", "res", ":", "if", "n", "!=", "r", "[", "-", "1", "]", ":", "r", ".", "append", "(", "n", ")", "return", "r", "return", "res", "else", ":", "raise", "FormatError", ",", "'Unknown shorthand: %s'", "%", "shorthand_string" ]

[ "Take", "a", "chord", "written", "in", "shorthand", "and", "return", "the", "notes", "in", "the", "chord", "." ]

[ "def", "determine", "(", "chord", ",", "shorthand", "=", "False", ",", "no_inversions", "=", "False", ",", "no_polychords", "=", "False", ")", ":", "if", "chord", "==", "[", "]", ":", "return", "[", "]", "elif", "len", "(", "chord", ")", "==", "1", ":", "return", "chord", "elif", "len", "(", "chord", ")", "==", "2", ":", "return", "[", "intervals", ".", "determine", "(", "chord", "[", "0", "]", ",", "chord", "[", "1", "]", ")", "]", "elif", "len", "(", "chord", ")", "==", "3", ":", "return", "determine_triad", "(", "chord", ",", "shorthand", ",", "no_inversions", ",", "no_polychords", ")", "elif", "len", "(", "chord", ")", "==", "4", ":", "return", "determine_seventh", "(", "chord", ",", "shorthand", ",", "no_inversions", ",", "no_polychords", ")", "elif", "len", "(", "chord", ")", "==", "5", ":", "return", "determine_extended_chord5", "(", "chord", ",", "shorthand", ",", "no_inversions", ",", "no_polychords", ")", "elif", "len", "(", "chord", ")", "==", "6", ":", "return", "determine_extended_chord6", "(", "chord", ",", "shorthand", ",", "no_inversions", ",", "no_polychords", ")", "elif", "len", "(", "chord", ")", "==", "7", ":", "return", "determine_extended_chord7", "(", "chord", ",", "shorthand", ",", "no_inversions", ",", "no_polychords", ")", "else", ":", "return", "determine_polychords", "(", "chord", ",", "shorthand", ")" ]

[ "Name", "a", "chord", "." ]

[ "def", "determine_triad", "(", "triad", ",", "shorthand", "=", "False", ",", "no_inversions", "=", "False", ",", "placeholder", "=", "None", ")", ":", "if", "len", "(", "triad", ")", "!=", "3", ":", "# warning: raise exception: not a triad", "return", "False", "def", "inversion_exhauster", "(", "triad", ",", "shorthand", ",", "tries", ",", "result", ")", ":", "\"\"\"Run tries every inversion and save the result.\"\"\"", "intval1", "=", "intervals", ".", "determine", "(", "triad", "[", "0", "]", ",", "triad", "[", "1", "]", ",", "True", ")", "intval2", "=", "intervals", ".", "determine", "(", "triad", "[", "0", "]", ",", "triad", "[", "2", "]", ",", "True", ")", "def", "add_result", "(", "short", ")", ":", "result", ".", "append", "(", "(", "short", ",", "tries", ",", "triad", "[", "0", "]", ")", ")", "intval", "=", "intval1", "+", "intval2", "if", "intval", "==", "'25'", ":", "add_result", "(", "'sus2'", ")", "elif", "intval", "==", "'3b7'", ":", "add_result", "(", "'dom7'", ")", "# changed from just '7'", "elif", "intval", "==", "'3b5'", ":", "add_result", "(", "'7b5'", ")", "# why not b5?", "elif", "intval", "==", "'35'", ":", "add_result", "(", "'M'", ")", "elif", "intval", "==", "'3#5'", ":", "add_result", "(", "'aug'", ")", "elif", "intval", "==", "'36'", ":", "add_result", "(", "'M6'", ")", "elif", "intval", "==", "'37'", ":", "add_result", "(", "'M7'", ")", "elif", "intval", "==", "'b3b5'", ":", "add_result", "(", "'dim'", ")", "elif", "intval", "==", "'b35'", ":", "add_result", "(", "'m'", ")", "elif", "intval", "==", "'b36'", ":", "add_result", "(", "'m6'", ")", "elif", "intval", "==", "'b3b7'", ":", "add_result", "(", "'m7'", ")", "elif", "intval", "==", "'b37'", ":", "add_result", "(", "'m/M7'", ")", "elif", "intval", "==", "'45'", ":", "add_result", "(", "'sus4'", ")", "elif", "intval", "==", "'5b7'", ":", "add_result", "(", "'m7'", ")", "elif", "intval", "==", "'57'", ":", "add_result", "(", "'M7'", ")", "if", "tries", "!=", "3", "and", "not", "no_inversions", ":", "return", "inversion_exhauster", "(", "[", "triad", "[", "-", "1", "]", "]", "+", "triad", "[", ":", "-", "1", "]", ",", "shorthand", ",", "tries", "+", "1", ",", "result", ")", "else", ":", "res", "=", "[", "]", "for", "r", "in", "result", ":", "if", "shorthand", ":", "res", ".", "append", "(", "r", "[", "2", "]", "+", "r", "[", "0", "]", ")", "else", ":", "res", ".", "append", "(", "r", "[", "2", "]", "+", "chord_shorthand_meaning", "[", "r", "[", "0", "]", "]", "+", "int_desc", "(", "r", "[", "1", "]", ")", ")", "return", "res", "return", "inversion_exhauster", "(", "triad", ",", "shorthand", ",", "1", ",", "[", "]", ")" ]

[ "Name", "the", "triad", ";", "return", "answers", "in", "a", "list", "." ]

[ "def", "determine_seventh", "(", "seventh", ",", "shorthand", "=", "False", ",", "no_inversion", "=", "False", ",", "no_polychords", "=", "False", ")", ":", "if", "len", "(", "seventh", ")", "!=", "4", ":", "# warning raise exception: seventh chord is not a seventh chord", "return", "False", "def", "inversion_exhauster", "(", "seventh", ",", "shorthand", ",", "tries", ",", "result", ",", "polychords", ")", ":", "\"\"\"Determine sevenths recursive functions.\"\"\"", "# Check whether the first three notes of seventh are part of some triad.", "triads", "=", "determine_triad", "(", "seventh", "[", ":", "3", "]", ",", "True", ",", "True", ")", "# Get the interval between the first and last note", "intval3", "=", "intervals", ".", "determine", "(", "seventh", "[", "0", "]", ",", "seventh", "[", "3", "]", ")", "def", "add_result", "(", "short", ",", "poly", "=", "False", ")", ":", "\"\"\"Helper function.\"\"\"", "result", ".", "append", "(", "(", "short", ",", "tries", ",", "seventh", "[", "0", "]", ",", "poly", ")", ")", "# Recognizing polychords", "if", "tries", "==", "1", "and", "not", "no_polychords", ":", "polychords", "=", "polychords", "+", "determine_polychords", "(", "seventh", ",", "shorthand", ")", "# Recognizing sevenths", "for", "triad", "in", "triads", ":", "# Basic triads", "triad", "=", "triad", "[", "len", "(", "seventh", "[", "0", "]", ")", ":", "]", "if", "triad", "==", "'m'", ":", "if", "intval3", "==", "'minor seventh'", ":", "add_result", "(", "'m7'", ")", "elif", "intval3", "==", "'major seventh'", ":", "add_result", "(", "'m/M7'", ")", "elif", "intval3", "==", "'major sixth'", ":", "add_result", "(", "'m6'", ")", "elif", "triad", "==", "'M'", ":", "if", "intval3", "==", "'major seventh'", ":", "add_result", "(", "'M7'", ")", "elif", "intval3", "==", "'minor seventh'", ":", "add_result", "(", "'7'", ")", "elif", "intval3", "==", "'major sixth'", ":", "add_result", "(", "'M6'", ")", "elif", "triad", "==", "'dim'", ":", "if", "intval3", "==", "'minor seventh'", ":", "add_result", "(", "'m7b5'", ")", "elif", "intval3", "==", "'diminished seventh'", ":", "add_result", "(", "'dim7'", ")", "elif", "triad", "==", "'aug'", ":", "if", "intval3", "==", "'minor seventh'", ":", "add_result", "(", "'m7+'", ")", "if", "intval3", "==", "'major seventh'", ":", "add_result", "(", "'M7+'", ")", "elif", "triad", "==", "'sus4'", ":", "if", "intval3", "==", "'minor seventh'", ":", "add_result", "(", "'sus47'", ")", "elif", "intval3", "==", "'minor second'", ":", "add_result", "(", "'sus4b9'", ")", "elif", "triad", "==", "'m7'", ":", "# Other", "if", "intval3", "==", "'perfect fourth'", ":", "add_result", "(", "'11'", ")", "elif", "triad", "==", "'7b5'", ":", "if", "intval3", "==", "'minor seventh'", ":", "add_result", "(", "'7b5'", ")", "if", "tries", "!=", "4", "and", "not", "no_inversion", ":", "return", "inversion_exhauster", "(", "[", "seventh", "[", "-", "1", "]", "]", "+", "seventh", "[", ":", "-", "1", "]", ",", "shorthand", ",", "tries", "+", "1", ",", "result", ",", "polychords", ")", "else", ":", "# Return results", "res", "=", "[", "]", "# Reset seventh", "seventh", "=", "[", "seventh", "[", "3", "]", "]", "+", "seventh", "[", "0", ":", "3", "]", "for", "x", "in", "result", ":", "if", "shorthand", ":", "res", ".", "append", "(", "x", "[", "2", "]", "+", "x", "[", "0", "]", ")", "else", ":", "res", ".", "append", "(", "x", "[", "2", "]", "+", "chord_shorthand_meaning", "[", "x", "[", "0", "]", "]", "+", "int_desc", "(", "x", "[", "1", "]", ")", ")", "return", "res", "+", "polychords", "return", "inversion_exhauster", "(", "seventh", ",", "shorthand", ",", "1", ",", "[", "]", ",", "[", "]", ")" ]

[ "Determine", "the", "type", "of", "seventh", "chord", ";", "return", "the", "results", "in", "a", "list", "ordered", "on", "inversions", "." ]

[ "def", "determine_extended_chord5", "(", "chord", ",", "shorthand", "=", "False", ",", "no_inversions", "=", "False", ",", "no_polychords", "=", "False", ")", ":", "if", "len", "(", "chord", ")", "!=", "5", ":", "# warning raise exeption: not an extended chord", "return", "False", "def", "inversion_exhauster", "(", "chord", ",", "shorthand", ",", "tries", ",", "result", ",", "polychords", ")", ":", "\"\"\"Recursive helper function.\"\"\"", "def", "add_result", "(", "short", ")", ":", "result", ".", "append", "(", "(", "short", ",", "tries", ",", "chord", "[", "0", "]", ")", ")", "triads", "=", "determine_triad", "(", "chord", "[", ":", "3", "]", ",", "True", ",", "True", ")", "sevenths", "=", "determine_seventh", "(", "chord", "[", ":", "4", "]", ",", "True", ",", "True", ",", "True", ")", "# Determine polychords", "if", "tries", "==", "1", "and", "not", "no_polychords", ":", "polychords", "+=", "determine_polychords", "(", "chord", ",", "shorthand", ")", "intval4", "=", "intervals", ".", "determine", "(", "chord", "[", "0", "]", ",", "chord", "[", "4", "]", ")", "for", "seventh", "in", "sevenths", ":", "seventh", "=", "seventh", "[", "len", "(", "chord", "[", "0", "]", ")", ":", "]", "if", "seventh", "==", "'M7'", ":", "if", "intval4", "==", "'major second'", ":", "add_result", "(", "'M9'", ")", "elif", "seventh", "==", "'m7'", ":", "if", "intval4", "==", "'major second'", ":", "add_result", "(", "'m9'", ")", "elif", "intval4", "==", "'perfect fourth'", ":", "add_result", "(", "'m11'", ")", "elif", "seventh", "==", "'7'", ":", "if", "intval4", "==", "'major second'", ":", "add_result", "(", "'9'", ")", "elif", "intval4", "==", "'minor second'", ":", "add_result", "(", "'7b9'", ")", "elif", "intval4", "==", "'augmented second'", ":", "add_result", "(", "'7#9'", ")", "elif", "intval4", "==", "'minor third'", ":", "add_result", "(", "'7b12'", ")", "elif", "intval4", "==", "'augmented fourth'", ":", "add_result", "(", "'7#11'", ")", "elif", "intval4", "==", "'major sixth'", ":", "add_result", "(", "'13'", ")", "elif", "seventh", "==", "'M6'", ":", "if", "intval4", "==", "'major second'", ":", "add_result", "(", "'6/9'", ")", "elif", "intval4", "==", "'minor seventh'", ":", "add_result", "(", "'6/7'", ")", "if", "tries", "!=", "5", "and", "not", "no_inversions", ":", "return", "inversion_exhauster", "(", "[", "chord", "[", "-", "1", "]", "]", "+", "chord", "[", ":", "-", "1", "]", ",", "shorthand", ",", "tries", "+", "1", ",", "result", ",", "polychords", ")", "else", ":", "res", "=", "[", "]", "for", "r", "in", "result", ":", "if", "shorthand", ":", "res", ".", "append", "(", "r", "[", "2", "]", "+", "r", "[", "0", "]", ")", "else", ":", "res", ".", "append", "(", "r", "[", "2", "]", "+", "chord_shorthand_meaning", "[", "r", "[", "0", "]", "]", "+", "int_desc", "(", "r", "[", "1", "]", ")", ")", "return", "res", "+", "polychords", "return", "inversion_exhauster", "(", "chord", ",", "shorthand", ",", "1", ",", "[", "]", ",", "[", "]", ")" ]

[ "Determine", "the", "names", "of", "an", "extended", "chord", "." ]

[ "def", "determine_extended_chord6", "(", "chord", ",", "shorthand", "=", "False", ",", "no_inversions", "=", "False", ",", "no_polychords", "=", "False", ")", ":", "if", "len", "(", "chord", ")", "!=", "6", ":", "# warning raise exeption: not an extended chord", "return", "False", "def", "inversion_exhauster", "(", "chord", ",", "shorthand", ",", "tries", ",", "result", ",", "polychords", ",", ")", ":", "\"\"\"Recursive helper function\"\"\"", "# Determine polychords", "if", "tries", "==", "1", "and", "not", "no_polychords", ":", "polychords", "+=", "determine_polychords", "(", "chord", ",", "shorthand", ")", "def", "add_result", "(", "short", ")", ":", "result", ".", "append", "(", "(", "short", ",", "tries", ",", "chord", "[", "0", "]", ")", ")", "ch", "=", "determine_extended_chord5", "(", "chord", "[", ":", "5", "]", ",", "True", ",", "True", ",", "True", ")", "intval5", "=", "intervals", ".", "determine", "(", "chord", "[", "0", "]", ",", "chord", "[", "5", "]", ")", "for", "c", "in", "ch", ":", "c", "=", "c", "[", "len", "(", "chord", "[", "0", "]", ")", ":", "]", "if", "c", "==", "'9'", ":", "if", "intval5", "==", "'perfect fourth'", ":", "add_result", "(", "'11'", ")", "elif", "intval5", "==", "'augmented fourth'", ":", "add_result", "(", "'7#11'", ")", "elif", "intval5", "==", "'major sixth'", ":", "add_result", "(", "'13'", ")", "elif", "c", "==", "'m9'", ":", "if", "intval5", "==", "'perfect fourth'", ":", "add_result", "(", "'m11'", ")", "elif", "intval5", "==", "'major sixth'", ":", "add_result", "(", "'m13'", ")", "elif", "c", "==", "'M9'", ":", "if", "intval5", "==", "'perfect fourth'", ":", "add_result", "(", "'M11'", ")", "elif", "intval5", "==", "'major sixth'", ":", "add_result", "(", "'M13'", ")", "if", "tries", "!=", "6", "and", "not", "no_inversions", ":", "return", "inversion_exhauster", "(", "[", "chord", "[", "-", "1", "]", "]", "+", "chord", "[", ":", "-", "1", "]", ",", "shorthand", ",", "tries", "+", "1", ",", "result", ",", "polychords", ")", "else", ":", "res", "=", "[", "]", "for", "r", "in", "result", ":", "if", "shorthand", ":", "res", ".", "append", "(", "r", "[", "2", "]", "+", "r", "[", "0", "]", ")", "else", ":", "res", ".", "append", "(", "r", "[", "2", "]", "+", "chord_shorthand_meaning", "[", "r", "[", "0", "]", "]", "+", "int_desc", "(", "r", "[", "1", "]", ")", ")", "return", "res", "+", "polychords", "return", "inversion_exhauster", "(", "chord", ",", "shorthand", ",", "1", ",", "[", "]", ",", "[", "]", ")" ]

[ "Determine", "the", "names", "of", "an", "6", "note", "chord", "." ]

[ "def", "determine_polychords", "(", "chord", ",", "shorthand", "=", "False", ")", ":", "polychords", "=", "[", "]", "function_list", "=", "[", "determine_triad", ",", "determine_seventh", ",", "determine_extended_chord5", ",", "determine_extended_chord6", ",", "determine_extended_chord7", "]", "# Range tracking.", "if", "len", "(", "chord", ")", "<=", "3", ":", "return", "[", "]", "elif", "len", "(", "chord", ")", ">", "14", ":", "return", "[", "]", "elif", "len", "(", "chord", ")", "-", "3", "<=", "5", ":", "function_nr", "=", "range", "(", "0", ",", "len", "(", "chord", ")", "-", "3", ")", "else", ":", "function_nr", "=", "range", "(", "0", ",", "5", ")", "for", "f", "in", "function_nr", ":", "for", "f2", "in", "function_nr", ":", "# The clever part: Try the function_list[f] on the len(chord) - (3 +", "# f) last notes of the chord. Then try the function_list[f2] on the", "# f2 + 3 first notes of the chord. Thus, trying all possible", "# combinations.", "for", "chord1", "in", "function_list", "[", "f", "]", "(", "chord", "[", "len", "(", "chord", ")", "-", "(", "3", "+", "f", ")", ":", "]", ",", "True", ",", "True", ",", "True", ")", ":", "for", "chord2", "in", "function_list", "[", "f2", "]", "(", "chord", "[", ":", "f2", "+", "3", "]", ",", "True", ",", "True", ",", "True", ")", ":", "polychords", ".", "append", "(", "'%s|%s'", "%", "(", "chord1", ",", "chord2", ")", ")", "if", "shorthand", ":", "for", "p", "in", "polychords", ":", "p", "=", "p", "+", "' polychord'", "return", "polychords" ]

[ "Determine", "the", "polychords", "in", "chord", ".", "This", "function", "can", "handle", "anything", "from", "polychords", "based", "on", "two", "triads", "to", "6", "note", "extended", "chords", "." ]

[ "def", "from_Note", "(", "note", ",", "process_octaves", "=", "True", ",", "standalone", "=", "True", ")", ":", "# Throw exception", "if", "not", "hasattr", "(", "note", ",", "'name'", ")", ":", "return", "False", "# Lower the case of the name", "result", "=", "note", ".", "name", "[", "0", "]", ".", "lower", "(", ")", "# Convert #'s and b's to 'is' and 'es' suffixes", "for", "accidental", "in", "note", ".", "name", "[", "1", ":", "]", ":", "if", "accidental", "==", "'#'", ":", "result", "+=", "'is'", "elif", "accidental", "==", "'b'", ":", "result", "+=", "'es'", "# Place ' and , for octaves", "if", "process_octaves", ":", "oct", "=", "note", ".", "octave", "if", "oct", ">=", "4", ":", "while", "oct", ">", "3", ":", "result", "+=", "\"'\"", "oct", "-=", "1", "elif", "oct", "<", "3", ":", "while", "oct", "<", "3", ":", "result", "+=", "','", "oct", "+=", "1", "if", "standalone", ":", "return", "'{ %s }'", "%", "result", "else", ":", "return", "result" ]

[ "Get", "a", "Note", "object", "and", "return", "the", "LilyPond", "equivalent", "in", "a", "string", "." ]

[ "def", "from_NoteContainer", "(", "nc", ",", "duration", "=", "None", ",", "standalone", "=", "True", ")", ":", "# Throw exception", "if", "nc", "is", "not", "None", "and", "not", "hasattr", "(", "nc", ",", "'notes'", ")", ":", "return", "False", "# Return rests for None or empty lists", "if", "nc", "is", "None", "or", "len", "(", "nc", ".", "notes", ")", "==", "0", ":", "result", "=", "'r'", "elif", "len", "(", "nc", ".", "notes", ")", "==", "1", ":", "# Return a single note if the list contains only one note", "result", "=", "from_Note", "(", "nc", ".", "notes", "[", "0", "]", ",", "standalone", "=", "False", ")", "else", ":", "# Return the notes grouped in '<' and '>'", "result", "=", "'<'", "for", "notes", "in", "nc", ".", "notes", ":", "result", "+=", "from_Note", "(", "notes", ",", "standalone", "=", "False", ")", "+", "' '", "result", "=", "result", "[", ":", "-", "1", "]", "+", "'>'", "# Add the duration", "if", "duration", "!=", "None", ":", "parsed_value", "=", "value", ".", "determine", "(", "duration", ")", "# Special case: check for longa and breve in the duration (issue #37)", "dur", "=", "parsed_value", "[", "0", "]", "if", "dur", "==", "value", ".", "longa", ":", "result", "+=", "'\\\\longa'", "elif", "dur", "==", "value", ".", "breve", ":", "result", "+=", "'\\\\breve'", "else", ":", "result", "+=", "str", "(", "int", "(", "parsed_value", "[", "0", "]", ")", ")", "for", "i", "in", "range", "(", "parsed_value", "[", "1", "]", ")", ":", "result", "+=", "'.'", "if", "not", "standalone", ":", "return", "result", "else", ":", "return", "'{ %s }'", "%", "result" ]

[ "Get", "a", "NoteContainer", "object", "and", "return", "the", "LilyPond", "equivalent", "in", "a", "string", "." ]

[ "def", "from_Bar", "(", "bar", ",", "showkey", "=", "True", ",", "showtime", "=", "True", ")", ":", "# Throw exception", "if", "not", "hasattr", "(", "bar", ",", "'bar'", ")", ":", "return", "False", "# Process the key", "if", "showkey", ":", "key_note", "=", "Note", "(", "bar", ".", "key", ".", "key", "[", "0", "]", ".", "upper", "(", ")", "+", "bar", ".", "key", ".", "key", "[", "1", ":", "]", ")", "key", "=", "'\\\\key %s \\\\%s '", "%", "(", "from_Note", "(", "key_note", ",", "False", ",", "standalone", "=", "False", ")", ",", "bar", ".", "key", ".", "mode", ")", "result", "=", "key", "else", ":", "result", "=", "''", "# Handle the NoteContainers", "latest_ratio", "=", "(", "1", ",", "1", ")", "ratio_has_changed", "=", "False", "for", "bar_entry", "in", "bar", ".", "bar", ":", "parsed_value", "=", "value", ".", "determine", "(", "bar_entry", "[", "1", "]", ")", "ratio", "=", "parsed_value", "[", "2", ":", "]", "if", "ratio", "==", "latest_ratio", ":", "result", "+=", "from_NoteContainer", "(", "bar_entry", "[", "2", "]", ",", "bar_entry", "[", "1", "]", ",", "standalone", "=", "False", ")", "+", "' '", "else", ":", "if", "ratio_has_changed", ":", "result", "+=", "'}'", "result", "+=", "'\\\\times %d/%d {'", "%", "(", "ratio", "[", "1", "]", ",", "ratio", "[", "0", "]", ")", "result", "+=", "from_NoteContainer", "(", "bar_entry", "[", "2", "]", ",", "bar_entry", "[", "1", "]", ",", "standalone", "=", "False", ")", "+", "' '", "latest_ratio", "=", "ratio", "ratio_has_changed", "=", "True", "if", "ratio_has_changed", ":", "result", "+=", "'}'", "# Process the time", "if", "showtime", ":", "return", "'{ \\\\time %d/%d %s}'", "%", "(", "bar", ".", "meter", "[", "0", "]", ",", "bar", ".", "meter", "[", "1", "]", ",", "result", ")", "else", ":", "return", "'{ %s}'", "%", "result" ]

[ "Get", "a", "Bar", "object", "and", "return", "the", "LilyPond", "equivalent", "in", "a", "string", "." ]

[ "def", "from_Track", "(", "track", ")", ":", "# Throw exception", "if", "not", "hasattr", "(", "track", ",", "'bars'", ")", ":", "return", "False", "lastkey", "=", "Key", "(", "'C'", ")", "lasttime", "=", "(", "4", ",", "4", ")", "# Handle the Bars:", "result", "=", "''", "for", "bar", "in", "track", ".", "bars", ":", "if", "lastkey", "!=", "bar", ".", "key", ":", "showkey", "=", "True", "else", ":", "showkey", "=", "False", "if", "lasttime", "!=", "bar", ".", "meter", ":", "showtime", "=", "True", "else", ":", "showtime", "=", "False", "result", "+=", "from_Bar", "(", "bar", ",", "showkey", ",", "showtime", ")", "+", "' '", "lastkey", "=", "bar", ".", "key", "lasttime", "=", "bar", ".", "meter", "return", "'{ %s}'", "%", "result" ]

[ "Process", "a", "Track", "object", "and", "return", "the", "LilyPond", "equivalent", "in", "a", "string", "." ]

[ "def", "from_Composition", "(", "composition", ")", ":", "# warning Throw exception", "if", "not", "hasattr", "(", "composition", ",", "'tracks'", ")", ":", "return", "False", "result", "=", "'\\\\header { title = \"%s\" composer = \"%s\" opus = \"%s\" } '", "%", "(", "composition", ".", "title", ",", "composition", ".", "author", ",", "composition", ".", "subtitle", ")", "for", "track", "in", "composition", ".", "tracks", ":", "result", "+=", "from_Track", "(", "track", ")", "+", "' '", "return", "result", "[", ":", "-", "1", "]" ]

[ "Return", "the", "LilyPond", "equivalent", "of", "a", "Composition", "in", "a", "string", "." ]

[ "def", "save_string_and_execute_LilyPond", "(", "ly_string", ",", "filename", ",", "command", ")", ":", "ly_string", "=", "'\\\\version \"2.10.33\"\\n'", "+", "ly_string", "if", "filename", "[", "-", "4", ":", "]", "in", "[", "'.pdf'", ",", "'.png'", "]", ":", "filename", "=", "filename", "[", ":", "-", "4", "]", "try", ":", "f", "=", "open", "(", "filename", "+", "'.ly'", ",", "'w'", ")", "f", ".", "write", "(", "ly_string", ")", "f", ".", "close", "(", ")", "except", ":", "return", "False", "command", "=", "'lilypond %s -o \"%s\" \"%s.ly\"'", "%", "(", "command", ",", "filename", ",", "filename", ")", "print", "'Executing: %s'", "%", "command", "p", "=", "subprocess", ".", "Popen", "(", "command", ",", "shell", "=", "True", ")", ".", "wait", "(", ")", "os", ".", "remove", "(", "filename", "+", "'.ly'", ")", "return", "True" ]

[ "A", "helper", "function", "for", "to_png", "and", "to_pdf", ".", "Should", "not", "be", "used", "directly", "." ]

[ "def", "determine", "(", "value", ")", ":", "i", "=", "-", "2", "for", "v", "in", "base_values", ":", "if", "value", "==", "v", ":", "return", "(", "value", ",", "0", ",", "1", ",", "1", ")", "if", "value", "<", "v", ":", "break", "i", "+=", "1", "scaled", "=", "float", "(", "value", ")", "/", "2", "**", "i", "if", "scaled", ">=", "0.9375", ":", "# base value", "return", "(", "base_values", "[", "i", "]", ",", "0", ",", "1", ",", "1", ")", "elif", "scaled", ">=", "0.8125", ":", "# septuplet: scaled = 0.875", "return", "(", "base_values", "[", "i", "+", "1", "]", ",", "0", ",", "7", ",", "4", ")", "elif", "scaled", ">=", "17", "/", "24.0", ":", "# triplet: scaled = 0.75", "return", "(", "base_values", "[", "i", "+", "1", "]", ",", "0", ",", "3", ",", "2", ")", "elif", "scaled", ">=", "31", "/", "48.0", ":", "# dotted note (one dot): scaled = 2/3.0", "return", "(", "v", ",", "1", ",", "1", ",", "1", ")", "elif", "scaled", ">=", "67", "/", "112.0", ":", "# quintuplet: scaled = 0.625", "return", "(", "base_values", "[", "i", "+", "1", "]", ",", "0", ",", "5", ",", "4", ")", "d", "=", "3", "for", "x", "in", "range", "(", "2", ",", "5", ")", ":", "d", "+=", "2", "**", "x", "if", "scaled", "==", "2.0", "**", "x", "/", "d", ":", "return", "(", "v", ",", "x", ",", "1", ",", "1", ")", "return", "(", "base_values", "[", "i", "+", "1", "]", ",", "0", ",", "1", ",", "1", ")" ]

[ "Analyse", "the", "value", "and", "return", "a", "tuple", "containing", "the", "parts", "it", "s", "made", "of", "." ]

[ "def", "init", "(", "sf2", ",", "driver", "=", "None", ",", "file", "=", "None", ")", ":", "global", "midi", ",", "initialized", "if", "not", "initialized", ":", "if", "file", "is", "not", "None", ":", "midi", ".", "start_recording", "(", "file", ")", "else", ":", "midi", ".", "start_audio_output", "(", "driver", ")", "if", "not", "midi", ".", "load_sound_font", "(", "sf2", ")", ":", "return", "False", "midi", ".", "fs", ".", "program_reset", "(", ")", "initialized", "=", "True", "return", "True" ]

[ "Initialize", "the", "audio", "." ]

[ "def", "start_recording", "(", "self", ",", "file", "=", "'mingus_dump.wav'", ")", ":", "w", "=", "wave", ".", "open", "(", "file", ",", "'wb'", ")", "w", ".", "setnchannels", "(", "2", ")", "w", ".", "setsampwidth", "(", "2", ")", "w", ".", "setframerate", "(", "44100", ")", "self", ".", "wav", "=", "w" ]

[ "Initialize", "a", "new", "wave", "file", "for", "recording", "." ]

[ "def", "load_sound_font", "(", "self", ",", "sf2", ")", ":", "self", ".", "sfid", "=", "self", ".", "fs", ".", "sfload", "(", "sf2", ")", "return", "not", "self", ".", "sfid", "==", "-", "1" ]

[ "Load", "a", "sound", "font", "." ]

[ "def", "create", "(", "self", ",", "group_type", ",", "config_file", ",", "group_name", "=", "None", ",", "region", "=", "None", ",", "profile_name", "=", "None", ")", ":", "logging", ".", "info", "(", "\"[begin] create command using group_types:{0}\"", ".", "format", "(", "self", ".", "group_types", ")", ")", "config", "=", "GroupConfigFile", "(", "config_file", "=", "config_file", ")", "if", "config", ".", "is_fresh", "(", ")", "is", "False", ":", "raise", "ValueError", "(", "\"Config file already tracking previously created group\"", ")", "if", "group_type", "not", "in", "self", ".", "group_types", ".", "keys", "(", ")", ":", "raise", "ValueError", "(", "\"Can only create {0} groups.\"", ".", "format", "(", "self", ".", "group_types", ")", ")", "if", "region", "is", "None", ":", "region", "=", "self", ".", "_region", "# create an instance of the requested group type that uses the given", "# config file and region", "gt", "=", "self", ".", "group_types", "[", "group_type", "]", "(", "config", "=", "config", ",", "region", "=", "region", ")", "# get and store the account's IoT endpoint for future use", "ep", "=", "_get_iot_session", "(", "region", "=", "region", ")", ".", "describe_endpoint", "(", ")", "misc", "=", "config", "[", "'misc'", "]", "misc", "[", "'iot_endpoint'", "]", "=", "ep", "[", "'endpointAddress'", "]", "config", "[", "'misc'", "]", "=", "misc", "# Create a Group", "logging", ".", "info", "(", "\"[begin] Creating a Greengrass Group\"", ")", "if", "group_name", "is", "None", ":", "group_name", "=", "group_type", "gg_client", "=", "_get_gg_session", "(", "region", "=", "region", ",", "profile_name", "=", "profile_name", ")", "group_info", "=", "gg_client", ".", "create_group", "(", "Name", "=", "\"{0}\"", ".", "format", "(", "group_name", ")", ")", "config", "[", "'group'", "]", "=", "{", "\"id\"", ":", "group_info", "[", "'Id'", "]", "}", "# setup the policies and roles", "gt", ".", "create_and_attach_thing_policy", "(", ")", "gt", ".", "create_and_attach_iam_role", "(", ")", "cl_arn", "=", "self", ".", "_create_core_definition", "(", "gg_client", "=", "gg_client", ",", "group_type", "=", "gt", ",", "config", "=", "config", ",", "group_name", "=", "group_name", ")", "dl_arn", "=", "self", ".", "_create_device_definition", "(", "gg_client", "=", "gg_client", ",", "group_type", "=", "gt", ",", "config", "=", "config", ",", "group_name", "=", "group_name", ")", "lv_arn", "=", "self", ".", "_create_function_definition", "(", "gg_client", "=", "gg_client", ",", "group_type", "=", "gt", ",", "config", "=", "config", ")", "log_arn", "=", "self", ".", "_create_logger_definition", "(", "gg_client", "=", "gg_client", ",", "group_type", "=", "gt", ",", "config", "=", "config", ")", "sub_arn", "=", "self", ".", "_create_subscription_definition", "(", "gg_client", "=", "gg_client", ",", "group_type", "=", "gt", ",", "config", "=", "config", ")", "logging", ".", "info", "(", "'Group details, core_def:{0} device_def:{1} func_def:{2} '", "'logger_def:{3} subs_def:{4}'", ".", "format", "(", "cl_arn", ",", "dl_arn", ",", "lv_arn", ",", "log_arn", ",", "sub_arn", ")", ")", "# Add all the constituent parts to the Greengrass Group", "group_args", "=", "{", "'GroupId'", ":", "group_info", "[", "'Id'", "]", "}", "if", "cl_arn", ":", "group_args", "[", "'CoreDefinitionVersionArn'", "]", "=", "cl_arn", "if", "dl_arn", ":", "group_args", "[", "'DeviceDefinitionVersionArn'", "]", "=", "dl_arn", "if", "lv_arn", ":", "group_args", "[", "'FunctionDefinitionVersionArn'", "]", "=", "lv_arn", "if", "log_arn", ":", "group_args", "[", "'LoggerDefinitionVersionArn'", "]", "=", "log_arn", "if", "sub_arn", ":", "group_args", "[", "'SubscriptionDefinitionVersionArn'", "]", "=", "sub_arn", "grp", "=", "gg_client", ".", "create_group_version", "(", "*", "*", "group_args", ")", "# store info about the provisioned artifacts into the local config file", "config", "[", "'group'", "]", "=", "{", "\"id\"", ":", "group_info", "[", "'Id'", "]", ",", "\"version_arn\"", ":", "grp", "[", "'Arn'", "]", ",", "\"version\"", ":", "grp", "[", "'Version'", "]", ",", "\"name\"", ":", "group_name", "}", "logging", ".", "info", "(", "\"[end] Created Greengrass Group {0}\"", ".", "format", "(", "group_info", "[", "'Id'", "]", ")", ")" ]

[ "Create", "a", "Greengrass", "group", "in", "the", "given", "region", "." ]

[ "def", "_create_subscription_definition", "(", "gg_client", ",", "group_type", ",", "config", ")", ":", "logging", ".", "info", "(", "'[begin] Configuring routing subscriptions'", ")", "sub_info", "=", "gg_client", ".", "create_subscription_definition", "(", "Name", "=", "\"{0}_routing\"", ".", "format", "(", "group_type", ".", "type_name", ")", ")", "logging", ".", "info", "(", "'Created subscription definition: {0}'", ".", "format", "(", "sub_info", ")", ")", "subs", "=", "group_type", ".", "get_subscription_definition", "(", "config", "=", "config", ")", "if", "subs", "is", "None", ":", "logging", ".", "warning", "(", "\"[end] No SubscriptionDefinition exists in GroupType:{0}\"", ".", "format", "(", "group_type", ".", "type_name", ")", ")", "return", "subv", "=", "gg_client", ".", "create_subscription_definition_version", "(", "SubscriptionDefinitionId", "=", "sub_info", "[", "'Id'", "]", ",", "Subscriptions", "=", "subs", ")", "sub_arn", "=", "subv", "[", "'Arn'", "]", "config", "[", "'subscription_def'", "]", "=", "{", "\"id\"", ":", "sub_info", "[", "'Id'", "]", ",", "\"version_arn\"", ":", "sub_arn", "}", "logging", ".", "info", "(", "'[end] Configured routing subscriptions'", ")", "return", "sub_arn" ]

[ "Configure", "routing", "subscriptions", "for", "a", "Greengrass", "group", "." ]

[ "def", "clean_core", "(", "self", ",", "config_file", ",", "region", "=", "None", ",", "profile_name", "=", "None", ")", ":", "config", "=", "GroupConfigFile", "(", "config_file", "=", "config_file", ")", "if", "region", "is", "None", ":", "region", "=", "self", ".", "_region", "# delete the Core's Certificate", "core_cert_id", "=", "config", "[", "'core'", "]", "[", "'cert_id'", "]", "core_cert_arn", "=", "config", "[", "'core'", "]", "[", "'cert_arn'", "]", "core_thing_name", "=", "config", "[", "'core'", "]", "[", "'thing_name'", "]", "policy_name", "=", "config", "[", "'misc'", "]", "[", "'policy_name'", "]", "logging", ".", "info", "(", "'Deleting core_thing_name:{0}'", ".", "format", "(", "core_thing_name", ")", ")", "GroupCommands", ".", "_delete_thing", "(", "cert_arn", "=", "core_cert_arn", ",", "cert_id", "=", "core_cert_id", ",", "thing_name", "=", "core_thing_name", ",", "region", "=", "region", ",", "policy_name", "=", "policy_name", ",", "profile_name", "=", "profile_name", ")", "config", ".", "make_core_fresh", "(", ")" ]

[ "Clean", "all", "Core", "related", "provisioned", "artifacts", "from", "both", "the", "local", "file", "and", "the", "AWS", "Greengrass", "service", "." ]

[ "def", "clean_devices", "(", "self", ",", "config_file", ",", "region", "=", "None", ",", "profile_name", "=", "None", ")", ":", "config", "=", "GroupConfigFile", "(", "config_file", "=", "config_file", ")", "if", "region", "is", "None", ":", "region", "=", "self", ".", "_region", "devices", "=", "config", "[", "'devices'", "]", "if", "'device_thing_name'", "in", "devices", ":", "logging", ".", "info", "(", "'Configured devices already clean'", ")", "return", "policy_name", "=", "config", "[", "'misc'", "]", "[", "'policy_name'", "]", "for", "device", "in", "devices", ":", "cert_arn", "=", "devices", "[", "device", "]", "[", "'cert_arn'", "]", "cert_id", "=", "devices", "[", "device", "]", "[", "'cert_id'", "]", "thing_name", "=", "device", "logging", ".", "info", "(", "'Deleting device_thing_name:{0}'", ".", "format", "(", "thing_name", ")", ")", "GroupCommands", ".", "_delete_thing", "(", "cert_arn", ",", "cert_id", ",", "thing_name", ",", "region", ",", "policy_name", ",", "profile_name", ")", "config", ".", "make_devices_fresh", "(", ")" ]

[ "Clean", "all", "device", "related", "provisioned", "artifacts", "from", "both", "the", "local", "file", "and", "the", "AWS", "Greengrass", "service", "." ]

[ "def", "clean_file", "(", "config_file", ")", ":", "logging", ".", "info", "(", "'[begin] Cleaning config file'", ")", "config", "=", "GroupConfigFile", "(", "config_file", "=", "config_file", ")", "if", "config", ".", "is_fresh", "(", ")", "is", "True", ":", "raise", "ValueError", "(", "\"Config is already clean.\"", ")", "config", ".", "make_fresh", "(", ")", "logging", ".", "info", "(", "'[end] Cleaned config file:{0}'", ".", "format", "(", "config_file", ")", ")" ]

[ "Clean", "all", "provisioned", "artifacts", "from", "the", "local", "config", "file", "." ]

[ "def", "clean_all", "(", "self", ",", "config_file", ",", "region", "=", "None", ",", "profile_name", "=", "None", ")", ":", "logging", ".", "info", "(", "'[begin] Cleaning all provisioned artifacts'", ")", "config", "=", "GroupConfigFile", "(", "config_file", "=", "config_file", ")", "if", "config", ".", "is_fresh", "(", ")", "is", "True", ":", "raise", "ValueError", "(", "\"Config is already clean.\"", ")", "if", "region", "is", "None", ":", "region", "=", "self", ".", "_region", "self", ".", "_delete_group", "(", "config_file", ",", "region", "=", "region", ",", "profile_name", "=", "profile_name", ")", "self", ".", "clean_core", "(", "config_file", ",", "region", "=", "region", ")", "self", ".", "clean_devices", "(", "config_file", ",", "region", "=", "region", ")", "self", ".", "clean_file", "(", "config_file", ")", "logging", ".", "info", "(", "'[end] Cleaned all provisioned artifacts'", ")" ]

[ "Clean", "all", "provisioned", "artifacts", "from", "both", "the", "local", "file", "and", "the", "AWS", "Greengrass", "service", "." ]

[ "def", "deploy", "(", "self", ",", "config_file", ",", "region", "=", "None", ",", "profile_name", "=", "None", ")", ":", "config", "=", "GroupConfigFile", "(", "config_file", "=", "config_file", ")", "if", "config", ".", "is_fresh", "(", ")", ":", "raise", "ValueError", "(", "\"Config not yet tracking a group. Cannot deploy.\"", ")", "if", "region", "is", "None", ":", "region", "=", "self", ".", "_region", "gg_client", "=", "_get_gg_session", "(", "region", "=", "region", ",", "profile_name", "=", "profile_name", ")", "dep_req", "=", "gg_client", ".", "create_deployment", "(", "GroupId", "=", "config", "[", "'group'", "]", "[", "'id'", "]", ",", "GroupVersionId", "=", "config", "[", "'group'", "]", "[", "'version'", "]", ",", "DeploymentType", "=", "\"NewDeployment\"", ")", "print", "(", "\"Group deploy requested for deployment_id:{0}\"", ".", "format", "(", "dep_req", "[", "'DeploymentId'", "]", ",", ")", ")" ]

[ "Deploy", "the", "configuration", "and", "Lambda", "functions", "of", "a", "Greengrass", "group", "to", "the", "Greengrass", "core", "contained", "in", "the", "group", "." ]

[ "def", "create_core", "(", "self", ",", "thing_name", ",", "config_file", ",", "region", "=", "None", ",", "cert_dir", "=", "None", ",", "account_id", "=", "None", ",", "policy_name", "=", "'ggc-default-policy'", ",", "profile_name", "=", "None", ")", ":", "config", "=", "GroupConfigFile", "(", "config_file", "=", "config_file", ")", "if", "config", ".", "is_fresh", "(", ")", "is", "False", ":", "raise", "ValueError", "(", "\"Config file already tracking previously created core or group\"", ")", "if", "region", "is", "None", ":", "region", "=", "self", ".", "_region", "if", "account_id", "is", "None", ":", "account_id", "=", "self", ".", "_account_id", "keys_cert", ",", "thing", "=", "self", ".", "create_thing", "(", "thing_name", ",", "region", ",", "cert_dir", ")", "cert_arn", "=", "keys_cert", "[", "'certificateArn'", "]", "config", "[", "'core'", "]", "=", "{", "'thing_arn'", ":", "thing", "[", "'thingArn'", "]", ",", "'cert_arn'", ":", "cert_arn", ",", "'cert_id'", ":", "keys_cert", "[", "'certificateId'", "]", ",", "'thing_name'", ":", "thing_name", "}", "logging", ".", "debug", "(", "\"create_core cfg:{0}\"", ".", "format", "(", "config", ")", ")", "logging", ".", "info", "(", "\"Thing:'{0}' associated with cert:'{1}'\"", ".", "format", "(", "thing_name", ",", "cert_arn", ")", ")", "core_policy", "=", "self", ".", "get_core_policy", "(", "core_name", "=", "thing_name", ",", "account_id", "=", "account_id", ",", "region", "=", "region", ")", "iot_client", "=", "_get_iot_session", "(", "region", "=", "region", ",", "profile_name", "=", "profile_name", ")", "self", ".", "_create_attach_thing_policy", "(", "cert_arn", ",", "core_policy", ",", "iot_client", "=", "iot_client", ",", "policy_name", "=", "policy_name", ")", "misc", "=", "config", "[", "'misc'", "]", "misc", "[", "'policy_name'", "]", "=", "policy_name", "config", "[", "'misc'", "]", "=", "misc" ]

[ "Using", "the", "thing_name", "value", "creates", "a", "Thing", "in", "AWS", "IoT", "attaches", "and", "downloads", "new", "keys", "&", "certs", "to", "the", "certificate", "directory", "then", "records", "the", "created", "information", "in", "the", "local", "config", "file", "for", "inclusion", "in", "the", "Greengrass", "Group", "as", "a", "Greengrass", "Core", "." ]