code: def plot_comparisons(
      model: Model,
      idata: az.InferenceData,
      contrast: Union[str, dict, list],
      conditional: Union[str, dict, list, None] = None,
      average_by: Union[str, list, None] = None,
      comparison_type: str = "diff",
      sample_new_groups: bool = False,
      use_hdi: bool = True,
      prob=None,
      legend: bool = True,
      transforms=None,
      ax=None,
      fig_kwargs=None,
      subplot_kwargs=None,
  ):
      """Plot Conditional Adjusted Comparisons
  
      Parameters
      ----------
      model : bambi.Model
          The model for which we want to plot the predictions.
      idata : arviz.InferenceData
          The InferenceData object that contains the samples from the posterior distribution of
          the model.
      contrast : str, dict, list
          The predictor name whose contrast we would like to compare.
      conditional : str, dict, list
          The covariates we would like to condition on. If dict, keys are the covariate names and
          values are the values to condition on.
      average_by: str, list, optional
          The covariates we would like to average by. The passed covariate(s) will marginalize
          over the other covariates in the model. Defaults to ``None``.
      comparison_type : str, optional
          The type of comparison to plot. Defaults to 'diff'.
      sample_new_groups : bool, optional
          If the model contains group-level effects, and data is passed for unseen groups, whether
          to sample from the new groups. Defaults to ``False``.
      use_hdi : bool, optional
          Whether to compute the highest density interval (defaults to True) or the quantiles.
      prob : float, optional
          The probability for the credibility intervals. Must be between 0 and 1. Defaults to 0.94.
          Changing the global variable ``az.rcParam["stats.hdi_prob"]`` affects this default.
      legend : bool, optional
          Whether to automatically include a legend in the plot. Defaults to ``True``.
      transforms : dict, optional
          Transformations that are applied to each of the variables being plotted. The keys are the
          name of the variables, and the values are functions to be applied. Defaults to ``None``.
      ax : matplotlib.axes._subplots.AxesSubplot, optional
          A matplotlib axes object or a sequence of them. If None, this function instantiates a
          new axes object. Defaults to ``None``.
      fig_kwargs : optional
          Keyword arguments passed to the matplotlib figure function as a dict. For example,
          ``fig_kwargs=dict(figsize=(11, 8)), sharey=True`` would make the figure 11 inches wide
          by 8 inches high and would share the y-axis values.
      subplot_kwargs : optional
          Keyword arguments used to determine the covariates used for the horizontal, group,
          and panel axes. For example, ``subplot_kwargs=dict(main="x", group="y", panel="z")`` would
          plot the horizontal axis as ``x``, the color (hue) as ``y``, and the panel axis as ``z``.
  
      Returns
      -------
      matplotlib.figure.Figure, matplotlib.axes._subplots.AxesSubplot
          A tuple with the figure and the axes.
  
      Raises
      ------
      ValueError
          If the number of contrast levels is greater than 2 and ``average_by`` is ``None``.
          If ``conditional`` and ``average_by`` are both ``None``.
          If length of ``conditional`` is greater than 3 and ``average_by`` is ``None``.
          If ``average_by`` is ``True``.
          If main covariate is not numeric or categoric.
      """
      contrast_name = contrast
      if isinstance(contrast, dict):
          contrast_name, contrast_levels = next(iter(contrast.items()))
          if len(contrast_levels) > 2 and average_by is None:
              raise ValueError(
                  "When plotting with more than 2 values for 'contrast', you must "
                  "pass a covariate to 'average_by'. "
                  f"{contrast_name} has {len(contrast_levels)} values."
              )
  
      if not isinstance(contrast, dict):
          if is_categorical_dtype(
              model.data[contrast_name]
          ) or is_string_dtype(model.data[contrast_name]):
              contrast_levels = len(model.data[contrast_name].unique())
              if contrast_levels > 2 and average_by is None:
                  raise ValueError(
                      "When plotting with more than 2 values for 'contrast', you must "
                      f"pass a covariate to 'average_by'. {contrast_name} has "
                      f"{contrast_levels} values."
                  )
  
      if conditional is None and average_by is None:
          raise ValueError(
              "Must specify at least one of 'conditional' or 'average_by'."
          )
  
      if conditional is not None and not isinstance(conditional, dict):
          conditional = listify(conditional)
          if len(conditional) > 3 and average_by is None:
              raise ValueError(
                  "Must specify a covariate to 'average_by' when number of covariates"
                  "passed to 'conditional' is greater than 3."
              )
  
      if average_by is True:
          raise ValueError(
              "Plotting when 'average_by = True' is not possible as 'True' marginalizes "
              "over all covariates resulting in a single prediction estimate. "
              "Please pass a covariate(s) to 'average_by'."
          )
  
      conditional_info = ConditionalInfo(model, conditional)
  
      contrast_summary = comparisons(
          model=model,
          idata=idata,
          contrast=contrast,
          conditional=conditional,
          average_by=average_by,
          comparison_type=comparison_type,
          use_hdi=use_hdi,
          prob=prob,
          transforms=transforms,
          sample_new_groups=sample_new_groups,
      )
  
      return _plot_differences(
          model=model,
          conditional_info=conditional_info,
          summary_df=contrast_summary,
          average_by=average_by,
          transforms=transforms,
          legend=legend,
          ax=ax,
          fig_kwargs=fig_kwargs,
          subplot_kwargs=subplot_kwargs,
      )
  
file_path: bambi/bambi/interpret/plotting.py
imports: from typing import Union
  import arviz
  from arviz.plots.backends.matplotlib import create_axes_grid
  from arviz.plots.plot_utils import default_grid
  import numpy
  import pandas
  from pandas.api.types import is_categorical_dtype, is_numeric_dtype, is_string_dtype
  from bambi.models import Model
  from bambi.interpret.effects import comparisons, slopes, predictions
  from bambi.interpret.plot_types import plot_categoric, plot_numeric
  from bambi.interpret.utils import get_covariates, ConditionalInfo
  from bambi.utils import get_aliased_name, listify
label_desc: Use image node_id 3 for calling a global function with example usage: plot_comparisons(model, idata, contrast, conditional, average_by, comparison_type, sample_new_groups, use_hdi, prob, legend, transforms, ax, fig_kwargs, subplot_kwargs) and returns: _plot_differences