pytron-kit 0.3.12__py3-none-win_amd64.whl

pytron/platforms/android/shell/app/src/main/cpp/include/warnings.h

@@ -0,0 +1,45 @@
+#ifndef Py_WARNINGS_H
+#define Py_WARNINGS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(int) PyErr_WarnEx(
+    PyObject *category,
+    const char *message,        /* UTF-8 encoded string */
+    Py_ssize_t stack_level);
+
+PyAPI_FUNC(int) PyErr_WarnFormat(
+    PyObject *category,
+    Py_ssize_t stack_level,
+    const char *format,         /* ASCII-encoded string  */
+    ...);
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
+/* Emit a ResourceWarning warning */
+PyAPI_FUNC(int) PyErr_ResourceWarning(
+    PyObject *source,
+    Py_ssize_t stack_level,
+    const char *format,         /* ASCII-encoded string  */
+    ...);
+#endif
+
+PyAPI_FUNC(int) PyErr_WarnExplicit(
+    PyObject *category,
+    const char *message,        /* UTF-8 encoded string */
+    const char *filename,       /* decoded from the filesystem encoding */
+    int lineno,
+    const char *module,         /* UTF-8 encoded string */
+    PyObject *registry);
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_WARNINGS_H
+#  include "cpython/warnings.h"
+#  undef Py_CPYTHON_WARNINGS_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_WARNINGS_H */
+

pytron/platforms/android/shell/app/src/main/cpp/include/weakrefobject.h

@@ -0,0 +1,46 @@
+/* Weak references objects for Python. */
+
+#ifndef Py_WEAKREFOBJECT_H
+#define Py_WEAKREFOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _PyWeakReference PyWeakReference;
+
+PyAPI_DATA(PyTypeObject) _PyWeakref_RefType;
+PyAPI_DATA(PyTypeObject) _PyWeakref_ProxyType;
+PyAPI_DATA(PyTypeObject) _PyWeakref_CallableProxyType;
+
+#define PyWeakref_CheckRef(op) PyObject_TypeCheck((op), &_PyWeakref_RefType)
+#define PyWeakref_CheckRefExact(op) \
+        Py_IS_TYPE((op), &_PyWeakref_RefType)
+#define PyWeakref_CheckProxy(op) \
+        (Py_IS_TYPE((op), &_PyWeakref_ProxyType) \
+         || Py_IS_TYPE((op), &_PyWeakref_CallableProxyType))
+
+#define PyWeakref_Check(op) \
+        (PyWeakref_CheckRef(op) || PyWeakref_CheckProxy(op))
+
+
+PyAPI_FUNC(PyObject *) PyWeakref_NewRef(PyObject *ob,
+                                        PyObject *callback);
+PyAPI_FUNC(PyObject *) PyWeakref_NewProxy(PyObject *ob,
+                                          PyObject *callback);
+Py_DEPRECATED(3.13) PyAPI_FUNC(PyObject *) PyWeakref_GetObject(PyObject *ref);
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030D0000
+PyAPI_FUNC(int) PyWeakref_GetRef(PyObject *ref, PyObject **pobj);
+#endif
+
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_WEAKREFOBJECT_H
+#  include "cpython/weakrefobject.h"
+#  undef Py_CPYTHON_WEAKREFOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_WEAKREFOBJECT_H */

pytron/platforms/android/shell/app/src/main/cpp/pytron_bridge.cpp

@@ -0,0 +1,224 @@
+#include <jni.h>
+#include <string>
+#include <android/log.h>
+#include <Python.h>
+#include <dlfcn.h>
+#include <vector>
+#include <unistd.h>
+#include <fcntl.h> // <--- REQUIRED for open/dup2
+
+#define LOG_TAG "PytronNative"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+static JavaVM* gJavaVM = nullptr;
+static jobject gMainActivity = nullptr;
+
+// Helper to send message to Java
+static PyObject* py_send_to_android(PyObject* self, PyObject* args) {
+    const char* message;
+    if (!PyArg_ParseTuple(args, "s", &message)) {
+        return NULL;
+    }
+
+    JNIEnv* env;
+    bool needsDetach = false;
+    int envStat = gJavaVM->GetEnv((void**)&env, JNI_VERSION_1_6);
+    if (envStat == JNI_EDETACHED) {
+        gJavaVM->AttachCurrentThread(&env, NULL);
+        needsDetach = true;
+    }
+
+    if (gMainActivity && env) {
+        jclass cls = env->GetObjectClass(gMainActivity);
+        jmethodID mid = env->GetMethodID(cls, "onMessageFromPython", "(Ljava/lang/String;)Ljava/lang/String;");
+        if (mid) {
+            jstring jStr = env->NewStringUTF(message);
+            jobject result = env->CallObjectMethod(gMainActivity, mid, jStr);
+            env->DeleteLocalRef(jStr);
+            if (env->ExceptionCheck()) {
+                env->ExceptionDescribe();
+                env->ExceptionClear();
+            }
+        }
+    }
+    if (needsDetach) gJavaVM->DetachCurrentThread();
+    Py_RETURN_NONE;
+}
+
+static PyMethodDef AndroidMethods[] = {
+    {"send_to_android", py_send_to_android, METH_VARARGS, "Send message to Android layer"},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef androidmodule = {
+    PyModuleDef_HEAD_INIT, "_pytron_android", NULL, -1, AndroidMethods
+};
+
+PyMODINIT_FUNC PyInit__pytron_android(void) {
+    return PyModule_Create(&androidmodule);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_pytron_shell_MainActivity_startPython(JNIEnv* env, jobject thiz, jstring homePath) {
+    if (gMainActivity) env->DeleteGlobalRef(gMainActivity);
+    gMainActivity = env->NewGlobalRef(thiz);
+
+    const char* path = env->GetStringUTFChars(homePath, 0);
+    LOGI("Starting Python configuration with home: %s", path);
+
+    // ==========================================================
+    // 1. FIX FILE DESCRIPTORS (THE CRITICAL FIX)
+    // Python crashes if fd 0, 1, 2 are closed/invalid. We point them to /dev/null.
+    // ==========================================================
+    int fd = open("/dev/null", O_RDWR);
+    if (fd != -1) {
+        dup2(fd, 0); // stdin
+        dup2(fd, 1); // stdout
+        dup2(fd, 2); // stderr
+        if (fd > 2) close(fd);
+    }
+    // ==========================================================
+
+    // 2. ENVIRONMENT SETUP
+    setenv("PYTHONHOME", path, 1);
+    setenv("PYTHONUNBUFFERED", "1", 1); // Disable buffering
+    setenv("PYTHON_PLATFORM","android",1);
+    std::string base = std::string(path);
+    std::string libPath = base + "/Lib";
+    std::string sitePath = base + "/site-packages";
+    std::string zipPath = base + "/python314.zip";
+
+    if (access(libPath.c_str(), F_OK) != -1) {
+        LOGI("Native: Found Lib folder at %s", libPath.c_str());
+    } else {
+        LOGI("Native: Lib folder not found, assuming zip or custom structure.");
+    }
+
+    // DLOPEN
+    // Use the specific version name to be safe
+    void* handle = dlopen("libpython3.14.so", RTLD_NOW | RTLD_GLOBAL);
+    if (!handle) LOGE("Could not dlopen libpython3.14.so: %s", dlerror());
+    else LOGI("Successfully loaded libpython3.14.so globally");
+
+    // --- CONFIGURATION ---
+    PyStatus status;
+    PyConfig config;
+    PyConfig_InitIsolatedConfig(&config);
+
+    // CRITICAL: Stop Python from trying to initialize C-level streams
+    config.configure_c_stdio = 0;
+    config.parse_argv = 0;
+    // Optional: Stop Python from stealing signal handlers (Good for Android)
+    config.install_signal_handlers = 0;
+
+    wchar_t *wpath = Py_DecodeLocale(path, NULL);
+    status = PyConfig_SetString(&config, &config.program_name, wpath);
+    status = PyConfig_SetString(&config, &config.home, wpath);
+
+    // MODULE SEARCH PATHS
+    config.module_search_paths_set = 1;
+
+    wchar_t *wBase = Py_DecodeLocale(base.c_str(), NULL);
+    wchar_t *wLib = Py_DecodeLocale(libPath.c_str(), NULL);
+    wchar_t *wSite = Py_DecodeLocale(sitePath.c_str(), NULL);
+    wchar_t *wZip = Py_DecodeLocale(zipPath.c_str(), NULL);
+
+    PyWideStringList_Append(&config.module_search_paths, wBase);
+    PyWideStringList_Append(&config.module_search_paths, wLib);
+
+    // Lib-dynload (Critical for .so extensions like _struct)
+    std::string dynPath = libPath + "/lib-dynload";
+    wchar_t *wDyn = Py_DecodeLocale(dynPath.c_str(), NULL);
+    PyWideStringList_Append(&config.module_search_paths, wDyn);
+
+    PyWideStringList_Append(&config.module_search_paths, wZip);
+    PyWideStringList_Append(&config.module_search_paths, wSite);
+
+    // Register embedded module
+    if (PyImport_AppendInittab("_pytron_android", PyInit__pytron_android) == -1) {
+        LOGE("Failed to add _pytron_android to builtins");
+    }
+
+    LOGI("Calling Py_InitializeFromConfig...");
+    status = Py_InitializeFromConfig(&config);
+
+    if (PyStatus_Exception(status)) {
+        LOGE("FATAL: Py_InitializeFromConfig failed.");
+        if (status.err_msg) LOGE("Python Config Error: %s", status.err_msg);
+        if (PyErr_Occurred()) PyErr_Print();
+    } else {
+        LOGI("Py_Initialize success!");
+
+        // Run Main
+        // We override sys.stdout/stderr here so print() goes to LogCat
+        std::string runCmd =
+            "import sys\n"
+            "class LogCatOut:\n"
+            "    def write(self, s):\n"
+            "        import _pytron_android, json\n"
+            "        if s.strip(): _pytron_android.send_to_android(json.dumps({'method': 'log', 'args': {'message': s.strip()}}))\n"
+            "    def flush(self): pass\n"
+            "sys.stdout = LogCatOut()\n"
+            "sys.stderr = LogCatOut()\n"
+            "try:\n"
+            "    print('Native: sys.path is ' + str(sys.path))\n"
+            "    import main\n"
+            "    if hasattr(main, 'main'): main.main()\n"
+            "except Exception as e:\n"
+            "    import traceback\n"
+            "    traceback.print_exc()\n"
+            "    err_msg = 'Python Crash: ' + str(e)\n"
+            "    import _pytron_android\n"
+            "    import json\n"
+            "    _pytron_android.send_to_android(json.dumps({'method': 'message_box', 'args': {'title': 'Crash', 'message': err_msg}}))\n";
+
+        PyRun_SimpleString(runCmd.c_str());
+    }
+
+    PyConfig_Clear(&config);
+    env->ReleaseStringUTFChars(homePath, path);
+    PyMem_Free(wpath);
+    PyMem_Free(wBase);
+    PyMem_Free(wLib);
+    PyMem_Free(wSite);
+    PyMem_Free(wZip);
+    PyMem_Free(wDyn);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_pytron_shell_MainActivity_sendToPython(JNIEnv* env, jobject thiz, jstring message) {
+    if (!Py_IsInitialized()) return;
+    PyGILState_STATE gstate = PyGILState_Ensure();
+    const char* msg = env->GetStringUTFChars(message, 0);
+    
+    // LOGI("Received message for Python: %s", msg);
+
+    // Call pytron.bindings.dispatch_android_message(msg)
+    PyObject* bindings = PyImport_ImportModule("pytron.bindings");
+    if (bindings) {
+        PyObject* func = PyObject_GetAttrString(bindings, "dispatch_android_message");
+        if (func && PyCallable_Check(func)) {
+            PyObject* args = PyTuple_Pack(1, PyUnicode_FromString(msg));
+            PyObject* result = PyObject_CallObject(func, args);
+            Py_XDECREF(result);
+            Py_DECREF(args);
+            Py_DECREF(func);
+        } else {
+             if (PyErr_Occurred()) PyErr_Print();
+             LOGE("Could not find dispatch_android_message in pytron.bindings");
+        }
+        Py_DECREF(bindings);
+    } else {
+         if (PyErr_Occurred()) PyErr_Print();
+         LOGE("Could not import pytron.bindings");
+    }
+
+    env->ReleaseStringUTFChars(message, msg);
+    PyGILState_Release(gstate);
+}
+
+extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
+    gJavaVM = vm;
+    return JNI_VERSION_1_6;
+}

pytron/platforms/android/shell/app/src/main/java/com/pytron/shell/MainActivity.kt

@@ -0,0 +1,208 @@
+package com.pytron.shell
+
+import android.app.Activity
+import android.os.Bundle
+import android.util.Log
+import android.webkit.WebSettings
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import org.json.JSONObject
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.io.IOException
+import java.util.zip.ZipEntry
+import java.util.zip.ZipInputStream
+
+class MainActivity : Activity() {
+
+    private lateinit var webView: WebView
+
+    companion object {
+        init {
+            // Load libffi first if it's separate, then your native lib
+            try { System.loadLibrary("ffi") } catch (e: UnsatisfiedLinkError) { Log.w("Pytron", "libffi not found (might be static)") }
+            System.loadLibrary("pytron-native")
+        }
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+            Log.e("Pytron", "FATAL JAVA CRASH: ${throwable.message}", throwable)
+        }
+
+        webView = WebView(this)
+        val settings = webView.settings
+        settings.javaScriptEnabled = true
+        settings.domStorageEnabled = true
+        settings.allowFileAccess = true
+        settings.allowFileAccessFromFileURLs = true
+        settings.allowUniversalAccessFromFileURLs = true
+
+        settings.allowUniversalAccessFromFileURLs = true
+
+        // Enable Remote Debugging (Inspect via chrome://inspect)
+        WebView.setWebContentsDebuggingEnabled(true)
+
+        // 2. INJECT THE BRIDGE OBJECT
+        // This allows JS to call window._pytron_bridge.postMessage("...")
+        webView.addJavascriptInterface(AndroidBridgeInterface(), "_pytron_bridge")
+
+        webView.webViewClient = object : WebViewClient() {
+            override fun onPageFinished(view: WebView?, url: String?) {
+                super.onPageFinished(view, url)
+                Log.d("Pytron", "WebView loaded: $url")
+                if (pendingScripts != null) {
+                    val script = pendingScripts
+                    // pendingScripts = null // Should we clear it? Usually yes, but depends if redirects happen.
+                    // For now, let's keep it until next nav call or just execute.
+                    view?.evaluateJavascript(script!!, null)
+                }
+            }
+        }
+
+        setContentView(webView)
+        webView.loadUrl("file:///android_asset/www/index.html")
+
+        // --- ASSET EXTRACTION LOGIC ---
+        val pythonHome = File(filesDir, "python")
+        
+        Thread {
+            try {
+                // 1. Copy Assets (main.py, Lib/, site-packages/)
+                Log.i("Pytron", "Checking/Copying python assets...")
+                copyAssetFolder("python", pythonHome.absolutePath)
+
+                Log.i("Pytron", "Starting Python Bridge...")
+                startPython(pythonHome.absolutePath)
+
+            } catch (e: Exception) {
+                Log.e("Pytron", "Failed to start Python: ${e.message}", e)
+            }
+        }.start()
+    }
+
+    // --- NEW INNER CLASS ---
+    inner class AndroidBridgeInterface {
+        @android.webkit.JavascriptInterface
+        fun postMessage(message: String) {
+            // Forward the message from JS to our C++ Native Bridge
+            // This eventually calls dispatch_android_message() in Python
+            sendToPython(message)
+        }
+    }
+
+    private fun copyAssetFolder(srcName: String, dstPath: String): Boolean {
+        try {
+            val fileList = assets.list(srcName) ?: return false
+            if (fileList.isEmpty()) return true
+
+            for (filename in fileList) {
+                var inPath = if (srcName.isEmpty()) filename else srcName + File.separator + filename
+                var outPath = dstPath + File.separator + filename
+
+                // Check if it's a directory by trying to list its children
+                // Note: assets.list returns empty array for both empty dir AND file.
+                // We assume if it has an extension it's a file, or try to open it.
+                var isDir = false
+                val subFiles = assets.list(inPath)
+                if (subFiles != null && subFiles.isNotEmpty()) {
+                    isDir = true
+                }
+
+                if (isDir) {
+                    File(outPath).mkdirs()
+                    copyAssetFolder(inPath, outPath)
+                } else {
+                    // It's a file. Copy it.
+                    copyAssetFile(inPath, outPath)
+                }
+            }
+            return true
+        } catch (e: Exception) {
+            Log.e("Pytron", "Asset Copy Failed for $srcName", e)
+            return false
+        }
+    }
+
+    private fun copyAssetFile(srcPath: String, dstPath: String) {
+        try {
+            val dstFile = File(dstPath)
+            
+            // OPTIMIZATION: Don't copy if it already exists and has size
+            // Note: For development, you might want to remove this check or add versioning
+            // so updates get applied.
+            // if (dstFile.exists() && dstFile.length() > 0) {
+            //      // Log.d("Pytron", "Skipping existing file: $dstPath")
+            //      return
+            // }
+
+            val inputStream = assets.open(srcPath)
+            val outStream = FileOutputStream(dstFile)
+            val buffer = ByteArray(64 * 1024) // 64KB buffer
+            var read: Int
+            while (inputStream.read(buffer).also { read = it } != -1) {
+                outStream.write(buffer, 0, read)
+            }
+            inputStream.close()
+            outStream.close()
+
+            if (srcPath.endsWith(".zip")) {
+                Log.i("Pytron", "SUCCESS: Copied $srcPath (Size: ${dstFile.length()})")
+            }
+        } catch (e: IOException) {
+            // If it fails to open as a file, it might have been an empty directory caught in the loop
+            // Log.w("Pytron", "Could not copy $srcPath (might be empty dir)")
+        }
+    }
+
+    external fun startPython(homePath: String)
+    external fun sendToPython(message: String)
+
+    private var pendingScripts: String? = null
+
+    fun onMessageFromPython(payload: String): String {
+        runOnUiThread {
+            try {
+                // Log.d("Pytron", "Received from Python: $payload")
+                val json = JSONObject(payload)
+                val method = json.optString("method")
+                val args = json.optJSONObject("args")
+
+                if (method == "log") {
+                    Log.i("PytronPython", args?.optString("message") ?: "")
+                }
+                else if (method == "message_box") {
+                    val title = args?.optString("title")
+                    val msg = args?.optString("message")
+                    android.app.AlertDialog.Builder(this)
+                        .setTitle(title)
+                        .setMessage(msg)
+                        .setPositiveButton("OK", null)
+                        .show()
+                }
+                else if (method == "navigate") {
+                    val url = args?.optString("url")
+                    val scripts = args?.optString("scripts")
+                    if (scripts != null) {
+                         pendingScripts = scripts
+                    }
+                    if (url != null) {
+                        webView.loadUrl(url)
+                    }
+                }
+                else if (method == "eval") {
+                    val code = args?.optString("code")
+                    if (code != null) {
+                        webView.evaluateJavascript(code, null)
+                    }
+                }
+            } catch (e: Exception) {
+                Log.e("Pytron", "Error processing message", e)
+            }
+        }
+        return "{}"
+    }
+}

pytron/platforms/android/shell/build.gradle

@@ -0,0 +1,11 @@
+
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+plugins {
+    id 'com.android.application' version '8.11.2' apply false
+    id 'com.android.library' version '8.11.2' apply false
+    id 'org.jetbrains.kotlin.android' version '1.9.20' apply false
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}

pytron/platforms/android/shell/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

pytron/platforms/android/shell/gradle.properties

@@ -0,0 +1,2 @@
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+android.useAndroidX=true

pytron/platforms/android/shell/gradlew.bat

@@ -0,0 +1,85 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%"=="0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

pytron/platforms/android/shell/settings.gradle

@@ -0,0 +1,16 @@
+pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+rootProject.name = "PytronShell"
+include ':app'