Update Python from https://github.com/adang1345/PythonWin7

update_python.py

# coding=utf-8
from __future__ import annotations

import logging
import ssl
from http import HTTPStatus
from http.client import HTTPResponse
from json import loads
from pathlib import Path
from platform import uname, uname_result
from subprocess import run
from sys import exc_info, version_info
from tempfile import TemporaryDirectory
from traceback import format_exception
from typing import Iterable, Literal, cast
from urllib import request

from packaging.version import Version

logger: logging.Logger = logging.getLogger(Path(__file__).name)

TIMEOUT: float = 10


def no_cert_context() -> ssl.SSLContext:
    context: ssl.SSLContext = ssl.create_default_context()
    context.check_hostname = False
    context.verify_mode = ssl.CERT_NONE
    return context


def get_github_files(
    user: str,
    repo_name: str,
    branch: str = "master",
) -> list[dict[str, int | str]]:
    url: str = f"https://api.github.com/repos/{user}/{repo_name}/commits/{branch}"
    logger.debug(f"Requesting {url}")
    r: HTTPResponse
    with request.urlopen(url, timeout=TIMEOUT, context=no_cert_context()) as r:
        logger.debug(f"{url!r}: Response code: {r.getcode()}")
        if r.getcode() != HTTPStatus.OK:
            logger.warning(f"{url!r}: Response code is not OK: {r.getcode()}")
            return []
        content: bytes = r.read()
    if not content:
        logger.warning(f"No data received from {url}")
        return []
    d: dict[
        str,
        str
        | dict[str, bool | int | str]
        | dict[str, int | str | dict[str, bool | str] | dict[str, str]]
        | dict[str, int]
        | list[dict[str, int | str]]
        | list[dict[str, str]],
    ] = loads(content)
    return d.get("files", [])


def get_recent_version(
    files_data: list[dict[str, int | str]],
    is64bit: bool,
    embed: bool = False,
    extension: Literal[".exe", ".zip"] = ".exe",
    restrict_to: Version | None = None,
) -> tuple[dict[str, int | str], Version] | tuple[None, None]:
    newest_version: Version | None = None
    newest_file: dict[str, int | str] | None = None
    for file in files_data:
        if file["filename"].count("/") != 1:
            logger.warning(f"Invalid filename: {file['filename']!r}")
            continue
        this_version_str: str
        filename: str
        this_version_str, filename = file["filename"].split("/", maxsplit=1)
        if not filename.endswith(extension):
            continue
        if is64bit and "amd64" not in filename:
            continue
        if embed != ("embed" in filename):
            continue
        this_version: Version = Version(this_version_str)
        if restrict_to is not None and not this_version.public.startswith(
            restrict_to.public
        ):
            continue
        if newest_version is None or newest_version < this_version:
            newest_version = this_version
            newest_file = file

    return newest_file, newest_version


def get_github_file(file_data: dict[str, int | str]) -> tuple[bytes, str]:
    if (
        "contents_url" not in file_data
        and "raw_url" not in file_data
        and "blob_url" not in file_data
    ):
        raise ValueError("No URL given")

    size: int | None = None
    url: str = ""
    filename: str = ""
    content: bytes
    r: HTTPResponse
    if "contents_url" in file_data:
        url = file_data["contents_url"]
        with request.urlopen(url, timeout=TIMEOUT, context=no_cert_context()) as r:
            logger.debug(f"{url!r}: Response code: {r.getcode()}")
            if r.getcode() != HTTPStatus.OK:
                logger.warning(f"{url!r}: Response code is not OK: {r.getcode()}")
            else:
                content = r.read()
                if content:
                    file_description: dict[str, str | dict[str, str]] = loads(content)
                    url = file_description.get("download_url", "")
                    if (
                        "sha" in file_description
                        and file_description["sha"] != file_data["sha"]
                    ):
                        logger.warning(f"{url!r}: SHA mismatch")
                    if "size" in file_description:
                        size = cast(int, file_description["size"])
                    if "name" in file_description:
                        filename = file_description["name"]
    if not url:
        url = file_data["raw_url"] or file_data["blob_url"]
    if not filename:
        filename = url.split("/")[-1]
    with request.urlopen(url, timeout=TIMEOUT, context=no_cert_context()) as r:
        logger.debug(f"{url!r}: Response code: {r.getcode()}")
        if r.getcode() != HTTPStatus.OK:
            logger.warning(f"{url!r}: Response code is not OK: {r.getcode()}")
            return b"", filename
        content = r.read()
    if size is not None and len(content) != size:
        logger.warning(f"{url!r}: size mismatch: {size} != {len(content)}")
    return content, filename


def install(
    micro_only: bool = True,
    *,
    quiet: bool = True,
    all_users: bool = False,
    prepend_path: bool = True,
    include_doc: bool = False,
    include_test: bool = False,
    other_args: Iterable[str] = (),
) -> int:
    u: uname_result = uname()
    if (u.system, u.release) != ("Windows", "7"):
        raise NotImplementedError("Only Windows 7 is supported")
    all_files: list[dict[str, int | str]] = get_github_files("adang1345", "PythonWin7")
    most_recent_file_data: dict[str, int | str] | None
    most_recent_file_version: Version | None
    most_recent_file_data, most_recent_file_version = get_recent_version(
        all_files,
        is64bit=(u.machine in ("AMD64", "x86_64")),
        restrict_to=(
            Version(".".join(map(str, [version_info.major, version_info.minor])))
            if micro_only
            else None
        ),
    )
    if most_recent_file_data is None:
        logger.warning("No matching release found")
        return 1

    logger.info(f"Found Python {most_recent_file_version} installer")
    print(f"Found Python {most_recent_file_version} installer")
    current_python_version: Version = Version(
        ".".join(map(str, filter(lambda v: v != "final", version_info)))
    )
    if current_python_version >= most_recent_file_version:
        print(
            f"Current Python version {current_python_version} is new enough. Exiting…"
        )
        return 0

    logger.info(f"Downloading Python {most_recent_file_version} installer…")
    print(f"Downloading Python {most_recent_file_version} installer…")
    data, name = get_github_file(most_recent_file_data)
    logger.info(f"Done. Installing Python {most_recent_file_version}…")
    print(f"Done. Installing Python {most_recent_file_version}…")

    with TemporaryDirectory() as tmpdir:
        pe_file: Path = Path(tmpdir) / name
        pe_file.write_bytes(data)

        try:
            ret: int = run(
                [pe_file]
                + (["/quiet"] if quiet else [])
                + [
                    f"InstallAllUsers={int(all_users)}",
                    f"PrependPath={int(prepend_path)}",
                    f"Include_doc={int(include_doc)}",
                    f"Include_test={int(include_test)}",
                ]
                + list(other_args),
                cwd=tmpdir,
                check=True,
            ).returncode
        except Exception as ex:
            logger.error(ex)
            if isinstance(ex, FileNotFoundError):
                logger.error(ex.filename or pe_file)
            logger.error("".join(format_exception(*exc_info())))
            input("Press Enter to continue")
        else:
            logger.info("Done")
            print("Done")
            return ret


if __name__ == "__main__":

    def main() -> int:
        from argparse import ArgumentParser, Namespace

        parser: ArgumentParser = ArgumentParser(
            description="Windows 7 only! Update Python from https://github.com/adang1345/PythonWin7.",
            epilog=" ".join(
                (
                    "Other arguments are passed directly to the Python installer",
                    "and may supersede the parameters above.",
                    "See https://docs.python.org/3/using/windows.html#installing-without-ui.",
                )
            ),
            prefix_chars="-/",
        )
        parser.add_argument(
            *("-F", "/F"),
            action="store_true",
            help="Install the newest available version, regardless of the currently installed one",
        )
        parser.add_argument(
            *("-q", "--quiet", "/quiet"),
            action="store_true",
            help="Install without displaying any UI",
        )
        parser.add_argument(
            "--all-users",
            action="store_true",
            help="Perform a system-wide installation (InstallAllUsers=1)",
        )
        parser.add_argument(
            "--prepend-path",
            action="store_true",
            help="Prepend install and Scripts directories to PATH and add .PY to PATHEXT (PrependPath=1)",
        )
        parser.add_argument(
            "--include-doc",
            action="store_true",
            help="Install Python manual (Include_doc=1)",
        )
        parser.add_argument(
            "--include-test",
            action="store_true",
            help="Install standard library test suite (Include_test=1)",
        )
        args: Namespace
        leftovers: list[str]
        args, leftovers = parser.parse_known_args()
        for a in leftovers.copy():
            if "=" not in a:
                continue
            k, v = a.split("=", maxsplit=1)
            if k == "InstallAllUsers":
                args.all_users = bool(int(v))
                leftovers.remove(a)
            elif k == "PrependPath":
                args.prepend_path = bool(int(v))
                leftovers.remove(a)
            elif k == "Include_doc":
                args.include_doc = bool(int(v))
                leftovers.remove(a)
            elif k == "Include_test":
                args.include_test = bool(int(v))
                leftovers.remove(a)
        return install(
            micro_only=not args.F,
            quiet=args.quiet,
            all_users=args.all_users,
            prepend_path=args.prepend_path,
            include_doc=args.include_doc,
            include_test=args.include_test,
            other_args=leftovers,
        )

    exit(main())