pythonnative 0.36.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

pythonnative/templates/android_template/pythonnative/src/test/java/com/pythonnative/runtime/AnimationSpecsTest.kt

@@ -0,0 +1,75 @@
+package com.pythonnative.runtime
+
+import com.pythonnative.runtime.animation.AnimationSpecs
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import kotlin.math.exp
+import kotlin.math.sqrt
+
+class AnimationSpecsTest {
+    @Test
+    fun springDampingRatio() {
+        // Critically damped when damping = 2 * sqrt(k * m).
+        val k = 100.0
+        val m = 2.0
+        val critical = 2 * sqrt(k * m)
+        assertEquals(1.0, AnimationSpecs.dampingRatio(k, critical, m), 1e-9)
+        val spec = JSONObject("""{"kind":"spring","from":0,"to":1,"stiffness":100,"damping":10,"mass":1}""")
+        val spring = AnimationSpecs.spring(spec)
+        assertEquals(100.0, spring.stiffness, 1e-9)
+        assertEquals(0.5, spring.dampingRatio, 1e-9)
+        // Mass scales the effective stiffness so the natural frequency matches.
+        val heavy = AnimationSpecs.spring(JSONObject("""{"kind":"spring","stiffness":100,"damping":10,"mass":4}"""))
+        assertEquals(25.0, heavy.stiffness, 1e-9)
+        assertEquals(10.0 / (2 * sqrt(400.0)), heavy.dampingRatio, 1e-9)
+    }
+
+    @Test
+    fun decayFrictionReproducesPythonDecay() {
+        val k = 0.002
+        val friction = AnimationSpecs.decayFriction(k)
+        // FlingAnimation: v(t) = v0 * exp(-4.2 * friction * t); Python: v0 * exp(-k * 1000 * t).
+        val t = 0.25
+        assertEquals(exp(-k * 1000 * t), exp(-AnimationSpecs.FLING_FRICTION_SCALE * friction * t), 1e-9)
+        val decay = AnimationSpecs.decay(JSONObject("""{"kind":"decay","from":10,"velocity":2,"deceleration":0.002}"""))
+        assertEquals(2000.0, decay.startVelocity, 1e-9)
+        assertEquals(10.0 + 2.0 / (0.002 * 1000.0), decay.projectedFinal, 1e-9)
+    }
+
+    @Test
+    fun timingDefaults() {
+        val timing = AnimationSpecs.timing(JSONObject("""{"kind":"timing","from":0,"to":1}"""))
+        assertEquals(300L, timing.durationMs)
+        assertEquals(1.0, timing.to, 0.0)
+    }
+
+    @Test
+    fun easingNamesMatchPythonCurves() {
+        @Suppress("UNCHECKED_CAST")
+        val easeInOut = AnimationSpecs.resolveEasing("ease_in_out") as (Float) -> Float
+        assertEquals(0.5f, easeInOut(0.5f), 1e-6f)
+        assertEquals(0.15625f, easeInOut(0.25f), 1e-6f)
+        @Suppress("UNCHECKED_CAST")
+        val linear = AnimationSpecs.resolveEasing("linear") as (Float) -> Float
+        assertEquals(0.3f, linear(0.3f), 1e-6f)
+        @Suppress("UNCHECKED_CAST")
+        val fallback = AnimationSpecs.resolveEasing("does-not-exist") as (Float) -> Float
+        assertEquals(easeInOut(0.3f), fallback(0.3f), 1e-6f)
+        @Suppress("UNCHECKED_CAST")
+        val bounce = AnimationSpecs.resolveEasing("bounce") as (Float) -> Float
+        assertEquals(1f, bounce(1f), 1e-6f)
+        assertTrue(bounce(0.5f) in 0f..1f)
+    }
+
+    @Test
+    fun cubicBezierArraysAreControlPoints() {
+        val pts = AnimationSpecs.resolveEasing(JSONArray("[0.25, 0.1, 0.25, 1.0]")) as DoubleArray
+        assertArrayEquals(doubleArrayOf(0.25, 0.1, 0.25, 1.0), pts, 1e-9)
+        val css = AnimationSpecs.resolveEasing("cubic-bezier(0.42, 0, 1, 1)") as DoubleArray
+        assertArrayEquals(doubleArrayOf(0.42, 0.0, 1.0, 1.0), css, 1e-9)
+    }
+}

pythonnative/templates/android_template/pythonnative/src/test/java/com/pythonnative/runtime/GestureArbiterTest.kt

@@ -0,0 +1,197 @@
+package com.pythonnative.runtime
+
+import com.pythonnative.runtime.gestures.GestureArbiter
+import com.pythonnative.runtime.gestures.GestureConfig
+import org.json.JSONArray
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class GestureArbiterTest {
+    private class Recorder {
+        val events = ArrayList<Pair<Int, Map<String, Any?>>>()
+        fun emit(index: Int, payload: Map<String, Any?>) {
+            events.add(index to payload)
+        }
+        fun states(index: Int) = events.filter { it.first == index }.map { it.second["state"] }
+    }
+
+    private fun tap(nTaps: Int = 1, sim: Set<Int>? = null, waitFor: Set<Int> = emptySet()) =
+        GestureConfig(kind = "tap", nTaps = nTaps, simultaneous = sim, waitFor = waitFor)
+
+    @Test
+    fun singleTapEmitsEnded() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(tap()), rec::emit)
+        arbiter.pointerDown(0, 10.0, 10.0, 0.0)
+        arbiter.pointerUp(0, 11.0, 10.0, 0.1)
+        assertEquals(listOf<Any?>("ended"), rec.states(0))
+        assertEquals(11.0, rec.events[0].second["x"])
+    }
+
+    @Test
+    fun tapFailsWhenPointerTravels() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(tap()), rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerMove(0, 50.0, 0.0, 0.05)
+        arbiter.pointerUp(0, 50.0, 0.0, 0.1)
+        assertTrue(rec.events.isEmpty())
+    }
+
+    @Test
+    fun doubleTapNeedsTwoTapsInsideTheWindow() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(tap(nTaps = 2)), rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerUp(0, 0.0, 0.0, 0.05)
+        assertTrue(rec.events.isEmpty())
+        arbiter.pointerDown(0, 0.0, 0.0, 0.2)
+        arbiter.pointerUp(0, 0.0, 0.0, 0.25)
+        assertEquals(listOf<Any?>("ended"), rec.states(0))
+    }
+
+    @Test
+    fun exclusiveSingleTapWaitsForDoubleTapWindow() {
+        // Exclusive(double_tap, single_tap): index 1 waits for index 0.
+        val rec = Recorder()
+        val specs = listOf(
+            tap(nTaps = 2, sim = emptySet()),
+            tap(nTaps = 1, sim = emptySet(), waitFor = setOf(0)),
+        )
+        val arbiter = GestureArbiter(specs, rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerUp(0, 0.0, 0.0, 0.05)
+        // Single tap is buffered until the double-tap gap expires.
+        assertTrue(rec.events.isEmpty())
+        val deadline = arbiter.nextDeadline()
+        assertTrue(deadline != null && deadline > 0.05)
+        arbiter.poll(deadline!! + 0.001)
+        assertEquals(listOf<Any?>("ended"), rec.states(1))
+        assertTrue(rec.states(0).isEmpty())
+    }
+
+    @Test
+    fun exclusiveDoubleTapSuppressesSingleTap() {
+        val rec = Recorder()
+        val specs = listOf(
+            tap(nTaps = 2, sim = emptySet()),
+            tap(nTaps = 1, sim = emptySet(), waitFor = setOf(0)),
+        )
+        val arbiter = GestureArbiter(specs, rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerUp(0, 0.0, 0.0, 0.05)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.15)
+        arbiter.pointerUp(0, 0.0, 0.0, 0.2)
+        assertEquals(listOf<Any?>("ended"), rec.states(0))
+        assertTrue(rec.states(1).isEmpty())
+    }
+
+    @Test
+    fun longPressActivatesOnPollAndEndsOnRelease() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(GestureConfig(kind = "long_press", minDurationMs = 500.0)), rec::emit)
+        arbiter.pointerDown(0, 5.0, 5.0, 0.0)
+        assertEquals(0.5, arbiter.nextDeadline()!!, 1e-9)
+        arbiter.poll(0.3)
+        assertTrue(rec.events.isEmpty())
+        arbiter.poll(0.5)
+        assertEquals(listOf<Any?>("began"), rec.states(0))
+        arbiter.pointerUp(0, 5.0, 5.0, 0.7)
+        assertEquals(listOf<Any?>("began", "ended"), rec.states(0))
+    }
+
+    @Test
+    fun panReportsTranslationAndVelocity() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(GestureConfig(kind = "pan", minDistance = 10.0)), rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerMove(0, 5.0, 0.0, 0.01)
+        assertTrue(rec.events.isEmpty())
+        arbiter.pointerMove(0, 20.0, 0.0, 0.02)
+        assertEquals(listOf<Any?>("began"), rec.states(0))
+        assertTrue(arbiter.hasActivePan())
+        arbiter.pointerMove(0, 30.0, 5.0, 0.03)
+        val changed = rec.events.last().second
+        assertEquals("changed", changed["state"])
+        assertEquals(10.0, changed["translation_x"] as Double, 1e-9)
+        assertEquals(5.0, changed["translation_y"] as Double, 1e-9)
+        assertTrue((changed["velocity_x"] as Double) > 0)
+        arbiter.pointerUp(0, 40.0, 5.0, 0.04)
+        val ended = rec.events.last().second
+        assertEquals("ended", ended["state"])
+        assertEquals(20.0, ended["translation_x"] as Double, 1e-9)
+        assertFalse(arbiter.hasActivePan())
+    }
+
+    @Test
+    fun raceLetsFirstActivationWin() {
+        // Pan and long press not simultaneous: the pan activates first, long press never fires.
+        val rec = Recorder()
+        val specs = listOf(
+            GestureConfig(kind = "pan", minDistance = 10.0, simultaneous = emptySet()),
+            GestureConfig(kind = "long_press", minDurationMs = 500.0, simultaneous = emptySet()),
+        )
+        val arbiter = GestureArbiter(specs, rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerMove(0, 3.0, 0.0, 0.05)
+        arbiter.pointerMove(0, 6.0, 0.0, 0.1)
+        arbiter.pointerMove(0, 20.0, 0.0, 0.15)
+        assertEquals(listOf<Any?>("began"), rec.states(0))
+        arbiter.poll(0.6)
+        assertTrue(rec.states(1).isEmpty())
+    }
+
+    @Test
+    fun simultaneousGesturesBothRun() {
+        val rec = Recorder()
+        val specs = listOf(
+            GestureConfig(kind = "pan", minDistance = 5.0, simultaneous = setOf(1)),
+            GestureConfig(kind = "pinch", simultaneous = setOf(0)),
+        )
+        val arbiter = GestureArbiter(specs, rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerDown(1, 100.0, 0.0, 0.01)
+        assertEquals(listOf<Any?>("began"), rec.states(1))
+        arbiter.pointerMove(1, 120.0, 0.0, 0.02)
+        assertEquals(listOf<Any?>("began"), rec.states(0))
+        assertEquals(listOf<Any?>("began", "changed"), rec.states(1))
+        assertEquals(1.2, rec.events.last().second["scale"] as Double, 1e-9)
+    }
+
+    @Test
+    fun swipeResolvesDirectionAndVelocity() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(GestureConfig(kind = "swipe", direction = "right", minVelocity = 300.0)), rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerMove(0, 50.0, 0.0, 0.05)
+        arbiter.pointerUp(0, 100.0, 0.0, 0.1)
+        val ended = rec.events.single().second
+        assertEquals("ended", ended["state"])
+        assertEquals("right", ended["direction"])
+        assertEquals(1000.0, ended["velocity_x"] as Double, 1e-6)
+    }
+
+    @Test
+    fun cancelAbortsActiveGestures() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(GestureConfig(kind = "pan", minDistance = 1.0)), rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerMove(0, 10.0, 0.0, 0.01)
+        arbiter.cancel(0.02)
+        assertEquals(listOf<Any?>("began", "cancelled"), rec.states(0))
+    }
+
+    @Test
+    fun decodesSerializedSpecs() {
+        val specs = GestureArbiter.decodeSpecs(
+            JSONArray("""[{"kind":"tap","n_taps":2,"simultaneous":[1],"wait_for":[]},{"kind":"pan","min_distance":4}]"""),
+        )
+        assertEquals(2, specs.size)
+        assertEquals(2, specs[0].nTaps)
+        assertEquals(setOf(1), specs[0].simultaneous)
+        assertEquals(4.0, specs[1].minDistance, 0.0)
+        assertEquals(null, specs[1].simultaneous)
+    }
+}

pythonnative/templates/android_template/pythonnative/src/test/java/com/pythonnative/runtime/PNColorTest.kt

@@ -0,0 +1,47 @@
+package com.pythonnative.runtime
+
+import com.pythonnative.runtime.components.PNColor
+import org.json.JSONArray
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class PNColorTest {
+    private fun hex(v: Int?): String = if (v == null) "null" else String.format("%08X", v)
+
+    @Test
+    fun parsesHexForms() {
+        assertEquals("FFFF0000", hex(PNColor.parse("#f00")))
+        assertEquals("FF112233", hex(PNColor.parse("#112233")))
+        assertEquals("80112233", hex(PNColor.parse("#80112233")))
+        assertEquals("FF112233", hex(PNColor.parse("112233")))
+    }
+
+    @Test
+    fun parsesFunctionalForms() {
+        assertEquals("FF0A141E", hex(PNColor.parse("rgb(10, 20, 30)")))
+        assertEquals("800A141E", hex(PNColor.parse("rgba(10, 20, 30, 0.5)")))
+    }
+
+    @Test
+    fun parsesNamedColors() {
+        assertEquals("FF000000", hex(PNColor.parse("black")))
+        assertEquals("FFFFFFFF", hex(PNColor.parse("White")))
+        assertEquals("00000000", hex(PNColor.parse("transparent")))
+    }
+
+    @Test
+    fun parsesIntegersAndArrays() {
+        assertEquals("FF112233", hex(PNColor.parse(0x112233)))
+        assertEquals("80112233", hex(PNColor.parse(0x80112233L)))
+        assertEquals("FF0A141E", hex(PNColor.parse(JSONArray("[10, 20, 30]"))))
+        assertEquals("800A141E", hex(PNColor.parse(JSONArray("[10, 20, 30, 0.5]"))))
+    }
+
+    @Test
+    fun rejectsGarbage() {
+        assertNull(PNColor.parse("not a color"))
+        assertNull(PNColor.parse(null))
+        assertEquals(7, PNColor.parseOr("nope", 7))
+    }
+}

pythonnative/templates/android_template/pythonnative/src/test/java/com/pythonnative/runtime/PNTransactionTest.kt

@@ -0,0 +1,78 @@
+package com.pythonnative.runtime
+
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.Op
+import com.pythonnative.runtime.bridge.PNTransaction
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class PNTransactionTest {
+    @Test
+    fun decodesEveryOpcode() {
+        val json = """
+            [
+              ["c", 1, "View", {"background_color": "#fff"}],
+              ["u", 1, {"opacity": 0.5, "background_color": null}],
+              ["i", 1, 2, 0],
+              ["f", 2, 10, 20.5, 100, 40],
+              ["d", 2]
+            ]
+        """.trimIndent()
+        val ops = PNTransaction.decode(json)
+        assertEquals(5, ops.size)
+        val create = ops[0] as Op.Create
+        assertEquals(1L, create.tag)
+        assertEquals("View", create.typeName)
+        assertEquals("#fff", create.props.getString("background_color"))
+        val update = ops[1] as Op.Update
+        assertEquals(0.5, update.changed.getDouble("opacity"), 1e-9)
+        assertTrue(update.changed.isNull("background_color"))
+        assertEquals(Op.Insert(1, 2, 0), ops[2])
+        assertEquals(Op.Frame(2, 10.0, 20.5, 100.0, 40.0), ops[3])
+        assertEquals(Op.Destroy(2), ops[4])
+    }
+
+    @Test
+    fun infinityStringsBecomeInfinity() {
+        val ops = PNTransaction.decode("""[["f", 1, 0, 0, "inf", "-inf"]]""")
+        val frame = ops[0] as Op.Frame
+        assertEquals(Double.POSITIVE_INFINITY, frame.width, 0.0)
+        assertEquals(Double.NEGATIVE_INFINITY, frame.height, 0.0)
+        assertEquals(Double.POSITIVE_INFINITY, JsonUtil.toDouble("Infinity"), 0.0)
+    }
+
+    @Test
+    fun malformedOpsAreIsolated() {
+        val errors = ArrayList<Int>()
+        val ops = PNTransaction.decode(
+            """[["c", 1, "View", {}], ["zz", 1], "not-an-array", ["i"], ["d", 1]]""",
+        ) { index, _ -> errors.add(index) }
+        assertEquals(listOf(1, 2, 3), errors)
+        assertEquals(2, ops.size)
+        assertTrue(ops[0] is Op.Create)
+        assertEquals(Op.Destroy(1), ops[1])
+    }
+
+    @Test
+    fun mergeKeepsExplicitNulls() {
+        val target = JSONObject("""{"a": 1, "b": 2}""")
+        JsonUtil.merge(target, JSONObject("""{"b": null, "c": "x"}"""))
+        assertEquals(1, target.getInt("a"))
+        assertTrue(target.isNull("b"))
+        assertNull(target.value("b"))
+        assertEquals("x", target.getString("c"))
+    }
+
+    @Test
+    fun encodesResultsAsJson() {
+        assertNull(JsonUtil.encode(null))
+        assertEquals("\"hi\"", JsonUtil.encode("hi"))
+        assertEquals("true", JsonUtil.encode(true))
+        assertEquals("""{"x":1.5}""", JsonUtil.encode(mapOf("x" to 1.5)))
+        assertEquals("[1,2]", JsonUtil.encode(listOf(1, 2)))
+    }
+}

pythonnative/templates/android_template/pythonnative/src/test/java/com/pythonnative/runtime/PromiseTest.kt

@@ -0,0 +1,75 @@
+package com.pythonnative.runtime
+
+import com.pythonnative.runtime.modules.ModuleEnvelope
+import com.pythonnative.runtime.modules.Promise
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class PromiseTest {
+    @Test
+    fun decodesCallEnvelope() {
+        val (callId, args) = ModuleEnvelope.decodeCall("""{"call_id": 7, "args": {"url": "x"}}""")
+        assertEquals(7L, callId)
+        assertEquals("x", args.getString("url"))
+        val (emptyId, emptyArgs) = ModuleEnvelope.decodeCall("")
+        assertEquals(0L, emptyId)
+        assertEquals(0, emptyArgs.length())
+    }
+
+    @Test
+    fun encodesResultEnvelopes() {
+        assertEquals("""{"ok":true,"value":3}""", ModuleEnvelope.ok(3))
+        val err = JSONObject(ModuleEnvelope.error("boom", "code_x"))
+        assertFalse(err.getBoolean("ok"))
+        assertEquals("boom", err.getString("error"))
+        assertEquals("code_x", err.getString("code"))
+        assertEquals("""{"pending":true}""", ModuleEnvelope.pending())
+        val event = JSONObject(ModuleEnvelope.event("change", mapOf("state" to "active")))
+        assertEquals("change", event.getString("event"))
+        assertEquals("active", event.getJSONObject("payload").getString("state"))
+    }
+
+    @Test
+    fun synchronousSettlementIsReturnedInline() {
+        val posted = ArrayList<Runnable>()
+        val promise = Promise(1, "Test") { posted.add(it) }
+        promise.resolve(mapOf("a" to 1))
+        assertTrue(promise.isSettled)
+        assertEquals("""{"ok":true,"value":{"a":1}}""", promise.markReturned())
+        assertTrue(posted.isEmpty())
+    }
+
+    @Test
+    fun asynchronousSettlementIsPosted() {
+        val posted = ArrayList<Runnable>()
+        val promise = Promise(9, "Test") { posted.add(it) }
+        assertEquals("""{"pending":true}""", promise.markReturned())
+        promise.resolve("later")
+        assertEquals(1, posted.size)
+        // Second settlement is ignored.
+        promise.reject("nope")
+        assertEquals(1, posted.size)
+    }
+
+    @Test
+    fun rejectionEnvelopeCarriesCode() {
+        val promise = Promise(2, "Test") { }
+        promise.reject("bad", "bad_request")
+        val obj = JSONObject(promise.markReturned())
+        assertFalse(obj.getBoolean("ok"))
+        assertEquals("bad_request", obj.getString("code"))
+    }
+
+    @Test
+    fun settledEnvelopesCarryCallId() {
+        val ok = JSONObject(ModuleEnvelope.settled(5, true))
+        assertEquals(5L, ok.getLong("call_id"))
+        assertTrue(ok.getBoolean("ok"))
+        val err = JSONObject(ModuleEnvelope.settledError(6, "x", null))
+        assertEquals(6L, err.getLong("call_id"))
+        assertFalse(err.has("code"))
+    }
+}

pythonnative/templates/android_template/settings.gradle

@@ -14,3 +14,4 @@ dependencyResolutionManagement {
 }
 rootProject.name = "android_template"
 include ':app'
+include ':pythonnative'

pythonnative/templates/ios_template/PythonNativeKit/Package.swift

@@ -0,0 +1,21 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "PythonNativeKit",
+    platforms: [.iOS(.v13)],
+    products: [
+        .library(name: "PythonNativeKit", targets: ["PythonNativeKit"]),
+    ],
+    targets: [
+        .target(
+            name: "PythonNativeKit",
+            path: "Sources/PythonNativeKit"
+        ),
+        .testTarget(
+            name: "PythonNativeKitTests",
+            dependencies: ["PythonNativeKit"],
+            path: "Tests/PythonNativeKitTests"
+        ),
+    ]
+)