Module Expr Str Import alias Import alias ImportFrom alias ImportFrom alias ImportFrom alias ImportFrom alias ImportFrom alias alias Import alias identifier ImportFrom alias alias ImportFrom alias Assign NameStore Call AttributeLoad Call NameLoad Str Str attr Str Expr Call NameLoad Call NameLoad NameLoad Assign NameStore NameLoad ClassDef bases AttributeLoad NameLoad attr body Expr Str Assign NameStore Call NameLoad Str keyword NameLoad Assign NameStore Call NameLoad keyword NameLoad Assign NameStore Call NameLoad keyword NameLoad Assign NameStore Call NameLoad keyword NameLoad Assign NameStore Str Assign NameStore Dict Str NameLoad FunctionDef arguments args NameParam NameParam defaults Str kwarg body Expr Str Expr Call AttributeLoad Call NameLoad NameLoad NameLoad attr NameLoad Assign AttributeStore NameLoad attr NameLoad Assign AttributeStore NameLoad attr Call NameLoad Assign AttributeStore NameLoad attr Dict Str Str Str Call AttributeLoad NameLoad attr Call AttributeLoad NameLoad attr Call AttributeLoad NameLoad attr Assign AttributeStore NameLoad attr Str Expr Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr Assign AttributeStore NameLoad attr Call NameLoad decorator_list FunctionDef arguments args NameParam defaults body Return BoolOpOr AttributeLoad NameLoad attr Str decorator_list NameLoad FunctionDef arguments args NameParam NameParam defaults body Expr Str Assign NameStore SubscriptLoad SubscriptLoad SubscriptLoad NameLoad Index Str Index Str Index Str If CompareEq Call AttributeLoad NameLoad attr Str Str Str body Assign AttributeStore NameLoad attr SubscriptLoad NameLoad Index Str While AttributeLoad NameLoad attr body Assign NameStore Call AttributeLoad AttributeLoad NameLoad attr attr Assign SubscriptStore NameLoad Index Str AttributeLoad NameLoad attr Assign NameStore Call AttributeLoad NameLoad attr NameLoad Assign AttributeStore NameLoad attr NameLoad If CompareIn Call AttributeLoad NameLoad attr Str Str ListLoad Str Str Str body If BoolOpOr CompareEq SubscriptLoad NameLoad Index Str Str CompareEq SubscriptLoad NameLoad Index Str Str body Assign NameStore SubscriptLoad SubscriptLoad NameLoad Index Str Index Str orelse If CompareEq SubscriptLoad NameLoad Index Str Str body Assign NameStore SubscriptLoad SubscriptLoad NameLoad Index Str Index Str Expr Call SubscriptLoad AttributeLoad NameLoad attr Index SubscriptLoad NameLoad Index Str NameLoad NameLoad If CompareEq Call AttributeLoad NameLoad attr Str Str Str body Assign AttributeStore NameLoad attr Call AttributeLoad NameLoad attr Str Dict If SubscriptLoad AttributeLoad NameLoad attr Index Str body Assign SubscriptStore AttributeLoad NameLoad attr Index Str NameLoad Assign NameStore Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr keyword NameLoad keyword AttributeLoad NameLoad attr keyword NameLoad Assign AttributeStore NameLoad attr NameLoad Expr Call AttributeLoad NameLoad attr Str Num decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam defaults body Expr Call AttributeLoad SubscriptLoad AttributeLoad NameLoad attr Index NameLoad attr NameLoad keyword NameLoad Assign NameStore AttributeLoad SubscriptLoad AttributeLoad NameLoad attr Index NameLoad attr If BoolOpAnd Call NameLoad NameLoad CompareNotIn NameLoad AttributeLoad NameLoad attr body Expr Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad Assign NameStore Dict Str Str Str Call NameLoad AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body If CompareEq AttributeLoad NameLoad attr Str body Expr Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad orelse Assign SubscriptStore NameLoad Index Str AttributeLoad NameLoad attr Assign SubscriptStore NameLoad Index Str Call NameLoad Call AttributeLoad NameLoad attr Assign AttributeStore NameLoad attr Call AttributeLoad NameLoad attr NameLoad keyword AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults NameLoad body Expr Str Expr Call AttributeLoad NameLoad attr Str NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults NameLoad body Expr Str Expr Call AttributeLoad NameLoad attr Str NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults NameLoad body Expr Str Expr Call AttributeLoad NameLoad attr Str NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults NameLoad body Expr Str If BoolOpOr CompareEq NameLoad Dict CompareEq NameLoad Call NameLoad body Assign NameStore NameLoad Assign NameStore Call AttributeLoad NameLoad attr NameLoad NameLoad Assign NameStore Dict Str Str Str Str Str Call AttributeLoad NameLoad attr Str ListLoad Call AttributeLoad NameLoad attr Str Dict AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults NameLoad body Expr Str Assign NameStore Dict Str Str Str Str NameLoad AttributeLoad NameLoad attr If NameLoad body Assign SubscriptStore NameLoad Index Str NameLoad Expr Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Assign NameStore Dict Str Str Str Str NameLoad AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam defaults vararg body Expr Str If CompareEq Call NameLoad NameLoad Num body Assign NameStore SubscriptLoad NameLoad Index Num Assign NameStore Dict Str Str Str Str NameLoad AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults NameLoad body Expr Str Assign NameStore Dict Str Str Str Str NameLoad AttributeLoad NameLoad attr If CompareIsNot NameLoad NameLoad body Assign SubscriptStore NameLoad Index Str NameLoad Expr Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Assign NameStore Dict Str Str Str Str NameLoad AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults NameLoad body Expr Str Assign NameStore Dict Str Str Str Str NameLoad AttributeLoad NameLoad attr If CompareIsNot NameLoad NameLoad body Assign SubscriptStore NameLoad Index Str NameLoad Expr Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults NameLoad Str body Expr Str Assign SubscriptStore AttributeLoad NameLoad attr Index Str NameLoad Assign AttributeStore NameLoad attr NameLoad Assign NameStore Dict Str Str Str NameLoad Expr Call AttributeLoad NameLoad attr NameLoad Expr Call AttributeLoad NameLoad attr Str Num decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam defaults TupleLoad Num NameLoad body Expr Str Assign NameStore Dict Str Str Str Str Str NameLoad AttributeLoad NameLoad attr NameLoad If CompareIsNot NameLoad NameLoad body Assign SubscriptStore NameLoad Index Str NameLoad Expr Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Assign NameStore Dict Str Str Str NameLoad NameLoad NameLoad Expr Call AttributeLoad NameLoad attr NameLoad decorator_list decorator_list
N/A N/A 
Module to allow Plotly graphs to interact with IPython widgets.

 N/A json N/A uuid collections deque pkg_resources resource_string IPython.html widgets IPython.utils.traitlets Unicode IPython.display Javascript display N/A plotly.plotly.plotly py plotly utils tools plotly.graph_objs Figure N/A js_widget_code N/A N/A N/A resource_string plotly widgets/graphWidget.js decode utf-8 N/A N/A display N/A Javascript js_widget_code N/A __all__ None GraphWidget N/A N/A widgets DOMWidget N/A N/A An interactive Plotly graph widget for use in IPython
    Notebooks.
     N/A _view_name N/A Unicode GraphView sync True N/A _message N/A Unicode sync True N/A _graph_url N/A Unicode sync True N/A _new_url N/A Unicode sync True N/A _filename N/A _flags N/A save_pending False __init__ N/A N/A self graph_url N/A https://plot.ly/~playground/7 kwargs N/A N/A Initialize a plotly graph widget

        Args:
            graph_url: The url of a Plotly graph

        Example:
            ```
            GraphWidget('https://plot.ly/~chris/3375')
            ```
         N/A N/A N/A N/A super GraphWidget self __init__ kwargs N/A N/A self _graph_url graph_url N/A N/A self _listener_set N/A set N/A N/A self _event_handlers N/A click hover zoom N/A N/A widgets CallbackDispatcher N/A N/A widgets CallbackDispatcher N/A N/A widgets CallbackDispatcher N/A N/A self _graphId N/A N/A N/A self on_msg N/A self _handle_msg N/A N/A self _clientMessages N/A deque N/A url N/A N/A self N/A N/A N/A N/A N/A self _new_url N/A property _handle_msg N/A N/A self message N/A N/A N/A Handle a msg from the front-end.

        Args:
            content (dict): Content of the msg.
         N/A content N/A N/A N/A message N/A content N/A data N/A content N/A N/A N/A N/A content get event pong N/A N/A N/A self _graphId N/A content N/A graphId N/A N/A self _clientMessages N/A N/A _message N/A N/A N/A self _clientMessages popleft N/A N/A _message N/A graphId N/A self _graphId N/A _message N/A N/A json dumps _message N/A N/A self _message _message N/A N/A N/A N/A content get event N/A click hover zoom N/A N/A N/A N/A N/A content N/A event click N/A N/A content N/A event hover N/A N/A message N/A N/A content N/A message N/A points N/A N/A N/A N/A content N/A event zoom N/A N/A message N/A N/A content N/A message N/A ranges N/A N/A N/A N/A self _event_handlers N/A N/A content N/A event self message N/A N/A N/A N/A content get event getAttributes N/A N/A N/A self _attributes N/A N/A content get response N/A N/A N/A N/A self _flags N/A save_pending N/A N/A N/A N/A self _flags N/A save_pending False N/A url N/A N/A py plot N/A self _attributes auto_open False filename N/A self _filename validate False N/A N/A self _new_url url N/A N/A N/A self _fade_to slow 1 N/A _handle_registration N/A N/A self event_type callback remove N/A N/A N/A N/A N/A N/A N/A self _event_handlers N/A event_type register_callback callback remove remove N/A event_callbacks N/A N/A N/A self _event_handlers N/A event_type callbacks N/A N/A N/A len event_callbacks N/A event_type N/A self _listener_set N/A N/A N/A N/A N/A self _listener_set add event_type N/A message N/A task events listen N/A list N/A self _listener_set N/A N/A N/A self _handle_outgoing_message message N/A _handle_outgoing_message N/A N/A self message N/A N/A N/A N/A N/A self _graphId N/A N/A N/A N/A N/A self _clientMessages append message N/A N/A N/A message N/A graphId N/A self _graphId N/A N/A message N/A uid N/A str N/A N/A uuid uuid4 N/A N/A self _message N/A N/A json dumps message cls N/A utils PlotlyJSONEncoder N/A on_click N/A N/A self callback remove N/A False N/A N/A  Assign a callback to click events propagated
        by clicking on point(s) in the Plotly graph.

        Args:
            callback (function): Callback function this is called
                on click events with the signature:
                callback(widget, hover_obj) -> None

                Args:
                    widget (GraphWidget): The current instance
                    of the graph widget that this callback is assigned to.

                    click_obj (dict): a nested dict that describes
                    which point(s) were clicked on.

                    click_obj example:
                    [
                        {
                            'curveNumber': 1,
                            'pointNumber': 2,
                            'x': 4,
                            'y': 14
                        }
                    ]

            remove (bool, optional): If False, attach the callback.
                If True, remove the callback. Defaults to False.


        Returns:
            None

        Example:
        ```
        from IPython.display import display
        def message_handler(widget, msg):
            display(widget._graph_url)
            display(msg)

        g = GraphWidget('https://plot.ly/~chris/3375')
        display(g)

        g.on_click(message_handler)
        ```
         N/A N/A N/A self _handle_registration click callback remove N/A on_hover N/A N/A self callback remove N/A False N/A N/A  Assign a callback to hover events propagated
        by hovering over points in the Plotly graph.

        Args:
            callback (function): Callback function this is called
                on hover events with the signature:
                callback(widget, hover_obj) -> None

                Args:
                    widget (GraphWidget): The current instance
                    of the graph widget that this callback is assigned to.

                    hover_obj (dict): a nested dict that describes
                    which point(s) was hovered over.

                    hover_obj example:
                    [
                        {
                                    'curveNumber': 1,
                                    'pointNumber': 2,
                                    'x': 4,
                                    'y': 14
                        }
                    ]

            remove (bool, optional): If False, attach the callback.
                If True, remove the callback. Defaults to False.


        Returns:
            None

        Example:
        ```
        from IPython.display import display
        def message_handler(widget, hover_msg):
            display(widget._graph_url)
            display(hover_msg)

        g = GraphWidget('https://plot.ly/~chris/3375')
        display(g)

        g.on_hover(message_handler)
        ```

         N/A N/A N/A self _handle_registration hover callback remove N/A on_zoom N/A N/A self callback remove N/A False N/A N/A  Assign a callback to zoom events propagated
        by zooming in regions in the Plotly graph.

        Args:
            callback (function): Callback function this is called
                on zoom events with the signature:
                callback(widget, ranges) -> None

                Args:
                    widget (GraphWidget): The current instance
                    of the graph widget that this callback is assigned to.

                    ranges (dict): A description of the
                        region that was zoomed into.

                        ranges example:
                        {
                            'x': [1.8399058038561549, 2.16443359662],
                            'y': [4.640902872777017, 7.855677154582]
                        }

                    remove (bool, optional): If False, attach the callback.
                        If True, remove the callback. Defaults to False.

        Returns:
            None

        Example:
        ```
        from IPython.display import display
        def message_handler(widget, ranges):
            display(widget._graph_url)
            display(ranges)

        g = GraphWidget('https://plot.ly/~chris/3375')
        display(g)

        g.on_zoom(message_handler)
        ```
         N/A N/A N/A self _handle_registration zoom callback remove N/A plot N/A N/A self figure_or_data validate N/A True N/A N/A Plot figure_or_data in the Plotly graph widget.

        Args:
            figure_or_data (dict, list, or plotly.graph_obj object):
                The standard Plotly graph object that describes Plotly
                graphs as used in `plotly.plotly.plot`. See examples
                of the figure_or_data in https://plot.ly/python/

        Returns: None

        Example 1 - Graph a scatter plot:
        ```
        from plotly.graph_objs import Scatter
        g = GraphWidget()
        g.plot([Scatter(x=[1, 2, 3], y=[10, 15, 13])])
        ```

        Example 2 - Graph a scatter plot with a title:
        ```
        from plotly.graph_objs import Scatter, Figure, Data
        fig = Figure(
            data = Data([
                Scatter(x=[1, 2, 3], y=[20, 15, 13])
            ]),
            layout = Layout(title='Experimental Data')
        )

        g = GraphWidget()
        g.plot(fig)
        ```

        Example 3 - Clear a graph widget
        ```
        from plotly.graph_objs import Scatter, Figure
        g = GraphWidget()
        g.plot([Scatter(x=[1, 2, 3], y=[10, 15, 13])])

        # Now clear it
        g.plot({}) # alternatively, g.plot(Figure())
        ```
         N/A N/A N/A figure_or_data N/A N/A figure_or_data N/A Figure N/A N/A validate False N/A figure N/A N/A tools return_figure_from_figure_or_data figure_or_data validate N/A message N/A task data layout graphId newPlot N/A N/A figure get data N/A N/A N/A figure get layout N/A N/A self _graphId N/A N/A N/A self _handle_outgoing_message message N/A restyle N/A N/A self update indices N/A None N/A N/A Update the style of existing traces in the Plotly graph.

        Args:
            update (dict):
                dict where keys are the graph attribute strings
                and values are the value of the graph attribute.

                To update graph objects that are nested, like
                a marker's color, combine the keys with a period,
                e.g. `marker.color`. To replace an entire nested object,
                like `marker`, set the value to the object.
                See Example 2 below.

                To update an attribute of multiple traces, set the
                value to an list of values. If the list is shorter
                than the number of traces, the values will wrap around.
                Note: this means that for values that are naturally an array,
                like `x` or `colorscale`, you need to wrap the value
                in an extra array,
                i.e. {'colorscale': [[[0, 'red'], [1, 'green']]]}

                You can also supply values to different traces with the
                indices argument.

                See all of the graph attributes in our reference documentation
                here: https://plot.ly/python/reference or by calling `help` on
                graph objects in `plotly.graph_objs`.

            indices (list, optional):
                Specify which traces to apply the update dict to.
                Negative indices are supported.
                If indices are not given, the update will apply to
                *all* traces.

        Examples:
            Initialization - Start each example below with this setup:
            ```
            from plotly.widgets import GraphWidget
            from IPython.display import display

            graph = GraphWidget()
            display(graph)
            ```

            Example 1 - Set `marker.color` to red in every trace in the graph
            ```
            graph.restyle({'marker.color': 'red'})
            ```

            Example 2 - Replace `marker` with {'color': 'red'}
            ```
            graph.restyle({'marker': {'color': red'}})
            ```

            Example 3 - Set `marker.color` to red
                        in the first trace of the graph
            ```
            graph.restyle({'marker.color': 'red'}, indices=[0])
            ```

            Example 4 - Set `marker.color` of all of the traces to
                alternating sequences of red and green
            ```
            graph.restyle({'marker.color': ['red', 'green']})
            ```

            Example 5 - Set just `marker.color` of the first two traces
                        to red and green
            ```
            graph.restyle({'marker.color': ['red', 'green']}, indices=[0, 1])
            ```

            Example 6 - Set multiple attributes of all of the traces
            ```
            graph.restyle({
                'marker.color': 'red',
                'line.color': 'green'
            })
            ```

            Example 7 - Update the data of the first trace
            ```
            graph.restyle({
                'x': [[1, 2, 3]],
                'y': [[10, 20, 30]],
            }, indices=[0])
            ```

            Example 8 - Update the data of the first two traces
            ```
            graph.restyle({
                'x': [[1, 2, 3],
                      [1, 2, 4]],
                'y': [[10, 20, 30],
                      [5, 8, 14]],
            }, indices=[0, 1])
            ```
         N/A message N/A task update graphId restyle update N/A self _graphId N/A indices N/A N/A N/A message N/A indices indices N/A N/A N/A self _handle_outgoing_message message N/A relayout N/A N/A self layout N/A N/A N/A Update the layout of the Plotly graph.

        Args:
            layout (dict):
                dict where keys are the graph attribute strings
                and values are the value of the graph attribute.

                To update graph objects that are nested, like
                the title of an axis, combine the keys with a period
                e.g. `xaxis.title`. To set a value of an element in an array,
                like an axis's range, use brackets, e.g. 'xaxis.range[0]'.
                To replace an entire nested object, just specify the value to
                the sub-object. See example 4 below.

                See all of the layout attributes in our reference documentation
                https://plot.ly/python/reference/#Layout
                Or by calling `help` on `plotly.graph_objs.Layout`

        Examples - Start each example below with this setup:
            Initialization:
            ```
            from plotly.widgets import GraphWidget
            from IPython.display import display

            graph = GraphWidget('https://plot.ly/~chris/3979')
            display(graph)
            ```

            Example 1 - Update the title
            ```
            graph.relayout({'title': 'Experimental results'})
            ```

            Example 2 - Update the xaxis range
            ```
            graph.relayout({'xaxis.range': [-1, 6]})
            ```

            Example 3 - Update the first element of the xaxis range
            ```
            graph.relayout({'xaxis.range[0]': -3})
            ```

            Example 4 - Replace the entire xaxis object
            ```
            graph.relayout({'xaxis': {'title': 'Experimental results'}})
            ```
         N/A message N/A task update graphId relayout layout N/A self _graphId N/A N/A N/A self _handle_outgoing_message message N/A hover N/A N/A self N/A hover_objs N/A N/A Show hover labels over the points specified in hover_obj.

        Hover labels are the labels that normally appear when the
        mouse hovers over points in the plotly graph.

        Args:
            hover_objs (tuple of dicts):
                Specifies which points to place hover labels over.

                The location of the hover labels is described by a dict with
                keys and'xval' and/or 'yval' or 'curveNumber' and 'pointNumber'
                and optional keys 'hovermode' and 'subplot'

                'xval' and 'yval' specify the (x, y) coordinates to
                place the label.
                'xval' and 'yval need to be close to a point drawn in a graph.

                'curveNumber' and 'pointNumber' specify the trace number and
                the index theof the point in that trace respectively.

                'subplot' describes which axes to the coordinates refer to.
                By default, it is equal to 'xy'. For example, to specify the
                second x-axis and the third y-axis, set 'subplot' to 'x2y3'

                'hovermode' is either 'closest', 'x', or 'y'.
                When set to 'x', all data sharing the same 'x' coordinate will
                be shown on screen with corresponding trace labels.
                When set to 'y' all data sharing the same 'y' coordinates will
                be shown on the screen with corresponding trace labels.
                When set to 'closest', information about the data point closest
                to where the viewer is hovering will appear.

                Note: If 'hovermode' is 'x', only 'xval' needs to be set.
                      If 'hovermode' is 'y', only 'yval' needs to be set.
                      If 'hovermode' is 'closest', 'xval' and 'yval' both
                      need to be set.

                Note: 'hovermode' can be toggled by the user in the graph
                      toolbar.

                Note: It is not currently possible to apply multiple hover
                      labels to points on different axes.

                Note: `hover` can only be called with multiple dicts if
                      'curveNumber' and 'pointNumber' are the keys of the dicts

        Examples:
            Initialization - Start each example below with this setup:
            ```
            from plotly.widgets import GraphWidget
            from IPython.display import display

            graph = GraphWidget('https://plot.ly/~chris/3979')
            display(graph)
            ```

            Example 1 - Apply a label to the (x, y) point (3, 2)
            ```
            graph.hover({'xval': 3, 'yval': 2, 'hovermode': 'closest'})
            ```

            Example 2 -Apply a labels to all the points with the x coordinate 3
            ```
            graph.hover({'xval': 3, 'hovermode': 'x'})
            ```

            Example 3 - Apply a label to the first point of the first trace
                        and the second point of the second trace.
            ```
            graph.hover({'curveNumber': 0, 'pointNumber': 0},
                        {'curveNumber': 1, 'pointNumber': 1})
            ```
         N/A N/A N/A len hover_objs 1 N/A N/A hover_objs N/A hover_objs N/A 0 N/A message N/A task selection graphId hover hover_objs N/A self _graphId N/A N/A N/A self _handle_outgoing_message message N/A add_traces N/A N/A self traces new_indices N/A None N/A N/A  Add new data traces to a graph.

        If `new_indices` isn't specified, they are simply appended.

        Args:
            traces (dict or list of dicts, or class of plotly.graph_objs):trace
            new_indices (list[int]|None), optional: The final indices the
                added traces should occupy in the graph.

        Examples:
            Initialization - Start each example below with this setup:
            ```
            from plotly.widgets import GraphWidget
            from plotly.graph_objs import Scatter
            from IPython.display import display

            graph = GraphWidget('https://plot.ly/~chris/3979')
            display(graph)
            ```

            Example 1 - Add a scatter/line trace to the graph
            ```
            graph.add_traces(Scatter(x = [1, 2, 3], y = [5, 4, 5]))
            ```

            Example 2 - Add a scatter trace and set it to to be the
                        second trace. This will appear as the second
                        item in the legend.
            ```
            graph.add_traces(Scatter(x = [1, 2, 3], y = [5, 6, 5]),
                             new_indices=[1])
            ```

            Example 3 - Add multiple traces to the graph
            ```
            graph.add_traces([
                Scatter(x = [1, 2, 3], y = [5, 6, 5]),
                Scatter(x = [1, 2.5, 3], y = [5, 8, 5])
            ])
            ```
         N/A message N/A task traces graphId addTraces traces N/A self _graphId N/A N/A new_indices None N/A N/A N/A message N/A newIndices new_indices N/A N/A N/A self _handle_outgoing_message message N/A delete_traces N/A N/A self indices N/A N/A N/A Delete data traces from a graph.

        Args:
            indices (list[int]): The indices of the traces to be removed

        Example - Delete the 2nd trace:
            ```
            from plotly.widgets import GraphWidget
            from IPython.display import display

            graph = GraphWidget('https://plot.ly/~chris/3979')
            display(graph)


            graph.delete_traces([1])
            ```

         N/A message N/A task indices graphId deleteTraces indices N/A self _graphId N/A N/A N/A self _handle_outgoing_message message N/A reorder_traces N/A N/A self current_indices new_indices N/A None N/A N/A Reorder the traces in a graph.

        The order of the traces determines the order of the legend entries
        and the layering of the objects drawn in the graph, i.e. the first
        trace is drawn first and the second trace is drawn on top of the
        first trace.

        Args:
            current_indices (list[int]): The index of the traces to reorder.

            new_indices (list[int], optional): The index of the traces
                specified by `current_indices` after ordering.
                If None, then move the traces to the end.

        Examples:
            Example 1 - Move the first trace to the second to last
                position, the second trace to the last position
            ```
            graph.move_traces([0, 1])
            ```

            Example 2 - Move the first trace to the second position,
                the second trace to the first position.
            ```
            graph.move_traces([0], [1])
            ```
         N/A message N/A task currentIndices graphId moveTraces current_indices N/A self _graphId N/A N/A new_indices None N/A N/A N/A message N/A newIndices new_indices N/A N/A N/A self _handle_outgoing_message message N/A save N/A N/A self ignore_defaults filename N/A False N/A N/A 
        Save a copy of the current state of the widget in plotly.

        :param (bool) ignore_defaults: Auto-fill in unspecified figure keys?
        :param (str) filename: Name of the file on plotly.

         N/A N/A N/A self _flags N/A save_pending True N/A N/A self _filename filename N/A message N/A task ignoreDefaults getAttributes ignore_defaults N/A N/A N/A self _handle_outgoing_message message N/A N/A N/A self _fade_to slow 0.1 N/A extend_traces N/A N/A self update indices max_points N/A N/A 0 None N/A N/A  Append data points to existing traces in the Plotly graph.

        Args:
            update (dict):
                dict where keys are the graph attribute strings
                and values are arrays of arrays with values to extend.

                Each array in the array will extend a trace.

                Valid keys include:
                    'x', 'y', 'text,
                    'marker.color', 'marker.size', 'marker.symbol',
                    'marker.line.color', 'marker.line.width'

            indices (list, int):
                Specify which traces to apply the `update` dict to.
                If indices are not given, the update will apply to
                the traces in order.

            max_points (int or dict, optional):
                If specified, then only show the `max_points` most
                recent points in the graph.
                This is useful to prevent traces from becoming too
                large (and slow) or for creating "windowed" graphs
                in monitoring applications.

                To set max_points to different values for each trace
                or attribute, set max_points to a dict mapping keys
                to max_points values. See the examples below.

            Examples:
                Initialization - Start each example below with this setup:
                ```
                from plotly.widgets import GraphWidget
                from IPython.display import display

                graph = GraphWidget()
                graph.plot([
                    {'x': [], 'y': []},
                    {'x': [], 'y': []}
                ])

                display(graph)
                ```

                Example 1 - Extend the first trace with x and y data
                ```
                graph.extend_traces({'x': [[1, 2, 3]], 'y': [[10, 20, 30]]},
                                    indices=[0])
                ```

                Example 2 - Extend the second trace with x and y data
                ```
                graph.extend_traces({'x': [[1, 2, 3]], 'y': [[10, 20, 30]]},
                                    indices=[1])
                ```

                Example 3 - Extend the first two traces with x and y data
                ```
                graph.extend_traces({
                    'x': [[1, 2, 3], [2, 3, 4]],
                    'y': [[10, 20, 30], [3, 4, 3]]
                }, indices=[0, 1])
                ```

                Example 4 - Extend the first trace with x and y data and
                            limit the length of data in that trace to 50
                            points.
                ```

                graph.extend_traces({
                    'x': [range(100)],
                    'y': [range(100)]
                }, indices=[0, 1], max_points=50)
                ```

                Example 5 - Extend the first and second trace with x and y data
                            and limit the length of data in the first trace to
                            25 points and the second trace to 50 points.
                ```
                new_points = range(100)
                graph.extend_traces({
                        'x': [new_points, new_points],
                        'y': [new_points, new_points]
                    },
                    indices=[0, 1],
                    max_points={
                        'x': [25, 50],
                        'y': [25, 50]
                    }
                )
                ```

                Example 6 - Update other attributes, like marker colors and
                            sizes and text
                ```
                # Initialize a plot with some empty attributes
                graph.plot([{
                    'x': [],
                    'y': [],
                    'text': [],
                    'marker': {
                        'size': [],
                        'color': []
                    }
                }])
                # Append some data into those attributes
                graph.extend_traces({
                    'x': [[1, 2, 3]],
                    'y': [[10, 20, 30]],
                    'text': [['A', 'B', 'C']],
                    'marker.size': [[10, 15, 20]],
                    'marker.color': [['blue', 'red', 'orange']]
                }, indices=[0])
                ```

                Example 7 - Live-update a graph over a few seconds
                ```
                import time

                graph.plot([{'x': [], 'y': []}])
                for i in range(10):
                    graph.extend_traces({
                        'x': [[i]],
                        'y': [[i]]
                    }, indices=[0])

                    time.sleep(0.5)
                ```

         N/A message N/A task update graphId indices extendTraces update N/A self _graphId indices N/A N/A max_points None N/A N/A N/A message N/A maxPoints max_points N/A N/A N/A self _handle_outgoing_message message N/A _fade_to N/A N/A self duration opacity N/A N/A N/A 
        Change the opacity to give a visual signal to users.

         N/A message N/A fadeTo duration opacity True duration opacity N/A N/A N/A self _handle_outgoing_message message N/A N/A