'''

MIN_NDK_API = 21

'''Sets the minimal ndk api number needed to use the recipe.

from_crystax = False

'''True if the python is used from CrystaX, False otherwise (i.e. if

configure_args = ()

'''The configure arguments needed to build the python recipe. Those are

stdlib_dir_blacklist = {

'__pycache__',

'test',

'tests',

'lib2to3',

'ensurepip',

'idlelib',

'tkinter',

}

'''The directories that we want to omit for our python bundle'''

stdlib_filen_blacklist = [

'*.py',

'*.exe',

'*.whl',

]

'''The file extensions that we want to blacklist for our python bundle'''

site_packages_dir_blacklist = {

'__pycache__',

'tests'

}

'''The directories from site packages dir that we don't want to be included

site_packages_filen_blacklist = [

'*.py'

]

'''The file extensions from site packages dir that we don't want to be

opt_depends = ['sqlite3', 'libffi', 'openssl']

'''The optional libraries which we would like to get our python linked'''

compiled_extension = '.pyc'

'''the default extension for compiled python files.

def __init__(self, *args, **kwargs):

self._ctx = None

super(GuestPythonRecipe, self).__init__(*args, **kwargs)

def get_recipe_env(self, arch=None, with_flags_in_cc=True):

if self.from_crystax:

return super(GuestPythonRecipe, self).get_recipe_env(

arch=arch, with_flags_in_cc=with_flags_in_cc)

env = environ.copy()

android_host = env['HOSTARCH'] = arch.command_prefix

toolchain = '{toolchain_prefix}-{toolchain_version}'.format(

toolchain_prefix=self.ctx.toolchain_prefix,

toolchain_version=self.ctx.toolchain_version)

toolchain = join(self.ctx.ndk_dir, 'toolchains',

toolchain, 'prebuilt', build_platform)

env['CC'] = (

'{clang} -target {target} -gcc-toolchain {toolchain}').format(

clang=join(self.ctx.ndk_dir, 'toolchains', 'llvm', 'prebuilt',

build_platform, 'bin', 'clang'),

target=arch.target,

toolchain=toolchain)

env['AR'] = join(toolchain, 'bin', android_host) + '-ar'

env['LD'] = join(toolchain, 'bin', android_host) + '-ld'

env['RANLIB'] = join(toolchain, 'bin', android_host) + '-ranlib'

env['READELF'] = join(toolchain, 'bin', android_host) + '-readelf'

env['STRIP'] = join(toolchain, 'bin', android_host) + '-strip'

env['STRIP'] += ' --strip-debug --strip-unneeded'

env['PATH'] = (

'{hostpython_dir}:{old_path}').format(

hostpython_dir=self.get_recipe(

'host' + self.name, self.ctx).get_path_to_python(),

old_path=env['PATH'])

ndk_flags = (

'-fPIC --sysroot={ndk_sysroot} -D__ANDROID_API__={android_api} '

'-isystem {ndk_android_host} -I{ndk_include}').format(

ndk_sysroot=join(self.ctx.ndk_dir, 'sysroot'),

android_api=self.ctx.ndk_api,

ndk_android_host=join(

self.ctx.ndk_dir, 'sysroot', 'usr', 'include', android_host),

ndk_include=join(self.ctx.ndk_dir, 'sysroot', 'usr', 'include'))

sysroot = self.ctx.ndk_platform

env['CFLAGS'] = env.get('CFLAGS', '') + ' ' + ndk_flags

env['CPPFLAGS'] = env.get('CPPFLAGS', '') + ' ' + ndk_flags

env['LDFLAGS'] = env.get('LDFLAGS', '') + ' --sysroot={} -L{}'.format(

sysroot, join(sysroot, 'usr', 'lib'))

# Manually add the libs directory, and copy some object

# files to the current directory otherwise they aren't

# picked up. This seems necessary because the --sysroot

# setting in LDFLAGS is overridden by the other flags.

# TODO: Work out why this doesn't happen in the original

# bpo-30386 Makefile system.

logger.warning('Doing some hacky stuff to link properly')

lib_dir = join(sysroot, 'usr', 'lib')

if arch.arch == 'x86_64':

lib_dir = join(sysroot, 'usr', 'lib64')

env['LDFLAGS'] += ' -L{}'.format(lib_dir)

shprint(sh.cp, join(lib_dir, 'crtbegin_so.o'), './')

shprint(sh.cp, join(lib_dir, 'crtend_so.o'), './')

env['SYSROOT'] = sysroot

if sh.which('lld') is not None:

# Note: The -L. is to fix a bug in python 3.7.

# https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=234409

env["LDFLAGS"] += ' -L. -fuse-ld=lld'

else:

logger.warning('lld not found, linking without it. ' +

'Consider installing lld if linker errors occur.')

return env

def set_libs_flags(self, env, arch):

'''Takes care to properly link libraries with python depending on our

def add_flags(include_flags, link_dirs, link_libs):

env['CPPFLAGS'] = env.get('CPPFLAGS', '') + include_flags

env['LDFLAGS'] = env.get('LDFLAGS', '') + link_dirs

env['LIBS'] = env.get('LIBS', '') + link_libs

if 'sqlite3' in self.ctx.recipe_build_order:

info('Activating flags for sqlite3')

recipe = Recipe.get_recipe('sqlite3', self.ctx)

add_flags(' -I' + recipe.get_build_dir(arch.arch),

' -L' + recipe.get_lib_dir(arch), ' -lsqlite3')

if 'libffi' in self.ctx.recipe_build_order:

info('Activating flags for libffi')

recipe = Recipe.get_recipe('libffi', self.ctx)

# In order to force the correct linkage for our libffi library, we

# set the following variable to point where is our libffi.pc file,

# because the python build system uses pkg-config to configure it.

env['PKG_CONFIG_PATH'] = recipe.get_build_dir(arch.arch)

add_flags(' -I' + ' -I'.join(recipe.get_include_dirs(arch)),

' -L' + join(recipe.get_build_dir(arch.arch), '.libs'),

' -lffi')

if 'openssl' in self.ctx.recipe_build_order:

info('Activating flags for openssl')

recipe = Recipe.get_recipe('openssl', self.ctx)

add_flags(recipe.include_flags(arch),

recipe.link_dirs_flags(arch), recipe.link_libs_flags())

return env

def prebuild_arch(self, arch):

super(TargetPythonRecipe, self).prebuild_arch(arch)

if self.from_crystax and self.ctx.ndk != 'crystax':

raise BuildInterruptingException(

'The {} recipe can only be built when using the CrystaX NDK. '

'Exiting.'.format(self.name))

self.ctx.python_recipe = self

def build_arch(self, arch):

if self.ctx.ndk_api < self.MIN_NDK_API:

raise BuildInterruptingException(

'Target ndk-api is {}, but the python3 recipe supports only'

' {}+'.format(self.ctx.ndk_api, self.MIN_NDK_API))

recipe_build_dir = self.get_build_dir(arch.arch)

# Create a subdirectory to actually perform the build

build_dir = join(recipe_build_dir, 'android-build')

ensure_dir(build_dir)

# TODO: Get these dynamically, like bpo-30386 does

sys_prefix = '/usr/local'

sys_exec_prefix = '/usr/local'

with current_directory(build_dir):

env = self.get_recipe_env(arch)

env = self.set_libs_flags(env, arch)

android_build = sh.Command(

join(recipe_build_dir,

'config.guess'))().stdout.strip().decode('utf-8')

if not exists('config.status'):

shprint(

sh.Command(join(recipe_build_dir, 'configure')),

*(' '.join(self.configure_args).format(

android_host=env['HOSTARCH'],

android_build=android_build,

prefix=sys_prefix,

exec_prefix=sys_exec_prefix)).split(' '),

_env=env)

if not exists('python'):

py_version = self.major_minor_version_string

if self.major_minor_version_string[0] == '3':

py_version += 'm'

shprint(sh.make, 'all', '-j', str(cpu_count()),

'INSTSONAME=libpython{version}.so'.format(

version=py_version), _env=env)

# TODO: Look into passing the path to pyconfig.h in a

# better way, although this is probably acceptable

sh.cp('pyconfig.h', join(recipe_build_dir, 'Include'))

def include_root(self, arch_name):

return join(self.get_build_dir(arch_name), 'Include')

def link_root(self, arch_name):

return join(self.get_build_dir(arch_name), 'android-build')

def compile_python_files(self, dir):

'''

args = [self.ctx.hostpython]

if self.ctx.python_recipe.name == 'python3':

args += ['-OO', '-m', 'compileall', '-b', '-f', dir]

else:

args += ['-OO', '-m', 'compileall', '-f', dir]

subprocess.call(args)

def create_python_bundle(self, dirn, arch):

"""

# Todo: find a better way to find the build libs folder

modules_build_dir = join(

self.get_build_dir(arch.arch),

'android-build',

'build',

'lib.linux{}-{}-{}'.format(

'2' if self.version[0] == '2' else '',

arch.command_prefix.split('-')[0],

self.major_minor_version_string

))

# Compile to *.pyc/*.pyo the python modules

self.compile_python_files(modules_build_dir)

# Compile to *.pyc/*.pyo the standard python library

self.compile_python_files(join(self.get_build_dir(arch.arch), 'Lib'))

# Compile to *.pyc/*.pyo the other python packages (site-packages)

self.compile_python_files(self.ctx.get_python_install_dir())

# Bundle compiled python modules to a folder

modules_dir = join(dirn, 'modules')

c_ext = self.compiled_extension

ensure_dir(modules_dir)

module_filens = (glob.glob(join(modules_build_dir, '*.so')) +

glob.glob(join(modules_build_dir, '*' + c_ext)))

info("Copy {} files into the bundle".format(len(module_filens)))

for filen in module_filens:

info(" - copy {}".format(filen))

copy2(filen, modules_dir)

# zip up the standard library

stdlib_zip = join(dirn, 'stdlib.zip')

with current_directory(join(self.get_build_dir(arch.arch), 'Lib')):

stdlib_filens = list(walk_valid_filens(

'.', self.stdlib_dir_blacklist, self.stdlib_filen_blacklist))

info("Zip {} files into the bundle".format(len(stdlib_filens)))

shprint(sh.zip, stdlib_zip, *stdlib_filens)

# copy the site-packages into place

ensure_dir(join(dirn, 'site-packages'))

ensure_dir(self.ctx.get_python_install_dir())

# TODO: Improve the API around walking and copying the files

with current_directory(self.ctx.get_python_install_dir()):

filens = list(walk_valid_filens(

'.', self.site_packages_dir_blacklist,

self.site_packages_filen_blacklist))

info("Copy {} files into the site-packages".format(len(filens)))

for filen in filens:

info(" - copy {}".format(filen))

ensure_dir(join(dirn, 'site-packages', dirname(filen)))

copy2(filen, join(dirn, 'site-packages', filen))

# copy the python .so files into place

python_build_dir = join(self.get_build_dir(arch.arch),

'android-build')

python_lib_name = 'libpython' + self.major_minor_version_string

if self.major_minor_version_string[0] == '3':

python_lib_name += 'm'

shprint(sh.cp, join(python_build_dir, python_lib_name + '.so'),

join(self.ctx.dist_dir, self.ctx.dist_name, 'libs', arch.arch))

info('Renaming .so files to reflect cross-compile')

self.reduce_object_file_names(join(dirn, 'site-packages'))

'''

name = ''

'''The hostpython's recipe name. This should be ``hostpython2`` or

version = ''

'''The hostpython's recipe version.

build_subdir = 'native-build'

'''Specify the sub build directory for the hostpython recipe. Defaults

url = 'https://www.python.org/ftp/python/{version}/Python-{version}.tgz'

'''The default url to download our host python recipe. This url will

def get_build_container_dir(self, arch=None):

choices = self.check_recipe_choices()

dir_name = '-'.join([self.name] + choices)

return join(self.ctx.build_dir, 'other_builds', dir_name, 'desktop')

def get_build_dir(self, arch=None):

'''

return join(self.get_build_container_dir(), self.name)

def get_path_to_python(self):

return join(self.get_build_dir(), self.build_subdir)

def build_arch(self, arch):

recipe_build_dir = self.get_build_dir(arch.arch)

# Create a subdirectory to actually perform the build

build_dir = join(recipe_build_dir, self.build_subdir)

ensure_dir(build_dir)

if not exists(join(build_dir, 'python')):

with current_directory(recipe_build_dir):

# Configure the build

with current_directory(build_dir):

if not exists('config.status'):

shprint(

sh.Command(join(recipe_build_dir, 'configure')))

# Create the Setup file. This copying from Setup.dist

# seems to be the normal and expected procedure.

shprint(sh.cp, join('Modules', 'Setup.dist'),

join(build_dir, 'Modules', 'Setup'))

shprint(sh.make, '-j', str(cpu_count()), '-C', build_dir)

else:

info('Skipping {name} ({version}) build, as it has already '

'been completed'.format(name=self.name, version=self.version))