code: def structured_preprocessor(data, ca_threshold=0.5, text=[]):
      # Preprocessing for datetime columns
      process_dates(data)
  
      # This will be used inside process_text once complete
      if len(text) > 0:
          text_preprocessing(data, text)
  
      # identifies the categorical and numerical columns
      categorical_columns = (
          data["train"].select_dtypes(exclude=["number"]).columns
      )
      numeric_columns = data["train"].columns[
          data["train"].dtypes.apply(
              lambda c: np.issubdtype(c, np.number)
          )
      ]
  
      # Removes text columns from categorical columns to use in separate pipeline
      categorical_columns = [
          cat_cols
          for cat_cols in categorical_columns
          if cat_cols not in text
      ]
  
      full_pipeline = ColumnTransformer([], remainder="passthrough")
  
      if len(numeric_columns) != 0:
          # pipeline for numeric columns
          num_pipeline = Pipeline(
              [
                  ("imputer", SimpleImputer(strategy="median")),
                  ("std_scaler", StandardScaler()),
              ]
          )
  
          full_pipeline.transformers.append(
              ("num", num_pipeline, numeric_columns)
          )
  
      if len(text) != 0:
          # Each text col needs a separate pipeline
          for x in range(len(text)):
              full_pipeline.transformers.append(
                  (
                      f"text_{x}",
                      Pipeline(
                          [
                              (
                                  "test",
                                  FunctionTransformer(
                                      lambda x: np.reshape(
                                          x.to_numpy(), (-1, 1)
                                      )
                                  ),
                              ),
                              (
                                  "imputer",
                                  SimpleImputer(
                                      strategy="constant", fill_value=""
                                  ),
                              ),
                              (
                                  "raveler",
                                  FunctionTransformer(
                                      lambda x: x.ravel(),
                                      accept_sparse=True,
                                  ),
                              ),
                              ("vect", TfidfVectorizer()),
                              (
                                  "densifier",
                                  FunctionTransformer(
                                      lambda x: x.todense(),
                                      accept_sparse=True,
                                  ),
                              ),
                              (
                                  "embedder",
                                  FunctionTransformer(
                                      textembedder, accept_sparse=True
                                  ),
                              ),
                          ]
                      ),
                      text[x],
                  )
              )
  
      if len(categorical_columns) != 0:
          combined = data["train"]
  
          ca_threshold = (
              combined.shape[0] * 0.25
              if ca_threshold is None
              else combined.shape[0] * ca_threshold
          )
  
          if too_many_values(
              combined[categorical_columns], ca_threshold
          ):
              cat_pipeline = Pipeline(
                  [
                      (
                          "imputer",
                          SimpleImputer(
                              strategy="constant", fill_value=""
                          ),
                      ),
                      (
                          "one_hotencoder",
                          OneHotEncoder(handle_unknown="ignore"),
                      ),
                      (
                          "transformer",
                          FunctionTransformer(
                              lambda x: x.toarray(), accept_sparse=True
                          ),
                      ),
                      ("ca", CA(n_components=-1)),
                  ]
              )
          else:
              cat_pipeline = Pipeline(
                  [
                      (
                          "imputer",
                          SimpleImputer(
                              strategy="constant", fill_value=""
                          ),
                      ),
                      (
                          "one_hotencoder",
                          OneHotEncoder(handle_unknown="ignore"),
                      ),
                  ]
              )
  
          full_pipeline.transformers.append(
              ("cat", cat_pipeline, categorical_columns)
          )
  
      train = full_pipeline.fit_transform(data["train"])
  
      train_cols = generate_column_labels(
          full_pipeline, numeric_columns, text
      )
  
      # Ternary clause because when running housing.csv,
      # the product of preprocessing is np array, but not when using landslide
      # data... not sure why
      data["train"] = pd.DataFrame(
          (
              train.toarray()
              if not isinstance(train, np.ndarray)
              else train
          ),
          columns=train_cols,
      )
      return data, full_pipeline
  
file_path: nylon/nylon/preprocessing/preprocessing_inference.py
imports: import numpy
  import pandas
  from sklearn.compose import ColumnTransformer
  from sklearn.feature_extraction.text import TfidfVectorizer
  from sklearn.pipeline import Pipeline
  from prince.ca import CA
  from nltk.stem import WordNetLemmatizer
  from nltk.tokenize import word_tokenize
  from nltk.corpus import stopwords
  from autocorrect import Speller
  from sklearn.impute import SimpleImputer
  from sklearn.preprocessing import OneHotEncoder, StandardScaler, FunctionTransformer, LabelEncoder
label_desc: Use image node_id 2 for calling a global function with example usage: structured_preprocessor(data, ca_threshold, text) and returns: data,  full_pipeline