RedBear-OS/local/recipes/dev/libclc/source/clang/utils/analyzer/SATestUtils.py

import os
import sys
import time

from subprocess import CalledProcessError, check_call
from typing import List, IO, Optional, Tuple


def which(command: str, paths: Optional[str] = None) -> Optional[str]:
    """which(command, [paths]) - Look up the given command in the paths string
    (or the PATH environment variable, if unspecified)."""

    if paths is None:
        paths = os.environ.get("PATH", "")

    # Check for absolute match first.
    if os.path.exists(command):
        return command

    # Would be nice if Python had a lib function for this.
    if not paths:
        paths = os.defpath

    # Get suffixes to search.
    # On Cygwin, 'PATHEXT' may exist but it should not be used.
    if os.pathsep == ";":
        pathext = os.environ.get("PATHEXT", "").split(";")
    else:
        pathext = [""]

    # Search the paths...
    for path in paths.split(os.pathsep):
        for ext in pathext:
            p = os.path.join(path, command + ext)
            if os.path.exists(p):
                return p

    return None


def has_no_extension(file_name: str) -> bool:
    root, ext = os.path.splitext(file_name)
    return ext == ""


def is_valid_single_input_file(file_name: str) -> bool:
    root, ext = os.path.splitext(file_name)
    return ext in (".i", ".ii", ".c", ".cpp", ".m", "")


def time_to_str(time: float) -> str:
    """
    Convert given time in seconds into a human-readable string.
    """
    return f"{time:.2f}s"


def memory_to_str(memory: int) -> str:
    """
    Convert given number of bytes into a human-readable string.
    """
    if memory:
        try:
            import humanize

            return humanize.naturalsize(memory, gnu=True)
        except ImportError:
            # no formatter installed, let's keep it in bytes
            return f"{memory}B"

    # If memory is 0, we didn't succeed measuring it.
    return "N/A"


def check_and_measure_call(*popenargs, **kwargs) -> Tuple[float, int]:
    """
    Run command with arguments.  Wait for command to complete and measure
    execution time and peak memory consumption.
    If the exit code was zero then return, otherwise raise
    CalledProcessError.  The CalledProcessError object will have the
    return code in the returncode attribute.

    The arguments are the same as for the call and check_call functions.

    Return a tuple of execution time and peak memory.
    """
    peak_mem = 0
    start_time = time.time()

    try:
        import psutil as ps

        def get_memory(process: ps.Process) -> int:
            mem = 0

            # we want to gather memory usage from all of the child processes
            descendants = list(process.children(recursive=True))
            descendants.append(process)

            for subprocess in descendants:
                try:
                    mem += subprocess.memory_info().rss
                except (ps.NoSuchProcess, ps.AccessDenied):
                    continue

            return mem

        with ps.Popen(*popenargs, **kwargs) as process:
            # while the process is running calculate resource utilization.
            while process.is_running() and process.status() != ps.STATUS_ZOMBIE:
                # track the peak utilization of the process
                peak_mem = max(peak_mem, get_memory(process))
                time.sleep(0.5)

            if process.is_running():
                process.kill()

        if process.returncode != 0:
            cmd = kwargs.get("args")
            if cmd is None:
                cmd = popenargs[0]
            raise CalledProcessError(process.returncode, cmd)

    except ImportError:
        # back off to subprocess if we don't have psutil installed
        peak_mem = 0
        check_call(*popenargs, **kwargs)

    return time.time() - start_time, peak_mem


def run_script(
    script_path: str,
    build_log_file: IO,
    cwd: str,
    out=sys.stdout,
    err=sys.stderr,
    verbose: int = 0,
):
    """
    Run the provided script if it exists.
    """
    if os.path.exists(script_path):
        try:
            if verbose == 1:
                out.write(f"  Executing: {script_path}\n")

            check_call(
                f"chmod +x '{script_path}'",
                cwd=cwd,
                stderr=build_log_file,
                stdout=build_log_file,
                shell=True,
            )

            check_call(
                f"'{script_path}'",
                cwd=cwd,
                stderr=build_log_file,
                stdout=build_log_file,
                shell=True,
            )

        except CalledProcessError:
            err.write(
                f"Error: Running {script_path} failed. "
                f"See {build_log_file.name} for details.\n"
            )
            sys.exit(-1)


def is_comment_csv_line(entries: List[str]) -> bool:
    """
    Treat CSV lines starting with a '#' as a comment.
    """
    return len(entries) > 0 and entries[0].startswith("#")