More accurate spanner stop/start on import (and make import of exported MusicXML from those scores work, too)

music21/_version.py

@@ -50,7 +50,7 @@
 '''
 from __future__ import annotations
 
-__version__ = '9.7.2a4'
+__version__ = '9.7.4'
 
 def get_version_tuple(vv):
     v = vv.split('.')

music21/base.py

@@ -27,7 +27,7 @@
 <class 'music21.base.Music21Object'>
 
 >>> music21.VERSION_STR
-'9.7.2a4'
+'9.7.4'
 
 Alternatively, after doing a complete import, these classes are available
 under the module "base":

music21/musicxml/test_m21ToXml.py

@@ -7,7 +7,7 @@
 import re
 import unittest
 from xml.etree.ElementTree import (
-    ElementTree, fromstring as et_fromstring
+    ElementTree, fromstring as et_fromstring, tostring as et_tostring
 )
 
 from music21 import articulations
@@ -29,6 +29,7 @@
 from music21 import stream
 from music21 import style
 from music21 import tempo
+from music21.common import opFrac
 
 from music21.musicxml import helpers
 from music21.musicxml import testPrimitive
@@ -195,7 +196,7 @@ def testSpannersWritePartStaffs(self):
 
         # and written after the backup tag, i.e. on the LH?
         xmlOut = self.getXml(s)
-        xmlAfterFirstBackup = xmlOut.split('</backup>\n')[1]
+        xmlAfterSecondBackup = xmlOut.split('</backup>\n')[1]
 
         self.assertIn(
             stripInnerSpaces(
@@ -205,7 +206,7 @@ def testSpannersWritePartStaffs(self):
                         </direction-type>
                         <staff>2</staff>
                     </direction>'''),
-            stripInnerSpaces(xmlAfterFirstBackup)
+            stripInnerSpaces(xmlAfterSecondBackup)
         )
 
     def testLowVoiceNumbers(self):
@@ -847,6 +848,63 @@ def testPedals(self):
                 for k in expectedResults2[i]:
                     self.assertEqual(mxPedal.get(k, ''), expectedResults2[i][k])
 
+    def testSpannersWithOffsets(self):
+        def gnfilter(overlaps):
+            removeKeys = []
+            for key, elList in overlaps.items():
+                gnCount = 0
+                for el in elList:
+                    if isinstance(el, note.GeneralNote):
+                        gnCount += 1
+                if gnCount < 2:
+                    removeKeys.append(key)
+            for key in removeKeys:
+                del overlaps[key]
+            return overlaps
+
+        def check(s1, s2, classType):
+            s1Spanners = list(s1[classType])
+            s2Spanners = list(s2[classType])
+            for s1sp, s2sp in zip(s1Spanners, s2Spanners):
+                # check that the spanners start and stop at exactly the same score offset
+                s1StartOffset = s1sp.getFirst().getOffsetInHierarchy(s1)
+                s2StartOffset = s2sp.getFirst().getOffsetInHierarchy(s2)
+                self.assertEqual(s1StartOffset, s2StartOffset)
+                s1EndOffset = opFrac(
+                    s1sp.getLast().getOffsetInHierarchy(s1) + s1sp.getLast().quarterLength
+                )
+                s2EndOffset = opFrac(
+                    s2sp.getLast().getOffsetInHierarchy(s2) + s2sp.getLast().quarterLength
+                )
+                self.assertEqual(s1EndOffset, s2EndOffset)
+
+                # check that there are no overlapping GeneralNotes in those measures
+                s1StartVoice = s1.containerInHierarchy(s1sp.getFirst())
+                s1EndVoice = s1.containerInHierarchy(s1sp.getLast())
+                s1StartVoiceOverlaps = s1StartVoice.getOverlaps()
+                s1EndVoiceOverlaps = s1EndVoice.getOverlaps()
+                self.assertEqual(gnfilter(s1StartVoiceOverlaps), {})
+                self.assertEqual(gnfilter(s1EndVoiceOverlaps), {})
+
+                s2StartVoice = s2.containerInHierarchy(s2sp.getFirst())
+                s2EndVoice = s2.containerInHierarchy(s2sp.getLast())
+                s2StartVoiceOverlaps = s2StartVoice.getOverlaps()
+                s2EndVoiceOverlaps = s2EndVoice.getOverlaps()
+                self.assertEqual(gnfilter(s2StartVoiceOverlaps), {})
+                self.assertEqual(gnfilter(s2EndVoiceOverlaps), {})
+
+        s1 = converter.parse(testPrimitive.directions31a)
+        x = self.getET(s1)
+        xmlStr = et_tostring(x)
+        s2 = converter.parseData(xmlStr, format='musicxml')
+        check(s1, s2, dynamics.DynamicWedge)
+
+        s1 = converter.parse(testPrimitive.octaveShifts33d)
+        x = self.getET(s1)
+        xmlStr = et_tostring(x)
+        s2 = converter.parseData(xmlStr, format='musicxml')
+        check(s1, s2, spanner.Ottava)
+
     def testArpeggios(self):
         expectedResults = (
             'arpeggiate',

music21/musicxml/test_xmlToM21.py

@@ -1134,14 +1134,19 @@ def testPedalMarks(self):
         self.assertEqual(pm.pedalType, expressions.PedalType.Sustain)
         spElements = pm.getSpannedElements()
         self.assertEqual(len(spElements), 4)
+        expectedInstances = [
+            note.Note,
+            expressions.PedalBounce,
+            note.Note,
+            note.Note,
+        ]
         expectedOffsets = [0.0, 1.0, 1.0, 2.0]
-        for i, (el, expectedOffset) in enumerate(zip(spElements, expectedOffsets)):
-            if i == 1:
-                self.assertIsInstance(el, expressions.PedalBounce)
-            else:
-                self.assertIsInstance(el, note.Note)
-                self.assertEqual(el.fullName, 'C in octave 4 Quarter Note')
+        for i, (el, expectedOffset, expectedInstance) in enumerate(zip(
+                spElements, expectedOffsets, expectedInstances)):
+            self.assertIsInstance(el, expectedInstance)
             self.assertEqual(el.offset, expectedOffset)
+            if expectedInstance == note.Note:
+                self.assertEqual(el.fullName, 'C in octave 4 Quarter Note')
 
         s = converter.parse(testPrimitive.spanners33a)
         pedals = list(s[expressions.PedalMark])
@@ -1152,14 +1157,18 @@ def testPedalMarks(self):
         self.assertEqual(pm.pedalType, expressions.PedalType.Sustain)
         spElements = pm.getSpannedElements()
         self.assertEqual(len(spElements), 3)
+        expectedInstances = [
+            note.Note,
+            expressions.PedalBounce,
+            note.Note,
+        ]
         expectedOffsets = [0.0, 1.0, 1.0]
-        for i, (el, expectedOffset) in enumerate(zip(spElements, expectedOffsets)):
-            if i == 1:
-                self.assertIsInstance(el, expressions.PedalBounce)
-            else:
-                self.assertIsInstance(el, note.Note)
-                self.assertEqual(el.fullName, 'B in octave 4 Quarter Note')
+        for i, (el, expectedOffset, expectedInstance) in enumerate(zip(
+                spElements, expectedOffsets, expectedInstances)):
+            self.assertIsInstance(el, expectedInstance)
             self.assertEqual(el.offset, expectedOffset)
+            if expectedInstance == note.Note:
+                self.assertEqual(el.fullName, 'B in octave 4 Quarter Note')
 
         s = corpus.parse('beach')
         pedals = list(s[expressions.PedalMark])
@@ -1169,7 +1178,7 @@ def testPedalMarks(self):
         self.assertEqual(pm.pedalForm, expressions.PedalForm.Symbol)
         self.assertEqual(pm.pedalType, expressions.PedalType.Sustain)
         spElements = pm.getSpannedElements()
-        self.assertEqual(len(spElements), 2)
+        self.assertEqual(len(spElements), 3)
         self.assertIsInstance(spElements[0], chord.Chord)
         self.assertEqual(
             spElements[0].fullName,
@@ -1179,6 +1188,11 @@ def testPedalMarks(self):
         self.assertIsInstance(spElements[1], note.Note)
         self.assertEqual(spElements[1].fullName, 'E-flat in octave 1 Whole Note')
         self.assertEqual(spElements[1].offset, 0.)
+        self.assertEqual(spElements[1].quarterLength, 4.)
+        # The pedal "stop" happens a quarter-note _before_ the end of the last whole note
+        # (last whole note <duration> is 32, <pedal><offset> is -8)
+        self.assertEqual(spElements[2].offset, 3.)
+        self.assertIsInstance(spElements[2], spanner.SpannerAnchor)
 
         s = corpus.parse('dichterliebe_no2')
         pedals = list(s[expressions.PedalMark])
@@ -1190,9 +1204,18 @@ def testPedalMarks(self):
         spElements = pm.getSpannedElements()
         self.assertEqual(len(spElements), 5)
         expectedOffsets = [1.5, 1.75, 0.0, 0.75, 1.0]
-        for i, (el, expectedOffset) in enumerate(zip(spElements, expectedOffsets)):
-            self.assertIsInstance(el, note.Note)
-            self.assertEqual(el.nameWithOctave, 'A3')
+        expectedInstances = [
+            note.Note,
+            note.Note,
+            note.Note,
+            note.Note,
+            note.Note,
+        ]
+        for i, (el, expectedOffset, expectedInstance) in enumerate(zip(
+                spElements, expectedOffsets, expectedInstances)):
+            self.assertIsInstance(el, expectedInstance)
+            if expectedInstance == note.Note:
+                self.assertEqual(el.nameWithOctave, 'A3')
             self.assertEqual(el.offset, expectedOffset)
 
     def testNoChordImport(self):
@@ -1256,8 +1279,8 @@ def testLineHeight(self):
         el2 = EL('<bracket type="stop" line-end="down" end-length="12.5" number="1"></bracket>')
 
         mp = MeasureParser()
-        line = mp.xmlDirectionTypeToSpanners(el1)[0]
-        mp.xmlDirectionTypeToSpanners(el2)
+        line = mp.xmlDirectionTypeToSpanners(el1, 1, 0.0)[0]
+        mp.xmlDirectionTypeToSpanners(el2, 1, 1.0)
         self.assertEqual(line.startHeight, 12.5)
         self.assertEqual(line.endHeight, 12.5)
 
@@ -1374,6 +1397,7 @@ def testHiddenRests(self):
         from music21 import corpus
         from music21.musicxml import testPrimitive
 
+        # With most software, <forward> tags should map to no objects at all
         # Voice 1: Half note, <forward> (quarter), quarter note
         # Voice 2: <forward> (half), quarter note, <forward> (quarter)
         s = converter.parse(testPrimitive.hiddenRestsNoFinale)
@@ -1580,11 +1604,37 @@ def testImportOttava(self):
             [o.placement for o in ottava_objs],
             ['above', 'below', 'above', 'below']
         )
+        ottavaPitches = []
+        for o in ottava_objs:
+            ottavaPitches.append([])
+            for p in o.getSpannedElements():
+                if hasattr(p, 'nameWithOctave'):
+                    name = p.nameWithOctave
+                else:
+                    name = repr(p)
+                ottavaPitches[-1].append(name)
+
         self.assertEqual(
-            [[p.nameWithOctave for p in o.getSpannedElements()] for o in ottava_objs],
-            # TODO(bug): first element should be ['C7', 'A6']
-            # not reading <offset>-4</offset>
-            [['A6'], ['C3', 'B2'], ['A5', 'A5'], ['B3', 'C4']]
+            ottavaPitches, [
+                [
+                    '<music21.spanner.SpannerAnchor at 0.5>',
+                    'C5',
+                    '<music21.spanner.SpannerAnchor at 1.0>'
+                ],
+                [
+                    'C3',
+                    '<music21.spanner.SpannerAnchor at 2.0>'
+                ],
+                [
+                    'A5',
+                    'A5',
+                    '<music21.spanner.SpannerAnchor at 3.125>'
+                ],
+                [
+                    'B3',
+                    '<music21.spanner.SpannerAnchor at 3.75>'
+                ]
+            ]
         )
 
     def testClearingTuplets(self):