Add headers to the examples

.gitignore

@@ -1 +1,2 @@
 .DS_Store
+.idea

README.md

@@ -11,12 +11,8 @@ size_categories:
 dataset_info:
 - config_name: default
   features:
-  - name: file
-    dtype: string
   - name: text
     dtype: string
-  - name: title
-    dtype: string
   - name: track_name
     dtype: string
   - name: track_number
@@ -25,18 +21,32 @@ dataset_info:
     dtype: string
   - name: instrument_number
     dtype: int32
+  - name: title
+    dtype: string
   - name: tempo
     dtype: int32
   - name: tuning
     dtype: string
   - name: frets
     dtype: int32
+  - name: file
+    dtype: string
+  - name: subtitle
+    dtype: string
+  - name: artist
+    dtype: string
+  - name: album
+    dtype: string
+  - name: words
+    dtype: string
+  - name: music
+    dtype: string
   splits:
   - name: train
-    num_bytes: 951605310
+    num_bytes: 955323858
     num_examples: 188297
   download_size: 75369951
-  dataset_size: 951605310
+  dataset_size: 955323858
 - config_name: all
   features:
   - name: file

guitar_tab.py

@@ -1,10 +1,12 @@
+import dataclasses
 import itertools
 from pathlib import Path
+from typing import List
+
 import datasets
 
 datasets.logging.set_verbosity_info()
 
-
 _DESCRIPTION = """\
 Dataset of music tablature, in alphaTex (https://alphatab.net/docs/alphatex) 
 format, converted from Guitar Pro files (gp3, gp4, gp5, which are downloaded 
@@ -143,32 +145,37 @@ INSTRUMENT_MAP = {
 }
 
 
+@dataclasses.dataclass
+class Example:
+    text: str
+    track_name: str
+    track_number: int
+    instrument_name: str
+    instrument_number: int
+    title: str = None
+    tempo: int = None
+    tuning: str = None
+    frets: int = None
+    file: str = None
+    subtitle: str = None
+    artist: str = None
+    album: str = None
+    words: str = None
+    music: str = None
+
+
 class Builder(datasets.GeneratorBasedBuilder):
-    VERSION = datasets.Version("1.3.1")
+    VERSION = datasets.Version("1.4.0")
 
     def _info(self):
         return datasets.DatasetInfo(
             description=_DESCRIPTION,
             features=datasets.Features(
                 {
-                    "file": datasets.Value("string"),
-                    "text": datasets.Value("string"),
-                    "title": datasets.Value("string"),
-                    "track_name": datasets.Value("string"),
-                    "track_number": datasets.Value("int32"),
-                    "instrument_name": datasets.Value("string"),
-                    "instrument_number": datasets.Value("int32"),
-                    "tempo": datasets.Value("int32"),
-                    "tuning": datasets.Value("string"),
-                    "frets": datasets.Value("int32"),
-                    # "subtitle": datasets.Value("string"),
-                    # "artist": datasets.Value("string"),
-                    # "album": datasets.Value("string"),
-                    # "words": datasets.Value("string"),
-                    # "music": datasets.Value("string"),
-                    # "copyright": datasets.Value("string"),
-                    # "tab": datasets.Value("string"),
-                    # "instructions": datasets.Value("string"),
+                    field: datasets.Value("int32")
+                    if type_ == int
+                    else datasets.Value("string")
+                    for field, type_ in Example.__annotations__.items()
                 }
             ),
         )
@@ -194,39 +201,30 @@ class Builder(datasets.GeneratorBasedBuilder):
             with open(path) as f:
                 examples = _parse_examples(f.read())
             for example in examples:
-                example["file"] = path.name
-                yield f"{idx}-{example['track_number']}", example
+                example.file = path.name
+                yield f"{idx}-{example.track_number}", example.__dict__
 
 
-def _parse_examples(tex):
+def _parse_examples(tex: str) -> List[Example]:
     """
     Returns a dictionary for each track
     """
-    tmpl = {
-        "text": None,
-        "file": None,
-        "title": None,
-        "track_name": None,
-        "track_number": None,
-        "instrument_name": None,
-        "instrument_number": None,
-        "tempo": None,
-        "tuning": None,
-        "frets": None,
-    }
-    tracks = [tmpl.copy()]
+    examples = []
+    data = {}
 
     def _parse_track_header(k, v):
         if k == "instrument":
-            tracks[-1]["instrument_name"] = INSTRUMENT_MAP.get(int(v), "unknown")
-            tracks[-1]["instrument_number"] = int(v)
+            data['instrument_name'] = INSTRUMENT_MAP.get(int(v), "unknown")
+            data['instrument_number'] = int(v)
         elif k == "tuning":
-            tracks[-1][k] = v.split(" ")
+            data['tuning'] = v.split(" ")
         elif k == "frets":
-            tracks[-1][k] = int(v)
+            data['frets'] = int(v)
 
-    lines = (l.strip() for l in tex.splitlines() if l.strip())
-    for line in itertools.takewhile(lambda l: l != ".", lines):
+    lines = (l_.strip() for l_ in tex.splitlines() if l_.strip())
+    header_lines = list(itertools.takewhile(lambda l: l != ".", lines))
+
+    for line in header_lines:
         assert line.startswith("\\")
         line = line.lstrip("\\")
         kv = line.split(" ", 1)
@@ -235,44 +233,47 @@ def _parse_examples(tex):
         k, v = kv
         if k in [
             "title",
-            # "subtitle",
-            # "artist",
-            # "album",
-            # "words",
-            # "music",
-            # "copyright",
-            # "tab",
-            # "instructions",
+            "subtitle",
+            "artist",
+            "album",
+            "words",
+            "music",
         ]:
-            tracks[-1][k] = v.strip('"').strip("'")
+            data[k] = v.strip('"').strip("'")
         elif k == "tempo":
-            tracks[-1][k] = int(v)
+            data['tempo'] = int(v)
         else:
             _parse_track_header(k, v)
 
-    track_lines = []
+    track_header_lines = []
+    track_tex_lines = []
+
+    def _add_example():
+        nonlocal data, track_header_lines, track_tex_lines
+        if track_tex_lines:
+            data['track_number'] = (track_number := len(examples) + 1)
+            data['track_name'] = v if v else f"Track {track_number}"
+            data['text'] = (
+                '\n'.join(track_header_lines + [" ".join(track_tex_lines)])
+            )
+            examples.append(Example(**data))
+            data = {}
+            track_header_lines = []
+            track_tex_lines = []
+
     for line in lines:
         if line.startswith("\\"):
-            line = line.lstrip("\\")
-            kv = line.split(" ", 1)
-            if len(kv) == 2:
+            if len(kv := line.lstrip("\\").split(" ", 1)) == 2:
                 k = kv[0]
                 v = kv[1].strip('"').strip("'")
             else:
                 k = kv[0]
                 v = None
             if k == "track":
-                if track_lines:
-                    tracks[-1]["text"] = " ".join(track_lines)
-                    track_lines = []
-                    tracks.append(tmpl.copy())
-                track_number = len(tracks) + 1
-                tracks[-1]["track_number"] = track_number
-                tracks[-1]["track_name"] = v if v else f"Track {track_number}"
+                _add_example()
             else:
                 _parse_track_header(k, v)
         else:
-            track_lines.append(line)
-    if track_lines:
-        tracks[-1]["text"] = " ".join(track_lines)
-    return [t for t in tracks if t["text"]]
+            track_tex_lines.append(line)
+    _add_example()
+    return [t for t in examples if t.text]