#!/usr/bin/env python ''' bwwtolily: will convert a bww file to a lilypond file copyright: 2008 Jezra Lickter GPL v3 ''' from optparse import OptionParser import sys,os,re,subprocess version = "0.4.0" #define the class that will convert a bww file to a lilypond file class bwwtolily : def __init__(self,addmidi=False): self.tune_elements = [] self.most_recent_note = 0 self.in_note_group=False self.slur_tie_pending = False self.last_group_close=0 '''compile a few regex queries''' #make a regex to determine if something is a lilypond note self.regex_lilynote= re.compile("[abcdefgAG][0-9]*") #try to determine the time signature self.sig_regex = re.compile("([0-9])_([0-9])") #a regex to find notes self.regex_note_info=re.compile("(?P[A-Z]+)(?P[a-z]*)_(?P[0-9]{1,2})") #a regex to find grace notes self.regex_grace_note = re.compile("([h|l]*[abcdefgt])g") #a regex to parse doublings self.regex_doubling = re.compile("^db([h|l]*[g|a|b|c|d|e|f]{1})") #a regex to parse half_doublings self.regex_half_doubling = re.compile("^hdb([h|l]*[g|a|b|c|d|e|f]{1})") #a regex for finding strikes self.regex_strike = re.compile("str([h|l]*[abcdefg])") #a regex to find dots self.regex_dot = re.compile("'[h|l]*[abcdefg]") #a regex to find sub repeats self.regex_sub_repeat = re.compile("'([0-9]+)") #a regex to find note slurs, not slur embellishments self.regex_slur = re.compile("\^(?P[0-9])(?P[a-z]*)") #we need a list to ignore self.ignore_elements = ("sharpf","sharpc","space","&") #create a dictionary of common bww elements and their lily counterparts self.transpose_dict = { "!":"\\bar \"|\"\n", "!I":"\\bar \".|\" \\break \n", #"''!I":"\\set Score.repeatCommands = #'( end-repeat ) \\break \n", "''!I":"\\bar \":|\" \\break\n", #"''!I":"} \\break \n", "I!''":"\\bar \"|:\"", "I!":"\\bar \"|.\"", #"I!''":"\\set Score.repeatCommands = #'( start-repeat )\n", #"I!''":"\n\\repeat volta 2 {\n", "_'":"\\set Score.repeatCommands = #'((volta #f)) \\bar \"|\"\n", "!t":"\\bar \"|\" \\break\n\n", "thrd":"\\thrwd", "gbr":"\\gbirl", "brl":"\\wbirl", "abr":"\\birl", "lgstd":"\\dbld", "gste":"\\slure", "grp":"\\grip", "tar":"\\taor", "gstd":"\\slurd", "tdbf":"\\tdblf" } #are we adding midi? if addmidi: self.lily_midi="\midi{}" else: self.lily_midi='' def set_file(self,file_path): #determine the absolute path to the file abs_file = os.path.join(os.getcwd(),file_path) file_name = os.path.basename(abs_file) (self.name,ext) = file_name.split(".") #does the file exist? if os.path.isfile(abs_file): self.original_file = abs_file self.file_dir = os.path.dirname(abs_file) else: raise Exception(bww_file_path+" is not a file") def quit(self,string=""): if string!="": print string sys.exit() def parse(self): '''reate a string that represents the converted contents of the file''' #open the file read only file_handle = open(self.original_file,"r") #read the contents of the file file_text = file_handle.read() #get the title,type,author of the file, these are in quotes quote_regex = re.compile("\"(.*)\"") tune_info = quote_regex.findall(file_text) self.tune_title = tune_info[0] self.tune_type = tune_info[1] self.tune_author = tune_info[2] #try to determine the time signature result = self.sig_regex.search(file_text) if result: self.tune_time_sig = result.group(1)+"/"+result.group(2) else: self.tune_time_sig = "4/4" #get the tunes note info '''greedy, multiline, from first ampersand to !''' notes_regex = re.compile("&.*!I",re.S) result = notes_regex.search(file_text) try: tune_notes = result.group() except: #no notes were found, what kind of file is this self.quit("No notes were found.\nIs this a valid input file?") #replace all whitespace characters with spaces tune_notes = tune_notes.replace("\r"," ") tune_notes = tune_notes.replace("\n"," ") tune_notes = tune_notes.replace("\t"," ") '''determine if there is a partial''' ''' #get the first part of the notes from & to ! partial_regex = re.compile("&.*?[ |\r\n]!",re.S) #partial_regex = re.compile("&.*?!",re.S) result = partial_regex.findall(tune_notes) search_string = result[0] #find the time of the notes in the search string partial_regex = re.compile("[A-Z]+[a-z]*_([0-9]{1,2})") result = partial_regex.findall(search_string) self.tune_partial_string = "" if result: partial_time = 0 #TODO: determine the proper way to determine the partial for number in result: partial_time += (1.0/int(number)) print "time: %s" % ( partial_time ) #how many quarter notes is this? quarters = partial_time/.25 print "quarters: %d" % quarters #self.tune_partial_string = "\\partial %d" % quarters #self.tune_partial_string = "\\partial "+str(part) ''' #split the string into it's constituents elements elements = tune_notes.split() for element in elements: self.transpose(element) #print self.tune_notes def lilynote(self,bwwname): #convert a bww notename to a lilypond notename #make the notename lowercase notename = bwwname.lower() if notename =="lg": lilynote = "G" elif notename == "la": lilynote ="a" elif notename == "hg": lilynote = "g" elif notename == "ha" or notename =="t": lilynote = "A" else: lilynote = notename return lilynote def transpose(self,element): '''receive a bww element and return a lilypond equivelent''' #is the element a note? note_result = self.regex_note_info.search(element) if note_result: note = self.lilynote( note_result.group("note") )+note_result.group("time") #is a tie slur pending? if self.slur_tie_pending: self.slur_tie_pending=False note+="~" self.tune_elements.append(note) self.most_recent_note = len(self.tune_elements)-1 if note_result.group("dir") == "r" and not self.in_note_group: self.in_note_group=True self.tune_elements.append("[") elif note_result.group("dir") == "l": if self.in_note_group: self.in_note_group=False self.tune_elements.append("]") self.last_group_close = len(self.tune_elements)-1 else: #delete the last group close del(self.tune_elements[self.last_group_close]) #decrement the most recent note self.most_recent_note-=1 self.tune_elements.append("]") return #is the element a grace note? grace_result=self.regex_grace_note.search(element) if grace_result: grace = "\\gr"+self.lilynote( grace_result.group(1) ) self.tune_elements.append(grace) return #is the element a doubling? doubling_result=self.regex_doubling.search(element) if doubling_result: doubling = "\\dbl"+self.lilynote( doubling_result.group(1) ) self.tune_elements.append(doubling) return #is the element a half doubling? hdoubling_result=self.regex_half_doubling.search(element) if hdoubling_result: half_doubling = "\\hdbl"+self.lilynote( hdoubling_result.group(1) ) self.tune_elements.append(half_doubling) return #is the element a strike? strike_result=self.regex_strike.search(element) if strike_result: strike = "\\slur"+self.lilynote( strike_result.group(1) ) #if the strike is on low g \\slurG if strike =="\\slurG": #let the strike be a low g grace note strike = "\\grG" #if the strike is on high G elif strike =="\\slurg": #let the strike be a grace note on the high g strike = "\\grg" #if hte strike is on low a elif strike == "\\slura": #let the strike be a grace not on low a strike = "\\gra" self.tune_elements.append(strike) return #is the element a dot? dot_result=self.regex_dot.search(element) if dot_result: #add a dot to the last note note = self.tune_elements[self.most_recent_note] if note[-1]=="~": self.tune_elements[self.most_recent_note].replace("~",".~") else: self.tune_elements[self.most_recent_note]+="." return #is the element a slur? slur_result = self.regex_slur.search(element) if slur_result: #get the matching elements note_count = slur_result.group("note_count") end_note = slur_result.group("end_note") #get the length of the slur as an integer slur_len = int(note_count) '''find the position of the note that is slur_len from the end''' #get the tune_elements lenght elem_index = len(self.tune_elements)-1 note_count = 0 while note_count<2: element = self.tune_elements[elem_index] #is this element a note? is_note = self.regex_lilynote.search(element) if is_note: #increment the note count note_count+=1 #decrease the element index elem_index-=1 #add the slur start just after the start note self.tune_elements.insert(elem_index+1,"(") #add the slur end self.tune_elements.append(")") return #is this a bww tie slur? if element == "^ts": self.slur_tie_pending = True return #is the element the start of a sub_repeat? sub_repeat_result = self.regex_sub_repeat.search(element) if sub_repeat_result: sub_repeat = "\\set Score.repeatCommands = #'((volta \"%s\")) " % ( sub_repeat_result.group(1) ) self.tune_elements.append(sub_repeat) return else: #is the element in the ignore list? if element in self.ignore_elements: return ''' if the element is an start double, check if the previous element was a end double ''' if len(self.tune_elements): last_element = self.tune_elements[-1] if element=="I!''" and last_element.find(":|"): #replace the last element with a double double self.tune_elements[-1] = "\\bar \":|:\" \\break\n\n" return #is this a time sig? result = self.sig_regex.search(element) if result: return try: dict_result = self.transpose_dict[element] if dict_result: self.tune_elements.append(dict_result) return except: print "unparsed: "+element return #handle writing the output def create_output_file(self): #determine the output file output_file = os.path.join(self.file_dir,self.name+".ly") #open the file for writing file_handle = open(output_file,"w") #write the data to the file text = self.get_lilypond_text() file_handle.write(text) #close the handle file_handle.close() #return the string of the path to the file return output_file def get_lilypond_text(self): tune_text = " ".join(self.tune_elements) lptext ='''\\include "bagpipe.ly" melody = { \\set Staff.midiInstrument = #"bagpipe" \\hideKeySignature \\cadenzaOn \\once \\override Score.BreakAlignment #'break-align-orders = #(make-vector 3 '(instrument-name left-edge ambitus span-bar breathing-sign clef key-signature time-signature staff-bar custos span-bar)) \\time %s %s } \\score { \\melody \\layout { indent = 0.0\\cm \\context { \\Score \\remove "Bar_number_engraver" } } \\header { title = "%s" meter = "%s" arranger = "%s" } %s } ''' % (self.tune_time_sig, tune_text, self.tune_title, self.tune_type, self.tune_author, self.lily_midi ) return lptext #use the bww2lily class if __name__ == "__main__" : parser = OptionParser() parser.add_option("-i", "--in", dest="input", help="the FILE to convert", metavar="FILE") parser.add_option("-l", "--lilypond", action="store_true", dest="runlilypond", default=False, help="run lilypond after converting the file") parser.add_option("-m", "--midi", action="store_true", dest="addmidi", default=False, help="add midi output to the lilypond file") parser.add_option("-v","--version",dest='version', default=False, action="store_true",help="print version information and quit") #parse the args (options, args) = parser.parse_args() if options.version: print "bwwtolily: ",version sys.exit() if options.input!=None: b2l = bwwtolily(options.addmidi) b2l.set_file(options.input) b2l.parse() new_file = b2l.create_output_file() #are we running lilypond? if options.runlilypond: #try to run lilypond as a subprocess subprocess.check_call("lilypond \""+new_file+"\"",shell=True) else: parser.print_help() sys.exit()