pythonnative 0.35.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/bridge/JsonUtil.kt

@@ -0,0 +1,175 @@
+package com.pythonnative.runtime.bridge
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Helpers for the JSON shapes the bridge exchanges with Python.
+ *
+ * Python normalizes values before encoding: `math.inf` arrives as the
+ * string `"inf"`, removed props arrive as JSON `null`, and tuples and
+ * frozensets arrive as arrays. These helpers hide those conventions.
+ */
+object JsonUtil {
+    /** Whether `value` is absent or an explicit JSON null. */
+    fun isNull(value: Any?): Boolean = value == null || value === JSONObject.NULL
+
+    /** Coerce a JSON value to a double; `"inf"` / `"-inf"` become infinities. */
+    fun toDoubleOrNull(value: Any?): Double? {
+        return when (value) {
+            null, JSONObject.NULL -> null
+            is Number -> value.toDouble()
+            is Boolean -> if (value) 1.0 else 0.0
+            is String -> {
+                val s = value.trim()
+                when (s.lowercase()) {
+                    "inf", "+inf", "infinity", "+infinity" -> Double.POSITIVE_INFINITY
+                    "-inf", "-infinity" -> Double.NEGATIVE_INFINITY
+                    "nan" -> Double.NaN
+                    else -> s.toDoubleOrNull()
+                }
+            }
+            else -> null
+        }
+    }
+
+    /** Coerce a JSON value to a double with `default` for missing or unparseable input. */
+    fun toDouble(value: Any?, default: Double = 0.0): Double = toDoubleOrNull(value) ?: default
+
+    /** Coerce a JSON value to an int (truncating), with `default` for bad input. */
+    fun toInt(value: Any?, default: Int = 0): Int {
+        val d = toDoubleOrNull(value) ?: return default
+        if (d.isNaN() || d.isInfinite()) return default
+        return d.toInt()
+    }
+
+    /** Coerce a JSON value to a long (truncating), with `default` for bad input. */
+    fun toLong(value: Any?, default: Long = 0L): Long {
+        return when (value) {
+            is Number -> value.toLong()
+            else -> {
+                val d = toDoubleOrNull(value) ?: return default
+                if (d.isNaN() || d.isInfinite()) default else d.toLong()
+            }
+        }
+    }
+
+    /** Python-style truthiness for JSON values. */
+    fun truthy(value: Any?): Boolean {
+        return when (value) {
+            null, JSONObject.NULL -> false
+            is Boolean -> value
+            is Number -> value.toDouble() != 0.0
+            is String -> value.isNotEmpty()
+            is JSONArray -> value.length() > 0
+            is JSONObject -> value.length() > 0
+            else -> true
+        }
+    }
+
+    /** `value` as a string, or `null` when absent or JSON null. */
+    fun stringOrNull(value: Any?): String? = if (isNull(value)) null else value.toString()
+
+    /** Copy `changed` into `target`, keeping explicit nulls as [JSONObject.NULL]. */
+    fun merge(target: JSONObject, changed: JSONObject) {
+        val keys = changed.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            target.put(key, changed.opt(key) ?: JSONObject.NULL)
+        }
+    }
+
+    /** Convert a [JSONArray] to a Kotlin list (JSON nulls become `null`). */
+    fun toList(array: JSONArray?): List<Any?> {
+        if (array == null) return emptyList()
+        val out = ArrayList<Any?>(array.length())
+        for (i in 0 until array.length()) {
+            val v = array.opt(i)
+            out.add(if (v === JSONObject.NULL) null else v)
+        }
+        return out
+    }
+
+    /** Convert a [JSONObject] to a Kotlin map (JSON nulls become `null`). */
+    fun toMap(obj: JSONObject?): Map<String, Any?> {
+        if (obj == null) return emptyMap()
+        val out = LinkedHashMap<String, Any?>()
+        val keys = obj.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            val v = obj.opt(key)
+            out[key] = if (v === JSONObject.NULL) null else v
+        }
+        return out
+    }
+
+    /** Wrap a Kotlin value into something `org.json` can hold (maps, lists, nulls). */
+    fun wrap(value: Any?): Any {
+        return when (value) {
+            null -> JSONObject.NULL
+            is JSONObject, is JSONArray, is String, is Boolean -> value
+            is Float -> if (value.isFinite()) value.toDouble() else JSONObject.NULL
+            is Double -> if (value.isFinite()) value else JSONObject.NULL
+            is Number -> value
+            is Map<*, *> -> {
+                val obj = JSONObject()
+                for ((k, v) in value) obj.put(k.toString(), wrap(v))
+                obj
+            }
+            is Iterable<*> -> {
+                val arr = JSONArray()
+                for (v in value) arr.put(wrap(v))
+                arr
+            }
+            is Array<*> -> wrap(value.asList())
+            is DoubleArray -> wrap(value.asList())
+            is FloatArray -> wrap(value.asList())
+            is IntArray -> wrap(value.asList())
+            else -> value.toString()
+        }
+    }
+
+    /** Build a JSON array of positional arguments. */
+    fun args(vararg values: Any?): JSONArray {
+        val arr = JSONArray()
+        for (v in values) arr.put(wrap(v))
+        return arr
+    }
+
+    /** Encode a command or module result as a JSON string; `null` stays `null`. */
+    fun encode(value: Any?): String? {
+        if (value == null || value === JSONObject.NULL) return null
+        return when (val wrapped = wrap(value)) {
+            is JSONObject, is JSONArray -> wrapped.toString()
+            is String -> JSONObject.quote(wrapped)
+            else -> wrapped.toString()
+        }
+    }
+}
+
+/** The value under `key`, or `null` for missing keys and JSON nulls. */
+fun JSONObject.value(key: String): Any? {
+    val v = opt(key) ?: return null
+    return if (v === JSONObject.NULL) null else v
+}
+
+/** String prop or `null`. */
+fun JSONObject.str(key: String): String? = JsonUtil.stringOrNull(opt(key))
+
+/** Numeric prop (accepting `"inf"`) or `null`. */
+fun JSONObject.num(key: String): Double? = JsonUtil.toDoubleOrNull(opt(key))
+
+/** Boolean prop using Python truthiness, or `null` when absent. */
+fun JSONObject.bool(key: String): Boolean? {
+    val v = value(key) ?: return null
+    return JsonUtil.truthy(v)
+}
+
+/** Object prop or `null`. */
+fun JSONObject.obj(key: String): JSONObject? = value(key) as? JSONObject
+
+/** Array prop or `null`. */
+fun JSONObject.arr(key: String): JSONArray? = value(key) as? JSONArray
+
+/** Whether the prop is present with a non-null value. */
+fun JSONObject.present(key: String): Boolean = value(key) != null

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/bridge/MainThread.kt

@@ -0,0 +1,32 @@
+package com.pythonnative.runtime.bridge
+
+import android.os.Handler
+import android.os.Looper
+
+/** Main-looper helpers shared by the bridge, modules, and managers. */
+object MainThread {
+    private val handler: Handler by lazy { Handler(Looper.getMainLooper()) }
+
+    /** Whether the current thread is the main thread. */
+    fun isMain(): Boolean = Looper.myLooper() == Looper.getMainLooper()
+
+    /** Post `runnable` to the main looper. */
+    fun post(runnable: Runnable) {
+        handler.post(runnable)
+    }
+
+    /** Post `runnable` to the main looper after `delayMs`. */
+    fun postDelayed(runnable: Runnable, delayMs: Long) {
+        handler.postDelayed(runnable, delayMs)
+    }
+
+    /** Remove a pending `runnable`. */
+    fun remove(runnable: Runnable) {
+        handler.removeCallbacks(runnable)
+    }
+
+    /** Run `runnable` inline when already on the main thread, otherwise post it. */
+    fun runOnMain(runnable: Runnable) {
+        if (isMain()) runnable.run() else post(runnable)
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/bridge/PNLog.kt

@@ -0,0 +1,33 @@
+package com.pythonnative.runtime.bridge
+
+import android.util.Log
+
+/** Rate-limited logging so a hot failing op cannot flood logcat. */
+object PNLog {
+    const val TAG = "PythonNative"
+
+    private const val BURST = 5
+    private const val EVERY = 100
+    private val counts = HashMap<String, Int>()
+    private val once = HashSet<String>()
+
+    /** Log `message` for `key`, letting the first few through and then every 100th. */
+    fun rateLimited(key: String, message: String, error: Throwable? = null) {
+        val n = (counts[key] ?: 0) + 1
+        counts[key] = n
+        if (n <= BURST || n % EVERY == 0) {
+            val suffix = if (n > BURST) " (x$n)" else ""
+            if (error != null) Log.e(TAG, message + suffix, error) else Log.e(TAG, message + suffix)
+        }
+    }
+
+    /** Log `message` at most once per `key`. */
+    fun once(key: String, message: String) {
+        if (once.add(key)) Log.w(TAG, message)
+    }
+
+    /** Log a swallowed exception at debug level. */
+    fun swallowed(where: String, error: Throwable) {
+        Log.d(TAG, "$where: ${error.javaClass.simpleName}: ${error.message}")
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/bridge/PNRegistry.kt

@@ -0,0 +1,82 @@
+package com.pythonnative.runtime.bridge
+
+import android.util.Log
+import com.pythonnative.runtime.components.BuiltinComponents
+import com.pythonnative.runtime.components.ComponentManager
+import com.pythonnative.runtime.modules.BuiltinModules
+import com.pythonnative.runtime.modules.NativeModule
+import com.pythonnative.runtime.plugins.GeneratedPlugins
+
+/**
+ * A native extension: registers component managers and native modules.
+ *
+ * `pn build` generates a call to each plugin entry's `register` in
+ * `plugins/GeneratedPlugins.kt`.
+ */
+interface PNPlugin {
+    fun register(registry: PNRegistry)
+}
+
+/**
+ * Registry of component managers (by element type) and native modules
+ * (by module name). Built-ins are registered on first use, followed by
+ * the generated plugin registrations.
+ */
+object PNRegistry {
+    private val componentFactories = HashMap<String, () -> ComponentManager>()
+    private val managers = HashMap<String, ComponentManager>()
+    private val moduleFactories = HashMap<String, () -> NativeModule>()
+    private val modules = HashMap<String, NativeModule>()
+    private var builtinsRegistered = false
+
+    /** Register (or override) the manager factory for element type `name`. */
+    fun registerComponent(name: String, factory: () -> ComponentManager) {
+        componentFactories[name] = factory
+        managers.remove(name)
+    }
+
+    /**
+     * Register a native module. The factory is invoked once to read the
+     * module's `name`; the same instance then serves every call.
+     */
+    fun registerModule(factory: () -> NativeModule) {
+        val module = factory()
+        moduleFactories[module.name] = factory
+        modules[module.name] = module
+    }
+
+    /** The manager for element type `name`, or `null` when unknown. */
+    fun managerFor(name: String): ComponentManager? {
+        ensureBuiltins()
+        managers[name]?.let { return it }
+        val factory = componentFactories[name] ?: return null
+        val manager = factory()
+        managers[name] = manager
+        return manager
+    }
+
+    /** The module named `name`, or `null`. */
+    fun module(name: String): NativeModule? {
+        ensureBuiltins()
+        return modules[name]
+    }
+
+    /** Registered element type names. */
+    fun componentNames(): Set<String> {
+        ensureBuiltins()
+        return componentFactories.keys
+    }
+
+    /** Register built-in components and modules plus generated plugins (idempotent). */
+    fun ensureBuiltins() {
+        if (builtinsRegistered) return
+        builtinsRegistered = true
+        BuiltinComponents.register(this)
+        BuiltinModules.register(this)
+        try {
+            GeneratedPlugins.registerAll(this)
+        } catch (e: Exception) {
+            Log.e(PNLog.TAG, "plugin registration failed", e)
+        }
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/bridge/PNTransaction.kt

@@ -0,0 +1,80 @@
+package com.pythonnative.runtime.bridge
+
+import org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
+
+/** One decoded mutation op. Geometry is in dp (points). */
+sealed class Op {
+    /** `["c", tag, "Type", {props}]` */
+    data class Create(val tag: Long, val typeName: String, val props: JSONObject) : Op()
+
+    /** `["u", tag, {changed}]` (a `null` value means the prop was removed) */
+    data class Update(val tag: Long, val changed: JSONObject) : Op()
+
+    /** `["i", parent, child, index]` (move-aware) */
+    data class Insert(val parent: Long, val child: Long, val index: Int) : Op()
+
+    /** `["d", tag]` */
+    data class Destroy(val tag: Long) : Op()
+
+    /** `["f", tag, x, y, w, h]` relative to the parent's content origin */
+    data class Frame(val tag: Long, val x: Double, val y: Double, val width: Double, val height: Double) : Op()
+}
+
+/**
+ * Decoder for the transaction wire format: a JSON array of ops, each an
+ * array whose first element is a one-letter opcode.
+ *
+ * Decoding is isolated per op: a malformed entry is reported through
+ * `onError` and skipped so the rest of the commit still applies.
+ */
+object PNTransaction {
+    /** Decode `json`; invalid ops are skipped after `onError(index, error)`. */
+    fun decode(json: String, onError: (Int, Throwable) -> Unit = { _, _ -> }): List<Op> {
+        val array = JSONArray(json)
+        val ops = ArrayList<Op>(array.length())
+        for (i in 0 until array.length()) {
+            try {
+                val raw = array.get(i) as? JSONArray
+                    ?: throw JSONException("op $i is not an array")
+                ops.add(decodeOp(raw))
+            } catch (e: Exception) {
+                onError(i, e)
+            }
+        }
+        return ops
+    }
+
+    /** Decode a single op array. */
+    fun decodeOp(raw: JSONArray): Op {
+        val code = raw.optString(0, "")
+        return when (code) {
+            "c" -> Op.Create(
+                tag(raw, 1),
+                raw.optString(2, ""),
+                raw.optJSONObject(3) ?: JSONObject(),
+            )
+            "u" -> Op.Update(tag(raw, 1), raw.optJSONObject(2) ?: JSONObject())
+            "i" -> Op.Insert(tag(raw, 1), tag(raw, 2), JsonUtil.toInt(raw.opt(3), 0))
+            "d" -> Op.Destroy(tag(raw, 1))
+            "f" -> Op.Frame(
+                tag(raw, 1),
+                JsonUtil.toDouble(raw.opt(2)),
+                JsonUtil.toDouble(raw.opt(3)),
+                JsonUtil.toDouble(raw.opt(4)),
+                JsonUtil.toDouble(raw.opt(5)),
+            )
+            else -> throw JSONException("unknown opcode '$code'")
+        }
+    }
+
+    private fun tag(raw: JSONArray, index: Int): Long {
+        val v = raw.opt(index) ?: throw JSONException("missing tag at $index")
+        return when (v) {
+            is Number -> v.toLong()
+            is String -> v.toLongOrNull() ?: throw JSONException("bad tag '$v'")
+            else -> throw JSONException("bad tag $v")
+        }
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/bridge/TransactionApplier.kt

@@ -0,0 +1,115 @@
+package com.pythonnative.runtime.bridge
+
+import android.view.View
+import com.pythonnative.runtime.PNBridge
+import com.pythonnative.runtime.components.ComponentManager
+import com.pythonnative.runtime.components.PlaceholderManager
+import com.pythonnative.runtime.gestures.GestureCoordinator
+import org.json.JSONObject
+
+/**
+ * Applies decoded transactions to the view tree, in order, with per-op
+ * error isolation. Unknown element types create a placeholder view and
+ * log once.
+ */
+class TransactionApplier(private val registry: ViewRegistry) {
+    private val placeholder = PlaceholderManager()
+
+    /** Decode and apply `transactionJson`. */
+    fun apply(transactionJson: String) {
+        val ops = try {
+            PNTransaction.decode(transactionJson) { index, error ->
+                PNLog.rateLimited("decode", "transaction op $index could not be decoded", error)
+            }
+        } catch (e: Exception) {
+            PNLog.rateLimited("decode-top", "transaction is not a JSON array", e)
+            return
+        }
+        for (op in ops) {
+            try {
+                applyOp(op)
+            } catch (e: Exception) {
+                PNLog.rateLimited("op:" + op.javaClass.simpleName, "failed to apply $op", e)
+            }
+        }
+    }
+
+    /** Apply a single op. */
+    fun applyOp(op: Op) {
+        when (op) {
+            is Op.Create -> create(op)
+            is Op.Update -> update(op)
+            is Op.Insert -> insert(op)
+            is Op.Destroy -> destroy(op)
+            is Op.Frame -> frame(op)
+        }
+    }
+
+    private fun create(op: Op.Create) {
+        registry.get(op.tag)?.let {
+            PNLog.rateLimited("dup-create", "tag ${op.tag} already exists (${it.typeName}); replacing")
+            destroyRecord(it)
+        }
+        val manager = PNRegistry.managerFor(op.typeName) ?: run {
+            PNLog.once("unknown-type:" + op.typeName, "unknown element type '${op.typeName}'; using a placeholder view")
+            placeholder
+        }
+        val view = manager.createView(PNBridge.context(), op.tag, op.props)
+        val record = ViewRecord(op.tag, op.typeName, view, manager)
+        JsonUtil.merge(record.props, op.props)
+        registry.register(record)
+        try {
+            manager.applyProps(view, op.props, true)
+        } finally {
+            record.initialized = true
+        }
+        if (op.props.has("gestures")) {
+            GestureCoordinator.bind(record, op.props.opt("gestures"))
+        }
+    }
+
+    private fun update(op: Op.Update) {
+        val record = registry.get(op.tag) ?: throw IllegalStateException("update: unknown tag ${op.tag}")
+        JsonUtil.merge(record.props, op.changed)
+        record.manager.update(record.view, op.changed)
+        if (op.changed.has("gestures")) {
+            GestureCoordinator.bind(record, op.changed.opt("gestures"))
+        }
+    }
+
+    private fun insert(op: Op.Insert) {
+        val parent = registry.get(op.parent) ?: throw IllegalStateException("insert: unknown parent ${op.parent}")
+        val child = registry.get(op.child) ?: throw IllegalStateException("insert: unknown child ${op.child}")
+        parent.manager.insertChild(parent.view, child.view, op.index)
+    }
+
+    private fun destroy(op: Op.Destroy) {
+        val record = registry.get(op.tag) ?: return
+        destroyRecord(record)
+    }
+
+    private fun destroyRecord(record: ViewRecord) {
+        GestureCoordinator.unbind(record)
+        try {
+            val parentRecord = (record.view.parent as? View)?.let { registry.recordFor(it) }
+            if (parentRecord != null) {
+                parentRecord.manager.removeChild(parentRecord.view, record.view)
+            }
+            record.manager.destroy(record.view)
+        } finally {
+            registry.unregister(record.tag)
+        }
+    }
+
+    private fun frame(op: Op.Frame) {
+        val record = registry.get(op.tag) ?: throw IllegalStateException("frame: unknown tag ${op.tag}")
+        record.frame = doubleArrayOf(op.x, op.y, op.width, op.height)
+        record.manager.setFrame(record.view, op.x, op.y, op.width, op.height)
+    }
+
+    /** Whether `manager` is the fallback placeholder manager. */
+    fun isPlaceholder(manager: ComponentManager): Boolean = manager === placeholder
+
+    /** The props recorded for `tag`, mainly for diagnostics. */
+    fun propsOf(tag: Long): JSONObject? = registry.get(tag)?.props
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/bridge/ViewRegistry.kt

@@ -0,0 +1,74 @@
+package com.pythonnative.runtime.bridge
+
+import android.view.View
+import com.pythonnative.runtime.components.ComponentManager
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.IdentityHashMap
+
+/**
+ * Per-view bookkeeping: the reconciler tag, the element type, the
+ * manager that owns it, the merged props, and free-form manager state.
+ */
+class ViewRecord(
+    val tag: Long,
+    val typeName: String,
+    val view: View,
+    val manager: ComponentManager,
+) {
+    /** Every prop applied so far (removed props stay as JSON null). */
+    val props = JSONObject()
+
+    /** Manager-private state (suppress flags, wrapped widgets, etc.). */
+    val state = HashMap<String, Any?>()
+
+    /** Last frame applied by `setFrame`, in dp (`x, y, w, h`). */
+    var frame: DoubleArray? = null
+
+    /** Whether the initial props have been applied. */
+    var initialized = false
+
+    /** Whether the element wired a callback named `name` this render. */
+    fun hasEvent(name: String): Boolean {
+        val events = props.opt("_pn_events") as? JSONArray ?: return false
+        for (i in 0 until events.length()) {
+            if (events.optString(i) == name) return true
+        }
+        return false
+    }
+}
+
+/** Tag to [ViewRecord] map with a reverse index by view identity. */
+class ViewRegistry {
+    private val byTag = HashMap<Long, ViewRecord>()
+    private val byView = IdentityHashMap<View, ViewRecord>()
+
+    /** Number of live records. */
+    val size: Int get() = byTag.size
+
+    /** Register `record`; replaces any earlier record with the same tag. */
+    fun register(record: ViewRecord) {
+        byTag.remove(record.tag)?.let { byView.remove(it.view) }
+        byTag[record.tag] = record
+        byView[record.view] = record
+    }
+
+    /** Remove and return the record for `tag`. */
+    fun unregister(tag: Long): ViewRecord? {
+        val record = byTag.remove(tag) ?: return null
+        byView.remove(record.view)
+        return record
+    }
+
+    /** The record for `tag`, or `null`. */
+    fun get(tag: Long): ViewRecord? = byTag[tag]
+
+    /** The record whose view is `view`, or `null`. */
+    fun recordFor(view: View): ViewRecord? = byView[view]
+
+    /** The tag of `view`, or `null` when it is not a PythonNative view. */
+    fun tagOf(view: View): Long? = byView[view]?.tag
+
+    /** Snapshot of all records. */
+    fun all(): List<ViewRecord> = ArrayList(byTag.values)
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/components/BuiltinComponents.kt

@@ -0,0 +1,35 @@
+package com.pythonnative.runtime.components
+
+import com.pythonnative.runtime.bridge.PNRegistry
+
+/** Registers the built-in element types with the registry. */
+object BuiltinComponents {
+    fun register(registry: PNRegistry) {
+        registry.registerComponent("View") { ViewManager() }
+        registry.registerComponent("Column") { ViewManager() }
+        registry.registerComponent("Row") { ViewManager() }
+        registry.registerComponent("Text") { TextManager() }
+        registry.registerComponent("Button") { ButtonManager() }
+        registry.registerComponent("TextInput") { TextInputManager() }
+        registry.registerComponent("Image") { ImageManager() }
+        registry.registerComponent("Switch") { SwitchManager() }
+        registry.registerComponent("Checkbox") { CheckboxManager() }
+        registry.registerComponent("ProgressBar") { ProgressBarManager() }
+        registry.registerComponent("ActivityIndicator") { ActivityIndicatorManager() }
+        registry.registerComponent("Slider") { SliderManager() }
+        registry.registerComponent("WebView") { WebViewManager() }
+        registry.registerComponent("Spacer") { SpacerManager() }
+        registry.registerComponent("ScrollView") { ScrollViewManager() }
+        registry.registerComponent("SafeAreaView") { SafeAreaViewManager() }
+        registry.registerComponent("KeyboardAvoidingView") { KeyboardAvoidingViewManager() }
+        registry.registerComponent("Modal") { ModalManager() }
+        registry.registerComponent("Portal") { PortalManager() }
+        registry.registerComponent("TabBar") { TabBarManager() }
+        registry.registerComponent("Pressable") { PressableManager() }
+        registry.registerComponent("StatusBar") { StatusBarManager() }
+        registry.registerComponent("Picker") { PickerManager() }
+        registry.registerComponent("SegmentedControl") { SegmentedControlManager() }
+        registry.registerComponent("DatePicker") { DatePickerManager() }
+        registry.registerComponent("VirtualList") { VirtualListManager() }
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/components/ButtonManager.kt

@@ -0,0 +1,33 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.view.View
+import android.widget.Button
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.num
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONObject
+
+/** `Button` element: a platform `Button` firing `on_press`. */
+class ButtonManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val button = Button(context)
+        button.setOnClickListener { fire(it, "on_press") }
+        return button
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val button = view as Button
+        if (props.has("title")) button.text = props.str("title") ?: ""
+        props.num("font_size")?.let { button.textSize = it.toFloat() }
+        PNColor.parse(props.value("color"))?.let { button.setTextColor(it) }
+        if (props.has("enabled")) button.isEnabled = JsonUtil.truthy(props.value("enabled"))
+        if (props.has("disabled")) button.isEnabled = !JsonUtil.truthy(props.value("disabled"))
+        if (props.has("all_caps")) button.isAllCaps = JsonUtil.truthy(props.value("all_caps"))
+        if (listOf("font_family", "font_weight", "italic", "bold").any { props.has(it) }) {
+            TextStyle.applyTypeface(button, propsOf(button))
+        }
+        ViewStyler.apply(button, props)
+    }
+}