code: def dash(self, df, mode):
      y_variable = self.y_variable
      g = plotly_graphs()
      ca = cohortAnalysis()
      y_variables = [col for col in df.columns if "_impact" in col]
      original_variables = [
          col for col in df.columns if not "_impact" in col
      ]
      original_variables = [
          col for col in original_variables if not "_rescaled" in col
      ]
      array = []
      PAGE_SIZE = 10
      row_number = 1
      # y_variable = "predict"
      columns = ["index", "0", "1", "2", "3", "4"]
      dat = []
  
      available_columns = list(df.columns)
  
      # external_stylesheets = [dbc.themes.BOOTSTRAP,
      #                         # {
      #                         #     'href': 'https://stackpath.bootstrapcdn.com/bootstrap/4.5.0/css/bootstrap.min.css',
      #                         #     'rel': 'stylesheet'
      #                         # }
      #                         ]
  
      # app = JupyterDash(__name__, external_stylesheets=external_stylesheets)
  
      app.title = "explainX.ai - Main Dashboard"
  
      PLOTLY_LOGO = "https://i.ibb.co/ZTWtVDV/explainx-logo.png"
  
      menu = dbc.Row(
          [
              dbc.Col(
                  dbc.NavItem(dbc.NavLink("Home", href="/apps/")),
                  style={"width": "150px", "fontSize": "10px"},
              ),
              dbc.Col(
                  dbc.NavItem(
                      dbc.NavLink(
                          "Global Explanation",
                          href="/apps/global_explanation",
                      )
                  ),
                  style={"width": "150px", "fontSize": "10px"},
              ),
              dbc.Col(
                  dbc.NavItem(
                      dbc.NavLink(
                          "Local Explanation",
                          href="/apps/local_explanation",
                      )
                  ),
                  style={"width": "150px", "fontSize": "10px"},
              ),
              dbc.Col(
                  dbc.NavItem(
                      dbc.NavLink(
                          "Feature Interaction",
                          href="/apps/feature_interaction",
                      )
                  ),
                  style={"width": "150px", "fontSize": "10px"},
              ),
              dbc.Col(
                  dbc.NavItem(
                      dbc.NavLink(
                          "Distributions", href="/apps/distribution"
                      )
                  ),
                  style={"width": "150px", "fontSize": "10px"},
              ),
              dbc.Col(
                  dbc.NavItem(
                      dbc.NavLink(
                          "Cohort Analysis", href="/apps/cohort"
                      )
                  ),
                  style={"width": "150px", "fontSize": "10px"},
              ),
          ],
          no_gutters=True,
          className="ml-auto flex-nowrap mt-3 mt-md-0",
          align="center",
      )
  
      navbar = dbc.Navbar(
          [
              html.A(
                  # Use row and col to control vertical alignment of logo / brand
                  dbc.Row(
                      [
                          dbc.Col(
                              html.Img(src=PLOTLY_LOGO, height="30px")
                          ),
                          dbc.Col(
                              dbc.NavbarBrand(
                                  "explainX.ai",
                                  className="ml-2",
                                  style={
                                      "fontSize": "15px",
                                      "color": "black",
                                  },
                              )
                          ),
                      ],
                      align="center",
                      no_gutters=True,
                  ),
                  href="https://www.explainx.ai",
              ),
              dbc.NavbarToggler(id="navbar-toggler"),
              dbc.Collapse(menu, id="navbar-collapse", navbar=True),
          ],
          color="light",
          dark=True,
      )
  
      # add callback for toggling the collapse on small screens
      @app.callback(
          Output("navbar-collapse", "is_open"),
          [Input("navbar-toggler", "n_clicks")],
          [State("navbar-collapse", "is_open")],
      )
      def toggle_navbar_collapse(n, is_open):
          if n:
              return not is_open
          return is_open
  
      @app.callback(
          Output("page-content", "children"), [Input("url", "pathname")]
      )
      def display_page(pathname):
          if pathname == "/apps/global_explanation":
              return global_explanation.global_explanation(
                  original_variables
              )
          elif pathname == "/apps/feature_interaction":
              return feature_interaction.layout_interaction(
                  original_variables, y_variables
              )
          elif pathname == "/apps/distribution":
              return distribution.layout_distribution(
                  original_variables
              )
          elif pathname == "/apps/local_explanation":
              return local_explanation.layout_local(
                  original_variables, columns, df.columns
              )
          elif pathname == "/apps/cohort":
              return cohort.cohort_layout(original_variables)
          else:
              return welcome_message
  
      welcome_message = html.Div(
          [
              html.Div(
                  [
                      html.H3(
                          "Welcome to ExplainX.ai Explainable AI Dashboard"
                      ),
                      html.H4(
                          "Start explaining your model by exploring one of the following options."
                      ),
                  ],
                  style={"margin-left": "20px"},
              ),
              html.Div(
                  [
                      html.Div(
                          [
                              html.Img(
                                  src="https://lh3.googleusercontent.com/uNkpoLQRIza6SSDk9fQed6bu6c1Q9zDkDjZqkRtF3cU97Smf2rS0soKo2ZQm32gJe8FyLYvNRUYJ-hqM7zs4esIAFchdPmgC4sHgbpxTKkGjm4dRK-NagI56K8vnXg8FH4s_Jct2RaQ",
                                  className="global_explanation_image",
                              ),
                              dcc.Link(
                                  "Global Explanation",
                                  href="/apps/global_explanation",
                                  className="link",
                              ),
                          ],
                          className="welcome_box",
                          id="global_explanation_deets",
                      ),
                      html.Div(
                          [
                              html.Img(
                                  src="https://lh3.googleusercontent.com/LpM-N2QavBVxlMW6vKm5fmT5Qe3mYtI2q2OQc5kgZfW4kKOFlyidgrwT5C9zB3XHZncHvlGcFl82Si7bMDQN_PtLf4PThqdEUs1UwoUPeNHs0VYY6ICKlHi44ppZLZIMQvaWI4bMqm0",
                                  className="global_explanation_image",
                              ),
                              dcc.Link(
                                  "Local Level Explanation",
                                  href="/apps/local_explanation",
                                  className="link",
                              ),
                          ],
                          className="welcome_box",
                          id="local_explanation_deets",
                      ),
                      html.Div(
                          [
                              html.Img(
                                  src="https://lh6.googleusercontent.com/GXnNtGlqQcsRXugwwlZ31SwrJda4Z1WVyIi5i13vZImrUY6YgIZvM81d7zrBOh8n2jK_Lqj3BB5IqS4dU5l680-rZuu40bMXa-EAd8ag3WDIU2SNYieg0DH3e_FwUq5f2-y-X_POE-k",
                                  className="global_explanation_image",
                              ),
                              dcc.Link(
                                  "Feature Interactions",
                                  href="/apps/feature_interaction",
                                  className="link",
                              ),
                          ],
                          className="welcome_box",
                          id="feature_interaction_deets",
                      ),
                      html.Div(
                          [
                              html.Img(
                                  src="https://uploads-ssl.webflow.com/5edc18e72f7ba21e1ed2efae/5f519fd99580494301e67b7b_pipeline.png",
                                  className="global_explanation_image",
                              ),
                              dcc.Link(
                                  "Cohort Analysis",
                                  href="/apps/cohort",
                                  className="link",
                              ),
                          ],
                          className="welcome_box",
                          id="cohort_analysis_deets",
                      ),
                  ],
                  className="main_welcome_div",
              ),
          ]
      )
      app.layout = html.Div(
          [
              navbar,
              html.Div(
                  [
                      dbc.Card(
                          [
                              dbc.CardHeader(
                                  html.H2(
                                      dbc.Button(
                                          "Analyze using SQL",
                                          id="collapse-button-2",
                                          color="link",
                                          style={
                                              "fontSize": "10px",
                                              "margin-top": "0px",
                                          },
                                      ),
                                      style={"margin-top": "0px"},
                                  ),
                                  style={"height": "50px"},
                              ),
                              dbc.Collapse(
                                  html.Div(
                                      [
                                          html.Div(
                                              dcc.Input(
                                                  id="input-on-submit",
                                                  type="text",
                                                  # placeholder="SELECT * FROM df"
                                                  value="SELECT * FROM df",
                                                  style={
                                                      "height": "200px",
                                                      "width": "700px",
                                                      "fontSize": "10px",
                                                  },
                                              )
                                          ),
                                          html.Button(
                                              "Execute Query",
                                              id="submit-val",
                                              n_clicks=1,
                                          ),
                                          html.Div(
                                              id="sql-query-button",
                                              children="Enter a value and press submit",
                                              style={"display": "none"},
                                          ),
                                      ],
                                      style={"marginTop": 0},
                                  ),
                                  id="collapse-2",
                              ),
                          ]
                      ),
                  ],
                  style=style4,
              ),
              html.Div(
                  [
                      dbc.Card(
                          [
                              dbc.CardHeader(
                                  html.H2(
                                      dbc.Button(
                                          "View Your Data",
                                          id="collapse-button",
                                          color="link",
                                          style={"fontSize": "10px"},
                                      ),
                                      style={"margin-top": "0px"},
                                  ),
                                  style={"height": "50px"},
                              ),
                              dbc.Collapse(
                                  html.Div(
                                      [
                                          html.H4("", style=style1),
                                          html.Div(
                                              [
                                                  dash_table.DataTable(
                                                      id="datatable-interactivity",
                                                      columns=[
                                                          {
                                                              "name": i,
                                                              "id": i,
                                                              "deletable": False,
                                                              "selectable": True,
                                                          }
                                                          for i in df.columns
                                                      ],
                                                      # data=df.to_dict('records'),
                                                      editable=True,
                                                      sort_mode="multi",
                                                      # selected_columns=[],
                                                      # selected_rows=[],
                                                      # page_action="native",
                                                      page_current=0,
                                                      page_size=PAGE_SIZE,
                                                      row_selectable="multi",
                                                      page_action="custom",
                                                      style_table=style2,
                                                      style_header=style3,
                                                      style_cell={
                                                          "font-family": "Helvetica, Arial, sans-serif",
                                                          "fontSize": "11px",
                                                          "width": "{}%".format(
                                                              len(
                                                                  df.columns
                                                              )
                                                          ),
                                                          "textOverflow": "ellipsis",
                                                          "overflow": "hidden",
                                                          "textAlign": "left",
                                                          "minWidth": "180px",
                                                          "width": "180px",
                                                          "maxWidth": "180px",
                                                      },
                                                      css=[
                                                          {
                                                              "selector": ".dash-spreadsheet td div",
                                                              "rule": """
                                      line-height: 15px;
                                      max-height: 20px; min-height: 20px; height: 20px;
                                      display: block;
                                      overflow-y: hidden;
  
                                  """,
                                                          }
                                                      ],
                                                  )
                                              ]
                                          ),
                                      ],
                                      style={"marginTop": 0},
                                  ),
                                  id="collapse",
                              ),
                          ]
                      ),
                  ],
                  style=style4,
              ),
              # Pages Data
              html.Div(
                  [
                      dcc.Location(id="url", refresh=False),
                      html.Div(id="page-content"),
                  ]
              )
              # end of collapsable div
          ],
          className="main_div",
      )
  
      # Navigation
  
      # Data Interactivity
      @app.callback(
          Output("datatable-interactivity", "data"),
          [
              Input("datatable-interactivity", "page_current"),
              Input("datatable-interactivity", "page_size"),
          ],
      )
      def update_table(page_current, page_size):
          return df.iloc[
              page_current * page_size : (page_current + 1) * page_size
          ].to_dict("records")
  
      # Collapse-Toggle
      @app.callback(
          Output("collapse", "is_open"),
          [Input("collapse-button", "n_clicks")],
          [State("collapse", "is_open")],
      )
      def toggle_collapse(n, is_open):
          if n:
              return not is_open
          return is_open
  
      # Collapse-Toggle 2
      @app.callback(
          Output("collapse-2", "is_open"),
          [Input("collapse-button-2", "n_clicks")],
          [State("collapse-2", "is_open")],
      )
      def toggle_collapse(n, is_open):
          if n:
              return not is_open
          return is_open
  
      # Cohort Analysis - Callbacks
      @app.callback(
          Output("modal", "is_open"),
          [Input("open", "n_clicks"), Input("close", "n_clicks")],
          [State("modal", "is_open")],
          prevent_initial_call=True,
      )
      def toggle_modal(n1, n2, is_open):
          if n1 or n2:
              return not is_open
          return is_open
  
      @app.callback(
          [
              Output("cohort-metrics-div", "children"),
              Output("cohort-details", "children"),
              Output("cohort-graph", "children"),
          ],
          [
              Input("add-cohort", "n_clicks"),
              Input("remove-cohort", "n_clicks"),
              Input("x-axis", "value"),
          ],
          [
              State("demo-dropdown", "value"),
              State("demo-operators", "value"),
              State("demo-values", "value"),
          ],
      )
      def cohort_metrics_details(
          add_cohort, remove_cohort, x_axis, var_name, operator, value
      ):
          changed_id = [
              p["prop_id"] for p in dash.callback_context.triggered
          ][0]
          if "remove-cohort" in changed_id:
              ca.remove_cohort()
              fig = ca.cohort_graph(x_axis)
              return (
                  ca.cohort_metrics_details(),
                  ca.cohort_details(),
                  dcc.Graph(figure=fig),
              )
          else:
              ca.add_cohort_metrics(
                  df,
                  var_name,
                  operator,
                  value,
                  self.param["is_classification"],
              )
              cohort = ca.add_cohort(
                  df, x_axis, var_name, operator, value
              )
              fig = ca.cohort_graph(x_axis)
              return (
                  ca.cohort_metrics_details(),
                  ca.cohort_details(),
                  dcc.Graph(figure=fig),
              )
  
      # SQL - Data Input Callback
      @app.callback(
          dash.dependencies.Output("sql-query-button", "children"),
          [dash.dependencies.Input("submit-val", "n_clicks")],
          [dash.dependencies.State("input-on-submit", "value")],
      )
      def update_output(n_clicks, value):
          sql_query = f"{value}"
          return sql_query
  
      # What-If Form CallBack
      @app.callback(
          Output("place_form_here", "children"),
          [Input("row_number", "value")],
      )
      def create_what_if_form(row_number):
          self.analytics.update_data()
          self.analytics["function"] = "what_if"
          self.analytics["time"] = str(datetime.datetime.now())
          self.analytics["query"] = row_number
          self.analytics.insert_data()
          self.analytics["finish_time"] = ""
          x = what_if()
          i = 0
          if type(row_number) == type(1):
              i = row_number
          array = df[i : i + 1]
          array1 = array
          impact_variables = [col for col in array if "_impact" in col]
          for col in impact_variables:
              array1.drop([col], axis=1, inplace=True)
          # features = [col for col in array if not '_impact' in col]
          features = list(self.param["columns"])
          features.append("y_prediction")
          features.append("y_actual")
  
          form = x.what_if_form(array1, features)
          return form
  
      """
          change this. Take input from what-if form.
          """
  
      # Local Feature Impact Graph
      @app.callback(
          [
              Output("local_feature_impact", "figure"),
              Output("local_message_1", "children"),
              Output("local_message_2", "children"),
              Output("local_message_3", "children"),
              Output("local_message_4", "children"),
          ],
          self.callback_input,
          prevent_initial_call=True,
      )
      def update_impact_graph(*values):
          changed_id = [
              p["prop_id"] for p in dash.callback_context.triggered
          ][0]
          df = pd.DataFrame([values[:-1]])
          df.columns = self.param["columns"]
          array = self.calculate_prediction_shap(df)
  
          # Y_Pred
          # Probability_
          if self.param["is_classification"]:
              y_and_prob = []
              y_and_prob.append(int(array["y_prediction"]))
              y_and_prob.append(
                  round(
                      float(
                          array[
                              "Probability_"
                              + str(int(array["y_prediction"]))
                          ]
                      ),
                      2,
                  )
              )
          else:
              y_and_prob = []
              y_and_prob.append(round(float(array["y_prediction"]), 2))
  
          # figure, dat = g.feature_impact_old(array)
          figure, dat = g.local_feature_impact_graph(array)
          message = self.insights.insight_2_local_feature_impact(
              dat, y_and_prob
          )
  
          return figure, message[0], message[1], message[2], message[3]
  
      # Prototypical Analysis
      """
          Change this. Take input from what-if from
          """
  
      @app.callback(
          Output(
              component_id="prototype_data", component_property="data"
          ),
          [Input(f[0], f[1]) for f in self.prototype_array],
      )
      def update_table(*values):
          changed_id = [
              p["prop_id"] for p in dash.callback_context.triggered
          ][0]
          if "btn-nclicks-1" in changed_id:
              # get x variables and prediction column from the data
  
              df_row = pd.DataFrame([values[:-1]])
              df_row.columns = self.param["columns"]
  
              # find prediction and impact values first here please.
              df_row = self.calculate_prediction(df_row)
              df_selected = df[
                  list(self.param["columns"])
                  + [self.param["y_variable_predict"]]
              ]
  
              row_number = len(df_selected)
              if not isinstance(df_row, pd.DataFrame):
                  df_row = df_row.as_data_frame()
              df_selected.loc[row_number] = df_row.values[0]
  
              p = protodash()
              p.preprocess_data(
                  df_selected, self.param["y_variable_predict"]
              )
  
              dfs, sample_row = p.find_prototypes(row_number)
              dat = dfs.T.reset_index()
              print("sample row columns")
              sample_row = sample_row.to_frame()
              sample_row.rename(
                  columns={sample_row.columns[0]: "orig"}, inplace=True
              )
              sample_row.reset_index(inplace=True)
              # print(sample_row.columns)
              dat = pd.merge(dat, sample_row, on=["index"], how="left")
              dat["orig"] = dat["orig"].astype(float)
              for i in list(dat.columns):
                  dat[str(i) + "_color"] = np.nan
                  if i != "index":
                      dat[i] = dat[i].astype(float)
                      dat[str(i) + "_color"] = dat[
                          str(i) + "_color"
                      ].astype(float)
                  dat[str(i) + "_color"] = np.where(
                      dat["orig"] == dat[i], 1, 0
                  )
              dat.drop(
                  ["index_color", "orig_color"], axis=1, inplace=True
              )
              dat = dat.to_dict("records")
              return dat
          else:
              return []
  
      # Global Feature Importance
      @app.callback(
          [
              Output("global_feature_importance", "figure"),
              Output("global_message_1", "children"),
          ],
          [
              Input("sql-query-button", "children"),
              Input("xaxis-column-test-2", "value"),
          ],
      )
      def update_graphs(sql_query, value):
          self.analytics.update_data()
          self.analytics["function"] = "feature_importance"
          self.analytics["time"] = str(datetime.datetime.now())
          self.analytics["query"] = sql_query
          self.analytics["finish_time"] = ""
          self.analytics.insert_data()
          g = plotly_graphs()
          graph_type = "feature_importance"
          dff = self.caching_data_manager(
              df, sql_query, graph_type, g.feature_importance
          )
          message = self.insights.insight_1_feature_imp(dff)
          figure = g.global_feature_importance_graph(
              dff, self.param["is_classification"]
          )
          return figure, message[0]
  
      # Global Feature Impact
      @app.callback(
          [
              Output("global_feature_impact", "figure"),
              Output("message_1", "children"),
              Output("message_2", "children"),
              Output("message_3", "children"),
          ],
          [
              Input("sql-query-button", "children"),
              Input("xaxis-column-test-2", "value"),
          ],
      )
      def update_graphs(sql_query, value):
          g = plotly_graphs()
          graph_type = "feature_impact"
          df3 = self.caching_data_manager(
              df, sql_query, graph_type, g.feature_impact
          )
          figure = g.global_feature_impact_graph(
              df3, self.param["is_classification"]
          )
          message = self.insights.insight_2_global_feature_impact(df3)
          return figure, message[0], message[1], message[2]
  
      # Partial Dependence Plot Graph
      @app.callback(
          Output("indicator-graphic", "figure"),
          [
              Input("xaxis-column", "value"),
              #  Input('yaxis-column', 'value'),
              Input("third-axis", "value"),
              Input("sql-query-button", "children"),
          ],
      )
      def update_graph(xaxis_column_name, third_axis_name, sql_query):
          self.analytics.update_data()
          self.analytics["function"] = "pdp"
          self.analytics["time"] = str(datetime.datetime.now())
          self.analytics["query"] = sql_query
          self.analytics.insert_data()
  
          g = plotly_graphs()
          graph_type = "pdp"
          df3 = self.caching_data_manager(
              df, sql_query, graph_type, g.partial_dependence_plot
          )
          print(df3)
          fig = g.pdp_plot(
              df3,
              df3[xaxis_column_name],
              df3[xaxis_column_name + "_impact"],
              df3[third_axis_name],
          )
          return fig
  
      # Summary Plot
      @app.callback(
          Output("summary_plot", "figure"),
          [
              Input("sql-query-button", "children"),
              Input("xaxis-column-test", "value"),
          ],
      )
      def update_graph2(sql_query, value):
          g = plotly_graphs()
          graph_type = "summary_plot"
          df3 = self.caching_data_manager(
              df, sql_query, graph_type, g.summary_plot
          )
          fig = g.summary_plot_graph(df3)
          return fig
  
      # Distributions
      @app.callback(
          Output("indicator-graphic2", "figure"),
          [
              Input("xaxis-column-name", "value"),
              Input("plot_type", "value"),
              Input("sql-query-button", "children"),
          ],
      )
      def update_graph2(xaxis_column_name, plot_type, sql_query):
          graph_type = "filtered_df"
          df3 = self.caching_data_manager(df, sql_query, graph_type)
          cat_variables = []
          num_variables = []
          for i in original_variables:
              if df[i].dtype == "object":
                  cat_variables.append(i)
              else:
                  num_variables.append(i)
  
          if plot_type == "Histogram":
              return px.histogram(
                  df3,
                  x=xaxis_column_name,
                  marginal="box",
                  template="plotly_white",
              )
          else:
              for i in cat_variables:
                  return px.violin(
                      df3,
                      x=xaxis_column_name,
                      box=True,
                      points="all",
                      template="plotly_white",
                  )
              else:
                  return px.violin(
                      df3,
                      y=xaxis_column_name,
                      box=True,
                      points="all",
                      template="plotly_white",
                  )
  
      # Port Finder
      port = 8080
      debug_value = True
  
      if mode == "inline":
          try:
              app.run_server(
                  mode="inline",
                  port=port,
                  debug=debug_value,
                  dev_tools_ui=debug_value,
                  dev_tools_props_check=debug_value,
                  dev_tools_silence_routes_logging=True,
                  dev_tools_hot_reload=True,
              )
          except:
              port = self.find_free_port()
              app.run_server(
                  mode="inline",
                  port=port,
                  debug=debug_value,
                  dev_tools_ui=debug_value,
                  dev_tools_props_check=debug_value,
                  dev_tools_silence_routes_logging=True,
                  dev_tools_hot_reload=True,
              )
      else:
          try:
              app.run_server(
                  host="127.0.0.1",
                  port=port,
                  debug=debug_value,
                  dev_tools_ui=debug_value,
                  dev_tools_props_check=debug_value,
                  dev_tools_silence_routes_logging=True,
                  dev_tools_hot_reload=True,
              )
          except:
              # try different ip in case 0.0.0.0 does not work
              try:
                  try:
                      port = self.find_free_port()
                      app.run_server(
                          host="127.0.0.1",
                          port=port,
                          debug=debug_value,
                          dev_tools_ui=debug_value,
                          dev_tools_props_check=debug_value,
                          dev_tools_silence_routes_logging=True,
                          dev_tools_hot_reload=True,
                      )
                  except:
                      port = self.find_free_port()
                      app.run_server(
                          host="127.0.0.1",
                          port=port,
                          debug=debug_value,
                          dev_tools_ui=debug_value,
                          dev_tools_props_check=debug_value,
                          dev_tools_silence_routes_logging=True,
                          dev_tools_hot_reload=True,
                      )
              except:
                  try:
                      port = self.find_free_port()
                      app.run_server(
                          host="127.0.0.1",
                          port=port,
                          debug=debug_value,
                          dev_tools_ui=debug_value,
                          dev_tools_props_check=debug_value,
                          dev_tools_silence_routes_logging=True,
                          dev_tools_hot_reload=True,
                      )
                  except:
                      print(
                          "Please restart Jupyter Notebook or Python IDE."
                      )
                      return False
      try:
          self.increate_counter()
      except:
          pass
      return port
  
imports: from imports import *
  from plotly_graphs import *
  from protodash import *
  from insights import *
  from plotly_css import *
  import pandasql
  import string
  import random
  import os
  from apps import global_explanation, local_explanation, distribution, feature_interaction, cohort
  from app import app
  from what_if import *
  from calculate_shap import *
  from analytics import Analytics
  from cohort_analysis import *
label_desc: Use image node_id 11 for calling the dashboard obj's underlying member method code with example usage: obj.dash(df, mode) and returns: port, is_open, df, is_open, is_open, is_open, sql_query, form, figure,  message,  message,  message,  message, figure,  message, figure,  message,  message,  message, fig, fig, unknown, global_explanation, unknown, unknown, unknown, ca,  ca,  dcc, ca,  ca,  dcc, dat, list, px, feature_interaction, px, px, distribution, local_explanation, cohort, welcome_message, False