Merge pull request #2362 from hmeine/master

Clean up ProgressBar class in example notebook

docs/examples/notebooks/Animations_and_Progress.ipynb

@@ -1,275 +1,259 b''
 {
  "metadata": {
   "name": "Animations_and_Progress"
  },
  "nbformat": 3,
  "nbformat_minor": 0,
  "worksheets": [
   {
    "cells": [
     {
      "cell_type": "heading",
      "level": 1,
      "metadata": {},
      "source": [
       "Simple animations, progress bars, and clearing output"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "Sometimes you want to print progress in-place, but don't want\n",
       "to keep growing the output area.  In terminals, there is the carriage-return\n",
       "(`'\\r'`) for overwriting a single line, but the notebook frontend does not support this\n",
       "behavior (yet).\n",
       "\n",
       "What the notebook *does* support is explicit `clear_output`, and you can use this to replace previous\n",
       "output (specifying stdout/stderr or the special IPython display outputs)."
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "A simple example printing our progress iterating through a list:"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": true,
      "input": [
       "import sys\n",
       "import time"
      ],
      "language": "python",
      "metadata": {},
      "outputs": []
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "from IPython.display import clear_output\n",
       "for i in range(10):\n",
       "    time.sleep(0.25)\n",
       "    clear_output()\n",
       "    print i\n",
       "    sys.stdout.flush()"
      ],
      "language": "python",
      "metadata": {},
      "outputs": []
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "The AsyncResult object has a special `wait_interactive()` method, which prints its progress interactively,\n",
       "so you can watch as your parallel computation completes.\n",
       "\n",
       "**This example assumes you have an IPython cluster running, which you can start from the [cluster panel](/#tab2)**"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "from IPython import parallel\n",
       "rc = parallel.Client()\n",
       "view = rc.load_balanced_view()\n",
       "\n",
       "amr = view.map_async(time.sleep, [0.5]*100)\n",
       "\n",
       "amr.wait_interactive()"
      ],
      "language": "python",
      "metadata": {},
      "outputs": []
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "You can also use `clear_output()` to clear figures and plots.\n",
       "\n",
       "This time, we need to make sure we are using inline pylab (**requires matplotlib**)"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "%pylab inline"
      ],
      "language": "python",
      "metadata": {},
      "outputs": []
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "from scipy.special import jn\n",
       "x = np.linspace(0,5)\n",
       "f, ax = plt.subplots()\n",
       "ax.set_title(\"Bessel functions\")\n",
       "\n",
       "for n in range(1,10):\n",
       "    time.sleep(1)\n",
       "    ax.plot(x, jn(x,n))\n",
       "    clear_output()\n",
       "    display(f)\n",
       "\n",
       "# close the figure at the end, so we don't get a duplicate\n",
       "# of the last plot\n",
       "plt.close()"
      ],
      "language": "python",
      "metadata": {},
      "outputs": []
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
       "A Javascript Progress Bar"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "`clear_output()` is still something of a hack, and if you want to do a progress bar in the notebook\n",
       "it is better to just use Javascript/HTML if you can.\n",
       "\n",
       "Here is a simple progress bar using HTML/Javascript:"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "import uuid\n",
       "from IPython.display import HTML, Javascript, display\n",
       "\n",
       "divid = str(uuid.uuid4())\n",
       "\n",
       "pb = HTML(\n",
       "\"\"\"\n",
       "<div style=\"border: 1px solid black; width:500px\">\n",
       "  <div id=\"%s\" style=\"background-color:blue; width:0%%\">&nbsp;</div>\n",
       "</div> \n",
       "\"\"\" % divid)\n",
       "display(pb)\n",
       "for i in range(1,101):\n",
       "    time.sleep(0.1)\n",
       "    \n",
       "    display(Javascript(\"$('div#%s').width('%i%%')\" % (divid, i)))"
      ],
      "language": "python",
      "metadata": {},
      "outputs": []
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "The above simply makes a div that is a box, and a blue div inside it with a unique ID \n",
       "(so that the javascript won't collide with other similar progress bars on the same page).  \n",
       "\n",
       "Then, at every progress point, we run a simple jQuery call to resize the blue box to\n",
       "the appropriate fraction of the width of its containing box, and voil\u00e0 a nice\n",
       "HTML/Javascript progress bar!"
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
       "ProgressBar class"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "And finally, here is a progress bar *class* extracted from [PyMC](http://code.google.com/p/pymc/), which will work in regular Python as well as in the IPython Notebook"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": true,
      "input": [
       "import sys, time\n",
-      "try:\n",
-      "    from IPython.display import clear_output\n",
-      "    have_ipython = True\n",
-      "except ImportError:\n",
-      "    have_ipython = False\n",
       "\n",
       "class ProgressBar:\n",
       "    def __init__(self, iterations):\n",
       "        self.iterations = iterations\n",
       "        self.prog_bar = '[]'\n",
       "        self.fill_char = '*'\n",
-      "        self.width = 40\n",
+      "        self.width = 50\n",
       "        self.__update_amount(0)\n",
-      "        if have_ipython:\n",
-      "            self.animate = self.animate_ipython\n",
-      "        else:\n",
-      "            self.animate = self.animate_noipython\n",
       "\n",
-      "    def animate_ipython(self, iter):\n",
+      "    def animate(self, iter):\n",
       "        print '\\r', self,\n",
       "        sys.stdout.flush()\n",
       "        self.update_iteration(iter + 1)\n",
       "\n",
       "    def update_iteration(self, elapsed_iter):\n",
       "        self.__update_amount((elapsed_iter / float(self.iterations)) * 100.0)\n",
       "        self.prog_bar += '  %d of %s complete' % (elapsed_iter, self.iterations)\n",
       "\n",
       "    def __update_amount(self, new_amount):\n",
       "        percent_done = int(round((new_amount / 100.0) * 100.0))\n",
       "        all_full = self.width - 2\n",
       "        num_hashes = int(round((percent_done / 100.0) * all_full))\n",
       "        self.prog_bar = '[' + self.fill_char * num_hashes + ' ' * (all_full - num_hashes) + ']'\n",
       "        pct_place = (len(self.prog_bar) // 2) - len(str(percent_done))\n",
       "        pct_string = '%d%%' % percent_done\n",
       "        self.prog_bar = self.prog_bar[0:pct_place] + \\\n",
       "            (pct_string + self.prog_bar[pct_place + len(pct_string):])\n",
       "\n",
       "    def __str__(self):\n",
       "        return str(self.prog_bar)"
      ],
      "language": "python",
      "metadata": {},
      "outputs": []
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "p = ProgressBar(1000)\n",
       "for i in range(1001):\n",
+      "    time.sleep(0.002)\n",
       "    p.animate(i)"
      ],
      "language": "python",
      "metadata": {},
      "outputs": []
-    },
-    {
-     "cell_type": "code",
-     "collapsed": false,
-     "input": [],
-     "language": "python",
-     "metadata": {},
-     "outputs": []
     }
    ],
    "metadata": {}
   }
  ]
 }
  No newline at end of file