docs/examples/data_visualization/widgets/histogram_widget.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Histogram widget\n",
    "\n",
    "Histogram widgets display the distribution of a numeric attribute, in buckets, to group ranges of values in your data. You can hover over each bar to see each bucket's values and count, and filter your map's data within a given range by selecting it. By default, as you zoom or pan the map, the values in the widget update to the current viewport. \n",
    "\n",
    "To see available parameters run `help(histogram_widget)`.\n",
    "\n",
    "In the example below, the number of vehicles involved in each collision in Seattle are grouped over 9 buckets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cartoframes.auth import set_default_credentials\n",
    "\n",
    "set_default_credentials('cartoframes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe\n",
       "  frameborder=\"0\"\n",
       "  style=\"\n",
       "    border: 1px solid #cfcfcf;\n",
       "    width: 100%;\n",
       "    height: 632px;\n",
       "    \"\n",
       "  srcDoc=\"\n",
       "  <!DOCTYPE html>\n",
       "<html lang=&quot;en&quot;>\n",
       "<head>\n",
       "  <title>None</title>\n",
       "  <meta name=&quot;description&quot; content=&quot;None&quot;>\n",
       "  <meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot;>\n",
       "  <meta charset=&quot;UTF-8&quot;>\n",
       "  <!-- Include CARTO VL JS -->\n",
       "  <script src=&quot;https://libs.cartocdn.com/carto-vl/v1.4/carto-vl.min.js&quot;></script>\n",
       "  <!-- Include Mapbox GL JS -->\n",
       "  <script src=&quot;https://api.tiles.mapbox.com/mapbox-gl-js/v1.0.0/mapbox-gl.js&quot;></script>\n",
       "  <!-- Include Mapbox GL CSS -->\n",
       "  <link href=&quot;https://api.tiles.mapbox.com/mapbox-gl-js/v1.0.0/mapbox-gl.css&quot; rel=&quot;stylesheet&quot; />\n",
       "\n",
       "  <!-- Include Airship -->\n",
       "  <script nomodule=&quot;&quot; src=&quot;https://libs.cartocdn.com/airship-components/v2.3/airship.js&quot;></script>\n",
       "  <script type=&quot;module&quot; src=&quot;https://libs.cartocdn.com/airship-components/v2.3/airship/airship.esm.js&quot;></script>\n",
       "  <script src=&quot;https://libs.cartocdn.com/airship-bridge/v2.3/asbridge.min.js&quot;></script>\n",
       "  <link href=&quot;https://libs.cartocdn.com/airship-style/v2.3/airship.min.css&quot; rel=&quot;stylesheet&quot;>\n",
       "  <link href=&quot;https://libs.cartocdn.com/airship-icons/v2.3/icons.css&quot; rel=&quot;stylesheet&quot;>\n",
       "\n",
       "  <link href=&quot;https://fonts.googleapis.com/css?family=Roboto&quot; rel=&quot;stylesheet&quot; type=&quot;text/css&quot;>\n",
       "\n",
       "  <!-- External libraries -->\n",
       "\n",
       "  <!-- pako -->\n",
       "  <script src=&quot;https://libs.cartocdn.com/cartoframes/dependencies/pako_inflate.min.js&quot;></script>\n",
       "  \n",
       "  <!-- html2canvas -->\n",
       "  \n",
       "\n",
       "  \n",
       "  <style>\n",
       "  body {\n",
       "    margin: 0;\n",
       "    padding: 0;\n",
       "  }\n",
       "\n",
       "  aside.as-sidebar {\n",
       "    min-width: 300px;\n",
       "  }\n",
       "\n",
       "  .map-image {\n",
       "    display: none;\n",
       "    max-width: 100%;\n",
       "    height: auto;\n",
       "  }\n",
       "\n",
       "  as-layer-selector-slot .as-layer-selector-slot--wrapper .as-caption { // FIXME\n",
       "    font-size: 14px;\n",
       "    line-height: 14px;\n",
       "  }\n",
       "</style>\n",
       "  <style>\n",
       "  .map {\n",
       "    position: absolute;\n",
       "    height: 100%;\n",
       "    width: 100%;\n",
       "  }\n",
       "\n",
       "  .map-info {\n",
       "    position: absolute;\n",
       "    bottom: 0;\n",
       "    padding: 0 5px;\n",
       "    background-color: rgba(255, 255, 255, 0.5);\n",
       "    margin: 0;\n",
       "    color: rgba(0, 0, 0, 0.75);\n",
       "    font-size: 12px;\n",
       "    width: auto;\n",
       "    height: 18px;\n",
       "    font-family: 'Open Sans';\n",
       "  }\n",
       "\n",
       "  .map-footer {\n",
       "    background: #F2F6F9;\n",
       "    font-family: Roboto;\n",
       "    font-size: 12px;\n",
       "    line-height: 24px;\n",
       "    color: #162945;\n",
       "    text-align: center;\n",
       "    z-index: 2;\n",
       "  }\n",
       "\n",
       "  .map-footer a {\n",
       "    text-decoration: none;\n",
       "  }\n",
       "\n",
       "  .map-footer a:hover {\n",
       "    text-decoration: underline;\n",
       "  }\n",
       "</style>\n",
       "    <style>\n",
       "    #error-container {\n",
       "      position: absolute;\n",
       "      width: 100%;\n",
       "      height: 100%;\n",
       "      background-color: white;\n",
       "      visibility: hidden;\n",
       "      padding: 1em;\n",
       "      font-family: &quot;Courier New&quot;, Courier, monospace;\n",
       "      margin: 0 auto;\n",
       "      font-size: 14px;\n",
       "      overflow: auto;\n",
       "      z-index: 1000;\n",
       "      color: black;\n",
       "    }\n",
       "\n",
       "    .error-section {\n",
       "      padding: 1em;\n",
       "      border-radius: 5px;\n",
       "      background-color: #fee;\n",
       "    }\n",
       "\n",
       "    #error-container #error-highlight {\n",
       "      font-weight: bold;\n",
       "      color: inherit;\n",
       "    }\n",
       "\n",
       "    #error-container #error-type {\n",
       "      color: #008000;\n",
       "    }\n",
       "\n",
       "    #error-container #error-name {\n",
       "      color: #ba2121;\n",
       "    }\n",
       "\n",
       "    #error-container #error-content {\n",
       "      margin-top: 0.4em;\n",
       "    }\n",
       "\n",
       "    .error-details {\n",
       "      margin-top: 1em;\n",
       "    }\n",
       "\n",
       "    #error-stacktrace {\n",
       "      list-style: none;\n",
       "    }\n",
       "</style>\n",
       "  <style>\n",
       "    .popup-content {\n",
       "      display: flex;\n",
       "      flex-direction: column;\n",
       "      padding: 8px;\n",
       "    }\n",
       "\n",
       "    .popup-name {\n",
       "      font-size: 12px;\n",
       "      font-weight: 400;\n",
       "      line-height: 20px;\n",
       "      margin-bottom: 4px;\n",
       "    }\n",
       "\n",
       "    .popup-value {\n",
       "      font-size: 16px;\n",
       "      font-weight: 600;\n",
       "      line-height: 20px;\n",
       "    }\n",
       "\n",
       "    .popup-value:not(:last-of-type) {\n",
       "      margin-bottom: 16px;\n",
       "    }\n",
       "</style>\n",
       "  <style>\n",
       "  as-widget-header .as-widget-header__header {\n",
       "    margin-bottom: 8px;\n",
       "    overflow-wrap: break-word;\n",
       "  }\n",
       "\n",
       "  as-widget-header .as-widget-header__subheader {\n",
       "    margin-bottom: 12px;\n",
       "  }\n",
       "\n",
       "  as-category-widget {\n",
       "    max-height: 250px;\n",
       "  }\n",
       "</style>\n",
       "</head>\n",
       "\n",
       "<body class=&quot;as-app-body as-app&quot;>\n",
       "  <img id=&quot;map-image&quot; class=&quot;map-image&quot; alt='Static map image' />\n",
       "  <as-responsive-content id=&quot;main-container&quot;>\n",
       "    \n",
       "      \n",
       "\n",
       "<aside class=&quot;as-sidebar as-sidebar--right&quot; id=&quot;widgets&quot; data-name=&quot;Widgets&quot;>\n",
       "  \n",
       "    \n",
       "      \n",
       "        \n",
       "          <div class=&quot;as-box&quot;>\n",
       "            <section class=&quot;as-body&quot;>\n",
       "    \n",
       "      <div>\n",
       "  <as-histogram-widget\n",
       "    id=&quot;layer0_widget0&quot;\n",
       "    description=&quot;Select a range of values to filter&quot;\n",
       "    heading=&quot;Number of Vehicles Involved&quot;>\n",
       "  </as-histogram-widget>\n",
       "  \n",
       "</div>\n",
       "    \n",
       "  </section>\n",
       "          </div>\n",
       "        \n",
       "    \n",
       "  \n",
       "</aside>\n",
       "    \n",
       "    <main class=&quot;as-main&quot;>\n",
       "      <div class=&quot;as-map-area&quot;>\n",
       "        <div id=&quot;map&quot; class=&quot;map&quot;></div>\n",
       "        \n",
       "        \n",
       "      </div> <!-- as-map-area -->\n",
       "    </main> <!-- as-main -->\n",
       "  </as-responsive-content>\n",
       "\n",
       "  \n",
       "\n",
       "  <div id=&quot;error-container&quot; class=&quot;error&quot;>\n",
       "  <section class=&quot;error-section&quot;>\n",
       "    <span class=&quot;errors&quot; id=&quot;error-name&quot;></span>:\n",
       "    <section id=&quot;error-content&quot;>\n",
       "      <span class=&quot;errors&quot; id=&quot;error-type&quot;></span>\n",
       "      <span class=&quot;errors&quot; id=&quot;error-message&quot;></span>\n",
       "    </section>\n",
       "  </section>\n",
       "\n",
       "  <details class=&quot;error-details&quot;>\n",
       "    <summary>StackTrace</summary>\n",
       "    <ul id=&quot;error-stacktrace&quot;></ul>\n",
       "  </details>\n",
       "</div>\n",
       "</body>\n",
       "\n",
       "<script>\n",
       "  var init = (function () {\n",
       "  'use strict';\n",
       "\n",
       "  const BASEMAPS = {\n",
       "    DarkMatter: carto.basemaps.darkmatter,\n",
       "    Voyager: carto.basemaps.voyager,\n",
       "    Positron: carto.basemaps.positron\n",
       "  };\n",
       "\n",
       "  const attributionControl = new mapboxgl.AttributionControl({\n",
       "    compact: false\n",
       "  });\n",
       "\n",
       "  const FIT_BOUNDS_SETTINGS = { animate: false, padding: 50, maxZoom: 16 };\n",
       "\n",
       "  /** From https://github.com/errwischt/stacktrace-parser/blob/master/src/stack-trace-parser.js */\n",
       "\n",
       "  /**\n",
       "   * This parses the different stack traces and puts them into one format\n",
       "   * This borrows heavily from TraceKit (https://github.com/csnover/TraceKit)\n",
       "   */\n",
       "\n",
       "  const UNKNOWN_FUNCTION = '<unknown>';\n",
       "  const chromeRe = /^\\s*at (.*?) ?\\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\n",
       "  const chromeEvalRe = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n",
       "  const winjsRe = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n",
       "  const geckoRe = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\\[native).*?|[^@]*bundle)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\n",
       "  const geckoEvalRe = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n",
       "\n",
       "  function parse(stackString) {\n",
       "    const lines = stackString.split('\\n');\n",
       "\n",
       "    return lines.reduce((stack, line) => {\n",
       "      const parseResult =\n",
       "        parseChrome(line) ||\n",
       "        parseWinjs(line) ||\n",
       "        parseGecko(line);\n",
       "\n",
       "      if (parseResult) {\n",
       "        stack.push(parseResult);\n",
       "      }\n",
       "\n",
       "      return stack;\n",
       "    }, []);\n",
       "  }\n",
       "\n",
       "  function parseChrome(line) {\n",
       "    const parts = chromeRe.exec(line);\n",
       "\n",
       "    if (!parts) {\n",
       "      return null;\n",
       "    }\n",
       "\n",
       "    const isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n",
       "    const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n",
       "\n",
       "    const submatch = chromeEvalRe.exec(parts[2]);\n",
       "    if (isEval && submatch != null) {\n",
       "      // throw out eval line/column and use top-most line/column number\n",
       "      parts[2] = submatch[1]; // url\n",
       "      parts[3] = submatch[2]; // line\n",
       "      parts[4] = submatch[3]; // column\n",
       "    }\n",
       "\n",
       "    return {\n",
       "      file: !isNative ? parts[2] : null,\n",
       "      methodName: parts[1] || UNKNOWN_FUNCTION,\n",
       "      arguments: isNative ? [parts[2]] : [],\n",
       "      lineNumber: parts[3] ? +parts[3] : null,\n",
       "      column: parts[4] ? +parts[4] : null,\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function parseWinjs(line) {\n",
       "    const parts = winjsRe.exec(line);\n",
       "\n",
       "    if (!parts) {\n",
       "      return null;\n",
       "    }\n",
       "\n",
       "    return {\n",
       "      file: parts[2],\n",
       "      methodName: parts[1] || UNKNOWN_FUNCTION,\n",
       "      arguments: [],\n",
       "      lineNumber: +parts[3],\n",
       "      column: parts[4] ? +parts[4] : null,\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function parseGecko(line) {\n",
       "    const parts = geckoRe.exec(line);\n",
       "\n",
       "    if (!parts) {\n",
       "      return null;\n",
       "    }\n",
       "\n",
       "    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n",
       "\n",
       "    const submatch = geckoEvalRe.exec(parts[3]);\n",
       "    if (isEval && submatch != null) {\n",
       "      // throw out eval line/column and use top-most line number\n",
       "      parts[3] = submatch[1];\n",
       "      parts[4] = submatch[2];\n",
       "      parts[5] = null; // no column when eval\n",
       "    }\n",
       "\n",
       "    return {\n",
       "      file: parts[3],\n",
       "      methodName: parts[1] || UNKNOWN_FUNCTION,\n",
       "      arguments: parts[2] ? parts[2].split(',') : [],\n",
       "      lineNumber: parts[4] ? +parts[4] : null,\n",
       "      column: parts[5] ? +parts[5] : null,\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function displayError(e) {\n",
       "    const error$ = document.getElementById('error-container');\n",
       "    const errors$ = error$.getElementsByClassName('errors');\n",
       "    const stacktrace$ = document.getElementById('error-stacktrace');\n",
       "\n",
       "    errors$[0].innerHTML = e.name;\n",
       "    errors$[1].innerHTML = e.type;\n",
       "    errors$[2].innerHTML = e.message.replace(e.type, '');\n",
       "\n",
       "    error$.style.visibility = 'visible';\n",
       "\n",
       "    const stack = parse(e.stack);\n",
       "    const list = stack.map(item => {\n",
       "      return `<li>\n",
       "      at <span class=&quot;stacktrace-method&quot;>${item.methodName}:</span>\n",
       "      (${item.file}:${item.lineNumber}:${item.column})\n",
       "    </li>`;\n",
       "    });\n",
       "\n",
       "    stacktrace$.innerHTML = list.join('\\n');\n",
       "  }\n",
       "\n",
       "  // Computes the decimal coefficient and exponent of the specified number x with\n",
       "  // significant digits p, where x is positive and p is in [1, 21] or undefined.\n",
       "  // For example, formatDecimal(1.23) returns [&quot;123&quot;, 0].\n",
       "  function formatDecimal(x, p) {\n",
       "    if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf(&quot;e&quot;)) < 0) return null; // NaN, ±Infinity\n",
       "    var i, coefficient = x.slice(0, i);\n",
       "\n",
       "    // The string returned by toExponential either has the form \\d\\.\\d+e[-+]\\d+\n",
       "    // (e.g., 1.2e+3) or the form \\de[-+]\\d+ (e.g., 1e+3).\n",
       "    return [\n",
       "      coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,\n",
       "      +x.slice(i + 1)\n",
       "    ];\n",
       "  }\n",
       "\n",
       "  function exponent(x) {\n",
       "    return x = formatDecimal(Math.abs(x)), x ? x[1] : NaN;\n",
       "  }\n",
       "\n",
       "  function formatGroup(grouping, thousands) {\n",
       "    return function(value, width) {\n",
       "      var i = value.length,\n",
       "          t = [],\n",
       "          j = 0,\n",
       "          g = grouping[0],\n",
       "          length = 0;\n",
       "\n",
       "      while (i > 0 && g > 0) {\n",
       "        if (length + g + 1 > width) g = Math.max(1, width - length);\n",
       "        t.push(value.substring(i -= g, i + g));\n",
       "        if ((length += g + 1) > width) break;\n",
       "        g = grouping[j = (j + 1) % grouping.length];\n",
       "      }\n",
       "\n",
       "      return t.reverse().join(thousands);\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function formatNumerals(numerals) {\n",
       "    return function(value) {\n",
       "      return value.replace(/[0-9]/g, function(i) {\n",
       "        return numerals[+i];\n",
       "      });\n",
       "    };\n",
       "  }\n",
       "\n",
       "  // [[fill]align][sign][symbol][0][width][,][.precision][~][type]\n",
       "  var re = /^(?:(.)?([<>=^]))?([+\\-( ])?([$#])?(0)?(\\d+)?(,)?(\\.\\d+)?(~)?([a-z%])?$/i;\n",
       "\n",
       "  function formatSpecifier(specifier) {\n",
       "    if (!(match = re.exec(specifier))) throw new Error(&quot;invalid format: &quot; + specifier);\n",
       "    var match;\n",
       "    return new FormatSpecifier({\n",
       "      fill: match[1],\n",
       "      align: match[2],\n",
       "      sign: match[3],\n",
       "      symbol: match[4],\n",
       "      zero: match[5],\n",
       "      width: match[6],\n",
       "      comma: match[7],\n",
       "      precision: match[8] && match[8].slice(1),\n",
       "      trim: match[9],\n",
       "      type: match[10]\n",
       "    });\n",
       "  }\n",
       "\n",
       "  formatSpecifier.prototype = FormatSpecifier.prototype; // instanceof\n",
       "\n",
       "  function FormatSpecifier(specifier) {\n",
       "    this.fill = specifier.fill === undefined ? &quot; &quot; : specifier.fill + &quot;&quot;;\n",
       "    this.align = specifier.align === undefined ? &quot;>&quot; : specifier.align + &quot;&quot;;\n",
       "    this.sign = specifier.sign === undefined ? &quot;-&quot; : specifier.sign + &quot;&quot;;\n",
       "    this.symbol = specifier.symbol === undefined ? &quot;&quot; : specifier.symbol + &quot;&quot;;\n",
       "    this.zero = !!specifier.zero;\n",
       "    this.width = specifier.width === undefined ? undefined : +specifier.width;\n",
       "    this.comma = !!specifier.comma;\n",
       "    this.precision = specifier.precision === undefined ? undefined : +specifier.precision;\n",
       "    this.trim = !!specifier.trim;\n",
       "    this.type = specifier.type === undefined ? &quot;&quot; : specifier.type + &quot;&quot;;\n",
       "  }\n",
       "\n",
       "  FormatSpecifier.prototype.toString = function() {\n",
       "    return this.fill\n",
       "        + this.align\n",
       "        + this.sign\n",
       "        + this.symbol\n",
       "        + (this.zero ? &quot;0&quot; : &quot;&quot;)\n",
       "        + (this.width === undefined ? &quot;&quot; : Math.max(1, this.width | 0))\n",
       "        + (this.comma ? &quot;,&quot; : &quot;&quot;)\n",
       "        + (this.precision === undefined ? &quot;&quot; : &quot;.&quot; + Math.max(0, this.precision | 0))\n",
       "        + (this.trim ? &quot;~&quot; : &quot;&quot;)\n",
       "        + this.type;\n",
       "  };\n",
       "\n",
       "  // Trims insignificant zeros, e.g., replaces 1.2000k with 1.2k.\n",
       "  function formatTrim(s) {\n",
       "    out: for (var n = s.length, i = 1, i0 = -1, i1; i < n; ++i) {\n",
       "      switch (s[i]) {\n",
       "        case &quot;.&quot;: i0 = i1 = i; break;\n",
       "        case &quot;0&quot;: if (i0 === 0) i0 = i; i1 = i; break;\n",
       "        default: if (!+s[i]) break out; if (i0 > 0) i0 = 0; break;\n",
       "      }\n",
       "    }\n",
       "    return i0 > 0 ? s.slice(0, i0) + s.slice(i1 + 1) : s;\n",
       "  }\n",
       "\n",
       "  var prefixExponent;\n",
       "\n",
       "  function formatPrefixAuto(x, p) {\n",
       "    var d = formatDecimal(x, p);\n",
       "    if (!d) return x + &quot;&quot;;\n",
       "    var coefficient = d[0],\n",
       "        exponent = d[1],\n",
       "        i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1,\n",
       "        n = coefficient.length;\n",
       "    return i === n ? coefficient\n",
       "        : i > n ? coefficient + new Array(i - n + 1).join(&quot;0&quot;)\n",
       "        : i > 0 ? coefficient.slice(0, i) + &quot;.&quot; + coefficient.slice(i)\n",
       "        : &quot;0.&quot; + new Array(1 - i).join(&quot;0&quot;) + formatDecimal(x, Math.max(0, p + i - 1))[0]; // less than 1y!\n",
       "  }\n",
       "\n",
       "  function formatRounded(x, p) {\n",
       "    var d = formatDecimal(x, p);\n",
       "    if (!d) return x + &quot;&quot;;\n",
       "    var coefficient = d[0],\n",
       "        exponent = d[1];\n",
       "    return exponent < 0 ? &quot;0.&quot; + new Array(-exponent).join(&quot;0&quot;) + coefficient\n",
       "        : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + &quot;.&quot; + coefficient.slice(exponent + 1)\n",
       "        : coefficient + new Array(exponent - coefficient.length + 2).join(&quot;0&quot;);\n",
       "  }\n",
       "\n",
       "  var formatTypes = {\n",
       "    &quot;%&quot;: function(x, p) { return (x * 100).toFixed(p); },\n",
       "    &quot;b&quot;: function(x) { return Math.round(x).toString(2); },\n",
       "    &quot;c&quot;: function(x) { return x + &quot;&quot;; },\n",
       "    &quot;d&quot;: function(x) { return Math.round(x).toString(10); },\n",
       "    &quot;e&quot;: function(x, p) { return x.toExponential(p); },\n",
       "    &quot;f&quot;: function(x, p) { return x.toFixed(p); },\n",
       "    &quot;g&quot;: function(x, p) { return x.toPrecision(p); },\n",
       "    &quot;o&quot;: function(x) { return Math.round(x).toString(8); },\n",
       "    &quot;p&quot;: function(x, p) { return formatRounded(x * 100, p); },\n",
       "    &quot;r&quot;: formatRounded,\n",
       "    &quot;s&quot;: formatPrefixAuto,\n",
       "    &quot;X&quot;: function(x) { return Math.round(x).toString(16).toUpperCase(); },\n",
       "    &quot;x&quot;: function(x) { return Math.round(x).toString(16); }\n",
       "  };\n",
       "\n",
       "  function identity(x) {\n",
       "    return x;\n",
       "  }\n",
       "\n",
       "  var map = Array.prototype.map,\n",
       "      prefixes = [&quot;y&quot;,&quot;z&quot;,&quot;a&quot;,&quot;f&quot;,&quot;p&quot;,&quot;n&quot;,&quot;µ&quot;,&quot;m&quot;,&quot;&quot;,&quot;k&quot;,&quot;M&quot;,&quot;G&quot;,&quot;T&quot;,&quot;P&quot;,&quot;E&quot;,&quot;Z&quot;,&quot;Y&quot;];\n",
       "\n",
       "  function formatLocale(locale) {\n",
       "    var group = locale.grouping === undefined || locale.thousands === undefined ? identity : formatGroup(map.call(locale.grouping, Number), locale.thousands + &quot;&quot;),\n",
       "        currencyPrefix = locale.currency === undefined ? &quot;&quot; : locale.currency[0] + &quot;&quot;,\n",
       "        currencySuffix = locale.currency === undefined ? &quot;&quot; : locale.currency[1] + &quot;&quot;,\n",
       "        decimal = locale.decimal === undefined ? &quot;.&quot; : locale.decimal + &quot;&quot;,\n",
       "        numerals = locale.numerals === undefined ? identity : formatNumerals(map.call(locale.numerals, String)),\n",
       "        percent = locale.percent === undefined ? &quot;%&quot; : locale.percent + &quot;&quot;,\n",
       "        minus = locale.minus === undefined ? &quot;-&quot; : locale.minus + &quot;&quot;,\n",
       "        nan = locale.nan === undefined ? &quot;NaN&quot; : locale.nan + &quot;&quot;;\n",
       "\n",
       "    function newFormat(specifier) {\n",
       "      specifier = formatSpecifier(specifier);\n",
       "\n",
       "      var fill = specifier.fill,\n",
       "          align = specifier.align,\n",
       "          sign = specifier.sign,\n",
       "          symbol = specifier.symbol,\n",
       "          zero = specifier.zero,\n",
       "          width = specifier.width,\n",
       "          comma = specifier.comma,\n",
       "          precision = specifier.precision,\n",
       "          trim = specifier.trim,\n",
       "          type = specifier.type;\n",
       "\n",
       "      // The &quot;n&quot; type is an alias for &quot;,g&quot;.\n",
       "      if (type === &quot;n&quot;) comma = true, type = &quot;g&quot;;\n",
       "\n",
       "      // The &quot;&quot; type, and any invalid type, is an alias for &quot;.12~g&quot;.\n",
       "      else if (!formatTypes[type]) precision === undefined && (precision = 12), trim = true, type = &quot;g&quot;;\n",
       "\n",
       "      // If zero fill is specified, padding goes after sign and before digits.\n",
       "      if (zero || (fill === &quot;0&quot; && align === &quot;=&quot;)) zero = true, fill = &quot;0&quot;, align = &quot;=&quot;;\n",
       "\n",
       "      // Compute the prefix and suffix.\n",
       "      // For SI-prefix, the suffix is lazily computed.\n",
       "      var prefix = symbol === &quot;$&quot; ? currencyPrefix : symbol === &quot;#&quot; && /[boxX]/.test(type) ? &quot;0&quot; + type.toLowerCase() : &quot;&quot;,\n",
       "          suffix = symbol === &quot;$&quot; ? currencySuffix : /[%p]/.test(type) ? percent : &quot;&quot;;\n",
       "\n",
       "      // What format function should we use?\n",
       "      // Is this an integer type?\n",
       "      // Can this type generate exponential notation?\n",
       "      var formatType = formatTypes[type],\n",
       "          maybeSuffix = /[defgprs%]/.test(type);\n",
       "\n",
       "      // Set the default precision if not specified,\n",
       "      // or clamp the specified precision to the supported range.\n",
       "      // For significant precision, it must be in [1, 21].\n",
       "      // For fixed precision, it must be in [0, 20].\n",
       "      precision = precision === undefined ? 6\n",
       "          : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision))\n",
       "          : Math.max(0, Math.min(20, precision));\n",
       "\n",
       "      function format(value) {\n",
       "        var valuePrefix = prefix,\n",
       "            valueSuffix = suffix,\n",
       "            i, n, c;\n",
       "\n",
       "        if (type === &quot;c&quot;) {\n",
       "          valueSuffix = formatType(value) + valueSuffix;\n",
       "          value = &quot;&quot;;\n",
       "        } else {\n",
       "          value = +value;\n",
       "\n",
       "          // Determine the sign. -0 is not less than 0, but 1 / -0 is!\n",
       "          var valueNegative = value < 0 || 1 / value < 0;\n",
       "\n",
       "          // Perform the initial formatting.\n",
       "          value = isNaN(value) ? nan : formatType(Math.abs(value), precision);\n",
       "\n",
       "          // Trim insignificant zeros.\n",
       "          if (trim) value = formatTrim(value);\n",
       "\n",
       "          // If a negative value rounds to zero after formatting, and no explicit positive sign is requested, hide the sign.\n",
       "          if (valueNegative && +value === 0 && sign !== &quot;+&quot;) valueNegative = false;\n",
       "\n",
       "          // Compute the prefix and suffix.\n",
       "          valuePrefix = (valueNegative ? (sign === &quot;(&quot; ? sign : minus) : sign === &quot;-&quot; || sign === &quot;(&quot; ? &quot;&quot; : sign) + valuePrefix;\n",
       "          valueSuffix = (type === &quot;s&quot; ? prefixes[8 + prefixExponent / 3] : &quot;&quot;) + valueSuffix + (valueNegative && sign === &quot;(&quot; ? &quot;)&quot; : &quot;&quot;);\n",
       "\n",
       "          // Break the formatted value into the integer “value” part that can be\n",
       "          // grouped, and fractional or exponential “suffix” part that is not.\n",
       "          if (maybeSuffix) {\n",
       "            i = -1, n = value.length;\n",
       "            while (++i < n) {\n",
       "              if (c = value.charCodeAt(i), 48 > c || c > 57) {\n",
       "                valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;\n",
       "                value = value.slice(0, i);\n",
       "                break;\n",
       "              }\n",
       "            }\n",
       "          }\n",
       "        }\n",
       "\n",
       "        // If the fill character is not &quot;0&quot;, grouping is applied before padding.\n",
       "        if (comma && !zero) value = group(value, Infinity);\n",
       "\n",
       "        // Compute the padding.\n",
       "        var length = valuePrefix.length + value.length + valueSuffix.length,\n",
       "            padding = length < width ? new Array(width - length + 1).join(fill) : &quot;&quot;;\n",
       "\n",
       "        // If the fill character is &quot;0&quot;, grouping is applied after padding.\n",
       "        if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = &quot;&quot;;\n",
       "\n",
       "        // Reconstruct the final output based on the desired alignment.\n",
       "        switch (align) {\n",
       "          case &quot;<&quot;: value = valuePrefix + value + valueSuffix + padding; break;\n",
       "          case &quot;=&quot;: value = valuePrefix + padding + value + valueSuffix; break;\n",
       "          case &quot;^&quot;: value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length); break;\n",
       "          default: value = padding + valuePrefix + value + valueSuffix; break;\n",
       "        }\n",
       "\n",
       "        return numerals(value);\n",
       "      }\n",
       "\n",
       "      format.toString = function() {\n",
       "        return specifier + &quot;&quot;;\n",
       "      };\n",
       "\n",
       "      return format;\n",
       "    }\n",
       "\n",
       "    function formatPrefix(specifier, value) {\n",
       "      var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = &quot;f&quot;, specifier)),\n",
       "          e = Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3,\n",
       "          k = Math.pow(10, -e),\n",
       "          prefix = prefixes[8 + e / 3];\n",
       "      return function(value) {\n",
       "        return f(k * value) + prefix;\n",
       "      };\n",
       "    }\n",
       "\n",
       "    return {\n",
       "      format: newFormat,\n",
       "      formatPrefix: formatPrefix\n",
       "    };\n",
       "  }\n",
       "\n",
       "  var locale;\n",
       "  var format;\n",
       "  var formatPrefix;\n",
       "\n",
       "  defaultLocale({\n",
       "    decimal: &quot;.&quot;,\n",
       "    thousands: &quot;,&quot;,\n",
       "    grouping: [3],\n",
       "    currency: [&quot;$&quot;, &quot;&quot;],\n",
       "    minus: &quot;-&quot;\n",
       "  });\n",
       "\n",
       "  function defaultLocale(definition) {\n",
       "    locale = formatLocale(definition);\n",
       "    format = locale.format;\n",
       "    formatPrefix = locale.formatPrefix;\n",
       "    return locale;\n",
       "  }\n",
       "\n",
       "  function formatter(value, specifier) {\n",
       "    const formatFunc = specifier ? format(specifier) : formatValue;\n",
       "\n",
       "    if (Array.isArray(value)) {\n",
       "      const [first, second] = value;\n",
       "      if (first === -Infinity) {\n",
       "        return `< ${formatFunc(second)}`;\n",
       "      }\n",
       "      if (second === Infinity) {\n",
       "        return `> ${formatFunc(first)}`;\n",
       "      }\n",
       "      return `${formatFunc(first)} - ${formatFunc(second)}`;\n",
       "    }\n",
       "    return formatFunc(value);\n",
       "  }\n",
       "\n",
       "  function formatValue(value) {\n",
       "    if (typeof value === 'number') {\n",
       "      return formatNumber(value);\n",
       "    }\n",
       "    return value;\n",
       "  }\n",
       "\n",
       "  function formatNumber(value) {\n",
       "    if (!Number.isInteger(value)) {\n",
       "      return value.toLocaleString(undefined, {\n",
       "        minimumFractionDigits: 2,\n",
       "        maximumFractionDigits: 3\n",
       "      });\n",
       "    }\n",
       "    return value.toLocaleString();\n",
       "  }\n",
       "\n",
       "  function updateViewport(id, map) {\n",
       "    function updateMapInfo() {\n",
       "      const mapInfo$ = document.getElementById(id);\n",
       "      const center = map.getCenter();\n",
       "      const lat = center.lat.toFixed(6);\n",
       "      const lng = center.lng.toFixed(6);\n",
       "      const zoom = map.getZoom().toFixed(2);\n",
       "\n",
       "      mapInfo$.innerText = `viewport={'zoom': ${zoom}, 'lat': ${lat}, 'lng': ${lng}}`;\n",
       "    }\n",
       "\n",
       "    updateMapInfo();\n",
       "\n",
       "    map.on('zoom', updateMapInfo);\n",
       "    map.on('move', updateMapInfo);\n",
       "  }\n",
       "\n",
       "  function getBasecolorSettings(basecolor) {\n",
       "    return {\n",
       "      'version': 8,\n",
       "      'sources': {},\n",
       "      'layers': [{\n",
       "          'id': 'background',\n",
       "          'type': 'background',\n",
       "          'paint': {\n",
       "              'background-color': basecolor\n",
       "          }\n",
       "      }]\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function getImageElement(mapIndex) {\n",
       "    const id = mapIndex !== undefined ? `map-image-${mapIndex}` : 'map-image';\n",
       "    return document.getElementById(id);\n",
       "  }\n",
       "\n",
       "  function getContainerElement(mapIndex) {\n",
       "    const id = mapIndex !== undefined ? `main-container-${mapIndex}` : 'main-container';\n",
       "    return document.getElementById(id);\n",
       "  }\n",
       "\n",
       "  function saveImage(mapIndex) {\n",
       "    const img = getImageElement(mapIndex);\n",
       "    const container = getContainerElement(mapIndex);\n",
       "\n",
       "    html2canvas(container)\n",
       "      .then((canvas) => setMapImage(canvas, img, container));\n",
       "  }\n",
       "\n",
       "  function setMapImage(canvas, img, container) {\n",
       "    const src = canvas.toDataURL();\n",
       "    img.setAttribute('src', src);\n",
       "    img.style.display = 'block';\n",
       "    container.style.display = 'none';\n",
       "  }\n",
       "\n",
       "  function resetPopupClick(interactivity) {\n",
       "    interactivity.off('featureClick');\n",
       "  }\n",
       "\n",
       "  function resetPopupHover(interactivity) {\n",
       "    interactivity.off('featureHover');\n",
       "  }\n",
       "\n",
       "  function setPopupsClick(map, clickPopup, hoverPopup, interactivity, attrs) {\n",
       "    interactivity.on('featureClick', (event) => {\n",
       "      updatePopup(map, clickPopup, event, attrs);\n",
       "      hoverPopup.remove();\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function setPopupsHover(map, hoverPopup, interactivity, attrs) {\n",
       "    interactivity.on('featureHover', (event) => {\n",
       "      updatePopup(map, hoverPopup, event, attrs);\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function updatePopup(map, popup, event, attrs) {\n",
       "    if (event.features.length > 0) {\n",
       "      let popupHTML = '';\n",
       "      const layerIDs = [];\n",
       "\n",
       "      for (const feature of event.features) {\n",
       "        if (layerIDs.includes(feature.layerId)) {\n",
       "          continue;\n",
       "        }\n",
       "        // Track layers to add only one feature per layer\n",
       "        layerIDs.push(feature.layerId);\n",
       "\n",
       "        for (const item of attrs) {\n",
       "          const variable = feature.variables[item.name];\n",
       "          if (variable) {\n",
       "            let value = variable.value;\n",
       "            value = formatter(value, item.format);\n",
       "\n",
       "            popupHTML = `\n",
       "            <span class=&quot;popup-name&quot;>${item.title}</span>\n",
       "            <span class=&quot;popup-value&quot;>${value}</span>\n",
       "          ` + popupHTML;\n",
       "          }\n",
       "        }\n",
       "      }\n",
       "\n",
       "      if (popupHTML) {\n",
       "        popup\n",
       "            .setLngLat([event.coordinates.lng, event.coordinates.lat])\n",
       "            .setHTML(`<div class=&quot;popup-content&quot;>${popupHTML}</div>`);\n",
       "\n",
       "        if (!popup.isOpen()) {\n",
       "          popup.addTo(map);\n",
       "        }\n",
       "      } else {\n",
       "        popup.remove();\n",
       "      }\n",
       "    } else {\n",
       "      popup.remove();\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function setInteractivity(map, interactiveLayers, interactiveMapLayers) {\n",
       "    const interactivity = new carto.Interactivity(interactiveMapLayers);\n",
       "\n",
       "    const clickPopup = new mapboxgl.Popup({\n",
       "      closeButton: true,\n",
       "      closeOnClick: false\n",
       "    });\n",
       "\n",
       "    const hoverPopup = new mapboxgl.Popup({\n",
       "      closeButton: false,\n",
       "      closeOnClick: false\n",
       "    });\n",
       "\n",
       "    const { clickAttrs, hoverAttrs } = _setInteractivityAttrs(interactiveLayers);\n",
       "\n",
       "    resetPopupClick(map);\n",
       "    resetPopupHover(map);\n",
       "\n",
       "    if (clickAttrs.length > 0) {\n",
       "      setPopupsClick(map, clickPopup, hoverPopup, interactivity, clickAttrs);\n",
       "    }\n",
       "\n",
       "    if (hoverAttrs.length > 0) {\n",
       "      setPopupsHover(map, hoverPopup, interactivity, hoverAttrs);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function _setInteractivityAttrs(interactiveLayers) {\n",
       "    let clickAttrs = [];\n",
       "    let hoverAttrs = [];\n",
       "\n",
       "    interactiveLayers.forEach((interactiveLayer) => {\n",
       "      interactiveLayer.interactivity.forEach((interactivityDef) => {\n",
       "        if (interactivityDef.event === 'click') {\n",
       "          clickAttrs = clickAttrs.concat(interactivityDef.attrs);\n",
       "        } else if (interactivityDef.event === 'hover') {\n",
       "          hoverAttrs = hoverAttrs.concat(interactivityDef.attrs);\n",
       "        }\n",
       "      });\n",
       "    });\n",
       "\n",
       "    return { clickAttrs, hoverAttrs };\n",
       "  }\n",
       "\n",
       "  function renderWidget(widget, value) {\n",
       "    widget.element = widget.element || document.querySelector(`#${widget.id}-value`);\n",
       "\n",
       "    if (value && widget.element) {\n",
       "      widget.element.innerText = typeof value === 'number' ? formatter(value, widget.options.format) : value;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function renderBridge(bridge, widget, mapLayer) {\n",
       "    widget.element = widget.element || document.querySelector(`#${widget.id}`);\n",
       "\n",
       "    switch (widget.type) {\n",
       "      case 'histogram':\n",
       "        const type = _getWidgetType(mapLayer, widget.value, widget.prop);\n",
       "        const histogram = type === 'category' ? 'categoricalHistogram' : 'numericalHistogram';\n",
       "        bridge[histogram](widget.element, widget.value, widget.options);\n",
       "        break;\n",
       "      case 'category':\n",
       "        bridge.category(widget.element, widget.value, widget.options);\n",
       "        break;\n",
       "      case 'animation':\n",
       "        widget.options.propertyName = widget.prop;\n",
       "        bridge.animationControls(widget.element, widget.value, widget.options);\n",
       "        break;\n",
       "      case 'time-series':\n",
       "        widget.options.propertyName = widget.prop;\n",
       "        bridge.timeSeries(widget.element, widget.value, widget.options);\n",
       "        break;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function bridgeLayerWidgets(map, mapLayer, mapSource, widgets) {\n",
       "    const bridge = new AsBridge.VL.Bridge({\n",
       "      carto: carto,\n",
       "      layer: mapLayer,\n",
       "      source: mapSource,\n",
       "      map: map\n",
       "    });\n",
       "\n",
       "    widgets\n",
       "      .filter((widget) => widget.has_bridge)\n",
       "      .forEach((widget) => renderBridge(bridge, widget, mapLayer));\n",
       "\n",
       "    bridge.build();\n",
       "  }\n",
       "\n",
       "  function _getWidgetType(layer, property, value) {\n",
       "    return layer.metadata && layer.metadata.properties[value] ?\n",
       "      layer.metadata.properties[value].type\n",
       "      : _getWidgetPropertyType(layer, property);\n",
       "  }\n",
       "\n",
       "  function _getWidgetPropertyType(layer, property) {\n",
       "    return layer.metadata && layer.metadata.properties[property] ?\n",
       "      layer.metadata.properties[property].type\n",
       "      : null;\n",
       "  }\n",
       "\n",
       "  function createLegends(layer, legends, layerIndex, mapIndex=0) {\n",
       "    if (legends.length) {\n",
       "      legends.forEach((legend, legendIndex) => _createLegend(layer, legend, layerIndex, legendIndex, mapIndex));\n",
       "    } else {\n",
       "      _createLegend(layer, legends, layerIndex, 0, mapIndex);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function _createLegend(layer, legend, layerIndex, legendIndex, mapIndex=0) {\n",
       "    const element = document.querySelector(`#layer${layerIndex}_map${mapIndex}_legend${legendIndex}`);\n",
       "\n",
       "    if (legend.prop) {\n",
       "      const othersLabel = 'Others';   // TODO: i18n\n",
       "      const prop = legend.prop;\n",
       "      const dynamic = legend.dynamic;\n",
       "      const order = legend.ascending ? 'ASC' : 'DESC';\n",
       "      const variable = legend.variable;\n",
       "      const config = { othersLabel, variable, order };\n",
       "      const formatFunc = (value) => formatter(value, legend.format);\n",
       "      const options = { format: formatFunc, config, dynamic };\n",
       "\n",
       "      if (legend.type.startsWith('size-continuous')) {\n",
       "        config.samples = 4;\n",
       "      }\n",
       "\n",
       "      AsBridge.VL.Legends.rampLegend(element, layer, prop, options);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function SourceFactory() {\n",
       "    const sourceTypes = { GeoJSON, Query, MVT };\n",
       "\n",
       "    this.createSource = (layer) => {\n",
       "      return sourceTypes[layer.type](layer);\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function GeoJSON(layer) {\n",
       "    const options = JSON.parse(JSON.stringify(layer.options));\n",
       "    const data = _decodeJSONData(layer.data, layer.encode_data);\n",
       "\n",
       "    return new carto.source.GeoJSON(data, options);\n",
       "  }\n",
       "\n",
       "  function Query(layer) {\n",
       "    const auth = {\n",
       "      username: layer.credentials.username,\n",
       "      apiKey: layer.credentials.api_key || 'default_public'\n",
       "    };\n",
       "\n",
       "    const config = {\n",
       "      serverURL: layer.credentials.base_url || `https://${layer.credentials.username}.carto.com/`\n",
       "    };\n",
       "\n",
       "    return new carto.source.SQL(layer.data, auth, config);\n",
       "  }\n",
       "\n",
       "  function MVT(layer) {\n",
       "    return new carto.source.MVT(layer.data.file, JSON.parse(layer.data.metadata));\n",
       "  }\n",
       "\n",
       "  function _decodeJSONData(data, encodeData) {\n",
       "    try {\n",
       "      if (encodeData) {\n",
       "        const decodedJSON = pako.inflate(atob(data), { to: 'string' });\n",
       "        return JSON.parse(decodedJSON);\n",
       "      } else {\n",
       "        return JSON.parse(data);\n",
       "      }\n",
       "    } catch(error) {\n",
       "      throw new Error(`\n",
       "      Error: &quot;${error}&quot;. CARTOframes is not able to parse your local data because it is too large.\n",
       "      Please, disable the data compresion with encode_data=False in your Layer class.\n",
       "    `);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  const factory = new SourceFactory();\n",
       "\n",
       "  function initMapLayer(layer, layerIndex, numLayers, hasLegends, map, mapIndex) {\n",
       "    const mapSource = factory.createSource(layer);\n",
       "    const mapViz = new carto.Viz(layer.viz);\n",
       "    const mapLayer = new carto.Layer(`layer${layerIndex}`, mapSource, mapViz);\n",
       "    const mapLayerIndex = numLayers - layerIndex - 1;\n",
       "\n",
       "    try {\n",
       "      mapLayer._updateLayer.catch(displayError);\n",
       "    } catch (e) {\n",
       "      throw e;\n",
       "    }\n",
       "\n",
       "    mapLayer.addTo(map);\n",
       "\n",
       "    setLayerLegend(layer, mapLayerIndex, mapLayer, mapIndex, hasLegends);\n",
       "    setLayerWidgets(map, layer, mapLayer, mapLayerIndex, mapSource);\n",
       "\n",
       "    return mapLayer;\n",
       "  }\n",
       "\n",
       "  function getInteractiveLayers(layers, mapLayers) {\n",
       "    const interactiveLayers = [];\n",
       "    const interactiveMapLayers = [];\n",
       "\n",
       "    layers.forEach((layer, index) => {\n",
       "      if (layer.interactivity) {\n",
       "        interactiveLayers.push(layer);\n",
       "        interactiveMapLayers.push(mapLayers[index]);\n",
       "      }\n",
       "    });\n",
       "\n",
       "    return { interactiveLayers, interactiveMapLayers };\n",
       "  }\n",
       "\n",
       "  function setLayerLegend(layer, mapLayerIndex, mapLayer, mapIndex, hasLegends) {\n",
       "    if (hasLegends && layer.legends) {\n",
       "      createLegends(mapLayer, layer.legends, mapLayerIndex, mapIndex);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function setLayerWidgets(map, layer, mapLayer, mapLayerIndex, mapSource) {\n",
       "    if (layer.widgets.length) {\n",
       "      initLayerWidgets(layer.widgets, mapLayerIndex);\n",
       "      updateLayerWidgets(layer.widgets, mapLayer);\n",
       "      bridgeLayerWidgets(map, mapLayer, mapSource, layer.widgets);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function initLayerWidgets(widgets, mapLayerIndex) {\n",
       "    widgets.forEach((widget, widgetIndex) => {\n",
       "      const id = `layer${mapLayerIndex}_widget${widgetIndex}`;\n",
       "      widget.id = id;\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function updateLayerWidgets(widgets, mapLayer) {\n",
       "    mapLayer.on('updated', () => renderLayerWidgets(widgets, mapLayer));\n",
       "  }\n",
       "\n",
       "  function renderLayerWidgets(widgets, mapLayer) {\n",
       "    const variables = mapLayer.viz.variables;\n",
       "\n",
       "    widgets\n",
       "      .filter((widget) => !widget.has_bridge)\n",
       "      .forEach((widget) => {\n",
       "        const name = widget.variable_name;\n",
       "        const value = getWidgetValue(name, variables);\n",
       "        renderWidget(widget, value);\n",
       "      });\n",
       "  }\n",
       "\n",
       "  function getWidgetValue(name, variables) {\n",
       "    return name && variables[name] ? variables[name].value : null;\n",
       "  }\n",
       "\n",
       "  function setReady(settings) {\n",
       "    try {\n",
       "      return settings.maps ? initMaps(settings.maps) : initMap(settings);\n",
       "    } catch (e) {\n",
       "      displayError(e);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function initMaps(maps) {\n",
       "    return maps.map((mapSettings, mapIndex) => {\n",
       "      return initMap(mapSettings, mapIndex);\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function initMap(settings, mapIndex) {\n",
       "    const basecolor = getBasecolorSettings(settings.basecolor);\n",
       "    const basemapStyle =  BASEMAPS[settings.basemap] || settings.basemap || basecolor;\n",
       "    const container = mapIndex !== undefined ? `map-${mapIndex}` : 'map';\n",
       "    const map = createMap(container, basemapStyle, settings.bounds, settings.mapboxtoken);\n",
       "\n",
       "    if (settings.show_info) {\n",
       "      const id = mapIndex !== undefined ? `map-info-${mapIndex}` : 'map-info';\n",
       "      updateViewport(id, map);\n",
       "    }\n",
       "\n",
       "    if (settings.camera) {\n",
       "      map.flyTo(settings.camera);\n",
       "    }\n",
       "\n",
       "    return initLayers(map, settings, mapIndex);\n",
       "  }\n",
       "\n",
       "  function initLayers(map, settings, mapIndex) {\n",
       "    const numLayers = settings.layers.length;\n",
       "    const hasLegends = settings.has_legends;\n",
       "    const isStatic = settings.is_static;\n",
       "    const layers = settings.layers;\n",
       "    const mapLayers = getMapLayers(\n",
       "      layers,\n",
       "      numLayers,\n",
       "      hasLegends,\n",
       "      map,\n",
       "      mapIndex\n",
       "    );\n",
       "\n",
       "    if (settings.layer_selector) {\n",
       "      addLayersSelector(layers.reverse(), mapLayers.reverse(), mapIndex);\n",
       "    }\n",
       "\n",
       "    setInteractiveLayers(map, layers, mapLayers);\n",
       "\n",
       "    return waitForMapLayersLoad(isStatic, mapIndex, mapLayers);\n",
       "  }\n",
       "\n",
       "  function waitForMapLayersLoad(isStatic, mapIndex, mapLayers) {\n",
       "    return new Promise((resolve) => {\n",
       "      carto.on('loaded', mapLayers, onMapLayersLoaded.bind(\n",
       "        this, isStatic, mapIndex, mapLayers, resolve)\n",
       "      );\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function onMapLayersLoaded(isStatic, mapIndex, mapLayers, resolve) {\n",
       "    if (isStatic) {\n",
       "      saveImage(mapIndex);\n",
       "    }\n",
       "\n",
       "    resolve(mapLayers);\n",
       "  }\n",
       "\n",
       "  function getMapLayers(layers, numLayers, hasLegends, map, mapIndex) {\n",
       "    return layers.map((layer, layerIndex) => {\n",
       "      return initMapLayer(layer, layerIndex, numLayers, hasLegends, map, mapIndex);\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function setInteractiveLayers(map, layers, mapLayers) {\n",
       "    const { interactiveLayers, interactiveMapLayers } = getInteractiveLayers(layers, mapLayers);\n",
       "\n",
       "    if (interactiveLayers && interactiveLayers.length > 0) {\n",
       "      setInteractivity(map, interactiveLayers, interactiveMapLayers);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function addLayersSelector(layers, mapLayers, mapIndex) {\n",
       "    const layerSelectorId = mapIndex !== undefined ? `#layer-selector-${mapIndex}` : '#layer-selector';\n",
       "    const layerSelector$ = document.querySelector(layerSelectorId);\n",
       "    const layersInfo = mapLayers.map((layer, index) => {\n",
       "      return {\n",
       "        title: layers[index].title || `Layer ${index}`,\n",
       "        id: layer.id,\n",
       "        checked: true\n",
       "      };\n",
       "    });\n",
       "\n",
       "    const layerSelector = new AsBridge.VL.Layers(layerSelector$, carto, layersInfo, mapLayers);\n",
       "\n",
       "    layerSelector.build();\n",
       "  }\n",
       "\n",
       "  function createMap(container, basemapStyle, bounds, accessToken) {\n",
       "    const map = createMapboxGLMap(container, basemapStyle, accessToken);\n",
       "\n",
       "    map.addControl(attributionControl);\n",
       "    map.fitBounds(bounds, FIT_BOUNDS_SETTINGS);\n",
       "\n",
       "    return map;\n",
       "  }\n",
       "\n",
       "  function createMapboxGLMap(container, style, accessToken) {\n",
       "    if (accessToken) {\n",
       "      mapboxgl.accessToken = accessToken;\n",
       "    }\n",
       "\n",
       "    return new mapboxgl.Map({\n",
       "      container,\n",
       "      style,\n",
       "      zoom: 9,\n",
       "      dragRotate: false,\n",
       "      attributionControl: false\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function init(settings) {\n",
       "    setReady(settings);\n",
       "  }\n",
       "\n",
       "  return init;\n",
       "\n",
       "}());\n",
       "</script>\n",
       "<script>\n",
       "  document\n",
       "  .querySelector('as-responsive-content')\n",
       "  .addEventListener('ready', () => {\n",
       "    const basecolor = '';\n",
       "    const basemap = 'Positron';\n",
       "    const bounds = [[-122.41652628785, 47.4959893722081], [-122.238951209297, 47.7341365013854]];\n",
       "    const camera = null;\n",
       "    const has_legends = 'False' === 'true';\n",
       "    const is_static = 'None' === 'true';\n",
       "    const layer_selector = 'False' === 'true';\n",
       "    const layers = [{&quot;credentials&quot;: {&quot;api_key&quot;: &quot;default_public&quot;, &quot;base_url&quot;: &quot;https://cartoframes.carto.com&quot;, &quot;username&quot;: &quot;cartoframes&quot;}, &quot;data&quot;: &quot;SELECT * FROM \\&quot;cartoframes\\&quot;.\\&quot;seattle_collisions\\&quot;&quot;, &quot;encode_data&quot;: true, &quot;has_legend_list&quot;: true, &quot;interactivity&quot;: [], &quot;legends&quot;: [], &quot;map_index&quot;: 0, &quot;options&quot;: {}, &quot;source&quot;: &quot;SELECT * FROM \\&quot;cartoframes\\&quot;.\\&quot;seattle_collisions\\&quot;&quot;, &quot;title&quot;: null, &quot;type&quot;: &quot;Query&quot;, &quot;viz&quot;: &quot;@vdd4fd2: prop(\\u0027vehcount\\u0027)\\ncolor: hex(\\&quot;#EE4D5A\\&quot;)\\nstrokeColor: opacity(#222,ramp(linear(zoom(),0,18),[0,0.6]))\\nstrokeWidth: ramp(linear(zoom(),0,18),[0,1])\\nwidth: ramp(linear(zoom(),0,18),[2,10])\\n&quot;, &quot;widgets&quot;: [{&quot;description&quot;: &quot;Select a range of values to filter&quot;, &quot;footer&quot;: &quot;&quot;, &quot;has_bridge&quot;: true, &quot;options&quot;: {&quot;autoplay&quot;: true, &quot;buckets&quot;: 9, &quot;format&quot;: null, &quot;readOnly&quot;: false, &quot;weight&quot;: 1}, &quot;prop&quot;: &quot;&quot;, &quot;title&quot;: &quot;Number of Vehicles Involved&quot;, &quot;type&quot;: &quot;histogram&quot;, &quot;value&quot;: &quot;vehcount&quot;, &quot;variable_name&quot;: &quot;vdd4fd2&quot;}]}];\n",
       "    const mapboxtoken = '';\n",
       "    const show_info = 'None' === 'true';\n",
       "\n",
       "    init({\n",
       "      basecolor,\n",
       "      basemap,\n",
       "      bounds,\n",
       "      camera,\n",
       "      has_legends,\n",
       "      is_static,\n",
       "      layer_selector,\n",
       "      layers,\n",
       "      mapboxtoken,\n",
       "      show_info\n",
       "    });\n",
       "});\n",
       "</script>\n",
       "</html>\n",
       "\">\n",
       "\n",
       "</iframe>"
      ],
      "text/plain": [
       "<cartoframes.viz.layer.Layer at 0x7f6104134760>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from cartoframes.viz import Layer, histogram_widget\n",
    "\n",
    "Layer(\n",
    "    'seattle_collisions',\n",
    "    widgets=[\n",
    "        histogram_widget(\n",
    "            'vehcount',\n",
    "            title='Number of Vehicles Involved',\n",
    "            description='Select a range of values to filter',\n",
    "            buckets=9\n",
    "        )\n",
    "    ]\n",
    ")"
   ]
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}