code: def data_with_complicated_types():
      """
      Generate InputData with mixed column types.
      Train part - idx [0 ... 15], test part - idx [16, 17]
      Column description by indices:
          0) int column with single np.nan value - nans must be filled in
          1) int column with nans more than 90% - column must be removed
          due to the fact that inf will be replaced with nans
          2) int-float column with categorical values (number of unique values = 12) -
          categorical indices must be converted into float, then due to number
          of unique values less than 13 - perform converting column into str type
          3) int column the same as 2) column but with additional 13th label in the test part
          4) int column (number of unique values = 4) - must be converted into string
          5) str-int column with words and numerical cells - must be converted to int,
          true str values replaced with nans and filled
          6) str column with unique categories 'a', 'b', 'c' and spaces in labels.
          New category 'd' arise in the test part. Categories will be encoded using OHE
          7) str binary column - must be converted into integer, nan cells must be filled in
          8) int binary column and nans - nan cells must be filled in
          9) str column with truly int values as strings - must be converted into float column,
          '?' and 'error' must be replaced with nans and then filled in
          10) str column with truly categorical values - must stay remained and encoded using OHE
      """
  
      task = Task(TaskTypesEnum.classification)
      features = np.array(
          [
              [0, np.nan, 1, 1, 1, "monday", "a ", "true", 1, "0", "a"],
              [
                  np.nan,
                  5,
                  2,
                  2,
                  0,
                  "tuesday",
                  "b",
                  np.nan,
                  0,
                  "1",
                  np.inf,
              ],
              [2, np.nan, 3, 3, np.nan, 3, "c", "false", 1, "?", "c"],
              [
                  3,
                  np.nan,
                  4,
                  4,
                  3.0,
                  4,
                  "  a  ",
                  "true",
                  0,
                  "error",
                  "d",
              ],
              [4, np.nan, 5, 5.0, 0, 5, "   b ", np.nan, 0, "3", "e"],
              [5, np.nan, 6, 6, 0, 6, "   c  ", "false", 0, "4", "f"],
              [6, np.inf, 7, 7, 0, 7, "    a  ", "true", 1, "5", "g"],
              [7, np.inf, 8, 8, 1.0, 1, " b   ", np.nan, 0, "6", "h"],
              [
                  np.inf,
                  np.inf,
                  "9",
                  "9",
                  2,
                  2,
                  np.nan,
                  "true",
                  1,
                  "7",
                  "i",
              ],
              [
                  9,
                  np.inf,
                  "10",
                  "10",
                  2,
                  3,
                  " c  ",
                  "false",
                  0,
                  "8",
                  "j",
              ],
              [
                  10,
                  np.nan,
                  11.0,
                  11.0,
                  0,
                  4,
                  "c ",
                  "false",
                  0,
                  "9",
                  "k",
              ],
              [
                  11,
                  np.nan,
                  12,
                  12,
                  2.0,
                  5,
                  np.nan,
                  "false",
                  1,
                  "10",
                  "l",
              ],
              [
                  12,
                  np.nan,
                  1,
                  1.0,
                  1.0,
                  6,
                  " b  ",
                  "false",
                  0,
                  "11",
                  "m",
              ],
              [
                  13,
                  np.nan,
                  2,
                  2,
                  1,
                  7,
                  " c  ",
                  "true",
                  np.nan,
                  "12",
                  "n",
              ],
              [
                  14,
                  np.nan,
                  3,
                  3,
                  2.0,
                  1,
                  "a",
                  "false",
                  np.nan,
                  "error",
                  "o",
              ],
              [
                  15,
                  np.nan,
                  4,
                  4,
                  1,
                  2,
                  "a  ",
                  "false",
                  np.nan,
                  "13",
                  "p",
              ],
              [16, 2, 5, 12, 0, 3, "   d       ", "true", 1, "?", "r"],
              [17, 3, 6, 13, 0, 4, "  d      ", "false", 0, "17", "s"],
          ],
          dtype=object,
      )
      target = np.array(
          [
              ["no"],
              ["yes"],
              ["yes"],
              ["yes"],
              ["no"],
              ["no"],
              ["no"],
              ["no"],
              ["no"],
              ["yes"],
              ["yes"],
              ["yes"],
              ["yes"],
              ["yes"],
              ["no"],
              ["no"],
              ["yes"],
              ["no"],
          ]
      )
      input_data = InputData(
          idx=np.arange(18),
          features=features,
          target=target,
          task=task,
          data_type=DataTypesEnum.table,
      )
  
      return train_test_data_setup(
          input_data, split_ratio=0.9, stratify=False
      )
  
imports: import numpy
  import pandas
  from golem.core.log import default_log
  from fedot.core.data.data import InputData
  from fedot.core.data.data_split import train_test_data_setup
  from fedot.core.pipelines.node import PipelineNode
  from fedot.core.pipelines.pipeline import Pipeline
  from fedot.core.repository.dataset_types import DataTypesEnum
  from fedot.core.repository.tasks import Task, TaskTypesEnum
  from fedot.core.utils import fedot_project_root
  from fedot.preprocessing.data_types import TYPE_TO_ID
  from fedot.preprocessing.data_types import TableTypesCorrector, apply_type_transformation
  from fedot.preprocessing.structure import DEFAULT_SOURCE_NAME
  from test.unit.preprocessing.test_pipeline_preprocessing import correct_preprocessing_params, data_with_mixed_types_in_each_column
label_desc: Use image node_id 4 for calling a global function with example usage: data_with_complicated_types() and returns: train_test_data_setup