spiffyscore

Check-in [18dba95a2e]
Login
Overview
Comment:Changed parser to include nodes
Timelines: family | ancestors | descendants | both | feature/abc
Files: files | file ages | folders
SHA1: 18dba95a2ee0cf3b0795ff7e88437a1a3104a7b1
User & Date: brian on 2011-09-13 20:02:12
Other Links: branch diff | manifest | tags
Context
2011-09-13
20:08
Added a name parameter to the Tree class that will prove helpful in generating the score check-in: 029fd48614 user: brian tags: feature/abc
20:02
Changed parser to include nodes check-in: 18dba95a2e user: brian tags: feature/abc
19:47
Replaced roman numerals with note literals check-in: 6a80123223 user: brian tags: feature/abc
Changes

Modified parse.py from [67fb9f1f54] to [751d12bb6a].

1


2
3
4
5
6
7
8
#!/usr/bin/env python



from ply import lex, yacc
class Note():
    def __init__(self, value, duration=.25, octave=8):
        self.value = value
        self.duration = duration
        self.octave = octave

>
>







1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env python

import tree

from ply import lex, yacc
class Note():
    def __init__(self, value, duration=.25, octave=8):
        self.value = value
        self.duration = duration
        self.octave = octave
33
34
35
36
37
38
39

40
41
42
43
44
45
46
47
48
49
50
51

52
53
54
55
56
57
58
        "NOTE_LENGTH",
        "BASENOTE",
        "ACCIDENTAL",
        "REST",
        "OCTAVE",
        "CHORD_TYPE",
        "QUOTE",

    )

    t_ignore = " |"

    #t_BASENOTE = r"[A-Ga-g]"
#    t_BASENOTE = r"I+V?|VI*|i+v?|vi*"
    t_BASENOTE = r"[A-Ga-g]"
    t_ACCIDENTAL = r"\^{1,2}|_{1,2}|="
    t_REST = r"z"
    t_OCTAVE = r"'+|,+"
    t_CHORD_TYPE = r"m|7|m7|0|o|\+|mb5|sus|sus4|maj7|mmaj7|7sus4|dim|dim7|7b5|m7b5|6|b6|m6|mb6|46|maj9|9|add9|7b9|m9"
    t_QUOTE = '"'


    def t_NOTE_LENGTH(t):
        r"/?\d+"
        multiplier = float(t.value.strip("/"))
        if t.value.startswith("/"):
            multiplier = 1/multiplier
        t.value = multiplier







>












>







35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
        "NOTE_LENGTH",
        "BASENOTE",
        "ACCIDENTAL",
        "REST",
        "OCTAVE",
        "CHORD_TYPE",
        "QUOTE",
        "NODE",
    )

    t_ignore = " |"

    #t_BASENOTE = r"[A-Ga-g]"
#    t_BASENOTE = r"I+V?|VI*|i+v?|vi*"
    t_BASENOTE = r"[A-Ga-g]"
    t_ACCIDENTAL = r"\^{1,2}|_{1,2}|="
    t_REST = r"z"
    t_OCTAVE = r"'+|,+"
    t_CHORD_TYPE = r"m|7|m7|0|o|\+|mb5|sus|sus4|maj7|mmaj7|7sus4|dim|dim7|7b5|m7b5|6|b6|m6|mb6|46|maj9|9|add9|7b9|m9"
    t_QUOTE = '"'
    t_NODE = r"([a-zA-Z0-9_-]+)"

    def t_NOTE_LENGTH(t):
        r"/?\d+"
        multiplier = float(t.value.strip("/"))
        if t.value.startswith("/"):
            multiplier = 1/multiplier
        t.value = multiplier
75
76
77
78
79
80
81

82
83
84
85
86
87
88

89
90
91
92
93
94
95
    # Parse (yacc)


    def p_pitch_list(p):
        '''score : score note
            | score chord
            | score rest

        '''
        p[0] = p[1] + [p[2]]

    def p_score(p):
        '''score : note
            | chord
            | rest

        '''
        p[0] = [p[1]]


    def p_note(p):
        '''note : pitch
        '''







>







>







79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
    # Parse (yacc)


    def p_pitch_list(p):
        '''score : score note
            | score chord
            | score rest
            | score node
        '''
        p[0] = p[1] + [p[2]]

    def p_score(p):
        '''score : note
            | chord
            | rest
            | node
        '''
        p[0] = [p[1]]


    def p_note(p):
        '''note : pitch
        '''
144
145
146
147
148
149
150






151
152
153
154
155
156
157
158
    def p_rest(p):
        ''' rest : REST
                | REST NOTE_LENGTH
        '''
        p[0] = Rest()
        if len(p) > 2:
            p[0].duration = p[2]







    def p_error(p):
        raise Exception("Syntax error at '%s' of element type %s" % (p.value, p.type))
        
    yacc.yacc()

    #print yacc.parse("GFG B'AB,, | g/2fg gab | GFG BAB | d2A AFD")
    return yacc.parse(score)







>
>
>
>
>
>








150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
    def p_rest(p):
        ''' rest : REST
                | REST NOTE_LENGTH
        '''
        p[0] = Rest()
        if len(p) > 2:
            p[0].duration = p[2]

    def node(p):
        '''node: NODE
        '''
        p[0] = tree.tree(node.strip("(").strip(")"))


    def p_error(p):
        raise Exception("Syntax error at '%s' of element type %s" % (p.value, p.type))
        
    yacc.yacc()

    #print yacc.parse("GFG B'AB,, | g/2fg gab | GFG BAB | d2A AFD")
    return yacc.parse(score)

Added tree.py version [7aba067c30].































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import pdb

class Tree():
    def __init__(self):
        self.nodes = []

    def traverse_depth_first(self):
        all_nodes = []
        for node in self.nodes:
            if isinstance(node, Node):
                all_nodes.append(node)
            elif isinstance(node, Tree):
#                pdb.set_trace()
                all_nodes.extend(node.traverse_depth_first())
        return all_nodes

    def __str__(self):
        return str(self.__unicode__())
    def __unicode__(self):
        return self.nodes


class Node():
    def __init__(self, parent, data):
        self.parent = parent
        self.data = data

    def __str__(self):
        return str(self.__unicode__())
    def __unicode__(self):
        return self.data