fixups

Author: Joseph Damiba

binder/requirements.txt

@@ -14,4 +14,4 @@ networkx
 scikit-image
 datashader
 pyarrow
-dash_core_components
+cufflinks==0.17.3

doc/python/creating-and-updating-figures.md

@@ -39,11 +39,11 @@ jupyter:
 
 ### Representing Figures
 
-The goal of the `plotly.py` package is to provide a pleasant Python interface for creating figure specifications which are displayed by the [`plotly.js`](https://plot.ly/javascript) JavaScript graphing library. 
+The goal of the plotly.py package is to provide a pleasant Python interface for creating figure specifications which are displayed by the [plotly.js](https://plot.ly/javascript) JavaScript graphing library. 
 
-In the context of the `plotly.js` library, a figure is specified by a declarative [JSON](https://www.json.org/json-en.html) data structure. 
+In the context of the plotly.js library, a figure is specified by a declarative [JSON](https://www.json.org/json-en.html) data structure. 
 
-Therefore, you should always keep in mind as you are creating and updating figures using the `plotly.py` package that its ultimate goal is to help users produce Python [dictionaries](https://docs.python.org/3/tutorial/datastructures.html#dictionaries) that can be automatically [serialized](https://en.wikipedia.org/wiki/Serialization) into the JSON data structure that the `plotly.js` graphing library understands.
+Therefore, you should always keep in mind as you are creating and updating figures using the plotly.py package that its ultimate goal is to help users produce Python [dictionaries](https://docs.python.org/3/tutorial/datastructures.html#dictionaries) that can be automatically [serialized](https://en.wikipedia.org/wiki/Serialization) into the JSON data structure that the plotly.js graphing library understands.
 
 #### Figures As Dictionaries
 
@@ -612,7 +612,7 @@ There are also `for_each_xaxis()` and `for_each_yaxis()` methods that are analog
 
 ### Other Update Methods
 
-Figures created with the `plotly.graph_objects` module also support:
+Figures created with the plotly.py graphing library also support:
     - the `update_layout_images()` method in order to [update background layout images](/python/images/), 
     - `update_annotations()` in order to [update annotations](/python/text-and-annotations/#multiple-annotations), 
     - and `update-shapes()` in order to [update shapes](/python/shapes/).

doc/python/renderers.md

@@ -40,15 +40,15 @@ Plotly's Python graphing library, `plotly.py`, gives you a wide range of options
 
 In general, there are three different approaches you can take in order to display figures:
 
- 1. Using the `renderers` framework in the context of a script or notebook
+ 1. Using the renderers framework in the context of a script or notebook
  2. Using [Dash](https://dash.plot.ly) in a web app context
  3. Using a `FigureWidget` in an `ipywidgets` context
 
 Each of these approaches is discussed below.
 
-### Displaying Figures Using The `renderers` Framework
+### Displaying Figures Using The renderers Framework
 
-The `renderers` framework is a flexible approach for displaying `plotly.py` figures in a variety of contexts.  To display a figure using the `renderers` framework, you call the `show()` method on a graph object figure, or pass the figure to the `plotly.io.show` function. With either approach, `plotly.py` will display the figure using the current default renderer(s).
+The renderers framework is a flexible approach for displaying `plotly.py` figures in a variety of contexts.  To display a figure using the renderers framework, you call the `.show()` method on a graph object figure, or pass the figure to the `plotly.io.show` function. With either approach, `plotly.py` will display the figure using the current default renderer(s).
 
 ```python
 import plotly.graph_objects as go
@@ -59,7 +59,7 @@ fig = go.Figure(
 fig.show()
 ```
 
-In most situations, you can omit the call to `show()` and allow the figure to display itself.
+In most situations, you can omit the call to `.show()` and allow the figure to display itself.
 
 ```python
 import plotly.graph_objects as go
@@ -115,17 +115,17 @@ fig.show(renderer="svg")
 In this section, we will describe the built-in renderers so that you can choose the one(s) that best suit your needs.
 
 ##### Interactive Renderers
-Interactive renderers display figures using the Plotly.js JavaScript library and are fully interactive, supporting pan, zoom, hover tooltips, etc.
+Interactive renderers display figures using the plotly.js JavaScript library and are fully interactive, supporting pan, zoom, hover tooltips, etc.
 
 ###### `notebook`
-This renderer is intended for use in the classic [Jupyter Notebook](https://jupyter.org/install.html) (not JupyterLab).  The full `plotly.js` JavaScript library bundle is added to the notebook the first time a figure is rendered, so this renderer will work without an Internet connection.
+This renderer is intended for use in the classic [Jupyter Notebook](https://jupyter.org/install.html) (not JupyterLab).  The full plotly.js JavaScript library bundle is added to the notebook the first time a figure is rendered, so this renderer will work without an Internet connection.
 
 This renderer is a good choice for notebooks that will be exported to HTML files (Either using [nbconvert](https://nbconvert.readthedocs.io/en/latest/) or the "Download as HTML" menu action) because the exported HTML files will work without an Internet connection.
 
-> Note: Adding the `plotly.js` bundle to the notebook adds a few megabytes to the notebook size. If you can count on always having an Internet connection, you may want to consider using the `notebook_connected` renderer if notebook size is a constraint.
+> Note: Adding the plotly.js bundle to the notebook adds a few megabytes to the notebook size. If you can count on always having an Internet connection, you may want to consider using the `notebook_connected` renderer if notebook size is a constraint.
 
 ###### `notebook_connected`
-This renderer is the same as `notebook` renderer, except the `plotly.js` JavaScript library bundle is loaded from an online CDN location.  This saves a few megabytes in notebook size, but an Internet connection is required in order to display figures that are rendered this way.
+This renderer is the same as `notebook` renderer, except the plotly.js JavaScript library bundle is loaded from an online CDN location.  This saves a few megabytes in notebook size, but an Internet connection is required in order to display figures that are rendered this way.
 
 This renderer is a good choice for notebooks that will be shared with [nbviewer](https://nbviewer.jupyter.org/) since users must have an active Internet connection to access nbviewer in the first place.
 
@@ -146,7 +146,7 @@ This renderer will open a figure in a browser tab using the default web browser.
 These renderers are the same as the `browser` renderer, but they force the use of a particular browser.
 
 ###### `iframe` and `iframe_connected`
-These renderers write figures out as standalone HTML files and then display [`iframe`](https://www.w3schools.com/html/html_iframe.asp) elements that reference these HTML files. The `iframe` renderer will include the `plotly.js` JavaScript bundle in each HTML file that is written, while the `iframe_connected` renderer includes only a reference to an online CDN location from which to load `plotly.js`.  Consequently, the `iframe_connected` renderer outputs files that are smaller than the `iframe` renderer, but it requires an Internet connection while the `iframe` renderer can operate offline.
+These renderers write figures out as standalone HTML files and then display [`iframe`](https://www.w3schools.com/html/html_iframe.asp) elements that reference these HTML files. The `iframe` renderer will include the plotly.js JavaScript bundle in each HTML file that is written, while the `iframe_connected` renderer includes only a reference to an online CDN location from which to load plotly.js.  Consequently, the `iframe_connected` renderer outputs files that are smaller than the `iframe` renderer, but it requires an Internet connection while the `iframe` renderer can operate offline.
 
 This renderer may be useful when working with notebooks than contain lots of large figures.  When using the `notebook` or `notebook_connected` renderer, all of the data for all of the figures in a notebook are stored inline in the notebook itself. If this would result in a prohibitively large notebook size, an `iframe` or `iframe_connected` renderer could be used instead. With the `iframe` renderers, the figure data are stored in the individual HTML files rather than in the notebook itself, resulting in a smaller notebook size.
 
@@ -175,16 +175,16 @@ fig = go.Figure(
 fig.show(renderer="png")
 ```
 
-###### `pdf`
-This renderer displays figures as static `.pdf` files. This is especially useful for notebooks that will be exported to `.pdf` files using the `LaTeX` export capabilities of `nbconvert`.
+###### PDF
+This renderer displays figures as static PDF files. This is especially useful for notebooks that will be exported to PDF files using the LaTeX export capabilities of [`nbconvert`](https://nbconvert.readthedocs.io/en/latest/).
 
 ##### Other Miscellaneous Renderers
 
-###### `json`
+###### JSON
 In editors that support it (JupyterLab, nteract, and the Visual Studio Code notebook interface), this renderer displays the JSON representation of a figure in a collapsible interactive tree structure.  This can be very useful for examining the structure of complex figures.
 
 ##### Multiple Renderers
-You can specify that multiple renderers should be used by joining their names on `"+"` characters.  This is useful when writing code that needs to support multiple contexts.  For example, if a notebook specifies a default renderer string of  `"notebook+plotly_mimetype+pdf"`then this notebook would be able to run in the classic Jupyter Notebook, in JupyterLab, and it would support being exported to `.pdf` using `nbconvert`.
+You can specify that multiple renderers should be used by joining their names on `"+"` characters.  This is useful when writing code that needs to support multiple contexts.  For example, if a notebook specifies a default renderer string of  `"notebook+plotly_mimetype+pdf"`then this notebook would be able to run in the classic Jupyter Notebook, in JupyterLab, and it would support being exported to PDF using `nbconvert`.
 
 #### Customizing Built-In Renderers
 Most built-in renderers have configuration options to customize their behavior.  To view a description of a renderer, including its configuration options, access the renderer object using dictionary-style key lookup on the `plotly.io.renderers` configuration object and then display it.  Here is an example of accessing and displaying the `png` renderer.
@@ -228,13 +228,15 @@ fig.show(renderer="png", width=800, height=300)
 ```
 
 ### Displaying Figures Using Dash
+
 [Dash](https://dash.plot.ly) is a Python framework for building web applications, and it provides built-in support for displaying figures created with Plotly's graphing libraries. See the [Dash User Guide](https://dash.plot.ly/) for more information.
 
-It is important to note that Dash does not use the renderers framework discussed above, so you should not use the `show()` figure method or the `plotly.io.show` function inside Dash applications.
+It is important to note that Dash does not use the renderers framework discussed above, so you should not try to use the `.show()` figure method or the `plotly.io.show` function to render figures inside Dash applications.
 
-Instead, pass your figure as the `figure` parameter to the `dcc.Graph` component. 
+Instead, pass your figure as the `figure` parameter to the [`dcc.Graph`](https://dash.plot.ly/dash-core-components/graph) component, which is part of the [Dash Core Components](https://dash.plot.ly/dash-core-components) library. The code below demonstrates how to do this. 
 
-```python
+
+```python .noeval
 import dash_core_components as dcc
 import plotly.graph_objs as go
 
@@ -246,6 +248,7 @@ dcc.Graph(
     )
 ```
 
+
 ## Displaying Figures Using `ipywidgets`
 Plotly figures can be displayed in [ipywidgets](https://ipywidgets.readthedocs.io/en/stable/) contexts using `plotly.graph_objects.FigureWidget` objects.  `FigureWidget` is a figure graph object (just like `plotly.graph_objects.Figure`), so you can add traces to it and update it just like a regular `Figure`.  But `FigureWidget` is also an `ipywidgets` object, which means that you can display it alongside other `ipywidgets` to build user interfaces right in the notebook.  
 

doc/python/subplots.md

@@ -37,9 +37,7 @@ jupyter:
 
 #### Simple Subplot
 
-Figures with subplots are created using the `make_subplots()` function from the `plotly.subplots` module. 
-
-This function accepts two integer parameters (`rows` and `cols`), which specifiy how the subplots should be laid out.
+Figures with subplots are created using the `make_subplots` function from the `plotly.subplots` module. 
 
 Here is an example of creating a figure that includes two `scatter` traces which are side-by-side since there are 2 columns and 1 row in the subplot layout.
 
@@ -185,7 +183,7 @@ fig.show()
 ```
 
 #### Customize Subplot Column Widths and Row Heights
-The `column_widths` argument to `make_subplots()` can be used to customize the relative widths of the columns in a subplot grid. It should be set to a list of numbers with a length that matches the `cols` argument.  These number will be normalized, so that they sum to 1, and used to compute the relative widths of the subplot grid columns. The `row_heights` argument serves the same purpose for controlling the relative heights of rows in the subplot grid.
+The `column_widths` argument to `make_subplots` can be used to customize the relative widths of the columns in a subplot grid. It should be set to a list of numbers with a length that matches the `cols` argument.  These number will be normalized, so that they sum to 1, and used to compute the relative widths of the subplot grid columns. The `row_heights` argument serves the same purpose for controlling the relative heights of rows in the subplot grid.
 
 Here is an example of creating a figure with two scatter traces in side-by-side subplots. The left subplot is set to be wider than the right one.
 
@@ -205,9 +203,9 @@ fig.show()
 ```
 
 #### Customizing Subplot Axes
-After a figure with subplots is created using the `make_subplots()` function, its axis properties (title, font, range, grid style, etc.) can be customized using the `update_xaxes` and `update_yaxes` graph object figure methods.  By default, these methods apply to all of the `x` axes or `y` axes in the figure. The `row` and `col` arguments can be used to control which axes are targeted by the update.
+After a figure with subplots is created using the `make_subplots` function, its axis properties (title, font, range, grid style, etc.) can be customized using the `update_xaxes` and `update_yaxes` graph object figure methods.  By default, these methods apply to all of the x axes or y axes in the figure. The `row` and `col` arguments can be used to control which axes are targeted by the update.
 
-Here is an example that creates a figure with a 2 x 2 subplot grid, populates each subplot with a scatter trace, and then updates the `x` and `y` axis titles for each subplot individually.
+Here is an example that creates a figure with a 2 x 2 subplot grid, populates each subplot with a scatter trace, and then updates the x and y axis titles for each subplot individually.
 
 ```python
 from plotly.subplots import make_subplots
@@ -243,9 +241,9 @@ fig.show()
 ```
 
 #### Subplots with Shared X-Axes
-The `shared_xaxes` argument to `make_subplots()` can be used to link the x axes of subplots in the resulting figure. The `vertical_spacing` argument is used to control the vertical spacing between rows in the subplot grid.
+The `shared_xaxes` argument to `make_subplots` can be used to link the x axes of subplots in the resulting figure. The `vertical_spacing` argument is used to control the vertical spacing between rows in the subplot grid.
 
-Here is an example that creates a figure with 3 vertically stacked subplots with linked `x` axes. A small vertical spacing value is used to reduce the spacing between subplot rows.
+Here is an example that creates a figure with 3 vertically stacked subplots with linked x axes. A small vertical spacing value is used to reduce the spacing between subplot rows.
 
 ```python
 from plotly.subplots import make_subplots
@@ -270,9 +268,9 @@ fig.show()
 ```
 
 #### Subplots with Shared Y-Axes
-The `shared_yaxes` argument to `make_subplots()` can be used to link the `y` axes of subplots in the resulting figure.
+The `shared_yaxes` argument to `make_subplots` can be used to link the y axes of subplots in the resulting figure.
 
-Here is an example that creates a figure with a 2 x 2 subplot grid, where the `y` axes of each row are linked.
+Here is an example that creates a figure with a 2 x 2 subplot grid, where the y axes of each row are linked.
 
 
 ```python
@@ -321,7 +319,7 @@ fig.show()
 ```
 
 #### Custom Sized Subplot with Subplot Titles
-The `specs` argument to `make_subplots()` is used to configure per-subplot options.  `specs` must be a 2-dimension list with dimensions that match those provided as the `rows` and `cols` arguments. The elements of `specs` may either be `None`, indicating no subplot should be initialized starting with this grid cell, or a dictionary containing subplot options.  The `colspan` subplot option specifies the number of grid columns that the subplot starting in the given cell should occupy.  If unspecified, `colspan` defaults to 1.
+The `specs` argument to `make_subplots` is used to configure per-subplot options.  `specs` must be a 2-dimension list with dimensions that match those provided as the `rows` and `cols` arguments. The elements of `specs` may either be `None`, indicating no subplot should be initialized starting with this grid cell, or a dictionary containing subplot options.  The `colspan` subplot option specifies the number of grid columns that the subplot starting in the given cell should occupy.  If unspecified, `colspan` defaults to 1.
 
 Here is an example that creates a 2 by 2 subplot grid containing 3 subplots.  The subplot `specs` element for position (2, 1) has a `colspan` value of 2, causing it to span the full figure width. The subplot `specs` element for position (2, 2) is `None` because no subplot begins at this location in the grid.
 
@@ -348,7 +346,7 @@ fig.show()
 ```
 
 #### Multiple Custom Sized Subplots
-If the `print_grid` argument to `make_subplots()` is set to `True`, then a text representation of the subplot grid will be printed.
+If the `print_grid` argument to `make_subplots` is set to `True`, then a text representation of the subplot grid will be printed.
 
 Here is an example that uses the `rowspan` and `colspan` subplot options to create a custom subplot layout with subplots of mixed sizes. The `print_grid` argument is set to `True` so that the subplot grid is printed to the screen.
 
@@ -377,7 +375,7 @@ fig.show()
 ```
 
 #### Subplots Types
-By default, the `make_subplots()` function assumes that the traces that will be added to all subplots are 2-dimensional cartesian traces (e.g. `scatter`, `bar`, `histogram`, `violin`, etc.).  Traces with other subplot types (e.g. `scatterpolar`, `scattergeo`, `parcoords`, etc.) are supporteed by specifying the `type` subplot option in the `specs` argument to `make_subplots`.
+By default, the `make_subplots` function assumes that the traces that will be added to all subplots are 2-dimensional cartesian traces (e.g. `scatter`, `bar`, `histogram`, `violin`, etc.).  Traces with other subplot types (e.g. `scatterpolar`, `scattergeo`, `parcoords`, etc.) are supporteed by specifying the `type` subplot option in the `specs` argument to `make_subplots`.
 
 Here are the possible values for the `type` option:
 

doc/requirements.txt

@@ -23,5 +23,4 @@ recommonmark
 pathlib
 python-frontmatter
 datashader
-pyarrow
-dash_core_components
+pyarrow