{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting sound_chirp.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile sound_chirp.py\n",
    "import numpy as np\n",
    "import time\n",
    "from scipy.signal import lfilter\n",
    "from functools import reduce\n",
    "\n",
    "import os\n",
    "import threading\n",
    "import random\n",
    "\n",
    "class SoundController:\n",
    "    # https://python-sounddevice.readthedocs.io/en/0.3.15/api/streams.html#sounddevice.OutputStream\n",
    "    \n",
    "    default_cfg = {\n",
    "        \"device\": [1, 26],\n",
    "        \"n_channels\": 10,\n",
    "        \"sounds\": {\n",
    "            \"noise\": {\"amp\": 0.2, \"channels\": [6, 8]},\n",
    "            \"background\": {\"freq\": 660, \"amp\": 0.1, \"duration\": 0.05, \"harmonics\": True, \"channels\": [3, 8]},\n",
    "            \"target\": {\"freq\": 1320, \"amp\": 0.1, \"duration\": 0.05, \"harmonics\": True, \"channels\": [3, 8]}, \n",
    "            \"distractor1\": {\"freq\": 860, \"amp\": 0.15, \"duration\": 0.05, \"harmonics\": True, \"channels\": [6, 8], \"enabled\": False},\n",
    "            \"distractor2\": {\"freq\": 1060, \"amp\": 0.25, \"duration\": 0.05, \"harmonics\": True, \"channels\": [6, 8], \"enabled\": False},\n",
    "            \"distractor3\": {\"freq\": 1320, \"amp\": 0.2, \"duration\": 0.05, \"harmonics\": True, \"channels\": [6, 8], \"enabled\": False}\n",
    "        },\n",
    "        \"pulse_duration\": 0.05,\n",
    "        \"sample_rate\": 44100,\n",
    "        \"latency\": 0.25,\n",
    "        \"volume\": 0.7,\n",
    "        \"roving\": 5.0,\n",
    "        \"file_path\": \"sounds.csv\"\n",
    "    }\n",
    "    \n",
    "    commutator = {\n",
    "        -1: 'noise',\n",
    "        0:  'silence',\n",
    "        1:  'background',\n",
    "        2:  'target',\n",
    "        3:  'distractor1',\n",
    "        4:  'distractor2',\n",
    "        5:  'distractor3',\n",
    "        6:  'distractor4',\n",
    "        7:  'distractor5'\n",
    "    }\n",
    "    \n",
    "    @classmethod\n",
    "    def get_pure_tone(cls, freq, duration, sample_rate=44100):\n",
    "        x = np.linspace(0, duration * freq * 2*np.pi, int(duration*sample_rate), dtype=np.float32)\n",
    "        return np.sin(x)\n",
    "\n",
    "    @classmethod\n",
    "    def get_harm_stack(cls, base_freq, duration, threshold=1500, sample_rate=44100):\n",
    "        harmonics = [x * base_freq for x in np.arange(20) + 2 if x * base_freq < threshold]  # first 20 enouch\n",
    "        freqs = [base_freq] + harmonics\n",
    "        x = np.linspace(0, duration, int(sample_rate * duration))\n",
    "        y = reduce(lambda x, y: x + y, [(1./(i+1)) * np.sin(base_freq * 2 * np.pi * x) for i, base_freq in enumerate(freqs)])\n",
    "        return y / y.max()  # norm to -1 to 1\n",
    "    \n",
    "    @classmethod\n",
    "    def get_cos_window(cls, tone, win_duration, sample_rate=44100):\n",
    "        x = np.linspace(0, np.pi/2, int(win_duration * sample_rate), dtype=np.float32)\n",
    "        onset =  np.sin(x)\n",
    "        middle = np.ones(len(tone) - 2 * len(x))\n",
    "        offset = np.cos(x)\n",
    "        return np.concatenate([onset, middle, offset])\n",
    "\n",
    "    @classmethod\n",
    "    def get_tone_stack(cls, cfg):\n",
    "        # silence\n",
    "        silence = np.zeros(2, dtype='float32')\n",
    "        sounds = {'silence': np.column_stack([silence for x in range(cfg['n_channels'])])}\n",
    "\n",
    "        # noise\n",
    "        filter_a = np.array([0.0075, 0.0225, 0.0225, 0.0075])\n",
    "        filter_b = np.array([1.0000,-2.1114, 1.5768,-0.4053])\n",
    "\n",
    "        noise = np.random.randn(int(0.25 * cfg['sample_rate']))  # 250ms of noise\n",
    "        noise = lfilter(filter_a, filter_b, noise)\n",
    "        noise = noise / np.abs(noise).max() * cfg['sounds']['noise']['amp']\n",
    "        noise = noise.astype(np.float32)\n",
    "        empty = np.zeros((len(noise), cfg['n_channels']), dtype='float32')\n",
    "        for ch in cfg['sounds']['noise']['channels']:\n",
    "            empty[:, ch-1] = noise\n",
    "        sounds['noise'] = empty\n",
    "        \n",
    "        # all other sounds\n",
    "        for key, snd in cfg['sounds'].items():\n",
    "            if key == 'noise' or ('enabled' in snd and not snd['enabled']):\n",
    "                continue  # skip noise or unused sounds\n",
    "                \n",
    "            if 'harmonics' in snd and snd['harmonics']:\n",
    "                tone = cls.get_harm_stack(snd['freq'], snd['duration'], sample_rate=cfg['sample_rate']) * cfg['volume']\n",
    "            else:\n",
    "                tone = cls.get_pure_tone(snd['freq'], snd['duration'], cfg['sample_rate']) * cfg['volume']\n",
    "            tone = tone * cls.get_cos_window(tone, 0.01, cfg['sample_rate'])  # onset / offset\n",
    "            tone = tone * snd['amp']  # amplitude\n",
    "            \n",
    "            sound = np.zeros([len(tone), cfg['n_channels']], dtype='float32')\n",
    "            for j in snd['channels']:\n",
    "                sound[:, j-1] = tone\n",
    "           \n",
    "            sounds[key] = sound\n",
    "\n",
    "        return sounds\n",
    "        \n",
    "    @classmethod\n",
    "    def run(cls, selector, status, cfg):\n",
    "        \"\"\"\n",
    "        selector        mp.Value object to set the sound to be played\n",
    "        status          mp.Value object to stop the loop\n",
    "        \"\"\"\n",
    "        import sounddevice as sd  # must be inside the function\n",
    "        import numpy as np\n",
    "        import time\n",
    "        \n",
    "        import soundfile as sf # chirp changes\n",
    "        \n",
    "        commutator = {\n",
    "            -1: 'noise',\n",
    "            0:  'silence',\n",
    "            1:  'background',\n",
    "            2:  'target',\n",
    "            3:  'distractor1',\n",
    "            4:  'distractor2',\n",
    "            5:  'distractor3',\n",
    "            6:  'distractor4',\n",
    "            7:  'distractor5'\n",
    "        }\n",
    "        \n",
    "        sounds = cls.get_tone_stack(cfg)\n",
    "\n",
    "        sd.default.device = cfg['device']\n",
    "        sd.default.samplerate = cfg['sample_rate']\n",
    "        \n",
    "        data, fs = sf.read(cfg['wav_file'], dtype='float32') #chirp changes\n",
    "        chirp = np.zeros((len(data),cfg['n_channels']),dtype='float32') #chirp changes\n",
    "        chirp[:,cfg['sounds']['target']['channels'][0]-1] = 0.07*data #chirp changes, amplitude for chirp=0.07, click=1.0\n",
    "        chirp[:,6] = 0.07*data #chirp changes, amplitude for chirp=0.07, click=1.0\n",
    "        \n",
    "        stream = sd.OutputStream(samplerate=cfg['sample_rate'], channels=cfg['n_channels'], dtype='float32', blocksize=256)\n",
    "        stream.start()\n",
    "\n",
    "        next_beat = time.time() + cfg['latency']\n",
    "        with open(cfg['file_path'], 'w') as f:\n",
    "            f.write(\"time,id\\n\")\n",
    "\n",
    "        while status.value > 0:\n",
    "            if status.value == 2 or (status.value == 1 and selector.value == -1):  # running state or masking noise\n",
    "                t0 = time.time()\n",
    "                if t0 < next_beat:\n",
    "                    #time.sleep(0.0001)  # not to spin the wheels too much\n",
    "                    if stream.write_available > 2:\n",
    "                        stream.write(sounds['silence'])  # silence\n",
    "                    continue\n",
    "\n",
    "                roving = 10**((np.random.rand() * cfg['roving'] - cfg['roving']/2.0)/20.)\n",
    "                roving = roving if int(selector.value) > -1 else 1  # no roving for noise\n",
    "#                 stream.write(sounds[commutator[int(selector.value)]] * roving) # chirp changes (uncomment->comment)\n",
    "                stream.write(chirp) # chirp changes\n",
    "                if status.value == 2:\n",
    "                    with open(cfg['file_path'], 'a') as f:\n",
    "                        f.write(\",\".join([str(x) for x in (t0, selector.value)]) + \"\\n\")\n",
    "\n",
    "                next_beat += cfg['latency']\n",
    "                \n",
    "                if stream.write_available > 2:\n",
    "                    stream.write(sounds['silence'])  # silence\n",
    "            \n",
    "            else:  # idle state\n",
    "                next_beat = time.time() + cfg['latency']\n",
    "                time.sleep(0.005)\n",
    "                \n",
    "        stream.stop()\n",
    "        print('Sound stopped')\n",
    "\n",
    "        \n",
    "class ContinuousSoundStream:\n",
    "   \n",
    "    default_cfg = {\n",
    "        'wav_file': os.path.join('..', 'assets', 'stream1.wav'),\n",
    "        'chunk_duration': 20,\n",
    "        'chunk_offset': 2\n",
    "    }\n",
    "    \n",
    "    def __init__(self, cfg):\n",
    "        from scipy.io import wavfile\n",
    "        import sounddevice as sd\n",
    "\n",
    "        self.cfg = cfg\n",
    "        self.stopped = False\n",
    "        self.samplerate, self.data = wavfile.read(cfg['wav_file'])\n",
    "        self.stream = sd.OutputStream(samplerate=self.samplerate, channels=2, dtype=self.data.dtype)\n",
    "\n",
    "    def start(self):\n",
    "        self._th = threading.Thread(target=self.update, args=())\n",
    "        self._th.start()\n",
    "\n",
    "    def stop(self):\n",
    "        self.stopped = True\n",
    "        self._th.join()\n",
    "        print('Continuous sound stream released')\n",
    "            \n",
    "    def update(self):\n",
    "        self.stream.start()\n",
    "        print('Continuous sound stream started at %s Hz' % (self.samplerate))\n",
    "        \n",
    "        offset = int(self.cfg['chunk_offset'] * self.samplerate)\n",
    "        chunk =  int(self.cfg['chunk_duration'] * self.samplerate)\n",
    "        \n",
    "        while not self.stopped:\n",
    "            start_idx = offset + np.random.randint(self.data.shape[0] - 2 * offset - chunk)\n",
    "            end_idx = start_idx + chunk\n",
    "            self.stream.write(self.data[start_idx:end_idx])\n",
    "            \n",
    "        self.stream.stop()\n",
    "        \n",
    "        \n",
    "class SoundControllerPR:\n",
    "    \n",
    "    default_cfg = {\n",
    "        \"device\": [1, 26],\n",
    "        \"n_channels\": 10,\n",
    "        \"sounds\": {\n",
    "            \"noise\": {\"amp\": 0.2, \"duration\": 2.0, \"channels\": [6, 8]},\n",
    "            \"target\": {\"freq\": 660, \"amp\": 0.1, \"duration\": 2.0}, \n",
    "        },\n",
    "        \"sample_rate\": 44100,\n",
    "        \"volume\": 0.7,\n",
    "        \"file_path\": \"sounds.csv\"\n",
    "    }\n",
    "        \n",
    "    def __init__(self, status, cfg):\n",
    "        import sounddevice as sd  # must be inside the function\n",
    "        import numpy as np\n",
    "        import time\n",
    "\n",
    "        sd.default.device = cfg['device']\n",
    "        sd.default.samplerate = cfg['sample_rate']\n",
    "        self.stream = sd.OutputStream(samplerate=cfg['sample_rate'], channels=cfg['n_channels'], dtype='float32', blocksize=256)\n",
    "        self.stream.start()\n",
    "\n",
    "        self.timers = []\n",
    "        self.status = status\n",
    "        self.cfg = cfg\n",
    "        \n",
    "        # noise (not assigned to channels)\n",
    "        filter_a = np.array([0.0075, 0.0225, 0.0225, 0.0075])\n",
    "        filter_b = np.array([1.0000,-2.1114, 1.5768,-0.4053])\n",
    "\n",
    "        noise = np.random.randn(int(cfg['sounds']['noise']['duration'] * cfg['sample_rate']))\n",
    "        noise = lfilter(filter_a, filter_b, noise)\n",
    "        noise = noise / np.abs(noise).max() * cfg['sounds']['noise']['amp']\n",
    "        noise = noise.astype(np.float32)\n",
    "\n",
    "        # target (not assigned to channels)\n",
    "        sample_rate = cfg['sample_rate']\n",
    "        target_cfg = cfg['sounds']['target']\n",
    "\n",
    "        tone = SoundController.get_pure_tone(target_cfg['freq'], target_cfg['duration'], sample_rate=cfg['sample_rate'])\n",
    "        tone = tone * SoundController.get_cos_window(tone, target_cfg['window'], sample_rate=cfg['sample_rate'])\n",
    "\n",
    "        if target_cfg['number'] > 1:\n",
    "            silence = np.zeros( int(target_cfg['iti'] * cfg['sample_rate']) )\n",
    "            tone_with_iti = np.concatenate([tone, silence])\n",
    "            target = np.concatenate([tone_with_iti for i in range(target_cfg['number'] - 1)])\n",
    "            target = np.concatenate([target, tone])\n",
    "        else:\n",
    "            target = tone\n",
    "            \n",
    "        target = target * target_cfg['amp']  # amplitude\n",
    "       \n",
    "        #snd = cfg['sounds']['target']\n",
    "        #target = SoundController.get_pure_tone(snd['freq'], snd['duration'], cfg['sample_rate']) * cfg['volume']\n",
    "        #target = target * SoundController.get_cos_window(target, 0.01, cfg['sample_rate'])  # onset / offset\n",
    "        #target = target * snd['amp']  # amplitude\n",
    "        \n",
    "        self.sounds = {'noise': noise, 'target': target}\n",
    "        \n",
    "    def target(self, hd_angle):\n",
    "        to_play = np.zeros((len(self.sounds['target']), self.cfg['n_channels']), dtype='float32')\n",
    "        channel = random.choice(self.cfg['sounds']['target']['channels'])  # random speaker!\n",
    "        \n",
    "        to_play[:, channel-1] = self.sounds['target']\n",
    "            \n",
    "        t0 = time.time()\n",
    "        with open(self.cfg['file_path'], 'a') as f:\n",
    "            f.write(\",\".join([str(x) for x in (t0, 2, channel)]) + \"\\n\")\n",
    "        \n",
    "        self.stream.write(to_play)\n",
    "        \n",
    "    def noise(self):\n",
    "        to_play = np.zeros((len(self.sounds['noise']), self.cfg['n_channels']), dtype='float32')\n",
    "        for ch in self.cfg['sounds']['noise']['channels']:\n",
    "            to_play[:, ch-1] = self.sounds['noise']\n",
    "        \n",
    "        ch1 = self.cfg['sounds']['noise']['channels'][0]\n",
    "        t0 = time.time()\n",
    "        with open(self.cfg['file_path'], 'a') as f:\n",
    "            f.write(\",\".join([str(x) for x in (t0, -1, ch1)]) + \"\\n\")\n",
    "        \n",
    "        self.stream.write(to_play)\n",
    "            \n",
    "    def play_non_blocking(self, sound_id, hd_angle=0):\n",
    "        if sound_id == 'target':\n",
    "            tf = threading.Timer(0, self.target, args=[hd_angle])\n",
    "        elif sound_id == 'noise':\n",
    "            tf = threading.Timer(0, self.noise, args=[])\n",
    "        tf.start()\n",
    "        self.timers.append(tf)\n",
    "        \n",
    "    def stop(self):\n",
    "        for t in self.timers:\n",
    "            t.cancel()\n",
    "        self.stream.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x22875c5dfd0>]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sound import SoundController\n",
    "import numpy as np\n",
    "\n",
    "sample_rate = 96000\n",
    "target_cfg = {\"freq\": 660, \"amp\": 0.1, \"duration\": 0.1, \"window\": 0.005, \"iti\": 0.1, \"number\": 7}\n",
    "\n",
    "tone = SoundController.get_pure_tone(target_cfg['freq'], target_cfg['duration'], sample_rate=sample_rate)\n",
    "tone = tone * SoundController.get_cos_window(tone, target_cfg['window'], sample_rate=sample_rate)\n",
    "\n",
    "if target_cfg['number'] > 1:\n",
    "    silence = np.zeros( int(target_cfg['iti'] * sample_rate) )\n",
    "    tone_with_iti = np.concatenate([tone, silence])\n",
    "    pulses = np.concatenate([tone_with_iti for i in range(target_cfg['number'] - 1)])\n",
    "    pulses = np.concatenate([pulses, tone])\n",
    "else:\n",
    "    pulses = tone\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.plot(pulses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing sound controller for Precedence project"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import time, os\n",
    "from sound import SoundControllerPR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc = SoundControllerPR(1, SoundControllerPR.default_cfg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc.play_non_blocking('target', 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building sound stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import time, os\n",
    "from sound import SoundController\n",
    "\n",
    "cfg = SoundController.default_cfg\n",
    "sounds = SoundController.get_tone_stack(cfg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "_ = plt.plot(sounds['noise'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Roving and onset window"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sound import SoundController\n",
    "\n",
    "duration = 0.05\n",
    "freq = 440\n",
    "\n",
    "tone = SoundController.get_pure_tone(freq, duration)\n",
    "tone = tone * SoundController.get_cos_window(tone, 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0xab1e490>]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(tone)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.signal import lfilter\n",
    "\n",
    "sample_rate = 44100\n",
    "\n",
    "filter_a = np.array([0.0075, 0.0225, 0.0225, 0.0075])\n",
    "filter_b = np.array([1.0000,-2.1114, 1.5768,-0.4053])\n",
    "\n",
    "noise = np.random.randn(3*sample_rate)\n",
    "noise = lfilter(filter_a, filter_b, noise)\n",
    "noise = noise / np.abs(noise).max() * 0.5\n",
    "noise = noise.astype(np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0xa85b550>]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(noise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing sound pulses without MP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-1-c2b7fcf1451e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[0mcfg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mSoundController\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdefault_cfg\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[1;31m#cfg['device'] = [1, 26]  # 'M-Audio Delta ASIO'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 14\u001b[1;33m \u001b[0mSoundController\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mselector\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstatus\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcfg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     15\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     16\u001b[0m \u001b[1;31m# nothing happens for a second\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\runSIT\\controllers\\sound.py\u001b[0m in \u001b[0;36mrun\u001b[1;34m(cls, selector, status, cfg)\u001b[0m\n\u001b[0;32m    134\u001b[0m                 \u001b[0mroving\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m**\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrand\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mcfg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'roving'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0mcfg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'roving'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m2.0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m20.\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    135\u001b[0m                 \u001b[0mroving\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mroving\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mselector\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m \u001b[1;32melse\u001b[0m \u001b[1;36m1\u001b[0m  \u001b[1;31m# no roving for noise\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 136\u001b[1;33m                 \u001b[0mstream\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msounds\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mcommutator\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mselector\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mroving\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    137\u001b[0m                 \u001b[1;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcfg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'file_path'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'a'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    138\u001b[0m                     \u001b[0mf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\",\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[1;32min\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mt0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mselector\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m\"\\n\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\.conda\\envs\\runsit\\lib\\site-packages\\sounddevice.py\u001b[0m in \u001b[0;36mwrite\u001b[1;34m(self, data)\u001b[0m\n\u001b[0;32m   1532\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mflags\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mc_contiguous\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1533\u001b[0m             \u001b[1;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'data must be C-contiguous'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1534\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mRawOutputStream\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1535\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1536\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\.conda\\envs\\runsit\\lib\\site-packages\\sounddevice.py\u001b[0m in \u001b[0;36mwrite\u001b[1;34m(self, data)\u001b[0m\n\u001b[0;32m   1319\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mremainder\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1320\u001b[0m             \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Number of samples not divisible by channels'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1321\u001b[1;33m         \u001b[0merr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_lib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mPa_WriteStream\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_ptr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mframes\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1322\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0merr\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0m_lib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpaOutputUnderflowed\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1323\u001b[0m             \u001b[0munderflowed\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import time, os\n",
    "import multiprocess as mp\n",
    "from sound import SoundController\n",
    "\n",
    "# sound selector: 0 - silence, 1 - tone 1, 2 - tone 2\n",
    "selector = mp.Value('i', -1)\n",
    "\n",
    "# loggin status: 1 - idle, 2 - running, 0 - stopped\n",
    "status = mp.Value('i', 2)\n",
    "\n",
    "cfg = SoundController.default_cfg\n",
    "#cfg['device'] = [1, 26]  # 'M-Audio Delta ASIO'\n",
    "SoundController.run(selector, status, cfg)\n",
    "\n",
    "# nothing happens for a second\n",
    "time.sleep(1)\n",
    "\n",
    "status.value = 2\n",
    "for i in range(2):\n",
    "    time.sleep(1)\n",
    "    selector.value = -1 if selector.value == 2 else 2\n",
    "\n",
    "# stop\n",
    "status.value = 0\n",
    "time.sleep(0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing sound pulses with MP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import time, os\n",
    "import multiprocess as mp\n",
    "from sound import SoundController\n",
    "\n",
    "# sound selector: 0 - silence, 1 - tone 1, 2 - tone 2\n",
    "selector = mp.Value('i', -1)\n",
    "\n",
    "# loggin status: 1 - idle, 2 - running, 0 - stopped\n",
    "status = mp.Value('i', 1)\n",
    "\n",
    "cfg = SoundController.default_cfg\n",
    "cfg['device'] = [1, 26]  # 'M-Audio Delta ASIO'\n",
    "sc = mp.Process(target=SoundController.run, args=(selector, status, cfg))\n",
    "sc.start()\n",
    "\n",
    "# nothing happens for a second\n",
    "time.sleep(1)\n",
    "\n",
    "status.value = 2\n",
    "for i in range(3):\n",
    "    time.sleep(1)\n",
    "    selector.value = -1 if selector.value == 1 else 1\n",
    "\n",
    "# stop\n",
    "status.value = 0\n",
    "time.sleep(0.2)\n",
    "sc.join()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x8703850>]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "ds = np.loadtxt('test_sound_log.csv', delimiter=',', skiprows=1)\n",
    "plt.plot(np.diff(ds[:, 0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sounddevice playground"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(24,\n",
       "  {'name': 'MOTU Audio ASIO',\n",
       "   'hostapi': 2,\n",
       "   'max_input_channels': 14,\n",
       "   'max_output_channels': 14,\n",
       "   'default_low_input_latency': 0.005804988662131519,\n",
       "   'default_low_output_latency': 0.005804988662131519,\n",
       "   'default_high_input_latency': 0.005804988662131519,\n",
       "   'default_high_output_latency': 0.005804988662131519,\n",
       "   'default_samplerate': 44100.0})]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sounddevice as sd\n",
    "[(i, x) for i, x in enumerate(sd.query_devices()) if x['name'].find('ASIO') > 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sounddevice as sd\n",
    "import numpy as np\n",
    "#import keyboard  # using module keyboard\n",
    "\n",
    "sd.default.device = [1, 24]\n",
    "sd.default.samplerate = 44100\n",
    "stream = sd.OutputStream(samplerate=44100, channels=14, dtype='float32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3rd channel - left arena speaker\n",
    "# 1st channel - right arena speaker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "duration = 2.5\n",
    "\n",
    "x1 = np.linspace(0, duration * 220 * 2*np.pi, int(duration*44100), dtype=np.float32)\n",
    "x2 = np.linspace(0, duration * 440 * 2*np.pi, int(duration*44100), dtype=np.float32)\n",
    "y1 = np.sin(x1)\n",
    "y2 = np.sin(x2)\n",
    "sil = np.zeros(len(x1), dtype=np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "stream.start()\n",
    "stream.write(np.column_stack([sil, sil, sil, sil, sil, sil, sil, sil, sil, y1, sil, sil, sil, sil]) * 0.8)\n",
    "stream.stop()\n",
    "\n",
    "# [None, None, 1, 2, 3, 4, 5, 6, 7, 8, None, None, None, None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "stream.start()\n",
    "\n",
    "try:\n",
    "    while True:  # making a loop\n",
    "        if keyboard.is_pressed('q'):  # if key 'q' is pressed \n",
    "            break  # finishing the loop\n",
    "\n",
    "        stream.write(np.column_stack([y1, sil, sil, sil, sil, sil, sil, sil, sil, sil]) * 0.8)\n",
    "        #stream.write(np.column_stack([y2, y2, y2, y2, y2, y2, y2, y2, y2, y2]) * 0.8)\n",
    "    \n",
    "finally:\n",
    "    stream.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Permanent sound in a separate audio stream"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sounddevice as sd\n",
    "import numpy as np\n",
    "import os\n",
    "import threading\n",
    "from scipy.io import wavfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "   0 Microsoft Sound Mapper - Input, MME (2 in, 0 out)\n",
       ">  1 MOTU S/PDIF (MOTU Audio Wave fo, MME (2 in, 0 out)\n",
       "   2 MOTU Reverb (MOTU Audio Wave fo, MME (2 in, 0 out)\n",
       "   3 MOTU UNUSED (MOTU Audio Wave fo, MME (2 in, 0 out)\n",
       "   4 MOTU Analog (MOTU Audio Wave fo, MME (2 in, 0 out)\n",
       "   5 MOTU Return (MOTU Audio Wave fo, MME (2 in, 0 out)\n",
       "   6 Microsoft Sound Mapper - Output, MME (0 in, 2 out)\n",
       "   7 Speakers (High Definition Audio, MME (0 in, 2 out)\n",
       "   8 MOTU S/PDIF (MOTU Audio Wave fo, MME (0 in, 2 out)\n",
       "   9 MOTU Main Out (MOTU Audio Wave , MME (0 in, 2 out)\n",
       "  10 MOTU Phones (MOTU Audio Wave fo, MME (0 in, 2 out)\n",
       "  11 MOTU Analog (MOTU Audio Wave fo, MME (0 in, 2 out)\n",
       "  12 Primary Sound Capture Driver, Windows DirectSound (2 in, 0 out)\n",
       "  13 MOTU S/PDIF (MOTU Audio Wave for 64 bit), Windows DirectSound (2 in, 0 out)\n",
       "  14 MOTU Reverb (MOTU Audio Wave for 64 bit), Windows DirectSound (2 in, 0 out)\n",
       "  15 MOTU UNUSED (MOTU Audio Wave for 64 bit), Windows DirectSound (2 in, 0 out)\n",
       "  16 MOTU Analog (MOTU Audio Wave for 64 bit), Windows DirectSound (2 in, 0 out)\n",
       "  17 MOTU Return (MOTU Audio Wave for 64 bit), Windows DirectSound (2 in, 0 out)\n",
       "  18 Primary Sound Driver, Windows DirectSound (0 in, 2 out)\n",
       "  19 Speakers (High Definition Audio Device), Windows DirectSound (0 in, 2 out)\n",
       "  20 MOTU S/PDIF (MOTU Audio Wave for 64 bit), Windows DirectSound (0 in, 2 out)\n",
       "  21 MOTU Main Out (MOTU Audio Wave for 64 bit), Windows DirectSound (0 in, 2 out)\n",
       "  22 MOTU Phones (MOTU Audio Wave for 64 bit), Windows DirectSound (0 in, 2 out)\n",
       "  23 MOTU Analog (MOTU Audio Wave for 64 bit), Windows DirectSound (0 in, 2 out)\n",
       "< 24 MOTU Audio ASIO, ASIO (14 in, 14 out)\n",
       "  25 MOTU S/PDIF (MOTU Audio Wave for 64 bit), Windows WASAPI (0 in, 2 out)\n",
       "  26 MOTU Main Out (MOTU Audio Wave for 64 bit), Windows WASAPI (0 in, 2 out)\n",
       "  27 MOTU Phones (MOTU Audio Wave for 64 bit), Windows WASAPI (0 in, 2 out)\n",
       "  28 MOTU Analog (MOTU Audio Wave for 64 bit), Windows WASAPI (0 in, 8 out)\n",
       "  29 Speakers (High Definition Audio Device), Windows WASAPI (0 in, 2 out)\n",
       "  30 MOTU Reverb (MOTU Audio Wave for 64 bit), Windows WASAPI (2 in, 0 out)\n",
       "  31 MOTU UNUSED (MOTU Audio Wave for 64 bit), Windows WASAPI (2 in, 0 out)\n",
       "  32 , Windows WASAPI (0 in, 0 out)\n",
       "  33 MOTU S/PDIF (MOTU Audio Wave for 64 bit), Windows WASAPI (2 in, 0 out)\n",
       "  34 MOTU Return (MOTU Audio Wave for 64 bit), Windows WASAPI (2 in, 0 out)\n",
       "  35 MOTU Analog (MOTU Analog), Windows WDM-KS (0 in, 8 out)\n",
       "  36 MOTU Phones (MOTU Phones), Windows WDM-KS (0 in, 2 out)\n",
       "  37 MOTU Analog (MOTU Analog), Windows WDM-KS (8 in, 0 out)\n",
       "  38 MOTU S/PDIF (MOTU S/PDIF), Windows WDM-KS (2 in, 0 out)\n",
       "  39 MOTU S/PDIF (MOTU S/PDIF), Windows WDM-KS (0 in, 2 out)\n",
       "  40 MOTU Main Out (MOTU Main Out), Windows WDM-KS (0 in, 2 out)\n",
       "  41 MOTU Return (MOTU Return), Windows WDM-KS (2 in, 0 out)\n",
       "  42 MOTU Reverb (MOTU Reverb), Windows WDM-KS (2 in, 0 out)\n",
       "  43 MOTU UNUSED (MOTU UNUSED), Windows WDM-KS (2 in, 0 out)\n",
       "  44 Speakers (HD Audio Speaker), Windows WDM-KS (0 in, 2 out)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sd.query_devices()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48000 (2880512, 2) int16\n"
     ]
    }
   ],
   "source": [
    "wav_fname = os.path.join('..', 'assets', 'stream1.wav')\n",
    "samplerate, data = wavfile.read(wav_fname)\n",
    "\n",
    "print(samplerate, data.shape, data.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "playing\n",
      "playing\n",
      "playing\n",
      "playing\n",
      "playing\n"
     ]
    }
   ],
   "source": [
    "stream = sd.OutputStream(samplerate=samplerate, channels=2, dtype=data.dtype)\n",
    "\n",
    "stream.start()\n",
    "\n",
    "for i in range(5):\n",
    "    stream.write(data[50000:100000])\n",
    "    print('playing')\n",
    "    \n",
    "stream.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Continuous sound stream started at 48000 Hz\n"
     ]
    }
   ],
   "source": [
    "cfg = ContinuousSoundStream.default_cfg\n",
    "\n",
    "cst = ContinuousSoundStream(cfg)\n",
    "cst.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Camera released\n"
     ]
    }
   ],
   "source": [
    "cst.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}