daktari 0.0.236__py3-none-any.whl → 0.0.254__py3-none-any.whl

daktari/checks/kubernetes.py

@@ -1,154 +0,0 @@
-import json
-import logging
-import re
-from typing import Optional, List
-
-from semver import VersionInfo
-
-from daktari.check import Check, CheckResult
-from daktari.command_utils import get_stdout, can_run_command
-from daktari.os import OS
-from daktari.version_utils import try_parse_semver
-from daktari.checks.google import GkeGcloudAuthPluginInstalled
-
-
-class KubectlInstalled(Check):
-    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
-        self.required_version = required_version
-        self.recommended_version = recommended_version
-        self.name = "kubectl.installed"
-        self.suggestions = {
-            OS.OS_X: "<cmd>brew install kubectl</cmd>",
-            OS.UBUNTU: "<cmd>sudo snap install kubectl --classic</cmd>",
-            OS.GENERIC: "Install kubectl: https://kubernetes.io/docs/tasks/tools/#kubectl",
-        }
-
-    def check(self) -> CheckResult:
-        installed_version = get_kubectl_version()
-        return self.validate_semver_expression(
-            "Kubectl", installed_version, self.required_version, self.recommended_version
-        )
-
-
-version_pattern = re.compile("Client Version: v(.*)")
-
-
-def get_kubectl_version() -> Optional[VersionInfo]:
-    raw_version = get_stdout("kubectl version --client=true --short")
-    # Handle deprecation of --short
-    if raw_version is None:
-        raw_version = get_stdout("kubectl version --client=true")
-
-    if raw_version:
-        match = version_pattern.search(raw_version)
-        if match:
-            version = try_parse_semver(match.group(1))
-            logging.debug(f"Kubectl version: {version}")
-            return version
-    return None
-
-
-class KubectlContextExists(Check):
-    depends_on = [GkeGcloudAuthPluginInstalled]
-
-    def __init__(self, context_name: str, provision_command: str = ""):
-        self.context_name = context_name
-        self.name = f"kubectl.contextExists.{context_name}"
-        self.suggestions = {OS.GENERIC: provision_command}
-
-    def check(self) -> CheckResult:
-        output = get_stdout("kubectl config get-contexts")
-        passed = bool(output and self.context_name in output)
-        if not passed:
-            return self.failed(f"{self.context_name} is <not/> configured for the current user")
-
-        can_connect = can_run_command(f"kubectl get ns --context {self.context_name}")
-        return self.verify(can_connect, f"Could <not/> connect to context {self.context_name}")
-
-
-class KubectlNoExtraneousContexts(Check):
-    def __init__(self, expected_contexts: List[str]):
-        self.expected_contexts = expected_contexts
-        self.name = "kubectl.noExtraneousContexts"
-
-    def check(self) -> CheckResult:
-        output = get_stdout("kubectl config get-contexts -o name")
-        if not output:
-            return self.failed("Failed to list kubectl contexts")
-
-        contexts = output.splitlines()
-        extraneous_contexts = list(filter(lambda context: context not in self.expected_contexts, contexts))
-        if extraneous_contexts:
-            suggestion = "\n".join(
-                f"<cmd>kubectl config delete-context {context}</cmd>" for context in extraneous_contexts
-            )
-            self.suggestions = {
-                OS.GENERIC: suggestion,
-            }
-            return self.passed_with_warning(f"{len(extraneous_contexts)} extraneous kubectl context(s) found")
-
-        return self.passed("No extraneous kubectl contexts found")
-
-
-class HelmInstalled(Check):
-    name = "helm.installed"
-
-    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
-        self.required_version = required_version
-        self.recommended_version = recommended_version
-        self.suggestions = {
-            OS.OS_X: "<cmd>brew install helm</cmd>",
-            OS.UBUNTU: "<cmd>sudo snap install helm --classic</cmd>",
-            OS.GENERIC: "Install Helm: https://helm.sh/docs/intro/install/",
-        }
-
-    def check(self) -> CheckResult:
-        installed_version = get_helm_version()
-        return self.validate_semver_expression(
-            "Helm", installed_version, self.required_version, self.recommended_version
-        )
-
-
-helm_version_pattern = re.compile("v([0-9\\.]+)")
-
-
-def get_helm_version() -> Optional[VersionInfo]:
-    raw_version = get_stdout("helm version --short")
-    if raw_version:
-        match = helm_version_pattern.search(raw_version)
-        if match:
-            version = try_parse_semver(match.group(1))
-            logging.debug(f"Helm Version: {version}")
-            return version
-    return None
-
-
-class HelmRepoExists(Check):
-    depends_on = [HelmInstalled]
-
-    def __init__(self, repo_name: str, repo_url: str):
-        self.repo_name = repo_name
-        self.repo_url = repo_url.strip("/")
-        self.name = f"helm.repoExists.{repo_name}"
-        self.suggestions = {
-            OS.GENERIC: f"<cmd>helm repo add {repo_name} {repo_url} --force-update</cmd>",
-        }
-
-    def check(self) -> CheckResult:
-        output = get_stdout("helm repo list -o json")
-        if not output:
-            return self.failed("No helm repos appear to be configured for the current user.")
-        repo_json = json.loads(output)
-        repo = next(filter(lambda repo_details: repo_details.get("name") == self.repo_name, repo_json), None)
-        if repo is None:
-            return self.failed(f"{self.repo_name} is not configured for the current user")
-
-        installed_url = repo["url"].strip("/")
-        logging.debug(f"{self.repo_name} helm repo is installed with URL {installed_url}.")
-
-        if installed_url != self.repo_url:
-            return self.failed(
-                f"{self.repo_name} is configured to use the wrong URL. Expected {self.repo_url}, got {installed_url}"
-            )
-
-        return self.passed(f"{self.repo_name} is configured for the current user")

daktari/checks/misc.py

@@ -1,302 +0,0 @@
-import logging
-from os.path import expanduser
-from typing import Dict, Optional
-
-from python_hosts import Hosts
-from tabulate import tabulate
-
-from daktari.check import Check, CheckResult
-from daktari.os import OS, check_env_var_exists, get_env_var_value
-from daktari.version_utils import get_simple_cli_version
-from daktari.command_utils import can_run_command
-
-
-class WatchmanInstalled(Check):
-    name = "watchman.installed"
-
-    suggestions = {
-        OS.OS_X: "<cmd>brew install watchman</cmd>",
-        OS.GENERIC: "Install watchman: https://facebook.github.io/watchman/docs/install.html#buildinstall",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify_install("watchman")
-
-
-class MkcertInstalled(Check):
-    name = "mkcert.installed"
-
-    suggestions = {
-        OS.OS_X: """
-            Install mkcert:
-            <cmd>brew install mkcert</cmd>
-            Install the local CA in the system trust store:
-            <cmd>mkcert -install</cmd>
-            """,
-        OS.GENERIC: """
-            Install mkcert: https://mkcert.dev/#installation
-            Install the local CA in the system trust store:
-            <cmd>mkcert -install</cmd>
-            """,
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify_install("mkcert")
-
-
-class KtlintInstalled(Check):
-    name = "ktlint.installed"
-
-    suggestions = {
-        OS.OS_X: "<cmd>brew install ktlint</cmd>",
-        OS.GENERIC: "Install ktlint: https://github.com/pinterest/ktlint#installation",
-    }
-
-    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
-        self.required_version = required_version
-        self.recommended_version = recommended_version
-
-    def check(self) -> CheckResult:
-        installed_version = get_simple_cli_version("ktlint")
-        return self.validate_semver_expression(
-            "ktlint", installed_version, self.required_version, self.recommended_version
-        )
-
-
-class CmakeInstalled(Check):
-    name = "cmake.installed"
-
-    suggestions = {
-        OS.OS_X: "<cmd>brew install cmake</cmd>",
-        OS.UBUNTU: "<cmd>apt-get install cmake</cmd>",
-        OS.GENERIC: "Install cmake: https://cmake.org/install/",
-    }
-
-    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
-        self.required_version = required_version
-        self.recommended_version = recommended_version
-
-    def check(self) -> CheckResult:
-        installed_version = get_simple_cli_version("cmake")
-        return self.validate_semver_expression(
-            "cmake", installed_version, self.required_version, self.recommended_version
-        )
-
-
-class JqInstalled(Check):
-    name = "jq.installed"
-
-    suggestions = {
-        OS.OS_X: "<cmd>brew install jq</cmd>",
-        OS.UBUNTU: "<cmd>sudo apt install jq</cmd>",
-        OS.GENERIC: "Install jq: https://stedolan.github.io/jq/download/",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify_install("jq")
-
-
-class FlywayInstalled(Check):
-    name = "flyway.installed"
-
-    suggestions = {
-        OS.OS_X: "<cmd>brew install flyway</cmd>",
-        OS.UBUNTU: "<cmd>snap install flyway</cmd>",
-        OS.GENERIC: "Install flyway: https://flywaydb.org/documentation/usage/commandline/#download-and-installation",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify_install("flyway", "-v")
-
-
-class ShellcheckInstalled(Check):
-    name = "shellcheck.installed"
-
-    suggestions = {
-        OS.OS_X: "<cmd>brew install shellcheck</cmd>",
-        OS.UBUNTU: "<cmd>sudo apt install shellcheck</cmd>",
-        OS.GENERIC: "Install shellcheck: https://github.com/koalaman/shellcheck#user-content-installing",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify_install("shellcheck")
-
-
-class MakeInstalled(Check):
-    name = "make.installed"
-
-    suggestions = {
-        OS.OS_X: "<cmd>xcode-select --install</cmd>",
-        OS.UBUNTU: "<cmd>sudo apt install make</cmd>",
-        OS.GENERIC: "Install make: https://www.gnu.org/software/make/",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify_install("make")
-
-
-class GccInstalled(Check):
-    name = "gcc.installed"
-
-    suggestions = {
-        OS.OS_X: "<cmd>xcode-select --install</cmd>",
-        OS.UBUNTU: "<cmd>sudo apt install gcc</cmd>",
-        OS.GENERIC: "Install gcc: https://gcc.gnu.org/",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify_install("gcc")
-
-
-class EnvVarSet(Check):
-    def __init__(self, variable_name: str, variable_value: Optional[str] = "", provision_command: str = ""):
-        self.name = f"env.variableSet.{variable_name}"
-        self.suggestions = {OS.GENERIC: provision_command}
-        self.variable_name = variable_name
-        self.variable_value = variable_value
-
-    def check(self) -> CheckResult:
-        if self.variable_value:
-            return self.verify(
-                get_env_var_value(self.variable_name) == self.variable_value,
-                f"{self.variable_name} has <not/> got the required value of {self.variable_value}",
-            )
-        else:
-            return self.verify(check_env_var_exists(self.variable_name), f"{self.variable_name} is <not/> set")
-
-
-class ShfmtInstalled(Check):
-    name = "shfmt.installed"
-
-    suggestions = {
-        OS.OS_X: "<cmd>brew install shfmt</cmd>",
-        OS.UBUNTU: "<cmd>snap install shfmt</cmd>",
-        OS.GENERIC: "Install shfmt: https://github.com/mvdan/sh",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify_install("shfmt")
-
-
-class Md5SumInstalled(Check):
-    name = "md5sum.installed"
-
-    suggestions = {OS.OS_X: "<cmd>brew install md5sha1sum</cmd>", OS.GENERIC: "Install md5sum"}
-
-    def check(self) -> CheckResult:
-        return self.verify_install("md5sum")
-
-
-class HostAliasesConfigured(Check):
-    name = "hostAliases.configured"
-
-    def __init__(self, required_aliases: Dict[str, str]):
-        self.required_aliases = required_aliases
-        hosts_path = Hosts.determine_hosts_path()
-        entries_text = tabulate([(addr, name) for (name, addr) in self.required_aliases.items()], tablefmt="plain")
-        self.suggestions = {OS.GENERIC: f"Add the following entries to {hosts_path}:\n\n{entries_text}"}
-
-    def check(self) -> CheckResult:
-        hosts = Hosts()
-        entries = [e for e in hosts.entries if e.entry_type in ("ipv4", "ipv6")]
-        entries_dict = {}
-        for entry in entries:
-            for name in entry.names:
-                entries_dict[name] = entry.address
-        logging.debug(f"Hosts file entries: {entries_dict}")
-        for name, address in self.required_aliases.items():
-            if entries_dict.get(name) != address:
-                return self.failed(f"{hosts.path} alias {name} -> {address} not present")
-
-        return self.passed(f"{hosts.path} aliases present")
-
-
-class DirectoryIsOnPath(Check):
-    name = "directory.on.path"
-
-    def __init__(self, directory: str):
-        self.directory = expanduser(directory)  # $PATH won't auto-expand ~
-        self.suggestions = {
-            OS.GENERIC: f"""
-                Append the following line to your profile (~/.bashrc or ~/.zshrc):
-                export PATH="{self.directory}:$PATH
-                """,
-            OS.UBUNTU: f"""
-                Append the following line to your profile (~/.bashrc):
-                export PATH="{self.directory}:$PATH"
-                For first time setup, you can run this:
-                <cmd>echo 'export PATH="{self.directory}:$PATH"' >> ~/.bashrc && source ~/.bashrc</cmd>
-                """,
-            OS.OS_X: f"""
-                Append the following line to your profile (~/.zshrc):
-                export PATH="{self.directory}:$PATH"
-                For first time setup, you can run this:
-                <cmd>echo 'export PATH="{self.directory}:$PATH"' >> ~/.zshrc && source ~/.zshrc</cmd>
-                """,
-        }
-
-    def check(self) -> CheckResult:
-        path_value = get_env_var_value("PATH")
-        return self.verify(path_value.__contains__(self.directory), f"{self.directory} is <not/> on the $PATH")
-
-
-class DetektInstalled(Check):
-    name = "detekt.installed"
-
-    def __init__(
-        self,
-        required_version: Optional[str] = None,
-        recommended_version: Optional[str] = None,
-        install_version: Optional[str] = None,
-    ):
-        self.install_version = install_version
-        self.required_version = required_version
-        self.recommended_version = recommended_version
-        self.suggestions = {
-            OS.OS_X: self.get_install_cmd(),
-            OS.UBUNTU: self.get_install_cmd(),
-            OS.GENERIC: "Install detekt: https://detekt.dev/cli.html#install-the-cli",
-        }
-
-    def get_install_cmd(self) -> str:
-        version = self.install_version or "[desired version - see https://github.com/detekt/detekt/releases]"
-        url = "https://github.com/detekt/detekt/releases/download/v$DETEKT_VERSION/detekt-cli-$DETEKT_VERSION.zip"
-        return f"""
-            <cmd>DETEKT_VERSION={version}</cmd>
-            <cmd>LOCAL_BIN=~/.local/bin</cmd>
-            <cmd>TEMP_FILE=$(mktemp)</cmd>
-            <cmd>mkdir -p "$LOCAL_BIN"</cmd>
-            <cmd>curl -L {url} --output "$TEMP_FILE"</cmd>
-            <cmd>unzip -u "$TEMP_FILE" -d "$LOCAL_BIN"</cmd>
-            <cmd>rm "$TEMP_FILE"</cmd>
-            <cmd>chmod +x "$LOCAL_BIN/detekt-cli-$DETEKT_VERSION/bin/detekt-cli"</cmd>
-            <cmd>ln -f -s "$LOCAL_BIN/detekt-cli-$DETEKT_VERSION/bin/detekt-cli" "$LOCAL_BIN/detekt"</cmd>
-            """
-
-    def check(self) -> CheckResult:
-        installed_version = get_simple_cli_version("detekt")
-        return self.validate_semver_expression(
-            "detekt", installed_version, self.required_version, self.recommended_version
-        )
-
-
-class TaskInstalled(Check):
-    name = "task.installed"
-    suggestions = {
-        OS.OS_X: "<cmd>brew install go-task</cmd>",
-        OS.GENERIC: "Install task: https://taskfile.dev/installation/",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify_install("task")
-
-
-class Rosetta2Installed(Check):
-    name = "rosetta2.installed"
-    run_on = OS.OS_X
-    suggestions = {OS.OS_X: "<cmd>softwareupdate --install-rosetta</cmd>"}
-
-    def check(self) -> CheckResult:
-        return self.verify(
-            can_run_command("arch -x86_64 true"), "Rosetta 2 is installed or not required", "Rosetta 2 is not installed"
-        )

daktari/checks/nodejs.py

@@ -1,92 +0,0 @@
-import logging
-from typing import List, Optional
-
-from semver import VersionInfo
-
-from daktari.check import Check, CheckResult
-from daktari.command_utils import get_stdout, run_command
-from daktari.os import OS
-from daktari.version_utils import try_parse_semver
-
-
-def get_nodejs_version() -> Optional[VersionInfo]:
-    version_output = get_stdout("node --version")
-    version_output = None if version_output is None else version_output.lstrip("v")
-    return try_parse_semver(version_output)
-
-
-def run_nvm(nvm_args: List[str]):
-    return run_command(["sh", "-c", '. "$NVM_DIR/nvm.sh"; nvm "$@"', "--", *nvm_args])
-
-
-def can_run_nvm() -> bool:
-    try:
-        run_nvm(["--version"])
-        return True
-    except Exception:
-        logging.debug("Exception running nvm", exc_info=True)
-        return False
-
-
-def get_nvmrc_version() -> Optional[str]:
-    try:
-        with open(".nvmrc", "r") as nvmrc_file:
-            return nvmrc_file.readline().strip()
-    except IOError:
-        logging.debug("Could not read .nvmrc", exc_info=True)
-        return None
-
-
-class NodeJsVersion(Check):
-    name = "nodejs.version"
-
-    def __init__(self, required_version: str, recommended_version: Optional[str] = None):
-        self.required_version = required_version
-        self.recommended_version = recommended_version
-
-    suggestions = {
-        OS.GENERIC: "Install node.js",
-    }
-
-    def check(self) -> CheckResult:
-        nodejs_version = get_nodejs_version()
-        logging.info(f"node.js version: {nodejs_version}")
-        return self.validate_semver_expression(
-            "node.js", nodejs_version, self.required_version, self.recommended_version
-        )
-
-
-class NvmInstalled(Check):
-    name = "nvm.installed"
-
-    suggestions = {OS.GENERIC: "Install nvm from: https://nvm.sh"}
-
-    def check(self) -> CheckResult:
-        return self.verify(can_run_nvm(), "nvm is <not/> installed")
-
-
-class NodeJsVersionMatchesNvmrc(Check):
-    name = "nodejs.nvmrc.version"
-
-    suggestions = {
-        OS.GENERIC: """
-            Run: <cmd>nvm install</cmd> (automatically picks up the right version from .nvmrc)
-            Run: <cmd>nvm use</cmd>
-            Run: <cmd>nvm alias default <version></cmd> to set the default node version to the newly
-            installed one
-            """
-    }
-
-    def check(self) -> CheckResult:
-        nvmrc_version = get_nvmrc_version()
-        if nvmrc_version is None:
-            return self.failed("Missing or invalid .nvmrc file")
-
-        active_version = get_nodejs_version()
-        if active_version is None:
-            return self.failed(f'node.js version "{nvmrc_version}" is not installed')
-
-        if active_version != nvmrc_version:
-            return self.failed(f'the active node.js version is {active_version}, "{nvmrc_version}" is required')
-
-        return self.passed(f"node.js version is {active_version}")

daktari/checks/onepassword.py

@@ -1,105 +0,0 @@
-import grp
-import json
-import os
-from stat import S_IMODE, S_ISGID
-from typing import Optional
-
-from daktari.check import Check, CheckResult
-from daktari.os import OS
-from daktari.command_utils import get_stdout
-from daktari.version_utils import get_simple_cli_version
-
-
-class OnePasswordCliInstalled(Check):
-    name = "onePasswordCli.installed"
-
-    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
-        self.required_version = required_version
-        self.recommended_version = recommended_version
-        self.suggestions = {
-            OS.GENERIC: """
-                Install the 1Password CLI (op):
-                https://support.1password.com/command-line-getting-started/#set-up-the-command-line-tool""",
-            OS.OS_X: """
-                Use these commands to update 1pass-cli to correct version:
-                <cmd>brew tap glean-notes/homebrew-tap git@github.com:glean-notes/homebrew-tap</cmd>
-                <cmd>brew reinstall glean-notes/homebrew-tap/1password-cli</cmd>""",
-        }
-
-    def check(self) -> CheckResult:
-        installed_version = get_simple_cli_version("op")
-        return self.validate_semver_expression(
-            "1Password CLI", installed_version, self.required_version, self.recommended_version
-        )
-
-
-class OnePasswordAccountConfigured(Check):
-    depends_on = [OnePasswordCliInstalled]
-    name = "onePassword.accountConfigured"
-
-    def __init__(self, account_shorthand: str):
-        self.account_shorthand = account_shorthand
-        self.account_url = f"{account_shorthand}.1password.com"
-        self.suggestions = {
-            OS.GENERIC: f"""
-            Use the 1Password desktop app integration: https://developer.1password.com/docs/cli/get-started/#sign-in
-            Otherwise:
-            <cmd>op signin -f --account {self.account_url}</cmd>""",
-        }
-
-    def check(self) -> CheckResult:
-        output = get_stdout("op account list")
-        if output is None:
-            return self.failed("1Password CLI command failed. Make sure it's installed and configured.")
-
-        account_present = contains_account(output, self.account_url)
-
-        if account_present:
-            return self.passed(f"{self.account_shorthand} is configured with OP CLI for the current user")
-        else:
-            return self.failed(f"{self.account_shorthand} is not configured with OP CLI for the current user")
-
-
-def contains_account(op_account_list_output: str, account_url: str) -> bool:
-    return account_url in op_account_list_output
-
-
-# If not set up, this breaks the integration between cli and desktop app (at least on Ubuntu)
-# https://github.com/NeoHsu/asdf-1password-cli/issues/6#issuecomment-1587502411
-class OnePasswordCliOwnedByCorrectGroup(Check):
-    depends_on = [OnePasswordCliInstalled]
-    name = "onePasswordCli.ownedByCorrectGroup"
-    run_on = OS.UBUNTU
-
-    def __init__(self):
-        self.suggestions = {
-            OS.UBUNTU: """
-            Ensure the onepassword-cli group exists:
-            <cmd>sudo groupadd -f onepassword-cli</cmd>
-            Then update the group ownership and set group id when executing:
-            <cmd>sudo chgrp onepassword-cli $(asdf which op) && sudo chmod g+s $(asdf which op)</cmd>
-            """,
-        }
-
-    def check(self) -> CheckResult:
-        op_path = get_stdout(["sh", "-c", "asdf which op"])
-        if op_path is None:
-            return self.failed("op not found")
-
-        op_stat = os.stat(op_path)
-        group_id = op_stat.st_gid
-        group_name = grp.getgrgid(group_id)[0]
-
-        if group_name != "onepassword-cli":
-            return self.failed(f"op group should be onepassword-cli, but was {group_name}")
-
-        if S_IMODE(op_stat.st_mode) & S_ISGID == 0:
-            return self.failed("op does not set groupid when running")
-
-        return self.passed("op has correct group and sets groupid when running")
-
-
-def account_exists(path: str, account_shorthand: str) -> bool:
-    with open(path) as f:
-        config = json.load(f)
-    return any(account.get("shorthand") == account_shorthand for account in config.get("accounts", []))

daktari/checks/python.py

@@ -1,16 +0,0 @@
-from daktari.check import Check, CheckResult
-from daktari.os import OS
-
-
-class PythonInstalled(Check):
-    def __init__(self, required_version: int):
-        self.required_version = required_version
-        self.name = f"python{required_version}.installed"
-        self.suggestions = {
-            OS.OS_X: f"<cmd>brew install python{required_version}</cmd>",
-            OS.UBUNTU: f"<cmd>sudo apt install python{required_version}-dev</cmd>",
-            OS.GENERIC: f"Download python {required_version}: https://www.python.org/downloads/",
-        }
-
-    def check(self) -> CheckResult:
-        return self.verify_install(f"python{self.required_version}")