code: def fit_and_transform(self, X_train, y_train, sample_weight=None):
      logger.debug("Preprocessing.fit_and_transform")
  
      if y_train is not None:
          # target preprocessing
          # this must be used first, maybe we will drop some rows because of missing target values
          target_preprocessing = self._params.get(
              "target_preprocessing"
          )
          logger.debug(
              "target_preprocessing params: {}".format(
                  target_preprocessing
              )
          )
  
          (
              X_train,
              y_train,
              sample_weight,
              _,
          ) = ExcludeRowsMissingTarget.transform(
              X_train, y_train, sample_weight
          )
  
          if (
              PreprocessingCategorical.CONVERT_INTEGER
              in target_preprocessing
          ):
              logger.debug("Convert target to integer")
              self._categorical_y = LabelEncoder(
                  try_to_fit_numeric=True
              )
              self._categorical_y.fit(y_train)
              y_train = pd.Series(
                  self._categorical_y.transform(y_train)
              )
  
          if (
              PreprocessingCategorical.CONVERT_ONE_HOT
              in target_preprocessing
          ):
              logger.debug("Convert target to one-hot coding")
              self._categorical_y = LabelBinarizer()
              self._categorical_y.fit(
                  pd.DataFrame({"target": y_train}), "target"
              )
              y_train = self._categorical_y.transform(
                  pd.DataFrame({"target": y_train}), "target"
              )
  
          if Scale.SCALE_LOG_AND_NORMAL in target_preprocessing:
              logger.debug("Scale log and normal")
  
              self._scale_y = Scale(
                  ["target"], scale_method=Scale.SCALE_LOG_AND_NORMAL
              )
              y_train = pd.DataFrame({"target": y_train})
              self._scale_y.fit(y_train)
              y_train = self._scale_y.transform(y_train)
              y_train = y_train["target"]
  
          if Scale.SCALE_NORMAL in target_preprocessing:
              logger.debug("Scale normal")
  
              self._scale_y = Scale(
                  ["target"], scale_method=Scale.SCALE_NORMAL
              )
              y_train = pd.DataFrame({"target": y_train})
              self._scale_y.fit(y_train)
              y_train = self._scale_y.transform(y_train)
              y_train = y_train["target"]
  
      # columns preprocessing
      columns_preprocessing = self._params.get("columns_preprocessing")
      for column in columns_preprocessing:
          transforms = columns_preprocessing[column]
          # logger.debug("Preprocess column {} with: {}".format(column, transforms))
  
      # remove empty or constant columns
      cols_to_remove = list(
          filter(
              lambda k: "remove_column" in columns_preprocessing[k],
              columns_preprocessing,
          )
      )
  
      if X_train is not None:
          X_train.drop(cols_to_remove, axis=1, inplace=True)
      self._remove_columns = cols_to_remove
  
      numeric_cols = []  # get numeric cols before text transformations
      # needed for golden features
      if X_train is not None and (
          "golden_features" in self._params
          or "kmeans_features" in self._params
      ):
          numeric_cols = X_train.select_dtypes(
              include="number"
          ).columns.tolist()
  
      # there can be missing values in the text data,
      # but we don't want to handle it by fill missing methods
      # zeros will be imputed by text_transform method
      cols_to_process = list(
          filter(
              lambda k: "text_transform" in columns_preprocessing[k],
              columns_preprocessing,
          )
      )
  
      new_text_columns = []
      for col in cols_to_process:
          t = TextTransformer()
          t.fit(X_train, col)
          X_train = t.transform(X_train)
          self._text_transforms += [t]
          new_text_columns += t._new_columns
      # end of text transform
  
      for missing_method in [PreprocessingMissingValues.FILL_NA_MEDIAN]:
          cols_to_process = list(
              filter(
                  lambda k: missing_method in columns_preprocessing[k],
                  columns_preprocessing,
              )
          )
          missing = PreprocessingMissingValues(
              cols_to_process, missing_method
          )
          missing.fit(X_train)
          X_train = missing.transform(X_train)
          self._missing_values += [missing]
  
      # golden features
      golden_columns = []
      if "golden_features" in self._params:
          results_path = self._params["golden_features"]["results_path"]
          ml_task = self._params["golden_features"]["ml_task"]
          features_count = self._params["golden_features"].get(
              "features_count"
          )
          n_jobs = self._params["golden_features"].get("n_jobs", -1)
          self._golden_features = GoldenFeaturesTransformer(
              results_path, ml_task, features_count, n_jobs
          )
          self._golden_features.fit(X_train[numeric_cols], y_train)
          X_train = self._golden_features.transform(X_train)
          golden_columns = self._golden_features._new_columns
  
      kmeans_columns = []
      if "kmeans_features" in self._params:
          results_path = self._params["kmeans_features"]["results_path"]
          self._kmeans = KMeansTransformer(
              results_path, self._model_name, self._k_fold
          )
          self._kmeans.fit(X_train[numeric_cols], y_train)
          X_train = self._kmeans.transform(X_train)
          kmeans_columns = self._kmeans._new_features
  
      for convert_method in [
          PreprocessingCategorical.CONVERT_INTEGER,
          PreprocessingCategorical.CONVERT_ONE_HOT,
          PreprocessingCategorical.CONVERT_LOO,
      ]:
          cols_to_process = list(
              filter(
                  lambda k: convert_method in columns_preprocessing[k],
                  columns_preprocessing,
              )
          )
          convert = PreprocessingCategorical(
              cols_to_process, convert_method
          )
          convert.fit(X_train, y_train)
          X_train = convert.transform(X_train)
          self._categorical += [convert]
  
      # datetime transform
      cols_to_process = list(
          filter(
              lambda k: "datetime_transform"
              in columns_preprocessing[k],
              columns_preprocessing,
          )
      )
  
      new_datetime_columns = []
      for col in cols_to_process:
          t = DateTimeTransformer()
          t.fit(X_train, col)
          X_train = t.transform(X_train)
          self._datetime_transforms += [t]
          new_datetime_columns += t._new_columns
  
      # SCALE
      for scale_method in [
          Scale.SCALE_NORMAL,
          Scale.SCALE_LOG_AND_NORMAL,
      ]:
          cols_to_process = list(
              filter(
                  lambda k: scale_method in columns_preprocessing[k],
                  columns_preprocessing,
              )
          )
          if (
              len(cols_to_process)
              and len(new_datetime_columns)
              and scale_method == Scale.SCALE_NORMAL
          ):
              cols_to_process += new_datetime_columns
          if (
              len(cols_to_process)
              and len(new_text_columns)
              and scale_method == Scale.SCALE_NORMAL
          ):
              cols_to_process += new_text_columns
  
          if (
              len(cols_to_process)
              and len(golden_columns)
              and scale_method == Scale.SCALE_NORMAL
          ):
              cols_to_process += golden_columns
  
          if (
              len(cols_to_process)
              and len(kmeans_columns)
              and scale_method == Scale.SCALE_NORMAL
          ):
              cols_to_process += kmeans_columns
  
          if len(cols_to_process):
              scale = Scale(cols_to_process)
              scale.fit(X_train)
              X_train = scale.transform(X_train)
              self._scale += [scale]
  
      if self._add_random_feature:
          # -1, 1, with 0 mean
          X_train["random_feature"] = (
              np.random.rand(X_train.shape[0]) * 2.0 - 1.0
          )
  
      if self._drop_features:
          available_cols = X_train.columns.tolist()
          drop_cols = [
              c for c in self._drop_features if c in available_cols
          ]
          if len(drop_cols) == X_train.shape[1]:
              raise AutoMLException(
                  "All features are droppped! Your data looks like random data."
              )
          if drop_cols:
              X_train.drop(drop_cols, axis=1, inplace=True)
          self._drop_features = drop_cols
  
      if X_train is not None:
          # there can be catagorical columns (in CatBoost) which cant be clipped
          numeric_cols = X_train.select_dtypes(
              include="number"
          ).columns.tolist()
          X_train[numeric_cols] = X_train[numeric_cols].clip(
              lower=np.finfo(np.float32).min + 1000,
              upper=np.finfo(np.float32).max - 1000,
          )
  
      return X_train, y_train, sample_weight
  
imports: import copy
  import logging
  import warnings
  import numpy
  import pandas
  from supervised.algorithms.registry import BINARY_CLASSIFICATION, MULTICLASS_CLASSIFICATION, REGRESSION
  from supervised.exceptions import AutoMLException
  from supervised.preprocessing.datetime_transformer import DateTimeTransformer
  from supervised.preprocessing.exclude_missing_target import ExcludeRowsMissingTarget
  from supervised.preprocessing.goldenfeatures_transformer import GoldenFeaturesTransformer
  from supervised.preprocessing.kmeans_transformer import KMeansTransformer
  from supervised.preprocessing.label_binarizer import LabelBinarizer
  from supervised.preprocessing.label_encoder import LabelEncoder
  from supervised.preprocessing.preprocessing_categorical import PreprocessingCategorical
  from supervised.preprocessing.preprocessing_missing import PreprocessingMissingValues
  from supervised.preprocessing.preprocessing_utils import PreprocessingUtils
  from supervised.preprocessing.scale import Scale
  from supervised.preprocessing.text_transformer import TextTransformer
  from supervised.utils.config import LOG_LEVEL
label_desc: Use image node_id 3 for calling the Preprocessing obj's underlying member method code with example usage: obj.fit_and_transform(X_train, y_train, sample_weight) and returns: X_train,  y_train,  sample_weight