          self.output = logger if logger else Output()
          self.updater = updater
          # Flag that setup is being run by installer so steps can be skipped
          self.is_installer = False
          self.cuda_path = ""
          self.cuda_version = ""
          self.cudnn_version = ""
          self.enable_amd = False
          self.enable_docker = False
          self.enable_cuda = False
 
</s> remove     def cuda_check(self):
        """ Check Cuda for Linux or Windows """
 </s> add class CudaCheck():  # pylint:disable=too-few-public-methods
    """ Find the location of system installed Cuda and cuDNN on Windows and Linux. """

    def __init__(self):
        self.cuda_path = None
        self.cuda_version = None
        self.cudnn_version = None

        self._os = platform.system().lower()
        self._cuda_keys = [key for key in os.environ if key.lower().startswith("cuda_path_v")]
        self._cudnn_header_files = ["cudnn_version.h", "cudnn.h"]

        if self._os in ("windows", "linux"):
            self._cuda_check()
            self._cudnn_check()

    def _cuda_check(self):
        """ Obtain the location and version of Cuda and populate :attr:`cuda_version` and
        :attr:`cuda_path`

        Initially just calls `nvcc -V` to get the installed version of Cuda currently in use.
        If this fails, drills down to more OS specific checking methods.
        """ </s> remove             version = re.search(r".*release (?P<cuda>\d+\.\d+)", stdout.decode(self.env.encoding))
            self.env.cuda_version = version.groupdict().get("cuda", None)
            if self.env.cuda_version:
                self.output.info("CUDA version: " + self.env.cuda_version)
                return
        # Failed to load nvcc
        if self.env.os_version[0] == "Linux":
            self.cuda_check_linux()
        elif self.env.os_version[0] == "Windows":
            self.cuda_check_windows()

    def cuda_check_linux(self):
        """ Check Linux CUDA Version """
 </s> add             version = re.search(r".*release (?P<cuda>\d+\.\d+)",
                                stdout.decode(locale.getpreferredencoding()))
            self.cuda_version = version.groupdict().get("cuda", None)
            locate = "where" if self._os == "windows" else "which"
            path = os.popen(f"{locate} nvcc").read()
            if path:
                path = path.split("\n")[0]  # Split multiple entries and take first found
                while True:  # Get Cuda root folder
                    path, split = os.path.split(path)
                    if split == "bin":
                        break
                self.cuda_path = path
            return

        # Failed to load nvcc, manual check
        getattr(self, f"_cuda_check_{self._os}")()

    def _cuda_check_linux(self):
        """ For Linux check the dynamic link loader for libcudart. If not found with ldconfig then
        attempt to find it in LD_LIBRARY_PATH. """ </s> remove                 self.output.info("{} not available in Conda. Installing with pip".format(package))
 </s> add                 self.output.info(f"{package} not available in Conda. Installing with pip") </s> remove                 self.output.warning("Couldn't install {} with Conda. "
                                    "Please install this package manually".format(package))
 </s> add                 self.output.warning(f"Couldn't install {package} with Conda. "
                                    "Please install this package manually")
          self.output = logger if logger else Output()
          self.updater = updater
          # Flag that setup is being run by installer so steps can be skipped
          self.is_installer = False

          self.cuda_version = ""
          self.cudnn_version = ""
          self.enable_amd = False
          self.enable_docker = False
          self.enable_cuda = False
keep keep keep keep replace keep keep keep keep keep
 sysinfo/setup - Standardize cuda/cudnn checks 
setup.py