Cairo - Canvas and intermediate output - 8.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext cairo_jupyter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install ipdb ipython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAABmJLR0QA/wD/AP+gvaeTAAAA+0lEQVR4nO3cwQ0CIRRFUTAWYidDQfYwFGUB2IlWgi24I8M7J2H/8nPX1GOM2cYoVzFaK+/j+JZaH6u3bOHsfc5SLvPO3meZ87P6bru4rR7AWgIIJ4BwAggngHACCCeAcAIIJ4BwAggngHACCCeAcAIIJ4BwAggngHACCCeAcAIIJ4BwAggngHACCCeAcAIIJ4BwAggngHACCCeAcAIIJ4BwAggngHACCCeAcAIIJ4BwAggngHACCHcfrZXe++odfxutrZ6wlXrRf3dfpdbn6hEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwG5+cAtt3w/mLOsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fin\n"
     ]
    }
   ],
   "source": [
    "import asyncio\n",
    "import enum\n",
    "import re\n",
    "import sys\n",
    "import traceback\n",
    "\n",
    "from aiohttp import web\n",
    "\n",
    "import cairo\n",
    "\n",
    "from contextlib import contextmanager\n",
    "from io import BytesIO\n",
    "from pathlib import Path\n",
    "\n",
    "from IPython.display import display, clear_output\n",
    "\n",
    "FORMAT_PS = 'ps'\n",
    "FORMAT_PDF = 'pdf'\n",
    "FORMAT_PNG = 'png'\n",
    "FORMAT_SVG = 'svg'\n",
    "FORMAT_SVG_XML = 'svg_xml'\n",
    "\n",
    "VALID_FORMATS = [FORMAT_PNG, FORMAT_SVG, FORMAT_SVG_XML]\n",
    "\n",
    "ERROR_UNSUPPORTED_FORMAT = \"Format must be FORMAT_PDF, FORMAT_PNG, FORMAT_PS, FORMAT_SVG or FORMAT_SVG_XML\"\n",
    "\n",
    "\n",
    "\n",
    "class RunObserver:\n",
    "    \"\"\"\n",
    "    RunObserver is an event that lets code wait until the\n",
    "    main loop has executed code.\n",
    "    \n",
    "    Code and execution status can then be retrieved.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        self._event = asyncio.Event()\n",
    "\n",
    "    async def wait_until_after_run(self):\n",
    "        \"\"\"\n",
    "        Wait until after source was ran\n",
    "        \"\"\"\n",
    "        await self._event.wait()\n",
    "    \n",
    "    def source_executed(self, source, success, errors=None):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        self._event.set()\n",
    "\n",
    "    \n",
    "class SourceChanged(RunObserver):\n",
    "    class Status(enum.Enum):\n",
    "        WAITING = 1\n",
    "        NOT_UPDATED = 2\n",
    "        UPDATED_SUCCESSFULLY = 3\n",
    "        UPDATED_BY_ANOTHER = 4\n",
    "\n",
    "    def __init__(self, source):\n",
    "        RunObserver.__init__(self)\n",
    "        \n",
    "        self.success = None\n",
    "        self.errors = None\n",
    "        \n",
    "        self.source = source\n",
    "        self.status = SourceChanged.Status.WAITING\n",
    "        self.updated_by = None\n",
    "\n",
    "    def source_updated(self, updated_by):\n",
    "        \"\"\"\n",
    "        Called when source was updated, by this SourceChanged or\n",
    "        another.\n",
    "        \n",
    "        If the update was from another then stop waiting immediately.\n",
    "        \"\"\"\n",
    "        self.updated_by = updated_by\n",
    "        if updated_by == self:\n",
    "            self.status = SourceChanged.Status.UPDATED_SUCCESSFULLY\n",
    "            # Don't stop waiting here\n",
    "            return True\n",
    "        \n",
    "        if updated_by is None :\n",
    "            self.status = SourceChanged.Status.NOT_UPDATED\n",
    "        elif updated_by != self:\n",
    "            self.status = SourceChanged.Status.UPDATED_BY_ANOTHER\n",
    "        self._event.set()\n",
    "      \n",
    "    def source_executed(self, source, success, errors=None):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        self.source = source\n",
    "        self.success = success\n",
    "        self.errors = errors\n",
    "        self._event.set()\n",
    "\n",
    "      \n",
    "        \n",
    "# Shoebot Grammar        \n",
    "class Grob:\n",
    "    def __init__(self, ctx):\n",
    "        self._ctx = ctx\n",
    "\n",
    "#  nodebox does:\n",
    "#     def draw(self):\n",
    "#         self._ctx.append(self)\n",
    "\n",
    "class ColorMixin:\n",
    "    def __init__(self, fill=None, stroke=None, blendmode=None, **kwargs):\n",
    "        self._fill = fill\n",
    "        self._stroke = stroke\n",
    "        self._blendmode = blendmode\n",
    "\n",
    "# TODO have state internal ?  ColorState, TranslationState etc ?\n",
    "# class PathState(ColorState, TranslationState)\n",
    "# self._state = PathState(....)\n",
    "\n",
    "MOVETO = \"moveto\"\n",
    "RMOVETO = \"rmoveto\"\n",
    "LINETO = \"lineto\"\n",
    "RLINETO = \"rlineto\"\n",
    "CURVETO = \"curveto\"\n",
    "RCURVETO = \"rcurveto\"\n",
    "ARC = \"arc\"\n",
    "ELLIPSE = \"ellipse\"\n",
    "CLOSE = \"close\"\n",
    "\n",
    "\n",
    "class Point:\n",
    "    def __init__(self, *args):\n",
    "        if len(args) == 2:\n",
    "            self.x, self.y = args\n",
    "        elif len(args) == 1:\n",
    "            self.x, self.y = args[0]\n",
    "        elif len(args) == 0:\n",
    "            self.x = self.y = 0.0\n",
    "        else:\n",
    "            raise ValueError(\"Point accepts 0, 1, or 2 arguments.\")\n",
    "\n",
    "\n",
    "class PathElement:\n",
    "    # Taken from Nodebox and extended.\n",
    "\n",
    "    def __init__(self, cmd=None, pts=None):\n",
    "        self.cmd = cmd\n",
    "        if cmd in (MOVETO, RMOVETO):\n",
    "            assert len(pts) == 1\n",
    "            self.x, self.y = pts[0]\n",
    "            self.ctrl1 = Point(pts[0])\n",
    "            self.ctrl2 = Point(pts[0])\n",
    "        elif cmd in (LINETO, RLINETO):\n",
    "            assert len(pts) == 1\n",
    "            self.x, self.y = pts[0]\n",
    "            self.ctrl1 = Point(pts[0])\n",
    "            self.ctrl2 = Point(pts[0])\n",
    "        elif cmd in (CURVETO, RCURVETO):\n",
    "            assert len(pts) == 3\n",
    "            self.ctrl1 = Point(pts[0])\n",
    "            self.ctrl2 = Point(pts[1])\n",
    "            self.x, self.y = pts[2]\n",
    "        elif cmd == CLOSE:\n",
    "            assert pts is None or len(pts) == 0\n",
    "            self.x = self.y = 0.0\n",
    "            self.ctrl1 = Point(0.0, 0.0)\n",
    "            self.ctrl2 = Point(0.0, 0.0)\n",
    "        else:\n",
    "            self.x = self.y = 0.0\n",
    "            self.ctrl1 = Point()\n",
    "            self.ctrl2 = Point()\n",
    "            \n",
    "    def as_cairo(self, ctx):\n",
    "        \"\"\"\n",
    "        Run command corresponding to this PathElement on a cairo Context.\n",
    "        \n",
    "        \"\"\"\n",
    "        if self.cmd == MOVETO:\n",
    "            ctx.move_to(self.x, self.y)\n",
    "        elif self.cmd == RMOVETO:\n",
    "            # actually dx, dy\n",
    "            ctx.rel_move_to(self.x, self.y)\n",
    "        elif self.cmd == LINETO:\n",
    "            ctx.line_to(self.x, self.y)\n",
    "        elif self.cmd == RLINETO:\n",
    "            # actually dx, dy\n",
    "            ctx.rel_line_to(self.x, self.y)\n",
    "        elif self.cmd == CURVETO:\n",
    "            ctx.curve_to(self.x, self.y,\n",
    "                         self.ctrl1.x, self.ctrl1.y,\n",
    "                         self.ctrl2.x, self.ctrl2.y)\n",
    "        elif self.cmd == RCURVETO:\n",
    "            # actually dx, dy\n",
    "            ctx.rel_curve_to(self.x, self.y,\n",
    "                             self.ctrl1.x, self.ctrl1.y,\n",
    "                             self.ctrl2.x, self.ctrl2.y)\n",
    "        elif self.cmd == CLOSE:\n",
    "            ctx.close_path()\n",
    "\n",
    "    def __repr__(self):\n",
    "        if self.cmd == MOVETO:\n",
    "            return \"PathElement(MOVETO, ((%.3f, %.3f),))\" % (self.x, self.y)\n",
    "        elif self.cmd == RMOVETO:\n",
    "            return \"PathElement(RMOVETO, ((%.3f, %.3f),))\" % (self.x, self.y)\n",
    "        elif self.cmd == LINETO:\n",
    "            return \"PathElement(LINETO, ((%.3f, %.3f),))\" % (self.x, self.y)\n",
    "        elif self.cmd == RLINETO:\n",
    "            return \"PathElement(RLINETO, ((%.3f, %.3f),))\" % (self.x, self.y)\n",
    "        elif self.cmd == CURVETO:\n",
    "            return \"PathElement(CURVETO, ((%.3f, %.3f), (%.3f, %s), (%.3f, %.3f))\" % \\\n",
    "                (self.ctrl1.x, self.ctrl1.y, self.ctrl2.x, self.ctrl2.y, self.x, self.y)\n",
    "        elif self.cmd == RCURVETO:\n",
    "            return \"PathElement(RCURVETO, ((%.3f, %.3f), (%.3f, %s), (%.3f, %.3f))\" % \\\n",
    "                (self.ctrl1.x, self.ctrl1.y, self.ctrl2.x, self.ctrl2.y, self.x, self.y)\n",
    "        elif self.cmd == CLOSE:\n",
    "            return \"PathElement(CLOSE)\"\n",
    "            \n",
    "    def __eq__(self, other):\n",
    "        if other is None:\n",
    "            return False\n",
    "        if self.cmd != other.cmd:\n",
    "            return False\n",
    "        return self.x == other.x and self.y == other.y \\\n",
    "            and self.ctrl1 == other.ctrl1 and self.ctrl2 == other.ctrl2\n",
    "        \n",
    "    def __ne__(self, other):\n",
    "        return not self.__eq__(other)\n",
    "\n",
    "\n",
    "class Path(Grob, ColorMixin):\n",
    "    def __init__(self, ctx, **kwargs):\n",
    "        Grob.__init__(self, ctx)\n",
    "        ColorMixin.__init__(self, ctx._fill, ctx._stroke)\n",
    "        self._elements = []\n",
    "        self.closed = False\n",
    "        \n",
    "    def append(self, element):\n",
    "        self._elements.append(element)\n",
    "        return self\n",
    "    \n",
    "    def moveto(self, x, y):\n",
    "        self.append(PathElement(MOVETO, ((x, y),)))\n",
    "\n",
    "    def lineto(self, x, y):\n",
    "        self.append(PathElement(LINETO, ((x, y),)))\n",
    "\n",
    "    def curveto(self, x1, y1, x2, y2, x3, y3):\n",
    "        self.append(\n",
    "            PathElement(CURVETO, (x1, y1), (x2, y2), (x3, y3))\n",
    "        )\n",
    "\n",
    "    def closepath(self):\n",
    "        if self._elements:\n",
    "            element = self._elements[0]\n",
    "            self.append(PathElement(CLOSE))\n",
    "            self.closed = True\n",
    "\n",
    "#     def ellipse(self, x, y, w, h, ellipsemode=CORNER):\n",
    "#         # convert values if ellipsemode is not CORNER\n",
    "#         if ellipsemode == CENTER:\n",
    "#             x = x - (w / 2)\n",
    "#             y = y - (h / 2)\n",
    "#         elif ellipsemode == CORNERS:\n",
    "#             w = w - x\n",
    "#             h = h - y\n",
    "#         self._append_element(\n",
    "#             self._canvas.ellipse_closure(x, y, w, h), (ELLIPSE, x, y, w, h)\n",
    "#         )\n",
    "#         self.closed = True\n",
    "\n",
    "    def rellineto(self, x, y):\n",
    "        self.append(PathElement(RLINETO, ((x, y),),))\n",
    "\n",
    "    # High level API\n",
    "    def line(self, x1, y1, x2, y2):\n",
    "        self.moveto(x1, y1)\n",
    "        self.lineto(x2, y2)\n",
    "\n",
    "    def rect(self, x, y, w, h, roundness=0.0): #, rectmode=CORNER):\n",
    "        # TODO - cornermode.\n",
    "        # convert values if rectmode is not CORNER\n",
    "        #         if rectmode == CENTER:\n",
    "        #             x = x - (w / 2.)\n",
    "        #             y = y - (h / 2.)\n",
    "        #         elif rectmode == CORNERS:\n",
    "        #             w = w - x\n",
    "        #             h = h - y\n",
    "        if not roundness:\n",
    "            self.moveto(x, y)\n",
    "            self.rellineto(w, 0)\n",
    "            self.rellineto(0, h)\n",
    "            self.rellineto(-w, 0)\n",
    "            self.closepath()\n",
    "        else:\n",
    "            # rounded rect.\n",
    "            curve = min(w * roundness, h * roundness)\n",
    "            self.moveto(x, y + curve)\n",
    "            self.curveto(x, y, x, y, x + curve, y)\n",
    "            self.lineto(x + w - curve, y)\n",
    "            self.curveto(x + w, y, x + w, y, x + w, y + curve)\n",
    "            self.lineto(x + w, y + h - curve)\n",
    "            self.curveto(x + w, y + h, x + w, y + h, x + w - curve, y + h)\n",
    "            self.lineto(x + curve, y + h)\n",
    "            self.curveto(x, y + h, x, y + h, x, y + h - curve)\n",
    "            self.closepath()\n",
    "    \n",
    "    def draw(self):\n",
    "        self._ctx._canvas.drawpath(self,\n",
    "                                   self._fill,\n",
    "                                   self._stroke)\n",
    "        return self\n",
    "\n",
    "    def as_cairo(self, ctx):\n",
    "        \"\"\"\n",
    "        Run path commands on a cairo Context.\n",
    "        \"\"\"\n",
    "        for element in self._elements:\n",
    "            element.as_cairo(ctx)\n",
    "        return self\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"<Path {self._elements}>\"\n",
    "\n",
    "_Path = Path\n",
    "\n",
    "class Canvas:\n",
    "    \"\"\"\n",
    "    Uses a RecordingSurface to keep track of the draw state on the current frame/page,\n",
    "    and allowing it to be copied to various outputs as needed.\n",
    "    \"\"\"\n",
    "    def __init__(self, extents=None):\n",
    "        \"\"\"\n",
    "        :param dimensions: Extents of recording surface, or None for unbounded.\n",
    "        \"\"\"\n",
    "        self.surface = cairo.RecordingSurface(cairo.CONTENT_COLOR_ALPHA, extents)\n",
    "        self.position = (0, 0)\n",
    "    \n",
    "    def drawpath(self, path, fill, stroke):\n",
    "        ctx = cairo.Context(self.surface)\n",
    "        path.as_cairo(ctx)\n",
    "        \n",
    "        strokewidth = 1.0  # TODO\n",
    "        \n",
    "        if fill is not None and stroke is not None:\n",
    "            if stroke[3] < 1:\n",
    "                # Draw fill onto intermediate surface so stroke does not overlay fill\n",
    "                ctx.push_group()\n",
    "\n",
    "                ctx.set_source_rgba(*fill)\n",
    "                ctx.fill_preserve()\n",
    "\n",
    "                ctx.set_source_rgba(*stroke)\n",
    "                ctx.set_operator(cairo.OPERATOR_SOURCE)\n",
    "                ctx.set_line_width(strokewidth)\n",
    "                ctx.stroke()\n",
    "\n",
    "                ctx.pop_group_to_source()\n",
    "                ctx.paint()\n",
    "            else:\n",
    "                # Fast path if no alpha in stroke\n",
    "                ctx.set_source_rgba(*fill)\n",
    "                ctx.fill_preserve()\n",
    "\n",
    "                ctx.set_source_rgba(*stroke)\n",
    "                ctx.set_line_width(strokewidth)\n",
    "                ctx.stroke()\n",
    "        elif fill is not None:\n",
    "            ctx.set_source_rgba(*fill)\n",
    "            ctx.fill()\n",
    "        elif stroke is not None:\n",
    "            ctx.set_source_rgba(*stroke)\n",
    "            ctx.set_line_width(strokewidth)\n",
    "            ctx.stroke()\n",
    "        del ctx\n",
    "    \n",
    "    def copy_to_surface(self, surface):\n",
    "        \"\"\"\n",
    "        Draw canvas onto to a cairo surface.\n",
    "        \"\"\"\n",
    "        ctx = cairo.Context(surface)\n",
    "        ctx.set_source_surface(self.surface)\n",
    "        ctx.paint()\n",
    "        del ctx\n",
    "\n",
    "    def save(self, f, format=None, *args, **kwargs):\n",
    "        \"\"\"\n",
    "        Output current canvas frame, using cairo to save.\n",
    "        \n",
    "        :param f: buffer or filename.\n",
    "        \"\"\"\n",
    "        if not format:\n",
    "            if isinstance(f, str):\n",
    "                suffix = Path(f).suffix\n",
    "                format = suffix.rsplit('.')[-1] or FORMAT_PNG\n",
    "            else:\n",
    "                format = FORMAT_PNG\n",
    "        \n",
    "        extents = self.surface.ink_extents()  # TODO: handle ink_extents that don't start at 0, 0\n",
    "        dimensions = extents[2], extents[3]\n",
    "        if format == FORMAT_PNG:\n",
    "            # PNG is special: write_to_png is called after drawing.\n",
    "            surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, int(dimensions[0]), int(dimensions[1]))\n",
    "            self.copy_to_surface(surface)\n",
    "            surface.write_to_png(f)\n",
    "            return\n",
    "        elif format == FORMAT_PDF:\n",
    "            surface = cairo.PDFSurface(f, *dimensions)\n",
    "        elif format == FORMAT_PS:\n",
    "            surface = cairo.PDFSurface(f, *dimensions)\n",
    "        elif format in (FORMAT_SVG, FORMAT_SVG_XML):\n",
    "            surface = cairo.SVGSurface(f, *dimensions)\n",
    "        else:\n",
    "            raise ValueError(ERROR_UNSUPPORTED_FORMAT)\n",
    "            \n",
    "        self.copy_to_surface(surface)\n",
    "        surface.flush()  # Ensure data written to file or buffer.\n",
    "\n",
    "    def display(self, format=None, *args, **kwargs):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        from IPython.display import Image, SVG, display as _display\n",
    "\n",
    "        if format in (FORMAT_PDF, FORMAT_PS):\n",
    "            raise NotImplementedError(f\"{format} is not yet supported.\")\n",
    "        \n",
    "        if format is None:\n",
    "            if not args and self.surface.ink_extents() == (.0, .0, .0, .0):\n",
    "                format = FORMAT_SVG  # 0 size images are legal in SVG.\n",
    "            else:\n",
    "                format = FORMAT_PNG\n",
    "        \n",
    "        with BytesIO() as buffer:\n",
    "            self.save(buffer, format, *args)\n",
    "            if format == FORMAT_PNG:\n",
    "                _display(Image(data=buffer.getvalue()))\n",
    "            elif format == FORMAT_SVG:\n",
    "                _display(SVG(buffer.getvalue()))\n",
    "            elif format == FORMAT_SVG_XML:\n",
    "                try:\n",
    "                    from display_xml import XML\n",
    "                except ImportError:\n",
    "                    raise ImportError('Install display_xml to output as XML:  $ pip3 install display_xml')\n",
    "\n",
    "                _display(XML(buffer.getvalue()))\n",
    "            else:\n",
    "                # Included for completeness, should have been caught by the call to save().\n",
    "                raise ValueError(ERROR_UNSUPPORTED_FORMAT)\n",
    "    \n",
    "    @contextmanager\n",
    "    def recording_surface(self, extents=None):\n",
    "        \"\"\"\n",
    "        While context is active, drawing is directed to a RecordingSurface,\n",
    "        if no exceptions occur, then the content is painted onto the canvases\n",
    "        original surface.\n",
    "        \"\"\"\n",
    "        _surface = self.surface\n",
    "        self.surface = surface = cairo.RecordingSurface(cairo.CONTENT_COLOR_ALPHA, extents)\n",
    "        try:\n",
    "            yield surface\n",
    "        except:\n",
    "            raise\n",
    "        finally:\n",
    "            self.surface = _surface\n",
    "        \n",
    "        # No exceptions were raised, draw\n",
    "        cr = cairo.Context(_surface)\n",
    "        cr.set_source_surface(surface)\n",
    "        cr.paint()\n",
    "\n",
    "\n",
    "class Variable:\n",
    "    pass\n",
    "\n",
    "class IntegerVariable(Variable):\n",
    "    def __init__(self, default=0, minimum=None, maximum=None):\n",
    "        self.value = default\n",
    "        if minimum is None:\n",
    "            self.minimum = default - 5\n",
    "        else:\n",
    "            self.minimum = minimum\n",
    "        \n",
    "        if maximum is None:\n",
    "            self.maximum = default - 5\n",
    "        else:\n",
    "            self.maximum = maximum\n",
    "\n",
    "\n",
    "class ShoebotContext:\n",
    "    \"\"\"\n",
    "    Define what is visible during the execution of a Shoebot script.\n",
    "    \n",
    "    Methods here, delegate drawing operations to the ShoebotCanvas.\n",
    "    \"\"\"\n",
    "    def __init__(self, canvas, ns=None, variables=None):\n",
    "        if ns is not None:\n",
    "            self._ns = {}\n",
    "        else:\n",
    "            self._ns = ns\n",
    "            \n",
    "        self._canvas = canvas\n",
    "        \n",
    "        self._ns = {\"test\"}\n",
    "        self._add_variables(ns, variables)\n",
    "        \n",
    "        # default fill / stroke  # TODO - set sensible defaults.\n",
    "        self.fill(1., 0., 0., 1.)\n",
    "        self.stroke(0., 1., 1., 1.)\n",
    "        \n",
    "    def _add_variables(self, *args):\n",
    "        pass\n",
    "    \n",
    "    def Path(self):\n",
    "        return _Path(self)\n",
    "        \n",
    "    def fill(self, *args):\n",
    "        self._fill = args\n",
    "        \n",
    "    def stroke(self, *args):\n",
    "        self._stroke = args\n",
    "            \n",
    "    def rect(self, x, y, w, h, draw=True):\n",
    "        p = Path(self)\n",
    "        p.rect(x, y, w, h)\n",
    "        if draw:\n",
    "            p.draw()\n",
    "\n",
    "        \n",
    "def context_as_dict(context):\n",
    "    \"\"\"\n",
    "    :param context: ShoebotContext.\n",
    "    \"\"\"\n",
    "    return {\n",
    "        name: getattr(context, name)\n",
    "        for name in dir(context) \n",
    "        if not name.startswith('_')\n",
    "    }\n",
    "        \n",
    "\n",
    "class ShoebotRunner:\n",
    "    def __init__(self, **kwargs):\n",
    "        self.canvas = Canvas(**kwargs)\n",
    "        self.context = ShoebotContext(self.canvas)\n",
    "        \n",
    "        self.run_observers = asyncio.Queue()\n",
    "\n",
    "    async def update_source(self, source):\n",
    "        \"\"\"\n",
    "        Update source code.\n",
    "        \n",
    "        Blocks until source is executed by main loop.\n",
    "        \"\"\"\n",
    "        event = SourceChanged(source)\n",
    "        await self.run_observers.put(event)\n",
    "        await event.wait()\n",
    "        return event\n",
    "                \n",
    "    def _get_run_observers(self):\n",
    "        \"\"\"\n",
    "        Return list of execution observers.\n",
    "        \n",
    "        An execution observer is an event that waits on source execution,\n",
    "        then gets informed when execution completes or fails, so it can\n",
    "        perform some action.\n",
    "        \"\"\"\n",
    "        observers = []\n",
    "        try:\n",
    "            while event := self.run_observers.get_nowait():\n",
    "                observers.append(event)\n",
    "        except asyncio.QueueEmpty:\n",
    "            return observers\n",
    "\n",
    "    def _get_updated_source(self, observers):\n",
    "        \"\"\"\n",
    "        Return the first observer that is a SourceChanged event,\n",
    "        this will get to update the source.\n",
    "        \n",
    "        Call source_updated on all SourceChanged observers, passing\n",
    "        in the SourceChanged instance that gets to do the actual\n",
    "        updating.\n",
    "        \"\"\"\n",
    "        source_changed_event = None\n",
    "        for event in observers:\n",
    "            if not isinstance(event, SourceChanged):\n",
    "                continue\n",
    "            \n",
    "            if source_changed_event is None:\n",
    "                source_changed_event = event\n",
    "            \n",
    "            event.source_updated(source_changed_event)\n",
    "        \n",
    "        return source_changed_event\n",
    "    \n",
    "    async def run_once(self, code):        \n",
    "        # TODO: During first frame canvas is already cleared.\n",
    "                \n",
    "        # TODO: During subsequent frames if canvas should be\n",
    "        # cleared use show_page, otherwise copy_page  for outputs.\n",
    "        with self.canvas.recording_surface() as surface:\n",
    "            _vars = dict(context_as_dict(self.context))\n",
    "            exec(code, _vars, _vars)\n",
    "\n",
    "        await asyncio.sleep(0)\n",
    "        return self.canvas\n",
    "    \n",
    "    async def run_multiple(self, code):\n",
    "        await asyncio.sleep(0)\n",
    "    \n",
    "    async def run(self, code):\n",
    "        while True:\n",
    "            # TODO - following should be in run, with loop\n",
    "            observers = self._get_run_observers()\n",
    "            source_changed = self._get_updated_source(observers)\n",
    "            if source_changed:\n",
    "                code = source_changed.source\n",
    "\n",
    "            try:\n",
    "                await self.run_once(code)\n",
    "            except Exception as e:\n",
    "                print(traceback.format_exc(), file=sys.stderr)\n",
    "                if source_changed:\n",
    "                    source_changed.source_executed(code, True)\n",
    "                    self.run_observers.task_done()\n",
    "                raise\n",
    "            else:\n",
    "                for event in observers:\n",
    "                    event.source_executed(code, True)\n",
    "                    self.run_observers.task_done()\n",
    "\n",
    "            clear_output()\n",
    "            #if source_changed:\n",
    "            self.canvas.display()  # TODO - just for prototyping.\n",
    "\n",
    "            await asyncio.sleep(1)\n",
    "\n",
    "    \n",
    "    \n",
    "## Web API\n",
    "class WebAPI:\n",
    "    def __init__(self, runner):\n",
    "        self.runner = runner\n",
    "        \n",
    "    async def post_source(self, request):\n",
    "        \"\"\"\n",
    "        Revieve source upload and pass to shoebot\n",
    "        runner.\n",
    "        \n",
    "        Wait until source ie executed or returns an\n",
    "        error, then return status,\n",
    "        \"\"\"\n",
    "        data = await request.post()\n",
    "\n",
    "        source = data['file']\n",
    "\n",
    "        if isinstance(source, str):\n",
    "            unescape_characters = data.get('unescape', \"true\").lower() in [\"true\", \"yes\"]\n",
    "\n",
    "            # To aid development, you can send source in this field.\n",
    "            if unescape_characters:\n",
    "                source_content = source.replace('\\\\n', '\\n')\n",
    "            else:\n",
    "                source_content = source\n",
    "        else:\n",
    "            filename = source.filename\n",
    "            source_file = source.file\n",
    "            source_content = source_file.read()\n",
    "\n",
    "        try:\n",
    "            code = compile(source_content, \"<string>\", \"exec\")\n",
    "        except Exception as e:\n",
    "            return web.json_response({\"compiled\": {\"success\": False, \"errors\": str(e)}})\n",
    "        \n",
    "        source_changed = await self.runner.update_source(source_content)\n",
    "        return web.json_response({\"compiled\": source_changed.success,\n",
    "                             \"ran\": source_changed.success,\n",
    "                             \"errors\": source_changed.errors or []})\n",
    "    \n",
    "    def routes(self):\n",
    "        return [\n",
    "            web.post(\"/source\", self.post_source)\n",
    "        ]\n",
    "\n",
    "async def web_api_runner(runner, host=\"localhost\", port=7780):\n",
    "    \"\"\"\n",
    "    Start server\n",
    "    >>>  await web_api = await web_api_runner(runner)\n",
    "    \"\"\"\n",
    "    api = WebAPI(runner)\n",
    "    app = web.Application()\n",
    "    app.add_routes([*api.routes()])\n",
    "\n",
    "    app_runner = web.AppRunner(app)\n",
    "    await app_runner.setup()\n",
    "    site = web.TCPSite(app_runner, host, port)\n",
    "    await site.start()\n",
    "    \n",
    "    return site\n",
    "    \n",
    "    \n",
    "## Usage\n",
    "code = \"\"\"\\\n",
    "rect(0, 0, 45, 45)\n",
    "print(FRAME)\n",
    "\"\"\"\n",
    "runner = ShoebotRunner(extents=(0, 0, 128, 128))\n",
    "\n",
    "async def _run_and_display():\n",
    "    await runner.run(code)\n",
    "    \n",
    "async def main():\n",
    "    web_api = await web_api_runner(runner)\n",
    "    try:\n",
    "        await _run_and_display()\n",
    "    except (asyncio.CancelledError, Exception):\n",
    "        await web_api.stop()\n",
    "          \n",
    "await main()\n",
    "print(\"fin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Path': <bound method ShoebotContext.Path of <__main__.ShoebotContext object at 0x7f4a3c181220>>,\n",
       " 'fill': <bound method ShoebotContext.fill of <__main__.ShoebotContext object at 0x7f4a3c181220>>,\n",
       " 'rect': <bound method ShoebotContext.rect of <__main__.ShoebotContext object at 0x7f4a3c181220>>,\n",
       " 'stroke': <bound method ShoebotContext.stroke of <__main__.ShoebotContext object at 0x7f4a3c181220>>}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import inspect\n",
    "\n",
    "dir(runner.context)\n",
    "\n",
    "#runner.context.__dict__.keys()\n",
    "\n",
    "{name: getattr(runner.context, name) for name in dir(runner.context) if not name.startswith('_')}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1"
   ]
  }
 ],
 "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.2"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}