class_docstr: Column-wise application of transformers.
  
  Applies transformations to columns of an array or pandas DataFrame. Simply
  takes the column transformer from sklearn
  and adds capability to handle pandas dataframe.
  
  This estimator allows different columns or column subsets of the input
  to be transformed separately and the features generated by each transformer
  will be concatenated to form a single feature space.
  This is useful for heterogeneous or columnar data, to combine several
  feature extraction mechanisms or transformations into a single transformer.
  
  Note: this estimator has the same effect as combining
  ``FeatureUnion`` with ``ColumnSelect``, but can be more convenient or compact.
  
  Parameters
  ----------
  transformers : sktime trafo, or list of tuples (str, estimator, int or pd.index)
      if tuples, with name = str, estimator is transformer, index as int or index
      if last element is index, it must be int, str, or pd.Index coercible
      if last element is int x, and is not in columns, is interpreted as x-th column
      all columns must be present in an index
  
      If transformer, clones of transformer are applied to all columns.
      If list of tuples, transformer in tuple is applied to column with int/str index
  
  remainder : {"drop", "passthrough"} or estimator, default "drop"
      By default, only the specified columns in `transformations` are
      transformed and combined in the output, and the non-specified
      columns are dropped. (default of ``"drop"``).
      By specifying ``remainder="passthrough"``, all remaining columns that
      were not specified in `transformations` will be automatically passed
      through. This subset of columns is concatenated with the output of
      the transformations.
      By setting ``remainder`` to be an estimator, the remaining
      non-specified columns will use the ``remainder`` estimator. The
      estimator must support `fit` and `transform`.
  
  feature_names_out : str, one of "auto" (default), "flat", "multiindex", "original"
      determines how return columns of return DataFrame-s are named
      has no effect if return mtype is one without column names
      "flat": columns are flat, e.g., "transformername__variablename"
      "multiindex": columns are MultiIndex, e.g., (transformername, variablename)
      "original: columns are as produced by transformers, e.g., variablename
          if this results in non-unique index, ValueError exception is raised
      "auto": as "original" for any unique columns under "original",
          column names as "flat" otherwise
  
  Attributes
  ----------
  transformers_ : list
      The collection of fitted transformations as tuples of
      (name, fitted_transformer, column). `fitted_transformer` can be an
      estimator, "drop", or "passthrough". In case there were no columns
      selected, this will be the unfitted transformer.
      If there are remaining columns, the final element is a tuple of the
      form:
      ("remainder", transformer, remaining_columns) corresponding to the
      ``remainder`` parameter. If there are remaining columns, then
      ``len(transformers_)==len(transformations)+1``, otherwise
      ``len(transformers_)==len(transformations)``.
  
  Examples
  --------
  .. Doctest::
  
      >>> import pandas as pd
      >>> from sktime.transformations.compose import ColumnEnsembleTransformer
      >>> from sktime.transformations.series.detrend import Detrender
      >>> from sktime.transformations.series.difference import Differencer
      >>> from sktime.datasets import load_longley
  
  Using integers (column iloc references) for indexing:
  
  .. Doctest::
  
      >>> y = load_longley()[1][["GNP", "UNEMP"]]
      >>> transformer = ColumnEnsembleTransformer([("difference", Differencer(), 1),
      ...                                 ("trend", Detrender(), 0),
      ...                                 ])
      >>> y_transformed = transformer.fit_transform(y)
  
  Using strings for indexing:
  
  >>> df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
  >>> transformer = ColumnEnsembleTransformer(
  ...     [("foo", Differencer(), "a"), ("bar", Detrender(), "b")]
  ... )
  >>> transformed_df = transformer.fit_transform(df)
  
  Applying one transformer to multiple columns, multivariate:
  
  >>> df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})
  >>> transformer = ColumnEnsembleTransformer(
  ...    [("ab", Differencer(), ["a", 1]), ("c", Detrender(), 2)]
  ... )
  >>> transformed_df = transformer.fit_transform(df)
code: def __init__(
      self, transformers, remainder=None, feature_names_out="auto"
  ):
      self.transformers = transformers
      self.remainder = remainder
      self.feature_names_out = feature_names_out
      super().__init__()
  
      # check remainder argument
      if remainder not in ["drop", "passthrough", None]:
          if not isinstance(remainder, BaseTransformer):
              raise ValueError(
                  "the remainder parameter of ColumnEnsembleTransformer "
                  ' must be one of the strings "drop", "passthrough", None,'
                  "or an sktime transformer inheriting from BaseTransformer"
              )
  
      # set requires-fh-in-fit depending on transformers
      if isinstance(transformers, BaseTransformer):
          tags_to_clone = [
              "fit_is_empty",
              "requires_y",
              "X-y-must-have-same-index",
              "transform-returns-same-time-index",
              "capability:unequal_length",
              "capability:unequal_length:removes",
              "handles-missing-data",
              "capability:missing_values:removes",
              "scitype:transform-output",
              "scitype:transform-labels",
          ]
          self.clone_tags(transformers, tags_to_clone)
      else:
          l_transformers = [(x[0], x[1]) for x in transformers]
          # self._anytagis_then_set("fit_is_empty", False, True, l_transformers)
          self._anytagis_then_set(
              "requires_y", True, False, l_transformers
          )
          self._anytagis_then_set(
              "X-y-must-have-same-index", True, False, l_transformers
          )
          self._anytagis_then_set(
              "transform-returns-same-time-index",
              False,
              True,
              l_transformers,
          )
          self._anytagis_then_set(
              "capability:unequal_length", False, True, l_transformers
          )
          self._anytagis_then_set(
              "capability:unequal_length:removes",
              False,
              True,
              l_transformers,
          )
          self._anytagis_then_set(
              "handles-missing-data", False, True, l_transformers
          )
          self._anytagis_then_set(
              "capability:missing_values:removes",
              False,
              True,
              l_transformers,
          )
  
          # must be all the same, currently not checking
          tags_to_clone = [
              "scitype:transform-output",
              "scitype:transform-labels",
          ]
          self.clone_tags(transformers[0][1], tags_to_clone)
  
imports: import pandas
  from sktime.base._meta import _ColumnEstimator, _HeterogenousMetaEstimator
  from sktime.transformations.base import BaseTransformer
  from sktime.utils.multiindex import rename_multiindex
  from sktime.utils.validation.series import check_series
label_desc: Use image node_id 1 to create a new ColumnEnsembleTransformer object from inherited base classes: _HeterogenousMetaEstimator, _ColumnEstimator, BaseTransformer with example: obj = ColumnEnsembleTransformer(transformers, remainder, feature_names_out)