code: def preprocess_module(request_info):
      json_file = request_info["json"]
      df = request_info["df"]
  
      shuffle_during_split = "preserve" not in request_info
  
      df_pre_transform = None
  
      if "preprocessor" in json_file:
          preprocess = json_file["preprocessor"]
  
          target = json_file["data"]["target"]
  
          df_pre_transform = df.copy()
  
          del df_pre_transform[target]
  
          target_transformers = []
  
          for element in preprocess:
              if element not in preprocess_vocab:
                  raise Exception(
                      "Your specificed preprocessing technique -- {} -- is not supported".format(
                          element
                      )
                  )
              if element == "custom":
                  sys_path = "/nylon/supplementaries/buffer/"
                  sys.path.insert(1, os.getcwd() + sys_path)
  
                  absolute_path = (
                      os.path.abspath(os.getcwd())
                      + "/nylon/supplementaries/buffer/temp.py"
                  )
  
                  file_name = json_file["preprocessor"]["custom"][
                      "loc"
                  ].rsplit("/")[-1]
                  shutil.copy(
                      json_file["preprocessor"]["custom"]["loc"],
                      absolute_path,
                  )
  
                  mod = import_module("temp")
                  new_func = getattr(
                      mod, json_file["preprocessor"]["custom"]["name"]
                  )
  
                  df = new_func(df, json_file)
                  sys.path.remove(sys_path)
                  os.remove("./buffer/temp.py")
  
              result = None
  
              if element == "label-encode":
                  result = handle_label_encode(preprocess, df, target)
              if element == "dates":
                  result = handle_dates(preprocess, df)
              if element == "clean-text":
                  result = handle_text(preprocess, df)
              if element == "embed":
                  result = handle_embedding(preprocess, df)
              if element == "fill":
                  result = handle_filling(preprocess, df, target)
                  null_rows = result.pop()
                  df_pre_transform = df_pre_transform.drop(null_rows)
  
              if element == "scale":
                  result = handle_scaling(preprocess, df, target)
              if element == "min-max":
                  result = handle_min_max(preprocess, df, target)
              if element == "ordinal":
                  result = handle_ordinal(preprocess, df, target)
              if element == "importance":
                  result = handle_importance(preprocess, df, target)
              if element == "one-hot":
                  result = handle_one_hot(preprocess, df, target)
  
              df = result.pop()
  
              if len(result) > 0:
                  for transformer in result:
                      target_transformers.append(transformer)
  
          request_info["target-transforms"] = target_transformers
  
          y = df[target]
  
          del df[target]
  
          X_train, X_test, y_train, y_test = train_test_split(
              df, y, test_size=0.2, shuffle=shuffle_during_split
          )
  
          df = {
              "train": pd.concat([X_train], axis=1),
              "test": pd.concat([X_test], axis=1),
          }
          y = {"train": y_train, "test": y_test}
  
          try:
              val = LinearRegression().fit(df["train"], y["train"])
          except:
              raise Exception(
                  "The preprocessing modules you provided is not sufficient"
              )
      else:
          json_file["shuffle"] = shuffle_during_split
          (
              df,
              y,
              df_pre_transform,
              target_transformers,
          ) = initial_preprocessor(df, json_file)
  
          request_info["target-transforms"] = target_transformers
  
      request_info["initial-data"] = df_pre_transform
  
      x_train, y_train = df["train"], y["train"]
      x_cols, y_col = list(x_train.columns), str(y_train.name)
      request_info["col_names"] = {"x": x_cols, "y": y_col}
      perform_pca = "pca" in request_info
      if perform_pca:
          perform_pca = request_info["pca"]
      if perform_pca:
          train_x, test_x = df["train"], df["test"]
          x_data = pd.concat([train_x, test_x])
          pca_model = PCA()
          fitted_pca = pca_model.fit(x_data)
          request_info["pca_model"] = fitted_pca
          X_train, X_test = train_test_split(x_data, test_size=0.2)
          X_train_pca = applyPCATransformation(fitted_pca, X_train)
          X_test_pca = applyPCATransformation(fitted_pca, X_test)
          df = {"train": X_train_pca, "test": X_test_pca}
      request_info["df"] = df
      request_info["y"] = y
  
      return request_info
  
imports: from pandas.core.algorithms import mode
  from pandas.io import json
  from sklearn.metrics import accuracy_score
  from sklearn.linear_model import LinearRegression
  from sklearn.ensemble import RandomForestRegressor
  import os
  from sklearn.ensemble import BaggingClassifier
  import sys
  from importlib import import_module
  import shutil
  from sklearn.ensemble import VotingClassifier
  import ssl
  from nylon.preprocessing.preprocessing import initial_preprocessor
  import nltk
  import pandas
  import time
  from sklearn.model_selection import train_test_split
  from sklearn.decomposition import PCA
  from nylon.modeling.modeling import a_svm, nearest_neighbors, a_tree, sgd, gradient_boosting, adaboost, rf, mlp, default_modeling, svm_stroke, ensemble_stroke
  from nylon.preprocessing.preprocessing_methods import handle_scaling, handle_min_max, handle_label_encode, handle_ordinal, handle_filling, handle_importance, handle_one_hot, handle_text, handle_embedding, handle_dates
  from nylon.analysis.analysis import default_analysis, acc_score, cross_score, confusion, precision_calculation, recall_score_helper
  from nylon.data.reader import DataReader
label_desc: Use image node_id 1 for calling a global function with example usage: preprocess_module(request_info) and returns: request_info