docs: def fig_to_html(fig=None, template='base.html', tiles=None, crs=None,
                  epsg=None, embed_links=False, float_precision=6):
      """
      Convert a Matplotlib Figure to a Leaflet map
  
      Parameters
      ----------
      fig : figure, default gcf()
          Figure used to convert to map
      template : string, default 'base.html'
          The Jinja2 template to use
      tiles : string or tuple
          The tiles argument is used to control the map tile source in the
          Leaflet map. Several simple shortcuts exist: 'osm', 'mapquest open',
          and 'mapbox bright' may be specified to use those tiles.
  
          The argument may be a tuple of two elements. The first element is the
          tile URL to use in the map's TileLayer, the second argument is the
          attribution to display.  See
          http://leafletjs.com/reference.html#tilelayer for more information on
          formatting the URL.
  
          See also maptiles.mapbox() for specifying Mapbox tiles based on a
          Mapbox map ID.
      crs : dict, default assumes lon/lat
          pyproj definition of the current figure. If None, then it is assumed
          the plot is longitude, latitude in X, Y.
      epsg : int, default 4326
          The EPSG code of the current plot. This can be used in place of the
          'crs' parameter.
      embed_links : bool, default False
          Whether external links (except tiles) shall be explicitly embedded in
          the final html.
      float_precision : int, default 6
          The precision to be used for the floats in the embedded geojson.
  
      Note: only one of 'crs' or 'epsg' may be specified. Both may be None, in
      which case the plot is assumed to be longitude / latitude.
  
      Returns
      -------
      String of html of the resulting webpage
  
      """
      if tiles is None:
          tiles = maptiles.osm
      elif isinstance(tiles, six.string_types):
          if tiles not in maptiles.tiles:
              raise ValueError('Unknown tile source "{}"'.format(tiles))
          else:
              tiles = maptiles.tiles[tiles]
  
      template = env.get_template(template)
  
      if fig is None:
          fig = plt.gcf()
      dpi = fig.get_dpi()
  
      renderer = LeafletRenderer(crs=crs, epsg=epsg)
      exporter = Exporter(renderer)
      exporter.run(fig)
  
      attribution = _attribution + ' | ' + tiles[1]
  
      mapid = str(uuid.uuid4()).replace('-', '')
  
      FloatEncoder._formatter = ".{}f".format(float_precision)
      gjdata = json.dumps(renderer.geojson(), cls=FloatEncoder)
      params = {
          'geojson': gjdata,
          'width': fig.get_figwidth()*dpi,
          'height': fig.get_figheight()*dpi,
          'mapid': mapid,
          'tile_url': tiles[0],
          'attribution': attribution,
          'links': [_leaflet_js,_leaflet_css],
          'embed_links': embed_links,
      }
      html = template.render(params)
  
      return html