Queue Minimum Priority.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initializeExported({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy\n",
    "import copy\n",
    "import scipy.stats as st\n",
    "import math\n",
    "from bqplot import LinearScale, OrdinalColorScale, ColorAxis, Axis, Lines, Figure\n",
    "\n",
    "from ipywidgets import HBox, VBox, SelectionSlider, ToggleButton, jslink, jsdlink, Layout, IntText"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".MathJax {float:left !important;}\n",
       ".js-plot-link-container { display:none !important; }\n",
       "</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initializeExported({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<style>\n",
    ".MathJax {float:left !important;}\n",
    ".js-plot-link-container { display:none !important; }\n",
    "</style>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initializeExported({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initializeExported({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initializeExported({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initialize({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initialize({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy\n",
    "import copy\n",
    "\n",
    "from bqplot import LinearScale, Axis, Figure\n",
    "from ipywidgets import HBox, VBox, SelectionSlider, ToggleButton, jslink, Layout, Label\n",
    "from IPython.display import HTML\n",
    "from inspect import isclass\n",
    "\n",
    "import ipywidgets.embed\n",
    "\n",
    "class bqExportablePlot(object):\n",
    "    hidden = Layout(visibility='hidden')\n",
    "    \n",
    "    initScript = '''\n",
    "    <script>\n",
    "        /* globals Jupyter:false */\n",
    "        var bqExportable = {};\n",
    "\n",
    "        // \"click\" the phantom buttons to make one particular line visible, and turn the\n",
    "        // rest invisible.\n",
    "        bqExportable.toggleTaggedPlots = function (name, outputRoot) {\n",
    "            var readouts = outputRoot.querySelectorAll('.widget-slider > .widget-readout');\n",
    "\n",
    "            var tagParts = [name];\n",
    "            for (var i=0; i<readouts.length; i++) {\n",
    "                tagParts.push(readouts[i].textContent);\n",
    "            }\n",
    "\n",
    "            var tag = tagParts.join('/');\n",
    "            var buttons = outputRoot.querySelectorAll('.widget-toggle-button');\n",
    "\n",
    "            for (var j=0; j<buttons.length; j++) {\n",
    "                if (buttons[j].textContent == tag) {\n",
    "                    if (buttons[j].className.indexOf('mod-active') == -1) {\n",
    "                        buttons[j].click();\n",
    "                    }\n",
    "                }\n",
    "                else if (buttons[j].className.indexOf('mod-active') > -1) {\n",
    "                    buttons[j].click();\n",
    "                }\n",
    "            }\n",
    "        };\n",
    "        \n",
    "        // find the output root node via the name of a plot\n",
    "        bqExportable.getRootNode = function (name) {\n",
    "            var referenceText = name + '/Reference';\n",
    "            var labels = document.querySelectorAll('.widget-label');\n",
    "            for (var i=0; i<labels.length; i++) {\n",
    "                if (labels[i].textContent == referenceText) {\n",
    "                    return bqExportable.findOutputRoot(labels[i]);\n",
    "                }\n",
    "            }\n",
    "\n",
    "            return null;\n",
    "        };\n",
    "        \n",
    "        // move up the DOM tree, from a widget, to find the root of the\n",
    "        // output area\n",
    "        bqExportable.findOutputRoot = function (target) {\n",
    "            var el = target;\n",
    "            while (el !== null) {\n",
    "                if (el.className.indexOf('widget-subarea') > -1) {\n",
    "                    return el;\n",
    "                }\n",
    "\n",
    "                if (el.className.indexOf('output_subarea') > -1) {\n",
    "                    return el;\n",
    "                }\n",
    "\n",
    "                el = el.parentElement;\n",
    "            }\n",
    "\n",
    "            return null;\n",
    "        };\n",
    "\n",
    "        bqExportable.collector = function (info) {\n",
    "            var totalReadouts = 0;\n",
    "            var matchedReadouts = {};\n",
    "\n",
    "            for (var name in info) {\n",
    "                if (info.hasOwnProperty(name)) {\n",
    "                    totalReadouts += info[name];\n",
    "                    matchedReadouts[name] = [];\n",
    "                }\n",
    "            }\n",
    "\n",
    "            var $self = {\n",
    "                'info': info,\n",
    "                'foundReadouts': [],\n",
    "                'foundRoots': {},\n",
    "                'matchedReadouts': matchedReadouts,\n",
    "                'totalReadouts': totalReadouts\n",
    "            };\n",
    "\n",
    "            // we're finished collecting nodes when we've found all the reference nodes\n",
    "            // *and* have found all needed readouts.\n",
    "            $self.checkFinish = function () {\n",
    "                if ($self.foundReadouts.length != $self.totalReadouts) {\n",
    "                    return false;\n",
    "                }\n",
    "\n",
    "                if (Object.keys($self.foundRoots).length != Object.keys($self.info).length) {\n",
    "                    return false;\n",
    "                }\n",
    "\n",
    "                return true;\n",
    "            };\n",
    "\n",
    "            // mark a node for collection if it is a slider readout or a reference\n",
    "            $self.checkNode = function (m) {\n",
    "                if (typeof(m.className) == 'undefined')  {\n",
    "                    return;\n",
    "                }\n",
    "\n",
    "                if (typeof(m.className) != 'string')  {\n",
    "                    return;\n",
    "                }\n",
    "\n",
    "                if (m.className.indexOf('widget-slider') > -1) {\n",
    "                    // believe it or not, we can't use a query selector here,\n",
    "                    // I guess because the observer sees the mutation before\n",
    "                    // the node is actually fully connected to the DOM or\n",
    "                    // something?\n",
    "                    var readout = m.children[2];\n",
    "                    $self.foundReadouts.push(readout);\n",
    "                    return;\n",
    "                }\n",
    "\n",
    "                if (m.className.indexOf('widget-toggle-button') > -1) {\n",
    "                    if (m.textContent.indexOf(name + '/') === 0) {\n",
    "                        $self.foundRoots[name] = bqExportable.findOutputRoot(m);\n",
    "                    }\n",
    "                }\n",
    "            };\n",
    "            \n",
    "            // match readouts to a plot name\n",
    "            $self.allocateReadouts = function () {\n",
    "                for (var i=0; i<$self.foundReadouts.length; i++) {\n",
    "                    var readout = $self.foundReadouts[i];\n",
    "                    var outputRoot = bqExportable.findOutputRoot(readout);\n",
    "\n",
    "                    for (var name in $self.foundRoots) {\n",
    "                        if ($self.foundRoots.hasOwnProperty(name)) {\n",
    "                            if (outputRoot == $self.foundRoots[name]) {\n",
    "                                $self.matchedReadouts[name].push(readout);\n",
    "                            }\n",
    "                        }\n",
    "                    }\n",
    "                }\n",
    "            };\n",
    "\n",
    "            $self.installHooks = function () {\n",
    "                for (var name in $self.matchedReadouts) {\n",
    "                    if ($self.matchedReadouts.hasOwnProperty(name)) {\n",
    "                        $self.initializeSliders(name);\n",
    "                    }\n",
    "                }\n",
    "            };\n",
    "\n",
    "            $self.initializeSliders = function (name) {\n",
    "                var outputRoot = $self.foundRoots[name];\n",
    "                var readouts = $self.matchedReadouts[name];\n",
    "\n",
    "                for (var i=0; i<readouts.length; i++) {\n",
    "                    $self.linkSlider(name, readouts[i], outputRoot);\n",
    "                }\n",
    "            };\n",
    "\n",
    "            $self.linkSlider = function (name, readout, outputRoot) {\n",
    "                readout.addEventListener('DOMSubtreeModified', function (e) {\n",
    "                    bqExportable.toggleTaggedPlots(name, outputRoot);\n",
    "                });\n",
    "            };\n",
    "\n",
    "            return $self;\n",
    "        };\n",
    "\n",
    "        // jupyter loads widgets in an embedded html through an amd via require.js,\n",
    "        // which has no easy event to hook into that tells us when our plot stuff\n",
    "        // is loaded. SO, we've gotta create an observer on the dom and tally up\n",
    "        // all the nodes we're interested in, after which we can finally hook our\n",
    "        // readout-watchers up\n",
    "        bqExportable.initializeExported = function (info) {\n",
    "            var collector = new bqExportable.collector(info);\n",
    "\n",
    "            var observer;\n",
    "            observer = new MutationObserver(function (mutations) {\n",
    "                for (var i=0; i<mutations.length; i++) {\n",
    "                    for (var j=0; j<mutations[i].addedNodes.length; j++) {\n",
    "                        collector.checkNode(mutations[i].addedNodes[j]);\n",
    "\n",
    "                        if (collector.checkFinish() === true) {\n",
    "                            observer.disconnect();\n",
    "                            collector.allocateReadouts();\n",
    "                            collector.installHooks();\n",
    "                            return;\n",
    "                        }\n",
    "                    }\n",
    "                }\n",
    "            });\n",
    "\n",
    "            observer.observe(\n",
    "                document.getElementsByTagName('body')[0],\n",
    "                { childList: true, subtree: true });\n",
    "        };\n",
    "        \n",
    "        // if the jupyter notebook is live, widgets will be rendered\n",
    "        // before our observer javascript is ever run, for some reason.\n",
    "        // so we do it manually.\n",
    "        bqExportable.initializeLive = function (info) {\n",
    "            var name = Object.keys(info)[0];\n",
    "            var collector = new bqExportable.collector({});\n",
    "            collector.foundRoots[name] = bqExportable.getRootNode(name);\n",
    "            collector.matchedReadouts[name] =\n",
    "                collector.foundRoots[name]\n",
    "                    .querySelectorAll('.widget-slider > .widget-readout');\n",
    "            \n",
    "            collector.installHooks();\n",
    "        };\n",
    "        \n",
    "        bqExportable.initialize = function (info) {\n",
    "            if (Jupyter) {\n",
    "                bqExportable.initializeLive(info);\n",
    "            }\n",
    "            else {\n",
    "                bqExportable.initializeExported(info);\n",
    "            }\n",
    "        };\n",
    "    </script>\n",
    "    '''\n",
    "    \n",
    "    if 'bqExportableUtil' not in ipywidgets.embed.snippet_template:\n",
    "        ipywidgets.embed.snippet_template += initScript\n",
    "    \n",
    "    initLink = \"<script>bqExportable.initialize({'%name%': %count%});</script>\"\n",
    "    \n",
    "    def __init__(self):\n",
    "        members = [getattr(self, s) for s in dir(self) if isclass(getattr(self, s))]\n",
    "        slider_classes = [s for s in members if issubclass(s, bqExportableSlider)]\n",
    "        figure_classes = [f for f in members if issubclass(f, bqExportableFigure)]\n",
    "\n",
    "        self.sliders = []\n",
    "        for slider in slider_classes:\n",
    "            sliderInstance = slider()\n",
    "            self.sliders.append(sliderInstance)\n",
    "            \n",
    "        self.combos = [c for c in self.gen_combinations(0, [])]\n",
    "        \n",
    "        self.defaultValue = None\n",
    "        for combo in self.combos:\n",
    "            if self.check_default(combo):\n",
    "                self.defaultValue = combo\n",
    "                break\n",
    "\n",
    "        self.export = False\n",
    "        self.figures = []\n",
    "        \n",
    "        for figure in figure_classes:\n",
    "            figureInstance = figure(self.defaultValue, self.combos)\n",
    "            self.figures.append(figureInstance)        \n",
    "            self.export = self.export or figure.export\n",
    "\n",
    "        # if our plot is to be exported, we'll make a new Mark for each slider\n",
    "        # permutation and then jslink its visibility to a hidden toggle button.\n",
    "        # each permutation being its own plot ensures that \"embed widget\" will\n",
    "        # convert them all, and we can contol the toggles by external scripting.\n",
    "        \n",
    "        if self.export:\n",
    "            self.buttons = []\n",
    "            className = self.__class__.__name__\n",
    "            for b, combo in enumerate(self.combos):\n",
    "                tag = className + '/' + '/'.join([str(x) for x in combo])\n",
    "                visibility = self.check_default(combo)\n",
    "\n",
    "                button = ToggleButton(\n",
    "                    value=visibility,\n",
    "                    description=tag,\n",
    "                    layout=self.hidden\n",
    "                )\n",
    "                self.buttons.append(button)\n",
    "\n",
    "                for figure in self.figures:\n",
    "                    figure.link_toggler(button, b)\n",
    "\n",
    "            # the reference label will be used by the javascript to find the\n",
    "            # output root via a plot name\n",
    "            self.referenceLabel = Label(\n",
    "                value='%s/Reference' % className,\n",
    "                layout=self.hidden)\n",
    "            \n",
    "        else:\n",
    "            for slider in self.sliders:\n",
    "                slider.observe(self.update_plot, names='value')\n",
    "\n",
    "    def update_plot(self, change):\n",
    "        slider_values = [slider.value for slider in self.sliders]\n",
    "        for figure in self.figures:\n",
    "            figure.update_plot(slider_values)\n",
    "\n",
    "    def check_default(self, combo):\n",
    "        for i,item in enumerate(combo):\n",
    "            if self.sliders[i].defaultValue != item:\n",
    "                return False\n",
    "        return True\n",
    "\n",
    "    # slickly generate all combinations of slider inputs via generators\n",
    "    # (and then gather them all into a list anyways so that we can normalize it XD)\n",
    "    def gen_combinations(self, i, current_list):\n",
    "        l = len(self.sliders)\n",
    "        \n",
    "        for val in self.sliders[i].options:\n",
    "            if (i+1) == l:\n",
    "                copy_list = copy.copy(current_list)\n",
    "                copy_list.append(val)\n",
    "                yield copy_list\n",
    "\n",
    "            else:\n",
    "                current_list.append(val)\n",
    "                yield from self.gen_combinations(i+1, current_list)\n",
    "                current_list.pop()\n",
    "\n",
    "    def display(self):\n",
    "        widgets_to_display = [\n",
    "            self.display_sliders(),\n",
    "            self.display_figures(),\n",
    "        ]\n",
    "        \n",
    "        if self.export:\n",
    "            display(HTML(self.initScript))\n",
    "            widgets_to_display = widgets_to_display \\\n",
    "                               + [HBox([*self.buttons])] \\\n",
    "                               + [self.referenceLabel]\n",
    "        \n",
    "        display(VBox([*widgets_to_display]))\n",
    "\n",
    "        if self.export:\n",
    "            ip = get_ipython()\n",
    "            ip.events.register('post_run_cell', self.run_js)\n",
    "\n",
    "    def display_sliders(self):\n",
    "        return HBox([slider.slider for slider in self.sliders])\n",
    "\n",
    "    def display_figures(self):\n",
    "        return HBox([figure.figure for figure in self.figures])\n",
    "        \n",
    "    def run_js(self):\n",
    "        run_code = self.initLink \\\n",
    "                       .replace('%name%', self.__class__.__name__) \\\n",
    "                       .replace('%count%', str(len(self.sliders)))\n",
    "        display(HTML(run_code))\n",
    "        \n",
    "class bqExportableSlider(object):\n",
    "    options = []\n",
    "    defaultValue = None\n",
    "    description = ''\n",
    "\n",
    "    def __init__(self):\n",
    "        self.slider = SelectionSlider(\n",
    "            options=self.options,\n",
    "            value=self.defaultValue,\n",
    "            description=self.description\n",
    "        )\n",
    "        \n",
    "    @property\n",
    "    def value(self):\n",
    "        return self.slider.value\n",
    "        \n",
    "    def observe(self, callback, **kwargs):\n",
    "        self.slider.observe(callback, **kwargs)\n",
    "    \n",
    "class bqExportableFigure(object):\n",
    "    export = True\n",
    "    \n",
    "    xscale_options = {}\n",
    "    yscale_options = {}\n",
    "    \n",
    "    xaxis_options = {}\n",
    "    yaxis_options = {'orientation': 'vertical'}\n",
    "\n",
    "    mark_class = None\n",
    "    mark_options = {'colors': ['Gray']}\n",
    "\n",
    "    title = ''\n",
    "    figure_options = {}\n",
    "\n",
    "    xdata = []\n",
    "    ydata = []\n",
    "    normalize_ydata = False\n",
    "\n",
    "    def ygen(self, *args):\n",
    "        pass\n",
    "\n",
    "    def __init__(self, defaultValue, combos):\n",
    "        self.defaultValue = defaultValue\n",
    "        self.combos = combos\n",
    "        self.gen_ydata(combos)\n",
    "\n",
    "        self.marks = []\n",
    "        self.xscale = LinearScale(**self.xscale_options)\n",
    "        self.yscale = LinearScale(**self.yscale_options)\n",
    "        self.xaxis = Axis(scale=self.xscale, **self.xaxis_options)\n",
    "        self.yaxis = Axis(scale=self.yscale, **self.yaxis_options)\n",
    "\n",
    "        for yset in self.ydata:\n",
    "            mark = self.mark_class(\n",
    "                x=self.xdata, y=yset,\n",
    "                scales={'x': self.xscale, 'y': self.yscale},\n",
    "                visible=not(self.export), **self.mark_options)\n",
    "            self.marks.append(mark)\n",
    "    \n",
    "        if self.title != '':\n",
    "            self.figure_options['title'] = self.title\n",
    "\n",
    "        self.figure = Figure(\n",
    "            marks=self.marks, axes=[self.xaxis, self.yaxis],\n",
    "            **self.figure_options)\n",
    "        \n",
    "    def gen_ydata(self, combos):\n",
    "        if not self.export:\n",
    "            self.ydata = [self.ygen(*self.defaultValue)]\n",
    "            return\n",
    "        \n",
    "        self.ydata = []\n",
    "\n",
    "        max_val = -1\n",
    "        for combo in combos:\n",
    "            yset = self.ygen(*combo)\n",
    "            self.ydata.append(yset)\n",
    "            max_val = max(max(yset), max_val)\n",
    "\n",
    "        # when the plot is live, an unconstrainted y-scale will auto-adjust to new\n",
    "        # data when mark.y is assigned to it. however, the scales for an exported\n",
    "        # plot will remain fixed, unfortunately. hence, an option to normalize.\n",
    "        if self.normalize_ydata:\n",
    "            for y,yset in enumerate(self.ydata):\n",
    "                factor = max_val / max(yset)\n",
    "                normed = factor * numpy.array(yset)\n",
    "                self.ydata[y] = normed\n",
    "\n",
    "    def link_toggler(self, button, index):\n",
    "        jslink((button, 'value'), (self.marks[index], 'visible'))\n",
    "\n",
    "    def update_plot(self, slider_values):\n",
    "        self.ydata = [self.ygen(*slider_values)]\n",
    "        self.marks[0].y = self.ydata[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <script>\n",
       "        var bqExportable = {};\n",
       "\n",
       "        bqExportable.toggleTaggedPlots = function (name, outputRoot) {\n",
       "            var readouts = outputRoot.querySelectorAll('.widget-slider > .widget-readout');\n",
       "\n",
       "            var tagParts = [name];\n",
       "            for (var i=0; i<readouts.length; i++) {\n",
       "                tagParts.push(readouts[i].textContent);\n",
       "            }\n",
       "\n",
       "            var tag = tagParts.join('/');\n",
       "            var buttons = outputRoot.querySelectorAll('.widget-toggle-button');\n",
       "\n",
       "            for (var j=0; j<buttons.length; j++) {\n",
       "                if (buttons[j].textContent == tag) {\n",
       "                    if (buttons[j].className.indexOf('mod-active') == -1) {\n",
       "                        buttons[j].click();\n",
       "                    }\n",
       "                }\n",
       "                else if (buttons[j].className.indexOf('mod-active') > -1) {\n",
       "                    buttons[j].click();\n",
       "                }\n",
       "            }\n",
       "        };\n",
       "        \n",
       "        bqExportable.getRootNode = function (name) {\n",
       "            var referenceText = name + '/Reference';\n",
       "            var labels = document.querySelectorAll('.widget-label');\n",
       "            for (var i=0; i<labels.length; i++) {\n",
       "                if (labels[i].textContent == referenceText) {\n",
       "                    return bqExportableUtil.findOutputRoot(labels[i]);\n",
       "                }\n",
       "            }\n",
       "\n",
       "            return null;\n",
       "        };\n",
       "        \n",
       "        bqExportable.findOutputRoot = function (target) {\n",
       "            var el = target;\n",
       "            while (el !== null) {\n",
       "                if (el.className.indexOf('widget-subarea') > -1) {\n",
       "                    return el;\n",
       "                }\n",
       "\n",
       "                if (el.className.indexOf('output_subarea') > -1) {\n",
       "                    return el;\n",
       "                }\n",
       "\n",
       "                el = el.parentElement;\n",
       "            }\n",
       "\n",
       "            return null;\n",
       "        };\n",
       "\n",
       "        bqExportable.collector = function (info) {\n",
       "            var totalReadouts = 0;\n",
       "            var matchedReadouts = {};\n",
       "\n",
       "            for (var name in info) {\n",
       "                if (info.hasOwnProperty(name)) {\n",
       "                    totalReadouts += info[name];\n",
       "                    matchedReadouts[name] = [];\n",
       "                }\n",
       "            }\n",
       "\n",
       "            var $self = {\n",
       "                'info': info,\n",
       "                'foundReadouts': [],\n",
       "                'foundRoots': {},\n",
       "                'matchedReadouts': matchedReadouts,\n",
       "                'totalReadouts': totalReadouts\n",
       "            };\n",
       "\n",
       "            $self.checkFinish = function () {\n",
       "                if ($self.foundReadouts.length != $self.totalReadouts) {\n",
       "                    return false;\n",
       "                }\n",
       "\n",
       "                if (Object.keys($self.foundRoots).length != Object.keys($self.info).length) {\n",
       "                    return false;\n",
       "                }\n",
       "\n",
       "                return true;\n",
       "            };\n",
       "\n",
       "            $self.checkNode = function (m) {\n",
       "                if (typeof(m.className) == 'undefined')  {\n",
       "                    return;\n",
       "                }\n",
       "\n",
       "                if (typeof(m.className) != 'string')  {\n",
       "                    return;\n",
       "                }\n",
       "\n",
       "                if (m.className.indexOf('widget-slider') > -1) {\n",
       "                    // believe it or not, we can't use a query selector here,\n",
       "                    // I guess because the observer sees the mutation before\n",
       "                    // the node is actually fully connected to the DOM or\n",
       "                    // something?\n",
       "                    var readout = m.children[2];\n",
       "                    $self.foundReadouts.push(readout);\n",
       "                    return;\n",
       "                }\n",
       "\n",
       "                if (m.className.indexOf('widget-toggle-button') > -1) {\n",
       "                    if (m.textContent.indexOf(name + '/') == 0) {\n",
       "                        $self.foundRoots[name] = bqExportable.findOutputRoot(m);\n",
       "                    }\n",
       "                }\n",
       "            };\n",
       "            \n",
       "            $self.allocateReadouts = function () {\n",
       "                for (var i=0; i<$self.foundReadouts.length; i++) {\n",
       "                    var readout = $self.foundReadouts[i];\n",
       "                    var outputRoot = bqExportable.findOutputRoot(readout);\n",
       "\n",
       "                    for (var name in $self.foundRoots) {\n",
       "                        if ($self.foundRoots.hasOwnProperty(name)) {\n",
       "                            if (outputRoot == $self.foundRoots[name]) {\n",
       "                                $self.matchedReadouts[name].push(readout);\n",
       "                            }\n",
       "                        }\n",
       "                    }\n",
       "                }\n",
       "            };\n",
       "\n",
       "            $self.installHooks = function () {\n",
       "                for (var name in $self.matchedReadouts) {\n",
       "                    if ($self.matchedReadouts.hasOwnProperty(name)) {\n",
       "                        $self.initializeSliders(name);\n",
       "                    }\n",
       "                }\n",
       "            };\n",
       "\n",
       "            $self.initializeSliders = function (name) {\n",
       "                var outputRoot = $self.foundRoots[name];\n",
       "                var readouts = $self.matchedReadouts[name];\n",
       "\n",
       "                for (var i=0; i<readouts.length; i++) {\n",
       "                    $self.linkSlider(name, readouts[i], outputRoot);\n",
       "                }\n",
       "            };\n",
       "\n",
       "            $self.linkSlider = function (name, readout, outputRoot) {\n",
       "                readout.addEventListener('DOMSubtreeModified', function (e) {\n",
       "                    bqExportable.toggleTaggedPlots(name, outputRoot);\n",
       "                });\n",
       "            };\n",
       "\n",
       "            return $self;\n",
       "        };\n",
       "\n",
       "        bqExportable.initializeExported = function (info) {\n",
       "            var collector = new bqExportable.collector(info);\n",
       "\n",
       "            var observer;\n",
       "            observer = new MutationObserver(function (mutations) {\n",
       "                for (var i=0; i<mutations.length; i++) {\n",
       "                    for (var j=0; j<mutations[i].addedNodes.length; j++) {\n",
       "                        collector.checkNode(mutations[i].addedNodes[j]);\n",
       "\n",
       "                        if (collector.checkFinish() === true) {\n",
       "                            observer.disconnect();\n",
       "                            $self.allocateReadouts();\n",
       "                            collector.installHooks();\n",
       "                            return;\n",
       "                        }\n",
       "                    }\n",
       "                }\n",
       "            });\n",
       "\n",
       "            observer.observe(\n",
       "                document.getElementsByTagName('body')[0],\n",
       "                { childList: true, subtree: true });\n",
       "        };\n",
       "        \n",
       "        bqExportable.initializeLive = function (info) {\n",
       "            var name = Object.keys(info)[0];\n",
       "            var collector = new bqExportable.collector({});\n",
       "            collector.foundRoots[name] = bqExportable.getRootNode(name);\n",
       "            collector.matchedReadouts[name] =\n",
       "                collector.foundRoots[name]\n",
       "                    .querySelectorAll('.widget-slider > .widget-readout');\n",
       "            \n",
       "            collector.installHooks();\n",
       "        };\n",
       "        \n",
       "        bqExportable.initialize = function (info) {\n",
       "            if (Jupyter) {\n",
       "                bqExportable.initializeLive(info);\n",
       "            }\n",
       "            else {\n",
       "                bqExportable.initializeExported(info);\n",
       "            }\n",
       "        };\n",
       "    </script>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "45b2f60c69c5412d8bc4cc94a6d1ebb5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(SelectionSlider(description='Priority Queue Size', index=1, options=(100, 1000, …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initializeExported({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initializeExported({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initializeExported({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initialize({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initialize({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>bqExportable.initialize({'PriorityMin': 2});</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class PriorityMin(bqExportablePlot):\n",
    "    class PriorityQueueSize(bqExportableSlider):\n",
    "        options = [int(x) for x in numpy.logspace(2.0, 4.0, 3)]\n",
    "        defaultValue = options[1]\n",
    "        description = 'Priority Queue Size'\n",
    "\n",
    "    class RequestsPerHarvest(bqExportableSlider):\n",
    "        options = [int(x) for x in numpy.logspace(2.0, 5.0, 3)]\n",
    "        defaultValue = options[1]\n",
    "        description = 'Requests Per Harvest'\n",
    "\n",
    "    class Figure1(bqExportableFigure):\n",
    "        export = True\n",
    "        title = 'PDF of Priority Queue Minimum Priority (normalized)'\n",
    "        normalize_ydata = True\n",
    "\n",
    "        xscale_options = { 'min': 0, 'max': 1 }\n",
    "        yaxis_options = { 'visible': False }\n",
    "        mark_class = Lines\n",
    "        mark_options = { 'colors': ['Gray'] }\n",
    "\n",
    "        num_points = 200\n",
    "        xdata = numpy.linspace(0, 1, num_points)\n",
    "        yz = numpy.zeros(num_points)\n",
    "        yz[0] = 1\n",
    "\n",
    "        def ygen(self, k, n):\n",
    "            if n > k:\n",
    "                return st.beta.pdf(self.xdata, n+1-k, k)\n",
    "            else:\n",
    "                return self.yz\n",
    "\n",
    "mp = PriorityMin()\n",
    "mp.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ipywidgets.embed.snippet_template"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}