docs/examples/data_management/read_carto_table.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read data from a CARTO Table\n",
    "\n",
    "This example illustrates how to read data from a CARTO table.\n",
    "\n",
    "> Use this when you need to see or modify the data locally. If you only need to visualize the data, just use the name of the dataset in the Layer: `Layer('dataset_name')`\n",
    "\n",
    "_Note: You'll need [CARTO Account](https://carto.com/signup) credentials to reproduce this example._"
   ]
  },
  {
   "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": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cartodb_id</th>\n",
       "      <th>the_geom</th>\n",
       "      <th>field_1</th>\n",
       "      <th>name</th>\n",
       "      <th>address</th>\n",
       "      <th>revenue</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>POINT (-73.95901 40.67109)</td>\n",
       "      <td>0</td>\n",
       "      <td>Franklin Ave &amp; Eastern Pkwy</td>\n",
       "      <td>341 Eastern Pkwy,Brooklyn, NY 11238</td>\n",
       "      <td>1321040.772</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>POINT (-73.96122 40.57796)</td>\n",
       "      <td>1</td>\n",
       "      <td>607 Brighton Beach Ave</td>\n",
       "      <td>607 Brighton Beach Avenue,Brooklyn, NY 11235</td>\n",
       "      <td>1268080.418</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>POINT (-73.98976 40.61912)</td>\n",
       "      <td>2</td>\n",
       "      <td>65th St &amp; 18th Ave</td>\n",
       "      <td>6423 18th Avenue,Brooklyn, NY 11204</td>\n",
       "      <td>1248133.699</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>POINT (-74.02744 40.63152)</td>\n",
       "      <td>3</td>\n",
       "      <td>Bay Ridge Pkwy &amp; 3rd Ave</td>\n",
       "      <td>7419 3rd Avenue,Brooklyn, NY 11209</td>\n",
       "      <td>1185702.676</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>POINT (-74.00098 40.59321)</td>\n",
       "      <td>4</td>\n",
       "      <td>Caesar's Bay Shopping Center</td>\n",
       "      <td>8973 Bay Parkway,Brooklyn, NY 11214</td>\n",
       "      <td>1148427.411</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   cartodb_id                    the_geom  field_1  \\\n",
       "0           1  POINT (-73.95901 40.67109)        0   \n",
       "1           2  POINT (-73.96122 40.57796)        1   \n",
       "2           3  POINT (-73.98976 40.61912)        2   \n",
       "3           4  POINT (-74.02744 40.63152)        3   \n",
       "4           5  POINT (-74.00098 40.59321)        4   \n",
       "\n",
       "                           name                                       address  \\\n",
       "0   Franklin Ave & Eastern Pkwy           341 Eastern Pkwy,Brooklyn, NY 11238   \n",
       "1        607 Brighton Beach Ave  607 Brighton Beach Avenue,Brooklyn, NY 11235   \n",
       "2            65th St & 18th Ave           6423 18th Avenue,Brooklyn, NY 11204   \n",
       "3      Bay Ridge Pkwy & 3rd Ave            7419 3rd Avenue,Brooklyn, NY 11209   \n",
       "4  Caesar's Bay Shopping Center           8973 Bay Parkway,Brooklyn, NY 11214   \n",
       "\n",
       "       revenue  \n",
       "0  1321040.772  \n",
       "1  1268080.418  \n",
       "2  1248133.699  \n",
       "3  1185702.676  \n",
       "4  1148427.411  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from cartoframes import read_carto\n",
    "\n",
    "gdf = read_carto('starbucks_brooklyn')\n",
    "gdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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",
       "    <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 = [[-74.03313, 40.57796], [-73.87015, 40.6915]];\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;: null, &quot;data&quot;: &quot;H4sIAO8Nyl8C/7XSPW8DIQwG4P/CfD1h82GcNVLn7lWGKKEVUnqcKB2i0/33clwqkZ2OWIZHNu8i8n324iBe/Tn/JH+Mt5u/5BAnMYiPvfYtDu+LCNfSJUv1+UIpzCnOPuWwNS7rID59/PI53cvpr/kthimX1kuM6Rqmc66PvpAa2bCEQcvREkg+revwoKA/ZQFxowwR24bC/pRjsnUqYMCGUp0pPUokrSulwLSU7k9Jya4ukBVCQ5n+C2S0eyyc020sbHfKkQRTKVM22FDUf4FKgXrEAqmh3D8kUJsadstPQ3F/STu9f5VCuQ11Wn8BOR2ZplYEAAA=&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;dateColumns&quot;: []}, &quot;source&quot;: &quot;H4sIAO8Nyl8C/7XSPW8DIQwG4P/CfD1h82GcNVLn7lWGKKEVUnqcKB2i0/33clwqkZ2OWIZHNu8i8n324iBe/Tn/JH+Mt5u/5BAnMYiPvfYtDu+LCNfSJUv1+UIpzCnOPuWwNS7rID59/PI53cvpr/kthimX1kuM6Rqmc66PvpAa2bCEQcvREkg+revwoKA/ZQFxowwR24bC/pRjsnUqYMCGUp0pPUokrSulwLSU7k9Jya4ukBVCQ5n+C2S0eyyc020sbHfKkQRTKVM22FDUf4FKgXrEAqmh3D8kUJsadstPQ3F/STu9f5VCuQ11Wn8BOR2ZplYEAAA=&quot;, &quot;title&quot;: null, &quot;type&quot;: &quot;GeoJSON&quot;, &quot;viz&quot;: &quot;color: 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;: []}];\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 0x7f6b5e729198>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from cartoframes.viz import Layer\n",
    "\n",
    "Layer(gdf)"
   ]
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}