spiffyscore

    }
    print '''f1 0 512 10 1
f2 0 8192 10 .24 .64 .88 .76 .06 .5 .34 .08
f3 0 1025 10 1
t 0 60
    '''

    start = 0
    for section in ["verse1", "verse2"]:
        section = composition[section]
#        for subsection in section
        instrs = []
        for instr in section.values():
            sync = None
            max_time = instr["duration"]
            instr_score = render_instr(instr, sync, max_time)
            instrs.append(instr_score)
            for line in generate_csound_score(instr_score, instr["score_line"], start):
                print line
        longest_score = max(instrs, key=lambda i: score_len(i))
        start = score_len(longest_score)
        


def render_instr(instr, sync, max_time):
    grammars = instr["grammars"]
    for g in instr["grammars"]:
        for i in range(len(grammars[g])):
            grammars[g][i] = parse.parse(grammars[g][i])
    init_node = random.choice(instr["grammars"].keys())
    init_score = random.choice(instr["grammars"][init_node])
    score = init_score
    while True:
        time_remaining = max_time - score_len(score)
        try:
            score = choose_node(score, grammars, time_remaining)
        except ValueError:
            break
    return score


def choose_node(score, grammars, time_remaining):
    if time_remaining <= 0:
        raise ValueError("No time remaining in the score")
    node = None
    node_index = None
    for item in range(len(score)):
        if isinstance(score[item], tree.Tree):
            node = score[item].name
            node_index = item
    if node is None:
        raise ValueError("No more nodes to fill in")
    options = []
    for g in range(len(grammars[node])):
        if score_len(grammars[node][g]) <= time_remaining:
            options.append(grammars[node][g])
    if len(options) == 0:
        raise ValueError("No available grammars that will fit in the score")



    phrase = random.choice(options)
    score = score[:node_index-1] + phrase + score[node_index+1:]
    return score

            
            



#    movement_start = 0
#    progression = "verse1 verse2"
#    for comp_name in progression.split():
#        # We need an arbitrary grammar from this instrument to start the score with
#        max_instr =  0
#        for instr_name, instr in composition[comp_name].iteritems():
#            for grammar in instr["grammars"]:
#                for g in range(len(instr["grammars"][grammar])):
#                    instr["grammars"][grammar][g] = parse.parse(instr["grammars"][grammar][g], default_octave=instr["octave"])
#            g = random.choice(instr["grammars"].keys())
#            ins_score = random.choice(instr["grammars"][g])
##            ins_score = instr["grammars"][g]
#            score_complete = False
#            while score_complete is False:
#                if score_len(ins_score) >= instr["duration"]:
#                    score_complete = True
#                    break
#                for i in range(len(ins_score)):
#                    if isinstance(ins_score[i], tree.Tree):
#                        unrolled_score = select_node(instr["grammars"][ins_score[i].name])
#                        new_score = ins_score[:i-1] + unrolled_score + ins_score[i+1:]
#                        ins_score = new_score
#                    if i == len(ins_score):
#                        score_complete = True
#                        break
#            
#
#            ins_score = [n for n in ins_score if not isinstance(n, tree.Tree)]
#            composition[comp_name][instr_name]["score"] = ins_score
#
#            if score_len(ins_score) > max_instr:
#                max_instr = score_len(ins_score)
#            for line in generate_csound_score(composition[comp_name][instr_name]["score"], instr["score_line"], movement_start):
#                print line
#
#        movement_start += max_instr


def score_len(score):
    total = 0
    for n in score:
        if not isinstance(n, tree.Tree):
            total += n.duration
    return total

def select_node(grammar):
    return random.choice(grammar)
            

def generate_score(score, grammars):
    while 1:
        found_substitution = False
        for key,value in grammars.iteritems():
            if score.find(key) != -1:
                found_substitution = True
                while score.find(key) != -1:
                    score = score.replace(key, random.choice(grammars[key]), 1)
#                    print scoe
                    if len(score.split()) > 2000:
                        for k in grammars.keys():
                            score = score.replace(k, "")
                        return score
        if found_substitution is False:
            break
    return score


def generate_csound_score(score, score_line, t):
    csound_note_values = {
        "C": "00",
        "C#": "01",
        "D": "02",
        "D#": "03",