code: def get_frameworks_table():
      """
      Generates a dataframe containing the supported auto classes for each model type, using the content of the auto
      modules.
      """
      # Dictionary model names to config.
      config_maping_names = (
          transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
      )
      model_prefix_to_model_type = {
          config.replace("Config", ""): model_type
          for model_type, config in config_maping_names.items()
      }
  
      # Dictionaries flagging if each model prefix has a backend in PT/TF/Flax.
      pt_models = collections.defaultdict(bool)
      tf_models = collections.defaultdict(bool)
      flax_models = collections.defaultdict(bool)
  
      # Let's lookup through all transformers object (once) and find if models are supported by a given backend.
      for attr_name in dir(transformers_module):
          lookup_dict = None
          if _re_tf_models.match(attr_name) is not None:
              lookup_dict = tf_models
              attr_name = _re_tf_models.match(attr_name).groups()[0]
          elif _re_flax_models.match(attr_name) is not None:
              lookup_dict = flax_models
              attr_name = _re_flax_models.match(attr_name).groups()[0]
          elif _re_pt_models.match(attr_name) is not None:
              lookup_dict = pt_models
              attr_name = _re_pt_models.match(attr_name).groups()[0]
  
          if lookup_dict is not None:
              while len(attr_name) > 0:
                  if attr_name in model_prefix_to_model_type:
                      lookup_dict[
                          model_prefix_to_model_type[attr_name]
                      ] = True
                      break
                  # Try again after removing the last word in the name
                  attr_name = "".join(camel_case_split(attr_name)[:-1])
  
      all_models = set(
          list(pt_models.keys())
          + list(tf_models.keys())
          + list(flax_models.keys())
      )
      all_models = list(all_models)
      all_models.sort()
  
      data = {"model_type": all_models}
      data["pytorch"] = [pt_models[t] for t in all_models]
      data["tensorflow"] = [tf_models[t] for t in all_models]
      data["flax"] = [flax_models[t] for t in all_models]
  
      # Now let's use the auto-mapping names to make sure
      processors = {}
      for t in all_models:
          if (
              t
              in transformers_module.models.auto.processing_auto.PROCESSOR_MAPPING_NAMES
          ):
              processors[t] = "AutoProcessor"
          elif (
              t
              in transformers_module.models.auto.tokenization_auto.TOKENIZER_MAPPING_NAMES
          ):
              processors[t] = "AutoTokenizer"
          elif (
              t
              in transformers_module.models.auto.feature_extraction_auto.FEATURE_EXTRACTOR_MAPPING_NAMES
          ):
              processors[t] = "AutoFeatureExtractor"
          else:
              # Default to AutoTokenizer if a model has nothing, for backward compatibility.
              processors[t] = "AutoTokenizer"
  
      data["processor"] = [processors[t] for t in all_models]
  
      return pd.DataFrame(data)
  
file_path: H2O/h2o_flexgen/benchmark/third_party/transformers/utils/update_metadata.py
imports: import argparse
  import collections
  import importlib.util
  import os
  import re
  import tempfile
  import pandas
  from datasets import Dataset
  from huggingface_hub import Repository
label_desc: Use image node_id 2 for calling a global function with example usage: get_frameworks_table() and returns: pd