self._name = 'xml_node'
self._parent = None
self._attribute_dict = {}
-
+
def get_parent (self):
return self._parent
-
+
def is_first (self):
return self._parent.get_typed_children (self.__class__)[0] == self
while p:
ly.progress (' In: <%s %s>\n' % (p._name, ' '.join (['%s=%s' % item for item in p._attribute_dict.items ()])))
p = p.get_parent ()
-
+
def dump (self, indent = ''):
ly.debug_output ('%s<%s%s>' % (indent, self._name, ''.join ([' %s=%s' % item for item in self._attribute_dict.items ()])))
non_text_children = [c for c in self._children if not isinstance (c, Hash_text)]
ly.debug_output (indent)
ly.debug_output ('</%s>\n' % self._name)
-
+
def get_typed_children (self, klass):
if not klass:
return []
return wt.get_text ()
else:
return ''
-
+
def get_work_title (self):
return self.get_work_information ('work-title')
def get_work_number (self):
return v
v = self.get_creator ('poet')
return v
-
+
def get_encoding_information (self, type):
enc = self.get_named_children ('encoding')
if enc:
return children[0].get_text ()
else:
return None
-
+
def get_encoding_software (self):
return self.get_encoding_information ('software')
def get_encoding_date (self):
return self.get_encoding_information ('encoder')
def get_encoding_description (self):
return self.get_encoding_information ('encoding-description')
-
+
def get_encoding_software_list (self):
enc = self.get_named_children ('encoding')
software = []
misc_fields = m.get_named_children ('miscellaneous-field')
for mf in misc_fields:
if hasattr (mf, 'name') and mf.name == 'description':
- return mf.get_text ()
+ return mf.get_text ()
return None
class Duration (Music_xml_node):
return cn[0] == self._original_tag
else:
return cn[0] == self
-
+
def set_attributes_from_previous (self, dict):
self._dict.update (dict)
-
+
def read_self (self):
for c in self.get_all_children ():
self._dict[c.get_name()] = c
def get_named_attribute (self, name):
return self._dict.get (name)
-
+
def single_time_sig_to_fraction (self, sig):
if len (sig) < 2:
return 0
# Simple (maybe compound) time signature of the form (beat, ..., type)
return self.single_time_sig_to_fraction (sig)
return 0
-
+
def get_time_signature (self):
"Return time sig as a (beat, beat-type) tuple. For compound signatures,"
"return either (beat, beat,..., beat-type) or ((beat,..., type), "
return 3
else:
return None
-
+
def get_duration_info (self):
log = self.get_duration_log ()
if log != None:
def __init__ (self):
Music_xml_node.__init__ (self)
self._id_instrument_name_dict = {}
-
+
def generate_id_instrument_dict (self):
## not empty to make sure this happens only once.
pass
class Score_part (Music_xml_node):
pass
-
+
class Measure (Music_xml_node):
def __init__ (self):
Music_xml_node.__init__ (self)
n = n._parent
return n.get_named_child ('part-list')
-
+
def interpret (self):
"""Set durations and starting points."""
"""The starting point of the very first note is 0!"""
-
+
part_list = self.get_part_list ()
-
+
now = Rational (0)
factor = Rational (1)
attributes_dict = {}
n.read_self ()
attributes_dict = n._dict.copy ()
attributes_object = n
-
+
factor = Rational (1,
int (attributes_dict.get ('divisions').get_text ()))
-
+
if (n.get_maybe_exist_typed_child (Duration)):
mxl_dur = n.get_maybe_exist_typed_child (Duration)
dur = mxl_dur.get_length () * factor
-
+
if n.get_name() == 'backup':
dur = - dur
# reset all graces before the backup to after-graces:
n._prev_measure_position = last_measure_position
# After-graces are placed at the same position as the previous note
if isinstance(n, Note) and n.is_after_grace ():
- # TODO: We should do the same for grace notes at the end of
+ # TODO: We should do the same for grace notes at the end of
# a measure with no following note!!!
n._when = last_moment
n._measure_position = last_measure_position
else:
id = "None"
- # We don't need backup/forward any more, since we have already
- # assigned the correct onset times.
+ # We don't need backup/forward any more, since we have already
+ # assigned the correct onset times.
# TODO: Let Grouping through. Also: link, print, bokmark sound
if not (isinstance (n, Note) or isinstance (n, Attributes) or
isinstance (n, Direction) or isinstance (n, Partial) or
continue
if isinstance (n, Harmony) or isinstance (n, FiguredBass):
- # store the harmony or figured bass element until we encounter
+ # store the harmony or figured bass element until we encounter
# the next note and assign it only to that one voice.
assign_to_next_note.append (n)
continue
if hasattr (n, 'print-object') and getattr (n, 'print-object') == "no":
- #Skip this note.
+ #Skip this note.
pass
else:
for i in assign_to_next_note:
def get_tuplet_note_count (self, tuplet_note):
if tuplet_note:
tuplet_nr = tuplet_note.get_maybe_exist_named_child ('tuplet-number')
- if tuplet_nr:
+ if tuplet_nr:
return int (tuplet_nr.get_text ())
return None
def get_normal_nr (self):
class Wavy_line (Music_xml_spanner):
pass
-
+
class Pedal (Music_xml_spanner):
pass
klass = new.classobj (class_name, (Music_xml_node,) , {})
class_dict[name] = klass
return klass
-
+
def lxml_demarshal_node (node):
name = node.tag
return None
klass = get_class (name)
py_node = klass()
-
+
py_node._original = node
py_node._name = name
py_node._data = node.text
py_node._children = [lxml_demarshal_node (cn) for cn in node.getchildren()]
py_node._children = filter (lambda x: x, py_node._children)
-
+
for c in py_node._children:
c._parent = py_node
for (nm, value) in node.attributes.items ():
py_node.__dict__[nm] = value
py_node._attribute_dict[nm] = value
-
+
py_node._data = None
if node.nodeType == node.TEXT_NODE and node.data:
py_node._data = node.data
if __name__ == '__main__':
import lxml.etree
-
+
tree = lxml.etree.parse ('beethoven.xml')
mxl_tree = lxml_demarshal_node (tree.getroot ())
ks = class_dict.keys ()
if staff_lines:
lines = string.atoi (staff_lines.get_text ())
- tunings = [musicexp.Pitch()]*lines
+ tunings = [musicexp.Pitch()] * lines
staff_tunings = details.get_named_children ('staff-tuning')
for i in staff_tunings:
p = musicexp.Pitch()
r.repeat_count = repeat_times
# don't erase the first element for "implicit" repeats (i.e. no
# starting repeat bars at the very beginning)
- start = repeat_start+1
+ start = repeat_start + 1
if repeat_start == music_start:
start = music_start
r.set_music (music_list[start:repeat_end])
for (start, end) in endings:
s = musicexp.SequentialMusic ()
- s.elements = music_list[start+1:end]
+ s.elements = music_list[start + 1:end]
r.add_ending (s)
- del music_list[repeat_start:final_marker+1]
+ del music_list[repeat_start:final_marker + 1]
music_list.insert (repeat_start, r)
repeat_replaced = True
pos += 1
# <time-modification> elements of the note:
def musicxml_tuplet_to_lily (tuplet_elt, time_modification):
tsm = musicexp.TimeScaledMusic ()
- fraction = (1,1)
+ fraction = (1, 1)
if time_modification:
fraction = time_modification.get_fraction ()
tsm.numerator = fraction[0]
- tsm.denominator = fraction[1]
+ tsm.denominator = fraction[1]
normal_type = tuplet_elt.get_normal_type ()
(fifths, mode) = key_sig
change.mode = mode
- start_pitch = musicexp.Pitch ()
+ start_pitch = musicexp.Pitch ()
start_pitch.octave = 0
try:
- (n,a) = {
- 'major' : (0,0),
- 'minor' : (5,0),
- 'ionian' : (0,0),
- 'dorian' : (1,0),
- 'phrygian' : (2,0),
- 'lydian' : (3,0),
- 'mixolydian': (4,0),
- 'aeolian' : (5,0),
- 'locrian' : (6,0),
+ (n, a) = {
+ 'major' : (0, 0),
+ 'minor' : (5, 0),
+ 'ionian' : (0, 0),
+ 'dorian' : (1, 0),
+ 'phrygian' : (2, 0),
+ 'lydian' : (3, 0),
+ 'mixolydian': (4, 0),
+ 'aeolian' : (5, 0),
+ 'locrian' : (6, 0),
}[mode]
start_pitch.step = n
start_pitch.alteration = a
chromatic_shift = string.atoi (transpose.get_named_child ('chromatic').get_text ())
chromatic_shift_normalized = chromatic_shift % 12;
(shift.step, shift.alteration) = [
- (0,0), (0,1), (1,0), (2,-1), (2,0),
- (3,0), (3,1), (4,0), (5,-1), (5,0),
- (6,-1), (6,0)][chromatic_shift_normalized];
+ (0, 0), (0, 1), (1, 0), (2, -1), (2, 0),
+ (3, 0), (3, 1), (4, 0), (5, -1), (5, 0),
+ (6, -1), (6, 0)][chromatic_shift_normalized];
shift.octave += (chromatic_shift - chromatic_shift_normalized) / 12
def musicxml_attributes_to_lily (attrs):
elts = []
- attr_dispatch = {
+ attr_dispatch = {
'clef': musicxml_clef_to_lily,
'time': musicxml_time_to_lily,
'key': musicxml_key_to_lily,
dynamicsname = dynentry.get_name ()
if dynamicsname == "other-dynamics":
dynamicsname = dynentry.get_text ()
- if not dynamicsname or dynamicsname=="#text":
+ if not dynamicsname or dynamicsname == "#text":
return
if not dynamicsname in dynamics_available:
def hex_to_color (hex_val):
res = re.match (r'#([0-9a-f][0-9a-f]|)([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])$', hex_val, re.IGNORECASE)
if res:
- return map (lambda x: hexcolorval_to_nr (x), res.group (2,3,4))
+ return map (lambda x: hexcolorval_to_nr (x), res.group (2, 3, 4))
else:
return None
dur = n.get_maybe_exist_named_child ('duration')
if dur:
# apply the duration to res
- length = Rational(int(dur.get_text()), n._divisions)*Rational(1,4)
+ length = Rational(int(dur.get_text()), n._divisions) * Rational(1, 4)
res.set_real_duration (length)
duration = rational_to_lily_duration (length)
if duration:
}
def musicxml_note_to_lily_main_event (n):
- pitch = None
+ pitch = None
duration = None
event = None
def current_duration (self):
return self.end_moment - self.begin_moment
- def add_music (self, music, duration, relevant = True):
+ def add_music (self, music, duration, relevant=True):
assert isinstance (music, musicexp.Music)
if self.pending_multibar > Rational (0):
self._insert_multibar ()
self.pending_dynamics = []
# Insert some music command that does not affect the position in the measure
- def add_command (self, command, relevant = True):
+ def add_command (self, command, relevant=True):
assert isinstance (command, musicexp.Music)
if self.pending_multibar > Rational (0):
self._insert_multibar ()
self.has_relevant_elements = self.has_relevant_elements or relevant
self.elements.append (command)
- def add_barline (self, barline, relevant = False):
+ def add_barline (self, barline, relevant=False):
# Insert only if we don't have a barline already
# TODO: Implement proper merging of default barline and custom bar line
has_relevant = self.has_relevant_elements
diff = moment - current_end
if diff < Rational (0):
- ly.warning (_ ('Negative skip %s (from position %s to %s)') %
- (diff, current_end, moment))
+ ly.warning (_ ('Negative skip %s (from position %s to %s)')
+ % (diff, current_end, moment))
diff = Rational (0)
if diff > Rational (0) and not (self.ignore_skips and moment == 0):
value = None
# if the position matches, find the last ChordEvent, do not cross a bar line!
- at = len( self.elements ) - 1
+ at = len(self.elements) - 1
while (at >= 0 and
not isinstance (self.elements[at], musicexp.ChordEvent) and
not isinstance (self.elements[at], musicexp.BarLine)):
def uniq_list (l):
- return dict ([(elt,1) for elt in l]).keys ()
+ return dict ([(elt, 1) for elt in l]).keys ()
# format the information about the staff in the form
# [staffid,
projects / lilypond.git / commitdiff