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/PNBridge.kt

@@ -0,0 +1,214 @@
+package com.pythonnative.runtime
+
+import android.app.Activity
+import android.content.Context
+import android.util.Log
+import com.pythonnative.runtime.animation.PNAnimator
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.MainThread
+import com.pythonnative.runtime.bridge.PNRegistry
+import com.pythonnative.runtime.bridge.TransactionApplier
+import com.pythonnative.runtime.bridge.ViewRegistry
+import com.pythonnative.runtime.modules.BuiltinModules
+import com.pythonnative.runtime.modules.ModuleEnvelope
+import com.pythonnative.runtime.modules.Promise
+import org.json.JSONObject
+import java.util.Locale
+
+/**
+ * The single Java class Python touches.
+ *
+ * Every entry point mirrors one C symbol of the iOS bridge and is
+ * expected to run on the main thread (Python's asyncio loop lives
+ * there). Calls from other threads are logged but still executed so a
+ * misbehaving caller fails loudly in logcat instead of silently.
+ */
+object PNBridge {
+    /** Logcat tag used by the whole runtime. */
+    const val TAG = "PythonNative"
+
+    /** Protocol version compiled into this library. */
+    const val PROTOCOL_VERSION = 1
+
+    private var host: PythonHost? = null
+    private var activity: Activity? = null
+    private val hostReadyListeners = ArrayList<Runnable>()
+
+    /** Tag to view bookkeeping shared by the applier and managers. */
+    val registry = ViewRegistry()
+
+    private val applier by lazy { TransactionApplier(registry) }
+
+    /** The protocol version Python must match before starting. */
+    @JvmStatic
+    fun protocolVersion(): Int = PROTOCOL_VERSION
+
+    /** Install the Python callback target; flushes callbacks queued before it existed. */
+    @JvmStatic
+    fun setHost(host: PythonHost) {
+        this.host = host
+        val pending = ArrayList(hostReadyListeners)
+        hostReadyListeners.clear()
+        for (listener in pending) {
+            try {
+                listener.run()
+            } catch (e: Exception) {
+                Log.e(TAG, "host-ready listener failed", e)
+            }
+        }
+    }
+
+    /** Whether a [PythonHost] has been installed. */
+    fun hasHost(): Boolean = host != null
+
+    /** Run `runnable` now if a host is installed, otherwise once [setHost] is called. */
+    fun runWhenHostReady(runnable: Runnable) {
+        if (host != null) runnable.run() else hostReadyListeners.add(runnable)
+    }
+
+    /** Record the current activity; modules and managers derive their `Context` from it. */
+    @JvmStatic
+    fun setContext(activity: Activity) {
+        this.activity = activity
+        PNRegistry.ensureBuiltins()
+        BuiltinModules.onContextAttached(activity)
+    }
+
+    /** Forget `activity` if it is the current one (called from `Activity.onDestroy`). */
+    @JvmStatic
+    fun clearContext(activity: Activity) {
+        if (this.activity === activity) this.activity = null
+    }
+
+    /** The current activity, or `null` before [setContext]. */
+    fun activity(): Activity? = activity
+
+    /** The context used to create views; throws before [setContext]. */
+    fun context(): Context =
+        activity ?: throw IllegalStateException("PNBridge.setContext(activity) has not been called")
+
+    /** Display density of the current context (1.0 when no context is attached). */
+    fun density(): Float {
+        val ctx = activity ?: return 1f
+        val d = ctx.resources.displayMetrics.density
+        return if (d > 0f) d else 1f
+    }
+
+    // ------------------------------------------------------------------
+    // Python -> native
+    // ------------------------------------------------------------------
+
+    /** Apply one serialized transaction (a JSON array of ops). */
+    @JvmStatic
+    fun apply(transactionJson: String) {
+        assertMain("apply")
+        applier.apply(transactionJson)
+    }
+
+    /**
+     * Measure the view with `tag` under the given constraints (dp; `1e6`
+     * means unconstrained) and return `"w,h"` in dp.
+     */
+    @JvmStatic
+    fun measure(tag: Long, maxWidth: Double, maxHeight: Double): String {
+        assertMain("measure")
+        val record = registry.get(tag)
+        if (record == null) {
+            Log.w(TAG, "measure: unknown tag $tag")
+            return "0,0"
+        }
+        val size = try {
+            record.manager.measure(record.view, maxWidth, maxHeight)
+        } catch (e: Exception) {
+            Log.e(TAG, "measure failed for ${record.typeName}#$tag", e)
+            floatArrayOf(0f, 0f)
+        }
+        return String.format(Locale.US, "%.3f,%.3f", size[0], size[1])
+    }
+
+    /** Run an imperative command on one view and return its JSON result. */
+    @JvmStatic
+    fun command(tag: Long, name: String, argsJson: String): String? {
+        assertMain("command")
+        val record = registry.get(tag) ?: return null
+        return try {
+            val args = if (argsJson.isBlank()) JSONObject() else JSONObject(argsJson)
+            JsonUtil.encode(record.manager.command(record.view, name, args))
+        } catch (e: Exception) {
+            Log.e(TAG, "command '$name' failed for ${record.typeName}#$tag", e)
+            null
+        }
+    }
+
+    /** Handle an animation request (`set`, `start`, or `cancel`) for one view. */
+    @JvmStatic
+    fun animate(tag: Long, requestJson: String): String? {
+        assertMain("animate")
+        val record = registry.get(tag) ?: return null
+        return try {
+            PNAnimator.handle(record, JSONObject(requestJson))
+        } catch (e: Exception) {
+            Log.e(TAG, "animate failed for ${record.typeName}#$tag: $requestJson", e)
+            null
+        }
+    }
+
+    /** Call a native module method; `argsJson` is `{"call_id": n, "args": {...}}`. */
+    @JvmStatic
+    fun call(module: String, method: String, argsJson: String): String? {
+        assertMain("call")
+        val (callId, args) = try {
+            ModuleEnvelope.decodeCall(argsJson)
+        } catch (e: Exception) {
+            return ModuleEnvelope.error("malformed call envelope: ${e.message}", "bad_request")
+        }
+        val target = PNRegistry.module(module)
+            ?: return ModuleEnvelope.error("unknown module '$module'", "unknown_module")
+        val promise = Promise(callId, module)
+        try {
+            target.call(method, args, promise)
+        } catch (e: Exception) {
+            Log.e(TAG, "module $module.$method threw", e)
+            if (!promise.isSettled) promise.reject(e.message ?: e.toString(), "exception")
+        }
+        return promise.markReturned()
+    }
+
+    // ------------------------------------------------------------------
+    // native -> Python
+    // ------------------------------------------------------------------
+
+    /**
+     * Deliver one callback to Python. Returns `null` when no host is
+     * installed or the Python handler raised (the error is logged).
+     */
+    fun callPython(kind: String, tag: Long, name: String, payloadJson: String): String? {
+        val target = host
+        if (target == null) {
+            Log.w(TAG, "callPython($kind, $tag, $name) dropped: no PythonHost installed")
+            return null
+        }
+        return try {
+            target.callback(kind, tag, name, payloadJson)
+        } catch (e: Exception) {
+            Log.e(TAG, "Python callback $kind/$name (tag $tag) raised", e)
+            null
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Threading helpers
+    // ------------------------------------------------------------------
+
+    /** Whether the caller is on the main thread. */
+    fun isMainThread(): Boolean = MainThread.isMain()
+
+    /** Post `runnable` to the main thread. */
+    fun post(runnable: Runnable) = MainThread.post(runnable)
+
+    private fun assertMain(entry: String) {
+        if (!MainThread.isMain()) {
+            Log.w(TAG, "PNBridge.$entry called off the main thread (${Thread.currentThread().name})")
+        }
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/PythonHost.kt

@@ -0,0 +1,20 @@
+package com.pythonnative.runtime
+
+/**
+ * The reverse direction of the bridge: native to Python.
+ *
+ * The app template installs an implementation that forwards to
+ * `pythonnative.bridge.native_callback` through Chaquopy. The runtime
+ * library itself never touches Chaquopy, which keeps it unit-testable
+ * with plain JUnit.
+ *
+ * `kind` is one of `event`, `module`, `host`, `animation`, or `pump`;
+ * see the bridge protocol documentation for the payload of each.
+ */
+interface PythonHost {
+    /**
+     * Deliver one callback to Python and return its (JSON-encoded)
+     * result, or `null` when the handler produced nothing.
+     */
+    fun callback(kind: String, tag: Long, name: String, payloadJson: String): String?
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/animation/AnimationSpecs.kt

@@ -0,0 +1,141 @@
+package com.pythonnative.runtime.animation
+
+import org.json.JSONArray
+import org.json.JSONObject
+import kotlin.math.max
+import kotlin.math.sqrt
+
+/**
+ * Pure-Kotlin decoding of animation specs (`pn.Animated.timing`,
+ * `spring`, `decay`) and their mapping to Android animator parameters.
+ * Kept free of Android types so the math is unit-testable.
+ */
+object AnimationSpecs {
+    /** `FlingAnimation` scales `friction` by this constant internally (`DragForce`). */
+    const val FLING_FRICTION_SCALE = 4.2
+
+    /** Easing curves identical to the Python ticker's `_EASINGS`. */
+    val EASINGS: Map<String, (Float) -> Float> = mapOf(
+        "linear" to { t -> t },
+        "ease" to { t -> 3f * t * t - 2f * t * t * t },
+        "ease_in" to { t -> t * t },
+        "ease_out" to { t -> 1f - (1f - t) * (1f - t) },
+        "ease_in_out" to { t -> 3f * t * t - 2f * t * t * t },
+        "ease_in_quad" to { t -> t * t },
+        "ease_out_quad" to { t -> 1f - (1f - t) * (1f - t) },
+        "bounce" to { t -> bounceOut(t) },
+    )
+
+    /** Decoded `timing` parameters. */
+    data class Timing(val from: Double, val to: Double, val durationMs: Long, val easing: Any?)
+
+    /** Decoded `spring` parameters mapped to `SpringForce` terms. */
+    data class Spring(
+        val from: Double,
+        val to: Double,
+        /** `stiffness / mass`, so the natural frequency matches the Python integrator. */
+        val stiffness: Double,
+        /** `damping / (2 * sqrt(stiffness * mass))`. */
+        val dampingRatio: Double,
+        /** Units per second. */
+        val initialVelocity: Double,
+    )
+
+    /** Decoded `decay` parameters mapped to `FlingAnimation` terms. */
+    data class Decay(
+        val from: Double,
+        /** Units per second (Python specs use units per millisecond). */
+        val startVelocity: Double,
+        /** `FlingAnimation.setFriction` value reproducing `v(t) = v0 * exp(-k * 1000 * t)`. */
+        val friction: Double,
+        /** Where the value settles: `from + v0 / (k * 1000)`. */
+        val projectedFinal: Double,
+    )
+
+    fun kind(spec: JSONObject): String = spec.optString("kind", "")
+
+    fun timing(spec: JSONObject): Timing = Timing(
+        from = spec.optDouble("from", 0.0),
+        to = spec.optDouble("to", 0.0),
+        durationMs = max(0L, spec.optDouble("duration_ms", 300.0).toLong()),
+        easing = spec.opt("easing"),
+    )
+
+    fun spring(spec: JSONObject): Spring {
+        val stiffness = max(1e-6, spec.optDouble("stiffness", 100.0))
+        val damping = max(0.0, spec.optDouble("damping", 10.0))
+        val mass = max(1e-6, spec.optDouble("mass", 1.0))
+        return Spring(
+            from = spec.optDouble("from", 0.0),
+            to = spec.optDouble("to", 0.0),
+            stiffness = stiffness / mass,
+            dampingRatio = dampingRatio(stiffness, damping, mass),
+            initialVelocity = spec.optDouble("initial_velocity", 0.0),
+        )
+    }
+
+    /** `damping / (2 * sqrt(stiffness * mass))`. */
+    fun dampingRatio(stiffness: Double, damping: Double, mass: Double): Double =
+        damping / (2.0 * sqrt(max(1e-12, stiffness * mass)))
+
+    fun decay(spec: JSONObject): Decay {
+        val v0PerMs = spec.optDouble("velocity", 0.0)
+        val k = max(1e-6, spec.optDouble("deceleration", 0.997))
+        val from = spec.optDouble("from", 0.0)
+        return Decay(
+            from = from,
+            startVelocity = v0PerMs * 1000.0,
+            friction = decayFriction(k),
+            projectedFinal = from + v0PerMs / (k * 1000.0),
+        )
+    }
+
+    /**
+     * The Python ticker decays velocity as `exp(-k * dt_ms)`, that is
+     * `exp(-k * 1000 * t_s)`. `FlingAnimation` decays as
+     * `exp(-4.2 * friction * t_s)`, so `friction = k * 1000 / 4.2`.
+     */
+    fun decayFriction(deceleration: Double): Double = deceleration * 1000.0 / FLING_FRICTION_SCALE
+
+    /**
+     * Resolve an easing value. Names map to [EASINGS]; a four-number
+     * array is returned as cubic-bezier control points (`DoubleArray`)
+     * for the caller to build a `PathInterpolator`. Unknown names fall
+     * back to `ease_in_out` like the Python ticker.
+     */
+    fun resolveEasing(easing: Any?): Any {
+        if (easing is JSONArray && easing.length() == 4) {
+            return DoubleArray(4) { easing.optDouble(it, 0.0) }
+        }
+        if (easing is String) {
+            val trimmed = easing.trim()
+            if (trimmed.startsWith("cubic-bezier(") || trimmed.startsWith("cubic_bezier(")) {
+                val inner = trimmed.substringAfter('(').substringBeforeLast(')')
+                val parts = inner.split(',').mapNotNull { it.trim().toDoubleOrNull() }
+                if (parts.size == 4) return parts.toDoubleArray()
+            }
+            return EASINGS[trimmed] ?: EASINGS.getValue("ease_in_out")
+        }
+        return EASINGS.getValue("ease_in_out")
+    }
+
+    private fun bounceOut(t: Float): Float {
+        val n1 = 7.5625f
+        val d1 = 2.75f
+        return when {
+            t < 1f / d1 -> n1 * t * t
+            t < 2f / d1 -> {
+                val u = t - 1.5f / d1
+                n1 * u * u + 0.75f
+            }
+            t < 2.5f / d1 -> {
+                val u = t - 2.25f / d1
+                n1 * u * u + 0.9375f
+            }
+            else -> {
+                val u = t - 2.625f / d1
+                n1 * u * u + 0.984375f
+            }
+        }
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/animation/PNAnimator.kt

@@ -0,0 +1,249 @@
+package com.pythonnative.runtime.animation
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.ArgbEvaluator
+import android.animation.TimeInterpolator
+import android.animation.ValueAnimator
+import android.view.View
+import android.view.animation.PathInterpolator
+import android.widget.TextView
+import androidx.dynamicanimation.animation.DynamicAnimation
+import androidx.dynamicanimation.animation.FlingAnimation
+import androidx.dynamicanimation.animation.FloatPropertyCompat
+import androidx.dynamicanimation.animation.SpringAnimation
+import androidx.dynamicanimation.animation.SpringForce
+import com.pythonnative.runtime.PNBridge
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.PNLog
+import com.pythonnative.runtime.bridge.ViewRecord
+import com.pythonnative.runtime.components.PNColor
+import com.pythonnative.runtime.components.ViewStyler
+import org.json.JSONObject
+
+/**
+ * Native driver for `animate` requests on the animatable props
+ * (`opacity`, `background_color`, `translate_x`, `translate_y`,
+ * `scale`, `scale_x`, `scale_y`, `rotate`, plus `color` for text).
+ *
+ * `timing` runs on a `ValueAnimator`, `spring` on a `SpringAnimation`,
+ * and `decay` on a `FlingAnimation`. Completion is reported with
+ * `callback("animation", 0, "", {"id": n, "finished": bool})`.
+ */
+object PNAnimator {
+    private class Running(val view: View, val prop: String, val cancel: () -> Unit)
+
+    private val running = HashMap<Long, Running>()
+
+    /** Handle one request object; returns the JSON reply string per the spec. */
+    fun handle(record: ViewRecord, request: JSONObject): String? {
+        val view = record.view
+        return when (request.optString("op")) {
+            "set" -> {
+                record.manager.setAnimatedProperty(view, request.optString("prop"), request.opt("value"))
+                null
+            }
+            "start" -> {
+                val id = request.optLong("id")
+                val spec = request.optJSONObject("spec") ?: JSONObject()
+                val ok = record.manager.startAnimation(view, id, request.optString("prop"), spec)
+                JSONObject().put("ok", ok).toString()
+            }
+            "cancel" -> {
+                val value = record.manager.cancelAnimation(view, request.optLong("id"))
+                if (value == null) null else JSONObject().put("value", JsonUtil.wrap(value)).toString()
+            }
+            else -> null
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Property access
+    // ------------------------------------------------------------------
+
+    /** Apply one animation frame to `view`. Unknown props are ignored. */
+    fun setProperty(view: View, prop: String, value: Any?) {
+        if (JsonUtil.isNull(value)) return
+        try {
+            when (prop) {
+                "opacity" -> view.alpha = JsonUtil.toDouble(value).toFloat()
+                "translate_x" -> view.translationX = px(JsonUtil.toDouble(value))
+                "translate_y" -> view.translationY = px(JsonUtil.toDouble(value))
+                "scale" -> {
+                    val s = JsonUtil.toDouble(value).toFloat()
+                    view.scaleX = s
+                    view.scaleY = s
+                }
+                "scale_x" -> view.scaleX = JsonUtil.toDouble(value).toFloat()
+                "scale_y" -> view.scaleY = JsonUtil.toDouble(value).toFloat()
+                "rotate" -> view.rotation = ViewStyler.angleDegrees(value)
+                "background_color" -> ViewStyler.setAnimatedBackground(view, value)
+                "color" -> (view as? TextView)?.setTextColor(PNColor.parseOr(value, 0xFF000000.toInt()))
+            }
+        } catch (e: Exception) {
+            PNLog.swallowed("PNAnimator.setProperty", e)
+        }
+    }
+
+    /** Read the current (presentation) value of an animatable prop, or `null`. */
+    fun readProperty(view: View, prop: String): Any? = when (prop) {
+        "opacity" -> view.alpha.toDouble()
+        "translate_x" -> view.translationX / PNBridge.density().toDouble()
+        "translate_y" -> view.translationY / PNBridge.density().toDouble()
+        "scale", "scale_x" -> view.scaleX.toDouble()
+        "scale_y" -> view.scaleY.toDouble()
+        "rotate" -> view.rotation.toDouble()
+        else -> null
+    }
+
+    // ------------------------------------------------------------------
+    // Start / cancel
+    // ------------------------------------------------------------------
+
+    /** Start a native animation; `false` means Python should tick it instead. */
+    fun start(view: View, id: Long, prop: String, spec: JSONObject): Boolean {
+        cancelQuietly(id)
+        return try {
+            when (AnimationSpecs.kind(spec)) {
+                "timing" -> startTiming(view, id, prop, spec)
+                "spring" -> startSpring(view, id, prop, spec)
+                "decay" -> startDecay(view, id, prop, spec)
+                else -> false
+            }
+        } catch (e: Exception) {
+            PNLog.rateLimited("anim-start", "native animation failed for '$prop'", e)
+            running.remove(id)
+            false
+        }
+    }
+
+    /** Cancel `id` and return the presentation value of its prop, if readable. */
+    fun cancel(id: Long): Any? {
+        val entry = running.remove(id) ?: return null
+        try {
+            entry.cancel()
+        } catch (e: Exception) {
+            PNLog.swallowed("PNAnimator.cancel", e)
+        }
+        return readProperty(entry.view, entry.prop)
+    }
+
+    private fun cancelQuietly(id: Long) {
+        running.remove(id)?.let { runCatching { it.cancel() } }
+    }
+
+    private fun complete(id: Long, finished: Boolean) {
+        if (running.remove(id) == null) return
+        PNBridge.callPython("animation", 0, "", JSONObject().put("id", id).put("finished", finished).toString())
+    }
+
+    private fun startTiming(view: View, id: Long, prop: String, spec: JSONObject): Boolean {
+        val timing = AnimationSpecs.timing(spec)
+        val animator: ValueAnimator
+        if (prop == "background_color") {
+            val from = PNColor.parse(spec.opt("from")) ?: return false
+            val to = PNColor.parse(spec.opt("to")) ?: return false
+            animator = ValueAnimator.ofObject(ArgbEvaluator(), from, to)
+            animator.addUpdateListener { ViewStyler.setAnimatedBackground(view, it.animatedValue as Int) }
+        } else if (prop == "color") {
+            val from = PNColor.parse(spec.opt("from")) ?: return false
+            val to = PNColor.parse(spec.opt("to")) ?: return false
+            animator = ValueAnimator.ofObject(ArgbEvaluator(), from, to)
+            animator.addUpdateListener { (view as? TextView)?.setTextColor(it.animatedValue as Int) }
+        } else {
+            if (!isFloatProp(prop)) return false
+            animator = ValueAnimator.ofFloat(timing.from.toFloat(), timing.to.toFloat())
+            animator.addUpdateListener { setProperty(view, prop, it.animatedValue as Float) }
+        }
+        animator.duration = timing.durationMs
+        animator.interpolator = interpolator(timing.easing)
+        var cancelled = false
+        animator.addListener(object : AnimatorListenerAdapter() {
+            override fun onAnimationCancel(animation: Animator) {
+                cancelled = true
+            }
+
+            override fun onAnimationEnd(animation: Animator) {
+                complete(id, !cancelled)
+            }
+        })
+        running[id] = Running(view, prop) { animator.cancel() }
+        animator.start()
+        return true
+    }
+
+    private fun startSpring(view: View, id: Long, prop: String, spec: JSONObject): Boolean {
+        val params = AnimationSpecs.spring(spec)
+        val property = floatProperty(prop) ?: return false
+        val scale = unitScale(prop)
+        val anim = SpringAnimation(view, property, (params.to * scale).toFloat())
+        anim.spring = SpringForce((params.to * scale).toFloat())
+            .setStiffness(params.stiffness.toFloat())
+            .setDampingRatio(params.dampingRatio.toFloat())
+        anim.setStartValue((params.from * scale).toFloat())
+        anim.setStartVelocity((params.initialVelocity * scale).toFloat())
+        anim.addEndListener { _, canceled, _, _ -> complete(id, !canceled) }
+        running[id] = Running(view, prop) { anim.cancel() }
+        anim.start()
+        return true
+    }
+
+    private fun startDecay(view: View, id: Long, prop: String, spec: JSONObject): Boolean {
+        val params = AnimationSpecs.decay(spec)
+        val property = floatProperty(prop) ?: return false
+        val scale = unitScale(prop)
+        val anim = FlingAnimation(view, property)
+        anim.setStartValue((params.from * scale).toFloat())
+        anim.setStartVelocity((params.startVelocity * scale).toFloat())
+        anim.friction = params.friction.toFloat()
+        anim.addEndListener { _, canceled, _, _ -> complete(id, !canceled) }
+        running[id] = Running(view, prop) { anim.cancel() }
+        anim.start()
+        return true
+    }
+
+    // ------------------------------------------------------------------
+    // Helpers
+    // ------------------------------------------------------------------
+
+    private fun px(dp: Double): Float = (dp * PNBridge.density()).toFloat()
+
+    private fun isFloatProp(prop: String): Boolean =
+        prop in setOf("opacity", "translate_x", "translate_y", "scale", "scale_x", "scale_y", "rotate")
+
+    /** Multiplier from spec units to native units (dp to px for translations). */
+    private fun unitScale(prop: String): Double =
+        if (prop == "translate_x" || prop == "translate_y") PNBridge.density().toDouble() else 1.0
+
+    /** A `FloatPropertyCompat` for physics animations; `null` for unsupported props. */
+    private fun floatProperty(prop: String): FloatPropertyCompat<View>? = when (prop) {
+        "opacity" -> DynamicAnimation.ALPHA
+        "translate_x" -> DynamicAnimation.TRANSLATION_X
+        "translate_y" -> DynamicAnimation.TRANSLATION_Y
+        "scale_x" -> DynamicAnimation.SCALE_X
+        "scale_y" -> DynamicAnimation.SCALE_Y
+        "rotate" -> DynamicAnimation.ROTATION
+        "scale" -> object : FloatPropertyCompat<View>("pnScale") {
+            override fun getValue(v: View): Float = v.scaleX
+            override fun setValue(v: View, value: Float) {
+                v.scaleX = value
+                v.scaleY = value
+            }
+        }
+        // Color props are not floats; physics specs on them fall back to the Python ticker.
+        else -> null
+    }
+
+    private fun interpolator(easing: Any?): TimeInterpolator {
+        return when (val resolved = AnimationSpecs.resolveEasing(easing)) {
+            is DoubleArray -> PathInterpolator(
+                resolved[0].toFloat(), resolved[1].toFloat(), resolved[2].toFloat(), resolved[3].toFloat(),
+            )
+            else -> {
+                @Suppress("UNCHECKED_CAST")
+                val fn = resolved as (Float) -> Float
+                TimeInterpolator { t -> fn(t) }
+            }
+        }
+    }
+}