util.py

import contextlib
from unittest import mock
from fnmatch import fnmatch
import logging
from os.path import exists, join
from os import getcwd, chdir, makedirs, walk
from pathlib import Path
from platform import uname
import shutil
from tempfile import mkdtemp

import packaging.version

from pythonforandroid.logger import (logger, Err_Fore, error, info)

LOGGER = logging.getLogger("p4a.util")

build_platform = "{system}-{machine}".format(
    system=uname().system, machine=uname().machine
).lower()
"""the build platform in the format `system-machine`. We use
this string to define the right build system when compiling some recipes or
to get the right path for clang compiler"""


@contextlib.contextmanager
def current_directory(new_dir):
    cur_dir = getcwd()
    logger.info(''.join((Err_Fore.CYAN, '-> directory context ', new_dir,
                         Err_Fore.RESET)))
    chdir(new_dir)
    yield
    logger.info(''.join((Err_Fore.CYAN, '<- directory context ', cur_dir,
                         Err_Fore.RESET)))
    chdir(cur_dir)


@contextlib.contextmanager
def temp_directory():
    temp_dir = mkdtemp()
    try:
        logger.debug(''.join((Err_Fore.CYAN, ' + temp directory used ',
                              temp_dir, Err_Fore.RESET)))
        yield temp_dir
    finally:
        shutil.rmtree(temp_dir)
        logger.debug(''.join((Err_Fore.CYAN, ' - temp directory deleted ',
                              temp_dir, Err_Fore.RESET)))


def walk_valid_filens(base_dir, invalid_dir_names, invalid_file_patterns, excluded_dir_exceptions=None):
    """Recursively walks all the files and directories in ``dirn``,
    ignoring directories that match any pattern in ``invalid_dirns``
    and files that patch any pattern in ``invalid_filens``.

    ``invalid_dirns`` and ``invalid_filens`` should both be lists of
    strings to match. ``invalid_dir_patterns`` expects a list of
    invalid directory names, while ``invalid_file_patterns`` expects a
    list of glob patterns compared against the full filepath.

    File and directory paths are evaluated as full paths relative to ``dirn``.

    If ``excluded_dir_exceptions`` is given, any directory path that contains
    any of those strings will *not* exclude subdirectories matching
    ``invalid_dir_names``.
    """

    excluded_dir_exceptions = [] if excluded_dir_exceptions is None else excluded_dir_exceptions

    for dirn, subdirs, filens in walk(base_dir):
        allow_invalid_dirs = any(ex in dirn for ex in excluded_dir_exceptions)

        # Remove invalid subdirs so that they will not be walked
        if not allow_invalid_dirs:
            for i in reversed(range(len(subdirs))):
                subdir = subdirs[i]
                if subdir in invalid_dir_names:
                    subdirs.pop(i)

        for filen in filens:
            for pattern in invalid_file_patterns:
                if fnmatch(filen, pattern):
                    break
            else:
                yield join(dirn, filen)


def load_source(module, filename):
    # Python 3.5+
    import importlib.util
    if hasattr(importlib.util, 'module_from_spec'):
        spec = importlib.util.spec_from_file_location(module, filename)
        mod = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(mod)
        return mod
    else:
        # Python 3.3 and 3.4:
        from importlib.machinery import SourceFileLoader
        return SourceFileLoader(module, filename).load_module()


class BuildInterruptingException(Exception):
    def __init__(self, message, instructions=None):
        super().__init__(message, instructions)
        self.message = message
        self.instructions = instructions


def handle_build_exception(exception):
    """
    Handles a raised BuildInterruptingException by printing its error
    message and associated instructions, if any, then exiting.
    """
    error('Build failed: {}'.format(exception.message))
    if exception.instructions is not None:
        info('Instructions: {}'.format(exception.instructions))
    exit(1)


def rmdir(dn, ignore_errors=False):
    if not exists(dn):
        return
    LOGGER.debug("Remove directory and subdirectory {}".format(dn))
    shutil.rmtree(dn, ignore_errors)


def ensure_dir(dn):
    if exists(dn):
        return
    LOGGER.debug("Create directory {0}".format(dn))
    makedirs(dn)


def move(source, destination):
    LOGGER.debug("Moving {} to {}".format(source, destination))
    shutil.move(source, destination)


def touch(filename):
    Path(filename).touch()


def build_tools_version_sort_key(
    version_string: str,
) -> packaging.version.Version:
    """
    Returns a packaging.version.Version object for comparison purposes.
    It includes canonicalization of the version string to allow for
    comparison of versions with spaces in them (historically, RC candidates)

    If the version string is invalid, it returns a version object with
    version 0, which will be sorted at worst position.
    """

    try:
        # Historically, Android build release candidates have had
        # spaces in the version number.
        return packaging.version.Version(version_string.replace(" ", ""))
    except packaging.version.InvalidVersion:
        # Put badly named versions at worst position.
        return packaging.version.Version("0")


def max_build_tool_version(
    build_tools_versions: list,
) -> str:
    """
    Returns the maximum build tools version from a list of build tools
    versions. It uses the :meth:`build_tools_version_sort_key` function to
    canonicalize the version strings and then returns the maximum version.
    """

    return max(build_tools_versions, key=build_tools_version_sort_key)


def patch_wheel_setuptools_logging():
    """
    When setuptools is not present and the root logger has no handlers,
    Wheels would configure the root logger with DEBUG level, refs:
    - https://github.com/pypa/wheel/blob/0.44.0/src/wheel/util.py
    - https://github.com/pypa/wheel/blob/0.44.0/src/wheel/_setuptools_logging.py

    Both of these conditions are met in our CI, leading to very verbose
    and unreadable `sh` logs. Patching it prevents that.
    """
    return mock.patch("wheel._setuptools_logging.configure")