gregchapman-dev
diff --git a/‎LICENSE‎
Lines changed: 1 addition & 1 deletion b/‎LICENSE‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎README.md‎
Lines changed: 1 addition & 1 deletion b/‎README.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎ReleaseNotes_3.1.0.txt‎
Lines changed: 46 additions & 0 deletions b/‎ReleaseNotes_3.1.0.txt‎
Lines changed: 46 additions & 0 deletions
diff --git a/‎musicdiff/annotation.py‎
Lines changed: 105 additions & 22 deletions b/‎musicdiff/annotation.py‎
Lines changed: 105 additions & 22 deletions
diff --git a/‎musicdiff/comparison.py‎
Lines changed: 13 additions & 0 deletions b/‎musicdiff/comparison.py‎
Lines changed: 13 additions & 0 deletions
@@ -1,6 +1,6 @@
 
 The MIT License (MIT)
-Copyright (c) 2022, 2023 Francesco Foscarin, Greg Chapman
+Copyright (c) 2022-2024 Francesco Foscarin, Greg Chapman
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
 
@@ -7,7 +7,7 @@ musicdiff is derived from: [music-score-diff](https://github.com/fosfrancesco/mu
     by [Francesco Foscarin](https://github.com/fosfrancesco).
 
 ## Setup
-Depends on [music21](https://pypi.org/project/music21) (version 9.1+),  [numpy](https://pypi.org/project/numpy), and [converter21](https://pypi.org/project/converter21) (version 3.0+). You also will need to configure music21 (instructions [here](https://web.mit.edu/music21/doc/usersGuide/usersGuide_01_installing.html)) to display a musical score (e.g. with MuseScore).  Requires Python 3.10+.
+Depends on [music21](https://pypi.org/project/music21) (version 9.1+),  [numpy](https://pypi.org/project/numpy), and [converter21](https://pypi.org/project/converter21) (version 3.1+). You also will need to configure music21 (instructions [here](https://web.mit.edu/music21/doc/usersGuide/usersGuide_01_installing.html)) to display a musical score (e.g. with MuseScore).  Requires Python 3.10+.
 
 ## Usage
 On the command line:
 
@@ -0,0 +1,46 @@
+Changes since 3.0.0:
+
+Feature-level changes:
+    - Move lyrics diff from GeneralNotesOnly detail level to AllObjects detail level.
+    - Compare GeneralNote offsets (visually, this is horizontal position in measure).
+    - compare tuplet_info (num and numBase, num format/visibility, bracket visibility),
+        not just tuplet (start/continue/stop).  This is technically a bugfix, but tuplet
+        comparisons were pretty much not working at all, so I'm calling it a new feature.
+    - Add py.typed, so clients can do mypy against musicdiff APIs.
+
+Bugfixes:
+    Metadata:
+        - Contributor might not have any names.  Deal with it.
+        - skip more metadata keys (that are specific to a particular file, so shouldn't
+            be compared against another file): 'EMD', 'EST', 'VTS', 'RLN', 'PUB'.
+        - html-unescape during annotation of metadata items.
+    Style:
+        - Ignore some style stuff we don't care about (e.g. absX/absY).
+        - Ignore fontSize, and regularize how 'bold' is represented.
+    Lyrics:
+        - Don't annotate lyric style if it is empty (hasStyleInformation could still be True).
+        - Consider lyric.syllabic == None and 'single' to be the same.
+        - Better comparison of lyrics, treat style.absoluteY as placement fallback when
+            placement is None.
+        - For lyrics, ignore placement=='below' and justify=='left', as equivalent to not
+            specifying.
+        - Ignore empty lyrics.
+    MetronomeMarks:
+        - Ignore playback-only MetronomeMarks (they're not marked invisible, but they are
+            not printed).
+        - Treat MetronomeMark with explicit number and no explicit text the same as one with no
+            explicit number and explicit text saying "x = NNN" (where x is a SMUFL note code
+            followed by 1-4 SMUFL dots).  They are printed identically, so they are the same.
+    Barlines:
+        - no specified barline is the same as normal barline (at start and end of measure,
+            that is).
+        - ignore invisible ('none') barlines.
+    Other fixes:
+        - Fix crash when diff is visualized between note with accidental and unpitched note/rest
+        - Ignore redundant system and page breaks
+        - Grace vs Appoggiatura is more complex (in music21) than I thought.
+        - Skip over non-realized ChordSymbols (realized ChordSymbols get treated as Chords)
+        - Skip over StaffGroup that contains all the staves and has neither barTogether nor
+            symbol.  Some file formats have one (MEI), and some file formats imply/don't need
+            it (MusicXML).
+
@@ -14,11 +14,12 @@
 
 __docformat__ = "google"
 
+import html
 from fractions import Fraction
-
 import typing as t
 
 import music21 as m21
+from music21.common.numberTools import OffsetQL
 
 from musicdiff import M21Utils
 from musicdiff import DetailLevel
@@ -27,6 +28,7 @@ class AnnNote:
     def __init__(
         self,
         general_note: m21.note.GeneralNote,
+        offsetInMeasure: OffsetQL,
         enhanced_beam_list: list[str],
         tuplet_list: list[str],
         tuplet_info: list[str],
@@ -46,6 +48,7 @@ def __init__(
 
         """
         self.general_note: int | str = general_note.id
+        self.offsetInMeasure: OffsetQL = offsetInMeasure
         self.beamings: list[str] = enhanced_beam_list
         self.tuplets: list[str] = tuplet_list
         self.tuplet_info: list[str] = tuplet_info
@@ -99,7 +102,21 @@ def __init__(
             self.graceType: str = 'acc'
             self.graceSlash: bool | None = general_note.duration.slash
         elif isinstance(general_note.duration, m21.duration.GraceDuration):
-            self.graceType = 'nonacc'
+            # might be accented or unaccented.  duration.slash isn't always reliable
+            # (historically), but we can use it as a fallback.
+            # Check duration.stealTimePrevious and duration.stealTimeFollowing first.
+            if general_note.duration.stealTimePrevious is not None:
+                self.graceType = 'unacc'
+            elif general_note.duration.stealTimeFollowing is not None:
+                self.graceType = 'acc'
+            elif general_note.duration.slash is True:
+                self.graceType = 'unacc'
+            elif general_note.duration.slash is False:
+                self.graceType = 'acc'
+            else:
+                # by default, GraceDuration with no other indications (slash is None)
+                # is assumed to be unaccented.
+                self.graceType = 'unacc'
             self.graceSlash = general_note.duration.slash
         else:
             self.graceType = ''
@@ -119,20 +136,25 @@ def __init__(
 
         # lyrics
         self.lyrics: list[str] = []
-        for lyric in general_note.lyrics:
-            lyricStr: str = ""
-            if lyric.number is not None:
-                lyricStr += f"number={lyric.number}"
-            if lyric._identifier is not None:
-                lyricStr += f" identifier={lyric._identifier}"
-            if lyric.syllabic is not None:
-                lyricStr += f" syllabic={lyric.syllabic}"
-            if lyric.text is not None:
-                lyricStr += f" text={lyric.text}"
-            lyricStr += f" rawText={lyric.rawText}"
-            if M21Utils.has_style(lyric):
-                lyricStr += f" style={M21Utils.obj_to_styledict(lyric, detail)}"
-            self.lyrics.append(lyricStr)
+        if DetailLevel.includesLyrics(detail):
+            for lyric in general_note.lyrics:
+                if not lyric.rawText:
+                    continue
+                lyricStr: str = ""
+                if lyric.number is not None:
+                    lyricStr += f"number={lyric.number}"
+                if lyric._identifier is not None:
+                    lyricStr += f" identifier={lyric._identifier}"
+                # ignore .syllabic and .text, what is visible is .rawText (and there
+                # are several .syllabic/.text combos that create the same .rawText).
+                lyricStr += f" rawText={lyric.rawText}"
+                if M21Utils.has_style(lyric):
+                    styleDict: dict[str, str] = M21Utils.obj_to_styledict(lyric, detail)
+                    if styleDict:
+                        # sort styleDict before converting to string so we can compare strings
+                        styleDict = dict(sorted(styleDict.items()))
+                        lyricStr += f" style={styleDict}"
+                self.lyrics.append(lyricStr)
 
         # precomputed representations for faster comparison
         self.precomputed_str: str = self.__str__()
@@ -239,6 +261,9 @@ def __str__(self) -> str:
         if self.stemDirection != 'unspecified':
             string += f"stemDirection={self.stemDirection}"
 
+        # offset
+        string += f" {self.offsetInMeasure}"
+
         # and then the style fields
         for i, (k, v) in enumerate(self.styledict.items()):
             if i > 0:
@@ -335,6 +360,11 @@ def __init__(
                 except m21.sites.SitesException:
                     endOffsetInScore = startOffsetInScore
                 self.duration = endOffsetInScore - startOffsetInScore
+        elif isinstance(extra, m21.bar.Barline):
+            # we ignore offset for barlines; barline offset is derived from the objects in the
+            # measure, which are already being compared.
+            self.offset = 0.0
+            self.duration = float(extra.duration.quarterLength)
         else:
             self.offset = float(extra.getOffsetInHierarchy(measure))
             self.duration = float(extra.duration.quarterLength)
@@ -344,7 +374,21 @@ def __init__(
 
         if M21Utils.has_style(extra):
             # includes extra.placement if present
-            self.styledict = M21Utils.obj_to_styledict(extra, detail)
+
+            # special case: MM with text='SMUFLNote = nnn" is being annotated as if there is
+            # no text, so none of the text style stuff should be added.
+            smuflTextSuppressed: bool = False
+            if (isinstance(extra, m21.tempo.MetronomeMark)
+                    and not extra.textImplicit
+                    and extra.text
+                    and not self.content.startswith('MM:TX:')):
+                smuflTextSuppressed = True
+
+            self.styledict = M21Utils.obj_to_styledict(
+                extra,
+                detail,
+                smuflTextSuppressed=smuflTextSuppressed
+            )
 
         # so far, always 1, but maybe some extra will be bigger someday
         self._notation_size: int = 1
@@ -386,6 +430,7 @@ class AnnVoice:
     def __init__(
         self,
         voice: m21.stream.Voice | m21.stream.Measure,
+        enclosingMeasure: m21.stream.Measure,
         detail: DetailLevel = DetailLevel.Default
     ) -> None:
         """
@@ -421,9 +466,11 @@ def __init__(
             # create a list of notes with beaming and tuplets information attached
             self.annot_notes = []
             for i, n in enumerate(note_list):
+                offset: OffsetQL = n.getOffsetInHierarchy(enclosingMeasure)
                 self.annot_notes.append(
                     AnnNote(
                         n,
+                        offset,
                         self.en_beam_list[i],
                         self.tuplet_list[i],
                         self.tuplet_info[i],
@@ -510,19 +557,19 @@ def __init__(
 
         if len(measure.voices) == 0:
             # there is a single AnnVoice (i.e. in the music21 Measure there are no voices)
-            ann_voice = AnnVoice(measure, detail)
+            ann_voice = AnnVoice(measure, measure, detail)
             if ann_voice.n_of_notes > 0:
                 self.voices_list.append(ann_voice)
         else:  # there are multiple voices (or an array with just one voice)
             for voice in measure.voices:
-                ann_voice = AnnVoice(voice, detail)
+                ann_voice = AnnVoice(voice, measure, detail)
                 if ann_voice.n_of_notes > 0:
                     self.voices_list.append(ann_voice)
         self.n_of_voices: int = len(self.voices_list)
 
         self.extras_list: list[AnnExtra] = []
         if DetailLevel.includesOtherMusicObjects(detail):
-            for extra in M21Utils.get_extras(measure, part, spannerBundle, detail):
+            for extra in M21Utils.get_extras(measure, part, score, spannerBundle, detail):
                 self.extras_list.append(AnnExtra(extra, measure, score, detail))
 
             # For correct comparison, sort the extras_list, so that any list slices
@@ -756,11 +803,24 @@ def __init__(
         if isinstance(value, m21.metadata.Text):
             # Create a string representing both the text and the language, but not isTranslated,
             # since isTranslated cannot be represented in many file formats.
-            self.value = str(value) + f'(language={value.language})'
+            self.value = (
+                self.make_value_string(value)
+                + f'(language={value.language})'
+            )
         elif isinstance(value, m21.metadata.Contributor):
             # Create a string (same thing: value.name.isTranslated will differ randomly)
             # Currently I am also ignoring more than one name, and birth/death.
-            self.value = str(value) + f'(role={value.role}, language={value._names[0].language})'
+            self.value = self.make_value_string(value)
+            roleEmitted: bool = False
+            if value.role:
+                self.value += f'(role={value.role}'
+                roleEmitted = True
+            if value._names:
+                if roleEmitted:
+                    self.value += ', '
+                self.value += f'language={value._names[0].language}'
+            if roleEmitted:
+                self.value += ')'
         else:
             self.value = value
 
@@ -791,6 +851,12 @@ def notation_size(self) -> int:
         """
         return 1
 
+    def make_value_string(self, value: m21.metadata.Contributor | m21.metadata.Text) -> str:
+        # Unescapes a bunch of stuff
+        output: str = str(value)
+        output = html.unescape(output)
+        return output
+
 
 class AnnScore:
     def __init__(
@@ -834,6 +900,13 @@ def __init__(
         if DetailLevel.includesOtherMusicObjects(detail):
             # staffgroups are extras (a.k.a. OtherMusicObjects)
             for staffGroup in score[m21.layout.StaffGroup]:
+                # ignore any StaffGroup that contains all the parts, and has no symbol
+                # and has no barthru (this is just a placeholder generated by some
+                # file formats, and has the same meaning if it is missing).
+                if len(staffGroup) == len(part_to_index):
+                    if not staffGroup.symbol and not staffGroup.barTogether:
+                        continue
+
                 ann_staff_group = AnnStaffGroup(staffGroup, part_to_index, detail)
                 if ann_staff_group.n_of_parts > 0:
                     self.staff_group_list.append(ann_staff_group)
@@ -855,6 +928,16 @@ def __init__(
                     # 'raw:freeform', 'humdrumraw:XXX'), it's often deleted
                     # when made obsolete by conversions/edits.
                     continue
+                if key in ('humdrum:EMD', 'humdrum:EST', 'humdrum:VTS',
+                        'humdrum:RLN', 'humdrum:PUB'):
+                    # Don't compare metadata items that should never be transferred
+                    # from one file to another.  'humdrum:EMD' is a modification
+                    # description entry, humdrum:EST is "current encoding status"
+                    # (i.e. complete or some value of not complete), 'humdrum:VTS'
+                    # is a checksum of the Humdrum file, 'humdrum:RLN' is the
+                    # extended ASCII encoding of the Humdrum file, 'humdrum:PUB'
+                    # is the publication status of the file (published or not?).
+                    continue
                 self.metadata_items_list.append(AnnMetadataItem(key, value))
 
     def __eq__(self, other) -> bool:
 
@@ -349,6 +349,7 @@ def _pitches_diff(pitch1, pitch2, noteNode1, noteNode2, ids):
                 op_list.append(("pitchtypeedit", noteNode1, noteNode2, 1, ids))
             else:  # they are two notes
                 op_list.append(("pitchnameedit", noteNode1, noteNode2, 1, ids))
+
         # add for the accidentals
         if pitch1[1] != pitch2[1]:  # if the accidental is different
             cost += 1
@@ -896,6 +897,13 @@ def _annotated_note_diff(annNote1: AnnNote, annNote2: AnnNote):
             )
             op_list.extend(tuplet_op_list)
             cost += tuplet_cost
+        # add for the tuplet info
+        if annNote1.tuplet_info != annNote2.tuplet_info:
+            tuplet_info_op_list, tuplet_info_cost = Comparison._beamtuplet_leveinsthein_diff(
+                annNote1.tuplet_info, annNote2.tuplet_info, annNote1, annNote2, "tuplet"
+            )
+            op_list.extend(tuplet_info_op_list)
+            cost += tuplet_info_cost
         # add for the articulations
         if annNote1.articulations != annNote2.articulations:
             artic_op_list, artic_cost = Comparison._generic_leveinsthein_diff(
@@ -930,6 +938,11 @@ def _annotated_note_diff(annNote1: AnnNote, annNote2: AnnNote):
             op_list.extend(lyr_op_list)
             cost += lyr_cost
 
+        # add for offset in quarter notes from start of measure (i.e. horizontal position)
+        if annNote1.offsetInMeasure != annNote2.offsetInMeasure:
+            cost += 1
+            op_list.append(("editnoteoffset", annNote1, annNote2, 1))
+
         # add for noteshape
         if annNote1.noteshape != annNote2.noteshape:
             cost += 1