Chaquopy: Utilizing Python in Android Apps | by Shubham Panchal | March 2023

Use Python scripts and packages to improve Android apps

Python is likely one of the hottest languages ​​within the developer group because of its simplicity, robustness, and enormous bundle ecosystem that make it extraordinarily helpful throughout many domains. The usage of packages like NumPy and SciPy permits programmers to carry out high-level math operations that different programming languages ​​can not simply do. What about bringing the ability of Python to Android apps?

Chaquopy is a framework that may assist builders run Python scripts from Java/Kotlin code in Android apps. In contrast to different multilingual libraries, there aren’t any NDK or native code problems and set up is simple. On this story, we are going to discover Chaquopy, its structure, and find out how to use Kotlin code.

Like most working multilingual interfaces, Python and Android share a typical ancestor, C/C++, which in all probability permits them to speak over a typical medium. The Android NDK permits builders to make use of native libraries (written in C/C++) in an Android utility, which is nice for high-performance graphics and scientific computing.

Chaquopy makes use of CPython, an implementation of Python written within the C language. Opposite to in style false impression, Python is just not a purely interpreted language. Python’s supply code is first compiled right into a particular bytecode, which is then interpreted by CPython. CPython is only one of a number of implementations of Python, others embrace PyPy, IronPython, Jython, and so forth.

The Chaquopy group builds CPython with the Android NDK toolchain. CPython is downloaded from the Maven Central repository utilizing Chaquopy’s Gradle plugin whereas constructing the undertaking, and the person doesn’t have to obtain the NDK for this course of. It additionally downloads the Chaquopy runtime which interfaces Java/Kotlin code to Python through JNI.

In the meantime, we’ll additionally want Python’s bundle supervisor pip interpreter packages could be downloaded. Fashionable packages like NumPy And SciPy makes use of native code to carry out CPU-intensive calculations, which have to be constructed earlier than set up. So the Chaquopy group maintains their very own repositories with native packages constructed particularly for Android’s ARM structure. The maintainers of those packages do not construct their native code for goal Android, as a result of smaller variety of customers, so Chaquopy group builds them for goal Android and distributes them through their very own repositories .

For pure Python packages, no exterior construct is required, and Chaquopy’s interpreter can run them immediately. For a high-level overview, Chaquopy accommodates three primary parts:

1. Chaquopy class plugin
2. Chaquopy Runtime
3. Bundle archive

1.1. Class dependencies and ABI . specs

So as to add Chaquopy to your new/present Android undertaking, go to undertaking degree construct.gradle script, the place we outline Gradle plugins for the undertaking and add Chaquopy’s Gradle plugin,

plugins {
id 'com.android.utility' model '7.3.0' apply false
id 'com.android.library' model '7.3.0' apply false
id 'org.jetbrains.kotlin.android' model '1.7.21' apply false
id 'com.chaquo.python' model '13.0.0' apply false 
}

Subsequent, on the module degree construct.gradle we are going to embrace Chaquopy plugin and likewise specify ABI filters,

plugins {
id 'com.android.utility'
id 'org.jetbrains.kotlin.android'
id 'com.chaquo.python'
}
android {
...
defaultConfig {
...
ndk {
abiFilters "armeabi-v7a" //, "arm64-v8a", "x86", "x86_64"
}
}
...
}

As talked about within the official docs, the Python interpreter is a local part constructed utilizing the Android NDK. NDK builds native code for a particular structure, like arm , x86 or x86_64 . Totally different gadgets assist totally different architectures, so we are able to simply embrace that individual Python interpreter construct, as an alternative of constructing for all architectures which will increase the dimensions utility. The official Android documentation communicate,

The default conduct of the construct system is to incorporate binaries for every ABI in an APK, often known as Fats APK. Fats APKs are considerably bigger than APKs containing solely binaries for a single ABI; The trade-off is attaining broader compatibility, on the expense of a bigger APK. We strongly advocate making the most of both Software pack or Cut up APK to cut back your APK dimension whereas sustaining most machine compatibility.

1.2. Python model and packages PIP

Subsequent, we are going to configure the Python model to construct. We will specify this by modifying the module degree construct.gradle ,

plugins {
id 'com.android.utility'
id 'org.jetbrains.kotlin.android'
id 'com.chaquo.python'
}
android {
...
defaultConfig {
...
ndk {
abiFilters "armeabi-v7a" //, "arm64-v8a", "x86", "x86_64"
}
python {
model "3.8"
}
}
...
}

Totally different variations of Chaquopy assist totally different variations of Python which have totally different minimal API degree necessities. Use this desk to search out the model that matches your necessities. Subsequent, we specify the packages to be put in within the Python interpreter.

defaultConfig {
python {
pip {
// A requirement specifier, with or with out a model quantity:
set up "scipy"
set up "requests==2.24.0"
// An sdist or wheel filename, relative to the undertaking listing:
set up "MyPackage-1.2.3-py2.py3-none-any.whl"


// A listing containing a setup.py, relative to the undertaking
// listing (should include a minimum of one slash):
set up "./MyPackage"


// "-r"` adopted by a necessities filename, relative to the
// undertaking listing:
set up "-r", "necessities.txt"
}
}
}

There are alternative ways to put in packages in Chaquopy; it may be a bundle title with a particular model, a customized bundle or necessities.txt bundle listing.

In Python, we use capabilities or information members that belong to a Python module as a .py file containing the supply code. To make use of any member from a Python module, step one is to place the Python supply code in /app/src/primary/python class.

# Contents of my_module.py
import numpy as np


def get_exec_details():
return __file__


def sumOp( nums ):
return sum( nums )


def powOp( a , x ):
return a**x


def npMatrixSum( m , n ):
mat = np.ones( ( m , n ) )
mat_sum = np.sum( mat , axis=1 )
return mat_sum


class Operations:


num_ops = 2


def meanOp( self , nums ):
return sum( nums ) / len( nums )


def maxOp( self , nums ):
return max( nums )


nums_len = 10
nums_len_str = "ten"
ops = Operations()

To make use of members from my_module we use Python.getModule technique to move the title of the module. Earlier than that, we have to activate Python fort utility, could be carried out in onCreate technique of Software ,

class App : Software() {
override enjoyable onCreate() {
tremendous.onCreate()
if( !Python.isStarted() ) {
Python.begin( AndroidPlatform( this ) )
}
}


}

Extra App ARRIVE AndroidManifest.xml ,

xmlns:instruments="http://schemas.android.com/instruments">
android:title=".App"
...

After which in MainActivity we’re allowed Python.getInstance (in any other case we are going to obtain a PyException ),

val py = Python.getInstance()
val module = py.getModule( "my_module" )

2.1. Accessing variables (information members)

To make use of a knowledge member, like nums_len IN my_module.py ,

val numsLength = module[ "nums_len" ]?.toInt()
println( "Nums Size is $numsLength" )

Nums Size is 10

To entry an object’s properties ops Of sophistication Operations ,

val ops = module[ "ops" ]!!
println( "Operations: $ops" )
println( "num_ops : ${ ops[ "num_ops" ] }" )
println( "imply func : ${ ops[ "meanOp" ] }" )

Operations: 
num_ops : 2
imply func : >

2.2. Name operate

Since a operate is an object in Python, accessing capabilities as values ​​of module be allowed. Then we use PyObject.name technique that passes arguments to a operate and will get the end result (if the operate returns a price)

val sumFunc = module[ "sumOp" ]
val sum = sumFunc?.name( intArrayOf( 12 , 25 , 32 ) )
val powFun = module[ "powOp" ]
val pow = powFun?.name( 5 , 2 )
println( "Sum: $sum" )
println( "Pow: $pow" )

Sum: 69
Pow: 25

To entry member capabilities from ops Factor,

val meanFunc = ops[ "meanOp" ]
val imply = meanFunc?.name( intArrayOf( 23 , 45 , 12 , 91 ) )
println( "Imply: $imply" )
// OR


val imply = ops.callAttr( "meanOp" , intArrayOf( 23 , 45 , 12 , 91 ) )
println( "Imply: $imply" )

Imply: 42.75

This is an instance the place a Python operate makes use of numpy and returns a results of sort np.ndarray

# my_module.py
import numpy as np
def npMatrixSum( m , n ):
mat = np.ones( ( m , n ) )
mat_sum = np.sum( mat , axis=1 )
return mat_sum

val npSumFunc = module[ "npMatrixSum" ]
val output = npSumFunc?.name( 2 , 3 )
// OR


val output = module.callAttr( "npMatrixSum" , 2 , 3 )


println( "Output: $output" )
println( "Output form: ${output!![ "shape" ] }")

Output: [3. 3.]
Output form: (2,)

Hope I’ve added a brand new instrument to your Android improvement toolbox! Chaquopy is a good instrument with a clear syntax and hassle-free set up. Be sure to use in your subsequent Android undertaking. Continue to learn and have a pleasant day forward!