scipy: update to v1.15.2

Makefile

@@ -60,19 +60,6 @@ testapps-with-numpy/%: virtualenv
     --arch=armeabi-v7a --arch=arm64-v8a --arch=x86_64 --arch=x86 \
 	--permission "(name=android.permission.WRITE_EXTERNAL_STORAGE;maxSdkVersion=18)" --permission "(name=android.permission.INTERNET)"
 
-testapps-with-scipy: testapps-with-scipy/debug/apk testapps-with-scipy/release/aab
-
-# testapps-with-scipy/MODE/ARTIFACT
-testapps-with-scipy/%: virtualenv
-	$(eval MODE := $(word 2, $(subst /, ,$@)))
-	$(eval ARTIFACT := $(word 3, $(subst /, ,$@)))
-	@echo Building testapps-with-scipy for $(MODE) mode and $(ARTIFACT) artifact
-	. $(ACTIVATE) && cd testapps/on_device_unit_tests/ && \
-	export LEGACY_NDK=$(ANDROID_NDK_HOME_LEGACY)  && \
-    python setup.py $(ARTIFACT) --$(MODE) --sdk-dir $(ANDROID_SDK_HOME) --ndk-dir $(ANDROID_NDK_HOME) \
-			--requirements python3,scipy,kivy \
-    --arch=armeabi-v7a --arch=arm64-v8a
-
 testapps-webview: testapps-webview/debug/apk testapps-webview/release/aab
 
 # testapps-webview/MODE/ARTIFACT

ci/constants.py

@@ -25,8 +25,6 @@ class TargetPython(Enum):
     # mpmath package with a version >= 0.19 required
     'sympy',
     'vlc',
-    # need extra gfortran NDK system add-on
-    'lapack', 'scipy',
     # Outdated and there's a chance that is now useless.
     'zope_interface',
     # Requires zope_interface, which is broken.

ci/makefiles/android.mk

@@ -1,7 +1,7 @@
 # Downloads and installs the Android SDK depending on supplied platform: darwin or linux
 
 # Those android NDK/SDK variables can be override when running the file
-ANDROID_NDK_VERSION ?= 25b
+ANDROID_NDK_VERSION ?= 27c
 ANDROID_NDK_VERSION_LEGACY ?= 21e
 ANDROID_SDK_TOOLS_VERSION ?= 6514223
 ANDROID_SDK_BUILD_TOOLS_VERSION ?= 29.0.3

doc/source/quickstart.rst

@@ -119,7 +119,7 @@ named ``tools``, and you will need to run extra commands to install
 the SDK packages needed. 
 
 For Android NDK, note that modern releases will only work on a 64-bit
-operating system. **The minimal, and recommended, NDK version to use is r25b:**
+operating system. **The minimal, and recommended, NDK version to use is r27c:**
 
  - `Go to ndk downloads page <https://developer.android.com/ndk/downloads/>`_
  - Windows users should create a virtual machine with an GNU Linux os

pythonforandroid/recipe.py

@@ -155,6 +155,11 @@ class Recipe(metaclass=RecipeMeta):
         starting from NDK r18 the `gnustl_shared` lib has been deprecated.
     '''
 
+    min_ndk_api_support = 20
+    '''
+    Minimum ndk api your recipe will support
+    '''
+
     def get_stl_library(self, arch):
         return join(
             arch.ndk_lib_dir,
@@ -269,6 +274,7 @@ def report_hook(index, blksize, size):
                     shprint(sh.git, 'pull')
                     shprint(sh.git, 'pull', '--recurse-submodules')
                 shprint(sh.git, 'submodule', 'update', '--recursive', '--init', '--depth', '1')
+
             return target
 
     def apply_patch(self, filename, arch, build_dir=None):
@@ -375,7 +381,12 @@ def get_recipe_dir(self):
     # Public Recipe API to be subclassed if needed
 
     def download_if_necessary(self):
+        if self.ctx.ndk_api < self.min_ndk_api_support:
+            error(f"In order to build '{self.name}', you must set minimum ndk api (minapi) to `{self.min_ndk_api_support}`.\n")
+            exit(1)
+
         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(
@@ -919,6 +930,32 @@ def folder_name(self):
             name = self.name
         return name
 
+    def patch_shebang(self, _file, original_bin):
+        _file_des = open(_file, "r")
+
+        try:
+            data = _file_des.readlines()
+        except UnicodeDecodeError:
+            return
+
+        if "#!" in (line := data[0]):
+            if line.split("#!")[-1].strip() == original_bin:
+                return
+
+            info(f"Fixing sheband for '{_file}'")
+            data.pop(0)
+            data.insert(0, "#!" + original_bin + "\n")
+            _file_des.close()
+            _file_des = open(_file, "w")
+            _file_des.write("".join(data))
+            _file_des.close()
+
+    def patch_shebangs(self, path, original_bin):
+        # set correct shebang
+        for file in listdir(path):
+            _file = join(path, file)
+            self.patch_shebang(_file, original_bin)
+
     def get_recipe_env(self, arch=None, with_flags_in_cc=True):
         env = super().get_recipe_env(arch, with_flags_in_cc)
         env['PYTHONNOUSERSITE'] = '1'
@@ -1260,6 +1297,9 @@ def build_arch(self, arch):
         self.install_hostpython_prerequisites(
             packages=["build[virtualenv]", "pip"] + self.hostpython_prerequisites
         )
+        python_bin_dir = join(self.hostpython_site_dir, "bin")
+        self.patch_shebangs(python_bin_dir, self.real_hostpython_location)
+
         build_dir = self.get_build_dir(arch.arch)
         env = self.get_recipe_env(arch, with_flags_in_cc=True)
         # make build dir separately
@@ -1308,6 +1348,7 @@ def get_recipe_meson_options(self, arch):
                 "cpp_args": self.sanitize_flags(env["CXXFLAGS"], env["CPPFLAGS"]),
                 "c_link_args": self.sanitize_flags(env["LDFLAGS"]),
                 "cpp_link_args": self.sanitize_flags(env["LDFLAGS"]),
+                "fortran_link_args": self.sanitize_flags(env["LDFLAGS"]),
             },
             "properties": {
                 "needs_exe_wrapper": True,

pythonforandroid/recipes/fortran/__init__.py

@@ -0,0 +1,188 @@
+import os
+import subprocess
+import shutil
+import sh
+from pathlib import Path
+from os.path import join
+from pythonforandroid.recipe import Recipe
+from pythonforandroid.recommendations import read_ndk_version
+from pythonforandroid.logger import info, shprint, info_main
+from pythonforandroid.util import ensure_dir
+import hashlib
+
+FLANG_FILES = {
+    "package-flang-aarch64.tar.bz2": "775f362c758abe8d3173edc7be9ced3730ff14c64d44743017c3af7ceb0a6610",
+    "package-flang-host.tar.bz2": "04fe24d67ee7eb5a4223299c610013585e75c56467e4b185ed929a3d17e3d077",
+    "package-flang-x86_64.tar.bz2": "2061a0e3179f4afa55516ce3858582d25ea7b108ff762d9fb4ec8a03b49b36d2",
+    "package-install.tar.bz2": "d37dc6a58b495807f015c7fec08a57ff95d52ad0d0553cbf573b0215d8a1707c",
+}
+
+
+class GFortranRecipe(Recipe):
+    # flang support in NDK by @termux (on github)
+    name = "fortran"
+    toolchain_ver = 0
+    url = "https://github.com/termux/ndk-toolchain-clang-with-flang/releases/download/"
+
+    def match_sha256(self, file_path, expected_hash):
+        sha256 = hashlib.sha256()
+        with open(file_path, "rb") as f:
+            for chunk in iter(lambda: f.read(8192), b""):
+                sha256.update(chunk)
+        file_hash = sha256.hexdigest()
+        return file_hash == expected_hash
+
+    @property
+    def ndk_version(self):
+        ndk_version = read_ndk_version(self.ctx.ndk_dir)
+        minor_to_letter = {0: ""}
+        minor_to_letter.update(
+            {n + 1: chr(i) for n, i in enumerate(range(ord("b"), ord("b") + 25))}
+        )
+        return f"{ndk_version.major}{minor_to_letter[ndk_version.minor]}"
+
+    def get_cache_dir(self):
+        dir_name = self.get_dir_name()
+        return join(self.ctx.build_dir, "other_builds", dir_name)
+
+    def get_fortran_dir(self):
+        toolchain_name = f"android-r{self.ndk_version}-api-{self.ctx.ndk_api}"
+        return join(
+            self.get_cache_dir(), f"{toolchain_name}-flang-v{self.toolchain_ver}"
+        )
+
+    def get_incomplete_files(self):
+        incomplete_files = []
+        cache_dir = self.get_cache_dir()
+        for file, sha256sum in FLANG_FILES.items():
+            _file = join(cache_dir, file)
+            if not (os.path.exists(_file) and self.match_sha256(_file, sha256sum)):
+                incomplete_files.append(file)
+        return incomplete_files
+
+    def download_if_necessary(self):
+        assert self.ndk_version == "27c"
+        if len(self.get_incomplete_files()) == 0:
+            return
+        self.download()
+
+    def download(self):
+        cache_dir = self.get_cache_dir()
+        ensure_dir(cache_dir)
+        for file in self.get_incomplete_files():
+            _file = join(cache_dir, file)
+            if os.path.exists(_file):
+                os.remove(_file)
+            self.download_file(f"{self.url}r{join(self.ndk_version, file)}", _file)
+
+    def extract_tar(self, file_path: Path, dest: Path, strip=1):
+        shprint(
+            sh.tar,
+            "xf",
+            str(file_path),
+            "--strip-components",
+            str(strip),
+            "-C",
+            str(dest) if dest else ".",
+        )
+
+    def create_flang_wrapper(self, path: Path, target: str):
+        script = f"""#!/usr/bin/env bash
+if [ "$1" != "-cpp" ] && [ "$1" != "-fc1" ]; then
+  `dirname $0`/flang-new --target={target}{self.ctx.ndk_api} -D__ANDROID_API__={self.ctx.ndk_api} "$@"
+else
+  `dirname $0`/flang-new "$@"
+fi
+"""
+        path.write_text(script)
+        path.chmod(0o755)
+
+    def unpack(self, arch):
+        info_main("Unpacking fortran")
+
+        flang_folder = self.get_fortran_dir()
+        if os.path.exists(flang_folder):
+            info("{} is already unpacked, skipping".format(self.name))
+            return
+
+        toolchain_path = Path(
+            join(self.ctx.ndk_dir, "toolchains/llvm/prebuilt/linux-x86_64")
+        )
+        cache_dir = Path(os.path.abspath(self.get_cache_dir()))
+
+        # clean tmp folder
+        tmp_folder = Path(os.path.abspath(f"{flang_folder}-tmp"))
+        shutil.rmtree(tmp_folder, ignore_errors=True)
+        tmp_folder.mkdir(parents=True)
+        os.chdir(tmp_folder)
+
+        self.extract_tar(cache_dir / "package-install.tar.bz2", None, strip=4)
+        self.extract_tar(cache_dir / "package-flang-host.tar.bz2", None)
+
+        sysroot_path = tmp_folder / "sysroot"
+        shutil.copytree(toolchain_path / "sysroot", sysroot_path)
+
+        self.extract_tar(
+            cache_dir / "package-flang-aarch64.tar.bz2",
+            sysroot_path / "usr/lib/aarch64-linux-android",
+        )
+        self.extract_tar(
+            cache_dir / "package-flang-x86_64.tar.bz2",
+            sysroot_path / "usr/lib/x86_64-linux-android",
+        )
+
+        # Fix lib/clang paths
+        version_output = subprocess.check_output(
+            [str(tmp_folder / "bin/clang"), "--version"], text=True
+        )
+        clang_version = next(
+            (line for line in version_output.splitlines() if "clang version" in line),
+            "",
+        )
+        major_ver = clang_version.split("clang version ")[-1].split(".")[0]
+
+        lib_path = tmp_folder / f"lib/clang/{major_ver}/lib"
+        src_lib_path = toolchain_path / f"lib/clang/{major_ver}/lib"
+        shutil.rmtree(lib_path, ignore_errors=True)
+        lib_path.mkdir(parents=True)
+
+        for item in src_lib_path.iterdir():
+            shprint(sh.cp, "-r", str(item), str(lib_path))
+
+        # Create flang wrappers
+        targets = [
+            "aarch64-linux-android",
+            "armv7a-linux-androideabi",
+            "i686-linux-android",
+            "x86_64-linux-android",
+        ]
+
+        for target in targets:
+            wrapper_path = tmp_folder / f"bin/{target}-flang"
+            self.create_flang_wrapper(wrapper_path, target)
+            shutil.copy(
+                wrapper_path, tmp_folder / f"bin/{target}{self.ctx.ndk_api}-flang"
+            )
+
+        tmp_folder.rename(flang_folder)
+
+    @property
+    def bin_path(self):
+        return f"{self.get_fortran_dir()}/bin"
+
+    def get_host_platform(self, arch):
+        return {
+            "arm64-v8a": "aarch64-linux-android",
+            "armeabi-v7a": "armv7a-linux-androideabi",
+            "x86_64": "x86_64-linux-android",
+            "x86": "i686-linux-android",
+        }[arch]
+
+    def get_fortran_bin(self, arch):
+        return join(self.bin_path, f"{self.get_host_platform(arch)}-flang")
+
+    def get_fortran_flags(self, arch):
+        return f"--target={self.get_host_platform(arch)}{self.ctx.ndk_api} -D__ANDROID_API__={self.ctx.ndk_api}"
+
+
+recipe = GFortranRecipe()