code: def check_transformers(list_encoding):
      """
      Check that all transformation are supported.
          - a single category encoders transformer
          - a single columns transformers
          - list of multiple category encoder with optional (dict, list of dict)
          - list with a single transformer with optional (dict, list of dict)
          - dict
          - list of dict
  
      If a dict is used, the dict must contain, a col, a mapping and a data_type.
      Example :
          input_dict1['col'] = 'my_col'
          input_dict1['mapping'] = pd.Series(data=['C', 'D', np.nan], index=['C', 'D', 'missing'])
          input_dict1['data_type'] = 'object'
  
      Parameters
      ----------
      list_encoding : list
          A list containing at least one transformation
  
      Returns
      -------
          use_ct : boolean
              true if column transformer is used
          use_ce : boolean
              true if category encoder is used
  
      """
  
      use_ct = False
      use_ce = False
  
      for enc in list_encoding:
          if str(type(enc)) in columntransformer:
              use_ct = True
              for encoding in enc.transformers_:
                  ct_encoding = encoding[1]
                  if (
                      str(type(ct_encoding)) not in supported_sklearn
                  ) and (
                      str(type(ct_encoding))
                      not in supported_category_encoder
                  ):
                      if str(type(ct_encoding)) != "<class 'str'>":
                          raise ValueError(
                              "One of the encoders used in ColumnTransformers isn't supported."
                          )
  
          elif str(type(enc)) in supported_category_encoder:
              use_ce = True
  
          # Check we have a list of dict
          elif isinstance(enc, list):
              for enc_dict in enc:
                  if isinstance(enc_dict, dict):
                      # Check dict structure : col - mapping - data_type
                      if not all(
                          struct in enc_dict
                          for struct in ("col", "mapping", "data_type")
                      ):
                          raise Exception(
                              f"{enc_dict} should have col, mapping and data_type as keys."
                          )
                  else:
                      raise Exception(f"{enc} is not a list of dict.")
          else:
              raise Exception(f"{enc} is not supported yet.")
  
      # check that encoding don't use ColumnTransformer and Category encoding at the same time
      if use_ct and use_ce:
          raise Exception(
              f"Can't support ColumnTransformer and Category encoding at the same time. "
              f"Use Category encoding in ColumnTransformer"
          )
  
      # check that Category encoding is apply on different columns
      col = []
      for enc in list_encoding:
          if not str(type(enc)) in (
              "<class 'list'>",
              "<class 'dict'>",
              columntransformer,
          ):
              col += enc.cols
      duplicate = set([x for x in col if col.count(x) > 1])
      if duplicate:
          raise Exception(
              "Columns "
              + str(duplicate)
              + " is used in multiple category encoding"
          )
  
      return use_ct, use_ce
  
file_path: shapash/shapash/utils/transform.py
imports: from shapash.utils.columntransformer_backend import columntransformer, inv_transform_ct, supported_sklearn, transform_ct, get_col_mapping_ct
  from shapash.utils.category_encoder_backend import transform_ce, inv_transform_ce, supported_category_encoder, get_col_mapping_ce
  import re
  import numpy
  import pandas
label_desc: Use image node_id 4 for calling a global function with example usage: check_transformers(list_encoding) and returns: use_ct,  use_ce