From 64dc0c9e2d90fa4bc78e7471a5c6af6111f07a1c Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 4 Jun 2019 13:10:39 -0400
Subject: [PATCH 01/34] remove old misspelled supress->suppress fallback

---
 dash/dash.py                     | 11 +++--------
 tests/integration/test_render.py | 10 +++++-----
 2 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index 292d8f207b..9b5058c4ee 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -707,9 +707,7 @@ def _validate_callback(self, output, inputs, state):
                     )
                 )
 
-        if (layout is None and
-                not self.config.first('suppress_callback_exceptions',
-                                      'supress_callback_exceptions')):
+        if (layout is None and not self.config.suppress_callback_exceptions):
             # Without a layout, we can't do validation on the IDs and
             # properties of the elements in the callback.
             raise exceptions.LayoutIsNotDefined('''
@@ -751,8 +749,7 @@ def _validate_callback(self, output, inputs, state):
                         invalid_characters
                     ))
 
-                if (not self.config.first('suppress_callback_exceptions',
-                                          'supress_callback_exceptions') and
+                if (not self.config.suppress_callback_exceptions and
                         arg.component_id not in layout and
                         arg.component_id != getattr(layout, 'id', None)):
                     raise exceptions.NonExistentIdException('''
@@ -775,9 +772,7 @@ def _validate_callback(self, output, inputs, state):
                         )
                     ).replace('    ', ''))
 
-                if not self.config.first('suppress_callback_exceptions',
-                                         'supress_callback_exceptions'):
-
+                if not self.config.suppress_callback_exceptions:
                     if getattr(layout, 'id', None) == arg.component_id:
                         component = layout
                     else:
diff --git a/tests/integration/test_render.py b/tests/integration/test_render.py
index d087ed12cd..364b9dd119 100644
--- a/tests/integration/test_render.py
+++ b/tests/integration/test_render.py
@@ -383,7 +383,7 @@ def pad_output(input):
         call_count = Value('i', 0)
 
         # these components don't exist in the initial render
-        app.config.supress_callback_exceptions = True
+        app.config.suppress_callback_exceptions = True
 
         @app.callback(
             Output('sub-output-1', 'children'),
@@ -536,7 +536,7 @@ def display_chapter(toc_value):
             call_counts['body'].value += 1
             return chapters[toc_value]
 
-        app.config.supress_callback_exceptions = True
+        app.config.suppress_callback_exceptions = True
 
         def generate_graph_callback(counterId):
             def callback(value):
@@ -779,7 +779,7 @@ def update_output(value):
 
         # callback for component that doesn't yet exist in the dom
         # in practice, it might get added by some other callback
-        app.config.supress_callback_exceptions = True
+        app.config.suppress_callback_exceptions = True
         output_2_call_count = Value('i', 0)
 
         @app.callback(
@@ -994,7 +994,7 @@ def test_event_properties_creating_inputs(self):
             script['namespace'] = 'dash_core_components'
             app.scripts.append_script(script)
 
-        app.config.supress_callback_exceptions = True
+        app.config.suppress_callback_exceptions = True
         call_counts = {
             ids['input-output']: Value('i', 0),
             ids['button-output']: Value('i', 0)
@@ -1164,7 +1164,7 @@ def test_removing_component_while_its_getting_updated(self):
             ),
             html.Div(id='body')
         ])
-        app.config.supress_callback_exceptions = True
+        app.config.suppress_callback_exceptions = True
 
         call_counts = {
             'body': Value('i', 0),

From 3be5dc627e8a8df038f3b5b07be357716eebf6f1 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 4 Jun 2019 13:17:03 -0400
Subject: [PATCH 02/34] remove Dash `**kwargs`, unused except to warn about
 csrf removal

---
 dash/dash.py | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index 9b5058c4ee..54fb5013ed 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -9,7 +9,6 @@
 import json
 import pkgutil
 import threading
-import warnings
 import re
 import logging
 import pprint
@@ -107,22 +106,12 @@ def __init__(
             suppress_callback_exceptions=None,
             components_cache_max_age=None,
             show_undo_redo=False,
-            plugins=None,
-            **kwargs):
+            plugins=None):
 
         # Store some flask-related parameters for use in init_app()
         self.compress = compress
         self.name = name
 
-        # pylint-disable: too-many-instance-attributes
-        if 'csrf_protect' in kwargs:
-            warnings.warn('''
-                `csrf_protect` is no longer used,
-                CSRF protection has been removed as it is no longer
-                necessary.
-                See https://github.com/plotly/dash/issues/141 for details.
-                ''', DeprecationWarning)
-
         self._assets_folder = os.path.join(
             flask.helpers.get_root_path(name),
             assets_folder,

From e48b12c796a1bc6808332b98bfa702900212caba Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 4 Jun 2019 14:49:22 -0400
Subject: [PATCH 03/34] remove static_folder kwarg - assets_folder is better

---
 dash/dash.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index 54fb5013ed..9e7f7b3513 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -89,7 +89,6 @@ def __init__(
             self,
             name='__main__',
             server=True,
-            static_folder='static',
             assets_folder='assets',
             assets_url_path='/assets',
             assets_ignore='',
@@ -122,7 +121,7 @@ def __init__(
         # (defer server creation) or a Flask app instance (we use their server)
         if isinstance(server, bool):
             if server:
-                self.server = Flask(name, static_folder=static_folder)
+                self.server = Flask(name)
             else:
                 self.server = None
         elif isinstance(server, Flask):

From 50527e1d11ec4c97c862fa446d33b352758381b7 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 4 Jun 2019 14:50:56 -0400
Subject: [PATCH 04/34] remove components_cache_max_age kwarg - we have
 cache-busting urls

---
 dash/dash.py | 24 +++++-------------------
 1 file changed, 5 insertions(+), 19 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index 9e7f7b3513..c00663719e 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -35,6 +35,7 @@
 from ._utils import get_asset_path as _get_asset_path
 from ._utils import create_callback_id as _create_callback_id
 from ._configs import (get_combined_config, pathname_configs)
+from .version import __version__
 
 _default_index = '''<!DOCTYPE html>
 <html>
@@ -103,7 +104,6 @@ def __init__(
             external_scripts=None,
             external_stylesheets=None,
             suppress_callback_exceptions=None,
-            components_cache_max_age=None,
             show_undo_redo=False,
             plugins=None):
 
@@ -148,10 +148,6 @@ def __init__(
                 'include_assets_files', include_assets_files, True),
             'assets_external_path': get_combined_config(
                 'assets_external_path', assets_external_path, ''),
-            'components_cache_max_age': int(get_combined_config(
-                'components_cache_max_age',
-                components_cache_max_age,
-                2678400)),
             'show_undo_redo': show_undo_redo
         })
 
@@ -542,15 +538,9 @@ def serve_component_suites(self, package_name, path_in_package_dist):
             'map': 'application/json'
         })[path_in_package_dist.split('.')[-1]]
 
-        headers = {
-            'Cache-Control': 'public, max-age={}'.format(
-                self.config.components_cache_max_age)
-        }
-
         return Response(
             pkgutil.get_data(package_name, path_in_package_dist),
-            mimetype=mimetype,
-            headers=headers
+            mimetype=mimetype
         )
 
     def index(self, *args, **kwargs):  # pylint: disable=unused-argument
@@ -568,8 +558,9 @@ def index(self, *args, **kwargs):  # pylint: disable=unused-argument
                 favicon_mod_time
             )
         else:
-            favicon_url = '{}_favicon.ico'.format(
-                self.config.requests_pathname_prefix)
+            favicon_url = '{}_favicon.ico?v={}'.format(
+                self.config.requests_pathname_prefix,
+                __version__)
 
         favicon = _format_tag('link', {
             'rel': 'icon',
@@ -1245,13 +1236,8 @@ def _invalid_resources_handler(err):
         return err.args[0], 404
 
     def _serve_default_favicon(self):
-        headers = {
-            'Cache-Control': 'public, max-age={}'.format(
-                self.config.components_cache_max_age)
-        }
         return flask.Response(
             pkgutil.get_data('dash', 'favicon.ico'),
-            headers=headers,
             content_type='image/x-icon',
         )
 

From f0282f877b319fff93b2344f1754dfe908413cf9 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 4 Jun 2019 15:48:23 -0400
Subject: [PATCH 05/34] remove unused resources.config.infer_from_layout

---
 dash/dash.py      |  5 -----
 dash/resources.py | 24 ++++++++----------------
 2 files changed, 8 insertions(+), 21 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index c00663719e..8a2a1c85c4 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -313,11 +313,6 @@ def layout(self, value):
 
         self._layout = value
 
-        layout_value = self._layout_value()
-        # pylint: disable=protected-access
-        self.css._update_layout(layout_value)
-        self.scripts._update_layout(layout_value)
-
     @property
     def index_string(self):
         return self._index_string
diff --git a/dash/resources.py b/dash/resources.py
index 87cd8b3ab1..144f1b6051 100644
--- a/dash/resources.py
+++ b/dash/resources.py
@@ -7,10 +7,9 @@
 
 
 class Resources:
-    def __init__(self, resource_name, layout):
+    def __init__(self, resource_name):
         self._resources = []
         self.resource_name = resource_name
-        self.layout = layout
 
     def append_resource(self, resource):
         self._resources.append(resource)
@@ -68,18 +67,14 @@ def get_all_resources(self, dev_bundles=False):
 
 # pylint: disable=too-few-public-methods
 class _Config:
-    def __init__(self, infer_from_layout, serve_locally):
-        self.infer_from_layout = infer_from_layout
+    def __init__(self, serve_locally):
         self.serve_locally = serve_locally
 
 
 class Css:
-    def __init__(self, layout=None):
-        self._resources = Resources('_css_dist', layout)
-        self._resources.config = self.config = _Config(True, True)
-
-    def _update_layout(self, layout):
-        self._resources.layout = layout
+    def __init__(self):
+        self._resources = Resources('_css_dist')
+        self._resources.config = self.config = _Config(True)
 
     def append_css(self, stylesheet):
         self._resources.append_resource(stylesheet)
@@ -89,12 +84,9 @@ def get_all_css(self):
 
 
 class Scripts:
-    def __init__(self, layout=None):
-        self._resources = Resources('_js_dist', layout)
-        self._resources.config = self.config = _Config(True, True)
-
-    def _update_layout(self, layout):
-        self._resources.layout = layout
+    def __init__(self):
+        self._resources = Resources('_js_dist')
+        self._resources.config = self.config = _Config(True)
 
     def append_script(self, script):
         self._resources.append_resource(script)

From ae685ee25795427781ff2490ff1f2c28941837a9 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 4 Jun 2019 16:17:53 -0400
Subject: [PATCH 06/34] new Dash kwarg serve_locally - sets Scripts and Css
 config

---
 dash/dash.py                      | 5 +++--
 dash/resources.py                 | 8 ++++----
 tests/unit/dash/test_resources.py | 6 ++++++
 3 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index 8a2a1c85c4..5349e3b3c8 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -98,6 +98,7 @@ def __init__(
             assets_external_path=None,
             requests_pathname_prefix=None,
             routes_pathname_prefix=None,
+            serve_locally=True,
             compress=True,
             meta_tags=None,
             index_string=_default_index,
@@ -163,8 +164,8 @@ def __init__(
         self.renderer = 'var renderer = new DashRenderer();'
 
         # static files from the packages
-        self.css = Css()
-        self.scripts = Scripts()
+        self.css = Css(serve_locally)
+        self.scripts = Scripts(serve_locally)
 
         self._external_scripts = external_scripts or []
         self._external_stylesheets = external_stylesheets or []
diff --git a/dash/resources.py b/dash/resources.py
index 144f1b6051..1c4574061d 100644
--- a/dash/resources.py
+++ b/dash/resources.py
@@ -72,9 +72,9 @@ def __init__(self, serve_locally):
 
 
 class Css:
-    def __init__(self):
+    def __init__(self, serve_locally):
         self._resources = Resources('_css_dist')
-        self._resources.config = self.config = _Config(True)
+        self._resources.config = self.config = _Config(serve_locally)
 
     def append_css(self, stylesheet):
         self._resources.append_resource(stylesheet)
@@ -84,9 +84,9 @@ def get_all_css(self):
 
 
 class Scripts:
-    def __init__(self):
+    def __init__(self, serve_locally):
         self._resources = Resources('_js_dist')
-        self._resources.config = self.config = _Config(True)
+        self._resources.config = self.config = _Config(serve_locally)
 
     def append_script(self, script):
         self._resources.append_resource(script)
diff --git a/tests/unit/dash/test_resources.py b/tests/unit/dash/test_resources.py
index 4a32f54878..b841051fb6 100644
--- a/tests/unit/dash/test_resources.py
+++ b/tests/unit/dash/test_resources.py
@@ -59,6 +59,12 @@ def test_external(mocker):
     ]
 
 
+def test_external_kwarg():
+    app = dash.Dash(__name__, serve_locally=False)
+    assert not app.scripts.config.serve_locally
+    assert not app.css.config.serve_locally
+
+
 def test_internal(mocker):
     mocker.patch('dash_core_components._js_dist')
     dcc._js_dist = _monkey_patched_js_dist  # noqa: W0212,

From 7c76583b4daca56ab39a52a9758d18859f60db92 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 4 Jun 2019 16:52:53 -0400
Subject: [PATCH 07/34] helpful errors if old kwargs are used in Dash
 constructor

---
 dash/dash.py       | 15 ++++++++++++++-
 dash/exceptions.py |  4 ++++
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/dash/dash.py b/dash/dash.py
index 5349e3b3c8..6a2305e968 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -106,7 +106,20 @@ def __init__(
             external_stylesheets=None,
             suppress_callback_exceptions=None,
             show_undo_redo=False,
-            plugins=None):
+            plugins=None,
+            **kwargs):
+
+        for key in kwargs:
+            if key in ['components_cache_max_age', 'static_folder']:
+                raise exceptions.ObsoleteKwargException(
+                    key + ' is no longer a valid keyword argument in Dash '
+                    'since v1.0. See https://dash.plot.ly for details.'
+                )
+            else:
+                # any other kwarg mimic the built-in exception
+                raise TypeError(
+                    "Dash() got an unexpected keyword argument '" + key + "'"
+                )
 
         # Store some flask-related parameters for use in init_app()
         self.compress = compress
diff --git a/dash/exceptions.py b/dash/exceptions.py
index 0b02966209..27f115f84e 100644
--- a/dash/exceptions.py
+++ b/dash/exceptions.py
@@ -2,6 +2,10 @@ class DashException(Exception):
     pass
 
 
+class ObsoleteKwargException(DashException):
+    pass
+
+
 class NoLayoutException(DashException):
     pass
 

From 37cf546a0edebd38f2851633421d2a2b41440540 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 4 Jun 2019 23:12:40 -0400
Subject: [PATCH 08/34] remove leading '/' from default assets_url_path it's
 more confusing to describe with it present - and we always strip it off in
 practice

---
 dash/dash.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dash/dash.py b/dash/dash.py
index 6a2305e968..cef5aa03a8 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -91,7 +91,7 @@ def __init__(
             name='__main__',
             server=True,
             assets_folder='assets',
-            assets_url_path='/assets',
+            assets_url_path='assets',
             assets_ignore='',
             include_assets_files=True,
             url_base_pathname=None,

From b4185e2a5068644ec427d00f40f96a642a38a3b2 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 4 Jun 2019 23:13:45 -0400
Subject: [PATCH 09/34] docstring for Dash class

---
 dash/dash.py | 119 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 118 insertions(+), 1 deletion(-)

diff --git a/dash/dash.py b/dash/dash.py
index cef5aa03a8..d289a82026 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -86,6 +86,123 @@ class _NoUpdate(object):
 # pylint: disable=too-many-instance-attributes
 # pylint: disable=too-many-arguments, too-many-locals
 class Dash(object):
+    """
+    Dash is a framework for building analytical web applications.
+    No JavaScript required.
+
+    If a parameter can be set by an environment variable, that is listed too.
+    Values provided here take precedence over environment variables.
+
+    :param name: The name Flask should use for your app. Even if you provide
+        your own ``server``, ``name`` will be used to help find assets.
+        Typically ``__name__`` (the magic global var, not a string) is the
+        best value to use. Default ``'__main__'``, env: ``DASH_APP_NAME``
+    :type name: string
+
+    :param server: Sets the Flask server for your app. There are three options:
+        ``True`` (default): Dash will create a new server
+        ``False``: The server will be added later via ``app.init_app(server)``
+            where ``server`` is a ``flask.Flask`` instance.
+        ``flask.Flask``: use this pre-existing Flask server.
+    :type server: boolean or flask.Flask
+
+    :param assets_folder: a path, relative to the current working directory,
+        for extra files to be used in the browser. Default ``'assets'`` By
+        default all .js and .css will be loaded immediately, and other files
+        such as images will be served if requested.
+    :type assets_folder: string
+
+    :param assets_url_path: The local urls for assets will be:
+        ``requests_pathname_prefix + assets_url_path + '/' + asset_path``
+        where ``asset_path`` is the path to a file inside ``assets_folder``.
+        Default ``'assets'``.
+    :type asset_url_path: string
+
+    :param assets_ignore: A regexp, as a string to pass to ``re.compile``, for
+        assets to omit from immediate loading. Ignored files will still be
+        served if specifically requested. You cannot use this to prevent access
+        to sensitive files.
+    :type assets_ignore: string
+
+    :param assets_external_path: an absolute URL from which to load assets.
+        Use with ``serve_locally=False``. Dash can still find js and css to
+        automatically load if you also keep local copies in your assets
+        folder that Dash can index, but external serving can improve
+        performance and reduce load on the Dash server.
+        env: ``DASH_ASSETS_EXTERNAL_PATH``
+    :type assets_external_path: string
+
+    :param include_assets_files: Default ``True``, set to ``False`` to prevent
+        immediate loading of any assets. Assets will still be served if
+        specifically requested. You cannot use this to prevent access
+        to sensitive files. env: ``DASH_INCLUDE_ASSETS_FILES``
+    :type include_assets_files: boolean
+
+    :param url_base_pathname: A local URL prefix to use app-wide.
+        Default ``'/'``. Both `requests_pathname_prefix` and
+        `routes_pathname_prefix` default to `url_base_pathname`.
+        env: ``DASH_URL_BASE_PATHNAME``
+    :type url_base_pathname: string
+
+    :param requests_pathname_prefix: A local URL prefix for file requests.
+        Defaults to `url_base_pathname`, and must end with
+        `routes_pathname_prefix`. env: ``DASH_REQUESTS_PATHNAME_PREFIX``
+    :type requests_pathname_prefix: string
+
+    :param routes_pathname_prefix: A local URL prefix for JSON requests.
+        Defaults to ``url_base_pathname``, and must start and end
+        with ``'/'``. env: ``DASH_ROUTES_PATHNAME_PREFIX``
+    :type routes_pathname_prefix: string
+
+    :param serve_locally: If ``True`` (default), assets and dependencies
+        (Dash and Component js and css) will be served from local URLs.
+        If ``False`` we will use CDN links where available.
+    :type serve_locally: boolean
+
+    :param compress: Use gzip to compress files and data served by Flask.
+        Default ``True``
+    :type compress: boolean
+
+    :param meta_tags: html <meta> tags to be added to the index page.
+        Each dict should have the attributes and values for one tag, eg:
+        ``{'name': 'description', 'content': 'My App'}``
+    :type meta_tags: list of dicts
+
+    :param index_string: Override the standard Dash index page.
+        Must contain the correct insertion markers to interpolate various
+        content into it depending on the app config and components used.
+        See https://dash.plot.ly/external-resources for details.
+    :type index_string: string
+
+    :param external_scripts: Additional JS files to load with the page.
+        Each entry can be a string (the URL) or a dict with ``src`` (the URL)
+        and optionally other ``<script>`` tag attributes such as ``integrity``
+        and ``crossorigin``.
+    :type external_scripts: list of strings or dicts
+
+    :param external_stylesheets: Additional CSS files to load with the page.
+        Each entry can be a string (the URL) or a dict with ``href`` (the URL)
+        and optionally other ``<link>`` tag attributes such as ``rel``,
+        ``integrity`` and ``crossorigin``.
+    :type external_stylesheets: list of strings or dicts
+
+    :param suppress_callback_exceptions: Default ``False``: check callbacks to
+        ensure referenced IDs exist and props are valid. Set to ``True``
+        if your layout is dynamic, to bypass these checks.
+        env: ``DASH_SUPPRESS_CALLBACK_EXCEPTIONS``
+    :type suppress_callback_exceptions: boolean
+
+    :param show_undo_redo: Default ``False``, set to ``True`` to enable undo
+        and redo buttons for stepping through the history of the app state.
+    :type show_undo_redo: boolean
+
+    :param plugins: Extend Dash functionality by passing a list of objects
+        with a ``plug`` method, taking a single argument: this app, which will
+        be called after the Flask server is attached.
+    :type plugins: list of objects
+
+    :param **kwargs: Do not use. Gives error messages for obsolete arguments.
+    """
     def __init__(
             self,
             name='__main__',
@@ -93,9 +210,9 @@ def __init__(
             assets_folder='assets',
             assets_url_path='assets',
             assets_ignore='',
+            assets_external_path=None,
             include_assets_files=True,
             url_base_pathname=None,
-            assets_external_path=None,
             requests_pathname_prefix=None,
             routes_pathname_prefix=None,
             serve_locally=True,

From 1ef7046cc6c6f2d6fe5714ce2104f67631fda852 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Wed, 5 Jun 2019 11:48:16 -0400
Subject: [PATCH 10/34] set default debug=True if enable_dev_tools is called
 directly

---
 dash/dash.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dash/dash.py b/dash/dash.py
index d289a82026..892e3641f1 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -1377,7 +1377,7 @@ def get_asset_url(self, path):
         return asset
 
     def enable_dev_tools(self,
-                         debug=False,
+                         debug=True,
                          dev_tools_ui=None,
                          dev_tools_props_check=None,
                          dev_tools_serve_dev_bundles=None,

From 2f737cd266665af74ed0988c20a16834f6912016 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Wed, 5 Jun 2019 13:51:15 -0400
Subject: [PATCH 11/34] change hot_reload_interval from msec to sec to match
 watch_interval

---
 dash/dash.py                     | 12 +++++++-----
 tests/integration/test_render.py |  2 +-
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index 892e3641f1..34490f1c56 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -312,7 +312,7 @@ def __init__(
         self._dev_tools = _AttributeDict({
             'serve_dev_bundles': False,
             'hot_reload': False,
-            'hot_reload_interval': 3000,
+            'hot_reload_interval': 3,
             'hot_reload_watch_interval': 0.5,
             'hot_reload_max_retry': 8,
             'ui': False,
@@ -474,6 +474,7 @@ def serve_layout(self):
         )
 
     def _config(self):
+        # pieces of config needed by the front end
         config = {
             'url_base_pathname': self.url_base_pathname,
             'requests_pathname_prefix': self.config.requests_pathname_prefix,
@@ -483,7 +484,8 @@ def _config(self):
         }
         if self._dev_tools.hot_reload:
             config['hot_reload'] = {
-                'interval': self._dev_tools.hot_reload_interval,
+                # convert from seconds to msec as used by js `setInterval`
+                'interval': int(self._dev_tools.hot_reload_interval * 1000),
                 'max_retry': self._dev_tools.hot_reload_max_retry
             }
         return config
@@ -1452,9 +1454,9 @@ def enable_dev_tools(self,
 
         self._dev_tools['hot_reload'] = get_combined_config(
             'hot_reload', dev_tools_hot_reload, default=debug)
-        self._dev_tools['hot_reload_interval'] = int(get_combined_config(
-            'hot_reload_interval', dev_tools_hot_reload_interval, default=3000
-        ))
+        self._dev_tools['hot_reload_interval'] = get_combined_config(
+            'hot_reload_interval', dev_tools_hot_reload_interval, default=3
+        )
         self._dev_tools['hot_reload_watch_interval'] = float(
             get_combined_config(
                 'hot_reload_watch_interval',
diff --git a/tests/integration/test_render.py b/tests/integration/test_render.py
index 364b9dd119..01e57f6dd7 100644
--- a/tests/integration/test_render.py
+++ b/tests/integration/test_render.py
@@ -1923,7 +1923,7 @@ def test_hot_reload(self):
         self.startServer(
             app,
             dev_tools_hot_reload=True,
-            dev_tools_hot_reload_interval=100,
+            dev_tools_hot_reload_interval=0.1,
             dev_tools_hot_reload_max_retry=30,
         )
 

From e32914ec165112d2eae048bc209427410f96e487 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Wed, 5 Jun 2019 15:36:06 -0400
Subject: [PATCH 12/34] update docstrings for enable_dev_tools and run_server

---
 dash/dash.py | 145 +++++++++++++++++++++++++++++++++------------------
 1 file changed, 95 insertions(+), 50 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index 34490f1c56..c6a88be3cd 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -1393,8 +1393,8 @@ def enable_dev_tools(self,
         served by wsgi and you want to activate the dev tools, you can call
         this method out of `__main__`.
 
-        If an argument is not provided, it can be set with environment
-        variables.
+        All parameters can be set by environment variables as listed.
+        Values provided here take precedence over environment variables.
 
         Available dev_tools environment variables:
 
@@ -1408,37 +1408,49 @@ def enable_dev_tools(self,
             - DASH_HOT_RELOAD_MAX_RETRY
             - DASH_SILENCE_ROUTES_LOGGING
 
-        :param debug: If True, then activate all the tools unless specifically
-            disabled by the arguments or by environ variables. Available as
-            `DASH_DEBUG` environment variable.
+        :param debug: Enable/disable all the dev tools unless overridden by the
+            arguments or environment variables. Default is ``True`` when
+            ``enable_dev_tools`` is called directly, and ``False`` when called
+            via ``run_server``. env: ``DASH_DEBUG``
         :type debug: bool
-        :param dev_tools_ui: Switch the dev tools UI in debugger mode
+
+        :param dev_tools_ui: Show the dev tools UI. env: ``DASH_UI``
         :type dev_tools_ui: bool
-        :param dev_tools_props_check: Validate the properties of
-            the Dash components
+
+        :param dev_tools_props_check: Validate the types and values of Dash
+            component props. env: ``DASH_PROPS_CHECK``
         :type dev_tools_props_check: bool
-        :param dev_tools_serve_dev_bundles: Serve the dev bundles. Available
-            as `DASH_SERVE_DEV_BUNDLES` environment variable.
+
+        :param dev_tools_serve_dev_bundles: Serve the dev bundles. Production
+            bundles do not necessarily include all the dev tools code.
+            env: ``DASH_SERVE_DEV_BUNDLES``
         :type dev_tools_serve_dev_bundles: bool
-        :param dev_tools_hot_reload: Activate the hot reloading. Available as
-            `DASH_HOT_RELOAD` environment variable.
+
+        :param dev_tools_hot_reload: Activate hot reloading when app, assets,
+            and component files change. env: ``DASH_HOT_RELOAD``
         :type dev_tools_hot_reload: bool
-        :param dev_tools_hot_reload_interval: Interval at which the client will
-            request the reload hash. Available as `DASH_HOT_RELOAD_INTERVAL`
-            environment variable.
-        :type dev_tools_hot_reload_interval: int
-        :param dev_tools_hot_reload_watch_interval: Interval at which the
-            assets folder are walked for changes. Available as
-            `DASH_HOT_RELOAD_WATCH_INTERVAL` environment variable.
+
+        :param dev_tools_hot_reload_interval: Interval in seconds for the
+            client to request the reload hash. Default 3.
+            env: ``DASH_HOT_RELOAD_INTERVAL``
+        :type dev_tools_hot_reload_interval: float
+
+        :param dev_tools_hot_reload_watch_interval: Interval in seconds for the
+            server to check asset and component folders for changes.
+            Default 0.5. env: ``DASH_HOT_RELOAD_WATCH_INTERVAL``
         :type dev_tools_hot_reload_watch_interval: float
-        :param dev_tools_hot_reload_max_retry: Maximum amount of retries before
-            failing and display a pop up. Default 30. Available as
-            `DASH_HOT_RELOAD_MAX_RETRY` environment variable.
+
+        :param dev_tools_hot_reload_max_retry: Maximum number of failed reload
+            hash requests before failing and displaying a pop up. Default 8.
+            env: ``DASH_HOT_RELOAD_MAX_RETRY``
         :type dev_tools_hot_reload_max_retry: int
+
         :param dev_tools_silence_routes_logging: Silence the `werkzeug` logger,
-            will remove all routes logging. Available as
-            `DASH_SILENCE_ROUTES_LOGGING` environment variable.
+            will remove all routes logging. Enabled with debugging by default
+            because hot reload hash checks generate a lot of requests.
+            env: ``DASH_SILENCE_ROUTES_LOGGING``
         :type dev_tools_silence_routes_logging: bool
+
         :return: debug
         """
         debug = debug or get_combined_config('debug', None, debug)
@@ -1558,45 +1570,78 @@ def delete_resource(resources):
 
         self._lock.release()
 
-    def run_server(self,
-                   port=8050,
-                   debug=False,
-                   dev_tools_ui=None,
-                   dev_tools_props_check=None,
-                   dev_tools_serve_dev_bundles=None,
-                   dev_tools_hot_reload=None,
-                   dev_tools_hot_reload_interval=None,
-                   dev_tools_hot_reload_watch_interval=None,
-                   dev_tools_hot_reload_max_retry=None,
-                   dev_tools_silence_routes_logging=None,
-                   **flask_run_options):
+    def run_server(
+            self,
+            port=8050,
+            debug=False,
+            dev_tools_ui=None,
+            dev_tools_props_check=None,
+            dev_tools_serve_dev_bundles=None,
+            dev_tools_hot_reload=None,
+            dev_tools_hot_reload_interval=None,
+            dev_tools_hot_reload_watch_interval=None,
+            dev_tools_hot_reload_max_retry=None,
+            dev_tools_silence_routes_logging=None,
+            **flask_run_options):
         """
         Start the flask server in local mode, you should not run this on a
-        production server and use gunicorn/waitress instead.
+        production server, use gunicorn/waitress instead.
 
-        :param port: Port the application
+        If a parameter can be set by an environment variable, that is listed
+        too. Values provided here take precedence over environment variables.
+
+        :param port: Port used to serve the application
         :type port: int
-        :param debug: Set the debug mode of flask and enable the dev tools.
+
+        :param debug: Set Flask debug mode and enable dev tools.
+            env: ``DASH_DEBUG``
         :type debug: bool
-        :param dev_tools_ui: Switch the dev tools UI in debugger mode
+
+        :param debug: Enable/disable all the dev tools unless overridden by the
+            arguments or environment variables. Default is ``True`` when
+            ``enable_dev_tools`` is called directly, and ``False`` when called
+            via ``run_server``. env: ``DASH_DEBUG``
+        :type debug: bool
+
+        :param dev_tools_ui: Show the dev tools UI. env: ``DASH_UI``
         :type dev_tools_ui: bool
-        :param dev_tools_props_check: Validate the properties of
-            the Dash components
+
+        :param dev_tools_props_check: Validate the types and values of Dash
+            component props. env: ``DASH_PROPS_CHECK``
         :type dev_tools_props_check: bool
-        :param dev_tools_serve_dev_bundles: Serve the dev bundles of components
+
+        :param dev_tools_serve_dev_bundles: Serve the dev bundles. Production
+            bundles do not necessarily include all the dev tools code.
+            env: ``DASH_SERVE_DEV_BUNDLES``
         :type dev_tools_serve_dev_bundles: bool
-        :param dev_tools_hot_reload: Enable the hot reload.
+
+        :param dev_tools_hot_reload: Activate hot reloading when app, assets,
+            and component files change. env: ``DASH_HOT_RELOAD``
         :type dev_tools_hot_reload: bool
-        :param dev_tools_hot_reload_interval: Reload request interval.
-        :type dev_tools_hot_reload_interval: int
-        :param dev_tools_hot_reload_watch_interval:
+
+        :param dev_tools_hot_reload_interval: Interval in seconds for the
+            client to request the reload hash. Default 3.
+            env: ``DASH_HOT_RELOAD_INTERVAL``
+        :type dev_tools_hot_reload_interval: float
+
+        :param dev_tools_hot_reload_watch_interval: Interval in seconds for the
+            server to check asset and component folders for changes.
+            Default 0.5. env: ``DASH_HOT_RELOAD_WATCH_INTERVAL``
         :type dev_tools_hot_reload_watch_interval: float
-        :param dev_tools_hot_reload_max_retry: The number of times the reloader
-            requests can fail before displaying an alert.
+
+        :param dev_tools_hot_reload_max_retry: Maximum number of failed reload
+            hash requests before failing and displaying a pop up. Default 8.
+            env: ``DASH_HOT_RELOAD_MAX_RETRY``
         :type dev_tools_hot_reload_max_retry: int
-        :param dev_tools_silence_routes_logging: Silence the routes logs.
+
+        :param dev_tools_silence_routes_logging: Silence the `werkzeug` logger,
+            will remove all routes logging. Enabled with debugging by default
+            because hot reload hash checks generate a lot of requests.
+            env: ``DASH_SILENCE_ROUTES_LOGGING``
         :type dev_tools_silence_routes_logging: bool
+
         :param flask_run_options: Given to `Flask.run`
+
         :return:
         """
         debug = self.enable_dev_tools(

From 77d42a4bc95ace012bd07abb14a20ae161277fe4 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Wed, 5 Jun 2019 16:15:53 -0400
Subject: [PATCH 13/34] simplify and DRY dev_tools setup also a fix for debug
 logic re: env vars

---
 dash/dash.py | 95 ++++++++++++++++++++++++++--------------------------
 1 file changed, 47 insertions(+), 48 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index c6a88be3cd..a4a5e102c1 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -309,15 +309,7 @@ def __init__(
 
         self._layout = None
         self._cached_layout = None
-        self._dev_tools = _AttributeDict({
-            'serve_dev_bundles': False,
-            'hot_reload': False,
-            'hot_reload_interval': 3,
-            'hot_reload_watch_interval': 0.5,
-            'hot_reload_max_retry': 8,
-            'ui': False,
-            'props_check': False,
-        })
+        self._make_dev_tools_config()
 
         self._assets_files = []
 
@@ -1378,8 +1370,36 @@ def get_asset_url(self, path):
 
         return asset
 
+    def _make_dev_tools_config(self, **kwargs):
+        debug = kwargs.get('debug', False)
+        dev_tools = self._dev_tools = _AttributeDict()
+
+        for attr in (
+            'ui',
+            'props_check',
+            'serve_dev_bundles',
+            'hot_reload',
+            'silence_routes_logging'
+        ):
+            dev_tools[attr] = get_combined_config(
+                attr, kwargs.get(attr, None), default=debug
+            )
+
+        for attr, _type, default in (
+            ('hot_reload_interval', float, 3),
+            ('hot_reload_watch_interval', float, 0.5),
+            ('hot_reload_max_retry', int, 8)
+        ):
+            dev_tools[attr] = _type(
+                get_combined_config(
+                    attr, kwargs.get(attr, None), default=default
+                )
+            )
+
+        return dev_tools
+
     def enable_dev_tools(self,
-                         debug=True,
+                         debug=None,
                          dev_tools_ui=None,
                          dev_tools_props_check=None,
                          dev_tools_serve_dev_bundles=None,
@@ -1453,47 +1473,26 @@ def enable_dev_tools(self,
 
         :return: debug
         """
-        debug = debug or get_combined_config('debug', None, debug)
-
-        self._dev_tools['ui'] = get_combined_config(
-            'ui', dev_tools_ui, default=debug
+        if debug is None:
+            debug = get_combined_config('debug', None, True)
+
+        dev_tools = self._make_dev_tools_config(
+            debug=debug,
+            ui=dev_tools_ui,
+            props_check=dev_tools_props_check,
+            serve_dev_bundles=dev_tools_serve_dev_bundles,
+            hot_reload=dev_tools_hot_reload,
+            hot_reload_interval=dev_tools_hot_reload_interval,
+            hot_reload_watch_interval=dev_tools_hot_reload_watch_interval,
+            hot_reload_max_retry=dev_tools_hot_reload_max_retry,
+            silence_routes_logging=dev_tools_silence_routes_logging
         )
-        self._dev_tools['props_check'] = get_combined_config(
-            'props_check', dev_tools_props_check, default=debug
-        )
-        self._dev_tools['serve_dev_bundles'] = get_combined_config(
-            'serve_dev_bundles', dev_tools_serve_dev_bundles, default=debug)
 
-        self._dev_tools['hot_reload'] = get_combined_config(
-            'hot_reload', dev_tools_hot_reload, default=debug)
-        self._dev_tools['hot_reload_interval'] = get_combined_config(
-            'hot_reload_interval', dev_tools_hot_reload_interval, default=3
-        )
-        self._dev_tools['hot_reload_watch_interval'] = float(
-            get_combined_config(
-                'hot_reload_watch_interval',
-                dev_tools_hot_reload_watch_interval,
-                default=0.5
-            )
-        )
-        self._dev_tools['hot_reload_max_retry'] = int(
-            get_combined_config(
-                'hot_reload_max_retry',
-                dev_tools_hot_reload_max_retry,
-                default=8
-            )
-        )
-        self._dev_tools['silence_routes_logging'] = get_combined_config(
-            'silence_routes_logging',
-            dev_tools_silence_routes_logging,
-            default=debug,
-        )
-
-        if self._dev_tools.silence_routes_logging:
+        if dev_tools.silence_routes_logging:
             logging.getLogger('werkzeug').setLevel(logging.ERROR)
             self.logger.setLevel(logging.INFO)
 
-        if self._dev_tools.hot_reload:
+        if dev_tools.hot_reload:
             self._reload_hash = _generate_hash()
 
             component_packages_dist = [
@@ -1510,12 +1509,12 @@ def enable_dev_tools(self,
                 target=lambda: _watch.watch(
                     [self._assets_folder] + component_packages_dist,
                     self._on_assets_change,
-                    sleep_time=self._dev_tools.hot_reload_watch_interval)
+                    sleep_time=dev_tools.hot_reload_watch_interval)
             )
             self._watch_thread.daemon = True
             self._watch_thread.start()
 
-        if (debug and self._dev_tools.serve_dev_bundles and
+        if (debug and dev_tools.serve_dev_bundles and
                 not self.scripts.config.serve_locally):
             # Dev bundles only works locally.
             self.scripts.config.serve_locally = True

From e579d34d8e8ca47a79858fa33d08d36c3223539d Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Wed, 5 Jun 2019 16:30:42 -0400
Subject: [PATCH 14/34] simpler AttributeDict usage, and typo fix

---
 dash/dash.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index a4a5e102c1..cb1f94d9a5 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -268,19 +268,19 @@ def __init__(
             )
 
         self.url_base_pathname = url_base_pathname
-        self.config = _AttributeDict({
-            'suppress_callback_exceptions': get_combined_config(
+        self.config = _AttributeDict(
+            suppress_callback_exceptions=get_combined_config(
                 'suppress_callback_exceptions',
                 suppress_callback_exceptions,
                 False),
-            'routes_pathname_prefix': routes_pathname_prefix,
-            'requests_pathname_prefix': requests_pathname_prefix,
-            'include_assets_files': get_combined_config(
+            routes_pathname_prefix=routes_pathname_prefix,
+            requests_pathname_prefix=requests_pathname_prefix,
+            include_assets_files=get_combined_config(
                 'include_assets_files', include_assets_files, True),
-            'assets_external_path': get_combined_config(
+            assets_external_path=get_combined_config(
                 'assets_external_path', assets_external_path, ''),
-            'show_undo_redo': show_undo_redo
-        })
+            show_undo_redo=show_undo_redo
+        )
 
         # list of dependencies
         self.callback_map = {}
@@ -1656,7 +1656,7 @@ def run_server(
         )
 
         if self._dev_tools.silence_routes_logging:
-            # Since it's silenced, the address don't show anymore.
+            # Since it's silenced, the address doesn't show anymore.
             host = flask_run_options.get('host', '127.0.0.1')
             ssl_context = flask_run_options.get('ssl_context')
             self.logger.info(

From 2eab14157b3b4d8b14407abe6b59c994181ece8a Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Wed, 5 Jun 2019 21:47:18 -0400
Subject: [PATCH 15/34] include all constructor args in app.config except
 server, index_string, and plugins

---
 dash/dash.py | 163 +++++++++++++++++++++++++--------------------------
 1 file changed, 79 insertions(+), 84 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index cb1f94d9a5..7e203b9596 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -238,56 +238,50 @@ def __init__(
                     "Dash() got an unexpected keyword argument '" + key + "'"
                 )
 
-        # Store some flask-related parameters for use in init_app()
-        self.compress = compress
-        self.name = name
-
-        self._assets_folder = os.path.join(
-            flask.helpers.get_root_path(name),
-            assets_folder,
-        )
-        self._assets_url_path = assets_url_path
-
         # We have 3 cases: server is either True (we create the server), False
         # (defer server creation) or a Flask app instance (we use their server)
         if isinstance(server, bool):
-            if server:
-                self.server = Flask(name)
-            else:
-                self.server = None
+            self.server = Flask(name) if server else None
         elif isinstance(server, Flask):
             self.server = server
         else:
-            raise ValueError('server must be a Flask app, or a boolean')
+            raise ValueError('server must be a Flask app or a boolean')
 
-        url_base_pathname, routes_pathname_prefix, requests_pathname_prefix = \
-            pathname_configs(
-                url_base_pathname,
-                routes_pathname_prefix,
-                requests_pathname_prefix
-            )
+        base_prefix, routes_prefix, requests_prefix = pathname_configs(
+            url_base_pathname, routes_pathname_prefix, requests_pathname_prefix
+        )
 
-        self.url_base_pathname = url_base_pathname
         self.config = _AttributeDict(
+            name=name,
+            assets_folder=os.path.join(
+                flask.helpers.get_root_path(name), assets_folder),
+            assets_url_path=assets_url_path,
+            assets_ignore=assets_ignore,
+            assets_external_path=get_combined_config(
+                'assets_external_path', assets_external_path, ''),
+            include_assets_files=get_combined_config(
+                'include_assets_files', include_assets_files, True),
+            url_base_pathname=base_prefix,
+            routes_pathname_prefix=routes_prefix,
+            requests_pathname_prefix=requests_prefix,
+            serve_locally=serve_locally,
+            compress=compress,
+            meta_tags=meta_tags or [],
+            external_scripts=external_scripts or [],
+            external_stylesheets=external_stylesheets or [],
             suppress_callback_exceptions=get_combined_config(
                 'suppress_callback_exceptions',
                 suppress_callback_exceptions,
                 False),
-            routes_pathname_prefix=routes_pathname_prefix,
-            requests_pathname_prefix=requests_pathname_prefix,
-            include_assets_files=get_combined_config(
-                'include_assets_files', include_assets_files, True),
-            assets_external_path=get_combined_config(
-                'assets_external_path', assets_external_path, ''),
             show_undo_redo=show_undo_redo
         )
 
         # list of dependencies
         self.callback_map = {}
 
+        # index_string has special setter so can't go in config
         self._index_string = ''
         self.index_string = index_string
-        self._meta_tags = meta_tags or []
         self._favicon = None
 
         # default renderer string
@@ -297,11 +291,6 @@ def __init__(
         self.css = Css(serve_locally)
         self.scripts = Scripts(serve_locally)
 
-        self._external_scripts = external_scripts or []
-        self._external_stylesheets = external_stylesheets or []
-
-        self.assets_ignore = assets_ignore
-
         self.registered_paths = collections.defaultdict(set)
 
         # urls
@@ -309,16 +298,10 @@ def __init__(
 
         self._layout = None
         self._cached_layout = None
-        self._make_dev_tools_config()
 
-        self._assets_files = []
+        self._setup_dev_tools()
 
-        # hot reload
-        self._reload_hash = None
-        self._hard_reload = False
-        self._lock = threading.RLock()
-        self._watch_thread = None
-        self._changed_assets = []
+        self._assets_files = []
 
         self.logger = logging.getLogger(name)
         self.logger.addHandler(logging.StreamHandler(stream=sys.stdout))
@@ -334,28 +317,29 @@ def init_app(self, app=None):
         """
         Initialize the parts of Dash that require a flask app
         """
+        config = self.config
 
         if app is not None:
             self.server = app
 
         assets_blueprint_name = '{}{}'.format(
-            self.config.routes_pathname_prefix.replace('/', '_'),
+            config.routes_pathname_prefix.replace('/', '_'),
             'dash_assets'
         )
 
         self.server.register_blueprint(
             flask.Blueprint(
                 assets_blueprint_name,
-                self.name,
-                static_folder=self._assets_folder,
+                config.name,
+                static_folder=self.config.assets_folder,
                 static_url_path='{}{}'.format(
-                    self.config.routes_pathname_prefix,
-                    self._assets_url_path.lstrip('/')
+                    config.routes_pathname_prefix,
+                    self.config.assets_url_path.lstrip('/')
                 )
             )
         )
 
-        if self.compress:
+        if config.compress:
             # gzip
             Compress(self.server)
 
@@ -364,7 +348,7 @@ def _handle_error(_):
             """Handle a halted callback and return an empty 204 response"""
             return '', 204
 
-        prefix = self.config['routes_pathname_prefix']
+        prefix = config.routes_pathname_prefix
 
         self.server.before_first_request(self._setup_server)
 
@@ -468,7 +452,7 @@ def serve_layout(self):
     def _config(self):
         # pieces of config needed by the front end
         config = {
-            'url_base_pathname': self.url_base_pathname,
+            'url_base_pathname': self.config.url_base_pathname,
             'requests_pathname_prefix': self.config.requests_pathname_prefix,
             'ui': self._dev_tools.ui,
             'props_check': self._dev_tools.props_check,
@@ -517,7 +501,7 @@ def _relative_url_path(relative_package_path='', namespace=''):
             modified = int(os.stat(module_path).st_mtime)
 
             return '{}_dash-component-suites/{}/{}?v={}&m={}'.format(
-                self.config['requests_pathname_prefix'],
+                self.config.requests_pathname_prefix,
                 namespace,
                 relative_package_path,
                 importlib.import_module(namespace).__version__,
@@ -560,7 +544,7 @@ def _relative_url_path(relative_package_path='', namespace=''):
         return srcs
 
     def _generate_css_dist_html(self):
-        links = self._external_stylesheets + \
+        links = self.config.external_stylesheets + \
             self._collect_and_register_resources(self.css.get_all_css())
 
         return '\n'.join([
@@ -578,17 +562,21 @@ def _generate_scripts_html(self):
         # The rest of the scripts can just be loaded after React but before
         # dash renderer.
         # pylint: disable=protected-access
-        srcs = self._collect_and_register_resources(
-            self.scripts._resources._filter_resources(
-                dash_renderer._js_dist_dependencies,
-                dev_bundles=self._dev_tools.serve_dev_bundles
-            )) + self._external_scripts + self._collect_and_register_resources(
-                self.scripts.get_all_scripts(
-                    dev_bundles=self._dev_tools.serve_dev_bundles) +
+        dev = self._dev_tools.serve_dev_bundles
+        srcs = (
+            self._collect_and_register_resources(
+                self.scripts._resources._filter_resources(
+                    dash_renderer._js_dist_dependencies, dev_bundles=dev
+                )
+            ) +
+            self.config.external_scripts +
+            self._collect_and_register_resources(
+                self.scripts.get_all_scripts(dev_bundles=dev) +
                 self.scripts._resources._filter_resources(
-                    dash_renderer._js_dist,
-                    dev_bundles=self._dev_tools.serve_dev_bundles
-                ))
+                    dash_renderer._js_dist, dev_bundles=dev
+                )
+            )
+        )
 
         return '\n'.join([
             _format_tag('script', src)
@@ -612,10 +600,11 @@ def _generate_renderer(self):
         ).format(self.renderer)
 
     def _generate_meta_html(self):
+        meta_tags = self.config.meta_tags
         has_ie_compat = any(
-            x.get('http-equiv', '') == 'X-UA-Compatible'
-            for x in self._meta_tags)
-        has_charset = any('charset' in x for x in self._meta_tags)
+            x.get('http-equiv', '') == 'X-UA-Compatible' for x in meta_tags
+        )
+        has_charset = any('charset' in x for x in meta_tags)
 
         tags = []
         if not has_ie_compat:
@@ -625,9 +614,7 @@ def _generate_meta_html(self):
         if not has_charset:
             tags.append('<meta charset="UTF-8">')
 
-        tags = tags + [
-            _format_tag('meta', x, opened=True) for x in self._meta_tags
-        ]
+        tags += [_format_tag('meta', x, opened=True) for x in meta_tags]
 
         return '\n      '.join(tags)
 
@@ -673,7 +660,7 @@ def index(self, *args, **kwargs):  # pylint: disable=unused-argument
 
         if self._favicon:
             favicon_mod_time = os.path.getmtime(
-                os.path.join(self._assets_folder, self._favicon))
+                os.path.join(self.config.assets_folder, self._favicon))
             favicon_url = self.get_asset_url(self._favicon) + '?m={}'.format(
                 favicon_mod_time
             )
@@ -1316,10 +1303,10 @@ def _add_assets_resource(self, url_path, file_path):
         return res
 
     def _walk_assets_directory(self):
-        walk_dir = self._assets_folder
+        walk_dir = self.config.assets_folder
         slash_splitter = re.compile(r'[\\/]+')
-        ignore_filter = re.compile(self.assets_ignore) \
-            if self.assets_ignore else None
+        ignore_str = self.config.assets_ignore
+        ignore_filter = re.compile(ignore_str) if ignore_str else None
 
         for current, _, files in os.walk(walk_dir):
             if current == walk_dir:
@@ -1332,14 +1319,13 @@ def _walk_assets_directory(self):
                 else:
                     base = splitted[0]
 
-            files_gen = (x for x in files if not ignore_filter.search(x)) \
-                if ignore_filter else files
+            if ignore_filter:
+                files_gen = (x for x in files if not ignore_filter.search(x))
+            else:
+                files_gen = files
 
             for f in sorted(files_gen):
-                if base:
-                    path = '/'.join([base, f])
-                else:
-                    path = f
+                path = '/'.join([base, f]) if base else f
 
                 full = os.path.join(current, f)
 
@@ -1365,12 +1351,12 @@ def get_asset_url(self, path):
         asset = _get_asset_path(
             self.config.requests_pathname_prefix,
             path,
-            self._assets_url_path.lstrip('/')
+            self.config.assets_url_path.lstrip('/')
         )
 
         return asset
 
-    def _make_dev_tools_config(self, **kwargs):
+    def _setup_dev_tools(self, **kwargs):
         debug = kwargs.get('debug', False)
         dev_tools = self._dev_tools = _AttributeDict()
 
@@ -1396,6 +1382,14 @@ def _make_dev_tools_config(self, **kwargs):
                 )
             )
 
+        if not hasattr(self, '_reload_hash'):
+            # for hot reload
+            self._reload_hash = None
+            self._hard_reload = False
+            self._lock = threading.RLock()
+            self._watch_thread = None
+            self._changed_assets = []
+
         return dev_tools
 
     def enable_dev_tools(self,
@@ -1476,7 +1470,7 @@ def enable_dev_tools(self,
         if debug is None:
             debug = get_combined_config('debug', None, True)
 
-        dev_tools = self._make_dev_tools_config(
+        dev_tools = self._setup_dev_tools(
             debug=debug,
             ui=dev_tools_ui,
             props_check=dev_tools_props_check,
@@ -1507,7 +1501,7 @@ def enable_dev_tools(self,
 
             self._watch_thread = threading.Thread(
                 target=lambda: _watch.watch(
-                    [self._assets_folder] + component_packages_dist,
+                    [self.config.assets_folder] + component_packages_dist,
                     self._on_assets_change,
                     sleep_time=dev_tools.hot_reload_watch_interval)
             )
@@ -1529,9 +1523,10 @@ def _on_assets_change(self, filename, modified, deleted):
         self._hard_reload = True
         self._reload_hash = _generate_hash()
 
-        if self._assets_folder in filename:
+        if self.config.assets_folder in filename:
             asset_path = os.path.relpath(
-                filename, os.path.commonprefix([self._assets_folder, filename])
+                filename,
+                os.path.commonprefix([self.config.assets_folder, filename])
             ).replace('\\', '/').lstrip('/')
 
             self._changed_assets.append({

From 3d749f10bb2acdde386b72e61a9e7ffcec5866b6 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Thu, 6 Jun 2019 07:31:03 -0400
Subject: [PATCH 16/34] fix some callback deps validation edge cases

---
 dash/dash.py                          | 66 +++++++++++++--------------
 tests/integration/test_integration.py | 37 ++++++++++++++-
 2 files changed, 68 insertions(+), 35 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index 7e203b9596..1244fb3c5d 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -766,33 +766,6 @@ def _validate_callback(self, output, inputs, state):
         layout = self._cached_layout or self._layout_value()
         is_multi = isinstance(output, (list, tuple))
 
-        for i in inputs:
-            bad = None
-            if is_multi:
-                for o in output:
-                    if o == i:
-                        bad = o
-            else:
-                if output == i:
-                    bad = output
-            if bad:
-                raise exceptions.SameInputOutputException(
-                    'Same output and input: {}'.format(bad)
-                )
-
-        if is_multi:
-            if len(set(output)) != len(output):
-                raise exceptions.DuplicateCallbackOutput(
-                    'Same output was used in a'
-                    ' multi output callback!\n Duplicates:\n {}'.format(
-                        ',\n'.join(
-                            k for k, v in
-                            ((str(x), output.count(x)) for x in output)
-                            if v > 1
-                        )
-                    )
-                )
-
         if (layout is None and not self.config.suppress_callback_exceptions):
             # Without a layout, we can't do validation on the IDs and
             # properties of the elements in the callback.
@@ -804,17 +777,15 @@ def _validate_callback(self, output, inputs, state):
                 `app.config['suppress_callback_exceptions']=True`
             '''.replace('    ', ''))
 
-        for args, obj, name in [(output if isinstance(output, (list, tuple))
-                                 else [output],
-                                 (Output, list, tuple),
-                                 'Output'),
+        outputs = output if is_multi else [output]
+        for args, obj, name in [(outputs, Output, 'Output'),
                                 (inputs, Input, 'Input'),
                                 (state, State, 'State')]:
 
-            if not isinstance(args, list):
+            if not isinstance(args, (list, tuple)):
                 raise exceptions.IncorrectTypeException(
-                    'The {} argument `{}` is '
-                    'not a list of `dash.dependencies.{}`s.'.format(
+                    'The {} argument `{}` must be '
+                    'a list or tuple of `dash.dependencies.{}`s.'.format(
                         name.lower(), str(args), name
                     ))
 
@@ -902,6 +873,33 @@ def _validate_callback(self, output, inputs, state):
                 'elements' if len(state) > 1 else 'element'
             ).replace('    ', ''))
 
+        for i in inputs:
+            bad = None
+            if is_multi:
+                for o in output:
+                    if o == i:
+                        bad = o
+            else:
+                if output == i:
+                    bad = output
+            if bad:
+                raise exceptions.SameInputOutputException(
+                    'Same output and input: {}'.format(bad)
+                )
+
+        if is_multi:
+            if len(set(output)) != len(output):
+                raise exceptions.DuplicateCallbackOutput(
+                    'Same output was used more than once in a '
+                    'multi output callback!\n Duplicates:\n {}'.format(
+                        ',\n'.join(
+                            k for k, v in
+                            ((str(x), output.count(x)) for x in output)
+                            if v > 1
+                        )
+                    )
+                )
+
         callback_id = _create_callback_id(output)
 
         callbacks = set(itertools.chain(*(
diff --git a/tests/integration/test_integration.py b/tests/integration/test_integration.py
index bfcc1e5b2e..70a79bdf96 100644
--- a/tests/integration/test_integration.py
+++ b/tests/integration/test_integration.py
@@ -18,7 +18,8 @@
 from dash.dependencies import Input, Output, State
 from dash.exceptions import (
     PreventUpdate, DuplicateCallbackOutput, CallbackException,
-    MissingCallbackContextException, InvalidCallbackReturnValue
+    MissingCallbackContextException, InvalidCallbackReturnValue,
+    IncorrectTypeException
 )
 from .IntegrationTests import IntegrationTests
 from .utils import invincible, wait_for
@@ -871,6 +872,40 @@ def failure2(children):
             context.exception.args[0]
         )
 
+    def test_callback_dep_types(self):
+        app = Dash(__name__)
+        app.layout = html.Div([
+            html.Div('child', id='in'),
+            html.Div('state', id='state'),
+            html.Div(id='out')
+        ])
+
+        with self.assertRaises(IncorrectTypeException):
+            @app.callback([[Output('out', 'children')]],  # extra nesting
+                          [Input('in', 'children')])
+            def f(i):
+                return i
+
+        with self.assertRaises(IncorrectTypeException):
+            @app.callback(Output('out', 'children'),
+                          Input('in', 'children'))  # no nesting
+            def f2(i):
+                return i
+
+        with self.assertRaises(IncorrectTypeException):
+            @app.callback(Output('out', 'children'),
+                          [Input('in', 'children')],
+                          State('state', 'children'))  # no nesting
+            def f3(i):
+                return i
+
+        # all OK with tuples
+        @app.callback((Output('out', 'children'),),
+                      (Input('in', 'children'),),
+                      (State('state', 'children'),))
+        def f4(i):
+            return i
+
     def test_callback_return_validation(self):
         app = Dash(__name__)
         app.layout = html.Div([

From d4a09ba1095c121c428eba1a1fbf0f6536232cbb Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Thu, 6 Jun 2019 08:18:22 -0400
Subject: [PATCH 17/34] linting / style improvements

---
 dash/dash.py | 190 +++++++++++++++++++++++++--------------------------
 1 file changed, 93 insertions(+), 97 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index 1244fb3c5d..a7eedab25d 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -413,7 +413,6 @@ def layout(self, value):
         if (not isinstance(value, Component) and
                 not isinstance(value, _patch_collections_abc('Callable'))):
             raise exceptions.NoLayoutException(
-                ''
                 'Layout must be a dash component '
                 'or a function that returns '
                 'a dash component.')
@@ -517,8 +516,7 @@ def _relative_url_path(relative_package_path='', namespace=''):
                 paths = [paths] if isinstance(paths, str) else paths
 
                 for rel_path in paths:
-                    self.registered_paths[resource['namespace']]\
-                        .add(rel_path)
+                    self.registered_paths[resource['namespace']].add(rel_path)
 
                     if not is_dynamic_resource:
                         srcs.append(_relative_url_path(
@@ -530,28 +528,27 @@ def _relative_url_path(relative_package_path='', namespace=''):
                     if isinstance(resource['external_url'], str):
                         srcs.append(resource['external_url'])
                     else:
-                        for url in resource['external_url']:
-                            srcs.append(url)
+                        srcs += resource['external_url']
             elif 'absolute_path' in resource:
                 raise Exception(
                     'Serving files from absolute_path isn\'t supported yet'
                 )
             elif 'asset_path' in resource:
                 static_url = self.get_asset_url(resource['asset_path'])
-                # Add a bust query param
+                # Add a cache-busting query param
                 static_url += '?m={}'.format(resource['ts'])
                 srcs.append(static_url)
         return srcs
 
     def _generate_css_dist_html(self):
-        links = self.config.external_stylesheets + \
-            self._collect_and_register_resources(self.css.get_all_css())
+        external_links = self.config.external_stylesheets
+        links = self._collect_and_register_resources(self.css.get_all_css())
 
         return '\n'.join([
             _format_tag('link', link, opened=True)
             if isinstance(link, dict)
             else '<link rel="stylesheet" href="{}">'.format(link)
-            for link in links
+            for link in (external_links + links)
         ])
 
     def _generate_scripts_html(self):
@@ -633,14 +630,12 @@ def serve_component_suites(self, package_name, path_in_package_dist):
                 'The path requested: "{}"\n'
                 'List of registered paths: {}'
                 .format(
-                    package_name,
-                    path_in_package_dist,
-                    self.registered_paths
+                    package_name, path_in_package_dist, self.registered_paths
                 )
             )
 
         mimetype = ({
-            'js': 'application/JavaScript',
+            'js': 'application/javascript',
             'css': 'text/css',
             'map': 'application/json'
         })[path_in_package_dist.split('.')[-1]]
@@ -699,9 +694,16 @@ def index(self, *args, **kwargs):  # pylint: disable=unused-argument
 
         return index
 
-    def interpolate_index(self,
-                          metas='', title='', css='', config='',
-                          scripts='', app_entry='', favicon='', renderer=''):
+    def interpolate_index(
+            self,
+            metas='',
+            title='',
+            css='',
+            config='',
+            scripts='',
+            app_entry='',
+            favicon='',
+            renderer=''):
         """
         Called to create the initial HTML string that is loaded on page.
         Override this method to provide you own custom HTML.
@@ -741,15 +743,17 @@ def interpolate_index(self, **kwargs):
         :param favicon: A favicon <link> tag if found in assets folder.
         :return: The interpolated HTML string for the index.
         """
-        return _interpolate(self.index_string,
-                            metas=metas,
-                            title=title,
-                            css=css,
-                            config=config,
-                            scripts=scripts,
-                            favicon=favicon,
-                            renderer=renderer,
-                            app_entry=app_entry)
+        return _interpolate(
+            self.index_string,
+            metas=metas,
+            title=title,
+            css=css,
+            config=config,
+            scripts=scripts,
+            favicon=favicon,
+            renderer=renderer,
+            app_entry=app_entry
+        )
 
     def dependencies(self):
         return flask.jsonify([
@@ -774,7 +778,7 @@ def _validate_callback(self, output, inputs, state):
                 the `layout` property has not been assigned.
                 Assign the `layout` property before assigning callbacks.
                 Alternatively, suppress this warning by setting
-                `app.config['suppress_callback_exceptions']=True`
+                `suppress_callback_exceptions=True`
             '''.replace('    ', ''))
 
         outputs = output if is_multi else [output]
@@ -792,73 +796,65 @@ def _validate_callback(self, output, inputs, state):
             for arg in args:
                 if not isinstance(arg, obj):
                     raise exceptions.IncorrectTypeException(
-                        'The {} argument `{}` is '
-                        'not of type `dash.{}`.'.format(
+                        'The {} argument `{}` must be '
+                        'of type `dash.{}`.'.format(
                             name.lower(), str(arg), name
                         ))
 
                 invalid_characters = ['.']
                 if any(x in arg.component_id for x in invalid_characters):
-                    raise exceptions.InvalidComponentIdError('''The element
-                    `{}` contains {} in its ID.
-                    Periods are not allowed in IDs right now.'''.format(
-                        arg.component_id,
-                        invalid_characters
-                    ))
-
-                if (not self.config.suppress_callback_exceptions and
-                        arg.component_id not in layout and
-                        arg.component_id != getattr(layout, 'id', None)):
-                    raise exceptions.NonExistentIdException('''
-                        Attempting to assign a callback to the
-                        component with the id "{}" but no
-                        components with id "{}" exist in the
-                        app\'s layout.\n\n
-                        Here is a list of IDs in layout:\n{}\n\n
-                        If you are assigning callbacks to components
-                        that are generated by other callbacks
-                        (and therefore not in the initial layout), then
-                        you can suppress this exception by setting
-                        `app.config['suppress_callback_exceptions']=True`.
-                    '''.format(
-                        arg.component_id,
-                        arg.component_id,
-                        list(layout.keys()) + (
-                            [] if not hasattr(layout, 'id') else
-                            [layout.id]
-                        )
-                    ).replace('    ', ''))
+                    raise exceptions.InvalidComponentIdError(
+                        'The element `{}` contains {} in its ID. '
+                        'Periods are not allowed in IDs.'.format(
+                            arg.component_id, invalid_characters
+                        ))
 
                 if not self.config.suppress_callback_exceptions:
-                    if getattr(layout, 'id', None) == arg.component_id:
-                        component = layout
-                    else:
-                        component = layout[arg.component_id]
+                    layout_id = getattr(layout, 'id', None)
+                    arg_id = arg.component_id
+                    arg_prop = getattr(arg, 'component_property', None)
+                    if (arg_id not in layout and arg_id != layout_id):
+                        raise exceptions.NonExistentIdException('''
+                            Attempting to assign a callback to the
+                            component with the id "{0}" but no
+                            components with id "{0}" exist in the
+                            app\'s layout.\n\n
+                            Here is a list of IDs in layout:\n{1}\n\n
+                            If you are assigning callbacks to components
+                            that are generated by other callbacks
+                            (and therefore not in the initial layout), then
+                            you can suppress this exception by setting
+                            `suppress_callback_exceptions=True`.
+                        '''.format(
+                            arg_id,
+                            list(layout.keys()) + (
+                                [layout_id] if layout_id else []
+                            )
+                        ).replace('    ', ''))
+
+                    component = (
+                        layout if layout_id == arg_id else layout[arg_id]
+                    )
 
-                    if (hasattr(arg, 'component_property') and
-                            arg.component_property not in
-                            component.available_properties and not
-                            any(arg.component_property.startswith(w) for w in
-                                component.available_wildcard_properties)):
+                    if (arg_prop and
+                            arg_prop not in component.available_properties and
+                            not any(arg_prop.startswith(w) for w in
+                                    component.available_wildcard_properties)):
                         raise exceptions.NonExistentPropException('''
                             Attempting to assign a callback with
-                            the property "{}" but the component
-                            "{}" doesn't have "{}" as a property.\n
-                            Here is a list of the available properties in "{}":
-                            {}
+                            the property "{0}" but the component
+                            "{1}" doesn't have "{0}" as a property.\n
+                            Here are the available properties in "{1}":
+                            {2}
                         '''.format(
-                            arg.component_property,
-                            arg.component_id,
-                            arg.component_property,
-                            arg.component_id,
-                            component.available_properties).replace(
-                                '    ', ''))
+                            arg_prop, arg_id, component.available_properties
+                        ).replace('    ', ''))
 
                     if hasattr(arg, 'component_event'):
                         raise exceptions.NonExistentEventException('''
                             Events have been removed.
                             Use the associated property instead.
-                        ''')
+                        '''.replace('    ', ''))
 
         if state and not inputs:
             raise exceptions.MissingInputsException('''
@@ -930,7 +926,7 @@ def duplicate_check():
                 '''.format(
                     callback_id,
                     pprint.pformat(ns['duplicates'])
-                )
+                ).replace('    ', '')
             else:
                 msg = '''
                 You have already assigned a callback to the output
@@ -947,8 +943,9 @@ def duplicate_check():
     def _validate_callback_output(output_value, output):
         valid = [str, dict, int, float, type(None), Component]
 
-        def _raise_invalid(bad_val, outer_val, bad_type, path, index=None,
+        def _raise_invalid(bad_val, outer_val, path, index=None,
                            toplevel=False):
+            bad_type = type(bad_val).__name__
             outer_id = "(id={:s})".format(outer_val.id) \
                 if getattr(outer_val, 'id', False) else ''
             outer_type = type(outer_val).__name__
@@ -981,7 +978,8 @@ def _raise_invalid(bad_val, outer_val, bad_type, path, index=None,
                      else ('[*] ' + outer_type + ' ' + outer_id))
                     + "\n" + path + "\n"
                 ) if not toplevel else '',
-                bad_val=bad_val).replace('    ', ''))
+                bad_val=bad_val
+            ).replace('    ', ''))
 
         def _value_is_valid(val):
             return (
@@ -1000,7 +998,6 @@ def _validate_value(val, index=None):
                         _raise_invalid(
                             bad_val=j,
                             outer_val=val,
-                            bad_type=type(j).__name__,
                             path=p,
                             index=index
                         )
@@ -1014,7 +1011,6 @@ def _validate_value(val, index=None):
                             _raise_invalid(
                                 bad_val=child,
                                 outer_val=val,
-                                bad_type=type(child).__name__,
                                 path=p + "\n" + "[*] " + type(child).__name__,
                                 index=index
                             )
@@ -1026,7 +1022,6 @@ def _validate_value(val, index=None):
                         _raise_invalid(
                             bad_val=child,
                             outer_val=val,
-                            bad_type=type(child).__name__,
                             path=type(child).__name__,
                             index=index
                         )
@@ -1037,7 +1032,6 @@ def _validate_value(val, index=None):
                     _raise_invalid(
                         bad_val=val,
                         outer_val=type(val).__name__,
-                        bad_type=type(val).__name__,
                         path='',
                         index=index,
                         toplevel=True
@@ -1207,8 +1201,10 @@ def add_context(*args, **kwargs):
                     In general, Dash properties can only be
                     dash components, strings, dictionaries, numbers, None,
                     or lists of those.
-                    '''.format(property=output.component_property,
-                               id=output.component_id))
+                    '''.format(
+                        property=output.component_property,
+                        id=output.component_id
+                    ).replace('    ', ''))
 
                 return jsonResponse
 
@@ -1263,7 +1259,6 @@ def dispatch(self):
     def _validate_layout(self):
         if self.layout is None:
             raise exceptions.NoLayoutException(
-                ''
                 'The layout was `None` '
                 'at the time that `run_server` was called. '
                 'Make sure to set the `layout` attribute of your application '
@@ -1390,16 +1385,17 @@ def _setup_dev_tools(self, **kwargs):
 
         return dev_tools
 
-    def enable_dev_tools(self,
-                         debug=None,
-                         dev_tools_ui=None,
-                         dev_tools_props_check=None,
-                         dev_tools_serve_dev_bundles=None,
-                         dev_tools_hot_reload=None,
-                         dev_tools_hot_reload_interval=None,
-                         dev_tools_hot_reload_watch_interval=None,
-                         dev_tools_hot_reload_max_retry=None,
-                         dev_tools_silence_routes_logging=None):
+    def enable_dev_tools(
+            self,
+            debug=None,
+            dev_tools_ui=None,
+            dev_tools_props_check=None,
+            dev_tools_serve_dev_bundles=None,
+            dev_tools_hot_reload=None,
+            dev_tools_hot_reload_interval=None,
+            dev_tools_hot_reload_watch_interval=None,
+            dev_tools_hot_reload_max_retry=None,
+            dev_tools_silence_routes_logging=None):
         """
         Activate the dev tools, called by `run_server`. If your application is
         served by wsgi and you want to activate the dev tools, you can call

From a4146d382e725b196469255e9718e37d9f956fb0 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Thu, 6 Jun 2019 15:43:36 -0400
Subject: [PATCH 18/34] linting, encapsulate hot reload state & helpers in
 AttributeDict, and use lock as context manager

---
 dash/dash.py | 154 +++++++++++++++++++++++++--------------------------
 1 file changed, 77 insertions(+), 77 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index a7eedab25d..3b561ea504 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -232,11 +232,10 @@ def __init__(
                     key + ' is no longer a valid keyword argument in Dash '
                     'since v1.0. See https://dash.plot.ly for details.'
                 )
-            else:
-                # any other kwarg mimic the built-in exception
-                raise TypeError(
-                    "Dash() got an unexpected keyword argument '" + key + "'"
-                )
+            # any other kwarg mimic the built-in exception
+            raise TypeError(
+                "Dash() got an unexpected keyword argument '" + key + "'"
+            )
 
         # We have 3 cases: server is either True (we create the server), False
         # (defer server creation) or a Flask app instance (we use their server)
@@ -300,6 +299,13 @@ def __init__(
         self._cached_layout = None
 
         self._setup_dev_tools()
+        self._hot_reload = _AttributeDict(
+            hash=None,
+            hard=False,
+            lock=threading.RLock(),
+            watch_thread=None,
+            changed_assets=[]
+        )
 
         self._assets_files = []
 
@@ -466,15 +472,16 @@ def _config(self):
         return config
 
     def serve_reload_hash(self):
-        hard = self._hard_reload
-        changed = self._changed_assets
-        self._lock.acquire()
-        self._hard_reload = False
-        self._changed_assets = []
-        self._lock.release()
+        reload = self._hot_reload
+        with reload.lock:
+            hard = reload.hard
+            changed = reload.changed_assets
+            _hash = reload.hash
+            reload.hard = False
+            reload.changed_assets = []
 
         return flask.jsonify({
-            'reloadHash': self._reload_hash,
+            'reloadHash': _hash,
             'hard': hard,
             'packages': list(self.registered_paths.keys()),
             'files': list(changed)
@@ -1334,7 +1341,8 @@ def _walk_assets_directory(self):
     def _invalid_resources_handler(err):
         return err.args[0], 404
 
-    def _serve_default_favicon(self):
+    @staticmethod
+    def _serve_default_favicon():
         return flask.Response(
             pkgutil.get_data('dash', 'favicon.ico'),
             content_type='image/x-icon',
@@ -1354,20 +1362,20 @@ def _setup_dev_tools(self, **kwargs):
         dev_tools = self._dev_tools = _AttributeDict()
 
         for attr in (
-            'ui',
-            'props_check',
-            'serve_dev_bundles',
-            'hot_reload',
-            'silence_routes_logging'
+                'ui',
+                'props_check',
+                'serve_dev_bundles',
+                'hot_reload',
+                'silence_routes_logging'
         ):
             dev_tools[attr] = get_combined_config(
                 attr, kwargs.get(attr, None), default=debug
             )
 
         for attr, _type, default in (
-            ('hot_reload_interval', float, 3),
-            ('hot_reload_watch_interval', float, 0.5),
-            ('hot_reload_max_retry', int, 8)
+                ('hot_reload_interval', float, 3),
+                ('hot_reload_watch_interval', float, 0.5),
+                ('hot_reload_max_retry', int, 8)
         ):
             dev_tools[attr] = _type(
                 get_combined_config(
@@ -1375,14 +1383,6 @@ def _setup_dev_tools(self, **kwargs):
                 )
             )
 
-        if not hasattr(self, '_reload_hash'):
-            # for hot reload
-            self._reload_hash = None
-            self._hard_reload = False
-            self._lock = threading.RLock()
-            self._watch_thread = None
-            self._changed_assets = []
-
         return dev_tools
 
     def enable_dev_tools(
@@ -1481,7 +1481,8 @@ def enable_dev_tools(
             self.logger.setLevel(logging.INFO)
 
         if dev_tools.hot_reload:
-            self._reload_hash = _generate_hash()
+            reload = self._hot_reload
+            reload.hash = _generate_hash()
 
             component_packages_dist = [
                 os.path.dirname(package.path)
@@ -1493,14 +1494,14 @@ def enable_dev_tools(
                 )
             ]
 
-            self._watch_thread = threading.Thread(
+            reload.watch_thread = threading.Thread(
                 target=lambda: _watch.watch(
                     [self.config.assets_folder] + component_packages_dist,
                     self._on_assets_change,
                     sleep_time=dev_tools.hot_reload_watch_interval)
             )
-            self._watch_thread.daemon = True
-            self._watch_thread.start()
+            reload.watch_thread.daemon = True
+            reload.watch_thread.start()
 
         if (debug and dev_tools.serve_dev_bundles and
                 not self.scripts.config.serve_locally):
@@ -1513,50 +1514,49 @@ def enable_dev_tools(
 
     # noinspection PyProtectedMember
     def _on_assets_change(self, filename, modified, deleted):
-        self._lock.acquire()
-        self._hard_reload = True
-        self._reload_hash = _generate_hash()
-
-        if self.config.assets_folder in filename:
-            asset_path = os.path.relpath(
-                filename,
-                os.path.commonprefix([self.config.assets_folder, filename])
-            ).replace('\\', '/').lstrip('/')
-
-            self._changed_assets.append({
-                'url': self.get_asset_url(asset_path),
-                'modified': int(modified),
-                'is_css': filename.endswith('css')
-            })
-
-            if filename not in self._assets_files and not deleted:
-                res = self._add_assets_resource(asset_path, filename)
-                if filename.endswith('js'):
-                    self.scripts.append_script(res)
-                elif filename.endswith('css'):
-                    self.css.append_css(res)
-
-            if deleted:
-                if filename in self._assets_files:
-                    self._assets_files.remove(filename)
-
-                def delete_resource(resources):
-                    to_delete = None
-                    for r in resources:
-                        if r.get('asset_path') == asset_path:
-                            to_delete = r
-                            break
-                    if to_delete:
-                        resources.remove(to_delete)
-
-                if filename.endswith('js'):
-                    # pylint: disable=protected-access
-                    delete_resource(self.scripts._resources._resources)
-                elif filename.endswith('css'):
-                    # pylint: disable=protected-access
-                    delete_resource(self.css._resources._resources)
-
-        self._lock.release()
+        reload = self._hot_reload
+        with reload.lock:
+            reload.hard = True
+            reload.hash = _generate_hash()
+
+            if self.config.assets_folder in filename:
+                asset_path = os.path.relpath(
+                    filename,
+                    os.path.commonprefix([self.config.assets_folder, filename])
+                ).replace('\\', '/').lstrip('/')
+
+                reload.changed_assets.append({
+                    'url': self.get_asset_url(asset_path),
+                    'modified': int(modified),
+                    'is_css': filename.endswith('css')
+                })
+
+                if filename not in self._assets_files and not deleted:
+                    res = self._add_assets_resource(asset_path, filename)
+                    if filename.endswith('js'):
+                        self.scripts.append_script(res)
+                    elif filename.endswith('css'):
+                        self.css.append_css(res)
+
+                if deleted:
+                    if filename in self._assets_files:
+                        self._assets_files.remove(filename)
+
+                    def delete_resource(resources):
+                        to_delete = None
+                        for r in resources:
+                            if r.get('asset_path') == asset_path:
+                                to_delete = r
+                                break
+                        if to_delete:
+                            resources.remove(to_delete)
+
+                    if filename.endswith('js'):
+                        # pylint: disable=protected-access
+                        delete_resource(self.scripts._resources._resources)
+                    elif filename.endswith('css'):
+                        # pylint: disable=protected-access
+                        delete_resource(self.css._resources._resources)
 
     def run_server(
             self,

From e75de81ceca89c74204110ef8d2ac33b3619fc98 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Thu, 6 Jun 2019 20:16:38 -0400
Subject: [PATCH 19/34] prevent changing some config keys or adding any new
 ones

---
 dash/_utils.py                | 24 ++++++++++++--
 dash/dash.py                  | 14 ++++++++
 tests/unit/dash/test_utils.py | 62 +++++++++++++++++++++++++++++++++++
 3 files changed, 98 insertions(+), 2 deletions(-)
 create mode 100644 tests/unit/dash/test_utils.py

diff --git a/dash/_utils.py b/dash/_utils.py
index 740f946d2a..dcd83b1c26 100644
--- a/dash/_utils.py
+++ b/dash/_utils.py
@@ -75,8 +75,28 @@ def __getattr__(self, key):
         try:
             return self[key]
         except KeyError:
-            # to conform with __getattr__ spec
-            raise AttributeError(key)
+            pass
+        # to conform with __getattr__ spec
+        # but get out of the except block so it doesn't look like a nested err
+        raise AttributeError(key)
+
+    def set_read_only(self, names, msg='Attribute is read-only'):
+        object.__setattr__(self, '_read_only', names)
+        object.__setattr__(self, '_read_only_msg', msg)
+
+    def finalize(self, msg='Object is final: No new keys may be added.'):
+        """Prevent any new keys being set"""
+        object.__setattr__(self, '_final', msg)
+
+    def __setitem__(self, key, val):
+        if key in self.__dict__.get('_read_only', []):
+            raise AttributeError(self._read_only_msg, key)
+
+        final_msg = self.__dict__.get('_final')
+        if final_msg and key not in self:
+            raise AttributeError(final_msg, key)
+
+        return super(AttributeDict, self).__setitem__(key, val)
 
     # pylint: disable=inconsistent-return-statements
     def first(self, *names):
diff --git a/dash/dash.py b/dash/dash.py
index 3b561ea504..48291c17c0 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -274,6 +274,20 @@ def __init__(
                 False),
             show_undo_redo=show_undo_redo
         )
+        self.config.set_read_only([
+            'name',
+            'assets_folder',
+            'assets_url_path',
+            'url_base_pathname',
+            'routes_pathname_prefix',
+            'requests_pathname_prefix',
+            'serve_locally',
+            'compress',
+        ], 'Read-only: can only be set in the Dash constructor')
+        self.config.finalize(
+            'Invalid config key. Some settings are only available '
+            'via the Dash constructor'
+        )
 
         # list of dependencies
         self.callback_map = {}
diff --git a/tests/unit/dash/test_utils.py b/tests/unit/dash/test_utils.py
new file mode 100644
index 0000000000..409cf7a89d
--- /dev/null
+++ b/tests/unit/dash/test_utils.py
@@ -0,0 +1,62 @@
+import dash._utils as utils
+import pytest
+
+
+def test_attribute_dict():
+    a = utils.AttributeDict()
+
+    assert str(a) == '{}'
+    with pytest.raises(AttributeError):
+        a.k
+    with pytest.raises(KeyError):
+        a['k']
+    assert a.first('no', 'k', 'nope') is None
+
+    a.k = 1
+
+    assert a.k == 1
+    assert a['k'] == 1
+    assert a.first('no', 'k', 'nope') == 1
+
+    a['k'] = 2
+
+    assert a.k == 2
+    assert a['k'] == 2
+
+    a.set_read_only(['k', 'q'], 'boo')
+
+    with pytest.raises(AttributeError) as err:
+        a.k = 3
+    assert err.value.args == ('boo', 'k')
+    assert a.k == 2
+
+    with pytest.raises(AttributeError) as err:
+        a['k'] = 3
+    assert err.value.args == ('boo', 'k')
+    assert a.k == 2
+
+    a.set_read_only(['q'])
+
+    a.k = 3
+    assert a.k == 3
+
+    with pytest.raises(AttributeError) as err:
+        a.q = 3
+    assert err.value.args == ('Attribute is read-only', 'q')
+    assert 'q' not in a
+
+    a.finalize('nope')
+
+    with pytest.raises(AttributeError) as err:
+        a.x = 4
+    assert err.value.args == ('nope', 'x')
+    assert 'x' not in a
+
+    a.finalize()
+
+    with pytest.raises(AttributeError) as err:
+        a.x = 4
+    assert err.value.args == (
+        'Object is final: No new keys may be added.', 'x'
+    )
+    assert 'x' not in a

From d898546f275e7f02fb980dbde348019d73c83349 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Thu, 6 Jun 2019 22:16:46 -0400
Subject: [PATCH 20/34] oops, who knew, reload is a builtin

---
 dash/dash.py | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index 48291c17c0..d7f3d83027 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -486,13 +486,13 @@ def _config(self):
         return config
 
     def serve_reload_hash(self):
-        reload = self._hot_reload
-        with reload.lock:
-            hard = reload.hard
-            changed = reload.changed_assets
-            _hash = reload.hash
-            reload.hard = False
-            reload.changed_assets = []
+        _reload = self._hot_reload
+        with _reload.lock:
+            hard = _reload.hard
+            changed = _reload.changed_assets
+            _hash = _reload.hash
+            _reload.hard = False
+            _reload.changed_assets = []
 
         return flask.jsonify({
             'reloadHash': _hash,
@@ -1495,8 +1495,8 @@ def enable_dev_tools(
             self.logger.setLevel(logging.INFO)
 
         if dev_tools.hot_reload:
-            reload = self._hot_reload
-            reload.hash = _generate_hash()
+            _reload = self._hot_reload
+            _reload.hash = _generate_hash()
 
             component_packages_dist = [
                 os.path.dirname(package.path)
@@ -1508,14 +1508,14 @@ def enable_dev_tools(
                 )
             ]
 
-            reload.watch_thread = threading.Thread(
+            _reload.watch_thread = threading.Thread(
                 target=lambda: _watch.watch(
                     [self.config.assets_folder] + component_packages_dist,
                     self._on_assets_change,
                     sleep_time=dev_tools.hot_reload_watch_interval)
             )
-            reload.watch_thread.daemon = True
-            reload.watch_thread.start()
+            _reload.watch_thread.daemon = True
+            _reload.watch_thread.start()
 
         if (debug and dev_tools.serve_dev_bundles and
                 not self.scripts.config.serve_locally):
@@ -1528,10 +1528,10 @@ def enable_dev_tools(
 
     # noinspection PyProtectedMember
     def _on_assets_change(self, filename, modified, deleted):
-        reload = self._hot_reload
-        with reload.lock:
-            reload.hard = True
-            reload.hash = _generate_hash()
+        _reload = self._hot_reload
+        with _reload.lock:
+            _reload.hard = True
+            _reload.hash = _generate_hash()
 
             if self.config.assets_folder in filename:
                 asset_path = os.path.relpath(
@@ -1539,7 +1539,7 @@ def _on_assets_change(self, filename, modified, deleted):
                     os.path.commonprefix([self.config.assets_folder, filename])
                 ).replace('\\', '/').lstrip('/')
 
-                reload.changed_assets.append({
+                _reload.changed_assets.append({
                     'url': self.get_asset_url(asset_path),
                     'modified': int(modified),
                     'is_css': filename.endswith('css')

From 080ac2b66ac0581012232b502cac16402cf0f053 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Thu, 6 Jun 2019 22:38:52 -0400
Subject: [PATCH 21/34] test_utils import order fix

---
 tests/unit/dash/test_utils.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/unit/dash/test_utils.py b/tests/unit/dash/test_utils.py
index 409cf7a89d..1df6519684 100644
--- a/tests/unit/dash/test_utils.py
+++ b/tests/unit/dash/test_utils.py
@@ -1,6 +1,7 @@
-import dash._utils as utils
 import pytest
 
+import dash._utils as utils
+
 
 def test_attribute_dict():
     a = utils.AttributeDict()

From 0056298348880695168f41290549b8a5b47b3da3 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Thu, 6 Jun 2019 23:12:23 -0400
Subject: [PATCH 22/34] changelog for dash.Dash API changes PR

---
 dash/CHANGELOG.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/dash/CHANGELOG.md b/dash/CHANGELOG.md
index ef8b9027a4..71a24b7280 100644
--- a/dash/CHANGELOG.md
+++ b/dash/CHANGELOG.md
@@ -1,5 +1,13 @@
 ## Unreleased
 ### Changed
+- [#761](https://github.com/plotly/dash/pull/761) Several breaking changes to the `dash.Dash` API:
+  - Removed two obsolete constructor kwargs: `static_folder` and `components_cache_max_age`
+  - Removed the misspelled `supress_callback_exceptions` fallback
+  - Removed the unused `resources.config.infer_from_layout`
+  - Revamped `app.config`: ALL constructor args are now stored in `config`, with three exceptions: `server`, `index_string`, and `plugins`. None of these are stored in any other instance attributes anymore.
+  - Changed `hot_reload_interval` from msec to seconds, for consistency with `hot_reload_watch_interval`
+  - When called from `enable_dev_tools`, `debug=True` by default. It's still `False` by default from `run_server`.
+
 - [#753](https://github.com/plotly/dash/pull/753) `Component` no longer inherits `MutableMapping`, so `values`, `keys`, and more are no longer methods. This fixed an issue reported in [dcc](https://github.com/plotly/dash-core-components/issues/440) where components with certain prop names defined but not provided would cause a failure to render. During component generation we now disallow all props with leading underscores or matching a few remaining reserved words: `UNDEFINED`, `REQUIRED`, `to_plotly_json`, `available_properties`, and `available_wildcard_properties`.
 
 - [#739](https://github.com/plotly/dash/pull/739) Allow the Flask app to be provided to Dash after object initialization. This allows users to define Dash layouts etc when using the app factory pattern, or any other pattern that inhibits access to the app object. This broadly complies with the flask extension API, allowing Dash to be considered as a Flask extension where it needs to be.

From cbd48b076d64425853067f3c137813ad7708f09b Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Fri, 7 Jun 2019 22:23:12 -0400
Subject: [PATCH 23/34] docstring updates as suggested by @byronz

---
 dash/dash.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index d7f3d83027..7d86e580ef 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -90,7 +90,8 @@ class Dash(object):
     Dash is a framework for building analytical web applications.
     No JavaScript required.
 
-    If a parameter can be set by an environment variable, that is listed too.
+    If a parameter can be set by an environment variable, that is listed as:
+        env: ``DASH_****``
     Values provided here take precedence over environment variables.
 
     :param name: The name Flask should use for your app. Even if you provide
@@ -107,9 +108,10 @@ class Dash(object):
     :type server: boolean or flask.Flask
 
     :param assets_folder: a path, relative to the current working directory,
-        for extra files to be used in the browser. Default ``'assets'`` By
-        default all .js and .css will be loaded immediately, and other files
-        such as images will be served if requested.
+        for extra files to be used in the browser. Default ``'assets'``.
+        All .js and .css files will be loaded immediately unless excluded by
+        ``assets_ignore``, and other files such as images will be served if
+        requested.
     :type assets_folder: string
 
     :param assets_url_path: The local urls for assets will be:
@@ -118,7 +120,7 @@ class Dash(object):
         Default ``'assets'``.
     :type asset_url_path: string
 
-    :param assets_ignore: A regexp, as a string to pass to ``re.compile``, for
+    :param assets_ignore: A regex, as a string to pass to ``re.compile``, for
         assets to omit from immediate loading. Ignored files will still be
         served if specifically requested. You cannot use this to prevent access
         to sensitive files.

From 02b31cdff752ec447a34ab929f22d637a7947ef0 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Sat, 8 Jun 2019 09:01:51 -0400
Subject: [PATCH 24/34] self-documenting **obsolete

---
 dash/dash.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/dash/dash.py b/dash/dash.py
index 7d86e580ef..e48dbe9c39 100644
--- a/dash/dash.py
+++ b/dash/dash.py
@@ -202,8 +202,6 @@ class Dash(object):
         with a ``plug`` method, taking a single argument: this app, which will
         be called after the Flask server is attached.
     :type plugins: list of objects
-
-    :param **kwargs: Do not use. Gives error messages for obsolete arguments.
     """
     def __init__(
             self,
@@ -226,9 +224,9 @@ def __init__(
             suppress_callback_exceptions=None,
             show_undo_redo=False,
             plugins=None,
-            **kwargs):
+            **obsolete):
 
-        for key in kwargs:
+        for key in obsolete:
             if key in ['components_cache_max_age', 'static_folder']:
                 raise exceptions.ObsoleteKwargException(
                     key + ' is no longer a valid keyword argument in Dash '

From 519fdc9f2165f2ddac42449ed03f42dfa0cc52ab Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Sat, 8 Jun 2019 09:08:12 -0400
Subject: [PATCH 25/34] boom in changelog

---
 dash/CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dash/CHANGELOG.md b/dash/CHANGELOG.md
index 71a24b7280..3e6f17d745 100644
--- a/dash/CHANGELOG.md
+++ b/dash/CHANGELOG.md
@@ -1,6 +1,6 @@
 ## Unreleased
 ### Changed
-- [#761](https://github.com/plotly/dash/pull/761) Several breaking changes to the `dash.Dash` API:
+- 💥 [#761](https://github.com/plotly/dash/pull/761) Several breaking changes to the `dash.Dash` API:
   - Removed two obsolete constructor kwargs: `static_folder` and `components_cache_max_age`
   - Removed the misspelled `supress_callback_exceptions` fallback
   - Removed the unused `resources.config.infer_from_layout`

From 9f202988d464b8f4ba5d15ce3038958ec91bcd69 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Mon, 10 Jun 2019 15:43:21 -0400
Subject: [PATCH 26/34] re-remove supress fallback after merging test refactor

---
 tests/integration/callbacks/test_basic_callback.py | 2 +-
 tests/integration/renderer/test_dependencies.py    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/integration/callbacks/test_basic_callback.py b/tests/integration/callbacks/test_basic_callback.py
index f12c589b0b..97cc40c5ba 100644
--- a/tests/integration/callbacks/test_basic_callback.py
+++ b/tests/integration/callbacks/test_basic_callback.py
@@ -66,7 +66,7 @@ def pad_output(input):
     call_count = Value("i", 0)
 
     # these components don't exist in the initial render
-    app.config.supress_callback_exceptions = True
+    app.config.suppress_callback_exceptions = True
 
     @app.callback(
         Output("sub-output-1", "children"), [Input("sub-input-1", "value")]
diff --git a/tests/integration/renderer/test_dependencies.py b/tests/integration/renderer/test_dependencies.py
index d1160d9c45..ef62c4406f 100644
--- a/tests/integration/renderer/test_dependencies.py
+++ b/tests/integration/renderer/test_dependencies.py
@@ -21,7 +21,7 @@ def update_output(value):
 
     # callback for component that doesn't yet exist in the dom
     # in practice, it might get added by some other callback
-    app.config.supress_callback_exceptions = True
+    app.config.suppress_callback_exceptions = True
     output_2_call_count = Value("i", 0)
 
     @app.callback(Output("output-2", "children"), [Input("input", "value")])

From b7b71afc14d4c78219f95249dad950b36bcf20fa Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Mon, 10 Jun 2019 16:17:53 -0400
Subject: [PATCH 27/34] improve testing messages for default timeout

---
 dash/testing/browser.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/dash/testing/browser.py b/dash/testing/browser.py
index 99e552c509..b804a412da 100644
--- a/dash/testing/browser.py
+++ b/dash/testing/browser.py
@@ -110,29 +110,32 @@ def wait_for_element(self, css_selector, timeout=None):
 
     # keep these two wait_for API for easy migration
     def wait_for_element_by_css_selector(self, selector, timeout=None):
+        _time = timeout or self._wait_timeout
         return self._wait_for(
             EC.presence_of_element_located,
             ((By.CSS_SELECTOR, selector),),
             timeout,
-            "timeout {} => waiting for selector {}".format(timeout, selector),
+            "timeout {}s => waiting for selector {}".format(_time, selector),
         )
 
     def wait_for_style_to_equal(self, selector, style, val, timeout=None):
+        _time = timeout or self._wait_timeout
         return self._wait_for(
             method=style_to_equal,
             args=(selector, style, val),
             timeout=timeout,
             msg="style val => {} {} not found within {}s".format(
-                style, val, timeout
+                style, val, _time
             ),
         )
 
     def wait_for_text_to_equal(self, selector, text, timeout=None):
+        _time = timeout or self._wait_timeout
         return self._wait_for(
             method=text_to_equal,
             args=(selector, text),
             timeout=timeout,
-            msg="text -> {} not found within {}s".format(text, timeout),
+            msg="text -> {} not found within {}s".format(text, _time),
         )
 
     def wait_for_page(self, url=None, timeout=10):

From dbc198133885531e26e171327f032de6a6350b5d Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Mon, 10 Jun 2019 16:20:03 -0400
Subject: [PATCH 28/34] re-convert hot_reload_interval to seconds in tests

---
 tests/integration/devtools/test_hot_reload.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/integration/devtools/test_hot_reload.py b/tests/integration/devtools/test_hot_reload.py
index 5c5845efde..1bb2b44dba 100644
--- a/tests/integration/devtools/test_hot_reload.py
+++ b/tests/integration/devtools/test_hot_reload.py
@@ -11,7 +11,7 @@ def test_dvhr001_hot_reload(dash_duo):
     dash_duo.start_server(
         app,
         dev_tools_hot_reload=True,
-        dev_tools_hot_reload_interval=100,
+        dev_tools_hot_reload_interval=0.1,
         dev_tools_hot_reload_max_retry=30,
     )
 

From 7fe4b5252097819523d5b26307eac3486037c1ae Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Mon, 10 Jun 2019 18:13:14 -0400
Subject: [PATCH 29/34] try to robustify callbacks_generating_children

---
 tests/integration/callbacks/test_basic_callback.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/integration/callbacks/test_basic_callback.py b/tests/integration/callbacks/test_basic_callback.py
index 97cc40c5ba..fffe0701ab 100644
--- a/tests/integration/callbacks/test_basic_callback.py
+++ b/tests/integration/callbacks/test_basic_callback.py
@@ -49,7 +49,8 @@ def update_output(value):
 def test_cbsc002_callbacks_generating_children(dash_duo):
     """ Modify the DOM tree by adding new components in the callbacks"""
 
-    app = dash.Dash(__name__)
+    # some components don't exist in the initial render
+    app = dash.Dash(__name__, suppress_callback_exceptions=True)
     app.layout = html.Div(
         [dcc.Input(id="input", value="initial value"), html.Div(id="output")]
     )
@@ -65,9 +66,6 @@ def pad_output(input):
 
     call_count = Value("i", 0)
 
-    # these components don't exist in the initial render
-    app.config.suppress_callback_exceptions = True
-
     @app.callback(
         Output("sub-output-1", "children"), [Input("sub-input-1", "value")]
     )
@@ -77,6 +75,8 @@ def update_input(value):
 
     dash_duo.start_server(app)
 
+    dash_duo.wait_for_text_to_equal("#sub-output-1", "sub input initial value")
+
     assert call_count.value == 1, "called once at initial stage"
 
     pad_input, pad_div = dash_duo.dash_innerhtml_dom.select_one(

From 55274bea6ad084443a785ca6c1bef926e9de0060 Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 11 Jun 2019 07:19:58 -0400
Subject: [PATCH 30/34] collapse _time intermediate

---
 dash/testing/browser.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/dash/testing/browser.py b/dash/testing/browser.py
index b804a412da..cac07b7ae8 100644
--- a/dash/testing/browser.py
+++ b/dash/testing/browser.py
@@ -110,32 +110,33 @@ def wait_for_element(self, css_selector, timeout=None):
 
     # keep these two wait_for API for easy migration
     def wait_for_element_by_css_selector(self, selector, timeout=None):
-        _time = timeout or self._wait_timeout
         return self._wait_for(
             EC.presence_of_element_located,
             ((By.CSS_SELECTOR, selector),),
             timeout,
-            "timeout {}s => waiting for selector {}".format(_time, selector),
+            "timeout {}s => waiting for selector {}".format(
+                timeout if timeout else self._wait_timeout, selector
+            ),
         )
 
     def wait_for_style_to_equal(self, selector, style, val, timeout=None):
-        _time = timeout or self._wait_timeout
         return self._wait_for(
             method=style_to_equal,
             args=(selector, style, val),
             timeout=timeout,
             msg="style val => {} {} not found within {}s".format(
-                style, val, _time
+                style, val, timeout if timeout else self._wait_timeout
             ),
         )
 
     def wait_for_text_to_equal(self, selector, text, timeout=None):
-        _time = timeout or self._wait_timeout
         return self._wait_for(
             method=text_to_equal,
             args=(selector, text),
             timeout=timeout,
-            msg="text -> {} not found within {}s".format(text, _time),
+            msg="text -> {} not found within {}s".format(
+                text, timeout if timeout else self._wait_timeout
+            ),
         )
 
     def wait_for_page(self, url=None, timeout=10):

From 6c93e60f3567dfbdf7aa3d59694533e292776e4f Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 11 Jun 2019 11:53:37 -0400
Subject: [PATCH 31/34] evaluate wait_cond before any wait in until(_not)

---
 dash/testing/wait.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dash/testing/wait.py b/dash/testing/wait.py
index 5d62d93c99..0fd33ec3c4 100644
--- a/dash/testing/wait.py
+++ b/dash/testing/wait.py
@@ -15,7 +15,7 @@ def until(
     poll=0.1,
     msg="expected condition not met within timeout",
 ):  # noqa: C0330
-    res = None
+    res = wait_cond()
     logger.debug(
         "start wait.until with method, timeout, poll => %s %s %s",
         wait_cond,
@@ -36,7 +36,7 @@ def until(
 def until_not(
     wait_cond, timeout, poll=0.1, msg="expected condition met within timeout"
 ):  # noqa: C0330
-    res = True
+    res = wait_cond()
     logger.debug(
         "start wait.until_not method, timeout, poll => %s %s %s",
         wait_cond,

From 40525079c6f6af873ca68faec8ee2743de3c1c2e Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 11 Jun 2019 11:54:22 -0400
Subject: [PATCH 32/34] convert test_integration.py to pytest

---
 tests/integration/test_integration.py | 1608 ++++++++++++-------------
 1 file changed, 772 insertions(+), 836 deletions(-)

diff --git a/tests/integration/test_integration.py b/tests/integration/test_integration.py
index 2505d19704..d5fa28e02d 100644
--- a/tests/integration/test_integration.py
+++ b/tests/integration/test_integration.py
@@ -3,7 +3,8 @@
 import itertools
 import re
 import time
-from selenium.webdriver.common.action_chains import ActionChains
+import pytest
+
 from selenium.webdriver.common.keys import Keys
 
 import dash_dangerously_set_inner_html
@@ -20,323 +21,328 @@
     MissingCallbackContextException, InvalidCallbackReturnValue,
     IncorrectTypeException
 )
-from .IntegrationTests import IntegrationTests
-from .utils import invincible, wait_for
-
-
-class Tests(IntegrationTests):
-    def setUp(self):
-        def wait_for_element_by_id(id):
-            wait_for(lambda: None is not invincible(
-                lambda: self.driver.find_element_by_id(id)
-            ))
-            return self.driver.find_element_by_id(id)
-        self.wait_for_element_by_id = wait_for_element_by_id
-
-    def test_simple_callback(self):
-        app = Dash(__name__)
-        app.layout = html.Div([
-            dcc.Input(
-                id='input',
-                value='initial value'
-            ),
-            html.Div(
-                html.Div([
-                    1.5,
-                    None,
-                    'string',
-                    html.Div(id='output-1')
-                ])
-            )
-        ])
-
-        call_count = Value('i', 0)
+from dash.testing.wait import until
 
-        @app.callback(Output('output-1', 'children'), [Input('input', 'value')])
-        def update_output(value):
-            call_count.value += 1
-            return value
 
-        self.startServer(app)
+def test_simple_callback(dash_duo):
+    app = Dash(__name__)
+    app.layout = html.Div([
+        dcc.Input(id='input', value='initial value'),
+        html.Div(html.Div([1.5, None, 'string', html.Div(id='output-1')]))
+    ])
 
-        self.wait_for_text_to_equal('#output-1', 'initial value')
-        self.percy_snapshot(name='simple-callback-1')
+    call_count = Value('i', 0)
 
-        input1 = self.wait_for_element_by_id('input')
+    @app.callback(Output('output-1', 'children'), [Input('input', 'value')])
+    def update_output(value):
+        call_count.value += 1
+        return value
 
-        chain = (
-            ActionChains(self.driver)
-            .click(input1)
-            .send_keys(Keys.HOME)
-            .key_down(Keys.SHIFT)
-            .send_keys(Keys.END)
-            .key_up(Keys.SHIFT)
-            .send_keys(Keys.DELETE))
-        chain.perform()
+    dash_duo.start_server(app)
 
-        input1.send_keys('hello world')
+    dash_duo.wait_for_text_to_equal('#output-1', 'initial value')
+    dash_duo.percy_snapshot(name='simple-callback-1')
 
-        self.wait_for_text_to_equal('#output-1', 'hello world')
-        self.percy_snapshot(name='simple-callback-2')
+    input1 = dash_duo.find_element('#input')
+    dash_duo.clear_input(input1)
+    input1.send_keys('hello world')
 
-        self.assertEqual(
-            call_count.value,
-            # an initial call to retrieve the first value
-            # and one for clearing the input
-            2 +
-            # one for each hello world character
-            len('hello world')
-        )
+    dash_duo.wait_for_text_to_equal('#output-1', 'hello world')
+    dash_duo.percy_snapshot(name='simple-callback-2')
 
-        self.assertTrue(self.is_console_clean())
-
-    def test_wildcard_callback(self):
-        app = Dash(__name__)
-        app.layout = html.Div([
-            dcc.Input(
-                id='input',
-                value='initial value'
-            ),
-            html.Div(
-                html.Div([
-                    1.5,
-                    None,
-                    'string',
-                    html.Div(id='output-1', **{'data-cb': 'initial value',
-                                               'aria-cb': 'initial value'})
-                ])
-            )
-        ])
+    # an initial call, one for clearing the input
+    # and one for each hello world character
+    assert call_count.value == 2 + len('hello world')
 
-        input_call_count = Value('i', 0)
-
-        @app.callback(Output('output-1', 'data-cb'), [Input('input', 'value')])
-        def update_data(value):
-            input_call_count.value += 1
-            return value
-
-        @app.callback(Output('output-1', 'children'),
-                      [Input('output-1', 'data-cb')])
-        def update_text(data):
-            return data
-
-        self.startServer(app)
-        self.wait_for_text_to_equal('#output-1', 'initial value')
-        self.percy_snapshot(name='wildcard-callback-1')
-
-        input1 = self.wait_for_element_by_css_selector('#input')
-        chain = (ActionChains(self.driver)
-                 .click(input1)
-                 .send_keys(Keys.HOME)
-                 .key_down(Keys.SHIFT)
-                 .send_keys(Keys.END)
-                 .key_up(Keys.SHIFT)
-                 .send_keys(Keys.DELETE))
-        chain.perform()
-
-        input1.send_keys('hello world')
-
-        self.wait_for_text_to_equal('#output-1', 'hello world')
-        self.percy_snapshot(name='wildcard-callback-2')
-
-        self.assertEqual(
-            input_call_count.value,
-            # an initial call
-            # and a call for clearing the input
-            2 +
-            # one for each hello world character
-            len('hello world')
-        )
+    assert not dash_duo.get_logs()
 
-        self.assertTrue(self.is_console_clean())
 
-    def test_aborted_callback(self):
-        """
-        Raising PreventUpdate OR returning no_update
-        prevents update and triggering dependencies
-        """
-
-        initial_input = 'initial input'
-        initial_output = 'initial output'
-
-        app = Dash(__name__)
-        app.layout = html.Div([
-            dcc.Input(id='input', value=initial_input),
-            html.Div(initial_output, id='output1'),
-            html.Div(initial_output, id='output2'),
-        ])
-
-        callback1_count = Value('i', 0)
-        callback2_count = Value('i', 0)
-
-        @app.callback(Output('output1', 'children'), [Input('input', 'value')])
-        def callback1(value):
-            callback1_count.value += 1
-            if callback1_count.value > 2:
-                return no_update
-            raise PreventUpdate("testing callback does not update")
-            return value
-
-        @app.callback(Output('output2', 'children'), [Input('output1', 'children')])
-        def callback2(value):
-            callback2_count.value += 1
-            return value
-
-        self.startServer(app)
-
-        input_ = self.wait_for_element_by_id('input')
-        input_.send_keys('xyz')
-        self.wait_for_text_to_equal('#input', 'initial inputxyz')
-        output1 = self.wait_for_element_by_id('output1')
-        output2 = self.wait_for_element_by_id('output2')
-
-        # callback1 runs 4x (initial page load and 3x through send_keys)
-        wait_for(lambda: callback1_count.value == 4)
-
-        # callback2 is never triggered, even on initial load
-        self.assertEqual(callback2_count.value, 0)
-
-        # double check that output1 and output2 children were not updated
-        self.assertEqual(output1.text, initial_output)
-        self.assertEqual(output2.text, initial_output)
-
-        self.assertTrue(self.is_console_clean())
-
-        self.percy_snapshot(name='aborted')
-
-    def test_wildcard_data_attributes(self):
-        app = Dash()
-        test_time = datetime.datetime(2012, 1, 10, 2, 3)
-        test_date = datetime.date(test_time.year, test_time.month,
-                                  test_time.day)
-        app.layout = html.Div([
-            html.Div(
-                id="inner-element",
-                **{
-                    'data-string': 'multiple words',
-                    'data-number': 512,
-                    'data-none': None,
-                    'data-date': test_date,
-                    'aria-progress': 5
-                }
-            )
-        ], id='data-element')
-
-        self.startServer(app)
-
-        div = self.wait_for_element_by_id('data-element')
-
-        # React wraps text and numbers with e.g. <!-- react-text: 20 -->
-        # Remove those
-        comment_regex = r'<!--[^\[](.*?)-->'  # noqa: W605
-
-        # Somehow the html attributes are unordered.
-        # Try different combinations (they're all valid html)
-        permutations = itertools.permutations([
-            'id="inner-element"',
-            'data-string="multiple words"',
-            'data-number="512"',
-            'data-date="%s"' % test_date,
-            'aria-progress="5"'
-        ], 5)
-        passed = False
-        for permutation in permutations:
-            actual_cleaned = re.sub(comment_regex, '',
-                                    div.get_attribute('innerHTML'))
-            expected_cleaned = re.sub(
-                comment_regex,
-                '',
-                "<div PERMUTE></div>"
-                .replace('PERMUTE', ' '.join(list(permutation)))
-            )
-            passed = passed or (actual_cleaned == expected_cleaned)
-            if passed:
-                break
-        if not passed:
-            raise Exception(
-                'HTML does not match\nActual:\n{}\n\nExpected:\n{}'.format(
-                    actual_cleaned,
-                    expected_cleaned
-                )
+def test_wildcard_callback(dash_duo):
+    app = Dash(__name__)
+    app.layout = html.Div([
+        dcc.Input(id='input', value='initial value'),
+        html.Div(
+            html.Div([
+                1.5,
+                None,
+                'string',
+                html.Div(id='output-1', **{'data-cb': 'initial value',
+                                           'aria-cb': 'initial value'})
+            ])
+        )
+    ])
+
+    input_call_count = Value('i', 0)
+
+    @app.callback(Output('output-1', 'data-cb'), [Input('input', 'value')])
+    def update_data(value):
+        input_call_count.value += 1
+        return value
+
+    @app.callback(Output('output-1', 'children'),
+                  [Input('output-1', 'data-cb')])
+    def update_text(data):
+        return data
+
+    dash_duo.start_server(app)
+    dash_duo.wait_for_text_to_equal('#output-1', 'initial value')
+    dash_duo.percy_snapshot(name='wildcard-callback-1')
+
+    input1 = dash_duo.find_element('#input')
+    dash_duo.clear_input(input1)
+    input1.send_keys('hello world')
+
+    dash_duo.wait_for_text_to_equal('#output-1', 'hello world')
+    dash_duo.percy_snapshot(name='wildcard-callback-2')
+
+    # an initial call, one for clearing the input
+    # and one for each hello world character
+    assert input_call_count.value == 2 + len('hello world')
+
+    assert not dash_duo.get_logs()
+
+
+def test_aborted_callback(dash_duo):
+    """
+    Raising PreventUpdate OR returning no_update
+    prevents update and triggering dependencies
+    """
+
+    initial_input = 'initial input'
+    initial_output = 'initial output'
+
+    app = Dash(__name__)
+    app.layout = html.Div([
+        dcc.Input(id='input', value=initial_input),
+        html.Div(initial_output, id='output1'),
+        html.Div(initial_output, id='output2'),
+    ])
+
+    callback1_count = Value('i', 0)
+    callback2_count = Value('i', 0)
+
+    @app.callback(Output('output1', 'children'), [Input('input', 'value')])
+    def callback1(value):
+        callback1_count.value += 1
+        if callback1_count.value > 2:
+            return no_update
+        raise PreventUpdate("testing callback does not update")
+        return value
+
+    @app.callback(
+        Output('output2', 'children'), [Input('output1', 'children')]
+    )
+    def callback2(value):
+        callback2_count.value += 1
+        return value
+
+    dash_duo.start_server(app)
+
+    input_ = dash_duo.find_element('#input')
+    input_.send_keys('xyz')
+    dash_duo.wait_for_text_to_equal('#input', 'initial inputxyz')
+
+    # callback1 runs 4x (initial page load and 3x through send_keys)
+    until(lambda: callback1_count.value == 4, 3)
+
+    # callback2 is never triggered, even on initial load
+    assert callback2_count.value == 0
+
+    # double check that output1 and output2 children were not updated
+    assert dash_duo.find_element('#output1').text == initial_output
+    assert dash_duo.find_element('#output2').text == initial_output
+
+    assert not dash_duo.get_logs()
+
+    dash_duo.percy_snapshot(name='aborted')
+
+
+def test_wildcard_data_attributes(dash_duo):
+    app = Dash()
+    test_time = datetime.datetime(2012, 1, 10, 2, 3)
+    test_date = datetime.date(test_time.year, test_time.month,
+                              test_time.day)
+    app.layout = html.Div([
+        html.Div(
+            id="inner-element",
+            **{
+                'data-string': 'multiple words',
+                'data-number': 512,
+                'data-none': None,
+                'data-date': test_date,
+                'aria-progress': 5
+            }
+        )
+    ], id='data-element')
+
+    dash_duo.start_server(app)
+
+    div = dash_duo.find_element('#data-element')
+
+    # React wraps text and numbers with e.g. <!-- react-text: 20 -->
+    # Remove those
+    comment_regex = r'<!--[^\[](.*?)-->'  # noqa: W605
+
+    # Somehow the html attributes are unordered.
+    # Try different combinations (they're all valid html)
+    permutations = itertools.permutations([
+        'id="inner-element"',
+        'data-string="multiple words"',
+        'data-number="512"',
+        'data-date="%s"' % test_date,
+        'aria-progress="5"'
+    ], 5)
+    passed = False
+    for permutation in permutations:
+        actual_cleaned = re.sub(comment_regex, '',
+                                div.get_attribute('innerHTML'))
+        expected_cleaned = re.sub(
+            comment_regex,
+            '',
+            "<div PERMUTE></div>"
+            .replace('PERMUTE', ' '.join(list(permutation)))
+        )
+        passed = passed or (actual_cleaned == expected_cleaned)
+        if passed:
+            break
+    if not passed:
+        raise Exception(
+            'HTML does not match\nActual:\n{}\n\nExpected:\n{}'.format(
+                actual_cleaned,
+                expected_cleaned
             )
+        )
 
-        self.assertTrue(self.is_console_clean())
-
-    def test_no_props_component(self):
-        app = Dash()
-        app.layout = html.Div([
-            dash_dangerously_set_inner_html.DangerouslySetInnerHTML('''
-                <h1>No Props Component</h1>
-            ''')
-        ])
-        self.startServer(app)
-        self.assertTrue(self.is_console_clean())
-        self.percy_snapshot(name='no-props-component')
-
-    def test_flow_component(self):
-        app = Dash()
-
-        app.layout = html.Div([
-            dash_flow_example.ExampleReactComponent(
-                id='react',
-                value='my-value',
-                label='react component'
-            ),
-            dash_flow_example.ExampleFlowComponent(
-                id='flow',
-                value='my-value',
-                label='flow component'
-            ),
+    assert not dash_duo.get_logs()
+
+
+def test_no_props_component(dash_duo):
+    app = Dash()
+    app.layout = html.Div([
+        dash_dangerously_set_inner_html.DangerouslySetInnerHTML('''
+            <h1>No Props Component</h1>
+        ''')
+    ])
+
+    dash_duo.start_server(app)
+
+    assert not dash_duo.get_logs()
+    dash_duo.percy_snapshot(name='no-props-component')
+
+
+def test_flow_component(dash_duo):
+    app = Dash()
+
+    app.layout = html.Div([
+        dash_flow_example.ExampleReactComponent(
+            id='react',
+            value='my-value',
+            label='react component'
+        ),
+        dash_flow_example.ExampleFlowComponent(
+            id='flow',
+            value='my-value',
+            label='flow component'
+        ),
+        html.Hr(),
+        html.Div(id='output')
+    ])
+
+    @app.callback(Output('output', 'children'),
+                  [Input('react', 'value'), Input('flow', 'value')])
+    def display_output(react_value, flow_value):
+        return html.Div([
+            'You have entered {} and {}'.format(react_value, flow_value),
             html.Hr(),
-            html.Div(id='output')
+            html.Label('Flow Component Docstring'),
+            html.Pre(dash_flow_example.ExampleFlowComponent.__doc__),
+            html.Hr(),
+            html.Label('React PropTypes Component Docstring'),
+            html.Pre(dash_flow_example.ExampleReactComponent.__doc__),
+            html.Div(id='waitfor')
         ])
 
-        @app.callback(Output('output', 'children'),
-                      [Input('react', 'value'), Input('flow', 'value')])
-        def display_output(react_value, flow_value):
-            return html.Div([
-                'You have entered {} and {}'.format(react_value, flow_value),
-                html.Hr(),
-                html.Label('Flow Component Docstring'),
-                html.Pre(dash_flow_example.ExampleFlowComponent.__doc__),
-                html.Hr(),
-                html.Label('React PropTypes Component Docstring'),
-                html.Pre(dash_flow_example.ExampleReactComponent.__doc__),
-                html.Div(id='waitfor')
-            ])
-
-        self.startServer(app)
-        self.wait_for_element_by_id('waitfor')
-        self.percy_snapshot(name='flowtype')
-
-    def test_meta_tags(self):
-        metas = [
-            {'name': 'description', 'content': 'my dash app'},
-            {'name': 'custom', 'content': 'customized'},
-        ]
-
-        app = Dash(meta_tags=metas)
+    dash_duo.start_server(app)
+    dash_duo.wait_for_element('#waitfor')
+    dash_duo.percy_snapshot(name='flowtype')
+
+
+def test_meta_tags(dash_duo):
+    metas = [
+        {'name': 'description', 'content': 'my dash app'},
+        {'name': 'custom', 'content': 'customized'},
+    ]
+
+    app = Dash(meta_tags=metas)
+
+    app.layout = html.Div(id='content')
+
+    dash_duo.start_server(app)
+
+    meta = dash_duo.find_elements('meta')
+
+    # -2 for the meta charset and http-equiv.
+    assert len(meta) == len(metas) + 2, 'Should have 2 extra meta tags'
+
+    for i in range(2, len(meta)):
+        meta_tag = meta[i]
+        meta_info = metas[i - 2]
+        assert meta_tag.get_attribute('name') == meta_info['name']
+        assert meta_tag.get_attribute('content') == meta_info['content']
+
+
+def test_index_customization(dash_duo):
+    app = Dash()
+
+    app.index_string = '''
+    <!DOCTYPE html>
+    <html>
+        <head>
+            {%metas%}
+            <title>{%title%}</title>
+            {%favicon%}
+            {%css%}
+        </head>
+        <body>
+            <div id="custom-header">My custom header</div>
+            <div id="add"></div>
+            {%app_entry%}
+            <footer>
+                {%config%}
+                {%scripts%}
+                {%renderer%}
+            </footer>
+            <div id="custom-footer">My custom footer</div>
+            <script>
+            // Test the formatting doesn't mess up script tags.
+            var elem = document.getElementById('add');
+            if (!elem) {
+                throw Error('could not find container to add');
+            }
+            elem.innerHTML = 'Got added';
+            var config = {};
+            fetch('/nonexist').then(r => r.json())
+                .then(r => config = r).catch(err => ({config}));
+            </script>
+        </body>
+    </html>
+    '''
 
-        app.layout = html.Div(id='content')
+    app.layout = html.Div('Dash app', id='app')
 
-        self.startServer(app)
+    dash_duo.start_server(app)
 
-        meta = self.driver.find_elements_by_tag_name('meta')
+    assert dash_duo.find_element('#custom-header').text == 'My custom header'
+    assert dash_duo.find_element('#custom-footer').text == 'My custom footer'
+    assert dash_duo.wait_for_element('#add').text == 'Got added'
 
-        # -2 for the meta charset and http-equiv.
-        self.assertEqual(len(metas), len(meta) - 2, 'Not enough meta tags')
+    dash_duo.percy_snapshot('custom-index')
 
-        for i in range(2, len(meta)):
-            meta_tag = meta[i]
-            meta_info = metas[i - 2]
-            name = meta_tag.get_attribute('name')
-            content = meta_tag.get_attribute('content')
-            self.assertEqual(name, meta_info['name'])
-            self.assertEqual(content, meta_info['content'])
 
-    def test_index_customization(self):
-        app = Dash()
+def test_invalid_index_string(dash_duo):
+    app = Dash()
 
+    def will_raise():
         app.index_string = '''
         <!DOCTYPE html>
         <html>
@@ -349,638 +355,568 @@ def test_index_customization(self):
             <body>
                 <div id="custom-header">My custom header</div>
                 <div id="add"></div>
-                {%app_entry%}
                 <footer>
-                    {%config%}
-                    {%scripts%}
-                    {%renderer%}
                 </footer>
-                <div id="custom-footer">My custom footer</div>
-                <script>
-                // Test the formatting doesn't mess up script tags.
-                var elem = document.getElementById('add');
-                if (!elem) {
-                    throw Error('could not find container to add');
-                }
-                elem.innerHTML = 'Got added';
-                var config = {};
-                fetch('/nonexist').then(r => r.json())
-                    .then(r => config = r).catch(err => ({config}));
-                </script>
             </body>
         </html>
         '''
 
-        app.layout = html.Div('Dash app', id='app')
-
-        self.startServer(app)
-
-        time.sleep(0.5)
-
-        header = self.wait_for_element_by_id('custom-header')
-        footer = self.wait_for_element_by_id('custom-footer')
-
-        self.assertEqual('My custom header', header.text)
-        self.assertEqual('My custom footer', footer.text)
+    with pytest.raises(Exception) as err:
+        will_raise()
 
-        add = self.wait_for_element_by_id('add')
+    exc_msg = str(err.value)
+    assert '{%app_entry%}' in exc_msg
+    assert '{%config%}' in exc_msg
+    assert '{%scripts%}' in exc_msg
 
-        self.assertEqual('Got added', add.text)
+    app.layout = html.Div('Hello World', id='a')
 
-        self.percy_snapshot('custom-index')
+    dash_duo.start_server(app)
+    assert dash_duo.find_element('#a').text == 'Hello World'
 
-    def test_invalid_index_string(self):
-        app = Dash()
 
-        def will_raise():
-            app.index_string = '''
-                    <!DOCTYPE html>
-                    <html>
-                        <head>
-                            {%metas%}
-                            <title>{%title%}</title>
-                            {%favicon%}
-                            {%css%}
-                        </head>
-                        <body>
-                            <div id="custom-header">My custom header</div>
-                            <div id="add"></div>
-                            <footer>
-                            </footer>
-                        </body>
-                    </html>
-                    '''
+def test_func_layout_accepted(dash_duo):
+    app = Dash()
 
-        with self.assertRaises(Exception) as context:
-            will_raise()
+    def create_layout():
+        return html.Div('Hello World', id='a')
+    app.layout = create_layout
 
-        app.layout = html.Div()
-        self.startServer(app)
+    dash_duo.start_server(app)
+    assert dash_duo.find_element('#a').text == 'Hello World'
 
-        exc_msg = str(context.exception)
-        self.assertTrue('{%app_entry%}' in exc_msg)
-        self.assertTrue('{%config%}' in exc_msg)
-        self.assertTrue('{%scripts%}' in exc_msg)
-        time.sleep(0.5)
 
-    def test_func_layout_accepted(self):
+def test_multi_output(dash_duo):
+    app = Dash(__name__)
 
-        app = Dash()
+    app.layout = html.Div([
+        html.Button('OUTPUT', id='output-btn'),
 
-        def create_layout():
-            return html.Div('Hello World')
-        app.layout = create_layout
-
-        self.startServer(app)
-        time.sleep(0.5)
-
-    def test_multi_output(self):
-        app = Dash(__name__)
-
-        app.layout = html.Div([
-            html.Button('OUTPUT', id='output-btn'),
-
-            html.Table([
-                html.Thead([
-                    html.Tr([
-                        html.Th('Output 1'),
-                        html.Th('Output 2')
-                    ])
-                ]),
-                html.Tbody([
-                    html.Tr([html.Td(id='output1'), html.Td(id='output2')]),
-                ])
+        html.Table([
+            html.Thead([
+                html.Tr([html.Th('Output 1'), html.Th('Output 2')])
             ]),
-
-            html.Div(id='output3'),
-            html.Div(id='output4'),
-            html.Div(id='output5')
-        ])
-
-        @app.callback([Output('output1', 'children'), Output('output2', 'children')],
-                      [Input('output-btn', 'n_clicks')],
-                      [State('output-btn', 'n_clicks_timestamp')])
-        def on_click(n_clicks, n_clicks_timestamp):
+            html.Tbody([
+                html.Tr([html.Td(id='output1'), html.Td(id='output2')]),
+            ])
+        ]),
+
+        html.Div(id='output3'),
+        html.Div(id='output4'),
+        html.Div(id='output5')
+    ])
+
+    @app.callback(
+        [Output('output1', 'children'), Output('output2', 'children')],
+        [Input('output-btn', 'n_clicks')],
+        [State('output-btn', 'n_clicks_timestamp')]
+    )
+    def on_click(n_clicks, n_clicks_timestamp):
+        if n_clicks is None:
+            raise PreventUpdate
+
+        return n_clicks, n_clicks_timestamp
+
+    # Dummy callback for DuplicateCallbackOutput test.
+    @app.callback(Output('output3', 'children'),
+                  [Input('output-btn', 'n_clicks')])
+    def dummy_callback(n_clicks):
+        if n_clicks is None:
+            raise PreventUpdate
+
+        return 'Output 3: {}'.format(n_clicks)
+
+    # Test that a multi output can't be included in a single output
+    with pytest.raises(DuplicateCallbackOutput) as err:
+        @app.callback(Output('output1', 'children'),
+                      [Input('output-btn', 'n_clicks')])
+        def on_click_duplicate(n_clicks):
             if n_clicks is None:
                 raise PreventUpdate
 
-            return n_clicks, n_clicks_timestamp
+            return 'something else'
 
-        # Dummy callback for DuplicateCallbackOutput test.
-        @app.callback(Output('output3', 'children'),
+    assert 'output1' in err.value.args[0]
+
+    # Test a multi output cannot contain a used single output
+    with pytest.raises(DuplicateCallbackOutput) as err:
+        @app.callback([Output('output3', 'children'),
+                       Output('output4', 'children')],
                       [Input('output-btn', 'n_clicks')])
-        def dummy_callback(n_clicks):
+        def on_click_duplicate_multi(n_clicks):
             if n_clicks is None:
                 raise PreventUpdate
 
-            return 'Output 3: {}'.format(n_clicks)
-
-        # Test that a multi output can't be included in a single output
-        with self.assertRaises(DuplicateCallbackOutput) as context:
-            @app.callback(Output('output1', 'children'),
-                          [Input('output-btn', 'n_clicks')])
-            def on_click_duplicate(n_clicks):
-                if n_clicks is None:
-                    raise PreventUpdate
+            return 'something else'
 
-                return 'something else'
+    assert 'output3' in err.value.args[0]
 
-        self.assertTrue('output1' in context.exception.args[0])
-
-        # Test a multi output cannot contain a used single output
-        with self.assertRaises(DuplicateCallbackOutput) as context:
-            @app.callback([Output('output3', 'children'),
-                           Output('output4', 'children')],
-                          [Input('output-btn', 'n_clicks')])
-            def on_click_duplicate_multi(n_clicks):
-                if n_clicks is None:
-                    raise PreventUpdate
-
-                return 'something else'
+    with pytest.raises(DuplicateCallbackOutput) as err:
+        @app.callback([Output('output5', 'children'),
+                       Output('output5', 'children')],
+                      [Input('output-btn', 'n_clicks')])
+        def on_click_same_output(n_clicks):
+            return n_clicks
 
-        self.assertTrue('output3' in context.exception.args[0])
+    assert 'output5' in err.value.args[0]
 
-        with self.assertRaises(DuplicateCallbackOutput) as context:
-            @app.callback([Output('output5', 'children'),
-                           Output('output5', 'children')],
-                          [Input('output-btn', 'n_clicks')])
-            def on_click_same_output(n_clicks):
-                return n_clicks
+    with pytest.raises(DuplicateCallbackOutput) as err:
+        @app.callback([Output('output1', 'children'),
+                       Output('output5', 'children')],
+                      [Input('output-btn', 'n_clicks')])
+        def overlapping_multi_output(n_clicks):
+            return n_clicks
 
-        self.assertTrue('output5' in context.exception.args[0])
+    assert (
+        '{\'output1.children\'}' in err.value.args[0]
+        or "set(['output1.children'])" in err.value.args[0]
+    )
 
-        with self.assertRaises(DuplicateCallbackOutput) as context:
-            @app.callback([Output('output1', 'children'),
-                           Output('output5', 'children')],
-                          [Input('output-btn', 'n_clicks')])
-            def overlapping_multi_output(n_clicks):
-                return n_clicks
+    dash_duo.start_server(app)
 
-        self.assertTrue(
-            '{\'output1.children\'}' in context.exception.args[0]
-            or "set(['output1.children'])" in context.exception.args[0]
-        )
+    t = time.time()
 
-        self.startServer(app)
+    btn = dash_duo.find_element('#output-btn')
+    btn.click()
+    time.sleep(1)
 
-        t = time.time()
+    dash_duo.wait_for_text_to_equal('#output1', '1')
 
-        btn = self.wait_for_element_by_id('output-btn')
-        btn.click()
-        time.sleep(1)
+    assert int(dash_duo.find_element('#output2').text) > t
 
-        self.wait_for_text_to_equal('#output1', '1')
-        output2 = self.wait_for_element_by_css_selector('#output2')
 
-        self.assertGreater(int(output2.text), t)
+def test_multi_output_no_update(dash_duo):
+    app = Dash(__name__)
 
-    def test_multi_output_no_update(self):
-        app = Dash(__name__)
+    app.layout = html.Div([
+        html.Button('B', 'btn'),
+        html.P('initial1', 'n1'),
+        html.P('initial2', 'n2'),
+        html.P('initial3', 'n3')
+    ])
 
-        app.layout = html.Div([
-            html.Button('B', 'btn'),
-            html.P('initial1', 'n1'),
-            html.P('initial2', 'n2'),
-            html.P('initial3', 'n3')
-        ])
+    @app.callback([Output('n1', 'children'),
+                   Output('n2', 'children'),
+                   Output('n3', 'children')],
+                  [Input('btn', 'n_clicks')])
+    def show_clicks(n):
+        # partial or complete cancelation of updates via no_update
+        return [
+            no_update if n and n > 4 else n,
+            no_update if n and n > 2 else n,
+            no_update
+        ]
 
-        @app.callback([Output('n1', 'children'),
-                       Output('n2', 'children'),
-                       Output('n3', 'children')],
-                      [Input('btn', 'n_clicks')])
-        def show_clicks(n):
-            # partial or complete cancelation of updates via no_update
-            return [
-                no_update if n and n > 4 else n,
-                no_update if n and n > 2 else n,
-                no_update
-            ]
-
-        self.startServer(app)
-
-        btn = self.wait_for_element_by_id('btn')
-        for _ in range(10):
-            btn.click()
-
-        self.wait_for_text_to_equal('#n1', '4')
-        self.wait_for_text_to_equal('#n2', '2')
-        self.wait_for_text_to_equal('#n3', 'initial3')
-
-    def test_no_update_chains(self):
-        app = Dash(__name__)
-
-        app.layout = html.Div([
-            dcc.Input(id='a_in', value='a'),
-            dcc.Input(id='b_in', value='b'),
-            html.P('', id='a_out'),
-            html.P('', id='a_out_short'),
-            html.P('', id='b_out'),
-            html.P('', id='ab_out')
-        ])
+    dash_duo.start_server(app)
 
-        @app.callback([Output('a_out', 'children'),
-                       Output('a_out_short', 'children')],
-                      [Input('a_in', 'value')])
-        def a_out(a):
-            return (a, a if len(a) < 3 else no_update)
-
-        @app.callback(Output('b_out', 'children'), [Input('b_in', 'value')])
-        def b_out(b):
-            return b
-
-        @app.callback(Output('ab_out', 'children'),
-                      [Input('a_out_short', 'children')],
-                      [State('b_out', 'children')])
-        def ab_out(a, b):
-            return a + ' ' + b
-
-        self.startServer(app)
-
-        a_in = self.wait_for_element_by_id('a_in')
-        b_in = self.wait_for_element_by_id('b_in')
-
-        b_in.send_keys('b')
-        a_in.send_keys('a')
-        self.wait_for_text_to_equal('#a_out', 'aa')
-        self.wait_for_text_to_equal('#b_out', 'bb')
-        self.wait_for_text_to_equal('#a_out_short', 'aa')
-        self.wait_for_text_to_equal('#ab_out', 'aa bb')
-
-        b_in.send_keys('b')
-        a_in.send_keys('a')
-        self.wait_for_text_to_equal('#a_out', 'aaa')
-        self.wait_for_text_to_equal('#b_out', 'bbb')
-        self.wait_for_text_to_equal('#a_out_short', 'aa')
-        # ab_out has not been triggered because a_out_short received no_update
-        self.wait_for_text_to_equal('#ab_out', 'aa bb')
-
-        b_in.send_keys('b')
-        a_in.send_keys(Keys.END)
-        a_in.send_keys(Keys.BACKSPACE)
-        self.wait_for_text_to_equal('#a_out', 'aa')
-        self.wait_for_text_to_equal('#b_out', 'bbbb')
-        self.wait_for_text_to_equal('#a_out_short', 'aa')
-        # now ab_out *is* triggered - a_out_short got a new value
-        # even though that value is the same as the last value it got
-        self.wait_for_text_to_equal('#ab_out', 'aa bbbb')
-
-    def test_with_custom_renderer(self):
-        app = Dash(__name__)
+    btn = dash_duo.find_element('#btn')
+    for _ in range(10):
+        btn.click()
 
-        app.index_string = '''
-        <!DOCTYPE html>
-        <html>
-            <head>
-                {%metas%}
-                <title>{%title%}</title>
-                {%favicon%}
-                {%css%}
-            </head>
-            <body>
-                <div>Testing custom DashRenderer</div>
-                {%app_entry%}
-                <footer>
-                    {%config%}
-                    {%scripts%}
-                    <script id="_dash-renderer" type="application/javascript">
-                        console.log('firing up a custom renderer!')
-                        const renderer = new DashRenderer({
-                            request_pre: () => {
-                                var output = document.getElementById('output-pre')
-                                if(output) {
-                                    output.innerHTML = 'request_pre changed this text!';
-                                }
-                            },
-                            request_post: () => {
-                                var output = document.getElementById('output-post')
-                                if(output) {
-                                    output.innerHTML = 'request_post changed this text!';
-                                }
+    dash_duo.wait_for_text_to_equal('#n1', '4')
+    dash_duo.wait_for_text_to_equal('#n2', '2')
+    dash_duo.wait_for_text_to_equal('#n3', 'initial3')
+
+
+def test_no_update_chains(dash_duo):
+    app = Dash(__name__)
+
+    app.layout = html.Div([
+        dcc.Input(id='a_in', value='a'),
+        dcc.Input(id='b_in', value='b'),
+        html.P('', id='a_out'),
+        html.P('', id='a_out_short'),
+        html.P('', id='b_out'),
+        html.P('', id='ab_out')
+    ])
+
+    @app.callback([Output('a_out', 'children'),
+                   Output('a_out_short', 'children')],
+                  [Input('a_in', 'value')])
+    def a_out(a):
+        return (a, a if len(a) < 3 else no_update)
+
+    @app.callback(Output('b_out', 'children'), [Input('b_in', 'value')])
+    def b_out(b):
+        return b
+
+    @app.callback(Output('ab_out', 'children'),
+                  [Input('a_out_short', 'children')],
+                  [State('b_out', 'children')])
+    def ab_out(a, b):
+        return a + ' ' + b
+
+    dash_duo.start_server(app)
+
+    a_in = dash_duo.find_element('#a_in')
+    b_in = dash_duo.find_element('#b_in')
+
+    b_in.send_keys('b')
+    a_in.send_keys('a')
+    dash_duo.wait_for_text_to_equal('#a_out', 'aa')
+    dash_duo.wait_for_text_to_equal('#b_out', 'bb')
+    dash_duo.wait_for_text_to_equal('#a_out_short', 'aa')
+    dash_duo.wait_for_text_to_equal('#ab_out', 'aa bb')
+
+    b_in.send_keys('b')
+    a_in.send_keys('a')
+    dash_duo.wait_for_text_to_equal('#a_out', 'aaa')
+    dash_duo.wait_for_text_to_equal('#b_out', 'bbb')
+    dash_duo.wait_for_text_to_equal('#a_out_short', 'aa')
+    # ab_out has not been triggered because a_out_short received no_update
+    dash_duo.wait_for_text_to_equal('#ab_out', 'aa bb')
+
+    b_in.send_keys('b')
+    a_in.send_keys(Keys.END)
+    a_in.send_keys(Keys.BACKSPACE)
+    dash_duo.wait_for_text_to_equal('#a_out', 'aa')
+    dash_duo.wait_for_text_to_equal('#b_out', 'bbbb')
+    dash_duo.wait_for_text_to_equal('#a_out_short', 'aa')
+    # now ab_out *is* triggered - a_out_short got a new value
+    # even though that value is the same as the last value it got
+    dash_duo.wait_for_text_to_equal('#ab_out', 'aa bbbb')
+
+
+def test_with_custom_renderer(dash_duo):
+    app = Dash(__name__)
+
+    app.index_string = '''
+    <!DOCTYPE html>
+    <html>
+        <head>
+            {%metas%}
+            <title>{%title%}</title>
+            {%favicon%}
+            {%css%}
+        </head>
+        <body>
+            <div>Testing custom DashRenderer</div>
+            {%app_entry%}
+            <footer>
+                {%config%}
+                {%scripts%}
+                <script id="_dash-renderer" type="application/javascript">
+                    console.log('firing up a custom renderer!')
+                    const renderer = new DashRenderer({
+                        request_pre: () => {
+                            var output = document.getElementById('output-pre')
+                            if(output) {
+                                output.innerHTML = 'request_pre!!!';
                             }
-                        })
-                    </script>
-                </footer>
-                <div>With request hooks</div>
-            </body>
-        </html>
-        '''
+                        },
+                        request_post: () => {
+                            var output = document.getElementById('output-post')
+                            if(output) {
+                                output.innerHTML = 'request_post ran!';
+                            }
+                        }
+                    })
+                </script>
+            </footer>
+            <div>With request hooks</div>
+        </body>
+    </html>
+    '''
+
+    app.layout = html.Div([
+        dcc.Input(id='input', value='initial value'),
+        html.Div(
+            html.Div([
+                html.Div(id='output-1'),
+                html.Div(id='output-pre'),
+                html.Div(id='output-post')
+            ])
+        )
+    ])
 
-        app.layout = html.Div([
-            dcc.Input(
-                id='input',
-                value='initial value'
-            ),
-            html.Div(
-                html.Div([
-                    html.Div(id='output-1'),
-                    html.Div(id='output-pre'),
-                    html.Div(id='output-post')
-                ])
-            )
-        ])
+    @app.callback(Output('output-1', 'children'), [Input('input', 'value')])
+    def update_output(value):
+        return value
 
-        @app.callback(Output('output-1', 'children'), [Input('input', 'value')])
-        def update_output(value):
-            return value
+    dash_duo.start_server(app)
 
-        self.startServer(app)
+    input1 = dash_duo.find_element('#input')
+    dash_duo.clear_input(input1)
 
-        input1 = self.wait_for_element_by_id('input')
-        chain = (ActionChains(self.driver)
-                 .click(input1)
-                 .send_keys(Keys.HOME)
-                 .key_down(Keys.SHIFT)
-                 .send_keys(Keys.END)
-                 .key_up(Keys.SHIFT)
-                 .send_keys(Keys.DELETE))
-        chain.perform()
+    input1.send_keys('fire request hooks')
 
-        input1.send_keys('fire request hooks')
+    dash_duo.wait_for_text_to_equal('#output-1', 'fire request hooks')
+    assert dash_duo.find_element('#output-pre').text == 'request_pre!!!'
+    assert dash_duo.find_element('#output-post').text == 'request_post ran!'
 
-        self.wait_for_text_to_equal('#output-1', 'fire request hooks')
-        self.wait_for_text_to_equal('#output-pre', 'request_pre changed this text!')
-        self.wait_for_text_to_equal('#output-post', 'request_post changed this text!')
+    dash_duo.percy_snapshot(name='request-hooks')
 
-        self.percy_snapshot(name='request-hooks')
 
-    def test_with_custom_renderer_interpolated(self):
+def test_with_custom_renderer_interpolated(dash_duo):
 
-        renderer = '''
-            <script id="_dash-renderer" type="application/javascript">
-                console.log('firing up a custom renderer!')
-                const renderer = new DashRenderer({
-                    request_pre: () => {
-                        var output = document.getElementById('output-pre')
-                        if(output) {
-                            output.innerHTML = 'request_pre changed this text!';
-                        }
-                    },
-                    request_post: () => {
-                        var output = document.getElementById('output-post')
-                        if(output) {
-                            output.innerHTML = 'request_post changed this text!';
-                        }
+    renderer = '''
+        <script id="_dash-renderer" type="application/javascript">
+            console.log('firing up a custom renderer!')
+            const renderer = new DashRenderer({
+                request_pre: () => {
+                    var output = document.getElementById('output-pre')
+                    if(output) {
+                        output.innerHTML = 'request_pre was here!';
                     }
-                })
-            </script>
-        '''
-
-        class CustomDash(Dash):
-
-            def interpolate_index(self, **kwargs):
-                return '''
-                <!DOCTYPE html>
-                <html>
-                    <head>
-                        <title>My App</title>
-                    </head>
-                    <body>
-
-                        <div id="custom-header">My custom header</div>
-                        {app_entry}
-                        {config}
-                        {scripts}
-                        {renderer}
-                        <div id="custom-footer">My custom footer</div>
-                    </body>
-                </html>
-                '''.format(
-                    app_entry=kwargs['app_entry'],
-                    config=kwargs['config'],
-                    scripts=kwargs['scripts'],
-                    renderer=renderer)
-
-        app = CustomDash()
-
-        app.layout = html.Div([
-            dcc.Input(
-                id='input',
-                value='initial value'
-            ),
-            html.Div(
-                html.Div([
-                    html.Div(id='output-1'),
-                    html.Div(id='output-pre'),
-                    html.Div(id='output-post')
-                ])
-            )
-        ])
+                },
+                request_post: () => {
+                    var output = document.getElementById('output-post')
+                    if(output) {
+                        output.innerHTML = 'request_post!!!';
+                    }
+                }
+            })
+        </script>
+    '''
+
+    class CustomDash(Dash):
+
+        def interpolate_index(self, **kwargs):
+            return '''
+            <!DOCTYPE html>
+            <html>
+                <head>
+                    <title>My App</title>
+                </head>
+                <body>
+
+                    <div id="custom-header">My custom header</div>
+                    {app_entry}
+                    {config}
+                    {scripts}
+                    {renderer}
+                    <div id="custom-footer">My custom footer</div>
+                </body>
+            </html>
+            '''.format(
+                app_entry=kwargs['app_entry'],
+                config=kwargs['config'],
+                scripts=kwargs['scripts'],
+                renderer=renderer)
+
+    app = CustomDash()
+
+    app.layout = html.Div([
+        dcc.Input(id='input', value='initial value'),
+        html.Div(
+            html.Div([
+                html.Div(id='output-1'),
+                html.Div(id='output-pre'),
+                html.Div(id='output-post')
+            ])
+        )
+    ])
 
-        @app.callback(Output('output-1', 'children'), [Input('input', 'value')])
-        def update_output(value):
-            return value
+    @app.callback(Output('output-1', 'children'), [Input('input', 'value')])
+    def update_output(value):
+        return value
 
-        self.startServer(app)
+    dash_duo.start_server(app)
 
-        input1 = self.wait_for_element_by_id('input')
-        chain = (ActionChains(self.driver)
-                 .click(input1)
-                 .send_keys(Keys.HOME)
-                 .key_down(Keys.SHIFT)
-                 .send_keys(Keys.END)
-                 .key_up(Keys.SHIFT)
-                 .send_keys(Keys.DELETE))
-        chain.perform()
+    input1 = dash_duo.find_element('#input')
+    dash_duo.clear_input(input1)
 
-        input1.send_keys('fire request hooks')
+    input1.send_keys('fire request hooks')
 
-        self.wait_for_text_to_equal('#output-1', 'fire request hooks')
-        self.wait_for_text_to_equal('#output-pre', 'request_pre changed this text!')
-        self.wait_for_text_to_equal('#output-post', 'request_post changed this text!')
+    dash_duo.wait_for_text_to_equal('#output-1', 'fire request hooks')
+    assert dash_duo.find_element('#output-pre').text == 'request_pre was here!'
+    assert dash_duo.find_element('#output-post').text == 'request_post!!!'
 
-        self.percy_snapshot(name='request-hooks interpolated')
+    dash_duo.percy_snapshot(name='request-hooks interpolated')
 
-    def test_modified_response(self):
-        app = Dash(__name__)
-        app.layout = html.Div([
-            dcc.Input(id='input', value='ab'),
-            html.Div(id='output')
-        ])
 
-        @app.callback(Output('output', 'children'), [Input('input', 'value')])
-        def update_output(value):
-            callback_context.response.set_cookie(
-                'dash cookie', value + ' - cookie')
-            return value + ' - output'
+def test_modified_response(dash_duo):
+    app = Dash(__name__)
+    app.layout = html.Div([
+        dcc.Input(id='input', value='ab'),
+        html.Div(id='output')
+    ])
 
-        self.startServer(app)
-        self.wait_for_text_to_equal('#output', 'ab - output')
-        input1 = self.wait_for_element_by_id('input')
+    @app.callback(Output('output', 'children'), [Input('input', 'value')])
+    def update_output(value):
+        callback_context.response.set_cookie(
+            'dash cookie', value + ' - cookie')
+        return value + ' - output'
 
-        input1.send_keys('cd')
+    dash_duo.start_server(app)
+    dash_duo.wait_for_text_to_equal('#output', 'ab - output')
+    input1 = dash_duo.find_element('#input')
 
-        self.wait_for_text_to_equal('#output', 'abcd - output')
-        cookie = self.driver.get_cookie('dash cookie')
-        # cookie gets json encoded
-        self.assertEqual(cookie['value'], '"abcd - cookie"')
+    input1.send_keys('cd')
 
-        self.assertTrue(self.is_console_clean())
+    dash_duo.wait_for_text_to_equal('#output', 'abcd - output')
+    cookie = dash_duo.driver.get_cookie('dash cookie')
+    # cookie gets json encoded
+    assert cookie['value'] == '"abcd - cookie"'
 
-    def test_late_component_register(self):
-        app = Dash()
+    assert not dash_duo.get_logs()
 
-        app.layout = html.Div([
-            html.Button('Click me to put a dcc ', id='btn-insert'),
-            html.Div(id='output')
-        ])
 
-        @app.callback(Output('output', 'children'),
-                      [Input('btn-insert', 'n_clicks')])
-        def update_output(value):
-            if value is None:
-                raise PreventUpdate
+def test_late_component_register(dash_duo):
+    app = Dash()
 
-            return dcc.Input(id='inserted-input')
+    app.layout = html.Div([
+        html.Button('Click me to put a dcc ', id='btn-insert'),
+        html.Div(id='output')
+    ])
 
-        self.startServer(app)
+    @app.callback(Output('output', 'children'),
+                  [Input('btn-insert', 'n_clicks')])
+    def update_output(value):
+        if value is None:
+            raise PreventUpdate
 
-        btn = self.wait_for_element_by_css_selector('#btn-insert')
-        btn.click()
-        time.sleep(1)
+        return dcc.Input(id='inserted-input')
 
-        self.wait_for_element_by_css_selector('#inserted-input')
+    dash_duo.start_server(app)
 
-    def test_output_input_invalid_callback(self):
-        app = Dash(__name__)
-        app.layout = html.Div([
-            html.Div('child', id='input-output'),
-            html.Div(id='out')
-        ])
+    btn = dash_duo.find_element('#btn-insert')
+    btn.click()
 
-        with self.assertRaises(CallbackException) as context:
-            @app.callback(Output('input-output', 'children'),
-                          [Input('input-output', 'children')])
-            def failure(children):
-                pass
+    dash_duo.find_element('#inserted-input')
 
-        self.assertEqual(
-            'Same output and input: input-output.children',
-            context.exception.args[0]
-        )
 
-        # Multi output version.
-        with self.assertRaises(CallbackException) as context:
-            @app.callback([Output('out', 'children'),
-                           Output('input-output', 'children')],
-                          [Input('input-output', 'children')])
-            def failure2(children):
-                pass
-
-        self.assertEqual(
-            'Same output and input: input-output.children',
-            context.exception.args[0]
-        )
+def test_output_input_invalid_callback():
+    app = Dash(__name__)
+    app.layout = html.Div([
+        html.Div('child', id='input-output'),
+        html.Div(id='out')
+    ])
 
-    def test_callback_dep_types(self):
-        app = Dash(__name__)
-        app.layout = html.Div([
-            html.Div('child', id='in'),
-            html.Div('state', id='state'),
-            html.Div(id='out')
-        ])
+    with pytest.raises(CallbackException) as err:
+        @app.callback(Output('input-output', 'children'),
+                      [Input('input-output', 'children')])
+        def failure(children):
+            pass
 
-        with self.assertRaises(IncorrectTypeException):
-            @app.callback([[Output('out', 'children')]],  # extra nesting
-                          [Input('in', 'children')])
-            def f(i):
-                return i
-
-        with self.assertRaises(IncorrectTypeException):
-            @app.callback(Output('out', 'children'),
-                          Input('in', 'children'))  # no nesting
-            def f2(i):
-                return i
-
-        with self.assertRaises(IncorrectTypeException):
-            @app.callback(Output('out', 'children'),
-                          [Input('in', 'children')],
-                          State('state', 'children'))  # no nesting
-            def f3(i):
-                return i
-
-        # all OK with tuples
-        @app.callback((Output('out', 'children'),),
-                      (Input('in', 'children'),),
-                      (State('state', 'children'),))
-        def f4(i):
-            return i
+    msg = 'Same output and input: input-output.children'
+    assert err.value.args[0] == msg
 
-    def test_callback_return_validation(self):
-        app = Dash(__name__)
-        app.layout = html.Div([
-            html.Div(id='a'),
-            html.Div(id='b'),
-            html.Div(id='c'),
-            html.Div(id='d'),
-            html.Div(id='e'),
-            html.Div(id='f')
-        ])
+    # Multi output version.
+    with pytest.raises(CallbackException) as err:
+        @app.callback([Output('out', 'children'),
+                       Output('input-output', 'children')],
+                      [Input('input-output', 'children')])
+        def failure2(children):
+            pass
 
-        @app.callback(Output('b', 'children'), [Input('a', 'children')])
-        def single(a):
-            # anything non-serializable, really
-            return set([1])
+    msg = 'Same output and input: input-output.children'
+    assert err.value.args[0] == msg
 
-        with self.assertRaises(InvalidCallbackReturnValue):
-            single('aaa')
 
-        @app.callback([Output('c', 'children'), Output('d', 'children')],
-                      [Input('a', 'children')])
-        def multi(a):
-            # non-serializable inside a list
-            return [1, set([2])]
+def test_callback_dep_types():
+    app = Dash(__name__)
+    app.layout = html.Div([
+        html.Div('child', id='in'),
+        html.Div('state', id='state'),
+        html.Div(id='out')
+    ])
 
-        with self.assertRaises(InvalidCallbackReturnValue):
-            multi('aaa')
+    with pytest.raises(IncorrectTypeException):
+        @app.callback([[Output('out', 'children')]],  # extra nesting
+                      [Input('in', 'children')])
+        def f(i):
+            return i
 
-        @app.callback([Output('e', 'children'), Output('f', 'children')],
-                      [Input('a', 'children')])
-        def multi2(a):
-            # wrong-length list
-            return ['abc']
+    with pytest.raises(IncorrectTypeException):
+        @app.callback(Output('out', 'children'),
+                      Input('in', 'children'))  # no nesting
+        def f2(i):
+            return i
 
-        with self.assertRaises(InvalidCallbackReturnValue):
-            multi2('aaa')
+    with pytest.raises(IncorrectTypeException):
+        @app.callback(Output('out', 'children'),
+                      [Input('in', 'children')],
+                      State('state', 'children'))  # no nesting
+        def f3(i):
+            return i
 
-    def test_callback_context(self):
-        app = Dash(__name__)
+    # all OK with tuples
+    @app.callback((Output('out', 'children'),),
+                  (Input('in', 'children'),),
+                  (State('state', 'children'),))
+    def f4(i):
+        return i
+
+
+def test_callback_return_validation():
+    app = Dash(__name__)
+    app.layout = html.Div([
+        html.Div(id='a'),
+        html.Div(id='b'),
+        html.Div(id='c'),
+        html.Div(id='d'),
+        html.Div(id='e'),
+        html.Div(id='f')
+    ])
+
+    @app.callback(Output('b', 'children'), [Input('a', 'children')])
+    def single(a):
+        # anything non-serializable, really
+        return set([1])
+
+    with pytest.raises(InvalidCallbackReturnValue):
+        single('aaa')
+
+    @app.callback([Output('c', 'children'), Output('d', 'children')],
+                  [Input('a', 'children')])
+    def multi(a):
+        # non-serializable inside a list
+        return [1, set([2])]
+
+    with pytest.raises(InvalidCallbackReturnValue):
+        multi('aaa')
+
+    @app.callback([Output('e', 'children'), Output('f', 'children')],
+                  [Input('a', 'children')])
+    def multi2(a):
+        # wrong-length list
+        return ['abc']
+
+    with pytest.raises(InvalidCallbackReturnValue):
+        multi2('aaa')
+
+
+def test_callback_context(dash_duo):
+    app = Dash(__name__)
+
+    btns = ['btn-{}'.format(x) for x in range(1, 6)]
+
+    app.layout = html.Div([
+        html.Div([
+            html.Button(x, id=x) for x in btns
+        ]),
+        html.Div(id='output'),
+    ])
+
+    @app.callback(Output('output', 'children'),
+                  [Input(x, 'n_clicks') for x in btns])
+    def on_click(*args):
+        if not callback_context.triggered:
+            raise PreventUpdate
+        trigger = callback_context.triggered[0]
+        return 'Just clicked {} for the {} time!'.format(
+            trigger['prop_id'].split('.')[0], trigger['value']
+        )
 
-        btns = ['btn-{}'.format(x) for x in range(1, 6)]
+    dash_duo.start_server(app)
 
-        app.layout = html.Div([
-            html.Div([
-                html.Button(x, id=x) for x in btns
-            ]),
-            html.Div(id='output'),
-        ])
+    btn_elements = [
+        dash_duo.find_element('#' + x) for x in btns
+    ]
 
-        @app.callback(Output('output', 'children'),
-                      [Input(x, 'n_clicks') for x in btns])
-        def on_click(*args):
-            if not callback_context.triggered:
-                raise PreventUpdate
-            trigger = callback_context.triggered[0]
-            return 'Just clicked {} for the {} time!'.format(
-                trigger['prop_id'].split('.')[0], trigger['value']
+    for i in range(1, 5):
+        for j, btn in enumerate(btns):
+            btn_elements[j].click()
+            dash_duo.wait_for_text_to_equal(
+                '#output',
+                'Just clicked {} for the {} time!'.format(
+                    btn, i
+                )
             )
 
-        self.startServer(app)
-
-        btn_elements = [
-            self.wait_for_element_by_id(x) for x in btns
-        ]
-
-        for i in range(1, 5):
-            for j, btn in enumerate(btns):
-                btn_elements[j].click()
-                self.wait_for_text_to_equal(
-                    '#output',
-                    'Just clicked {} for the {} time!'.format(
-                        btn, i
-                    )
-                )
 
-    def test_no_callback_context(self):
-        for attr in ['inputs', 'states', 'triggered', 'response']:
-            with self.assertRaises(MissingCallbackContextException):
-                getattr(callback_context, attr)
+def test_no_callback_context():
+    for attr in ['inputs', 'states', 'triggered', 'response']:
+        with pytest.raises(MissingCallbackContextException):
+            getattr(callback_context, attr)

From 62a18d3cf62921a90155c048fb2980b845644f4e Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 11 Jun 2019 12:14:20 -0400
Subject: [PATCH 33/34] add some tcids

---
 tests/integration/test_integration.py | 44 +++++++++++++--------------
 tests/unit/dash/test_dash_import.py   |  2 +-
 tests/unit/dash/test_utils.py         |  2 +-
 3 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/tests/integration/test_integration.py b/tests/integration/test_integration.py
index d5fa28e02d..3c1a063fb1 100644
--- a/tests/integration/test_integration.py
+++ b/tests/integration/test_integration.py
@@ -24,7 +24,7 @@
 from dash.testing.wait import until
 
 
-def test_simple_callback(dash_duo):
+def test_inin001_simple_callback(dash_duo):
     app = Dash(__name__)
     app.layout = html.Div([
         dcc.Input(id='input', value='initial value'),
@@ -57,7 +57,7 @@ def update_output(value):
     assert not dash_duo.get_logs()
 
 
-def test_wildcard_callback(dash_duo):
+def test_inin002_wildcard_callback(dash_duo):
     app = Dash(__name__)
     app.layout = html.Div([
         dcc.Input(id='input', value='initial value'),
@@ -102,7 +102,7 @@ def update_text(data):
     assert not dash_duo.get_logs()
 
 
-def test_aborted_callback(dash_duo):
+def test_inin003_aborted_callback(dash_duo):
     """
     Raising PreventUpdate OR returning no_update
     prevents update and triggering dependencies
@@ -157,7 +157,7 @@ def callback2(value):
     dash_duo.percy_snapshot(name='aborted')
 
 
-def test_wildcard_data_attributes(dash_duo):
+def test_inin004_wildcard_data_attributes(dash_duo):
     app = Dash()
     test_time = datetime.datetime(2012, 1, 10, 2, 3)
     test_date = datetime.date(test_time.year, test_time.month,
@@ -216,7 +216,7 @@ def test_wildcard_data_attributes(dash_duo):
     assert not dash_duo.get_logs()
 
 
-def test_no_props_component(dash_duo):
+def test_inin005_no_props_component(dash_duo):
     app = Dash()
     app.layout = html.Div([
         dash_dangerously_set_inner_html.DangerouslySetInnerHTML('''
@@ -230,7 +230,7 @@ def test_no_props_component(dash_duo):
     dash_duo.percy_snapshot(name='no-props-component')
 
 
-def test_flow_component(dash_duo):
+def test_inin006_flow_component(dash_duo):
     app = Dash()
 
     app.layout = html.Div([
@@ -267,7 +267,7 @@ def display_output(react_value, flow_value):
     dash_duo.percy_snapshot(name='flowtype')
 
 
-def test_meta_tags(dash_duo):
+def test_inin007_meta_tags(dash_duo):
     metas = [
         {'name': 'description', 'content': 'my dash app'},
         {'name': 'custom', 'content': 'customized'},
@@ -291,7 +291,7 @@ def test_meta_tags(dash_duo):
         assert meta_tag.get_attribute('content') == meta_info['content']
 
 
-def test_index_customization(dash_duo):
+def test_inin008_index_customization(dash_duo):
     app = Dash()
 
     app.index_string = '''
@@ -339,7 +339,7 @@ def test_index_customization(dash_duo):
     dash_duo.percy_snapshot('custom-index')
 
 
-def test_invalid_index_string(dash_duo):
+def test_inin009_invalid_index_string(dash_duo):
     app = Dash()
 
     def will_raise():
@@ -375,7 +375,7 @@ def will_raise():
     assert dash_duo.find_element('#a').text == 'Hello World'
 
 
-def test_func_layout_accepted(dash_duo):
+def test_inin010_func_layout_accepted(dash_duo):
     app = Dash()
 
     def create_layout():
@@ -386,7 +386,7 @@ def create_layout():
     assert dash_duo.find_element('#a').text == 'Hello World'
 
 
-def test_multi_output(dash_duo):
+def test_inin011_multi_output(dash_duo):
     app = Dash(__name__)
 
     app.layout = html.Div([
@@ -485,7 +485,7 @@ def overlapping_multi_output(n_clicks):
     assert int(dash_duo.find_element('#output2').text) > t
 
 
-def test_multi_output_no_update(dash_duo):
+def test_inin012_multi_output_no_update(dash_duo):
     app = Dash(__name__)
 
     app.layout = html.Div([
@@ -518,7 +518,7 @@ def show_clicks(n):
     dash_duo.wait_for_text_to_equal('#n3', 'initial3')
 
 
-def test_no_update_chains(dash_duo):
+def test_inin013_no_update_chains(dash_duo):
     app = Dash(__name__)
 
     app.layout = html.Div([
@@ -577,7 +577,7 @@ def ab_out(a, b):
     dash_duo.wait_for_text_to_equal('#ab_out', 'aa bbbb')
 
 
-def test_with_custom_renderer(dash_duo):
+def test_inin014_with_custom_renderer(dash_duo):
     app = Dash(__name__)
 
     app.index_string = '''
@@ -647,7 +647,7 @@ def update_output(value):
     dash_duo.percy_snapshot(name='request-hooks')
 
 
-def test_with_custom_renderer_interpolated(dash_duo):
+def test_inin015_with_custom_renderer_interpolated(dash_duo):
 
     renderer = '''
         <script id="_dash-renderer" type="application/javascript">
@@ -725,7 +725,7 @@ def update_output(value):
     dash_duo.percy_snapshot(name='request-hooks interpolated')
 
 
-def test_modified_response(dash_duo):
+def test_inin016_modified_response(dash_duo):
     app = Dash(__name__)
     app.layout = html.Div([
         dcc.Input(id='input', value='ab'),
@@ -752,7 +752,7 @@ def update_output(value):
     assert not dash_duo.get_logs()
 
 
-def test_late_component_register(dash_duo):
+def test_inin017_late_component_register(dash_duo):
     app = Dash()
 
     app.layout = html.Div([
@@ -776,7 +776,7 @@ def update_output(value):
     dash_duo.find_element('#inserted-input')
 
 
-def test_output_input_invalid_callback():
+def test_inin018_output_input_invalid_callback():
     app = Dash(__name__)
     app.layout = html.Div([
         html.Div('child', id='input-output'),
@@ -804,7 +804,7 @@ def failure2(children):
     assert err.value.args[0] == msg
 
 
-def test_callback_dep_types():
+def test_inin019_callback_dep_types():
     app = Dash(__name__)
     app.layout = html.Div([
         html.Div('child', id='in'),
@@ -839,7 +839,7 @@ def f4(i):
         return i
 
 
-def test_callback_return_validation():
+def test_inin020_callback_return_validation():
     app = Dash(__name__)
     app.layout = html.Div([
         html.Div(id='a'),
@@ -877,7 +877,7 @@ def multi2(a):
         multi2('aaa')
 
 
-def test_callback_context(dash_duo):
+def test_inin021_callback_context(dash_duo):
     app = Dash(__name__)
 
     btns = ['btn-{}'.format(x) for x in range(1, 6)]
@@ -916,7 +916,7 @@ def on_click(*args):
             )
 
 
-def test_no_callback_context():
+def test_inin022_no_callback_context():
     for attr in ['inputs', 'states', 'triggered', 'response']:
         with pytest.raises(MissingCallbackContextException):
             getattr(callback_context, attr)
diff --git a/tests/unit/dash/test_dash_import.py b/tests/unit/dash/test_dash_import.py
index 5448882471..35465fc7f5 100644
--- a/tests/unit/dash/test_dash_import.py
+++ b/tests/unit/dash/test_dash_import.py
@@ -2,7 +2,7 @@
 import types
 
 
-def test_dash_import_is_correct():
+def test_dddi001_dash_import_is_correct():
     imported = importlib.import_module("dash")
     assert isinstance(imported, types.ModuleType), "dash can be imported"
 
diff --git a/tests/unit/dash/test_utils.py b/tests/unit/dash/test_utils.py
index 1df6519684..70e3c74e05 100644
--- a/tests/unit/dash/test_utils.py
+++ b/tests/unit/dash/test_utils.py
@@ -3,7 +3,7 @@
 import dash._utils as utils
 
 
-def test_attribute_dict():
+def test_ddut001_attribute_dict():
     a = utils.AttributeDict()
 
     assert str(a) == '{}'

From b389bfb59c45876e0778c71883127886aabb786e Mon Sep 17 00:00:00 2001
From: alexcjohnson <alex@plot.ly>
Date: Tue, 11 Jun 2019 13:35:09 -0400
Subject: [PATCH 34/34] BZ-proof test_integration

---
 tests/integration/test_integration.py | 148 +++++++++++---------------
 1 file changed, 63 insertions(+), 85 deletions(-)

diff --git a/tests/integration/test_integration.py b/tests/integration/test_integration.py
index 3c1a063fb1..b17825fa7b 100644
--- a/tests/integration/test_integration.py
+++ b/tests/integration/test_integration.py
@@ -5,6 +5,7 @@
 import time
 import pytest
 
+from bs4 import BeautifulSoup
 from selenium.webdriver.common.keys import Keys
 
 import dash_dangerously_set_inner_html
@@ -142,11 +143,14 @@ def callback2(value):
     input_.send_keys('xyz')
     dash_duo.wait_for_text_to_equal('#input', 'initial inputxyz')
 
-    # callback1 runs 4x (initial page load and 3x through send_keys)
-    until(lambda: callback1_count.value == 4, 3)
+    until(
+        lambda: callback1_count.value == 4,
+        timeout=3,
+        msg="callback1 runs 4x (initial page load and 3x through send_keys)"
+    )
 
-    # callback2 is never triggered, even on initial load
-    assert callback2_count.value == 0
+    assert callback2_count.value == 0, \
+        "callback2 is never triggered, even on initial load"
 
     # double check that output1 and output2 children were not updated
     assert dash_duo.find_element('#output1').text == initial_output
@@ -160,58 +164,31 @@ def callback2(value):
 def test_inin004_wildcard_data_attributes(dash_duo):
     app = Dash()
     test_time = datetime.datetime(2012, 1, 10, 2, 3)
-    test_date = datetime.date(test_time.year, test_time.month,
-                              test_time.day)
-    app.layout = html.Div([
-        html.Div(
-            id="inner-element",
-            **{
-                'data-string': 'multiple words',
-                'data-number': 512,
-                'data-none': None,
-                'data-date': test_date,
-                'aria-progress': 5
-            }
-        )
-    ], id='data-element')
+    test_date = datetime.date(test_time.year, test_time.month, test_time.day)
+    attrs = {
+        "id": "inner-element",
+        "data-string": "multiple words",
+        "data-number": 512,
+        "data-none": None,
+        "data-date": test_date,
+        "aria-progress": 5
+    }
+    app.layout = html.Div([html.Div(**attrs)], id='data-element')
 
     dash_duo.start_server(app)
 
     div = dash_duo.find_element('#data-element')
 
-    # React wraps text and numbers with e.g. <!-- react-text: 20 -->
-    # Remove those
-    comment_regex = r'<!--[^\[](.*?)-->'  # noqa: W605
-
-    # Somehow the html attributes are unordered.
-    # Try different combinations (they're all valid html)
-    permutations = itertools.permutations([
-        'id="inner-element"',
-        'data-string="multiple words"',
-        'data-number="512"',
-        'data-date="%s"' % test_date,
-        'aria-progress="5"'
-    ], 5)
-    passed = False
-    for permutation in permutations:
-        actual_cleaned = re.sub(comment_regex, '',
-                                div.get_attribute('innerHTML'))
-        expected_cleaned = re.sub(
-            comment_regex,
-            '',
-            "<div PERMUTE></div>"
-            .replace('PERMUTE', ' '.join(list(permutation)))
-        )
-        passed = passed or (actual_cleaned == expected_cleaned)
-        if passed:
-            break
-    if not passed:
-        raise Exception(
-            'HTML does not match\nActual:\n{}\n\nExpected:\n{}'.format(
-                actual_cleaned,
-                expected_cleaned
-            )
-        )
+    # attribute order is ill-defined - BeautifulSoup will sort them
+    actual = BeautifulSoup(div.get_attribute('innerHTML'), 'lxml').decode()
+    expected = BeautifulSoup(
+        '<div ' + ' '.join(
+            '{}="{!s}"'.format(k, v) for k, v in attrs.items() if v is not None
+        ) + '></div>',
+        'lxml'
+    ).decode()
+
+    assert actual == expected, 'all attrs are included except None values'
 
     assert not dash_duo.get_logs()
 
@@ -314,7 +291,7 @@ def test_inin008_index_customization(dash_duo):
             </footer>
             <div id="custom-footer">My custom footer</div>
             <script>
-            // Test the formatting doesn't mess up script tags.
+            // Test the formatting doesn"t mess up script tags.
             var elem = document.getElementById('add');
             if (!elem) {
                 throw Error('could not find container to add');
@@ -426,8 +403,10 @@ def dummy_callback(n_clicks):
 
         return 'Output 3: {}'.format(n_clicks)
 
-    # Test that a multi output can't be included in a single output
-    with pytest.raises(DuplicateCallbackOutput) as err:
+    with pytest.raises(
+        DuplicateCallbackOutput,
+        message="multi output can't be included in a single output"
+    ) as err:
         @app.callback(Output('output1', 'children'),
                       [Input('output-btn', 'n_clicks')])
         def on_click_duplicate(n_clicks):
@@ -438,8 +417,10 @@ def on_click_duplicate(n_clicks):
 
     assert 'output1' in err.value.args[0]
 
-    # Test a multi output cannot contain a used single output
-    with pytest.raises(DuplicateCallbackOutput) as err:
+    with pytest.raises(
+        DuplicateCallbackOutput,
+        message="multi output cannot contain a used single output"
+    ) as err:
         @app.callback([Output('output3', 'children'),
                        Output('output4', 'children')],
                       [Input('output-btn', 'n_clicks')])
@@ -451,7 +432,10 @@ def on_click_duplicate_multi(n_clicks):
 
     assert 'output3' in err.value.args[0]
 
-    with pytest.raises(DuplicateCallbackOutput) as err:
+    with pytest.raises(
+        DuplicateCallbackOutput,
+        message="same output cannot be used twice in one callback"
+    ) as err:
         @app.callback([Output('output5', 'children'),
                        Output('output5', 'children')],
                       [Input('output-btn', 'n_clicks')])
@@ -460,7 +444,10 @@ def on_click_same_output(n_clicks):
 
     assert 'output5' in err.value.args[0]
 
-    with pytest.raises(DuplicateCallbackOutput) as err:
+    with pytest.raises(
+        DuplicateCallbackOutput,
+        message="no part of an existing multi-output can be used in another"
+    ) as err:
         @app.callback([Output('output1', 'children'),
                        Output('output5', 'children')],
                       [Input('output-btn', 'n_clicks')])
@@ -509,9 +496,7 @@ def show_clicks(n):
 
     dash_duo.start_server(app)
 
-    btn = dash_duo.find_element('#btn')
-    for _ in range(10):
-        btn.click()
+    dash_duo.multiple_click('#btn', 10)
 
     dash_duo.wait_for_text_to_equal('#n1', '4')
     dash_duo.wait_for_text_to_equal('#n2', '2')
@@ -812,22 +797,22 @@ def test_inin019_callback_dep_types():
         html.Div(id='out')
     ])
 
-    with pytest.raises(IncorrectTypeException):
-        @app.callback([[Output('out', 'children')]],  # extra nesting
+    with pytest.raises(IncorrectTypeException, message="extra output nesting"):
+        @app.callback([[Output('out', 'children')]],
                       [Input('in', 'children')])
         def f(i):
             return i
 
-    with pytest.raises(IncorrectTypeException):
+    with pytest.raises(IncorrectTypeException, message="un-nested input"):
         @app.callback(Output('out', 'children'),
-                      Input('in', 'children'))  # no nesting
+                      Input('in', 'children'))
         def f2(i):
             return i
 
-    with pytest.raises(IncorrectTypeException):
+    with pytest.raises(IncorrectTypeException, message="un-nested state"):
         @app.callback(Output('out', 'children'),
                       [Input('in', 'children')],
-                      State('state', 'children'))  # no nesting
+                      State('state', 'children'))
         def f3(i):
             return i
 
@@ -852,28 +837,29 @@ def test_inin020_callback_return_validation():
 
     @app.callback(Output('b', 'children'), [Input('a', 'children')])
     def single(a):
-        # anything non-serializable, really
         return set([1])
 
-    with pytest.raises(InvalidCallbackReturnValue):
+    with pytest.raises(InvalidCallbackReturnValue, message="not serializable"):
         single('aaa')
 
     @app.callback([Output('c', 'children'), Output('d', 'children')],
                   [Input('a', 'children')])
     def multi(a):
-        # non-serializable inside a list
         return [1, set([2])]
 
-    with pytest.raises(InvalidCallbackReturnValue):
+    with pytest.raises(
+        InvalidCallbackReturnValue, message="nested non-serializable"
+    ):
         multi('aaa')
 
     @app.callback([Output('e', 'children'), Output('f', 'children')],
                   [Input('a', 'children')])
     def multi2(a):
-        # wrong-length list
         return ['abc']
 
-    with pytest.raises(InvalidCallbackReturnValue):
+    with pytest.raises(
+        InvalidCallbackReturnValue, message="wrong-length list"
+    ):
         multi2('aaa')
 
 
@@ -883,9 +869,7 @@ def test_inin021_callback_context(dash_duo):
     btns = ['btn-{}'.format(x) for x in range(1, 6)]
 
     app.layout = html.Div([
-        html.Div([
-            html.Button(x, id=x) for x in btns
-        ]),
+        html.Div([html.Button(btn, id=btn) for btn in btns]),
         html.Div(id='output'),
     ])
 
@@ -901,18 +885,12 @@ def on_click(*args):
 
     dash_duo.start_server(app)
 
-    btn_elements = [
-        dash_duo.find_element('#' + x) for x in btns
-    ]
-
     for i in range(1, 5):
-        for j, btn in enumerate(btns):
-            btn_elements[j].click()
+        for btn in btns:
+            dash_duo.find_element('#' + btn).click()
             dash_duo.wait_for_text_to_equal(
                 '#output',
-                'Just clicked {} for the {} time!'.format(
-                    btn, i
-                )
+                'Just clicked {} for the {} time!'.format(btn, i)
             )