semantic-to-pae.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "af145899",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0c51ba1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Key signature to sharps and flats\n",
    "translate_key = {\n",
    "    'CM': '',\n",
    "    'FM': 'bB',\n",
    "    'BbM': 'bBE',\n",
    "    'EbM': 'bBEA',\n",
    "    'AbM': 'bBEAD',\n",
    "    'DbM': 'bBEADG',\n",
    "    'GbM': 'bBEADGC',\n",
    "    'FxM': 'xFCGDAE',\n",
    "    'BM': 'xFCGDA',\n",
    "    'EM': 'xFCGD',\n",
    "    'AM': 'xFCG',\n",
    "    'DM': 'xFC',\n",
    "    'GM': 'xF'\n",
    "}\n",
    "\n",
    "# Simple cases for duration to integer\n",
    "translate_duration_dict = {\n",
    "    'quadruple_whole': '0',\n",
    "    'double_whole': '9',\n",
    "    'whole': '1',\n",
    "    'half': '2',\n",
    "    'quarter': '4',\n",
    "    'eighth': '8',\n",
    "    'sixteenth': '6',\n",
    "    'thirty_second': '3',\n",
    "    'sixty_fourth': '5'\n",
    "}\n",
    "\n",
    "# Simple cases for duration to integer\n",
    "duration_to_sfs = {\n",
    "    'quadruple_whole': 256,\n",
    "    'double_whole': 128,\n",
    "    'whole': 64,\n",
    "    'half': 32,\n",
    "    'quarter': 16,\n",
    "    'eighth': 8,\n",
    "    'sixteenth': 4,\n",
    "    'thirty_second': 2,\n",
    "    'sixty_fourth': 1\n",
    "}\n",
    "\n",
    "def timesig_to_sfs(timesig):\n",
    "    if timesig == 'c':\n",
    "        return 16, 64\n",
    "    elif timesig == 'c/':\n",
    "        return 32, 64\n",
    "    else:\n",
    "        numer = int(timesig.split('/')[0])\n",
    "        denom = int(timesig.split('/')[1])\n",
    "        sfs_per_beat = 64 // denom\n",
    "        sfs_per_bar = sfs_per_beat * numer\n",
    "        return sfs_per_beat, sfs_per_bar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f4789880",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_pitch(pitch):\n",
    "    # Octave is last character\n",
    "    octave = int(pitch[-1])\n",
    "    return octave, pitch[:-1]\n",
    "\n",
    "def translate_octave(octave):\n",
    "    # ' is octave of middle C, '' is two octaves above; opposite for comma\n",
    "    if octave < 4:\n",
    "        return ',' * (4 - octave)\n",
    "    else:\n",
    "        return \"'\" * (octave - 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c1973e91",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pseudo_semantic_to_semantic(semantic):\n",
    "    semantic = re.sub('note (.*?) ', r'note-\\1_', semantic)\n",
    "    semantic = re.sub('rest ', r'rest-', semantic)\n",
    "    semantic = re.sub(' fermata', r'_fermata', semantic)\n",
    "    semantic = re.sub(' dotdot', '..', semantic)\n",
    "    semantic = re.sub(' dot', '.', semantic)\n",
    "    return semantic.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1203cdfb",
   "metadata": {},
   "outputs": [],
   "source": [
    "BEAM_DURATIONS = [\"eighth\", \"sixteenth\", \"thirty_second\", \"sixty_fourth\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0e34eff2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_clef(symbol):\n",
    "    clef = symbol.split('-')[1]\n",
    "    # If clef is something like G2, PAE wants G-2\n",
    "    if len(clef) == 2:\n",
    "        clef = clef[0] + '-' + clef[1]\n",
    "    return clef"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "499a3b8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_timesig(symbol):\n",
    "    timesig = symbol.split('-')[1].lower()\n",
    "    sfs_per_beat, sfs_per_bar = timesig_to_sfs(timesig)\n",
    "    return timesig, sfs_per_beat, sfs_per_bar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1b4f5882",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_note(symbol, keysig):\n",
    "    dots = 0\n",
    "    isGrace = False\n",
    "    isFermata = False\n",
    "    data = ''\n",
    "    # If gracenote, take out grace and add \"q\" to data\n",
    "    if symbol[:5] == 'grace':\n",
    "        symbol = symbol[5:]\n",
    "        isGrace = True\n",
    "    # Keep track of number of dots\n",
    "    while symbol[-1] == '.':\n",
    "        dots += 1\n",
    "        symbol = symbol[:-1]\n",
    "    if len(symbol) >= 8 and symbol[-8:] == '_fermata':\n",
    "        symbol = symbol[:-8]\n",
    "        isFermata = True\n",
    "    # Pitch comes after - and before _\n",
    "    pitch = symbol.split('-')[1].split('_')[0]\n",
    "    # Duration is everything after _ (can have another _, like thirty_second)\n",
    "    duration = '_'.join(symbol.split('_')[1:])\n",
    "    duration_sfs = int(duration_to_sfs[duration] * (1.5 ** dots)) if not isGrace else 0\n",
    "    octave, pitch = parse_pitch(pitch)\n",
    "    data += translate_octave(octave)\n",
    "    data += translate_duration_dict[duration]\n",
    "    # Add dots\n",
    "    data += '.' * dots\n",
    "    if isGrace:\n",
    "        data += 'q'\n",
    "    if isFermata:\n",
    "        data += '('\n",
    "    # If the accidental is already included in the time signature, just use letter name\n",
    "    if pitch[0] in keysig and len(pitch) > 1 and pitch[-1] == keysig[0]:\n",
    "        data += pitch[0]\n",
    "    # If the pitch is in the key signature but doesn't have an accidental, mark as natural\n",
    "    elif pitch[0] in keysig and len(pitch) == 1:\n",
    "        data += 'n' + pitch\n",
    "    else:\n",
    "        data += pitch[::-1]\n",
    "    if isFermata:\n",
    "        data += ')'\n",
    "    return data, duration_sfs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "836abd44",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_rest(symbol):\n",
    "    data = ''\n",
    "    isFermata = False\n",
    "    dots = 0\n",
    "    # Duplicate code from note\n",
    "    while symbol[-1] == '.':\n",
    "        dots += 1\n",
    "        symbol = symbol[:-1]\n",
    "    if len(symbol) >= 8 and symbol[-8:] == '_fermata':\n",
    "        symbol = symbol[:-8]\n",
    "        isFermata = True\n",
    "    duration = symbol.split('-')[1]\n",
    "    duration_sfs = int(duration_to_sfs[duration] * (1.5 ** dots))\n",
    "    \n",
    "    data += translate_duration_dict[duration]\n",
    "    \n",
    "    data += '.' * dots\n",
    "    # Symbol for rest\n",
    "    data += '-' if not isFermata else '(-)'\n",
    "    return data, duration_sfs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ae3002cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def insert_beams(data_pieces, sfs_per_beat, sfs_per_bar):\n",
    "    data = ''\n",
    "    breakpoints = list(range(0, sfs_per_bar, sfs_per_beat))\n",
    "    breakpoints_eighth = [sfs_per_bar // 2]\n",
    "    location_sfs = 0\n",
    "    inBeam = False\n",
    "    justStartedBeam = False\n",
    "    for i, (data_piece, sfs) in enumerate(data_pieces):\n",
    "        worthy_of_beam = '-' not in data_piece and sfs < 16 and sfs != 0\n",
    "        is_eighth = 8 <= sfs < 16\n",
    "        is_breakpoint = not is_eighth and location_sfs in breakpoints or location_sfs in breakpoints_eighth\n",
    "        \n",
    "        # If in a beam, end beam BEFORE ADDING TOKEN if:\n",
    "        # This token is a rest\n",
    "        # OR This token is a quarter note or slower\n",
    "        # OR This token does not have rhythmic value (includes barline)\n",
    "        # OR This token is on a breakpoint\n",
    "        if inBeam and (not worthy_of_beam or is_breakpoint):\n",
    "            inBeam = False\n",
    "            if not justStartedBeam:\n",
    "                data += '}'\n",
    "            else:\n",
    "                # Just started a beam, remove last {\n",
    "                data = data[::-1].replace('{', '', 1)[::-1]\n",
    "        \n",
    "        # If not in a beam, start beam BEFORE ADDING TOKEN if:\n",
    "        # This token is not a rest\n",
    "        # AND This token is faster than a quarter note\n",
    "        # AND This token has rhythmic value\n",
    "        if not inBeam and worthy_of_beam:\n",
    "            inBeam = True\n",
    "            justStartedBeam = True\n",
    "            data += '{'\n",
    "        else:\n",
    "            justStartedBeam = False\n",
    "            \n",
    "        data += data_piece\n",
    "        location_sfs += sfs\n",
    "        \n",
    "        if data_piece == '/':\n",
    "            location_sfs = 0\n",
    "    if inBeam:\n",
    "        data += '}'\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "45f1bf7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert(semantic):\n",
    "    # PAE uses x for sharp\n",
    "    semantic = re.sub('#', 'x', semantic)\n",
    "    semantic_split = semantic.split()\n",
    "    clef = ''\n",
    "    keysig = ''\n",
    "    timesig = ''\n",
    "    data = ''\n",
    "    data_pieces = []\n",
    "    inBeams = False\n",
    "    sfs_per_beat = 0\n",
    "    sfs_per_bar = 0\n",
    "    # Number of dots to add at some point\n",
    "    dots = 0\n",
    "    for i, symbol in enumerate(semantic_split):\n",
    "        data = ''\n",
    "        duration_sfs = 0\n",
    "        # Clef\n",
    "        if len(symbol) >= 4 and symbol[:4] == 'clef':\n",
    "            clef = parse_clef(symbol)\n",
    "            continue\n",
    "        # Key signature\n",
    "        elif len(symbol) >= 3 and symbol[:3] == 'key':\n",
    "            keysig = translate_key[symbol.split('-')[1]]\n",
    "            continue\n",
    "        # Time signature\n",
    "        elif len(symbol) >= 4 and symbol[:4] == 'time':\n",
    "            timesig, sfs_per_beat, sfs_per_bar = parse_timesig(symbol)\n",
    "            continue\n",
    "        # Note or gracenote (e.g. note-C4_quarter. => 4.'C)\n",
    "        elif len(symbol) >= 5 and symbol[:4] == 'note' or symbol[:5] == 'grace':\n",
    "            parsed, duration_sfs = parse_note(symbol, keysig)\n",
    "            data += parsed\n",
    "        # Rest (e.g. rest-quarter => 4-)\n",
    "        elif len(symbol) >= 4 and symbol[:4] == 'rest':\n",
    "            parsed, duration_sfs = parse_rest(symbol)\n",
    "            data += parsed\n",
    "        # Barline (barline => /)\n",
    "        elif symbol == 'barline':\n",
    "            data += '/'\n",
    "        # Multirest (e.g. multirest-11 => =11)\n",
    "        elif len(symbol) >= 5 and symbol[:5] == 'multi':\n",
    "            data += '=' + symbol.split('-')[1]\n",
    "        # Tie (tie => +)\n",
    "        elif symbol == 'tie':\n",
    "            data += '+'\n",
    "        data_pieces.append((data, duration_sfs))\n",
    "    data = insert_beams(data_pieces, sfs_per_beat, sfs_per_bar)\n",
    "    # Return data object\n",
    "    obj = {\n",
    "        \"clef\": clef,\n",
    "        \"keysig\": keysig,\n",
    "        \"timesig\": timesig,\n",
    "        \"data\": data\n",
    "    }\n",
    "    return obj\n",
    "\n",
    "def convert_and_save(semantic, filename):\n",
    "    data = convert(semantic)\n",
    "    json.dump(data, open(filename, 'w'))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}