Cairo - Canvas and intermediate output - 11 forked from 10.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<module 'cairo_jupyter' from '/home/stu/.local/lib/python3.8/site-packages/cairo_jupyter/__init__.py'>\n"
     ]
    }
   ],
   "source": [
    "import cairo_jupyter\n",
    "print(cairo_jupyter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "%reload_ext cairo_jupyter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "#!pip install ipdb ipython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "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",
    "\n",
    "VALID_FORMATS = [FORMAT_PNG, FORMAT_SVG]\n",
    "\n",
    "ERROR_UNSUPPORTED_FORMAT = \"Format must be FORMAT_PDF, FORMAT_PNG, FORMAT_PS or FORMAT_SVG\"\n",
    "\n",
    "\n",
    "\n",
    "class RunObserver:\n",
    "    \"\"\"\n",
    "    RunObserver is a base class that allowing the user to asynchronously block until source has\n",
    "    executed successfully or raised an exception.\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 successful 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 self 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 successful 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 its exception is raised.\n",
    "        \"\"\"\n",
    "        await super().wait_until_after_run()\n",
    "        if self.exception:\n",
    "            raise self.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",
    "        \n",
    "class Channels(enum.Enum):\n",
    "    Alpha = 0\n",
    "    Red = 1\n",
    "    Green = 2\n",
    "    Blue = 3\n",
    "    Intensity = 4\n",
    "\n",
    "BGRA = (\n",
    "    Channels.Blue,\n",
    "    Channels.Green,\n",
    "    Channels.Red,\n",
    "    Channels.Alpha\n",
    ")\n",
    "RGB = (\n",
    "    Channels.Red,\n",
    "    Channels.Green,\n",
    "    Channels.Blue,\n",
    ")\n",
    "RGBA = (\n",
    "    Channels.Red,\n",
    "    Channels.Green,\n",
    "    Channels.Blue,\n",
    "    Channels.Alpha\n",
    ")\n",
    "\n",
    "GRAYSCALE = (Channels.Intensity,)\n",
    "ALPHA = Channels.Alpha\n",
    "GRAYSCALE_ALPHA = (Channels.Intensity, Channels.Alpha)\n",
    "TRANSPARENT = ()\n",
    "\n",
    "class Color:\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        channels = kwargs.get('channels')\n",
    "        if channels is None:\n",
    "            if len(args) == 0:\n",
    "                channels = TRANSPARENT\n",
    "            elif len(args) == 1:\n",
    "                if args[0] is None:\n",
    "                    channels = TRANSPARENT\n",
    "                elif isinstance(args[0], Color):\n",
    "                    color = args[0]\n",
    "                    channels, args = tuple(color.data.items())\n",
    "                else:\n",
    "                    channels = GRAYSCALE\n",
    "            elif len(args) == 2:\n",
    "                 channels = GRAYSCALE_ALPHA\n",
    "            elif len(args) == 3:\n",
    "                channels = RGB\n",
    "            elif len(args) == 4:\n",
    "                channels = RGBA\n",
    "            else:\n",
    "                raise ValueError(f\"Unknown color arrangement: {args}\")\n",
    "\n",
    "        if len(args) != len(channels):\n",
    "            raise ValueError(f\"len(args) != channel(args): args={args}, channels={channels}\")\n",
    "            \n",
    "        # Build dict of {channel: color} from tuples of (channel, color)\n",
    "        self.data = dict(zip(channels, args))\n",
    "    \n",
    "    @property\n",
    "    def is_transparent(self):\n",
    "        if not self.data:\n",
    "            return True\n",
    "        \n",
    "        return self.alpha == 0.0\n",
    "    \n",
    "    @property\n",
    "    def alpha(self):\n",
    "        if not self.data:\n",
    "            return 0.0\n",
    "        \n",
    "        return self.data.get(Channels.Alpha, 1.0)\n",
    "\n",
    "    def calculate_intensity(self):\n",
    "        \"\"\"Calculate intensity from colour channels.\n",
    "        \n",
    "        If there are no colour channels, returns zero.\n",
    "        \"\"\"\n",
    "        intensity_channels = 0\n",
    "        intensity = 0\n",
    "        \n",
    "        for channel, value in self.data.items():\n",
    "            if channel in (Channels.Alpha, Channels.Intensity):\n",
    "                continue\n",
    "            intensity_channels += 1\n",
    "            intensity += value\n",
    "            \n",
    "        if intensity == 0:\n",
    "            return 0.0\n",
    "        \n",
    "        return intensity / intensity_channels        \n",
    "    \n",
    "    @property\n",
    "    def intensity(self):\n",
    "        \"\"\"Intensity - for greyscale images this is the intensity channel (grey)\n",
    "        for colour images this is calculated from the colour channels.\n",
    "        \"\"\"\n",
    "        intensity = self.data.get(Channels.Intensity)\n",
    "        if intensity is not None:\n",
    "            return intensity\n",
    "        \n",
    "        return self.data.get(Channels.Intensity, self.calculate_intensity())\n",
    "    \n",
    "    @property\n",
    "    def r(self):\n",
    "        value = self.data.get(Channels.Red)\n",
    "        if value is not None:\n",
    "            return value\n",
    "\n",
    "        if self.is_transparent:\n",
    "            return 0.0\n",
    "\n",
    "        return self.data[Channels.Intensity]\n",
    "    \n",
    "    @property\n",
    "    def g(self):\n",
    "        value = self.data.get(Channels.Green)\n",
    "        if value is not None:\n",
    "            return value\n",
    "\n",
    "        if self.is_transparent:\n",
    "            return 0.0\n",
    "\n",
    "        return self.data[Channels.Intensity]\n",
    "    \n",
    "    @property\n",
    "    def b(self):\n",
    "        value = self.data.get(Channels.Blue)\n",
    "        if value is not None:\n",
    "            return value\n",
    "\n",
    "        if self.is_transparent:\n",
    "            return 0.0\n",
    "\n",
    "        return self.data[Channels.Intensity]\n",
    "    \n",
    "    @property\n",
    "    def rgba(self):\n",
    "        return (\n",
    "            self.r,\n",
    "            self.g,\n",
    "            self.b,\n",
    "            self.alpha,\n",
    "        )\n",
    "    \n",
    "    @property\n",
    "    def rgb(self):\n",
    "        return (\n",
    "            self.r,\n",
    "            self.g,\n",
    "            self.b,\n",
    "        )\n",
    "    \n",
    "    def __str__(self):\n",
    "        # TODO - make output consistent - you can't acually pass data as a param\n",
    "        return f\"<Color data={self.data}>\"\n",
    "\n",
    "\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",
    "    # TODO - is this really a color, a different name\n",
    "    # pen, drawable, paintable Colorable ???\n",
    "    def __init__(self, fill=None, stroke=None, blendmode=None, **kwargs):\n",
    "        if isinstance(fill, Color):\n",
    "            self._fill = fill\n",
    "        else:\n",
    "            self._fill = Color(*fill)\n",
    "\n",
    "        if isinstance(stroke, Color):\n",
    "            self._stroke = stroke\n",
    "        else:\n",
    "            self._stroke = Color(*stroke)\n",
    "\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",
    "        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 f\"<PathElement(MOVETO, (({self.x:.3f}, {self.y:.3f}),))>\"\n",
    "        elif self.cmd == RMOVETO:\n",
    "            return f\"<PathElement(RMOVETO, (({self.x:.3f}, {self.y:.3f}),))>\"\n",
    "        elif self.cmd == LINETO:\n",
    "            return f\"<PathElement(LINETO, (({self.x:.3f}, {self.y:.3f}),))>\"\n",
    "        elif self.cmd == RLINETO:\n",
    "            return f\"<PathElement(RLINETO, (({self.x:.3f}, {self.y:.3f}),))>\"\n",
    "        elif self.cmd == CURVETO:\n",
    "            return f\"<PathElement(CURVETO, (({self.ctrl1.x:.3f}, {self.ctrl1.y:.3f}), ({self.ctrl2.x:.3f}, {self.ctrl2.y}), ({self.x:.3f}, {self.y:.3f}))>\"\n",
    "        elif self.cmd == RCURVETO:\n",
    "            return f\"<PathElement(RCURVETO, (({self.ctrl1.x:.3f}, {self.ctrl1.y:.3f}), ({self.ctrl2.x:.3f}, {self.ctrl2.y}), ({self.x:.3f}, {self.y:.3f}))>\"\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.draw_path(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 CanvasBase:\n",
    "    ## TODO - this isn't used, trying to work out if the API is right by prototyping this.\n",
    "    def new_page(self, context):\n",
    "        raise NotImplemented()\n",
    "        \n",
    "    def draw_path(seslf, path, fill, stroke):\n",
    "        raise NotImplemented()\n",
    "        \n",
    "    def save(self, f, format=None, *args, **kwargs):\n",
    "        # TODO: naming - f could be dest ?\n",
    "        raise NotImplemented()\n",
    "        \n",
    "    @contextmanager\n",
    "    def recording_surface(self, extents=None):\n",
    "        # TODO: naming - This definitely shows the name is too cairo\n",
    "        raise NotImplemented()\n",
    "        \n",
    "    def display(self, format=None, *args, **kwargs):\n",
    "        # TODO: should this be here... (maybe jupyter support should be seperate?)\n",
    "        #       For:  everything should have jupyter support\n",
    "        #       Against:  No it shouldn't\n",
    "        #       Alternative:  Have different put targets, think about how it would work\n",
    "        #                     in a DAG/Node based world.\n",
    "        raise NotImplemented()\n",
    "        \n",
    "        \n",
    "        \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: (float, float, float, float) = None, resizable=None, **kwargs):\n",
    "        \"\"\"\n",
    "        :param extents: Extents of recording surface, or None for unbounded.\n",
    "        :param resizable: If True, the surface will be resizable.\n",
    "        \"\"\"\n",
    "        self.resizable = resizable or extents is None\n",
    "        self.surface = self.create_recording_surface(extents)\n",
    "        self.position = (0, 0)\n",
    "        self.extents = extents\n",
    "\n",
    "    def create_recording_surface(self, extents=None):\n",
    "        return cairo.RecordingSurface(cairo.CONTENT_COLOR_ALPHA, extents)\n",
    "\n",
    "    def resize(self, dimensions, clear=True):\n",
    "        if not self.resizable:\n",
    "            return False\n",
    "\n",
    "        extents = (0, 0, dimensions[0], dimensions[1])\n",
    "        if self.extents == extents:\n",
    "            return True\n",
    "\n",
    "        self.extents = extents\n",
    "        new_surface = self.create_recording_surface(extents)\n",
    "\n",
    "        if not clear:\n",
    "            # Copy the old surface to the new one.\n",
    "            with new_surface.get_context() as ctx:\n",
    "                ctx.set_source_surface(self.surface, 0, 0)\n",
    "                ctx.paint()\n",
    "\n",
    "        self.surface = new_surface\n",
    "        return True\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 new_page(self, context):\n",
    "        \"\"\":param context: Context object is passed to retrieve the background after execution.\n",
    "        \"\"\"\n",
    "        ctx = cairo.Context(self.surface)\n",
    "        \n",
    "        ctx.push_group()\n",
    "        try:\n",
    "            yield\n",
    "        except:\n",
    "            # Don't leak resources if something went wrong.\n",
    "            ctx.pop_group()\n",
    "            raise\n",
    "            \n",
    "        background = context._background\n",
    "        if background is not None:\n",
    "            ctx.set_source_rgba(*background.rgba)\n",
    "            ctx.paint()\n",
    "\n",
    "        ctx.pop_group()\n",
    "        if background is None:\n",
    "            ctx.copy_page()\n",
    "        else:\n",
    "            ctx.show_page()\n",
    "    \n",
    "    def draw_path(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.alpha + stroke.alpha == 0.0:\n",
    "            # Tranverse path here, so point is at correct location\n",
    "            ctx.traverse()\n",
    "            return\n",
    "        \n",
    "        if fill.alpha and stroke.alpha:\n",
    "            if stroke.alpha == 1.0:\n",
    "                # Fast path if no alpha in stroke\n",
    "                ctx.set_source_rgba(*fill.rgb)\n",
    "                ctx.fill_preserve()\n",
    "\n",
    "                ctx.set_source_rgba(*stroke.rgb)\n",
    "                ctx.set_line_width(strokewidth)\n",
    "                ctx.stroke()\n",
    "\n",
    "            else:\n",
    "                # Draw fill onto intermediate surface so stroke does not overlay fill\n",
    "                ctx.push_group()\n",
    "\n",
    "                ctx.set_source_rgba(*fill.rgba)\n",
    "                ctx.fill_preserve()\n",
    "\n",
    "                ctx.set_source_rgba(*stroke.rgba)\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",
    "                \n",
    "        elif fill.alpha:\n",
    "            ctx.set_source_rgba(*fill.rgba)\n",
    "            ctx.fill()\n",
    "        elif stroke.alpha:\n",
    "            ctx.set_source_rgba(*stroke.rgba)\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",
    "        # TODO - this is a cairo specific utility function, to this canvas.\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 to a file or buffer, using cairo to save.\n",
    "        \n",
    "        :param f: buffer or filename.\n",
    "        \"\"\"\n",
    "        # TODO - this is handling output formats, saving to buffers etc.\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 == FORMAT_SVG:\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",
    "        \"\"\"Display to Jupyter cell.\n",
    "        \"\"\"\n",
    "        # TODO - formats supported here may not be the same as for saving.\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 unlike many bitmap formats.\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",
    "                if kwargs.get(\"syntax_highlight\") is True:\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",
    "                    _display(XML(buffer.getvalue()))\n",
    "                else:\n",
    "                    _display(SVG(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",
    "        Context manager to provide a temporary RecordingSurface to draw on.\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",
    "        Buffering drawing commands like this makes it possible to implementing livecoding\n",
    "        interfaces that don't output graphics when errors occur.\n",
    "        \"\"\"\n",
    "        # TODO - there is probably a less Cairo term for this function than recording_surface.\n",
    "        _surface = self.surface\n",
    "        self.surface = surface = cairo.RecordingSurface(cairo.CONTENT_COLOR_ALPHA, extents or self.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(None)\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",
    "        return self._canvas.resize((width, height))\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 = Color(*(args or ()))\n",
    "    \n",
    "    def fill(self, *args):\n",
    "        \"\"\"Set fill color, or None for no fill.\"\"\"\n",
    "        if args == (None,):\n",
    "            args = ()\n",
    "        self._fill = Color(*args)\n",
    "        \n",
    "    def stroke(self, *args):\n",
    "        \"\"\"Set stroke color, or None for no stroke.\"\"\"\n",
    "        if args == (None,):\n",
    "            args = ()\n",
    "        self._stroke = Color(*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, \n",
    "        pass draw=False if drawing 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",
    "\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 allowing user functions to be called before code is executed wait until it runs an iteration.\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 run 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",
    "        with self.canvas.recording_surface():\n",
    "            ns = context_as_dict(self.context)\n",
    "            ns.update(extra_ns)\n",
    "            \n",
    "            with self.canvas.new_page(self.context):\n",
    "                exec(code, ns, ns)\n",
    "        \n",
    "        await asyncio.sleep(0)\n",
    "    \n",
    "    async def run_multiple(self, code):\n",
    "        # TODO - remember what running multiple is in nodeboxes runner.\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",
    "    An HTTP end-point that allows tools such as IDEs to update the source\n",
    "    being executed.\n",
    "    \"\"\"\n",
    "    def __init__(self, runner):\n",
    "        self.runner = runner\n",
    "        \n",
    "    async def post_source(self, request):\n",
    "        \"\"\"\n",
    "        Post updated source to Squiggle to execute.\n",
    "\n",
    "        Source is posted in the file field.\n",
    "\n",
    "        Errors in compilation immediately return with a 500 status code.\n",
    "\n",
    "        By default, runs the code for one iteration, returning a status 200 on success or 500 if an exception was raised.\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",
    "                                     status=500)\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 []}, status = 500 if source_changed.errors else 200)\n",
    "    \n",
    "    def routes(self):\n",
    "        return [\n",
    "            web.post(\"/source\", self.post_source)\n",
    "        ]\n",
    "\n",
    "    \n",
    "async def web_api_runner(runner, host=\"localhost\", port=7780, **kwargs):\n",
    "    \"\"\"\n",
    "    Start the web API.\n",
    "    \n",
    "    Accepts new source code POSTed to /source\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, raise_cancelled=False, **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) as e:\n",
    "        await web_api.stop()\n",
    "        if isinstance(e, asyncio.CancelledError):\n",
    "            if raise_cancelled:\n",
    "                raise\n",
    "        else:\n",
    "            raise\n",
    "        \n",
    "    return runner\n",
    "\n",
    "\n",
    "## Usage\n",
    "\n",
    "code = \"\"\"\\\n",
    "from random import random\n",
    "\n",
    "size(400, 50)\n",
    "\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",
    "\"\"\"\n",
    "\n",
    "# with open(\"../Squiggle/examples/basic/Squiggle.bot\") as f:\n",
    "#     code = f.read()\n",
    "#     print(code)\n",
    "\n",
    "runner = await run_webserver(code, extents=(0., 0., 400., 400.), resizable=True)\n",
    "print(\"fin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# import inspect\n",
    "# dir(runner.context)\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": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "#help(Path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "help(Path)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "squiggle-venv",
   "language": "python",
   "name": "squiggle-venv"
  },
  "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.13"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}