Parse tex directly

guitar_tab.py

@@ -1,9 +1,8 @@
+import itertools
 import os
 from pathlib import Path
 import datasets
 from typing import Optional
-import guitarpro as gp
-import itertools
 from tqdm import tqdm
 from pathlib import Path
 import re
@@ -183,118 +182,74 @@ class Builder(datasets.GeneratorBasedBuilder):
 
     def _generate_examples(self, filepaths):
         for idx, path in enumerate(filepaths):
-            try:
-                song: gp.Song = gp.parse(path)
-            except Exception as e:
-                print(f"failed to parse {path}: {e}")
-                continue
-            for track in song.tracks:
-                try:
-                    tex = track_to_alphatex(track)
-                except Exception as e:
-                    print(f"failed to convert {path} to alphaTex: {e}")
-                    continue
-                key = f"{idx}-{track.number}"
-                yield key, {
-                    "text": tex,
-                    "title": path.stem,
-                    "track": track.number,
-                    "instrument": INSTRUMENT_MAP.get(
-                        track.channel.instrument, "unknown"
-                    ),
-                }
+            with open(path) as f:
+                examples = _parse_examples(f.read())
+            for example in examples:
+                example['file'] = path.name
+                yield f"{idx}-{example['number']}", example
 
 
-def track_to_alphatex(track: gp.Track) -> str:
+def _parse_examples(tex):
     """
-    Convert a GuitarPro track to the alphaTex flat text format
+    Returns a dictionary for each track
     """
-    header = []
-    header.append(f'\\title "{track.song.title}"')
-    if track.song.subtitle:
-        header.append(f'\\subtitle "{track.name}"')
-    header.append(f"\\tempo {track.song.tempo}")
-    if track.channel and track.channel.instrument is not None:
-        header.append(f"\\instument {INSTRUMENT_MAP[track.channel.instrument]}")
-    if track.strings:
-        header.append(f"\\strings {len(track.strings)}")
-    if track.fretCount:
-        header.append(f"\\frets {track.fretCount}")
-    header.append(".")
+    tracks = [{}]
+
+    def _parse_track_header(k, v):
+        if k == "instrument":
+            tracks[-1][k] = INSTRUMENT_MAP.get(int(v), "unknown")
+        elif k == "tuning":
+            tracks[-1][k] = v.split(" ")
+        elif k == "frets":
+            tracks[-1][k] = int(v)
 
-    mstrs = []
-    curduration = None
-    for measure in track.measures:
-        mstr = ""
-        beats = measure.voices[0].beats
-        if beats and beats[0].duration != curduration:
-            curduration = beats[0].duration
-            mstr += f":{curduration.value} "
-        for beat in beats:
-            if not beat.notes:
-                bstr = "r"
-                if beat.duration != curduration:
-                    bstr += f".{beat.duration.value}"
-                mstr += bstr + " "
-                continue
-            bstr = ""
-            nstrs = []
-            bdur = None
-            for note in beat.notes:
-                nstrs.append(f"{note.value}.{note.string}")
-                ef = []
-                if note.beat.duration.isDotted:
-                    ef.append("d")
-                if note.effect.vibrato:
-                    ef.append("v")
-                if note.effect.hammer:
-                    ef.append("h")
-                if note.effect.trill is not None:
-                    ef.append("tr")
-                if note.effect.palmMute:
-                    ef.append("pm")
-                if note.effect.harmonic is not None:
-                    if isinstance(note.effect.harmonic, gp.NaturalHarmonic):
-                        ef.append("nh")
-                    elif isinstance(note.effect.harmonic, gp.ArtificialHarmonic):
-                        ef.append("ah")
-                    elif isinstance(note.effect.harmonic, gp.TappedHarmonic):
-                        ef.append("th")
-                    elif isinstance(note.effect.harmonic, gp.PinchHarmonic):
-                        ef.append("ph")
-                    elif isinstance(note.effect.harmonic, gp.SemiHarmonic):
-                        ef.append("sh")
-                if note.effect.isBend:
-                    ef.append("be")
-                    ef.append(
-                        "("
-                        + " ".join(
-                            f"{p.position} {p.value}" for p in note.effect.bend.points
-                        )
-                        + ")"
-                    )
-                if note.effect.staccato:
-                    ef.append("st")
-                if note.effect.letRing:
-                    ef.append("lr")
-                if note.effect.ghostNote:
-                    ef.append("g")
-                if beat.effect.fadeIn:
-                    ef.append("f")
-                if beat.duration.tuplet.enters != 1:
-                    ef.append(f"tu {beat.duration.tuplet.enters}")
-                # Finished parsing effects
-                if ef:
-                    nstrs[-1] += "{" + " ".join(ef) + "}"
-                if beat.duration != curduration:
-                    bdur = beat.duration.value
-            if len(nstrs) > 1:
-                bstr += "(" + " ".join(nstrs) + ")"
-            elif len(nstrs) == 1:
-                bstr = nstrs[0]
-            if bdur is not None:
-                bstr += f".{bdur}"
-            mstr += bstr + " "
-        if mstr := mstr.strip():
-            mstrs.append(mstr)
-    return "\n".join(header) + "\n" + " | \n".join(mstrs)
+    lines = (l.strip() for l in tex.splitlines() if l.strip())
+    for line in itertools.takewhile(lambda l: l != ".", lines):
+        assert line.startswith("\\")
+        line = line.lstrip("\\")
+        kv = line.split(" ", 1)
+        if len(kv) == 1:
+            continue
+        k, v = kv
+        if k in [
+            "title",
+            "subtitle",
+            "artist",
+            "album",
+            "words",
+            "music",
+            "copyright",
+            "tab",
+            "instructions",
+        ]:
+            tracks[-1][k] = v.strip('"').strip("'")
+        elif k == "tempo":
+            tracks[-1][k] = int(v)
+        else:
+            _parse_track_header(k, v)
+
+    track_lines = []
+    for line in lines:
+        if line.startswith("\\"):
+            line = line.lstrip("\\")
+            kv = line.split(" ", 1)
+            if len(kv) == 2:
+                k = kv[0]
+                v = kv[1].strip('"').strip("'")
+            else:
+                k = kv[0]
+                v = None
+            if k == "track":
+                if track_lines:
+                    tracks[-1]["tex"] = " ".join(track_lines)
+                    track_lines = []
+                    tracks.append({})
+                tracks[-1]["number"] = len(tracks) + 1
+                tracks[-1]["name"] = v if v else f"Track {tracks[-1]['number']}"
+            else:
+                _parse_track_header(k, v)
+        else:
+            track_lines.append(line)
+    if track_lines:
+        tracks[-1]["tex"] = " ".join(track_lines)
+    return tracks