python-sonic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# python-sonic - Programming Music with Python, Sonic Pi or Supercollider"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python-Sonic is a simple Python interface for Sonic Pi, which is a real great music software created by Sam Aaron (http://sonic-pi.net). \n",
    "\n",
    "At the moment Python-Sonic works with Sonic Pi. It is planned, that it will work with Supercollider, too.\n",
    "\n",
    "If you like it, use it. If you have some suggestions, tell me (gkvoelkl@nelson-games.de)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* First you need Python 3 (https://www.python.org, ) - Python 3.5 should work, because it's the development environment\n",
    "* Then Sonic Pi (https://sonic-pi.net) - That makes the sound\n",
    "* Modul python-osc (https://pypi.python.org/pypi/python-osc) - Connection between Python and Sonic Pi Server\n",
    "* And this modul python-sonic - simply copy the source\n",
    "\n",
    "Or try"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "$ pip install python-sonic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That should work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Limitations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* You have to start _Sonic Pi_ first before you can use it with python-sonic\n",
    "* Only the notes from C2 to C6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changelog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Version       |                                                                                          |\n",
    "|--------------|------------------------------------------------------------------------------------------|\n",
    "|  0.2.0       | Some changes for Sonic Pi 2.11. Simpler multi-threading with decorator *@in_thread*. Messaging with *cue* and *sync*. |\n",
    "|  0.3.0       | OSC Communication | "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many of the examples are inspired from the help menu in *Sonic Pi*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first sound"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play(70) #play MIDI note 70"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some more notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play(72)\n",
    "sleep(1)\n",
    "play(75)\n",
    "sleep(1)\n",
    "play(79) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In more tratitional music notation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play(C5)\n",
    "sleep(0.5)\n",
    "play(D5)\n",
    "sleep(0.5)\n",
    "play(G5) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play sharp notes like *F#* or dimished ones like *Eb*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play(Fs5)\n",
    "sleep(0.5)\n",
    "play(Eb5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play louder (parameter amp) or from a different direction (parameter pan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play(72,amp=2)\n",
    "sleep(0.5)\n",
    "play(74,pan=-1) #left"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different synthesizer sounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "use_synth(SAW)\n",
    "play(38)\n",
    "sleep(0.25)\n",
    "play(50)\n",
    "sleep(0.5)\n",
    "use_synth(PROPHET)\n",
    "play(57)\n",
    "sleep(0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ADSR *(Attack, Decay, Sustain and Release)* Envelope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play (60, attack=0.5, decay=1, sustain_level=0.4, sustain=2, release=0.5) \n",
    "sleep(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play some samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(AMBI_LUNAR_LAND, amp=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(LOOP_AMEN,pan=-1)\n",
    "sleep(0.877)\n",
    "sample(LOOP_AMEN,pan=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(LOOP_AMEN,rate=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(LOOP_AMEN,rate=1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(LOOP_AMEN,rate=-1)#back"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(DRUM_CYMBAL_OPEN,attack=0.01,sustain=0.3,release=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(LOOP_AMEN,start=0.5,finish=0.8,rate=-0.2,attack=0.3,release=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play some random notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "for i in range(5):\n",
    "    play(random.randrange(50, 100))\n",
    "    sleep(0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    play(random.choice([C5,E5,G5]))\n",
    "    sleep(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sample slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "\n",
    "number_of_pieces = 8\n",
    "\n",
    "for i in range(16):\n",
    "    s = random.randrange(0,number_of_pieces)/number_of_pieces #sample starts at 0.0 and finishes at 1.0\n",
    "    f = s + (1.0/number_of_pieces)\n",
    "    sample(LOOP_AMEN,beat_stretch=2,start=s,finish=f)\n",
    "    sleep(2.0/number_of_pieces)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An infinite loop and if"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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-18-d8759ac2d27e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      5\u001b[0m   \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[0msample\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mDRUM_CYMBAL_CLOSED\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m     \u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0.25\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m/mnt/jupyter/python-sonic/psonic.py\u001b[0m in \u001b[0;36msleep\u001b[1;34m(duration)\u001b[0m\n\u001b[0;32m    587\u001b[0m     \u001b[1;33m:\u001b[0m\u001b[1;32mreturn\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    588\u001b[0m     \"\"\"\n\u001b[1;32m--> 589\u001b[1;33m     \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mduration\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    590\u001b[0m     \u001b[0m_debug\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'sleep'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mduration\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    591\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "while True:\n",
    "  if one_in(2):\n",
    "    sample(DRUM_HEAVY_KICK)\n",
    "    sleep(0.5)\n",
    "  else:\n",
    "    sample(DRUM_CYMBAL_CLOSED)\n",
    "    sleep(0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to hear more than one sound at a time, use Threads."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "from psonic import *\n",
    "from threading import Thread\n",
    "\n",
    "def bass_sound():\n",
    "    c = chord(E3, MAJOR7)\n",
    "    while True:\n",
    "        use_synth(PROPHET)\n",
    "        play(random.choice(c), release=0.6)\n",
    "        sleep(0.5)\n",
    "\n",
    "def snare_sound():\n",
    "    while True:\n",
    "        sample(ELEC_SNARE)\n",
    "        sleep(1)\n",
    "\n",
    "bass_thread = Thread(target=bass_sound)\n",
    "snare_thread = Thread(target=snare_sound)\n",
    "\n",
    "bass_thread.start()\n",
    "snare_thread.start()\n",
    "\n",
    "while True:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every function *bass_sound* and *snare_sound* have its own thread. Your can hear them running."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Press Enter to continue...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from psonic import *\n",
    "from threading import Thread, Condition\n",
    "from random import choice\n",
    "\n",
    "def random_riff(condition):\n",
    "    use_synth(PROPHET)\n",
    "    sc = scale(E3, MINOR)\n",
    "    while True:\n",
    "        s = random.choice([0.125,0.25,0.5])\n",
    "        with condition:\n",
    "            condition.wait() #Wait for message\n",
    "        for i in range(8):\n",
    "            r = random.choice([0.125, 0.25, 1, 2])\n",
    "            n = random.choice(sc)\n",
    "            co = random.randint(30,100)\n",
    "            play(n, release = r, cutoff = co)\n",
    "            sleep(s)\n",
    "\n",
    "def drums(condition):\n",
    "    while True:\n",
    "        with condition:\n",
    "            condition.notifyAll() #Message to threads\n",
    "        for i in range(16):\n",
    "            r = random.randrange(1,10)\n",
    "            sample(DRUM_BASS_HARD, rate=r)\n",
    "            sleep(0.125)\n",
    "\n",
    "condition = Condition()\n",
    "random_riff_thread = Thread(name='consumer1', target=random_riff, args=(condition,))\n",
    "drums_thread = Thread(name='producer', target=drums, args=(condition,))\n",
    "\n",
    "random_riff_thread.start()\n",
    "drums_thread.start()\n",
    "\n",
    "input(\"Press Enter to continue...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To synchronize the thread, so that they play a note at the same time, you can use *Condition*. One function sends a message with *condition.notifyAll* the other waits until the message comes *condition.wait*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More simple with decorator __@in_thread__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Press Enter to continue...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from psonic import *\n",
    "from random import choice\n",
    "\n",
    "tick = Message()\n",
    "\n",
    "@in_thread\n",
    "def random_riff():\n",
    "    use_synth(PROPHET)\n",
    "    sc = scale(E3, MINOR)\n",
    "    while True:\n",
    "        s = random.choice([0.125,0.25,0.5])\n",
    "        tick.sync()\n",
    "        for i in range(8):\n",
    "            r = random.choice([0.125, 0.25, 1, 2])\n",
    "            n = random.choice(sc)\n",
    "            co = random.randint(30,100)\n",
    "            play(n, release = r, cutoff = co)\n",
    "            sleep(s)\n",
    "            \n",
    "@in_thread\n",
    "def drums():\n",
    "    while True:\n",
    "        tick.cue()\n",
    "        for i in range(16):\n",
    "            r = random.randrange(1,10)\n",
    "            sample(DRUM_BASS_HARD, rate=r)\n",
    "            sleep(0.125)\n",
    "\n",
    "random_riff()\n",
    "drums()\n",
    "\n",
    "input(\"Press Enter to continue...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "\n",
    "tick = Message()\n",
    "\n",
    "@in_thread\n",
    "def metronom():\n",
    "    while True:\n",
    "        tick.cue()\n",
    "        sleep(1)\n",
    "        \n",
    "@in_thread\n",
    "def instrument():\n",
    "    while True:\n",
    "        tick.sync()\n",
    "        sample(DRUM_HEAVY_KICK)\n",
    "\n",
    "metronom()\n",
    "instrument()\n",
    "\n",
    "while True:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play a list of notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "\n",
    "play ([64, 67, 71], amp = 0.3) \n",
    "sleep(1)\n",
    "play ([E4, G4, B4])\n",
    "sleep(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play chords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play(chord(E4, MINOR)) \n",
    "sleep(1)\n",
    "play(chord(E4, MAJOR))\n",
    "sleep(1)\n",
    "play(chord(E4, MINOR7))\n",
    "sleep(1)\n",
    "play(chord(E4, DOM7))\n",
    "sleep(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play arpeggios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play_pattern( chord(E4, 'm7')) \n",
    "play_pattern_timed( chord(E4, 'm7'), 0.25) \n",
    "play_pattern_timed(chord(E4, 'dim'), [0.25, 0.5]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play scales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play_pattern_timed(scale(C3, MAJOR), 0.125, release = 0.1) \n",
    "play_pattern_timed(scale(C3, MAJOR, num_octaves = 2), 0.125, release = 0.1) \n",
    "play_pattern_timed(scale(C3, MAJOR_PENTATONIC, num_octaves = 2), 0.125, release = 0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function *scale* returns a list with all notes of a scale. So you can use list methodes or functions. For example to play arpeggios descending or shuffeld."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[48, 50, 52, 53, 55, 57, 59, 60]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "from psonic import *\n",
    "\n",
    "s = scale(C3, MAJOR)\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s.reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "play_pattern_timed(s, 0.125, release = 0.1)\n",
    "random.shuffle(s)\n",
    "play_pattern_timed(s, 0.125, release = 0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Live Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the best in SONIC PI is the _Live Loop_. While a loop is playing music you can change it and hear the change. Let's try it in Python, too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Press Enter to continue...Y\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Y'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from psonic import *\n",
    "from threading import Thread\n",
    "\n",
    "def my_loop():\n",
    "  play(60)\n",
    "  sleep(1)\n",
    "\n",
    "def looper():\n",
    "  while True:\n",
    "    my_loop()\n",
    "\n",
    "looper_thread = Thread(name='looper', target=looper)\n",
    "\n",
    "looper_thread.start()\n",
    "\n",
    "input(\"Press Enter to continue...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now change the function *my_loop* und you can hear it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def my_loop():\n",
    "  use_synth(TB303)\n",
    "  play (60, release= 0.3)\n",
    "  sleep (0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def my_loop():\n",
    "  use_synth(TB303)\n",
    "  play (chord(E3, MINOR), release= 0.3)\n",
    "  sleep(0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def my_loop():\n",
    "    use_synth(TB303)\n",
    "    sample(DRUM_BASS_HARD, rate = random.uniform(0.5, 2))\n",
    "    play(random.choice(chord(E3, MINOR)), release= 0.2, cutoff=random.randrange(60, 130))\n",
    "    sleep(0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To stop the sound you have to end the kernel. In IPython with Kernel --> Restart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now with two live loops which are synch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Press Enter to continue...y\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from psonic import *\n",
    "from threading import Thread, Condition\n",
    "from random import choice\n",
    "\n",
    "def loop_foo():\n",
    "  play (E4, release = 0.5)\n",
    "  sleep (0.5)\n",
    "\n",
    "\n",
    "def loop_bar():\n",
    "  sample (DRUM_SNARE_SOFT)\n",
    "  sleep (1)\n",
    "    \n",
    "\n",
    "def live_loop_1(condition):\n",
    "    while True:\n",
    "        with condition:\n",
    "            condition.notifyAll() #Message to threads\n",
    "        loop_foo()\n",
    "            \n",
    "def live_loop_2(condition):\n",
    "    while True:\n",
    "        with condition:\n",
    "            condition.wait() #Wait for message\n",
    "        loop_bar()\n",
    "\n",
    "condition = Condition()\n",
    "live_thread_1 = Thread(name='producer', target=live_loop_1, args=(condition,))\n",
    "live_thread_2 = Thread(name='consumer1', target=live_loop_2, args=(condition,))\n",
    "\n",
    "live_thread_1.start()\n",
    "live_thread_2.start()\n",
    "\n",
    "input(\"Press Enter to continue...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def loop_foo():\n",
    "  play (A4, release = 0.5)\n",
    "  sleep (0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def loop_bar():\n",
    "  sample (DRUM_HEAVY_KICK)\n",
    "  sleep (0.125)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If would be nice if we can stop the loop with a simple command. With stop event it works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Press Enter to continue...y\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from psonic import *\n",
    "from threading import Thread, Condition, Event\n",
    "\n",
    "def loop_foo():\n",
    "  play (E4, release = 0.5)\n",
    "  sleep (0.5)\n",
    "\n",
    "\n",
    "def loop_bar():\n",
    "  sample (DRUM_SNARE_SOFT)\n",
    "  sleep (1)\n",
    "    \n",
    "\n",
    "def live_loop_1(condition,stop_event):\n",
    "    while not stop_event.is_set():\n",
    "        with condition:\n",
    "            condition.notifyAll() #Message to threads\n",
    "        loop_foo()\n",
    "            \n",
    "def live_loop_2(condition,stop_event):\n",
    "    while not stop_event.is_set():\n",
    "        with condition:\n",
    "            condition.wait() #Wait for message\n",
    "        loop_bar()\n",
    "\n",
    "\n",
    "\n",
    "condition = Condition()\n",
    "stop_event = Event()\n",
    "live_thread_1 = Thread(name='producer', target=live_loop_1, args=(condition,stop_event))\n",
    "live_thread_2 = Thread(name='consumer1', target=live_loop_2, args=(condition,stop_event))\n",
    "\n",
    "\n",
    "live_thread_1.start()\n",
    "live_thread_2.start()\n",
    "\n",
    "input(\"Press Enter to continue...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "stop_event.set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "More complex live loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sc = Ring(scale(E3, MINOR_PENTATONIC))\n",
    "\n",
    "def loop_foo():\n",
    "  play (next(sc), release= 0.1)\n",
    "  sleep (0.125)\n",
    "\n",
    "sc2 = Ring(scale(E3,MINOR_PENTATONIC,num_octaves=2))\n",
    "           \n",
    "def loop_bar():\n",
    "  use_synth(DSAW)\n",
    "  play (next(sc2), release= 0.25)\n",
    "  sleep (0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now a simple structure with four live loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Press Enter to continue...y\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "from psonic import *\n",
    "from threading import Thread, Condition, Event\n",
    "\n",
    "def live_1():\n",
    "    pass\n",
    "\n",
    "def live_2():\n",
    "    pass\n",
    "    \n",
    "def live_3():\n",
    "    pass\n",
    "\n",
    "def live_4():\n",
    "    pass\n",
    "\n",
    "def live_loop_1(condition,stop_event):\n",
    "    while not stop_event.is_set():\n",
    "        with condition:\n",
    "            condition.notifyAll() #Message to threads\n",
    "        live_1()\n",
    "            \n",
    "def live_loop_2(condition,stop_event):\n",
    "    while not stop_event.is_set():\n",
    "        with condition:\n",
    "            condition.wait() #Wait for message\n",
    "        live_2()\n",
    "\n",
    "def live_loop_3(condition,stop_event):\n",
    "    while not stop_event.is_set():\n",
    "        with condition:\n",
    "            condition.wait() #Wait for message\n",
    "        live_3()\n",
    "\n",
    "def live_loop_4(condition,stop_event):\n",
    "    while not stop_event.is_set():\n",
    "        with condition:\n",
    "            condition.wait() #Wait for message\n",
    "        live_4()\n",
    "        \n",
    "condition = Condition()\n",
    "stop_event = Event()\n",
    "live_thread_1 = Thread(name='producer', target=live_loop_1, args=(condition,stop_event))\n",
    "live_thread_2 = Thread(name='consumer1', target=live_loop_2, args=(condition,stop_event))\n",
    "live_thread_3 = Thread(name='consumer2', target=live_loop_3, args=(condition,stop_event))\n",
    "live_thread_4 = Thread(name='consumer3', target=live_loop_3, args=(condition,stop_event))\n",
    "\n",
    "live_thread_1.start()\n",
    "live_thread_2.start()\n",
    "live_thread_3.start()\n",
    "live_thread_4.start()\n",
    "\n",
    "input(\"Press Enter to continue...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After starting the loops you can change them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def live_1():\n",
    "    sample(BD_HAUS,amp=2)\n",
    "    sleep(0.5)\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def live_2():\n",
    "    #sample(AMBI_CHOIR, rate=0.4)\n",
    "    #sleep(1)\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def live_3():\n",
    "    use_synth(TB303)\n",
    "    play(E2, release=4,cutoff=120,cutoff_attack=1)\n",
    "    sleep(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def live_4():\n",
    "    notes = scale(E3, MINOR_PENTATONIC, num_octaves=2)\n",
    "    for i in range(8):\n",
    "        play(random.choice(notes),release=0.1,amp=1.5)\n",
    "        sleep(0.125)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And stop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "stop_event.set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Sound"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "\n",
    "synth(SINE, note=D4)\n",
    "synth(SQUARE, note=D4)\n",
    "synth(TRI, note=D4, amp=0.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "detune = 0.7\n",
    "synth(SQUARE, note = E4)\n",
    "synth(SQUARE, note = E4+detune)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "detune=0.1 # Amplitude shaping\n",
    "synth(SQUARE, note = E2, release = 2)\n",
    "synth(SQUARE, note = E2+detune, amp =  2, release = 2)\n",
    "synth(GNOISE, release = 2, amp = 1, cutoff = 60)\n",
    "synth(GNOISE, release = 0.5, amp = 1, cutoff = 100)\n",
    "synth(NOISE, release = 0.2, amp = 1, cutoff = 90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Next Step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using FX *Not implemented yet*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "\n",
    "with Fx(SLICER):\n",
    "    synth(PROPHET,note=E2,release=8,cutoff=80)\n",
    "    synth(PROPHET,note=E2+4,release=8,cutoff=80)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with Fx(SLICER, phase=0.125, probability=0.6,prob_pos=1):\n",
    "    synth(TB303, note=E2, cutoff_attack=8, release=8)\n",
    "    synth(TB303, note=E3, cutoff_attack=4, release=8)\n",
    "    synth(TB303, note=E4, cutoff_attack=2, release=8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OSC Communication (Sonic Pi Ver. 3.x or better)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Sonic Pi version 3 or better you can work with messages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First you need a programm in the Sonic Pi server that receives messages. You can write it in th GUI or send one with Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "run(\"\"\"live_loop :foo do\n",
    "  use_real_time\n",
    "  a, b, c = sync \"/osc/trigger/prophet\"\n",
    "  synth :prophet, note: a, cutoff: b, sustain: c\n",
    "end \"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now send a message to Sonic Pi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "send_message('/trigger/prophet', 70, 100, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Inspired by Steve Reich Clapping Music\n",
    "\n",
    "clapping = [1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0]\n",
    "\n",
    "for i in range(13):\n",
    "    for j in range(4):\n",
    "        for k in range(12): \n",
    "          if clapping[k] ==1 : sample(DRUM_SNARE_SOFT,pan=-0.5)\n",
    "          if clapping[(i+k)%12] == 1: sample(DRUM_HEAVY_KICK,pan=0.5)\n",
    "          sleep (0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Projects that use Python-Sonic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Raspberry Pi sonic-track.py a Sonic-pi Motion Track Demo https://github.com/pageauc/sonic-track"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Sources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Joe Armstrong: Connecting Erlang to the Sonic Pi http://joearms.github.io/2015/01/05/Connecting-Erlang-to-Sonic-Pi.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Joe Armstrong: Controlling Sound with OSC Messages http://joearms.github.io/2016/01/29/Controlling-Sound-with-OSC-Messages.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}