import contextlib

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):

"""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``.

"""

for dirn, subdirs, filens in walk(base_dir):

# Remove invalid subdirs so that they will not be walked

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)