#!/usr/bin/env python3# SPDX-License-Identifier: GPL-2.0-or-later# Copyright (c) 2017-2025 Mauro Carvalho Chehab <mchehab+huawei@kernel.org> """Handle Python version check logic. Not all Python versions are supported by scripts. Yet, on some cases,like during documentation build, a newer version of python could beavailable. This class allows checking if the minimal requirements are followed. Better than that, PythonVersion.check_python() not only checks the minimalrequirements, but it automatically switches to a the newest availablePython version if present. """ import osimport reimport subprocessimport shleximport sys from glob import globfrom textwrap import indent class PythonVersion:    """    Ancillary methods that checks for missing dependencies for different    types of types, like binaries, python modules, rpm deps, etc.    """     def __init__(self, version):        """        Ïnitialize self.version tuple from a version string.        """        self.version = self.parse_version(version)     @staticmethod    def parse_version(version):        """        Convert a major.minor.patch version into a tuple.        """        return tuple(int(x) for x in version.split("."))     @staticmethod    def ver_str(version):        """        Returns a version tuple as major.minor.patch.        """        return ".".join([str(x) for x in version])     @staticmethod    def cmd_print(cmd, max_len=80):        """        Outputs a command line, repecting maximum width.        """         cmd_line = []         for w in cmd:            w = shlex.quote(w)             if cmd_line:                if not max_len or len(cmd_line[-1]) + len(w) < max_len:                    cmd_line[-1] += " " + w                    continue                else:                    cmd_line[-1] += " \\"                    cmd_line.append(w)            else:                cmd_line.append(w)         return "\n  ".join(cmd_line)     def __str__(self):        """        Return a version tuple as major.minor.patch from self.version.        """        return self.ver_str(self.version)     @staticmethod    def get_python_version(cmd):        """        Get python version from a Python binary. As we need to detect if        are out there newer python binaries, we can't rely on sys.release here.        """         kwargs = {}        if sys.version_info < (3, 7):            kwargs['universal_newlines'] = True        else:            kwargs['text'] = True         result = subprocess.run([cmd, "--version"],                                stdout = subprocess.PIPE,                                stderr = subprocess.PIPE,                                **kwargs, check=False)         version = result.stdout.strip()         match = re.search(r"(\d+\.\d+\.\d+)", version)        if match:            return PythonVersion.parse_version(match.group(1))         print(f"Can't parse version {version}")        return (0, 0, 0)     @staticmethod    def find_python(min_version):        """        Detect if are out there any python 3.xy version newer than the        current one.         Note: this routine is limited to up to 2 digits for python3. We        may need to update it one day, hopefully on a distant future.        """        patterns = [            "python3.[0-9][0-9]",            "python3.[0-9]",        ]         python_cmd = []         # Seek for a python binary newer than min_version        for path in os.getenv("PATH", "").split(":"):            for pattern in patterns:                for cmd in glob(os.path.join(path, pattern)):                    if os.path.isfile(cmd) and os.access(cmd, os.X_OK):                        version = PythonVersion.get_python_version(cmd)                        if version >= min_version:                            python_cmd.append((version, cmd))         return sorted(python_cmd, reverse=True)     @staticmethod    def check_python(min_version, show_alternatives=False, bail_out=False,                     success_on_error=False):        """        Check if the current python binary satisfies our minimal requirement        for Sphinx build. If not, re-run with a newer version if found.        """        cur_ver = sys.version_info[:3]        if cur_ver >= min_version:            ver = PythonVersion.ver_str(cur_ver)            return         python_ver = PythonVersion.ver_str(cur_ver)         available_versions = PythonVersion.find_python(min_version)        if not available_versions:            print(f"ERROR: Python version {python_ver} is not supported anymore\n")            print("       Can't find a new version. This script may fail")            return         script_path = os.path.abspath(sys.argv[0])         # Check possible alternatives        if available_versions:            new_python_cmd = available_versions[0][1]        else:            new_python_cmd = None         if show_alternatives and available_versions:            print("You could run, instead:")            for _, cmd in available_versions:                args = [cmd, script_path] + sys.argv[1:]                 cmd_str = indent(PythonVersion.cmd_print(args), "  ")                print(f"{cmd_str}\n")         if bail_out:            msg = f"Python {python_ver} not supported. Bailing out"            if success_on_error:                print(msg, file=sys.stderr)                sys.exit(0)            else:                sys.exit(msg)         print(f"Python {python_ver} not supported. Changing to {new_python_cmd}")         # Restart script using the newer version        args = [new_python_cmd, script_path] + sys.argv[1:]         try:            os.execv(new_python_cmd, args)        except OSError as e:            sys.exit(f"Failed to restart with {new_python_cmd}: {e}")