code: def test_predict_triplot_class(self):
      pt = PredictTriplot(sample_method="binom")
      pt2 = PredictTriplot(type="shap")
      pt.fit(self.aspect, self.X.iloc[12])
      pt2.fit(self.aspect2, self.X.iloc[12])
  
      self.assertIsInstance(pt, dx.aspect.PredictTriplot)
      self.assertIsInstance(pt2, dx.aspect.PredictTriplot)
  
      self.assertIsInstance(pt.result, pd.DataFrame)
      self.assertIsInstance(pt2.result, pd.DataFrame)
  
      self.assertEqual(
          set(pt.result.columns),
          set(
              [
                  "variable_names",
                  "variable_values",
                  "importance",
                  "min_depend",
                  "vars_min_depend",
                  "label",
              ]
          ),
      )
      self.assertEqual(
          set(pt2.result.columns),
          set(
              [
                  "variable_names",
                  "variable_values",
                  "importance",
                  "min_depend",
                  "vars_min_depend",
                  "label",
              ]
          ),
      )
  
      self.assertGreaterEqual(1, pt.result.min_depend.max())
      self.assertGreaterEqual(1, pt2.result.min_depend.max())
  
      self.assertGreaterEqual(pt.result.min_depend.min(), 0)
      self.assertGreaterEqual(pt2.result.min_depend.min(), 0)
  
      self.assertEqual(
          set(pt.result["variable_names"].iloc[-1]),
          set(self.X.columns),
      )
      self.assertEqual(
          set(pt2.result["variable_names"].iloc[-1]),
          set(self.X.columns),
      )
  
      for i in range(len(pt.result)):
          self.assertTrue(
              len(pt.result.loc[i, "variable_values"])
              == len(pt.result.loc[i, "variable_names"])
          )
          self.assertTrue(
              set(pt.result.loc[i, "vars_min_depend"]).issubset(
                  set(pt.result.loc[i, "variable_names"])
              )
          )
      for i in range(len(pt2.result)):
          self.assertTrue(
              [
                  len(pt2.result.loc[i, "variable_values"])
                  == len(pt2.result.loc[i, "variable_names"])
              ]
          )
          self.assertTrue(
              set(pt.result.loc[i, "vars_min_depend"]).issubset(
                  set(pt.result.loc[i, "variable_names"])
              )
          )
  
      fig = pt.plot(show=False)
      self.assertIsInstance(fig, Figure)
      fig2 = pt2.plot(show=False)
      self.assertIsInstance(fig2, Figure)
      fig3 = pt.plot(
          show=False, absolute_value=True, width=1200, abbrev_labels=6
      )
      self.assertIsInstance(fig3, Figure)
      fig4 = pt.plot(
          show=False,
          absolute_value=True,
          width=1200,
          abbrev_labels=6,
          widget=True,
      )
      self.assertIsInstance(fig4, HBox)
      fig5 = pt.plot(
          show=False,
          bar_width=22,
          width=1200,
          abbrev_labels=6,
          title="Test",
      )
      self.assertIsInstance(fig5, Figure)
      fig6 = pt.plot(
          show=False,
          bar_width=22,
          width=1200,
          abbrev_labels=6,
          title="Test",
          widget=True,
      )
      self.assertIsInstance(fig6, HBox)
      fig7 = pt.plot(
          show=False,
          absolute_value=True,
          digits=2,
          bar_width=22,
          width=1200,
          abbrev_labels=6,
          title="Test",
          widget=True,
      )
      self.assertIsInstance(fig7, HBox)
  
imports: import unittest
  import numpy
  import pandas
  from plotly.graph_objs import Figure
  from ipywidgets.widgets.widget_box import HBox
  from sklearn.compose import ColumnTransformer
  from sklearn.impute import SimpleImputer
  from sklearn.neural_network import MLPClassifier
  from sklearn.pipeline import Pipeline
  from sklearn.preprocessing import StandardScaler, LabelEncoder, OneHotEncoder
  from sklearn.ensemble import RandomForestRegressor
  from traitlets.traitlets import Dict
  import dalex
  from dalex.model_explanations._variable_importance.loss_functions import *
  from dalex.aspect._predict_aspect_importance.object import PredictAspectImportance
  from dalex.aspect._model_triplot.object import ModelTriplot
  from dalex.aspect._predict_triplot.object import PredictTriplot
  from dalex.aspect._model_aspect_importance.object import ModelAspectImportance
label_desc: Use image node_id 8 for calling the AspectTestTitanic obj's underlying member method code with example usage: obj.test_predict_triplot_class() without return types