idx int64 0 251k | question stringlengths 53 3.53k | target stringlengths 5 1.23k | len_question int64 20 893 | len_target int64 3 238 |
|---|---|---|---|---|
235,300 | def _find_log_index ( f ) : global _last_asked , _log_cache ( begin , end ) = ( 0 , 128 ) # Most calls are sequential, this keeps track of the last value asked for so # that we need to search much, much less. if _last_asked is not None : ( lastn , lastval ) = _last_asked if f >= lastval : if f <= _log_cache [ lastn ] : _last_asked = ( lastn , f ) return lastn elif f <= _log_cache [ lastn + 1 ] : _last_asked = ( lastn + 1 , f ) return lastn + 1 begin = lastn # Do some range checking if f > _log_cache [ 127 ] or f <= 0 : return 128 # Binary search related algorithm to find the index while begin != end : n = ( begin + end ) // 2 c = _log_cache [ n ] cp = _log_cache [ n - 1 ] if n != 0 else 0 if cp < f <= c : _last_asked = ( n , f ) return n if f < c : end = n else : begin = n _last_asked = ( begin , f ) return begin | Look up the index of the frequency f in the frequency table . | 271 | 13 |
235,301 | def find_frequencies ( data , freq = 44100 , bits = 16 ) : # Fast fourier transform n = len ( data ) p = _fft ( data ) uniquePts = numpy . ceil ( ( n + 1 ) / 2.0 ) # Scale by the length (n) and square the value to get the amplitude p = [ ( abs ( x ) / float ( n ) ) ** 2 * 2 for x in p [ 0 : uniquePts ] ] p [ 0 ] = p [ 0 ] / 2 if n % 2 == 0 : p [ - 1 ] = p [ - 1 ] / 2 # Generate the frequencies and zip with the amplitudes s = freq / float ( n ) freqArray = numpy . arange ( 0 , uniquePts * s , s ) return zip ( freqArray , p ) | Convert audio data into a frequency - amplitude table using fast fourier transformation . | 185 | 16 |
235,302 | def find_Note ( data , freq , bits ) : data = find_frequencies ( data , freq , bits ) return sorted ( find_notes ( data ) , key = operator . itemgetter ( 1 ) ) [ - 1 ] [ 0 ] | Get the frequencies feed them to find_notes and the return the Note with the highest amplitude . | 56 | 19 |
235,303 | def analyze_chunks ( data , freq , bits , chunksize = 512 ) : res = [ ] while data != [ ] : f = find_frequencies ( data [ : chunksize ] , freq , bits ) res . append ( sorted ( find_notes ( f ) , key = operator . itemgetter ( 1 ) ) [ - 1 ] [ 0 ] ) data = data [ chunksize : ] return res | Cut the one channel data in chunks and analyzes them separately . | 91 | 13 |
235,304 | def find_melody ( file = '440_480_clean.wav' , chunksize = 512 ) : ( data , freq , bits ) = data_from_file ( file ) res = [ ] for d in analyze_chunks ( data , freq , bits , chunksize ) : if res != [ ] : if res [ - 1 ] [ 0 ] == d : val = res [ - 1 ] [ 1 ] res [ - 1 ] = ( d , val + 1 ) else : res . append ( ( d , 1 ) ) else : res . append ( ( d , 1 ) ) return [ ( x , freq ) for ( x , freq ) in res ] | Cut the sample into chunks and analyze each chunk . | 147 | 10 |
235,305 | def write_Note ( file , note , bpm = 120 , repeat = 0 , verbose = False ) : m = MidiFile ( ) t = MidiTrack ( bpm ) m . tracks = [ t ] while repeat >= 0 : t . set_deltatime ( '\x00' ) t . play_Note ( note ) t . set_deltatime ( "\x48" ) t . stop_Note ( note ) repeat -= 1 return m . write_file ( file , verbose ) | Expect a Note object from mingus . containers and save it into a MIDI file specified in file . | 112 | 21 |
235,306 | def write_NoteContainer ( file , notecontainer , bpm = 120 , repeat = 0 , verbose = False ) : m = MidiFile ( ) t = MidiTrack ( bpm ) m . tracks = [ t ] while repeat >= 0 : t . set_deltatime ( '\x00' ) t . play_NoteContainer ( notecontainer ) t . set_deltatime ( "\x48" ) t . stop_NoteContainer ( notecontainer ) repeat -= 1 return m . write_file ( file , verbose ) | Write a mingus . NoteContainer to a MIDI file . | 124 | 12 |
235,307 | def write_Bar ( file , bar , bpm = 120 , repeat = 0 , verbose = False ) : m = MidiFile ( ) t = MidiTrack ( bpm ) m . tracks = [ t ] while repeat >= 0 : t . play_Bar ( bar ) repeat -= 1 return m . write_file ( file , verbose ) | Write a mingus . Bar to a MIDI file . | 75 | 11 |
235,308 | def write_Track ( file , track , bpm = 120 , repeat = 0 , verbose = False ) : m = MidiFile ( ) t = MidiTrack ( bpm ) m . tracks = [ t ] while repeat >= 0 : t . play_Track ( track ) repeat -= 1 return m . write_file ( file , verbose ) | Write a mingus . Track to a MIDI file . | 75 | 11 |
235,309 | def write_Composition ( file , composition , bpm = 120 , repeat = 0 , verbose = False ) : m = MidiFile ( ) t = [ ] for x in range ( len ( composition . tracks ) ) : t += [ MidiTrack ( bpm ) ] m . tracks = t while repeat >= 0 : for i in range ( len ( composition . tracks ) ) : m . tracks [ i ] . play_Track ( composition . tracks [ i ] ) repeat -= 1 return m . write_file ( file , verbose ) | Write a mingus . Composition to a MIDI file . | 116 | 12 |
235,310 | def get_midi_data ( self ) : tracks = [ t . get_midi_data ( ) for t in self . tracks if t . track_data != '' ] return self . header ( ) + '' . join ( tracks ) | Collect and return the raw binary MIDI data from the tracks . | 52 | 12 |
235,311 | 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 . | 73 | 9 |
235,312 | 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 . | 115 | 15 |
235,313 | 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 . | 185 | 13 |
235,314 | 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 . | 91 | 8 |
235,315 | 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 . | 263 | 9 |
235,316 | 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 . | 312 | 11 |
235,317 | 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 . | 50 | 9 |
235,318 | 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 . | 94 | 28 |
235,319 | 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 . | 60 | 17 |
235,320 | 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 . | 139 | 7 |
235,321 | 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 | 93 | 7 |
235,322 | 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 | 215 | 17 |
235,323 | 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 | 373 | 27 |
235,324 | 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 . | 66 | 7 |
235,325 | def set_author ( self , author , email = '' ) : self . author = author self . email = email | Set the author of the suite . | 24 | 7 |
235,326 | def set_title ( self , title , subtitle = '' ) : self . title = title self . subtitle = subtitle | Set the title and the subtitle of the suite . | 24 | 10 |
235,327 | 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 . | 99 | 7 |
235,328 | 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 . | 92 | 11 |
235,329 | 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 . | 63 | 12 |
235,330 | 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 . | 154 | 19 |
235,331 | 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 . | 90 | 24 |
235,332 | 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 . | 213 | 17 |
235,333 | 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 . | 87 | 17 |
235,334 | 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 . | 125 | 13 |
235,335 | 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 . | 121 | 18 |
235,336 | 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 . | 51 | 14 |
235,337 | 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 . | 56 | 9 |
235,338 | 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 . | 128 | 14 |
235,339 | def note_off ( self , channel , note , velocity ) : return self . midi_event ( NOTE_OFF , channel , note , velocity ) | Return bytes for a note off event . | 32 | 8 |
235,340 | def note_on ( self , channel , note , velocity ) : return self . midi_event ( NOTE_ON , channel , note , velocity ) | Return bytes for a note_on event . | 32 | 9 |
235,341 | 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 . | 41 | 9 |
235,342 | 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 . | 51 | 6 |
235,343 | 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 . | 39 | 19 |
235,344 | 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 . | 77 | 10 |
235,345 | 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 . | 103 | 8 |
235,346 | 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 . | 48 | 11 |
235,347 | 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 . | 132 | 9 |
235,348 | 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 . | 49 | 10 |
235,349 | 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 . | 148 | 10 |
235,350 | 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 . | 237 | 16 |
235,351 | 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 . | 724 | 11 |
235,352 | 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 . | 89 | 12 |
235,353 | 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 . | 218 | 10 |
235,354 | 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 . | 156 | 11 |
235,355 | 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 . | 87 | 26 |
235,356 | 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 . | 37 | 12 |
235,357 | 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 . | 208 | 15 |
235,358 | 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 . | 166 | 9 |
235,359 | 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 . | 39 | 11 |
235,360 | def from_interval ( self , startnote , shorthand , up = True ) : return self . from_interval_shorthand ( startnote , shorthand , up ) | Shortcut to from_interval_shorthand . | 37 | 12 |
235,361 | 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 . | 88 | 15 |
235,362 | 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 . | 91 | 5 |
235,363 | 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 . | 70 | 6 |
235,364 | 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 . | 42 | 11 |
235,365 | 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 . | 31 | 15 |
235,366 | 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 . | 39 | 13 |
235,367 | 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 . | 182 | 9 |
235,368 | 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 . | 120 | 6 |
235,369 | 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 . | 101 | 12 |
235,370 | 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 . | 366 | 21 |
235,371 | 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 . | 346 | 17 |
235,372 | 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 . | 181 | 17 |
235,373 | 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 . | 449 | 17 |
235,374 | 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 . | 136 | 19 |
235,375 | 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 . | 102 | 11 |
235,376 | 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 . | 43 | 15 |
235,377 | def triad ( note , key ) : return [ note , intervals . third ( note , key ) , intervals . fifth ( note , key ) ] | Return the triad on note in key as a list . | 31 | 12 |
235,378 | 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 . | 66 | 8 |
235,379 | def augmented_triad ( note ) : return [ note , intervals . major_third ( note ) , notes . augment ( intervals . major_fifth ( note ) ) ] | Build an augmented triad on note . | 36 | 8 |
235,380 | def seventh ( note , key ) : return triad ( note , key ) + [ intervals . seventh ( note , key ) ] | Return the seventh chord on note in key . | 27 | 9 |
235,381 | 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 . | 68 | 12 |
235,382 | 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 . | 35 | 9 |
235,383 | 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 . | 40 | 9 |
235,384 | def eleventh ( note ) : return [ note , intervals . perfect_fifth ( note ) , intervals . minor_seventh ( note ) , intervals . perfect_fourth ( note ) ] | Build an eleventh chord on note . | 39 | 8 |
235,385 | 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 . | 35 | 9 |
235,386 | 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 . | 681 | 14 |
235,387 | 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 . | 246 | 4 |
235,388 | 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 . | 581 | 11 |
235,389 | 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 . | 758 | 20 |
235,390 | 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 . | 607 | 10 |
235,391 | 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 . | 493 | 11 |
235,392 | 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 . | 312 | 30 |
235,393 | 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 . | 180 | 15 |
235,394 | 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 . | 295 | 16 |
235,395 | 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 . | 348 | 15 |
235,396 | 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 . | 131 | 15 |
235,397 | 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 . | 90 | 14 |
235,398 | 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 . | 170 | 18 |
235,399 | 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 . | 277 | 16 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.