02_routing_outputs_to_a_specific_cell.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Routing outputs to a specific cell\n",
    "\n",
    "\n",
    "## About this notebook\n",
    "\n",
    "This notebook belongs to a series of small projects which aim is to evaluate the [Jupyter](http://jupyter.org/) ecosystem for science experiments control. The main idea is to use the _Juypter notebook_ as a convergence platform in order to offer a fully featured environment to scientists. \n",
    "\n",
    "## Update\n",
    "[There's now a way to set an id for a display](http://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html#IPython.display.display) - this id can be used for updating this display area later via update_display. However, the proposed implementation - I call it the [@minrk](https://github.com/minrk)'s trick - works fine and seems to still make sense. \n",
    "\n",
    "\n",
    "## Topic of the day\n",
    "\n",
    "When working in the notebook, we might have some asynchronous activities running in several cells. We could, for instance, have a couple of live plots updated regularly in their associated cell. In such a case, we certainly want any output generated by a given asynchronous process to be routed to the cell to which it's attached. However, so far, the notebook routes the outputs to the _current cell_ - i.e. to the one in which we are currently working. It means that any output produce from the python backend - e.g. messages or even some widgets - will drop into the _current cell_. That could be quite annoying. \n",
    "\n",
    "## The problem we want to address\n",
    "The problem is simple: we want to be able to select the cell in which our outputs are rendered/printed/...\n",
    "\n",
    "By default, any 'new' output becomes part of the 'current' cell. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"this our 'target-cell'...\")\n",
    "print(\"... and this first message is an 'output' of 'target-cell'\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"we are now in another cell...\")\n",
    "print(\"... but we would like this message to also be a 'target-cell' output - how could we do that?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a solution based on [this expert trick](https://nbviewer.jupyter.org/gist/minrk/049545c1edcf20415bb3d68f16047628). A **big thanks** to [@minrk](https://github.com/minrk) for sharing his expertise. \n",
    "\n",
    "## CellContext class\n",
    "A simple cell context holder (i.e. holds info related to the 'target-cell')."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "from contextlib import contextmanager\n",
    "from IPython import get_ipython\n",
    "\n",
    "class CellContext(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        k = get_ipython().kernel\n",
    "        self._ident = k._parent_ident\n",
    "        self._header = k._parent_header\n",
    "    \n",
    "    def __call__(self):\n",
    "        return (self._ident, self._header)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cell_context [python contextmanager]\n",
    "A python context manager allowing to execute some user code in the context of a specific (or target) cell.\n",
    "\n",
    "This `contextmanager` saves the current context, switches to the specified one, call `yield` to execute the user's then restore the initial context. It also flushes the standard streams in order to properly route `print` outputs. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@contextmanager\n",
    "def cell_context(context):\n",
    "    try:\n",
    "        assert(isinstance(context, CellContext))\n",
    "        kernel = get_ipython().kernel\n",
    "        save_context = (kernel._parent_ident, kernel._parent_header)\n",
    "        sys.stdout.flush()\n",
    "        sys.stderr.flush()\n",
    "        kernel.set_parent(*context())\n",
    "    except Exception as e:\n",
    "        print(e)\n",
    "        return\n",
    "    try:\n",
    "        yield\n",
    "    except:\n",
    "        raise\n",
    "    finally:\n",
    "        sys.stdout.flush()\n",
    "        sys.stderr.flush()\n",
    "        kernel.set_parent(*save_context)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NotebookCellContent class\n",
    "This is supposed to become the super class of any object which outputs must be routed to a particular cell.\n",
    "It notably provides cell specific API for `IPython.display` and `IPython.clear_output`. It also exposes a subset of  `logging.Logger` interface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import logging\n",
    "from IPython.display import display, clear_output\n",
    "    \n",
    "class NotebookCellContent(object):\n",
    "\n",
    "    def __init__(self):\n",
    "        self._context = CellContext()\n",
    "        self._logger = logging.getLogger('jupyter.for.controls')\n",
    "        try:\n",
    "            # no default handler workaround \n",
    "            h = self._logger.handlers[0]\n",
    "        except IndexError:\n",
    "            logging.basicConfig(format=\"[%(asctime)-15s] %(name)s: %(message)s\", level=logging.ERROR)\n",
    "\n",
    "    @property\n",
    "    def context(self):\n",
    "        return self._context\n",
    "\n",
    "    def display(self, widgets_layout):\n",
    "        with cell_context(self._context):\n",
    "            display(widgets_layout)\n",
    "       \n",
    "    def clear_output(self):\n",
    "        with cell_context(self._context):\n",
    "            clear_output()\n",
    "\n",
    "    @property\n",
    "    def logger(self):\n",
    "        return self._logger\n",
    "\n",
    "    def set_logging_level(self, level):\n",
    "        self._logger.setLevel(level)\n",
    "\n",
    "    def verbose(self, *args):\n",
    "        with cell_context(self._context):\n",
    "            print(*args)\n",
    "            \n",
    "    def debug(self, msg, *args, **kwargs):\n",
    "        with cell_context(self._context):\n",
    "            self._logger.debug(msg, *args, **kwargs)\n",
    "\n",
    "    def info(self, msg, *args, **kwargs):\n",
    "        with cell_context(self._context):\n",
    "            self._logger.info(msg, *args, **kwargs)\n",
    "\n",
    "    def warning(self, msg, *args, **kwargs):\n",
    "        with cell_context(self._context):\n",
    "            self._logger.warning(msg, *args, **kwargs)\n",
    "\n",
    "    def error(self, msg, *args, **kwargs):\n",
    "        with cell_context(self._context):\n",
    "            self._logger.error(msg, *args, **kwargs)\n",
    "\n",
    "    def critical(self, msg, *args, **kwargs):\n",
    "        with cell_context(self._context):\n",
    "            self._logger.critical(msg, *args, **kwargs)\n",
    "\n",
    "    def exception(self, msg, *args, **kwargs):\n",
    "        with cell_context(self._context):\n",
    "            self._logger.exception(msg, *args, **kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's play with a NotebookCellContent instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ncc = NotebookCellContent()\n",
    "ncc.set_logging_level(logging.DEBUG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ncc.verbose(\"this simple print goes to 'ncc' cell\")\n",
    "ncc.debug(\"this debug message goes to 'ncc' cell\")\n",
    "print('this text goes to current cell')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  An ipywigets example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ncc = NotebookCellContent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ipywidgets as ipw\n",
    "\n",
    "def say_hello_to_the_world(attr):\n",
    "    ncc.verbose('bonjour le monde!, hola el mundo!')\n",
    "\n",
    "b = ipw.Button(description='Hello World!')\n",
    "b.on_click(say_hello_to_the_world)\n",
    "\n",
    "display(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we now want 'b' to also be displayed in 'ncc' cell\n",
    "ncc.display(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "It seems we now know how to route any output to a specific cell. Hope this help...\n",
    "\n",
    "Thanks again to @minrk."
   ]
  }
 ],
 "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}