code: def finalize_options(self):
      from distutils import sysconfig
  
      self.set_undefined_options(
          "build",
          ("build_lib", "build_lib"),
          ("build_temp", "build_temp"),
          ("compiler", "compiler"),
          ("debug", "debug"),
          ("force", "force"),
          ("parallel", "parallel"),
          ("plat_name", "plat_name"),
      )
  
      if self.package is None:
          self.package = self.distribution.ext_package
  
      self.extensions = self.distribution.ext_modules
  
      # Make sure Python's include directories (for Python.h, pyconfig.h,
      # etc.) are in the include search path.
      py_include = sysconfig.get_python_inc()
      plat_py_include = sysconfig.get_python_inc(plat_specific=1)
      if self.include_dirs is None:
          self.include_dirs = self.distribution.include_dirs or []
      if isinstance(self.include_dirs, str):
          self.include_dirs = self.include_dirs.split(os.pathsep)
  
      # If in a virtualenv, add its include directory
      # Issue 16116
      if sys.exec_prefix != sys.base_exec_prefix:
          self.include_dirs.append(
              os.path.join(sys.exec_prefix, "include")
          )
  
      # Put the Python "system" include dir at the end, so that
      # any local include dirs take precedence.
      self.include_dirs.extend(py_include.split(os.path.pathsep))
      if plat_py_include != py_include:
          self.include_dirs.extend(
              plat_py_include.split(os.path.pathsep)
          )
  
      self.ensure_string_list("libraries")
      self.ensure_string_list("link_objects")
  
      # Life is easier if we're not forever checking for None, so
      # simplify these options to empty lists if unset
      if self.libraries is None:
          self.libraries = []
      if self.library_dirs is None:
          self.library_dirs = []
      elif isinstance(self.library_dirs, str):
          self.library_dirs = self.library_dirs.split(os.pathsep)
  
      if self.rpath is None:
          self.rpath = []
      elif isinstance(self.rpath, str):
          self.rpath = self.rpath.split(os.pathsep)
  
      # for extensions under windows use different directories
      # for Release and Debug builds.
      # also Python's library directory must be appended to library_dirs
      if os.name == "nt":
          # the 'libs' directory is for binary installs - we assume that
          # must be the *native* platform.  But we don't really support
          # cross-compiling via a binary install anyway, so we let it go.
          self.library_dirs.append(
              os.path.join(sys.exec_prefix, "libs")
          )
          if sys.base_exec_prefix != sys.prefix:  # Issue 16116
              self.library_dirs.append(
                  os.path.join(sys.base_exec_prefix, "libs")
              )
          if self.debug:
              self.build_temp = os.path.join(self.build_temp, "Debug")
          else:
              self.build_temp = os.path.join(self.build_temp, "Release")
  
          # Append the source distribution include and library directories,
          # this allows distutils on windows to work in the source tree
          self.include_dirs.append(
              os.path.dirname(get_config_h_filename())
          )
          _sys_home = getattr(sys, "_home", None)
          if _sys_home:
              self.library_dirs.append(_sys_home)
  
          # Use the .lib files for the correct architecture
          if self.plat_name == "win32":
              suffix = "win32"
          else:
              # win-amd64
              suffix = self.plat_name[4:]
          new_lib = os.path.join(sys.exec_prefix, "PCbuild")
          if suffix:
              new_lib = os.path.join(new_lib, suffix)
          self.library_dirs.append(new_lib)
  
      # For extensions under Cygwin, Python's library directory must be
      # appended to library_dirs
      if sys.platform[:6] == "cygwin":
          if sys.executable.startswith(
              os.path.join(sys.exec_prefix, "bin")
          ):
              # building third party extensions
              self.library_dirs.append(
                  os.path.join(
                      sys.prefix,
                      "lib",
                      "python" + get_python_version(),
                      "config",
                  )
              )
          else:
              # building python standard extensions
              self.library_dirs.append(".")
  
      # For building extensions with a shared Python library,
      # Python's library directory must be appended to library_dirs
      # See Issues: #1600860, #4366
      if sysconfig.get_config_var("Py_ENABLE_SHARED"):
          if not sysconfig.python_build:
              # building third party extensions
              self.library_dirs.append(
                  sysconfig.get_config_var("LIBDIR")
              )
          else:
              # building python standard extensions
              self.library_dirs.append(".")
  
      # The argument parsing will result in self.define being a string, but
      # it has to be a list of 2-tuples.  All the preprocessor symbols
      # specified by the 'define' option will be set to '1'.  Multiple
      # symbols can be separated with commas.
  
      if self.define:
          defines = self.define.split(",")
          self.define = [(symbol, "1") for symbol in defines]
  
      # The option for macros to undefine is also a string from the
      # option parsing, but has to be a list.  Multiple symbols can also
      # be separated with commas here.
      if self.undef:
          self.undef = self.undef.split(",")
  
      if self.swig_opts is None:
          self.swig_opts = []
      else:
          self.swig_opts = self.swig_opts.split(" ")
  
      # Finally add the user include and library directories if requested
      if self.user:
          user_include = os.path.join(USER_BASE, "include")
          user_lib = os.path.join(USER_BASE, "lib")
          if os.path.isdir(user_include):
              self.include_dirs.append(user_include)
          if os.path.isdir(user_lib):
              self.library_dirs.append(user_lib)
              self.rpath.append(user_lib)
  
      if isinstance(self.parallel, str):
          try:
              self.parallel = int(self.parallel)
          except ValueError:
              raise DistutilsOptionError(
                  "parallel should be an integer"
              )
  
imports: import contextlib
  import os
  import re
  import sys
  from distutils.core import Command
  from distutils.errors import *
  from distutils.sysconfig import customize_compiler, get_python_version
  from distutils.sysconfig import get_config_h_filename
  from distutils.dep_util import newer_group
  from distutils.extension import Extension
  from distutils.util import get_platform
  from distutils import log
  from site import USER_BASE
label_desc: Use image node_id 2 for calling the build_ext obj's underlying member method code with example usage: obj.finalize_options() without return types