code: def get_cmdclass():
      """Get the custom setuptools/distutils subclasses used by Versioneer."""
      if "versioneer" in sys.modules:
          del sys.modules["versioneer"]
          # this fixes the "python setup.py develop" case (also 'install' and
          # 'easy_install .'), in which subdependencies of the main project are
          # built (using setup.py bdist_egg) in the same python process. Assume
          # a main project A and a dependency B, which use different versions
          # of Versioneer. A's setup.py imports A's Versioneer, leaving it in
          # sys.modules by the time B's setup.py is executed, causing B to run
          # with the wrong versioneer. Setuptools wraps the sub-dep builds in a
          # sandbox that restores sys.modules to it's pre-build state, so the
          # parent is protected against the child's "import versioneer". By
          # removing ourselves from sys.modules here, before the child build
          # happens, we protect the child from the parent's versioneer too.
          # Also see https://github.com/warner/python-versioneer/issues/52
  
      cmds = {}
  
      # we add "version" to both distutils and setuptools
      from distutils.core import Command
  
      class cmd_version(Command):
          description = "report generated version string"
          user_options = []
          boolean_options = []
  
          def initialize_options(self):
              pass
  
          def finalize_options(self):
              pass
  
          def run(self):
              vers = get_versions(verbose=True)
              print("Version: %s" % vers["version"])
              print(
                  " full-revisionid: %s" % vers.get("full-revisionid")
              )
              print(" dirty: %s" % vers.get("dirty"))
              if vers["error"]:
                  print(" error: %s" % vers["error"])
  
      cmds["version"] = cmd_version
  
      # we override "build_py" in both distutils and setuptools
      #
      # most invocation pathways end up running build_py:
      #  distutils/build -> build_py
      #  distutils/install -> distutils/build ->..
      #  setuptools/bdist_wheel -> distutils/install ->..
      #  setuptools/bdist_egg -> distutils/install_lib -> build_py
      #  setuptools/install -> bdist_egg ->..
      #  setuptools/develop -> ?
  
      # we override different "build_py" commands for both environments
      if "setuptools" in sys.modules:
          from setuptools.command.build_py import build_py as _build_py
      else:
          from distutils.command.build_py import build_py as _build_py
  
      class cmd_build_py(_build_py):
          def run(self):
              root = get_root()
              cfg = get_config_from_root(root)
              versions = get_versions()
              _build_py.run(self)
              # now locate _version.py in the new build/ directory and replace
              # it with an updated value
              if cfg.versionfile_build:
                  target_versionfile = os.path.join(
                      self.build_lib, cfg.versionfile_build
                  )
                  print("UPDATING %s" % target_versionfile)
                  write_to_version_file(target_versionfile, versions)
  
      cmds["build_py"] = cmd_build_py
  
      if "cx_Freeze" in sys.modules:  # cx_freeze enabled?
          from cx_Freeze.dist import build_exe as _build_exe
  
          class cmd_build_exe(_build_exe):
              def run(self):
                  root = get_root()
                  cfg = get_config_from_root(root)
                  versions = get_versions()
                  target_versionfile = cfg.versionfile_source
                  print("UPDATING %s" % target_versionfile)
                  write_to_version_file(target_versionfile, versions)
  
                  _build_exe.run(self)
                  os.unlink(target_versionfile)
                  with open(cfg.versionfile_source, "w") as f:
                      LONG = LONG_VERSION_PY[cfg.VCS]
                      f.write(
                          LONG
                          % {
                              "DOLLAR": "$",
                              "STYLE": cfg.style,
                              "TAG_PREFIX": cfg.tag_prefix,
                              "PARENTDIR_PREFIX": cfg.parentdir_prefix,
                              "VERSIONFILE_SOURCE": cfg.versionfile_source,
                          }
                      )
  
          cmds["build_exe"] = cmd_build_exe
          del cmds["build_py"]
  
      # we override different "sdist" commands for both environments
      if "setuptools" in sys.modules:
          from setuptools.command.sdist import sdist as _sdist
      else:
          from distutils.command.sdist import sdist as _sdist
  
      class cmd_sdist(_sdist):
          def run(self):
              versions = get_versions()
              self._versioneer_generated_versions = versions
              # unless we update this, the command will keep using the old
              # version
              self.distribution.metadata.version = versions["version"]
              return _sdist.run(self)
  
          def make_release_tree(self, base_dir, files):
              root = get_root()
              cfg = get_config_from_root(root)
              _sdist.make_release_tree(self, base_dir, files)
              # now locate _version.py in the new base_dir directory
              # (remembering that it may be a hardlink) and replace it with an
              # updated value
              target_versionfile = os.path.join(
                  base_dir, cfg.versionfile_source
              )
              print("UPDATING %s" % target_versionfile)
              write_to_version_file(
                  target_versionfile,
                  self._versioneer_generated_versions,
              )
  
      cmds["sdist"] = cmd_sdist
  
      return cmds
  
imports: from __future__ import print_function
  import errno
  import json
  import os
  import re
  import subprocess
  import sys
label_desc: Use image node_id 22 for calling a global function with example usage: get_cmdclass() and returns: cmds, _sdist