code: def _get_handler_meta(self, module):
      handler_dir = Path(module.__path__[0])
      handler_folder_name = handler_dir.name
      dependencies = self._read_dependencies(handler_dir)
  
      self.handler_modules[module.name] = module
      import_error = getattr(module, "import_error", None)
      handler_meta = {
          "import": {
              "success": import_error is None,
              "folder": handler_folder_name,
              "dependencies": dependencies,
          },
          "version": module.version,
      }
      if import_error is not None:
          handler_meta["import"]["error_message"] = str(import_error)
  
      # for ml engines, patch the connection_args from the argument probing
      if hasattr(module, "Handler"):
          handler_class = module.Handler
          try:
              prediction_args = handler_class.prediction_args()
              creation_args = handler_class.creation_args()
              connection_args = {
                  "prediction": prediction_args,
                  "creation_args": creation_args,
              }
              setattr(module, "connection_args", connection_args)
              logger.debug(
                  "Patched connection_args for %s", handler_folder_name
              )
          except Exception as e:
              # do nothing
              logger.debug(
                  "Failed to patch connection_args for %s, reason: %s",
                  handler_folder_name,
                  str(e),
              )
      module_attrs = [
          attr
          for attr in [
              "connection_args_example",
              "connection_args",
              "description",
              "name",
              "type",
              "title",
          ]
          if hasattr(module, attr)
      ]
  
      for attr in module_attrs:
          handler_meta[attr] = getattr(module, attr)
  
      # region icon
      if hasattr(module, "icon_path"):
          icon_path = handler_dir.joinpath(module.icon_path)
          handler_meta["icon"] = {
              "name": icon_path.name,
              "type": icon_path.name[
                  icon_path.name.rfind(".") + 1 :
              ].lower(),
          }
          if handler_meta["icon"]["type"] == "svg":
              with open(str(icon_path), "rt") as f:
                  handler_meta["icon"]["data"] = f.read()
          else:
              with open(str(icon_path), "rb") as f:
                  handler_meta["icon"]["data"] = base64.b64encode(
                      f.read()
                  ).decode("utf-8")
      # endregion
      if hasattr(module, "permanent"):
          handler_meta["permanent"] = module.permanent
      else:
          if handler_meta.get("name") in (
              "files",
              "views",
              "lightwood",
          ):
              handler_meta["permanent"] = True
          else:
              handler_meta["permanent"] = False
  
      return handler_meta
  
imports: import os
  import sys
  import base64
  import shutil
  import tempfile
  import importlib
  import threading
  import inspect
  import multiprocessing
  from time import time
  from pathlib import Path
  from copy import deepcopy
  from typing import Optional
  from textwrap import dedent
  from collections import OrderedDict
  from sqlalchemy import func
  from mindsdb.interfaces.storage import db
  from mindsdb.utilities.config import Config
  from mindsdb.interfaces.storage.fs import FsStore, FileStorage, RESOURCE_GROUP
  from mindsdb.interfaces.storage.model_fs import HandlerStorage
  from mindsdb.interfaces.file.file_controller import FileController
  from mindsdb.integrations.libs.base import DatabaseHandler
  from mindsdb.integrations.libs.base import BaseMLEngine
  from mindsdb.integrations.libs.api_handler import APIHandler
  from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE, HANDLER_TYPE
  from mindsdb.integrations.handlers_client.db_client_factory import DBClient
  from mindsdb.interfaces.model.functions import get_model_records
  from mindsdb.utilities.context import context
  from mindsdb.utilities import log
  from mindsdb.integrations.libs.ml_exec_base import BaseMLEngineExec
  import mindsdb.utilities.profiler
label_desc: Use image node_id 18 for calling the IntegrationController obj's underlying member method code with example usage: obj._get_handler_meta(module) and returns: handler_meta