mapbox/mapboxgl-jupyter

Use Mapbox GL JS to visualize data in a Python Jupyter notebook

Location Data Visualization library for Jupyter Notebooks

Library documentation at https://mapbox-mapboxgl-jupyter.readthedocs-hosted.com/en/latest/.

Create Mapbox GL JS data visualizations natively in Jupyter Notebooks with Python and Pandas. mapboxgl is a high-performance, interactive, WebGL-based data visualization tool that drops directly into Jupyter. mapboxgl is similar to Folium built on top of the raster Leaflet map library, but with much higher performance for large data sets using WebGL and Mapbox Vector Tiles.

Try out the interactive map example notebooks from the /examples directory in this repository

1. Categorical points
2. All visualization types
3. Choropleth Visualization types
4. Image Visualization types
5. Raster Tile Visualization types

Installation

$ pip install mapboxgl

Documentation

Documentation is on Read The Docs at https://mapbox-mapboxgl-jupyter.readthedocs-hosted.com/en/latest/.

Usage

The examples directory contains sample Jupyter notebooks demonstrating usage.

import os

import pandas as pd

from mapboxgl.utils import create_color_stops, df_to_geojson
from mapboxgl.viz import CircleViz


# Load data from sample csv
data_url = 'https://raw.githubusercontent.com/mapbox/mapboxgl-jupyter/master/examples/data/points.csv'
df = pd.read_csv(data_url)

# Must be a public token, starting with `pk`
token = os.getenv('MAPBOX_ACCESS_TOKEN')

# Create a geojson file export from a Pandas dataframe
df_to_geojson(df, filename='points.geojson',
              properties=['Avg Medicare Payments', 'Avg Covered Charges', 'date'],
              lat='lat', lon='lon', precision=3)

# Generate data breaks and color stops from colorBrewer
color_breaks = [0,10,100,1000,10000]
color_stops = create_color_stops(color_breaks, colors='YlGnBu')

# Create the viz from the dataframe
viz = CircleViz('points.geojson',
                access_token=token,
                height='400px',
                color_property = "Avg Medicare Payments",
                color_stops = color_stops,
                center = (-95, 40),
                zoom = 3,
                below_layer = 'waterway-label'
              )
viz.show()

Development

Install the python library locally with pip:

$ pip install -e .

To run tests use pytest:

$ pip install mock pytest
$ python -m pytest

To run the Jupyter examples,

$ cd examples
$ pip install jupyter
$ jupyter notebook

We follow the PEP8 style guide for Python for all Python code.

Release process

• After merging all relevant PRs for the upcoming release, pull the master branch

  • git checkout master
  • git pull

• Update the version number in mapboxgl/__init__.py and push directly to master.

• Tag the release

  • git tag <version>
  • git push --tags

• Setup for pypi (one time only)

  • You'll need to pip install twine and set up your credentials in a ~/.pypirc file.

• Create the release files

  • rm dist/* # clean out old releases if they exist
  • python setup.py sdist bdist_wheel

• Upload the release files

  • twine upload dist/mapboxgl-*

mapboxgl-jupyter's Issues

Break out common viz fucntions into a base parent class

There are several viz class functions that are common among every viz class type:

• show()
• as_iframe()
• as_image()
• Objects:
  self.access_token = access_token
  self.div_id = div_id
  self.width = width
  self.height = height
  self.data = data
  self.style_url = style_url
  self.center = center
  self.zoom = zoom

We should wrap these functions and common objects in a base parent class, and inherit it for each child viz type.

Save Map to HTML

This is a feature request to save the map to file such that it could be subsequently served to a web browser, a la folium's save (see cell 3 in this example)

Generate entire Mapbox Style sheet in Python thread

Background

Currently, there is business logic occurring in both the Python mapboxgl library and the javascript templates. Since this is a Python library, we should isolate all business logic to Python, and make the Javascript/HTML components true templates only. This should greatly increase supportability of the mapboxgl library as it grows by isolating bugs to Mapbox GL Style Spec changes, which are much rarer than changes to the Mapbox GL JS Javascript library.

Approach

1. Generate a complete Mapbox GL Style Sheet in a Python dictionary in the viz.py
2. Serve the JSON-format style sheet to the HTML template via a the Jupyter Notebook local web server.
3. Each time the analysis updates, the templates do not need to be destroyed & recreated. The map style simply updates with map.setStyle(newStyleURL)

cc @perrygeo

Circle Overlapping

I am showing near 40k data and someplace circle overlapping is happening I want to see all circle separately.is there any property i can use.

Enable `data` for any viz to come from a vector tile source

Problem

Currently, each viz class data object only supports geojson format data from a URL or local variable geoJSON format object. We should enable users to pass a data as a vector tile source.

Implementation

I propose we maintain that the data object should be a URL or local geoJSON format object. We can add another optional parameter to each parent viz class named vector_source_layername. This will parameter specifies the name of the vector tile layer to create the visual from a layer in a vector tile.

If the user passes the optional vector_source_layername parameter, the visualization will create a layer from a vector tile source instead of a geojson source.

Bug in `GraduatedCircleViz` with `radius_function_type='match'`?

I believe I'm seeing a bug in GraduatedCircleViz.

Here's the JS console error:

Error: layers.circle.paint.circle-radius[4]: Expected number but found string instead.
emitErrors — validate_style.js:10
addLayer — style.js:531
addLayer — map.js:1125

Here's the paint it is attempting to set on the layer, which is failing validation (I believe this is because my default radius has at some point been converted from a number to a string):

{
    "circle-color": [
        "match", [
            "get",
            "category"
        ],
        "A",
        "rgb(255,0,0)",
        "B",
        "rgb(255,255,0)",
        "C",
        "rgb(0,255,0)",
        "D",
        "rgb(0,255,255)",
        "E",
        "rgb(0,0,255)",
        "gray"
    ],
    "circle-radius": [
        "match", [
            "get",
            "category"
        ],
        "A", 1,
        "B", 2,
        "C", 3,
        "D", 4,
        "E", 5,
        "10"
    ],
    "circle-stroke-color": "grey",
    "circle-stroke-width": [
        "interpolate", [
            "linear"
        ],
        [
            "zoom"
        ], 0, 0.01, 18, 1
    ],
    "circle-opacity": 1
}

Here's my python code:

viz = mapboxgl.viz.GraduatedCircleViz(
    map_geojson, 
    access_token=MAPBOX_ACCESS_TOKEN, 
    # label_property = 'name',
    color_property = 'category',
    color_stops = [
        ['A', 'rgb(255,0,0)'],  
        ['B', 'rgb(255,255,0)'], 
        ['C', 'rgb(0,255,0)'], 
        ['D', 'rgb(0,255,255)'], 
        ['E', 'rgb(0,0,255)'], 
    ],
    color_function_type = 'match',
    color_default = 'gray',
    radius_property = 'category',
    radius_stops = [
        ['A', 1.0],  
        ['B', 2.0], 
        ['C', 3.0], 
        ['D', 4.0], 
        ['E', 5.0]
    ],
    radius_function_type = 'match',
    radius_default = 10,
    center = (-40, 25),
    zoom = 3,
    height='500px'
)
viz.show() 

Feature request: adjusting opacity

I would be lovely to be able to adjust the opacity of the heatmap, graduated circle, and circle layers, so that the underlying streets are visible.

Map Flicker in Chrome, Convert Stops to Expressions

mapboxgl version: 0.1.0

Background

Upgrade GL JS version to fix a common bug in Chrome browsers that causes the map to ficker on render.

Tasks

• Upgrade to GL JS v0.42.1 to address chrome-flicker bug
• Change all property function generation to GL Expression generation.

Radius should be adjustable for `circleViz`

In the current master branch, the radius is not adjustable for the circle visualization. We should add a radius parameter just like the GraduatedCircleViz

Trying to run the example, no points are displayed on the map.

Configuration:

• Python: 3.6.2
• Chrome: Version 61.0.3163.100

The maps is displayed, is correctly centered and zoomed, but no points are displayed.

Add examples/points.csv file

It's really exciting to see this project - there is a definite gap in the market for maps within Jupyter notebooks. Folium doesn't scale well to 1000+ data points.

I noted that for the demo notebook, points.csv is missing. It would be handy to have that file to get up and running as quickly as possible.

Mapboxgl viz types roadmap

This ticket tracks the project roadmap. If you have a specific feature request, please open a new ticket and track there!

Visualization Types

• Circle map
• Graduated Circle map
• Clustered Circle map
• Heatmap
• Raster Tile map
• Image map
• Choropleth (fill map)
• Linestring map
• Arc origin / destination map
• 3D extrusion map
• Symbol map
• 3D terrain / environment map
• Add multiple visualization layers to one map

Utilities

• Export rendered viz to image
• Create viz data directly from Pandas or Geopandas dataframe

Viz interaction

• Hover/Highlight effects for mouseover of features
• Data selection and filtering on map with a lasso, rectangle, and circle selection tool

Improve Legend Design

The current default legend is very basic - we should improve the design with a bit of CSS magic.

Allow selection of points in Map

Rendering points as output of calculations and other processing is a good first step.

A user should be able to select points, and groups of points, for further analysis. This is similar to the Keep Only or Exclude functions that are used in Tableau's mapping functions.

Kept (selected data) or Excluded (All - Selected) should then be exported back to a DF for additional analysis.

MapViz raises a TokenError before checking whether a custom style_url is supplied

Hi,

#57 indicates the library doesn't need a Mapbox token as long as the style_url doesn't use resources from Mapbox APIs but the MapViz class raises a TokenError when access_token is None, even when using a custom style_url .

Cf this line:

mapboxgl-jupyter/mapboxgl/viz.py

Line 42 in e7106f1

if not access_token.startswith('pk'):

Currently we have to pass "pk" in the token attribute to circumvent the issue.

Public documentation

As the API for mapboxgl-jupyter solidifies:

To hit a 1.0 release, we need great documentation. Let's use this ticket to track docs to-dos:

• Create documentation generation framework
• Doc content - viz types
• Doc content - utilities
• Doc content - web hosting

cc/ @perrygeo

Improve documentation about how Mapbox API & Tokens work

Documentation and tests should:

1. How Mapbox GL JS does or does not require a Mapbox Access token.
   • Mapboxgl-Jupyter uses the Mapbox GL Style Spec, an open source specification for map styles.
   • If the style sheet you specify as the style_url does not use resources from Mapbox APIs - which means that you created a style sheet yourself from public or locally hosted map data sources - then a Mapbox Access Token is not required.
2. How user data added to a visualization layer is never sent to Mapbox.
   • Mapbox GL JS renders all data used in a visualization locally on the client using Geojson-VT.
   • No data included as a layer from mapboxgl.viz.*(data) is sent to Mapbox APIs in any way.
3. What metadata about an map tile API request is sent to Mapbox.
   • Creferrer, IP Address, User Agent
4. What a Mapbox Access Token does
   • Associates API requests made to Mapbox with a user account
   • Meters API access based on user account

Test should:

1. Ensure that a local non-Mapbox hosted style sheet and resources work -> #19
2. Ensure that a non-mapbox tile resource, such as ArcGIS server WMS or WFS layer served as Geojson, works appropriately in Mapboxgl-Jupyter.

Fetch data for viz from python web server for jupyter

A CircleViz today requires a Python dictionary formatted as geoJSON. The Python dict is stringified when the user passes the geoJSON-format dict as the data parameter, which in turn is and passed to an HTML-format string object used to create the viz.

To increase the load-time performance and data volume limit the data for the viz could be served from the Python web server back end. This could be accomplished by either saving data to a static file, or directly querying data from a Pandas data frame via an API to geojson.

The Jupyter Notebook Server API we could use for this architecture is here: https://github.com/jupyter/jupyter/wiki/Jupyter-Notebook-Server-API

Add image export function to viz classes

A common data science workflow is to include a static image version of a visual for sharing or screen shot creating.

This could be added as a saveImage() HTML button on a viz class object that downloads the current map viewport as a PNG, or it could be a viz.toImage() python function that outputs a PNG of the viz at the stated zoom, center, pitch, and bearing.

Add text-label option to circle* viz classes

For all circle* viz types, add a parameter option to use a data property as a text-label.

An example of labels on top of circles based on a data property:
https://www.mapbox.com/mapbox-gl-js/example/cluster/

add python2.7 in Travis tests matrix

mapboxgl-jupyter/.travis.yml

Lines 3 to 4 in 506b73c

	- "3.4"
	- "3.6"

we do not run tests for python 2.7

cc @ryanbaumann

df_to_geojson() function should JSON-safe stringify all Pandas datatypes

Problem

Passing a datetime Pandas datatype column to df_to_geojson() as a property output throws a JSON serialization error.

See https://github.com/mapbox/mapboxgl-jupyter/blob/master/mapboxgl/utils.py#L28

Solution

Add a data type check and JSON-safe stringification method for all Pandas datatypes datetime64, timedelta[ns], and boolean .

CircleViz doesn't plot data if color_stops is None

Hi,

I was trying to plot a CircleViz and my points wouldn't appear. Once I supplied the color_stops argument they showed up.
If color_stops are required to plot data they should raise an error when missing, or be set to a meaningful default.
Related to #13 I think.

Cheers

Javascript and HTML templating

Having the js/html portions of the application written as python strings is not ideal for maintenance.

We could instead write them as jinja2 templates in order to make them easier to find and edit.

Add Timeslider option to all visualizations

A time slider/filter is a critical component to many data visualizations. We should start thinking about how to add a time slider component to any viz class type, where a mapboxgl filter could be applied for each time step or filter category in the slider.

Questions to consider:

1. Would users want a filter/time slider with all visualizations?
2. Would we want to handle this at the data level (filter data, then bring to map on each interaction), or at the render level (load all data into map, then filter the data using a mapboxgl layer filter)?

Add splash screen message when access token is not valid

If a user were to have an invalid access token (token deleted or Mapbox account expired) on their visual, we should present a relevant splash screen message. That way a user of the visual understands a) who to contact and b) what to do in the case that a visual has an invalid token.

Default Radius should be `1` for all circle and graduatedCircle visualizaitons

In the current master branch, the radius_default is None. This should be 1.

Geopandas integration

it would be great to have a geopandas integration.
I can envision it working like this (tqdm-pandas style):

import mapboxgl as mbx
import geopandas as gp
mbx.mapboxgl()  # initialisation - checking serial number and adding function to geodataFrame

gdf = gp.read_file('points.geojson')
gdf.mbx_plot(figsize=(18,10), column='Avg Medicare Payments', cmap='...')

it would be awesome ( in my opinion ) to mimic matplotlib-esque interface in this case as much as it is possible - all the way to

ax = gdf.mbx_plot(figsize=(18,10)
gdf2.mbx_plot(ax=ax)  # second layer

Add function for showing map in Databricks notebook

Databricks notebooks use the displayHTML function instead of Jupyter's display function to show HTML in a results pane.

We should adopt the show function to work with dataBricks notebooks, by falling back to the displayHTML function if needed. A secondary option would be to add a viz.showDatabricks() function.

Move create_color_stops function to utils.py

Currently, the create_color_stops function is in colors.py - this is confusing for users, as the majority of utility functions are in utils.py.

Add linestring viz

Create a new Viz class tyle, LinestringViz, that allows a user to create a line map from a geojson source or a vector tile source. Follow the same techniques used to make the Choropleth Viz. #40

Example:

Remove `pysal` as requirement for examples

Problem

Pysal depends on scipy, which can be a difficult dependancy to require users to install to get stared. Removing pysal from the examples should increase a first-time users ease of running the examples.

Solution

Use a pandas.Series.quantile to calculate breaks (instead of jenks / natural breaks with pysal). https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.quantile.html

Jupyterlab extentions

Not exactly related to this project, but still - it would be awesome to have an alternative geojson extension (or alternative engine for the same extension), as current jupyterlab geojson viewer is very, very slow

https://github.com/jupyterlab/jupyter-renderers

Clicking on point should not re-zoom the map

Currently, when a user clicks on a point, the map will snap to that point at the default zoom (or what is specified as a arg).

The map should not zoom out based on interaction with a point

`df_to_geojson` adds properties `latitude` and `longitude`

When converting data using:

df_to_geojson(shocks[["longitude", "latitude"]],properties=None, lat='latitude', lon='longitude')

the resulting JSON looks lilke:

{'features': [{'geometry': {'coordinates': [43.625447000000001,
     1.3775569999999999],
    'type': 'Point'},
   'properties': {'latitude': 43.625447000000001,
    'longitude': 1.3775569999999999},
   'type': 'Feature'},
  {'geometry': {'coordinates': [43.625250000000001, 1.377567],
    'type': 'Point'},
   'properties': {'latitude': 43.625250000000001, 'longitude': 1.377567},
   'type': 'Feature'},
  {'geometry': {'coordinates': [43.625250000000001, 1.377567],
    'type': 'Point'},
   'properties': {'latitude': 43.625250000000001, 'longitude': 1.377567},
   'type': 'Feature'},
  {'geometry': {'coordinates': [43.625312000000001, 1.377515],
    'type': 'Point'},
   'properties': {'latitude': 43.625312000000001, 'longitude': 1.377515},
   'type': 'Feature'},
  {'geometry': {'coordinates': [43.632674999999999, 1.371165],
    'type': 'Point'},
[...]

Is it a desired behaviour?

Streaming data architecture

Investigate creating a streaming data architecture from a Pandas dataframe to a map using the approach in the Smalltalk python library https://github.com/murphy214/smalltalk.

Data does not show in JupyterLab from local geojson file resources

I tried to reproduce the example given in the README with an OpenMapTiles style but the data does not show, I only see the tiles. This is the result:

And this is the code:

import pandas as pd
import os

from mapboxgl.utils import *
from mapboxgl.viz import *

# Load data from sample csv
data_url = 'https://raw.githubusercontent.com/mapbox/mapboxgl-jupyter/master/examples/points.csv'
df = pd.read_csv(data_url)

# Create a geojson file export from a Pandas dataframe
df_to_geojson(df, filename='points.geojson',
              properties=['Avg Medicare Payments', 'Avg Covered Charges', 'date'],
              lat='lat', lon='lon', precision=3)

# Generate data breaks and color stops from colorBrewer
color_breaks = [0,10,100,1000,10000]
color_stops = create_color_stops(color_breaks, colors='YlGnBu')

# Create the viz from the dataframe
viz = CircleViz('points.geojson',
                height='400px',
                access_token='pk',
                color_property = "Avg Medicare Payments",
                color_stops = color_stops,
                center = (-95, 40),
                zoom = 3,
                #below_layer = 'waterway-label',
                style_url='https://openmaptiles.github.io/osm-bright-gl-style/style-cdn.json',
              )
viz.show()

I'm using mapboxgl 0.5.1 installed with pip 9.0.1 in Python 3.4 and latest JupyterLab.

Create Anaconda distribution

We should create an auto-deployed Anaconda distribution of mapboxgl-jupyter. Data scientists and analysts frequently use the Anaconda distribution of Python.

Process: https://conda.io/docs/user-guide/tutorials/build-pkgs-skeleton.html

Displaying plots on map, with no property, choosing a colour and a size.

This appears not to be possible currently and it would be a huge gain.

Support for category data in Circle and Graduated Circle Visualization Classes

Noticed you have this on your roadmap - I made some small changes to viz.py, circle.html and graduated_circle.html allowing user to use Mapbox's "categorical" type to assign circle color or radius. My implementation includes properties for default color and radius mentioned in #13 . I have a branch ready to submit as a PR at your convenience.

viz.py

12  class CircleViz(object):
13    """Create a circle map"""
14
15    def __init__(self,
16                 data,
17                 access_token=None,
18                 center=(0, 0),
19                 color_property=None,
20                 color_stops=None,
21                 label_property=None,
22                 color_function_type='interval',
23                 default_color='grey',
24                 div_id='map',
25                 height='500px',
26                 style_url="mapbox://styles/mapbox/light-v9?optimize=true",
27                 width='100%',
28                 zoom=0):

etc.

and

circle.html

41    map.addLayer({
42        "id": "circle",
43        "source": "data",
44        "type": "circle",
45        "paint": {
46            "circle-color": {
47                // Data property to style color by from python variable
48                "property": "{{ colorProperty }}",
49                // Color stops array to use based on data values from python variable
50                "stops": {{ colorStops }},
51                // Type of function to use for assigning colors provided via colorStops
52                "type": "{{ colorType }}",
53                // Default color for if colorProperty does not match any of color stops
54                "default": "{{ defaultColor }}",
55            },
56            "circle-radius" : {
57                "stops": [[0,1], [18,10]]
58            },
59            "circle-stroke-color": "white",
60            "circle-stroke-width": {
61                "stops": [[0,0.01], [18,1]]
62            }
63        }
64    }, "label");

color_property, radius_property not used by ClusteredCircleViz

I'm attempting to use a color_property or radius_property with a ClusteredCircleViz, which the table of params includes. However, from looking at the source and the errors I'm getting, these options don't seem to be present!

Is this an issue with the documentation?

Support multiple layers in a map visualization

Problem

As we add more visualization types, it will be useful to pull in multiple visualization layers into the same visualization. To do this, we'll need an API to addLayer to an existing visualization.

For example, users may want to create a heatmap visualization at low zoom levels, and a graduatedCircle visualization at high zoom levels.

A user may also want to add two or more layers to a map from different data sources.

Implementation

• Add minZoom and maxZoom properties to each viz type
• Create addLayer function to add a layer to an existing viz object

Package Jenks with `mapboxgl` library

Users have reported issues installing the jenks package via

• pip install -e "git+https://github.com/perrygeo/jenks.git#egg=jenks"

We should bundle up jenks with the mapboxgl library, as it will be one of the most common breaks classifiers to use on a domain of values.

cc @perrygeo

Changelog for 0.6.0

Tracking the current changelog for v0.6.0 release, targeting to release this week on pypi:

Breaking changes

• The Viz style_url property is now just style to reflect that a local style sheet may be used, not just a URL

New Features

• Add Raster Tile Viz class #63
• Add Image viz class #61
• Enable custom and local mapboxgl style sheets #59
• TBD: Choropleth Viz support cc/ @akacarlyann #40

Improvements

• Adds label_size, label_color, label_halo_color, label_halo_width, stroke_color, stroke_width properties to all Circle* Viz types
• Improves default style options for circle* viz types
• Adds heatmap_intensity style option
• Removes requirement for any style options to be passed to create a valid Heatmap viz
• Removes requirement for any style options to be passed to create a valid Circle* viz
• Changes default interpolation expression to use an exponential function with base 1.2

Bug fixes

• A list of colors (custom color palettes) now work with utils.create_color_stops() #52
• The radius_default value for GraduatedCircleViz is now set to 1 instead of None #72
• utils.df_to_geojson() now coverts data row-by-row, saving massive amounts of memory when converting large dataframes to geojson files. #69

raster data layers

I see in the roadmap that you want to be able to add raster data layers from numpy arrays.
I wanted that as well so set up a very basic tile server that runs within a jupyter notebook and will project, tile and render a numpy array quickly on the fly.
Its still rough around the edges but works very nicely for me using folium and ipyleaflet to view tiles.
https://github.com/artttt/livemaptiles

support for custom mapboxgl style

It would be nice to be able to load a custom json file with a malboxgl style in it, instead of using mapbox ones.

Add 3D `height` option to ChoroplethViz

Add support to extrude a Choropleth polygon layer. Expose the option as height* properties to the Choropleth Viz.

• height_stops
• height_property
• height_default

Example Viz: 3D Population Density - www.mapbox.com/bites/00273

Add support to show polygons

Hi there,

I would like to add support to show polygons. Before I start with an implementation, I would like to discuss with you the best approach.

I was thinking about the following steps:

1. Create a new template polygon.html.
2. Create in viz.py a new Class PolygonViz.
3. Create in viz.py a new base Class Viz. PolygonViz, GraduatedCircleViz, and CircleViz inherit from this Class. Below is the rough outline of the Viz Class.
4. Create one polygon example jupyter notebook that proves the implementation.

I am happy for any feedback about the above. Since I am new to the project, I am also open for a complete different approach to show polygons.

Looking forward to work on this 😊

---

class Viz(object):
    """Base class for all visualisations"""

    def __init__(self,
                 access_token=None,
                 center=(0, 0),
                 div_id='map',
                 height='500px',
                 style_url="mapbox://styles/mapbox/light-v9?optimize=true",
                 width='100%',
                 zoom=0):

        if access_token is None:
            access_token = os.environ.get('MAPBOX_ACCESS_TOKEN', '')
        if not access_token.startswith('pk'):
            raise TokenError('Mapbox access token must be public (pk)')
        self.access_token = access_token

        self.div_id = div_id
        self.width = width
        self.height = height
        self.data = data
        self.style_url = style_url
        self.center = center
        self.zoom = zoom

    def as_iframe(self, html_data):
        """Build the HTML representation for the mapviz."""
        ...
       
    def show(self, **kwargs):
        """Load the HTML iframe and display the  the iframe in the current jupyter notebook view"""
        ...

Accept custom color palettes in create_color_stops()

Problem

Currently, the create_color_stops function accepts a string that defines a color palette from ColorBrewer. This function should also allow the user to pass a custom color palette as a list of color strings. The documentation claims this is possible today, but it is not yet implemented.

Solution

Make a PR to add support for passing a custom list of colors to create_color_stops -> https://github.com/mapbox/mapboxgl-jupyter/blob/master/mapboxgl/utils.py#L109

cc @pveugen

Propagate errors from Mapbox GL JS

Problem

The Mapbox GL JS library has tons of built-in error checking for tokens, styles, and sources. In order to provide relevant and useful error messages to a user creating a visualization, we'd have to re-create many error checks in the Python mapboxgl library.

Proposal

Propagate errors that affect the visualization (invalid token, invalid Mapbox style sheet, missing source, etc) and throw them from the python mapboxgl code execution. We wouldn't want to propagate all types of errors - only ones that prevent a valid data visualization layer from being drawn on the map, or from the map being initialized.

Reference PR by @EtienneDesticourt - #59 (comment)

@perrygeo @sgillies, any thoughts on this approach?