gp3/gp4: extract note accent flags (0x02 heavy, 0x40 normal)

`GP3File.readNote` never read flag bits 0x02 (heavy accent) and 0x40
(normal accent) from the note flags byte, even though the docstring
documented them. GP4 inherited this broken read path; only GP5 read
them correctly.

The writer side was asymmetric too: `GP3File.packNoteFlags` emitted
0x02 but not 0x40, while GP4 overrode it to add 0x40 only. Round-tripping
a note with `accentuatedNote=True` through PGP silently dropped the flag.

This change:
  * reads both flags in `GP3File.readNote` (inherited by GP4)
  * writes flag 0x40 in `GP3File.packNoteFlags`
  * drops the now-redundant override in `GP4File.packNoteFlags`
  * adds a round-trip regression test for all three formats

Cross-checked against alphaTab's `Gp3To5Importer.ts:1203-1207` which
extracts both flags universally.

Closes #1

Author: kaizenman

src/guitarpro/gp3.py

@@ -899,7 +899,9 @@ def readNote(self, note, guitarString, track):
         """
         flags = self.readU8()
         note.string = guitarString.number
+        note.effect.heavyAccentuatedNote = bool(flags & 0x02)
         note.effect.ghostNote = bool(flags & 0x04)
+        note.effect.accentuatedNote = bool(flags & 0x40)
         if flags & 0x20:
             note.type = gp.NoteType(self.readU8())
         if flags & 0x01:
@@ -1443,6 +1445,8 @@ def packNoteFlags(self, note):
         if note.velocity != gp.Velocities.default:
             flags |= 0x10
         flags |= 0x20
+        if note.effect.accentuatedNote:
+            flags |= 0x40
         return flags
 
     def writeNoteEffects(self, note):

src/guitarpro/gp4.py

@@ -655,8 +655,6 @@ def writeNote(self, note):
 
     def packNoteFlags(self, note):
         flags = super().packNoteFlags(note)
-        if note.effect.accentuatedNote:
-            flags |= 0x40
         if note.effect.isFingering:
             flags |= 0x80
         return flags

tests/test_conversion.py

@@ -126,6 +126,37 @@ def testChord(tmpdir, caplog, filename):
     assert song == song2
 
 
+@pytest.mark.parametrize('filename', ['Effects.gp3', 'Effects.gp4', 'Effects.gp5'])
+def testNoteAccentuationRoundtrip(tmpdir, filename):
+    """Regression test for GP3/GP4 note accent flag extraction.
+
+    `GP3File.readNote` historically did not extract flag bits 0x02 (heavy
+    accent) and 0x40 (normal accent), while `writeNote` *does* write them.
+    GP4 inherits the broken read path; only GP5 read them correctly.
+
+    This caused a reader/writer asymmetry: accent flags were silently
+    dropped on every parse, even though PGP could write them.
+    """
+    filepath = LOCATION / filename
+    song = gp.parse(filepath)
+    note = song.tracks[0].measures[0].voices[0].beats[0].notes[0]
+
+    note.effect.accentuatedNote = True
+    note.effect.heavyAccentuatedNote = True
+
+    destpath = str(tmpdir.join(filename))
+    gp.write(song, destpath)
+    song2 = gp.parse(destpath)
+    note2 = song2.tracks[0].measures[0].voices[0].beats[0].notes[0]
+
+    assert note2.effect.accentuatedNote is True, (
+        f'{filename}: accentuatedNote not preserved on round-trip'
+    )
+    assert note2.effect.heavyAccentuatedNote is True, (
+        f'{filename}: heavyAccentuatedNote not preserved on round-trip'
+    )
+
+
 @pytest.mark.parametrize('version', ['gp3', 'gp4', 'gp5'])
 def testReadErrorAnnotation(version):
     def writeToBytesIO(song):