spec = importlib.util.spec_from_file_location(module, filename)

mod = importlib.util.module_from_spec(spec)

spec.loader.exec_module(mod)

def __new__(cls, name, bases, dct):

if name != 'Recipe':

if 'url' in dct:

dct['_url'] = dct.pop('url')

if 'version' in dct:

dct['_version'] = dct.pop('version')

_url = None

'''The address from which the recipe may be downloaded. This is not

_version = None

'''A string giving the version of the software the recipe describes,

md5sum = None

'''The md5sum of the source from the :attr:`url`. Non-essential, but

depends = []

'''A list containing the names of any recipes that this recipe depends on.

conflicts = []

'''A list containing the names of any recipes that are known to be

opt_depends = []

'''A list of optional dependencies, that must be built before this

patches = []

'''A list of patches to apply to the source. Values can be either a string

python_depends = []

'''A list of pure-Python packages that this package requires. These

archs = ['armeabi'] # Not currently implemented properly

@property

def version(self):

key = 'VERSION_' + self.name

return environ.get(key, self._version)

@property

def url(self):

key = 'URL_' + self.name

return environ.get(key, self._url)

@property

def versioned_url(self):

'''A property returning the url of the recipe with ``{version}``

if self.url is None:

return None

return self.url.format(version=self.version)

def download_file(self, url, target, cwd=None):

"""

if not url:

return

info('Downloading {} from {}'.format(self.name, url))

if cwd:

target = join(cwd, target)

parsed_url = urlparse(url)

if parsed_url.scheme in ('http', 'https'):

def report_hook(index, blksize, size):

if size <= 0:

progression = '{0} bytes'.format(index * blksize)

else:

progression = '{0:.2f}%'.format(

index * blksize * 100. / float(size))

stdout.write('- Download {}\r'.format(progression))

stdout.flush()

if exists(target):

unlink(target)

urlretrieve(url, target, report_hook)

return target

elif parsed_url.scheme in ('git', 'git+file', 'git+ssh', 'git+http', 'git+https'):

if isdir(target):

with current_directory(target):

shprint(sh.git, 'fetch', '--tags')

if self.version:

shprint(sh.git, 'checkout', self.version)

shprint(sh.git, 'pull')

shprint(sh.git, 'pull', '--recurse-submodules')

shprint(sh.git, 'submodule', 'update', '--recursive')

else:

if url.startswith('git+'):

url = url[4:]

shprint(sh.git, 'clone', '--recursive', url, target)

if self.version:

with current_directory(target):

shprint(sh.git, 'checkout', self.version)

shprint(sh.git, 'submodule', 'update', '--recursive')

return target

# def get_archive_rootdir(self, filename):

# if filename.endswith(".tgz") or filename.endswith(".tar.gz") or \

# filename.endswith(".tbz2") or filename.endswith(".tar.bz2"):

# archive = tarfile.open(filename)

# root = archive.next().path.split("/")

# return root[0]

# elif filename.endswith(".zip"):

# with zipfile.ZipFile(filename) as zf:

# return dirname(zf.namelist()[0])

# else:

# print("Error: cannot detect root directory")

# print("Unrecognized extension for {}".format(filename))

# raise Exception()

def apply_patch(self, filename, arch):

"""

info("Applying patch {}".format(filename))

filename = join(self.get_recipe_dir(), filename)

shprint(sh.patch, "-t", "-d", self.get_build_dir(arch), "-p1",

"-i", filename, _tail=10)

def copy_file(self, filename, dest):

info("Copy {} to {}".format(filename, dest))

filename = join(self.get_recipe_dir(), filename)

dest = join(self.build_dir, dest)

shutil.copy(filename, dest)

def append_file(self, filename, dest):

info("Append {} to {}".format(filename, dest))

filename = join(self.get_recipe_dir(), filename)

dest = join(self.build_dir, dest)

with open(filename, "rb") as fd:

data = fd.read()

with open(dest, "ab") as fd:

fd.write(data)

# def has_marker(self, marker):

# """

# Return True if the current build directory has the marker set

# """

# return exists(join(self.build_dir, ".{}".format(marker)))

# def set_marker(self, marker):

# """

# Set a marker info the current build directory

# """

# with open(join(self.build_dir, ".{}".format(marker)), "w") as fd:

# fd.write("ok")

# def delete_marker(self, marker):

# """

# Delete a specific marker

# """

# try:

# unlink(join(self.build_dir, ".{}".format(marker)))

# except:

# pass

@property

def name(self):

'''The name of the recipe, the same as the folder containing it.'''

modname = self.__class__.__module__

return modname.split(".", 2)[-1]

# @property

# def archive_fn(self):

# bfn = basename(self.url.format(version=self.version))

# fn = "{}/{}-{}".format(

# self.ctx.cache_dir,

# self.name, bfn)

# return fn

@property

def filtered_archs(self):

'''Return archs of self.ctx that are valid build archs

result = []

for arch in self.ctx.archs:

if not self.archs or (arch.arch in self.archs):

result.append(arch)

return result

def check_recipe_choices(self):

'''Checks what recipes are being built to see which of the alternative

recipes = []

built_recipes = self.ctx.recipe_build_order

for recipe in self.depends:

if isinstance(recipe, (tuple, list)):

for alternative in recipe:

if alternative in built_recipes:

recipes.append(alternative)

break

for recipe in self.opt_depends:

if recipe in built_recipes:

recipes.append(recipe)

return sorted(recipes)

def get_build_container_dir(self, arch):

'''Given the arch name, returns the directory where it will be

dir_name = self.get_dir_name()

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

def get_dir_name(self):

choices = self.check_recipe_choices()

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

return dir_name

def get_build_dir(self, arch):

'''Given the arch name, returns the directory where the

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

def get_recipe_dir(self):

"""

if self.ctx.local_recipes is not None:

local_recipe_dir = join(self.ctx.local_recipes, self.name)

if exists(local_recipe_dir):

return local_recipe_dir

return join(self.ctx.root_dir, 'recipes', self.name)

# Public Recipe API to be subclassed if needed

def download_if_necessary(self):

info_main('Downloading {}'.format(self.name))

user_dir = environ.get('P4A_{}_DIR'.format(self.name.lower()))

if user_dir is not None:

info('P4A_{}_DIR is set, skipping download for {}'.format(

self.name, self.name))

return

self.download()

def download(self):

if self.url is None:

info('Skipping {} download as no URL is set'.format(self.name))

return

url = self.versioned_url

ma = match(u'^(.+)#md5=([0-9a-f]{32})$', url)

if ma: # fragmented URL?

if self.md5sum:

raise ValueError(

('Received md5sum from both the {} recipe '

'and its url').format(self.name))

url = ma.group(1)

expected_md5 = ma.group(2)

else:

expected_md5 = self.md5sum

shprint(sh.mkdir, '-p', join(self.ctx.packages_path, self.name))

with current_directory(join(self.ctx.packages_path, self.name)):

filename = shprint(sh.basename, url).stdout[:-1].decode('utf-8')

do_download = True

marker_filename = '.mark-{}'.format(filename)

if exists(filename) and isfile(filename):

if not exists(marker_filename):

shprint(sh.rm, filename)

elif expected_md5:

current_md5 = md5sum(filename)

if current_md5 != expected_md5:

debug('* Generated md5sum: {}'.format(current_md5))

debug('* Expected md5sum: {}'.format(expected_md5))

raise ValueError(

('Generated md5sum does not match expected md5sum '

'for {} recipe').format(self.name))

do_download = False

else:

do_download = False

# If we got this far, we will download

if do_download:

debug('Downloading {} from {}'.format(self.name, url))

shprint(sh.rm, '-f', marker_filename)

self.download_file(self.versioned_url, filename)

shprint(sh.touch, marker_filename)

if exists(filename) and isfile(filename) and expected_md5:

current_md5 = md5sum(filename)

if expected_md5 is not None:

if current_md5 != expected_md5:

debug('* Generated md5sum: {}'.format(current_md5))

debug('* Expected md5sum: {}'.format(expected_md5))

raise ValueError(

('Generated md5sum does not match expected md5sum '

'for {} recipe').format(self.name))

else:

info('{} download already cached, skipping'.format(self.name))

def unpack(self, arch):

info_main('Unpacking {} for {}'.format(self.name, arch))

build_dir = self.get_build_container_dir(arch)

user_dir = environ.get('P4A_{}_DIR'.format(self.name.lower()))

if user_dir is not None:

info('P4A_{}_DIR exists, symlinking instead'.format(

self.name.lower()))

if exists(self.get_build_dir(arch)):

return

shprint(sh.rm, '-rf', build_dir)

shprint(sh.mkdir, '-p', build_dir)

shprint(sh.rmdir, build_dir)

ensure_dir(build_dir)

shprint(sh.cp, '-a', user_dir, self.get_build_dir(arch))

return

if self.url is None:

info('Skipping {} unpack as no URL is set'.format(self.name))

return

filename = shprint(

sh.basename, self.versioned_url).stdout[:-1].decode('utf-8')

ma = match(u'^(.+)#md5=([0-9a-f]{32})$', filename)

if ma: # fragmented URL?

filename = ma.group(1)

with current_directory(build_dir):

directory_name = self.get_build_dir(arch)

if not exists(directory_name) or not isdir(directory_name):

extraction_filename = join(

self.ctx.packages_path, self.name, filename)

if isfile(extraction_filename):

if extraction_filename.endswith('.zip'):

try:

sh.unzip(extraction_filename)

except (sh.ErrorReturnCode_1, sh.ErrorReturnCode_2):

pass # return code 1 means unzipping had

# warnings but did complete,

# apparently happens sometimes with

# github zips

import zipfile

fileh = zipfile.ZipFile(extraction_filename, 'r')

root_directory = fileh.filelist[0].filename.split('/')[0]

if root_directory != basename(directory_name):

shprint(sh.mv, root_directory, directory_name)

elif (extraction_filename.endswith('.tar.gz') or

extraction_filename.endswith('.tgz') or

extraction_filename.endswith('.tar.bz2') or

extraction_filename.endswith('.tbz2') or

extraction_filename.endswith('.tar.xz') or

extraction_filename.endswith('.txz')):

sh.tar('xf', extraction_filename)

root_directory = shprint(

sh.tar, 'tf', extraction_filename).stdout.decode(

'utf-8').split('\n')[0].split('/')[0]

if root_directory != directory_name:

shprint(sh.mv, root_directory, directory_name)

else:

raise Exception(

'Could not extract {} download, it must be .zip, '

'.tar.gz or .tar.bz2 or .tar.xz'.format(extraction_filename))

elif isdir(extraction_filename):

mkdir(directory_name)

for entry in listdir(extraction_filename):

if entry not in ('.git',):

shprint(sh.cp, '-Rv',

join(extraction_filename, entry),

directory_name)

else:

raise Exception(

'Given path is neither a file nor a directory: {}'

.format(extraction_filename))

else:

info('{} is already unpacked, skipping'.format(self.name))

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

"""Return the env specialized for the recipe

if arch is None:

arch = self.filtered_archs[0]

return arch.get_env(with_flags_in_cc=with_flags_in_cc)

def prebuild_arch(self, arch):

'''Run any pre-build tasks for the Recipe. By default, this checks if

prebuild = "prebuild_{}".format(arch.arch.replace('-', '_'))

if hasattr(self, prebuild):

getattr(self, prebuild)()

else:

info('{} has no {}, skipping'.format(self.name, prebuild))

def is_patched(self, arch):

build_dir = self.get_build_dir(arch.arch)

return exists(join(build_dir, '.patched'))

def apply_patches(self, arch):

'''Apply any patches for the Recipe.'''

if self.patches:

info_main('Applying patches for {}[{}]'

.format(self.name, arch.arch))

if self.is_patched(arch):

info_main('{} already patched, skipping'.format(self.name))

return

for patch in self.patches:

if isinstance(patch, (tuple, list)):

patch, patch_check = patch

if not patch_check(arch=arch, recipe=self):

continue

self.apply_patch(

patch.format(version=self.version, arch=arch.arch),

arch.arch)

shprint(sh.touch, join(self.get_build_dir(arch.arch), '.patched'))

def should_build(self, arch):

'''Should perform any necessary test and return True only if it needs

return True

def build_arch(self, arch):

'''Run any build tasks for the Recipe. By default, this checks if

build = "build_{}".format(arch.arch)

if hasattr(self, build):

getattr(self, build)()

def postbuild_arch(self, arch):

'''Run any post-build tasks for the Recipe. By default, this checks if

postbuild = "postbuild_{}".format(arch.arch)

if hasattr(self, postbuild):

getattr(self, postbuild)()

def prepare_build_dir(self, arch):

'''Copies the recipe data into a build dir for the given arch. By

self.unpack(arch)

def clean_build(self, arch=None):

'''Deletes all the build information of the recipe.

if arch is None:

base_dir = join(self.ctx.build_dir, 'other_builds', self.name)

else:

base_dir = self.get_build_container_dir(arch)

dirs = glob.glob(base_dir + '-*')

if exists(base_dir):

dirs.append(base_dir)

if not dirs:

warning(('Attempted to clean build for {} but found no existing '

'build dirs').format(self.name))

for directory in dirs:

if exists(directory):

info('Deleting {}'.format(directory))

shutil.rmtree(directory)

# Delete any Python distributions to ensure the recipe build

# doesn't persist in site-packages

shutil.rmtree(self.ctx.python_installs_dir)

def install_libs(self, arch, *libs):

libs_dir = self.ctx.get_libs_dir(arch.arch)

if not libs:

warning('install_libs called with no libraries to install!')

return

args = libs + (libs_dir,)

shprint(sh.cp, *args)

def has_libs(self, arch, *libs):

return all(map(lambda l: self.ctx.has_lib(arch.arch, l), libs))

@classmethod

def recipe_dirs(cls, ctx):

recipe_dirs = []

if ctx.local_recipes is not None:

recipe_dirs.append(realpath(ctx.local_recipes))

if ctx.storage_dir:

recipe_dirs.append(join(ctx.storage_dir, 'recipes'))

recipe_dirs.append(join(ctx.root_dir, "recipes"))

return recipe_dirs

@classmethod

def list_recipes(cls, ctx):

forbidden_dirs = ('__pycache__', )

for recipes_dir in cls.recipe_dirs(ctx):

if recipes_dir and exists(recipes_dir):

for name in listdir(recipes_dir):

if name in forbidden_dirs:

continue

fn = join(recipes_dir, name)

if isdir(fn):

yield name

@classmethod

def get_recipe(cls, name, ctx):

'''Returns the Recipe with the given name, if it exists.'''

if not hasattr(cls, "recipes"):

cls.recipes = {}

if name in cls.recipes:

return cls.recipes[name]

recipe_file = None

for recipes_dir in cls.recipe_dirs(ctx):

recipe_file = join(recipes_dir, name, '__init__.py')

if exists(recipe_file):

break

recipe_file = None

if not recipe_file:

raise IOError('Recipe does not exist: {}'.format(name))

mod = import_recipe('pythonforandroid.recipes.{}'.format(name), recipe_file)

if len(logger.handlers) > 1:

logger.removeHandler(logger.handlers[1])

recipe = mod.recipe

recipe.ctx = ctx

cls.recipes[name] = recipe

'''Recipe mixin class that will automatically unpack files included in

src_filename = None

def prepare_build_dir(self, arch):

if self.src_filename is None:

print('IncludedFilesBehaviour failed: no src_filename specified')

exit(1)

shprint(sh.rm, '-rf', self.get_build_dir(arch))

shprint(sh.cp, '-a', join(self.get_recipe_dir(), self.src_filename),

'''A recipe class for recipes built in an Android project jni dir with

dir_name = None # The name of the recipe build folder in the jni dir

def get_build_container_dir(self, arch):

return self.get_jni_dir()

def get_build_dir(self, arch):

if self.dir_name is None:

raise ValueError('{} recipe doesn\'t define a dir_name, but '

'this is necessary'.format(self.name))

return join(self.get_build_container_dir(arch), self.dir_name)

def get_jni_dir(self):

'''A recipe class for any NDK project not included in the bootstrap.'''

generated_libraries = []

def should_build(self, arch):

lib_dir = self.get_lib_dir(arch)

for lib in self.generated_libraries:

if not exists(join(lib_dir, lib)):

return True

return False

def get_lib_dir(self, arch):

return join(self.get_build_dir(arch.arch), 'obj', 'local', arch.arch)

def get_jni_dir(self, arch):

return join(self.get_build_dir(arch.arch), 'jni')

def build_arch(self, arch, *extra_args):

super(NDKRecipe, self).build_arch(arch)

env = self.get_recipe_env(arch)

with current_directory(self.get_build_dir(arch.arch)):

site_packages_name = None

'''The name of the module's folder when installed in the Python

call_hostpython_via_targetpython = True

'''If True, tries to install the module using the hostpython binary

install_in_hostpython = False

'''If True, additionally installs the module in the hostpython build

install_in_targetpython = True

'''If True, installs the module in the targetpython installation dir.

setup_extra_args = []

'''List of extra arugments to pass to setup.py'''

def clean_build(self, arch=None):

super(PythonRecipe, self).clean_build(arch=arch)

name = self.folder_name

python_install_dirs = glob.glob(join(self.ctx.python_installs_dir, '*'))

for python_install in python_install_dirs:

site_packages_dir = glob.glob(join(python_install, 'lib', 'python*',

'site-packages'))

if site_packages_dir:

build_dir = join(site_packages_dir[0], name)

if exists(build_dir):

info('Deleted {}'.format(build_dir))

rmtree(build_dir)

@property

def real_hostpython_location(self):

if 'hostpython2' in self.ctx.recipe_build_order:

return join(

Recipe.get_recipe('hostpython2', self.ctx).get_build_dir(),

'hostpython')

elif 'hostpython3crystax' in self.ctx.recipe_build_order:

return join(

Recipe.get_recipe('hostpython3crystax', self.ctx).get_build_dir(),

'hostpython')

else:

python_recipe = self.ctx.python_recipe

return 'python{}'.format(python_recipe.version)

@property

def hostpython_location(self):

if not self.call_hostpython_via_targetpython:

return self.real_hostpython_location

return self.ctx.hostpython

@property

def folder_name(self):

'''The name of the build folders containing this recipe.'''

name = self.site_packages_name

if name is None:

name = self.name

return name

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

env = super(PythonRecipe, self).get_recipe_env(arch, with_flags_in_cc)

env['PYTHONNOUSERSITE'] = '1'

if not self.call_hostpython_via_targetpython:

hppath = []

hppath.append(join(dirname(self.hostpython_location), 'Lib'))

hppath.append(join(hppath[0], 'site-packages'))

builddir = join(dirname(self.hostpython_location), 'build')

hppath += [join(builddir, d) for d in listdir(builddir)

if isdir(join(builddir, d))]

if 'PYTHONPATH' in env:

env['PYTHONPATH'] = ':'.join(hppath + [env['PYTHONPATH']])

else:

env['PYTHONPATH'] = ':'.join(hppath)

return env

def should_build(self, arch):

name = self.folder_name

if self.ctx.has_package(name):

info('Python package already exists in site-packages')

return False

info('{} apparently isn\'t already in site-packages'.format(name))

return True

def build_arch(self, arch):

'''Install the Python module by calling setup.py install with

super(PythonRecipe, self).build_arch(arch)

self.install_python_package(arch)

def install_python_package(self, arch, name=None, env=None, is_dir=True):

'''Automate the installation of a Python package (or a cython

# arch = self.filtered_archs[0] # old kivy-ios way

if name is None:

name = self.name

if env is None:

env = self.get_recipe_env(arch)

info('Installing {} into site-packages'.format(self.name))

with current_directory(self.get_build_dir(arch.arch)):

hostpython = sh.Command(self.hostpython_location)

if self.ctx.python_recipe.from_crystax:

hpenv = env.copy()

shprint(hostpython, 'setup.py', 'install', '-O2',

'--root={}'.format(self.ctx.get_python_install_dir()),

'--install-lib=.',

_env=hpenv, *self.setup_extra_args)

elif self.call_hostpython_via_targetpython:

shprint(hostpython, 'setup.py', 'install', '-O2', _env=env,

*self.setup_extra_args)

else:

hppath = join(dirname(self.hostpython_location), 'Lib',

'site-packages')

hpenv = env.copy()

if 'PYTHONPATH' in hpenv:

hpenv['PYTHONPATH'] = ':'.join([hppath] +

hpenv['PYTHONPATH'].split(':'))

else:

hpenv['PYTHONPATH'] = hppath

shprint(hostpython, 'setup.py', 'install', '-O2',

'--root={}'.format(self.ctx.get_python_install_dir()),

'--install-lib=lib/python2.7/site-packages',

_env=hpenv, *self.setup_extra_args)

# If asked, also install in the hostpython build dir

if self.install_in_hostpython:

self.install_hostpython_package(arch)

def get_hostrecipe_env(self, arch):

env = environ.copy()

env['PYTHONPATH'] = join(dirname(self.real_hostpython_location), 'Lib', 'site-packages')

return env

def install_hostpython_package(self, arch):

env = self.get_hostrecipe_env(arch)

real_hostpython = sh.Command(self.real_hostpython_location)

shprint(real_hostpython, 'setup.py', 'install', '-O2',

'--root={}'.format(dirname(self.real_hostpython_location)),

'--install-lib=Lib/site-packages',

pre_build_ext = False

build_cmd = 'build_ext'

def build_arch(self, arch):

'''Build any cython components, then install the Python module by

Recipe.build_arch(self, arch)

self.build_compiled_components(arch)

self.install_python_package(arch)

def build_compiled_components(self, arch):

info('Building compiled components in {}'.format(self.name))

env = self.get_recipe_env(arch)

with current_directory(self.get_build_dir(arch.arch)):

hostpython = sh.Command(self.hostpython_location)

if self.install_in_hostpython:

shprint(hostpython, 'setup.py', 'clean', '--all', _env=env)

shprint(hostpython, 'setup.py', self.build_cmd, '-v',

_env=env, *self.setup_extra_args)

build_dir = glob.glob('build/lib.*')[0]

shprint(sh.find, build_dir, '-name', '"*.o"', '-exec',

env['STRIP'], '{}', ';', _env=env)

def install_hostpython_package(self, arch):

env = self.get_hostrecipe_env(arch)

self.rebuild_compiled_components(arch, env)

super(CompiledComponentsPythonRecipe, self).install_hostpython_package(arch)

def rebuild_compiled_components(self, arch, env):

info('Rebuilding compiled components in {}'.format(self.name))

hostpython = sh.Command(self.real_hostpython_location)

shprint(hostpython, 'setup.py', 'clean', '--all', _env=env)

shprint(hostpython, 'setup.py', self.build_cmd, '-v', _env=env,

""" Extensions that require the cxx-stl """

call_hostpython_via_targetpython = False

def get_recipe_env(self, arch):

env = super(CppCompiledComponentsPythonRecipe, self).get_recipe_env(arch)

keys = dict(

ctx=self.ctx,

arch=arch,

arch_noeabi=arch.arch.replace('eabi', ''),

pyroot=self.ctx.get_python_install_dir()

)

env['LDSHARED'] = env['CC'] + ' -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions'

env['CFLAGS'] += " -I{pyroot}/include/python2.7 " \

" -I{ctx.ndk_dir}/platforms/android-{ctx.android_api}/arch-{arch_noeabi}/usr/include" \

" -I{ctx.ndk_dir}/sources/cxx-stl/gnu-libstdc++/{ctx.toolchain_version}/include" \

" -I{ctx.ndk_dir}/sources/cxx-stl/gnu-libstdc++/{ctx.toolchain_version}/libs/{arch.arch}/include".format(**keys)

env['CXXFLAGS'] = env['CFLAGS'] + ' -frtti -fexceptions'

env['LDFLAGS'] += " -L{ctx.ndk_dir}/sources/cxx-stl/gnu-libstdc++/{ctx.toolchain_version}/libs/{arch.arch}" \

" -lpython2.7" \

" -lgnustl_shared".format(**keys)

return env

def build_compiled_components(self, arch):

super(CppCompiledComponentsPythonRecipe, self).build_compiled_components(arch)

# Copy libgnustl_shared.so

with current_directory(self.get_build_dir(arch.arch)):

sh.cp(

"{ctx.ndk_dir}/sources/cxx-stl/gnu-libstdc++/{ctx.toolchain_version}/libs/{arch.arch}/libgnustl_shared.so".format(ctx=self.ctx, arch=arch),

self.ctx.get_libs_dir(arch.arch)

pre_build_ext = False

cythonize = True

cython_args = []

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

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

depends = self.depends

depends.append(('python2', 'python3crystax'))

depends = list(set(depends))

self.depends = depends

def build_arch(self, arch):

'''Build any cython components, then install the Python module by

Recipe.build_arch(self, arch)

self.build_cython_components(arch)

self.install_python_package(arch)

def build_cython_components(self, arch):

info('Cythonizing anything necessary in {}'.format(self.name))

env = self.get_recipe_env(arch)

if self.ctx.python_recipe.from_crystax:

command = sh.Command('python{}'.format(self.ctx.python_recipe.version))

site_packages_dirs = command(

'-c', 'import site; print("\\n".join(site.getsitepackages()))')

site_packages_dirs = site_packages_dirs.stdout.decode('utf-8').split('\n')

if 'PYTHONPATH' in env:

env['PYTHONPATH'] = env['PYTHONPATH'] + ':{}'.format(':'.join(site_packages_dirs))

else:

env['PYTHONPATH'] = ':'.join(site_packages_dirs)

with current_directory(self.get_build_dir(arch.arch)):

hostpython = sh.Command(self.ctx.hostpython)

shprint(hostpython, '-c', 'import sys; print(sys.path)', _env=env)

print('cwd is', realpath(curdir))

info('Trying first build of {} to get cython files: this is '

'expected to fail'.format(self.name))

manually_cythonise = False

try:

shprint(hostpython, 'setup.py', 'build_ext', '-v', _env=env,

*self.setup_extra_args)

except sh.ErrorReturnCode_1:

print()

info('{} first build failed (as expected)'.format(self.name))

manually_cythonise = True

if manually_cythonise:

self.cythonize_build(env=env)

shprint(hostpython, 'setup.py', 'build_ext', '-v', _env=env,

_tail=20, _critical=True, *self.setup_extra_args)

else:

info('First build appeared to complete correctly, skipping manual'

'cythonising.')

if 'python2' in self.ctx.recipe_build_order:

info('Stripping object files')

build_lib = glob.glob('./build/lib*')

shprint(sh.find, build_lib[0], '-name', '*.o', '-exec',

env['STRIP'], '{}', ';', _env=env)

if 'python3crystax' in self.ctx.recipe_build_order:

info('Stripping object files')

shprint(sh.find, '.', '-iname', '*.so', '-exec',

'/usr/bin/echo', '{}', ';', _env=env)

shprint(sh.find, '.', '-iname', '*.so', '-exec',

env['STRIP'].split(' ')[0], '--strip-unneeded',

# '/usr/bin/strip', '--strip-unneeded',

'{}', ';', _env=env)

def cythonize_file(self, env, build_dir, filename):

short_filename = filename

if filename.startswith(build_dir):

short_filename = filename[len(build_dir) + 1:]

info(u"Cythonize {}".format(short_filename))

cyenv = env.copy()

if 'CYTHONPATH' in cyenv:

cyenv['PYTHONPATH'] = cyenv['CYTHONPATH']

elif 'PYTHONPATH' in cyenv: