code: def __init__(self, plugin_dest_dir=None):
      self.src_path = os.path.dirname(os.path.realpath(__file__))
      self.dali_lib_path = get_module_path("nvidia/dali")
      self.tf_path = get_module_path("tensorflow")
      self.plugin_dest_dir = (
          os.path.join(self.src_path, "nvidia", "dali_tf_plugin")
          if plugin_dest_dir is None
          else plugin_dest_dir
      )
      self.is_conda = is_conda_env()
      self.tf_version = get_tf_version()
      self.tf_compiler = get_tf_compiler_version()
      self.cpp_compiler = get_cpp_compiler()
      self.default_cpp_version = get_cpp_compiler_version()
      self.alt_compiler = "g++-{}".format(self.tf_compiler)
      self.has_alt_compiler = which(self.alt_compiler) is not None
      self.platform_system = platform.system()
      self.platform_machine = platform.machine()
      self.is_compatible_with_prebuilt_bin = (
          self.platform_system == "Linux"
          and self.platform_machine == "x86_64"
      )
      self.prebuilt_dir = os.path.join(self.src_path, "prebuilt")
      self.prebuilt_stub_dir = os.path.join(self.prebuilt_dir, "stub")
      dali_stubs = find("libdali.so", self.prebuilt_stub_dir)
      self.prebuilt_dali_stub = (
          dali_stubs[0] if len(dali_stubs) > 0 else None
      )
  
      # If set, checking for prebuilt binaries or compiler version check is disabled
      self.always_build = bool(
          int(os.getenv("DALI_TF_ALWAYS_BUILD", "0"))
      )
  
      # Can install prebuilt if both conditions apply:
      # - we know the compiler used to build TF
      # - we have prebuilt artifacts for that compiler version
      # - We have an exact match with the TF version major.minor or an exact match of the
      #   major version and the minor version in the prebuilt plugin is lower than the
      #   requested one.
      self.can_install_prebuilt = (
          not self.always_build
          and bool(self.tf_compiler)
          and StrictVersion(self.tf_compiler) >= StrictVersion("5.0")
          and self.is_compatible_with_prebuilt_bin
          and self.prebuilt_dali_stub is not None
      )
  
      self.prebuilt_plugins_available = []
      self.prebuilt_plugin_best_match = None
      self.plugin_name = None
  
      self.prebuilt_exact_ver = False
      if self.can_install_prebuilt:
          self.prebuilt_plugins_available = find(
              "libdali_tf_*.so", self.prebuilt_dir
          )
          best_version = find_available_prebuilt_tf(
              self.tf_version, self.prebuilt_plugins_available
          )
          if best_version is None:
              # No prebuilt plugins available
              self.can_install_prebuilt = False
          else:
              self.prebuilt_exact_ver = best_version == self.tf_version
              tf_version_underscore = best_version.replace(".", "_")
              self.plugin_name = (
                  "libdali_tf_" + tf_version_underscore + ".so"
              )
              self.prebuilt_plugin_best_match = os.path.join(
                  self.prebuilt_dir, self.plugin_name
              )
  
      # Allow to compile if either condition apply
      # - The default C++ compiler version matches the one used to build TF
      # - The compiler used to build TF is unknown
      # - Both TF and default compilers are >= 5.0
      self.can_default_compile = (
          self.always_build
          or self.default_cpp_version == self.tf_compiler
          or not bool(self.tf_compiler)
          or (
              StrictVersion(self.default_cpp_version)
              >= StrictVersion("5.0")
              and StrictVersion(self.tf_compiler)
              >= StrictVersion("5.0")
          )
      )
  
imports: import platform
  from shutil import copyfile
  from dali_tf_plugin_utils import get_module_path, is_conda_env, get_tf_version, get_tf_compiler_version, get_cpp_compiler, get_cpp_compiler_version, which, find, find_available_prebuilt_tf, get_cuda_build_flags, get_tf_build_flags
  import os
  from distutils.version import StrictVersion, LooseVersion
  from pathlib import Path
  import tempfile
  from stubgen import stubgen
  from multiprocessing import Process
  import subprocess
label_desc: Use image node_id 1 to create a new InstallerHelper object  with example: obj = InstallerHelper(plugin_dest_dir)