code: def available_acceleration_combination(
      excludes: Optional[List[str]],
      includes: Optional[List[str]],
      full_methods: Dict[str, AccelerationOption],
      all_methods: Dict[str, AccelerationOption] = None,
  ):
      """
      :return: a dictionary states the availability (if meet dependencies)
      """
      dependency_checker = {
          "inc": _inc_checker,
          "ipex": _ipex_checker,
          "onnxruntime": _onnxruntime_checker,
          "openvino": _openvino_checker,
          "pot": _openvino_checker,
      }
      if excludes is None:
          exclude_set: Set[str] = set()
      else:
          exclude_set: Set[str] = set(excludes)
          exclude_set.discard("original")
  
      if includes is None:
          include_set: Set[str] = set(full_methods.keys())
      else:
          include_set: Set[str] = set(includes)
          include_set.add("original")
          if all_methods is not None:
              for method in include_set:
                  if method not in full_methods:
                      # append include method into full methods
                      full_methods[method] = all_methods[method]
  
      available_dict = {}
      for method, option in full_methods.items():
          if method not in include_set:
              continue
  
          if method in exclude_set:
              continue
  
          available_iter = True
          for name, value in option.__dict__.items():
              if value is True:
                  if (
                      name in dependency_checker
                      and not dependency_checker[name]()
                  ):
                      available_iter = False
          available_dict[method] = available_iter
      return available_dict
  
file_path: BigDL/python/nano/src/bigdl/nano/utils/common/optimizer/acceleration_option.py
imports: from abc import abstractmethod
  from typing import Optional, List, Set, Dict
  from bigdl.nano.utils.common import _inc_checker, _ipex_checker, _onnxruntime_checker, _openvino_checker
label_desc: Use image node_id 1 for calling a global function with example usage: available_acceleration_combination(excludes, includes, full_methods, all_methods) and returns: available_dict