sloppyNoto.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "sloppyNoto.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "mount_file_id": "14g9IK2SrnYZwxxZ0k2FrxqVz5No0ooxj",
      "authorship_tag": "ABX9TyPHRe6duxJBZTRUZR9bNMH5",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/olaviinha/SloppyNoto/blob/master/sloppyNoto.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QqY1kaQ1kqi8"
      },
      "source": [
        "#<font face=\"Trebuchet MS\" size=\"6\">Sloppy Noto <font color=\"#999\" size=\"3\">Data Audiolizer v0.0.5</font><font color=\"#999\" size=\"4\">&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;</font><a href=\"https://github.com/olaviinha/SloppyNoto\" target=\"_blank\"><font color=\"#999\" size=\"4\">Github</font></a><font color=\"#999\" size=\"4\">&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;</font><font size=\"3\" color=\"#999\"><a href=\"https://inha.se\" target=\"_blank\"><font color=\"#999\">O. Inha</font></a></font></font>\n",
        "\n",
        "Sloppy Noto converts raw numeric data to audio signals. It was initially created to do so from <a href=\"https://esa.int\" target=\"_blank\">ESA</a> and <a href=\"https://nasa.gov\" target=\"_blank\">NASA</a> spacecraft data.\n",
        "\n",
        "- Noto **does not** oscillate or generate sound waves by other means _based_ on given data, modify any such waves, or take artistic liberties.\n",
        "\n",
        "- Noto **does** interpret given series of numbers directly as digital audio signal sample magnitudes. _What you see is what you hear._\n",
        "\n",
        "See the [Github repository](https://github.com/olaviinha/SloppyNoto) for more details and audio demos.\n",
        "\n",
        "<font size=\"5\">Howto</font>\n",
        "- Proceed one cell at a time (don't _Run all_).\n",
        "- Follow instructions per field per cell.\n",
        "- Run a cell by clicking the play button on the left side of the cell.\n",
        "\n",
        "<font size=\"5\">Tips</font>\n",
        "- Suitable file types include (but are not limited to) `.csv`, `.tsv`, `.tab`, `.lst`, `.asc`, `.log`, `.xls`, `.xlsx`, `.json`, `.xml`, `.kml`, `.kmz`, `.zip`, `.tar`, `.gz`.\n",
        "- Archive files (`.zip`, `.tar`, `.gz`) will work as long as there is a **single file inside**, that is naturally also in suitable format. For more advanced usage of archive files, please use the accompanying [ZIP Crawler](crawlers.ipynb), or better yet, extract the files manually to your Google Drive as you see fit, and enter path to an already extracted file in the `data_file` field.\n",
        "- In case Noto does not recognize the file extension, it will attempt to interpret it as delimiter-separated values format.\n",
        "- Duration of produced audio always depends more on the contents of the data file (notably the number of rows) than the file size, but likely you mostly want to use files that are **at least** over 50 MB in size.\n",
        "- You might find the accompanying [Data Crawlers utility](crawlers.ipynb) useful in your quest to find suitable data from dataset archives.\n",
        "- Noto is rather poorly tested for what comes to different file types. Feel free to [raise an issue in Github](https://github.com/olaviinha/SloppyNoto/issues) should any problems occur."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LA9AhpijaTcI",
        "cellView": "form"
      },
      "source": [
        "#@title #**<font color=\"#dd6\">Setup</font>**\n",
        "#@markdown This cell needs to be run only once. It will mount your Google Drive and setup prerequisities.\n",
        "\n",
        "import os\n",
        "from google.colab import output\n",
        "force_setup = False\n",
        "\n",
        "pip_packages = 'pysoundfile'\n",
        "\n",
        "# inhagcutils\n",
        "if not os.path.isfile('/content/inhagcutils.ipynb') and force_setup == False:\n",
        "  %cd /content/\n",
        "  !pip -q install import-ipynb {pip_packages}\n",
        "  !curl -s -O https://raw.githubusercontent.com/olaviinha/inhagcutils/master/inhagcutils.ipynb\n",
        "import import_ipynb\n",
        "from inhagcutils import *\n",
        "\n",
        "# Mount Drive\n",
        "if not os.path.isdir('/content/drive') and force_setup == False:\n",
        "  from google.colab import drive\n",
        "  drive.mount('/content/drive')\n",
        "\n",
        "# Drive symlink\n",
        "if not os.path.isdir('/content/mydrive') and force_setup == False:\n",
        "  os.symlink('/content/drive/My Drive', '/content/mydrive')\n",
        "  drive_root_set = True\n",
        "drive_root = '/content/mydrive/'\n",
        "\n",
        "dir_tmp = '/content/tmp/'\n",
        "create_dirs([dir_tmp])\n",
        "last_data_file = ''\n",
        "\n",
        "output.clear()\n",
        "op(c.ok, 'Setup finished.')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TJghmKIzspF_",
        "cellView": "form"
      },
      "source": [
        "#@title #**<font color=\"#6dd\">1. Select Data</font>**\n",
        "#@markdown Note: You do not need to know these settings beforehand. You can run this cell after each time you have filled one field. Cell output will print a data preview that will help you to determine what to fill in the next field.\n",
        "\n",
        "#@markdown <small>`data_file` may be a URL (www, ftp) to a file or a path to a file located in your Google Drive. File can have any extension, but content should be in a delimiter-separated values-like format, a JSON-like format, or an XML-like format. Archive files (_zip, gz_) are automatically extracted before processed, but should contain only one file.<br>Whenever you change your `data_file`, remember to reset other settings in this cell as well if you're unsure about them.</small><br>\n",
        "data_file = \"\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown Next, use **only one** of the _Settings for..._ sections below to determine which columns or data to use from your data file. Ignore all and any settings irrelevant to your data file.\n",
        "\n",
        "#@markdown <hr size=\"1\" color=\"#555\"/><br>\n",
        "\n",
        "#@markdown ##<font color=\"#6dd\">a)</font> Settings for delimiter-separated and Excel file types (.csv, .tab, .xls, .xlsx, ...)\n",
        "delimiter = \"None\" #@param [\"None\", \"whitespace\", \"tab\", \"semicolon\", \"comma\", \"pipe\", \"double_pipe\"]\n",
        "#use = \"columns\" #@param [\"columns\", \"rows\"]\n",
        "#@markdown <small>Enter the columns you are interested in. List column numbers separated by commas (e.g. _1, 3, 5_). You may also include ranges (e.g. _1, 4-8, 12, 13-16_) or select all by just typing in _all_. These columns should contain **only numeric values**. They will be the candidates for sound file creation. You will make more specific selections later.</small>\n",
        "columns = \"\" #@param {type:\"string\"}\n",
        "#@markdown <small>Run this cell once more after selecting columns.</small>\n",
        "\n",
        "#@markdown <hr size=\"1\" color=\"#555\"/><br>\n",
        "\n",
        "#@markdown ##<font color=\"#6dd\">b)</font> Settings for JSON (.json)\n",
        "#@markdown <small>Enter attribute keys separated by commas (e.g. _latitude, longitude_). These attributes should contain **only numeric values**. They will be the candidates for sound file creation. You will make more specific selections later.</small>\n",
        "json_keys = \"\" #@param {type:\"string\"}\n",
        "#@markdown <small>Run this cell once more after selecting json attribute keys.</small>\n",
        "\n",
        "#@markdown <hr size=\"1\" color=\"#555\"/><br>\n",
        "\n",
        "#@markdown ##<font color=\"#6dd\">c)</font> Settings for XML (.xml, .kml, .kmz, ...)\n",
        "#@markdown <small>Enter tags separated by commas (e.g. _gx:coord_). These tags should contain **only numeric values**. If there are multiple numbers inside the tag, they will be separated further to their own columns. They will be the candidates for sound file creation. You will make more specific selections later.</small>\n",
        "xml_tags = \"\" #@param {type:\"string\"}\n",
        "#@markdown <small>Run this cell once more after selecting xml tags.</small>\n",
        "\n",
        "last_data_file = rnd_str(4)\n",
        "\n",
        "columns = columns\n",
        "data = ''\n",
        "prev_rows = 10\n",
        "separator = ''\n",
        "global_sr = 44100\n",
        "secs_warn_limit = 0.8\n",
        "zips = ('.zip', '.tar', '.gz')\n",
        "excels = ('.xls', '.xlsx')\n",
        "jsons = ('.json')\n",
        "xmls = ('.xml', '.kml', '.kmz')\n",
        "\n",
        "import xlrd, csv, json, itertools\n",
        "import pandas as pd\n",
        "from bs4 import BeautifulSoup\n",
        "\n",
        "\n",
        "def listlen(list, rmin=True):\n",
        "  list_len = [len(i) for i in list]\n",
        "  return min(list_len) if rmin==True else max(list_len)\n",
        "\n",
        "def excel2csv(file_path):\n",
        "  wb = xlrd.open_workbook(file_path)\n",
        "  #sheet_names = xl_workbook.sheet_names()\n",
        "  sh = wb.sheet_by_index(0)\n",
        "  csv_file = open(path_dir(file_path)+basename(file_path)+'.csv', 'w')\n",
        "  wr = csv.writer(csv_file, quoting=csv.QUOTE_ALL)\n",
        "  for rownum in range(sh.nrows):\n",
        "    wr.writerow(sh.row_values(rownum))\n",
        "  csv_file.close()\n",
        "  return path_dir(file_path)+basename(file_path)+'.csv'\n",
        "\n",
        "val_list = []\n",
        "def get_all(myjson, key, is_dict=False):\n",
        "  global val_list\n",
        "  if is_dict == True:\n",
        "    val_list = []\n",
        "  if type(myjson) == str:\n",
        "    myjson = json.loads(myjson)\n",
        "  if type(myjson) is dict:\n",
        "    for jsonkey in myjson:\n",
        "      if type(myjson[jsonkey]) in (list, dict):\n",
        "        get_all(myjson[jsonkey], key)\n",
        "      elif jsonkey == key:\n",
        "        #print('append', myjson[jsonkey])\n",
        "        val_list.append(myjson[jsonkey])\n",
        "        #print(myjson[jsonkey])\n",
        "    if is_dict == True:\n",
        "      return val_list\n",
        "  elif type(myjson) is list:\n",
        "    for item in myjson:\n",
        "      if type(item) in (list, dict):\n",
        "        get_all(item, key)\n",
        "        \n",
        "if data_file != last_data_file:\n",
        "  input_type = check_input_type(data_file)\n",
        "  source_id = rnd_str(6)  \n",
        "  last_data_file = data_file\n",
        "  if input_type == 'link':\n",
        "    op(c.title, 'Downloading...')\n",
        "    wfile = slug(basename(data_file))\n",
        "    wdir = dir_tmp+wfile+'/'\n",
        "    wext = path_ext(data_file)\n",
        "    file_path = wdir+wfile+wext\n",
        "    if not os.path.isdir(wdir):\n",
        "      !mkdir {wdir}\n",
        "      !wget {data_file} -O {file_path}\n",
        "      if data_file.endswith(zips):\n",
        "        if not file_path.endswith('.tar.gz') and file_path.endswith('.gz'):\n",
        "          print('gunzip', data_file, 'to', file_path)\n",
        "          %cd {dir_tmp}\n",
        "          !gunzip {file_path}\n",
        "          %cd /content/\n",
        "        else:\n",
        "          shutil.unpack_archive(file_path, path_dir(file_path))\n",
        "          !rm {file_path}\n",
        "        use_file = glob(wdir+'*')[0]\n",
        "      elif data_file.endswith(excels):\n",
        "        use_file = excel2csv(file_path)\n",
        "      else:\n",
        "        use_file = file_path\n",
        "    input_type = check_input_type(use_file)\n",
        "  elif input_type == 'unknown':\n",
        "    use_file = drive_root+data_file\n",
        "    input_type = check_input_type(use_file)\n",
        "    if input_type == 'file':\n",
        "      source_id = slug(basename(use_file))\n",
        "    else:\n",
        "      op(c.fail, 'Data file error.')\n",
        "  elif input_type == 'file':\n",
        "\n",
        "    if data_file.endswith(zips):\n",
        "      if not file_path.endswith('.tar.gz') and file_path.endswith('.gz'):\n",
        "        print('gunzip', data_file, 'to', file_path)\n",
        "        %cd {dir_tmp}\n",
        "        !gunzip {file_path}\n",
        "        %cd /content/\n",
        "      else:\n",
        "        shutil.unpack_archive(file_path, path_dir(file_path))\n",
        "        !rm {file_path}\n",
        "      use_file = glob(wdir+'*')[0]\n",
        "    elif data_file.endswith(excels):\n",
        "      use_file = excel2csv(file_path)\n",
        "    elif data_file.endswith(jsons):\n",
        "      use_file = file_path\n",
        "    else:\n",
        "      use_file = file_path\n",
        "  else:\n",
        "    op(c.fail, 'Data file error.')\n",
        "\n",
        "if input_type != 'file':\n",
        "  op(c.fail, 'Data file error.')\n",
        "else:\n",
        "\n",
        "  if use_file.endswith(jsons):\n",
        "    if json_keys == '':\n",
        "      prev_rows = 30\n",
        "      skip_rows = 1\n",
        "      with open(use_file, 'r') as f:\n",
        "        for line in f:\n",
        "          if line.startswith('#'):\n",
        "            skip_rows += 1\n",
        "          else:\n",
        "            break\n",
        "      with open(use_file) as f:\n",
        "        #data_head = [next(f) for x in range(skip_rows, skip_rows+prev_rows)]\n",
        "        data_head = itertools.islice(f, skip_rows, skip_rows+prev_rows)\n",
        "        op(c.title, 'Preview of input file:', use_file+'\\n')\n",
        "        for line in data_head:\n",
        "          print(line.replace('\\n', ''))\n",
        "      op(c.warn, '\\nPlease select attributes by entering their keys in json_keys field and run this cell again.')\n",
        "    elif json_keys != '':\n",
        "      json_keys = json_keys.split(',')\n",
        "      key_count = len(json_keys)\n",
        "      json_cols = [None] * key_count\n",
        "      with open(use_file) as f:\n",
        "        json_data = json.load(f) #str(json.load(f))\n",
        "      for i, json_key in enumerate(json_keys):\n",
        "        json_cols[i] = get_all(json_data, json_key.strip(), is_dict=True)\n",
        "\n",
        "      columns = list(range(len(json_cols)))\n",
        "      short_list = listlen(json_cols)\n",
        "      json_cols = [s[:short_list] for s in json_cols]\n",
        "      data = pd.DataFrame(json_cols).transpose()\n",
        "      precise_secs = data.shape[0]/global_sr\n",
        "      \n",
        "      data = data.apply(pd.to_numeric, errors='coerce')\n",
        "      data = data.fillna(0)\n",
        "     \n",
        "      output.clear()\n",
        "      op(c.title, 'Data preview\\n')\n",
        "      print(data.head(skip_rows+prev_rows))\n",
        "\n",
        "\n",
        "      if precise_secs > secs_warn_limit:\n",
        "        print('\\nEstimated audio duration:', str(precise_secs), 'seconds.')\n",
        "      op(c.ok, '\\nAll set. You may proceed to next step.')\n",
        "      if precise_secs < secs_warn_limit:\n",
        "        op(c.fail, '\\nWARN:', 'Your data will produce only '+str(precise_secs)+' seconds of audio. Try a file with more numeric rows if you want longer audio.')\n",
        "\n",
        "  elif use_file.endswith(xmls):\n",
        "    xml = ''\n",
        "    skip_rows = 2\n",
        "\n",
        "    if xml_tags == '':\n",
        "      prev_rows = 30   \n",
        "      with open(use_file, 'r') as f:\n",
        "        for i, line in enumerate(f):\n",
        "          if line.startswith('#'):\n",
        "            skip_rows += 1\n",
        "          else:\n",
        "            break\n",
        "\n",
        "      with open(use_file) as f:\n",
        "        data_head = itertools.islice(f, skip_rows, skip_rows+prev_rows)\n",
        "        op(c.title, 'Preview of input file:', use_file+'\\n')\n",
        "        for line in data_head:\n",
        "          print(line.replace('\\n', ''))\n",
        "      op(c.warn, '\\nPlease select tags by entering tag names in xml_tags field and run this cell again.')\n",
        "    elif xml_tags != '':\n",
        "\n",
        "      op(c.title, 'Working on it...', 'This may take a short while with XML. Please hold.')\n",
        "\n",
        "      xml_tags = xml_tags.split(',')\n",
        "      tag_count = len(xml_tags)\n",
        "      xml_cols = [None] * tag_count\n",
        "\n",
        "      with open(use_file) as f:\n",
        "        for i, line in enumerate(f):\n",
        "          if i > skip_rows:\n",
        "            xml += line\n",
        "\n",
        "      soup = BeautifulSoup(xml)\n",
        "      for i, xml_tag in enumerate(xml_tags):\n",
        "        tags = soup.findAll(xml_tag)\n",
        "        #print('tags', tags)\n",
        "        xml_cols[i] = [tag.getText() for tag in tags]\n",
        "\n",
        "      #print('xml_tags', xml_tags)\n",
        "      #print('xml_cols 0', xml_cols[0][:10] )\n",
        "\n",
        "      col_parts = []\n",
        "      for i in range(30):\n",
        "        col_parts.append([])\n",
        "      for xml_col in xml_cols:\n",
        "        for val in xml_col:\n",
        "          if ' ' in val.strip():\n",
        "            parts = val.strip().split(' ')\n",
        "            for i, part in enumerate(parts):\n",
        "              #col_parts[i].extend(part)\n",
        "              col_parts[i].append(part)\n",
        "      \n",
        "      if len(col_parts[0]) > 0:\n",
        "        stripped = [x for x in col_parts if x != []]  \n",
        "        data = pd.DataFrame(stripped).transpose()\n",
        "      else:\n",
        "        data = pd.DataFrame(xml_cols).transpose()\n",
        "      \n",
        "      data = data.apply(pd.to_numeric, errors='coerce')\n",
        "      data = data.fillna(0)\n",
        "      columns = range(data.shape[1])\n",
        "\n",
        "      output.clear()\n",
        "      op(c.title, 'Data preview\\n')\n",
        "      print(data.head(skip_rows+prev_rows))\n",
        "\n",
        "\n",
        "      if precise_secs > secs_warn_limit:\n",
        "        print('\\nEstimated audio duration:', str(precise_secs), 'seconds.')\n",
        "      op(c.ok, '\\nAll set. You may proceed to next step.')\n",
        "      if precise_secs < secs_warn_limit:\n",
        "        op(c.fail, '\\nWARN:', 'Your data will produce only '+str(precise_secs)+' seconds of audio. Try a file with more numeric rows if you want longer audio.')\n",
        "\n",
        "\n",
        "  else:\n",
        "\n",
        "    columnlist = []\n",
        "    if \",\" in columns:\n",
        "      columns = columns.split(',')\n",
        "      for col in columns:\n",
        "        if \"-\" in col:\n",
        "          cr = [int(i) for i in col.split('-')]\n",
        "          columnlist.extend(list(range(cr[0], cr[1]+1)))\n",
        "        else:\n",
        "          columnlist.append(int(col))\n",
        "      columns = columnlist\n",
        "    elif \"-\" in columns:\n",
        "      cr = [int(i) for i in columns.split('-')]\n",
        "      columnlist.extend(list(range(cr[0], cr[1]+1)))\n",
        "      columns = columnlist\n",
        "    elif columns == '':\n",
        "      columns = ''\n",
        "    elif columns.lower() == 'all':\n",
        "      columns = 'all' #list(range(0, 999))\n",
        "    else:\n",
        "      columns = [int(columns)]\n",
        "\n",
        "    skip_rows = 1\n",
        "    with open(use_file, 'r') as f:\n",
        "      for line in f:\n",
        "        if line.startswith('#'):\n",
        "          skip_rows += 1\n",
        "        else:\n",
        "          break\n",
        "\n",
        "    if delimiter == 'None':\n",
        "      output.clear()\n",
        "      op(c.title, 'Preview of input file:', use_file+'\\n')\n",
        "      \n",
        "      #print( range(skip_rows, skip_rows+prev_rows) )\n",
        "      with open(use_file) as f:\n",
        "        #data_head = [next(f) for x in range(skip_rows, skip_rows+prev_rows)]\n",
        "        data_head = itertools.islice(f, skip_rows, skip_rows+prev_rows)\n",
        "        for line in data_head:\n",
        "          print(line.replace('\\n', ''))\n",
        "\n",
        "      op(c.warn, '\\nPlease select delimiter and run this cell again before proceeding.')\n",
        "    elif delimiter == 'whitespace':\n",
        "      separator = '\\s+'\n",
        "    elif delimiter == 'tab':\n",
        "      separator = '\\s+' #'\\t'\n",
        "    elif delimiter == 'semicolon':\n",
        "      separator = ';'\n",
        "    elif delimiter == 'comma':\n",
        "      separator = ','  \n",
        "    elif delimiter == 'pipe':\n",
        "      separator = '|'\n",
        "    elif delimiter == 'double_pipe':\n",
        "      separator = '||'\n",
        "    if separator != '':\n",
        "      \n",
        "      pd.set_option('display.max_columns', None)\n",
        "      colselect_warn = False\n",
        "      if columns == '' or columns == 'all':\n",
        "        data = pd.read_csv(use_file, sep=separator, error_bad_lines=False, skiprows=skip_rows, skipfooter=1, header=None, index_col=False, skipinitialspace=True, skip_blank_lines=True, engine='python')\n",
        "        if columns == '':\n",
        "          colselect_warn = True\n",
        "        if columns == 'all':\n",
        "          columns = list(range(len(data.columns)))\n",
        "      else:\n",
        "        data = pd.read_csv(use_file, sep=separator, error_bad_lines=False, skiprows=skip_rows, skipfooter=1, header=None, index_col=False, skipinitialspace=True, skip_blank_lines=True, engine='python', usecols=columns)\n",
        "      \n",
        "      #data = data[data.iloc[:,0].str.startswith('#').ne(True)]\n",
        "      data = data.apply(pd.to_numeric, errors='coerce')\n",
        "      data = data.fillna(0)\n",
        "      #data = data.dropna()\n",
        "      #data = data.reset_index(drop=True)\n",
        "      \n",
        "      output.clear()\n",
        "      op(c.title, 'Data preview\\n')\n",
        "      print(data.head(skip_rows+prev_rows))\n",
        "      print('\\nSeparator:', separator, '('+delimiter+')')\n",
        "      precise_secs = data.shape[0]/global_sr\n",
        "        \n",
        "      if colselect_warn == True:\n",
        "        print('\\nNote that the columns in this preview may be divided to multiple rows (scroll up to see all).\\n')\n",
        "        op(c.warn, 'Please select which columns to use by typing their numbers or \\'all\\' into preview_columns field and run this cell again before proceeding.')\n",
        "      else:\n",
        "        if precise_secs > secs_warn_limit:\n",
        "          print('Estimated audio duration:', str(precise_secs), 'seconds.')\n",
        "        op(c.ok, '\\nAll set. You may proceed to next step.')\n",
        "      if precise_secs < secs_warn_limit:\n",
        "        op(c.fail, '\\nWARN:', 'Your data will produce only '+str(precise_secs)+' seconds of audio. Try a file with more numeric rows if you want longer audio.')\n",
        "\n",
        "import warnings\n",
        "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
        "\n",
        "info_file_created = False\n",
        "source_run = 0\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HL2gANSFFOp1",
        "cellView": "form"
      },
      "source": [
        "#@title #**<font color=\"#d6d\">2. Visualize columns</font>**\n",
        "#@markdown - This cell creates visual \"waveform previews\" of all selected columns. These previews do not represent final waveforms of the created audio files, but will provide some **idea** of what kind of audio the column is going to produce.<br> \n",
        "#@markdown - DC offsets won't be as wonky in the final sound files as they likely appear in these previews.<br>\n",
        "#@markdown - Column numbers located above each waveform will be used in the next step to determine which columns will be used as left and right channels to create a stereo audio file.<br>\n",
        "\n",
        "%matplotlib inline\n",
        "import matplotlib\n",
        "import matplotlib.pyplot as plt\n",
        "import scipy\n",
        "plt.rcParams['figure.figsize'] = [25, 6]\n",
        "plt.rcParams.update({\"axes.facecolor\": \"black\"})\n",
        "spheight = 6 * data.shape[1]\n",
        "\n",
        "precise_secs = data.shape[0]/global_sr\n",
        "if precise_secs < secs_warn_limit:\n",
        "  secs = precise_secs\n",
        "else:\n",
        "  secs = math.floor(precise_secs)\n",
        "\n",
        "op(c.title, 'Generating visual previews...\\n')\n",
        "for col in columns:\n",
        "  op(c.warn, 'Column number: '+str(col))\n",
        "  data[col].plot(color=np.random.rand(1,3))\n",
        "  plt.show()\n",
        "\n",
        "def pretty(secs):\n",
        "  return str(datetime.timedelta(seconds=secs))\n",
        "\n",
        "op(c.title, 'Estimated audio duration\\n')\n",
        "if precise_secs < secs_warn_limit:\n",
        "  print(secs, 'seconds')\n",
        "else:\n",
        "  print(pretty(secs), '(h:mm:ss)')\n",
        "\n",
        "print('\\n')\n",
        "# op(c.title, '\\nExamples of time-stretched durations:')\n",
        "# print('  2 x:', pretty(secs*2))\n",
        "# print('  5 x:', pretty(secs*5))\n",
        "# print(' 10 x:', pretty(secs*10))\n",
        "# print(' 25 x:', pretty(secs*25))\n",
        "# print(' 50 x:', pretty(secs*50))\n",
        "# print(' 75 x:', pretty(secs*75))\n",
        "# print('100 x:', pretty(secs*100))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "td3AlunKxG9Y",
        "cellView": "form"
      },
      "source": [
        "#@title #**<font color=\"#6d6\">3. Output</font>**\n",
        "#@markdown - You may run this cell multiple times with different selections and settings. No need to run previous cells.\n",
        "#@markdown - Audio creation is limited to a maximum duration of 3 minutes by default. This is to prevent: \n",
        "#@markdown <br>1) time-stretching accidents, such as 45 seconds of audio time_stretched by the factor of 100, ending up on a sound file duration of 1 hour and 15 minutes.\n",
        "#@markdown <br>2) Colab runtime from crashing. Standard-RAM runtime will run out of RAM and crash after converting data to around 20 minutes of audio.\n",
        "\n",
        "#@markdown <hr size=\"1\" color=\"#555\"/><br>\n",
        "\n",
        "#@markdown ##<font color=\"#6d6\">1)</font> Audio settings\n",
        "#@markdown Select waveforms from above by typing in their column numbers. They will be the left and right channel of the created soundfile. Leave `right_channel` blank if you want the same waveform on both channels (mono sound).<br>\n",
        "left_channel = \"\" #@param {type:\"string\"}\n",
        "right_channel = \"\" #@param {type:\"string\"}\n",
        "stereo_width = 10 #@param {type:\"slider\", min:0, max:10, step:1}\n",
        "time_stretch = 1 #@param {type:\"slider\", min:1, max:100, step:1}\n",
        "#@markdown <small>Default sample rate is 44100 Hz. `stretch_type: sample_rate` option will stretch the sound by reducing sample rate (fast but lo-fi). With this option, your maximum `time_stretch` factor is 14. `stretch_type: linear_interpolation` will retain the sample rate of 44100 Hz and compute in the blanks (hi-fi but slow).<br>**I.e. `stretch_type: linear_interpolation` option will produce higher quality audio for your auditory perception.**</small>\n",
        "stretch_type = \"linear_interpolation\" #@param [\"sample_rate\", \"linear_interpolation\"]\n",
        "#@markdown <small>Use this to increase sample rate if the sound feels too \"slow\". This will be ignored if `time_stretch` is used (value is higher than 1), no sense in using both.</small>\n",
        "speed_up = 1 #@param {type:\"slider\", min:1, max:4, step:1}\n",
        "\n",
        "#@markdown <hr size=\"1\" color=\"#555\"/><br>\n",
        "\n",
        "#@markdown ##<font color=\"#6d6\">2)</font> Save files\n",
        "#@markdown <small>Save all created audio files as WAV to your Google Drive.</small>\n",
        "save_to_drive = False #@param {type:\"boolean\"}\n",
        "timestamp_output_files = False #@param {type:\"boolean\"}\n",
        "#@markdown <small>Directory path in Drive, in which the files will be saved.</small>\n",
        "output_dir = \"\" #@param {type:\"string\"}\n",
        "#@markdown <small>Save accompanying .txt file containing information about your settings. May come in handy one day in the distant future.</small>\n",
        "save_info_txt = False #@param {type:\"boolean\"}\n",
        "#@markdown <small>Optional note to be included in the information txt file. Sloppy Noto has no idea what this data is.</small>\n",
        "free_note = \"\" #@param {type:\"string\"}\n",
        "#@markdown <small>Check `allow_long` if you want to take your chances and attempt to create and save audio files longer than 3 minutes without Colab runtime crashing. High-RAM runtime (Colab Pro only) is highly recommended. Whatever the runtime, use with caution.<br>**I.e. checking `allow_long` is not recommended.**</small>\n",
        "allow_long = False #@param {type:\"boolean\"}\n",
        "\n",
        "op(c.title, 'Processing...')\n",
        "\n",
        "output_dir = fix_path(drive_root+output_dir)\n",
        "\n",
        "stereo_sep = stereo_width\n",
        "maxv = 0.45\n",
        "max_dur_min = 3\n",
        "detail_view = False\n",
        "run_id = rnd_str(6)\n",
        "\n",
        "plt.rcParams.update({\"axes.facecolor\": \"black\"})\n",
        "\n",
        "def appendTxt(file, content):\n",
        "  txt = open(txt_file, 'a+') \n",
        "  txt.writelines(content+'\\n')\n",
        "  txt.close();\n",
        "  \n",
        "def swf(sig1, sig2='', sr=global_sr):\n",
        "  #yellowgreen, salmon\n",
        "  duration = len(sig1)/sr\n",
        "  time = np.arange(0,duration,1/sr)\n",
        "  plt.rcParams.update({\"axes.facecolor\": \"black\"})\n",
        "  plt.ylim(-1, 1)\n",
        "  plt.plot(time, sig1, color=np.random.rand(3), linewidth=1, alpha=1)\n",
        "  if sig2 != '':\n",
        "    plt.plot(time, sig2, color=np.random.rand(3), linewidth=1, alpha=0.55)\n",
        "  plt.show()\n",
        "\n",
        "def query_yes_no(question, default=\"yes\"):\n",
        "  valid = {\"yes\": True, \"y\": True, \"ye\": True,\n",
        "            \"no\": False, \"n\": False}\n",
        "  if default is None:\n",
        "    prompt = \" [y/n] \"\n",
        "  elif default == \"yes\":\n",
        "    prompt = \" [Y/n] \"\n",
        "  elif default == \"no\":\n",
        "    prompt = \" [y/N] \"\n",
        "  else:\n",
        "    raise ValueError(\"invalid default answer: '%s'\" % default)\n",
        "\n",
        "  while True:\n",
        "    sys.stdout.write(question + prompt)\n",
        "    choice = input().lower()\n",
        "    if default is not None and choice == '':\n",
        "      return valid[default]\n",
        "    elif choice in valid:\n",
        "      return valid[choice]\n",
        "    else:\n",
        "      sys.stdout.write(\"Please respond with 'yes' or 'no' (or 'y' or 'n').\\n\")\n",
        "            \n",
        "channels = []\n",
        "ready = True\n",
        "cmp_time_stretch = time_stretch\n",
        "max_duration = max_dur_min*60*global_sr\n",
        "\n",
        "if secs*cmp_time_stretch > 1200 and allow_long == True:\n",
        "  op(c.fail, '\\n\\nWARN:', 'You are about to time-stretch the soundfile to over 20 minutes (to '+pretty(secs*time_stretch)+' to be exact).\\nIf you are rocking the free standard RAM version of Colab, there is a good chance Colab will run out of RAM and crash.\\n')\n",
        "  ready = query_yes_no('Want to take your chances anyway?')\n",
        "  error = 'timestretch_length'\n",
        "if ready == False:\n",
        "  if error == 'timestretch_length':\n",
        "    op(c.fail, 'Try reducing time-stretch and run cell again.')\n",
        "else:\n",
        "\n",
        "  left = int(left_channel)\n",
        "  if right_channel == '':\n",
        "    right = int(left_channel)\n",
        "    stereo_width = 0\n",
        "  else:\n",
        "    right = int(right_channel)\n",
        "\n",
        "  channels.append(data[left])\n",
        "  channels.append(data[right])\n",
        "\n",
        "  if time_stretch > 1:\n",
        "    speed_up = 1\n",
        "  for i, chan in enumerate(channels):\n",
        "    if time_stretch > 1 and stretch_type == \"linear_interpolation\":\n",
        "      real_duration = len(chan)\n",
        "      max_duration = math.floor((max_dur_min*60*global_sr)/cmp_time_stretch)\n",
        "      if real_duration > max_duration and allow_long == False:\n",
        "        print('Channel', i, ':', real_duration, '->', max_duration)\n",
        "        chan = chan[:max_duration]\n",
        "      stretcher = []\n",
        "      for ii, fr in enumerate(chan):\n",
        "        cur = fr\n",
        "        if ii > 0 and ii < (real_duration-1):\n",
        "          prv = chan.iloc[ii-1]\n",
        "          #nxt = chan[ii+1]\n",
        "          new_frame = np.linspace(prv, cur, time_stretch)\n",
        "          stretcher.extend(new_frame)\n",
        "      chan = np.array(stretcher).astype(np.float64)\n",
        "    print('Channel', i, ':', chan.min(), chan.max(), '->', np.negative(maxv), maxv)\n",
        "    chan = np.interp(chan, (chan.min(), chan.max()), (np.negative(maxv), maxv))\n",
        "    sos = scipy.signal.butter(10, 15, 'hp', fs=global_sr, output='sos')\n",
        "    chan = scipy.signal.sosfilt(sos, chan)\n",
        "    channels[i] = chan\n",
        "\n",
        "  xsr = global_sr\n",
        "  if time_stretch > 1 and stretch_type == \"sample_rate\":\n",
        "    xsr = math.floor(global_sr/time_stretch)\n",
        "    print('New sample rate:', xsr)\n",
        "  \n",
        "  if stereo_sep == 0:\n",
        "    fin_left = channels[0]+channels[1]\n",
        "    fin_right = fin_left\n",
        "  elif stereo_sep == 10:\n",
        "    fin_left = channels[0]\n",
        "    fin_right = channels[1]\n",
        "  else:\n",
        "    fin_left = channels[0]+channels[1]/stereo_sep\n",
        "    fin_right = channels[0]/stereo_sep+channels[1]\n",
        "\n",
        "  if detail_view == True:\n",
        "    dvend = math.floor(xsr/2)\n",
        "    swf(fin_left[0:dvend])\n",
        "    swf(fin_right[0:dvend])\n",
        "\n",
        "  if fin_left[0] < -0.4 or fin_left[0] > 0.4 or fin_right[0] < -0.4 or fin_right[0] > 0.4:\n",
        "    clip_point = math.floor(xsr/2)\n",
        "    fin_left = fin_left[clip_point:]\n",
        "    fin_right = fin_right[clip_point:]\n",
        "\n",
        "  if detail_view == True:\n",
        "    dvend = math.floor(xsr/2)\n",
        "    swf(fin_left[0:dvend])\n",
        "    swf(fin_right[0:dvend])\n",
        "    swf(fin_left)\n",
        "    swf(fin_right)\n",
        "\n",
        "  output.clear()\n",
        "\n",
        "  if time_stretch > 14 and stretch_type == 'sample_rate':\n",
        "    op(c.fail, 'ERROR:', 'You may not set time_stretch higher than 14 if you use \\'sample_rate\\' as stretch_type. Reduce time_stretch or change stretch_type to \\'linear_fill\\'')\n",
        "  else:\n",
        "\n",
        "    if speed_up > 1:\n",
        "      xsr = xsr * speed_up\n",
        "\n",
        "    max_duration = max_dur_min*60*xsr\n",
        "    real_duration = len(fin_left)\n",
        "    max_secs = max_dur_min*60\n",
        "    real_secs = real_duration/xsr\n",
        "\n",
        "    if real_duration > max_duration and allow_long == False:\n",
        "      fin_left = fin_left[:max_duration]\n",
        "      fin_right = fin_right[:max_duration]\n",
        "      \n",
        "    swf(fin_left, fin_right, xsr)\n",
        "    if real_duration > max_duration and allow_long == False:\n",
        "      print('Audio duration:', pretty(max_secs), '(clipped from', pretty(real_secs)+')\\n')\n",
        "    else:\n",
        "      print('Audio duration:', pretty(real_secs), '\\n')\n",
        "    audio = np.array([fin_left, fin_right], np.float64)\n",
        "\n",
        "    audio_player(audio, sr=xsr)\n",
        "\n",
        "    source_run += 1\n",
        "    if save_to_drive == True:\n",
        "      import soundfile\n",
        "      import datetime\n",
        "      if timestamp_output_files == True:\n",
        "        wav_timestamp = datetime.datetime.today().strftime('%Y-%m-%d-%H-%M-%S')+'_'\n",
        "      else:\n",
        "        wav_timestamp = ''\n",
        "      wav_file = output_dir+'noto_'+wav_timestamp+source_id+'_'+run_id+'.wav'\n",
        "      soundfile.write(wav_file, audio.T, xsr)\n",
        "      view_out = wav_file.replace(drive_root, '')\n",
        "      op(c.ok, '\\n\\nFile saved:', view_out)\n",
        "      if save_info_txt == True:\n",
        "        if info_file_created == False:\n",
        "          if timestamp_output_files == True:\n",
        "            txt_timestamp = datetime.datetime.today().strftime('%Y-%m-%d-%H-%M-%S')+'_'\n",
        "          else:\n",
        "            txt_timestamp = ''\n",
        "          txt_file = output_dir+'noto_'+txt_timestamp+source_id+'.txt'\n",
        "          txt = open(txt_file,'w') \n",
        "          params = ['started:            '+datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S')+'\\n\\n',\n",
        "                    free_note+'\\n\\n',\n",
        "                    'data_file:          '+data_file+'\\n',\n",
        "                    'columns:            '+str(preview_columns)+'\\n',\n",
        "                    'delimiter:          '+delimiter+' ('+separator+')\\n\\n',\n",
        "                    '---\\n\\n']\n",
        "          txt.writelines(params)\n",
        "          txt.close()\n",
        "          view_txt = txt_file.replace(drive_root, '')\n",
        "          op(c.ok, 'Info file saved:', view_txt) \n",
        "          last_free_note = free_note\n",
        "          info_file_created = True\n",
        "        \n",
        "        txt = open(txt_file,'a+') \n",
        "        params = ['VARIANT #'+str(source_run)+': '+path_leaf(wav_file)+'\\n',\n",
        "                  'created:            '+datetime.datetime.today().strftime('%H:%M:%S')+'\\n',\n",
        "                  'left_channel:       column '+str(left_channel)+'\\n'\n",
        "                  'right_channel:      column '+str(right_channel)+'\\n',\n",
        "                  'stereo_width:       '+str(stereo_width)+'\\n',\n",
        "                  'time_stretch:       '+str(time_stretch)+'x\\n',\n",
        "                  'stretch_type:       '+stretch_type+'\\n\\n']\n",
        "        txt.writelines(params)\n",
        "        txt.close()\n",
        "        if free_note != last_free_note:\n",
        "          appendTxt(txt_file, free_note+'\\n')\n",
        "          last_free_note = free_note\n",
        "\n",
        "op(c.ok, '\\nFIN.')\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}