class GeneralDiagnosticToolOutline:

    def __init__(self, idata: az.InferenceData) -> None:
        """We convert the Bean Machine MonteCarloSamples object to an ArviZ
        InferenceData object when we add accessor capabilities to MCS objects. This is
        why the __init__ takes an InferenceData object and not a MonteCarloSamples
        object.

        We also compute some standard values from the model like the number of chains
        and draws in the model. We also set the HDI probability here for some tools,
        which is defined by the rcParams in ArviZ.

        The widgets used in all the tools require string representations of the
        RVIdentifiers, which is why there are typically a list of rv_names and
        rv_identifiers in each tool. We use these to determine how to select data from
        the idata object, since the idata object uses RVIdentifiers as keys, and not
        their string representations.
        """
        self.idata = idata
        self.rv_identifiers = list(self.idata["posterior"].data_vars)
        self.rv_names = [str(rv_identifier) for rv_identifier in self.rv_identifiers]
        self.num_chains = self.idata["posterior"].dims["chain"]
        self.num_draws_single_chain = self.idata["posterior"].dims["draw"]
        self.num_draws_all_chains = self.num_chains * self.num_draws_single_chain
        self.hdi_prob = az.rcParams["stats.hdi_prob"]
        ...

    def compute(self, rv_name: str, **kwargs) -> Dict:
        """Compute data for the tool using ArviZ. The compute function returns some form
        of a dictionary that is used by other methods. Different tools will have
        different dictionary objects, but all will return a JSON serializable object.

        Depending on which tool the compute method is in will determine other keyword
        arguments that are passed to the method. All methods take a single random
        variable string representation except for the 2D marginal tool, which requires 2
        RV names.
        """
        rv_identifier = self.rv_identifiers[self.rv_names.index(rv_name)]
        data = self.idata["posterior"][rv_identifier].values
        ...

    def create_sources(self, rv_name: str, **kwargs) -> Dict:
        """Create Bokeh ColumnDataSource objects. Here we again ask for the Bean Machine
        RVIdentifier string representation so that we can compute the data associated
        for the RV in the tool. No caching of data is done, and every time a user
        changes the RV shown in the tool, the data is recomputed. This method creates
        the objects that Bokeh consumes for displaying data in the tool. The output is
        again a dictionary, where the keys are sometimes chain labels and sometimes
        different glyphs to be drawn in the figures.
        """
        data = self.compute(rv_name=rv_name, **kwargs)
        ...

    def create_figures(self, rv_name: str) -> Dict | Figure:
        """Create Bokeh figures. Here we create empty figures that have no data in them.
        All figures are styled in the same way, and the method returns either a
        dictionary of figure objects, or a single figure dependent on the tool being
        displayed.
        """
        fig = figure(...)
        utils.style_figure(fig)
        ...

    def create_glyphs(self) -> Dict:
        """Create Bokeh Glyph objects that will be bound to figures when data is bound
        to the glyph.

        It may seem odd to create empty glyphs with no data attached to them, and this
        may change with newer version of Bokeh, but it was done for debugging purposes
        when creating the tools as there is a well defined differentiation between what
        a glyph is, and what other components of a figure are (see the annotations
        method). If this layer of abstraction is found to be too complex, then we can
        change it such that glyphs are drawn directly on figures with data attached to
        them.

        All tools use the same palette for colors, which is the color blind palette
        found in Bokeh. This was chosen for accessibility reasons. We can update it such
        that a user can choose a palette if they so wish, but I think defaulting to the
        most accessible color palette available is a good first option.
        """
        palette = utils.choose_palette(self.num_chains)
        ...

    def create_annotations(self, figs: Dict[str, Figure], rv_name: str) -> Dict | Annotation:
        """Create Bokeh Annotation objects.

        Annotations are things like spans, shaded regions, legends, or text on a figure.
        Most methods in the various tools that have a create_annotations method return a
        dictionary where the key is the figure name and the value is the annotation
        drawn on the figure. Glyphs and annotations need to be redrawn as a user
        interacts with the tool so these are updated with different callbacks defined
        below.

        Again, depending on the tool the parameters will either be a dictionary of
        figures or a single figure.
        """
        ...

    def add_tools(self, figs: Dict[str, Figure]) -> None:
        """Add Bokeh HoverTool objects to the figures.

        This method directly manipulates a figure by adding hover tools to it. In order
        to add hover tools, data has to be bound to a glyph or annotation, and the glyph
        or annotation must be bound to a figure. The values displayed by the hover tools
        are defined in the Bokeh ColumnDataSource objects defined above.
        """
        ...

    def update_figure(self, rv_name: str, old_sources: Dict, figs: Dict, **kwargs) -> None:
        """Update the figures in the tool.

        This is the main worker for the callbacks. Here we update the Bokeh
        ColumnDataSource objects with new data, which is computed using the compute
        method. Each tool updates itself differently, but the general rule of thumb here
        is that each widget and figure is updated on user interaction.
        """
        ...

    def help_page(self) -> Div:
        """Here is where we create the prose for the help tab found in all the tools.
        Most of the prose has been culled from tutorials that have repeated descriptions
        about diagnostics etc.
        """
        text = """"""
        div = Div(text=text, disable_math=False)
        return div

    def modify_doc(self, doc) -> None:
        """This is the essential piece to the Bokeh app as it is where we create Bokeh
        sources, create figures, glyphs, annotations, attach tools to the figures,
        create widgets, and callbacks for the widgets.

        Most steps below occur for each of the tools. Differences arise when we have to
        handle callbacks differently, or we need to recall a previous bandwidth value.
        """
        # Set the initial view.
        rv_name = self.rv_names[0]

        # Create data source(s) for the figure(s).
        sources = self.create_sources(rv_name)

        # Create the figure(s).
        figs = self.create_figures(rv_name)

        # Create glyphs and add them to the figure(s).
        glyphs = self.create_glyphs()

        # Create annotations for the figure(s) and add them to their appropriate figure.
        annotations = self.create_annotations(figs=figs, rv_name=rv_name)

        # Create tooltips for the figure(s).
        self.add_tools(figs=figs)

        # Create the widget(s).
        rv_select = Select(title="Query", value=rv_name, options=self.rv_names)
        bw_slider = Slider(...)

        # Callbacks for the widget(s).
        def update_rv(attr, old, new):
            """All tools have this widget as each tool displays visual diagnostics for
            the chosen random variable.
            """
            self.update_figure(rv_name=new, old_sources=sources, figs=figs, **kwargs)
            # Update other widgets if they exist in the tool.

        def update_bw(attr, old, new):
            # Callback for a different widget, as an example of multiple widgets in the
            # tool.
            ...

        # NOTE: Here is where we listen for changes to the widgets. When a user changes
        #       the value of a widget, then the change triggers the callback, and in
        #       some cases triggers the update_figure() method defined above. It just
        #       depends on the widget and the tool.
        rv_select.on_change("value", update_rv)
        bw_slider.on_change("value", update_bw)
        # NOTE: We are using Bokeh's CustomJS model in order to reset the ranges of the
        #       figures. This is an odd quirk of a Bokeh app. If a user changes the view
        #       port of a figure and then changes the RV being displayed, then Bokeh
        #       sometimes will not reset the figure ranges in order to accommodate the
        #       new data. This is a work-around that fixes this issue, and is present in
        #       all the tools that need their figures reset due to user interactions.
        rv_select.js_on_change(
            "value",
            CustomJS(args={fig}, code=("fig.reset.emit();\n")),
        )

        # Add widgets and figures to tabs, and then add them to a tool layout.
        # Here we define the data to be shown in the tool's tabs, and the layout of the
        # tool itself. Once the layout has been created, we add it to the doc that the
        # Bokeh app is in.
        tab = Panel(child=figs, title="tool tab")
        layout = column(...)
        tool_panel = Panel(child=_layout, title="tool")
        help_panel = Panel(child=self.help_page(), title="Help")
        tabs = Tabs(tabs=[tool_panel, help_panel])
        doc.add_root(tabs)

    def show_widget(self) -> None:
        """Display the widget. This is just syntactic sugar. A more appropriate name for
        it could be display_tool. Its main use was for debugging, and to have all Bokeh
        apps have the same API output.
        """
        show(self.modify_doc)