32347666627

Committed 20 Aug 2026 08:12AM UTC coverage: 62.777% (+0.01%) from 62.763%

Build # 32347666627

Build Type

Pull #3366

github

Committed by

web-flow

Commit Message

Merge e131de844 into 7af1d1325

Pull Request Pull Request #3366: Remove venv creation for python package install stage

Coverage Stats

1819 of 3170 branches covered (57.38%)

Branch coverage included in aggregate %.

9 of 25 new or added lines in 1 file covered. (36.0%)

7 existing lines in 1 file now uncovered.

5396 of 8323 relevant lines covered (64.83%)

3.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

48.52

/pythonforandroid/build.py

import glob
import os
import json
import tempfile
from os import environ
from os.path import (
    abspath, join, realpath, dirname, expanduser, exists, basename
)
import re
import shutil
import subprocess
import sys

import sh

from packaging.utils import parse_wheel_filename
from packaging.requirements import Requirement

from pythonforandroid.androidndk import AndroidNDK
from pythonforandroid.archs import ArchARM, ArchARMv7_a, ArchAarch_64, Archx86, Archx86_64
from pythonforandroid.logger import (info, warning, info_notify, info_main, shprint, Out_Style, Out_Fore)
from pythonforandroid.pythonpackage import get_package_name
from pythonforandroid.recipe import Recipe, PyProjectRecipe
from pythonforandroid.recommendations import (
    check_ndk_version, check_target_api, check_ndk_api,
    RECOMMENDED_NDK_API, RECOMMENDED_TARGET_API)
from pythonforandroid.util import (
    current_directory, ensure_dir,
    BuildInterruptingException
)


def get_targets(sdk_dir):
    if exists(join(sdk_dir, 'cmdline-tools', 'latest', 'bin', 'avdmanager')):
        avdmanager = sh.Command(join(sdk_dir, 'cmdline-tools', 'latest', 'bin', 'avdmanager'))
        targets = avdmanager('list', 'target').split('\n')

    elif exists(join(sdk_dir, 'tools', 'bin', 'avdmanager')):
        avdmanager = sh.Command(join(sdk_dir, 'tools', 'bin', 'avdmanager'))
        targets = avdmanager('list', 'target').split('\n')
    elif exists(join(sdk_dir, 'tools', 'android')):
        android = sh.Command(join(sdk_dir, 'tools', 'android'))
        targets = android('list').split('\n')
    else:
        raise BuildInterruptingException(
            'Could not find `android` or `sdkmanager` binaries in Android SDK',
            instructions='Make sure the path to the Android SDK is correct')
    return targets


def get_available_apis(sdk_dir):
    targets = get_targets(sdk_dir)
    apis = [s for s in targets if re.match(r'^ *API level: ', s)]
    apis = [re.findall(r'[0-9]+', s) for s in apis]
    apis = [int(s[0]) for s in apis if s]
    return apis


class Context:
    '''A build context. If anything will be built, an instance this class
    will be instantiated and used to hold all the build state.'''

    # Whether to make a debug or release build
    build_as_debuggable = False

    # Whether to strip debug symbols in `.so` files
    with_debug_symbols = False

    env = environ.copy()
    # the filepath of toolchain.py
    root_dir = None
    # the root dir where builds and dists will be stored
    storage_dir = None

    # in which bootstraps are copied for building
    # and recipes are built
    build_dir = None

    distribution = None
    """The Distribution object representing the current build target location."""

    # the Android project folder where everything ends up
    dist_dir = None

    # Whether setup.py or similar should be used if present:
    use_setup_py = False

    ccache = None  # whether to use ccache

    ndk = None

    bootstrap = None
    bootstrap_build_dir = None

    recipe_build_order = None  # Will hold the list of all built recipes

    python_modules = None  # Will hold resolved pure python packages

    symlink_bootstrap_files = False  # If True, will symlink instead of copying during build

    java_build_tool = 'auto'

    skip_prebuilt = False

    extra_index_urls = []

    use_prebuilt_version_for = []

    save_wheel_dir = ''

    @property
    def packages_path(self):
        '''Where packages are downloaded before being unpacked'''
        return join(self.storage_dir, 'packages')

    @property
    def templates_dir(self):
        return join(self.root_dir, 'templates')

    @property
    def libs_dir(self):
        """
        where Android libs are cached after build
        but before being placed in dists
        """
        # Was previously hardcoded as self.build_dir/libs
        directory = join(self.build_dir, 'libs_collections',
                         self.bootstrap.distribution.name)
        ensure_dir(directory)
        return directory

    @property
    def javaclass_dir(self):
        # Was previously hardcoded as self.build_dir/java
        directory = join(self.build_dir, 'javaclasses',
                         self.bootstrap.distribution.name)
        ensure_dir(directory)
        return directory

    @property
    def aars_dir(self):
        directory = join(self.build_dir, 'aars', self.bootstrap.distribution.name)
        ensure_dir(directory)
        return directory

    @property
    def python_installs_dir(self):
        directory = join(self.build_dir, 'python-installs')
        ensure_dir(directory)
        return directory

    def get_python_install_dir(self, arch):
        return join(self.python_installs_dir, self.bootstrap.distribution.name, arch)

    def setup_dirs(self, storage_dir):
        '''Calculates all the storage and build dirs, and makes sure
        the directories exist where necessary.'''
        self.storage_dir = expanduser(storage_dir)
        if ' ' in self.storage_dir:
            raise ValueError('storage dir path cannot contain spaces, please '
                             'specify a path with --storage-dir')
        self.build_dir = join(self.storage_dir, 'build')
        self.dist_dir = join(self.storage_dir, 'dists')

    def ensure_dirs(self):
        ensure_dir(self.storage_dir)
        ensure_dir(self.build_dir)
        ensure_dir(self.dist_dir)
        ensure_dir(join(self.build_dir, 'bootstrap_builds'))
        ensure_dir(join(self.build_dir, 'other_builds'))

    @property
    def android_api(self):
        '''The Android API being targeted.'''
        if self._android_api is None:
            raise ValueError('Tried to access android_api but it has not '
                             'been set - this should not happen, something '
                             'went wrong!')
        return self._android_api

    @android_api.setter
    def android_api(self, value):
        self._android_api = value

    @property
    def ndk_api(self):
        '''The API number compile against'''
        if self._ndk_api is None:
            raise ValueError('Tried to access ndk_api but it has not '
                             'been set - this should not happen, something '
                             'went wrong!')
        return self._ndk_api

    @ndk_api.setter
    def ndk_api(self, value):
        self._ndk_api = value

    @property
    def sdk_dir(self):
        '''The path to the Android SDK.'''
        if self._sdk_dir is None:
            raise ValueError('Tried to access sdk_dir but it has not '
                             'been set - this should not happen, something '
                             'went wrong!')
        return self._sdk_dir

    @sdk_dir.setter
    def sdk_dir(self, value):
        self._sdk_dir = value

    @property
    def ndk_dir(self):
        '''The path to the Android NDK.'''
        if self._ndk_dir is None:
            raise ValueError('Tried to access ndk_dir but it has not '
                             'been set - this should not happen, something '
                             'went wrong!')
        return self._ndk_dir

    @ndk_dir.setter
    def ndk_dir(self, value):
        self._ndk_dir = value

    def prepare_build_environment(self,
                                  user_sdk_dir,
                                  user_ndk_dir,
                                  user_android_api,
                                  user_ndk_api):
        '''Checks that build dependencies exist and sets internal variables
        for the Android SDK etc.

        ..warning:: This *must* be called before trying any build stuff

        '''

        self.ensure_dirs()

        if self._build_env_prepared:
            return

        # Work out where the Android SDK is
        sdk_dir = None
        if user_sdk_dir:
            sdk_dir = user_sdk_dir
        # This is the old P4A-specific var
        if sdk_dir is None:
            sdk_dir = environ.get('ANDROIDSDK', None)
        # This seems used more conventionally
        if sdk_dir is None:
            sdk_dir = environ.get('ANDROID_HOME', None)
        # Checks in the buildozer SDK dir, useful for debug tests of p4a
        if sdk_dir is None:
            possible_dirs = glob.glob(expanduser(join(
                '~', '.buildozer', 'android', 'platform', 'android-sdk-*')))
            possible_dirs = [d for d in possible_dirs if not
                             d.endswith(('.bz2', '.gz'))]
            if possible_dirs:
                info('Found possible SDK dirs in buildozer dir: {}'.format(
                    ', '.join(d.split(os.sep)[-1] for d in possible_dirs)))
                info('Will attempt to use SDK at {}'.format(possible_dirs[0]))
                warning('This SDK lookup is intended for debug only, if you '
                        'use python-for-android much you should probably '
                        'maintain your own SDK download.')
                sdk_dir = possible_dirs[0]
        if sdk_dir is None:
            raise BuildInterruptingException('Android SDK dir was not specified, exiting.')
        self.sdk_dir = realpath(sdk_dir)

        # Check what Android API we're using
        android_api = None
        if user_android_api:
            android_api = user_android_api
            info('Getting Android API version from user argument: {}'.format(android_api))
        elif 'ANDROIDAPI' in environ:
            android_api = environ['ANDROIDAPI']
            info('Found Android API target in $ANDROIDAPI: {}'.format(android_api))
        else:
            info('Android API target was not set manually, using '
                 'the default of {}'.format(RECOMMENDED_TARGET_API))
            android_api = RECOMMENDED_TARGET_API
        android_api = int(android_api)
        self.android_api = android_api

        for arch in self.archs:
            # Maybe We could remove this one in a near future (ARMv5 is definitely old)
            check_target_api(android_api, arch)
        apis = get_available_apis(self.sdk_dir)
        info('Available Android APIs are ({})'.format(
            ', '.join(map(str, apis))))
        if android_api in apis:
            info(('Requested API target {} is available, '
                  'continuing.').format(android_api))
        else:
            raise BuildInterruptingException(
                ('Requested API target {} is not available, install '
                 'it with the SDK android tool.').format(android_api))

        # Find the Android NDK
        # Could also use ANDROID_NDK, but doesn't look like many tools use this
        ndk_dir = None
        if user_ndk_dir:
            ndk_dir = user_ndk_dir
            info('Getting NDK dir from from user argument')
        if ndk_dir is None:  # The old P4A-specific dir
            ndk_dir = environ.get('ANDROIDNDK', None)
            if ndk_dir is not None:
                info('Found NDK dir in $ANDROIDNDK: {}'.format(ndk_dir))
        if ndk_dir is None:  # Apparently the most common convention
            ndk_dir = environ.get('NDK_HOME', None)
            if ndk_dir is not None:
                info('Found NDK dir in $NDK_HOME: {}'.format(ndk_dir))
        if ndk_dir is None:  # Another convention (with maven?)
            ndk_dir = environ.get('ANDROID_NDK_HOME', None)
            if ndk_dir is not None:
                info('Found NDK dir in $ANDROID_NDK_HOME: {}'.format(ndk_dir))
        if ndk_dir is None:  # Checks in the buildozer NDK dir, useful
            #                # for debug tests of p4a
            possible_dirs = glob.glob(expanduser(join(
                '~', '.buildozer', 'android', 'platform', 'android-ndk-r*')))
            if possible_dirs:
                info('Found possible NDK dirs in buildozer dir: {}'.format(
                    ', '.join(d.split(os.sep)[-1] for d in possible_dirs)))
                info('Will attempt to use NDK at {}'.format(possible_dirs[0]))
                warning('This NDK lookup is intended for debug only, if you '
                        'use python-for-android much you should probably '
                        'maintain your own NDK download.')
                ndk_dir = possible_dirs[0]
        if ndk_dir is None:
            raise BuildInterruptingException('Android NDK dir was not specified')
        self.ndk_dir = realpath(ndk_dir)
        check_ndk_version(ndk_dir)

        ndk_api = None
        if user_ndk_api:
            ndk_api = user_ndk_api
            info('Getting NDK API version (i.e. minimum supported API) from user argument')
        elif 'NDKAPI' in environ:
            ndk_api = environ.get('NDKAPI', None)
            info('Found Android API target in $NDKAPI')
        else:
            ndk_api = min(self.android_api, RECOMMENDED_NDK_API)
            warning('NDK API target was not set manually, using '
                    'the default of {} = min(android-api={}, default ndk-api={})'.format(
                        ndk_api, self.android_api, RECOMMENDED_NDK_API))
        ndk_api = int(ndk_api)
        self.ndk_api = ndk_api

        check_ndk_api(ndk_api, self.android_api)

        self.ndk = AndroidNDK(self.ndk_dir)

        # path to some tools
        self.ccache = shutil.which("ccache")
        if not self.ccache:
            info('ccache is missing, the build will not be optimized in the '
                 'future.')
        try:
            subprocess.check_output([
                "python3", "-m", "cython", "--help",
            ])
        except subprocess.CalledProcessError:
            warning('Cython for python3 missing. If you are building for '
                    ' a python 3 target (which is the default)'
                    ' then THINGS WILL BREAK.')

        self.env["PATH"] = ":".join(
            [
                self.ndk.llvm_bin_dir,
                self.ndk_dir,
                f"{self.sdk_dir}/tools",
                environ.get("PATH"),
            ]
        )

    def __init__(self):
        self.include_dirs = []

        self._build_env_prepared = False

        self._sdk_dir = None
        self._ndk_dir = None
        self._android_api = None
        self._ndk_api = None
        self.ndk = None

        self.local_recipes = None
        self.copy_libs = False

        self.activity_class_name = u'org.kivy.android.PythonActivity'
        self.service_class_name = u'org.kivy.android.PythonService'

        # this list should contain all Archs, it is pruned later
        self.archs = (
            ArchARM(self),
            ArchARMv7_a(self),
            Archx86(self),
            Archx86_64(self),
            ArchAarch_64(self),
            )

        self.root_dir = realpath(dirname(__file__))

        # remove the most obvious flags that can break the compilation
        self.env.pop("LDFLAGS", None)
        self.env.pop("ARCHFLAGS", None)
        self.env.pop("CFLAGS", None)

        self.python_recipe = None  # Set by TargetPythonRecipe

    def set_archs(self, arch_names):
        all_archs = self.archs
        new_archs = set()
        for name in arch_names:
            matching = [arch for arch in all_archs if arch.arch == name]
            for match in matching:
                new_archs.add(match)
        self.archs = list(new_archs)
        if not self.archs:
            raise BuildInterruptingException('Asked to compile for no Archs, so failing.')
        info('Will compile for the following archs: {}'.format(
            ', '.join(arch.arch for arch in self.archs)))

    def prepare_bootstrap(self, bootstrap):
        if not bootstrap:
            raise TypeError("None is not allowed for bootstrap")
        bootstrap.ctx = self
        self.bootstrap = bootstrap
        self.bootstrap.prepare_build_dir()
        self.bootstrap_build_dir = self.bootstrap.build_dir

    def prepare_dist(self):
        self.bootstrap.prepare_dist_dir()

    def get_site_packages_dir(self, arch):
        '''Returns the location of site-packages in the python-install build
        dir.
        '''
        return self.get_python_install_dir(arch.arch)

    def get_libs_dir(self, arch):
        '''The libs dir for a given arch.'''
        ensure_dir(join(self.libs_dir, arch))
        return join(self.libs_dir, arch)

    def has_lib(self, arch, lib):
        return exists(join(self.get_libs_dir(arch), lib))

    def has_package(self, name, arch=None):
        # If this is a file path, it'll need special handling:
        if (name.find("/") >= 0 or name.find("\\") >= 0) and \
                name.find("://") < 0:  # (:// would indicate an url)
            if not os.path.exists(name):
                # Non-existing dir, cannot look this up.
                return False
            try:
                name = get_package_name(os.path.abspath(name))
            except ValueError:
                # Failed to look up any meaningful name.
                return False

        # normalize name to remove version tags
        try:
            name = Requirement(name).name
        except Exception:
            pass

        # Try to look up recipe by name:
        try:
            recipe = Recipe.get_recipe(name, self)
        except ValueError:
            pass
        else:
            name = getattr(recipe, 'site_packages_name', None) or name
        name = name.replace('.', '/')
        site_packages_dir = self.get_site_packages_dir(arch)
        return (exists(join(site_packages_dir, name)) or
                exists(join(site_packages_dir, name + '.py')) or
                exists(join(site_packages_dir, name + '.pyc')) or
                exists(join(site_packages_dir, name + '.so')) or
                glob.glob(join(site_packages_dir, name + '-*.egg')))

    def not_has_package(self, name, arch=None):
        return not self.has_package(name, arch)


def build_recipes(build_order, python_modules, ctx, project_dir,
                  ignore_project_setup_py=False
                 ):
    # Put recipes in correct build order
    info_notify("Recipe build order is {}".format(build_order))
    if python_modules:
        python_modules = sorted(set(python_modules))
        info_notify(
            ('The requirements ({}) were not found as recipes, they will be '
             'installed with pip.').format(', '.join(python_modules)))

    recipes = [Recipe.get_recipe(name, ctx) for name in build_order]

    # download is arch independent
    info_main('# Downloading recipes ')
    for recipe in recipes:
        recipe.download_if_necessary()

    for arch in ctx.archs:
        info_main('# Building all recipes for arch {}'.format(arch.arch))

        info_main('# Unpacking recipes')
        for recipe in recipes:
            ensure_dir(recipe.get_build_container_dir(arch.arch))
            recipe.prepare_build_dir(arch.arch)

        info_main('# Prebuilding recipes')
        # ensure we have `ctx.python_recipe` and `ctx.hostpython`
        Recipe.get_recipe("python3", ctx).prebuild_arch(arch)
        ctx.hostpython = Recipe.get_recipe("hostpython3", ctx).python_exe

        # 2) prebuild packages
        for recipe in recipes:
            info_main('Prebuilding {} for {}'.format(recipe.name, arch.arch))
            recipe.prebuild_arch(arch)
            recipe.apply_patches(arch)

        # 3) build packages
        info_main('# Building recipes')
        for recipe in recipes:
            info_main('Building {} for {}'.format(recipe.name, arch.arch))
            if recipe.should_build(arch):
                recipe.build_arch(arch)
            else:
                info('{} said it is already built, skipping'
                     .format(recipe.name))
            recipe.install_libraries(arch)

        # 4) biglink everything
        info_main('# Biglinking object files')
        if not ctx.python_recipe:
            biglink(ctx, arch)
        else:
            warning(
                "Context's python recipe found, "
                "skipping biglink (will this work?)"
            )

        # 5) postbuild packages
        info_main('# Postbuilding recipes')
        for recipe in recipes:
            info_main('Postbuilding {} for {}'.format(recipe.name, arch.arch))
            recipe.postbuild_arch(arch)

    info_main('# Installing pure Python modules')
    for arch in ctx.archs:
        run_pymodules_install(
            ctx, arch, python_modules, project_dir,
            ignore_setup_py=ignore_project_setup_py
        )


def project_has_setup_py(project_dir):
    return (project_dir is not None and
            (exists(join(project_dir, "setup.py")) or
             exists(join(project_dir, "pyproject.toml"))
            ))


def is_wheel_platform_independent(whl_name):
    name, version, build, tags = parse_wheel_filename(whl_name)
    return all(tag.platform == "any" for tag in tags)


def is_wheel_compatible(whl_name, arch, ctx):
    name, version, build, tags = parse_wheel_filename(whl_name)
    supported_tags = PyProjectRecipe.get_wheel_platform_tags(arch.arch, ctx)
    supported_tags.append("any")
    result = all(tag.platform in supported_tags for tag in tags)
    if not result:
        warning(f"Incompatible module : {whl_name}")
    return result


def process_python_modules(ctx, modules, arch):
    """Use pip --dry-run to resolve dependencies and filter for pure-Python packages
    """
    modules = list(modules)
    build_order = list(ctx.recipe_build_order)

    _requirement_names = []
    processed_modules = []

    for module in modules+build_order:
        try:
            # we need to normalize names
            # eg Requests>=2.0 becomes requests
            _requirement_names.append(Requirement(module).name)
        except Exception:
            # name parsing failed; skip processing this module via pip
            processed_modules.append(module)
            if module in modules:
                modules.remove(module)

    if len(processed_modules) > 0:
        warning(f'Ignored by module resolver : {processed_modules}')

    # preserve the original module list
    processed_modules.extend(modules)

    # temp file for pip report
    fd, path = tempfile.mkstemp()
    os.close(fd)

    # setup hostpython recipe
    env = environ.copy()
    host_recipe = None
    try:
        host_recipe = Recipe.get_recipe("hostpython3", ctx)
        pip = host_recipe.pip
    except Exception:
        # hostpython3 is unavailable, so fall back to system pip
        pip = sh.Command("pip")

    # add platform tags
    platforms = []
    tags = PyProjectRecipe.get_wheel_platform_tags(arch.arch, ctx)
    for tag in tags:
        platforms.append(f"--platform={tag}")

    if host_recipe is not None:
        platforms.extend(["--python-version", host_recipe.version])
    else:
        # use the version of the currently running Python interpreter
        current_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
        platforms.extend(["--python-version", current_version])

    indices = []
    # add extra index urls
    for index in ctx.extra_index_urls:
        indices.extend(["--extra-index-url", index])

    state = [pip, platforms, indices, env]

    try:
        shprint(
            pip, 'install', *modules,
            '--dry-run', '--break-system-packages', '--ignore-installed',
            '--disable-pip-version-check', '--only-binary=:all:',
            '--report', path, '-q', *platforms, *indices, _env=env
        )
    except Exception as e:
        warning(f"Auto module resolution failed: {e}")
        return processed_modules, state

    with open(path, "r") as f:
        try:
            report = json.load(f)
        except Exception:
            report = {}

    os.remove(path)

    if "install" not in report.keys():
        # pip changed json reporting format?
        warning("Auto module resolution failed: invalid json!")
        return processed_modules, state

    info('Extra resolved python platform dependencies :')

    ignored_str = " (ignored)"
    # did we find any non pure python package?
    any_not_pure_python = False

    # just for style
    info(" ")
    for module in report["install"]:

        mname = module["metadata"]["name"]
        mver = module["metadata"]["version"]
        filename = basename(module["download_info"]["url"])
        pure_python = True

        if (
                filename.endswith(".whl") and not is_wheel_compatible(filename, arch, ctx)
        ):
            any_not_pure_python = True
            pure_python = False

        if mname.lower().replace("-", "_") in _requirement_names or mname.lower() in _requirement_names:
            continue

        color = Out_Fore.GREEN if pure_python else Out_Fore.RED
        ignored = "" if pure_python else ignored_str

        info(
            f"  {color}{mname}{Out_Fore.WHITE} : "
            f"{Out_Style.BRIGHT}{mver}{Out_Style.RESET_ALL}"
            f"{ignored}"
        )

        if pure_python:
            # Direct whl file to avoid resolving again
            processed_modules.append(module["download_info"]["url"])
    info(" ")

    if any_not_pure_python:
        warning("Some packages were ignored because they are not pure Python.")
        warning("To install the ignored packages, explicitly list them in your requirements file.")

    return processed_modules, state


def run_pymodules_install(ctx, arch, modules, project_dir=None,
                          ignore_setup_py=False):
    """ This function will take care of all non-recipe things, by:

        1. Processing them from --requirements (the modules argument)
           and installing them

        2. Installing the user project/app itself via setup.py if
           ignore_setup_py=True

    """

    info('*** PYTHON PACKAGE / PROJECT INSTALL STAGE FOR ARCH: {} ***'.format(arch))

    # Restore version strings from environment
    for index, module in enumerate(modules):
        if (m_version := os.environ.get(f'VERSION_{module}', None)) is not None:
            modules[index] = f'{module}=={m_version}'

    modules, state = process_python_modules(ctx, modules, arch)
    # Reuse the state constructed
    pip, platforms, indices, env = state

    # It always runs with --upgrade so this is not required as it skips if module already exists
    # modules = [m for m in modules if ctx.not_has_package(m, arch)]

    # We change current working directory later, so this has to be an absolute
    # path or `None` in case that we didn't supply the `project_dir` via kwargs
    project_dir = abspath(project_dir) if project_dir else None

    # Bail out if no python deps and no setup.py to process:
    if not modules and (
            ignore_setup_py or
            not project_has_setup_py(project_dir)
            ):
        info('No Python modules and no setup.py to process, skipping')
        return

    # Output messages about what we're going to do:
    if modules:
        info(
            "The requirements ({}) don\'t have recipes, attempting to "
            "install them with pip".format(', '.join(modules))
        )
        info(
            "If this fails, it may mean that the module has compiled "
            "components and needs a recipe."
        )

    if project_has_setup_py(project_dir) and not ignore_setup_py:
        info(
            "Will process project install, if it fails then the "
            "project may not be compatible for Android install."
        )

    if not modules:
        info('There are no Python modules to install, skipping')
    else:

        info('Installing Python modules with pip')
        info(
            "IF THIS FAILS, THE MODULES MAY NEED A RECIPE. "
            "A reason for this is often modules compiling "
            "native code that is unaware of Android cross-compilation "
            "and does not work without additional "
            "changes / workarounds."
        )
        # --no-deps is required here as auto resolution is already done above
        shprint(
            pip, 'install', *modules,
            '--target', ctx.get_site_packages_dir(arch),
            '--upgrade', '--ignore-installed', '--no-deps',
            '--disable-pip-version-check', '--only-binary=:all:',
            *platforms, *indices, _env=env
        )

    # Afterwards, run setup.py if present:
    if project_has_setup_py(project_dir) and not ignore_setup_py:
        with current_directory(project_dir):
            # TODO: It will only work for basic python projects with no compiled components
            shprint(
                pip, 'install', ".",
                '--target', ctx.get_site_packages_dir(arch),
                '--disable-pip-version-check', '--upgrade',
                *platforms, *indices, _env=env
            )
    elif not ignore_setup_py:
        info("No setup.py found in project directory: " + str(project_dir))

    # Strip object files after potential Cython or native code builds:
    if not ctx.with_debug_symbols and env.get("STRIP", None) is not None:
        info('Stripping object files')
        shprint(
            sh.find, '.', '-iname', '*.so',
            '-exec', env['STRIP'].split(' ')[0],
            '--strip-unneeded', '{}', ';',
            _env=env
        )


def biglink(ctx, arch):
    # First, collate object files from each recipe
    info('Collating object files from each recipe')
    obj_dir = join(ctx.bootstrap.build_dir, 'collated_objects')
    ensure_dir(obj_dir)
    recipes = [Recipe.get_recipe(name, ctx) for name in ctx.recipe_build_order]
    for recipe in recipes:
        recipe_obj_dir = join(recipe.get_build_container_dir(arch.arch),
                              'objects_{}'.format(recipe.name))
        if not exists(recipe_obj_dir):
            info('{} recipe has no biglinkable files dir, skipping'
                 .format(recipe.name))
            continue
        files = glob.glob(join(recipe_obj_dir, '*'))
        if not len(files):
            info('{} recipe has no biglinkable files, skipping'
                 .format(recipe.name))
            continue
        info('{} recipe has object files, copying'.format(recipe.name))
        files.append(obj_dir)
        shprint(sh.cp, '-r', *files)

    env = arch.get_env()
    env['LDFLAGS'] = env['LDFLAGS'] + ' -L{}'.format(
        join(ctx.bootstrap.build_dir, 'obj', 'local', arch.arch))

    if not len(glob.glob(join(obj_dir, '*'))):
        info('There seem to be no libraries to biglink, skipping.')
        return
    info('Biglinking')
    info('target {}'.format(join(ctx.get_libs_dir(arch.arch),
                                 'libpymodules.so')))
    do_biglink = copylibs_function if ctx.copy_libs else biglink_function

    # Move to the directory containing crtstart_so.o and crtend_so.o
    # This is necessary with newer NDKs? A gcc bug?
    with current_directory(arch.ndk_lib_dir):
        do_biglink(
            join(ctx.get_libs_dir(arch.arch), 'libpymodules.so'),
            obj_dir.split(' '),
            extra_link_dirs=[join(ctx.bootstrap.build_dir,
                                  'obj', 'local', arch.arch),
                             os.path.abspath('.')],
            env=env)


def biglink_function(soname, objs_paths, extra_link_dirs=None, env=None):
    if extra_link_dirs is None:
        extra_link_dirs = []
    print('objs_paths are', objs_paths)
    sofiles = []

    for directory in objs_paths:
        for fn in os.listdir(directory):
            fn = os.path.join(directory, fn)

            if not fn.endswith(".so.o"):
                continue
            if not os.path.exists(fn[:-2] + ".libs"):
                continue

            sofiles.append(fn[:-2])

    # The raw argument list.
    args = []

    for fn in sofiles:
        afn = fn + ".o"
        libsfn = fn + ".libs"

        args.append(afn)
        with open(libsfn) as fd:
            data = fd.read()
            args.extend(data.split(" "))

    unique_args = []
    while args:
        a = args.pop()
        if a in ('-L', ):
            continue
        if a not in unique_args:
            unique_args.insert(0, a)

    for dir in extra_link_dirs:
        link = '-L{}'.format(dir)
        if link not in unique_args:
            unique_args.append(link)

    cc_name = env['CC']
    cc = sh.Command(cc_name.split()[0])
    cc = cc.bake(*cc_name.split()[1:])

    shprint(cc, '-shared', '-O3', '-o', soname, *unique_args, _env=env)


def copylibs_function(soname, objs_paths, extra_link_dirs=None, env=None):
    if extra_link_dirs is None:
        extra_link_dirs = []
    print('objs_paths are', objs_paths)

    re_needso = re.compile(r'^.*\(NEEDED\)\s+Shared library: \[lib(.*)\.so\]\s*$')
    blacklist_libs = (
        'c',
        'stdc++',
        'dl',
        'python2.7',
        'sdl',
        'sdl_image',
        'sdl_ttf',
        'z',
        'm',
        'GLESv2',
        'jpeg',
        'png',
        'log',

        # bootstrap takes care of sdl2 libs (if applicable)
        'SDL2',
        'SDL2_ttf',
        'SDL2_image',
        'SDL2_mixer',
        'SDL3',
        'SDL3_ttf',
        'SDL3_image',
        'SDL3_mixer',
    )
    found_libs = []
    sofiles = []
    if env and 'READELF' in env:
        readelf = env['READELF']
    elif 'READELF' in os.environ:
        readelf = os.environ['READELF']
    else:
        readelf = shutil.which('readelf').strip()
    readelf = sh.Command(readelf).bake('-d')

    dest = dirname(soname)

    for directory in objs_paths:
        for fn in os.listdir(directory):
            fn = join(directory, fn)

            if not fn.endswith('.libs'):
                continue

            dirfn = fn[:-1] + 'dirs'
            if not exists(dirfn):
                continue

            with open(fn) as f:
                libs = f.read().strip().split(' ')
                needed_libs = [lib for lib in libs
                               if lib and
                               lib not in blacklist_libs and
                               lib not in found_libs]

            while needed_libs:
                print('need libs:\n\t' + '\n\t'.join(needed_libs))

                start_needed_libs = needed_libs[:]
                found_sofiles = []

                with open(dirfn) as f:
                    libdirs = f.read().split()
                    for libdir in libdirs:
                        if not needed_libs:
                            break

                        if libdir == dest:
                            # don't need to copy from dest to dest!
                            continue

                        libdir = libdir.strip()
                        print('scanning', libdir)
                        for lib in needed_libs[:]:
                            if lib in found_libs:
                                continue

                            if lib.endswith('.a'):
                                needed_libs.remove(lib)
                                found_libs.append(lib)
                                continue

                            lib_a = 'lib' + lib + '.a'
                            libpath_a = join(libdir, lib_a)
                            lib_so = 'lib' + lib + '.so'
                            libpath_so = join(libdir, lib_so)
                            plain_so = lib + '.so'
                            plainpath_so = join(libdir, plain_so)

                            sopath = None
                            if exists(libpath_so):
                                sopath = libpath_so
                            elif exists(plainpath_so):
                                sopath = plainpath_so

                            if sopath:
                                print('found', lib, 'in', libdir)
                                found_sofiles.append(sopath)
                                needed_libs.remove(lib)
                                found_libs.append(lib)
                                continue

                            if exists(libpath_a):
                                print('found', lib, '(static) in', libdir)
                                needed_libs.remove(lib)
                                found_libs.append(lib)
                                continue

                for sofile in found_sofiles:
                    print('scanning dependencies for', sofile)
                    out = readelf(sofile)
                    for line in out.splitlines():
                        needso = re_needso.match(line)
                        if needso:
                            lib = needso.group(1)
                            if (lib not in needed_libs
                                    and lib not in found_libs
                                    and lib not in blacklist_libs):
                                needed_libs.append(needso.group(1))

                sofiles += found_sofiles

                if needed_libs == start_needed_libs:
                    raise RuntimeError(
                            'Failed to locate needed libraries!\n\t' +
                            '\n\t'.join(needed_libs))

    print('Copying libraries')
    shprint(sh.cp, *sofiles, dest)

kivy / python-for-android / 32347666627

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous