redis-benchmarks-specification 0.2.42__py3-none-any.whl

redis_benchmarks_specification/__common__/builder_schema.py

@@ -0,0 +1,256 @@
+#  BSD 3-Clause License
+#
+#  Copyright (c) 2021., Redis Labs Modules
+#  All rights reserved.
+#
+import logging
+import os
+import tempfile
+import zipfile
+import git
+from urllib.error import URLError
+from urllib.request import urlopen
+from github import Github
+
+import redis
+
+from redis_benchmarks_specification.__common__.env import (
+    STREAM_KEYNAME_GH_EVENTS_COMMIT,
+)
+
+
+def commit_schema_to_stream(
+    fields: dict,
+    conn: redis.StrictRedis,
+    gh_org,
+    gh_repo,
+    gh_token=None,
+    local_repo_path=None,
+):
+    """uses to the provided JSON dict of fields and pushes that info to the corresponding stream"""
+    fields = fields
+    reply_fields = dict(fields)
+    result = False
+    error_msg = None
+    use_git_timestamp = False
+    if "use_git_timestamp" in fields:
+        use_git_timestamp = bool(fields["use_git_timestamp"])
+    if "git_hash" not in fields:
+        error_msg = "Missing required 'git_hash' field"
+    else:
+        (
+            result,
+            error_msg,
+            fields,
+            _,
+            binary_key,
+            binary_value,
+        ) = get_commit_dict_from_sha(
+            fields["git_hash"],
+            gh_org,
+            gh_repo,
+            fields,
+            use_git_timestamp,
+            gh_token,
+            None,  # gh_branch
+            local_repo_path,
+        )
+        reply_fields["use_git_timestamp"] = fields["use_git_timestamp"]
+        if "git_timestamp_ms" in fields:
+            reply_fields["git_timestamp_ms"] = fields["git_timestamp_ms"]
+        reply_fields["archived_zip"] = True
+    if result is True:
+        # 7 days expire
+        binary_exp_secs = 24 * 60 * 60 * 7
+        result, reply_fields, error_msg = request_build_from_commit_info(
+            conn, fields, reply_fields, binary_key, binary_value, binary_exp_secs
+        )
+
+    return result, reply_fields, error_msg
+
+
+def get_archive_zip_from_hash(gh_org, gh_repo, git_hash, fields, local_repo_path=None):
+    error_msg = None
+    result = False
+    binary_value = None
+    bin_key = "zipped:source:{}/{}/archive/{}.zip".format(gh_org, gh_repo, git_hash)
+
+    if local_repo_path is not None:
+        # Create ZIP archive from local repository
+        try:
+            logging.info(
+                "Creating ZIP archive from local repository: {}".format(local_repo_path)
+            )
+
+            # Create a temporary ZIP file
+            temp_zip = tempfile.NamedTemporaryFile(delete=False, suffix=".zip")
+            temp_zip.close()
+
+            # Create ZIP archive from the local repository at the specific commit
+            repo = git.Repo(local_repo_path)
+
+            # Get the commit object
+            commit = repo.commit(git_hash)
+
+            # Create archive using git archive command with prefix to match GitHub structure
+            # GitHub creates archives with directory name like "redis-{commit_hash}"
+            archive_prefix = "{}-{}/".format(gh_repo, git_hash)
+            with open(temp_zip.name, "wb") as zip_file:
+                repo.archive(zip_file, commit, format="zip", prefix=archive_prefix)
+
+            # Read the ZIP file content
+            with open(temp_zip.name, "rb") as zip_file:
+                binary_value = zip_file.read()
+
+            # Clean up temporary file
+            os.unlink(temp_zip.name)
+
+            fields["zip_archive_key"] = bin_key
+            fields["zip_archive_len"] = len(binary_value)
+            result = True
+            logging.info(
+                "Successfully created ZIP archive from local repository. Size: {} bytes ({:.2f} MB)".format(
+                    len(binary_value), len(binary_value) / (1024 * 1024)
+                )
+            )
+
+        except Exception as e:
+            error_msg = (
+                "Error creating ZIP archive from local repository {}: {}".format(
+                    local_repo_path, str(e)
+                )
+            )
+            logging.error(error_msg)
+            result = False
+    else:
+        # Fetch from GitHub as before
+        github_url = "https://github.com/{}/{}/archive/{}.zip".format(
+            gh_org, gh_repo, git_hash
+        )
+        try:
+            logging.info("Fetching data from {}".format(github_url))
+            response = urlopen(github_url, timeout=5)
+            content = response.read()
+            fields["zip_archive_key"] = bin_key
+            fields["zip_archive_len"] = len(bytes(content))
+            binary_value = bytes(content)
+            result = True
+        except URLError as e:
+            error_msg = "Catched URLError while fetching {} content. Error {}".format(
+                github_url, e.__str__()
+            )
+            logging.error(error_msg)
+            result = False
+
+    return result, bin_key, binary_value, error_msg
+
+
+def get_commit_dict_from_sha(
+    git_hash,
+    gh_org,
+    gh_repo,
+    commit_dict={},
+    use_git_timestamp=False,
+    gh_token=None,
+    gh_branch=None,
+    local_repo_path=None,
+):
+    commit = None
+    # using an access token - but only if we're not using a local repository
+    if gh_token is not None and local_repo_path is None:
+        g = Github(gh_token)
+        repo = g.get_repo("{}/{}".format(gh_org, gh_repo))
+        commit = repo.get_commit(sha=git_hash)
+        commit_dict["git_timestamp_ms"] = int(
+            commit.commit.author.date.timestamp() * 1000.0
+        )
+    elif local_repo_path is not None:
+        # For local repositories, get timestamp from local git repo
+        try:
+            local_repo = git.Repo(local_repo_path)
+            local_commit = local_repo.commit(git_hash)
+            commit_dict["git_timestamp_ms"] = int(local_commit.committed_date * 1000.0)
+        except Exception as e:
+            logging.warning(
+                "Could not get timestamp from local repository: {}".format(str(e))
+            )
+            if "git_timestamp_ms" not in commit_dict:
+                use_git_timestamp = False
+    else:
+        if "git_timestamp_ms" not in commit_dict:
+            use_git_timestamp = False
+    commit_dict["use_git_timestamp"] = str(use_git_timestamp)
+    commit_dict["git_hash"] = git_hash
+    if gh_branch is not None:
+        commit_dict["git_branch"] = gh_branch
+
+    result, binary_key, binary_value, error_msg = get_archive_zip_from_hash(
+        gh_org,
+        gh_repo,
+        git_hash,
+        commit_dict,
+        local_repo_path,
+    )
+    return result, error_msg, commit_dict, commit, binary_key, binary_value
+
+
+def request_build_from_commit_info(
+    conn, fields, reply_fields, binary_key, binary_value, binary_exp_secs
+):
+    """Generates a build event from the commit dictionary
+    It expected the fields dictionary to contain at least the following keys:
+        - "git_branch": reference to the branch that the commit refers to
+        - "git_hash": reference to the commit hash
+        - "zip_archive": containing the source code archived binary
+        - "zip_archive_len": the length of the zip archived
+        - "archived_zip": boolean value specifying if the archive is zipped ( always true for now )
+
+    Parameters
+    ----------
+    conn : redis.Con
+        The redis client connection
+    fields : dict
+        The input commit info dictionary
+    reply_fields : dict
+        The output reply commit info dictionary
+
+    """
+    result = True
+    error_msg = None
+    conn.set(binary_key, binary_value, ex=binary_exp_secs)
+    for k, v in fields.items():
+        if type(v) not in [str, int, float, bytes]:
+            raise Exception(
+                "Type of field {} is not bytes, string, int or float. Type ({}). Value={}".format(
+                    k, type(v), v
+                )
+            )
+    id = conn.xadd(STREAM_KEYNAME_GH_EVENTS_COMMIT.encode(), fields)
+    reply_fields["id"] = id
+    return result, reply_fields, error_msg
+
+
+def get_branch_version_from_test_details(testDetails):
+    git_branch = None
+    git_version = None
+    if b"git_branch" in testDetails:
+        git_branch = testDetails[b"git_branch"]
+    if b"ref_label" in testDetails:
+        git_branch = testDetails[b"ref_label"]
+    if b"git_version" in testDetails:
+        git_version = testDetails[b"git_version"]
+    if git_branch is not None:
+        # remove event prefix
+        if type(git_branch) == bytes:
+            git_branch = git_branch.decode()
+        if git_branch.startswith("/refs/heads/"):
+            git_branch = git_branch.replace("/refs/heads/", "")
+        if git_branch.startswith("refs/heads/"):
+            git_branch = git_branch.replace("refs/heads/", "")
+        if git_branch.startswith("/"):
+            git_branch = git_branch[1:]
+    if git_version is not None:
+        if type(git_version) == bytes:
+            git_version = git_version.decode()
+
+    return git_branch, git_version

redis_benchmarks_specification/__common__/env.py

@@ -0,0 +1,96 @@
+import logging
+import os
+
+# default specification paths
+import pkg_resources
+import psutil
+
+SPECS_PATH_SETUPS_DEFAULT_PATH = pkg_resources.resource_filename(
+    "redis_benchmarks_specification", "setups"
+)
+
+SPECS_PATH_TEST_SUITES_DEFAULT_PATH = pkg_resources.resource_filename(
+    "redis_benchmarks_specification", "test-suites"
+)
+
+SPECS_PATH_SETUPS = os.getenv("SPECS_PATH_SETUPS", SPECS_PATH_SETUPS_DEFAULT_PATH)
+SPECS_PATH_TEST_SUITES = os.getenv(
+    "SPECS_PATH_TEST_SUITES", SPECS_PATH_TEST_SUITES_DEFAULT_PATH
+)
+
+# event stream from github
+STREAM_KEYNAME_GH_EVENTS_COMMIT = os.getenv(
+    "STREAM_KEYNAME_GH_EVENTS_COMMIT", "oss:api:gh/redis/redis/commits"
+)
+
+STREAM_GH_EVENTS_COMMIT_BUILDERS_CG = os.getenv(
+    "STREAM_GH_EVENTS_COMMIT_BUILDERS_CG", "builders-cg:redis/redis/commits"
+)
+
+# build events stream. This is the stream read by the coordinators to kickoff benchmark variations
+STREAM_KEYNAME_NEW_BUILD_EVENTS = os.getenv(
+    "STREAM_KEYNAME_NEW_BUILD_EVENTS", "oss:api:gh/redis/redis/builds"
+)
+
+
+# Function to get architecture-specific build events stream name
+def get_arch_specific_stream_name(arch):
+    """Get architecture-specific stream name for build events"""
+    base_stream = STREAM_KEYNAME_NEW_BUILD_EVENTS
+    if arch in ["amd64", "x86_64"]:
+        return f"{base_stream}:amd64"
+    elif arch in ["arm64", "aarch64"]:
+        return f"{base_stream}:arm64"
+    else:
+        # Fallback to base stream for unknown architectures
+        return base_stream
+
+
+STREAM_GH_NEW_BUILD_RUNNERS_CG = os.getenv(
+    "STREAM_GH_NEW_BUILD_RUNNERS_CG", "runners-cg:redis/redis/commits"
+)
+
+# host used to store the streams of events
+GH_TOKEN = os.getenv("GH_TOKEN", None)
+GH_REDIS_SERVER_HOST = os.getenv("GH_REDIS_SERVER_HOST", "localhost")
+GH_REDIS_SERVER_PORT = int(os.getenv("GH_REDIS_SERVER_PORT", "6379"))
+GH_REDIS_SERVER_AUTH = os.getenv("GH_REDIS_SERVER_AUTH", None)
+GH_REDIS_SERVER_USER = os.getenv("GH_REDIS_SERVER_USER", None)
+
+# DB used to authenticate ( read-only/non-dangerous access only )
+REDIS_AUTH_SERVER_HOST = os.getenv("REDIS_AUTH_SERVER_HOST", "localhost")
+REDIS_AUTH_SERVER_PORT = int(os.getenv("REDIS_AUTH_SERVER_PORT", "6379"))
+REDIS_HEALTH_CHECK_INTERVAL = int(os.getenv("REDIS_HEALTH_CHECK_INTERVAL", "15"))
+REDIS_SOCKET_TIMEOUT = int(os.getenv("REDIS_SOCKET_TIMEOUT", "300"))
+REDIS_BINS_EXPIRE_SECS = int(
+    os.getenv("REDIS_BINS_EXPIRE_SECS", "{}".format(24 * 7 * 60 * 60))
+)
+
+# environment variables
+PULL_REQUEST_TRIGGER_LABEL = os.getenv(
+    "PULL_REQUEST_TRIGGER_LABEL", "action:run-benchmark"
+)
+DATASINK_RTS_PUSH = bool(os.getenv("DATASINK_PUSH_RTS", False))
+DATASINK_RTS_AUTH = os.getenv("DATASINK_RTS_AUTH", None)
+DATASINK_RTS_USER = os.getenv("DATASINK_RTS_USER", None)
+DATASINK_RTS_HOST = os.getenv("DATASINK_RTS_HOST", "localhost")
+DATASINK_RTS_PORT = int(os.getenv("DATASINK_RTS_PORT", "6379"))
+ALLOWED_PROFILERS = "perf:record,vtune"
+PROFILERS_DEFAULT = "perf:record"
+PROFILE_FREQ_DEFAULT = "99"
+PROFILERS_DSO = os.getenv("PROFILERS_DSO", None)
+PROFILERS_ENABLED = bool(int(os.getenv("PROFILE", 0)))
+PROFILERS = os.getenv("PROFILERS", PROFILERS_DEFAULT)
+MAX_PROFILERS_PER_TYPE = int(os.getenv("MAX_PROFILERS", 1))
+PROFILE_FREQ = os.getenv("PROFILE_FREQ", PROFILE_FREQ_DEFAULT)
+S3_BUCKET_NAME = os.getenv("S3_BUCKET_NAME", "redis.benchmarks.spec")
+# logging related
+VERBOSE = os.getenv("VERBOSE", "1") == "0"
+LOG_FORMAT = "%(asctime)s %(levelname)-4s %(message)s"
+LOG_DATEFMT = "%Y-%m-%d %H:%M:%S"
+LOG_LEVEL = logging.INFO
+if VERBOSE:
+    LOG_LEVEL = logging.WARN
+
+MACHINE_CPU_COUNT = psutil.cpu_count()
+MACHINE_NAME = os.uname()[1]

redis_benchmarks_specification/__common__/github.py

@@ -0,0 +1,280 @@
+import logging
+from github import Github
+
+
+def check_regression_comment(comments):
+    res = False
+    pos = -1
+    for n, comment in enumerate(comments):
+        body = comment.body
+        if "Comparison between" in body and "Time Period from" in body:
+            res = True
+            pos = n
+    return res, pos
+
+
+def generate_build_started_pr_comment(
+    build_datetime,
+    commit_datetime,
+    commit_summary,
+    git_branch,
+    git_hash,
+    tests_groups_regexp,
+    tests_priority_lower_limit,
+    tests_priority_upper_limit,
+    tests_regexp,
+):
+    comment_body = "### CE Performance Automation : step 1 of 2 (build) STARTING...\n\n"
+    comment_body += (
+        "This comment was automatically generated given a benchmark was triggered.\n"
+    )
+    comment_body += f"Started building at {build_datetime}\n"
+    comment_body += "You can check each build/benchmark progress in grafana:\n"
+    if not isinstance(git_hash, str):
+        git_hash = git_hash.decode()
+    comment_body += f"   - git hash: {git_hash}\n"
+    comment_body += f"   - git branch: {git_branch}\n"
+    comment_body += f"   - commit date and time: {commit_datetime}\n"
+    comment_body += f"   - commit summary: {commit_summary}\n"
+    comment_body += "   - test filters:\n"
+    comment_body += (
+        f"       - command priority lower limit: {tests_priority_lower_limit}\n"
+    )
+    comment_body += (
+        f"       - command priority upper limit: {tests_priority_upper_limit}\n"
+    )
+    comment_body += f"       - test name regex: {tests_regexp}\n"
+    comment_body += f"       - command group regex: {tests_groups_regexp}\n\n"
+    return comment_body
+
+
+def generate_build_finished_pr_comment(
+    benchmark_stream_ids,
+    commit_datetime,
+    commit_summary,
+    git_branch,
+    git_hash,
+    tests_groups_regexp,
+    tests_priority_lower_limit,
+    tests_priority_upper_limit,
+    tests_regexp,
+    build_start_datetime,
+    build_duration_seconds,
+):
+    build_duration_seconds = int(build_duration_seconds)
+    comment_body = "### CE Performance Automation : step 1 of 2 (build) DONE.\n\n"
+    comment_body += (
+        "This comment was automatically generated given a benchmark was triggered.\n"
+    )
+    comment_body += f"Started building at {build_start_datetime} and took {build_duration_seconds} seconds.\n"
+    comment_body += "You can check each build/benchmark progress in grafana:\n"
+    if not isinstance(git_hash, str):
+        git_hash = git_hash.decode()
+    comment_body += f"   - git hash: {git_hash}\n"
+    comment_body += f"   - git branch: {git_branch}\n"
+    comment_body += f"   - commit date and time: {commit_datetime}\n"
+    comment_body += f"   - commit summary: {commit_summary}\n"
+    comment_body += "   - test filters:\n"
+    comment_body += (
+        f"       - command priority lower limit: {tests_priority_lower_limit}\n"
+    )
+    comment_body += (
+        f"       - command priority upper limit: {tests_priority_upper_limit}\n"
+    )
+    comment_body += f"       - test name regex: {tests_regexp}\n"
+    comment_body += f"       - command group regex: {tests_groups_regexp}\n\n"
+    for benchmark_stream_id in benchmark_stream_ids:
+        if not isinstance(benchmark_stream_id, str):
+            benchmark_stream_id = benchmark_stream_id.decode()
+        grafana_benchmark_status_link = f"https://benchmarksredisio.grafana.net/d/edsxdsrbexhc0f/ce-benchmark-run-status?orgId=1&var-benchmark_work_stream={benchmark_stream_id}"
+        print("=============================================================")
+        print(f"Check benchmark run status in: {grafana_benchmark_status_link}")
+        comment_body += f"You can check a comparison in detail via the [grafana link]({grafana_benchmark_status_link})"
+    return comment_body
+
+
+def check_github_available_and_actionable(
+    fn, github_token, pull_request, tf_github_org, tf_github_repo, verbose
+):
+    # using an access token
+    is_actionable_pr = False
+    contains_regression_comment = False
+    regression_comment = None
+    github_pr = None
+    old_regression_comment_body = ""
+    pr_link = None
+    if github_token is not None:
+        logging.info("Detected github token")
+        g = Github(github_token)
+        if pull_request is not None and pull_request != "":
+            try:
+                pull_request_n = int(pull_request)
+                github_pr = (
+                    g.get_user(tf_github_org)
+                    .get_repo(tf_github_repo)
+                    .get_issue(pull_request_n)
+                )
+                comments = github_pr.get_comments()
+                pr_link = github_pr.html_url
+                logging.info("Working on github PR already: {}".format(pr_link))
+                is_actionable_pr = True
+                contains_regression_comment, pos = fn(comments)
+                if contains_regression_comment:
+                    regression_comment = comments[pos]
+                    old_regression_comment_body = regression_comment.body
+                    logging.info(
+                        "Already contains PR comment. Link: {}".format(
+                            regression_comment.html_url
+                        )
+                    )
+                    if verbose:
+                        logging.info("Printing old PR comment:")
+                        print("".join(["-" for x in range(1, 80)]))
+                        print(regression_comment.body)
+                        print("".join(["-" for x in range(1, 80)]))
+                else:
+                    logging.info("Does not contain PR comment")
+            except Exception as e:
+                logging.error(
+                    f"an error occured when checking github info. {e.__str__()}. proceeding..."
+                )
+            logging.info(
+                f"contains_regression_comment: {contains_regression_comment}, is_actionable_pr: {is_actionable_pr}, pr_link: {pr_link}"
+            )
+
+    return (
+        contains_regression_comment,
+        github_pr,
+        is_actionable_pr,
+        old_regression_comment_body,
+        pr_link,
+        regression_comment,
+    )
+
+
+def create_new_pr_comment(auto_approve, comment_body, github_pr, pr_link):
+    regression_comment = None
+    user_input = "n"
+    if auto_approve:
+        print("auto approving...")
+    else:
+        user_input = input("Do you wish to add a comment in {} (y/n): ".format(pr_link))
+    if user_input.lower() == "y" or auto_approve:
+        print("creating an comment in PR {}".format(pr_link))
+        regression_comment = github_pr.create_comment(comment_body)
+        html_url = regression_comment.html_url
+        print("created comment. Access it via {}".format(html_url))
+    return regression_comment
+
+
+def update_comment_if_needed(
+    auto_approve, comment_body, old_regression_comment_body, regression_comment, verbose
+):
+    same_comment = False
+    user_input = "n"
+    if comment_body == old_regression_comment_body:
+        logging.info(
+            "The old github comment is the same as the new comment. skipping..."
+        )
+        same_comment = True
+    else:
+        logging.info(
+            "The old github comment is different from the new comment. updating it..."
+        )
+        comment_body_arr = comment_body.split("\n")
+        old_regression_comment_body_arr = old_regression_comment_body.split("\n")
+        if verbose:
+            DF = [
+                x for x in comment_body_arr if x not in old_regression_comment_body_arr
+            ]
+            print("---------------------")
+            print(DF)
+            print("---------------------")
+    if same_comment is False:
+        if auto_approve:
+            print("auto approving...")
+        else:
+            user_input = input(
+                "Do you wish to update the comment {} (y/n): ".format(
+                    regression_comment.html_url
+                )
+            )
+        if user_input.lower() == "y" or auto_approve:
+            html_url = regression_comment.html_url
+            print("Updating comment {}".format(html_url))
+            regression_comment.edit(comment_body)
+            print("Updated comment. Access it via {}".format(html_url))
+
+
+def check_benchmark_build_comment(comments):
+    res = False
+    pos = -1
+    for n, comment in enumerate(comments):
+        body = comment.body
+        if "CE Performance Automation : step" in body:
+            res = True
+            pos = n
+    return res, pos
+
+
+def check_benchmark_running_comment(comments):
+    res = False
+    pos = -1
+    for n, comment in enumerate(comments):
+        body = comment.body
+        if "CE Performance Automation : step" in body:
+            res = True
+            pos = n
+    return res, pos
+
+
+def markdown_progress_bar(current, total, bar_length=40):
+    progress = 1.0
+    if total > 0:
+        progress = current / total
+    block = int(round(bar_length * progress))
+    bar = "#" * block + "-" * (bar_length - block)
+    percentage = round(progress * 100, 2)
+    return f"[{bar}] {percentage}%"
+
+
+def generate_benchmark_started_pr_comment(
+    benchmark_stream_id,
+    total_pending,
+    total_benchmarks,
+    total_failed,
+    benchmark_suite_start_datetime,
+    benchmark_suite_duration_secs,
+):
+    comment_body = "### CE Performance Automation : step 2 of 2 (benchmark) "
+    if total_pending > 0:
+        comment_body += "RUNNING...\n\n"
+    else:
+        comment_body += "FINISHED.\n\n"
+
+    comment_body += (
+        "This comment was automatically generated given a benchmark was triggered.\n\n"
+    )
+
+    comment_body += f"Started benchmark suite at {benchmark_suite_start_datetime} and took {benchmark_suite_duration_secs} seconds "
+    if total_pending > 0:
+        comment_body += "up until now.\n"
+    else:
+        comment_body += "to finish.\n"
+
+    completed = total_benchmarks - total_pending
+    successful = completed - total_failed
+    comment_body += (
+        f"Status: {markdown_progress_bar(completed,total_benchmarks,80)} completed.\n\n"
+    )
+    comment_body += f"In total will run {total_benchmarks} benchmarks.\n"
+    comment_body += f"    - {total_pending} pending.\n"
+    comment_body += f"    - {completed} completed:\n"
+    comment_body += f"      - {successful} successful.\n"
+    comment_body += f"      - {total_failed} failed.\n"
+
+    if not isinstance(benchmark_stream_id, str):
+        benchmark_stream_id = benchmark_stream_id.decode()
+    grafana_benchmark_status_link = f"https://benchmarksredisio.grafana.net/d/edsxdsrbexhc0f/ce-benchmark-run-status?orgId=1&var-benchmark_work_stream={benchmark_stream_id}"
+    comment_body += f"You can check a the status in detail via the [grafana link]({grafana_benchmark_status_link})"
+    return comment_body

redis_benchmarks_specification/__common__/package.py

@@ -0,0 +1,28 @@
+from redis_benchmarks_specification import __version__
+
+import os
+import toml
+
+PACKAGE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+def populate_with_poetry_data():
+    project_name = "redis-benchmarks-specification"
+    project_version = __version__
+    project_description = None
+    try:
+        poetry_data = toml.load("pyproject.toml")["tool"]["poetry"]
+        project_name = poetry_data["name"]
+        project_version = poetry_data["version"]
+        project_description = poetry_data["description"]
+    except FileNotFoundError:
+        pass
+
+    return project_name, project_description, project_version
+
+
+def get_version_string(project_name, project_version):
+    version_str = "{project_name} {project_version}".format(
+        project_name=project_name, project_version=project_version
+    )
+    return version_str