class_docstr: This component is used to apply distinct transformations to categorical,
  numerical and text features of a dataset. It is built on top of sklearn's
  ColumnTransformer.
class_docstr_tok: ["This","component","is","used","to","apply","distinct","transformations","to","categorical",",","numerical","and","text","features","of","a","dataset",".","It","is","built","on","top","of","sklearn's","ColumnTransformer","."]
code: def __init__(
      self,
      config: Optional[Configuration] = None,
      pipeline: Optional[BasePipeline] = None,
      dataset_properties: Optional[DATASET_PROPERTIES_TYPE] = None,
      include: Optional[Dict[str, str]] = None,
      exclude: Optional[Dict[str, str]] = None,
      random_state: Optional[Union[int, np.random.RandomState]] = None,
      init_params: Optional[Dict[str, Any]] = None,
      feat_type: Optional[FEAT_TYPE_TYPE] = None,
      force_sparse_output: bool = False,
      column_transformer: Optional[
          sklearn.compose.ColumnTransformer
      ] = None,
  ):
      if pipeline is not None:
          raise ValueError(
              "DataPreprocessor's argument 'pipeline' should be None"
          )
  
      self.config = config
      self.pipeline = pipeline
      self.dataset_properties = dataset_properties
      self.include = include
      self.exclude = exclude
      self.random_state = random_state
      self.init_params = init_params
      self.feat_type = feat_type
      self.force_sparse_output = force_sparse_output
  
      # The pipeline that will be applied to the categorical features (i.e. columns)
      # of the dataset
      # Configuration of the data-preprocessor is different from the configuration of
      # the categorical pipeline. Hence, force to None
      # It is actually the call to set_hyperparameter who properly sets this argument
      # TODO: Extract the child configuration space from the FeatTypeSplit to the
      # pipeline if needed
      self.categ_ppl = CategoricalPreprocessingPipeline(
          feat_type=self.feat_type,
          config=None,
          steps=pipeline,
          dataset_properties=dataset_properties,
          include=include,
          exclude=exclude,
          random_state=random_state,
          init_params=init_params,
      )
      # The pipeline that will be applied to the numerical features (i.e. columns)
      # of the dataset
      # Configuration of the data-preprocessor is different from the configuration of
      # the numerical pipeline. Hence, force to None
      # It is actually the call to set_hyperparameter who properly sets this argument
      # TODO: Extract the child configuration space from the FeatTypeSplit to the
      # pipeline if needed
      self.numer_ppl = NumericalPreprocessingPipeline(
          feat_type=self.feat_type,
          config=None,
          steps=pipeline,
          dataset_properties=dataset_properties,
          include=include,
          exclude=exclude,
          random_state=random_state,
          init_params=init_params,
      )
  
      # The pipeline that will be applied to the text features (i.e. columns)
      # of the dataset
      # Configuration of the data-preprocessor is different from the configuration of
      # the numerical or categorical pipeline. Hence, force to None
      # It is actually the call to set_hyperparameter who properly sets this argument
      # TODO: Extract the child configuration space from the FeatTypeSplit to the
      # pipeline if needed
      self.txt_ppl = TextPreprocessingPipeline(
          feat_type=self.feat_type,
          config=None,
          steps=pipeline,
          dataset_properties=dataset_properties,
          include=include,
          exclude=exclude,
          random_state=random_state,
          init_params=init_params,
      )
  
      if self.feat_type is None:
          self._transformers: List[Tuple[str, AutoSklearnComponent]] = [
              ("categorical_transformer", self.categ_ppl),
              ("numerical_transformer", self.numer_ppl),
              ("text_transformer", self.txt_ppl),
          ]
      else:
          self._transformers: List[
              Tuple[str, AutoSklearnComponent]
          ] = []
          if "categorical" in self.feat_type.values():
              self._transformers.append(
                  ("categorical_transformer", self.categ_ppl)
              )
          if "numerical" in self.feat_type.values():
              self._transformers.append(
                  ("numerical_transformer", self.numer_ppl)
              )
          if "string" in self.feat_type.values():
              self._transformers.append(
                  ("text_transformer", self.txt_ppl)
              )
  
      if self.config:
          self.set_hyperparameters(
              feat_type=self.feat_type,
              configuration=self.config,
              init_params=init_params,
          )
  
      self.column_transformer = column_transformer
  
imports: from typing import Any, Dict, List, Optional, Tuple, Union
  import numpy
  import sklearn.compose
  from ConfigSpace import Configuration
  from ConfigSpace.configuration_space import ConfigurationSpace
  from scipy import sparse
  from sklearn.base import BaseEstimator
  from autosklearn.askl_typing import FEAT_TYPE_TYPE
  from autosklearn.data.validation import SUPPORTED_FEAT_TYPES, SUPPORTED_TARGET_TYPES
  from autosklearn.pipeline.base import DATASET_PROPERTIES_TYPE, PIPELINE_DATA_DTYPE, BasePipeline
  from autosklearn.pipeline.components.base import AutoSklearnChoice, AutoSklearnComponent, AutoSklearnPreprocessingAlgorithm
  from autosklearn.pipeline.components.data_preprocessing.feature_type_categorical import CategoricalPreprocessingPipeline
  from autosklearn.pipeline.components.data_preprocessing.feature_type_numerical import NumericalPreprocessingPipeline
  from autosklearn.pipeline.components.data_preprocessing.feature_type_text import TextPreprocessingPipeline
  from autosklearn.pipeline.constants import DENSE, INPUT, SPARSE, UNSIGNED_DATA
label_desc: Use image node_id 1 to create a new FeatTypeSplit object from inherited base classes: AutoSklearnPreprocessingAlgorithm with example: obj = FeatTypeSplit(config, pipeline, dataset_properties, include, exclude, random_state, init_params, feat_type, force_sparse_output, column_transformer)