Cairo - Canvas and intermediate output - 9.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": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "size not implemented\n",
      "fin\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-9-3ca51295bf3a>\", line 724, in run\n",
      "    await self.run_once(code, extra_ns={\"FRAME\": frame, \"PAGE_NUM\": frame})\n",
      "  File \"<ipython-input-9-3ca51295bf3a>\", line 704, in run_once\n",
      "    exec(code, ns, ns)\n",
      "  File \"<string>\", line 6, in <module>\n",
      "  File \"<ipython-input-9-3ca51295bf3a>\", line 616, in rect\n",
      "    p.draw()\n",
      "  File \"<ipython-input-9-3ca51295bf3a>\", line 359, in draw\n",
      "    self._ctx._canvas.drawpath(self,\n",
      "  File \"<ipython-input-9-3ca51295bf3a>\", line 429, in drawpath\n",
      "    ctx.set_source_rgba(*fill)\n",
      "TypeError: Context.set_source_rgba() takes at least 3 arguments (1 given)\n",
      "\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 functools import partialmethod\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 allows the user to block until source has\n",
    "    been executed or raised an exception.\n",
    "    \n",
    "    This is a base class that ca\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        self._event = asyncio.Event()\n",
    "\n",
    "    async def wait_until_after_run(self):\n",
    "        \"\"\"\n",
    "        Wait for source to run an iteration or throw exception.\n",
    "        \"\"\"\n",
    "        await self._event.wait()\n",
    "    \n",
    "    def run_was_successful(self, source):\n",
    "        \"\"\"\n",
    "        Called after a sucessful run of the source.\n",
    "        Unblocks callers to wait_until_after_run.   \n",
    "        \n",
    "        Subclasses may save information to be retrieved by wait_until_after_run.\n",
    "        \"\"\"\n",
    "        self._event.set()\n",
    "        \n",
    "    def run_raised_exception(self, source, exception):\n",
    "        \"\"\"\n",
    "        Called if attempting to run the source raised an exception.\n",
    "        Unblocks callers to wait_until_after_run.   \n",
    "        \n",
    "        Subclasses may save information to be retrieved by wait_until_after_run.\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.exception = 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 updated_by was this SourceChanged set status to UPDATED_SUCCESSFULLY and continue waiting.\n",
    "        \n",
    "        If updated_by is None then set status to NOT_UPDATED and finish waiting.\n",
    "        If updated_by is not thisSourceChanged set status to UPDATED_BY_ANOTHER and finish waiting.\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 run_was_successful(self, source):\n",
    "        \"\"\"\n",
    "        Called after a sucessful run of the source.\n",
    "        Unblocks callers to wait_until_after_run.   \n",
    "        \n",
    "        Saves the successfully run source to self.source.\n",
    "        \"\"\"\n",
    "        self.source = source\n",
    "        self.exception = None\n",
    "        self._event.set()\n",
    "        \n",
    "    def run_raised_exception(self, source, exception):\n",
    "        \"\"\"\n",
    "        Called if attempting to run the source raised an exception.\n",
    "        Unblocks callers to wait_until_after_run.   \n",
    "        \n",
    "        Save the failed source and the exception then allow wait_until_after_run\n",
    "        to stop waiting.\n",
    "        \"\"\"\n",
    "        self.source = source\n",
    "        self.exception = exception\n",
    "        self._event.set()\n",
    "        \n",
    "    async def wait_until_after_run(self):\n",
    "        \"\"\"\n",
    "        Wait for source to run an iteration or throw exception.\n",
    "        \n",
    "        If run_raised_exception was called then raise the exception it stored.\n",
    "        \"\"\"\n",
    "        await super().wait_until_after_run()\n",
    "        if self.exception:\n",
    "            raise exception\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",
    "    \"\"\"\n",
    "    Color state:\n",
    "        fill: (r, g, b, a)\n",
    "        stroke: (r, g, b, a)\n",
    "        blendmode: TODO enum, like BlendMode.THROUGH\n",
    "    \"\"\"\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",
    "# self._state.fill = (1., 1., .5)\n",
    "# self._state.blendmode = BlendMode.xor\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",
    "    f\"\"\"\n",
    "    Path containing Beziers and straight lines.\n",
    "    \n",
    "    {ColorMixin.__doc__}\n",
    "    \"\"\"\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 translate(self, x, y):\n",
    "        # TODO - added to get shoebot.bot working\n",
    "        #        think about how position should really work\n",
    "        self.position += (x, y)\n",
    "        \n",
    "    @contextmanager\n",
    "    def page(self, background):\n",
    "        ctx = cairo.Context(self.surface)\n",
    "        if background is not None:\n",
    "            ctx.set_source_rgb(*background)\n",
    "            ctx.paint()\n",
    "        yield\n",
    "        if background is None:\n",
    "            ctx.copy_page()\n",
    "        else:\n",
    "            ctx.show_page()\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 Context:\n",
    "    \"\"\"\n",
    "    Define what is visible during the execution of a Shoebot script.\n",
    "    \n",
    "    Methods here, delegate drawing operations to the Shoebot Canvas.\n",
    "    \"\"\"\n",
    "    def __init__(self, canvas):\n",
    "        self._canvas = canvas\n",
    "        \n",
    "        self._ns = {}\n",
    "        \n",
    "        # default fill / stroke  # TODO - set sensible defaults.\n",
    "        self.fill(1., 0., 0., 1.)\n",
    "        self.stroke(0., 1., 1., 1.)\n",
    "        self.background(1., 1., 1.)\n",
    "        # TODO - if state had better handling, maybe we could do\n",
    "        # self._state.colors(fill=(...), stroke=(...), background=(...))\n",
    "        # TODO - look at what PlotDevice does around state.\n",
    "       \n",
    "    # Pass \"self\" to Path instance.\n",
    "    #     def Path(self):\n",
    "    #         f\"{_Path.__doc__}\"\n",
    "    #         return _Path(self)\n",
    "    Path = _Path\n",
    "    \n",
    "    def size(self, width, height):\n",
    "        print(\"size not implemented\")\n",
    "        \n",
    "    def translate(self, x, y):\n",
    "        # TODO - added but without thought on how positioning should work\n",
    "        self._canvas.translate(x, y)\n",
    "    \n",
    "    def background(self, *args):\n",
    "        \"\"\"Set background color, or None for to preserve the last frame or page.\"\"\"\n",
    "        if args == (None,):\n",
    "            args = None\n",
    "        self._background = args\n",
    "    \n",
    "    def fill(self, *args):\n",
    "        \"\"\"Set fill color, or None for no fill.\"\"\"\n",
    "        if args == (None,):\n",
    "            args = None\n",
    "        self._fill = args\n",
    "        \n",
    "    def stroke(self, *args):\n",
    "        \"\"\"Set stroke color, or None for no stroke.\"\"\"\n",
    "        if args == (None,):\n",
    "            args = None\n",
    "        self._stroke = args\n",
    "            \n",
    "    def rect(self, x, y, w, h, draw=True):\n",
    "        \"\"\"\n",
    "        :return: a rectangular Path\n",
    "        \n",
    "        By default the Path is added to the canvas, pass draw=False\n",
    "        if drawin is not required.\n",
    "        \"\"\"\n",
    "        p = Path(self)\n",
    "        p.rect(x, y, w, h)\n",
    "        if draw:\n",
    "            p.draw()\n",
    "        return p\n",
    "\n",
    "def context_as_dict(context):\n",
    "    \"\"\"\n",
    "    :param context: Shoebot Context.\n",
    "    :return: dict of all public members.\n",
    "    \"\"\"\n",
    "    return {\n",
    "        name: getattr(context, name)\n",
    "        for name in dir(context) \n",
    "        if not name.startswith('_')\n",
    "    }\n",
    "        \n",
    "\n",
    "class Runner:\n",
    "    \"\"\"\n",
    "    Shoebot \"Runner\".\n",
    "    \n",
    "    Handles the bot lifecycle.\n",
    "    \n",
    "    Using aio, extension points are provided to run actions before\n",
    "    the code runs and await on the result.\n",
    "    \"\"\"\n",
    "    def __init__(self, **kwargs):\n",
    "        self.canvas = Canvas(**kwargs)\n",
    "        self.context = Context(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, extra_ns=None):\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",
    "            ns = context_as_dict(self.context)\n",
    "            if ns:\n",
    "                ns.update(extra_ns)\n",
    "                \n",
    "            with self.canvas.page(background=self.context._background):\n",
    "                exec(code, ns, ns)\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",
    "        frame = 1\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",
    "                # TODO - handling extra_ns should probably be somewhere else,\n",
    "                #        (here should be grammar neutral)\n",
    "                await self.run_once(code, extra_ns={\"FRAME\": frame, \"PAGE_NUM\": frame})\n",
    "            except Exception as e:\n",
    "                print(traceback.format_exc(), file=sys.stderr)\n",
    "                if source_changed:\n",
    "                    source_changed.run_raised_exception(e)\n",
    "                    self.run_observers.task_done()\n",
    "                raise\n",
    "            else:\n",
    "                # TODO frame handling should be somewhere grammar neutral.\n",
    "                frame += 1\n",
    "                for event in observers:\n",
    "                    event.run_was_successful(code)\n",
    "                    self.run_observers.task_done()\n",
    "\n",
    "            if frame % 10 == 0:\n",
    "                clear_output()\n",
    "            #if source_changed:\n",
    "            self.canvas.display()  # TODO - just for prototyping.\n",
    "\n",
    "            await asyncio.sleep(.5)  # TODO let bot set speed\n",
    "\n",
    "    \n",
    "    \n",
    "## Web API\n",
    "class WebAPI:\n",
    "    \"\"\"Web API.\n",
    "    \n",
    "    Allows POSTing new code, for use with IDEs / livecoding tools.\n",
    "    \"\"\"\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\", \"1\"]\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, **kwargs):\n",
    "    \"\"\"\n",
    "    Start web API.\n",
    "    \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",
    "async def run_webserver(code, runner=None, **kwargs):\n",
    "    \"\"\"\n",
    "    Convenience function to run bot + webserver.\n",
    "    \n",
    "    Users may also take the take the web_api_runner and\n",
    "    runner to run in their own event loops if needed.\n",
    "    \"\"\"\n",
    "    if runner is None:\n",
    "        runner = Runner(**kwargs)\n",
    "    web_api = await web_api_runner(runner, **kwargs)\n",
    "    try:\n",
    "        await runner.run(code)\n",
    "    except (asyncio.CancelledError, Exception):\n",
    "        await web_api.stop()\n",
    "\n",
    "\n",
    "## Usage\n",
    "\n",
    "# code = \"\"\"\\\n",
    "# from random import random\n",
    "# if FRAME == 4:\n",
    "#     background(None)  # set background to None \n",
    "# fill(random(), random(), random())\n",
    "# p = rect(50*FRAME-50, 0, 45, 45)\n",
    "# \"\"\"\n",
    "\n",
    "with open(\"../shoebot/examples/basic/shoebot.bot\") as f:\n",
    "    code = f.read()\n",
    "    \n",
    "await run_webserver(code, extents=(0, 0, 400, 50))\n",
    "print(\"fin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(Path)"
   ]
  }
 ],
 "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.5"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}