class_docstr: Set up executor: mock data handler
code: def set_executor(
      self,
      mock_lightwood=False,
      mock_model_controller=False,
      import_dummy_ml=False,
      import_dummy_llm=False,
  ):
      # creates executor instance with mocked model_interface
      from mindsdb.api.executor.controllers.session_controller import (
          SessionController,
      )
      from mindsdb.api.executor.command_executor import (
          ExecuteCommands,
      )
      from mindsdb.interfaces.database.integrations import (
          integration_controller,
      )
      from mindsdb.interfaces.file.file_controller import FileController
      from mindsdb.interfaces.model.model_controller import (
          ModelController,
      )
      from mindsdb.utilities.context import context as ctx
  
      self.file_controller = FileController()
  
      if mock_model_controller:
          model_controller = mock.Mock()
          self.mock_model_controller = model_controller
      else:
          model_controller = ModelController()
  
      # no predictors yet
      # self.mock_model_controller.get_models.side_effect = lambda: []
  
      if import_dummy_ml:
          test_handler_path = os.path.dirname(__file__)
          sys.path.append(test_handler_path)
  
          handler_dir = Path(test_handler_path) / "dummy_ml_handler"
          integration_controller.import_handler("", handler_dir)
  
          if not integration_controller.handlers_import_status[
              "dummy_ml"
          ]["import"]["success"]:
              error = integration_controller.handlers_import_status[
                  "dummy_ml"
              ]["import"]["error_message"]
              raise Exception(
                  f"Can not import: {str(handler_dir)}: {error}"
              )
  
      if import_dummy_llm:
          test_handler_path = os.path.dirname(__file__)
          sys.path.append(test_handler_path)
  
          handler_dir = Path(test_handler_path) / "dummy_llm_handler"
          integration_controller.import_handler("", handler_dir)
  
          if not integration_controller.handlers_import_status[
              "dummy_llm"
          ]["import"]["success"]:
              error = integration_controller.handlers_import_status[
                  "dummy_llm"
              ]["import"]["error_message"]
              raise Exception(
                  f"Can not import: {str(handler_dir)}: {error}"
              )
  
      if mock_lightwood:
          predict_patcher = mock.patch(
              "mindsdb.integrations.libs.ml_exec_base.BaseMLEngineExec.predict"
          )
          self.mock_predict = predict_patcher.__enter__()
  
          create_patcher = mock.patch(
              "mindsdb.integrations.handlers.lightwood_handler.Handler.create"
          )
          self.mock_create = create_patcher.__enter__()
  
      ctx.set_default()
      sql_session = SessionController()
      sql_session.database = "mindsdb"
      sql_session.integration_controller = integration_controller
  
      self.command_executor = ExecuteCommands(sql_session)
  
      # disable cache. it is need to check predictor input
      config_patch = mock.patch("mindsdb.utilities.cache.FileCache.get")
      self.mock_config = config_patch.__enter__()
      self.mock_config.side_effect = lambda x: None
  
imports: import copy
  import datetime
  import json
  import os
  import sys
  import tempfile
  from unittest import mock
  from pathlib import Path
  import duckdb
  import numpy
  import pandas
  from mindsdb_sql.render.sqlalchemy_render import SqlalchemyRender
  from mindsdb_sql import parse_sql
label_desc: Use image node_id 2 for calling the BaseExecutorTest obj's underlying member method code with example usage: obj.set_executor(mock_lightwood, mock_model_controller, import_dummy_ml, import_dummy_llm) without return types