code: def preconfigure_modules(ctx: Context, MODULES, compiler, settings):
      """Returns a list of modules buildable in given environment and settings.
  
      For each module in MODULES list, this function checks if the module
      can be built in the current environment and reports it.
      Returns a list of module names available.
      """
  
      nvcc_path = build.get_nvcc_path()
      hipcc_path = build.get_hipcc_path()
      summary = [
          "",
          "************************************************************",
          "* CuPy Configuration Summary                               *",
          "************************************************************",
          "",
          "Build Environment:",
          "  Include directories: {}".format(
              str(settings["include_dirs"])
          ),
          "  Library directories: {}".format(
              str(settings["library_dirs"])
          ),
          "  nvcc command       : {}".format(
              nvcc_path if nvcc_path else "(not found)"
          ),
          "  hipcc command      : {}".format(
              hipcc_path if hipcc_path else "(not found)"
          ),
          "",
          "Environment Variables:",
      ]
  
      for key in [
          "CFLAGS",
          "LDFLAGS",
          "LIBRARY_PATH",
          "CUDA_PATH",
          "NVCC",
          "HIPCC",
          "ROCM_HOME",
      ]:
          summary += [
              "  {:<16}: {}".format(key, os.environ.get(key, "(none)"))
          ]
  
      summary += [
          "",
          "Modules:",
      ]
  
      ret = []
      for module in MODULES:
          installed = False
          status = "No"
          errmsg = []
  
          if module["name"] == "cutensor":
              cutensor_path = os.environ.get("CUTENSOR_PATH", "")
              inc_path = os.path.join(cutensor_path, "include")
              if os.path.exists(inc_path):
                  settings["include_dirs"].append(inc_path)
              lib_path = os.path.join(cutensor_path, "lib")
              if os.path.exists(lib_path):
                  settings["library_dirs"].append(lib_path)
              cuda_version = ctx.features["cuda"].get_version()
              cuda_major = str(cuda_version // 1000)
              cuda_major_minor = (
                  cuda_major + "." + str((cuda_version // 10) % 100)
              )
              for cuda_ver in (cuda_major_minor, cuda_major):
                  lib_path = os.path.join(
                      cutensor_path, "lib", cuda_ver
                  )
                  if os.path.exists(lib_path):
                      settings["library_dirs"].append(lib_path)
                      break
  
          # In ROCm 4.1 and later, we need to use the independent version of
          # hipfft as well as rocfft. We configure the lists of include
          # directories and libraries to link here depending on ROCm version
          # before the configuration process following.
          if ctx.use_hip and module["name"] == "cuda":
              if module.configure(compiler, settings):
                  hip_version = module.get_version()
                  if hip_version >= 401:
                      rocm_path = build.get_rocm_path()
                      inc_path = os.path.join(
                          rocm_path, "hipfft", "include"
                      )
                      settings["include_dirs"].insert(0, inc_path)
                      lib_path = os.path.join(
                          rocm_path, "hipfft", "lib"
                      )
                      settings["library_dirs"].insert(0, lib_path)
                  # n.b., this modifieds MODULES['cuda']['libraries'] inplace
                  canonicalize_hip_libraries(
                      hip_version, module["libraries"]
                  )
  
          print("")
          print(
              "-------- Configuring Module: {} --------".format(
                  module["name"]
              )
          )
          sys.stdout.flush()
          if not check_library(
              compiler,
              includes=module["include"],
              include_dirs=settings["include_dirs"],
              define_macros=settings["define_macros"],
              extra_compile_args=settings["extra_compile_args"],
          ):
              errmsg = [
                  "Include files not found: %s" % module["include"],
                  "Check your CFLAGS environment variable.",
              ]
          elif not check_library(
              compiler,
              libraries=module["libraries"],
              library_dirs=settings["library_dirs"],
              define_macros=settings["define_macros"],
              extra_compile_args=settings["extra_compile_args"],
          ):
              errmsg = [
                  "Cannot link libraries: %s" % module["libraries"],
                  "Check your LDFLAGS environment variable.",
              ]
          elif not module.configure(compiler, settings):
              # Fail on per-library condition check (version requirements etc.)
              installed = True
              errmsg = ["The library is installed but not supported."]
          elif module["name"] in ("thrust", "cub", "random") and (
              nvcc_path is None and hipcc_path is None
          ):
              installed = True
              cmd = "nvcc" if not ctx.use_hip else "hipcc"
              errmsg = [
                  "{} command could not be found in PATH.".format(cmd),
                  "Check your PATH environment variable.",
              ]
          else:
              installed = True
              status = "Yes"
              ret.append(module["name"])
  
          if installed:
              version = module.get_version()
              if version is not None:
                  status += f" (version {version})"
  
          summary += ["  {:<10}: {}".format(module["name"], status)]
  
          # If error message exists...
          if len(errmsg) != 0:
              summary += ["    -> {}".format(m) for m in errmsg]
  
              # Skip checking other modules when CUDA is unavailable.
              if module["name"] == "cuda":
                  break
  
      # Get a list of the CC of the devices connected to this node
      if not ctx.use_hip:
          build.check_compute_capabilities(compiler, settings)
  
      if len(ret) != len(MODULES):
          if "cuda" in ret:
              lines = [
                  "WARNING: Some modules could not be configured.",
                  "CuPy will be installed without these modules.",
              ]
          else:
              lines = [
                  "ERROR: CUDA could not be found on your system.",
                  "",
                  "HINT: You are trying to build CuPy from source, "
                  "which is NOT recommended for general use.",
                  "      Please consider using binary packages instead.",
                  "",
              ]
          summary += (
              [
                  "",
              ]
              + lines
              + [
                  "Please refer to the Installation Guide for details:",
                  "https://docs.cupy.dev/en/stable/install.html",
                  "",
              ]
          )
  
      summary += [
          "************************************************************",
          "",
      ]
  
      print("\n".join(summary))
      return ret, settings
  
imports: import copy
  from distutils import ccompiler
  from distutils import sysconfig
  import os
  import shutil
  import sys
  import setuptools
  import cupy_builder.install_build
  from cupy_builder._context import Context
  from cupy_builder.install_build import PLATFORM_LINUX
  from cupy_builder.install_build import PLATFORM_WIN32
label_desc: Use image node_id 7 for calling a global function with example usage: preconfigure_modules(ctx, MODULES, compiler, settings) and returns: ret,  settings