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

pythonnative/templates/ios_template/PythonNativeKit/Tests/PythonNativeKitTests/PNGestureTests.swift

@@ -0,0 +1,101 @@
+import XCTest
+@testable import PythonNativeKit
+
+final class PNGestureTests: XCTestCase {
+    override func tearDown() {
+        PNViewRegistry.shared.removeAll()
+        super.tearDown()
+    }
+
+    func testSpecsBecomeRecognizersWithRelationships() {
+        let manager = PNViewManager()
+        let view = manager.createView(tag: 1, props: [
+            "gestures": [
+                ["kind": "tap", "n_taps": 2, "simultaneous": [1], "wait_for": []],
+                ["kind": "pan", "min_distance": 10, "simultaneous": [0], "wait_for": []],
+                ["kind": "long_press", "min_duration_ms": 800, "simultaneous": [], "wait_for": [0]],
+                ["kind": "swipe", "direction": "left", "simultaneous": [], "wait_for": []],
+                ["kind": "pinch", "simultaneous": [], "wait_for": []],
+                ["kind": "rotation", "simultaneous": [], "wait_for": []],
+                ["kind": "fling", "direction": "down", "n_pointers": 2, "simultaneous": [], "wait_for": []],
+            ],
+        ])
+        let recognizers = PNViewState.existing(for: view)?.gestureRecognizers ?? []
+        XCTAssertEqual(recognizers.count, 7)
+        XCTAssertEqual((recognizers[0] as? UITapGestureRecognizer)?.numberOfTapsRequired, 2)
+        XCTAssertTrue(recognizers[1] is UIPanGestureRecognizer)
+        XCTAssertEqual((recognizers[2] as? UILongPressGestureRecognizer)?.minimumPressDuration ?? 0, 0.8, accuracy: 0.001)
+        XCTAssertEqual((recognizers[3] as? UISwipeGestureRecognizer)?.direction, .left)
+        XCTAssertTrue(recognizers[4] is UIPinchGestureRecognizer)
+        XCTAssertTrue(recognizers[5] is UIRotationGestureRecognizer)
+        XCTAssertEqual((recognizers[6] as? UISwipeGestureRecognizer)?.numberOfTouchesRequired, 2)
+        XCTAssertEqual((recognizers[6] as? UISwipeGestureRecognizer)?.direction, .down)
+
+        let coordinator = PNGestureCoordinator.shared
+        XCTAssertEqual(coordinator.index(of: recognizers[2]), 2)
+        XCTAssertTrue(coordinator.allowsSimultaneous(recognizers[0], recognizers[1]))
+        XCTAssertFalse(coordinator.allowsSimultaneous(recognizers[0], recognizers[2]))
+        XCTAssertFalse(coordinator.allowsSimultaneous(recognizers[3], recognizers[4]))
+        XCTAssertTrue(view.isUserInteractionEnabled)
+        XCTAssertTrue(recognizers.allSatisfy { $0.view === view && !$0.cancelsTouchesInView })
+    }
+
+    func testRewiringReplacesRecognizersAndUnknownKindsAreSkipped() {
+        let manager = PNViewManager()
+        let view = manager.createView(tag: 2, props: ["gestures": [["kind": "tap"]]])
+        XCTAssertEqual(view.gestureRecognizers?.count, 1)
+        manager.update(view: view, changed: ["gestures": [["kind": "nonsense"], ["kind": "pan"]]])
+        let recognizers = PNViewState.existing(for: view)?.gestureRecognizers ?? []
+        XCTAssertEqual(recognizers.count, 1)
+        XCTAssertTrue(recognizers[0] is UIPanGestureRecognizer)
+        XCTAssertEqual(PNGestureCoordinator.shared.index(of: recognizers[0]), 1, "index follows the spec position")
+        manager.update(view: view, changed: ["gestures": NSNull()])
+        XCTAssertEqual(view.gestureRecognizers?.count ?? 0, 0)
+    }
+
+    func testStateAndDirectionNames() {
+        XCTAssertEqual(PNGestureCoordinator.stateName(.began), "began")
+        XCTAssertEqual(PNGestureCoordinator.stateName(.changed), "changed")
+        XCTAssertEqual(PNGestureCoordinator.stateName(.ended), "ended")
+        XCTAssertEqual(PNGestureCoordinator.stateName(.cancelled), "cancelled")
+        XCTAssertEqual(PNGestureCoordinator.swipeDirection("up"), .up)
+        XCTAssertEqual(PNGestureCoordinator.swipeDirection("any"), [.left, .right, .up, .down])
+    }
+
+    func testAnyDirectionSwipeInstallsOneRecognizerPerDirection() {
+        let manager = PNViewManager()
+        let view = manager.createView(tag: 3, props: [
+            "gestures": [
+                ["kind": "tap", "simultaneous": [], "wait_for": [1]],
+                ["kind": "swipe", "direction": "any", "simultaneous": [], "wait_for": []],
+            ],
+        ])
+        let recognizers = PNViewState.existing(for: view)?.gestureRecognizers ?? []
+        XCTAssertEqual(recognizers.count, 5, "one tap plus four single-direction swipes")
+        let coordinator = PNGestureCoordinator.shared
+        let swipes = recognizers.compactMap { $0 as? UISwipeGestureRecognizer }
+        XCTAssertEqual(swipes.map { coordinator.direction(of: $0) }, ["left", "right", "up", "down"])
+        XCTAssertEqual(swipes.map { $0.direction }, [.left, .right, .up, .down])
+        XCTAssertTrue(swipes.allSatisfy { coordinator.index(of: $0) == 1 }, "every recognizer reports the spec index")
+        XCTAssertNil(coordinator.direction(of: recognizers[0]))
+    }
+
+    func testAnimatorTimingParameters() {
+        let timing = PNAnimator.timingParameters(kind: "timing", spec: ["duration_ms": 250, "easing": "linear"])
+        XCTAssertEqual(timing.duration, 0.25, accuracy: 0.0001)
+        let spring = PNAnimator.timingParameters(kind: "spring", spec: ["stiffness": 100, "damping": 10, "mass": 1, "from": 0, "to": 1])
+        XCTAssertGreaterThan(spring.duration, 0.15)
+        XCTAssertTrue(spring.parameters is UISpringTimingParameters)
+        XCTAssertTrue(PNAnimator.curve(for: [0.1, 0.2, 0.3, 0.4]) is UICubicTimingParameters)
+    }
+
+    func testAnimatorSetAppliesImmediately() {
+        PNTransaction.apply("[[\"c\", 50, \"View\", {}]]")
+        _ = PNAnimator.shared.handle(tag: 50, request: ["op": "set", "prop": "opacity", "value": 0.25])
+        XCTAssertEqual(PNViewRegistry.shared.view(for: 50)?.alpha ?? 0, 0.25, accuracy: 0.001)
+        _ = PNAnimator.shared.handle(tag: 50, request: ["op": "set", "prop": "translate_x", "value": 12])
+        XCTAssertEqual(PNViewRegistry.shared.view(for: 50)?.transform.tx ?? 0, 12, accuracy: 0.001)
+        let rejected = PNAnimator.shared.handle(tag: 50, request: ["op": "start", "id": 1, "prop": "opacity", "spec": ["kind": "mystery"]])
+        XCTAssertEqual((rejected as? [String: Any])?["ok"] as? Bool, false)
+    }
+}

pythonnative/templates/ios_template/PythonNativeKit/Tests/PythonNativeKitTests/PNManagerTests.swift

@@ -0,0 +1,124 @@
+import XCTest
+@testable import PythonNativeKit
+
+final class PNManagerTests: XCTestCase {
+    override func tearDown() {
+        PNViewRegistry.shared.removeAll()
+        super.tearDown()
+    }
+
+    func testViewManagerAppliesCommonProps() {
+        let manager = PNViewManager()
+        let view = manager.createView(tag: 1, props: [
+            "background_color": "#ff0000",
+            "opacity": 0.5,
+            "border_width": 2,
+            "border_color": "#00ff00",
+            "border_radius": 8,
+            "test_id": "hero",
+            "accessibility_label": "Hero card",
+        ])
+        XCTAssertEqual(view.alpha, 0.5, accuracy: 0.001)
+        XCTAssertEqual(view.layer.borderWidth, 2)
+        XCTAssertEqual(view.layer.cornerRadius, 8)
+        XCTAssertEqual(view.accessibilityIdentifier, "hero")
+        XCTAssertEqual(view.accessibilityLabel, "Hero card")
+        XCTAssertEqual(PNColor.hexString(view.backgroundColor ?? .clear).lowercased(), "#ffff0000")
+
+        manager.update(view: view, changed: ["opacity": 1, "background_color": NSNull(), "display": "none"])
+        XCTAssertEqual(view.alpha, 1, accuracy: 0.001)
+        XCTAssertTrue(view.isHidden)
+        XCTAssertNil(PNViewState.existing(for: view)?.props["background_color"])
+        XCTAssertEqual(PNProps.double(PNViewState.existing(for: view)?.props["opacity"]), 1)
+    }
+
+    func testTransformPropBuildsAffineTransform() {
+        let manager = PNViewManager()
+        let view = manager.createView(tag: 2, props: [
+            "transform": [["translate_x": 10], ["translate_y": 5], ["scale": 2]],
+        ])
+        XCTAssertEqual(view.transform.tx, 10, accuracy: 0.001)
+        XCTAssertEqual(view.transform.ty, 5, accuracy: 0.001)
+        XCTAssertEqual(view.transform.a, 2, accuracy: 0.001)
+        XCTAssertEqual(view.transform.d, 2, accuracy: 0.001)
+
+        manager.update(view: view, changed: ["transform": [["rotate": "90deg"]]])
+        XCTAssertEqual(view.transform.b, 1, accuracy: 0.001)
+        XCTAssertEqual(view.transform.a, 0, accuracy: 0.001)
+
+        manager.update(view: view, changed: ["transform": NSNull()])
+        XCTAssertTrue(view.transform.isIdentity)
+    }
+
+    func testFrameSurvivesTransform() {
+        let manager = PNViewManager()
+        let view = manager.createView(tag: 3, props: ["transform": [["scale": 2]]])
+        manager.setFrame(view: view, x: 10, y: 20, w: 100, h: 50)
+        XCTAssertEqual(view.bounds.size, CGSize(width: 100, height: 50))
+        XCTAssertEqual(view.center, CGPoint(x: 60, y: 45))
+    }
+
+    func testTextMeasureAndTransform() {
+        let manager = PNTextManager()
+        let view = manager.createView(tag: 4, props: ["text": "hello world", "font_size": 20, "text_transform": "uppercase"])
+        XCTAssertEqual((view as? UILabel)?.text, "HELLO WORLD")
+        let unconstrained = manager.measure(view: view, maxW: .infinity, maxH: .infinity)
+        XCTAssertGreaterThan(unconstrained.width, 50)
+        XCTAssertGreaterThan(unconstrained.height, 15)
+        let narrow = manager.measure(view: view, maxW: 60, maxH: 1e6)
+        XCTAssertLessThanOrEqual(narrow.width, 60)
+        XCTAssertGreaterThan(narrow.height, unconstrained.height, "wrapped text grows in height")
+        XCTAssertEqual(PNTextManager.transform("hello big world", mode: "capitalize"), "Hello Big World")
+    }
+
+    func testTextSpansProduceAttributedString() {
+        let manager = PNTextManager()
+        let view = manager.createView(tag: 5, props: [
+            "spans": [["text": "Hi "], ["text": "there", "bold": true, "color": "#ff0000"]],
+        ])
+        let label = view as? UILabel
+        XCTAssertEqual(label?.attributedText?.string, "Hi there")
+        var range = NSRange()
+        let color = label?.attributedText?.attribute(.foregroundColor, at: 3, effectiveRange: &range) as? UIColor
+        XCTAssertNotNil(color)
+        XCTAssertEqual(range.location, 3)
+        XCTAssertEqual(range.length, 5)
+    }
+
+    func testVirtualListBindsRowsThroughRegistry() {
+        PNTransaction.apply("[[\"c\", 40, \"View\", {\"background_color\": \"#123456\"}]]")
+        let manager = PNVirtualListManager()
+        guard let table = manager.createView(tag: 41, props: ["count": 3, "row_height": 50]) as? UITableView else {
+            return XCTFail("expected a table")
+        }
+        XCTAssertEqual(table.dataSource?.tableView(table, numberOfRowsInSection: 0), 3)
+        XCTAssertEqual(table.delegate?.tableView?(table, heightForRowAt: IndexPath(row: 1, section: 0)), 50)
+        manager.update(view: table, changed: ["row_heights": [10, 20, 30]])
+        XCTAssertEqual(table.delegate?.tableView?(table, heightForRowAt: IndexPath(row: 2, section: 0)), 30)
+    }
+
+    func testScrollPayloadShape() {
+        let scroll = UIScrollView(frame: CGRect(x: 0, y: 0, width: 100, height: 200))
+        scroll.contentSize = CGSize(width: 100, height: 800)
+        scroll.contentOffset = CGPoint(x: 0, y: 40)
+        let payload = PNScrollPayload.make(scroll)
+        XCTAssertEqual(payload["y"] as? Double, 40)
+        XCTAssertEqual(payload["extent"] as? Double, 200)
+        XCTAssertEqual(payload["range"] as? Double, 800)
+    }
+
+    func testRegistryKnowsEveryBuiltinType() {
+        let names = PNRegistry.shared.componentNames
+        for type in ["View", "Column", "Row", "Text", "Button", "TextInput", "Image", "Switch", "ProgressBar",
+                     "ActivityIndicator", "WebView", "Spacer", "ScrollView", "SafeAreaView", "Modal", "Portal",
+                     "Slider", "TabBar", "Pressable", "StatusBar", "KeyboardAvoidingView", "Picker", "Checkbox",
+                     "SegmentedControl", "DatePicker", "VirtualList"] {
+            XCTAssertTrue(names.contains(type), "missing manager for \(type)")
+        }
+        for module in ["Host", "Device", "Alert", "Storage", "SecureStore", "Clipboard", "Share", "Linking",
+                       "Haptics", "Battery", "NetInfo", "AppState", "Permissions", "Notifications", "Camera",
+                       "Location", "Biometrics"] {
+            XCTAssertTrue(PNRegistry.shared.moduleNames.contains(module), "missing module \(module)")
+        }
+    }
+}

pythonnative/templates/ios_template/PythonNativeKit/Tests/PythonNativeKitTests/PNModuleTests.swift

@@ -0,0 +1,98 @@
+import XCTest
+@testable import PythonNativeKit
+
+/// A module that settles inline or later depending on the method.
+final class PNTestEchoModule: PNNativeModule {
+    static let name = "TestEcho"
+    static var pending: PNPromise?
+
+    init() {}
+
+    func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "echo": promise.resolve(args["value"])
+        case "fail": promise.reject("nope", code: "test_code")
+        case "later": PNTestEchoModule.pending = promise
+        default: promise.reject("unknown method \(method)")
+        }
+    }
+}
+
+final class PNModuleTests: XCTestCase {
+    override func setUp() {
+        super.setUp()
+        PNRegistry.shared.registerModule(PNTestEchoModule.self)
+    }
+
+    func testSynchronousResolveProducesOkEnvelope() {
+        let result = PNModuleDispatcher.shared.call(module: "TestEcho", method: "echo", envelope: ["call_id": 7, "args": ["value": 42]])
+        XCTAssertEqual(result["ok"] as? Bool, true)
+        XCTAssertEqual(result["value"] as? Int, 42)
+        XCTAssertNil(result["pending"])
+    }
+
+    func testRejectProducesErrorEnvelope() {
+        let result = PNModuleDispatcher.shared.call(module: "TestEcho", method: "fail", envelope: ["call_id": 8, "args": [:]])
+        XCTAssertEqual(result["ok"] as? Bool, false)
+        XCTAssertEqual(result["error"] as? String, "nope")
+        XCTAssertEqual(result["code"] as? String, "test_code")
+    }
+
+    func testUnknownModuleAndMethod() {
+        let missing = PNModuleDispatcher.shared.call(module: "Nope", method: "x", envelope: [:])
+        XCTAssertEqual(missing["ok"] as? Bool, false)
+        XCTAssertEqual(missing["code"] as? String, "unknown_module")
+        let method = PNModuleDispatcher.shared.call(module: "TestEcho", method: "zzz", envelope: [:])
+        XCTAssertEqual(method["ok"] as? Bool, false)
+    }
+
+    func testAsynchronousSettlementReturnsPending() {
+        let result = PNModuleDispatcher.shared.call(module: "TestEcho", method: "later", envelope: ["call_id": 9, "args": [:]])
+        XCTAssertEqual(result["pending"] as? Bool, true)
+        guard let promise = PNTestEchoModule.pending else { return XCTFail("promise not captured") }
+        XCTAssertFalse(promise.isSettled)
+        XCTAssertEqual(promise.callId, 9)
+        promise.resolve("done")
+        XCTAssertTrue(promise.isSettled)
+        promise.resolve("again")
+        XCTAssertEqual(promise.result?["value"] as? String, "done", "second settlement is ignored")
+    }
+
+    func testEnvelopeJSONRoundTrip() {
+        let ok = PNJSON.encode(["ok": true, "value": ["a": 1]])
+        let decoded = PNJSON.decodeObject(ok)
+        XCTAssertEqual(decoded["ok"] as? Bool, true)
+        XCTAssertEqual((decoded["value"] as? [String: Any])?["a"] as? Int, 1)
+        XCTAssertEqual(PNJSON.decodeObject(PNJSON.encode(["pending": true]))["pending"] as? Bool, true)
+        XCTAssertEqual(PNJSON.encode(Double.infinity), "null", "non-finite numbers never leave Swift as JSON numbers")
+        XCTAssertEqual(PNJSON.resolveInfinity("inf") as? Double, Double.infinity)
+        XCTAssertEqual(PNJSON.encode(nil), "null")
+    }
+
+    func testDeviceInfoShape() {
+        let info = DeviceModule.info()
+        XCTAssertEqual(info["os"] as? String, "ios")
+        XCTAssertNotNil(info["os_version"])
+        XCTAssertNotNil(info["app_dir"])
+        XCTAssertNotNil(info["cache_dir"])
+        XCTAssertNotNil(info["scale"])
+    }
+
+    func testStorageModuleRoundTrip() {
+        let storage = StorageModule()
+        _ = PNModuleDispatcher.shared.call(module: "Storage", method: "clear", envelope: [:])
+        let set = PNPromise(callId: 1, module: "Storage", method: "set")
+        storage.call("set", args: ["key": "k", "value": "v"], promise: set)
+        let get = PNPromise(callId: 2, module: "Storage", method: "get")
+        storage.call("get", args: ["key": "k"], promise: get)
+        XCTAssertEqual(get.result?["value"] as? String, "v")
+        let keys = PNPromise(callId: 3, module: "Storage", method: "all_keys")
+        storage.call("all_keys", args: [:], promise: keys)
+        XCTAssertEqual(keys.result?["value"] as? [String], ["k"])
+        let del = PNPromise(callId: 4, module: "Storage", method: "delete")
+        storage.call("delete", args: ["key": "k"], promise: del)
+        let missing = PNPromise(callId: 5, module: "Storage", method: "get")
+        storage.call("get", args: ["key": "k"], promise: missing)
+        XCTAssertTrue(missing.result?["value"] is NSNull)
+    }
+}

pythonnative/templates/ios_template/PythonNativeKit/Tests/PythonNativeKitTests/PNTransactionTests.swift

@@ -0,0 +1,91 @@
+import XCTest
+@testable import PythonNativeKit
+
+final class PNTransactionTests: XCTestCase {
+    override func tearDown() {
+        PNViewRegistry.shared.removeAll()
+        super.tearDown()
+    }
+
+    func testDecodesEveryOpcode() throws {
+        let json = """
+        [["c", 1, "View", {"background_color": "#ff0000"}],
+         ["u", 1, {"opacity": 0.5}],
+         ["c", 2, "Text", {"text": "hi"}],
+         ["i", 1, 2, 0],
+         ["f", 2, 1.5, 2.5, 100, 20],
+         ["d", 2]]
+        """
+        let ops = try PNTransaction.decode(json)
+        XCTAssertEqual(ops.count, 6)
+        XCTAssertEqual(ops[0], .create(tag: 1, type: "View", props: ["background_color": "#ff0000"]))
+        XCTAssertEqual(ops[1], .update(tag: 1, changed: ["opacity": 0.5]))
+        XCTAssertEqual(ops[3], .insert(parent: 1, child: 2, index: 0))
+        XCTAssertEqual(ops[4], .frame(tag: 2, x: 1.5, y: 2.5, w: 100, h: 20))
+        XCTAssertEqual(ops[5], .destroy(tag: 2))
+    }
+
+    func testInfinityStringsBecomeInfinity() throws {
+        let ops = try PNTransaction.decode("[[\"c\", 5, \"View\", {\"max_width\": \"inf\", \"nested\": {\"h\": \"inf\"}}]]")
+        guard case let .create(_, _, props) = ops[0] else { return XCTFail("expected create") }
+        XCTAssertEqual(props["max_width"] as? Double, Double.infinity)
+        XCTAssertEqual((props["nested"] as? [String: Any])?["h"] as? Double, Double.infinity)
+    }
+
+    func testMalformedOpsAreSkippedNotFatal() throws {
+        let ops = try PNTransaction.decode("[[\"c\", 1, \"View\", {}], [\"zz\", 9], [\"u\"], 42, [\"d\", 1]]")
+        XCTAssertEqual(ops.count, 2)
+        XCTAssertEqual(ops[0], .create(tag: 1, type: "View", props: [:]))
+        XCTAssertEqual(ops[1], .destroy(tag: 1))
+    }
+
+    func testNonArrayDocumentThrows() {
+        XCTAssertThrowsError(try PNTransaction.decode("{\"not\": \"an array\"}"))
+    }
+
+    func testApplyBuildsHierarchyAndIsolatesFailures() {
+        PNTransaction.apply("""
+        [["c", 10, "View", {"background_color": "#00ff00"}],
+         ["c", 11, "Text", {"text": "hello"}],
+         ["u", 999, {"opacity": 0.1}],
+         ["i", 10, 11, 0],
+         ["i", 10, 12345, 0],
+         ["f", 11, 4, 8, 120, 30],
+         ["c", 13, "NoSuchType", {}]]
+        """)
+        let parent = PNViewRegistry.shared.view(for: 10)
+        let child = PNViewRegistry.shared.view(for: 11)
+        XCTAssertNotNil(parent)
+        XCTAssertNotNil(child)
+        XCTAssertTrue(child?.superview === parent)
+        XCTAssertEqual(child?.frame, CGRect(x: 4, y: 8, width: 120, height: 30))
+        XCTAssertNotNil(PNViewRegistry.shared.view(for: 13), "unknown types get a placeholder view")
+        XCTAssertEqual(PNViewRegistry.shared.resolve(13)?.typeName, "NoSuchType")
+
+        PNTransaction.apply("[[\"d\", 11]]")
+        XCTAssertNil(PNViewRegistry.shared.view(for: 11))
+        XCTAssertEqual(parent?.subviews.count, 0)
+    }
+
+    func testInsertIsMoveAwareAndClamps() {
+        PNTransaction.apply("""
+        [["c", 20, "View", {}], ["c", 21, "View", {}], ["c", 22, "View", {}], ["c", 23, "View", {}],
+         ["i", 20, 21, 0], ["i", 20, 22, 1], ["i", 20, 23, 99]]
+        """)
+        let parent = PNViewRegistry.shared.view(for: 20)
+        XCTAssertEqual(parent?.subviews.map { PNViewState.existing(for: $0)?.tag }, [21, 22, 23])
+        PNTransaction.apply("[[\"i\", 20, 23, 0]]")
+        XCTAssertEqual(parent?.subviews.map { PNViewState.existing(for: $0)?.tag }, [23, 21, 22])
+        XCTAssertEqual(parent?.subviews.count, 3)
+    }
+
+    func testFrameClampsNonFiniteValues() {
+        PNTransaction.apply("[[\"c\", 30, \"View\", {}]]")
+        guard let record = PNViewRegistry.shared.resolve(30) else { return XCTFail("missing view") }
+        record.manager.setFrame(view: record.view, x: .nan, y: 5, w: .infinity, h: -3)
+        XCTAssertEqual(record.view.frame.origin.x, 0)
+        XCTAssertEqual(record.view.frame.origin.y, 5)
+        XCTAssertEqual(record.view.frame.size.height, 0)
+        XCTAssertTrue(record.view.frame.size.width.isFinite)
+    }
+}

pythonnative/templates/ios_template/ios_template/AppDelegate.swift

@@ -2,12 +2,13 @@
 //  AppDelegate.swift
 //  ios_template
 //
-//  Application-level callbacks. Remote-notification registration
-//  results are forwarded to pythonnative.native_modules.notifications,
-//  which resolves the awaitable returned by
-//  Notifications.get_device_token().
+//  Application-level callbacks. Battery monitoring and APNs
+//  registration results are forwarded to the Swift native modules in
+//  PythonNativeKit (BatteryModule, NotificationsModule), which relay
+//  them to Python over the bridge.
 //
 
+import PythonNativeKit
 import UIKit
 
 @main
@@ -16,67 +17,24 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         _ application: UIApplication,
         didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
     ) -> Bool {
-        registerBatteryObservers()
+        BatteryModule.startMonitoring()
         return true
     }
 
-    // MARK: - Battery forwarding
-
-    // UIDevice only posts battery notifications while monitoring is on;
-    // Battery.add_listener subscribers receive {"level", "state"}.
-    private func registerBatteryObservers() {
-        UIDevice.current.isBatteryMonitoringEnabled = true
-        let center = NotificationCenter.default
-        for name in [UIDevice.batteryLevelDidChangeNotification, UIDevice.batteryStateDidChangeNotification] {
-            center.addObserver(forName: name, object: nil, queue: .main) { _ in
-                self.dispatchBattery()
-            }
-        }
-    }
-
-    private func dispatchBattery() {
-        guard PythonRuntime.shared.started else { return }
-        let device = UIDevice.current
-        let state: String
-        switch device.batteryState {
-        case .unplugged: state = "unplugged"
-        case .charging: state = "charging"
-        case .full: state = "full"
-        default: state = "unknown"
-        }
-        PythonRuntime.shared.notify(
-            module: "pythonnative.native_modules.battery",
-            function: "dispatch_battery",
-            Double(device.batteryLevel),
-            state
-        )
-    }
-
     // MARK: - Remote notifications (APNs)
 
     func application(
         _ application: UIApplication,
         didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
     ) {
-        let token = deviceToken.map { String(format: "%02x", $0) }.joined()
-        guard PythonRuntime.shared.started else { return }
-        PythonRuntime.shared.notify(
-            module: "pythonnative.native_modules.notifications",
-            function: "dispatch_device_token",
-            token
-        )
+        NotificationsModule.deliverToken(deviceToken)
     }
 
     func application(
         _ application: UIApplication,
         didFailToRegisterForRemoteNotificationsWithError error: Error
     ) {
-        guard PythonRuntime.shared.started else { return }
-        PythonRuntime.shared.notify(
-            module: "pythonnative.native_modules.notifications",
-            function: "dispatch_device_token_error",
-            String(describing: error)
-        )
+        NotificationsModule.deliverError(error)
     }
 
     // MARK: - UISceneSession lifecycle

pythonnative/templates/ios_template/ios_template/Info.plist

@@ -2,11 +2,11 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-	<!-- PythonNative's StatusBar element drives the bar through the legacy
-	     UIApplication setters, which UIKit only honors when view-controller-based
-	     status bar appearance is turned off. -->
+	<!-- PythonNative's StatusBar element is applied through PNViewController's
+	     preferredStatusBarStyle / prefersStatusBarHidden overrides, so the
+	     modern view-controller-based appearance must stay enabled. -->
 	<key>UIViewControllerBasedStatusBarAppearance</key>
-	<false/>
+	<true/>
 	<key>UIApplicationSceneManifest</key>
 	<dict>
 		<key>UIApplicationSupportsMultipleScenes</key>

pythonnative/templates/ios_template/ios_template/PythonRuntime.swift

@@ -6,8 +6,15 @@
 //  Python.xcframework is linked at build time, so a missing runtime is
 //  a build error, never a silent runtime fallback.
 //
+//  After the interpreter starts, `pythonnative.bootstrap.start()` binds
+//  the PythonNativeKit C exports, registers the Python callback, and
+//  verifies the protocol version. Everything else (screens, modules,
+//  deep links) flows over that bridge; nothing else here calls Python
+//  functions by name.
+//
 
 import Foundation
+import PythonNativeKit
 
 enum PythonRuntimeError: Error, CustomStringConvertible {
     case startup(String)
@@ -62,28 +69,54 @@ final class PythonRuntime {
 
     private(set) var started = false
     private(set) var startupError: String? = nil
-    private var pendingURLs: [String] = []
 
     private init() {}
 
     // MARK: - Startup
 
-    /// Initialize the embedded interpreter once. Throws with a full
-    /// description when the bundle is not packaged correctly; there is
+    /// Initialize the embedded interpreter once and complete the bridge
+    /// handshake. Throws with a full description when the bundle is not
+    /// packaged correctly or the protocol versions disagree; there is
     /// deliberately no fallback mode.
     func ensureStarted() throws {
-        if started { return }
         if let error = startupError { throw PythonRuntimeError.startup(error) }
+        if started { return }
         do {
             try start()
+            // The interpreter is live from here on; a failed handshake is
+            // recorded as a startup error but Python is never re-initialized.
             started = true
-            flushPendingURLs()
+            try connectBridge()
         } catch let error as PythonRuntimeError {
             startupError = error.description
             throw error
         }
     }
 
+    /// Run `pythonnative.bootstrap.start(dev, strict=True)`: it binds the
+    /// `pn_bridge_*` symbols, registers the native -> Python callback,
+    /// verifies the protocol version against `pn_bridge_protocol_version()`,
+    /// routes `print()` to the console, and warms the asyncio runtime.
+    private func connectBridge() throws {
+        #if DEBUG
+        let dev = true
+        #else
+        let dev = false
+        #endif
+        do {
+            try callList(module: "pythonnative.bootstrap", function: "start", [dev, true])
+        } catch let error as PythonRuntimeError {
+            throw PythonRuntimeError.startup(
+                "Bridge bootstrap failed (native protocol v\(pn_bridge_protocol_version())):\n\(error.description)"
+            )
+        }
+        guard PNBridge.shared.hasCallback else {
+            throw PythonRuntimeError.startup(
+                "pythonnative.bridge.handshake() returned without registering the native callback."
+            )
+        }
+    }
+
     private func start() throws {
         guard let resourcePath = Bundle.main.resourcePath else {
             throw PythonRuntimeError.startup("The app bundle has no resource path; the build is corrupt.")
@@ -250,16 +283,6 @@ final class PythonRuntime {
         return try Self.invoke(fnObj, args: args, context: "\(module).\(function)")
     }
 
-    /// Like `call`, but logs failures instead of throwing. For host
-    /// notifications where the app must keep running.
-    func notify(module: String, function: String, _ args: Any...) {
-        do {
-            _ = try callList(module: module, function: function, args)
-        } catch {
-            NSLog("[PN] \(module).\(function) failed: \(error)")
-        }
-    }
-
     /// Shared invocation helper. The caller must hold the GIL.
     fileprivate static func invoke(
         _ callable: UnsafeMutablePointer<PyObject>,
@@ -300,26 +323,6 @@ final class PythonRuntime {
         }
     }
 
-    // MARK: - Deep links
-
-    /// Deliver a deep-link URL to the Python side, buffering it until
-    /// the interpreter is running.
-    func deliverURL(_ url: String) {
-        guard started else {
-            pendingURLs.append(url)
-            return
-        }
-        notify(module: "pythonnative.native_modules.linking", function: "dispatch_url", url)
-    }
-
-    private func flushPendingURLs() {
-        let urls = pendingURLs
-        pendingURLs = []
-        for url in urls {
-            notify(module: "pythonnative.native_modules.linking", function: "dispatch_url", url)
-        }
-    }
-
     // MARK: - Error formatting
 
     /// Format and clear the pending Python exception (caller holds the GIL).
@@ -384,14 +387,3 @@ final class PythonRuntime {
         return "unknown error"
     }
 }
-
-/// Exported for the Python side: `pythonnative.runtime` wakes the guest
-/// asyncio loop by resolving this symbol via `ctypes.CDLL(None)` and
-/// calling it whenever loop work is scheduled.
-@_cdecl("pn_schedule_render_drain")
-public func pn_schedule_render_drain() {
-    DispatchQueue.main.async {
-        guard PythonRuntime.shared.started else { return }
-        PythonRuntime.shared.notify(module: "pythonnative.hosts", function: "drain_ios_scheduled_renders")
-    }
-}