iframe-proxy | Sunbelt Computer Software

History

179 lines (139 loc) · 5.69 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

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

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

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

Sunbelt Computer Software

PL/B Language Development and Support

Navigation Menu

Sunbelt Computer Software

PL/B Language Development and Support

FilesExpand file tree

util.py

Latest commit

History

util.py

File metadata and controls